Quickstart: Deposit USDC into xReserve

mkdir xreserve-deposit-usdcx
cd xreserve-deposit-usdcx
npm init -y

npm pkg set type=module
npm pkg set scripts.start="node --env-file=.env index.ts"

npm install viem

npm install --save-dev typescript @types/node

npm install bech32

touch .env

PRIVATE_KEY=YOUR_PRIVATE_KEY
REMOTE_ADDRESS=YOUR_MOVEMENT_BARDOCK_ADDRESS
# RPC_URL=https://your-rpc.example  # optional; omit to use the chain default

import {
  createPublicClient,
  createWalletClient,
  formatUnits,
  http,
  parseUnits,
  type Address,
  type Hex,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { arcTestnet } from "viem/chains";

const X_RESERVE_CONTRACT =
  "0x008888878f94C0d87defdf0B07f46B93C1934442" as Address;
const USDC_ADDRESS = "0x3600000000000000000000000000000000000000" as Address;
const USDC_DECIMALS = 6;

// --- Remote chain config (Movement worked example; swap for your chain) ---
const REMOTE_DOMAIN = 10005;
const DEPOSIT_AMOUNT = 5;
const MAX_FEE = 0;
const REMOTE_ADDRESS = process.env.REMOTE_ADDRESS;
if (!REMOTE_ADDRESS) {
  throw new Error("Set REMOTE_ADDRESS in .env");
}

const remoteRecipient = (
  REMOTE_ADDRESS.startsWith("0x") ? REMOTE_ADDRESS : `0x${REMOTE_ADDRESS}`
) as Hex;
const hookData = "0x" as Hex;
// --- End remote chain config ---

const X_RESERVE_ABI = [
  {
    name: "depositToRemote",
    type: "function",
    stateMutability: "nonpayable",
    inputs: [
      { name: "value", type: "uint256" },
      { name: "remoteDomain", type: "uint32" },
      { name: "remoteRecipient", type: "bytes32" },
      { name: "localToken", type: "address" },
      { name: "maxFee", type: "uint256" },
      { name: "hookData", type: "bytes" },
    ],
    outputs: [],
  },
  {
    name: "RemoteDomainNotRegistered",
    type: "error",
    inputs: [{ name: "remoteDomain", type: "uint32" }],
  },
] as const;

const ERC20_ABI = [
  {
    name: "balanceOf",
    type: "function",
    stateMutability: "view",
    inputs: [{ name: "account", type: "address" }],
    outputs: [{ name: "", type: "uint256" }],
  },
  {
    name: "approve",
    type: "function",
    stateMutability: "nonpayable",
    inputs: [
      { name: "spender", type: "address" },
      { name: "amount", type: "uint256" },
    ],
    outputs: [{ name: "", type: "bool" }],
  },
] as const;

if (!process.env.PRIVATE_KEY) {
  throw new Error("Set PRIVATE_KEY in .env");
}

const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
const publicClient = createPublicClient({
  chain: arcTestnet,
  transport: http(process.env.RPC_URL),
});
const walletClient = createWalletClient({
  account,
  chain: arcTestnet,
  transport: http(process.env.RPC_URL),
});

try {
  const value = parseUnits(DEPOSIT_AMOUNT.toString(), USDC_DECIMALS);
  const maxFee = parseUnits(MAX_FEE.toString(), USDC_DECIMALS);

  const nativeBalance = await publicClient.getBalance({
    address: account.address,
  });
  const usdcBalance = await publicClient.readContract({
    address: USDC_ADDRESS,
    abi: ERC20_ABI,
    functionName: "balanceOf",
    args: [account.address],
  });

  console.log("Balance:", formatUnits(usdcBalance, USDC_DECIMALS), "USDC");

  if (nativeBalance === 0n) throw new Error("Insufficient balance for gas");
  if (usdcBalance < value) throw new Error("Insufficient USDC balance");

  const approveHash = await walletClient.writeContract({
    address: USDC_ADDRESS,
    abi: ERC20_ABI,
    functionName: "approve",
    args: [X_RESERVE_CONTRACT, value],
  });
  const approveReceipt = await publicClient.waitForTransactionReceipt({
    hash: approveHash,
  });
  if (approveReceipt.status !== "success") {
    throw new Error("USDC approve failed");
  }

  // Public RPCs can lag on sim: retry deposit if allowance isn't visible yet
  let depositHash: Hex | undefined;
  for (let attempt = 0; attempt < 3; attempt++) {
    try {
      depositHash = await walletClient.writeContract({
        address: X_RESERVE_CONTRACT,
        abi: X_RESERVE_ABI,
        functionName: "depositToRemote",
        args: [
          value,
          REMOTE_DOMAIN,
          remoteRecipient,
          USDC_ADDRESS,
          maxFee,
          hookData,
        ],
      });
      break;
    } catch (err) {
      const msg = err instanceof Error ? err.message : String(err);
      if (!msg.includes("transfer amount exceeds allowance") || attempt === 2) {
        throw err;
      }
      await new Promise((r) => setTimeout(r, 1_000));
    }
  }
  if (!depositHash) throw new Error("Deposit failed");
  await publicClient.waitForTransactionReceipt({ hash: depositHash });

  console.log(
    `Deposit confirmed: ${arcTestnet.blockExplorers.default.url}/tx/${depositHash}`,
  );
} catch (err) {
  console.error("Deposit failed:", err instanceof Error ? err.message : err);
  process.exit(1);
}

npm run start