Migration Guide: From Gelato Web3 Functions to Mimic

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

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

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}`>
    );
  });

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')
}