add dynamic call example

Author: PedroAraoz

examples/15-simple-dynamic-call/.gitignore

@@ -0,0 +1,4 @@
+node_modules
+build
+types
+scripts/.env

examples/15-simple-dynamic-call/.mocharc.json

@@ -0,0 +1,3 @@
+{
+  "node-option": ["import=tsx/esm"]
+}

examples/15-simple-dynamic-call/.npmrc

@@ -0,0 +1,2 @@
+node-linker=hoisted
+legacy-peer-deps=true

examples/15-simple-dynamic-call/eslint.config.mjs

@@ -0,0 +1,108 @@
+import eslintPluginTypeScript from "@typescript-eslint/eslint-plugin"
+import eslintParserTypeScript from "@typescript-eslint/parser"
+import eslintPluginImport from "eslint-plugin-import"
+import eslintPluginSimpleImportSort from "eslint-plugin-simple-import-sort"
+import eslintConfigPrettier from "eslint-config-prettier"
+import eslintPluginPrettier from "eslint-plugin-prettier"
+
+export default [
+  {
+    ignores: ["node_modules/**", "**/dist/**", "**/build/**", "**/.prettierrc.*", "./src/types/**"]
+  },
+  {
+    files: ["**/*.{ts,tsx}"],
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parser: eslintParserTypeScript,
+      parserOptions: {
+        project: "./tsconfig.json"
+      }
+    },
+    plugins: {
+      "@typescript-eslint": eslintPluginTypeScript,
+      prettier: eslintPluginPrettier,
+      import: eslintPluginImport,
+      "simple-import-sort": eslintPluginSimpleImportSort
+    },
+    rules: {
+      ...eslintPluginTypeScript.configs.recommended.rules,
+      "@typescript-eslint/no-namespace": "off",
+      "@typescript-eslint/no-unused-vars": ["error"],
+      "@typescript-eslint/explicit-function-return-type": "error",
+      "@typescript-eslint/no-explicit-any": "error",
+      
+      "prettier/prettier": [
+        "error",
+        {
+          "semi": false,
+          "singleQuote": true,
+          "trailingComma": "es5",
+          "arrowParens": "always",
+          "bracketSpacing": true,
+          "printWidth": 120,
+          "tabWidth": 2,
+          "useTabs": false
+        }
+      ],
+      
+      "simple-import-sort/imports": [
+        "error",
+        {
+          groups: [
+            ["^@?\\w"],
+            ["^\\.\\.(?!/?$)", "^\\.\\./?$"],
+            ["^\\./(?=.*/)(?!/?$)", "^\\.(?!/?$)", "^\\./?$"]
+          ]
+        }
+      ],
+      "simple-import-sort/exports": "error",
+      
+      "comma-spacing": ["error", { before: false, after: true }],
+      "no-multiple-empty-lines": ["error", { max: 1, maxEOF: 1 }]
+    },
+    settings: {
+      "import/resolver": {
+        typescript: {
+          alwaysTryTypes: true,
+          project: "./tsconfig.json"
+        }
+      }
+    }
+  },
+  // configuration for test files
+  {
+    files: ["tests/**/*.{ts,tsx}", "**/*.spec.{ts,tsx}", "**/*.test.{ts,tsx}"],
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parser: eslintParserTypeScript,
+      parserOptions: {
+        project: "./tests/tsconfig.json"
+      }
+    },
+    rules: {
+      "@typescript-eslint/no-unused-expressions": "off"
+    }
+  },
+  {
+    files: ["scripts/**/*.{ts,tsx}"],
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parser: eslintParserTypeScript,
+      parserOptions: {
+        project: "./scripts/tsconfig.json"
+      }
+    },
+    settings: {
+      "import/resolver": {
+        typescript: {
+          alwaysTryTypes: true,
+          project: "./scripts/tsconfig.json"
+        }
+      }
+    }
+  },
+  eslintConfigPrettier
+]

examples/15-simple-dynamic-call/manifest.yaml

