@solard/sdk 0.2.29 → 0.2.33

package/src/export-surface.test.ts

@@ -1,192 +1,208 @@
-import { describe, expect, test } from "bun:test";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const source = readFileSync(join(import.meta.dir, "index.ts"), "utf8");
-const client = readFileSync(join(import.meta.dir, "client.ts"), "utf8");
-const protocol = readFileSync(join(import.meta.dir, "protocol.ts"), "utf8");
-const defaultClient = readFileSync(join(import.meta.dir, "default.ts"), "utf8");
-const live = readFileSync(join(import.meta.dir, "live.ts"), "utf8");
-
-function exportedNames(value: string) {
-  const values: string[] = [];
-  const types: string[] = [];
-  const pattern = /export\s+(type\s+)?\{([\s\S]*?)\}\s+from\s+["'][^"']+["'];/g;
-  for (const match of value.matchAll(pattern)) {
-    const target = match[1] ? types : values;
-    for (const raw of match[2]!.split(",")) {
-      const name =
-        raw.trim().split(/\s+as\s+/)[1] ?? raw.trim().split(/\s+as\s+/)[0];
-      if (name) target.push(name.trim());
-    }
-  }
-  return {
-    values: [...new Set(values)].sort(),
-    types: [...new Set(types)].sort(),
-  };
-}
-
-describe("sdk membrane", () => {
-  test("has an exact curated root export surface", () => {
-    expect(exportedNames(source)).toEqual({
-      values: [
-        "createSolard",
-        "default",
-        "fetchTokenMetadata",
-        "formatRaw",
-        "getSolUsdPrice",
-        "isDefinitivePreSubmissionError",
-        "publicTokenMetadataUrl",
-        "subscribeLaunches",
-        "subscribeMigrations",
-        "listenTrades",
-        "sol",
-        "tokenAmount",
-      ].sort(),
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const source = readFileSync(join(import.meta.dir, "index.ts"), "utf8");
+const client = readFileSync(join(import.meta.dir, "client.ts"), "utf8");
+const protocol = readFileSync(join(import.meta.dir, "protocol.ts"), "utf8");
+const defaultClient = readFileSync(join(import.meta.dir, "default.ts"), "utf8");
+const live = readFileSync(join(import.meta.dir, "live.ts"), "utf8");
+
+function exportedNames(value: string) {
+  const values: string[] = [];
+  const types: string[] = [];
+  const pattern = /export\s+(type\s+)?\{([\s\S]*?)\}\s+from\s+["'][^"']+["'];/g;
+  for (const match of value.matchAll(pattern)) {
+    const target = match[1] ? types : values;
+    for (const raw of match[2]!.split(",")) {
+      const name =
+        raw.trim().split(/\s+as\s+/)[1] ?? raw.trim().split(/\s+as\s+/)[0];
+      if (name) target.push(name.trim());
+    }
+  }
+  return {
+    values: [...new Set(values)].sort(),
+    types: [...new Set(types)].sort(),
+  };
+}
+
+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",
+        "default",
+        "fetchTokenMetadata",
+        "formatRaw",
+        "getSolUsdPrice",
+        "isDefinitivePreSubmissionError",
+        "publicTokenMetadataUrl",
+        "subscribeLaunches",
+        "subscribeMigrations",
+        "listenTrades",
+        "sol",
+        "tokenAmount",
+      ].sort(),
       types: [
-        "TradeLandingPolicy",
-        "ClaimCreatorRewardsOptions",
-        "CreatorRewardClaimPayout",
-        "CreatorRewardClaimResult",
-        "CumulativeDistributionExecuteOptions",
-        "CumulativeDistributionInput",
-        "CumulativeDistributionPlan",
-        "CumulativeDistributionRecipient",
-        "CumulativeDistributionState",
-        "CumulativeEntitlement",
-        "FetchTokenMetadataOptions",
-        "GetSolUsdPriceOptions",
-        "HumanAmount",
-        "LaunchEvent",
-        "LaunchSubscription",
-        "LaunchVenue",
-        "MigrationDestination",
-        "MigrationEvent",
-        "MigrationSubscription",
-        "MigrationVenue",
-        "MarketHistory",
-        "MarketHistoryOptions",
-        "MarketPrice",
-        "SolUsdPrice",
-        "SolUsdSource",
-        "SubscribeLaunchesOptions",
-        "SubscribeMigrationsOptions",
-        "ListenTradesOptions",
-        "MergedReplayEventStream",
-        "QuoteAsset",
-        "ReplayCoverage",
-        "ReplayEventSubscription",
-        "ReplayEventsOptions",
-        "ReplayHistory",
-        "ReplayItem",
-        "ReplayOptions",
-        "ReplayPayout",
-        "ReplayTransaction",
-        "RecordConfirmedTradeInput",
-        "SendReceipt",
-        "SenderId",
-        "SimulationResult",
-        "SolardDecodedTransaction",
-        "SolardPosition",
-        "SolardPositionQuery",
-        "SolardTransactionNativeBalance",
-        "SolardTransactionOptions",
-        "SolardTransactionTokenBalance",
-        "SolardTrade",
-        "SolardTradeQuery",
-        "SolardTradeSide",
-        "SolardTradeStatus",
-        "TradeEvent",
-        "TradeMarket",
-        "TradeSide",
-        "TradeListener",
-        "TradeVenue",
-        "Solard",
-        "SolardBuyInput",
-        "SolardSellInput",
-        "SolardTradeExecutionOptions",
-        "SolardTradeExecutionResult",
-        "SolardCanonicalEvent",
-        "SolardClaimAttribution",
-        "SolardClaimEvent",
-        "SolardEventsApi",
-        "SolardHistoryApi",
-        "SolardOptions",
-        "ExcludedTokenHolder",
-        "TokenHolder",
-        "TokenHolderSnapshot",
-        "TokenHolderSnapshotOptions",
-        "TokenEventHistoryProgress",
-        "TokenMetadata",
-        "TokenMetadataHint",
-        "TokenMetadataKind",
-        "TokenMetadataMode",
-        "TokenRef",
-        "TokenRow",
-        "WalletInfo",
-        "WalletPrivateKeyExport",
-        "WalletPrivateKeyFormat",
-        "WalletRef",
-      ].sort(),
-    });
-  });
-
-  test("does not wildcard-export or deep-import core", () => {
-    expect(source).not.toContain('export * from "@solard/core"');
-    expect(source).not.toMatch(/\.\.\/\.\.\/core\/src|@solard\/core\//);
-    expect(client).not.toMatch(/\.\.\/\.\.\/core\/src|@solard\/core\//);
-  });
-
-  test("keeps raw protocol decoders off the root surface", () => {
-    expect(source).not.toMatch(
-      /decode(?:ProgramDataLogs|PumpProgramData|PumpSwapProgramData|RaydiumLaunchLabProgramData)/,
-    );
-    expect(exportedNames(protocol)).toEqual({
-      values: [
-        "decodeProgramDataLogs",
-        "decodePumpProgramData",
-        "decodePumpSwapProgramData",
-        "decodeRaydiumLaunchLabProgramData",
-      ].sort(),
-      types: [
-        "PumpDecodedEvent",
-        "PumpSwapDecodedEvent",
-        "RaydiumLaunchLabDecodedEvent",
-      ].sort(),
-    });
-  });
-
-  test("exports a lazy zero-config default client", () => {
-    expect(source).toContain('export { default } from "./default.ts"');
-    expect(defaultClient).toContain("instance ??= createSolard()");
-    expect(defaultClient).toContain('if (key === "close")');
-    expect(defaultClient).toContain("getSolUsdPrice");
-    expect(defaultClient).toContain("listenTrades");
-    expect(defaultClient).toContain("subscribeLaunches");
-    expect(defaultClient).toContain("subscribeMigrations");
-    expect(defaultClient).not.toContain("export default createSolard()");
-    expect(live).toContain("process.env.RPC_ENDPOINT");
-    expect(live).not.toContain("SOLANA_RPC_URL");
-    expect(live).not.toContain("HELIUS_RPC_URL");
-    expect(live).not.toContain("SOLANA_WS_URL");
-    expect(live).not.toContain("HELIUS_WS_URL");
-  });
-
-  test("does not create persistence at module import", () => {
-    expect(source).not.toMatch(/createCoreSolard|createTraderSolard\(\)/);
-    expect(defaultClient).not.toMatch(/^const\s+\w+\s*=\s*createSolard\(\)/m);
-    expect(client.indexOf("createCoreSolard(options)")).toBeGreaterThan(
-      client.indexOf("export function createSolard"),
-    );
-    expect(client).toContain(
-      "recordConfirmedTrade: core.recordConfirmedTrade.bind(core)",
-    );
-    expect(client).toContain("trades: core.trades.bind(core)");
-  });
-
-  test("does not expose core repositories or secret-bearing handles", () => {
-    expect(client).not.toMatch(
-      /\b(?:db|wallets|tokens|groups|executions|positions|prices|alts|senders|venues|claimSources|launches|launchpads|connection|signer)\s*:/,
-    );
-  });
-});
+        "SellEconomics",
+        "SupportedLaunchLabPair",
+        "TradeListenerMigration",
+        "ValueBandPolicy", "ValueBandRuntimeState", "ValueBandDecision",
+        "TargetWeightPolicy", "TargetWeightRebalancePlan",
+        "HistoricalTradeTape", "HistoricalCandle", "HistoricalStrategy",
+        "HistoricalExecutionOptions", "HistoricalStrategyResult",
+        "CreatorFeeDiscovery", "CreatorFeeGroup", "CreatorFeeItem",
+        "WalletLedger", "WalletLedgerEntry", "WalletLedgerOptions", "CurrentMarket",
+        "PreparedTokenDeployment", "PrepareDeploymentArgs",
+        "TradeLandingPolicy",
+        "LiveEndpointOptions",
+        "LivePoolReserves",
+        "ClaimCreatorRewardsOptions",
+        "CreatorRewardClaimPayout",
+        "CreatorRewardClaimResult",
+        "CumulativeDistributionExecuteOptions",
+        "CumulativeDistributionInput",
+        "CumulativeDistributionPlan",
+        "CumulativeDistributionRecipient",
+        "CumulativeDistributionState",
+        "CumulativeEntitlement",
+        "FetchTokenMetadataOptions",
+        "GetSolUsdPriceOptions",
+        "HumanAmount",
+        "LaunchEvent",
+        "LaunchSubscription",
+        "LaunchVenue",
+        "MigrationDestination",
+        "MigrationEvent",
+        "MigrationSubscription",
+        "MigrationVenue",
+        "MarketHistory",
+        "MarketHistoryOptions",
+        "MarketPrice",
+        "SolUsdPrice",
+        "SolUsdSource",
+        "SubscribeLaunchesOptions",
+        "SubscribeMigrationsOptions",
+        "ListenTradesOptions",
+        "MergedReplayEventStream",
+        "QuoteAsset",
+        "ReplayCoverage",
+        "ReplayEventSubscription",
+        "ReplayEventsOptions",
+        "ReplayHistory",
+        "ReplayItem",
+        "ReplayOptions",
+        "ReplayPayout",
+        "ReplayTransaction",
+        "RecordConfirmedTradeInput",
+        "SendReceipt",
+        "SenderId",
+        "SimulationResult",
+        "SolardDecodedTransaction",
+        "SolardPosition",
+        "SolardPositionQuery",
+        "SolardTransactionNativeBalance",
+        "SolardTransactionOptions",
+        "SolardTransactionTokenBalance",
+        "SolardTrade",
+        "SolardTradeQuery",
+        "SolardTradeSide",
+        "SolardTradeStatus",
+        "TradeEvent",
+        "TradeMarket",
+        "TradeSide",
+        "TradeListener",
+        "TradeVenue",
+        "Solard",
+        "SolardBuyInput",
+        "SolardSellInput",
+        "SolardTradeExecutionOptions",
+        "SolardTradeExecutionResult",
+        "SolardCanonicalEvent",
+        "SolardClaimAttribution",
+        "SolardClaimEvent",
+        "SolardEventsApi",
+        "SolardHistoryApi",
+        "SolardOptions",
+        "ExcludedTokenHolder",
+        "TokenHolder",
+        "TokenHolderSnapshot",
+        "TokenHolderSnapshotOptions",
+        "TokenEventHistoryProgress",
+        "TokenMetadata",
+        "TokenMetadataHint",
+        "TokenMetadataKind",
+        "TokenMetadataMode",
+        "TokenRef",
+        "TokenRow",
+        "WalletInfo",
+        "WalletPrivateKeyExport",
+        "WalletPrivateKeyFormat",
+        "WalletRef",
+      ].sort(),
+    });
+  });
+
+  test("does not wildcard-export or deep-import core", () => {
+    expect(source).not.toContain('export * from "@solard/core"');
+    expect(source).not.toMatch(/\.\.\/\.\.\/core\/src|@solard\/core\//);
+    expect(client).not.toMatch(/\.\.\/\.\.\/core\/src|@solard\/core\//);
+  });
+
+  test("keeps raw protocol decoders off the root surface", () => {
+    expect(source).not.toMatch(
+      /decode(?:ProgramDataLogs|PumpProgramData|PumpSwapProgramData|RaydiumLaunchLabProgramData)/,
+    );
+    expect(exportedNames(protocol)).toEqual({
+      values: [
+        "decodeProgramDataLogs",
+        "decodePumpProgramData",
+        "decodePumpSwapProgramData",
+        "decodeRaydiumLaunchLabProgramData",
+      ].sort(),
+      types: [
+        "PumpDecodedEvent",
+        "PumpSwapDecodedEvent",
+        "RaydiumLaunchLabDecodedEvent",
+      ].sort(),
+    });
+  });
+
+  test("exports a lazy zero-config default client", () => {
+    expect(source).toContain('export { default } from "./default.ts"');
+    expect(defaultClient).toContain("instance ??= createSolard()");
+    expect(defaultClient).toContain('if (key === "close")');
+    expect(defaultClient).toContain("getSolUsdPrice");
+    expect(client).toContain("listenTrades:");
+    expect(defaultClient).toContain("subscribeLaunches");
+    expect(defaultClient).toContain("subscribeMigrations");
+    expect(defaultClient).not.toContain("export default createSolard()");
+    expect(live).toContain("process.env.RPC_ENDPOINT");
+    expect(live).not.toContain("SOLANA_RPC_URL");
+    expect(live).not.toContain("HELIUS_RPC_URL");
+    expect(live).not.toContain("SOLANA_WS_URL");
+    expect(live).not.toContain("HELIUS_WS_URL");
+  });
+
+  test("does not create persistence at module import", () => {
+    expect(source).not.toMatch(/createCoreSolard|createTraderSolard\(\)/);
+    expect(defaultClient).not.toMatch(/^const\s+\w+\s*=\s*createSolard\(\)/m);
+    expect(client.indexOf("createCoreSolard(options)")).toBeGreaterThan(
+      client.indexOf("export function createSolard"),
+    );
+    expect(client).toContain(
+      "recordConfirmedTrade: core.recordConfirmedTrade.bind(core)",
+    );
+    expect(client).toContain("trades: core.trades.bind(core)");
+  });
+
+  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,
+    );
+  });
+});

