FACTOR Integration

https://api.nest.credit/v1/actions

curl -X POST https://api.nest.credit/v1/actions/vaults/plume-factor-vault/mint/quote \
  -H 'content-type: application/json' \
  -d '{
    "depositAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "depositAmount": "1000000",
    "chainId": 98866
  }'

{
  "data": {
    "slug": "plume-factor-vault",
    "shareTokenAddress": "0x1f37620a0e0660db3cdbb8cdbf62d8099f959925",
    "depositAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "depositAmount": "1000000",
    "depositDecimals": 6,
    "shareAmount": "...",
    "shareDecimals": 6,
    "rate": "...",
    "rateDecimals": 6,
    "feeAmount": "0",
    "fees": {
      "ratePpm": 0,
      "flatAmount": "0",
      "maxRatePpm": 0,
      "maxFlatAmount": "0"
    },
    "steps": [
      { "label": "approve", "description": "Approve PredicateProxy to spend the deposit asset" },
      { "label": "deposit", "description": "Deposit through NestVaultPredicateProxy" }
    ]
  }
}

curl -X POST https://api.nest.credit/v1/actions/vaults/plume-factor-vault/mint/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "depositAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "depositAmount": "1000000",
    "chainId": 98866,
    "recipient": "0x00000000000000000000000000000000000000ab"
  }'

curl -X POST https://api.nest.credit/v1/actions/vaults/plume-factor-vault/redeem/quote \
  -H 'content-type: application/json' \
  -d '{
    "redemptionAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "shareAmount": "1000000",
    "chainId": 98866
  }'

curl -X POST https://api.nest.credit/v1/actions/vaults/plume-factor-vault/redeem/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "redemptionAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "shareAmount": "1000000",
    "chainId": 98866,
    "user": "0x00000000000000000000000000000000000000ab"
  }'

curl -X POST https://api.nest.credit/v1/actions/vaults/plume-factor-vault/claim/pending \
  -H 'content-type: application/json' \
  -d '{
    "redemptionAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "chainId": 98866,
    "user": "0x00000000000000000000000000000000000000ab"
  }'

curl -X POST https://api.nest.credit/v1/actions/vaults/plume-factor-vault/claim/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "redemptionAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "chainId": 98866,
    "user": "0x00000000000000000000000000000000000000ab"
  }'

POST /vaults/plume-factor-vault/update-redeem/pending
POST /vaults/plume-factor-vault/update-redeem/build-tx

POST /vaults/plume-factor-vault/instant-redeem/quote
POST /vaults/plume-factor-vault/instant-redeem/liquidity
POST /vaults/plume-factor-vault/instant-redeem/build-tx

import { encodeFunctionData, parseUnits } from "viem";

const chainId = 98866;
const recipient = "0x00000000000000000000000000000000000000ab";
const depositAsset = "0x222365ef19f7947e5484218551b56bb3965aa7af";
const depositAmount = parseUnits("1", 6);
const nestVault = "0xb195aebf42c93b50e768a97fd3087bb004b4187f";
const predicateProxy = "0xfc0c4222b3a0c9b060c0b959dec62442036b9035";

// 1. previewDeposit on nestVault
// 2. get Predicate message for recipient
// 3. approve depositAsset -> predicateProxy
// 4. encode PredicateProxy deposit call
const data = encodeFunctionData({
  abi: NestVaultPredicateProxyAbi,
  functionName: "deposit",
  args: [depositAsset, depositAmount, recipient, nestVault, predicateMessage],
});

https://api.nest.credit/v1/solana

curl -X POST https://api.nest.credit/v1/solana/nest/mint/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "rawAmountUsdc": 1000000,
    "finality": "standard",
    "nestVaultSlug": "plume-factor-vault",
    "receiver": "CFagSTMBFiMaD4YKHr7mMcKTzpi35DqiBKbDA35BvZgr"
  }'

{
  "data": {
    "txBase64": "..."
  }
}

{
  "nestVaultSlug": "plume-factor-vault",
  "rawAmountUsdc": 1000000,
  "receiver": "<USER_SOLANA_PUBKEY>",
  "feePayer": "<RELAY_SOLANA_PUBKEY>",
  "finality": "fast"
}

