feat(svm): svm spoke binaries integration tests

.gitignore

@@ -12,6 +12,8 @@ dist
 /artifacts
 /typechain-types
 .ledger
+/target
+*.tar.gz
 
 # production
 /build

package.json

@@ -105,14 +105,14 @@
   "dependencies": {
     "@across-protocol/across-token": "^1.0.0",
     "@across-protocol/constants": "^3.1.67",
-    "@across-protocol/contracts": "^4.0.9",
+    "@across-protocol/contracts": "4.0.9",
     "@coral-xyz/anchor": "^0.30.1",
     "@eth-optimism/sdk": "^3.3.1",
     "@ethersproject/bignumber": "^5.7.0",
     "@pinata/sdk": "^2.1.0",
-    "@solana/kit": "^2.1.0",
     "@solana-program/system": "^0.7.0",
     "@solana-program/token-2022": "^0.4.0",
+    "@solana/kit": "^2.1.0",
     "@solana/web3.js": "^1.31.0",
     "@types/mocha": "^10.0.1",
     "@uma/sdk": "^0.34.10",

src/arch/svm/types.ts

@@ -56,9 +56,10 @@ export type EventWithData = {
   program: Address;
 };
 
+export type SVMProvider = Rpc<SolanaRpcApiFromTransport<RpcTransport>>;
+
 // Typed aggregate of JSON‑RPC and subscription clients.
 export type RpcClient = {
-  rpc: Rpc<SolanaRpcApiFromTransport<RpcTransport>>;
+  rpc: SVMProvider;
   rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi>;
 };
-export type SVMProvider = Rpc<SolanaRpcApiFromTransport<RpcTransport>>;

test/SVMSpokePoolClient.fills.ts

@@ -1,4 +1,4 @@
-import { KeyPairSigner, address } from "@solana/kit";
+import { KeyPairSigner, address, fetchEncodedAccount } from "@solana/kit";
 import { CHAIN_IDs } from "@across-protocol/constants";
 import { SvmSpokeClient } from "@across-protocol/contracts";
 import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1";
@@ -12,6 +12,8 @@ import {
   formatRelayData,
   mintTokens,
   sendRequestSlowFill,
+  closeFillPda,
+  setCurrentTime,
 } from "./utils/svm/utils";
 import { SVM_DEFAULT_ADDRESS, findFillEvent, getRandomSvmAddress } from "../src/arch/svm";
 import { SVMSpokePoolClient } from "../src/clients";
@@ -202,4 +204,43 @@ describe("SVMSpokePoolClient: Fills", function () {
     );
     expect(fillStatusAfterRequest).to.equal(FillStatus.RequestedSlowFill);
   });
+
+  it("Closes the fill pda after the fill deadline has passed", async () => {
+    const currentSlot = await solanaClient.rpc.getSlot({ commitment: "confirmed" }).send();
+    const currentSlotTimestamp = await solanaClient.rpc.getBlockTime(currentSlot).send();
+    const fillDeadline = Number(currentSlotTimestamp) + 1;
+    await setCurrentTime(signer, solanaClient, Number(currentSlotTimestamp));
+    const newRelayData = { ...relayData, depositId: new Uint8Array(intToU8Array32(getRandomInt())), fillDeadline };
+    const formattedRelayData = formatRelayData(newRelayData);
+    await mintTokens(signer, solanaClient, mint.address, BigInt(relayData.outputAmount));
+    const { fillInput, relayData: fillRelayData } = await sendCreateFill(
+      solanaClient,
+      signer,
+      mint,
+      decimals,
+      newRelayData
+    );
+
+    const fillStatusAfterFill = await spokePoolClient.relayFillStatus(formattedRelayData);
+    expect(fillStatusAfterFill).to.equal(FillStatus.Filled);
+
+    try {
+      await closeFillPda(signer, solanaClient, fillInput.fillStatus);
+    } catch (error) {
+      expect(error.context.logs.some((log) => log.includes("The fill deadline has not passed!"))).to.be.true;
+    }
+
+    await setCurrentTime(signer, solanaClient, fillRelayData.fillDeadline + 1);
+
+    await closeFillPda(signer, solanaClient, fillInput.fillStatus);
+
+    const fillStatusAccount = await fetchEncodedAccount(solanaClient.rpc, fillInput.fillStatus, {
+      commitment: "confirmed",
+    });
+
+    expect(fillStatusAccount.exists).to.be.false;
+
+    const fillStatusWithPdaClosed = await spokePoolClient.relayFillStatus(formattedRelayData);
+    expect(fillStatusWithPdaClosed).to.equal(FillStatus.Filled);
+  });
 });

test/Solana.setup.ts

@@ -1,18 +1,25 @@
 import { validatorSetup, validatorTeardown } from "./utils/svm/validator.setup";
 import { createDefaultSolanaClient, generateKeyPairSignerWithSol, initializeSvmSpoke } from "./utils/svm/utils";
