Quickstart: Deposit into xReserve from CCTP blockchains

PRIVATE_KEY=your-base-sepolia-private-key
MOVEMENT_RECIPIENT=your-movement-bardock-account-address
BASE_SEPOLIA_RPC_URL=https://sepolia.base.org

import {
  createPublicClient,
  createWalletClient,
  http,
  padHex,
  parseUnits,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { baseSepolia } from "viem/chains";

const privateKey = process.env.PRIVATE_KEY;
const recipient = process.env.MOVEMENT_RECIPIENT;
if (!privateKey || !/^0x[0-9a-fA-F]{64}$/.test(privateKey)) {
  throw new Error("Set PRIVATE_KEY to your Base Sepolia wallet key.");
}
if (!recipient || !/^0x[0-9a-fA-F]{1,64}$/.test(recipient)) {
  throw new Error(
    "Set MOVEMENT_RECIPIENT to your Movement Bardock account address.",
  );
}

export const account = privateKeyToAccount(privateKey as `0x${string}`);
export const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http(process.env.BASE_SEPOLIA_RPC_URL),
});
export const walletClient = createWalletClient({
  account,
  chain: baseSepolia,
  transport: http(process.env.BASE_SEPOLIA_RPC_URL),
});

export const SOURCE_DOMAIN = 6;
export const ARC_DOMAIN = 26;
export const REMOTE_DOMAIN = 10005;
export const AMOUNT = parseUnits("1", 6);
export const SOURCE_USDC = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
export const TMWF = "0x8745D906D67C346E5eb1aEEED38Eb87F34DF0C0A";
export const CIRCLE_WRAPPER = "0xEdC81040756AcCfF070c21D37b265b9D0b5Ba45e";
export const DEPOSIT_HANDLER = "0xD05E7D2E7d30b92c5F17d7d0fC575fce231F1A48";
export const XRESERVE = "0x008888878f94C0d87defdf0B07f46B93C1934442";
export const ARC_USDC = "0x3600000000000000000000000000000000000000";

// Movement uses its account address, left-padded to bytes32, and empty hook data.
export const REMOTE_RECIPIENT = padHex(
  `0x${recipient.slice(2).padStart(64, "0")}`,
  { size: 32 },
);
export const XRESERVE_HOOK_DATA = "0x";

import {
  type Address,
  type Hex,
  concatHex,
  encodeAbiParameters,
  encodeFunctionData,
  numberToHex,
  padHex,
  parseAbi,
  parseAbiParameters,
  size,
  stringToHex,
} from "viem";

interface DepositHookParams {
  recoveryAddress: Address;
  handler: Address;
  xreserve: Address;
  localToken: Address;
  remoteDomain: number;
  remoteRecipient: Hex;
  maxFee: bigint;
  xReserveHookData: Hex;
}

const WRAPPER_HOOK_MAGIC: Hex =
  "0x636972636c652d67656e657269632d6578656375746f7200";

function encodeHookFrame(magic: Hex, payload: Hex): Hex {
  return concatHex([
    magic,
    numberToHex(1, { size: 4 }),
    numberToHex(size(payload), { size: 4 }),
    payload,
  ]);
}

export function buildDepositHookData(params: DepositHookParams): Hex {
  const depositCalldata = encodeFunctionData({
    abi: parseAbi([
      "function depositToRemote(uint256 value, uint32 remoteDomain, bytes32 remoteRecipient, address localToken, uint256 maxFee, bytes hookData)",
    ]),
    functionName: "depositToRemote",
    args: [
      0n,
      params.remoteDomain,
      params.remoteRecipient,
      params.localToken,
      params.maxFee,
      params.xReserveHookData,
    ],
  });
  const handlerCalldata = encodeAbiParameters(
    parseAbiParameters(
      "address depositContract, address approvalTarget, bytes depositCalldata, uint256[] amountIndices",
    ),
    [params.xreserve, params.xreserve, depositCalldata, [4n]],
  );
  const wrapperPayload = encodeAbiParameters(
    parseAbiParameters(
      "uint8 payloadVersion, bytes32 recoveryAddress, address handler, bytes handlerCalldata",
    ),
    [
      1,
      padHex(params.recoveryAddress, { size: 32 }),
      params.handler,
      handlerCalldata,
    ],
  );
  return concatHex([
    encodeHookFrame(stringToHex("cctp-forward", { size: 24 }), "0x"),
    encodeHookFrame(WRAPPER_HOOK_MAGIC, wrapperPayload),
  ]);
}

import { padHex } from "viem";
import {
  account,
  AMOUNT,
  ARC_USDC,
  DEPOSIT_HANDLER,
  CIRCLE_WRAPPER,
  REMOTE_DOMAIN,
  REMOTE_RECIPIENT,
  SOURCE_USDC,
  XRESERVE,
  XRESERVE_HOOK_DATA,
} from "./config.ts";
import { buildDepositHookData } from "./hookData.ts";

