@solard/cli 0.2.27 → 0.2.31

package/src/commands/sell.ts

@@ -1,239 +1,248 @@
-import {
-  executeJupiterSwap,
-  NATIVE_SOL_MINT,
-  nativePumpTradeAvailable,
-  quoteJupiterSwap,
-  resolveTradeRoute,
-  type SenderId,
-  type Solard,
-} from "@solard/core";
-
-import { resolveTradeTargets, type TradeTargets } from "./trade-targets.ts";
-import { summarizeTradeRoute, type TradeRouteSummary } from "./trade-result.ts";
-import { parseVenuePreference, type TradeCommandFlags } from "./trade-venue.ts";
-
-export type JupiterSellWalletPlan = {
-  wallet: string;
-  balanceRaw: bigint;
-  amountRaw: bigint;
-};
-
-export type SmartSellCommandResult =
-  | {
-      mode: "simulation";
-      route: "native";
-      target: TradeTargets;
-      routing: TradeRouteSummary;
-      results: unknown[];
-    }
-  | {
-      mode: "quote";
-      route: "jupiter";
-      target: TradeTargets;
-      routing: TradeRouteSummary;
-      plans: Array<
-        JupiterSellWalletPlan & {
-          quote: Awaited<ReturnType<typeof quoteJupiterSwap>>;
-        }
-      >;
-      hint: string;
-    }
-  | {
-      mode: "live";
-      route: "native";
-      target: TradeTargets;
-      routing: TradeRouteSummary;
-      receipts: unknown;
-    }
-  | {
-      mode: "live";
-      route: "jupiter";
-      target: TradeTargets;
-      routing: TradeRouteSummary;
-      results: Array<
-        JupiterSellWalletPlan & {
-          result: Awaited<ReturnType<typeof executeJupiterSwap>>;
-        }
-      >;
-    };
-
-type RunSmartSellCommandArgs = {
-  slrd: Solard;
-  values: string[];
-  flags: TradeCommandFlags;
-};
-
-function intFlag(
-  flags: TradeCommandFlags,
-  key: string,
-  fallback: number,
-): number {
-  const value = flags.get(key);
-  if (!value || value === "true") return fallback;
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed)) throw new Error(`--${key} must be an integer`);
-  return parsed;
-}
-
-export async function jupiterSellableAtaBalance(
-  slrd: Solard,
-  walletRef: string,
-  mint: string,
-): Promise<bigint> {
-  const accounts = await slrd.tokenAccounts(walletRef);
-  let associatedRaw = 0n;
-
-  for (const account of accounts) {
-    if (
-      account.mint === mint &&
-      account.isAssociated &&
-      account.amountRaw > 0n
-    ) {
-      associatedRaw += account.amountRaw;
-    }
-  }
-
-  return associatedRaw;
-}
-
-async function jupiterSellPlan(
-  slrd: Solard,
-  wallet: string,
-  mint: string,
-  bps: number,
-): Promise<JupiterSellWalletPlan> {
-  const balanceRaw = await jupiterSellableAtaBalance(slrd, wallet, mint);
-  const amountRaw = (balanceRaw * BigInt(bps)) / 10_000n;
-  if (amountRaw <= 0n) {
-    throw new Error(`No sellable associated-token-account balance for ${mint}`);
-  }
-  return { wallet, balanceRaw, amountRaw };
-}
-
-export async function runSmartSellCommand({
-  slrd,
-  values,
-  flags,
-}: RunSmartSellCommandArgs): Promise<SmartSellCommandResult> {
-  const tokenRef = values[0];
-  const usage =
-    "Usage: slrd sell <token|ca> (--wallet <wallet> | --wallets <w1,w2> | --group <group>) [--bps 10000] [--venue auto|native|jupiter]";
-  if (!tokenRef) throw new Error(usage);
-
-  const bps = intFlag(flags, "bps", 10_000);
-  if (bps <= 0 || bps > 10_000) throw new Error("--bps must be 1..10000");
-
-  const target = resolveTradeTargets(slrd, flags, usage);
-  const resolution = await resolveTradeRoute(
-    slrd,
-    tokenRef,
-    parseVenuePreference(flags),
-  );
-
-  if (resolution.asset.mint === NATIVE_SOL_MINT) {
-    throw new Error("slrd sell expects an SPL token");
-  }
-
-  if (resolution.route === "native") {
-    if (!nativePumpTradeAvailable(resolution.token)) {
-      throw new Error(
-        "Native sell requires a registered Pump/PumpSwap token; use --venue jupiter for ordinary SPL assets",
-      );
-    }
-
-    const options = {
-      bps,
-      slippageBps: intFlag(flags, "slippage-bps", 1_500),
-      via: (flags.get("sender") ?? "rpc") as SenderId,
-      skipSimulation: flags.has("skip-simulation"),
-      skipPreflight:
-        flags.has("skip-preflight") || flags.has("skip-simulation"),
-    };
-
-    if (flags.has("simulate-only")) {
-      const plans =
-        target.refs.length === 1
-          ? [
-              await slrd
-                .tx(target.refs[0]!)
-                .sell(resolution.token!.mint, options)
-                .build(),
-            ]
-          : await slrd
-              .composeMany(target.refs)
-              .sell(resolution.token!.mint, options)
-              .build();
-      const results = await Promise.all(
-        plans.map((plan) => slrd.simulatePlan(plan)),
-      );
-      return {
-        mode: "simulation",
-        route: "native",
-        target,
-        routing: summarizeTradeRoute(resolution),
-        results,
-      };
-    }
-
-    const receipts =
-      target.refs.length === 1
-        ? await slrd.sell(resolution.token!.mint, target.refs[0]!, options)
-        : await slrd.sellMany(resolution.token!.mint, target.refs, options);
-
-    return {
-      mode: "live",
-      route: "native",
-      target,
-      routing: summarizeTradeRoute(resolution),
-      receipts,
-    };
-  }
-
-  const plans: JupiterSellWalletPlan[] = [];
-  for (const wallet of target.refs) {
-    plans.push(await jupiterSellPlan(slrd, wallet, resolution.asset.mint, bps));
-  }
-
-  if (flags.has("simulate-only")) {
-    const quoted = [];
-    for (const plan of plans) {
-      quoted.push({
-        ...plan,
-        quote: await quoteJupiterSwap({
-          inputMint: resolution.asset.mint,
-          outputMint: NATIVE_SOL_MINT,
-          amountRaw: plan.amountRaw,
-        }),
-      });
-    }
-    return {
-      mode: "quote",
-      route: "jupiter",
-      target,
-      routing: summarizeTradeRoute(resolution),
-      plans: quoted,
-      hint: "Remove --simulate-only to execute these Jupiter-routed sells.",
-    };
-  }
-
-  const results = [];
-  for (const plan of plans) {
-    results.push({
-      ...plan,
-      result: await executeJupiterSwap({
-        inputMint: resolution.asset.mint,
-        outputMint: NATIVE_SOL_MINT,
-        amountRaw: plan.amountRaw,
-        signer: slrd.signer(plan.wallet),
-      }),
-    });
-  }
-
-  return {
-    mode: "live",
-    route: "jupiter",
-    target,
-    routing: summarizeTradeRoute(resolution),
-    results,
-  };
-}
+import {
+  executeJupiterSwap,
+  NATIVE_SOL_MINT,
+  nativePumpTradeAvailable,
+  quoteJupiterSwap,
+  resolveTradeRoute,
+  type SenderId,
+  type Solard,
+} from "@solard/core";
+
+import { resolveTradeTargets, type TradeTargets } from "./trade-targets.ts";
+import { tradeFeeOptions } from "./trade-fees.ts";
+import { summarizeTradeRoute, type TradeRouteSummary } from "./trade-result.ts";
+import { parseVenuePreference, type TradeCommandFlags } from "./trade-venue.ts";
+
+export type JupiterSellWalletPlan = {
+  wallet: string;
+  balanceRaw: bigint;
+  amountRaw: bigint;
+};
+
+export type SmartSellCommandResult =
+  | {
+      mode: "simulation";
+      route: "native";
+      target: TradeTargets;
+      routing: TradeRouteSummary;
+      results: unknown[];
+    }
+  | {
+      mode: "quote";
+      route: "jupiter";
+      target: TradeTargets;
+      routing: TradeRouteSummary;
+      plans: Array<
+        JupiterSellWalletPlan & {
+          quote: Awaited<ReturnType<typeof quoteJupiterSwap>>;
+        }
+      >;
+      hint: string;
+    }
+  | {
+      mode: "live";
+      route: "native";
+      target: TradeTargets;
+      routing: TradeRouteSummary;
+      receipts: unknown;
+    }
+  | {
+      mode: "live";
+      route: "jupiter";
+      target: TradeTargets;
+      routing: TradeRouteSummary;
+      results: Array<
+        JupiterSellWalletPlan & {
+          result: Awaited<ReturnType<typeof executeJupiterSwap>>;
+        }
+      >;
+    };
+
+type RunSmartSellCommandArgs = {
+  slrd: Solard;
+  values: string[];
+  flags: TradeCommandFlags;
+};
+
+function intFlag(
+  flags: TradeCommandFlags,
+  key: string,
+  fallback: number,
+): number {
+  const value = flags.get(key);
+  if (!value || value === "true") return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) throw new Error(`--${key} must be an integer`);
+  return parsed;
+}
+
+export async function jupiterSellableAtaBalance(
+  slrd: Solard,
+  walletRef: string,
+  mint: string,
+): Promise<bigint> {
+  const accounts = await slrd.tokenAccounts(walletRef);
+  let associatedRaw = 0n;
+
+  for (const account of accounts) {
+    if (
+      account.mint === mint &&
+      account.isAssociated &&
+      account.amountRaw > 0n
+    ) {
+      associatedRaw += account.amountRaw;
+    }
+  }
+
+  return associatedRaw;
+}
+
+async function jupiterSellPlan(
+  slrd: Solard,
+  wallet: string,
+  mint: string,
+  bps: number,
+): Promise<JupiterSellWalletPlan> {
+  const balanceRaw = await jupiterSellableAtaBalance(slrd, wallet, mint);
+  const amountRaw = (balanceRaw * BigInt(bps)) / 10_000n;
+  if (amountRaw <= 0n) {
+    throw new Error(`No sellable associated-token-account balance for ${mint}`);
+  }
+  return { wallet, balanceRaw, amountRaw };
+}
+
+export async function runSmartSellCommand({
+  slrd,
+  values,
+  flags,
+}: RunSmartSellCommandArgs): Promise<SmartSellCommandResult> {
+  const tokenRef = values[0];
+  const usage =
+    "Usage: slrd sell <token|ca> (--wallet <wallet> | --wallets <w1,w2> | --group <group>) [--bps 10000] [--venue auto|native|jupiter]";
+  if (!tokenRef) throw new Error(usage);
+
+  const bps = intFlag(flags, "bps", 10_000);
+  if (bps <= 0 || bps > 10_000) throw new Error("--bps must be 1..10000");
+
+  const target = resolveTradeTargets(slrd, flags, usage);
+  const resolution = await resolveTradeRoute(
+    slrd,
+    tokenRef,
+    parseVenuePreference(flags),
+  );
+
+  if (resolution.asset.mint === NATIVE_SOL_MINT) {
+    throw new Error("slrd sell expects an SPL token");
+  }
+
+  if (resolution.route === "native") {
+    if (!nativePumpTradeAvailable(resolution.token)) {
+      throw new Error(
+        "Native sell requires a registered Pump/PumpSwap token; use --venue jupiter for ordinary SPL assets",
+      );
+    }
+
+    const options = {
+      ...tradeFeeOptions(flags),
+      bps,
+      slippageBps: intFlag(flags, "slippage-bps", 1_500),
+      via: (flags.get("sender") ?? "rpc") as SenderId,
+      skipSimulation: flags.has("skip-simulation"),
+      skipPreflight:
+        flags.has("skip-preflight") || flags.has("skip-simulation"),
+    };
+
+    if (flags.has("simulate-only")) {
+      const plans =
+        target.refs.length === 1
+          ? [
+              await slrd
+                .tx(target.refs[0]!)
+                .priorityFee(options.priorityFee)
+                .sell(resolution.token!.mint, options)
+                .build(),
+            ]
+          : await slrd
+              .composeMany(target.refs)
+              .priorityFee(options.priorityFee)
+              .sell(resolution.token!.mint, options)
+              .build();
+      const results = await Promise.all(
+        plans.map(async (plan, index) => {
+          const prepared = await slrd.prepareTradePlan(target.refs[index]!, plan, options);
+          return { ...await slrd.simulatePlan(prepared.plan),
+            priorityMicroLamports: prepared.priorityMicroLamports,
+            cuLimit: prepared.plan.draft.cuLimit ?? 600_000 };
+        }),
+      );
+      return {
+        mode: "simulation",
+        route: "native",
+        target,
+        routing: summarizeTradeRoute(resolution),
+        results,
+      };
+    }
+
+    const receipts =
+      target.refs.length === 1
+        ? await slrd.sell(resolution.token!.mint, target.refs[0]!, options)
+        : await slrd.sellMany(resolution.token!.mint, target.refs, options);
+
+    return {
+      mode: "live",
+      route: "native",
+      target,
+      routing: summarizeTradeRoute(resolution),
+      receipts,
+    };
+  }
+
+  const plans: JupiterSellWalletPlan[] = [];
+  for (const wallet of target.refs) {
+    plans.push(await jupiterSellPlan(slrd, wallet, resolution.asset.mint, bps));
+  }
+
+  if (flags.has("simulate-only")) {
+    const quoted = [];
+    for (const plan of plans) {
+      quoted.push({
+        ...plan,
+        quote: await quoteJupiterSwap({
+          inputMint: resolution.asset.mint,
+          outputMint: NATIVE_SOL_MINT,
+          amountRaw: plan.amountRaw,
+        }),
+      });
+    }
+    return {
+      mode: "quote",
+      route: "jupiter",
+      target,
+      routing: summarizeTradeRoute(resolution),
+      plans: quoted,
+      hint: "Remove --simulate-only to execute these Jupiter-routed sells.",
+    };
+  }
+
+  const results = [];
+  for (const plan of plans) {
+    results.push({
+      ...plan,
+      result: await executeJupiterSwap({
+        inputMint: resolution.asset.mint,
+        outputMint: NATIVE_SOL_MINT,
+        amountRaw: plan.amountRaw,
+        signer: slrd.signer(plan.wallet),
+      }),
+    });
+  }
+
+  return {
+    mode: "live",
+    route: "jupiter",
+    target,
+    routing: summarizeTradeRoute(resolution),
+    results,
+  };
+}

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

