Smart Contracts

Overview

CashmereCCTP wraps Circle’s CCTP on every supported chain: the contract takes Cashmere’s fee, burns the USDC through Circle and emits a CashmereTransfer event. Cashmere’s relayers then mint on the destination chain, so a transfer is a single source-chain transaction.

Most integrations don’t need this page. The Cashmere Agent SDK builds and sends every transaction below (cctp.transfer()), and its MCP server exposes them to AI agents. Read on to call the contracts yourself; the SDK’s src/chains/*.ts is a tested reference implementation of each flow.

Use CCTP V2. Circle cuts V1 burn limits from 31 Oct 2026 and stops V1 burns on 1 Dec 2026. Every route has V2, Aptos and Sui included since 26 Oct 2026. The V1 entry points are listed for reference only.

Contract Repository: GitHub - cashmere-prod/contracts-prod. Addresses for every chain are on Contract Addresses.

contracts-prod/
├── evm/src/CashmereCCTP.sol            # Solidity (EVM chains), with the Circle interfaces in evm/src/circle/
├── solana/programs/cashmere_cctp/      # Rust/Anchor (Solana)
├── aptos/sources/transfer.move         # Move (Aptos)
└── sui/sources/transfer.move           # Move (Sui)

Entry Points

Chain	V2 (use this)	V1 (legacy)
EVM	`transferV2`, `transferV2WithPermit`	`transfer`, `transferWithPermit`
Solana	`transfer_v2`	`transfer`
Aptos	`transfer_v2_outer` (entry function), `transfer_v2` (takes your own `FungibleAsset` and `Coin`)	`transfer_outer`, `transfer`
Sui	`prepare_deposit_for_burn_v2` on package `0x7eab670b…`, then Circle’s package-auth calls	`prepare_deposit_for_burn_ticket`, `post_deposit_for_burn`

From Quote to Call

Every transfer carries a quote signed by the Cashmere Gas API. The quote’s fee and deadline are part of the signed message, so pass them exactly as returned: any other value fails the signature check.

Get a quote for the route (Backend APIs):
- EVM sources: GET https://gas.cashmere.exchange/getEcdsaSig_native?localDomain=6&destinationDomain=3&isNative=true&isV2=true
- Solana, Aptos and Sui sources: GET https://gas.cashmere.exchange/getEd25519Sig_native?localDomain=9&destinationDomain=6&isNative=true&version=2
Get Circle’s fee for the finality threshold: GET https://iris-api.circle.com/v2/burn/USDC/fees/6/3 returns an array of finalityThreshold and minimumFee (basis points, possibly fractional, such as 1.3).
Call the V2 entry point with these values:

Parameter	Value
`fee`, `deadline`	From the quote, unchanged. Quotes expire about 100 seconds after they are issued
`isNative` / `fee_is_native`	The value you requested the quote with: the fee is then paid in the source chain’s gas token instead of USDC
`gasDropAmount`	`0`: gas drop is currently disabled
`minFinalityThreshold`	`1000` (V2 Fast) from Ethereum, Arbitrum, Base, Optimism, Unichain, Linea and World Chain; `2000` (V2 Norm) from every other chain
`maxFee`	`ceil(amount × ceil(minimumFee × 10) / 100000)` for that threshold, in USDC base units: Circle keeps up to this much on mint
`hookData` (EVM)	`0x00`. Circle rejects empty hook data, so `0x` reverts
Native value	`fee` when `isNative` is true (EVM `msg.value`, Aptos `native_amount`, Sui gas coin split), otherwise `0`
`recipient`, `solanaOwner`	See Recipient Encoding

What arrives. The contract takes amount × feeBP / 10000 from the USDC (feeBP is 0 today, at most 100, that is 1%), plus the quoted fee when isNative is false. On V2 Fast, Circle keeps up to maxFee when it mints. The recipient gets the rest.

Signed Payloads

The Gas API signs the same fields on every chain: local domain, destination domain, fee, deadline, isNative and the CCTP version. A V1 signature therefore never passes a V2 entry point, and the other way round. EVM checks an ECDSA signature over the raw digest (no \x19Ethereum Signed Message prefix):

bytes32 digest = keccak256(abi.encodePacked(
    uint32(localDomain),        // set from Circle's MessageTransmitter
    uint32(destinationDomain),
    uint128(fee),
    uint64(deadline),
    bool(isNative),
    uint8(2)                    // 1 for transfer, 2 for transferV2
));

Solana checks an Ed25519 signature over the Borsh encoding below, through an Ed25519 program instruction placed before the transfer instruction. Always request Solana quotes with version=1 or version=2: without it the message has no version byte and the program rejects it (InvalidMessageData).

struct TransferMessage {
    cctp_version: u8,        // 2 for transfer_v2
    local_domain: u32,       // 5
    destination_domain: u32,
    fee: u64,
    deadline: u64,
    fee_is_native: bool,
}

Aptos and Sui check an Ed25519 signature over the BCS encoding of TransferParamsV2 (TransferParams without cctp_version for V1). Request their quotes with version=2.

struct TransferParamsV2 has drop, copy {
    cctp_version: u8,        // 2
    local_domain: u32,       // 9 on Aptos, 8 on Sui
    destination_domain: u32,
    fee: u64,
    deadline: u64,
    fee_is_native: bool,
}

On the Ed25519 endpoint the message field of the quote is exactly these bytes, and publicKey is the signer key that the contracts store.

Recipient Encoding

Every chain takes the recipient as 32 bytes, and CCTP mints to whatever account those bytes name. An address in the wrong format doesn’t revert: the USDC arrives at an account nobody controls. The SDK’s recipientError(to, recipient) checks a recipient before you sign.

To an EVM chain: the 20-byte address, left-padded to 32 bytes (ethers.zeroPadValue(address, 32)).
To Solana (domain 5): recipient is the wallet’s USDC associated token account (ATA) and solanaOwner is the wallet itself, both as 32-byte hex. Cashmere’s relayers create the ATA if it doesn’t exist yet.
To Aptos or Sui: the 32-byte account address (0x and 64 hex characters). An EVM address padded to 32 bytes is not an Aptos or Sui account.
solanaOwner is 32 zero bytes for every destination other than Solana.

import bs58 from 'bs58';
import { PublicKey } from '@solana/web3.js';
import { getAssociatedTokenAddressSync } from '@solana/spl-token';

const SOLANA_USDC = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
const toHex = (key: PublicKey) => `0x${Buffer.from(key.toBytes()).toString('hex')}`;

// Into Solana: the wallet's USDC token account as recipient, the wallet as solanaOwner
export function solanaRecipient(wallet: string) {
  const owner = new PublicKey(wallet);
  return { recipient: toHex(getAssociatedTokenAddressSync(SOLANA_USDC, owner, true)), solanaOwner: toHex(owner) };
}

// From Solana: Anchor takes the 32-byte recipient as a number array
export const evmRecipientBytes = (address: string) =>
  Array.from(Buffer.from(address.slice(2).padStart(64, '0'), 'hex'));

EVM Implementation

Interface

interface ICashmereCCTP {
    struct TransferV2Params {
        uint64 amount;               // USDC, 6 decimals
        uint256 maxFee;              // Circle fee cap, USDC base units
        uint128 fee;                 // from the quote: USDC base units, or wei when isNative
        uint64 deadline;             // from the quote
        uint128 gasDropAmount;       // 0
        uint32 destinationDomain;
        uint32 minFinalityThreshold; // 1000 Fast, 2000 Norm
        bytes32 recipient;
        bytes32 solanaOwner;
        bool isNative;
        bytes hookData;              // 0x00
        bytes signature;             // 65-byte ECDSA signature from the quote
    }

    struct PermitParams {
        uint256 value;               // the transfer amount
        uint256 deadline;            // the permit's own deadline
        bytes signature;             // EIP-2612 permit signature
    }

    function transferV2(TransferV2Params memory _params) payable external;
    function transferV2WithPermit(TransferV2Params memory _params, PermitParams memory _permitParams) payable external;

    // V1 (legacy): transfer and transferWithPermit take TransferParams, the same fields without
    // maxFee, minFinalityThreshold and hookData

    function getFee(uint64 _amount, uint256 _staticFee) external view returns (uint64);
}

TransferV2

import { ethers } from 'ethers';

// Base (domain 6) to Arbitrum (domain 3), fee paid in ETH
const quote = await fetch(
  'https://gas.cashmere.exchange/getEcdsaSig_native?localDomain=6&destinationDomain=3&isNative=true&isV2=true',
).then(r => r.json());
const circleFees = await fetch('https://iris-api.circle.com/v2/burn/USDC/fees/6/3').then(r => r.json());
const fast = circleFees.find((f: { finalityThreshold: number }) => f.finalityThreshold === 1000);

const amount = ethers.parseUnits('100', 6);
const params = {
  amount,
  maxFee: (amount * BigInt(Math.ceil(fast.minimumFee * 10)) + 99_999n) / 100_000n,
  fee: BigInt(quote.fee),
  deadline: BigInt(quote.deadline),
  gasDropAmount: 0n,
  destinationDomain: 3,
  minFinalityThreshold: 1000,
  recipient: ethers.zeroPadValue(recipientAddress, 32),
  solanaOwner: ethers.ZeroHash,
  isNative: true,
  hookData: '0x00',
  signature: quote.signature,
};

// The contract pulls `amount` of USDC and takes its fee out of it
await (await usdc.approve(CASHMERE_CCTP_ADDRESS, amount)).wait();
const tx = await cashmere.transferV2(params, { value: params.isNative ? params.fee : 0n });
const receipt = await tx.wait();
if (receipt?.status !== 1) throw new Error('transfer reverted');

TransferV2WithPermit

Skip the approval transaction with an EIP-2612 permit for the same amount:

const permitParams = {
  value: params.amount,
  deadline: BigInt(Math.floor(Date.now() / 1000) + 600),
  signature: permitSignature, // 65-byte EIP-2612 signature from the user's wallet
};

const tx = await cashmere.transferV2WithPermit(params, permitParams, { value: params.isNative ? params.fee : 0n });
await tx.wait();

Security Features

Reentrancy: a lock flag in the contract state guards every transfer and fee withdrawal.
Signed quotes: the fee, deadline, route and version are signed by the Cashmere signer and checked on chain.
Fee cap: the percentage fee is at most 100 basis points (1%); it is 0 today.
Pause: the admin can pause transfers.

Solana Implementation

Program ID 5RsvKL6LFq6yEFiAXEwgYHAN3aLFypeB4AaafdeDnHqM, domain 5. Account addresses, the address lookup table and the CCTP program IDs are on Contract Addresses.

pub fn transfer_v2(
    ctx: Context<TransferV2Context>,
    usdc_amount: u64,
    destination_domain: u32,
    recipient: [u8; 32],
    solana_owner: [u8; 32],
    fee: u64,
    deadline: u64,
    gas_drop_amount: u64,
    fee_is_native: bool,
    max_fee: u64,
    min_finality_threshold: u32,
) -> Result<()>

The transaction needs three instructions in this order: a compute budget, the Ed25519 verification of the quote, and transfer_v2. transfer_v2 also needs a fresh keypair that signs as messageSentEventData, where Circle stores the burn message.

import { BN, Program } from '@coral-xyz/anchor';
import { ComputeBudgetProgram, Ed25519Program, Keypair, TransactionMessage, VersionedTransaction } from '@solana/web3.js';

// Solana (5) to Base (6), fee paid in SOL; Solana sends V2 Norm
const quote = await fetch(
  'https://gas.cashmere.exchange/getEd25519Sig_native?localDomain=5&destinationDomain=6&isNative=true&version=2',
).then(r => r.json());
const bytes = (hex: string) => Buffer.from(hex.slice(2), 'hex');

const program = new Program(idl, provider); // Anchor 0.30: the IDL carries the program ID
const messageSentEventData = Keypair.generate();
const transferIx = await program.methods
  .transferV2(new BN(amount), 6, evmRecipientBytes(recipient), new Array(32).fill(0),
    new BN(quote.fee), new BN(quote.deadline), new BN(0), true, new BN(maxFee.toString()), 2000)
  .accounts({ /* the accounts in src/chains/solana.ts of the SDK */ messageSentEventData: messageSentEventData.publicKey })
  .instruction();

