@solard/sdk 0.2.29 → 0.2.33

package/README.md

@@ -3,11 +3,59 @@
 Public Solard SDK. It intentionally contains no duplicate business logic; it re-exports the supported `@solard/core` API.
 
 ```ts
-import { Solard, sol } from "@solard/sdk";
+import { createSolard } from "@solard/sdk";
 
-const slrd = new Solard();
-const wallet = slrd.createWallet("trader-1");
-const wallets = slrd.listWallets();
-
-await slrd.tx(wallet.address).transferSol("RECIPIENT", sol("0.01")).send();
+const slrd = createSolard();
+await slrd.addToken(mint, undefined, { venueHint: "pumpswap", pool: poolAddress });
+const buy = await slrd.buy(
+  { wallet: "trader-1", token: mint, amount: { sol: 0.001 }, slippageBps: 500 },
+  { intentKey: "example:buy:1", priorityFee: { cuLimit: 600_000, microLamports: 200_000 } },
+);
+if (buy.status === "confirmed") {
+  console.log(buy.solPrincipalDeltaLamports, buy.networkFeeLamports, buy.targetTokenDeltaRaw);
+}
+// Sell through the same atomic quote-token -> SOL route.
+// await slrd.sell({ wallet: "trader-1", token: mint, amount: "all", slippageBps: 500 });
 ```
+
+The trader preset supports Pump/PumpSwap, Meteora DBC and DAMM v2. Custom quote
+routes require a supported SOL market for the quote token and suitable lookup
+tables when needed. Composer routes fall back to Jupiter instructions. Unavailable
+converted prices are null. `unresolved` means reconcile with `resumeTrade(intentKey)`
+before another trade. Buy accepts `minOutputRaw`; sell accepts `minOutputLamports`.
+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.29",
+  "version": "0.2.33",
   "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.29"
+    "@solard/core": "0.2.33"
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.browser.json",

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

@@ -0,0 +1,45 @@
+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,34 @@
+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

@@ -1,60 +1,60 @@
-import { expect, spyOn, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-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 { createSolard } from "./client.ts";
-
-test("SDK buy rebuild and sell preserve custom fees in immediate submitted results", async () => {
-  const directory = mkdtempSync(join(tmpdir(), "solard-sdk-fees-"));
-  const drafts: Array<TransactionDraft> = [];
-  // 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) {
-    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 }));
-  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 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 sell = await sdk.sell({ token: "token", wallet: "wallet" }, options);
-    expect(drafts).toHaveLength(3);
-    for (const draft of drafts) {
-      expect(draft.cuLimit).toBe(300_000);
-      expect(draft.cuPriceMicroLamports).toBe(0);
-    }
-    expect(buy.status).toBe("submitted");
-    expect(sell.status).toBe("submitted");
-    expect(buy.executionId).toBe(42);
-    expect(settle).not.toHaveBeenCalled();
-  } finally {
-    sdk.close();
-    build.mockRestore();
-    signer.mockRestore();
-    compile.mockRestore();
-    submit.mockRestore();
-    settle.mockRestore();
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
+import { expect, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+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 { createSolard } from "./client.ts";
+
+test("SDK buy rebuild and sell preserve custom fees in immediate submitted results", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "solard-sdk-fees-"));
+  const drafts: Array<TransactionDraft> = [];
+  // 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) {
+    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 }));
+  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 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 sell = await sdk.sell({ token: "token", wallet: "wallet" }, options);
+    expect(drafts).toHaveLength(3);
+    for (const draft of drafts) {
+      expect(draft.cuLimit).toBe(300_000);
+      expect(draft.cuPriceMicroLamports).toBe(0);
+    }
+    expect(buy.status).toBe("unresolved");
+    expect(sell.status).toBe("unresolved");
+    expect(buy.executionId).toBe(42);
+    expect(settle).not.toHaveBeenCalled();
+  } finally {
+    sdk.close();
+    build.mockRestore();
+    signer.mockRestore();
+    compile.mockRestore();
+    submit.mockRestore();
+    settle.mockRestore();
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

package/src/client.ts

@@ -17,8 +17,11 @@ import {
   type ReplayOptions,
   type ReplayEventsOptions,
   type RecordConfirmedTradeInput,
-  type SendReceipt,
-  type TradeLandingPolicy,
+  type SendReceipt,
+  type TradeLandingPolicy,
+  type TradeResult,
+  type TradeExecutionOptions,
+  type LivePoolReserves,
   type SenderId,
   type SolardDecodedTransaction,
   type SolardTransactionOptions,
@@ -31,11 +34,14 @@ import {
   type TokenRef,
   type WalletRef,
   type WalletPrivateKeyExport,
-  type WalletPrivateKeyFormat,
-} from "@solard/core";
+  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[];
   dbPath?: string;
   cacheTtlMs?: number;
 };
@@ -60,47 +66,53 @@ export type SolardEventsApi = {
 };
 
 export type SolardBuyInput = {
+  reserves?: LivePoolReserves;
+  maxPriceSol?: string | number;
   wallet: WalletRef;
   token: TokenRef;
   amount: HumanAmount | string | number;
   slippageBps?: number;
+  minOutputRaw?: bigint | string;
 };
 
 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;
 };
 
