Send Universal Transaction

Overview

Universal transactions let you execute transfers, contract calls, asset movement, and batched transactions across Push Chain and supported external chains through one unified interface.

You do not need separate transactions, wrapping, manual bridging, or extra tooling.

To understand this concept in detail, please see Understanding Universal Transactions.

How Routing Works

sendTransaction automatically selects the execution route based on the to and from fields.

Route	Input Shape	Executes On	Notes
Route 1	`to: "0x..."`	Push Chain	Default route for Push Chain targets.
Route 2	`to: { address, chain }`	External chain	Executes on the specified external chain.
Route 3	`to: "0x..."` and `from: { chain }`	Push Chain	Uses your CEA on the specified external chain as the execution origin.

Send a Universal Transaction

pushChainClient.universal.sendTransaction({tx}): Promise<TxResponse>

const txResponse = await pushChainClient.universal.sendTransaction({
  to: '0xa54E96d3fB93BD9f6cCEf87c2170aEdB1D47E1cF',
  value: PushChain.utils.helpers.parseUnits('0.1', 18), // 0.1 PC in uPC
  // value: BigInt('100000000000000000') is equivalent here
});

TheseArgumentsare mandatory

Arguments	Type	Description
`tx.to`	`string` \| `{ address: string; chain: CHAIN }`	Defines the execution target. Passing a plain address triggers Push Chain execution. Passing `{ address, chain }` targets an external chain.
`tx.from`	`{ chain: PushChain.CONSTANTS.CHAIN }`	Optional. When set to an external chain, execution uses the Chain Executor Account (CEA) for that chain as the transaction origin. This is primarily used for external origin or CEA-based execution flows. PushChain.CONSTANTS.CHAIN `PushChain.CONSTANTS.CHAIN.PUSH_TESTNETPushChain.CONSTANTS.CHAIN.PUSH_TESTNET_DONUTPushChain.CONSTANTS.CHAIN.ETHEREUM_SEPOLIAPushChain.CONSTANTS.CHAIN.BNB_TESTNETPushChain.CONSTANTS.CHAIN.BASE_SEPOLIAPushChain.CONSTANTS.CHAIN.ARBITRUM_SEPOLIAPushChain.CONSTANTS.CHAIN.SOLANA_DEVNET`
`tx.value`	`BigInt`	Native value to send, expressed in the smallest unit of the execution context. On Push Chain this is uPC (the smallest unit, like wei in ETH). On external execution routes, this maps to the native asset amount of that route.
`tx.data`	`string` \| `Array<{ to: string; value: bigint; data: string }>`	Use `string` as ABI-encoded calldata for a single call. Use `Array<...>` for batched multicall payload.
`tx.funds`	`{ amount: BigInt; token?: PushChain.CONSTANTS.MOVEABLE.TOKEN }`	Moves supported assets as part of the transaction flow. Depending on the route, assets may be moved into Push Chain or between Push Chain and a supported external chain. If `tx.data` is provided, asset movement and execution happen atomically. PushChain.CONSTANTS.MOVEABLE.TOKEN `PushChain.CONSTANTS.MOVEABLE.TOKEN.ETHEREUM_SEPOLIA.ETHPushChain.CONSTANTS.MOVEABLE.TOKEN.ETHEREUM_SEPOLIA.USDTPushChain.CONSTANTS.MOVEABLE.TOKEN.ETHEREUM_SEPOLIA.USDCPushChain.CONSTANTS.MOVEABLE.TOKEN.ETHEREUM_SEPOLIA.WETHPushChain.CONSTANTS.MOVEABLE.TOKEN.ETHEREUM_SEPOLIA.stETHPushChain.CONSTANTS.MOVEABLE.TOKEN.ARBITRUM_SEPOLIA.ETHPushChain.CONSTANTS.MOVEABLE.TOKEN.ARBITRUM_SEPOLIA.USDTPushChain.CONSTANTS.MOVEABLE.TOKEN.ARBITRUM_SEPOLIA.USDCPushChain.CONSTANTS.MOVEABLE.TOKEN.ARBITRUM_SEPOLIA.WETHPushChain.CONSTANTS.MOVEABLE.TOKEN.BASE_SEPOLIA.ETHPushChain.CONSTANTS.MOVEABLE.TOKEN.BASE_SEPOLIA.USDTPushChain.CONSTANTS.MOVEABLE.TOKEN.BASE_SEPOLIA.USDCPushChain.CONSTANTS.MOVEABLE.TOKEN.BASE_SEPOLIA.WETHPushChain.CONSTANTS.MOVEABLE.TOKEN.BNB_TESTNET.ETHPushChain.CONSTANTS.MOVEABLE.TOKEN.BNB_TESTNET.USDTPushChain.CONSTANTS.MOVEABLE.TOKEN.SOLANA_DEVNET.SOLPushChain.CONSTANTS.MOVEABLE.TOKEN.SOLANA_DEVNET.USDTPushChain.CONSTANTS.MOVEABLE.TOKEN.SOLANA_DEVNET.USDCPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.pEthPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.pEthArbPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.pEthBasePushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.pEthBnbPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.pSolPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDT.ethPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDT.arbPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDT.basePushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDT.bnbPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDT.solPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDC.ethPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDC.arbPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDC.basePushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDC.bnbPushChain.CONSTANTS.MOVEABLE.TOKEN.PUSH_TESTNET_DONUT.USDC.sol`
`tx.progressHook`	`(progress: ProgressHookType) => void`	A callback function to receive progress updates during transaction lifecycle, especially useful for tracking cross-chain transactions.