{
  "nestVaultSlug": "plume-factor-vault",
  "rawAmountNestToken": "1000000",
  "owner": "<USER_SOLANA_PUBKEY>",
  "feePayer": "<RELAY_SOLANA_PUBKEY>"
}

{
  "nestVaultSlug": "plume-factor-vault",
  "newRawAmountNestToken": "0",
  "owner": "<USER_SOLANA_PUBKEY>",
  "feePayer": "<RELAY_SOLANA_PUBKEY>"
}

curl https://api.nest.credit/v1/solana/redeem-status/<SOLANA_REDEEM_TX_SIGNATURE>

curl -X POST https://api.nest.credit/v1/solana/nest/redeem/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "rawAmountNestToken": 1000000,
    "nestVaultSlug": "plume-factor-vault",
    "owner": "CFagSTMBFiMaD4YKHr7mMcKTzpi35DqiBKbDA35BvZgr"
  }'

{
  "data": {
    "txBase64": "..."
  }
}

{
  "nestVaultSlug": "plume-factor-vault",
  "rawAmountNestToken": 1000000,
  "owner": "<USER_SOLANA_PUBKEY>",
  "feePayer": "<RELAY_SOLANA_PUBKEY>"
}

import { Connection, PublicKey, VersionedTransaction } from "@solana/web3.js";

export async function mintWithApi(
  connection: Connection,
  wallet: {
    publicKey: PublicKey;
    signTransaction(tx: VersionedTransaction): Promise<VersionedTransaction>;
  },
) {
  const response = await fetch("https://api.nest.credit/v1/solana/nest/mint/build-tx", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({
      nestVaultSlug: "plume-factor-vault",
      rawAmountUsdc: 1_000_000,
      receiver: wallet.publicKey.toBase58(),
      finality: "standard",
    }),
  });
  if (!response.ok) throw new Error(await response.text());
  const { data } = await response.json();
  const bytes = Uint8Array.from(atob(data.txBase64), c => c.charCodeAt(0));
  const transaction = VersionedTransaction.deserialize(bytes);
  // Keep the message and its keeper/event-account signatures intact.
  const signed = await wallet.signTransaction(transaction);
  return connection.sendRawTransaction(signed.serialize(), { skipPreflight: false });
}

import { AnchorProvider, BN, Program, type Idl } from "@coral-xyz/anchor";
import {
  ComputeBudgetProgram, Keypair, PublicKey, SystemProgram,
  TransactionMessage, VersionedTransaction,
} from "@solana/web3.js";
import {
  createAssociatedTokenAccountIdempotentInstruction,
  getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID,
} from "@solana/spl-token";
import { ethers } from "ethers";
// Save the linked Circle v2 IDLs in ./idl/.
import tokenMessengerIdl from "./idl/token_messenger_minter_v2.json";
import messageTransmitterIdl from "./idl/message_transmitter_v2.json";
import { signAndSubmit } from "./submit"; // submission helper below

