Integration Examples

import { CashmereCCTP } from '@cashmerelabs/cashmere-agent-sdk';

const cctp = new CashmereCCTP({ evm: { privateKey: process.env.EVM_PRIVATE_KEY! } });

// One transfer at a time from the same wallet, and each one confirmed before the next
for (const { to, recipient, amount } of routes) {
  const { txHash, explorerUrl } = await cctp.transfer({ from: 'base', to, amount, recipient });
  console.log(to, txHash, explorerUrl);
}

const bridge = useCallback(async ({ amount, destinationDomain, isNative }) => {
  assertWalletConnected();

  // A fresh quote for every transfer: it expires about 100 seconds after it is issued
  const quote = await fetchEcdsaQuote({ localDomain, destinationDomain, isV2: true, isNative });

  const params = buildTransferV2Params({
    amount,
    destinationDomain,
    quote,              // fee and deadline go in unchanged: they are signed
    isNative,
    recipient: toBytes32(destinationAddress),
  });

  await ensureAllowance(params.amount);
  return cashmere.transferV2(params, { value: isNative ? params.fee : 0n });
}, [provider, cashmere, usdc]);

async function distribute({ amount, fromDomain, routes }) {
  const signer = buildSigner(fromDomain);
  const cashmere = loadCashmereContract(fromDomain, signer);
  const usdc = loadUsdcContract(fromDomain, signer);

  // The contract pulls exactly `amount` per transfer
  await (await usdc.approve(cashmere.target, amount * BigInt(routes.length))).wait();

  for (const route of routes) {
    const quote = await fetchEcdsaQuote({
      localDomain: fromDomain,
      destinationDomain: route.domain,
      isV2: true,
      isNative: route.isNativeFee,
    });

    const params = buildTransferV2Params({
      amount,
      destinationDomain: route.domain,
      quote,
      isNative: route.isNativeFee,
      recipient: route.recipient,
    });
    const tx = await cashmere.transferV2(params, { value: route.isNativeFee ? params.fee : 0n });
    await tx.wait(); // one at a time, so nonces and allowances stay in order
  }
}

async function fetchRecentTransfers(address: string) {
  const url = new URL('https://kapi.cashmere.exchange/transactionsmainnet');
  url.searchParams.set('senders', address);
  url.searchParams.set('limit', '25');

  const res = await fetch(url.toString());
  if (!res.ok) throw new Error('Failed to fetch transactions');
  const body = await res.json();

  return body.transactions.map((tx) => ({
    hash: tx.source_tx_hash,
    route: `${tx.source_domain} → ${tx.destination_domain}`,
    amount: Number(tx.deposit_amount) / 1e6,                // USDC has 6 decimals
    received: tx.receive_amount == null ? null : Number(tx.receive_amount) / 1e6,
    // USDC base units, or the source chain's smallest native unit (wei, lamports, octas, MIST) when paid natively.
    // It is a JSON number, so wei values above 2^53 arrive rounded: fine for display, not for accounting
    relayerFee: tx.is_gas_drop_in_native ? { native: tx.relayer_fee } : { usdc: Number(tx.relayer_fee) / 1e6 },
    status:
      tx.destination_tx_status === 'success' ? 'completed'
      : tx.destination_tx_status === 'failed' ? 'failed'      // see tx.destination_tx_error
      : tx.confirmed ? 'in progress'
      : 'pending',
  }));
}

const quote = await fetchEd25519Quote({ localDomain: 5, destinationDomain, isNative: isNativeFee, version: 2 });
const config = await loadCashmereConfig(connection);

const signatureIx = buildEd25519Ix(quote); // the quote's publicKey, message and signature
const transferIx = await cashmereProgram.methods.transferV2(
  new BN(amount.toString()),
  destinationDomain,
  recipientBytes,                // 32 bytes, see Recipient Encoding
  solanaOwnerBytes,              // 32 zero bytes unless the destination is Solana
  new BN(quote.fee),
  new BN(quote.deadline),
  new BN(0),                     // gas drop is currently disabled
  isNativeFee,
  new BN(maxFee.toString()),
  new BN(2000),                  // Solana sends V2 Norm
).accounts(buildAccountMap({ owner, config, destinationDomain })).instruction();

const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
const tx = assembleAndSign({
  payer: owner,
  blockhash,
  ixs: [setComputeUnits(), signatureIx, transferIx],
  lookupTables: [cashmereLookupTable],
  additionalSigners: [messageSentEventData], // a fresh keypair per transfer
});

const signature = await connection.sendTransaction(tx);
await connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, 'confirmed');

const quote = await fetchEd25519Quote({ localDomain: 8, destinationDomain, isNative, version: 2 });

const tx = new Transaction();
const ids = loadSuiConstants(); // the package and object IDs from Smart Contracts → Sui
const [nativeFee] = tx.splitCoins(tx.gas, [tx.pure.u64(isNative ? quote.fee : '0')]);

const [ticket] = tx.moveCall({
  target: `${ids.cashmereV2}::transfer::prepare_deposit_for_burn_v2`,
  arguments: buildPrepareV2Args({ tx, quote, nativeFee, amount, recipientHex, solanaOwnerHex, maxFee, ids }),
});
const [burnReceipt, burnCoin] = tx.moveCall({
  target: `${ids.tmmV2}::deposit_for_burn::deposit_for_burn_with_package_auth`,
  typeArguments: [ids.usdcType, `${ids.cashmereTypes}::transfer::Auth`],
  arguments: [ticket, tx.object(ids.tmmV2State)],
});
const [completeBurnTicket] = tx.moveCall({
  target: `${ids.usdcHandler}::handler::burn`,
  arguments: [tx.object(ids.usdcHandlerState), burnReceipt, burnCoin, tx.object('0x403'), tx.object(ids.usdcTreasury)],
});
tx.moveCall({
  target: `${ids.tmmV2}::deposit_for_burn::complete_burn`,
  typeArguments: [ids.usdcType, `${ids.usdcHandler}::handler::Auth`],
  arguments: [completeBurnTicket, tx.object(ids.tmmV2State), tx.object(ids.mtV2State)],
});

await wallet.signAndExecuteTransaction({ transaction: tx });

const quote = await fetchEd25519Quote({ localDomain: 9, destinationDomain, isNative, version: 2 });

const tx = await aptos.transaction.build.simple({
  sender,
  data: {
    function: '0xe49afb1896889e3e1dd7bcbb9e31d1df8221899d3d368e98588ac6b4d84b136d::transfer::transfer_v2_outer',
    typeArguments: [],
    functionArguments: [
      amount.toString(), isNative ? quote.fee : '0', destinationDomain, recipientHex, solanaOwnerHex,
      quote.fee, quote.deadline, '0', isNative, maxFee.toString(), 2000,
      Array.from(Buffer.from(quote.signature.slice(2), 'hex')),
    ],
  },
});
const submission = await signer.signAndSubmitTransaction({ transaction: tx });
await aptos.waitForTransaction({ transactionHash: submission.hash });