Progress Hook Type and Response

ProgressHook Type and Response

Field	Type	Description
`progress`	`Object`	The progress of the transaction.
`progress.id`	`string`	Unique identifier for the progress event.
`progress.title`	`string`	Brief title of the progress event.
`progress.message`	`string`	Detailed message describing the event.
`progress.level`	`INFO` \| `SUCCESS` \| `ERROR`	Severity level of the event.
`progress.timestamp`	`string`	ISO-8601 timestamp when the event occurred (e.g. `2025-06-26T15:04:05.000Z`).

ID	Title	Message	Level
`SEND-TX-01`	Origin Chain Detected	Origin chain: `<namespace>` - Origin Address: `<origin address>`	INFO
`SEND-TX-02-01`	Estimating Gas	Estimating and fetching gas limit, gas price for TX	INFO
`SEND-TX-02-02`	Gas Estimated	Total execution cost (Gas cost + value): `<amount>` UPC	SUCCESS
`SEND-TX-03-01`	Resolving UEA	Resolving Universal Executor Account (UEA) – computing address, checking deployment status/balance	INFO
`SEND-TX-03-02`	UEA Resolved	UEA: `<address>`, Deployed: `<true/false>`	SUCCESS
`SEND-TX-04-01`	Awaiting Transaction	Awaiting user transaction on origin chain	INFO
`SEND-TX-04-02`	Awaiting Signature	Awaiting user signature for universal payload	INFO
`SEND-TX-04-03`	Verification Success	Verification completed via Transaction or Signature	SUCCESS
`SEND-TX-04-04`	Verification Declined	Verification declined by user	ERROR
`SEND-TX-05-01`	Gas Funding In Progress	Gas funding tx sent: `<origin chain tx hash>`	INFO
`SEND-TX-05-02`	Gas Funding Confirmed	Gas funding confirmed on origin chain	SUCCESS
`SEND-TX-06-01`	Preparing Funds Transfer	Preparing to move `<amount> <symbol>` from origin chain	INFO
`SEND-TX-06-02`	Funds Lock Submitted	Locking `<amount> <symbol>` for transfer (Tx hash: `<origin tx hash>`)	INFO
`SEND-TX-06-03`	Awaiting Confirmations	Waiting for `<required>` confirmations	INFO
`SEND-TX-06-03-01`	Confirmation #`<current>` Received	`<current>/<required>` confirmations received	INFO
`SEND-TX-06-03-02`	Confirmation #`<current>` Received	`<current>/<required>` confirmations received	SUCCESS
`SEND-TX-06-04`	Funds Confirmed	Origin chain lock confirmed	SUCCESS
`SEND-TX-06-05`	Syncing State with Push Chain	Waiting for transaction to appear on Push Chain	SUCCESS
`SEND-TX-06-06`	Funds Credited on Push Chain	Funds credited: `<amount> <symbol>` (minus fees)	SUCCESS
`SEND-TX-07`	Broadcasting to Push Chain	Sending Tx to Push Chain...	INFO
`SEND-TX-99-01`	Push Chain Tx Success	Tx executed successfully on Push Chain	SUCCESS
`SEND-TX-99-02`	Push Chain Tx Failed	`<error message>`	ERROR

