js: replace bankrun with litesvm

Author: 2501babe

clients/js-legacy/package.json

@@ -32,22 +32,22 @@
     "./dist/types"
   ],
   "devDependencies": {
-    "@types/node": "^25.6.0",
     "@ava/typescript": "^6.0.0",
+    "@types/node": "^25.6.0",
     "@typescript-eslint/eslint-plugin": "^8.58.2",
     "ava": "^7.0.0",
     "eslint": "^8.57.0",
-    "solana-bankrun": "^0.4.0",
+    "litesvm": "0.3.3",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@solana/web3.js": "^1.98.4",
     "@solana/addresses": "6.8.0",
     "@solana/prettier-config-solana": "^0.0.6",
     "@solana/rpc-api": "6.8.0",
     "@solana/rpc-spec": "6.8.0",
     "@solana/spl-single-pool": "workspace:*",
+    "@solana/web3.js": "^1.98.4",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.5",
     "prettier": "^3.8.2"

clients/js-legacy/tests/transactions.test.ts

@@ -1,10 +1,10 @@
-/* eslint-disable */
-
 import test from 'ava';
-import { start, BanksClient, ProgramTestContext } from 'solana-bankrun';
+import path from 'node:path';
+import { LiteSVM, StakeHistoryEntry, FailedTransactionMetadata } from 'litesvm';
 import {
   Keypair,
   PublicKey,
+  SystemProgram,
   Transaction,
   Authorized,
   TransactionInstruction,
@@ -38,17 +38,46 @@ const voteAccount = {
   },
 };
 
-const SLOTS_PER_EPOCH: bigint = 432000n;
 const LAMPORTS_PER_SOL: number = 1_000_000_000;
+const STAKE_HISTORY_ENTRY = new StakeHistoryEntry(
+  BigInt(LAMPORTS_PER_SOL) * 1000n,
+  BigInt(LAMPORTS_PER_SOL) * 10n,
+  BigInt(LAMPORTS_PER_SOL) * 10n,
+);
+
+type LiteContext = {
+  svm: LiteSVM;
+  payer: Keypair;
+  banksClient: LiteBanksClient;
+  advanceEpoch(): void;
+};
+
+class LiteBanksClient {
+  constructor(readonly svm: LiteSVM) {}
+
+  async getAccount(address: PublicKey) {
+    const account = this.svm.getAccount(address);
+    if (!account) return null;
+    return { ...account, data: Buffer.from(account.data) };
+  }
+
+  async processTransaction(tx: Transaction) {
+    const res = this.svm.sendTransaction(tx);
+    if (res instanceof FailedTransactionMetadata) {
+      throw new Error(`${res.err().toString()}\n${res.meta().prettyLogs()}`);
+    }
+    return res;
+  }
+}
 
 class BanksConnection {
-  constructor(client: BanksClient, payer: Keypair) {
+  constructor(client: LiteBanksClient, payer: Keypair) {
     this.client = client;
     this.payer = payer;
   }
 
   async getMinimumBalanceForRentExemption(dataLen: number): Promise<number> {
-    const rent = await this.client.getRent();
+    const rent = await this.client.svm.getRent();
     return Number(rent.minimumBalance(BigInt(dataLen)));
   }
 
@@ -61,27 +90,27 @@ class BanksConnection {
         data: Buffer.from([13, 0, 0, 0]),
       }),
     );
-    transaction.recentBlockhash = (await this.client.getLatestBlockhash())[0];
+    transaction.recentBlockhash = this.client.svm.latestBlockhash();
     transaction.feePayer = this.payer.publicKey;
     transaction.sign(this.payer);
 
-    const res = await this.client.simulateTransaction(transaction);
-    const data = Array.from(res.inner.meta.returnData.data);
+    const res = await this.client.svm.simulateTransaction(transaction);
+    const data = Array.from(res.meta().returnData().data());
     const minimumDelegation = data[0] + (data[1] << 8) + (data[2] << 16) + (data[3] << 24);
 
     return { value: minimumDelegation };
   }
 
