@solard/sdk 0.2.31 → 0.2.37

package/README.md

@@ -26,3 +26,36 @@ before another trade. Buy accepts `minOutputRaw`; sell accepts `minOutputLamport
 Both use confirmed/failed/unresolved results with phase, code, attempts and accounting.
 `quote`, `curveLiquidity`, `maxSendableSol`, `transferToken` and `exitWallet` share the
 core implementation. Raydium AMM/CPMM execution does not supply live pool prices.
+
+In 0.2.32, sell an exact positive integer number of raw token units with the
+object API. For a six-decimal mint, `"1000000"` is one token:
+
+```ts
+const sold = await slrd.sell(
+  { wallet: "trader-1", token: mint, amountRaw: "1000000", slippageBps: 500 },
+  { intentKey: "example:sell:1", priorityFee: { cuLimit: 200_000, microLamports: 20_000 } },
+);
+```
+
+`amountRaw` also accepts bigint and is mutually exclusive with `amount`.
+An economic sell guard rejects output at or below the selected network fee plus
+tip before broadcasting, with `UNECONOMIC_SELL`. Its `sellEconomics` fields describe
+the expected output and selected costs; they are not charges already paid.
+`networkFeeLamports` is the actual on-chain charge only when known. Selected
+priority cost reserves the chosen CU limit, so it differs from consumed CUs.
+
+The configured client inherits its database path and RPC endpoints for listeners.
+Live history is recorded by default; disable recording with `history: false`:
+
+```ts
+const slrd = createSolard({ dbPath: "./slrd.db", rpcUrl });
+const listener = await slrd.listenTrades({ tokens: [mint] });
+listener.onTrade((event) => console.log(event));
+// await slrd.listenTrades({ tokens: [mint], history: false });
+await listener.close(); // Wait for queued history writes to flush.
+```
+
+The collected live tail is partial history, not a complete backfill. Processed
+events can later disappear; `slrd.historicalTape(mint)` excludes them by default.
+Pass `{ includeProcessed: true }` to inspect that provisional tail and check the
+returned completeness information before using it for backtests.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solard/sdk",
-  "version": "0.2.31",
+  "version": "0.2.37",
   "description": "Public Solard SDK for wallets, trading, history, live market subscriptions and token metadata.",
   "type": "module",
   "main": "./src/index.ts",
@@ -27,7 +27,7 @@
   "license": "MIT",
   "dependencies": {
     "@solana/web3.js": "^1.98.4",
-    "@solard/core": "0.2.31"
+    "@solard/core": "0.2.37"
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.browser.json",

package/src/client.exact-sell.test.ts

@@ -0,0 +1,95 @@
+import { expect, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Solard } from "../../core/src/core/solard.ts";
+import { tradeResult } from "../../core/src/tx/trade-result.ts";
+import { createSolard, type SolardSellInput } from "./client.ts";
+import { isDefinitivePreSubmissionError } from "@solard/core";
+
+test("SDK exact raw sell forwards an isolated position without inserting default bps", async () => {
+  const folder = mkdtempSync(join(tmpdir(), "solard-sdk-exact-"));
+  const calls: Array<Record<string, unknown>> = [];
+  const sell = spyOn(Solard.prototype, "sell").mockImplementation(
+    async (_token, _wallet, options) => {
+      calls.push(options as unknown as Record<string, unknown>);
+      return tradeResult({
+        signature: "fixture",
+        sender: "rpc",
+        status: "confirmed",
+        slot: 1,
+      });
+    },
+  );
+  const sdk = createSolard({ dbPath: join(folder, "test.sqlite") });
+  try {
+    await sdk.sell(
+      {
+        token: "mint",
+        wallet: "wallet",
+        amountRaw: "284725",
+        slippageBps: 500,
+        minOutputLamports: 1n,
+      },
+      { priorityFee: { microLamports: 20_000 } },
+    );
+    await sdk.sell({
+      token: "mint",
+      wallet: "wallet",
+      amount: { raw: 284725n },
+    });
+    await sdk.sell({ token: "mint", wallet: "wallet", amount: { bps: 1000 } });
+    await sdk.sell({ token: "mint", wallet: "wallet", amount: "all" });
+    expect(calls[0]).toMatchObject({
+      amountRaw: "284725",
+      slippageBps: 500,
+      minOutputLamports: 1n,
+      priorityFee: { microLamports: 20_000 },
+    });
+    expect(calls[0]?.bps).toBeUndefined();
+    expect(calls[1]?.amountRaw).toBe(284725n);
+    expect(calls[1]?.bps).toBeUndefined();
+    expect(calls[2]?.bps).toBe(1000);
+    expect(calls[3]?.bps).toBe(10000);
+  } finally {
+    sdk.close();
+    sell.mockRestore();
+    rmSync(folder, { recursive: true, force: true });
+  }
+});
+
+test("SDK rejects ambiguous and invalid raw quantities before invoking core sell", async () => {
+  const folder = mkdtempSync(join(tmpdir(), "solard-sdk-exact-invalid-"));
+  const sell = spyOn(Solard.prototype, "sell").mockImplementation(async () => {
+    throw new Error("must not call core");
+  });
+  const sdk = createSolard({ dbPath: join(folder, "test.sqlite") });
+  try {
+    for (const size of [
+      { amountRaw: "284725", amount: { bps: 1000 } },
+      { amountRaw: 0n },
+      { amountRaw: "1.5" },
+      { amount: { raw: "-1" } },
+      { amount: { bps: 1.5 } },
+      { amount: { raw: "284725", bps: 1000 } },
+    ]) {
+      await expect(
+        sdk.sell({
+          token: "mint",
+          wallet: "wallet",
+          ...size,
+        } as SolardSellInput),
+      ).rejects.toThrow();
+    }
+    expect(sell).not.toHaveBeenCalled();
+    try {
+      await sdk.sell({ token: "mint", wallet: "wallet", amountRaw: 0n });
+    } catch (error) {
+      expect(isDefinitivePreSubmissionError(error)).toBe(true);
+    }
+  } finally {
+    sdk.close();
+    sell.mockRestore();
+    rmSync(folder, { recursive: true, force: true });
+  }
+});

package/src/client.listen-trades.test.ts

@@ -0,0 +1,64 @@
+import { expect, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import * as live from "./live.ts";
+import { createSolard } from "./client.ts";
+
+test("client listener inherits its configured database and endpoint pool", async () => {
+  const folder = mkdtempSync(join(tmpdir(), "solard-sdk-listener-"));
+  const dbPath = join(folder, "test.sqlite");
+  const seen: Array<live.ListenTradesOptions> = [];
+  const fixture = {} as live.TradeListener;
+  const listen = spyOn(live, "listenTrades").mockImplementation(
+    async (options) => {
+      seen.push(options);
+      return fixture;
+    },
+  );
+  const sdk = createSolard({
+    dbPath,
+    rpcUrls: ["https://first.example.com", "https://second.example.com"],
+  });
+  try {
+    expect(await sdk.listenTrades({ tokens: ["mint"] })).toBe(fixture);
+    expect(seen[0]).toMatchObject({
+      dbPath,
+      rpcUrls: ["https://first.example.com", "https://second.example.com"],
+      tokens: ["mint"],
+    });
+    await sdk.listenTrades();
+    expect(seen[1]?.tokens).toEqual([]);
+  } finally {
+    sdk.close();
+    listen.mockRestore();
+    rmSync(folder, { recursive: true, force: true });
+  }
+});
+
+test("single RPC configuration is forwarded and absent URLs preserve live environment fallback", async () => {
+  const folder = mkdtempSync(join(tmpdir(), "solard-sdk-listener-url-"));
+  const seen: Array<live.ListenTradesOptions> = [];
+  const listen = spyOn(live, "listenTrades").mockImplementation(
+    async (options) => {
+      seen.push(options);
+      return {} as live.TradeListener;
+    },
+  );
+  const first = createSolard({
+    dbPath: join(folder, "first.sqlite"),
+    rpcUrl: "https://configured.example.com",
+  });
+  const second = createSolard({ dbPath: join(folder, "second.sqlite") });
+  try {
+    await first.listenTrades();
+    await second.listenTrades();
+    expect(seen[0]?.rpcUrls).toEqual(["https://configured.example.com"]);
+    expect(seen[1]?.rpcUrls).toBeUndefined();
+  } finally {
+    first.close();
+    second.close();
+    listen.mockRestore();
+    rmSync(folder, { recursive: true, force: true });
+  }
+});

package/src/client.trade-fees.test.ts

@@ -5,7 +5,10 @@ import { join } from "node:path";
 import { Keypair } from "@solana/web3.js";
 import { Solard } from "../../core/src/core/solard.ts";
 import { TransactionComposer } from "../../core/src/tx/composer.ts";
-import type { PlannedTransaction, TransactionDraft } from "../../core/src/tx/types.ts";
+import type {
+  PlannedTransaction,
+  TransactionDraft,
+} from "../../core/src/tx/types.ts";
 import { createSolard } from "./client.ts";
 
 test("SDK buy rebuild and sell preserve custom fees in immediate submitted results", async () => {
@@ -14,30 +17,49 @@ test("SDK buy rebuild and sell preserve custom fees in immediate submitted resul
   // A sentinel plan is never compiled, signed, or broadcast in this test.
   const payer = Keypair.generate();
   const plan = { payer: payer.publicKey } as PlannedTransaction;
-  const build = spyOn(TransactionComposer.prototype, "build").mockImplementation(async function (this: TransactionComposer) {
+  const build = spyOn(
+    TransactionComposer.prototype,
+    "build",
+  ).mockImplementation(async function (this: TransactionComposer) {
     drafts.push(this.snapshot());
     return { ...plan, draft: this.snapshot() };
   });
-  const signer = spyOn(Solard.prototype, "signer").mockImplementation(() => payer);
-  const compile = spyOn(Solard.prototype, "compile").mockImplementation(async (_payer, draft) => ({ ...plan, draft }));
+  const signer = spyOn(Solard.prototype, "signer").mockImplementation(
+    () => payer,
+  );
+  const compile = spyOn(Solard.prototype, "compile").mockImplementation(
+    async (_payer, draft) => ({ ...plan, draft }),
+  );
   let submissions = 0;
-  const submit = spyOn(Solard.prototype, "submitPlan").mockImplementation(async () => {
-    submissions += 1;
-    if (submissions === 1) {
-      throw new Error("Simulation failed: BuySlippageBelowMinBaseAmountOut");
-    }
-    return { signature: "test-signature", sender: "rpc", executionId: 42, plan };
-  });
-  const settle = spyOn(Solard.prototype, "settleSubmission").mockImplementation(async () => {
-    throw new Error("Immediate submission must not wait for confirmation");
-  });
+  const submit = spyOn(Solard.prototype, "submitPlan").mockImplementation(
+    async () => {
+      submissions += 1;
+      if (submissions === 1) {
+        throw new Error("Simulation failed: BuySlippageBelowMinBaseAmountOut");
+      }
+      return {
+        signature: "test-signature",
+        sender: "rpc",
+        executionId: 42,
+        plan,
+      };
+    },
+  );
+  const settle = spyOn(Solard.prototype, "settleSubmission").mockImplementation(
+    async () => {
+      throw new Error("Immediate submission must not wait for confirmation");
+    },
+  );
   const sdk = createSolard({ dbPath: join(directory, "test.sqlite") });
   try {
     const options = {
       priorityFee: { cuLimit: 300_000, microLamports: 0 },
       waitForConfirmation: false,
     };
-    const buy = await sdk.buy({ token: "token", wallet: "wallet", amount: 0.1 }, options);
+    const buy = await sdk.buy(
+      { token: "token", wallet: "wallet", amount: 0.1 },
+      options,
+    );
     const sell = await sdk.sell({ token: "token", wallet: "wallet" }, options);
     expect(drafts).toHaveLength(3);
     for (const draft of drafts) {

package/src/client.ts

@@ -20,8 +20,8 @@ import {
   type SendReceipt,
   type TradeLandingPolicy,
   type TradeResult,
-  type TradeExecutionOptions,
-  type LivePoolReserves,
+  type TradeExecutionOptions,
+  type LivePoolReserves,
   type SenderId,
   type SolardDecodedTransaction,
   type SolardTransactionOptions,
@@ -35,11 +35,17 @@ import {
   type WalletRef,
   type WalletPrivateKeyExport,
   type WalletPrivateKeyFormat,
+  TradePreSubmissionError,
 } from "@solard/core";
+import {
+  listenTrades as openTradeListener,
+  type ListenTradesOptions,
+  type TradeListener,
+} from "./live.ts";
 
 export type SolardOptions = {
-  rpcUrl?: string;
-  rpcUrls?: readonly string[];
+  rpcUrl?: string;
+  rpcUrls?: readonly string[];
   dbPath?: string;
   cacheTtlMs?: number;
 };
@@ -63,9 +69,9 @@ export type SolardEventsApi = {
   merge(streams: readonly ReplayEventSubscription[]): MergedReplayEventStream;
 };
 
-export type SolardBuyInput = {
-  reserves?: LivePoolReserves;
-  maxPriceSol?: string | number;
+export type SolardBuyInput = {
+  reserves?: LivePoolReserves;
+  maxPriceSol?: string | number;
   wallet: WalletRef;
   token: TokenRef;
   amount: HumanAmount | string | number;
@@ -73,13 +79,15 @@ export type SolardBuyInput = {
   minOutputRaw?: bigint | string;
 };
 
-export type SolardSellInput = {
-  closeTokenAccount?: boolean;
-  reserves?: LivePoolReserves;
-  minPriceSol?: string | number;
+export type SolardSellInput = {
+  closeTokenAccount?: boolean;
+  reserves?: LivePoolReserves;
+  minPriceSol?: string | number;
   wallet: WalletRef;
   token: TokenRef;
-  amount?: "all" | { bps: number };
+  amount?: "all" | { bps: number } | { raw: bigint | string };
+  /** Exact raw token units; mutually exclusive with amount. */
+  amountRaw?: bigint | string;
   slippageBps?: number;
   minOutputLamports?: bigint | string;
 };
@@ -87,19 +95,39 @@ export type SolardSellInput = {
 export type SolardTradeExecutionOptions = TradeExecutionOptions;
 
 export type SolardTradeExecutionResult = TradeResult;
-export type Solard = {
-  resolveCurrentMarket: ReturnType<typeof createCoreSolard>["resolveCurrentMarket"];
-  getClaimableCreatorFees: ReturnType<typeof createCoreSolard>["getClaimableCreatorFees"];
-  claimAllCreatorFees: ReturnType<typeof createCoreSolard>["claimAllCreatorFees"];
-  walletLedger: ReturnType<typeof createCoreSolard>["walletLedger"];
-  historicalTape: ReturnType<typeof createCoreSolard>["historicalTape"];
-  getSupportedPumpPairs: ReturnType<typeof createCoreSolard>["getSupportedPumpPairs"];
-  listVanityMints: ReturnType<typeof createCoreSolard>["listVanityMints"];
-  releaseVanityMint: ReturnType<typeof createCoreSolard>["releaseVanityMint"];
-  closeEmptyTokenAccounts: ReturnType<typeof createCoreSolard>["closeEmptyTokenAccounts"];
-  prepareTokenDeployment: ReturnType<typeof createCoreSolard>["prepareTokenDeployment"];
-  deployToken: ReturnType<typeof createCoreSolard>["deployToken"];
-  warmBlockhash: ReturnType<typeof createCoreSolard>["warmBlockhash"];
+export type Solard = {
+  listenTrades(
+    options?: Omit<ListenTradesOptions, "tokens"> & {
+      tokens?: readonly string[];
+    },
+  ): Promise<TradeListener>;
+  resolveCurrentMarket: ReturnType<
+    typeof createCoreSolard
+  >["resolveCurrentMarket"];
+  getClaimableCreatorFees: ReturnType<
+    typeof createCoreSolard
+  >["getClaimableCreatorFees"];
+  claimAllCreatorFees: ReturnType<
+    typeof createCoreSolard
+  >["claimAllCreatorFees"];
+  walletLedger: ReturnType<typeof createCoreSolard>["walletLedger"];
+  historicalTape: ReturnType<typeof createCoreSolard>["historicalTape"];
+  getSupportedPumpPairs: ReturnType<
+    typeof createCoreSolard
+  >["getSupportedPumpPairs"];
+  getSupportedLaunchLabPairs: ReturnType<
+    typeof createCoreSolard
+  >["getSupportedLaunchLabPairs"];
+  listVanityMints: ReturnType<typeof createCoreSolard>["listVanityMints"];
+  releaseVanityMint: ReturnType<typeof createCoreSolard>["releaseVanityMint"];
+  closeEmptyTokenAccounts: ReturnType<
+    typeof createCoreSolard
+  >["closeEmptyTokenAccounts"];
+  prepareTokenDeployment: ReturnType<
+    typeof createCoreSolard
+  >["prepareTokenDeployment"];
+  deployToken: ReturnType<typeof createCoreSolard>["deployToken"];
+  warmBlockhash: ReturnType<typeof createCoreSolard>["warmBlockhash"];
   curveLiquidity: ReturnType<typeof createCoreSolard>["curveLiquidity"];
   maxSendableSol: ReturnType<typeof createCoreSolard>["maxSendableSol"];
   transferToken: ReturnType<typeof createCoreSolard>["transferToken"];
@@ -174,15 +202,38 @@ function tradeAmount(value: HumanAmount | string | number): HumanAmount {
     : value;
 }
 
-function sellBps(value: SolardSellInput["amount"]): number {
-  if (value == null || value === "all") return 10_000;
-  const bps = Math.trunc(value.bps);
-  if (!(bps > 0 && bps <= 10_000))
+function sellSize(input: SolardSellInput): {
+  bps?: number;
+  amountRaw?: bigint | string;
+} {
+  const value = input.amount;
+  if (input.amountRaw !== undefined && value !== undefined)
+    throw new Error("sell amountRaw and amount are mutually exclusive");
+  const raw =
+    input.amountRaw !== undefined
+      ? input.amountRaw
+      : typeof value === "object" && value !== null && "raw" in value
+        ? value.raw
+        : undefined;
+  if (raw !== undefined) {
+    if (typeof value === "object" && value !== null && "bps" in value)
+      throw new Error("sell raw and bps are mutually exclusive");
+    if (
+      (typeof raw !== "bigint" &&
+        (typeof raw !== "string" || !/^\d+$/.test(raw))) ||
+      BigInt(raw) <= 0n
+    )
+      throw new Error("sell amountRaw must be a positive raw integer");
+    return { amountRaw: raw };
+  }
+  if (value == null || value === "all") return { bps: 10_000 };
+  if (!("bps" in value)) throw new Error("sell amount must specify bps or raw");
+  const bps = value.bps;
+  if (!Number.isInteger(bps) || !(bps > 0 && bps <= 10_000))
     throw new Error("sell amount.bps must be between 1 and 10000");
-  return bps;
+  return { bps };
 }
 
-
 async function executeTrade(
   core: ReturnType<typeof createCoreSolard>,
   side: "buy" | "sell",
@@ -191,11 +242,30 @@ async function executeTrade(
 ): Promise<SolardTradeExecutionResult> {
   if (side === "buy") {
     const buy = input as SolardBuyInput;
-    return await core.buy(buy.token, buy.wallet, tradeAmount(buy.amount), { ...options, slippageBps: buy.slippageBps, minOutputRaw: buy.minOutputRaw, maxPriceSol: buy.maxPriceSol, reserves: buy.reserves });
+    return await core.buy(buy.token, buy.wallet, tradeAmount(buy.amount), {
+      ...options,
+      slippageBps: buy.slippageBps,
+      minOutputRaw: buy.minOutputRaw,
+      maxPriceSol: buy.maxPriceSol,
+      reserves: buy.reserves,
+    });
   }
   const sell = input as SolardSellInput;
-  return await core.sell(sell.token, sell.wallet, { ...options, bps: sellBps(sell.amount), slippageBps: sell.slippageBps, minOutputLamports: sell.minOutputLamports, minPriceSol: sell.minPriceSol, reserves: sell.reserves, closeTokenAccount: sell.closeTokenAccount });
-
+  let size: ReturnType<typeof sellSize>;
+  try {
+    size = sellSize(sell);
+  } catch (error) {
+    throw new TradePreSubmissionError(error);
+  }
+  return await core.sell(sell.token, sell.wallet, {
+    ...options,
+    ...size,
+    slippageBps: sell.slippageBps,
+    minOutputLamports: sell.minOutputLamports,
+    minPriceSol: sell.minPriceSol,
+    reserves: sell.reserves,
+    closeTokenAccount: sell.closeTokenAccount,
+  });
 }
 
 export function createSolard(options: SolardOptions = {}): Solard {
@@ -210,19 +280,32 @@ export function createSolard(options: SolardOptions = {}): Solard {
       core.events(token, eventOptions),
     { merge: core.events.merge },
   ) as SolardEventsApi;
-  return Object.freeze({
-    resolveCurrentMarket: core.resolveCurrentMarket.bind(core),
-    getClaimableCreatorFees: core.getClaimableCreatorFees.bind(core),
-    claimAllCreatorFees: core.claimAllCreatorFees.bind(core),
-    walletLedger: core.walletLedger.bind(core),
-    historicalTape: core.historicalTape.bind(core),
-    getSupportedPumpPairs: core.getSupportedPumpPairs.bind(core),
-    listVanityMints: core.listVanityMints.bind(core),
-    releaseVanityMint: core.releaseVanityMint.bind(core),
-    closeEmptyTokenAccounts: core.closeEmptyTokenAccounts.bind(core),
-    prepareTokenDeployment: core.prepareTokenDeployment.bind(core),
-    deployToken: core.deployToken.bind(core),
-    warmBlockhash: core.warmBlockhash.bind(core),
+  return Object.freeze({
+    listenTrades: (
+      listenerOptions: Omit<ListenTradesOptions, "tokens"> & {
+        tokens?: readonly string[];
+      } = {},
+    ) =>
+      openTradeListener({
+        rpcUrls:
+          options.rpcUrls ?? (options.rpcUrl ? [options.rpcUrl] : undefined),
+        dbPath: options.dbPath,
+        ...listenerOptions,
+        tokens: listenerOptions.tokens ?? [],
+      }),
+    resolveCurrentMarket: core.resolveCurrentMarket.bind(core),
+    getClaimableCreatorFees: core.getClaimableCreatorFees.bind(core),
+    claimAllCreatorFees: core.claimAllCreatorFees.bind(core),
+    walletLedger: core.walletLedger.bind(core),
+    historicalTape: core.historicalTape.bind(core),
+    getSupportedPumpPairs: core.getSupportedPumpPairs.bind(core),
+    getSupportedLaunchLabPairs: core.getSupportedLaunchLabPairs.bind(core),
+    listVanityMints: core.listVanityMints.bind(core),
+    releaseVanityMint: core.releaseVanityMint.bind(core),
+    closeEmptyTokenAccounts: core.closeEmptyTokenAccounts.bind(core),
+    prepareTokenDeployment: core.prepareTokenDeployment.bind(core),
+    deployToken: core.deployToken.bind(core),
+    warmBlockhash: core.warmBlockhash.bind(core),
     curveLiquidity: core.curveLiquidity.bind(core),
     maxSendableSol: core.maxSendableSol.bind(core),
     transferToken: core.transferToken.bind(core),

package/src/default.ts

@@ -1,14 +1,9 @@
 import { getSolUsdPrice } from "@solard/core";
-import {
-  listenTrades,
-  subscribeLaunches,
-  subscribeMigrations,
-} from "./live.ts";
+import { subscribeLaunches, subscribeMigrations } from "./live.ts";
 import { createSolard, type Solard } from "./client.ts";
 
 type DefaultSolard = Solard & {
   getSolUsdPrice: typeof getSolUsdPrice;
-  listenTrades: typeof listenTrades;
   subscribeLaunches: typeof subscribeLaunches;
   subscribeMigrations: typeof subscribeMigrations;
 };
@@ -22,7 +17,6 @@ function client(): Solard {
 
 const operations = {
   getSolUsdPrice,
-  listenTrades,
   subscribeLaunches,
   subscribeMigrations,
 } as const;

package/src/export-surface.test.ts

@@ -29,12 +29,19 @@ 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: [
+        "normalizeValueBandPolicy",
+        "planValueBandDecision",
+        "valueBandThresholds",
+        "normalizeTargetWeightPolicy",
+        "planTargetWeightRebalance",
+        "buildHistoricalCandles",
+        "runHistoricalStrategy",
+        "sweepHistoricalStrategies",
+        "LAUNCHLAB_PLATFORM_PRESETS",
+        "resolveLaunchLabPlatform",
+        "createSolard",
+        "createTraderSolard",
         "default",
         "fetchTokenMetadata",
         "formatRaw",
@@ -47,18 +54,32 @@ describe("sdk membrane", () => {
         "sol",
         "tokenAmount",
       ].sort(),
-      types: [
-        "TradeListenerMigration",
-        "ValueBandPolicy", "ValueBandRuntimeState", "ValueBandDecision",
-        "TargetWeightPolicy", "TargetWeightRebalancePlan",
-        "HistoricalTradeTape", "HistoricalCandle", "HistoricalStrategy",
-        "HistoricalExecutionOptions", "HistoricalStrategyResult",
-        "CreatorFeeDiscovery", "CreatorFeeGroup", "CreatorFeeItem",
-        "WalletLedger", "WalletLedgerEntry", "WalletLedgerOptions", "CurrentMarket",
-        "PreparedTokenDeployment", "PrepareDeploymentArgs",
-        "TradeLandingPolicy",
-        "LiveEndpointOptions",
-        "LivePoolReserves",
+      types: [
+        "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",
@@ -175,7 +196,7 @@ describe("sdk membrane", () => {
     expect(defaultClient).toContain("instance ??= createSolard()");
     expect(defaultClient).toContain('if (key === "close")');
     expect(defaultClient).toContain("getSolUsdPrice");
-    expect(defaultClient).toContain("listenTrades");
+    expect(client).toContain("listenTrades:");
     expect(defaultClient).toContain("subscribeLaunches");
     expect(defaultClient).toContain("subscribeMigrations");
     expect(defaultClient).not.toContain("export default createSolard()");
@@ -200,7 +221,7 @@ describe("sdk membrane", () => {
 
   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*:/,
+      /^(?: {2}| {4})(?:db|wallets|tokens|groups|executions|positions|prices|alts|senders|venues|claimSources|launches|launchpads|connection|signer)\s*:/m,
     );
   });
 });