@solard/cli 0.1.8 → 0.2.3

package/README.md

@@ -0,0 +1,13 @@
+# @solard/cli
+
+CLI adapter for `@solard/sdk`.
+
+```bash
+slrd wallet create trader-1
+slrd wallets
+slrd token <mint> my-token
+slrd buy my-token --wallet trader-1 --sol 0.05
+slrd sell my-token --wallet trader-1
+```
+
+Set `SLRD_MASTER_KEY` for persisted wallets and `RPC_ENDPOINT` for chain operations.

package/bin/solard.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env bun
-import "../src/index.js";
+import "../src/index.ts";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@solard/cli",
-  "version": "0.1.8",
-  "description": "Multi-wallet Solana trading CLI UI and commands.",
+  "version": "0.2.3",
+  "description": "Command-line interface for the Solard SDK.",
   "type": "module",
   "main": "./src/index.ts",
   "bin": {
@@ -13,8 +13,16 @@
     "src",
     "README.md"
   ],
+  "license": "MIT",
+  "engines": {
+    "bun": ">=1.1.0"
+  },
   "dependencies": {
-    "@solard/core": "0.1.10"
+    "@solard/sdk": "^0.2.1",
+    "bs58": "^6.0.0",
+    "@solana/web3.js": "^1.98.4"
   },
-  "license": "MIT"
+  "scripts": {
+    "typecheck": "tsc --noEmit -p ../../tsconfig.json"
+  }
 }

package/src/index.ts

@@ -1,7 +1,9 @@
 #!/usr/bin/env bun
-import type { TokenRow } from "@solard/core/db/schema.ts";
-import { emit } from "@solard/core/core/ui.ts";
-import { listScripts, runScript } from "@solard/core/runner/run-script.ts";
+import { listScripts, runScript, type TokenRow } from "@solard/sdk";
+
+function emit(value: string): void {
+  process.stdout.write(value);
+}
 
 const OWL = "🦉";
 type Flags = Map<string, string>;