Advanced Arguments

Arguments	Type	Default	Description
`tx.gasLimit`	`BigInt`	`SDK Estimated`	Optional override for transaction gas limit. If omitted, the SDK estimates it.
`tx.maxFeePerGas`	`BigInt`	`SDK Estimated`	Optional override for max fee per gas. If omitted, the SDK estimates it when applicable.
`tx.maxPriorityFeePerGas`	`BigInt`	`SDK Estimated`	Optional override for priority fee. If omitted, the SDK estimates it when applicable.
`tx.payGasWith`	`{ token?: PushChain.CONSTANTS.PAYABLE.TOKEN; slippageBps?: number; minAmountOut?: bigint \| string }`	-	Pay universal transaction fees using a supported token (e.g., `PushChain.CONSTANTS.PAYABLE.TOKEN.ETHEREUM_SEPOLIA.USDT`). Optional `slippageBps` (e.g., `100` = 1%) and `minAmountOut` (wei) let you control on-chain swap execution. PushChain.CONSTANTS.PAYABLE.TOKEN `PushChain.CONSTANTS.PAYABLE.TOKEN.ETHEREUM_SEPOLIA.ETHPushChain.CONSTANTS.PAYABLE.TOKEN.ETHEREUM_SEPOLIA.USDTPushChain.CONSTANTS.PAYABLE.TOKEN.ETHEREUM_SEPOLIA.USDCPushChain.CONSTANTS.PAYABLE.TOKEN.ETHEREUM_SEPOLIA.WETHPushChain.CONSTANTS.PAYABLE.TOKEN.ETHEREUM_SEPOLIA.stETHPushChain.CONSTANTS.PAYABLE.TOKEN.ARBITRUM_SEPOLIA.ETHPushChain.CONSTANTS.PAYABLE.TOKEN.ARBITRUM_SEPOLIA.USDTPushChain.CONSTANTS.PAYABLE.TOKEN.ARBITRUM_SEPOLIA.USDCPushChain.CONSTANTS.PAYABLE.TOKEN.BASE_SEPOLIA.ETHPushChain.CONSTANTS.PAYABLE.TOKEN.BASE_SEPOLIA.USDTPushChain.CONSTANTS.PAYABLE.TOKEN.BASE_SEPOLIA.USDCPushChain.CONSTANTS.PAYABLE.TOKEN.BNB_TESTNET.BNBPushChain.CONSTANTS.PAYABLE.TOKEN.BNB_TESTNET.USDTPushChain.CONSTANTS.PAYABLE.TOKEN.SOLANA_DEVNET.SOLPushChain.CONSTANTS.PAYABLE.TOKEN.SOLANA_DEVNET.USDTPushChain.CONSTANTS.PAYABLE.TOKEN.SOLANA_DEVNET.USDC`
`tx.deadline`	`BigInt`	-	Optional execution deadline for the transaction.

Returns TxResponse

Returns `TxResponse` <object>