-
+import { airdropFactory, generateKeyPairSigner, lamports } from "@solana/kit";
 // Create the signer
 let signer: Awaited<ReturnType<typeof generateKeyPairSignerWithSol>>;
 
 before(async function () {
+  // Generate the signer
+  signer = await generateKeyPairSigner();
+
   /* Local validator spin‑up can take a few seconds */
   this.timeout(60_000);
-  await validatorSetup();
+  await validatorSetup(signer.address);
 
   const solanaClient = createDefaultSolanaClient();
 
-  // Generate the signer
-  signer = await generateKeyPairSignerWithSol(solanaClient);
+  // Airdrop SOL to the signer
+  await airdropFactory(solanaClient)({
+    recipientAddress: signer.address,
+    lamports: lamports(1_000_000_000n),
+    commitment: "confirmed",
+  });
 
   // Initialize the program and get the state
   await initializeSvmSpoke(signer, solanaClient, signer.address);

test/utils/svm/utils.ts

@@ -1,7 +1,7 @@
+import { CHAIN_IDs } from "@across-protocol/constants";
 import { SvmSpokeClient } from "@across-protocol/contracts";
-import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1";
 import { RelayDataArgs } from "@across-protocol/contracts/dist/src/svm/clients/SvmSpoke";
-import { CHAIN_IDs } from "@across-protocol/constants";
+import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1";
 import { getCreateAccountInstruction, SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
@@ -34,21 +34,20 @@ import {
   TransactionMessageWithBlockhashLifetime,
   TransactionSigner,
 } from "@solana/kit";
-import { hexlify, arrayify } from "ethers/lib/utils";
+import { arrayify, hexlify } from "ethers/lib/utils";
 import {
   getAssociatedTokenAddress,
   getEventAuthority,
   getFillStatusPda,
   getRandomSvmAddress,
   getRoutePda,
   getStatePda,
-  getTimestampForSlot,
   RpcClient,
   SVM_DEFAULT_ADDRESS,
   SVM_SPOKE_SEED,
 } from "../../../src/arch/svm";
-import { EvmAddress, SvmAddress, getRandomInt, getRelayDataHash, randomAddress, BigNumber } from "../../../src/utils";
 import { RelayData } from "../../../src/interfaces";
+import { BigNumber, EvmAddress, getRandomInt, getRelayDataHash, randomAddress, SvmAddress } from "../../../src/utils";
 
 /** RPC / Client */
 
@@ -336,6 +335,40 @@ export const createFill = async (
   );
 };
 
+// Closes the fill PDA.
+export const closeFillPda = async (signer: KeyPairSigner, solanaClient: RpcClient, fillStatusPda: Address) => {
+  const closeFillPdaIx = await SvmSpokeClient.getCloseFillPdaInstruction({
+    signer,
+    state: await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+    fillStatus: fillStatusPda,
+  });
+  return pipe(
+    await createDefaultTransaction(solanaClient, signer),
+    (tx) => appendTransactionMessageInstruction(closeFillPdaIx, tx),
+    (tx) => signAndSendTransaction(solanaClient, tx)
+  );
+};
+
+// Sets the current time for the SVM Spoke program.
+export const setCurrentTime = async (signer: KeyPairSigner, solanaClient: RpcClient, newTime: number) => {
+  const setCurrentTimeIx = await SvmSpokeClient.getSetCurrentTimeInstruction({
+    signer,
+    state: await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+    newTime,
+  });
+  return pipe(
+    await createDefaultTransaction(solanaClient, signer),
+    (tx) => appendTransactionMessageInstruction(setCurrentTimeIx, tx),
+    (tx) => signAndSendTransaction(solanaClient, tx)
+  );
+};
+
+export const getCurrentTime = async (solanaClient: RpcClient) => {
+  const statePda = await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS);
+  const state = await SvmSpokeClient.fetchState(solanaClient.rpc, statePda);
+  return state.data.currentTime;
+};
+
 // helper to send a fill
 export const sendCreateFill = async (
   solanaClient: RpcClient,
@@ -344,8 +377,7 @@ export const sendCreateFill = async (
   mintDecimals: number,
   overrides: Partial<RelayDataArgs> = {}
 ) => {
-  const latestSlot = await solanaClient.rpc.getSlot({ commitment: "confirmed" }).send();
-  const currentTime = await getTimestampForSlot(solanaClient.rpc, Number(latestSlot));
+  const currentTime = await getCurrentTime(solanaClient);
 
   const relayData: SvmSpokeClient.FillRelayInput["relayData"] = {
     depositor: overrides.depositor ?? address(EvmAddress.from(randomAddress()).toBase58()),
@@ -402,7 +434,7 @@ export const sendCreateFill = async (
   };
 
   const signature = await createFill(signer, solanaClient, fillInput, mintDecimals);
-  return { signature, relayData };
+  return { signature, relayData, fillInput };
 };
 
 // helper to send a request slow fill
@@ -412,8 +444,7 @@ export const sendRequestSlowFill = async (
   overrides: Partial<RelayDataArgs> = {}
 ) => {
   const destinationChainId = CHAIN_IDs.SOLANA;
-  const latestSlot = await solanaClient.rpc.getSlot({ commitment: "confirmed" }).send();
-  const currentTime = await getTimestampForSlot(solanaClient.rpc, Number(latestSlot));
+  const currentTime = await getCurrentTime(solanaClient);
 
   const relayData: SvmSpokeClient.RequestSlowFillInstructionDataArgs["relayData"] = {
     depositor: overrides.depositor ?? address(EvmAddress.from(randomAddress()).toBase58()),
@@ -463,8 +494,7 @@ export const sendCreateDeposit = async (
   overrides: Partial<SvmSpokeClient.DepositInput> = {},
   destinationChainId: number = CHAIN_IDs.MAINNET
 ) => {
-  const latestSlot = await solanaClient.rpc.getSlot({ commitment: "confirmed" }).send();
-  const currentTime = await solanaClient.rpc.getBlockTime(latestSlot).send();
+  const currentTime = await getCurrentTime(solanaClient);
 
   const depositInput: SvmSpokeClient.DepositInput = {
     depositor: signer.address,

test/utils/svm/validator.setup.ts

@@ -1,19 +1,58 @@
+import { SvmSpokeClient } from "@across-protocol/contracts";
+import { Address } from "@solana/kit";
 import { spawn } from "child_process";
-import path from "node:path";
 import fs from "node:fs/promises";
-import { SvmSpokeClient } from "@across-protocol/contracts";
+import path from "node:path";
+import tar from "tar";
 
+// Directory and file constants
 const LEDGER_DIR = path.resolve(__dirname, "..", ".ledger");
+const TARGET_DIR = path.resolve(__dirname, "..", "..", "..");
+const SVM_SPOKE_SO_PATH = path.resolve(TARGET_DIR, "target", "deploy", "svm_spoke.so");
+const BINARY_RELEASE_TAG = process.env.SVM_BINARY_RELEASE_TAG || "v4.0.11";
+const BINARY_ARCHIVE_NAME = process.env.SVM_BINARY_ARCHIVE_NAME || "svm-verified-test-binaries.tar.gz";
+const BINARY_DOWNLOAD_URL = `https://github.com/across-protocol/contracts/releases/download/${BINARY_RELEASE_TAG}/${BINARY_ARCHIVE_NAME}`;
+const SAVED_ARCHIVE_NAME = `svm-verified-test-binaries.${BINARY_RELEASE_TAG}.tar.gz`;
+
+/**
+ * Download and save the SVM spoke test binaries if not already present.
+ */
+async function ensureBinaries(): Promise<void> {
+  const archivePath = path.join(TARGET_DIR, SAVED_ARCHIVE_NAME);
+  try {
+    await fs.access(archivePath);
+  } catch {
+    const response = await fetch(BINARY_DOWNLOAD_URL);
+    if (!response.ok) {
+      throw new Error(`Failed to download binaries: ${response.status} ${response.statusText}`);
+    }
 
-export const validatorSetup = async () => {
-  // Always start with a clean ledger
+    const blob = await response.blob();
+    await fs.writeFile(archivePath, Buffer.from(await blob.arrayBuffer()));
+  }
+
+  await tar.x({ file: path.join(TARGET_DIR, SAVED_ARCHIVE_NAME), cwd: TARGET_DIR });
+}
+
+/**
+ * Starts a local Solana test validator with the SVM spoke program loaded.
+ * @param upgradeAuthority - The address authorized to upgrade the program
+ */
+export async function validatorSetup(upgradeAuthority: Address): Promise<void> {
+  // Clean previous ledger state
   await fs.rm(LEDGER_DIR, { recursive: true, force: true });
+  // Ensure target directory
+  await fs.mkdir(TARGET_DIR, { recursive: true });
+
+  // Prepare binaries
+  await ensureBinaries();
 
+  // Launch test validator
   const args = [
-    "--clone-upgradeable-program",
+    "--upgradeable-program",
     SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS,
-    "--url",
-    "https://api.mainnet-beta.solana.com",
+    SVM_SPOKE_SO_PATH,
+    upgradeAuthority,
     "--ledger",
     LEDGER_DIR,
     "--reset",
@@ -23,24 +62,30 @@ export const validatorSetup = async () => {
     stdio: ["ignore", "pipe", "pipe"],
   });
 
+  // Wait until the validator is ready
   await new Promise<void>((resolve, reject) => {
-    proc.stdout.on("data", (d: Buffer) => {
-      if (d.toString().includes("JSON RPC URL")) resolve();
+    proc.stdout.on("data", (chunk: Buffer) => {
+      const msg = chunk.toString();
+      if (msg.includes("JSON RPC URL")) {
+        resolve();
+      }
     });
     proc.on("error", reject);
-    proc.on("exit", (code) => reject(new Error(`validator exited early with code ${code}`)));
+    proc.on("exit", (code) => reject(new Error(`Validator exited early with code ${code}`)));
   });
 
-  // expose the pid for teardown
+  // Store PID for teardown
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   (global as any).__SOLANA_VALIDATOR_PID__ = proc.pid;
-};
+}
 
-export const validatorTeardown = () => {
+/**
+ * Stops the running Solana test validator, if any.
+ */
+export function validatorTeardown(): void {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const pid = (global as any).__SOLANA_VALIDATOR_PID__;
   if (pid) {
     process.kill(pid);
-    return;
   }
-};
+}