Runtime Functions

import { runtimeERC20BalanceOf } from "@biconomy/abstractjs";

const balance = runtimeERC20BalanceOf(options);

import { runtimeERC20BalanceOf, greaterThanOrEqualTo } from "@biconomy/abstractjs";

// Transfer entire USDC balance
const transfer = await account.buildComposable({
  type: "transfer",
  data: {
    chainId: 8453,
    tokenAddress: USDC,
    recipient: userAddress,
    amount: runtimeERC20BalanceOf({
      tokenAddress: USDC,
      targetAddress: account.addressOn(8453, true),
      constraints: [greaterThanOrEqualTo(1n)]
    })
  }
});

import { runtimeNativeBalanceOf } from "@biconomy/abstractjs";

const balance = runtimeNativeBalanceOf(options);

import { runtimeNativeBalanceOf } from "@biconomy/abstractjs";

// Send all ETH
const sendAll = await account.buildComposable({
  type: "nativeTokenTransfer",
  data: {
    chainId: 8453,
    to: recipient,
    value: runtimeNativeBalanceOf({
      targetAddress: account.addressOn(8453, true)
    })
  }
});

import { runtimeERC20AllowanceOf } from "@biconomy/abstractjs";

const allowance = runtimeERC20AllowanceOf(options);

const transferFrom = await account.buildComposable({
  type: "default",
  data: {
    chainId: 8453,
    to: USDC,
    abi: erc20Abi,
    functionName: "transferFrom",
    args: [
      owner,
      recipient,
      runtimeERC20AllowanceOf({
        owner,
        spender: account.addressOn(8453, true),
        tokenAddress: USDC
      })
    ]
  }
});

import { runtimeParamViaCustomStaticCall } from "@biconomy/abstractjs";

const value = runtimeParamViaCustomStaticCall(options);

const dynamicRecipient = runtimeParamViaCustomStaticCall({
  targetContractAddress: registry,
  functionAbi: registryAbi,
  functionName: "getRecipient",
  args: [userId]
});

const transfer = await account.buildComposable({
  type: "nativeTokenTransfer",
  data: {
    chainId: 8453,
    to: dynamicRecipient,
    value: parseEther("0.1")
  }
});

import { greaterThanOrEqualTo } from "@biconomy/abstractjs";

constraints: [greaterThanOrEqualTo(parseUnits("90", 6))]

import { lessThanOrEqualTo } from "@biconomy/abstractjs";

constraints: [lessThanOrEqualTo(parseUnits("100", 6))]

import { equalTo } from "@biconomy/abstractjs";

constraints: [equalTo(expectedValue)]

// Step 1: Swap (executes first)
const swap = await account.buildComposable({ /* ... */ });

// Step 2: Deposit (waits for swap to complete)
const deposit = await account.buildComposable({
  type: "default",
  data: {
    args: [
      runtimeERC20BalanceOf({
        tokenAddress: WETH,
        targetAddress: account.addressOn(8453, true),
        constraints: [greaterThanOrEqualTo(minExpected)]  // Waits here
      })
    ]
  }
});