How-to: Operate an EIP-3009 relayer on Arc

import { ethers } from "ethers";

const userAddress: string = "0x..."; // the user's address (the authorization signer)
const recipientAddress: string = "0x...";
const transferAmount: bigint = 10_000_000n; // 10 USDC in 6-decimal units

const USDC_ADDRESS = "0x3600000000000000000000000000000000000000";
const CHAIN_ID = 5042002;

const domain: ethers.TypedDataDomain = {
  name: "USDC",
  version: "2",
  chainId: CHAIN_ID,
  verifyingContract: USDC_ADDRESS,
};

const types = {
  TransferWithAuthorization: [
    { name: "from", type: "address" },
    { name: "to", type: "address" },
    { name: "value", type: "uint256" },
    { name: "validAfter", type: "uint256" },
    { name: "validBefore", type: "uint256" },
    { name: "nonce", type: "bytes32" },
  ],
};

// Generate a random bytes32 nonce for replay protection
const nonce: string = ethers.hexlify(ethers.randomBytes(32));
const validAfter: bigint = 0n;
const validBefore: bigint = BigInt(Math.floor(Date.now() / 1000) + 3600); // 1 hour

const message = {
  from: userAddress,
  to: recipientAddress,
  value: transferAmount, // amount in USDC token units (6 decimals)
  validAfter,
  validBefore,
  nonce,
};

// userSigner is an ethers.js v6 Signer connected to the user's wallet
const signature: string = await userSigner.signTypedData(
  domain,
  types,
  message,
);
const sig: ethers.Signature = ethers.Signature.from(signature);
// Pass sig.v, sig.r, and sig.s to the relayer along with the message fields

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("https://rpc.testnet.arc.io");

// Open .env in your editor and add your relayer private key:
// RELAYER_PRIVATE_KEY=your-private-key
// Keep this key secure. It controls the USDC gas supply for your relayer.
const relayerWallet = new ethers.Wallet(
  process.env.RELAYER_PRIVATE_KEY!,
  provider,
);

const USDC_ABI = [
  "function transferWithAuthorization(" +
    "address from, address to, uint256 value, " +
    "uint256 validAfter, uint256 validBefore, " +
    "bytes32 nonce, uint8 v, bytes32 r, bytes32 s" +
    ") external",
];

const usdc = new ethers.Contract(
  "0x3600000000000000000000000000000000000000",
  USDC_ABI,
  relayerWallet,
);

const tx = await usdc.transferWithAuthorization(
  message.from,
  message.to,
  message.value,
  message.validAfter,
  message.validBefore,
  message.nonce,
  sig.v,
  sig.r,
  sig.s,
);
const receipt = await tx.wait();

const FLOOR_FEE: bigint = 20_000_000_000n; // 20 Gwei

const feeData = await provider.getFeeData();
const maxFeePerGas: bigint =
  feeData.maxFeePerGas !== null && feeData.maxFeePerGas > FLOOR_FEE
    ? feeData.maxFeePerGas
    : FLOOR_FEE;

const gasEstimate: bigint = await usdc.transferWithAuthorization.estimateGas(
  message.from,
  message.to,
  message.value,
  message.validAfter,
  message.validBefore,
  message.nonce,
  sig.v,
  sig.r,
  sig.s,
);

const tx = await usdc.transferWithAuthorization(
  message.from,
  message.to,
  message.value,
  message.validAfter,
  message.validBefore,
  message.nonce,
  sig.v,
  sig.r,
  sig.s,
  {
    gasLimit: gasEstimate,
    maxFeePerGas,
    maxPriorityFeePerGas: 0n, // 0 Gwei; increase to 1 Gwei when load is high
  },
);
const receipt = await tx.wait();

const gasCostWei: bigint = receipt.gasUsed * receipt.effectiveGasPrice;
const gasCostUsdc: bigint = gasCostWei / 10n ** 12n; // in ERC-20 USDC units (6 decimals)