export async function buildMintLocally(
  provider: AnchorProvider,
  user: PublicKey, // USDC owner AND share receiver, not a token account
  amount = 1_000_000n, // 1 USDC, six decimals
  finality: "standard" | "fast" = "standard",
  microLamports = 0, // choose a current priority fee before collecting signatures
) {
  if (amount <= 0n || amount > BigInt(Number.MAX_SAFE_INTEGER)) {
    throw new Error("Amount must be positive and safe for the current fee calculation");
  }
  const connection = provider.connection;
  const tmm = new Program(tokenMessengerIdl as Idl, provider);
  const mt = new Program(messageTransmitterIdl as Idl, provider);
  const usdc = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
  const shareMint = new PublicKey("6ESVavhfwC4rXHHHZmR6ajg7nLmL6X5UkpZuAcoA7xj7");
  const composer = "0x6fa27f5447a5ec7b8246d71aab6d7d7c7066d520";
  const relayer = "0x7de01896d36Bea9CF072Ac64E41685418941d8bE";
  const usdcAta = getAssociatedTokenAddressSync(usdc, user);
  const shareAta = getAssociatedTokenAddressSync(shareMint, user);
  const instructions = [
    ComputeBudgetProgram.setComputeUnitLimit({ units: 150_000 }),
    ComputeBudgetProgram.setComputeUnitPrice({ microLamports }),
  ];
  if (!(await connection.getAccountInfo(shareAta))) {
    instructions.push(createAssociatedTokenAccountIdempotentInstruction(
      user, shareAta, user, shareMint,
    ));
  }

  const minFinalityThreshold = finality === "fast" ? 1000 : 2000;
  const response = await fetch("https://iris-api.circle.com/v2/burn/USDC/fees/5/22");
  if (!response.ok) throw new Error("Circle fee lookup failed");
  const rows: { finalityThreshold: number; minimumFee: number }[] = await response.json();
  const row = rows.find(r => r.finalityThreshold === minFinalityThreshold);
  if (!row || !Number.isFinite(row.minimumFee) || row.minimumFee < 0) {
    throw new Error("Missing or invalid finality fee");
  }
  // minimumFee is in basis points; round the fee up to a USDC base unit.
  const maxFee = BigInt(Math.ceil(row.minimumFee * Number(amount) / 10_000));
  if (maxFee >= amount) throw new Error("No net USDC remaining");
  const abi = ethers.AbiCoder.defaultAbiCoder();
  const callData = abi.encode(
    ["bytes32", "uint256", "(uint32,bytes32,uint256,uint256,bytes,bytes,bytes)", "address"],
    [
      ethers.hexlify(usdcAta.toBytes()), // refundTo is a USDC TOKEN ACCOUNT
      amount - maxFee,
      [30168, ethers.hexlify(user.toBytes()), 0n, 0n, "0x", "0x", "0x"],
      composer, // EVM refundAddress
    ],
  );
  // sendParam.to above is the receiver WALLET, not shareAta.
  const hookData = Buffer.from(ethers.getBytes(ethers.solidityPacked(
    ["address", "bytes4", "bytes"], [composer, "0xfe030ec4", callData],
  )));
  const pda = (program: PublicKey, seed: string, ...extra: Buffer[]) =>
    PublicKey.findProgramAddressSync([Buffer.from(seed), ...extra], program)[0];
  const eventAccount = Keypair.generate();
  const relayerBytes32 = new PublicKey(ethers.getBytes(ethers.zeroPadValue(relayer, 32)));
  const burn = await tmm.methods.depositForBurnWithHook({
    amount: new BN(amount.toString()), destinationDomain: 22,
    mintRecipient: relayerBytes32, destinationCaller: relayerBytes32,
    maxFee: new BN(maxFee.toString()), minFinalityThreshold, hookData,
  }).accounts({
    owner: user,
    eventRentPayer: user, // user funds the temporary CCTP event account
    senderAuthorityPda: pda(tmm.programId, "sender_authority"),
    burnTokenAccount: usdcAta,
    denylistAccount: pda(tmm.programId, "denylist_account", user.toBuffer()),
    messageTransmitter: pda(mt.programId, "message_transmitter"),
    tokenMessenger: pda(tmm.programId, "token_messenger"),
    remoteTokenMessenger: pda(tmm.programId, "remote_token_messenger", Buffer.from("22")),
    tokenMinter: pda(tmm.programId, "token_minter"),
    localToken: pda(tmm.programId, "local_token", usdc.toBuffer()),
    burnTokenMint: usdc,
    messageSentEventData: eventAccount.publicKey,
    messageTransmitterProgram: mt.programId,
    tokenMessengerMinterProgram: tmm.programId,
    tokenProgram: TOKEN_PROGRAM_ID, systemProgram: SystemProgram.programId,
    eventAuthority: pda(tmm.programId, "__event_authority"), program: tmm.programId,
  }).instruction();

  const { value: lookup } = await connection.getAddressLookupTable(
    new PublicKey("2Hd1BW1xK5wPZB8zKm9Diu9zvadZJSpK47QyP6CbedM6"),
  );
  if (!lookup || !lookup.isActive()) throw new Error("Missing/inactive lookup table");
  const validity = await connection.getLatestBlockhash("confirmed");
  const transaction = new VersionedTransaction(new TransactionMessage({
    payerKey: user, recentBlockhash: validity.blockhash,
    instructions: [...instructions, burn],
  }).compileToV0Message([lookup]));
  transaction.sign([eventAccount]);
  // signAndSubmit below adds the user's signature, preserving the event signature.
  // Save the event account address with the source signature for later rent recovery.
  return { transaction, validity, eventAccount: eventAccount.publicKey };
}

