@solard/cli 0.2.13 → 0.2.14

package/src/commands/buy.ts

@@ -0,0 +1,207 @@
+import {
+  executeJupiterSwap,
+  NATIVE_SOL_MINT,
+  nativePumpTradeAvailable,
+  quoteJupiterSwap,
+  resolveTradeRoute,
+  sol,
+  type SenderId,
+  type Solard,
+} from "@solard/sdk";
+
+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 SmartBuyCommandResult =
+  | {
+      mode: "simulation";
+      route: "native";
+      target: TradeTargets;
+      routing: TradeRouteSummary;
+      results: unknown[];
+    }
+  | {
+      mode: "quote";
+      route: "jupiter";
+      target: TradeTargets;
+      routing: TradeRouteSummary;
+      amountSol: string;
+      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<{
+        wallet: string;
+        result: Awaited<ReturnType<typeof executeJupiterSwap>>;
+      }>;
+    };
+
+type RunSmartBuyCommandArgs = {
+  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 runSmartBuyCommand({
+  slrd,
+  values,
+  flags,
+}: RunSmartBuyCommandArgs): Promise<SmartBuyCommandResult> {
+  const tokenRef = values[0];
+  const usage =
+    "Usage: slrd buy <token|ca> (--wallet <wallet> | --wallets <w1,w2> | --group <group>) --sol <amount> [--venue auto|native|jupiter]";
+  if (!tokenRef) throw new Error(usage);
+
+  const amountSol = flags.get("sol");
+  if (!amountSol || amountSol === "true") {
+    throw new Error("Buy requires explicit --sol <amount>");
+  }
+
+  const amount = sol(amountSol);
+  if (amount.raw <= 0n) throw new Error("--sol must be greater than zero");
+
+  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 buy expects an SPL token; SOL is already the input asset",
+    );
+  }
+
+  if (resolution.route === "native") {
+    if (!nativePumpTradeAvailable(resolution.token)) {
+      throw new Error(
+        "Native buy requires a registered Pump/PumpSwap token; use --venue jupiter for ordinary SPL assets",
+      );
+    }
+
+    const options = {
+      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]!)
+                .buy(resolution.token!.mint, amount, options)
+                .build(),
+            ]
+          : await slrd
+              .composeMany(target.refs)
+              .buy(resolution.token!.mint, amount, 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.buy(
+            resolution.token!.mint,
+            target.refs[0]!,
+            amount,
+            options,
+          )
+        : await slrd.buyMany(
+            resolution.token!.mint,
+            target.refs,
+            amount,
+            options,
+          );
+
+    return {
+      mode: "live",
+      route: "native",
+      target,
+      routing: summarizeTradeRoute(resolution),
+      receipts,
+    };
+  }
+
+  if (flags.has("simulate-only")) {
+    const quote = await quoteJupiterSwap({
+      inputMint: NATIVE_SOL_MINT,
+      outputMint: resolution.asset.mint,
+      amountRaw: amount.raw,
+    });
+    return {
+      mode: "quote",
+      route: "jupiter",
+      target,
+      routing: summarizeTradeRoute(resolution),
+      amountSol,
+      quote,
+      hint: "Remove --simulate-only to execute this Jupiter-routed buy.",
+    };
+  }
+
+  // Jupiter transport has its own measured, instance-scoped rate limiter. Keep
+  // multi-wallet execution sequential so a one-shot CLI command cannot create
+  // an avoidable burst against the API.
+  const results: Array<{
+    wallet: string;
+    result: Awaited<ReturnType<typeof executeJupiterSwap>>;
+  }> = [];
+  for (const wallet of target.refs) {
+    results.push({
+      wallet,
+      result: await executeJupiterSwap({
+        inputMint: NATIVE_SOL_MINT,
+        outputMint: resolution.asset.mint,
+        amountRaw: amount.raw,
+        signer: slrd.signer(wallet),
+      }),
+    });
+  }
+
+  return {
+    mode: "live",
+    route: "jupiter",
+    target,
+    routing: summarizeTradeRoute(resolution),
+    results,
+  };
+}