-export type SolardTradeExecutionOptions = {
-  landing?: TradeLandingPolicy;
-  waitForConfirmation?: boolean;
-  priorityFee?: { cuLimit?: number; microLamports?: number };
-  via?: SenderId;
-  skipSimulation?: boolean;
-  skipPreflight?: boolean;
-};
-
-export type SolardTradeExecutionResult = {
-  attempts?: Array<{ executionId: number; signature: string; priorityMicroLamports: number }>;
-  executionId: number;
-  signature: string;
-  sender: string;
-  status: SendReceipt["status"];
-  slot: number | null;
-  error: string | null;
-  feeLamports?: number;
-  computeUnitsConsumed?: number;
-  /** Signed economic SOL delta excluding network fee and token-account rent. */
-  solPrincipalDeltaLamports?: bigint;
-  /** Signed target-token delta for the confirmed atomic route. */
-  targetTokenDeltaRaw?: bigint;
-  /** Confirmed transaction network fee. */
-  networkFeeLamports?: bigint;
-};
+export type SolardTradeExecutionOptions = TradeExecutionOptions;
 
-export type Solard = {
+export type SolardTradeExecutionResult = TradeResult;
+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"];
+  exitWallet: ReturnType<typeof createCoreSolard>["exitWallet"];
+  resumeTrade(intentKey: string): Promise<SolardTradeExecutionResult>;
+  reconcile(intentKey: string): Promise<SolardTradeExecutionResult>;
+  quote: ReturnType<typeof createCoreSolard>["quote"];
   close(): void;
   history: SolardHistoryApi;
   events: SolardEventsApi;
@@ -168,12 +180,22 @@ 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))
-    throw new Error("sell amount.bps must be between 1 and 10000");
-  return bps;
+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 };
 }
 
 
