USDC from Base with CCTP and Crossmint

// Circle CCTP, mainnet. Sources in the table above.
export const cctp = {
  baseDomain: 6,
  stellarDomain: 27,
  baseTokenMessengerV2: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
  baseUsdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  stellarCctpForwarder: "CBZL2IH7F6BIDAA3WBNXYKIXSATJGMSW7K5P5MJ6STX5RXN47TZJDF5T",
  irisApi: "https://iris-api.circle.com",
};

export const stellar = {
  rpcUrl: process.env.STELLAR_SOROBAN_RPC_URL ?? "https://mainnet.sorobanrpc.com",
  networkPassphrase: "Public Global Stellar Network ; September 2015",
  // Funded classic account (G...) that pays the fee of mint_and_forward. See step 5.
  relayerSecret: process.env.STELLAR_RELAYER_SECRET!,
};

import { CrossmintRestClient } from "./shared/crossmint-rest.js";
import { config } from "./shared/config.js";

const rest = new CrossmintRestClient(config.apiKey, config.baseUrl);

const { address: evmWallet } = await rest.getOrCreateEvmWallet();   // 0x...
const stellarWallet = await rest.getStellarWalletAddress();          // C...

import { StrKey } from "@stellar/stellar-sdk";

function contractStrkeyToBytes32(strkey: string): `0x${string}` {
  if (!StrKey.isValidContract(strkey)) {
    throw new Error(`Invalid contract strkey: ${strkey}`);
  }
  return `0x${Buffer.from(StrKey.decodeContract(strkey)).toString("hex")}`;
}

// bytes 0-23 zero, 24-27 version (0), 28-31 recipient length, 32+ recipient strkey (UTF-8)
function buildCctpForwarderHookData(forwardRecipientStrkey: string): `0x${string}` {
  const isValid =
    StrKey.isValidEd25519PublicKey(forwardRecipientStrkey) ||
    StrKey.isValidContract(forwardRecipientStrkey) ||
    StrKey.isValidMed25519PublicKey(forwardRecipientStrkey);
  if (!isValid) throw new Error(`Invalid forward recipient: ${forwardRecipientStrkey}`);

  const recipientBytes = Buffer.from(forwardRecipientStrkey, "utf8");
  const hookData = Buffer.alloc(32 + recipientBytes.length);
  hookData.writeUInt32BE(0, 24);
  hookData.writeUInt32BE(recipientBytes.length, 28);
  recipientBytes.copy(hookData, 32);
  return `0x${hookData.toString("hex")}`;
}

const forwarderBytes32 = contractStrkeyToBytes32(cctp.stellarCctpForwarder);
const hookData = buildCctpForwarderHookData(stellarWallet); // the Crossmint C... address

import { ethers } from "ethers";

const erc20 = new ethers.Interface([
  "function approve(address spender, uint256 amount) returns (bool)",
]);
const tokenMessenger = new ethers.Interface([
  "function depositForBurnWithHook(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller, uint256 maxFee, uint32 minFinalityThreshold, bytes hookData)",
]);

const amount = ethers.parseUnits("100", 6); // 100 USDC on Base

// 4a. Allow TokenMessengerV2 to pull the USDC
await rest.sendTransactionAndGetHash(
  evmWallet,
  {
    to: cctp.baseUsdc,
    data: erc20.encodeFunctionData("approve", [cctp.baseTokenMessengerV2, amount]),
  },
  "base"
);

// 4b. Burn, Standard Transfer: maxFee 0, minFinalityThreshold 2000
const burnTxHash = await rest.sendTransactionAndGetHash(
  evmWallet,
  {
    to: cctp.baseTokenMessengerV2,
    data: tokenMessenger.encodeFunctionData("depositForBurnWithHook", [
      amount,
      cctp.stellarDomain,  // 27
      forwarderBytes32,    // mintRecipient = CctpForwarder
      cctp.baseUsdc,       // burnToken
      forwarderBytes32,    // destinationCaller = CctpForwarder
      0n,                  // maxFee
      2000,                // Standard Transfer
      hookData,
    ]),
  },
  "base"
);

interface AttestationMessage {
  message: string;     // 0x-prefixed hex
  attestation: string; // 0x-prefixed hex
  status: string;
}

async function waitForAttestation(burnTxHash: string): Promise<AttestationMessage> {
  const url = `${cctp.irisApi}/v2/messages/${cctp.baseDomain}?transactionHash=${burnTxHash}`;
  while (true) {
    const res = await fetch(url);
    if (res.ok) {
      const data = (await res.json()) as { messages?: AttestationMessage[] };
      const msg = data.messages?.[0];
      if (msg?.status === "complete") return msg;
    } else if (res.status !== 404) {
      console.warn(`Iris ${res.status}: ${await res.text()}`);
    }
    await new Promise((r) => setTimeout(r, 5000)); // Iris rate limit is 40 req/s
  }
}

const attestation = await waitForAttestation(burnTxHash);

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

async function mintAndForward(att: AttestationMessage): Promise<string> {
  const server = new rpc.Server(stellar.rpcUrl);
  const relayer = Keypair.fromSecret(stellar.relayerSecret);
  const account = await server.getAccount(relayer.publicKey());

  const messageBytes = Buffer.from(att.message.replace("0x", ""), "hex");
  const attestationBytes = Buffer.from(att.attestation.replace("0x", ""), "hex");

  const tx = new TransactionBuilder(account, {
    fee: "10000000",
    networkPassphrase: stellar.networkPassphrase,
  })
    .addOperation(
      new Contract(cctp.stellarCctpForwarder).call(
        "mint_and_forward",
        xdr.ScVal.scvBytes(messageBytes),
        xdr.ScVal.scvBytes(attestationBytes)
      )
    )
    .setTimeout(120)
    .build();

  const sim = await server.simulateTransaction(tx);
  if (rpc.Api.isSimulationError(sim)) throw new Error(`Simulation failed: ${sim.error}`);

  const prepared = rpc.assembleTransaction(tx, sim).build();
  prepared.sign(relayer);

  const sent = await server.sendTransaction(prepared);
  if (sent.status === "ERROR") throw new Error(`Send failed: ${JSON.stringify(sent)}`);

  let result = await server.getTransaction(sent.hash);
  while (result.status === "NOT_FOUND") {
    await new Promise((r) => setTimeout(r, 2000));
    result = await server.getTransaction(sent.hash);
  }
  if (result.status !== "SUCCESS") throw new Error(`mint_and_forward failed: ${sent.hash}`);
  return sent.hash;
}

const mintTxHash = await mintAndForward(attestation);

const VAULT = process.env.DEFINDEX_VAULT_ADDRESS!; // a USDC vault

const balance = await getStellarDepositBalance(stellarWallet); // USDC, 7 decimals
if (balance === 0n) throw new Error("USDC not in the wallet yet");

const depositTxHash = await depositToDefindexVault(rest, stellarWallet, VAULT, balance);