Solana: Mainnet fork tests with the Surfpool Kit plugin

import assert from "node:assert/strict";
import { after, before, describe, it } from "node:test";
import {
  address,
  appendTransactionMessageInstructions,
  createClient,
  createSolanaRpc,
  createTransactionMessage,
  fetchEncodedAccount,
  generateKeyPairSigner,
  getBase64EncodedWireTransaction,
  pipe,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners,
} from "@solana/kit";
import { surfpool } from "@solana/surfpool/kit";
import { fetchSysvarClock } from "@solana/sysvars";
import {
  TOKEN_PROGRAM_ADDRESS,
  fetchMint,
  fetchToken,
  findAssociatedTokenPda,
  getCreateAssociatedTokenIdempotentInstructionAsync,
  getTransferCheckedInstruction,
  tokenProgram,
} from "@solana-program/token";

const CHAINSTACK_ENDPOINT = process.env.CHAINSTACK_ENDPOINT;
const USDC_MINT = address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const ONE_USDC = 1_000_000n;

async function usdcAccountOf(owner) {
  const [tokenAccount] = await findAssociatedTokenPda({
    owner,
    mint: USDC_MINT,
    tokenProgram: TOKEN_PROGRAM_ADDRESS,
  });
  return tokenAccount;
}

describe("USDC on a Solana Mainnet fork", () => {
  const mainnet = createSolanaRpc(CHAINSTACK_ENDPOINT);
  let client;

  before(async () => {
    client = await createClient()
      .use(surfpool({ surfnet: { remoteRpcUrl: CHAINSTACK_ENDPOINT, slotTimeMs: 400 } }))
      .use(tokenProgram());
  });

  after(() => client.surfnet.stop());

  it("reads the USDC mint from mainnet", async () => {
    const forked = await fetchMint(client.rpc, USDC_MINT);
    const live = await fetchMint(mainnet, USDC_MINT);

    assert.equal(forked.data.decimals, 6);
    assert.deepEqual(forked.data.mintAuthority, live.data.mintAuthority);
  });

  it("transfers USDC without touching mainnet", async () => {
    await client.cheatcodes
      .setTokenAccount(client.payer.address, USDC_MINT, { amount: 1_000n * ONE_USDC })
      .send();
    const recipient = await generateKeyPairSigner();

    await client.token.instructions
      .transferToATA({
        mint: USDC_MINT,
        authority: client.payer,
        recipient: recipient.address,
        amount: 250n * ONE_USDC,
        decimals: 6,
      })
      .sendTransaction();

    const payerAccount = await fetchToken(client.rpc, await usdcAccountOf(client.payer.address));
    const recipientAddress = await usdcAccountOf(recipient.address);
    const recipientAccount = await fetchToken(client.rpc, recipientAddress);
    assert.equal(payerAccount.data.amount, 750n * ONE_USDC);
    assert.equal(recipientAccount.data.amount, 250n * ONE_USDC);

    const onMainnet = await fetchEncodedAccount(mainnet, recipientAddress);
    assert.equal(onMainnet.exists, false);
  });

  it("profiles a transfer without sending it", async (t) => {
    await client.cheatcodes
      .setTokenAccount(client.payer.address, USDC_MINT, { amount: 1_000n * ONE_USDC })
      .send();
    const recipient = await generateKeyPairSigner();
    const recipientAddress = await usdcAccountOf(recipient.address);

    const createRecipientAccount = await getCreateAssociatedTokenIdempotentInstructionAsync({
      payer: client.payer,
      owner: recipient.address,
      mint: USDC_MINT,
    });
    const transfer = getTransferCheckedInstruction({
      source: await usdcAccountOf(client.payer.address),
      mint: USDC_MINT,
      destination: recipientAddress,
      authority: client.payer,
      amount: 250n * ONE_USDC,
      decimals: 6,
    });
    const { value: latestBlockhash } = await client.rpc.getLatestBlockhash().send();
    const message = pipe(
      createTransactionMessage({ version: 0 }),
      (m) => setTransactionMessageFeePayerSigner(client.payer, m),
      (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
      (m) => appendTransactionMessageInstructions([createRecipientAccount, transfer], m),
    );
    const transaction = await signTransactionMessageWithSigners(message);

    const profile = await client.cheatcodes
      .profileTransaction(getBase64EncodedWireTransaction(transaction), "usdc-transfer")
      .send();

    assert.equal(profile.transactionProfile.errorMessage, null);
    t.diagnostic(`compute units: ${profile.transactionProfile.computeUnitsConsumed}`);

    const afterProfile = await fetchEncodedAccount(client.rpc, recipientAddress);
    assert.equal(afterProfile.exists, false);
  });

  it("moves the clock forward 30 days", async (t) => {
    const start = await fetchSysvarClock(client.rpc);
    const thirtyDays = 30n * 24n * 60n * 60n;

    await client.cheatcodes
      .timeTravel({ absoluteTimestamp: (start.unixTimestamp + thirtyDays) * 1000n })
      .send();

    const end = await fetchSysvarClock(client.rpc);
    assert.equal(end.unixTimestamp - start.unixTimestamp, thirtyDays);
    t.diagnostic(`epoch ${start.epoch} -> ${end.epoch}, slot ${start.slot} -> ${end.slot}`);
  });
});