export async function mintAndSubmit(provider: AnchorProvider, amount: bigint) {
  const { transaction, validity, eventAccount } = await buildMintLocally(
    provider, provider.wallet.publicKey, amount,
  );
  const signature = await signAndSubmit(provider.connection, provider.wallet, transaction, validity);
  return { signature, eventAccount }; // retain both for status tracking and rent recovery
}

import { Connection, PublicKey, TransactionMessage, VersionedTransaction,
  ComputeBudgetProgram } from "@solana/web3.js";
import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync,
  createAssociatedTokenAccountIdempotentInstruction } from "@solana/spl-token";
import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
import { publicKey, createNoopSigner, signerIdentity } from "@metaplex-foundation/umi";
import { mplToolbox, fetchToken } from "@metaplex-foundation/mpl-toolbox";
import { toWeb3JsInstruction } from "@metaplex-foundation/umi-web3js-adapters";
import { oft } from "@layerzerolabs/oft-v2-solana-sdk";
import { Options, addressToBytes32 } from "@layerzerolabs/lz-v2-utilities";
import { ethers } from "ethers";

const tuple = "tuple(uint32 dstEid,bytes32 to,uint256 amountLD,uint256 minAmountLD,bytes extraOptions,bytes composeMsg,bytes oftCmd)";
const composerAddress = "0x6fa27f5447a5ec7b8246d71aab6d7d7c7066d520";
const abi = ethers.AbiCoder.defaultAbiCoder();