@@ -0,0 +1,12 @@
+version: 1.0.0
+name: Swap + Dynamic Call Function
+description: Use swap outputs as dynamic call inputs
+inputs:
+  - tokenIn: address
+  - tokenOut: address
+  - chainId: uint32
+  - amount: string          # e.g., '20.5' = 20.5 of the given token
+  - slippageBps: uint16     # e.g., 50 = 0.50%
+  - smartAccount: address
+  - recipient: address
+  - maxFeeUsd: string       # e.g., '0.01' = 0.01 USD

examples/15-simple-dynamic-call/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "mimic-function",
+  "version": "0.0.1",
+  "license": "Unlicensed",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "deploy": "mimic deploy",
+    "build": "mimic build",
+    "codegen": "mimic codegen",
+    "compile": "mimic compile",
+    "test": "mimic test",
+    "lint": "eslint ."
+  },
+  "devDependencies": {
+    "@mimicprotocol/cli": "1.0.0",
+    "@mimicprotocol/lib-ts": "0.1.0",
+    "@mimicprotocol/sdk": "0.1.0",
+    "@mimicprotocol/test-ts": "0.1.0",
+    "@types/chai": "^5.2.2",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.10.5",
+    "assemblyscript": "0.27.36",
+    "chai": "^4.3.7",
+    "dotenv": "^17.2.3",
+    "eslint": "^9.10.0",
+    "json-as": "1.1.7",
+    "mocha": "^10.2.0",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3",
+    "visitor-as": "0.11.4"
+  }
+}

examples/15-simple-dynamic-call/src/function.ts

@@ -0,0 +1,54 @@
+import {
+  Bytes,
+  DenominationToken,
+  ERC20Token,
+  EvmDynamicArg,
+  EvmDynamicCallBuilder,
+  EvmEncodeParam,
+  IntentBuilder,
+  SwapBuilder,
+  TokenAmount,
+} from '@mimicprotocol/lib-ts'
+
+import { inputs } from './types'
+
+export default function main(): void {
+  const chainId = inputs.chainId
+  const smartAccount = inputs.smartAccount
+  const recipient = inputs.recipient
+
+  const tokenIn = ERC20Token.fromAddress(inputs.tokenIn, chainId)
+  const tokenOut = ERC20Token.fromAddress(inputs.tokenOut, chainId)
+
+  const amountIn = TokenAmount.fromStringDecimal(tokenIn, inputs.amount)
+  const expectedOut = amountIn.toTokenAmount(tokenOut).unwrap()
+  const minAmountOut = expectedOut.applySlippageBps(inputs.slippageBps)
+
+  const maxFee = TokenAmount.fromStringDecimal(DenominationToken.USD(), inputs.maxFeeUsd)
+
+  // Swap operation (tokens are received in the smart account)
+  const swap = SwapBuilder.forChain(chainId)
+    .addTokenInFromTokenAmount(amountIn)
+    .addTokenOutFromTokenAmount(minAmountOut, smartAccount)
+
+  /*
+    Dynamic call operation (called after the swap, using the received tokens)
+    It is calling the contract of tokenOut.address on the transfer() function
+    Using a literal address value for the first arg and the swap operation output as the second arg
+    This would be equivalent of doing:
+    `IERC20(tokenOut.address).transfer(to=recipient, value=result of swap)`
+  */
+  const target = tokenOut.address
+  const selector = Bytes.fromHexString('0xa9059cbb') // transfer() selector
+  const dynamicCall = EvmDynamicCallBuilder.forChain(chainId)
+    .addCall(target, selector, [
+      EvmDynamicArg.literal([new EvmEncodeParam('address', recipient.toString())], false),
+      EvmDynamicArg.variable(0, 0, false), // swap operation output
+    ])
+    .addUser(smartAccount)
+
+  new IntentBuilder()
+    .addOperationsBuilders([swap, dynamicCall]) // The order is important!
+    .addMaxFee(maxFee)
+    .send()
+}

examples/15-simple-dynamic-call/tests/function.spec.ts