{
  hash: '0xe2302bd21ab0902f37cb605d491ce5f95ee35ce4083405dddf3657d782acae35',
  origin: 'eip155:42101:0xFd6C2fE69bE13d8bE379CCB6c9306e74193EC1A9',
  blockNumber: 0n,
  blockHash: '',
  transactionIndex: 0,
  chainId: '42101',
  from: '0xFd6C2fE69bE13d8bE379CCB6c9306e74193EC1A9',
  to: '0x35B84d6848D16415177c64D64504663b998A6ab4',
  nonce: 341,
  data: '0x',
  value: 1000n,
  gasLimit: 21000n,
  gasPrice: 1325000000n,
  maxFeePerGas: 1325000000n,
  maxPriorityFeePerGas: 125000000n,
  accessList: [],
  wait: [Function: wait],
  type: '2',
  typeVerbose: 'eip1559',
  signature: {
    r: '0x556566ba1304bf8e93025fc82daff32eb24b7ee9804a76d0baa0098dfa7237de',
    s: '0x4495d7811d3dcb1beac16f29261903b542b0b65f51aa5942f65dbaf67e735724',
    v: 1,
    yParity: 1
  },
  raw: {
    from: '0xFd6C2fE69bE13d8bE379CCB6c9306e74193EC1A9',
    to: '0x35B84d6848D16415177c64D64504663b998A6ab4',
    nonce: 341,
    data: '0x',
    value: 1000n
  }
}

Property	Type	Description
`hash`	`string`	Unique transaction hash identifier
`origin`	`string`	Origin identifier in format "eip155:chainId:address" or "solana:chainId:address"
`blockNumber`	`BigInt`	Block number where transaction was included
`blockHash`	`string`	Hash of the block containing this transaction
`transactionIndex`	`number`	Position/index of transaction within the block
`chainId`	`string`	Chain identifier (e.g. Push Chain = `42101`)
`from`	`string`	UEA (Universal Executor Account) that executed the transaction
`to`	`string`	Target address the UEA executed against
`nonce`	`number`	Derived nonce for the UEA
`data`	`string`	Perceived calldata (transaction input data)
`value`	`BigInt`	Amount of native tokens transferred (in wei)
`gasLimit`	`BigInt`	Maximum gas units allocated for transaction
`gasPrice`	`BigInt`	Gas price for legacy transactions (in wei)
`maxFeePerGas`	`BigInt`	Maximum fee per gas for EIP-1559 transactions
`maxPriorityFeePerGas`	`BigInt`	Maximum priority fee (tip) per gas for EIP-1559
`accessList`	`array`	EIP-2930 access list for optimized storage access
`type`	`string`	Transaction type identifier
`typeVerbose`	`string`	Human-readable transaction type
`signature`	`object`	ECDSA signature components
`signature.r`	`string`	R component of ECDSA signature
`signature.s`	`string`	S component of ECDSA signature
`signature.v`	`number`	Recovery ID (legacy format)
`signature.yParity`	`number`	Y-parity for EIP-1559 (0 or 1)
`raw`	`object`	Original on-chain transaction data
`raw.from`	`string`	Actual from address that went on chain
`raw.to`	`string`	Actual to address that went on chain
`raw.nonce`	`number`	Actual raw nonce used on chain
`raw.data`	`string`	Actual raw data that went on chain
`raw.value`	`BigInt`	Actual derived value that went on chain
`wait`	`function`	Async function that returns a Promise resolving to UniversalTxReceipt

Getting `txReceipt` <object> from `txResponse` <object>

Calling the wait() function from txResponse object will give you a Promise<UniversalTxReceipt> once the transaction is confirmed on-chain.

const txReceipt = await txResponse.wait(1); // number of blocks confirmations to wait for

{
  hash: '0xb52706db4116dd6bbea87be5142ac2c69b17fe8ccf8e2b88ac176adb30b90dd6',
  blockNumber: 3413247n,
  blockHash: '0x5a7b6e2716f7d4450b6ca08aebfe74cea3d876367a8afe6f603196ba8c346a2d',
  transactionIndex: 0,
  from: '0xFd6C2fE69bE13d8bE379CCB6c9306e74193EC1A9',
  to: '0x35B84d6848D16415177c64D64504663b998A6ab4',
  contractAddress: null,
  gasPrice: 1325000000n,
  gasUsed: 21000n,
  cumulativeGasUsed: 21000n,
  logs: [],
  logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
  status: 1,
  raw: {
    from: '0xFd6C2fE69bE13d8bE379CCB6c9306e74193EC1A9',
    to: '0x35B84d6848D16415177c64D64504663b998A6ab4',
    nonce: 342,
    data: '0x',
    value: 1000n
  }
}