export const wrapperBytes32 = padHex(CIRCLE_WRAPPER, { size: 32 });
export const hookData = buildDepositHookData({
  recoveryAddress: account.address,
  handler: DEPOSIT_HANDLER,
  xreserve: XRESERVE,
  localToken: ARC_USDC,
  remoteDomain: REMOTE_DOMAIN,
  remoteRecipient: REMOTE_RECIPIENT,
  maxFee: 0n,
  xReserveHookData: XRESERVE_HOOK_DATA,
});
export const quoteRequest = {
  amount: AMOUNT.toString(),
  feeToken: SOURCE_USDC,
  requests: [
    { type: "PRE_FINALITY" },
    {
      type: "FORWARD",
      params: { destinationCaller: wrapperBytes32, hookData },
    },
  ],
};

import { writeFileSync } from "node:fs";
import { quoteRequest } from "./request.ts";

writeFileSync("request.json", JSON.stringify(quoteRequest, null, 2));
console.log(
  "Created request.json with the amount, fee token, and composable hook data.",
);

import { readFileSync } from "node:fs";
import { type Hex, erc20Abi, parseAbi } from "viem";
import { baseSepolia } from "viem/chains";
import {
  account,
  AMOUNT,
  ARC_DOMAIN,
  publicClient,
  SOURCE_USDC,
  TMWF,
  walletClient,
} from "./config.ts";
import { wrapperBytes32, hookData, quoteRequest } from "./request.ts";

type Quote = {
  signedQuote: Hex;
  feeTotalAmount: string;
  feeToken: string;
  expiry:
    | { mode: "TIMESTAMP"; expiresAt: number }
    | { mode: "BLOCK_NUMBER"; expiresAtBlock: number };
};

if (
  JSON.stringify(JSON.parse(readFileSync("request.json", "utf8"))) !==
  JSON.stringify(quoteRequest)
) {
  throw new Error("Configuration changed. Repeat Step 4 before submitting.");
}
const quote: Quote = JSON.parse(readFileSync("quote.json", "utf8"));
if (
  !/^0x(?:[0-9a-fA-F]{2})+$/.test(quote.signedQuote) ||
  !/^\d+$/.test(quote.feeTotalAmount) ||
  quote.feeToken?.toLowerCase() !== SOURCE_USDC.toLowerCase()
) {
  throw new Error("Expected a successful quote with fees in source USDC.");
}

async function checkQuoteExpiry(): Promise<void> {
  const expiry = quote.expiry;
  const block = await publicClient.getBlock();
  if (
    expiry?.mode === "BLOCK_NUMBER" &&
    Number.isSafeInteger(expiry.expiresAtBlock)
  ) {
    if (block.number < BigInt(expiry.expiresAtBlock)) return;
  } else if (
    expiry?.mode === "TIMESTAMP" &&
    Number.isSafeInteger(expiry.expiresAt)
  ) {
    if (
      BigInt(Math.floor(Date.now() / 1000)) < BigInt(expiry.expiresAt) &&
      block.timestamp < BigInt(expiry.expiresAt)
    )
      return;
  }
  throw new Error(
    "Quote expired or expiry is invalid. Request a new quote in Step 4.",
  );
}

if ((await publicClient.getChainId()) !== baseSepolia.id) {
  throw new Error("The source RPC must point to Base Sepolia.");
}
await checkQuoteExpiry();
const approvalAmount: bigint = AMOUNT + BigInt(quote.feeTotalAmount);
const balance: bigint = await publicClient.readContract({
  address: SOURCE_USDC,
  abi: erc20Abi,
  functionName: "balanceOf",
  args: [account.address],
});
if (balance < approvalAmount)
  throw new Error("Insufficient USDC for the deposit and fee.");
const allowance: bigint = await publicClient.readContract({
  address: SOURCE_USDC,
  abi: erc20Abi,
  functionName: "allowance",
  args: [account.address, TMWF],
});
if (allowance < approvalAmount) {
  const approvalHash = await walletClient.writeContract({
    address: SOURCE_USDC,
    abi: erc20Abi,
    functionName: "approve",
    args: [TMWF, approvalAmount],
  });
  console.log("Approval transaction:", approvalHash);
  const approval = await publicClient.waitForTransactionReceipt({
    hash: approvalHash,
  });
  if (approval.status !== "success") throw new Error("USDC approval reverted.");
}

await checkQuoteExpiry();
const { request } = await publicClient.simulateContract({
  account,
  address: TMWF,
  abi: parseAbi([
    "function depositForBurnWithHookAndFees(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken, bytes32 destinationCaller, bytes hookData, (bytes signedQuote, address refundAddress) claim) payable",
  ]),
  functionName: "depositForBurnWithHookAndFees",
  args: [
    AMOUNT,
    ARC_DOMAIN,
    wrapperBytes32,
    SOURCE_USDC,
    wrapperBytes32,
    hookData,
    {
      signedQuote: quote.signedQuote,
      refundAddress: account.address,
    },
  ],
  value: 0n,
});
const burnHash = await walletClient.writeContract(request);
console.log("Source burn transaction:", burnHash);
const burn = await publicClient.waitForTransactionReceipt({ hash: burnHash });
if (burn.status !== "success")
  throw new Error("Source burn reverted. No transfer started.");
console.log(
  "Source burn confirmed. Track this transaction through both settlement legs.",
);