export async function buildRedeemLocally(
  connection: Connection,
  owner: PublicKey,
  mode: "instant" | "request" | "update",
  rawAmount: bigint, // update: FINAL pending amount; 0n cancels, never a delta
  plumeRpcUrl = "https://rpc.plume.org",
  microLamports = 0,
) {
  if (rawAmount < 0n || rawAmount > 18_446_744_073_709_551_615n ||
      (mode !== "update" && rawAmount === 0n)) throw new Error("Invalid raw u64 amount");
  const umi = createUmi(connection.rpcEndpoint).use(mplToolbox());
  const signer = createNoopSigner(publicKey(owner.toBase58()));
  umi.use(signerIdentity(signer)); // construction only; does not sign
  const programId = publicKey("ChEfPd3RzLeYiRwp1K9evimmaFSd6DV1S4Mv5q5Aj1th");
  const storeKey = publicKey("DhS3uG7QxsDkwA3oWm4siCazZ3JaQqZBW85cHXdfU6RD");
  const store = await oft.accounts.fetchOFTStore(umi, storeKey);
  const storeAccount = await connection.getAccountInfo(new PublicKey(storeKey));
  if (!storeAccount?.owner.equals(new PublicKey(programId)) ||
      store.tokenMint !== "6ESVavhfwC4rXHHHZmR6ajg7nLmL6X5UkpZuAcoA7xj7") throw new Error("Unexpected OFT store");
  const mint = new PublicKey(store.tokenMint);
  const escrow = new PublicKey(store.tokenEscrow); // read state, NOT the owner's ATA
  console.log("Vault token escrow:", escrow.toBase58());
  const [derivedStore] = PublicKey.findProgramAddressSync(
    [Buffer.from("OFT"), escrow.toBuffer()], new PublicKey(programId),
  );
  if (derivedStore.toBase58() !== storeKey) throw new Error("OFT PDA mismatch");

  const solanaDecimals = 9;
  const plumeDecimals = 6;
  const difference = solanaDecimals - plumeDecimals;
  const rate = 10n ** BigInt(Math.max(difference, 0));
  if (BigInt(store.ld2sdRate) !== rate) throw new Error("Unexpected OFT conversion rate");
  if (rawAmount % rate !== 0n) throw new Error("OFT dust: choose an exactly representable amount");
  const plumeAmount = difference >= 0
    ? rawAmount / rate : rawAmount * 10n ** BigInt(-difference);
  const shareAta = getAssociatedTokenAddressSync(mint, owner);
  const usdc = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
  const usdcAta = getAssociatedTokenAddressSync(usdc, owner);
  const balance = (await fetchToken(umi, publicKey(shareAta.toBase58()))).amount;
  const transferAmount = mode === "update" ? 0n : rawAmount;
  if (balance < transferAmount) throw new Error("Insufficient shares");

  let recipient = ethers.hexlify(usdcAta.toBytes()); // USDC token account
  let minMsgValue = 0n; // destination PLUME native units, not SOL lamports
  if (mode === "update") {
    const provider = new ethers.JsonRpcProvider(plumeRpcUrl);
    const composer = new ethers.Contract(composerAddress, [
      "function version() view returns (string)",
      "function SHARE_OFT() view returns (address)",
      "function pendingRedeem(bytes32,uint32) view returns (uint256 shares)",
      "function pendingRedeem(bytes32,bytes32,uint32) view returns (uint256 shares)",
    ], provider);
    // Fail on an unreadable version; do not silently assume a legacy composer.
    const version: string = await composer.version();
    const parts = /^(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?(?:\+.+)?$/.exec(version);
    if (!parts) throw new Error("Unrecognized composer version");
    const [, major, minor, patch, prerelease] = parts;
    const receiverKeyed = Number(major) > 1 || (Number(major) === 1 &&
      (Number(minor) > 2 || (Number(minor) === 2 && (Number(patch) > 0 || !prerelease))));
    const redeemer = ethers.hexlify(owner.toBytes()); // wallet
    const pending: bigint = receiverKeyed
      ? await composer["pendingRedeem(bytes32,bytes32,uint32)"](redeemer, recipient, 30168)
      : await composer["pendingRedeem(bytes32,uint32)"](redeemer, 30168);
    if (pending === 0n || plumeAmount > pending) throw new Error("Invalid pending amount");
    if (!receiverKeyed) recipient = redeemer; // legacy update uses wallet, >=1.2.0 uses USDC ATA
    const returnAmount = pending - plumeAmount;
    if (returnAmount > 0n) {
      const shareOft = new ethers.Contract(await composer.SHARE_OFT(), [
        "function quoteSend(" + tuple + ",bool) view returns (tuple(uint256 nativeFee,uint256 lzTokenFee))",
      ], provider);
      const fee = await shareOft.quoteSend(
        [30168, redeemer, returnAmount, 0n, "0x", "0x", "0x"], false,
      );
      minMsgValue = fee.nativeFee; // funds the Plume -> Solana share return
    }
  }
  const command = mode === "instant" ? 0 : mode === "request" ? 1 : 2;
  const inner = [
    mode === "request" ? 30370 : 30168,
    recipient, mode === "instant" ? 0n : plumeAmount, 0n,
    "0x", "0x", abi.encode(["uint8"], [command]),
  ];
  const composeMsg = Buffer.from(ethers.getBytes(abi.encode([tuple, "uint256"], [inner, minMsgValue])));
  const options = Options.newOptions().addExecutorComposeOption(
    0, mode === "update" ? 350_000 : 100_000, minMsgValue,
  );
  const params = {
    dstEid: 30370, to: Buffer.from(addressToBytes32(composerAddress)),
    amountLd: transferAmount, minAmountLd: transferAmount,
    options: Buffer.from(options.toHex().slice(2), "hex"), composeMsg,
  };
  const lookupKey = new PublicKey("2Hd1BW1xK5wPZB8zKm9Diu9zvadZJSpK47QyP6CbedM6");
  const { value: lookup } = await connection.getAddressLookupTable(lookupKey);
  if (!lookup || !lookup.isActive()) throw new Error("Missing/inactive lookup table");
  const rpc = Object.assign(Object.create(Object.getPrototypeOf(umi.rpc)), umi.rpc, { connection });
  const accounts = { tokenMint: store.tokenMint, tokenEscrow: store.tokenEscrow };
  const { nativeFee } = await oft.quote(
    rpc, { payer: signer.publicKey, ...accounts }, { ...params, payInLzToken: false },
    { oft: programId }, [], [publicKey(lookupKey.toBase58())],
  );
  const send = await oft.send(
    rpc, { payer: signer, ...accounts, tokenSource: publicKey(shareAta.toBase58()) },
    { ...params, nativeFee }, { oft: programId, token: publicKey(TOKEN_PROGRAM_ID.toBase58()) },
  );
  const instructions = [
    ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 }),
    ComputeBudgetProgram.setComputeUnitPrice({ microLamports }),
  ];
  if (mode !== "update") instructions.push(createAssociatedTokenAccountIdempotentInstruction(
    owner, usdcAta, owner, usdc,
  ));
  instructions.push(toWeb3JsInstruction(send.instruction));
  const validity = await connection.getLatestBlockhash("confirmed");
  const transaction = new VersionedTransaction(new TransactionMessage({
    payerKey: owner, recentBlockhash: validity.blockhash, instructions,
  }).compileToV0Message([lookup]));
  // Have the owner's wallet sign transaction, then simulate and submit below.
  // There is NO source-transaction keeper or ephemeral event-account signer.
  return { transaction, validity };
}

