@solard/sdk 0.2.33 → 0.2.40

package/src/export-surface.test.ts

@@ -29,12 +29,22 @@ function exportedNames(value: string) {
 describe("sdk membrane", () => {
   test("has an exact curated root export surface", () => {
     expect(exportedNames(source)).toEqual({
-      values: [
-        "normalizeValueBandPolicy", "planValueBandDecision", "valueBandThresholds",
-        "normalizeTargetWeightPolicy", "planTargetWeightRebalance",
-        "buildHistoricalCandles", "runHistoricalStrategy", "sweepHistoricalStrategies",
-        "LAUNCHLAB_PLATFORM_PRESETS", "resolveLaunchLabPlatform",
-        "createSolard",
+      values: [
+        "composeTransactionDrafts",
+        "observeSolardRpc",
+        "withSolardRpcContext",
+        "normalizeValueBandPolicy",
+        "planValueBandDecision",
+        "valueBandThresholds",
+        "normalizeTargetWeightPolicy",
+        "planTargetWeightRebalance",
+        "buildHistoricalCandles",
+        "runHistoricalStrategy",
+        "sweepHistoricalStrategies",
+        "LAUNCHLAB_PLATFORM_PRESETS",
+        "resolveLaunchLabPlatform",
+        "createSolard",
+        "createTraderSolard",
         "default",
         "fetchTokenMetadata",
         "formatRaw",
@@ -48,16 +58,35 @@ describe("sdk membrane", () => {
         "tokenAmount",
       ].sort(),
       types: [
-        "SellEconomics",
-        "SupportedLaunchLabPair",
+        "TransactionDraft",
+        "TransactionGroupInput",
+        "PlannedTransaction",
+        "SolardRpcObservation",
+        "SolardRpcContext",
+        "FeedRecoveryVerification",
+        "RecoverableTradeSubscription",
+        "SellEconomics",
+        "SupportedLaunchLabPair",
         "TradeListenerMigration",
-        "ValueBandPolicy", "ValueBandRuntimeState", "ValueBandDecision",
-        "TargetWeightPolicy", "TargetWeightRebalancePlan",
-        "HistoricalTradeTape", "HistoricalCandle", "HistoricalStrategy",
-        "HistoricalExecutionOptions", "HistoricalStrategyResult",
-        "CreatorFeeDiscovery", "CreatorFeeGroup", "CreatorFeeItem",
-        "WalletLedger", "WalletLedgerEntry", "WalletLedgerOptions", "CurrentMarket",
-        "PreparedTokenDeployment", "PrepareDeploymentArgs",
+        "ValueBandPolicy",
+        "ValueBandRuntimeState",
+        "ValueBandDecision",
+        "TargetWeightPolicy",
+        "TargetWeightRebalancePlan",
+        "HistoricalTradeTape",
+        "HistoricalCandle",
+        "HistoricalStrategy",
+        "HistoricalExecutionOptions",
+        "HistoricalStrategyResult",
+        "CreatorFeeDiscovery",
+        "CreatorFeeGroup",
+        "CreatorFeeItem",
+        "WalletLedger",
+        "WalletLedgerEntry",
+        "WalletLedgerOptions",
+        "CurrentMarket",
+        "PreparedTokenDeployment",
+        "PrepareDeploymentArgs",
         "TradeLandingPolicy",
         "LiveEndpointOptions",
         "LivePoolReserves",
@@ -177,7 +206,7 @@ describe("sdk membrane", () => {
     expect(defaultClient).toContain("instance ??= createSolard()");
     expect(defaultClient).toContain('if (key === "close")');
     expect(defaultClient).toContain("getSolUsdPrice");
-    expect(client).toContain("listenTrades:");
+    expect(client).toContain("listenTrades:");
     expect(defaultClient).toContain("subscribeLaunches");
     expect(defaultClient).toContain("subscribeMigrations");
     expect(defaultClient).not.toContain("export default createSolard()");
@@ -202,7 +231,7 @@ describe("sdk membrane", () => {
 
   test("does not expose core repositories or secret-bearing handles", () => {
     expect(client).not.toMatch(
-      /^(?: {2}| {4})(?:db|wallets|tokens|groups|executions|positions|prices|alts|senders|venues|claimSources|launches|launchpads|connection|signer)\s*:/m,
+      /^(?: {2}| {4})(?:db|wallets|tokens|groups|executions|positions|prices|alts|senders|venues|claimSources|launches|launchpads|connection|signer)\s*:/m,
     );
   });
 });

package/src/index.ts

@@ -1,5 +1,8 @@
 export { default } from "./default.ts";
-export { createSolard } from "./client.ts";
+export { createSolard } from "./client.ts";
+export {observeSolardRpc,withSolardRpcContext} from '@solard/core';
+export type {SolardRpcObservation,SolardRpcContext} from '@solard/core';
+export { createTraderSolard } from "@solard/core";
 export {
   normalizeValueBandPolicy,
   planValueBandDecision,
@@ -12,9 +15,9 @@ export {
   LAUNCHLAB_PLATFORM_PRESETS,
   resolveLaunchLabPlatform,
 } from "@solard/core";
-export type {
-  SellEconomics,
-  SupportedLaunchLabPair,
+export type {
+  SellEconomics,
+  SupportedLaunchLabPair,
   ValueBandPolicy,
   ValueBandRuntimeState,
   ValueBandDecision,
@@ -122,6 +125,8 @@ export {
 export type {
   ListenTradesOptions,
   LiveEndpointOptions,
+  FeedRecoveryVerification,
+  RecoverableTradeSubscription,
   SubscribeLaunchesOptions,
   SubscribeMigrationsOptions,
   TradeListener,
@@ -148,3 +153,5 @@ export type {
   TokenMetadataKind,
   TokenMetadataMode,
 } from "@solard/core";
+export {composeTransactionDrafts} from '@solard/core';
+export type {TransactionDraft,TransactionGroupInput,PlannedTransaction} from '@solard/core';

package/src/live-recovery.test.ts

@@ -0,0 +1,122 @@
+import { expect, spyOn, test } from "bun:test";
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID, NATIVE_MINT } from "@solana/spl-token";
+import * as core from "@solard/core";
+import { subscribeTrades } from "./live.ts";
+
+test("feed verification gates delivery, validates a snapshot, preserves deduplication and cancels queued recovery", async () => {
+  const originalSocket = globalThis.WebSocket;
+  globalThis.WebSocket = class extends EventTarget {
+    constructor() { super(); queueMicrotask(() => this.dispatchEvent(new Event("open"))); }
+    send(text: string) { const value = JSON.parse(text);
+      if (value.method === "slotSubscribe") queueMicrotask(() => this.dispatchEvent(
+        new MessageEvent("message", { data: JSON.stringify({ id: value.id, result: 1 }) })));
+    }
+    close() {}
+  } as any;
+  const fetchMock = spyOn(globalThis, "fetch").mockImplementation((async (_url, init) => {
+    const method = JSON.parse(String(init?.body)).method;
+    return Response.json({ result: method === "getGenesisHash"
+      ? "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d"
+      : { context: { slot: 42 }, value: 0 } });
+  }) as typeof fetch);
+  const mint = Keypair.generate().publicKey, pool = Keypair.generate().publicKey;
+  const poolProgram = Keypair.generate().publicKey;
+  let snapshotValid = false, emitted = 0, reads = 0;
+  const accounts = spyOn(Connection.prototype, "getAccountInfo").mockImplementation(async address => {
+    reads++;
+    if (!snapshotValid) return null;
+    const data = Buffer.alloc(82);
+    if (address.equals(mint)) { data[44] = 6; data.writeBigUInt64LE(1_000_000_000n, 36); }
+    else { mint.toBuffer().copy(data); NATIVE_MINT.toBuffer().copy(data, 32); }
+    return { executable: false, lamports: 1, owner: address.equals(mint) ? TOKEN_PROGRAM_ID : poolProgram, data };
+  });
+  let emit!: (event: core.TradeEvent) => Promise<void>;
+  const trades = spyOn(core, "subscribeTrades").mockImplementation(async options => {
+    emit = options.onTrade as typeof emit;
+    const watched = new Set(options.tokens);
+    let settle!: () => void;
+    const closed = new Promise<void>(resolve => { settle = resolve; });
+    return {
+      addTokens: async values => { for (const value of typeof values === "string" ? [values] : values) watched.add(value); },
+      removeTokens: async values => { for (const value of typeof values === "string" ? [values] : values) watched.delete(value); },
+      hasToken: value => watched.has(value), listTokens: () => [...watched],
+      close: async () => { watched.clear(); settle(); }, closed,
+    };
+  });
+  let subscription: Awaited<ReturnType<typeof subscribeTrades>> | undefined;
+  let clock: ReturnType<typeof spyOn> | undefined;
+  const event = (signature: string, atMs = Date.now()) => ({
+    type: "trade", mint: mint.toBase58(), signature, venue: "pumpswap", pool: pool.toBase58(),
+    side: "buy", slot: 42, atMs, baseRaw: 1n, quoteRaw: 2n,
+    metadata: null, market: {
+      quoteMint: NATIVE_MINT.toBase58(), baseDecimals: 6, quoteDecimals: 9,
+      supplyRaw: 1_000_000_000n, supply: 1000,
+      baseReserveRaw: 1n, baseReserve: 0.000001,
+      quoteReserveRaw: 2n, quoteReserve: 0.000000002,
+      priceQuotePerToken: 0.002, marketCapQuote: 2,
+      priceSol: 0.002, marketCapSol: 2, solUsd: null,
+      solUsdSource: null, solUsdAtMs: null, priceUsd: null, marketCapUsd: null,
+    },
+  }) as core.TradeEvent;
+  const verify = async ({ connection, tokens, signal }: coreVerification) => {
+    expect(signal.aborted).toBe(false);
+    expect(tokens).toContain(mint.toBase58());
+    const [mintAccount, poolAccount] = await Promise.all([
+      connection.getAccountInfo(mint), connection.getAccountInfo(pool),
+    ]);
+    return !!mintAccount && !!poolAccount && mintAccount.owner.equals(TOKEN_PROGRAM_ID) &&
+      mintAccount.data[44] === 6 && mintAccount.data.readBigUInt64LE(36) > 0n &&
+      poolAccount.owner.equals(poolProgram) &&
+      new PublicKey(poolAccount.data.subarray(0, 32)).equals(mint) &&
+      new PublicKey(poolAccount.data.subarray(32, 64)).equals(NATIVE_MINT);
+  };
+  try {
+    // Environment-only/single-endpoint streams expose the same recovery API.
+    const oldEndpoint = process.env.RPC_ENDPOINT;
+    process.env.RPC_ENDPOINT = "https://recovery-only.example/";
+    try { subscription = await subscribeTrades({ tokens: [mint.toBase58()],
+      rpcUrls: [], healthCheckIntervalMs: 1000, onTrade: () => { emitted++; } }); }
+    finally { if (oldEndpoint === undefined) delete process.env.RPC_ENDPOINT; else process.env.RPC_ENDPOINT = oldEndpoint; }
+    expect(await subscription.verifyAndResume(verify)).toBe(false);
+    await emit(event("blocked")); expect(emitted).toBe(0);
+    snapshotValid = true;
+    expect(await subscription.verifyAndResume(verify)).toBe(true);
+    expect(reads).toBe(4);
+    await emit(event("accepted")); await emit(event("accepted"));
+    await emit(event("old", Date.now() - 31_000));
+    expect(emitted).toBe(1);
+    const future = Date.now() + 61_000;
+    clock = spyOn(Date, "now").mockReturnValue(future);
+    expect(subscription.feedVerified).toBe(false);
+    await emit(event("after-silence")); expect(emitted).toBe(1);
+    expect(await subscription.verifyAndResume(verify)).toBe(true);
+    await emit(event("resumed")); expect(emitted).toBe(2);
+    clock.mockRestore(); clock = undefined;
+    let finish!: (value: boolean) => void;
+    const verification = subscription.verifyAndResume(async () => await new Promise<boolean>(resolve => { finish = resolve; }));
+    while (!finish) await Bun.sleep(1);
+    const added = subscription.addTokens(Keypair.generate().publicKey.toBase58());
+    finish(true);
+    expect(await verification).toBe(false); await added;
+    expect(subscription.feedVerified).toBe(false);
+    let queuedRan = false;
+    let hangingStarted = false;
+    const hanging = subscription.verifyAndResume(async () => {
+      hangingStarted = true; return await new Promise<boolean>(() => {});
+    });
+    const hangingResult = hanging.then(value => ({ value, error: undefined as unknown }),
+      error => ({ value: false, error }));
+    while (!hangingStarted) await Bun.sleep(1);
+    await expect(subscription.verifyAndResume(async () => { queuedRan = true; return true; }, 5))
+      .rejects.toThrow("cancelled or timed out");
+    expect(queuedRan).toBe(false);
+    await subscription.close();
+    expect(((await hangingResult).error as Error).message).toContain("cancelled or timed out");
+    expect(subscription.feedVerified).toBe(false);
+  } finally {
+    clock?.mockRestore(); await subscription?.close();
+    trades.mockRestore(); accounts.mockRestore(); fetchMock.mockRestore(); globalThis.WebSocket = originalSocket;
+  }
+});
+type coreVerification = Parameters<import("./live.ts").FeedRecoveryVerification>[0];

package/src/live.test.ts

@@ -1,11 +1,18 @@
 import { describe, expect, spyOn, test } from "bun:test";
-import { Connection } from "@solana/web3.js";
-import { mkdtempSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { openDatabase, closeDatabase } from "../../core/src/db/database.ts";
-import { SqliteTokenHistoryRepository } from "../../core/src/chain/token-history/repository.ts";
-import { deriveWebSocketEndpoint, LiveEndpointPool, redactRpcEndpoint, subscribeTrades } from "./live.ts";
+const mockFetch = (implementation: (...args: Parameters<typeof fetch>) => ReturnType<typeof fetch>) =>
+  spyOn(globalThis, "fetch").mockImplementation(implementation as typeof fetch);
+import { Connection } from "@solana/web3.js";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { openDatabase, closeDatabase } from "../../core/src/db/database.ts";
+import { SqliteTokenHistoryRepository } from "../../core/src/chain/token-history/repository.ts";
+import {
+  deriveWebSocketEndpoint,
+  LiveEndpointPool,
+  redactRpcEndpoint,
+  subscribeTrades,
+} from "./live.ts";
 
 describe("sdk live endpoint", () => {
   test("derives websocket from the one RPC endpoint", () => {
@@ -21,16 +28,23 @@ describe("sdk live endpoint", () => {
       redactRpcEndpoint(
         "https://mainnet.helius-rpc.com/?api-key=secret-value&foo=bar",
       ),
-    ).toBe("https://mainnet.helius-rpc.com/?api-key=<redacted>&foo=bar");
+    ).toBe("https://mainnet.helius-rpc.com/***");
   });
 });
 test("live endpoint selection requires readiness, sticks, and rotates after later failures", async () => {
   const calls: string[] = [];
   const unavailable = new Set(["https://first.example/"]);
-  const pool = new LiveEndpointPool(["https://first.example/", "https://second.example/", "https://public.example/"], async (endpoint) => {
-    calls.push(endpoint);
-    if (unavailable.has(endpoint)) throw new Error("probe failed");
-  });
+  const pool = new LiveEndpointPool(
+    [
+      "https://first.example/",
+      "https://second.example/",
+      "https://public.example/",
+    ],
+    async (endpoint) => {
+      calls.push(endpoint);
+      if (unavailable.has(endpoint)) throw new Error("probe failed");
+    },
+  );
   expect(await pool.select()).toBe("https://second.example/");
   calls.length = 0;
   expect(await pool.select()).toBe("https://second.example/");
@@ -45,83 +59,245 @@ test("pooled trade stream preserves dynamic watched tokens when it rotates and c
   const originalSocket = globalThis.WebSocket;
   let firstHealthy = true;
   let nextId = 0;
-  const registrations: Array<{ endpoint: string; token: string }> = [];
+  const registrations: Array<{ endpoint: string; ws: string; token: string }> = [];
   const first = "https://live-primary.example/";
   const second = "https://live-fallback.example/";
   const mint = "So11111111111111111111111111111111111111112";
   globalThis.WebSocket = class extends EventTarget {
-    constructor() { super(); queueMicrotask(() => this.dispatchEvent(new Event("open"))); }
+    constructor() {
+      super();
+      queueMicrotask(() => this.dispatchEvent(new Event("open")));
+    }
+    send(payload: string) {
+      const request = JSON.parse(payload) as { method?: string; id?: number };
+      if (request.method === "slotSubscribe") queueMicrotask(() =>
+        this.dispatchEvent(new MessageEvent("message", { data: JSON.stringify({
+          jsonrpc: "2.0", id: request.id, result: 42,
+        }) })));
+    }
     close() {}
   } as any;
-  const fetchMock = spyOn(globalThis, "fetch").mockImplementation(async (input) => {
-    if (String(input) === first && !firstHealthy) return new Response("", { status: 401 });
-    return new Response(JSON.stringify({ result: "ok" }));
-  });
-  const logsMock = spyOn(Connection.prototype, "onLogs").mockImplementation(function (token) {
-    registrations.push({ endpoint: this.rpcEndpoint, token: String(token) });
-    return ++nextId;
-  });
-  const removeMock = spyOn(Connection.prototype, "removeOnLogsListener").mockResolvedValue(undefined);
+  const fetchMock = mockFetch(
+    async (input, init) => {
+      if (String(input) === first && !firstHealthy)
+        return new Response("", { status: 401 });
+      const method = JSON.parse(String(init?.body)).method;
+      return new Response(JSON.stringify({ result: method === "getGenesisHash"
+        ? "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d"
+        : { context: { slot: 50 }, value: 0 } }));
+    },
+  );
+  const logsMock = spyOn(Connection.prototype, "onLogs").mockImplementation(
+    function (token) {
+      registrations.push({ endpoint: this.rpcEndpoint,
+        ws: (this as any)._rpcWsEndpoint, token: String(token) });
+      return ++nextId;
+    },
+  );
+  const removeMock = spyOn(
+    Connection.prototype,
+    "removeOnLogsListener",
+  ).mockResolvedValue(undefined);
   let subscription: Awaited<ReturnType<typeof subscribeTrades>> | undefined;
   try {
-    subscription = await subscribeTrades({ tokens: [], rpcUrls: [first, second], healthCheckIntervalMs: 1000, onTrade() {} });
+    subscription = await subscribeTrades({
+      tokens: [],
+      rpcUrls: [first, second],
+      healthCheckIntervalMs: 1000,
+      onTrade() {},
+    });
     await subscription.addTokens(mint);
     firstHealthy = false;
     const deadline = Date.now() + 3000;
-    while (!registrations.some((row) => row.endpoint === second) && Date.now() < deadline) await Bun.sleep(25);
-    expect(registrations).toEqual([{ endpoint: first, token: mint }, { endpoint: second, token: mint }]);
+    while (
+      !registrations.some((row) => row.endpoint === second) &&
+      Date.now() < deadline
+    )
+      await Bun.sleep(25);
+    expect(registrations).toEqual([
+      { endpoint: first, ws: "wss://live-primary.example/", token: mint },
+      { endpoint: second, ws: "wss://live-fallback.example/", token: mint },
+    ]);
     expect(subscription.listTokens()).toEqual([mint]);
     expect(subscription.hasToken(mint)).toBe(true);
+    // A provider change must be explicitly reconciled by the application;
+    // a rejected snapshot cannot re-enable trading callbacks.
+    expect(subscription.feedVerified).toBe(false);
+    const rejected = await subscription.verifyAndResume(async ({tokens}) => {
+      expect(tokens).toEqual([mint]); return false;
+    });
+    expect(rejected).toBe(false);
+    expect(subscription.feedVerified).toBe(false);
+    const recovery = await subscription.verifyAndResume(async ({connection, tokens, signal}) => {
+      expect(connection.rpcEndpoint).toBe(second);
+      expect(tokens).toEqual([mint]);
+      expect(signal.aborted).toBe(false);
+      return true; // fixture represents successfully checked fresh pool/mint state
+    });
+    expect(recovery).toBe(true);
+    expect(subscription.feedVerified).toBe(true);
+    await expect(subscription.verifyAndResume(async () => new Promise<boolean>(() => {}), 5))
+      .rejects.toThrow("Feed verification cancelled or timed out");
     await subscription.close();
     await subscription.closed;
     expect(subscription.listTokens()).toEqual([]);
     expect(removeMock).toHaveBeenCalledTimes(2);
   } finally {
     await subscription?.close();
-    logsMock.mockRestore(); removeMock.mockRestore(); fetchMock.mockRestore(); globalThis.WebSocket = originalSocket;
+    logsMock.mockRestore();
+    removeMock.mockRestore();
+    fetchMock.mockRestore();
+    globalThis.WebSocket = originalSocket;
   }
 });
 
-test("listenTrades refreshes migrated identities without changing the watched token list", async () => {
+test("listenTrades refreshes migrated identities without changing the watched token list", async () => {
   const core = await import("@solard/core");
   const { listenTrades } = await import("./live.ts");
   const mint = "So11111111111111111111111111111111111111112";
-  const endpoint = "https://migration-listener.example/";
-  const dir = mkdtempSync(join(tmpdir(), "slrd-sdk-listener-"));
-  const dbPath = join(dir, "history.sqlite");
+  const endpoint = "https://migration-listener.example/";
+  const dir = mkdtempSync(join(tmpdir(), "slrd-sdk-listener-"));
+  const dbPath = join(dir, "history.sqlite");
   const originalSocket = globalThis.WebSocket;
-  globalThis.WebSocket = class extends EventTarget { constructor() { super(); queueMicrotask(() => this.dispatchEvent(new Event("open"))); } close() {} } as any;
-  const fetchMock = spyOn(globalThis, "fetch").mockImplementation(async () => new Response(JSON.stringify({ result: "ok" })));
-  let onMigration: any; let onTrade: any;
-  const tokens = new Set<string>(); const changes: string[] = [];
+  globalThis.WebSocket = class extends EventTarget {
+    constructor() {
+      super();
+      queueMicrotask(() => this.dispatchEvent(new Event("open")));
+    }
+    send(payload: string) {
+      const request = JSON.parse(payload) as { method?: string; id?: number };
+      if (request.method === "slotSubscribe") queueMicrotask(() =>
+        this.dispatchEvent(new MessageEvent("message", { data: JSON.stringify({
+          jsonrpc: "2.0", id: request.id, result: 42,
+        }) })));
+    }
+    close() {}
+  } as any;
+  const fetchMock = mockFetch(
+    async (_input, init) => {
+      const method = JSON.parse(String(init?.body)).method;
+      return new Response(JSON.stringify({ result: method === "getGenesisHash"
+        ? "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d"
+        : { context: { slot: 50 }, value: 0 } }));
+    },
+  );
+  let onMigration: any;
+  let onTrade: any;
+  const tokens = new Set<string>();
+  const changes: string[] = [];
   let closeTrade!: () => void;
-  const tradeClosed = new Promise<void>(resolve => { closeTrade = resolve; });
-  const tradeMock = spyOn(core, "subscribeTrades").mockImplementation(async (options: any) => {
-    options.tokens.forEach((t: string) => tokens.add(t)); onTrade = options.onTrade;
-    return { addTokens: async (value: any) => { changes.push("add"); (typeof value === "string" ? [value] : value).forEach((t: string) => tokens.add(t)); },
-      removeTokens: async (value: any) => { changes.push("remove"); (typeof value === "string" ? [value] : value).forEach((t: string) => tokens.delete(t)); },
-      hasToken: (t: string) => tokens.has(t), listTokens: () => [...tokens], close: async () => closeTrade(), closed: tradeClosed };
-  });
-  const migrationMock = spyOn(core, "subscribeMigrations").mockImplementation(async (options: any) => {
-    onMigration = options.onMigration;
-    return { mode: "selected", addTokens: async () => {}, removeTokens: async () => {}, hasToken: () => true, listTokens: () => options.tokens, close: async () => {}, closed: Promise.resolve() } as any;
+  const tradeClosed = new Promise<void>((resolve) => {
+    closeTrade = resolve;
   });
+  const tradeMock = spyOn(core, "subscribeTrades").mockImplementation(
+    async (options: any) => {
+      options.tokens.forEach((t: string) => tokens.add(t));
+      onTrade = options.onTrade;
+      return {
+        addTokens: async (value: any) => {
+          changes.push("add");
+          (typeof value === "string" ? [value] : value).forEach((t: string) =>
+            tokens.add(t),
+          );
+        },
+        removeTokens: async (value: any) => {
+          changes.push("remove");
+          (typeof value === "string" ? [value] : value).forEach((t: string) =>
+            tokens.delete(t),
+          );
+        },
+        hasToken: (t: string) => tokens.has(t),
+        listTokens: () => [...tokens],
+        close: async () => closeTrade(),
+        closed: tradeClosed,
+      };
+    },
+  );
+  const migrationMock = spyOn(core, "subscribeMigrations").mockImplementation(
+    async (options: any) => {
+      onMigration = options.onMigration;
+      return {
+        mode: "selected",
+        addTokens: async () => {},
+        removeTokens: async () => {},
+        hasToken: () => true,
+        listTokens: () => options.tokens,
+        close: async () => {},
+        closed: Promise.resolve(),
+      } as any;
+    },
+  );
   let listener: Awaited<ReturnType<typeof listenTrades>> | undefined;
   try {
-    listener = await listenTrades({ tokens: [mint], rpcUrls: [endpoint], dbPath });
-    const received: any[] = []; listener.onMigration(event => { received.push(event); });
-    const event = { signature: "trade", mint, pool: "old-pool", venue: "pumpswap", side: "buy", eventIndex: 0, slot: 11, atMs: Date.now(), baseRaw: 1000000n, quoteRaw: 10000000n,
-      market: { quoteMint: mint, baseDecimals: 6, quoteDecimals: 9, supplyRaw: 1000000000000000n, baseReserveRaw: 100000000n, quoteReserveRaw: 1000000000n,
-        priceQuotePerToken: .01, priceSol: .01, priceUsd: 1, marketCapSol: 10000000, marketCapUsd: 1000000000 } };
-    await onTrade(event); await onTrade(event);
-    await onMigration({ type: "migration", mint, pool: "new-pool", signature: "migration", slot: 12, venue: "pump", destination: "pumpswap", quoteMint: mint, atMs: Date.now(), isMayhemMode: false, metadata: null });
+    listener = await listenTrades({
+      tokens: [mint],
+      rpcUrls: [endpoint],
+      dbPath,
+    });
+    const received: any[] = [];
+    listener.onMigration((event) => {
+      received.push(event);
+    });
+    const event = {
+      signature: "trade",
+      mint,
+      pool: "old-pool",
+      venue: "pumpswap",
+      side: "buy",
+      eventIndex: 0,
+      slot: 11,
+      atMs: Date.now(),
+      baseRaw: 1000000n,
+      quoteRaw: 10000000n,
+      market: {
+        quoteMint: mint,
+        baseDecimals: 6,
+        quoteDecimals: 9,
+        supplyRaw: 1000000000000000n,
+        baseReserveRaw: 100000000n,
+        quoteReserveRaw: 1000000000n,
+        priceQuotePerToken: 0.01,
+        priceSol: 0.01,
+        priceUsd: 1,
+        marketCapSol: 10000000,
+        marketCapUsd: 1000000000,
+      },
+    };
+    await onTrade(event);
+    await onTrade(event);
+    await onMigration({
+      type: "migration",
+      mint,
+      pool: "new-pool",
+      signature: "migration",
+      slot: 12,
+      venue: "pump",
+      destination: "pumpswap",
+      quoteMint: mint,
+      atMs: Date.now(),
+      isMayhemMode: false,
+      metadata: null,
+    });
     expect(changes).toEqual(["remove", "add"]);
     expect(listener.list()).toEqual([mint]);
-    expect(received[0]).toMatchObject({ oldPool: "old-pool", newPool: "new-pool", slot: 12 });
-    await listener.close(); await listener.closed;
-    const repository = new SqliteTokenHistoryRepository(openDatabase(dbPath));
-    expect(repository.loadTrades(mint)).toHaveLength(1);
-    expect(repository.loadCandles1s(mint)).toHaveLength(1);
-    closeDatabase(dbPath);
-  } finally { await listener?.close(); closeDatabase(dbPath); tradeMock.mockRestore(); migrationMock.mockRestore(); fetchMock.mockRestore(); globalThis.WebSocket = originalSocket; rmSync(dir, { recursive: true, force: true }); }
-});
+    expect(received[0]).toMatchObject({
+      oldPool: "old-pool",
+      newPool: "new-pool",
+      slot: 12,
+    });
+    await listener.close();
+    await listener.closed;
+    const repository = new SqliteTokenHistoryRepository(openDatabase(dbPath));
+    expect(repository.loadTrades(mint)).toHaveLength(1);
+    expect(repository.loadCandles1s(mint)).toHaveLength(1);
+    closeDatabase(dbPath);
+  } finally {
+    await listener?.close();
+    closeDatabase(dbPath);
+    tradeMock.mockRestore();
+    migrationMock.mockRestore();
+    fetchMock.mockRestore();
+    globalThis.WebSocket = originalSocket;
+    rmSync(dir, { recursive: true, force: true });
+  }
+});