# Mimic — full content

> Mimic is a developer platform for building and scaling web3 products across chains. Teams define what should happen and when; Mimic handles execution securely — non-custodial, cross-chain and policy-controlled.

This file contains the full text of every Mimic blog post in markdown. For a compact index of the site, see https://www.mimic.fi/llms.txt.

---

# What is Mimic?

> Mimic is a programmable layer for onchain products. Define the logic, Mimic runs it — no smart contracts to write or babysit.

Published: 2026-07-28 | Updated: 2026-07-28 | Author: Mimic team | Tags: Mimic Platform | Source: https://www.mimic.fi/blog/what-is-mimic

<Lede>

Mimic is a programmable layer for onchain products. Define the logic, Mimic runs it, no smart contracts to write or babysit. $9B processed, 450M+ transactions, running inside Ledger, Trust Wallet, Safe, and Trezor since 2022.

</Lede>

## The problem

Writing onchain logic was never the hard part. Keeping it running is. Every deployed contract drags along servers, RPCs, monitoring, and a slow trickle of protocol changes that break things quietly at 3am. Most engineering teams end up maintaining infrastructure that has nothing to do with the product they set out to build.

## What Mimic does about it

Mimic splits logic from execution. Logic gets written offchain, in code engineers already use daily. Mimic Protocol compiles it deterministically, runs it trustlessly, and enforces it onchain through policies. Change a rule, no redeploy. No new audit every time the business logic shifts.

Wallets, AI agents, asset managers, and fintechs already run DCA, subscriptions, rebalancing, and fee collection on it, in production, today.

## How Mimic works under the hood

Mimic Protocol runs on a decentralized network of three layers: execution, data, and coordination. Logic gets compiled deterministically and finalized with cryptographic guarantees, so what runs onchain matches exactly what was defined offchain, no surprises, no drift. A policy engine sits on top, deciding what's allowed to execute before anything touches a chain.

That's the part that used to eat a sprint: wiring monitoring, retry logic, RPC failovers, permissions. Mimic absorbs it, which tends to free up the kind of time better spent on the next feature than on keeping the last one alive.