const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
const tx = new VersionedTransaction(new TransactionMessage({
  payerKey: wallet.publicKey,
  recentBlockhash: blockhash,
  instructions: [
    ComputeBudgetProgram.setComputeUnitLimit({ units: 160_000 }),
    Ed25519Program.createInstructionWithPublicKey({
      publicKey: bytes(quote.publicKey),
      message: bytes(quote.message),
      signature: bytes(quote.signature),
    }),
    transferIx,
  ],
}).compileToV0Message([lookupTable]));
tx.sign([wallet, messageSentEventData]);

const signature = await connection.sendTransaction(tx);
const { value } = await connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, 'confirmed');
if (value.err) throw new Error(`transfer failed: ${JSON.stringify(value.err)}`);

Aptos Implementation

Module 0xe49afb1896889e3e1dd7bcbb9e31d1df8221899d3d368e98588ac6b4d84b136d::transfer, domain 9. Aptos sends V2 Norm (min_finality_threshold = 2000).

public entry fun transfer_v2_outer(
    sender: &signer,
    usdc_amount: u64,
    native_amount: u64,          // the fee when fee_is_native, otherwise 0
    destination_domain: u32,
    recipient: address,
    solana_owner: address,
    fee: u64,
    deadline: u64,
    gas_drop_amount: u64,        // 0
    fee_is_native: bool,
    max_fee: u64,
    min_finality_threshold: u32,
    signature: vector<u8>
)