-  async getAccountInfo(address: PublicKey, commitment?: string): Promise<AccountInfo<Buffer>> {
-    const account = await this.client.getAccount(address, commitment);
+  async getAccountInfo(address: PublicKey): Promise<AccountInfo<Buffer>> {
+    const account = await this.client.getAccount(address);
     if (account) {
       account.data = Buffer.from(account.data);
     }
     return account;
   }
 }
 
-async function startWithContext(authorizedWithdrawer?: PublicKey) {
+async function startWithContext(authorizedWithdrawer?: PublicKey): Promise<LiteContext> {
   const voteAccountData = Uint8Array.from(atob(voteAccount.account.data[0]), (c) =>
     c.charCodeAt(0),
   );
@@ -90,48 +119,74 @@ async function startWithContext(authorizedWithdrawer?: PublicKey) {
     voteAccountData.set(authorizedWithdrawer.toBytes(), 36);
   }
 
-  return await start(
-    [
-      {
-        name: Buffer.from('spl_single_pool').toString('utf-8'),
-        programId: SinglePoolProgram.programId,
-      },
-      {
-        name: Buffer.from('mpl_token_metadata').toString('utf-8'),
-        programId: MPL_METADATA_PROGRAM_ID,
-      },
-    ],
-    [
-      {
-        address: new PublicKey(voteAccount.pubkey),
-        info: {
-          lamports: voteAccount.account.lamports,
-          data: voteAccountData,
-          owner: VoteProgram.programId,
-          executable: false,
-        },
-      },
-    ],
-    undefined,
-    undefined,
-    // stake_raise_minimum_delegation_to_1_sol::id()
-    [new PublicKey('9onWzzvCzNC2jfhxxeqRgs5q7nFAAKpCUvkj6T6GJK9i')],
+  const svm = new LiteSVM();
+  const payer = Keypair.generate();
+
+  svm.airdrop(payer.publicKey, 10_000n * BigInt(LAMPORTS_PER_SOL));
+
+  svm.addProgramFromFile(
+    SinglePoolProgram.programId,
+    path.resolve(process.cwd(), 'tests', 'fixtures', 'spl_single_pool.so'),
   );
+  svm.addProgramFromFile(
+    MPL_METADATA_PROGRAM_ID,
+    path.resolve(process.cwd(), 'tests', 'fixtures', 'mpl_token_metadata.so'),
+  );
+
+  svm.setAccount(new PublicKey(voteAccount.pubkey), {
+    lamports: voteAccount.account.lamports,
+    data: voteAccountData,
+    owner: VoteProgram.programId,
+    executable: false,
+    rentEpoch: 0,
+  });
+
+  const schedule = svm.getEpochSchedule();
+  const clock = svm.getClock();
+  const history = svm.getStakeHistory();
+
+  clock.slot = schedule.firstNormalSlot + 1n;
+  clock.epoch = schedule.firstNormalEpoch;
+  clock.leaderScheduleEpoch = schedule.firstNormalEpoch;
+
+  for (let epoch = 0n; epoch < schedule.firstNormalEpoch; epoch += 1n) {
+    history.add(epoch, STAKE_HISTORY_ENTRY);
+  }
+
+  svm.setClock(clock);
+  svm.setStakeHistory(history);
+
+  const banksClient = new LiteBanksClient(svm);
+
+  return {
+    svm,
+    payer,
+    banksClient,
+    advanceEpoch() {
+      const schedule = svm.getEpochSchedule();
+      const clock = svm.getClock();
+      const history = svm.getStakeHistory();
+
+      history.add(clock.epoch, STAKE_HISTORY_ENTRY);
+      clock.slot += schedule.slotsPerEpoch;
+      clock.epoch += 1n;
+      clock.leaderScheduleEpoch = clock.epoch;
+
+      svm.setClock(clock);
+      svm.setStakeHistory(history);
+    },
+  };
 }
 
-async function processTransaction(
-  context: ProgramTestContext,
-  transaction: Transaction,
-  signers = [],
-) {
-  transaction.recentBlockhash = context.lastBlockhash;
+async function processTransaction(context: LiteContext, transaction: Transaction, signers = []) {
+  transaction.recentBlockhash = context.svm.latestBlockhash();
   transaction.feePayer = context.payer.publicKey;
   transaction.sign(...[context.payer].concat(signers));
   return context.banksClient.processTransaction(transaction);
 }
 
 async function createAndDelegateStakeAccount(
-  context: ProgramTestContext,
+  context: LiteContext,
   voteAccountAddress: PublicKey,
 ): Promise<PublicKey> {
   const connection = new BanksConnection(context.banksClient, context.payer);
@@ -193,6 +248,9 @@ test('replenish pool', async (t) => {
   const connection = new BanksConnection(client, payer);
 
   const voteAccountAddress = new PublicKey(voteAccount.pubkey);
+  const poolAddress = await findPoolAddress(SinglePoolProgram.programId, voteAccountAddress);
+  const poolStakeAddress = await findPoolStakeAddress(SinglePoolProgram.programId, poolAddress);
+  const poolOnrampAddress = await findPoolOnRampAddress(SinglePoolProgram.programId, poolAddress);
 
   // initialize pool
   let transaction = await SinglePoolProgram.initialize(
@@ -201,17 +259,24 @@ test('replenish pool', async (t) => {
     payer.publicKey,
   );
   await processTransaction(context, transaction);
-
-  const slot = await client.getSlot();
-  context.warpToSlot(slot + SLOTS_PER_EPOCH);
+  context.advanceEpoch();
+
+  transaction = new Transaction().add(
+    SystemProgram.transfer({
+      fromPubkey: payer.publicKey,
+      toPubkey: poolStakeAddress,
+      lamports: LAMPORTS_PER_SOL,
+    }),
+  );
+  await processTransaction(context, transaction);
 
   // replenish pool
   transaction = await SinglePoolProgram.replenishPool(voteAccountAddress);
+  await processTransaction(context, transaction);
 
-  // NOTE we cannot test executing this because bankrun latest is on 1.18
-  // maybe someday
-  //await processTransaction(context, transaction);
-  t.true(true);
+  const stakeRent = await connection.getMinimumBalanceForRentExemption(StakeProgram.space);
+  const poolOnrampAccount = await client.getAccount(poolOnrampAddress);
+  t.is(poolOnrampAccount.lamports, LAMPORTS_PER_SOL + stakeRent, 'lamports have been replenished');
 });
 
 test('deposit', async (t) => {
@@ -232,12 +297,9 @@ test('deposit', async (t) => {
     payer.publicKey,
   );
   await processTransaction(context, transaction);
-
-  const slot = await client.getSlot();
-  context.warpToSlot(slot + SLOTS_PER_EPOCH);
+  context.advanceEpoch();
 
   // deposit
-  /* bankrun is still on 1.18 so this fails. update later
   transaction = await SinglePoolProgram.deposit({
     connection,
     pool: poolAddress,
@@ -254,9 +316,6 @@ test('deposit', async (t) => {
     LAMPORTS_PER_SOL + minimumDelegation + stakeRent,
     'stake has been deposited',
   );
-  */
-
-  t.true(true);
 });
 
 test('withdraw', async (t) => {
@@ -277,9 +336,7 @@ test('withdraw', async (t) => {
     payer.publicKey,
   );
   await processTransaction(context, transaction);
-
-  const slot = await client.getSlot();
-  context.warpToSlot(slot + SLOTS_PER_EPOCH);
+  context.advanceEpoch();
 
   // deposit
   transaction = await SinglePoolProgram.deposit({
@@ -288,7 +345,6 @@ test('withdraw', async (t) => {
     userWallet: payer.publicKey,
     userStakeAccount: depositAccount,
   });
-  /* bankrun is still on 1.18 so this fails. update later
   await processTransaction(context, transaction);
 
   const minimumDelegation = (await connection.getStakeMinimumDelegation()).value;
@@ -310,9 +366,6 @@ test('withdraw', async (t) => {
   const stakeRent = await connection.getMinimumBalanceForRentExemption(StakeProgram.space);
   const userStakeAccount = await client.getAccount(withdrawAccount.publicKey);
   t.is(userStakeAccount.lamports, minimumDelegation + stakeRent, 'stake has been withdrawn');
-  */
-
-  t.true(true);
 });
 
 test('create metadata', async (t) => {