@@ -183,49 +205,15 @@ async function executeTrade(
   input: SolardBuyInput | SolardSellInput,
   options: SolardTradeExecutionOptions = {},
 ): Promise<SolardTradeExecutionResult> {
-  const { submission, receipt, attempts } = await core.executeTradePlan(input.wallet, async () => {
-    const composer = core.tx(input.wallet).priorityFee(options.priorityFee ?? {});
-    if (side === "buy") {
-      const buy = input as SolardBuyInput;
-      composer.buy(buy.token, tradeAmount(buy.amount), { slippageBps: buy.slippageBps });
-    } else {
-      const sell = input as SolardSellInput;
-      composer.sell(sell.token, { bps: sellBps(sell.amount), slippageBps: sell.slippageBps });
-    }
-    return await composer.build();
-  }, options.via ?? "rpc", side, options);
-  const confirmedTrade =
-    receipt.status === "confirmed"
-      ? (
-          await core.trades({
-            wallet: input.wallet,
-            token: input.token,
-            side,
-            status: "confirmed",
-            limit: 32,
-          })
-        ).find((trade) => trade.signature === receipt.signature) ?? null
-      : null;
-  return {
-    executionId: submission.executionId,
-    signature: receipt.signature,
-    sender: receipt.sender,
-    status: receipt.status,
-    slot: receipt.slot,
-    error: receipt.error ?? null,
-    feeLamports: receipt.feeLamports,
-    computeUnitsConsumed: receipt.computeUnitsConsumed,
-    attempts,
-    ...(confirmedTrade?.solDeltaLamports != null
-      ? { solPrincipalDeltaLamports: confirmedTrade.solDeltaLamports }
-      : {}),
-    ...(confirmedTrade?.tokenDeltaRaw != null
-      ? { targetTokenDeltaRaw: confirmedTrade.tokenDeltaRaw }
-      : {}),
-    ...(confirmedTrade?.networkFeeLamports != null
-      ? { networkFeeLamports: confirmedTrade.networkFeeLamports }
-      : {}),
-  };
+  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 });
+  }
+  const sell = input as SolardSellInput;
+  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 {
@@ -240,7 +228,33 @@ export function createSolard(options: SolardOptions = {}): Solard {
       core.events(token, eventOptions),
     { merge: core.events.merge },
   ) as SolardEventsApi;
-  return Object.freeze({
+  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),
+    exitWallet: core.exitWallet.bind(core),
+    resumeTrade: core.resumeTrade.bind(core),
+    reconcile: core.reconcile.bind(core),
+    quote: core.quote.bind(core),
     close: core.close.bind(core),
     history,
     events: Object.freeze(events),

package/src/default.ts

@@ -1,51 +1,48 @@
-import { getSolUsdPrice } from "@solard/core";
-import {
-  listenTrades,
+import { getSolUsdPrice } from "@solard/core";
+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;
-};
-
-let instance: Solard | undefined;
-
-function client(): Solard {
-  instance ??= createSolard();
-  return instance;
-}
-
-const operations = {
-  getSolUsdPrice,
-  listenTrades,
+  subscribeMigrations,
+} from "./live.ts";
+import { createSolard, type Solard } from "./client.ts";
+
+type DefaultSolard = Solard & {
+  getSolUsdPrice: typeof getSolUsdPrice;
+  subscribeLaunches: typeof subscribeLaunches;
+  subscribeMigrations: typeof subscribeMigrations;
+};
+
+let instance: Solard | undefined;
+
+function client(): Solard {
+  instance ??= createSolard();
+  return instance;
+}
+
+const operations = {
+  getSolUsdPrice,
   subscribeLaunches,
-  subscribeMigrations,
-} as const;
-
-const slrd = new Proxy({} as DefaultSolard, {
-  get(_target, key) {
-    if (key === "close") {
-      return () => {
-        const current = instance;
-        instance = undefined;
-        current?.close();
-      };
-    }
-    if (typeof key === "string" && key in operations) {
-      return operations[key as keyof typeof operations];
-    }
-    const current = client();
-    const value = Reflect.get(current as object, key, current);
-    return typeof value === "function" ? value.bind(current) : value;
-  },
-  set() {
-    return false;
-  },
-});
-
-export default slrd;
+  subscribeMigrations,
+} as const;
+
+const slrd = new Proxy({} as DefaultSolard, {
+  get(_target, key) {
+    if (key === "close") {
+      return () => {
+        const current = instance;
+        instance = undefined;
+        current?.close();
+      };
+    }
+    if (typeof key === "string" && key in operations) {
+      return operations[key as keyof typeof operations];
+    }
+    const current = client();
+    const value = Reflect.get(current as object, key, current);
+    return typeof value === "function" ? value.bind(current) : value;
+  },
+  set() {
+    return false;
+  },
+});
+
+export default slrd;