Cross-Chain USDC Transfers with CCTP

import {
  Address,
  BASE_FEE,
  Contract,
  Keypair,
  Networks,
  TransactionBuilder,
  nativeToScVal,
  rpc,
  xdr,
} from "@stellar/stellar-sdk";

// Testnet values. For mainnet, use Circle's mainnet contract list,
// the mainnet USDC SAC, and https://iris-api.circle.com.
const RPC_URL = "https://soroban-testnet.stellar.org";
const IRIS_URL = "https://iris-api-sandbox.circle.com";
const TOKEN_MESSENGER_MINTER =
  "CDNG7HXAPBWICI2E3AUBP3YZWZELJLYSB6F5CC7WLDTLTHVM74SLRTHP";
const USDC_SAC = "CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA";
const STELLAR_DOMAIN = 27;
const BASE_DOMAIN = 6;

// "cctp-forward", hook version 0, no extra data
const FORWARD_HOOK = Buffer.from(
  "636374702d666f72776172640000000000000000000000000000000000000000",
  "hex",
);

const server = new rpc.Server(RPC_URL);
const signer = Keypair.fromSecret(process.env.STELLAR_SECRET_KEY!);

function evmAddressToBytes32(address: string): Buffer {
  const hex = address.toLowerCase().replace(/^0x/, "");
  if (!/^[0-9a-f]{40}$/.test(hex)) {
    throw new Error(`Invalid EVM address: ${address}`);
  }
  return Buffer.from(hex.padStart(64, "0"), "hex");
}

async function invoke(contractId: string, method: string, args: xdr.ScVal[]) {
  const account = await server.getAccount(signer.publicKey());
  const tx = new TransactionBuilder(account, {
    fee: BASE_FEE,
    networkPassphrase: Networks.TESTNET,
  })
    .addOperation(new Contract(contractId).call(method, ...args))
    .setTimeout(60)
    .build();

  const prepared = await server.prepareTransaction(tx);
  prepared.sign(signer);
  const sent = await server.sendTransaction(prepared);
  if (sent.status !== "PENDING") {
    throw new Error(`Submit failed: ${sent.status}`);
  }
  const result = await server.pollTransaction(sent.hash);
  if (result.status !== rpc.Api.GetTransactionStatus.SUCCESS) {
    throw new Error(`Transaction failed: ${result.status}`);
  }
  return sent.hash;
}

async function quoteMaxFee(amount: bigint): Promise<bigint> {
  const res = await fetch(
    `${IRIS_URL}/v2/burn/USDC/fees/${STELLAR_DOMAIN}/${BASE_DOMAIN}?forward=true`,
  );
  const quotes = await res.json();
  const quote = quotes.find((q: any) => q.finalityThreshold === 2000);
  if (!quote) {
    throw new Error("No fee quote for finality threshold 2000");
  }
  // The live API returns forwardFee.med. Circle's spec names it medium.
  const forwardFee = quote.forwardFee.med ?? quote.forwardFee.medium;
  // minimumFee is in basis points. forwardFee uses 6 decimals, so
  // multiply by 10 for Stellar's 7-decimal units.
  const protocolFee =
    (amount * BigInt(Math.ceil(quote.minimumFee * 100))) / 1_000_000n;
  return protocolFee + BigInt(forwardFee) * 10n;
}

async function waitForAttestation(txHash: string) {
  while (true) {
    const res = await fetch(
      `${IRIS_URL}/v2/messages/${STELLAR_DOMAIN}?transactionHash=${txHash}`,
    );
    if (res.ok) {
      const { messages } = await res.json();
      if (messages?.[0]?.status === "complete") return messages[0];
    }
    await new Promise((resolve) => setTimeout(resolve, 5000));
  }
}

async function bridgeToBase(amount: bigint, evmRecipient: string) {
  const caller = signer.publicKey();
  const maxFee = await quoteMaxFee(amount);

  // Transaction 1: let the TokenMessengerMinter pull `amount` USDC.
  const { sequence } = await server.getLatestLedger();
  await invoke(USDC_SAC, "approve", [
    new Address(caller).toScVal(),
    new Address(TOKEN_MESSENGER_MINTER).toScVal(),
    nativeToScVal(amount, { type: "i128" }),
    nativeToScVal(sequence + 100, { type: "u32" }),
  ]);

  // Transaction 2: burn with the forwarding hook.
  const burnHash = await invoke(
    TOKEN_MESSENGER_MINTER,
    "deposit_for_burn_with_hook",
    [
      new Address(caller).toScVal(),
      nativeToScVal(amount, { type: "i128" }),
      nativeToScVal(BASE_DOMAIN, { type: "u32" }),
      nativeToScVal(evmAddressToBytes32(evmRecipient), { type: "bytes" }),
      new Address(USDC_SAC).toScVal(),
      nativeToScVal(Buffer.alloc(32), { type: "bytes" }), // any caller
      nativeToScVal(maxFee, { type: "i128" }),
      nativeToScVal(2000, { type: "u32" }),
      nativeToScVal(FORWARD_HOOK, { type: "bytes" }),
    ],
  );

  const message = await waitForAttestation(burnHash);
  console.log("Burn:", burnHash, "Forward state:", message.forwardState);
}

// 5 USDC in 7-decimal units
bridgeToBase(50_000_000n, "0xYourBaseSepoliaAddress").catch(console.error);