swap out bankrun for litesvm in ts-sdk whirlpool tests

Author: jshiohaha

ts-sdk/whirlpool/package.json

@@ -43,7 +43,7 @@
   },
   "devDependencies": {
     "@solana/kit": "^5.0.0",
-    "solana-bankrun": "^0.4.0",
+    "litesvm": "^0.3.3",
     "tsup": "^8.4.0",
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"

ts-sdk/whirlpool/src/token.ts

@@ -151,7 +151,7 @@ export async function prepareTokenAccountsInstructions(
         : 0n;
       if (ENFORCE_TOKEN_BALANCE_CHECK) {
         assert(
-          BigInt(spec[mint.address]) <= existingBalance,
+          BigInt(spec[mint.address]) < existingBalance,
           `Token account for ${mint.address} does not have the required balance`,
         );
       }

ts-sdk/whirlpool/tests/increaseLiquidity.test.ts

@@ -1,17 +1,21 @@
-import { describe, it, beforeAll } from "vitest";
-import { increaseLiquidityInstructions } from "../src/increaseLiquidity";
-import { rpc, signer, sendTransaction } from "./utils/mockRpc";
-import { setupMint, setupAta } from "./utils/token";
 import { fetchPosition, getPositionAddress } from "@orca-so/whirlpools-client";
 import { fetchToken } from "@solana-program/token-2022";
 import type { Address } from "@solana/kit";
 import assert from "assert";
+import { beforeAll, describe, it } from "vitest";
+import {
+  DEFAULT_FUNDER,
+  setDefaultFunder,
+  setEnforceTokenBalanceCheck,
+} from "../src/config";
+import { increaseLiquidityInstructions } from "../src/increaseLiquidity";
+import { rpc, sendTransaction, signer } from "./utils/mockRpc";
 import {
   setupPosition,
   setupTEPosition,
   setupWhirlpool,
 } from "./utils/program";
-import { DEFAULT_FUNDER, setDefaultFunder } from "../src/config";
+import { setupAta, setupMint } from "./utils/token";
 import {
   setupAtaTE,
   setupMintTE,
@@ -132,7 +136,7 @@ describe("Increase Liquidity Instructions", () => {
     const liquidity = 100_000n;
     setDefaultFunder(DEFAULT_FUNDER);
     await assert.rejects(
-      increaseLiquidityInstructions(rpc, positions.entries().next().value, {
+      increaseLiquidityInstructions(rpc, positions.entries().next().value![1], {
         liquidity,
       }),
     );
@@ -141,10 +145,12 @@ describe("Increase Liquidity Instructions", () => {
 
   it("Should throw error increase liquidity amount by token is equal or greater than the token balance", async () => {
     const tokenAAmount = 1_000_000n;
+    setEnforceTokenBalanceCheck(true);
     await assert.rejects(
-      increaseLiquidityInstructions(rpc, positions.entries().next().value, {
+      increaseLiquidityInstructions(rpc, positions.entries().next().value![1], {
         tokenA: tokenAAmount,
       }),
     );
+    setEnforceTokenBalanceCheck(false);
   });
 });

ts-sdk/whirlpool/tests/pool.test.ts

@@ -73,15 +73,21 @@ describe("Fetch Pool", () => {
     assert.strictEqual(pool.whirlpoolsConfig, WHIRLPOOLS_CONFIG_ADDRESS);
   });
 
-  // TODO: Enable this test once solana-bankrun exposes getProgramAccounts
-  it.skip("Should be able to fetch all pools for a pair", async () => {
+  it("Should be able to fetch all pools for a pair", async () => {
     const pools = await fetchWhirlpoolsByTokenPair(rpc, mintA, mintB);
     assert.strictEqual(pools.length, 3);
-    assert.strictEqual(pools[0].initialized, true);
-    assert.strictEqual(pools[0].tickSpacing, 64);
-    assert.strictEqual(pools[1].initialized, true);
-    assert.strictEqual(pools[1].tickSpacing, SPLASH_POOL_TICK_SPACING);
-    assert.strictEqual(pools[2].initialized, false);
-    assert.strictEqual(pools[2].tickSpacing, 128);
+
+    // Check that we have all expected tick spacings
+    const tickSpacings = pools.map((p) => p.tickSpacing);
+    assert.ok(tickSpacings.includes(64));
+    assert.ok(tickSpacings.includes(SPLASH_POOL_TICK_SPACING));
+    assert.ok(tickSpacings.includes(128));
+
+    // Check initialized states
+    const initializedPools = pools.filter((p) => p.initialized);
+    const uninitializedPools = pools.filter((p) => !p.initialized);
+    assert.strictEqual(initializedPools.length, 2);
+    assert.strictEqual(uninitializedPools.length, 1);
+    assert.strictEqual(uninitializedPools[0].tickSpacing, 128);
   });
 });

ts-sdk/whirlpool/tests/position.test.ts

@@ -14,6 +14,7 @@ import {
   fetchPositionsInWhirlpool,
 } from "../src/position";
 import { rpc, signer } from "./utils/mockRpc";
+import { getFullRangeTickIndexes } from "@orca-so/whirlpools-core";
 
 describe("Fetch Position", () => {
   let mintA: Address;
@@ -29,28 +30,48 @@ describe("Fetch Position", () => {
     pool = await setupWhirlpool(mintA, mintB, 128);
     splashPool = await setupWhirlpool(mintA, mintB, SPLASH_POOL_TICK_SPACING);
     await setupPosition(pool);
-    await setupPosition(splashPool);
+    const splashFullRange = getFullRangeTickIndexes(SPLASH_POOL_TICK_SPACING);
+    await setupPosition(splashPool, {
+      tickLower: splashFullRange.tickLowerIndex,
+      tickUpper: splashFullRange.tickUpperIndex,
+    });
     await setupTEPosition(pool);
-    await setupPositionBundle(pool);
-    await setupPositionBundle(splashPool, [{}, {}]);
+
+    // bundle with 1 position, 2 positions
+    await setupPositionBundle(pool, [{ tickLower: -100, tickUpper: 100 }]);
+    await setupPositionBundle(splashPool, [
+      {
+        tickLower: splashFullRange.tickLowerIndex,
+        tickUpper: splashFullRange.tickUpperIndex,
+      },
+      {
+        tickLower: splashFullRange.tickLowerIndex,
+        tickUpper: splashFullRange.tickUpperIndex,
+      },
+    ]);
   });
 
-  // TODO: enable this when solana-bankrun supports gpa
-  it.skip("Should fetch all positions for an address", async () => {
+  it("Should fetch all positions for an address", async () => {
     const positions = await fetchPositionsForOwner(rpc, signer.address);
-    assert.strictEqual(positions.length, 5);
+
+    // 3 positions: 1 regular on pool, 1 full-range on splashPool, 1 TE on pool
+    const standalone = positions.filter((p) => !p.isPositionBundle);
+    assert.strictEqual(standalone.length, 3);
+
+    const bundles = positions.filter((p) => p.isPositionBundle);
+    assert.strictEqual(bundles.length, 2);
+    assert.deepEqual(bundles.map((b) => b.positions.length).sort(), [1, 2]);
   });
 
-  // TODO: enable this when solana-bankrun supports gpa
-  it.skip("Should fetch no positions for a different address", async () => {
+  it("Should fetch no positions for a different address", async () => {
     const other = await generateKeyPairSigner();
     const positions = await fetchPositionsForOwner(rpc, other.address);
     assert.strictEqual(positions.length, 0);
   });
 
-  // TODO: enable this when solana-bankrun supports gpa
-  it.skip("Should fetch positions for a whirlpool", async () => {
+  it("Should fetch positions for a whirlpool", async () => {
     const positions = await fetchPositionsInWhirlpool(rpc, pool);
+    // 3 positions in pool: 1 regular + 1 TE + 1 bundled
     assert.strictEqual(positions.length, 3);
   });
 });