import { Connection, PublicKey, type VersionedTransaction,
  type BlockhashWithExpiryBlockHeight } from "@solana/web3.js";

export async function signAndSubmit(
  connection: Connection,
  wallet: {
    publicKey: PublicKey;
    signTransaction(tx: VersionedTransaction): Promise<VersionedTransaction>;
  },
  transaction: VersionedTransaction,
  validity: BlockhashWithExpiryBlockHeight,
) {
  if (!transaction.message.staticAccountKeys[0].equals(wallet.publicKey)) {
    throw new Error("Wallet must be the transaction fee payer");
  }
  if (transaction.message.recentBlockhash !== validity.blockhash) {
    throw new Error("Blockhash/validity mismatch");
  }
  const signed = await wallet.signTransaction(transaction);
  const simulation = await connection.simulateTransaction(signed, {
    sigVerify: true, commitment: "confirmed",
  });
  if (simulation.value.err) throw new Error(JSON.stringify(simulation.value));
  const signature = await connection.sendRawTransaction(signed.serialize(), {
    skipPreflight: false, preflightCommitment: "confirmed",
  });
  const confirmation = await connection.confirmTransaction({ signature, ...validity }, "confirmed");
  if (confirmation.value.err) throw new Error(JSON.stringify(confirmation.value.err));
  return signature;
}

GET https://api.nest.credit/v1/solana/mint-status/<SOLANA_MINT_SIGNATURE>
GET https://api.nest.credit/v1/solana/redeem-status/<SOLANA_REDEEM_SIGNATURE>
GET https://api.nest.credit/v1/solana/update-status/<SOLANA_UPDATE_SIGNATURE>

import { AnchorProvider, Program, type Idl } from "@coral-xyz/anchor";
import { PublicKey } from "@solana/web3.js";
import { ethers } from "ethers";
import messageTransmitterIdl from "./idl/message_transmitter_v2.json";

export async function reclaimEventRent(
  provider: AnchorProvider,
  eventAccount: PublicKey, // saved from buildMintLocally
  message: string, // Circle's attested destination message (hex)
  attestation: string, // matching Circle attestation (hex)
) {
  const program = new Program(messageTransmitterIdl as Idl, provider);
  const [messageTransmitter] = PublicKey.findProgramAddressSync(
    [Buffer.from("message_transmitter")], program.programId,
  );
  // Circle requires payee to be the original eventRentPayer.
  const transaction = await program.methods.reclaimEventAccount({
    destinationMessage: Buffer.from(ethers.getBytes(message)),
    attestation: Buffer.from(ethers.getBytes(attestation)),
  }).accounts({
    payee: provider.wallet.publicKey,
    messageTransmitter,
    messageSentEventData: eventAccount,
  }).transaction();
  // Use a legacy transaction without compute-budget instructions to fit the payload.
  const validity = await provider.connection.getLatestBlockhash("confirmed");
  transaction.feePayer = provider.wallet.publicKey;
  transaction.recentBlockhash = validity.blockhash;
  const signed = await provider.wallet.signTransaction(transaction);
  const signature = await provider.connection.sendRawTransaction(signed.serialize(), {
    skipPreflight: false, preflightCommitment: "confirmed",
  });
  const result = await provider.connection.confirmTransaction({ signature, ...validity }, "confirmed");
  if (result.value.err) throw new Error(JSON.stringify(result.value.err));
  return signature;
}