Property	Type	Description
`hash`	`string`	Transaction hash (same as in transaction response)
`blockNumber`	`BigInt`	Block number where transaction was confirmed
`blockHash`	`string`	Hash of the block containing the transaction
`transactionIndex`	`number`	Position/index of transaction within the block
`from`	`string`	Executor account address (UEA on Push Chain)
`to`	`string`	Actual intended target address of the transaction
`contractAddress`	`string` \| `null`	Address of deployed contract (null for regular transfers)
`gasPrice`	`BigInt`	Gas price used for the transaction (in wei)
`gasUsed`	`BigInt`	Actual gas consumed by the transaction
`cumulativeGasUsed`	`BigInt`	Total gas used by all transactions in the block up to this one
`logs`	`array`	Array of log objects emitted by the transaction
`logsBloom`	`string`	Bloom filter for efficient log searching
`status`	`number`	Transaction status (1 = success, 0 = failure)
`raw`	`object`	Raw on-chain transaction data
`raw.from`	`string`	Actual from address that executed on chain
`raw.to`	`string`	Actual to address that was called on chain
`raw.nonce`	`number`	Actual nonce used on chain
`raw.data`	`string`	Actual calldata sent on chain
`raw.value`	`BigInt`	Actual value transferred on chain

Send Transaction with Contract Interaction

When calling a smart contract method via sendTransaction, supply the ABI-encoded function call as a hex string in the data field. You can choose ethers or viem or any of your favorite libraries to encode the function data. Or, use our utility function PushChain.utils.helpers.encodeTxData to encode the function data.

// Define the ABI for the ERC20 transfer function
const erc20Abi = [
  'function transfer(address to, uint256 amount) returns (bool)',
];

// Generate the encoded function data using viem
const data = PushChain.utils.helpers.encodeTxData({
  abi: erc20Abi,
  functionName: 'transfer',
  // Transfer 10 tokens, converted to 18 decimal places
  args: ['0xRecipientAddress', PushChain.utils.helpers.parseUnits('10', 18)],
});

// Send the transaction using Push Chain SDK
const txResponse = await pushChainClient.universal.sendTransaction({
  to: '0xTokenContractAddress', // The smart contract address on Push Chain
  value: BigInt('0'), // No $PC being sent, just contract interaction
  data: data, // The encoded function call
});

Send Transaction with Asset Movement

You can move supported assets (e.g., USDT, USDC, or other tokens) from your origin chain to Push Chain and execute your call in a single transaction.

Use the funds field to specify the amount of assets to move, and optionally the data field to specify the function call to execute on Push Chain.

Note: funds transactions are only supported from external origin chains.
Native Push Chain users should call ERC-20 transfer or transferFrom directly (instead of using funds).

// Send 1 USDT to the recipient address
const txResponse = await pushChainClient.universal.sendTransaction({
  to: '0xRecipientAddress', // The recipient address on Push Chain
  data: data, // pass this if you want to execute a function on Push Chain as well
  funds: {
    amount: PushChain.utils.helpers.parseUnits('1', 6), // 1 USDT
    token: PushChain.CONSTANTS.MOVEABLE.TOKEN.ETHEREUM_SEPOLIA.USDT, // MoveableToken accessor from client
  },
});

Send Batch Transactions (Multicall)

You can batch multiple calls into a single transaction. This pattern is commonly referred to as Multicall in EVM ecosystems.

To do so, instead of passing a single data field, supply an array of calls (each with to, value, and data) to sendTransaction.

Note: Batch transactions are only supported from external origin chains.
Native Push Chain users cannot use batch mode on Push but can use it on other chains (ie: when doing Route 2 or Route 3 universal transactions).

// Execute two increment() calls atomically
const incrementData = PushChain.utils.helpers.encodeTxData({
  abi: CounterABI,
  functionName: 'increment',
});