import { Aptos, AptosConfig, Network } from '@aptos-labs/ts-sdk';

const aptos = new Aptos(new AptosConfig({ network: Network.MAINNET }));
const quote = await fetch(
  'https://gas.cashmere.exchange/getEd25519Sig_native?localDomain=9&destinationDomain=6&isNative=true&version=2',
).then(r => r.json());

const transaction = await aptos.transaction.build.simple({
  sender: account.accountAddress,
  data: {
    function: '0xe49afb1896889e3e1dd7bcbb9e31d1df8221899d3d368e98588ac6b4d84b136d::transfer::transfer_v2_outer',
    typeArguments: [],
    functionArguments: [
      amount.toString(),   // usdc_amount
      quote.fee,           // native_amount (fee_is_native is true)
      6,                   // destination_domain: Base
      recipientHex,        // 32-byte recipient
      '0x0',               // solana_owner
      quote.fee,
      quote.deadline,
      '0',                 // gas_drop_amount
      true,                // fee_is_native
      maxFee.toString(),
      2000,                // min_finality_threshold
      Array.from(Buffer.from(quote.signature.slice(2), 'hex')),
    ],
  },
});
const pending = await aptos.signAndSubmitTransaction({ signer: account, transaction });
const result = await aptos.waitForTransaction({ transactionHash: pending.hash });
if (!result.success) throw new Error(result.vm_status);