@@ -0,0 +1,81 @@
+import { Chains, EvmDynamicCallOperation, OpType, randomEvmAddress, SwapOperation } from '@mimicprotocol/sdk'
+import { EvmCallQueryMock, runFunction, TokenPriceQueryMock } from '@mimicprotocol/test-ts'
+import { expect } from 'chai'
+
+describe('Function', () => {
+  const functionDir = './build'
+
+  const chainId = Chains.Optimism
+
+  const context = {
+    user: '0x756f45e3fa69347a9a973a725e3c98bc4db0b5a0',
+    settlers: [{ address: '0xdcf1d9d12a0488dfb70a8696f44d6d3bc303963d', chainId }],
+    timestamp: Date.now(),
+  }
+
+  const inputs = {
+    tokenIn: randomEvmAddress(),
+    tokenOut: randomEvmAddress(),
+    chainId,
+    amount: '1.5',
+    slippageBps: 1,
+    smartAccount: randomEvmAddress(),
+    recipient: randomEvmAddress(),
+    maxFeeUsd: '0.1',
+  }
+
+  const calls: EvmCallQueryMock[] = [
+    {
+      request: { to: inputs.tokenIn, chainId, fnSelector: '0x313ce567' }, // decimals
+      response: { value: '6', abiType: 'uint8' },
+    },
+    {
+      request: { to: inputs.tokenOut, chainId, fnSelector: '0x313ce567' }, // decimals
+      response: { value: '6', abiType: 'uint8' },
+    },
+  ]
+
+  const prices: TokenPriceQueryMock[] = [
+    {
+      request: { token: { address: inputs.tokenIn, chainId: inputs.chainId } },
+      response: ['1000000000000000000'], // 1 token = 1 USD
+    },
+    {
+      request: { token: { address: inputs.tokenOut, chainId: inputs.chainId } },
+      response: ['1000000000000000000'], // 1 token = 1 USD
+    },
+  ]
+
+  it('produces the expected intents', async () => {
+    const result = await runFunction(functionDir, context, { inputs, calls, prices })
+    expect(result.success).to.be.true
+    expect(result.timestamp).to.be.equal(context.timestamp)
+
+    expect(result.intents).to.have.lengthOf(1)
+    const intent = result.intents[0]
+
+    expect(intent.feePayer).to.be.equal(context.user)
+    expect(intent.feePayer).to.be.equal(context.user)
+    expect(intent.maxFees).to.have.lengthOf(1)
+    expect(intent.maxFees[0].token).to.be.equal('0x0000000000000000000000000000000000000348')
+    expect(intent.maxFees[0].amount).to.be.equal('100000000000000000')
+    expect(intent.operations).to.have.lengthOf(2)
+    expect(intent.settler).to.be.equal(context.settlers[0].address)
+
+    const swap = intent.operations[0] as SwapOperation
+    const call = intent.operations[1] as EvmDynamicCallOperation
+    expect(swap.opType).to.be.equal(OpType.Swap)
+    expect(call.opType).to.be.equal(OpType.EvmDynamicCall)
+
+    expect(swap.user).to.be.equal(context.user)
+    expect(call.user).to.be.equal(inputs.smartAccount)
+
+    expect(swap.sourceChain).to.be.equal(inputs.chainId)
+    expect(swap.destinationChain).to.be.equal(inputs.chainId)
+    expect(call.chainId).to.be.equal(inputs.chainId)
+
+    expect(call.calls).to.have.lengthOf(1)
+    expect(call.calls[0].target).to.be.equal(inputs.tokenOut)
+    expect(call.calls[0].arguments).to.have.lengthOf(2)
+  })
+})

examples/15-simple-dynamic-call/tests/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "declaration": true,
+    "composite": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["ES2020", "DOM"],
+    "types": ["mocha", "chai", "node"]
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

examples/15-simple-dynamic-call/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "assemblyscript/std/assembly.json",
+  "include": ["./src/**/*.ts"],
+  "exclude": ["tests/**/*"],
+  "references": [{ "path": "./tests" }]
+}