How it works

A new standard for automated blockchain operations

Introduction

Imagine being able to fully automate your blockchain operations without constantly monitoring the network or manually triggering transactions at just the right time. With Mimic Protocol, you can define on-chain workflows in code, let the network handle inputs and scheduling, and trust that these operations will execute reliably, securely, and cost-effectively.

Mimic Protocol is a next-generation automation framework for blockchain developers. Whether you’re coordinating multi-step contract interactions, ensuring certain conditions are met before a state transition, or orchestrating cross-chain tasks, Mimic gives you the ability to “set it and forget it”. It provides a standard way to define, schedule, and enforce the execution of on-chain operations, all while leveraging decentralized data sources and secure execution participants.

Key Takeaways

Automation: Simplify repetitive tasks, enforce conditional logic, and handle cross-chain operations without manual intervention.
Trustless and Deterministic: Built on cryptographic proofs and a network of independent actors (oracles, relayers, and solvers), so you don’t have to trust any single party.
Flexible: Define exactly what you need—data sources, triggers, conditions—then pay only for executions that happen, not for ongoing maintenance.
Easy-to-use: Write code in a familiar environment, compile it to a deterministic form, and deploy it. The protocol’s tooling and documentation make integration straightforward, even for complex logic.

How does it work?

Mimic is built in three layers, each focusing on a distinct part of the automation pipeline, ensuring transparency, reliability, and modularity:

Planning Layer

Here, you define tasks—logical units of automation. A task describes what data is needed, how to interpret it, and what conditions must be met to create intents. An intent represents an actionable instruction on the blockchain.

Oracles supply trustworthy signed data (e.g., block info, contract states, or prices), while relayers execute your defined logic to decide whether intents should be generated.

Execution Layer

Once intents are created, it’s handled by a coordination engine called Axia.

Axia broadcasts the intent to a network of solvers that compete to fulfill it under optimal conditions (lowest fees, fastest execution, highest reliability). The best solver is chosen to carry out the action on-chain, ensuring a competitive and cost-efficient environment.

Security Layer

Finally, the Settler contracts enforce that everything was done correctly. It verifies the solver’s actions, ensures that user-defined restrictions are respected, and finalizes the transaction outcome.

This layer ensures no half-finished states, no replay attacks, and no deviation from the intended behavior.

A developer’s perspective: Defining a task

You write logic that runs whenever conditions are met. The following snippet shows a hypothetical scenario: checking if the token balance of an account has reached a certain threshold in order to sell them or not.

import { BigNumber, Environment, log } from '@mimicprotocol/lib-ts'
import { TaskInput } from './types'

export default function main(environment: Environment, input: TaskInput): void {
  const tokenIn = environment.getERC20(input.chainId, input.tokenIn)
  const balance = tokenIn.balanceOf(input.account)
  const valueInUsd = environment.convertToUsd(tokenIn, balance)
  const minAmountOut = environment.getMinAmountOut(input.tokenIn, balance, input.tokenOut, input.slippage)

  if (valueInUsd > input.threshold) {
    const intent = environment.swap({
      from: input.account,
      to: input.account,
      tokenIn: input.tokenIn,
      tokenOut: input.tokenOut,
      amount: balance,
      minAmountOut: minAmountOut,
    })
    log.info('Intent created')
  } else {
    log.debug('Threshold not met')
  }
}

What’s happening here?

Your code runs inside the Planning Layer.
It fetches data from oracles (prices and blockchain state) and checks a condition.
If the condition holds, it creates an intent to perform a swap, effectively handing off to the Execution Layer.
Later, the solvers network picks this up, executes the best route, and the Settler finalizes the transaction on-chain.

Manifest configuration

Your code is paired with a manifest file YAML defining:

Task descriptive metadata
Which trigger alternative will be used for the task.
External parameters like the threshold (which can be adjusted without changing code).

version: 1.0.0
name: Balance Monitoring Task
description: Monitors an account's token balance and creates a swap intent if conditions are met.
trigger: cron
inputs:
  - chainId: number
  - account: address
  - tokenIn: address
  - tokenOut: address
  - slippage: number
  - threshold: number

Publishing your task

Once you’re happy with your logic and configuration, you can build it and publish it to the network. By doing this, you announce your task is ready to be tracked by the relayers, who will start executing it automatically, under the conditions you set.

Next steps

Begin experimenting by following our step-by-step guides to write, compile, and deploy a basic task. This hands-on experience will help you understand the workflow, get comfortable with the tooling, and prepare you for building more complex, production-grade automations.
Dive into additional use cases and real-world scenarios to spark ideas and discover how you can leverage Mimic for your specific needs. From automated contract maintenance to cross-chain data orchestration, exploring more examples will inspire you to craft tailored automation strategies.
Explore the Mimic team’s roadmap to see how the protocol will evolve over time. The roadmap provides insight into upcoming features, iterative enhancements, and the pragmatic steps planned to broaden Mimic’s capabilities. Stay informed and help shape the future of on-chain automation.

PreviousWhat's Mimic Protocol NextRoadmap

Last updated 1 month ago