@@ -0,0 +1,15 @@
+import { expect, test } from "bun:test";
+import { tradeFeeOptions } from "./trade-fees.ts";
+
+test("native buy/sell fee flags preserve custom compute limit and price", () => {
+  expect(tradeFeeOptions(new Map([
+    ["cu-limit", "150000"], ["priority-micro-lamports", "1000000"],
+    ["trade-attempts", "4"], ["max-priority-fee-lamports", "500000"],
+  ]))).toMatchObject({ priorityFee: { cuLimit: 150_000, microLamports: 1_000_000 },
+    landing: { maxAttempts: 4, maxPriorityFeeLamports: 500_000 } });
+});
+
+test("invalid fee flags reject instead of being ignored", () => {
+  for (const [name, value] of [["cu-limit", "0"], ["priority-micro-lamports", "-1"], ["priority-micro-lamports", "true"]])
+    expect(() => tradeFeeOptions(new Map([[name!, value!]]))).toThrow();
+});

package/src/commands/trade-fees.ts

@@ -0,0 +1,24 @@
+import type { TradeLandingPolicy } from "@solard/core";
+
+/** Validate fee flags before constructing or signing a trade. */
+export function tradeFeeOptions(flags: ReadonlyMap<string, string>) {
+  const number = (name: string): number | undefined => {
+    if (!flags.has(name)) return undefined;
+    const value = Number(flags.get(name));
+    if (!Number.isFinite(value)) throw new Error(`--${name} must be a number`);
+    return value;
+  };
+  const cuLimit = number("cu-limit");
+  const microLamports = number("priority-micro-lamports");
+  if (cuLimit != null && (!Number.isInteger(cuLimit) || cuLimit < 1 || cuLimit > 1_400_000))
+    throw new Error("--cu-limit must be an integer between 1 and 1400000");
+  if (microLamports != null && (!Number.isSafeInteger(microLamports) || microLamports < 0))
+    throw new Error("--priority-micro-lamports must be a non-negative integer");
+  const landing: TradeLandingPolicy = {
+    maxAttempts: number("trade-attempts"),
+    feeMultiplier: number("fee-multiplier"),
+    feePercentile: number("fee-percentile"),
+    maxPriorityFeeLamports: number("max-priority-fee-lamports"),
+  };
+  return { priorityFee: { cuLimit, microLamports }, landing };
+}