Full breakdown at [docs.mimic.fi](https://docs.mimic.fi/).

## Who it's for

<PhotoBanner src="https://www.mimic.fi/blog/what-is-mimic/hackathon-wide.jpg" alt="Team working at a Mimic hackathon" />

Wallets, fintech products, asset managers, protocols, AI agents. Different shapes, similar pattern: teams that keep getting pulled back into the same maintenance loop instead of building the next thing.

It's rarely one big fire. It's the RPC that flakes at 2am, the retry logic nobody wants to touch, the small script that quietly needs a rewrite every time a protocol changes something upstream. None of it takes long on its own. All of it adds up to less time on the actual product.

Mimic exists for the teams who'd rather that time went somewhere else. Not because they're short on time in some abstract sense, because they've already lived the specific version of losing it.

---

## You're not building alone

Behind Mimic is a squad that genuinely enjoys getting into the details. We build the product, use it, test it, and regularly find ourselves following an unusual edge case further than strictly necessary, simply because we want to understand it.

We stay close to the teams building with Mimic. Questions turn into conversations, tricky integrations sometimes become shared puzzles, and when a project needs us, _we are usually not far away_.

Our Discord is where much of that happens. A place to ask questions, share what you are working on, or compare notes with other builders using Mimic.

Come by, show us what you are building, and let's see where it can go.

<Closing>

## Start building

Mimic is live on Arbitrum, Base, Base Sepolia, Ethereum, Gnosis, Optimism, and Sonic.

Explore the docs to start building, or bring your project to Discord and meet the squad behind Mimic.

Read the docs: [docs.mimic.fi](https://docs.mimic.fi/)

Join the Discord: [discord.mimic.fi](https://discord.mimic.fi/)

</Closing>

---

# The Execution Gap in Onchain Asset Management

> The gap between strategy and execution is the real bottleneck in onchain asset management. Mimic bridges it with programmable, policy-driven execution.

Published: 2026-04-01 | Updated: 2026-04-01 | Author: Mimic Engineering Team | Tags: Asset Management, Mimic Platform | Source: https://www.mimic.fi/blog/the-execution-gap-in-onchain-asset-management

![](https://www.mimic.fi/blog/the-execution-gap-in-onchain-asset-management/X---The-Execution-Gap--in-Onchain-Asset-Management-1.png)

Onchain asset management is growing exponentially through vaults and other execution systems. The strategy is getting more sophisticated, with risk evaluation across lending markets, target allocation, and custom logic, **but the execution is still outdated**.

Manual operations, multisig signing, scripts, bots, and custom smart contracts are usually patched together on the execution side.

The real bottleneck is turning strategy into transactions. Withdraw from one protocol. Approve another. Supply. Handle gas. Watch for reverts. Do it again tomorrow, across twelve vaults, on three chains.

That's where things break.

## The gap between strategy and execution

Onchain asset management has a missing middle. On one side, you have strategy: models, analytics, allocation decisions. On the other side, you have the blockchain: contracts, transactions, gas, and finality.

Between them? Scripts. Cron jobs. Custom smart contracts. Bots held together with monitoring alerts. Maybe a dedicated ops person who knows which Safe needs which signer for which vault on which chain.

It works until it doesn't. And it doesn't scale.

There are no standards. Every new vault builds another set of scripts. Every new chain means another deployment pipeline. Every new mandate means more humans in the loop. The marginal cost of operating a new strategy grows linearly (or faster) with AUM. That's the opposite of what asset management should look like.

## What asset managers actually need

When a team starts managing capital onchain at any real scale, the requirements converge quickly. They look something like this.

1.  **Multi-protocol, multi-chain operations.** A real allocation strategy doesn't live inside one protocol. Rebalancing between Aave, Morpho, Spark, Fluid, and Compound (and more). Bridging USDC from Ethereum to Base when the yield differential justifies the cost. Claiming rewards from multiple different gauges and compounding them into the current target allocation. This all needs to work as a coordinated flow, not as five disconnected scripts.
2.  **Emergency mechanisms.** When a protocol gets exploited, you need to pull capital out immediately. When gas spikes, you need to pause non-urgent operations. When a bridge gets stuck, you need to halt cross-chain flows and alert the team. Emergency handling should be built into the execution layer, not bolted on after the first incident.
3.  **Auditability.** Institutional allocators need to know exactly what happened, when, and why. Every execution should produce a clear trail. Not only server logs, but onchain records that map back to the policies and constraints that governed them.
4.  **Programmable, safe execution.** You need a layer between your strategy engine and the blockchain. Something that takes an allocation target and turns it into a sequence of onchain transactions (like withdraw, approve, supply) with constraints enforced onchain. Whitelisted contracts, slippage limits, volume caps, health factor floors. Not checks in your code. Policies on the blockchain. If your bot has a bug, the policy still holds.

## The problem with custom contracts

The instinctive response is to build smart contracts for all of this. Encode your rebalancing logic into a contract. Deploy it. Audit it.

But here's what happens in practice: your strategy changes every few weeks. Markets shift. New protocols launch. A lending market you were using gets deprecated. Your risk parameters evolve as you learn more about how your portfolio behaves under stress.

Every change means rewriting contracts, redeploying, and re-auditing. Audit costs scale with contract complexity. Deployment introduces risk windows. And the more logic you put onchain, the larger your attack surface.

There's a better model: keep the complex logic offchain, where it's easy to iterate, test, and update, and put only the constraints onchain. The constraints are simple, small, auditable. They define what's allowed. The execution logic decides what to do within those bounds.

That's what programmable execution looks like.

![](https://www.mimic.fi/blog/the-execution-gap-in-onchain-asset-management/PB---The-Execution-Gap--in-Onchain-Asset-Management-1.png)

## Building safer systems for onchain asset management with Mimic

Mimic is a programmable layer that sits between your strategy and the blockchain. You define execution logic offchain, in the form of functions that encode what should happen and when. Mimic enforces policies onchain: the constraints that guarantee nothing runs outside your boundaries.

For an asset manager, the flow looks like this:

Your team or system produces an allocation target. With Mimic, you can translate it into a sequence of onchain actions (withdraw, approve, supply, bridge, swap), and executes them through a policy-driven account. The policies (whitelisted contracts, method selectors, value caps, slippage limits) are signed onchain and can't be bypassed by the execution logic.

No custom contracts to deploy or bots to maintain. Strategy logic lives where it's easy to change. The safety constraints live where they can't be changed without explicit authorization.

This applies across the full range of what an onchain asset manager does:

**Lending market rebalancing.** Your model identifies the best-yielding market for USDC across Aave, Morpho, Spark, and Compound. Mimic handles the cross-protocol flow: withdraw from the current position, approve the target protocol, and supply. Same-protocol, cross-protocol, and cross-chain rebalances, all executed through the same programmable layer.

**Reward harvesting and compounding.** Claim rewards across protocols, swap to the target asset through a whitelisted DEX aggregator, and resupply. Triggered on a schedule or when accumulated rewards exceed a cost threshold.

**Leveraged strategies.** Supply collateral, borrow, re-supply, and repeat until the target leverage ratio is reached. Health factor floors and maximum leverage caps enforced as onchain policies, not if-statements in a script. Automatic unwind when the health factor drops below a threshold.

**Time-weighted token sales.** When your vaults receive token incentives, you need to sell them without moving the market. Mimic executes time-weighted sales, splitting the sell across intervals, enforcing minimum prices and slippage limits per execution, so the disposal is gradual, predictable, and auditable.

## Earning vaults: a concrete example

One of the clearest applications of programmable execution for asset managers is an automated earning vault: a vault that continuously reallocates capital across lending protocols to maximize yield.

Here's what a production-grade earning vault built on Mimic looks like.

The vault accepts deposits in a base asset (say, USDC). Mimic monitors yields across protocols. When the yield differential between the current allocation and the best available market exceeds a threshold, Mimic executes the rebalance.

But yield optimization alone isn't enough for institutional capital. The vault also needs **onchain compliance checks** (Chainalysis integration for OFAC screening on deposits), **granular pause mechanisms** (partial pause on deposits, emergency pause on all operations, emergency exit from all positions), **modular fee structures** enforced onchain, and **redemption processing** that unwinds positions in order, pulling from the least disruptive position first, respecting slippage limits.

This isn't a theoretical design. These are the components teams need before institutional allocators will commit capital.

## What "institutional grade" actually means

The phrase gets thrown around a lot. For onchain asset management, it comes down to a few specific things.

**Deterministic execution.** Given the same inputs and state, the same thing happens every time. No race conditions, no timing-dependent behavior, no "it worked in testing but not in production."

**Separation of risks.** Strategy logic, execution logic, and safety constraints are decoupled. The people who define the strategy don't need to touch the execution code. The people who set risk parameters don't need to understand the underlying protocol calls. Each layer can be reviewed, updated, and audited independently.

**Onchain policy enforcement.** This is worth repeating: the constraints that protect capital must be enforced onchain, by the blockchain itself, not by your server or your bot. Whitelisted addresses. Approved method selectors. Maximum transaction values. Daily volume caps. Health factor minimums. Slippage ceilings. These aren't configuration files, they're signed onchain policies.

**Operational continuity.** What happens when your ops lead leaves? When the person who wrote the rebalancing script gets sick? When the monitoring system goes down for two hours? Institutional-grade means the system keeps running correctly even when the humans aren't watching. The logic is encoded in the execution layer, not in someone's head.

**Audit trail.** Every execution traces back to the policy that authorized it, the trigger that initiated it, and the onchain result. Not logs on a server. Not a Slack thread. An immutable, verifiable record.

## Where most teams start with Mimic

If you're an asset manager running strategies onchain, whether you're managing vaults, DAO treasuries, or delegated capital, Mimic can help you achieve programmable execution in days instead of months.

Most teams start with one or two recurring operations that are currently manual or script-dependent. A rebalancing flow. A fee collection routine. A reward harvesting cycle. Something that runs regularly, involves multiple protocol interactions, and would benefit from onchain policy enforcement.

From there, the pattern repeats: encode the logic, define the constraints, let it run. Add the next workflow. Then the next.

Mimic has processed over $9B in value across 450M+ transactions for teams like Trust Wallet, Trezor, and Ledger. The execution layer is production-tested.

* * *

If you're running strategies onchain_,_ [_reach out_](https://mimic.fillout.com/t/14mhpYTCR4us)_. We'll walk through your workflows and show you what the first integration looks like._

📚 [Documentation](https://docs.mimic.fi/) | 🌐 [Website](https://www.mimic.fi/) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# The Infrastructure Behind One-Click DeFi

> Behind every single user click in DeFi, there are some of the most complex coordination problems in crypto. Let's explore what we don't see in the UI.

Published: 2026-03-09 | Updated: 2026-04-01 | Author: Mimic Engineering Team | Tags: Mimic Platform | Source: https://www.mimic.fi/blog/the-infrastructure-behind-one-click-defi

![](https://www.mimic.fi/blog/the-infrastructure-behind-one-click-defi/The-Infra-blog.png)

You click deposit, a wallet pops up, a signature, a short wait. And just like that, your funds are working.

From an user perspective, modern DeFi feels more accessible (especially compared to the early days): a vault, a button, access to yield.

But behind that single click is one of the most complex coordination problems in crypto.

This article is about everything that we don't see in the UI.

## The illusion of simplicity

One-click DeFi is not simple because DeFi itself became simple, it's because complexity was abstracted, pushed behind the curtains.

When a user deposits funds into a smart contract, they are not just moving tokens, they are joining a system that must:

-   Observe markets
-   React to changing conditions
-   Execute transactions at the right time (and at the right gas cost)
-   Usually across chains
-   Under strict security requirements

And of course without breaking the user's trust.

The UI hides all of this, but the system underneath has to handle all of this continuously.

## The two types of one-click DeFi

From the user’s perspective, there are two kinds of one-click DeFi:

### Passive one-click DeFi

You deposit once and the protocol simply holds your position, earning yield or accruing interest, but never acting on your behalf.

Lending on Aave or depositing into a basic pool feels one-click, yet risk and optimization remain your responsibility.

### Active (or automated) one-click DeFi

It goes a step further: you still click once, but behind the scenes the system continuously monitors conditions, makes decisions, and executes transactions for you.

Rebalancing, compounding, protecting against risk, and reacting to the market all happen without further user input. The UX looks the same, but the second replaces ongoing human attention with infrastructure.

![](https://www.mimic.fi/blog/the-infrastructure-behind-one-click-defi/image.png)

[https://x.com/mimicfi/article/2030999687897989328/media/2030999462823260161](https://x.com/mimicfi/article/2030999687897989328/media/2030999462823260161)

## How one-click DeFi works behind the scenes

From the UI, passive and active one-click DeFi look almost identical: you deposit, sign, and you’re done. Behind the scenes, however, they follow very different execution paths.

### Passive one-click DeFi: “set and forget”

This is the simplest form of one-click DeFi. The system does very little for the user after the initial deposit.

1.  **Deposit & accounting:** funds are deposited into a protocol (e.g. a lending market or pool) and tracked under your position.
2.  **Static rules apply:** interest rates, rewards, or fees are calculated based on the parameters set by the protocol.
3.  **External actors react:** for example if risk thresholds are crossed, other parties like liquidators, arbitrageurs or keepers might act.
4.  **No decisions for the user:** the protocol never rebalances your position, reduces risk, or optimizes yield. You are the one that needs to keep track of the liquidation threshold.

### Active / automated one-click DeFi: “set and delegate”

Active one-click DeFi replaces ongoing user attention with infrastructure.What happens behind the scenes:

1.  **Deposit + strategy definition:** your deposit gets defined with certain conditions, thresholds, safeguards, and allowed actions.
2.  **Continuous monitoring.** The system constantly observes:

-   Prices
-   Balances
-   Positions
-   Market conditions
-   Cross-chain state (when relevant)

3\. **Deterministic decision-making.** Predefined logic evaluates whether something should happen now:

-   Rebalance
-   Compound
-   Repay debt
-   Move liquidity
-   Exit a position

4\. **Coordinated execution.** The best execution path is selected, via intents or other methods.

5\. **Safeguards & verification.** Before funds move:

-   Slippage limits are enforced
-   Outputs are validated
-   Constraints are checked onchain

6\. **Recovery by design.** If an executor fails:

-   The system retries
-   Another executor takes over
-   The user never has to intervene

Here, one-click means everything that should happen later is handled for you.

## Why one-click DeFi is hard to build and maintain

Building this once is difficult, but maintaining it is harder. The system must survive market volatility, chain congestion, oracle failures, or constant attackers, among other threats. Check this post by bsmokes about building with 4337 wallets:

[https://x.com/bsmokes](https://x.com/bsmokes)

  
  
The real product is not the button. The button is just the interface. The real product is all the infrastructure that runs the coordination, execution, and keeps working after the user closes the app.

## Build one-click DeFi with Mimic

> Building in DeFi is hard.

You need systems that monitor markets, evaluate conditions, trigger transactions, and keep everything running across chains.

Mimic provides that infrastructure through a development platform:

1.  Define your DeFi logic as programmable functions (with conditions, triggers, thresholds)
2.  Or choose from ready-to-use templates
3.  Let Mimic handle monitoring, coordination, and execution

No custom scripts, smart contracts to deploy, or execution infrastructure to maintain.

Just ship new features and products. Users click once. Mimic runs everything behind the scenes.

Explore more at [docs.mimic.fi](http://docs.mimic.fi/)

---

# The Fastest Way to Build a DeFi App in 2026

> Most DeFi apps don't fail because teams can't write contracts, they fail because of the the infrastructure deployment and maintenance. Let's explore the fastest way to build a DeFi app in 2026.

Published: 2026-03-04 | Updated: 2026-03-04 | Author: Mimic Engineering Team | Tags: Mimic Platform | Source: https://www.mimic.fi/blog/the-fastest-way-to-build-a-defi-app-in-2026

![](https://www.mimic.fi/blog/the-fastest-way-to-build-a-defi-app-in-2026/build-fast-1-social2-1.png)

Five years ago, writing smart contracts was rare. But today, Solidity is taught in universities and bootcamps, and AI can write contracts in seconds. The number of people who can write DeFi code has exploded.

But here's the truth: Most DeFi apps don't fail because teams can't write contracts. They fail because of what comes next, the infrastructure deployment and maintenance.

-   Bots
-   Gas abstraction
-   Retry logic
-   Monitoring
-   Server maintenance

AI can help you write contracts faster, but it does not remove the execution, coordination, and settlement problems. That's where most teams spend months, or give up entirely.

## The Real Bottleneck in DeFi Development

In 2026, the real bottleneck in DeFi is not Solidity, it's execution infrastructure.

Let's say you've written the smart contracts needed, compiled and tested them, maybe even audited. It feels like you're on the finish line, but you're not. Writing the smart contracts is just the beginning.

The real work starts when your DeFi apps needs to run reliably in the real world. The moment your app goes live, you now need to handle:

-   Transaction monitoring across chains
-   Gas price volatility
-   Settlement guarantees
-   Oracle integrations
-   Liquidity and execution routing
-   Secure key management for any bots and human operators
-   Alerting and monitoring

And none of this is your actual product, it's just what's needed to keep it alive.

## The Costs in DeFi Development

1.  **Time cost**

Infrastructure maintenance doesn't just add complexity, it adds a lot of time to the development. Time spent writing contracts, bots, scripts. Time spent fixing errors, monitoring dashboards.

2.  **Financial cost**

Auditing, running nodes or RPC providers, paying engineers, covering failures, managing gas across chains... all the costs add up.

3.  **Mental energy**

This is harder to measure, but instead of managing infrastructure, you could use your mental energy to make your product better.

## The Solution: Build the Product, Delegate the Execution

What if building a DeFi app didn't require you to become an infra company? What if you didn't need to manage bots, gas, retries, or servers?

### **Introducing Mimic**

Mimic is a developer platform that allows teams to build blockchain applications without dealing with low-level complexities.

Instead of building and maintaining custom infrastructure, builders can focus on product logic while Mimic handles execution, reliability, and security under the hood.

Developers define what should happen and when, Mimic handles how it happens:

1.  Write simple, familiar code to define what should happen and when
2.  Mimic handles execution, data sourcing, coordination, and safeguards
3.  A decentralized network of three layers powers the platform
4.  Logic is compiled, executed, and settled with security guarantees

If you want to learn more, check out our documentation at [**docs.mimic.fi**](http://docs.mimic.fi/).

![](https://www.mimic.fi/blog/the-fastest-way-to-build-a-defi-app-in-2026/build-fast-1-PostBreaks01.png)

## Examples of Building With Mimic

We built some real mini-apps on top of Mimic to show how development with our platform could look like.

Each of these examples is simple at the surface: a front-end that connects to Mimic functions. These apps do not rely on custom scripts, RPCs, or cross-chain swaps; all of that is handled and abstracted by the platform.

The app only define the parameters, as a user would interact with any front-end you create to interact with Mimic.

Here are four examples you can explore today:

### Swap App

A simple swap interface where users define de source and destination token and chain, amount, and slippage.

![](https://www.mimic.fi/blog/the-fastest-way-to-build-a-defi-app-in-2026/Screenshot-2026-02-27-at-11.39.02.png)

The frontend defines what the user wants, and Mimic handles how it happens.

Link: [https://github.com/mimic-fi/ethereum-swap-app-with-mimic](https://github.com/mimic-fi/ethereum-swap-app-with-mimic)

### Automated Savings

A recurring savings app that deposits funds into Aave automatically.

Users define the asset, chain, amount, and frequency.

![](https://www.mimic.fi/blog/the-fastest-way-to-build-a-defi-app-in-2026/Screenshot-2026-02-27-at-11.43.04.png)

The user can focus on the savings logic, and Mimic ensures it get executed on time.

Link: [https://github.com/mimic-fi/aave-savings-app-with-mimic](https://github.com/mimic-fi/aave-savings-app-with-mimic)

### Cross-Chain Subscriptions

A subscription payment system where users can:

-   Pay in any supported token
-   On any supported chain
-   On a recurring schedule
-   Without holding native gas tokens

![](https://www.mimic.fi/blog/the-fastest-way-to-build-a-defi-app-in-2026/Screenshot-2026-02-27-at-11.43.25.png)

Mimic coordinates execution across chains atomically. From the product side, you’re just defining a recurring payment rule.

Link: [https://github.com/mimic-fi/cross-chain-subscription-payments-with-mimic](https://github.com/mimic-fi/cross-chain-subscription-payments-with-mimic)

### Card Auto Top-Up

A programmable card top-up system.

Users define the balance threshold, the amount they want to send, the token (and chain) they want to send, and the slippage.

![](https://www.mimic.fi/blog/the-fastest-way-to-build-a-defi-app-in-2026/Screenshot-2026-02-27-at-11.43.36.png)

Mimic monitors, routes, swaps, settles, and guarantees the top-up when conditions are met. The product only defines the policy.

Link: [https://github.com/mimic-fi/card-top-up-with-mimic](https://github.com/mimic-fi/card-top-up-with-mimic)

### Check the examples here

You can check all these mini-apps and their source code here:

👉 [https://github.com/mimic-fi](https://github.com/mimic-fi)

## Unlock easier DeFi development with Mimic

Each of these apps would traditionally require:

-   Backend infrastructure
-   Bots and cron jobs
-   Cross-chain bridges
-   Gas abstraction layers
-   Monitoring dashboards
-   Retry systems
-   Dedicated DevOps

With Mimic, they require none of that. You define deterministic logic. Mimic compiles it, coordinates it, executes it, and settles it securely.

If you start using Mimic to build DeFi apps, you’ll notice something immediately:

The complexity is gone.

## Try Mimic Now!

**Available on Arbitrum, Base, Base Sepolia, Ethereum, Gnosis, Optimism, and Sonic.**

![](https://www.mimic.fi/blog/the-fastest-way-to-build-a-defi-app-in-2026/try-mimic-now.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let Mimic handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 💬 [Discord](https://discord.mimic.fi/) | 💻 [Telegram](https://t.me/+cBCtvvZuGpplNmY8)

🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# Migration Guide: From Gelato Web3 Functions to Mimic

> Are you looking to migrate from Gelato Web3 Functions (Automation) before they shut down? Use Mimic, a clean, low-risk, and battle-tested alternative. 

Published: 2026-02-09 | Updated: 2026-02-09 | Author: Mimic Engineering Team | Tags: Mimic Platform, Onchain Automation, Mimic Guides | Source: https://www.mimic.fi/blog/migration-guide-from-gelato-web3-functions-to-mimic

![](https://www.mimic.fi/blog/migration-guide-from-gelato-web3-functions-to-mimic/Migration-Guide_-From-Gelato-Web3-Functions-to-Mimic.png)

This guide is written for teams migrating off Gelato Web3 Functions before they shut down, and looking for a clean, low-risk and battle-tested alternative.

It focuses on replacing the automation that used to live in Gelato towards Mimic.

## What Gelato Web3 Functions were typically used for

**Onchain logic and data**

-   Fetching prices or external signals from APIs
-   Refreshing oracles or updating interest rates
-   Write here the different use cases

**Triggers and schedules**

Gelato provided a flexible trigger system that set up when the logic should run:

-   Time-based (cron, interval),
-   Event-based (onchain events),
-   State-based (every block).

**Execution + operations**

Gelato also handled submitting transactions, managing whitelisted executors, and retrying functions.

## Mapping Gelato to Mimic concepts

In order to achieve a successful migration, we want to show how Gelato's concepts translate into the Mimic system.

![](https://www.mimic.fi/blog/migration-guide-from-gelato-web3-functions-to-mimic/Screenshot-2026-02-09-at-13.59.42.png)

You can easily migrate all of Gelato's Web3 Functions into Mimic Functions, that also support TypeScript.

-   A Mimic Function is executable logic onchain that runs on demand of the user
-   You can group multiple Functions together to create a project
-   And add multiple triggers to run your functions

As you might see, even tho the Mimic system uses a different technical approach than Gelato, some of the workflows are similar, allowing you to quickly rewrite your Web3 Functions into Mimic.

## How to start the migration of Gelato Web3 Functions into Mimic

We recommend a step-by-step approach to have everything running smoothly in a short time.

**Migration checklist:**

1.  Inventory of existing Gelato functions
2.  Classify by criticality (leave the most critical for the end)
3.  Find the TS code of your Web3 Functions
4.  Translate it into Mimic functions
5.  Test and deploy one-by-one
6.  Cut Gelato Web3 functions gradually

Before starting the deployment in Mimic, let’s figure out the differences between Gelato Functions and Mimic Functions.

### Example: **Automated Fee Consolidation**

The goal of this function is to swap multiple tokens for USDC, and transfer the USDC to another account.

How to provide the configuration for the function:

-   In Gelato (schema.json)

```json
{
  "web3FunctionVersion": "2.0.0",
  "runtime": "js-1.0",
  "memory": 128,
  "timeout": 30,
  "userArgs": {
    "proxyAddress": "string",
    "tokenInAddresses": "string[]",
    "tokenOutAddress": "string",
    "minOutAmount": "string"
  }
}
```

-   In Mimic (manifest.yaml)

```yaml
version: 1.0.0
name: Collect Function
description: Swaps all user tokens for USDC and sends the USDC to a recipient
inputs:
  - chainId: int32
  - slippageBps: uint16   # e.g., 50 = 0.50%
  - recipient: address
```

Then the function itself:

-   In Gelato

```tsx
import { AutomateSDK, Web3Function } from "@gelatonetwork/automate-sdk";
import { task } from "hardhat/config";
import "dotenv";

task("consolidate", "Automatically swap accrued tokens")
  .addParam("in", "list of tokens to swap, separated by commas")
  .addParam("out", "unified token to swap input tokens for")
  .addParam("amount", "minimum output amount denominated in output tokens")
  .setAction(async (args, { ethers, w3f }) => {
    const apiKey = process.env.ONEINCH_API_KEY;
    if (!apiKey) throw new Error("Consolidate: missing 1inch API key in .env");

    const tokensIn = (args.in as string).split(" ");
    for (const token of tokensIn) {
      if (!ethers.utils.isAddress(token))
        throw new Error("Consolidate: invalid input token address");
    }

    const tokenOut = args.out as string;
    if (!ethers.utils.isAddress(tokenOut))
      throw new Error("Consolidate: invalid output token address");

    const amount = BigInt(args.amount);
    if (!amount) throw new Error("Consolidate: invalid amount");

    // deploy W3F to IPFS
    console.log("Deploying W3F to IPFS.");

    const consolidateW3f = w3f.get("consolidate");
    const cid = await consolidateW3f.deploy();

    console.log(`Deployed W3F hash ${cid}.`);

    // create W3F task
    console.log("Creating W3F task.");

    const [deployer] = await ethers.getSigners();
    const chainId = await deployer.getChainId();

    const automate = new AutomateSDK(chainId, deployer);
    const web3Function = new Web3Function(chainId, deployer);
    const proxy = await automate.getDedicatedMsgSender();

    const { taskId, tx } = await automate.createBatchExecTask({
      name: "Automated Fee Consolidation",
      web3FunctionHash: cid,
      web3FunctionArgs: {
        proxyAddress: proxy.address,
        tokenInAddresses: tokensIn,
        tokenOutAddress: tokenOut,
        minOutAmount: amount.toString(),
      },
    });

    await web3Function.secrets.set({ key: apiKey }, taskId);
    await tx.wait();

    console.log(
      `Created consolidate task: <https://beta.app.gelato.network/task/${taskId}?chainId=${chainId}`>
    );
  });
```

-   In Mimic

```tsx
import {
  Arbitrum,
  Base,
  ChainId,
  environment,
  ListType,
  log,
  Optimism,
  SwapBuilder,
  Token,
  USD,
} from '@mimicprotocol/lib-ts'

import { inputs } from './types'

export default function main(): void {
  const chainId = inputs.chainId
  const context = environment.getContext()

  // Find tokens with user's balance > 0
  const amountsIn = environment.relevantTokensQuery(context.user, [chainId], USD.zero(), [], ListType.DenyList).unwrap()
  if (amountsIn.length == 0) {
    log.info(`No tokens found on chain ${chainId}`)
    return
  }

  const USDC = getUsdc(chainId)

  for (let i = 0; i < amountsIn.length; i++) {
    const amountIn = amountsIn[i]
    const amountOut = amountIn.toTokenAmount(USDC).unwrap()
    const minAmountOut = amountOut.applySlippageBps(inputs.slippageBps as i32)

    // Note that the recipient will receive the USDC
    SwapBuilder.forChain(chainId)
      .addTokenInFromTokenAmount(amountIn)
      .addTokenOutFromTokenAmount(minAmountOut, inputs.recipient)
      .build()
      .send()

    log.info(`Adding swap of ${amountIn} to ${minAmountOut} on chain ${chainId}`)
  }
}

function getUsdc(chainId: i32): Token {
  if (chainId == ChainId.ARBITRUM) return Arbitrum.USDC
  if (chainId == ChainId.BASE) return Base.USDC
  if (chainId == ChainId.OPTIMISM) return Optimism.USDC
  throw new Error('Invalid chain')
}
```

You can learn more about how to write a Mimic function in our documentation: [https://docs.mimic.fi/](https://docs.mimic.fi/)

And library: [https://docs.mimic.fi/developers/library](https://docs.mimic.fi/developers/library)

![](https://www.mimic.fi/blog/migration-guide-from-gelato-web3-functions-to-mimic/Migration-Guide_-From-Gelato-Web3-Functions-to-Mimic--2-.png)

## What is Mimic and how does it work?

Mimic is a developer platform to build blockchain apps, unlocking automation for your Web3 stack in a simple way.

Using the Mimic platform consists of the following steps:

1.  Start your function: start a working directory to create your function
2.  Define the manifest: it’s a .yaml file where you write the metadata (name, description, version), parameters, and other things
3.  Generate types
4.  Write the function logic
5.  Build: validate and compile the function logic
6.  Deploy: upload your build to the Mimic registry, so it’s available to execute

## Useful resources to start with Mimic

Starting guide: [https://docs.mimic.fi/examples/build-a-simple-function](https://docs.mimic.fi/examples/build-a-simple-function)

How to understand the platform quickly: [https://www.mimic.fi/blog/understand-mimic-in-10-minutes](https://www.mimic.fi/blog/understand-mimic-in-10-minutes)

## Migrate Gelato Web3 Functions to Mimic and achieve more

Mimic has a similar approach to Gelato Automation, but also lets you achieve even more:

1.  **Multi-step workflows:** you can compose logic that can be chained, and reused, enabling solutions to cover any use case you need. Just chain multiple functions or have them listen to each other to activate.
2.  **Cross-chain by design:** one function or project can safely operate across multiple networks.
3.  **Built-in safety engine:** Mimic includes native safeguards and policies (constraints that define what must and must never happen).

For teams coming from Gelato automation, Mimic feels close enough that you can migrate quickly, while still unlocking more advanced use cases over time.

## Need help migrating from Gelato Web3 Functions?

We’re always happy to help!

You can reach us out here:

Discord: [https://discord.mimic.fi/](https://discord.mimic.fi/)

Telegram: [https://t.me/+cBCtvvZuGpplNmY8](https://t.me/+cBCtvvZuGpplNmY8)

![](https://www.mimic.fi/blog/migration-guide-from-gelato-web3-functions-to-mimic/Migration-Guide_-From-Gelato-Web3-Functions-to-Mimic--3-.png)

---

# Gelato Web3 Automation is Ending: Use Mimic

> Gelato Web3 Functions are ending in March of 2026. If your team used Gelato for automation, Mimic is a great alternative. Explore more in this blog!

Published: 2026-02-09 | Updated: 2026-02-09 | Author: Mimic Engineering Team | Tags: Mimic Platform, Onchain Automation | Source: https://www.mimic.fi/blog/gelato-web3-automation-is-ending-use-mimic

![](https://www.mimic.fi/blog/gelato-web3-automation-is-ending-use-mimic/Gelato-Web3-Automation-Is-Ending_-Use-Mimic.png)

Gelato's automation platform (Web3 Functions) will be deprecated on March 31 2026.

![](https://www.mimic.fi/blog/gelato-web3-automation-is-ending-use-mimic/Screenshot-2026-02-09-at-14.24.22.png)

*You might have seen this on Gelato's app.*

After years of powering automation for key Web3 applications and protocols, Gelato is shifting focus, due to their great success of their rollup-as-a-service (RaaS) business, where it has seen massive adoption and growth.

For teams that relied on Gelato Web3 Functions to run critical automation, this marks an important transition point: workflows that used Gelato's automation will stop soon unless they are migrated to a new service.

This posts explains who is affected, what breaks with the shut down, and why Mimic is especially relevant right now.

## What is ending?

Gelato Web3 Functions are being deprecated, Gelato's automation product.

They acted as a backend or execution layer. Developers could write TypeScript functions, deploy them to IPFS, and give the execution to the Gelato system.

They allowed cron jobs, recurring transactions, onchain events, and more. That entire product line is now being shut down.

## How does this impact existing Gelato automation users?

If your application relied on Gelato Web3 Functions, you’re affected.

This includes teams using Web3 Functions for:

-   Off-chain data ingestion (APIs, subgraphs, analytics)
-   Conditional onchain execution
-   Scheduled automation (cron jobs, interval tasks)
-   Event-driven workflows
-   Large-scale operational systems (liquidations, treasury ops, rebalancing)

All your triggers, recurring jobs, functions, logs, and more will stop functioning.

If Web3 Functions were part of your infrastructure, now is the time to look for another solution.

![](https://www.mimic.fi/blog/gelato-web3-automation-is-ending-use-mimic/Gelato-Web3-Automation-Is-Ending_-Use-Mimic--2-.png)

## The alternative: Mimic

Mimic is a developer platform to build blockchain apps, unlocking automation for your Web3 stack in a simple way.

You can easily migrate all of Gelato's Web3 Functions into Mimic Functions, that also support TypeScript.

-   A Mimic Function is executable logic onchain that runs on demand of the user.
-   You can group multiple Functions together to create a project.
-   And add multiple triggers to run your functions.

Mimic has a similar approach to Gelato Automation, but also lets you achieve even more:

1.  Multi-step workflows: you can compose logic that can be chained, and reused, enabling solutions to cover any use case you need. Just chain multiple functions or have them listen to each other to activate.
2.  Cross-chain by design: one function or project can safely operate across multiple networks.
3.  Built-in safety engine: Mimic includes native safeguards and policies (constraints that define what must and must never happen).

For teams coming from Gelato automation, Mimic feels close enough that you can migrate quickly, while still unlocking more advanced use cases over time.

## Quickly understand Mimic

If you're evaluating how to replace Gelato Web3 Functions with Mimic Functions, or planning a migration before March 31st 2026, start here:

-   [Understand Mimic in 10 minutes](https://www.mimic.fi/blog/understand-mimic-in-10-minutes)
-   [Migration Guide: From Gelato Web3 Functions to Mimic](https://www.mimic.fi/blog/migration-guide-from-gelato-web3-functions-to-mimic)

### Need help migrating from Gelato Web3 Functions?

We’re always happy to help!

You can reach us out here:

Discord: [https://discord.mimic.fi/](https://discord.mimic.fi/)

Telegram: [https://t.me/+cBCtvvZuGpplNmY8](https://t.me/+cBCtvvZuGpplNmY8)

![](https://www.mimic.fi/blog/gelato-web3-automation-is-ending-use-mimic/Gelato-Web3-Automation-Is-Ending_-Use-Mimic--3-.png)

---

# Understand Mimic in 10 Minutes

> Mimic removes the friction of traditional blockchain development, enabling developers to build and scale onchain with greater speed, confidence, and operational clarity. Let's understand Mimic quickly!

Published: 2026-02-02 | Updated: 2026-02-05 | Author: Mimic Engineering Team | Tags: Mimic Platform | Source: https://www.mimic.fi/blog/understand-mimic-in-10-minutes

![](https://www.mimic.fi/blog/understand-mimic-in-10-minutes/BLOG_What-is-mimic-protocol-04--2-.png)

Mimic is a developer platform for building blockchain applications, agents, and protocols faster and easier.

You can write what should happen onchain and when in simple, familiar code, without having to deploy smart contracts, or manage servers, nodes, wallets, keys, scripts, or bots.

## Why use Mimic

Mimic removes the friction of traditional blockchain development, enabling developers to build and scale onchain with greater speed, confidence, and operational clarity, while retaining full transparency and control over how things should work.

With Mimic, teams can:

-   Build onchain in less steps
-   Express business/product logic in familiar code
-   Run that logic with security guarantees
-   Easily scale across chains
-   Replace cron jobs, scripts, and bots
-   Access powerful onchain automation

## Understanding Mimic quickly

In Mimic, you create what we call **functions**: executable logic that runs on demand without managing servers or infrastructure.

Then we have a **project**, which is a group of different functions. For advanced use cases, when a single function doesn’t cover the entire workflow, or as a way to use a function in multiple use cases without having to write a new one from scratch.

Inside each function you can set up different triggers (price, events, thresholds, etc.) and also policies (onchain constraints that limit what can be executed on a user’s behalf).

## The Mimic workflow

The process consists of the following steps:

1.  Start your function: start a working directory to create your function.
2.  Define the manifest: it’s a .yaml file where you write the metadata (name, description, version), parameters, and other things.
3.  Generate types.
4.  Write the function logic.
5.  Build: validate and compile the function logic.
6.  Deploy: upload your build to the Mimic registry, so it’s available to execute.

Let’s start using Mimic!

![](https://www.mimic.fi/blog/understand-mimic-in-10-minutes/BLOG_What-is-mimic-protocol-03--3-.png)

## 1\. Start your function

Let's start a new working directory to develop your function. To do that you can run the following command:

```
npx @mimicprotocol/cli init ./my-mimic-task
```

## 2\. Define the manifest

The manifest file provides the configuration for your task, including:

-   **Metadata**: Name, description, and version of the function.
-   **Inputs**: Parameters required by the function logic.
-   **ABIs**: Smart contract ABIs (description of a contract’s public interface) to generate type-safe interfaces for the task.

The manifest can be located in your working directory as a manifest.yaml file.

Here is an example on how the manifest looks like:

```yaml
version:1.0.0
name:Transfer based on USD threshold
description:Automated task to execute parameterized transfers based on balance threshold in USD
inputs:
  -chainId:uint32
  -token:address
  -amount:string# e.g., '10.2' = 10.2 of the given token
  -recipient:address
  -maxFee:string# e.g., '0.01' = 0.01 of the given token
  -thresholdUsd:string# e.g., '30.5' = 30.5 USD
abis:
  -ERC20:./abis/ERC20.json
```

This manifest file defines different inputs that will be accessible from the task logic code thanks to the types generation process that will be explained in the next section.

For a more detailed explanation about the manifest, [check our documentation](https://docs.mimic.fi/examples/build-a-simple-task#manifest-definition).

You can also find different examples of manifests here: [https://github.com/mimic-protocol/examples/tree/main/examples](https://github.com/mimic-protocol/examples/tree/main/examples)

## 3\. Generate types

This steps allows you to validate the manifest definitions and generate the corresponding code to access both your declared inputs and the contract objects for your declared ABIs.

To do this you can run the `codegen` command using the CLI:

```
yarn mimic codegen
```

## 4\. Write the function logic

This is the main point of Mimic: focusing on what you want to happen, and when. Inside each function, you can write different types of triggers, schedules, events, etc.

In this step you are going to expand what you defined in the manifest.yaml.

The function logic is implemented in AssemblyScript and must export:

1.  **Input type**: The generated `inputs` type from the manifest..
2.  **Main function**: The core function logic, which receives the inputs as an argument.

For now Mimic functions allows creating three types of intents:

-   Transfers
-   Generic calls
-   Cross-chain swaps

You can find different examples of functions here: [https://github.com/mimic-protocol/examples/tree/main/examples](https://github.com/mimic-protocol/examples/tree/main/examples)

## 5\. Build

The compile process converts your task logic and manifest into deployable artifacts. Basically it takes your manifest and function logic and transforms it into something you can upload to the Mimic registry to run at any time you want.

For this, just run the compile command:

```
yarn mimic compile
```

## 6\. Deploy

Once your function has been compiled into an artifact, you can upload it to the network so others can discover it.

To do this you can run the `deploy` command using the CLI:

```
yarn mimic deploy --api-key [DEPLOYMENT_KEY]
```

You can generate a deployment key from the explorer app:

Just go to: [https://protocol.mimic.fi/](https://protocol.mimic.fi/)

Login using your wallet, and click on “generate API key”.

<video src="https://www.mimic.fi/blog/understand-mimic-in-10-minutes/API-Key-Generation.mp4" autoPlay loop muted playsInline />

Once you have it, keep it secure and don't share it publicly.

## 7\. Give allowance to the Mimic settler

**Before you configure your task in the dashboard, you must allow the Mimic Settler to spend tokens on behalf of your smart account.**

If you created a smart account through the Mimic dashboard, you are set. If you have a different type of smart account:

1.  Open your network’s block explorer and find your smart account contract.
2.  Connect your wallet.
3.  Set the Mimic Settler in "setSettler".
4.  Approve the contract so it can manage the tokens needed for your task.

Mimic Settler contract:

`0x609d831c0068844e11ef85a273c7f356212fd6d1`

![](https://www.mimic.fi/blog/understand-mimic-in-10-minutes/image.png)

## 8\. Configure your function

After deploying your function, you can now configure it to tell which config relayers should use to run your task. This means defining the parameters declared in your `manifest.yml` file.

This configuration is done in the [explorer UI](https://protocol.mimic.fi/) where you will be requested to sign your config with your wallet.

![](https://www.mimic.fi/blog/understand-mimic-in-10-minutes/screely-1761217455989--2-.png)

1.  Open the explorer and locate the function you just deployed under the function section.
2.  Add or edit your config parameters
3.  Sign the new config

This signature ensures relayers know the config is authorized by the task owner.

You can update or deprecate this config at any point in time to reflect changes, without needing to redeploy the task code again. Just sign the new config in the explorer, and relayers will pick up the latest version.

# Start building with Mimic!

That’s the basics of building with Mimic. In future blogs we’ll go deeper into advanced functions, cross-chain execution, and real production use cases.

If you’re ready to build, head to [docs.mimic.fi](http://docs.mimic.fi/)!

![](https://www.mimic.fi/blog/understand-mimic-in-10-minutes/BLOG_What-is-mimic-protocol-03--4-.png)

---

# 2025 Year in Review

> As 2025 comes to an end, we wanted to pause and summarise what we've accomplished this year, and what lies ahead in 2026.

Published: 2025-12-31 | Updated: 2026-01-02 | Author: Mimic Engineering Team | Tags: Events | Source: https://www.mimic.fi/blog/2025-year-in-review

![](https://www.mimic.fi/blog/2025-year-in-review/2025_Review.png)

# Mimic 2025 Year in Review

In 2025, we had a single north star - what onchain programmability looks like for real builders?

Writing Solidity, deploying smart contracts, handling upgrades, or maintaining infrastructure slows teams down and increases risks. During Devcon 7, we realised how big a challenge it is for builders. This sparked an idea for Mimic Protocol, and what was an idea at the end of 2024 became reality over the course of 2025.

With the release of our Whitepaper in January, we went heads down and started shipping:

-   Implemented core components for the Mimic Protocol: settler, validators, smart account generation
-   Deployed the protocol to Arbitrum, Base, Ethereum, Gnosis, Optimism, Sonic, and Base Sepolia for testnet use
-   Solana implementation is underway, very close to production
-   We worked on supporting crosschain integration
-   Validators went live
-   Added new intent properties, support for event-triggered tasks, Subgraph queries, and more

![](https://www.mimic.fi/blog/2025-year-in-review/Screenshot-2025-12-31-at-10.45.47.png)

## 2) Real-World Usage

We did not only focus on delivering the infrastructure layer. With a large customer base, we began exploring areas where Mimic Protocol can actually improve existing processes and which use cases we can finally deliver (and not spend months coding).

-   Automated multiple internal client workflows using Mimic Protocol
-   Expanded the Mimic Fee Collector to Solana, Unichain, and Sonic
-   Launched an alpha and beta versions of the protocol
-   TokenLogic used a Mimic task to collect and distribute fees from the Aave Protocol to the DAO and treasury
-   Launched an automated vault demo on Lagoon Finance using Mimic tasks

## 3) Developer Experience

We want to meet builders where they are, and we know they want programmable and composable systems that they can plug into existing stacks, so we have been improving the Mimic Protocol, having dev experience on top of mind:

-   Dev-friendly SDK
-   Improved task-writing experience
-   Added event-triggered tasks, ABI decoding, subgraph queries
-   Expanded intent properties for more complex workflows
-   Updated explorer UX, onboarding flows
-   Improved the docs and added extensive examples on GitHub
-   Added Safe compatibility + EIP-7702 support
-   Upgraded our infra for zero-downtime deployments
-   You can now run a task to test it before production

![](https://www.mimic.fi/blog/2025-year-in-review/Screenshot-2025-12-31-at-10.47.03.png)

## 4) Community

Throughout the year, we've been connecting IRL as much as possible with devs and builders to learn how they think, what they need, and how we can help them in their journey.

-   Mini-hackathon at Aleph Hub
-   Technical workshops (online and offline)
-   Panels, mentoring, and coworking days across Argentina 🇦🇷
-   Builder-focused side events at Devconnect (Builders Brunch, DevNVibe)
-   Content designed to educate (scripts vs Mimic, protocol guides, use cases)
-   We created a Telegram channel for dev support and hackathon support

## 5) Key Events

-   Introduced Mimic Protocol at ETH Denver
-   We soft launched the Protocol at EthCC Cannes with our own side event
-   Heavy presence across Europe: ETH Zurich, Bratislava, Prague, Belgrade, Berlin Blockchain Week, ETH Warsaw
-   Devconnect Buenos Aires: Ethereum World Fair, talks, workshops, hackathons, side events
-   Ethereum featured Mimic on their official X, and the EF featured Mimic in their blog around Devconnect
-   Our CTO Facu participated in Argentina's crypto story livestream by the EF

![](https://www.mimic.fi/blog/2025-year-in-review/image-12.png)

## 2026 and beyond

We've spent the whole of 2025 in the builder mode. We don’t plan to stop; there are still many more features that need shipping, including external solvers, relayers, and oracles, a better dev experience, custom data as triggers, and more.

But since we have a workable product, the next few quarters are going to be key for growth and expansion of our dev community. We're entering the next phase of onchain programmability, with a production-ready SDK, deeper wallet and agent integrations, and helping builders abstract all the complexities of blockchain development.

Mimic abstracts away execution, gas, RPCs, and cross-chain complexity, so developers can focus on logic and product outcomes, making blockchain development faster, safer, and accessible without sacrificing power or composability.

2026 will be a year of growth and exploration of new use cases and integrations. We’re going to expand our Automated Vaults, and connect the Mimic Protocol directly with Web3 builders and those coming from Web2 wanting to learn blockchain development.

Let’s keep building!

![](https://www.mimic.fi/blog/2025-year-in-review/2025_Review--2-.png)

---

# Auto-Investing On Aave With Mimic Protocol

> Automate Aave deposits directly from your smart account using Mimic Protocol. Adapt it to your preferred configuration!

Published: 2025-12-22 | Updated: 2026-02-02 | Author: Mimic Engineering Team | Tags: Mimic Guides | Source: https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol

![](https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/mimic-protocol-guide-Aave.01.png)

## TL;DR

Automate Aave deposits directly from your smart account using Mimic Protocol. This guide walks through building a function that automatically converts idle tokens into their corresponding Aave aTokens once a USD balance threshold is met.

## Quick Details

-   **Function type:** auto-investment (deposit into Aave)
-   **Strategy:** detect when a token balance exceeds a USD threshold and deposit it into Aave
-   **Key inputs:** `aToken`, `thresholdUSD`, `chainId`

<div className="kg-card kg-callout-card kg-callout-card-yellow">

This is just an example. Mimic Protocol lets you automate any DeFi action (deposits, swaps, or complex multi-step investment flows) directly inside your wallet.

</div>

## What You Need to Get Started

-   [Node.js](https://nodejs.org/en) + [Yarn](https://www.geeksforgeeks.org/installation-guide/how-to-install-yarn-in-macos-ubuntu-windows) installed
-   **Smart account with funds**

## Step-by-Step Aave Auto-Investing Guide.

## Understand the Auto-Invest Flow

This function automatically checks your **smart account** balance and invests it into Aave if it exceeds a USD threshold:

1.  Find the selected **Aave aToken** and identify its **underlying ERC20 token**.
2.  Fetch your smart account’s balance of the underlying token.
3.  Convert that balance to **USD** and compare it to the configured **threshold**.
4.  If the threshold is met, **supply the full underlying balance to Aave, minting the corresponding aToken**.

## Define the Function

### 1\. Initialize project

Start a new working directory to develop your function:

```jsx
npx @mimicprotocol/cli init ./my-aave-auto-investing
```

### 2\. Update your `manifest.yaml`

The manifest file provides the configuration for your function, including:

-   **Metadata**: Name, description, and version of the function.
-   **Inputs**: Parameters required by the function logic.
-   **ABIs**: Smart contract ABIs to generate type-safe interfaces for the function.

Save this configuration in the `manifest.yaml` file:

```yaml
version: 1.0.0
name: Invest in AAVE idle balance
description: Automated function to invest in AAVE idle balance above certain threshold in USD
inputs:
  - chainId: uint32
  - aToken: address
  - smartAccount: address
  - thresholdUsd: string    # e.g., '30.5' = 30.5 USD
  - maxFeeUsd: string       # e.g., '0.05' = 0.05 USD
abis:
  - ERC20: ./abis/ERC20.json
  - AaveToken: ./abis/AaveToken.json
  - AavePool: ./abis/AavePool.json
```

This manifest file defines different inputs that will be accessible from the function logic code thanks to the types generation process that will be explained in the next section.

It also declares the **path for the ERC20 and AaveToken ABIs required by the function logic**. Similar to the inputs list, the ABIs will be processed to generate the proper types to access them from the codebase.

For the purpose of this example you can set the **ERC20, AaveToken, and AavePool ABIs** into `./abis/ERC20.json` , `./abis/AaveToken.json` and `./abis/AavePool.json` (just create a new folder called abis) by adding these files:

[AaveToken.json](https://github.com/mimic-protocol/examples/blob/main/examples/05-invest-aave-idle-balance/abis/AaveToken.json) (redirects to GitHub)

[AavePool.json](https://github.com/mimic-protocol/examples/blob/main/examples/05-invest-aave-idle-balance/abis/AavePool.json) (redirects to GitHub)

[ERC20.json](https://github.com/mimic-protocol/examples/blob/main/examples/05-invest-aave-idle-balance/abis/ERC20.json) (redirects to GitHub)

<div className="kg-card kg-callout-card kg-callout-card-yellow">

You can adapt this to any auto-investing in Aave, just change the configurations you want.

</div>

### 3. Generate types

This steps allows you to validate the manifest definitions and generate the corresponding code to access both your declared inputs and the contract objects for your declared ABIs.

To do this you can run the `codegen` command using the CLI:

```
yarn mimic codegen
```

### 4. Write the function logic

The function logic is implemented in AssemblyScript and must export:

1.  **Input type**: The generated `inputs` type from the previous step.
2.  **Main function**: The core function logic, which receives the inputs as an argument.

Create a file `./src/function.ts` (or update the pre-existing one), and implement the logic:

```tsx
import { DenominationToken, ERC20Token, log, TokenAmount, USD } from '@mimicprotocol/lib-ts'

import { AavePool } from './types/AavePool'
import { AaveToken } from './types/AaveToken'
import { ERC20 } from './types/ERC20'
import { inputs } from './types'

export default function main(): void {
  // Create a typed ERC20 token instance for the provided aToken address
  // (e.g. aUSDC, aDAI)
  const aToken = ERC20Token.fromAddress(inputs.aToken, inputs.chainId)

  // Instantiate the on-chain Aave aToken contract wrapper
  const aTokenContract = new AaveToken(aToken.address, aToken.chainId)

  // Read the underlying asset address for this aToken
  // (e.g. USDC for aUSDC)
  const underlyingTokenAddressResult = aTokenContract.UNDERLYING_ASSET_ADDRESS()
  if (underlyingTokenAddressResult.isError) {
    throw new Error(underlyingTokenAddressResult.error)
  }
  const underlyingTokenAddress = underlyingTokenAddressResult.value

  // Create a typed ERC20 token instance for the underlying asset
  const underlyingToken = ERC20Token.fromAddress(underlyingTokenAddress, aToken.chainId)

  // Read the Aave Pool address associated with this aToken
  const aavePoolAddressResult = aTokenContract.POOL()
  if (aavePoolAddressResult.isError) {
    throw new Error(aavePoolAddressResult.error)
  }
  const aavePoolAddress = aavePoolAddressResult.value

  // Instantiate the Aave Pool contract wrapper
  const aavePool = new AavePool(aavePoolAddress, inputs.chainId)

  // Create a raw ERC20 contract wrapper for balance and approval calls
  const underlyingTokenContract = new ERC20(
    underlyingToken.address,
    underlyingToken.chainId
  )

  // Fetch the underlying token balance of the smart account
  const underlyingTokenBalanceAmountResult =
    underlyingTokenContract.balanceOf(inputs.smartAccount)

  if (underlyingTokenBalanceAmountResult.isError) {
    throw new Error(underlyingTokenBalanceAmountResult.error)
  }

  const underlyingTokenBalanceAmount = underlyingTokenBalanceAmountResult.value

  // Wrap the raw BigInt balance into a typed TokenAmount
  const underlyingTokenBalance = TokenAmount.fromBigInt(
    underlyingToken,
    underlyingTokenBalanceAmount
  )

  // Convert the token balance into USD using Mimic pricing oracles
  const underlyingTokenBalanceInUsdResult = underlyingTokenBalance.toUsd()
  if (underlyingTokenBalanceInUsdResult.isError) {
    throw new Error(underlyingTokenBalanceInUsdResult.error)
  }
  const underlyingTokenBalanceInUsd = underlyingTokenBalanceInUsdResult.value

  // Parse the user-provided USD threshold input
  const thresholdUsd = USD.fromStringDecimal(inputs.thresholdUsd)

  log.info(`Underlying balance in USD: ${underlyingTokenBalanceInUsd}`)

  // Guard clause:
  // If the USD value of the balance is below the threshold, stop execution
  if (underlyingTokenBalanceInUsd.lt(thresholdUsd)) {
    log.info('Threshold not met')
    return
  }

  // First transaction call:
  // Approve the Aave Pool to spend the full underlying token balance
  const calls = underlyingTokenContract.approve(
    aavePool.address,
    underlyingTokenBalanceAmount
  )

  // Second transaction call:
  // Supply the entire underlying token balance into Aave
  calls.addCallsFromBuilder(
    aavePool.supply(
      underlyingToken.address,        // asset to supply
      underlyingTokenBalance.amount,  // amount to supply
      inputs.smartAccount,             // supply on behalf of this account
      0                                // referral code (unused)
    )
  )

  // Pay transaction fees using Mimic credits, capped by maxFeeUsd
  const feeWithCredits = TokenAmount.fromStringDecimal(
    DenominationToken.USD(),
    inputs.maxFeeUsd
  )

  // Finalize and send the transaction bundle
  calls
    .addUser(inputs.smartAccount)
    .addMaxFee(feeWithCredits)
    .build()
    .send()
}
```

<div className="kg-card kg-callout-card kg-callout-card-yellow">

You can set up an auto-investing strategy on Aave with any ERC-20 (and Aave) tokens across all supported chains, including ****Arbitrum, Base, Base Sepolia, Ethereum Gnosis, Optimism, and Sonic****.  
  
Every function is fully customizable, so you can adapt it to your preferred configuration. For details, explore the [Mimic Protocol Library](https://docs.mimic.fi/developers/library).  
  
For now Mimic function allows creating three types of intents: transfers, generic calls, and crosschain swaps.

</div>

### 5. Compile

The compile process converts your function logic and manifest into deployable artifacts:

-   `build/function.wasm` - Compiled WebAssembly binary
-   `build/manifest.json` - Processed manifest configuration

Run the compile command:

```
yarn mimic compile
```

Here is an example of the output produced by this command:

```
build/
├── function.wasm     # Compiled WASM binary
├── manifest.json     # Validated manifest
```

### 6. Deploy your function

This is where you upload your function artifacts to the network so others can discover it. To do this you can run the `deploy` command using the CLI:

```
yarn mimic deploy --api-key [DEPLOYMENT_KEY]
```

You can **generate a deployment key from the explorer app**, where you can login using your wallet.

> Link to Mimic Protocol Explorer: [https://protocol.mimic.fi/](https://protocol.mimic.fi/)

<video src="https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/API-Key-Generation.mp4" autoPlay loop muted playsInline />

This command will deploy the generated artifacts from the `build` directory by default.

This command will upload your artifacts to the Mimic Registry (which stores them on IPFS) and pin the resultant CID so it can be discovered by others. The CID is also written to `CID.json` in the specified output directory.

### 7. Generate a Smart Account (If You Haven't)

You can use a Safe, or any smart account. Mimic also allows you to generate a smart account directly from your wallet on any network selected.

Just go to your profile and click on the "Smart Account" section. Approve on your wallet and your smart account will be generated, giving your wallet full control over it.

![](https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/Screenshot-2026-02-02-at-15.47.52.png)

<div className="kg-card kg-callout-card kg-callout-card-yellow">

This option generates something similar to a Gnosis Safe, but specific for Mimic. In this example, you can call the Aave contracts directly (for withdrawals), or just create another Mimic function for easier interaction.

</div>

### 8. Give allowance to the Mimic settler

**Before you configure your function in the dashboard, you must allow the Mimic Settler to spend tokens on behalf of your smart account.**

If you created a smart account through the Mimic dashboard, you are set. If you have a different type of smart account:

1.  Open your network’s block explorer and find your smart account contract.
2.  Connect your wallet.
3.  Set the Mimic Settler in "setSettler".
4.  Approve the contract so it can manage the tokens needed for your function.

Mimic Settler contract:

```
0x609d831c0068844e11ef85a273c7f356212fd6d1
```

![](https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/screely-1766147640210.png)

**9\. Configure your function**

After deploying your function, you can now add a trigger, to tell which trigger relayers should use to run your function. This means defining the parameters declared in your `manifest.yml` file. This is done in the [explorer UI](https://protocol.mimic.fi/) where you will be requested to sign your trigger with your wallet or with the SDK.

<video src="https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/Aavetaskconfig1-ezgif.com-speed.mp4" autoPlay loop muted playsInline />

1.  Open the explorer and locate the function you just deployed under the functions section.
2.  Add or edit your trigger parameters
3.  Sign the new trigger

![](https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/screely-1766148276632.png)

In this example

```tsx
10 // CHAINID (Optimism)
0x38d693ce1df5aadf7bc62595a37d667ad57922e5 // ATOKEN (for USDC on OP)
10 // THRESHOLDUSD Threshold to send deposit tokens on Aave (in this case if the USD value is above $10 the USDC.e will be deposited.
0 // Max fee in USD
```

Finally set the delta (time window to execute), the end date (optional), and sign with your wallet

This signature ensures relayers know the trigger is authorized by the function owner.

You can update or deprecate this trigger at any point in time to reflect changes, without needing to redeploy the function code again. Just sign the new trigger in the explorer, and relayers will pick up the latest version.

You will get a confirmation message: **Function created successfully!**

You can check the status of the function at the top of the page, and either deactivate function or execute again (if finished or inactive):

![](https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/Screenshot-2025-12-19-at-13.30.53.png)

Below, you can see a summary of the function (how many runs, completions, and errors), as well as the recent executions and all details about it (inputs, trigger, creation date…).

![](https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/screely-1766148370898.png)

If you press on any of the recent executions, you can get a full execution detail, with info such as inputs, outputs, general details, logs, and more.

You can run multiple functions at the same time, and you can make changes to the configuration by creating a new function, without needing to redeploy the function code again.

**10\. Withdraw Function**

In order to Withdraw from Aave, you can call their contracts directly, or easier just deploy a new Mimic function.

The steps would be the same as in this guide, just changing the .yaml file and the function code to the withdraw workflow.

You can find two functions already written for Aave withdraw in our GitHub examples:

1- Withdraw based on a balance threshold: [https://github.com/mimic-protocol/examples/tree/main/examples/06-withdraw-from-aave-balance-threshold](https://github.com/mimic-protocol/examples/tree/main/examples/06-withdraw-from-aave-balance-threshold)

2- Withdraw, swap, and transfer: [https://github.com/mimic-protocol/examples/tree/main/examples/07-withdraw-from-aave-swap-and-transfer](https://github.com/mimic-protocol/examples/tree/main/examples/07-withdraw-from-aave-swap-and-transfer)

### Notes & Variations

You will need:

-   **Smart account with funds** (for gas and token approvals)
-   **API key** from Mimic Explorer: [https://protocol.mimic.fi/api-key](https://protocol.mimic.fi/api-key)

<div className="kg-card kg-callout-card kg-callout-card-yellow">

Remember to give allowance to the settler for your smart account.  
  
You can go to your smart account contract on the explorer, connect your wallet, and add approval to the Mimic settler: 0x609d831c0068844e11ef85a273c7f356212fd6d1

</div>

![](https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/screely-1766147640210.png)

You can easily extend this function to:

-   Auto-invest **multiple tokens** (e.g., DAI, USDC, USDT).
-   Withdraw from Aave under certain conditions (e.g., portfolio balancing).
-   Combine with **yield strategy routing** for optimized performance.

* * *

👉 With this, you’ve got a production-ready **auto-invest strategy**: USD-aware, slippage-protected, fully automated, and easy to deploy via signed configs in the Mimic Explorer.

![](https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/mimic-protocol-guide-Aave.01--2-.png)

## Auto-Investing on Aave is Just the Start

With Mimic Protocol, auto-investing into Aave no longer requires maintaining bots, writing custom scripts, or giving up custody of your funds. You simply define your investment logic once as a function, sign it, and let Mimic relayers execute it automatically and directly from your wallet or treasury, whenever your thresholds are met.

But Mimic Protocol can be used for many other use cases around blockchain automation: wallet rebalancing, yield auto-compunding, DCA, fee management, and many more!

Stay tuned for future guides and details on what automation can unlock onchain. Mimic is the automation engine for Web3.

## Try Mimic Protocol Now!

**Available on Arbitrum, Base, Base Sepolia, Ethereum, Gnosis, Optimism, and Sonic.**

![](https://www.mimic.fi/blog/auto-investing-on-aave-with-mimic-protocol/Group-1547764730--2-.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let Mimic handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 💬 [Discord](https://discord.mimic.fi/) | 💻 [Telegram](https://t.me/+cBCtvvZuGpplNmY8)

🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# Why Mimic Protocol is Perfect for Web3 Hackathons

> Mimic Protocol gives your Web3 hackathon project functional automation, programmability, and abstraction that runs across chains, verifies conditions, and scales your idea instantly. 

Published: 2025-12-12 | Updated: 2025-12-12 | Author: Mimic Engineering Team | Tags: Events, Mimic Platform, Onchain Automation | Source: https://www.mimic.fi/blog/why-mimic-protocol-is-perfect-for-web3-hackathons

![](https://www.mimic.fi/blog/why-mimic-protocol-is-perfect-for-web3-hackathons/BLOG_Mimic-for-hackathon_X.png)

Anyone who’s been in a hackathon knows the pressure of a limited time, a small team, and an ambitious idea. You’ve got to go from concept to demo-ready product very fast, and the challenge isn’t just building something cool, it’s building something that actually works.

That’s where Mimic Protocol comes in. Mimic gives you a head start by taking care of the hardest parts of onchain execution, letting your hackathon project stand out with real, functional automation, programmability and abstraction that runs across chains, verifies conditions, and scales your idea instantly.

## What Mimic Protocol Gives You

Mimic abstracts away the most complex parts of blockchain development so that builders can focus on logic rather than low-level operations.

Instead of writing and deploying smart contracts, managing async execution, gas, RPCs, or cross-chain logic, developers just define what should happen, and Mimic takes care of the rest, securely onchain.

-   Interact with blockchains through TypeScript
-   Power your apps, agents or protocols with onchain logic
-   No need to manage infrastructure

👉 **In short:**

<div className="kg-card kg-callout-card kg-callout-card-blue">

Mimic turns blockchain complexity into simple, programmable flows.

</div>

## Unlock Use Cases That Other Teams Can’t Do in Time

Most hackathon projects run out of time before they reach real execution. With Mimic, your team can ship complex functionality in less time than other teams.

Here are some examples you can build fast:

-   **Auto-compounding vaults:** Create vaults that reinvest yield automatically using Mimic tasks.
-   **DAO treasury rebalancers:** Automate reallocation strategies, execute onchain swaps, or trigger rebalances based on real data.
-   **AI agent execution:** Connect an AI model to onchain actions. Let an agent decide, and Mimic execute with security.

Because Mimic handles execution, you can focus on logic and UX, not transaction wiring.

**Automation = scalability = winning hackathon edge.**

## Judges Love Real Functionality

Hackathon judges can spot the difference between a demo and a working product. Mimic lets your team prove your idea actually runs:

-   **Automation that actually executes:** Schedule tasks, trigger events, and have them verifiably completed.
-   **Execution proofs:** Every action is logged onchain or in Mimic’s history, so you can show it actually happened.
-   **Task history:** Demonstrate reliability and transparency (a real product backbone that most hackathon projects lack).

When the judges ask, “Does it actually work?”, you’ll have the receipts.

## Cross-Chain = Instant Differentiator

Hackathons love innovation. Mimic supports execution across multiple chains, meaning your project can go beyond a single ecosystem.

You can automate actions on Ethereum, Arbitrum, Base, and more, without rebuilding your logic for each. That’s a huge differentiator when every other team is stuck on one chain.

## Security Built In

Speed shouldn’t mean cutting corners on security. Mimic was built with secure execution in mind:

-   Tasks run through proven smart contracts.
-   Permissions and execution limits are enforced by design.
-   Your automations don’t require giving up full control of your keys.

That means you can innovate fast while staying within safe, auditable boundaries, something judges and users appreciate.

## Perfect for AI Agent Integrations

AI agents are taking over hackathons, but most are very limited in what they can do onchain. Mimic changes that.

Mimic acts as the execution layer for AI systems: your agent makes the decision, Mimic makes it happen. Whether it’s swapping tokens, claiming rewards, or rebalancing a portfolio, you can turn AI intent into verified blockchain action.

This combination, **AI + Mimic automation**, is a great edge during hackathons.

## Technical Support

Hackathons move fast, and having support matters. The Mimic team is active in different channels, ready to help you get your automation running, from writing your first task to deploying your project.

[Telegram](https://t.me/+cBCtvvZuGpplNmY8) | [Discord](https://discord.mimic.fi/)

You’ll find starter templates, docs, and examples designed specifically for hackathon builders.

## The Mimic Hackathon Starter Kit

Quickstart guide: [https://docs.mimic.fi/examples/build-a-simple-task](https://docs.mimic.fi/examples/build-a-simple-task)

GitHub examples: [https://github.com/mimic-protocol/examples/tree/main/examples](https://github.com/mimic-protocol/examples/tree/main/examples)

![](https://www.mimic.fi/blog/why-mimic-protocol-is-perfect-for-web3-hackathons/Group-1547764730--2-.svg)

<div className="kg-card kg-callout-card kg-callout-card-blue">

Supported Chains: Arbitrum, Base, Base Sepolia, Ethereum, Gnosis Chain, Optimism, and Sonic.

</div>

❓ **Any questions? Reach Support here:**

[Telegram](https://t.me/+cBCtvvZuGpplNmY8) | [Discord](https://discord.mimic.fi/)

![](https://www.mimic.fi/blog/why-mimic-protocol-is-perfect-for-web3-hackathons/BLOG_Mimic-for-hackathon_PB_01.png)

You can find other useful links below:

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# Devconnect Argentina 2025: The Recap

> Devconnect Argentina 2025 delivered! In case you missed it, or want to remember the best parts, we've got you covered. 

Published: 2025-12-03 | Updated: 2025-12-03 | Author: Mimic Engineering Team | Tags: Events | Source: https://www.mimic.fi/blog/devconnect-argentina-2025-the-recap

![](https://www.mimic.fi/blog/devconnect-argentina-2025-the-recap/Devcon-Recap--1-.png)

Devconnect 2025 delivered! In case you missed it, or want to remember the best parts, we've got you covered. Builders, panels, new social media superstars, and much more. Let's dive in!

## Iconic Cultural Moments at [@EFDevcon](https://x.com/@EFDevcon) 2025

Vitalik's outfit on the first day was a statement of what was coming.

![](https://www.mimic.fi/blog/devconnect-argentina-2025-the-recap/1000058291.jpg)

Thiru.eth became an international superstar, when he posted a welcoming tweet about being in Argentina, and was received with a lot of racism. Luckily, the whole crypto community came forward to spread positivity and welcome Thiru to the country. At the time of writing, the tweet has 29.4M views.

The announcement of Devcon 8 coming to India was unexpected, but welcomed by the community.

The Uniswap cup featured incredible football matches, Polymarket bets, and the perfect atmosphere before starting Devconnect.

## Notable Events at La Rural

ETHCon Argentina, [@EtherArgentina](https://x.com/@EtherArgentina) Hackathon, [@AgenticZero](https://x.com/@AgenticZero), Money Rails, and [@summit\_defi](https://x.com/@summit_defi) were praised for their quality.

![](https://www.mimic.fi/blog/devconnect-argentina-2025-the-recap/1000058258-1.jpg)

## Notable Side Events

The quality of side events was very high this year. Fewer than in other conferences, but very good. Some notable ones praised were DeFi Connect, Sky Connect, Bankless Summit, WalletCon, DeFi Day del Sur, Arbipanadas, and DuneCon.

## Devconnect for Mimic

Devconnect Argentina has been a very meaningful event for us. Mimic was born here, built by a team of Argentinian engineers who believed crypto infra could solve real-world problems.The main highlight for us was our booth at the DeFi District. We had a mini prediction game which featured 426 players, with rewards that made people queue to get, like our termo or our little octopus plushie.

![](https://www.mimic.fi/blog/devconnect-argentina-2025-the-recap/1000057866.jpg)

We hosted a couple of side events, focused at builders and developers, which featured incredible conversations. We learned a lot and are planning to implement all the insights to improve Mimic Protocol moving forward!

We also got highlighted by Josh Stark from the EF:

Lastly, we were fortunate to get invited to present Mimic and talk at some events and panels, even featuring a 5 minute pitch at ETH/ACC Demo Day!

![](https://www.mimic.fi/blog/devconnect-argentina-2025-the-recap/2025-11-26-14.11.18.jpg)

Devconnect 2025 reminded us why we build: the people, the energy, the culture, and above all the belief that Ethereum can power real change. We're inspired, grateful, and more committed than ever to keep building and give developers the tools they need to achieve more onchain.See you at the next one! 💜

### Try Mimic Protocol Now!

**Available on Arbitrum, Base Sepolia, Base, Ethereum, Gnosis, Optimism, and Sonic.**

![](https://www.mimic.fi/blog/devconnect-argentina-2025-the-recap/Group-1547764730--2-.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let Mimic handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 💬 [Discord](https://discord.mimic.fi/) | 💻 [Telegram](https://t.me/+cBCtvvZuGpplNmY8)

🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# The Complete Guide to Onchain Automation

> Automation is one of the main forces of modern technology. If Web3 is to reach the next billion users, it needs reliable, verifiable, and decentralized automation built into its core infrastructure.

Published: 2025-11-24 | Updated: 2025-11-24 | Author: Mimic Engineering Team | Tags: Onchain Automation | Source: https://www.mimic.fi/blog/the-complete-guide-to-onchain-automation

![](https://www.mimic.fi/blog/the-complete-guide-to-onchain-automation/complete-guide-to-autmation--3-.png)

## 1\. Introduction: Why Automation Matters in Web3

Automation is one of the main forces of modern technology. In Web2, it powers nearly every major industry, like finance, logistics, energy, agriculture, or software, enabling operations that are faster, safer, and more scalable. From algorithmic trading to smart irrigation systems, automation eliminates manual bottlenecks and allows systems to function autonomously, efficiently, and with little or no breaks.

In traditional finance, for instance:

-   60–75% of all U.S. equity market trading volume happens through algorithmic systems.
-   98% of CFOs surveyed by McKinsey are investing in finance automation.
-   The U.S. ACH network processed over $42 trillion in value in 2024.

These numbers show that automation isn’t just convenient, but essential for scaling.

### Web3 Needs Automation to Grow

Despite the progress of automation elsewhere, many operations in Web3 remain manual. Even a simple token transfer requires a series of complicated steps. It’s manageable once, but impossible to scale when repeated thousands of times across chains and protocols.

Developers today still rely on:

-   Custom scripts and bots that need constant maintenance.
-   Fragile cron jobs that can fail at any time.
-   Manual monitoring of price feeds, gas costs, or governance triggers.

This manual approach slows down innovation, increases operational risk, and makes automation a luxury rather than a default. If Web3 is to reach the next billion users, it needs reliable, verifiable, and decentralized automation built into its core infrastructure.

### Why Trustless Automation Matters

Manual effort doesn’t scale, but trustless automation does. Just as Web2 relies on CI/CD pipelines and scheduled tasks, Web3 needs systems that can safely and transparently execute actions on behalf of users and protocols. Automation in a decentralized environment must also be secure, transparent, and censorship-resistant, aligned with the ethos of blockchain.

Trustless automation removes the need to rely on centralized keepers or offchain scripts. Instead, tasks are executed through verifiable, onchain processes governed by logic and safeguards you define. This is the foundation of resilient, scalable, and autonomous infrastructure for decentralized systems.

You can dive deeper into the concept in our full post: [Why Trustless Automation Matters in Web3](https://www.mimic.fi/blog/why-trustless-automation-matters-in-web3)

### Mimic Protocol: Building the Automation Engine for Web3

Mimic Protocol was created to make this vision real. It enables developers and protocols to automate any onchain tasks or workflows, with full security, transparence, and without surrendering control. By combining deterministic planning, solver-based execution, and safeguard-enforced settlement, Mimic is redefining what “automation” means for blockchain.

Automation has always been the backbone of progress. In Web3, it’s how we scale from manual scripts to autonomous, self-operating systems that move crypto forward.

## 2\. The Evolution of Onchain Automation

When Ethereum launched in 2015, it introduced a revolutionary idea: smart contracts. Self-executing programs that could manage assets without intermediaries. But there was one major limitation. Smart contracts can’t _initiate_ actions on their own; someone or something has to trigger them with a transaction. That small detail created one of the biggest challenges in blockchain development: how to make onchain logic run automatically.

### From Scripts to Decentralized Networks

Early developers solved this problem the hard way, writing custom scripts or cron jobs to call smart contract functions on a schedule. These bots worked, but they were fragile, centralized, and lacked transparency. A single failure or misconfigured node could halt operations. This gap led to the birth of onchain automation, the pursuit of trustless, verifiable, and reliable frameworks for smart contract execution.

### Key Milestones in Onchain Automation

**Ethereum Alarm Clock (2015–2019)**

The first major attempt at blockchain automation. It let users schedule future transactions by depositing ETH, setting a time window, and defining a call function. Although pioneering, it faced usability and cost issues, and its “TimeNodes” lacked sustainable incentives.

**Keep3r Network (2020)**

Created by Yearn’s Andre Cronje, Keep3r introduced a decentralized job marketplace where developers could list tasks, and “keepers” would execute them for KP3R rewards. It decentralized DevOps for protocols like Yearn and Fixed Forex, laying the groundwork for incentive-aligned automation.

**Gelato Network (2020)**

Gelato made automation developer-friendly. It allowed builders to define time-based or conditional tasks—like executing swaps or adjusting vaults—handled by a decentralized network of bots. Used by Aavegotchi, Beefy, and others, Gelato made “automation-as-a-service” a reality.

**OpenZeppelin Defender (2020)**

Defender offered a professional automation stack for DAOs and protocols. Through Autotasks, Relayers, and Sentinels, teams could securely schedule and monitor smart contract actions. Trusted by Compound, Gnosis, and Optimism, it prioritized auditability and developer experience. (Note: Defender will sunset in 2026, as its components become open source.)

**Chainlink Automation (2021)**

Formerly Chainlink Keepers, this solution extended Chainlink’s oracle network into automated task execution. Developers wrote a `checkUpkeep()` function that Chainlink nodes monitored and executed when conditions were met. Used by Aave, Synthetix, and PoolTogether, it brought trusted decentralization to high-value operations.

### The Next Leap: Intent-Based Automation

The next generation, intent-based systems, let users define _what_ needs to happen, while solvers compete on _how_ to execute it most efficiently. This model unlocks programmability, efficiency, and crosschain capabilities.

Mimic Protocol (2024) represents this shift. Designed as the Automation Engine for Web3, it enables developers, wallets, DAOs, and AI agents to automate any onchain task using familiar programming logic. With Mimic, users can:

-   Define the logic and triggers (time-based, event-based, or custom).
-   Set execution conditions and safeguards.
-   Let the protocol coordinate solvers to execute optimally across chains.

### From Cron Jobs to Coordinated Systems

From Ethereum Alarm Clock to Chainlink Automation, each step moved Web3 closer to reliable, decentralized automation. But Mimic Protocol marks the transition from ad-hoc scripts to scalable, composable infrastructure.

Automation in Web3 has gone from _possible_ to _programmable_. The next sections will unpack how it actually works, what enables crosschain execution, and how safeguards keep it secure.

Further reading: [The Evolution of Blockchain Automation](https://x.com/mimicfi/status/1970892473871298681)

## 3\. How Onchain Automation Works

### Step-by-Step: How Onchain Automation Works

At a high level, onchain automation follows a simple pattern:

1.  Define what to automate: the logic or sequence of actions (e.g., swap tokens, stake, rebalance).
2.  Set the conditions: time, price, or event triggers that determine when the task should run.
3.  Execute the action: once the condition is met, a transaction is sent to the blockchain.
4.  Verify and settle: the outcome is validated and recorded onchain.

This flow ensures that every action is deterministic, auditable, and transparent.

### Onchain Automation ELI5: Explain It Like I’m Five

Event → Condition → Execution.

That’s the essence of onchain automation.

Something happens (an event), a rule is met (a condition), and the blockchain reacts (execution).

You can think of it like a programmable alarm clock for crypto.

Examples:

-   “If ETH > $3,000 → rebalance my vault.”
-   “Every Friday → send 10 USDC to my contributors.”
-   “If gas < 30 gwei → refill my treasury account.”

Instead of you clicking buttons, automation handles it trustlessly and continuously.

### The Main Ways to Automate Onchain

You can read a detailed explanation in our blog: [Scripts vs Keepers vs Mimic Protocol](https://www.mimic.fi/blog/scripts-vs-keepers-vs-mimic-protocol-for-web3-automation)

### 1. Automation Scripts

Definition: Simple programs (usually in Python or TypeScript) that execute blockchain transactions under certain conditions.

How they work: They live offchain. You write a script (e.g., “if price < X, execute swap”), run it manually or with a cron job, and it sends a transaction when triggered.

When to use: Small personal automations, testing, or one-off tasks.

Limitations: Must be hosted manually, prone to downtime, require key management, and lack transparency.

### 2. Keepers

Definition: Decentralized networks that monitor and trigger onchain actions. Examples: Chainlink Automation and Gelato Network.

How they work: Developers define a condition and an action; keeper nodes monitor the chain and execute when criteria are met.

When to use: For event- or time-based onchain tasks that need reliability and decentralization.

Limitations: Limited flexibility, higher cost per upkeep, and difficult multi-step or cross-protocol workflows.

### 3. Bots

Definition: Infrastructure providers or custom setups that host offchain “robots” executing your defined actions.

How they work: Similar to scripts, but managed on external infrastructure like cloud servers or third-party services.

When to use: When you want consistent uptime without fully relying on decentralized systems.

Limitations: Centralized, opaque, and reliant on trusted operators.

### 4. Mimic Protocol

Definition: A fully programmable automation and abstraction layer for Web3. Users can define any task or workflow, onchain and crosschain, without running servers or custom bots.

How it works: Mimic uses smart contract primitives called Tasks, which define logic, triggers, and permissions directly onchain. Solvers compete to execute tasks optimally, while validators ensure the result follows all user-defined safeguards.

When to use: For DeFi protocols, DAOs, and wallets needing transparent, composable, and secure automation.

Limitations: Newer tooling and onboarding curve, but rapidly expanding.

### Benefits of Onchain Automation

Automation offers clear advantages across ecosystems:

-   Efficiency Without Middlemen: Automate workflows directly onchain.
-   24/7 Uptime: No need for human oversight or manual approvals.
-   Trustless Execution: Code enforces actions exactly as defined.
-   Reduced Human Error: Deterministic logic minimizes mistakes.
-   Scalability: Handle complex, crosschain workflows without extra manpower.
-   Transparency & Auditability: Everything is recorded onchain.

As DeFi becomes more complex and multichain, automation becomes essential for growth and reliability.

## 4\. Crosschain Automation: Expanding Beyond One Network

Crosschain activity is at the heart of modern DeFi. Treasury operations, yield strategies, AI agents, and DAOs all interact with assets and protocols across chains. Without automation, teams must manually monitor balances, bridge funds, or execute transactions on each network.

This creates operational headaches:

-   Manual overhead: Multiple wallets, bridges, and gas setups.
-   Risk of inconsistency: Failing to execute on one chain can cause system-wide desyncs.
-   Lost opportunities: Timing mismatches between markets can erode yield or cause liquidation risk.

Crosschain automation solves these by providing coordinated, deterministic execution, so a task that starts on one chain can safely complete on another, all under defined conditions.

### How Crosschain Automation Works

At a high level, crosschain automation involves three key components:

1.  Task Definition

Developers define multi-step workflows that can involve multiple networks. For example:

-   Claim fees on Ethereum → Bridge funds to Arbitrum → Reinvest in a yield strategy.

2.  Message Passing & Verification

Once a task starts, automation protocols rely on secure message-passing standards (like Axelar GMP, LayerZero, or custom validators) to communicate between chains. Validators or relayers ensure that messages are valid, signed, and non-replayable.

3.  Settlement & Safeguards

The final step ensures that every action is executed or reverted deterministically. Safeguards—such as timeouts, nonces, or fallback conditions—guarantee that if something fails on one chain, the system doesn’t leave funds stranded or create inconsistent states.

## 5\. Security in Onchain Automation

Security is essential on any automation solution in Web3. When tasks execute autonomously and handle real assets, even small errors or vulnerabilities can lead to major consequences. Onchain automation introduces new trust models, mainly replacing human oversight with verifiable logic, so ensuring that every action follows predefined, immutable rules becomes essential.

A secure automation framework must answer three questions:

1.  Who can trigger execution? (permissions and access control)
2.  What logic can be executed? (validated and deterministic)
3.  How are results verified? (proofs, safeguards, and challenge mechanisms)

Traditional automation frameworks often rely on trusted operators, which introduces points of failure or censorship risk. In contrast, protocol-level automation systems use verifiable computation, consensus validation, and cryptographic proofs to ensure that actions are executed exactly as defined.

### How Mimic Protocol Approaches Security in Web3 Automation

Mimic Protocol was built with security at its core. Its architecture integrates a dedicated Security Layer that enforces strict safeguards at the protocol level. Every automated task, regardless of its complexity or chain, is validated through:

-   Safeguards: User-defined parameters that restrict what a task can and cannot do (e.g., spending limits, slippage caps, deadlines, or approved counterparties).
-   Validator Verification: Independent validators confirm that solver-submitted results match expected logic and inputs before settlement.
-   Deterministic Enforcement: The system executes only when all predefined conditions are met, ensuring predictable and transparent outcomes.
-   Immutable Audit Trail: Every action, validation, and safeguard check is recorded onchain, providing full transparency and post-event traceability.

Mimic’s Security Layer ensures that automation is not only efficient but also trustless by design, protecting users, DAOs, and protocols from missexecution, manipulation, or unforeseen behaviors.

You can read more about our approach in our [documentation](https://docs.mimic.fi/developers/architecture#id-3.-security-layer).

![](https://www.mimic.fi/blog/the-complete-guide-to-onchain-automation/complete-guide-to-autmation-2.png)

## 6\. Real-World Use Cases

From DAOs and DeFi protocols to wallets and AI agents, automation can drastically improve operations, app development, and user experience. In an industry that runs 24/7, onchain automation eliminates repetitive manual work, optimizes performance, and can enable entirely new business models.

### How Automation Improves Web3

**1\. Streamlined Operations**

Web3 teams often spend valuable time managing repetitive tasks, like moving funds, claiming rewards, or triggering contract calls. Automation replaces manual monitoring and execution with predefined rules that run reliably onchain. This frees teams to focus on strategy, not maintenance.

**2\. Smarter App Development**

Developers can integrate automation into their dApps to handle actions like periodic updates, price-triggered swaps, or rebalancing strategies. Instead of maintaining private bots or backend servers, they can define tasks directly onchain, reducing infrastructure risk and increasing transparency.

**3\. Better User Experience**

For users, automation removes friction. Instead of constantly approving transactions or managing wallets, users can set logic once and let the protocol handle the rest, whether it’s staking rewards, scheduled payments, or portfolio management. This is key to onboarding the next billion users to Web3.

### Real Use Cases of Onchain Automation With Mimic Protocol

**AI Agents**

Mimic enables AI to act onchain safely. AI systems can autonomously execute defined strategies, like rebalancing or liquidity management, without full wallet access. Mimic enforces user-defined safeguards to ensure security and compliance with predefined limits.

**Treasury & Asset Management**

Automate treasury operations across multiple chains: rebalancing portfolios, reallocating assets, or distributing funds. Mimic executes these actions deterministically, providing transparency and efficiency without centralized oversight.

**Automated Vaults**

Protocols can create vaults that execute multi-step DeFi strategies (invest, swap, bridge, stake…) automatically. Users or DAOs define their logic once, and Mimic ensures consistent, rule-based execution under the conditions they set.

**Internal Operations**

Developers can offload backend workflows, like task validation, transaction routing, or risk control, to Mimic’s deterministic automation layer. This reduces operational risk while ensuring reproducible, auditable processes.

**Fee Collection & Distribution**

Protocols can use Mimic to automate fee aggregation, conversion, and distribution. Fees collected on one chain can be bridged, converted, and allocated across networks with full auditability.

**Account Top-Ups & Rebalancing**

Mimic allows automatic monitoring and topping up of operational wallets or keeper accounts when balances fall below thresholds, critical for uptime and continuity in DAO or treasury operations.

**Airdrops & Rewards**

Launch controlled, gas-optimized airdrops triggered by preset events, such as onchain activity or snapshot data. Mimic ensures repeatability and accuracy in every distribution.

**Recurring Payments**

DAOs and organizations can automate payrolls, grants, or subscription payments using Mimic’s scheduler. Funds are moved, bridged, and distributed under strict logic—no human approvals, no missed deadlines.

### From Web2 Ideas to Web3 Execution

In Web2, automation is everywhere: CI/CD pipelines, CRM integrations, payroll systems, and FX conversions. These tools run the global digital economy. Web3 is catching up fast, but it needs automation that’s trustless, decentralized, and composable.

Mimic Protocol delivers that. By embedding automation directly onchain, it enables developers, DAOs, and AI agents to operate without limits, scaling securely across chains, protocols, and user bases.

Automation is how Web3 starts to scale fast, and becoming autonomous infrastructure.

## 7\. The Future of Onchain Automation

What started as a way to schedule transactions with cron jobs is evolving into a fundamental layer of blockchain infrastructure, driving scalability, interoperability, and autonomy across the ecosystem.

### Onchain Automation Will Power the Next Wave of Web3 Apps

Building reliable onchain applications still feels far from the Web2 experience. When blockchains first emerged, they promised trustless execution without intermediaries, a vision that expanded into entire ecosystems of DeFi, gaming, and decentralized governance. Yet, despite all this progress, developers still spend countless hours maintaining scripts, approving transactions, and patching operational workflows just to keep systems running.

It’s a paradox: blockchains are designed for autonomy, but the workflows around them remain manual, brittle, and dependent on offchain operators. That’s about to change. The future of Web3 will be defined not just by execution layers (L1s, L2s), data layers (oracles, indexers), or wallets, but by the missing piece: the automation layer. And the builders who embrace it will define the next generation of decentralized applications.

### From Manual Workflows to Autonomous Systems

Every Web3 team knows the struggle: transactions pile up, multisigs need constant approvals, treasuries must be rebalanced, and rewards distributed. Most of this is done manually today, often by a few team members or fragile scripts that can fail at any moment.

This approach is inefficient, error-prone, and expensive. Centralized bots introduce trust assumptions that undermine decentralization, while manual oversight slows everything down. Automation changes that, as it shifts repetitive execution into a trustless, onchain layer, where actions follow deterministic logic under full transparency.

With automation, apps evolve from static tools into self-operating systems that are secure, predictable, and scalable. Teams regain time to innovate. Protocols operate with precision. Users experience Web3 apps that simply _work_, without human babysitting.

### Automation as a First-Class Primitive for Developers

Developers are the first-class citizens of the onchain economy. But right now, every team has to reinvent automation from scratch, with custom scripts, bots, or keepers, all solving the same problem differently.

Imagine if every dApp had to build its own wallet just to onboard users. The ecosystem would have never scaled. Wallets created a shared abstraction for user interaction; automation must do the same for execution.

For developers, automation means:

-   Shorter build cycles: Focus on logic, not infrastructure.
-   Simplified maintenance: Onchain workflows run deterministically.
-   Predictable performance: Apps behave as intended, 24/7.

Automation will soon become a native primitive of the developer stack, just like smart contracts or APIs, turning intent into guaranteed onchain action.

### Moving Beyond Scripts: The Power of AI and Blockchain

Automation isn’t new to crypto, as bots, liquidators, and arbitrage systems have existed for years. What’s emerging now is something more powerful: AI-native automation.

AI agents can already analyze markets, detect opportunities, and make real-time decisions. But they still need a secure, verifiable way to _act_ onchain. This is where automation layers like Mimic Protocol come in.

Instead of building fragile bridges between AI models and smart contracts, developers can use Mimic as the execution engine for intelligent agents. The AI determines _what_ to do, and Mimic ensures it happens safely, transparently, and onchain.

Imagine a future where:

-   Autonomous trading agents rebalance liquidity positions across multiple protocols in real time.
-   Governance agents submit and execute proposals aligned with community mandates.
-   IoT devices manage payments and subscriptions without human intervention.

In every case, automation acts as the connective tissue between intelligence and execution, the layer that turns decision-making into deterministic action.

### The Missing Link in Web3 Development

Today’s Web3 stack has three pillars:

-   **Execution layers:** L1s and L2s that process transactions.
-   **Data layers:** oracles and indexers that provide context.
-   **Wallets:** interfaces that connect users to the network.

What’s missing is the automation layer, the mechanism that takes intent and transforms it into reliable onchain execution. Without it, developers are left patching together incomplete solutions. With it, entire new categories of applications become possible.

Imagine a DAO treasury that automatically rebalances itself, a lending market that dynamically adjusts rewards to maintain liquidity, or an NFT marketplace that distributes royalties instantly. These aren’t distant ideas, they’re applications waiting for a standardized automation layer to make them real.

### Mimic’s Place in the Future of Onchain Automation

At Mimic, we’ve lived this challenge firsthand. What began as tooling for operational workflows evolved into a mission: to build the Automation Engine for Web3. Our goal is to make automation a protocol, not a service: open, permissionless, and available to all builders.

Mimic’s architecture provides the foundation for autonomous, crosschain, and AI-integrated systems. Developers and protocols can focus on defining logic while Mimic handles the rest: verifiable execution, safeguards, and settlement.

Just as smart contracts made money programmable, Mimic makes workflows programmable. Once automation becomes a shared layer of Web3 infrastructure, the way we build and interact with decentralized applications will fundamentally change.

### The Builders Will Define What Comes Next

The future of Web3 won’t be defined solely by faster chains or better wallets, but by autonomous, self-operating applications capable of running without constant human input.

For developers, this is both a challenge and an opportunity. By embracing onchain automation, they can create apps that scale with the digital economy, reliable, reactive, and always on.

At Mimic, we believe the next wave of Web3 applications will come from builders who understand this shift early. Automation isn’t just about saving time, it’s about unlocking entirely new possibilities. And that future is closer than it seems.

## 8\. Glossary & Resources

### Key Terms

**Automation Layer**

The missing layer in the Web3 stack that connects user or app-defined intent with reliable, trustless onchain execution. It enables smart contracts and protocols to operate autonomously without manual triggers.

**Task**

A defined set of actions and conditions to be automated onchain. In Mimic, tasks can include sequences like swap → stake → bridge → distribute.

**Intent**

A structured instruction that describes _what_ should happen onchain. Solvers compete to fulfill these intents efficiently while respecting safeguards.

**Solver**

An independent actor that proposes and executes a task or intent. Solvers compete based on cost, efficiency, and reliability.

**Relayer**

A participant that transmits transactions or messages between chains or layers, ensuring tasks are executed correctly.

**Validator**

An entity responsible for verifying solver results and confirming that execution conditions were met before final settlement.

**Safeguards**

Rules defined by users to protect their automation logic, such as spending caps, slippage limits, whitelists, or execution deadlines.

**Security Layer**

A core component of Mimic’s architecture that enforces safeguards, verifies solver performance, and records all automation activity transparently onchain.

**Planning Layer**

Where automation begins. It defines the task’s inputs, triggers, logic, and dependencies before execution.

**Execution Layer**

Coordinates solver competition and task fulfillment, ensuring that operations are performed optimally and efficiently.

### Further Reading & Related Posts

**Mimic Blogs & Articles**

-   [What is Onchain Automation?](https://www.mimic.fi/blog/what-is-onchain-automation)
-   [Why Trustless Automation Matters in Web3](https://www.mimic.fi/blog/why-trustless-automation-matters-in-web3)
-   [How Onchain Automation Works](https://www.mimic.fi/blog/can-web2-automation-work-in-web3) (with Examples)
-   [History of Onchain Automation](https://x.com/mimicfi/status/1970892473871298681)
-   [Challenges of Manual Transactions in Crypto](https://www.mimic.fi/blog/challenges-of-manual-transactions-in-crypto)

**Documentation & Whitepaper**

-   Mimic Protocol Whitepaper (pdf): [https://www.mimic.fi/documents/Mimic\_Protocol\_Whitepaper.pdf](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf)
-   Developer Docs: [https://docs.mimic.fi/](https://docs.mimic.fi/)

**Community & Ecosystem**

-   [Twitter](https://x.com/mimicfi)
-   [GitHub](https://github.com/mimic-protocol)
-   [Discord](https://discord.mimic.fi/)
-   [Telegram](https://discord.mimic.fi/)

![](https://www.mimic.fi/blog/the-complete-guide-to-onchain-automation/complete-guide-to-autmation-3.png)

---

# Meet Mimic at Devconnect Buenos Aires 2025!

> This November, Devconnect finally comes to Argentina, and the Mimic team will be there all week: events, panels, hackathons, meetups, and more. Vamos!

Published: 2025-11-13 | Updated: 2025-11-24 | Author: Mimic Engineering Team | Tags: Events | Source: https://www.mimic.fi/blog/meet-mimic-at-devconnect-buenos-aires-2025

![](https://www.mimic.fi/blog/meet-mimic-at-devconnect-buenos-aires-2025/meet-mimic-at-devcon.png)

Buenos Aires has always been a city of builders, full of resilient, creative, and curious people. This November, Devconnect finally comes to Argentina after years of anticipation, and we couldn’t be more proud to welcome it home.

The Mimic team will be there all week: events, panels, hackathons, meetups, and more.

From powering top protocols and companies to opening our stack so anyone can scale development onchain, we’re here to share what we’ve built, learn from the community that shaped us, and show how simplifying blockchain interactions can help scale crypto to billions.

## What Mimic is Building

The more we build onchain, the more complex it gets. Every interaction, transaction, script, or contract call adds friction to the development process, so builders end up using temporary or insecure solutions to make things work. In essence, Mimic Protocol was born to remove that friction.

We're building a programmable layer that abstracts away the most complex parts of blockchain interactions so that you can focus on logic, not time-consuming operations. With Mimic, any team can define what needs to happen onchain, set the conditions, and let the protocol handle execution without writing any smart contract. Instead of building custom scripts or relying on third-party services, builders can access infrastructure to create onchain tasks or workflows, enabling them to scale development across chains. It's the same power we've been building for leading teams like Trust Wallet, Trezor, Ledger, WalletConnect, or Velora, but now open to everyone. Mimic turns blockchain complexity into simple, programmable flows, intending to make onchain development scale as easily as software development does today.

## Mimic Agenda at Devconnect

### All Week (Nov 17-22) - Mimic Booth at La Rural (Ethereum World Fair)

Visit the Mimic booth at the Ethereum World Fair (La Rural) throughout Devconnect week. There will be a cool prediction game, merchandise, prizes, and a POAP quest to complete. Come to say hi, we will be at the DeFi District, booth number x.

📍 La Rural | ⏰ 9 AM – 5 PM

### Nov 18 (10 AM) - Builders Brunch × Dev3Pack

A relaxed morning meetup for developers, founders, and Web3 creatives.

Hosted by Mimic and Dev3Pack, the Builders Brunch is a space to connect, exchange ideas, and start the week with the local builder community at the Dev3Pack Village.

📍 Dev3Pack Village | ⏰ 10 AM – 1 PM

### Nov 18 (10:30 AM) - ETHCon Panel

Facu Spagunolo, Mimic CTO will join a panel - Por qué Ethereum

### Nov 19-20 - Ethereum Argentina Hackathon

We’re proud sponsors of Tierra de Builders, the in-person hackathon hosted at La Rural as part of Devconnect.

This is Argentina’s largest gathering of Web3 developers, bringing together teams to create, collaborate, and launch new ideas in areas like DeFi + AI agents, or MiniApps & UX.

Mimic will provide access to our SDK and protocol so participants can create their own onchain logic, design crosschain workflows, and test new ideas directly on our infrastructure.

📍 La Rural | ⏰ 9 AM – 6 PM

### Nov 19 - Friends & Family Event

A private gathering for close collaborators and long-time supporters of Mimic: friends, partners, and community members who have been part of the project since the early days. IYKYK

### Nov 20 - Builder Meetup With Developer DAO

Together with Developer DAO, we’re hosting DevNVibe, an evening meetup designed for developers, founders, and product builders to connect before ETHGlobal Buenos Aires. It’s a relaxed environment for exchanging ideas, meeting new collaborators, and learning about emerging tooling in onchain development.

📍 Aleph Hub @ Crecimiento | ⏰ 5 – 8 PM

### Nov 20 - Agentic Zero Panel (2:50 PM)

Our Head of GTM - Lukasz - will join Uniswap, Virtuals and ZyFAI for a panel on “DeFi as an Agent Playground.” We’ll discuss how AI agents and automated systems are shaping the next frontier of DeFi, and how Mimic Protocol enables agents to execute secure, crosschain interactions and transactions autonomously.

### Nov 21 - DeFi Security Summit Talk

Mimic CTO Facundo Spagnuolo will deliver a talk titled “Beyond the Cron Job: Eliminating Single Points of Failure with Automation.” He’ll explore how decentralized task execution and protocol-level safeguards can replace fragile, centralized automation setups with trustless, verifiable infrastructure.

📍 La Rural | ⏰ 11:20 AM

## Why Devconnect Matters to us

For us, Devconnect Argentina is not just another conference. Mimic was born here, built by a team of Argentine engineers who believed that crypto infra could help solve some of the problems of the country.

This week, we don't want to only show what we're building, we want to celebrate the whole crypto community and ecosystem that made it possible.

Argentina’s builder culture has always thrived under constraints: creative, self-taught, resilient. It’s that same spirit that drives our mission to simplify onchain development and help Web3 scale without limits.

By abstracting blockchain complexity into programmable, reusable components, Mimic enables builders to move faster, whether they’re running protocols, managing treasuries, deploying AI agents, or experimenting with new financial primitives.

We want to make building onchain feel as natural as building on the web. And there’s no better place to show what that looks like than right here, where it all started.

> See you in Buenos Aires, and see you onchain!

![](https://www.mimic.fi/blog/meet-mimic-at-devconnect-buenos-aires-2025/meet-mimic-at-devcon--2-.png)

---

# Scripts vs Keepers vs Mimic Protocol for Web3 Automation

> Developers rely on different tools to trigger smart contracts at certain intervals or times. In this article, we’ll break down the differences between Scripts, Keepers, and Mimic Protocol, using a simple, consistent framework for comparison.

Published: 2025-10-23 | Updated: 2026-02-02 | Author: Mimic Engineering Team | Tags: Mimic Platform, Onchain Automation | Source: https://www.mimic.fi/blog/scripts-vs-keepers-vs-mimic-protocol-for-web3-automation

![](https://www.mimic.fi/blog/scripts-vs-keepers-vs-mimic-protocol-for-web3-automation/blog-vs.png)

Automation is very important in Web3 for applications, protocols, and blockchain interactions. When building in DeFi, there are many different components that need to be scheduled or triggered at different times, or react to certain events.

Smart contracts are self-executing, but they need to be triggered with a transaction, meaning automation is not native on most blockchain networks. Developers rely on scripts, keepers, bots, and other types of automation protocols like Mimic.

But what's the real difference between these solutions? How do they work, when should you use each, and why should developers move towards protocol-level automation?

In this article, we’ll break down the distinctions between Scripts, Keepers, Bots, and Mimic Protocol, using a simple, consistent framework for comparison.

## Automation Scripts

### Definition: What Are Automation Scripts?

Scripts are the simplest form of automation: short programs that execute a set of predefined instructions. In Web3 or DeFi, a script can:

-   Swap tokens at specific intervals
-   Claim staking rewards
-   Move funds between wallets

Developers often write scripts in Python, JavaScript/TS, or Solidity, using libraries like web3.js or ether.js to interact directly with smart contracts.

### Execution: How Automation Scripts Work

Scripts run offchain, meaning they live outside the blockchain. You usually:

1.  Write a script that defines what to do (e.g., “if price < X, execute swap”).
2.  Run it manually, or schedule it via a cron job or cloud function.
3.  The script sends a transaction to the blockchain when triggered.

### Use Cases: When to Use Automation Scripts

-   Quick one-time automations
-   Simple repetitive actions
-   Personal use or testing
-   Projects with limited onchain dependencies

### Drawbacks: Limitations of Automation Scripts

-   **Manual setup:** You must host and run the script yourself.
-   **Reliability:** If your server is offline, automation stops.
-   **Security:** Requires private key management offchain.
-   **No visibility:** Other users can’t easily see or reuse your logic.

<div className="kg-card kg-callout-card kg-callout-card-yellow">

****In summary,**** Scripts are ideal for small-scale or personal automation but lack scalability and transparency for DeFi production environments.

</div>

## Keepers

### Definition: What Are Keepers?

Keepers are decentralized networks designed to automatically trigger smart contract functions. Popular examples include Chainlink Automation (formerly known as Chainlink Keepers) and Gelato Network.

They act as the “cron jobs” of blockchain. Always watching, ready to execute predefined actions when conditions are met.

### Execution: How Keepers Work

Keepers monitor smart contracts on-chain. Developers define:

-   A trigger condition (e.g., when collateral ratio < threshold)
-   An action to perform (e.g., liquidate a position)

When conditions are met, the keeper network calls the contract function. This process is permissioned, verifiable, and decentralized, meaning no single entity controls execution.

### Use Cases: When to Use Keepers

-   Time-based or condition-based onchain functions
-   Protocols needing automated execution without user input
-   Situations where transparency and reliability are important

### Drawbacks: Limitations of Keepers

-   **Limited flexibility:** Hard to handle multi-step workflows.
-   **Protocol dependency:** Each network has its own integration rules.
-   **Execution cost:** You pay for each trigger and upkeep transaction.
-   **Less composability:** Hard to chain complex logic across multiple contracts.

<div className="kg-card kg-callout-card kg-callout-card-yellow">

****In summary:**** Keepers are reliable for scheduled or event-based execution but can be rigid for complex or multi-protocol automation needs.

</div>

## Mimic Protocol

### Definition: What Is Mimic Protocol?

Mimic Protocol is an automation and abstraction layer to create programmable functions onchain. Users can set the conditions for any operations, and let the protocol take care of the execution.

Users can define the logic of their function using TypeScript, so no Solidity or smart contract knowledge is required to interact with blockchain. Instead of running off-chain bots or subscribing to keeper networks, users can define functions directly through familiar code, describing what to execute, how to execute it, and who can trigger it.

Mimic turns automation into programmable, shareable, and verifiable infrastructure.

### Execution: How Mimic Protocol Works

Mimic uses onchain primitives to represent automation:

-   **Function:** Define sequences of actions (swap → stake → claim).
-   **Executors:** Authorized entities that can trigger these functions.
-   **Permissions:** Define who can modify or execute workflows.

All state and configuration live onchain, meaning:

-   No servers or bots to maintain
-   Transparent, verifiable execution
-   Fully composable with DeFi protocols

### Use Cases: When to Use Mimic Protocol

Mimic is ideal for:

-   **Protocol or DAO automation** (e.g., treasury operations)
-   **Yield strategies** that require periodic or conditional actions
-   **Composable workflows** that interact across multiple protocols
-   **Shared, onchain automation infrastructure**

### Drawbacks: Limitations of Mimic Protocol

-   **Still evolving:** As with any new protocol, developer tooling is growing.
-   **Gas costs:** Onchain configuration adds minor overhead.
-   **Learning curve:** Understanding Mimic’s functions structure takes some onboarding.

<div className="kg-card kg-callout-card kg-callout-card-yellow">

****In summary:**** Mimic replaces off-chain bots and keepers with onchain, composable automation. It’s a next-generation approach for teams that want transparent, modular, and programmable DeFi workflows.

</div>

## Conclusion

The evolution from **scripts → keepers → Mimic Protocol** mirrors the broader trend in Web3: moving automation from off-chain, isolated code toward on-chain, interoperable systems.

-   **Scripts**: Great for quick or personal automations.
-   **Keepers**: Reliable for protocol-level triggers.
-   **Mimic**: The future. Composable, trustless, and onchain automation.

As automation becomes a shared public good in DeFi, Mimic offers a framework where logic lives onchain, not in someone’s server. That shift unlocks transparency, composability, and trust, key ingredients for the next era of autonomous finance.

---

# Rebalance a Wallet Portfolio With Mimic Protocol (3 Assets)

> Automate portfolio rebalancing inside your EVM wallet using Mimic Protocol. This guide shows how to build a task that rebalances three ERC-20 tokens to target USD weights.

Published: 2025-10-09 | Updated: 2026-02-02 | Author: Mimic Engineering Team | Tags: Mimic Guides | Source: https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens

![](https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/mimic-protocol-guide-rebalancing.png)

## TL;DR

Automate portfolio rebalancing inside your EVM wallet using Mimic Protocol. This guide shows how to build a function that **rebalances three ERC-20 tokens to target USD weights** (in basis points), applies **slippage protection**, and deploys to the Mimic Protocol.

## Quick Details

-   **Function type:** portfolio rebalancing (3 tokens, USD targets)
-   **Strategy:** move value from **surplus → deficit** tokens until targets are met
-   **Key inputs:** tokenA/B/C, targetBpsA/B/C (sum to 10,000), slippageBps, chainId

<div className="kg-card kg-callout-card kg-callout-card-yellow">

This is just an example, Mimic Protocol allows for any type of logic to create a wallet rebalancing strategy.

</div>

## What You Need to Get Started

-   [Node.js](https://nodejs.org/en) + [Yarn](https://www.geeksforgeeks.org/installation-guide/how-to-install-yarn-in-macos-ubuntu-windows) installed
-   **Wallet with funds**

![](https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/banner04--4-.png)

## Understand the Rebalancing Flow

We want to maintain fixed **USD weights** across three tokens (for example, **50% / 30% / 20%**). Each time the strategy runs, it follows this process:

1.  **Check balances:** Read your wallet balances for tokens A, B, and C.
2.  **Convert to USD:** Use on-chain pricing to calculate the USD value of each token balance.
3.  **Set targets:** Based on your chosen allocation (e.g., 50/30/20), compute the target USD value for each token.
4.  **Find imbalances:** Compare current vs. target balances
5.  **Rebalance iteratively:** Start swapping:

-   Always swap from the largest surplus token into the largest deficit token.

6.  **Finish when balanced:** Continue swapping until either surpluses or deficits are resolved. At this point, allocations should match the targets (to integer precision).

## Define the Function

### 1\. Initialize project

Start a new working directory to develop your function:

```jsx
npx @mimicprotocol/cli init ./my-mimic-function
```

### 2\. Update your `manifest.yaml`

The manifest file provides the configuration for your function, including:

-   **Metadata**: Name, description, and version of the function.
-   **Inputs**: Parameters required by the function logic.
-   **ABIs**: Smart contract ABIs to generate type-safe interfaces for the function.

Save this configuration in the `manifest.yaml` file:

```yaml
version: 1.0.0
name: Rebalance to USD target ratios (3 tokens)
description: Automated function that rebalances a 3-token portfolio to target basis-point weights using USD valuations and slippage-protected swaps
inputs:
  - chainId: uint32
  - tokenA: address
  - tokenB: address
  - tokenC: address
  - targetBpsA: uint16      # e.g., 5000 = 50%
  - targetBpsB: uint16      # must sum with A & C to 10000
  - targetBpsC: uint16
  - slippageBps: uint16     # e.g., 50 = 0.50%
abis:
  - ERC20: ./abis/ERC20.json
```

This manifest file defines different inputs that will be accessible from the function logic code thanks to the types generation process that will be explained in the next section.

It also declares the **path for the ERC20 ABI required by the function logic**. Similar to the inputs list, the ABIs will be processed to generate the proper types to access them from the codebase.

For the purpose of this example you can set the **ERC20 ABI** into `./abis/ERC20.json` (just create a new folder called abis) by using this file:

[ERC20.json](https://216358192-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2K6E4Us9xYRIC0Tt0SIZ%2Fuploads%2FLzvR464ArklTLEA67qfw%2FERC20.json?alt=media&token=163296d8-8fd0-4376-a649-4c7c07f8b321)

<div className="kg-card kg-callout-card kg-callout-card-yellow">

You can adapt this to any rebalancing you want to create, just change the values for your desired tokens.

</div>

### 3. Generate types

This steps allows you to validate the manifest definitions and generate the corresponding code to access both your declared inputs.

To do this you can run the `codegen` command using the CLI:

```
mimic codegen
```

### 4. Write the function logic

The function logic is implemented in AssemblyScript and must export:

1.  **Input type**: The generated `inputs` type from the previous step.
2.  **Main function**: The core function logic, which receives the inputs as an argument.

Create a file `./src/function.ts` (or update the pre-existing one), and implement the logic:

```tsx
import { Address, BigInt, environment, ERC20Token, log, Swap, TokenAmount, USD } from '@mimicprotocol/lib-ts'

import { ERC20 } from './types/ERC20'
import { inputs } from './types'

// Basis points denominator (100% = 10,000 bps)
const BPS_DENOMINATOR = BigInt.fromI32(10_000)

// Return the minimum of two USD amounts
function usdMin(left: USD, right: USD): USD {
  return left.lt(right) ? left : right
}

// Compute a USD share given a bps ratio
function shareByBps(amountUSD: USD, bps: i32): USD {
  const numerator = amountUSD.times(BigInt.fromI32(bps))
  return numerator.div(BPS_DENOMINATOR)
}

// Read user's onchain ERC20 balance and wrap it as TokenAmount
function getTokenAmount(chainId: u32, tokenAddress: Address): TokenAmount {
  const me = environment.getContext().user
  const contract = new ERC20(tokenAddress, chainId)
  const balance = contract.balanceOf(me)
  const token = ERC20Token.fromAddress(tokenAddress, chainId)
  return TokenAmount.fromBigInt(token, balance)
}

// Helper structure to track surplus/deficit buckets in USD for each token index
class Bucket {
  constructor(
    public index: i32,
    public amountUSD: USD
  ) {}
}

export default function main(): void {
  // Read inputs: three tokens and their target portfolio weights in bps
  // Each target is expressed in basis points where 10,000 = 100%.
  // Example: [5000, 3000, 2000] => 50%, 30%, 20%.
  const tokenAddresses = [inputs.tokenA, inputs.tokenB, inputs.tokenC]
  const targetBps = [inputs.targetBpsA as i32, inputs.targetBpsB as i32, inputs.targetBpsC as i32]

  // Validate that targets add up to 100% to ensure a closed allocation that
  // fully assigns the current portfolio value across the three tokens.
  const totalTargetBps = targetBps[0] + targetBps[1] + targetBps[2]
  if (totalTargetBps != 10_000) throw new Error('Targets BPS must sum to 10000')

  // Initialize tokens for pricing/conversions
  // We use token data to convert between on-chain units and USD, so
  // we can compare heterogeneous assets on a common value scale.
  const tokensMetadata = [
    ERC20Token.fromAddress(tokenAddresses[0], inputs.chainId),
    ERC20Token.fromAddress(tokenAddresses[1], inputs.chainId),
    ERC20Token.fromAddress(tokenAddresses[2], inputs.chainId),
  ]

  // Fetch current user balances as TokenAmount
  // Balances are read on-chain for the function's caller (context user).
  const tokenAmounts = [
    getTokenAmount(inputs.chainId, tokenAddresses[0]),
    getTokenAmount(inputs.chainId, tokenAddresses[1]),
    getTokenAmount(inputs.chainId, tokenAddresses[2]),
  ]

  // Value current balances in USD and compute portfolio total
  // Using USD allows target computation and rebalancing independently of
  // token decimals and relative prices.
  const currentBalancesUsd = [tokenAmounts[0].toUsd(), tokenAmounts[1].toUsd(), tokenAmounts[2].toUsd()]
  const totalPortfolioUSD = currentBalancesUsd[0].plus(currentBalancesUsd[1]).plus(currentBalancesUsd[2])
  if (totalPortfolioUSD.le(USD.zero())) {
    log.info('No rebalance needed (total USD is zero)')
    return
  }

  // Compute desired USD balances per token based on target bps
  // This gives the ideal dollar amount we want allocated per token.
  const desiredBalancesUsd = [
    shareByBps(totalPortfolioUSD, targetBps[0]),
    shareByBps(totalPortfolioUSD, targetBps[1]),
    shareByBps(totalPortfolioUSD, targetBps[2]),
  ]

  // Build lists of surplus and deficit buckets (in USD)
  // Surplus: current > desired (we will sell some of this token)
  // Deficit: desired > current (we will buy this token)
  const surpluses = new Array<Bucket>()
  const deficits = new Array<Bucket>()
  for (let i: i32 = 0; i < 3; i++) {
    if (currentBalancesUsd[i].gt(desiredBalancesUsd[i])) {
      surpluses.push(new Bucket(i, currentBalancesUsd[i].minus(desiredBalancesUsd[i])))
    } else if (desiredBalancesUsd[i].gt(currentBalancesUsd[i])) {
      deficits.push(new Bucket(i, desiredBalancesUsd[i].minus(currentBalancesUsd[i])))
    }
  }

  // If either side is empty, portfolio already matches targets
  if (surpluses.length == 0 || deficits.length == 0) {
    log.info('No rebalance needed (target ratios matched)')
    return
  }

  // Swap from tokens with extra (surplus) to tokens that need more (deficit).
  // Always move the smaller USD amount between the two buckets.
  // Repeat until either the surplus or the deficit bucket is satisfied.
  let surplusIndex: i32 = 0
  let deficitIndex: i32 = 0
  while (surplusIndex < surpluses.length && deficitIndex < deficits.length) {
    const movedUSD = usdMin(surpluses[surplusIndex].amountUSD, deficits[deficitIndex].amountUSD)

    const surplusTokenIndex = surpluses[surplusIndex].index
    const deficitTokenIndex = deficits[deficitIndex].index

    // Convert USD amount to token in/out amounts using token metadata
    // The input token amount is what we sell; the expected output token amount
    // is the USD-equivalent we want to buy before slippage is applied.
    const amountInToken = movedUSD.toTokenAmount(tokensMetadata[surplusTokenIndex])
    const expectedOutToken = movedUSD.toTokenAmount(tokensMetadata[deficitTokenIndex])

    // Apply slippage tolerance to compute minimum acceptable output
    // `slippageBps` bounds the worst price movement we are willing to accept.
    // minimumOut = expectedOut * (1 - slippageBps/10000)
    const slippageFactor = BPS_DENOMINATOR.minus(BigInt.fromI32(inputs.slippageBps as i32))
    const minimumOutAmount = expectedOutToken.amount.times(slippageFactor).div(BPS_DENOMINATOR)

    // Execute swap from surplus token to deficit token with slippage protection
    Swap.create(
      inputs.chainId,
      tokensMetadata[surplusTokenIndex],
      amountInToken.amount,
      tokensMetadata[deficitTokenIndex],
      minimumOutAmount
    ).send()

    // Update remaining USD amounts in both buckets
    // We subtract the USD we just moved; if a bucket hits zero, advance.
    surpluses[surplusIndex].amountUSD = surpluses[surplusIndex].amountUSD.minus(movedUSD)
    deficits[deficitIndex].amountUSD = deficits[deficitIndex].amountUSD.minus(movedUSD)

    // Advance to next bucket if this one is fully satisfied
    if (surpluses[surplusIndex].amountUSD.le(USD.zero())) surplusIndex++
    if (deficits[deficitIndex].amountUSD.le(USD.zero())) deficitIndex++
  }

  // At this point, all surpluses have been swapped into deficits within the
  // provided slippage tolerance, approximating the target allocation.
  log.info('Rebalance executed')
}
```

<div className="kg-card kg-callout-card kg-callout-card-yellow">

You can set up a wallet rebalancing strategy with any ERC-20 token across all supported chains, including ****Arbitrum, Base, Base Sepolia, Ethereum, Gnosis, Optimism, and Sonic****.  
  
Every function is fully customizable, so you can adapt it to your preferred configuration. For details, explore the [Mimic Protocol Library](https://docs.mimic.fi/developers/library).  
  
For now Mimic functions allows creating three types of intents: transfers, generic calls, and crosschain swaps.

</div>

### 5. Compile

The compile process converts your function logic and manifest into deployable artifacts:

-   `build/function.wasm` - Compiled WebAssembly binary
-   `build/manifest.json` - Processed manifest configuration

Run the compile command:

```
yarn mimic compile
```

By default, outputs are saved in the `build` directory.

Here is an example of the output produced by this command:

```
build/
├── function.wasm     # Compiled WASM binary
├── manifest.json     # Validated manifest
```

### 6. Deploy your function

This is where you upload your function artifacts to the network so others can discover it. To do this you can run the `deploy` command using the CLI:

```
yarn mimic deploy --api-key [DEPLOYMENT_KEY]
```

You can **generate a deployment key from the explorer app**, where you can login using your wallet.

> Link to Mimic Protocol Explorer: [https://protocol.mimic.fi/](https://protocol.mimic.fi/)

<video src="https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/API-Key-Generation.mp4" autoPlay loop muted playsInline />

This command will deploy the generated artifacts from the `build` directory by default.

This command will upload your artifacts to the Mimic Registry (which stores them on IPFS) and pin the resultant CID so it can be discovered by others. The CID is also written to `CID.json` in the specified output directory.

### 7. Give allowance to the Mimic settler

Before you configure your function in the dashboard, you must allow the Mimic Settler contract to spend tokens on your behalf.

To grant this permission:

1.  Open your network’s block explorer and find your spending token contract.
2.  Connect your wallet.
3.  Set the Mimic Settler as the spender address.
4.  Approve the contract so it can manage the tokens needed for your function.

Mimic Settler contract:

```
0x609d831c0068844e11ef85a273c7f356212fd6d1
```

For example, for USDC on Base, you can go to the smart contract on basescan, click on "write as proxy", connect your wallet, and add approval to the Mimic settler.[https://basescan.org/address/0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913#writeProxyContract](https://basescan.org/address/0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913#writeProxyContract)

![](https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/Mimic-Settler-Screenshot.png)

The spender is the Mimic settler, and the value depends on the token you want to use in uint256 (USDC has 6 decimals, so the amount + 6 extra zeros).

If you want to allow 20 USDC spending limit, you would write 20000000 (20 + 6 zeroes). Most explorers allow to add them easily as shown below.

<video src="https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/mimic-settler-allowance-1-1.mp4" autoPlay loop muted playsInline />

<div className="kg-card kg-callout-card kg-callout-card-yellow">

Give allowance to the Mimic settler for the tokens you want to rebalance.  
  
In this example USDC, WETH, and cbBTC on Base. You can go to the smart contracts on basescan, connect your wallet, and add approval to the Mimic settler: 0x609d831c0068844e11ef85a273c7f356212fd6d1  
  
[USDC](https://basescan.org/address/0x833589fcd6edb6e08f4c7c32d4f71b54bda02913#writeProxyContract) | [WETH](https://basescan.org/address/0x4200000000000000000000000000000000000006#writeContract) | [cbBTC](https://basescan.org/address/0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf#writeProxyContract)

</div>

### 8. Configure your function

After deploying your function, you can now add a trigger, to tell which trigger relayers should use to run your function. This means defining the parameters declared in your `manifest.yml` file. This is done in the [explorer UI](https://protocol.mimic.fi/) where you will be requested to sign your trigger with your wallet or with the SDK.

<video src="https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/ezgif-7c6f9f01874e82.mp4" autoPlay loop muted playsInline />

1.  Open the explorer and locate the function you just deployed under the functions section.
2.  Add or edit your trigger parameters
3.  Sign the new trigger

![](https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/image--22-.png)

Remember that the targets (A,B,C) must sum a total of 10000 (100% in basis points). In this example:

```tsx
8453 // CHAINID (Base)
0x833589fcd6edb6e08f4c7c32d4f71b54bda02913 // USDC (Base)
0x4200000000000000000000000000000000000006 // WETH (Base)
0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf // cbBTC (Base)

5000 // USDC target in basis points (50%)
3000 // WETH target in basis points (30%)
2000 // cbBTC target in basis points (20%)
200 // 2% Slippage in basis point (1% = 100)
```

Finally set the delta (time window to execute), the end date (optional), and sign with your wallet

This signature ensures relayers know the trigger is authorized by the function owner.

You can update or deprecate this trigger at any point in time to reflect changes, without needing to redeploy the function code again. Just sign the new trigger in the explorer, and relayers will pick up the latest version.

You will get a confirmation message: **Function created successfully!**

Below, you can see a summary of the function (how many runs, completions, and errors), as well as the recent executions and all details about it (inputs, trigger, creation date…).

![](https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/image--23-.png)

If you press on any of the recent executions, you can get a full execution detail, with info such as inputs, outputs, general details, logs, and more.

You can run multiple functions at the same time, and you can make changes to the configuration by creating a new function, without needing to redeploy the function code again.

### Notes & Variations

You will need:

-   **Wallet with funds** (for gas and token approvals)
-   **API key** from Mimic Explorer: [https://protocol.mimic.fi/api-key](https://protocol.mimic.fi/api-key)

<div className="kg-card kg-callout-card kg-callout-card-yellow">

Remember to give allowance to the Mimic settler for the tokens you want to rebalance.  
  
In this example USDC, WETH, and cbBTC on Base. You can go to the smart contracts on basescan, connect your wallet, and add approval to the Mimic settler: 0x609d831c0068844e11ef85a273c7f356212fd6d1  
  
[USDC](https://basescan.org/address/0x833589fcd6edb6e08f4c7c32d4f71b54bda02913#writeProxyContract) | [WETH](https://basescan.org/address/0x4200000000000000000000000000000000000006#writeContract) | [cbBTC](https://basescan.org/address/0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf#writeProxyContract)

</div>

-   Extend to **N tokens** (you can add more tokens to the rebalancing).

* * *

👉 With this, you’ve got a production-style **wallet rebalancer**: USD-aware, slippage-protected, self-contained, and easy to operate via signed configs in Explorer.

![](https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/mimic-protocol-guide-wrebalancing.png)

## Wallet Rebalancing is Only the Beginning

With **Mimic Protocol**, setting up a wallet rebalancing strategy is no longer about writing and maintaining bots, custom scripts, or handing funds over to custodial services. You define the rules once in a **function**, sign them, and let Mimic relayers execute on your behalf, directly from **your wallet or treasury**.

But Mimic Protocol can be used for many other use cases around blockchain automation: auto-investing, yield auto-compunding, DCA, fee management, and many more!

Stay tuned for future guides and details on what automation can unlock onchain. Mimic is the automation engine for Web3.

### Get alpha access to Mimic Protocol by clicking below 👇

![](https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens/Group-1547764730--1-.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let automation handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 📄 [Whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# Dollar-Cost Averaging (DCA) Inside any EVM Wallet With Mimic Protocol

> Set up an automated DCA strategy directly inside your EVM wallet using Mimic Protocol. 

Published: 2025-09-18 | Updated: 2026-02-02 | Author: Mimic Engineering Team | Tags: Mimic Guides | Source: https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol

![](https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/Group-1547765546.png)

## TL;DR

Set up an automated DCA strategy directly inside your wallet using Mimic Protocol. This guide walks you through creating a function that lets you buy any ERC-20 token for a fixed amount of another ERC20 token periodically in any supported network, with schedules & slippage protection, and deployed to the Mimic Protocol.

## Quick Details

-   **Function type:** recurring DCA swap
-   **Flow:** swap ERC20 → ERC20 periodically
-   **Key inputs:** amount, assets, slippage tolerance, recipient, chain, schedule

<div className="kg-card kg-callout-card kg-callout-card-yellow">

This is just an example, Mimic Protocol allows for any type of logic to create a DCA strategy.

</div>

## What You Need to Get Started

-   [Node.js](https://nodejs.org/en) + [Yarn](https://www.geeksforgeeks.org/installation-guide/how-to-install-yarn-in-macos-ubuntu-windows) installed
-   **Wallet with funds**

![](https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/banner04--1-.png)

## Understand the DCA Flow

Dollar-cost averaging means investing a fixed amount of a token at regular intervals:

-   In this example, USDC → WETH, in any of the supported chains
-   Use slippage protection (e.g. 0.5%)
-   Send purchased tokens to your wallet

Mimic Protocol automates this as a **function**:

-   Trigger: cron (weekly)

## Define the Function

### 1\. Initialize project

Start a new working directory to develop your function:

```jsx
npx @mimicprotocol/cli init ./my-mimic-function
```

### 2\. Update your `manifest.yaml`

The manifest file provides the configuration for your function, including:

-   **Metadata**: Name, description, and version of the function.
-   **Inputs**: Parameters required by the function logic.
-   **ABIs**: Smart contract ABIs to generate type-safe interfaces for the function.

Save this configuration in the `manifest.yaml` file:

```yaml
version: 1.0.0
name: DCA WETH Purchase
description: Dollar-cost averaging function that swaps USDC to WETH
inputs:
  - chainId: uint32
  - usdc: address
  - weth: address
  - amountUsdcDecimal: string
  - slippageBps: uint16
  - recipient: address
```

<div className="kg-card kg-callout-card kg-callout-card-yellow">

You can adapt this to any DCA you want to create, just change USDC and WETH for your desired tokens. Also feel free to delete the "recipient: address" if it's the same wallet.

</div>

### 3. Generate types

This steps allows you to validate the manifest definitions and generate the corresponding code to access both your declared inputs and the contract objects for your declared ABIs.

To do this you can run the `codegen` command using the CLI:

```
yarn mimic codegen
```

### 4. Write the function logic

The function logic is implemented in AssemblyScript and must export:

1.  **Input type**: The generated `inputs` type from the previous step.
2.  **Main function**: The core function logic, which receives the inputs as an argument.

Create a file `./src/function.ts` (or update the pre-existing one), and implement the logic:

```javascript
import { ERC20Token, log, SwapBuilder, TokenAmount } from '@mimicprotocol/lib-ts'

import { inputs } from './types'

export default function main(): void {
  // Log input parameters
  log.info(
    `Starting DCA swap: amountFromToken=${inputs.amount}, slippageBps=${inputs.slippageBps}, chainId=${inputs.chainId}, recipient=${inputs.recipient}`
  )

  // Create token instances
  const tokenIn = ERC20Token.fromAddress(inputs.tokenIn, inputs.chainId)
  const tokenOut = ERC20Token.fromAddress(inputs.tokenOut, inputs.chainId)

  // Create amount from decimal string and estimate amount out
  const amountIn = TokenAmount.fromStringDecimal(tokenIn, inputs.amount)
  const expectedOut = amountIn.toTokenAmount(tokenOut).unwrap()
  // Apply slippage to calculate the expected minimum amount out
  const minAmountOut = expectedOut.applySlippageBps(inputs.slippageBps as i32)
  log.info(`Calculated minOut: ${minAmountOut} (equivalent=${expectedOut}, slippageBps=${inputs.slippageBps})`)

  // Create and execute swap
  SwapBuilder.forChain(inputs.chainId)
    .addTokenInFromTokenAmount(amountIn)
    .addTokenOutFromTokenAmount(minAmountOut, inputs.recipient)
    .build()
    .send()

  log.info('DCA swap executed successfully')
}
```

<div className="kg-card kg-callout-card kg-callout-card-yellow">

You can set up a DCA (Dollar-Cost Averaging) strategy with any ERC-20 token across all supported chains, including ****Arbitrum, Base, Base Sepolia, Ethereum, Gnosis, Optimism, and Sonic****.  
  
This is a USDC → WETH DCA setup. You can replace these with any ERC-20 tokens of your choice (just make sure to specify the correct decimals and token symbol).  
  
Every function is fully customizable, so you can adapt it to your preferred configuration. For details, explore the [Mimic Protocol Library](https://docs.mimic.fi/developers/library).  
  
For now Mimic functions allows creating three types of intents: transfers, generic calls, and crosschain swaps.

</div>

**5\. Compile**

The compile process converts your function logic and manifest into deployable artifacts:

-   `build/function.wasm` - Compiled WebAssembly binary
-   `build/manifest.json` - Processed manifest configuration

Run the compile command:

```
yarn mimic compile
```

By default, outputs are saved in the `build` directory.

Here is an example of the output produced by this command:

```
build/
├── function.wasm     # Compiled WASM binary
├── manifest.json     # Validated manifest
```

### 6. Deploy your function

This is where you upload your function artifacts to the network so others can discover it. To do this you can run the `deploy` command using the CLI:

```
yarn mimic deploy --api-key [DEPLOYMENT_KEY]
```

You can **generate a deployment key from the protocol app**, where you can login using your wallet.

> Link to Mimic Protocol Explorer: [https://protocol.mimic.fi/](https://protocol.mimic.fi/)

![](https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/apikeyvideo-ezgif.com-video-to-webp-converter.webp)

This command will deploy the generated artifacts from the `build` directory by default.

This command will upload your artifacts to the Mimic Registry (which stores them on IPFS) and pin the resultant CID so it can be discovered by others. The CID is also written to `CID.json` in the specified output directory.

### 7. Give allowance to the Mimic settler

**Before you configure your function in the dashboard, you must allow the Mimic Settler contract to spend tokens on your behalf.**

To grant this permission:

1.  Open your network’s block explorer and find your spending token contract.
2.  Connect your wallet.
3.  Set the Mimic Settler as the spender address.
4.  Approve the contract so it can manage the tokens needed for your function.

Mimic Settler contract:

```
0x609d831c0068844e11ef85a273c7f356212fd6d1
```

<div className="kg-card kg-callout-card kg-callout-card-yellow">

In this example, we are going to be using USDC on Base. You can go to the smart contract on basescan, click on "write as proxy", connect your wallet, and add approval to the Mimic settler.  
  
[https://basescan.org/address/0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913#writeProxyContract](https://basescan.org/address/0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913#writeProxyContract)

</div>

The spender is the Mimic settler, and the value depends on the token you want to use in uint256 (USDC has 6 decimals, so the amount + 6 extra zeros).

<div className="kg-card kg-callout-card kg-callout-card-yellow">

If you want to allow 20 USDC spending limit, you would write 20000000 (20 + 6 zeroes). Most explorers allow to add them easily as shown below.

</div>

<video src="https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/mimic-settler-allowance-1.mp4" autoPlay loop muted playsInline />

### 8. Configure your function

After deploying your function, you can now add a trigger, to tell which trigger relayers should use to run your function. This means defining the parameters declared in your `manifest.yml` file. This is done in the [explorer UI](https://protocol.mimic.fi/) where you will be requested to sign your trigger with your wallet or with the SDK.

![](https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/createtask-ezgif.com-video-to-webp-converter.webp)

1.  Open the explorer and locate the function you just deployed under the functions section.
2.  Add or edit your trigger parameters
3.  Sign the new trigger

![](https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/screely-1758581110678.png)

In this example:

```
8453 // CHAINID (Base)
0x833589fcd6edb6e08f4c7c32d4f71b54bda02913 // USDC (Base)
0x4200000000000000000000000000000000000006 // WETH (Base)
2 // AmountUSDDecimal, in this example 2 USDC
200 // 2% Slippage in basis point (1% = 100)
```

Then set the the execution fee limit (you can set 0, which means no limit), the execution mode, and the the cron trigger:

![](https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/screely-1758581219869.png)

Finally set the delta (time window to execute), the end date (optional), and sign with your wallet

This signature ensures relayers know the trigger is authorized by the function owner.

You can update or deprecate this trigger at any point in time to reflect changes, without needing to redeploy the function code again. Just sign the new trigger in the explorer, and relayers will pick up the latest version.

You will get a confirmation message: **Function created successfully!**

Below, you can see a summary of the function (how many runs, completions, and errors), as well as the recent executions and all details about it (inputs, trigger, creation date…).

![](https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/screely-1758624780519.png)

If you press on any of the recent executions, you can get a full execution detail, with info such as inputs, outputs, general details, logs, and more.

You can run multiple functions at the same time, and you can make changes to the configuration by creating a new function, without needing to redeploy the function code again.

### Notes & Variations:

<div className="kg-card kg-callout-card kg-callout-card-yellow">

Remember to give allowance to the settler of the token you are going to be spending. In this example USDC, you can go to the [smart contract on basescan](https://basescan.org/address/0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913#writeProxyContract), connect your wallet, and add approval to the Mimic settler: 0x609d831c0068844e11ef85a273c7f356212fd6d1

</div>

Variations:

-   Change `usdc` and `weth` addresses for any token pair (ERC-20 in supported networks).
-   Adjust `cron` schedule (e.g. daily, biweekly).
-   You can add `recipient` to the manifest to send into a different wallet.

* * *

👉 With this setup, you’ve created a **repeatable DCA flow inside your wallet** using Mimic Protocol.

![](https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/banner03.png)

## DCA is Only the Beginning

With **Mimic Protocol**, setting up a DCA strategy is no longer about writing and maintaining bots, custom scripts, or handing funds over to custodial services. You define the rules once in a **function**, sign them, and let Mimic relayers execute on your behalf, directly from **your wallet or treasury**.

But Mimic Protocol can be used for many other use cases around blockchain automation: auto-investing, yield auto-compunding, wallet rebalancing, fee management, and many more!

Stay tuned for future guides and details on what automation can unlock onchain. Mimic is the automation engine for Web3!

### Get alpha access to Mimic Protocol by clicking below 👇

![](https://www.mimic.fi/blog/dollar-cost-averaging-dca-inside-any-evm-wallet-with-mimic-protocol/Group-1547764730--1-.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let automation handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# Automation Spotlight: How Mimic Fee Collector Empowers Teams to Manage Crosschain Fees

> Today’s multi-chain market results in significant operational challenges around the management of revenue fees. Our fee collection solution empowers teams to automate the process: consolidating assets from multiple chains into a single token and destination, in a secure manner.

Published: 2025-09-11 | Updated: 2025-09-24 | Author: Mimic Engineering Team | Tags: Fee Collector | Source: https://www.mimic.fi/blog/automation-spotlight-how-mimic-fee-collector-empowers-teams-to-manage-crosschain-fees

![](https://www.mimic.fi/blog/automation-spotlight-how-mimic-fee-collector-empowers-teams-to-manage-crosschain-fees/fee-collector-spotlight-fees-1.png)

When Web3 protocols and applications generate revenue fees across multiple chains and tokens, the finance and operations teams need to convert all those fees into something more manageable, such as stablecoins, to pay salaries, distribute profits, and pay taxes, among other uses.

The more networks, tokens, and wallets involved in the process, the more complicated it becomes. There are several steps involved: collecting the fees, swapping them, bridging, and distributing all those tokens into one or multiple wallets.

## Why Managing Fees Manually is Difficult and Time-consuming

Today’s multi-chain market results in significant operational challenges around the management of revenue fees:

-   Complexities due to the diversity of tokens, prices, and networks
    -   One of our customers has regularly more than 2,700 tokens only in the Polygon network
-   Manual operations increase the risk of mistakes and delays
    -   Another customer automated only 80% of their flow, and they still made a mistake in the final step of the workflow, causing a loss of funds
-   “Long-tail token problem”: only selling the main tokens in order to avoid the tedious task of selling every single token manually
    -   A lot of clients only sold major tokens (ETH, USDC, USDT, WBTC, etc.), which made up 70% of the volume, wasting a high percentage of potential revenue (30% of volume) and leaving it in illiquid tokens that lost value over time
-   Requires constant checks and vigilance over market conditions
    -   Some of our clients used to spend too much on gas costs while manually doing this, due to bad operation timing (e.g. needing salaries at the end of the month)
-   Operational overhead and security risks add up fast
-   Time-consuming and monotonous, preventing valuable team members from focusing on more critical engineering tasks
    -   For example, the Balancer team used to spend 8–10 hours every two weeks on v2 to swap fee tokens manually

> _“Integrating Mimic's Fee Collector into our operations has been a game-changer. It completely automated how we handle fee management across multiple integrations, eliminating hours of manual work.”_  
> **Ledger**

## Introducing Mimic Fee Collector

Our fee collection solution empowers teams to automate the process: consolidating assets from multiple chains into a single token and destination, in a secure manner.

**Collects your fees anywhere → swaps them at the best price and in the correct time → bridges with complete security → withdraws to your destination address/es in one token (instead of 1000s).**

![](https://www.mimic.fi/blog/automation-spotlight-how-mimic-fee-collector-empowers-teams-to-manage-crosschain-fees/07-PRES.png)

End-to-end automation that adapts to every client’s specific use case.

Different than protocols that might share the same smart contracts to manage the assets of several clients (e.g., Pools), **Mimic deploys a dedicated environment for each client:**

-   The privacy feature adds a higher level of security, as only authorized entities can access these smart contracts, thereby shielding client assets
-   Customers always retain full control over their assets since each environment is fully non-custodial and isolated
-   This approach ensures operational efficiency while maintaining trust and reliability

> _“Mimic \[…\] manages our fee collection with precision and reliability, eliminating manual overhead and reducing operational risk.”  
> **Trust Wallet**_

With over $7B of value processed, **Mimic Fee Collector** is a battle-tested and reliable solution for onchain fee management:

-   Trusted by leaders such as Balancer, Ledger, Trust Wallet, Velora, and more
-   Live across all major EVM networks and Solana
-   Offers extensive reporting, giving businesses the information they need to make better decisions
-   Provides world-class service for customer support, reporting, and ongoing maintenance

> _“The comprehensive reporting adds another layer of confidence for our team and stakeholders.”_  
> **Ledger**

> _“Their team continues to provide top-tier support whenever we need it.”_  
> **Trust Wallet**

## How Customers Managed Onchain Fees Before Mimic

Fee management was typically a task assigned to the finance team, often without in-depth knowledge of crypto markets, as they needed to handle revenue and financial projections. Before adopting Mimic Fee Collector, many teams relied on a mix of manual transactions, internal scripts, and centralized providers to manage their fee operations.

1.  Most teams were doing **manual fee collection**, tracking down the revenue tokens across wallets, executing swaps, bridging, and transferring repeatedly
2.  Others built custom in-house tools or scripts that required constant maintenance, engineering time, and lacked the flexibility to adapt to evolving use cases.
3.  Lastly, some relied on centralized services that introduced security vulnerabilities and access control problems.

> _“This helped us scale the business and improve our financial operations.”_ **Velora (formerly ParaSwap)**

All these approaches worked on their own, but were time-consuming, error-prone, difficult to scale as protocols grew across chains, or involved third parties temporarily taking control over company assets.

## Why Switch to Mimic Fee Collector Instead of Handling Fee Collection In-house

We've spent years helping teams automate fee collection across all kinds of setups. That experience lets us move fast, adapt to any business requirements, and deliver a solution that just works. No matter how complex the need, our system is built for customization, security, and scale, so you can focus on strategy, while we handle the operations.

Aside from execution, our fee collection solution helps teams streamline their management flow, providing structured data for each step of the process. Clients can **select from multiple of parameters** to customize their environment tasks, while always remaining in control of their assets.

![](https://www.mimic.fi/blog/automation-spotlight-how-mimic-fee-collector-empowers-teams-to-manage-crosschain-fees/Mimic-Fee-Collector-Pillars.png)

The Mimic team configures shared parameters, including token management, slippage tolerance, transaction limits, transaction cost thresholds, fee claiming, permissions, execution settings, and more, **based on customer instructions**.

Clients also have the flexibility to set thresholds, slippage, or timing themselves, allowing detailed customization and strategic oversight. It’s worth noting that all these parameters can be changed anytime, based on the client/business needs.

Every single one of our customers has access to a world-class integration team and customer support, addressing any issue that may arise and ensuring every dedicated environment remains up to date for optimal performance.

> _“The ongoing support from the Mimic team is impeccable — working with them is a sheer pleasure.”_ **Velora (formerly ParaSwap)**

> _“Their consistent professionalism, reliable execution, and seamless integration have made Mimic a trusted part of our infrastructure.”_ **Balancer**

## What Our Customers Say (Full Testimonials)

![](https://www.mimic.fi/blog/automation-spotlight-how-mimic-fee-collector-empowers-teams-to-manage-crosschain-fees/Group-1547765294.png)

## Ready to Automate your Fee Collection?

**Still handling fees manually?** Let us take it from here.

Join leading teams using Mimic Fee Collector to automate fee management across chains.

👉 [Let’s talk](https://www.mimic.fi/contact)

[Learn more](https://www.mimic.fi/fee-collector) | [Supported networks](https://www.notion.so/Supported-networks-Fee-Collector-24ef0204dbef4cbeb119273be01092b2?pvs=21) | [Fee Collector blog](https://www.mimic.fi/blog/mimic-fee-collector-automate-your-onchain-fee-management)

---

# How Mimic Fee Collector Could Have Avoided Coinbase’s $550K MEV Exploit

> Even the best-prepared teams in crypto are not immune to mistakes. This week, Coinbase, one of the industry’s largest and most experienced players, lost around $550,000 when its corporate wallet mistakenly approved tokens to 0x’s swapper contract. An opportunistic MEV bot, long waiting for this type of misstep, instantly drained the authorized assets.

Looks like @coinbase was recently drained of ~$300,000 after using @0xProject swapper incorrectly.

They approved all the tokens accrued as fees 

Published: 2025-09-09 | Updated: 2025-09-10 | Author: Mimic Engineering Team | Tags: Fee Collector | Source: https://www.mimic.fi/blog/how-mimic-fee-collector-could-have-avoided-coinbases-550k-mev-exploit

![](https://www.mimic.fi/blog/how-mimic-fee-collector-could-have-avoided-coinbases-550k-mev-exploit/coinbase-loss--1-.png)

Even the best-prepared teams in crypto are not immune to mistakes. This week, Coinbase, one of the industry’s largest and most experienced players, lost around $550,000 when its corporate wallet mistakenly approved tokens to 0x’s _swapper_ contract. An opportunistic MEV bot, long waiting for this type of misstep, instantly drained the authorized assets.

No customer funds were affected, and Coinbase acted quickly to secure its wallets. But the event is a reminder that **token approvals are one of the most overlooked security risks in DeFi.**

You can read an article by Cointelegraph about it here: [https://cointelegraph.com/news/coinbase-0x-contract-error-mev-bot-300k-loss](https://cointelegraph.com/news/coinbase-0x-contract-error-mev-bot-300k-loss)

## Why Token Approvals Are Tricky

Onchain approvals are designed to let smart contracts spend tokens on your behalf. But when approvals are given to contracts that shouldn’t hold them (like a swapper contract) they effectively hand over the wallet funds. Because these approvals are public and permissionless, anyone can call the contract and drain the funds once the allowance exists.

The Coinbase case shows that:

-   Errors don’t have to be malicious exploits, misconfigurations alone are enough.
-   MEV bots are always watching, ready to execute when high-value wallets slip.
-   Once approvals are live, revoking them is usually too late.

Whether the authorization was made manually or through code doesn’t matter. **The lesson is that approvals need continuous control, monitoring, and safeguards.**

## Introducing Mimic Fee Collector

At Mimic, we designed the Mimic **Fee Collector** to handle exactly these kinds of operational challenges for teams, DEXes, and wallets:

Instead of manually managing dozens of fee streams across networks and tokens, teams can consolidate their fees into one asset and address/es with secure automation. Automated **collect, swap, bridge, and withdraw** tasks, always executed within their chosen rules.

-   **Oracles validate conditions** before any action (like approvals, swaps, or bridges) takes place. This prevents unsafe or unintended operations from executing.
-   **Safeguards enforce limits** such as allowed tokens, slippage boundaries, gas price caps, and destination addresses. No task runs outside of user-defined parameters.
-   **Dedicated SmartVault environments** keep operations isolated, non-custodial, and configurable per client.
-   **Revocation and renewal of approvals** can be automated, so allowances are never left open-ended.

## How Mimic Fee Collector Could Have Prevented Coinbase’s $550k MEV Exploit

Mimic Fee Collector could have prevented Coinbase’s $550K loss by removing the need for broad ERC-20 approvals to unsafe contracts in the first place. With Fee Collector, all fee operations (collecting, swapping, bridging, and withdrawing) are executed through **dedicated SmartVaults in private environments**, where permissions, token approvals, and execution parameters are tightly controlled and only exposed under user-defined safeguards.

Instead of granting unlimited allowances to a permissionless contract like 0x Settler, Coinbase’s fee wallet would have routed all operations through Mimic’s automated workflows, which enforce role-based permissions, slippage limits, gas controls, and destination whitelists. This design ensures that **no external actor could exploit approvals**, while still allowing fees to be consolidated, swapped, and bridged automatically.

> In short, Fee Collector’s trustless, non-custodial automation would have eliminated the human error of misconfigured approvals that MEV bots exploited, protecting Coinbase from a costly “drained by design” mistake.

## Why Security Safeguards Matter More Than Ever

For Coinbase, $300,000 is a small loss. But for most teams, a similar mistake could be critical. The incident is a timely reminder that operational fragility is real, even at the top.

As DeFi grows, the complexity of fee management and token flows across chains only increases. Relying on manual processes or fragile scripts is not enough. Exchanges, wallets, and protocols need **automation with safeguards:** systems that check, validate, and enforce safe behavior before mistakes become losses.

## Start Using Automation for Fee Management

**Still handling fees manually?** Let us take it from here.

Join leading teams using Mimic Fee Collector to automate fee management across chains:

👉 Let’s talk: [https://www.mimic.fi/contact](https://www.mimic.fi/contact)

[Learn more](https://www.mimic.fi/fee-collector) | [Supported networks](https://www.notion.so/Supported-networks-Fee-Collector-24ef0204dbef4cbeb119273be01092b2?pvs=21) | [Fee Collector blog](https://www.mimic.fi/blog/mimic-fee-collector-automate-your-onchain-fee-management)

---

# What is Mimic Protocol?

> Mimic Protocol is the automation layer for Web3. Automate everything onchain: any tasks, any logic, with crosschain execution. 

Published: 2025-08-29 | Updated: 2026-02-23 | Author: Mimic Engineering Team | Tags: Mimic Platform | Source: https://www.mimic.fi/blog/what-is-mimic-protocol

![](https://www.mimic.fi/blog/what-is-mimic-protocol/what-is-mimic-protocol_04--2-.png)

Mimic Protocol is the automation layer for Web3. Open and secure automation for builders, DeFi teams, AI agents, developers, wallets, and beyond.

Automate everything onchain: any functions, any logic, with crosschain execution. Programmable and non-custodial to help you combine simple actions (like swaps, bridging, claiming or staking) with custom conditions (balances, prices, dates, and more), taking your onchain operations to the next level.

The end goal is to make automation accessible to everyone (from developers to product managers and even finance teams) while maintaining precision, transparency and scalability in execution.

At a high level, Mimic lets you “set it and forget it” for onchain workflows. Builders can define complex conditional operations in code (for example, a multi-step DeFi strategy or periodic portfolio rebalancing) and the protocol will handle the rest – fetching data, checking conditions and executing transactions when needed.

## Why does it matter?

Web3 wants to scale, but it lacks automation standards

Every industry in the world has grown with automation. But for some reason, Web3 still relies on manual operations. Imagine a DAO wants to keep their treasury balanced at 60% stablecoins, 30% ETH, and 10% DeFi tokens. Doing this manually looks like:

> Check the portfolio composition → Calculate deviations from the target allocation → Decide what to sell and buy → Connect to a DEX → Approve tokens for trading → Execute swaps (sometimes across multiple chains) → Bridge assets if needed → Verify new balances → Repeat every week (or more often if markets move).

Add monitoring gas prices, interacting with multiple protocols (each with its own interface and requirements) or getting gas fees, _and things can start getting intense._ If this seems like too many steps, that’s because it is. Now imagine thousands of transactions, across several blockchains, and adding more complex actions like staking, swapping, or withdrawing assets.

One portfolio rebalance is doable. But try doing it for multiple treasuries, vaults, or funds, and it quickly becomes **operationally impossible.** Doing things manually can only get you so far.

Web2 already has standards for automation. **We want to bring the same level of scalability to Web3:** a simple, easy way to integrate automation into apps, wallets, and protocols.

## How does Mimic Protocol work?

> **TLDR:** select the operations, set the triggers, let the protocol automate the execution.

Mimic Protocol offers developers a **“plug-and-play” solution to automate any blockchain operations** (like swaps, transfers, staking) with different triggers, such as onchain events (even across chains), chronological schedules (times & dates), and other types of custom conditions (like balance thresholds).

It allows developers to:

-   Decide what they want to automate, and Mimic Protocol executes according to their exact conditions, in a reliable, secure, and decentralised manner.
-   Implement automation directly in their apps or backend, offering them flexibility to build and scale exactly what they need.
-   Set how long to run their automation, and as long as the conditions are met, Mimic Protocol will execute the operations 24/7.

**Mimic Protocol is not an L1 or L2**, but rather a chain-agnostic protocol, helping connect multiple actions on multiple chains. Users can decide what they want to automate, and Mimic Protocol executes functions 24/7 according to the exact conditions, with complete reliability, security, and decentralization.

## Mimic Protocol technical architecture

Mimic is built with a three-layer architecture, each layer focusing on a distinct part of the automation pipeline. This modular design allows the protocol to maintain clarity of roles and responsibilities, enhancing both security and scalability. The layers are:

(1) the Planning Layer where functions are defined and evaluated

(2) the Execution Layer where intents (function outputs) are processed and fulfilled and

(3) the Security Layer which finalizes transactions and enforces safeguards

Each layer involves specific participants and components that work together to ensure deterministic execution and robust handling of user operations

1.  **Planning Layer**

Allows you to define and schedule functions with precise triggers (time-based, event-based, or custom conditions). Multiple independent relayers fetch data from oracles, validate conditions, and keep everything deterministic.

2.  **Execution Layer**

Transforms user functions into “intents” and coordinates a network of solvers in a competitive auction-like environment to find the most efficient, reliable proposal. Think of it as a decentralized “function runner” that ensures you get **the best** execution outcome.

3.  **Security Layer**

The final on-chain contract that validates a solver’s proposed outcome against your **user-defined safeguards,** and ensures only authorized, expected actions take place. It’s your safety net, enforcing the logic you originally set.

With Mimic, you get the benefits of automation without surrendering your private keys or trusting a single intermediary.

You can learn more about the full protocol architecture in our documentation: [https://docs.mimic.fi/developers/architecture](https://docs.mimic.fi/developers/architecture)

## Who is it for?

Mimic Protocol is designed for a wide range of Web3 audiences, from developers and dApp teams to institutional treasuries and autonomous agents, all needing reliable, scalable, and secure automation. Here’s a breakdown of the key protocol users:

-   **Web3 developers**: Developers can define functions using custom logic, integrate automation into smart contracts, and interact with Mimic through APIs and SDKs to build robust automation layers into their apps, protocols, or bots.
-   **Web2 developers entering Web3**: For developers without deep Solidity or smart contract experience, Mimic abstracts away much of the blockchain complexity. It provides intuitive scripting environments, pre-built templates, and strong guardrails, making it easy to set up and deploy automation logic without writing low-level smart contract code.
-   **AI agents & autonomous systems**: AI and offchain agents can leverage Mimic to interact with blockchain infrastructure safely. Thanks to strict safeguard enforcement, agents can execute operations like swaps, staking, or bridging without risking asset loss or unauthorized behavior, enabling the rise of “AI-native” DeFi execution models.
-   **Treasury managers & financial teams**: For DAOs, DeFi protocols, or Web3 companies managing multi-chain treasuries, Mimic enables automation of key workflows, such as rebalancing portfolios, moving assets between networks, distributing funds, or executing market-driven strategies, all with full control over timing, thresholds, and security rules.
-   **Wallets & superapps**: Mimic allows wallets to offer embedded automation features like DCA, auto-investment, rewards compounding, or conditional staking. These can be added via SDKs or function templates, giving users features without the complexity of writing custom contracts.
-   **DeFi protocols & DAOs**: Protocol teams can automate backend operations like fee collection, token distribution, vault strategies, and even airdrops, improving operational efficiency while preserving decentralization.
-   **App builders & infrastructure teams**: Teams building Web3 applications or services can use Mimic to handle operational logic in the background, like reacting to user activity, automating liquidity provision, or scheduling time-based actions, letting them focus on product development, not execution pipelines.
-   **Crosschain platforms**: Since Mimic is chain-agnostic and supports cross-chain intents, it's a powerful tool for teams operating across multiple networks. It handles bridging, token standardization, and conditional execution, solving key interoperability challenges.
-   **Governance & DAO coordinators**: Mimic allows for automated proposal execution, periodic rewards distribution, or milestone-based funding, all configured through community-approved parameters, ensuring transparency and execution fidelity.

In essence, Mimic is for anyone who needs automation in Web3 but refuses to compromise on control, security, or flexibility.

## Real use cases with Mimic Protocol

**AI agents:** Mimic lets AI handle automation without letting it run wild, so you get the benefits of innovative, proactive execution without risking full wallet compromise.

**Treasury/asset management:** Automate treasury strategies, including portfolio rebalancing, asset allocation, and liquidity optimization, across multiple chains and assets.

**Automated vaults:** automate DeFi strategies that include any function, such as investing, staking, swapping, bridging, or any smart contract call, with custom parameters and complete user control.

**Internal operations:** handle backend workflows like function execution, input validation, and safeguarding logic with deterministic and decentralized automation.

**Fee collection:** automate the secure aggregation, conversion, and distribution of protocol fees across networks

**Airdropper solution:** enable token airdrops based on preset triggers and logic, ensuring controlled, repeatable, and gas-efficient distribution campaigns.

**Account topper:** by monitoring balances and executing refills upon thresholds, automate topping up accounts or wallets across chains with minimal manual oversight.

**Recurring payments:** through scheduled or condition-triggered functions, support automated periodic payments or billing flows with precision and reliability.

In a world where technology scaled with automation, Mimic Protocol brings new standards to Web3.

### Get alpha access to Mimic Protocol by clicking below 👇

![](https://www.mimic.fi/blog/what-is-mimic-protocol/Group-1547764730--1-.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let automation handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 📄 [Whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# Why Trustless Automation Matters in Web3

> Manual processes don’t scale. In traditional tech stacks, we rely on automated pipelines and scheduled tasks. Why should blockchain be any different?

Published: 2025-08-18 | Updated: 2025-08-29 | Author: Mimic Engineering Team | Tags: Onchain Automation, Mimic Platform | Source: https://www.mimic.fi/blog/why-trustless-automation-matters-in-web3

![](https://www.mimic.fi/blog/why-trustless-automation-matters-in-web3/Option-B.png)

Manual processes don’t scale. In traditional tech stacks, we rely on automated pipelines and scheduled tasks. Why should blockchain be any different?

Modern software development embraces automation everywhere: from CI/CD pipelines to cloud infrastructure. Yet in blockchain, many recurring tasks still rely on human intervention, such as manually executing scripts, monitoring market conditions, or toggling smart contracts. This approach limits Web3’s potential, because manual effort is prone to error, delay, and unpredictability.

At a time when developers are building advanced DeFi protocols and crosschain apps, the tools we use to manage onchain actions still feel like the early days of Web2: fragmented, fragile, and frustrating.

**Trustless automation** changes that. It provides a secure and decentralized way to schedule and execute onchain actions, removing the need to babysit your transactions or rely on a single, centralized service.

And that’s where **Mimic Protocol** comes in. We’re building **the automation layer for Web3** that helps you handle **routine or complex tasks** onchain, just as seamlessly as you’d run scheduled jobs in AWS or any other enterprise-grade infrastructure.

## The State of Automation in Blockchain: A Decade Behind

In the broader tech world, companies use services like AWS, Kubernetes, or specialized DevOps tools to keep their workloads running smoothly, even when employees are offline.

In Web3, however, automation is still **underdeveloped**. Existing solutions often rely on:

-   **Centralized operators** you must trust not to censor or misfire your transactions.
-   **Manual tasks** that force you or your dev team to be on-call for routine updates.
-   **Semi-closed frameworks** that don’t offer the same transparency or composability as onchain solutions.

Moreover, each chain or layer often has its own tooling, making crosschain operations cumbersome. The result? Builders who want enterprise-level automation face a tangle of ad-hoc scripts, partial solutions, or manual processes.

Despite blockchain’s innovation around decentralization, many Web3 operations are still manual. Developers maintain bots, cron jobs, and backend scripts just to keep things running. Teams must constantly monitor markets, approve transactions, and move funds—especially when working across multiple chains.

Compare this with **Web2 infrastructure**, where automation is a given:

-   Cloud engineers rely on autoscaling, uptime monitoring, and scheduled jobs.
-   Financial services use algorithms to move trillions in daily volume automatically.
-   DevOps teams deploy changes with zero downtime via CI/CD pipelines.

The irony is clear: blockchains were designed to eliminate intermediaries, yet we often end up playing the middleman for our own systems.

## Why Trustless Automation Matters

Automation is about **efficiency**: reducing repetitive tasks, minimizing human errors, and enabling 24/7 operations. But in a **trustless** environment, it also needs to ensure:

### Decentralization

No single operator can censor or commandeer your scheduled tasks. Multiple independent actors verify data and process execution, mirroring the ethos of blockchain.

### Security & Transparency

Clear onchain records of who, when, and how tasks are triggered. Automated actions must respect user-defined safeguards.

### Scalability

As your onchain workflow grows—whether it’s supply chain tracking, decentralized finance, treasury management, or enterprise use cases—human oversight can’t keep up. Automation helps scale tasks seamlessly.

### Cost Optimization

With the right incentives, tasks can execute at optimal times or under certain cost conditions (like gas fee thresholds), reducing operational expenses for the end user.

Onchain Automation isn't just about convenience, it's about resilience, decentralization, safety, and focusing on building instead of time-consuming operations.

## Introducing Mimic: A High-Level Teaser

Mimic Protocol is engineered to **standardize and scale** automation for Web3. We’re building it around three foundational layers—**Planning**, **Execution**, and **Security**—to ensure every step from “task definition” to “onchain finalization” is handled **transparently** and **securely**.

### Planning Layer

Allows you to define and schedule tasks with precise triggers (time-based, event-based, or custom conditions). Multiple independent relayers fetch data from oracles, validate conditions, and keep everything deterministic.

### Execution Layer

Transforms user tasks into “intents” and coordinates a network of solvers in a competitive auction-like environment to find the most efficient, reliable proposal. Think of it as a decentralized “task runner” that ensures you get **the best** execution outcome.

### Security Layer

The final onchain contract that validates a solver’s proposed outcome against your **user-defined safeguards**—and ensures only authorized, expected actions take place. It’s your safety net, enforcing the logic you originally set.

With Mimic, you get the benefits of automation without surrendering your keys or trusting a single intermediary.

## A Foundation for Scalable Web3

We often compare Mimic’s mission to the role **cloud infrastructure** plays in traditional tech: you don’t need to set up your own servers or manually push every system update; **you let the platform handle it**.

Similarly, Mimic is designed to be a **flexible automation layer** that any project, DAO, or enterprise can plug into, letting them focus on innovation instead of repetitive tasks. This approach unlocks:

1.  **Faster Iteration:** Spend less time on manual upkeep, more time building new features.
2.  **Reduced Risk:** Remove the reliance on ad-hoc scripts that could fail at the worst possible moment.
3.  **Greater Accessibility:** Even non-technical stakeholders can define repeatable processes, trusting the protocol to execute them precisely.

## Automation as The Future of Blockchain

Blockchain is more than just tokens and trading; it’s about **orchestrating trustless collaboration**. As onchain applications grow, **automation** becomes the backbone that lets us scale securely and efficiently, much like how continuous integration and cloud hosting revolutionized web development.

Just like AWS and GitHub enabled a generation of builders to ship software faster, **Mimic Protocol is enabling Web3 teams to operate faster, safer, and smarter**.

Ready to reshape your onchain workflow? Stay tuned for our next posts. We can’t wait to show you how we’re moving blockchain automation forward, together.

Manual effort doesn’t scale. Trustless automation does.

## Join the Mimic Protocol Alpha

As onchain automation continues to transform the way teams operate, Mimic Protocol is building a new standard in programmable, decentralized execution for Web3.

Alpha testing will start soon! If you're a crypto developer or protocol operator, now’s your chance to get ahead of the curve.

### Get alpha access to Mimic Protocol by clicking below 👇

![](https://www.mimic.fi/blog/why-trustless-automation-matters-in-web3/Group-1547764730--1-.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let automation handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 📄 [Whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# First Mimic Protocol Use Case: Internal Automation for a Client

> We found a way to replace an internal script we had to trigger manually with the Mimic Protocol, and we gained a lot of time, security, and saved resources!

Published: 2025-08-08 | Updated: 2026-02-02 | Author: Mimic Engineering Team | Tags: Mimic Platform | Source: https://www.mimic.fi/blog/first-mimic-protocol-use-case-internal-automation-for-a-client

![](https://www.mimic.fi/blog/first-mimic-protocol-use-case-internal-automation-for-a-client/Option-A.png)

**TLDR:** We found a way to replace an internal script we had to trigger manually with the Mimic Protocol, and we gained a lot of **time**, **security**, and **saved resources**!

They say the best products are the ones that you build to solve your own problems. Let’s dive right in into this first use case study of our Blockchain Automation Protocol.

## The Context: Using Mimic Protocol for Internal Workflows

-   We have a product called Fee Collector that consolidates onchain fees across networks into a single asset and chain, using secure automation.
-   Every client gets their own dedicated and trustless environment, for extra security and reliability.

We had just finished the full integration for our new client, Indexcoop, and we were ready to deploy the Fee Collector, but there was one final catch. Indexcoop mints tokens that represent leverage positions, so you can access leverage without the complexity (e.g. BTC2x, ETH3x, etc.).

We set up the new environment and integrated the Indexcoop swapper, to access all the different fees. Since it’s leverage, you first need to withdraw the position, which was straightforward for us to do.

But it was not as straightforward as we expected...

## The Problem

Each token (BTC2x, ETH3x, etc.) has its own fee contract, and fees only get sent to our depositor **if someone manually calls** `accrueFeesAndDistribute()` on each token.

Once the fees are in our depositor contract, the whole Fee Collector can go on as usual: swap → bridge → withdraw. But in this case we encountered two challenges:

1.  Anyone at any moment can call this function, `accrueFeesAndDistribute()`, to collect the fees
2.  The client asked to always call it, without threshold or any type of advanced logic

Normally we would set up a custom automation function on our product for this type of actions, but it would add more time as we would need to develop, test and deploy. And since the rest of the integration was ready, we decided to launch the Fee Collector with the idea to automate it later. In the mean time, someone from our team would take care of calling this manually once a week.

## The Original Script Solution

To start processing the fees right away, we did it manually at the beginning. We would send one transaction per token pool, and setting a script that would trigger all the transactions at the same time. But it depended entirely on one of us to run it, being online, and not forgetting it.

We were ready to make a proper integration with a full smart contract when we realized we could use Mimic Protocol!

## New Solution: From Script to Protocol

Since it’s a very straight-forward function call, we decided to automate it with Mimic Protocol. Once a week, an address must execute a series of calls to Indexcoop's fee contracts.

Our tech lead Agustín programmed the task, which is very simple, since there are no threshold verifications or anything out of the ordinary.

For example here we can see it in action in Arbitrum:

![](https://www.mimic.fi/blog/first-mimic-protocol-use-case-internal-automation-for-a-client/image--10-.png)

Each "FeeSlitExtension" contract obtains the fees for each token (BTC2x, BTC3x, ETH2x, etc etc) and sends them to the depositor contract of Indexcoop’s environment. Also we can see a nice graph of all the different tokens being transferred:

![](https://www.mimic.fi/blog/first-mimic-protocol-use-case-internal-automation-for-a-client/Screenshot-2025-07-31-at-22.08.59--1-.png)

## What We Gained and Why it Matters

We were about to write more code. Instead, we used our automation protocol, saving time, resources, and gaining security, plus a lot other benefits:

-   No manual steps to forget
-   No need to over-engineer a simple task
-   We realized even our internal operations can use the same tools we are offering users!

In hindsight, this was an ideal Mimic Protocol use case, and we are very happy with the results. It is live on Arbitrum and Base, which means even if our automation protocol is in alpha version, it’s viable and genuinely useful for improving internal operations.

## The Lesson

While this is a basic use-case, it's good to see the protocol working, and already making our lives easier. Mimic Protocol is able to do so much more, but this also shows the flexilibity of the system: it can cover from very simple and specific actions (like calling multiple contracts at the same time) to more complex needs around treasury management or portfolio rebalancing.

The next time you're about to solve a repetitive blockchain operation with a script, ask yourself:

> Would my life improve if I automate this?

If the answer is yes, think about using Mimic Protocol!

## Join the Mimic Protocol Alpha

As onchain automation continues to transform the way teams operate, Mimic Protocol is building a new standard in programmable, decentralized execution for Web3.

Alpha testing will start soon! If you're a crypto developer or protocol operator, now’s your chance to get ahead of the curve.

### Get alpha access to Mimic Protocol by clicking below 👇

![](https://www.mimic.fi/blog/first-mimic-protocol-use-case-internal-automation-for-a-client/Group-1547764730--1-.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let automation handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 📄 [Whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# Mimic EthCC[8] Wrap-up: Our Time in Cannes 2025

> From presenting trustless automation on the main venue, to launching our first public event, here's a recap of Mimic at EthCC[8] in Cannes!

Published: 2025-07-11 | Updated: 2025-07-11 | Author: Mimic Engineering Team | Tags: Events | Source: https://www.mimic.fi/blog/mimic-ethcc-8-wrap-up-our-time-in-cannes-2025

![](https://www.mimic.fi/blog/mimic-ethcc-8-wrap-up-our-time-in-cannes-2025/EthCC_Wrap_UP.png)

EthCC 2025 was a huge success! This year it was hosted in Cannes, in the south of France, and despite some early criticisms, the event turned out to be great, with more people focusing on building and creating rather than subtracting from the ecosystem.

The Mimic team attended both the main conference, as well as some super high quality side events (where we got the most alpha). We want to share our experience, what we learned, and the key takeaways for Mimic and our new automation protocol.

Whether you attended EthCC or not, let’s explore what happened during the week in Cannes!

## Sentiment Turned Bullish Quickly

When Cannes was announced for EthCC\[8\], there was a bit of backlash at the beginning, about the city being small and expensive, hot weather, and the closest airport being Nice (not an international hub).

But as soon as people saw the main venue, and how good the city was for hosting side events, sentiment changed to positive fast.

## Main Venue

The main event of EthCC\[8\] was hosted at Palais des Festivais, the same venue that hosts the annual Cannes Film Festival, the Cannes Lions International Festival of Creativity, MIPIM, and the NRJ Music Awards.

![](https://www.mimic.fi/blog/mimic-ethcc-8-wrap-up-our-time-in-cannes-2025/IMG_0536-3.jpg)

It’s a great convention centre, with bigger and smaller stages, and an outdoor space where the food court was located. The ac worked great, and there were so many interesting panels and workshops, although sometimes the organization could have been a bit better.

Overall it was a great space to host a crypto conference: it was big enough so you wouldn’t feel crowded but small enough that random interactions could happen. Each floor was nicely colored, and there was a coffee station at the entrance that was very popular.

## Mimic Presentations at Palais des Festivais

We had two representations at the main venue: our CTO, Facu, and our tech lead, Agustín.

![](https://www.mimic.fi/blog/mimic-ethcc-8-wrap-up-our-time-in-cannes-2025/IMG_0685.jpg)

Facu Spagnuolo, Mimic's CTO and Co-Founder, introduced Mimic Protocol to a very engaged audience. He paid tribute to The Hitchhiker's Guide to the Galaxy, and used Marvin the Paranoid Android (a character in the books) to show how our automation protocol works.

We were very happy about the attendance, people seemed very interested about onchain automation, and asked some great questions, such as exploring potential onchain + offchain events in the future.

![](https://www.mimic.fi/blog/mimic-ethcc-8-wrap-up-our-time-in-cannes-2025/E74A2DE9-B75E-4662-9D77-B34B3E3349DB.JPG)

Agustín, Tech Lead, gave a presentation about enhancing web3 Security through smart contract verification, and showed how his open-source verification system worked. You can watch the [full video here.](https://ethcc.io/archives/sci-enhancing-web3-security-through-smart-contract-verification)

## Below the Surface: Our Side Event at EthCC

We hosted our first ever public event on July 3rd 2025. We were very excited, but uncertain on how it would turn out, but we were very surprised to see so many great people joining us to talk about **onchain automation** and infrastructure.

We introduced the Mimic Protocol for the first time in a public demo. Here is a bit more context about it:

* * *

### 🛠️  Introducing Mimic Protocol

[Mimic](https://x.com/mimicfi) is building an automation protocol for onchain builders.

We have been providing blockchain automation solutions since 2021 for top leaders in the industry, such as 1inch, Balancer, Ledger, Trezor, Trust Wallet, or WalletConnect, among others.

After 4 years of building infrastructure, we realized that a lot of users have needs for blockchain automation, but there are no clear standards in Web3.

With Mimic Protocol you can automate everything onchain:

-   Create or select the onchain tasks to automate (like swaps, transfers, staking)
-   Set your triggers (onchain events, cron schedules, balance thresholds, and more)
-   Let the protocol take care of the execution

Potential users include devs, protocols, AI agents, DAOs, and financial institutions.

* * *

The biggest win is that people were truly interested in onchain automation and saw the potential of bringing a new standard into Web3. We are very happy with our first event, and will look forward to improving the experience for Devconnect Argentina!

Overall it was a great experience, and we learned a lot. We are more inspired than ever to build, and we are sure onchain automation can help crypto grow, and scale blockchain operations and workflows to the next level.

## Become a Mimic Protocol Alpha Tester!

​If you want to try our automation protocol before it becomes publicly available, simply ****fill out this form:****

[Form here](https://forms.fillout.com/t/bsQfgbMcLPus)

## Our Side Events Experience at EthCC\[8\]

While the main venue is great, full of amazing experiences, the best interactions we had were attending all kinds of side events.

Some of our favorites were DeFi Summer, Builder Nights by Metamask, all 1inch events, rAave, the different sports events, and WalletConnect brunch, among others!

![](https://www.mimic.fi/blog/mimic-ethcc-8-wrap-up-our-time-in-cannes-2025/image.png)

## Learnings From EthCC\[8\] in Cannes

Never stop building: the blockchain space is maturing, and people are becoming more interested in real numbers and revenue-generating projects. The time to build is now.

The vibes are changing. Less talk about memecoins, and speculation, more talk about the real impact of blockchain in the world, and potential use cases of the technology on everyday’s lives.

**Crypto needs onchain automation in order to scale.** Every other industry grew with some sort of automation: agriculture, banking, software. Now it’s time for blockchain automation to grow to the next level. We’re ready to put our builder hats on and to work on solving these problems!

See you next year in Cannes EthCC\[9\]!

![](https://www.mimic.fi/blog/mimic-ethcc-8-wrap-up-our-time-in-cannes-2025/IMG_0551-1.jpg)

---

# Mimic at EthCC 2025: Bringing Onchain Automation to Cannes

> Join Mimic at EthCC 2025 in Cannes, and explore the possibilities of onchain automation in a beautiful location!

Published: 2025-06-29 | Updated: 2026-02-02 | Author: Mimic Engineering Team | Tags: Events | Source: https://www.mimic.fi/blog/mimic-at-ethcc-2025-bringing-onchain-automation-to-cannes-2

![](https://www.mimic.fi/blog/mimic-at-ethcc-2025-bringing-onchain-automation-to-cannes-2/Mimic-EthCC-2025-1.png)

The Mimic team is at Cannes for EthCC 2025! We want to put onchain automation on the map, so we are coming to EthCC this year with a bag full of surprises. Expect cool merch and gifts, great conversations, and our own event: Below the Surface.

We’re opening up blockchain automation for the community with Mimic Protocol, a decentralized automation layer for onchain builders. We’ve been working very hard for the past few years to give Web3 some necessary standards to scale blockchain operations and projects, so we are extremely excited to reveal our progress in public!

EthCC is where it all begins, so let’s explore what we are planning to do, and why it matters. Keep reading to find out how it all started, and what’s coming for Mimic Protocol.

If you are a builder at heart, and onchain automation sounds interesting, join our event on July 3rd here:

![](https://www.mimic.fi/blog/mimic-at-ethcc-2025-bringing-onchain-automation-to-cannes-2/event-one.png)

### The Journey of Mimic

Mimic has been providing blockchain automation solutions since 2021 for top leaders in the space, like 1inch, Balancer, Ledger, Trezor, Trust Wallet, or WalletConnect, among others. To date, we’ve helped them improve their day-to-day task management and significantly reduce the effort required to perform frequent transactions such as collecting, swapping, or bridging assets.

After 4 years of building infrastructure for top players in the space, we had all the pieces to open up the experience to the community, and create a fully decentralized automation protocol.

If you want to explore Mimic’s journey and see everything we have learned so far, we published a blog detailing all of it: [check it out here!](https://www.mimic.fi/blog/the-mimic-automation-story-early-days-to-protocol-design)

### What is Mimic Protocol?

[Mimic Protocol](https://www.mimic.fi/) provides blockchain automation for Web3 builders. Users and devs can create or select the [functions](https://docs.mimic.fi/resources/glossary#function) they want to automate, set their logic, and the protocol handles the rest: execution, security, and reliability.

It’s a decentralized solution to automate any blockchain operations (like swaps, transfers, staking) with different triggers, such as onchain events (even across chains), chronological schedules (times & dates), and other types of custom conditions (like balance thresholds). Users can implement pre-built automation, or code their own custom tasks directly in their apps or backend, offering them flexibility to build and scale exactly what they need.

If you want to learn more, check out our [whitepaper & documentation!](https://www.mimic.fi/whitepaper-and-docs)

### Why Develop an Automation Protocol?

A lot of developers and builders have needs for blockchain automation, but there are no robust solutions in the space, and the community needs Web3 standards. We want to set a new standard for [onchain automation](https://www.mimic.fi/blog/what-is-onchain-automation), creating a great developer experience, growing adoption, and achieving full decentralization, while helping builders integrate automation directly into their apps or backends with minimal effort.

Mimic Protocol is a blockchain automation protocol designed to streamline and secure onchain operations. Web2 already has standards for automation, [we want to bring the same level of scalability to Web3.](https://www.mimic.fi/blog/can-web2-automation-work-in-web3)

### Mimic at EthCC

**Below the Surface Event: Onchain Automation**

Below the Surface is a space to celebrate and empower the builders shaping the future of blockchain, exploring all the possibilities of automation in Web3.

A hands-on gathering for developers, protocol teams, and infra providers to experiment and explore how to scale onchain infrastructure. This is not your average side event: live demos, collaborative workshops, love for blockchain, and conversations that matter.

We will explore some interesting usecases:

-   Fee collector
-   Treasury management (or DeFi strategies)
-   Recurrent payments/ billing
-   Airdropper solution
-   Portfolio rebalancer
-   Account topper
-   Yield aggregator

📍 July 3 | 🕒 3–7 PM CEST

Register here:

![](https://www.mimic.fi/blog/mimic-at-ethcc-2025-bringing-onchain-automation-to-cannes-2/event-one.png)

**Mimic Protocol Live Demo**

We will be presenting the first public demo of Mimic Protocol, the automation layer for onchain builders. We’ve spent the last four years building automation infra under the hood, now it’s time to open it up to the community, and we want you to try it out.

Our technical team will show some cool automation usecases, will be coding tasks live, and will also help the people that want to test out our automation capabilities.

For people attending and participating in the event, we will be giving out some cool gifts, and you will have priority as alpha tester before we launch Mimic Protocol to the public!

**Attending Side-events**

The Mimic team will also be fully immersed into EthCC!

![](https://www.mimic.fi/blog/mimic-at-ethcc-2025-bringing-onchain-automation-to-cannes-2/Mimic_Team.png)

If you want to meet up or discuss onchain automation before the event, reach out:

[Twitter](https://x.com/mimicfi) | [Discord](https://discord.com/invite/qr2ywWuhxe)

### Join us Below the Surface at EthCC!

Our event capacity is limited. Reserve your spot early!

Let’s explore the future of onchain infra, and have a drink while we’re at it!

![](https://www.mimic.fi/blog/mimic-at-ethcc-2025-bringing-onchain-automation-to-cannes-2/event-one.png)

---

# The Mimic Automation Story: Early Days to Protocol Design

> This is Mimic’s journey, a story about turning a whiteboard idea into the automation standard for Web3, and why it matters.

Published: 2025-06-26 | Updated: 2026-02-02 | Author: Mimic Engineering Team | Tags: Mimic Platform | Source: https://www.mimic.fi/blog/the-mimic-automation-story-early-days-to-protocol-design

![](https://www.mimic.fi/blog/the-mimic-automation-story-early-days-to-protocol-design/Mimic-Automation-Story--4-.png)

On June 10th, 2021, three founders sketched out a bold idea on a whiteboard. Four years and $7b in processed value later, our automation has evolved into a flexible protocol that empowers builders to automate a wide variety of blockchain operations.

> This is Mimic’s journey, a story about how we turned a whiteboard idea into the automation standard for Web3, why it matters, and what got us here.

It’s been a path marked by both trial and error and crucial insights. Each version of Mimic taught us new lessons about decentralization, scalability, user experience, and how best to integrate into the broader blockchain ecosystem. This is our quest towards onchain automation.

## Why This Story Matters

This blog post is for anyone curious about Mimic’s origin, evolution, and the hard-earned lessons behind our Protocol. It’s the founder’s-eye view of the product design journey, from MVP hacks to a robust infrastructure serving billions in automated volume. If you're building in Web3 or exploring programmable automation, this one’s for you.

## The Early Days of V1: Structured Strategies in Smart Contracts

In the beginning of 2021, Mimic was built around on-chain strategies that were essentially “recipes” for DeFi operations, each one tightly embedded in its own smart contract. It worked well for specific use cases—like a certain lending-borrowing pattern—because everything was predefined: users only had to plug in a few parameters. But that same rigidity was also its weakness. If you wanted to change a step or tweak a condition, you often needed an entirely new contract deployment. Worse, there was no real scheduling or relayer network; users still had to press the “Execute” button at the right time.

This approach proved that onchain automation could handle repetitive DeFi actions, yet it fell short of being truly automated or flexible. We realized that allowing more dynamic configuration, letting users adapt strategies on the fly, would be critical for scaling.

## Enter v2: Extracting Configurations & Empowering Users

With that lesson in mind, we took a big leap in 2022 with Mimic v2, by breaking out important parameters and configurations from the smart contracts themselves. Instead of a hard-coded sequence of DeFi steps, users could now define elements like token addresses, thresholds, or triggers at runtime, without redeploying everything. We also introduced the concept of relayers to start automating tasks under simple conditions, though we were still figuring out how best to integrate external data sources like price oracles.

This shift taught us a few things. Granting more control is powerful but can easily become inconvenient if every detail has to be set up from scratch. We also learned that robust validation of external data—think “swap only if the price is below X”—would be essential for safe, dynamic triggers. And perhaps most importantly, we saw the real promise of a network of relayers who could take care of executing tasks entirely, removing the need for users to intervene at critical moments.

Ultimately, v2 was a major step toward letting users shape strategies to their needs, but we still lacked a truly modular system for tasks. We also realized we’d need “connectors”—adapters for specific DeFi protocols—to handle the growing complexity of integrations.

## v3 (Present Day): Modular Tasks, Connectors & Relayers

Mimic v3 takes the best of those earlier lessons to create a truly **modular** and **decentralized** automation platform.

### Building Blocks: The Rise of Standardized Tasks

We introduced a library of common DeFi operations (swapping, bridging, lending, borrowing, rebalancing, etc.). Users choose from these tasks like building blocks. Each task is highly configurable, so you can set parameters, triggers, and conditions.

### Connectors: The Key for Protocol Integrations

Instead of hardcoding everything, we use “connectors” as plug-and-play modules to interface with external protocols (like Uniswap, Aave, 1inch, Paraswap, Hop, LiFi, etc). This means tasks remain _extensible_: if a new protocol emerges, we can develop a connector and slot it right in.

### Relayers & Delegation: Automation Without Sacrificing Control

Users can finally delegate the execution of tasks to Mimic relayers, who handle the heavy lifting of sending transactions, monitoring chain states, and verifying oracle data. This architecture also opens up the door for multiple **independent** relayers (think of them as decentralized operators) who compete or cooperate to ensure tasks get done reliably.

### Onchain Security & User Control

All automation logic is enforced on-chain via **smart contracts** that check user-defined conditions. There’s no custodial risk: Mimic never holds your private keys or takes custody of your assets. Everything is validated by the protocol’s smart contracts.

This structure—customizable tasks, modular connectors, and relayer delegation—gives users an **AWS-like** automation experience, but in a trustless and decentralized environment.

## Building the Protocol: Turning Learnings into Architecture

While experimenting with onchain strategies, user-defined configurations, and the initial relayer concepts, we discovered we already had the essential pieces of a truly trustless system, and in 2024 we decided to start building Mimic Protocol, with components such as oracles, relayers, and user safeguards.

But putting them together into a coherent, scalable framework required a new architectural approach. If we wanted Mimic to evolve into a fully decentralized protocol, opening the door to automated and trustless operations across multiple chains, we needed a tech stack that made sense, was elegant, and did not rely on partial solutions or centralized steps.

After key iterations, we designed a system that boiled down to **three core layers**:

### Planning Layer

This is where **functions** are defined, combining oracle inputs, user-defined logic, and triggers. It’s also where relayers first come into play, fetching data and determining whether conditions are met.

### Execution Layer

Once a function is ready to run, it transforms into an **intent** and heads to a decentralized environment where solvers compete to execute it. By letting multiple parties submit proposals, we ensure the best fee/latency combination and avoid single points of failure.

### Security Layer

Finally, a **settler contract** verifies that the solver’s execution meets the original safeguards—things like deadlines, slippage limits, or maximum spending caps. Only then does it finalize the transaction onchain, ensuring funds stay secure and under the user’s control.

Together, these three layers offer a **fully automated** pipeline: from reading real-time data to actually executing and verifying each action on-chain. By adding in economic incentives and staking mechanisms for oracles, relayers, and solvers, we’re buiding a protocol that prioritizes **reliability**, **transparency**, and **user-defined security**—all the lessons we gained from our early explorations in our past versions.

If you are interested in a more technical explanation, here is our [whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) (opens a pdf link).

## What We Learned Along the Way

-   **Modularity Unlocks Scale:** Splitting operations into tasks and connectors avoids the “one strategy = one contract” problem. Users love building custom workflows from standardized building blocks.
-   **User-Centric Configuration:** Letting users tweak parameters in real time was a game-changer. It lowered the barrier to entry and gave non-technical participants more control.
-   **Incentivized Decentralization:** For relayers to be truly decentralized, we needed a staking and slashing mechanism, plus robust oracle/data validation. It took real-world testing to refine these incentives.
-   **Keep the UX as Simple as Possible:** Automation can be complex under the hood, but it shouldn’t feel that way to the user.

## What’s Next?

We’re aiming to create a system where tasks are transparently defined, executed, and settled on-chain, all while giving users granular control over what happens and when.

In short, our ambition is to provide an **open, modular protocol** that anyone can build on, removing the last barriers to full automation for blockchain. By democratizing the tools for scheduling, triggering, and executing onchain tasks, we’re one step closer to a future where users and developers can orchestrate complex operations with ease, all while trusting the integrity of each step.

## Conclusion

Mimic’s evolution hasn’t always been a straight line, but it revealed invaluable lessons at every turn. Each iteration revealed what real-world users truly need: flexibility, transparency, and genuine hands-off automation. Today, we’re turning those lessons into a **decentralized automation protocol**. Yet this is only the beginning. As we complete our decentralized architecture and expand our integration capabilities, Mimic will become even more powerful and user-friendly.

## Join the Mimic Protocol Alpha

As onchain automation continues to transform the way DeFi teams operate, Mimic Protocol is building a new standard in programmable, decentralized execution for Web3.

Alpha testing will start soon! If you're a crypto developer or protocol operator, now’s your chance to get ahead of the curve.

### Get alpha access to Mimic Protocol by clicking below 👇

![](https://www.mimic.fi/blog/the-mimic-automation-story-early-days-to-protocol-design/Group-1547764730.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let automation handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 📄 [Whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# Mimic Fee Collector: Automate Your Onchain Fee Management

> Automate your onchain fee management with Mimic Fee Collector. Consolidate all your fees into a single asset with secure, crosschain automation.

Published: 2025-06-13 | Updated: 2025-06-29 | Author: Mimic Engineering Team | Tags: Fee Collector | Source: https://www.mimic.fi/blog/mimic-fee-collector-automate-your-onchain-fee-management

![](https://www.mimic.fi/blog/mimic-fee-collector-automate-your-onchain-fee-management/1--2-.png)

What happens if you are a Web3 company or protocol generating revenue fees in different tokens, across multiple chains, from thousands of accounts? Fee management becomes incredibly hard.

Manual collection, swapping, bridging, and distributing the fees is time-consuming, error-prone, and expensive. It often costs teams hundreds of hours and exposes them to risks from human error and volatile gas fees. 

To manage revenue fees, many teams build custom scripts or internal tools. While this solves some of the challenges, it introduces new problems, such as relying on private data sources, server-stored keys, and manual intervention through regular maintenance, updating, and testing.

Some projects use centralized solutions, giving them whole ownership of the tokens and full access through the whole process. While this seems practical, it is definitely not DeFi-friendly, and the projects lose control of the funds, adding an extra layer of risk.

Even with skilled devs, internal automation drains valuable time and requires updates with every protocol change. You can’t just “set and forget” fee workflows.

Guess what…? **There’s a better way:** Mimic solution automates onchain fee collection across networks, securely, efficiently, and without sacrificing control.

## Introducing Mimic Fee Collector

A fully automated, secure, and customizable solution trusted by industry leaders like 1inch, Balancer, Ledger, Trezor, Trust Wallet, or Velora, among others.

Projects and protocols can consolidate all their fees into a single asset with crosschain automation. This results in **improved cost efficiency, reduced error risk**, and, most importantly, the **freedom to focus** on strategic decision-making rather than day-to-day operations.

It is an end-to-end solution that collects, swaps, bridges, and withdraws to the designated address(es). You can define your own parameters like frequency, thresholds, and limits to fit your operations cycle.

Mimic Fee Collector includes real-time reporting features that provide structured, actionable data for each step of the process, enabling teams to make informed decisions efficiently. The reporting has been audited by EY, ensuring institutional-grade security and reliability.

The system is constantly checking when the client conditions are met, while being cautious of gas spikes (gas-efficiency), and controlling price against oracles to get a good price. Live across most EVM networks, with full security, customization, and easy integration in mind, all while running 24/7 to execute the conditions whenever possible.

For example, many projects decide to convert all their collected fees into a stable coin like USDC on a single network, for efficiency, cost savings, and also accounting benefits.

## How Does it Work?

Mimic deploys a dedicated environment for each client, ensuring operational efficiency while keeping the system trust-minimized and reliable.

At the core of this architectural framework, the environment enables autonomous operations without interference. This means that users' tasks and components operate autonomously, without colluding or interfering with one another. Our deployment process ensures that different instances running on different chains can seamlessly interact with each other, eliminating the need for users to worry about crosschain interoperability.

There are five main tasks performed automatically in Mimic’s fee collection model:

-   **Collect** from whitelisted wallets/contracts from multiple sources across networks into a smart vault.
-   **Swap** at best prices, using top DEX aggregators with set slippage, thresholds, and gas costs (ie: we do not swap if the cost is above some % of the value being swapped).
-   **Bridge** across networks using protocols like Socket or Circle’s CCTP Bridge.
-   **Withdraw** to any recipient address specified (e.g., DAO multisig or community wallet).

![](https://www.mimic.fi/blog/mimic-fee-collector-automate-your-onchain-fee-management/Group-1547765007.png)

Another key component of the system is the **Splitter:** divides/splits assets according to user-defined percentages. Can be placed at different points in the flow.

Some clients use it at the beginning, others during the swap part and others right before the withdrawal, highlighting the flexibility of this solution, adapting to many different operational needs and on-chain workflows.

Want to to learn more how you can integrate it? [https://www.mimic.fi/fee-collector](https://www.mimic.fi/fee-collector)

## Built for Wallets, DAOs, DEXes, and Beyond

Mimic Fee Collector helps projects automate on-chain revenue workflows. Instead of manually checking balances, swapping tokens, and bridging funds crosschain, Mimic handles it all behind the scenes, based on your rules.

For example, Velora (fka ParaSwap) used to spend hours every month managing protocol fees across seven chains. With Mimic, they now automatically collect and convert fees to wETH, and have custom distribution within the DAO every epoch. No manual work, no missed steps.

DEXes and aggregators use Mimic to make sure fees earned on one chain get swapped and bridged to a preferred chain in the right token, at the right time. Our smart simulations help pick the best moment to execute, saving costs on gas and slippage.

Wallet providers and custodial tools benefit from Mimic’s non-custodial setup. No more hot wallet risks, just secure automation with full control. And because everything is tracked and reported, it’s easier to share updates with your community or auditors. We provide a detailed report at the end of each epoch.

Whether you're running a DAO treasury or managing protocol incentives, Mimic Fee Collector saves you time, cuts costs, and helps you focus on what matters—building.

## Fee Management With Full Customization

Within Mimic’s Fee Collector, users have the freedom to choose the destination chain where they wish to receive their consolidated fees. They can also customize the conditions for any executing bridge tasks based on individual preferences. For instance, users can opt to trigger the tasks once a specific threshold amount is reached on each chain, or they can schedule regular periodic executions.

Additionally, users can pick both the DEX swap and the bridge protocols they trust (from the ones we support), enabling them to bridge assets across protocols that align with their preferences and requirements.

Mimic's solution can be customized to meet each user's requirements by configuring:

1.  Roles and permissions of the parties involved
2.  Whitelisted DEXes and aggregators to execute swaps
3.  Threshold balance for triggering operations
4.  Maximum allowed slippage for swaps
5.  Destination chains to bridge assets
6.  Recipient address to send swapped fees back
7.  Destination token to swap all the fees
8.  Gas price limits per operation
9.  Maximum transaction cost percentage (instead of gas price)

## Secure by Design

Mimic's solution is secure due to its trustless design, smart contract auditing, and robust permission models. Mimic is completely decentralized and non-custodial. Our built-in authentication and permissions system ensures that only authorized accounts can execute specific operations. Our Smart Contracts have been audited by Certora, Verlog, and independent auditors from Open Zeppelin.

## End-to-end Solution & Dedicated Support Every Step of the Way

We work hard to provide a seamless integration experience, working alongside your protocol to ensure the implementation is easy, fast, and as pain-free as possible.

Since we have extensive experience working with Web3 protocols across multiple networks, we have developed a list of best practices that we follow to help you get the most out of your fee management structure!

### How Long Does it Take to Get it up and Running?

After settling the final configuration details, the Mimic team will be fully responsible for setting up the required environment. The entire process should not take longer than a few weeks.

### List of Supported Networks and Aggregators

Active across Ethereum, BNB Chain, Polygon, Optimism, Arbitrum, Gnosis, Avalanche, Fantom, Aurora, Base, zkEVM, Mode, Blast, and Sonic. Coming soon to Solana!

[\[Link to supported Networks\]](https://www.notion.so/Supported-networks-24ef0204dbef4cbeb119273be01092b2?pvs=21)

Works with leading DEX/bridge aggregators:

-   DEXes: 1inch, Velora (formerly ParaSwap), Kyberswap, Odos, Bebop, among others.
-   Bridges: CCTP/Wormhole, Socket, Axelar, Symbiosis, among others.

## Want to Build Your Own Fee Management Tool?

With our upcoming Mimic Protocol you will be able to create your own fee collection solution: [https://docs.mimic.fi/use-cases-and-examples/more-examples/fee-collection](https://docs.mimic.fi/use-cases-and-examples/more-examples/fee-collection)

Mimic Protocol is a modular automation protocol that simplifies developing and scaling blockchain projects for Web3 builders. You can develop your own fee management tool with full control over onchain operations, automation logic, and execution.

You will be able to create your own operations (collect, swap, bridge, withdraw), and set the conditions you want, giving you the flexibility to build your own fee management solution.

Want to learn more? Visit [https://www.mimic.fi/](https://www.mimic.fi/) or read our [whitepaper/docs!](https://www.mimic.fi/whitepaper-and-docs)

## Wondering if Mimic Fee Collector Fits your Flow? Let’s Chat

Whether you're managing a DAO, running a DEX, or just tired of juggling tokens across chains, we’ll help you automate it safely and on your terms.

Mimic's ability to streamline fee collection across multiple chains empowers projects to focus on their core activities while effortlessly consolidating their earnings.

This not only simplifies financial operations but also enhances transparency and efficiency in managing protocol revenues.

Le'ts talk! [https://www.mimic.fi/contact](https://www.mimic.fi/contact)

* * *

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/?utm_source=ghost&utm_medium=blog&utm_campaign=mimic_docs) | 📄 [Whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance) | 🔁 [Fee Collector](https://www.mimic.fi/fee-collector)

---

# Can Web2 Automation Work in Web3?

> Web3 still lacks what Web2 takes for granted: automation. This blog explores how automation should work in crypto, and how Mimic Protocol can make it possible. 

Published: 2025-06-09 | Updated: 2026-02-02 | Author: Mimic Engineering Team | Tags: Onchain Automation | Source: https://www.mimic.fi/blog/can-web2-automation-work-in-web3

![](https://www.mimic.fi/blog/can-web2-automation-work-in-web3/Web2-auto-in-web3.png)

Automation is everywhere: from individuals setting up calendar reminders to massive enterprises integrating, testing, and deploying software changes, **automation powers our digital word**. In Web2, it’s second nature. Tools like Zapier, Slack integrations, Google Scripts, CRMs, accounting platforms, and email marketing suites all come with built-in automation.

Need to send an invoice every 30 days? Want to notify your sales team when a lead reaches a certain score? Auto-deploy new code to production when your tests pass? All of that can be automated in a simple way.

Most operations in traditional finance are also automated:

-   60-75% of all the trading volume in U.S. equity markets is done through algorithmic trading | [Source](https://www.quantifiedstrategies.com/what-percentage-of-trading-is-algorithmic).
-   98% of all CFOs surveyed by McKinsey are investing in finance automation | [Source](https://www.mckinsey.com/capabilities/strategy-and-corporate-finance/our-insights/toward-the-long-term-cfo-perspectives-on-the-future-of-finance#).
-   The network used for electronically moving money between bank accounts across the U.S. processed Over $42 trillion in value in 2024 | [Source](https://www.federalreserve.gov/paymentsystems/fedach_quarterlycomm.htm).

And it’s not just convenience, it’s _critical_. Automation reduces error, saves time, and allows people and teams to scale their operations without constant manual inputs. Whether it’s finance, logistics, software, or customer engagement, automation is how modern systems run.

## But What Happens When You Step into Web3?

Suddenly, all the things we take for granted become difficult. The large number of chains, the cost of execution, and the trustless environment mean that doing something as simple as "send tokens every Monday" is **a whole infrastructure and security challenge**.

So we want to ask in this blog: what would it take for automation to work in Web3? Could those same Web2 automations work in a decentralized space?

It’s clear that not everything will translate the exact same way, because there are major structural differences between traditional tech stacks and blockchain, but the use cases can be adapted.

Let’s explore some Web2 use cases and their potential counterparts in Web3!

## Case Studies in Automation: From Web2 to Web3 With Mimic Protocol

### Scheduled Payrolls

#### Web2

Automating recurring salary payments and bonuses are streamlined in Web2. Services like Gusto, Deel, or ADP handle everything: they pull the funds from the company account, convert currencies if needed, apply tax rules, and distribute salaries or bonuses to teams, often across time zones or countries (although global payments are a different topic).

#### Web3

If you want to automate payrolls in Web3, you need to take into consideration the distribution of funds to multisigs, or predefined wallets. Imagine you’re a DAO or a DeFi protocol with contributors or stakeholders across chains. You’ve got revenue coming in on Arbitrum, treasury assets held on Ethereum, and payments due to contributors in USDC on Polygon, and maybe one core contributor only accepts wETH. There’s volatility in token prices, slippage on swaps, and bridge delays to consider.

#### Scheduled Payrolls With Mimic Protocol

Mimic Protocol enables you to encode your payroll logic once, and let automation handle the rest, with full visibility and control. Here’s what the flow could look like:

1.  Collect Function: automatically collect earnings from deployed contracts or payroll wallet addresses.
2.  Swap Function: if contributors are paid in stablecoins (USDC, DAI), the Protocol can convert volatile tokens (e.g., AAVE, BAL) into stable assets, or convert to their token of choice.
3.  Bridge Function: bridge assets from the treasury vault (e.g., on Ethereum) to contributor destination chains (e.g., Polygon).
4.  Withdraw Function: Once assets are in place, funds are automatically distributed to each contributor or multisig, following the rules you define (e.g., every 30 days).

This is just one way to build a scheduled payroll system. Since everything can be encoded onchain, you could set up this solution to adapt to your specific operations.

### Currency Conversions

#### Web2

Automated foreign exchange (FX) has become a standard feature in tools like Wise, Revolut, and even corporate finance systems. Want to convert EUR to USD every Friday at 9am, or auto-swap only if the rate drops below 1.05? It is possible.

Behind the scenes, these tools shield users from volatility by batching conversions, alerting them to unfavorable conditions, and avoiding execution during spikes in transaction fees or rate spread. All this creates a sense of reliability and predictability, even in the unpredictable world of currency markets.

#### Web3

In Web3, the same need exists, but it's significantly harder to fulfill. Protocols, DAOs, and yield strategies often earn fees or rewards in volatile governance tokens (like AAVE, BAL, UNI, or COMP). While these assets are useful within their ecosystems, they aren’t ideal for stable operations or payouts. Teams typically want to convert them into stablecoins like USDC or DAI, which serve as a more dependable base for:

-   Contributor payments
-   DAO treasury allocations
-   Grant funding
-   Revenue recognition

But unlike in Web2, there's no bank API here, just DEXs, gas fees, and slippage. And timing matters.

#### Token Conversions With Mimic Protocol

Mimic Protocol enables onchain rules-based token swaps that work just like FX automation, but built for the decentralized, multi-chain world. You can define logic such as: “If my AAVE balance exceeds $3,000, swap to USDC using a DEX aggregator, but only if slippage is under 0.5% and gas is below 100 gwei.” Or, schedule recurring swaps: “Convert UNI to DAI every Monday at noon.” You retain full control over parameters like timing, gas limits, slippage tolerance, and allowed aggregators, all enforced onchain.

With different types of triggers supported, like chronological (time & date), event based (onchain actions or oracle prices), or custom thresholds, you can create token conversion workflows for different use cases, depending on what you want to achieve.

### Portfolio Rebalancing

#### Web2

In traditional finance, investment platforms like Wealthfront, Betterment, or Schwab Intelligent Portfolios offer automated portfolio rebalancing. Users define a target allocation — say, 60% stocks, 30% bonds, 10% cash — and the system automatically adjusts their holdings when the actual mix drifts too far from the target due to market movements.

This kind of automation removes emotion from investing, maintains long-term strategy, and saves investors from tedious manual intervention. These services custody user assets and have centralized authority to move funds freely within the platform. Users trust the system to do what’s right, and the system handles all trades, taxes, and timing behind the scenes.

#### Web3

In Web3, portfolio rebalancing is just as important, especially for DAOs, treasuries, or yield strategies trying to maintain specific allocations between volatile and stable assets. But the environment is radically different:

-   Assets are self-custodied in multisigs or Smart Contracts.
-   Rebalancing means manual swaps, bridging, and tracking across multiple chains.
-   Every action costs gas, introduces slippage, and requires precise timing.

Several centralized exchanges (CEXes) and related platforms do offer portfolio rebalancing options, though typically with varying levels of automation, control, and asset availability compared to traditional robo-advisors, not to mention relying on a fully centralized system.

#### Portfolio Rebalancing With Mimic Protocol

With Mimic Protocol, anyone can set up a fully automated portfolio rebalancing system tailored to their on-chain strategy. No spreadsheets, no manual swaps, no middlemen. Users define their ideal asset allocation and configure conditions for rebalancing, whether it's based on time (e.g., every Monday) or thresholds (e.g., when ETH exceeds 60% of the portfolio). Mimic Protocol makes it easy to enforce rules like slippage limits, gas price ceilings, and preferred DEX routes, ensuring swaps only execute under favorable conditions.

Building your own rebalancing system with Mimic makes sense because you control the keys, not a centralized exchange. You gain access to a wider range of assets beyond what CEXes support, can trigger actions based on real-time on-chain conditions, and operate across multiple networks, all without sacrificing transparency or self-custody.

You can read our guide about portfolio rebalancing here: [https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens](https://www.mimic.fi/blog/rebalance-a-wallet-portfolio-with-mimic-protocol-usd-targets-3-tokens)

### When This Happens, Do That Automation

#### Web2

Zapier, IFTTT, [Make.com](http://make.com/), n8n, and other platforms have made automation accessible to anyone. With a few clicks, users can set up workflows like:

-   "When someone submits a form, send a Slack message."
-   "Every Friday, export sales data from Shopify to Google Sheets."
-   "If a tweet mentions our brand, create a support ticket."

These tools let businesses and creators connect services, respond to events, and automate operations, all without writing code. They abstract away the infrastructure and provide confidence that workflows just work reliably, quietly, in the background.

#### Web3

Web3 lacks a native automation layer. There’s no “connect your wallet and trigger this task if balance exceeds X” interface. Every action — swaps, bridges, wrapping, rebalances — needs to be executed manually, coded into custom smart contracts, or programmed through internal tooling.

Even basic workflows require manual steps, multisig coordination, and real-time market awareness. Add volatility, gas fees, and multi-chain fragmentation, and suddenly a "simple" automation becomes a full-time job.

#### Endless Possibilities With Mimic Protocol

Mimic Protocol simplifies that process, making onchain automation programmable, secure, and fully customizable. It allows anyone to build powerful workflows that react to real-time blockchain conditions, like swapping tokens when treasury balances grow, bridging assets during low gas periods, or sending scheduled payouts to contributors.

Every automation is fully defined by the user: what should happen, when it should happen, and under which conditions it’s allowed to execute. Whether you're managing a DAO, automating treasury operations, or building advanced DeFi infrastructure, Mimic gives you the tools to scale safely, with full decentralization & control, and across chains.

## About Mimic Protocol

At Mimic, we are building a crosschain automation protocol to simplify the way users build and scale blockchain projects. Mimic Protocol allows developers to define their rules, pick the tasks they want to automate, while the platform handles execution, offering full control over blockchain operations. Mimic enables teams to focus on innovation while the protocol ensures precision, efficiency, and trustless automation.

You can read the Mimic Protocol [whitepaper here](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) (pdf will open up).

## Join the Mimic Protocol Waitlist

As onchain automation continues to transform the way crypto teams operate, Mimic Protocol is paving the way for a new standard in programmable, decentralized execution.

Beta testing is starting soon. If you're a crypto developer or protocol operator, now’s your chance to get ahead of the curve.

**Get early access to Mimic Protocol by clicking below 👇**

![](https://www.mimic.fi/blog/can-web2-automation-work-in-web3/Group-1547764730.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let automation handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/?utm_source=ghost&utm_medium=blog&utm_campaign=mimic_docs) | 📄 [Whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# Challenges of Manual Transactions in Crypto

> Crypto promised full control, but it also brought a lot of manual transactions. Let's explore the challenges of manual txs and how onchain automation can help!

Published: 2025-05-29 | Updated: 2025-06-29 | Author: Mimic Engineering Team | Tags: Onchain Automation | Source: https://www.mimic.fi/blog/challenges-of-manual-transactions-in-crypto

![](https://www.mimic.fi/blog/challenges-of-manual-transactions-in-crypto/Challenges-of-manual-txs-blog-rectangle.png)

Welcome to a new educational blog post where we explore the challenges of manual transactions for users and developers in crypto, and how onchain automation is the key for better user experience.

At Mimic, we are creating automation tools to simplify the way people code, execute, and scale blockchain projects. We want to share all our insights around exciting Web3 topics, and start setting the context of Mimic Protocol, our new decentralized automation layer, ahead of its public launch.

The early promise of crypto was ambitious: reduce reliance on traditional financial intermediaries and give users full control over their money.

Crypto has evolved a lot over the years, and the future is looking very promising. However, as anyone who’s handled manual crypto transactions knows, this promise of full control has come with a cost, notably in terms of user experience, both for developers and general public.

From Bitcoin’s early days to today’s complex and constantly changing space, manual transactions present a unique set of challenges, especially when it comes to crosschain ecosystems. Let’s break them down!

## Early Web3 Days and the UX Dilemma

When Bitcoin was created, sending a crypto transaction meant more than just entering an address and clicking “send”. It involved multiple steps, and a deeper understanding of transaction fees, confirmation times, and wallet management.

Compared to traditional banking, or even online payment services (like PayPal or Venmo), where a user could send money in seconds with minimal effort, Bitcoin’s manual process was more complex for the average user. Thus in the beginning it attracted mainly tech enthusiasts and developers that saw the promise of a purely decentralized and digital currency.

The first ever Bitcoin wallet, [Bitcoin Core](https://en.wikipedia.org/wiki/Bitcoin_Core), was created by Satoshi Nakamoto himself:

![](https://www.mimic.fi/blog/challenges-of-manual-transactions-in-crypto/image.png)

### Smart Contracts and the Explosion of Manual Transactions

Ethereum introduced the idea of adding code into the blockchain directly, allowing smart contracts and decentralized applications (dApps) to run inside the network. But this also introduced a layer of complexity. Each interaction with a smart contract (like staking, lending, or providing liquidity) became a manual transaction.

While smart contracts allowed new use cases for crypto, including DeFi, they were limited in terms of execution. Someone or something must call the smart contract with a transaction. This caused an exponential increase in the number of transactions users needed to handle.

### UX Issues in The Beginning of Web3:

-   **Complex Fee Management**: users had to manually set transaction fees, risking delays or overpayments.
-   **Address Management**: long, unintuitive addresses led to frequent mistakes.
-   **Confirmation Anxiety**: waiting for network confirmations was a new experience.
-   **Multiple Steps**: a single DeFi action often requires 3-5 manual confirmations.
-   **Gas Fees**: constantly fluctuating, requiring manual adjustments.
-   **Wallet Fatigue**: users had to sign dozens of transactions daily, leading to errors and frustration.

<video src="https://www.mimic.fi/blog/challenges-of-manual-transactions-in-crypto/high-heels-heels-on-ice--1-.mp4" autoPlay loop muted playsInline />

## Crosschain Protocols: Another Layer of Complexity

At the current stage of crypto, most protocols enable interactions across multiple blockchains, like Ethereum, Solana, or BNB Chain. While this expands the possibilities, it also increases the number of manual transactions required to interact on this level. The crypto landscape is more fragmented than ever, with new networks appearing constantly.

### Cross-Chain Challenges:

-   **Multiple Wallets**: managing assets across different chains.
-   **Bridge Risks**: manually bridging tokens introduces both complexity and security risks.
-   **Synchronization Issues**: keeping track of assets on various chains requires constant attention.

## Manual Transactions for Users

Performing some basic onchain operations (like swaps or token transfers) manually once or twice seems manageable, but the situation changes when scale comes into play. What happens when you need to execute thousands of transactions, on multiple blockchains?

Suddenly, what was a simple task becomes a burden. A time-consuming and error-prone situation. Crosschain operations require users to manage assets, fees, and risks across different networks, while manually confirming each step. This level of manual interaction is simply unsustainable as the crypto ecosystem grows.

Here is a list of some of the main problems with manual transacting in crypto:

-   **Human error:** entering the wrong addresses, miscalculating gas fees, or confirming the wrong transaction are common. There's no "undo" in blockchain.
-   **Time-consuming:** each transaction needs careful review, especially when interacting with smart contracts. Time adds up quickly when every action is manual.
-   **Non-scalable:** at some point manual transactions don’t scale. A power user handling a lot of transactions daily will encounter a bottleneck to grow.
-   **Cost inefficiency:** mistakes, delays, or bad timing can lead to wasted gas fees, lost funds, or missed opportunities in the market.
-   **Tedious & repetitive:** clicking “confirm” over and over is not fun. It’s also a poor use of time for users.
-   **Security risks:** manual processes increase the chance of falling for phishing, malicious contracts, or simply making costly mistakes.

<video src="https://www.mimic.fi/blog/challenges-of-manual-transactions-in-crypto/mood-help.mp4" autoPlay loop muted playsInline />

## Manual Transactions for Developers

There are a lot of developers building their own custom solutions to tackle manual transactions, but sometimes they can become a serious bottleneck:

### Scripting Solutions

To manage repetitive tasks like token transfers or smart contract interactions, many devs resort to writing custom scripts. While these can offer short-term relief, they demand constant maintenance, rigorous testing, and carry the risk of introducing new vulnerabilities.

### Internal Tools

Larger teams might build internal tools or dashboards to streamline transaction handling, but these solutions divert valuable time away from actual innovation and product development. The more time developers spend on manual processes, the less they can focus on improving protocols, deploying new contracts, or enhancing user experience. Worse still, these ad-hoc solutions often rely on private data sources, server-stored keys, and manual intervention—introducing points of failure and security risks.

### Manual Operations in Smart Contract Development

Time spent handling manual processes means less time writing code. Devs often delay pushing updates or deploying contracts due to the overhead of managing transactions manually, such as confirming execution states, or monitoring gas prices manually.

On the other hand, developing smart contracts is complex. The process requires a precise understanding of blockchain behavior, gas optimization, contract security, and integration across different protocols. If you add the need for constant manual intervention, such as crafting custom scripts for recurring tasks, checking for execution triggers, or rebalancing assets across chains, developers face increased mental workload and operational risk.

### Increase of Crosschain Protocols

The rise of crosschain protocols has opened new possibilities for DeFi, but it has also added significant complexity for developers. Integrating multiple networks means dealing with different token standards, bridging mechanisms, and network-specific issues. Each chain has its own tooling, gas fee dynamics, and transaction confirmation processes, requiring developers to work on multiple environments at the same time.

Manual operations across chains amplify this challenge. Developers must monitor and execute transactions on different timelines, ensure asset security during bridges, and handle network-specific errors, all of which increase the risk of mistakes and slow down workflows.

## Onchain Automation is the Future of Crypto Operations

Smart contracts and dealing with onchain assets is a high-stakes environment, where any small error can put funds at risk. Incorrectly calculated slippage, forgotten transaction parameters, or errors in private key management can threaten the security of blockchain projects.

Additionally, these manual workflows often rely on private, centralized data sources and infrastructure (like server-stored keys), introducing single points of failure and undermining the decentralized nature of blockchain systems. Without onchain automation tools, many teams build scripts that are difficult to program and maintain, lacking the flexibility, scalability, and security needed for robust DeFi operations.

As blockchain technology evolves, automation, batch processing, and smart UX layers will be critical. Developers and users alike need tools that reduce friction, eliminate manual bottlenecks, and allow the ecosystem to scale securely and efficiently.

Interested in learning more about onchain automation? Read [our blog here](https://www.mimic.fi/blog/what-is-onchain-automation).

At Mimic, we are building a crosschain automation protocol to simplify the way users build and scale blockchain projects. Mimic Protocol allows developers to define their rules, pick the tasks they want to automate, while the platform handles execution, offering full control over blockchain operations. Mimic enables teams to focus on innovation while the protocol ensures precision, efficiency, and trustless automation.

You can read the Mimic Protocol [whitepaper here](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) (pdf will open up).

# Join the Mimic Protocol Waitlist

As onchain automation continues to transform the way DeFi teams operate, Mimic Protocol is paving the way for a new standard in programmable, decentralized execution.

Beta testing is starting soon. If you're a crypto developer or protocol operator, now’s your chance to get ahead of the curve.

**Get early access to Mimic Protocol by clicking below 👇**

![](https://www.mimic.fi/blog/challenges-of-manual-transactions-in-crypto/Group-1547764730.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let automation handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/?utm_source=ghost&utm_medium=blog&utm_campaign=mimic_docs) | 📄 [Whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---

# What is Onchain Automation?

> Onchain automation is the use of smart contracts to automate actions directly on a blockchain when specific conditions are met, reducing the need for manual inputs or offchain actions.

Published: 2025-04-17 | Updated: 2026-02-02 | Author: Mimic Engineering Team | Tags: Onchain Automation | Source: https://www.mimic.fi/blog/what-is-onchain-automation

![](https://www.mimic.fi/blog/what-is-onchain-automation/01-Cover--4--3.png)

Welcome to the first blog of a series of educational posts around exciting Web3 topics. At Mimic, we are blockchain infrastructure providers, and we are passionate about moving the crypto industry forward. We believe that there is a heavy reliance on manual processes and transactions in Web3, and we are creating automation tools to simplify the way people code, execute, and scale blockchain projects. 

The goal of these blog posts is to share knowledge on key Web3 concepts, such as onchain automation, intents, crosschain, smart contract execution, or chain abstraction. From our years of experience building automation infrastructure for leading DeFi projects, we want to share all our insights around exciting blockchain topics, and start setting the context of Mimic Protocol, our new decentralized automation layer, ahead of its public launch.

### So, what is onchain automation?

Onchain automation is the use of smart contracts and decentralized protocols to automate tasks, actions, or workflows directly on a blockchain when specific conditions are met, eliminating the need for manual inputs or offchain intervention.

In this blog, we will explore how automation is already helping Web2 industries, why it is needed in Web3, and some approaches to solving the current challenges in executing smart contract functions. We will also provide a brief overview of the Mimic Protocol.  _Sounds interesting? Let’s dive right in!_

## The Web2 World is Already Automated

Automation has been essential for the growth of many different industries, enabling tasks to be performed with greater efficiency, accuracy, and scalability. 

For example, in Web2, the finance, agriculture, energy, software, retail, and logistics sectors have integrated automated systems to improve operations and enhance productivity.  In agriculture, automated machinery and irrigation systems have revolutionized farming practices, while automation in logistics, tracking, and transportation systems has massively improved supply chain management. 

Automation plays a crucial role in processing transactions, managing accounts, and facilitating different trading activities in finance. The majority of financial transactions are now automated:

-   60-75% of all the trading volume in U.S. equity markets is done through algorithmic trading | [Source](https://www.quantifiedstrategies.com/what-percentage-of-trading-is-algorithmic).
-   98% of all CFOs surveyed by McKinsey are investing in finance automation | [Source](https://www.mckinsey.com/capabilities/strategy-and-corporate-finance/our-insights/toward-the-long-term-cfo-perspectives-on-the-future-of-finance#).
-   The network used for electronically moving money between bank accounts across the U.S. processed Over $42 trillion in value in 2024 | [Source](https://www.federalreserve.gov/paymentsystems/fedach_quarterlycomm.htm). 

These trends underscore a broader movement towards automation in the financial sector, driven by the need for efficiency, scalability, and enhanced customer experiences.

## Web3 Needs Automation to Grow

Although other industries understand the value of automation, there are still many processes being done manually in Web3. For example, a simple action like sending an ERC20 token from one wallet to another involves:

-   Opening and unlocking a wallet. 
-   Choosing the correct network. 
-   Clicking on send.
-   Entering the recipient address. 
-   Selecting the asset and amount.
-   Setting the transaction fee. 
-   Double-checking all the details (once a transaction is sent it can’t be reversed).
-   Approving the spending. 
-   Executing the transaction. 

At first, handling a few onchain transactions manually doesn’t seem so bad. Still, once the operations multiply (thousands of transactions across multiple chains, triggered by real-time onchain or offchain events), the cracks start to show:

-   Time-consuming custom scripts
-   Fragile cron jobs and bots
-   Increased risk of human error
-   High operational overhead
-   Poor scalability

<video src="https://www.mimic.fi/blog/what-is-onchain-automation/this-is.mp4" autoPlay loop muted playsInline />

Whether building a DeFi protocol, a DAO treasury, or a crosschain app, developers are likely to be involved in many different onchain tasks, such as token swaps, fee distributions, asset bridging, and more, while trying to keep up with shifting market conditions and growing infrastructure demands. 

Smart contracts added a new wave of use cases to blockchain networks, but they can’t self-execute any functions. Someone needs to call the contract with a transaction in order for the smart contract to execute any actions. 

Given this, if we want to reach the next billion users, we must abandon processes that don’t scale, and it is certain that manual transactions don’t scale well. In traditional tech stacks, we rely on automated pipelines and scheduled tasks. **Why should blockchain be any different?** 

Yet, many recurring tasks in blockchain still require human intervention (e.g., manually executing scripts, monitoring market conditions, or toggling smart contracts). This approach limits Web3’s potential because manual effort is prone to error, delay, and unpredictability.

_History shows a few attempts to introduce standardized automation, but none gave developers full flexibility in creating complex workflows._ 

## Brief History of Blockchain Automation

Smart contracts are often compared to “unstoppable programs” on the blockchain, but one thing they cannot accomplish independently is scheduling future actions. In other words, a contract won’t automatically execute a function at a specific time or when a certain condition is fulfilled. **Someone or something must trigger it with a transaction.** 

Initially, this required developers or users to run external scripts (bots) to invoke smart contract functions on a schedule. This approach was inconvenient and created central points of failure. 

Thus the demand for reliable onchain automation (crypto cron jobs) was born, and over the years several projects have tackled the challenge with different solutions. 

### Ethereum Alarm Clock (2015–2019)

One of the earliest attempts at on-chain automation, Ethereum Alarm Clock, allowed users to schedule transactions for future execution. It enabled users to deposit ETH and specify a time window and call function. However, it never achieved widespread adoption due to costs, complexity, and the lack of incentives for executors ("TimeNodes”). 

You can access the [documentation](https://ethereum-alarm-clock.readthedocs.io/en/latest) and [GitHub](https://github.com/ethereum-alarm-clock/ethereum-alarm-clock) pages (which are no longer actively maintained) to learn more about it.

### Keep3r Network (2020)

Launched by Yearn founder Andre Cronje, [Keep3r Network](https://keep3r.network/) introduced a decentralized job board where projects list tasks (like harvesting yield), and independent bots called keepers execute them for KP3R token rewards. The system is fully permissionless—anyone can become a keeper by bonding KP3R—and has been used in protocols like Yearn and Fixed Forex. Its focus is on decentralizing DevOps for DeFi protocols.

### Gelato Network (2020)

[Gelato](https://www.gelato.network/web3-functions) adopted a more developer-friendly approach by offering “automation as a service.” Developers can define tasks (e.g., "run this function every hour" or "when a price hits X") using resolvers or time-based triggers, while Gelato’s decentralized network of bots manages the rest. It minimizes the need to maintain your own infrastructure. The service is utilized across hundreds of DeFi, NFTs, and gaming applications, including projects like Aavegotchi and Beefy Finance. 

### OpenZeppelin Defender (2020)

Created by the team behind the most widely used smart contract libraries, [OpenZeppelin Defender](https://www.openzeppelin.com/defender) provided secure, production-ready automation for Ethereum and EVM chains. It includes a suite of tools—Relayers, Autotasks, Sentinels, and Admin—designed for managing smart contracts and automating on-chain operations. Developers can write lightweight scripts (Autotasks) that trigger time-based schedules or smart contract events, executing them through secure relayers. While not fully decentralized, Defender emphasizes security, auditability, and developer experience, making it a favorite among DAOs and protocols like Compound, Optimism, and Gnosis. Recently they have announced that their Relayers and Monitor tools are [now open source](https://blog.openzeppelin.com/monitor-and-relayers-are-now-open-source).

### Chainlink Automation (2021)

Formerly known as Chainlink Keepers, [Chainlink Automation](https://chain.link/automation) brought the reliability of Chainlink’s oracle network to automation. 

Developers register an “upkeep” and write a checkUpkeep() function that Chainlink nodes monitor. When the conditions are met, Chainlink performs the task using its decentralized network of trusted nodes. This system is ideal for critical, high-value operations and is utilized by protocols such as Aave, Synthetix, and PoolTogether.

* * *

Each solution demonstrated the growth of Web3’s infrastructure, evolving from basic scheduled calls to comprehensive decentralized automation networks. Collectively, they empower smart contracts to operate independently, eliminating the need for centralized cron jobs.

## Moving Onchain Automation Forward With Mimic Protocol

We are solving the on-chain automation challenge by creating an open, flexible, and programmable [automation layer](https://docs.mimic.fi/).

Since 2021, Mimic has provided automation solutions for major DeFi leaders, including 1inch, Balancer, Ledger, Trezor, Trust Wallet, and WalletConnect. After three years of developing automation for top players in the industry, we are now opening our infrastructure to anyone seeking to elevate their projects to the next level. We aim to assist developers and protocols in scheduling and executing any onchain tasks based on custom conditions, as we recognize that each project requires a unique solution.

Mimic Protocol introduces a new infrastructure that simplifies how you code and scale blockchain projects across different chains. It enables you to [program functions](https://docs.mimic.fi/examples/build-a-simple-function) within your app or directly from your backend and utilize audited and pre-built smart contract functions that can be executed according to the logic you set. 

This logic can range from simple triggers, such as dates and times, to complex automation that depends on onchain and offchain events, balance thresholds, and more. As infrastructure providers, the tools we create should be practical and fully customizable.

There are a number of small actions that can be automated, serving as building blocks to scale your applications (like swap, wrap, or bridge). We want to help developers create music: we provide the notes so you can write the songs. 

We will delve deeper into how it works in more detail in the near future, but for now, we want to share that the Mimic Protocol consists of [three core layers](https://docs.mimic.fi/developers/architecture): the Planning Layer, the Execution Layer, and the Security Layer. Each layer involves key actors and components collaborating to ensure deterministic task execution, reliable intent handling, and robust security for all user operations.

> **If you are interested in a more technical explanation, here is our** [**whitepaper**](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) **(opens a pdf link).**

## Benefits of Onchain Automation

As DeFi ecosystems become increasingly complex and inherently multichain, onchain automation has emerged as an excellent tool for scaling operations and doing so securely, efficiently, and without human error.

### Key Benefits of Onchain Automation

Onchain automation leverages smart contracts to eliminate the inefficiencies that slow down financial workflows. Here’s what it brings to the table:

-   **Efficiency Without Middlemen:** Smart contracts can automatically handle tasks like rebalancing, swaps, or distributions, reducing costs and saving time.
-   **24/7 Uptime:** Tasks run continuously, even while you sleep. No human oversight is needed.
-   **Trustless Execution:** Code is law; actions follow logic exactly as written, supported by cryptographic proof.
-   **Reduced Risk of Human Error:** Deterministic logic eliminates manual steps, ensuring consistent outcomes.
-   **Scalability for Complex Operations:** Multi-chain treasury management? DAO workflows? Automation manages it all without requiring additional manpower.
-   **Transparency & Auditability:** Every execution is recorded onchain for complete traceability.

### Why Mimic Protocol Sets a New Standard

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcfEbu8_WLia76kR8B450zhgTtCDFUc2xHnMGCP8_AmVAo2z5E-566KmLHfiuFPu2-6oZTLBXi9VcQz9jksuvVAHXKqzxS_HvrudZPcU9qYlELvr5GuHK9ZVthaDNLIWzdw5zqv?key=fyLvT-ZRhJwnQtZ2ZM33ljJh)

While the benefits mentioned above apply broadly, Mimic Protocol elevates onchain automation with its modular & decentralized infrastructure, and unmatched customization:

-   **Decentralized & Secure Execution:** A global network of relayers, solvers, and oracle verifiers ensures fault tolerance and safe automation without centralized risks.
-   **Full Customization:** Each developer can select the components that best suit their needs, with hundreds of configurable parameters, from token lists and gas limits to custom slippage thresholds.
-   **Crosschain Power:** Mimic Protocol operates seamlessly across 15+ chains.
-   **Onchain & Offchain Simulation:** Optimize gas and swap prices with real-time market simulations prior to every execution.
-   **Automation with Intents:** define tasks, which describe 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).
-   **User-defined Safeguards:** a settler verifies that everything was done correctly, ensures that user-defined restrictions are respected, and finalizes the transaction outcome.

# Join the Mimic Protocol Waitlist

As onchain automation continues to transform the way DeFi teams operate, Mimic Protocol is paving the way for a new standard in programmable, decentralized execution. 

Beta testing is starting soon. If you're a crypto developer or protocol operator, now’s your chance to get ahead of the curve.

### Get early access to Mimic Protocol by clicking below 👇

![](https://www.mimic.fi/blog/what-is-onchain-automation/Group-1547764730-1.svg)

Start simplifying how you code, execute, and scale blockchain projects. **Let automation handle the busy work while you focus on building.**

🐦 [X (Twitter)](https://x.com/mimicfi) | 📚 [Documentation](https://docs.mimic.fi/) | 📄 [Whitepaper](https://www.mimic.fi/documents/Mimic_Protocol_Whitepaper.pdf) | 💬 [Discord](https://discord.com/invite/qr2ywWuhxe) | 🌐 [Website](https://www.mimic.fi/) | 🌀 [Farcaster](https://farcaster.xyz/mimicfi) | 💼 [LinkedIn](https://www.linkedin.com/company/mimic-finance)

---