The module withdraws usdc_amount and burns it minus the USDC fee.

Sui Implementation

Calls go to the upgraded package 0x7eab670b3f3e3bb7a0451c7c6b6b627c09e282f0c78eac24966f6479c649d0d5; its types keep the original package ID 0xdf37112aacb7d3535f7b3b754b9a7b9fa1a6b3a756288dc734522c603c6f11a4. Domain 8. Sui sends V2 Norm (min_finality_threshold = 2000).

public fun prepare_deposit_for_burn_v2(
    usdc_coin: Coin<USDC>,
    native_fee_coin: Coin<SUI>,  // the fee in SUI when fee_is_native, otherwise a zero coin
    destination_domain: u32,
    recipient: address,
    solana_owner: address,
    fee: u64,
    deadline: u64,
    gas_drop_amount: u64,        // 0
    fee_is_native: bool,
    max_fee: u256,
    min_finality_threshold: u32,
    signature: vector<u8>,
    config: &mut Config,
    clock: &Clock,
    ctx: &mut TxContext,
): DepositForBurnWithPackageAuthTicket<USDC, Auth>

V2 runs Circle’s package-auth flow in one transaction: Cashmere takes its fee and returns a ticket, TokenMessengerMinter V2 turns it into a burn receipt, the USDC handler burns the coin, and complete_burn sends the message. The ticket and receipts can’t be stored or dropped, so the four calls must share a transaction.

import { Transaction, coinWithBalance } from '@mysten/sui/transactions';

