@solard/sdk 0.2.27 → 0.2.31

package/README.md

@@ -3,11 +3,26 @@
 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solard/sdk",
-  "version": "0.2.27",
+  "version": "0.2.31",
   "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.27"
+    "@solard/core": "0.2.31"
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.browser.json",

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

@@ -0,0 +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("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 });
+  }
+});