@solard/sdk 0.2.33 → 0.2.37

package/README.md

@@ -25,37 +25,37 @@ converted prices are null. `unresolved` means reconcile with `resumeTrade(intent
 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.
+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.33",
+  "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.33"
+    "@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

@@ -1,45 +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 }); }
-});
+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

@@ -1,34 +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 }); }
-});
+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

@@ -34,10 +34,14 @@ import {
   type TokenRef,
   type WalletRef,
   type WalletPrivateKeyExport,
-  type WalletPrivateKeyFormat,
-  TradePreSubmissionError,
-} from "@solard/core";
-import { listenTrades as openTradeListener, type ListenTradesOptions, type TradeListener } from "./live.ts";
+  type WalletPrivateKeyFormat,
+  TradePreSubmissionError,
+} from "@solard/core";
+import {
+  listenTrades as openTradeListener,
+  type ListenTradesOptions,
+  type TradeListener,
+} from "./live.ts";
 
 export type SolardOptions = {
   rpcUrl?: string;
@@ -81,9 +85,9 @@ export type SolardSellInput = {
   minPriceSol?: string | number;
   wallet: WalletRef;
   token: TokenRef;
-  amount?: "all" | { bps: number } | { raw: bigint | string };
-  /** Exact raw token units; mutually exclusive with amount. */
-  amountRaw?: bigint | string;
+  amount?: "all" | { bps: number } | { raw: bigint | string };
+  /** Exact raw token units; mutually exclusive with amount. */
+  amountRaw?: bigint | string;
   slippageBps?: number;
   minOutputLamports?: bigint | string;
 };
@@ -91,19 +95,37 @@ export type SolardSellInput = {
 export type SolardTradeExecutionOptions = TradeExecutionOptions;
 
 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"];
+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"];
+  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"];
+  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"];
@@ -180,25 +202,38 @@ function tradeAmount(value: HumanAmount | string | number): HumanAmount {
     : value;
 }
 
-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 };
+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 };
 }
 
-
 async function executeTrade(
   core: ReturnType<typeof createCoreSolard>,
   side: "buy" | "sell",
@@ -207,13 +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;
-  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 });
-
+  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 {
@@ -228,20 +280,26 @@ export function createSolard(options: SolardOptions = {}): Solard {
       core.events(token, eventOptions),
     { merge: core.events.merge },
   ) as SolardEventsApi;
-  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 ?? [],
-    }),
+  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),
+    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),

package/src/default.ts

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