await client.universal.sendTransaction({
  // Must be '0x0000000000000000000000000000000000000000' for multicall
  to: '0x0000000000000000000000000000000000000000',
  data: [
    { to: '0xCounterContract1', value: 0n, data: incrementData },
    { to: '0xCounterContract2', value: 0n, data: incrementData },
  ],
});

Multicall requirements

For multicall, the to should always be zero address (0x0000000000000000000000000000000000000000). The SDK will console.warn if you pass any other address. This will become mandatory in a future release.

Live Playground

Quickstart
Ethers (v6)
Viem
Solana (Web3 JS)
UI Kit

VIRTUAL NODE IDE

REACT PLAYGROUND

// Import necessary components from @pushchain/ui-kit
import {
  PushUniversalWalletProvider,
  PushUniversalAccountButton,
  usePushWalletContext,
  usePushChainClient,
  PushUI,
} from '@pushchain/ui-kit';

function App() {
  // Define Wallet Config
  const walletConfig = {
    network: PushUI.CONSTANTS.PUSH_NETWORK.TESTNET,
  };

  function Component() {
    const [txnHash, setTxnHash] = useState<string | null>(null);
    const [isLoading, setIsLoading] = useState(false);

    const { connectionStatus } = usePushWalletContext();
    const { pushChainClient } = usePushChainClient();

    const handleSendTransaction = async () => {
      if (pushChainClient) {
        setIsLoading(true);
        try {
          const res = await pushChainClient.universal.sendTransaction({
            to: '0xFaE3594C68EDFc2A61b7527164BDAe80bC302108',
            value: PushChain.utils.helpers.parseUnits('0.001', 18), // 0.001 PC in uPC
            data: '0x',
          });
          setTxnHash(res.hash);
        } catch (err) {
          console.log(err);
        }  finally {
          setIsLoading(false);
        }
      }
    };

    return (
      <div>
        <PushUniversalAccountButton />

        {connectionStatus == PushUI.CONSTANTS.CONNECTION.STATUS.CONNECTED &&
          <button
            disabled={isLoading}
            style={{
                background: 'transparent',
                border: '1px solid',
                borderRadius: '10px',
                padding: '12px 18px',
                cursor: 'pointer',
                margin: '8px 0',
            }}
            onClick={handleSendTransaction}
          >
            Send Transaction
          </button>
        }
        {txnHash && (
            <>
                <p>Txn Hash: {txnHash}</p>
                <a
                    href={pushChainClient.explorer.getTransactionUrl(txnHash)}
                    target="_blank"
                    rel="noopener noreferrer"
                >
                    View in Explorer
                </a>
            </>
        )}
      </div>
    );
  }

  return (
    <PushUniversalWalletProvider config={walletConfig}>
      <Component />
    </PushUniversalWalletProvider>
  );
}

LIVE APP PREVIEW

Next Steps

Explore end-to-end examples for each route with Universal Transaction Scenarios
Sequence multiple chain transactions in one go with Send Multichain Transactions
Trigger cross-chain execution directly from a smart contract with Contract Initiated Multichain Execution
Integrate transaction flows into your frontend app using the UI Kit

Start building

Quick Start

Learn with tutorials

Explore Push Chain

Join Discord

Explore Examples

Send Universal Transaction

Overview

How Routing Works

Send a Universal Transaction

Progress Hook Type and Response

Returns TxResponse

Send Transaction with Contract Interaction

Send Transaction with Asset Movement

Send Batch Transactions (Multicall)

Live Playground

Next Steps

Start building

Quick Start

Learn with tutorials

Explore Push Chain

Join Discord

Explore Examples

Overview​

How Routing Works​

Send a Universal Transaction​

Progress Hook Type and Response

Returns TxResponse

Send Transaction with Contract Interaction​

Send Transaction with Asset Movement​

Send Batch Transactions (Multicall)​

Live Playground​

Next Steps​

Overview

How Routing Works

Send a Universal Transaction

Send Transaction with Contract Interaction

Send Transaction with Asset Movement

Send Batch Transactions (Multicall)

Live Playground

Next Steps