ERC-8211 Smart Batching

# npm
npm install @biconomy/smart-batching @biconomy/abstractjs viem

# bun
bun add @biconomy/smart-batching @biconomy/abstractjs viem

import { createComposableBatch } from "@biconomy/smart-batching";
import {
  createMeeClient,
  getDefaultMEENetworkApiKey,
  getDefaultMEENetworkUrl,
  getMEEVersion,
  MEEVersion,
  toMultichainNexusAccount,
} from "@biconomy/abstractjs";
import { createPublicClient, http, parseUnits } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { baseSepolia } from "viem/chains";

const USDC = "0x036CbD53842c5426634e7929541eC2318f3dCF7e"; // Base Sepolia USDC
const recipient = "0xRecipientAddress";

// 1. Smart account on MEE v2.2.2
const signer = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const account = await toMultichainNexusAccount({
  signer,
  chainConfigurations: [
    {
      chain: baseSepolia,
      transport: http(),
      version: getMEEVersion(MEEVersion.V2_2_2),
    },
  ],
});

const scaAddress = account.addressOn(baseSepolia.id, true);
const publicClient = createPublicClient({ chain: baseSepolia, transport: http() });

// 2. Build the ERC-8211 batch with @biconomy/smart-batching
const batch = createComposableBatch(publicClient, scaAddress);
const usdc = batch.erc20Token(USDC);
const minExpected = parseUnits("1", 6); // 1 USDC

batch.add([
  // Pre-condition: revert before doing anything if the SCA doesn't have at least 1 USDC.
  usdc.check({
    functionName: "balanceOf",
    args: [scaAddress],
    constraint: { gte: minExpected },
  }),

  // Action: transfer the SCA's live USDC balance to the recipient.
  // The amount is resolved on-chain at execution time — no need to know it now.
  usdc.write({
    functionName: "transfer",
    args: [recipient, usdc.runtimeBalance()],
  }),

  // Post-condition: assert the recipient actually received at least 1 USDC.
  usdc.check({
    functionName: "balanceOf",
    args: [recipient],
    constraint: { gte: minExpected },
  }),
]);

// 3. Execute through @biconomy/abstractjs
const isStaging = true; // staging MEE env for testnets
const meeClient = await createMeeClient({
  account,
  url: getDefaultMEENetworkUrl(isStaging),
  apiKey: getDefaultMEENetworkApiKey(isStaging),
});

const quote = await meeClient.getQuote({
  instructions: [
    {
      calls: await batch.toCalls(),
      chainId: baseSepolia.id,
      isComposable: true, // tells MEE to dispatch through the ERC-8211 module
    },
  ],
  feeToken: { address: USDC, chainId: baseSepolia.id },
});

const { hash } = await meeClient.executeQuote({ quote });
const receipt = await meeClient.waitForSupertransactionReceipt({ hash });
console.log("Done:", receipt.transactionHash);

const batch = createComposableBatch(publicClient, scaAddress);
const usdc = batch.erc20Token(USDC);
const eth = batch.nativeToken();
const oracle = batch.contract("0xOracleAddress", ORACLE_ABI);

// ERC-20 balance of any address at execution time
usdc.runtimeBalance();
usdc.runtimeBalance({ owner: "0xSomePoolAddress" });

// Native ETH balance
eth.runtimeBalance();

// Any view function — read a live oracle price, contract state, etc.
oracle.runtimeValue({ functionName: "latestPrice", args: [] });

// ERC-20 allowance — "consume exactly what was approved"
usdc.runtimeAllowance({ spender: "0xDexAddress" });

// Slippage guard: only proceed if the runtime balance is at least 5 USDC
usdc.runtimeBalance({ constraint: { gte: parseUnits("5", 6) } });

// Signed bound — for values that may be negative (e.g. a price delta from an oracle)
oracle.check({ functionName: "priceDelta", args: [], constraint: { gteSigned: -500n } });

// OR — pool must be either fully drained OR replenished above 100 USDC
usdc.check({
  functionName: "balanceOf",
  args: [poolAddress],
  constraint: { or: [{ eq: 0n }, { gte: parseUnits("100", 6) }] },
});

const storage = batch.storage();
const storageKey = await storage.getStorageKey();

batch.add([
  // Call that produces a value — capture its return into storage automatically
  swapContract.write({
    functionName: "swapExactIn",
    args: [tokenIn, tokenOut, amountIn],
    capture: { type: "execResult", storageKey },
  }),

  // Use the captured value as the amount for the next call
  vault.write({
    functionName: "deposit",
    args: [await storage.runtimeValue({ storageKey })],
  }),
]);