package/src/commands/jupiter-swap.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+import {
+  jupiterCliAmountRaw,
+  parseJupiterSwapCliRequest,
+  type JupiterCliAsset,
+} from "./jupiter-swap.ts";
+
+function flags(entries: Record<string, string>): ReadonlyMap<string, string> {
+  return new Map(Object.entries(entries));
+}
+
+describe("Jupiter swap CLI parsing", () => {
+  test("parses generic from/to syntax", () => {
+    expect(
+      parseJupiterSwapCliRequest(
+        [],
+        flags({
+          from: "USDC",
+          to: "SOL",
+          amount: "90",
+          wallet: "phantom",
+        }),
+      ),
+    ).toEqual({
+      wallet: "phantom",
+      fromRef: "USDC",
+      toRef: "SOL",
+      amountUi: "90",
+      live: false,
+    });
+  });
+
+  test("preserves legacy SOL input syntax", () => {
+    expect(
+      parseJupiterSwapCliRequest(
+        ["USDC"],
+        flags({
+          wallet: "phantom",
+          sol: "1",
+          live: "true",
+        }),
+      ),
+    ).toEqual({
+      wallet: "phantom",
+      fromRef: "SOL",
+      toRef: "USDC",
+      amountUi: "1",
+      live: true,
+    });
+  });
+
+  test("rejects --sol with non-SOL --from", () => {
+    expect(() =>
+      parseJupiterSwapCliRequest(
+        [],
+        flags({
+          wallet: "phantom",
+          from: "USDC",
+          to: "SOL",
+          sol: "1",
+        }),
+      ),
+    ).toThrow("--from SOL only");
+  });
+
+  test("uses canonical SOL amount parsing", () => {
+    const solAsset: JupiterCliAsset = {
+      ref: "SOL",
+      kind: "sol",
+      symbol: "SOL",
+      mint: "So11111111111111111111111111111111111111112",
+      decimals: 9,
+      tokenProgram: null,
+    };
+
+    expect(jupiterCliAmountRaw(solAsset, "1.25")).toBe(1_250_000_000n);
+  });
+});

package/src/commands/jupiter-swap.ts