const CASHMERE_V2 = '0x7eab670b3f3e3bb7a0451c7c6b6b627c09e282f0c78eac24966f6479c649d0d5';
const CASHMERE_TYPES = '0xdf37112aacb7d3535f7b3b754b9a7b9fa1a6b3a756288dc734522c603c6f11a4';
const CASHMERE_CONFIG = '0x5f1b2e205777713f44a99894d98e1e66e33dc11ff88e50108c94ee79b7ea3d67';
const TMM_V2 = '0xeb14978abfe93a37c5d5bf86a0623b923553a5f0e794daac7724f1e2fdbfb830';
const TMM_V2_STATE = '0x06fb166941cd7bc095edc019d054a753ec3f1e4c25f28f2ecc4a6cfa0a9b1167';
const MT_V2_STATE = '0x0c067f7d325e5b60e3179712e7783534ba1556cbb3d359d8161497e37689230c';
const USDC_HANDLER = '0x185ed207c4d64fc594882ab927f9f3c6ff957aad03df8a731ba64378faeeb2bf';
const USDC_HANDLER_STATE = '0xa32de8a6dd0178fb05f662929d55cddb69a25c26bde4b83f89e36d17ead94c41';
const USDC_TREASURY = '0x57d6725e7a8b49a7b2a612f6bd66ab5f39fc95332ca48be421c3229d514a6de7';
const USDC_TYPE = '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC';

// Sui (8) to Base (6), fee paid in SUI
const quote = await fetch(
  'https://gas.cashmere.exchange/getEd25519Sig_native?localDomain=8&destinationDomain=6&isNative=true&version=2',
).then(r => r.json());

const tx = new Transaction();
const [nativeFee] = tx.splitCoins(tx.gas, [tx.pure.u64(quote.fee)]);
const [ticket] = tx.moveCall({
  target: `${CASHMERE_V2}::transfer::prepare_deposit_for_burn_v2`,
  arguments: [
    coinWithBalance({ type: USDC_TYPE, balance: amount }), nativeFee,
    tx.pure.u32(6), tx.pure.address(recipientHex), tx.pure.address('0x0'),
    tx.pure.u64(quote.fee), tx.pure.u64(quote.deadline), tx.pure.u64(0), tx.pure.bool(true),
    tx.pure.u256(maxFee), tx.pure.u32(2000),
    tx.pure.vector('u8', Array.from(Buffer.from(quote.signature.slice(2), 'hex'))),
    tx.object(CASHMERE_CONFIG), tx.object('0x6'),
  ],
});
const [burnReceipt, burnCoin] = tx.moveCall({
  target: `${TMM_V2}::deposit_for_burn::deposit_for_burn_with_package_auth`,
  typeArguments: [USDC_TYPE, `${CASHMERE_TYPES}::transfer::Auth`],
  arguments: [ticket, tx.object(TMM_V2_STATE)],
});
const [completeBurnTicket] = tx.moveCall({
  target: `${USDC_HANDLER}::handler::burn`,
  arguments: [tx.object(USDC_HANDLER_STATE), burnReceipt, burnCoin, tx.object('0x403'), tx.object(USDC_TREASURY)],
});
tx.moveCall({
  target: `${TMM_V2}::deposit_for_burn::complete_burn`,
  typeArguments: [USDC_TYPE, `${USDC_HANDLER}::handler::Auth`],
  arguments: [completeBurnTicket, tx.object(TMM_V2_STATE), tx.object(MT_V2_STATE)],
});

const result = await client.signAndExecuteTransaction({ signer: keypair, transaction: tx });
if (result.$kind === 'FailedTransaction') {
  throw new Error(result.FailedTransaction.status.error?.message ?? 'transfer failed');
}

client is a SuiGrpcClient from @mysten/sui/grpc: Sui fullnodes no longer serve JSON-RPC.

Domain IDs

Circle CCTP domain IDs differ from chain IDs. Use them in every Gas API request and contract call.

Chain	Domain	V2 Fast source
Ethereum	0	Yes
Avalanche	1	No
Optimism	2	Yes
Arbitrum	3	Yes
Solana	5	No
Base	6	Yes
Polygon	7	No
Sui	8	No
Aptos	9	No
Unichain	10	Yes
Linea	11	Yes
Sonic	13	No
Worldchain	14	Yes
Monad	15	No
Sei	16	No
HyperEVM	19	No
Arc	26	No

Every chain can send V2 Norm to every other chain, and receive V2 Fast from the Fast sources.

Chain IDs

Chain	Chain ID
Ethereum	1
Avalanche	43114
Polygon	137
Arbitrum	42161
Optimism	10
Base	8453
Unichain	130
Linea	59144
Worldchain	480
Sei	1329
Sonic	146
HyperEVM	999
Monad	143
Arc	5042

Error Codes

EVM

