@solard/sdk 0.2.33 → 0.2.37

package/src/export-surface.test.ts

@@ -30,11 +30,18 @@ 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",
+        "normalizeValueBandPolicy",
+        "planValueBandDecision",
+        "valueBandThresholds",
+        "normalizeTargetWeightPolicy",
+        "planTargetWeightRebalance",
+        "buildHistoricalCandles",
+        "runHistoricalStrategy",
+        "sweepHistoricalStrategies",
+        "LAUNCHLAB_PLATFORM_PRESETS",
+        "resolveLaunchLabPlatform",
+        "createSolard",
+        "createTraderSolard",
         "default",
         "fetchTokenMetadata",
         "formatRaw",
@@ -47,17 +54,29 @@ describe("sdk membrane", () => {
         "sol",
         "tokenAmount",
       ].sort(),
-      types: [
-        "SellEconomics",
-        "SupportedLaunchLabPair",
+      types: [
+        "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 +196,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 +221,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,6 @@
 export { default } from "./default.ts";
-export { createSolard } from "./client.ts";
+export { createSolard } from "./client.ts";
+export { createTraderSolard } from "@solard/core";
 export {
   normalizeValueBandPolicy,
   planValueBandDecision,
@@ -12,9 +13,9 @@ export {
   LAUNCHLAB_PLATFORM_PRESETS,
   resolveLaunchLabPlatform,
 } from "@solard/core";
-export type {
-  SellEconomics,
-  SupportedLaunchLabPair,
+export type {
+  SellEconomics,
+  SupportedLaunchLabPair,
   ValueBandPolicy,
   ValueBandRuntimeState,
   ValueBandDecision,

package/src/live.test.ts

@@ -1,11 +1,16 @@
 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";
+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", () => {
@@ -27,10 +32,17 @@ describe("sdk live endpoint", () => {
 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/");
@@ -50,26 +62,49 @@ test("pooled trade stream preserves dynamic watched tokens when it rotates and c
   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")));
+    }
     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 = 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() {} });
+    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, token: mint },
+      { endpoint: second, token: mint },
+    ]);
     expect(subscription.listTokens()).toEqual([mint]);
     expect(subscription.hasToken(mint)).toBe(true);
     await subscription.close();
@@ -78,50 +113,148 @@ test("pooled trade stream preserves dynamic watched tokens when it rotates and c
     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")));
+    }
+    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;
+  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 });
+  }
+});