@@ -0,0 +1,269 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+  executeJupiterSwap,
+  formatRaw,
+  quoteJupiterSwap,
+  RaydiumService,
+  resolveTradeAsset,
+  sol,
+  tokenAmount,
+  type JupiterSwapExecuteResult,
+  type JupiterSwapQuote,
+  type Solard,
+  type TradeAsset,
+} from "@solard/sdk";
+
+export type JupiterSwapCliFlags = ReadonlyMap<string, string>;
+
+export type JupiterCliAsset = TradeAsset;
+
+export type JupiterSwapCliRequest = {
+  wallet: string;
+  fromRef: string;
+  toRef: string;
+  amountUi: string;
+  live: boolean;
+};
+
+export type JupiterSwapQuoteCommandResult = {
+  mode: "quote";
+  wallet: string;
+  input: JupiterCliAsset & { amountUi: string; amountRaw: bigint };
+  output: JupiterCliAsset & { expectedOutputUi: string };
+  quote: JupiterSwapQuote;
+  hint: string;
+};
+
+export type JupiterSwapLiveCommandResult = {
+  mode: "live";
+  wallet: string;
+  input: JupiterCliAsset & { amountUi: string; amountRaw: bigint };
+  output: JupiterCliAsset;
+  result: JupiterSwapExecuteResult;
+};
+
+export type JupiterSwapCommandResult =
+  JupiterSwapQuoteCommandResult | JupiterSwapLiveCommandResult;
+
+export type RaydiumSwapCommandResult =
+  | {
+      mode: "quote";
+      route: "raydium";
+      wallet: string;
+      input: JupiterCliAsset & { amountUi: string; amountRaw: bigint };
+      output: JupiterCliAsset & {
+        expectedOutputUi: string;
+        minimumOutputUi: string;
+      };
+      quote: Awaited<ReturnType<RaydiumService["quoteExactIn"]>>;
+      hint: string;
+    }
+  | {
+      mode: "live";
+      route: "raydium";
+      wallet: string;
+      input: JupiterCliAsset & { amountUi: string; amountRaw: bigint };
+      output: JupiterCliAsset;
+      result: Awaited<ReturnType<RaydiumService["executePrepared"]>>;
+    };
+
+type RunJupiterSwapCommandArgs = {
+  slrd: Solard;
+  values: string[];
+  flags: JupiterSwapCliFlags;
+};
+
+function requiredFlag(flags: JupiterSwapCliFlags, key: string): string {
+  const value = flags.get(key);
+  if (!value || value === "true") {
+    throw new Error(`Missing --${key} <value>`);
+  }
+  return value;
+}
+
+export function parseJupiterSwapCliRequest(
+  values: readonly string[],
+  flags: JupiterSwapCliFlags,
+): JupiterSwapCliRequest {
+  const usage =
+    "Usage: slrd swap --from <SOL|token|mint> --to <SOL|token|mint> --amount <ui> --wallet <wallet> [--live]\n" +
+    "   or: slrd swap <token|mint> --wallet <wallet> --sol <amount> [--live]";
+
+  const wallet = requiredFlag(flags, "wallet");
+  const legacySolAmount = flags.get("sol");
+  const fromRef = flags.get("from") ?? (legacySolAmount ? "SOL" : undefined);
+  const toRef = flags.get("to") ?? values[0];
+  const amountUi = flags.get("amount") ?? legacySolAmount;
+
+  if (!fromRef || !toRef || !amountUi || amountUi === "true") {
+    throw new Error(usage);
+  }
+  if (legacySolAmount && fromRef.trim().toUpperCase() !== "SOL") {
+    throw new Error(
+      "--sol is compatibility syntax for --from SOL only; use --amount with non-SOL input",
+    );
+  }
+
+  return {
+    wallet,
+    fromRef,
+    toRef,
+    amountUi,
+    live: flags.has("live"),
+  };
+}
+
+export async function resolveJupiterCliAsset(
+  slrd: Solard,
+  refInput: string,
+): Promise<JupiterCliAsset> {
+  return await resolveTradeAsset(slrd, refInput);
+}
+
+export function jupiterCliAmountRaw(
+  asset: JupiterCliAsset,
+  amountUi: string,
+): bigint {
+  const raw =
+    asset.kind === "sol"
+      ? sol(amountUi).raw
+      : (() => {
+          if (!asset.tokenProgram) {
+            throw new Error(`Missing token program for ${asset.mint}`);
+          }
+          return tokenAmount(
+            amountUi,
+            new PublicKey(asset.mint),
+            asset.decimals,
+            new PublicKey(asset.tokenProgram),
+          ).raw;
+        })();
+
+  if (raw <= 0n) throw new Error("Swap amount must be greater than zero");
+  return raw;
+}
+
+export async function runJupiterSwapCommand({
+  slrd,
+  values,
+  flags,
+}: RunJupiterSwapCommandArgs): Promise<
+  JupiterSwapCommandResult | RaydiumSwapCommandResult
+> {
+  const request = parseJupiterSwapCliRequest(values, flags);
+
+  const [input, output] = await Promise.all([
+    resolveJupiterCliAsset(slrd, request.fromRef),
+    resolveJupiterCliAsset(slrd, request.toRef),
+  ]);
+  if (input.mint === output.mint) {
+    throw new Error(
+      `Swap input and output resolve to the same mint: ${input.mint}`,
+    );
+  }
+
+  const amountRaw = jupiterCliAmountRaw(input, request.amountUi);
+
+  const raydiumRequested =
+    flags.has("raydium") ||
+    (flags.get("venue") ?? "").toLowerCase() === "raydium";
+  if (raydiumRequested) {
+    const raydium = new RaydiumService(slrd);
+    const slippageBps = (() => {
+      const value = flags.get("slippage-bps");
+      if (!value || value === "true") return 100;
+      const parsed = Number(value);
+      if (!Number.isInteger(parsed))
+        throw new Error("--slippage-bps must be an integer");
+      return parsed;
+    })();
+    if (!request.live) {
+      const quote = await raydium.quoteExactIn({
+        inputMint: input.mint,
+        outputMint: output.mint,
+        amountRaw,
+        slippageBps,
+      });
+      return {
+        mode: "quote",
+        route: "raydium",
+        wallet: request.wallet,
+        input: { ...input, amountUi: request.amountUi, amountRaw },
+        output: {
+          ...output,
+          expectedOutputUi: formatRaw(quote.outputRaw, output.decimals),
+          minimumOutputUi: formatRaw(quote.minOutputRaw, output.decimals),
+        },
+        quote,
+        hint: "Re-run with --live and SOLARD_ENABLE_LIVE_TRADES=1 to execute this Raydium swap.",
+      };
+    }
+    const prepared = await raydium.buildSwapExactIn({
+      wallet: request.wallet,
+      inputMint: input.mint,
+      outputMint: output.mint,
+      amountRaw,
+      slippageBps,
+      computeUnitPriceMicroLamports:
+        flags.get("priority-micro-lamports") === "true"
+          ? undefined
+          : flags.get("priority-micro-lamports"),
+    });
+    const result = await raydium.executePrepared(prepared, {
+      live: true,
+      simulate: !flags.has("skip-simulation"),
+      skipPreflight: flags.has("skip-preflight"),
+    });
+    return {
+      mode: "live",
+      route: "raydium",
+      wallet: request.wallet,
+      input: { ...input, amountUi: request.amountUi, amountRaw },
+      output,
+      result,
+    };
+  }
+
+  if (!request.live) {
+    const quote = await quoteJupiterSwap({
+      inputMint: input.mint,
+      outputMint: output.mint,
+      amountRaw,
+    });
+
+    return {
+      mode: "quote",
+      wallet: request.wallet,
+      input: {
+        ...input,
+        amountUi: request.amountUi,
+        amountRaw,
+      },
+      output: {
+        ...output,
+        expectedOutputUi: formatRaw(quote.outAmountRaw, output.decimals),
+      },
+      quote,
+      hint: "Re-run with --live to execute this exact-input Jupiter swap.",
+    };
+  }
+
+  const result = await executeJupiterSwap({
+    inputMint: input.mint,
+    outputMint: output.mint,
+    amountRaw,
+    signer: slrd.signer(request.wallet),
+  });
+
+  return {
+    mode: "live",
+    wallet: request.wallet,
+    input: {
+      ...input,
+      amountUi: request.amountUi,
+      amountRaw,
+    },
+    output,
+    result,
+  };
+}