package/src/commands/transfer.test.ts

@@ -0,0 +1,33 @@
+import { test, expect } from "bun:test";
+import { Keypair } from "@solana/web3.js";
+import { Solard, estimatePlanFee, type PlannedTransaction } from "@solard/core";
+import { runTransferCommand } from "./transfer.ts";
+function fixture(status: "confirmed" | "submitted" | "failed" = "confirmed") {
+  const core: Solard = Object.create(Solard.prototype); const payer = Keypair.generate();
+  const prices: number[] = []; let samples = 0;
+  core.signer = () => payer;
+  core.connection = () => ({
+    getRecentPrioritizationFees: async () => { samples++; return [200_000, 400_000, 800_000, 1_000_000].map((prioritizationFee) => ({ prioritizationFee })); },
+    getFeeForMessage: async (message: { price: number }) => ({ value: 5000 + Math.ceil(10_000 * message.price / 1_000_000) }),
+  }) as any;
+  core.compile = async (_payer, draft) => ({ draft, payer: payer.publicKey, transaction: { message: { price: draft.cuPriceMicroLamports ?? 100_000 } } }) as unknown as PlannedTransaction;
+  core.submitPlan = async (plan, sender) => { prices.push(plan.draft.cuPriceMicroLamports!); return { signature: "test-signature", executionId: 1, sender, plan, feeEstimate: await estimatePlanFee(core.connection(), plan) }; };
+  core.settleSubmission = async () => ({ signature: "test-signature", sender: "rpc", status, slot: status === "confirmed" ? 1 : null, ...(status === "confirmed" ? { feeLamports: 13000 } : {}) });
+  Object.defineProperty(core, "executions", { value: { get: () => ({ metaJson: null }) } });
+  return { core, prices, samples: () => samples };
+}
+const flags = (extra: Array<[string, string]> = []) => new Map([["wallet", "bags"], ["sol", "2"], ["live", "true"], ...extra]);
+test("SOL transfer uses writable market fees and reports selected versus actual network fees", async () => {
+  const ctx = fixture();
+  const result = await runTransferCommand({ slrd: ctx.core, values: [Keypair.generate().publicKey.toBase58()], flags: flags() });
+  expect(ctx.prices).toEqual([800_000]); expect(ctx.samples()).toBe(1);
+  expect(result.status).toBe("confirmed"); expect(result.feeEstimate).toEqual({ cuLimit: 10_000, priorityMicroLamports: 800_000, priorityFeeLamports: 8000, estimatedBaseFeeLamports: 5000, estimatedNetworkFeeLamports: 13000 });
+  expect(result.feeLamports).toBe(13000);
+});
+test("explicit zero disables transfer fee estimation and pending outcome is never repeated blindly", async () => {
+  const ctx = fixture("submitted");
+  const result = await runTransferCommand({ slrd: ctx.core, values: [Keypair.generate().publicKey.toBase58()], flags: flags([["priority-micro-lamports", "0"]]) });
+  expect(ctx.prices).toEqual([0]); expect(ctx.samples()).toBe(0);
+  expect(result.status).toBe("unresolved"); expect(result.code).toBe("UNRESOLVED"); expect(result.feeLamports).toBeUndefined();
+  expect(result.feeEstimate).toMatchObject({ priorityFeeLamports: 0, estimatedNetworkFeeLamports: 5000 });
+});