package/src/index.ts

@@ -1,6 +1,41 @@
 export { default } from "./default.ts";
 export { createSolard } from "./client.ts";
+export {
+  normalizeValueBandPolicy,
+  planValueBandDecision,
+  valueBandThresholds,
+  normalizeTargetWeightPolicy,
+  planTargetWeightRebalance,
+  buildHistoricalCandles,
+  runHistoricalStrategy,
+  sweepHistoricalStrategies,
+  LAUNCHLAB_PLATFORM_PRESETS,
+  resolveLaunchLabPlatform,
+} from "@solard/core";
 export type {
+  SellEconomics,
+  SupportedLaunchLabPair,
+  ValueBandPolicy,
+  ValueBandRuntimeState,
+  ValueBandDecision,
+  TargetWeightPolicy,
+  TargetWeightRebalancePlan,
+  HistoricalTradeTape,
+  HistoricalCandle,
+  HistoricalStrategy,
+  HistoricalExecutionOptions,
+  HistoricalStrategyResult,
+  CreatorFeeDiscovery,
+  CreatorFeeGroup,
+  CreatorFeeItem,
+  WalletLedger,
+  WalletLedgerEntry,
+  WalletLedgerOptions,
+  CurrentMarket,
+  PreparedTokenDeployment,
+  PrepareDeploymentArgs,
+} from "@solard/core";
+export type {
   Solard,
   SolardBuyInput,
   SolardEventsApi,
@@ -18,9 +53,10 @@ export {
   isDefinitivePreSubmissionError,
 } from "@solard/core";
 
-export type {
-  ClaimCreatorRewardsOptions,
-  TradeLandingPolicy,
+export type {
+  ClaimCreatorRewardsOptions,
+  TradeLandingPolicy,
+  LivePoolReserves,
   CreatorRewardClaimPayout,
   CreatorRewardClaimResult,
   CumulativeDistributionExecuteOptions,
@@ -85,9 +121,11 @@ export {
 } from "./live.ts";
 export type {
   ListenTradesOptions,
+  LiveEndpointOptions,
   SubscribeLaunchesOptions,
   SubscribeMigrationsOptions,
   TradeListener,
+  TradeListenerMigration,
 } from "./live.ts";
 export type {
   LaunchEvent,

package/src/live.test.ts

@@ -1,20 +1,127 @@
-import { describe, expect, test } from "bun:test";
-import { deriveWebSocketEndpoint, redactRpcEndpoint } from "./live.ts";
-
-describe("sdk live endpoint", () => {
-  test("derives websocket from the one RPC endpoint", () => {
-    expect(
-      deriveWebSocketEndpoint(
-        "https://mainnet.helius-rpc.com/?api-key=secret-value",
-      ),
-    ).toBe("wss://mainnet.helius-rpc.com/?api-key=secret-value");
-  });
-
-  test("redacts API credentials in diagnostics", () => {
-    expect(
-      redactRpcEndpoint(
-        "https://mainnet.helius-rpc.com/?api-key=secret-value&foo=bar",
-      ),
-    ).toBe("https://mainnet.helius-rpc.com/?api-key=<redacted>&foo=bar");
-  });
+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";
+
+describe("sdk live endpoint", () => {
+  test("derives websocket from the one RPC endpoint", () => {
+    expect(
+      deriveWebSocketEndpoint(
+        "https://mainnet.helius-rpc.com/?api-key=secret-value",
+      ),
+    ).toBe("wss://mainnet.helius-rpc.com/?api-key=secret-value");
+  });
+
+  test("redacts API credentials in diagnostics", () => {
+    expect(
+      redactRpcEndpoint(
+        "https://mainnet.helius-rpc.com/?api-key=secret-value&foo=bar",
+      ),
+    ).toBe("https://mainnet.helius-rpc.com/?api-key=<redacted>&foo=bar");
+  });
+});
+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");
+  });
+  expect(await pool.select()).toBe("https://second.example/");
+  calls.length = 0;
+  expect(await pool.select()).toBe("https://second.example/");
+  expect(calls).toEqual(["https://second.example/"]);
+  unavailable.add("https://second.example/");
+  expect(await pool.check()).toBe("https://public.example/");
+  unavailable.add("https://public.example/");
+  await expect(pool.check()).rejects.toThrow("probe failed");
+});
+
+test("pooled trade stream preserves dynamic watched tokens when it rotates and closes", async () => {
+  const originalSocket = globalThis.WebSocket;
+  let firstHealthy = true;
+  let nextId = 0;
+  const registrations: Array<{ endpoint: 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"))); }
+    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);
+  let subscription: Awaited<ReturnType<typeof subscribeTrades>> | undefined;
+  try {
+    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 }]);
+    expect(subscription.listTokens()).toEqual([mint]);
+    expect(subscription.hasToken(mint)).toBe(true);
+    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;
+  }
+});
+
+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 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[] = [];
+  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;
+  });
+  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 });
+    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 }); }
 });