Deposit on EVM

The deposit is one call on the source chain, carrying the quote hash. The quote’s parameters, not preference, determine which entry point you use and which contract it goes to. Plain deposits go to the escrow, which is the router_address on the quote; deposits that swap go to the router returned by GetSwapInstructions.

Choosing the call

Condition on `order_params`	Call	Target
`src_token` is the zero address	`depositNative`	`order_params.router_address`
`src_token` equals `lock_token`	`depositToken`	`order_params.router_address`
`src_token` differs from `lock_token`	`depositWithSwap`	`GetSwapInstructions` `router_address`
`src_chain` equals `dst_chain`	`swapAndForward`, see Same-chain swaps	`order_params.router_address`

const params = quote.orderParams;
const native = /^0x0*$/i.test(params.srcToken);
const swap = params.srcToken !== params.lockToken;

When the quote has direct_transfer: true, the depositToken row has a cheaper alternative: a plain ERC-20 transfer to the escrow with the quote hash appended to the calldata. See Direct transfer. A quote requested with gasless: true takes none of these paths: the user signs a permit2 authorization instead of sending a transaction, and the operator relays the deposit. See SubmitGaslessOrder.

Native deposits

No approval, no allowance check. The amount rides as transaction value.

function depositNative(bytes32 quoteHash) external payable;

await wallet.sendTransaction({
  to: params.routerAddress,
  data: encodeFunctionData({
    abi: routerAbi,
    functionName: "depositNative",
    args: [quote.quoteHash],
  }),
  value: BigInt(params.expectedAmountIn),
});

Token deposits

The router pulls the tokens, so it needs an allowance first. Check before prompting: a user who already approved should not be asked twice.

function depositToken(bytes32 quoteHash, address token, uint256 amount) external;

Check allowance

const allowance = await erc20.read.allowance([owner, params.routerAddress]);

Approve if short

Approve at least expected_amount_in. Wait for the approval to confirm before the deposit; sending both in one block fails on most RPCs.

Deposit

await wallet.sendTransaction({
  to: params.routerAddress,
  data: encodeFunctionData({
    abi: routerAbi,
    functionName: "depositToken",
    args: [quote.quoteHash, params.srcToken, BigInt(params.expectedAmountIn)],
  }),
});

Permit

Tokens supporting EIP-2612 can skip the approval transaction entirely by signing instead. The catalog marks them with permit: true. The permit variants live on the router contract (router from GetChains), which forwards the funds into the escrow, so the permit’s spender and the transaction target are the router.

function depositTokenWithPermit(
    bytes32 quoteHash,
    address token,
    uint256 amount,
    uint256 permitValue,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
) external;

permitValue is the value the permit was signed for, passed to the token unchanged; any other number fails the signature check. Sign the permit for amount, the amount the deposit pulls, not for an unlimited allowance. The permit is attempted and its failure swallowed, so a permit that was already consumed does not break the deposit, but the transfer still needs the allowance to exist by then, from either the permit or a prior approval. depositTokenWithPermit2 is the equivalent for wallets with a standing permit2 allowance: a SignatureTransfer signature replaces the approval, and any ERC-20 works, not just EIP-2612 tokens.

Direct transfer

When the quote carries direct_transfer: true, the whole deposit collapses into a single ERC-20 transfer to the vault, with the 32-byte quote hash appended after the calldata. No approval, no router call, and the cheapest gas of any path. The flag is only set on cross-chain quotes where src_token equals lock_token on a chain that supports it.

await wallet.sendTransaction({
  to: params.srcToken,
  data: encodeFunctionData({
    abi: erc20Abi,
    functionName: "transfer",
    args: [params.routerAddress, BigInt(params.expectedAmountIn)],
  }) + quote.quoteHash.replace(/^0x/, ""),
});

The transfer must be the transaction’s own calldata: sent from the wallet directly to the token contract, for expected_amount_in, with the quote hash as the trailing 32 bytes. A transfer routed through a contract wallet or batching layer hides the calldata and the deposit will not be attributed. The SDK uses this path automatically when the quote allows it.

Deposits that swap first

When the source token is not the asset that bridges, the router swaps through an allowlisted aggregator inside the deposit transaction. The calldata comes from GetSwapInstructions, keyed by quote hash.

const instructions = await blink.getSwapInstructions({ quoteHash: quote.quoteHash });

Field	Use
`router_address`	The router contract to send the deposit to.
`payload.evm.aggregator`	Target of the swap, allowlisted on the router.
`payload.evm.swap_calldata`	Calldata to execute.
`src_token`, `amount_in`	Input leg.
`lock_token`, `min_lock_amount`	Output leg and its floor.
`payload.evm.value`	Transaction value, non-zero when the source token is native.

function depositWithSwap(
    bytes32 quoteHash,
    address srcToken,
    uint256 amountIn,
    address aggregator,
    bytes calldata swapData,
    address lockToken,
    uint256 minLockAmount
) external payable;

Fetch the instructions immediately before sending. Routing calldata reflects pool state at the time it was built, and a stale route is the most common cause of a reverted deposit. depositWithSwapAndPermit takes the same arguments plus the permit parameters (permitValue, deadline, v, r, s), with the permit signed for amountIn.

If the swap returns less than min_lock_amount the transaction reverts with InsufficientOutput. The user pays gas and nothing else; their funds never leave their wallet.

With the SDK

ChainAdapter resolves all of this (entry point, allowance, swap instructions, chain switching) into an ordered list of steps.

import { createChainAdapter } from "@mayanfinance/blink-sdk";

const adapter = createChainAdapter(client, chainStatus, 42161n);
const steps = await adapter.steps(wallet, quote.quoteHash, quote.orderParams);

for (const step of steps) {
  const hash = await step.run();   // step.kind is "approve" or "deposit"
}

Render step.kind in your UI so the user knows which prompt they are signing.

After it lands

The deposit emits Deposit and the indexer picks it up. There is nothing else to submit: no attestation, no claim, no destination transaction from the user. Move to Track an order.

Deposit exactly expected_amount_in. A direct deposit has no tolerance: min_lock_amount equals expected_lock_amount, so a short deposit is a mismatched deposit and is refunded. A deposit above expected_amount_in is filled at expected_amount_out. On a source swap the router enforces min_lock_amount inside the deposit transaction, and a swap output between it and expected_lock_amount is filled with the payout scaled down in proportion; see Slippage.

Get started

Build a swap

Extend

Deposit on EVM

Choosing the call

Native deposits

Token deposits

Permit

Direct transfer

Deposits that swap first

With the SDK

After it lands

​Choosing the call

​Native deposits

​Token deposits

​Permit

​Direct transfer

​Deposits that swap first

​With the SDK

​After it lands

Choosing the call

Native deposits

Token deposits

Permit

Direct transfer

Deposits that swap first

With the SDK

After it lands