@@ -116,6 +118,7 @@ function help(): string {
   return `${OWL} slrd — multi-wallet Solana CLI + SDK for traders and AI agents
 
 Wallets and tokens
+  slrd wallet create [name]                  Generate and persist an encrypted Solana wallet
   slrd import <private_key> [name]
   cat key.json | slrd import --stdin [name]
   slrd wallets [--token <token>] [--addresses-only]    Show SOL and registered-token balances
@@ -125,13 +128,12 @@ Wallets and tokens
   slrd tokens
 
 Metadata and launching
-  solwal launch pump --creator <wallet> (--uri <metadata_uri> | --metadata <json> | --image <path> --description <text>) [--alias <name>] [--live] [--skip-simulation]
+  slrd launch pump --creator <wallet> (--uri <metadata_uri> | --metadata <json> | --image <path> --description <text>) [--alias <name>] [--live] [--skip-simulation]
                     [--deployment-sender helius-rpc|helius-fast] [--helius-tip-sol 0.01]
   slrd metadata upload --image <local_path> --name <name> --symbol <symbol> --description <text> [--provider pump-frontend|pinata]
                        [--twitter <url>] [--telegram <url>] [--website <url>] [--video <url>] [--hide-name]
   slrd deploy pump --wallet <wallet> --name <name> --symbol <symbol> (--uri <metadata_uri> | --image <local_path> --description <text>) [--alias <name>] [--live]
                    [--twitter <url>] [--telegram <url>] [--website <url>] [--video <url>] [--hide-name]
-  slrd run launch-pump-token --creator <wallet> --metadata <token.json> [--deploy-only] [--live]
 
 Prices
   slrd quote buy <token|ca> --sol <amount>           Inspect buy quote without submitting
@@ -143,7 +145,6 @@ Trading
   slrd buy <token|ca> (--wallet <wallet> | --wallets <w1,w2> | --group <name>) --sol <amount> [--slippage-bps 1500] [--sender rpc|helius|jito] [--simulate-only]
   slrd buy <future-mint> (--wallet <wallet> | --group <name>) (--sol <amount> | --lamports <amount> | --min-bps <n> --max-bps <n>) --spam [--live]
   slrd spam-buy [pump] <future-mint> (--wallet <wallet> | --group <name>) (--sol <amount> | --lamports <amount> | --min-bps <n> --max-bps <n>) [--sender <id>] [--live]
-  bun run scripts/spam-pump-buyers.ts --mint <future-mint> (--wallet <wallet> | --group <name>) --amount-mode range-bps --min-bps <n> --max-bps <n> [--live]
   slrd sell <token|ca> (--wallet <wallet> | --wallets <w1,w2> | --group <name>) [--bps 10000] [--slippage-bps 1500] [--sender rpc|helius|jito] [--simulate-only]
   slrd unwrap-wsol (--wallet <wallet> | --wallets <w1,w2> | --group <name>) [--sender rpc|helius|jito] [--ignore-missing] [--simulate-only]
   slrd claim <token|ca> --wallet <wallet> [--sender rpc|helius|jito]
@@ -152,7 +153,6 @@ Scripts (strategies stay outside the kernel)
   slrd scripts                              List scripts registered in slrd.config.ts
   slrd run <name-or-path> [script flags...] Execute a script that imports slrd
   slrd run snipe --name <exact_name> --group <group> --sol 0.05 --sender jito
-  slrd run claim-trade-send --claim <token> --buy <token> --wallet <wallet> --recipient <address>
 
 Groups and agents
   slrd group create <name> [description]
@@ -180,8 +180,8 @@ Transactions and ALTs
   slrd alt extend <address> --wallet <wallet> <account...>
 
 Environment
-  SLRD_DB_PATH      local shared database; default ./slrd.db
-  SLRD_MASTER_KEY   required to import/decrypt stored wallets
+  SLRD_DB_PATH      shared SDK/CLI database; default ./slrd.db (SOLARD_DB_PATH alias supported)
+  SLRD_MASTER_KEY   required to create/import/decrypt stored wallets
   RPC_ENDPOINT      required only for chain operations
   HELIUS_SENDER_URL regional/global Helius Sender endpoint used by launch scripts
   HELIUS_RPC_URL    RPC endpoint used for ordinary Helius-RPC buyer lane
@@ -212,8 +212,11 @@ async function main() {
     return;
   }
   if (command === "vanity") {
-    const { generateMintKeypairWithSuffix, saveMintKeypairFile, cleanVanitySuffix } =
-      await import("@solard/core/launches/pump/vanity-mint.ts");
+    const {
+      generateMintKeypairWithSuffix,
+      saveMintKeypairFile,
+      cleanVanitySuffix,
+    } = await import("@solard/sdk");
     const suffix = cleanVanitySuffix(need(flags, "suffix"));
     const out = need(flags, "out");
     const count = int(flags, "count", 1)!;
@@ -226,10 +229,14 @@ async function main() {
         timeoutMs: int(flags, "timeout-ms", 0)!,
         reportEvery: int(flags, "report-every", 1_000_000)!,
         onProgress: (p) =>
-          emit(`${OWL} grinding ${p.suffix}: ${p.attempts} attempts, ${p.ratePerSecond}/s\n`),
+          emit(
+            `${OWL} grinding ${p.suffix}: ${p.attempts} attempts, ${p.ratePerSecond}/s\n`,
+          ),
       });
       const path = count === 1 ? out : out.replace(/(\.json)?$/, `-${i + 1}$1`);
-      const saved = saveMintKeypairFile(path, found.mint, { force: flags.has("force") });
+      const saved = saveMintKeypairFile(path, found.mint, {
+        force: flags.has("force"),
+      });
       results.push({
         address: found.mint.publicKey.toBase58(),
         keypairPath: saved,
@@ -242,21 +249,15 @@ async function main() {
     return;
   }
   if (command === "spam-buy" || command === "buy-spam") {
-    const { runPumpSpamBuyFromArgs } =
-      await import("@solard/core/launches/pump/spam-buy-cli.ts");
+    const { runPumpSpamBuyFromArgs } = await import("./pump/spam-buy-cli.ts");
     await runPumpSpamBuyFromArgs(rest);
     return;
   }
   if (command === "buy" && flags.has("spam")) {
-    const { runPumpSpamBuyFromArgs } =
-      await import("@solard/core/launches/pump/spam-buy-cli.ts");
+    const { runPumpSpamBuyFromArgs } = await import("./pump/spam-buy-cli.ts");
     await runPumpSpamBuyFromArgs(rest);
     return;
   }
-  // const { maybeRunWorkerCliCommand } =
-  //   await import("./worker-commands.js");
-  // if (await maybeRunWorkerCliCommand({ values: [command, ...values], flags }))
-  //   return;
   if (command === "scripts") {
     emit(json(await listScripts()) + "\n");
     return;
@@ -273,7 +274,7 @@ async function main() {
     (values[0] === "pump" || values[0] === "pump-token")
   ) {
     const { runPumpTokenLaunchFromArgs } =
-      await import("@solard/core/launches/pump/token-launch-cli.ts");
+      await import("./pump/token-launch-cli.ts");
     await runPumpTokenLaunchFromArgs(rest.slice(1), {
       defaultSubmitMode: "after-deploy-processed",
       defaultDeploymentPriorityMicroLamports: 500_000,
@@ -290,29 +291,13 @@ async function main() {
       process.env.JITO_BLOCK_ENGINE_URL ??
       "https://mainnet.block-engine.jito.wtf"
     ).replace(/\/$/, "");
-    const response = await fetch(`${endpoint}/api/v1/bundles`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        id: Date.now(),
-        method: "getTipAccounts",
-        params: [],
-      }),
-    });
-    const payload = (await response.json()) as {
-      result?: string[];
-      error?: unknown;
-    };
-    if (!response.ok || payload.error || !Array.isArray(payload.result))
-      throw new Error(
-        `Jito getTipAccounts failed: ${JSON.stringify(payload.error ?? response.status)}`,
-      );
-    emit(json({ endpoint, tipAccounts: payload.result }) + "\n");
+    const { getJitoTipAccounts } = await import("@solard/sdk");
+    const tipAccounts = await getJitoTipAccounts(endpoint);
+    emit(json({ endpoint, tipAccounts }) + "\n");
     return;
   }
   if (command === "metadata" && values[0] === "upload") {
-    const { uploadPumpMetadata } = await import("@solard/core/metadata/pump-metadata.ts");
+    const { uploadPumpMetadata } = await import("@solard/sdk");
     const uploaded = await uploadPumpMetadata(
       {
         imagePath: need(flags, "image"),
@@ -338,12 +323,17 @@ async function main() {
   }
   const [{ sol, formatRaw }, { shortKey }, { createTraderSolard }] =
     await Promise.all([
-      import("@solard/core/core/amounts.ts"),
-      import("@solard/core/core/log.ts"),
-      import("@solard/core/presets/trader.ts"),
+      import("@solard/sdk"),
+      import("@solard/sdk"),
+      import("@solard/sdk"),
     ]);
   const slrd = createTraderSolard();
   try {
+    if (command === "wallet" && values[0] === "create") {
+      const wallet = slrd.createWallet(values[1]);
+      emit(`${OWL} created @${wallet.name} ${wallet.address}\n`);
+      return;
+    }
     if (command === "export") {
       const ref = values[0];
       if (!ref)
@@ -382,10 +372,12 @@ async function main() {
         : values[0];
       if (!input)
         throw new Error(
-          "Usage: slrd import <private_key> [name] or cat key.json | slrd import --stdin [name]",
+          "Usage: slrd import <private_key> [name] [--force] or cat key.json | slrd import --stdin [name] [--force]",
         );
       const name = flags.has("stdin") ? values[0] : values[1];
-      const wallet = slrd.importWallet(input, name);
+      const wallet = slrd.importWallet(input, name, {
+        overwrite: flags.has("force") || flags.has("overwrite"),
+      });
       emit(`${OWL} imported @${wallet.name} ${wallet.address}\n`);
       return;
     }
@@ -431,8 +423,7 @@ async function main() {
           throw new Error(
             "Provide --uri <metadata_uri> or --image <local_path> --description <text>",
           );
-        const { uploadPumpMetadata } =
-          await import("@solard/core/metadata/pump-metadata.ts");
+        const { uploadPumpMetadata } = await import("@solard/sdk");
         uploadedMetadata = await uploadPumpMetadata(
           {
             imagePath: need(flags, "image"),
@@ -928,4 +919,4 @@ main().catch((error) => {
   process.exitCode = 1;
 });
 
-export { formatCliError } from "@solard/core";
+export { formatCliError } from "./pump/token-launch-cli.ts";

package/src/pump/spam-buy-cli.ts

@@ -0,0 +1,314 @@
+import { PublicKey } from "@solana/web3.js";
+
+import {
+  createTraderSolard,
+  installPumpLaunchSenders,
+  loadExplicitBuyerAllocations,
+  runPumpSpamBuyers,
+  sol,
+  validateHeliusTip,
+  type ExplicitBuyerAmount,
+  type ExplicitBuyerPlanRow,
+  type LaunchReporter,
+  type PumpSpamBuyRunResult,
+  type PumpSpamBuySettings,
+  type SenderId,
+} from "@solard/sdk";
+import {
+  bigintFlag,
+  enabled,
+  first,
+  json,
+  numberFlag,
+  parseArgs,
+  pumpLaunchEnvironmentFromFlags,
+  required,
+} from "./token-launch-cli.ts";
+
+export type PumpSpamBuyCliOptions = {
+  report?: LaunchReporter;
+};
+
+function defaultReport(label: string, value: unknown): void {
+  console.log(`${label}: ${json(value)}`);
+}
+
+function selectedMint(
+  flags: ReturnType<typeof parseArgs>["flags"],
+  positionals: string[],
+): string {
+  const values = positionals[0] === "pump" ? positionals.slice(1) : positionals;
+  const positionalMint = values[0];
+  const flagMint = first(flags, "mint");
+  const mint = flagMint && flagMint !== "true" ? flagMint : positionalMint;
+  if (!mint) {
+    throw new Error(
+      "Usage: bun run scripts/spam-pump-buyers.ts --mint <mint> (--wallet <wallet> | --group <group>) --amount-mode <range-bps|exact-sol|exact-lamports> [amount flags] [--live]",
+    );
+  }
+  if (flagMint && positionalMint && flagMint !== positionalMint) {
+    throw new Error(
+      `Conflicting mint values: --mint ${flagMint} and positional ${positionalMint}`,
+    );
+  }
+  return new PublicKey(mint).toBase58();
+}
+
+function amountFromFlags(
+  flags: ReturnType<typeof parseArgs>["flags"],
+): ExplicitBuyerAmount {
+  const requestedMode = first(flags, "amount-mode")?.trim().toLowerCase();
+  const exactSol = first(flags, "sol") ?? first(flags, "exact-sol");
+  const exactLamports =
+    first(flags, "lamports") ?? first(flags, "exact-lamports");
+  const hasRangeFlags =
+    flags.has("min-bps") ||
+    flags.has("max-bps") ||
+    flags.has("buyer-min-bps") ||
+    flags.has("buyer-max-bps");
+
+  const inferredMode =
+    exactSol != null
+      ? "exact-sol"
+      : exactLamports != null
+        ? "exact-lamports"
+        : hasRangeFlags
+          ? "range-bps"
+          : null;
+  const modeAliases: Record<
+    string,
+    "range-bps" | "exact-sol" | "exact-lamports"
+  > = {
+    "range-bps": "range-bps",
+    range: "range-bps",
+    "balance-bps": "range-bps",
+    "exact-sol": "exact-sol",
+    sol: "exact-sol",
+    "exact-lamports": "exact-lamports",
+    lamports: "exact-lamports",
+  };
+  if (requestedMode && !modeAliases[requestedMode]) {
+    throw new Error(
+      `Invalid --amount-mode ${requestedMode}. Use range-bps, exact-sol, or exact-lamports.`,
+    );
+  }
+  const mode = requestedMode ? modeAliases[requestedMode] : inferredMode;
+
+  if (!mode) {
+    throw new Error(
+      "Missing amount configuration. Use --amount-mode range-bps with --min-bps/--max-bps, --amount-mode exact-sol with --sol, or --amount-mode exact-lamports with --lamports.",
+    );
+  }
+  if (inferredMode && mode !== inferredMode) {
+    throw new Error(
+      `--amount-mode ${requestedMode} conflicts with the supplied amount flags.`,
+    );
+  }
+
+  if (mode === "exact-sol") {
+    if (exactSol == null || exactSol === "true") {
+      throw new Error("--amount-mode exact-sol requires --sol <amount>.");
+    }
+    return { kind: "exact-sol", sol: exactSol };
+  }
+
+  if (mode === "exact-lamports") {
+    if (exactLamports == null || exactLamports === "true") {
+      throw new Error(
+        "--amount-mode exact-lamports requires --lamports <amount>.",
+      );
+    }
+    return {
+      kind: "exact-lamports",
+      lamports: BigInt(exactLamports),
+    };
+  }
+
+  const minKey = flags.has("min-bps") ? "min-bps" : "buyer-min-bps";
+  const maxKey = flags.has("max-bps") ? "max-bps" : "buyer-max-bps";
+  if (!flags.has(minKey) || !flags.has(maxKey)) {
+    throw new Error(
+      "--amount-mode range-bps requires both --min-bps <n> and --max-bps <n>.",
+    );
+  }
+
+  const reserveLamports = flags.has("reserve-lamports")
+    ? bigintFlag(flags, "reserve-lamports", 0n)
+    : flags.has("buyer-reserve-lamports")
+      ? bigintFlag(flags, "buyer-reserve-lamports", 0n)
+      : sol(
+          first(flags, "reserve-sol") ??
+            first(flags, "buyer-reserve-sol") ??
+            "0.01",
+        ).raw;
+
+  return {
+    kind: "balance-bps",
+    minBps: numberFlag(flags, minKey, 0),
+    maxBps: numberFlag(flags, maxKey, 0),
+    reserveLamports,
+  };
+}
+
+function buyerRows(args: {
+  flags: ReturnType<typeof parseArgs>["flags"];
+  amount: ExplicitBuyerAmount;
+}): ExplicitBuyerPlanRow[] {
+  const wallet = first(args.flags, "wallet");
+  const group = first(args.flags, "group");
+  if (Boolean(wallet) === Boolean(group)) {
+    throw new Error(
+      "Supply exactly one of --wallet <wallet> or --group <group>.",
+    );
+  }
+
+  if (wallet) return [{ wallet, amount: args.amount }];
+
+  // Group expansion is intentionally deferred until Solard is available below.
+  return [{ wallet: `group:${group}`, amount: args.amount }];
+}
+
+function settingsFromFlags(args: {
+  flags: ReturnType<typeof parseArgs>["flags"];
+  sender: SenderId;
+  tipAccount?: string;
+  tipLamports?: bigint;
+  defaults: ReturnType<typeof pumpLaunchEnvironmentFromFlags>;
+}): PumpSpamBuySettings {
+  return {
+    sender: args.sender,
+    tip:
+      String(args.sender) === "helius-fast" &&
+      args.tipAccount &&
+      args.tipLamports != null
+        ? { account: args.tipAccount, lamports: args.tipLamports }
+        : {},
+    cuLimit: numberFlag(args.flags, "cu-limit", args.defaults.cuLimit),
+    priorityMicroLamports: numberFlag(
+      args.flags,
+      "priority-micro-lamports",
+      args.defaults.priorityMicroLamports,
+    ),
+    slippageBps: numberFlag(args.flags, "slippage-bps", 1_500),
+    discoveryIntervalMs: numberFlag(args.flags, "discovery-interval-ms", 25),
+    retryIntervalMs: numberFlag(
+      args.flags,
+      "retry-interval-ms",
+      args.defaults.spam.intervalMs,
+    ),
+    recompileIntervalMs: numberFlag(
+      args.flags,
+      args.flags.has("recompile-interval-ms")
+        ? "recompile-interval-ms"
+        : "retry-recompile-interval-ms",
+      args.defaults.spam.recompileIntervalMs ?? 750,
+    ),
+    freshQuoteIntervalMs: numberFlag(
+      args.flags,
+      "fresh-quote-delay-ms",
+      args.defaults.spam.freshQuoteDelayMs ?? 2_500,
+    ),
+    timeoutMs: numberFlag(
+      args.flags,
+      args.flags.has("timeout-ms") ? "timeout-ms" : "retry-timeout-ms",
+      0,
+    ),
+    maxFailedAttempts: numberFlag(
+      args.flags,
+      "max-failed-attempts",
+      args.defaults.spam.maxFailedAttempts,
+    ),
+  };
+}
+
+export async function runPumpSpamBuyFromArgs(
+  argv: string[],
+  options: PumpSpamBuyCliOptions = {},
+): Promise<PumpSpamBuyRunResult> {
+  const { flags, positionals } = parseArgs(argv);
+  const report = options.report ?? defaultReport;
+  const mint = selectedMint(flags, positionals);
+  const amount = amountFromFlags(flags);
+  const requestedRows = buyerRows({ flags, amount });
+  const env = pumpLaunchEnvironmentFromFlags(flags);
+  const sender = (first(flags, "sender") ??
+    first(flags, "buyer-sender") ??
+    String(env.policy.rpcTraderSender)) as SenderId;
+  const live = enabled(flags, "live", "LIVE");
+
+  const tipAccount =
+    first(flags, "tip-account") ??
+    first(flags, "helius-tip-account") ??
+    env.policy.fastTip.account;
+  const tipLamports = flags.has("tip-lamports")
+    ? bigintFlag(flags, "tip-lamports", 0n)
+    : flags.has("tip-sol")
+      ? sol(required(flags, "tip-sol")).raw
+      : env.policy.fastTip.lamports;
+
+  if (String(sender) === "helius-fast") {
+    if (!env.senderUrl) {
+      throw new Error(
+        "--sender helius-fast requires HELIUS_SENDER_URL or --helius-sender-url.",
+      );
+    }
+    validateHeliusTip({
+      tip: { account: tipAccount, lamports: tipLamports },
+      endpoint: env.senderUrl,
+      live,
+      label: "Pump spam buyer",
+    });
+  }
+
+  const slrd = createTraderSolard({ rpcUrl: env.rpcUrl });
+  installPumpLaunchSenders(slrd, env);
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+
+  try {
+    const rows = requestedRows[0]!.wallet.toString().startsWith("group:")
+      ? slrd
+          .groupWallets(requestedRows[0]!.wallet.toString().slice(6))
+          .map((wallet): ExplicitBuyerPlanRow => ({ wallet, amount }))
+      : requestedRows;
+    const buyers = await loadExplicitBuyerAllocations({ slrd, rows });
+    const settings = settingsFromFlags({
+      flags,
+      sender,
+      tipAccount,
+      tipLamports,
+      defaults: env,
+    });
+
+    report("pump spam-buy plan", {
+      mint,
+      live,
+      buyers: buyers.map((buyer) => ({
+        wallet: buyer.address,
+        balanceLamports: buyer.balanceLamports,
+        reserveLamports: buyer.reserveLamports,
+        selectedBps: buyer.selectedBps,
+        spendLamports: buyer.spendLamports,
+      })),
+      settings,
+    });
+
+    const result = await runPumpSpamBuyers({
+      slrd,
+      mint,
+      buyers,
+      settings,
+      live,
+      signal: controller.signal,
+      reporter: report,
+    });
+    report("pump spam-buy result", result);
+    return result;
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+    slrd.close();
+  }
+}