Error	Meaning
`InvalidSignature()`	The quote’s signature doesn’t match its fields (a changed fee, deadline, route or version)
`InvalidSignatureLength()`	The signature is not 65 bytes
`DeadlineExpired()`	The quote’s deadline has passed: request a new quote
`FeeExceedsAmount()`	The USDC fee is larger than the amount
`NativeAmountTooLow()`	`msg.value` is below the native fee
`NativeTransferFailed()`	Returning the extra native value failed
`GasDropLimitExceeded()`	`gasDropAmount` is above the limit (pass 0)
`TransferFailed()`	Pulling the USDC failed: check the balance and approval
`ReentrancyError()`	A re-entrant call
`Paused()`	Transfers are paused

BPTooHigh(), ZeroLimit(), WithdrawCooldownNotPassed() and WithdrawLimitExceeded() come from admin functions.

Solana

Anchor numbers each error enum from 6000, so the same code can mean different errors: identify them by name in the transaction logs.

Error	Meaning
`NotSigVerified`, `InvalidSignatureData`, `InvalidDataFormat`, `LessDataThanExpected`	The Ed25519 instruction is missing, malformed or not directly before the transfer
`InvalidMessageData`	The signed message doesn’t match the call (wrong fields, or a quote requested without `version`)
`InvalidSignature`	The quote was not signed by the program’s signer key
`DeadlineExpired`	The quote’s deadline has passed
`FeeExceedsAmount`, `NativeAmountTooLow`	Not enough USDC or SOL for the fee
`GasDropLimitExceeded`	Pass a gas drop of 0
`InvalidDomain`	The destination domain is out of range
`Paused`	Transfers are paused

Aptos and Sui

Abort code	Aptos	Sui
`0x1000`	Wrong signature	Wrong signature
`0x1001`	Deadline expired	Deadline expired
`0x1002`	Gas drop limit exceeded	Gas drop limit exceeded
`0x1003`	Fee exceeds amount	Fee exceeds amount
`0x1004`	Native fee too low	Native fee too low
`0x1005`	Paused	Duplicate nonce
`0x1006`	Fee basis points above the maximum	Paused

Events

Every chain emits a CashmereTransfer event with the same fields, which Cashmere’s relayers and indexers read:

event CashmereTransfer(
    uint32 destinationDomain,
    uint256 indexed nonce,
    bytes32 recipient,
    bytes32 solanaOwner,
    address indexed user,
    uint64 amount,
    uint256 gasDropAmount,
    bool isNative
);

Admin Functions

Integrators never call these: they set the fee, the signer, the gas-drop limits and the pause flag, and withdraw collected fees. On EVM they are restricted to DEFAULT_ADMIN_ROLE (setFeeBP, setSigner, setMaxUSDCGasDrop, setMaxNativeGasDrop, setPaused, withdrawFee); Solana, Aptos and Sui have the equivalent owner-only instructions.

Best Practices

Use V2 entry points on every route.
Pass the quote’s fee and deadline unchanged, and request a new quote if the deadline is close.
Check the recipient format for the destination chain before signing.
Take maxFee from Circle Iris for the threshold you send.
Report a transfer only once its transaction is confirmed, and keep the transaction hash: delivery on the destination chain is automatic.
Use permits on EVM to skip the approval transaction.

View Source Code

Browse the contract repository

Welcome

Overview

Products

Goat Street

Goat LP

Developer Resources

API Reference

Overview

Entry Points

From Quote to Call

Signed Payloads

Recipient Encoding

EVM Implementation

Interface

TransferV2

TransferV2WithPermit

Security Features

Solana Implementation

Aptos Implementation

Sui Implementation

Domain IDs

Chain IDs

Error Codes

EVM

Solana

Aptos and Sui

Events

Admin Functions

Best Practices

View Source Code

​Overview

​Entry Points

​From Quote to Call

​Signed Payloads

​Recipient Encoding

​EVM Implementation

​Interface

​TransferV2

​TransferV2WithPermit

​Security Features

​Solana Implementation

​Aptos Implementation

​Sui Implementation

​Domain IDs

​Chain IDs

​Error Codes

​EVM

​Solana

​Aptos and Sui

​Events

​Admin Functions

​Best Practices

View Source Code

Overview

Entry Points

From Quote to Call

Signed Payloads

Recipient Encoding

EVM Implementation

Interface

TransferV2

TransferV2WithPermit

Security Features

Solana Implementation

Aptos Implementation

Sui Implementation

Domain IDs

Chain IDs

Error Codes

EVM

Solana

Aptos and Sui

Events

Admin Functions

Best Practices