@solard/cli 0.2.15 → 0.2.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solard/cli",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "Command-line interface for the Solard SDK.",
   "type": "module",
   "main": "./src/index.ts",
@@ -18,7 +18,7 @@
     "bun": ">=1.1.0"
   },
   "dependencies": {
-    "@solard/sdk": "0.2.15",
+    "@solard/sdk": "0.2.16",
     "bs58": "^6.0.0",
     "@solana/web3.js": "^1.98.4"
   },

package/src/fairfun-commands.ts

@@ -216,18 +216,41 @@ export async function handleFairfunCommand(args: {
     const ref = values[0];
     if (!ref)
       throw new Error(
-        "Usage: slrd events <token|ca> [--swaps-only|--transfers-only] [--jsonl]",
+        "Usage: slrd events <token|ca> [--all|--swaps|--transfers|--creates|--swaps-only|--transfers-only] [--jsonl]",
       );
     const token = await ensureToken(slrd, ref);
     const controller = new AbortController();
     const stop = () => controller.abort();
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
-    const swaps = !bool(flags, "transfers-only");
-    const transfers = !bool(flags, "swaps-only");
+
+    const explicit =
+      bool(flags, "all") ||
+      bool(flags, "swaps") ||
+      bool(flags, "transfers") ||
+      bool(flags, "creates");
+    let swaps = true;
+    let transfers = true;
+    let creates = false;
+    if (bool(flags, "swaps-only")) {
+      swaps = true;
+      transfers = false;
+      creates = false;
+    } else if (bool(flags, "transfers-only")) {
+      swaps = false;
+      transfers = true;
+      creates = false;
+    } else if (explicit) {
+      const all = bool(flags, "all");
+      swaps = all || bool(flags, "swaps");
+      transfers = all || bool(flags, "transfers");
+      creates = all || bool(flags, "creates");
+    }
+
     const subscription = await slrd.subscribeTokenEvents(token.mint, {
       swaps,
       transfers,
+      creates,
       commitment: bool(flags, "finalized") ? "finalized" : "confirmed",
       signal: controller.signal,
     });
@@ -251,7 +274,12 @@ export async function handleFairfunCommand(args: {
         if (event.type === "swap") {
           emit(
             `${new Date(event.blockTimeMs ?? event.observedAtMs).toISOString()}  SWAP ${event.venue} ${event.side.toUpperCase()} ` +
-              `${event.tokenAmountRaw} tokenRaw trader=${event.trader ?? "?"} sig=${event.signature}\n`,
+              `${event.tokenAmountRaw} tokenRaw quote=${event.quoteAmountRaw ?? "?"} ${event.quoteMint} trader=${event.trader ?? "?"} sig=${event.signature}\n`,
+          );
+        } else if (event.type === "create") {
+          emit(
+            `${new Date(event.blockTimeMs ?? event.observedAtMs).toISOString()}  CREATE ` +
+              `${event.symbol ?? "?"} ${event.name ?? "?"} creator=${event.creator ?? "?"} quote=${event.quoteMint} sig=${event.signature}\n`,
           );
         } else {
           emit(

package/src/index.ts

@@ -322,7 +322,7 @@ async function storedWalletCount(): Promise<number> {
   const { createTraderSolard } = await import("@solard/sdk");
   const probe = createTraderSolard();
   try {
-    return probe.wallets.list().length;
+    return (probe.db.wallets.select().all() as unknown[]).length;
   } finally {
     probe.close();
   }
@@ -333,7 +333,7 @@ function help(): string {
 
 Wallets and tokens
   slrd setup [--status]                      Check ephemeral wallet-password mode; no password is persisted
-  slrd wallet create [name]                  Generate and persist an encrypted Solana wallet
+  slrd wallet create [name] [--vanity <suffix>]        Generate and persist an encrypted Solana wallet
   slrd import <private_key> [name]
   cat key.json | slrd import --stdin [name]
 
@@ -356,7 +356,7 @@ External contacts (public addresses only; never signing wallets or group members
   slrd token analyze <ca> [--top N] [--json]
   slrd tokens
   slrd holders <token|ca> [--exclude <a,b>] [--min-raw N] [--json]         Complete on-chain holder snapshot
-  slrd events <token|ca> [--swaps-only|--transfers-only] [--jsonl]          Live typed Pump/PumpSwap + transfer stream
+  slrd events <token|ca> [--all|--swaps|--transfers|--creates] [--jsonl]     Live typed Pump/PumpSwap + transfer/create stream
 
 Vanity mints
   slrd vanity --suffix pump --out .\\mint.json [--count <n>]
@@ -365,6 +365,9 @@ Vanity mints
   slrd vanity pool release <mint-address>               Release an ambiguous/failed launch reservation
   launch/vamp: add --mint-pool pump [--mint-pool-address <address>] to consume a pooled mint
 
+Pump pairs
+  slrd pump pairs [--json]                              Read Pump-supported quote mints from the on-chain Global account
+
 Metadata and launching
   slrd launch pump --creator <wallet> (--uri <metadata_uri> | --metadata <json> | --image <path> --description <text>) [--pair SOL|USDC|<custom-quote-mint>] [--beneficiary <wallet|address>] [--alias <name>] [--live] [--skip-simulation]
                     [--deployment-sender helius-rpc|helius-fast] [--helius-tip-sol 0.01]
@@ -559,7 +562,7 @@ async function main() {
     return;
   }
 
-  if (needsVault && !process.env.SLRD_MASTER_KEY?.trim()) {
+  if (needsVault) {
     const allowCreate =
       (command === "wallet" && values[0] === "create") ||
       command === "import" ||
@@ -860,6 +863,20 @@ async function main() {
       return;
     }
 
+    if (command === "pump" && values[0] === "pairs") {
+      const pairs = await slrd.pump.getSupportedPairs();
+      if (flags.has("json")) {
+        emit(json(pairs) + "\n");
+      } else {
+        for (const pair of pairs) {
+          emit(
+            `${(pair.symbol ?? "?").padEnd(12)} ${(pair.name ?? "?").padEnd(28)} ${pair.mint}  decimals=${pair.decimals}\n`,
+          );
+        }
+      }
+      return;
+    }
+
     if (command === "swap") {
       const { runJupiterSwapCommand } =
         await import("./commands/jupiter-swap.ts");
@@ -929,16 +946,46 @@ async function main() {
 
     if (command === "wallet" && values[0] === "create") {
       const firstWallet = slrd.wallets.list().length === 0;
-      const wallet = slrd.createWallet(
-        values[1] ?? (firstWallet ? "main" : undefined),
-      );
+      const name = values[1] ?? (firstWallet ? "main" : undefined);
+      const vanity = flags.has("vanity") ? need(flags, "vanity") : null;
+      const vanityResult = vanity
+        ? await slrd.createVanityWallet(name, {
+            suffix: vanity,
+            workers: int(flags, "workers"),
+            maxAttempts: int(flags, "max-attempts"),
+            timeoutMs: int(flags, "timeout-ms", 0),
+            reportEvery: int(flags, "report-every", 1_000_000),
+            onProgress: process.stderr.isTTY
+              ? (progress) =>
+                  process.stderr.write(
+                    `${OWL} wallet vanity ${progress.suffix}: ${progress.attempts} attempts, ${progress.ratePerSecond}/s\r`,
+                  )
+              : undefined,
+          })
+        : null;
+      if (vanityResult && process.stderr.isTTY) process.stderr.write("\n");
+      const wallet = vanityResult?.wallet ?? slrd.createWallet(name);
+      const output = vanityResult
+        ? {
+            ...wallet,
+            vanity: {
+              suffix: vanityResult.suffix,
+              attempts: vanityResult.attempts,
+              elapsedMs: vanityResult.elapsedMs,
+              ratePerSecond: vanityResult.ratePerSecond,
+            },
+          }
+        : wallet;
       if (flags.has("json")) {
-        emit(json(wallet) + "\n");
+        emit(json(output) + "\n");
       } else if (process.stdout.isTTY) {
         emit(
           `\n╭─ ${OWL} wallet ready ──────────────────────────────────╮\n` +
             `  name     @${wallet.name}\n` +
             `  address  ${wallet.address}\n` +
+            (vanityResult
+              ? `  vanity   suffix=${vanityResult.suffix} attempts=${vanityResult.attempts}\n`
+              : "") +
             `  storage  encrypted in Solard's local wallet database\n` +
             `  password NOT saved; you will enter it again next invocation\n` +
             `╰──────────────────────────────────────────────────────╯\n` +

package/src/vault-onboarding.ts

@@ -118,37 +118,20 @@ async function validateAllStoredWallets(password: string): Promise<void> {
   const { createTraderSolard } = await import("@solard/sdk");
   const probe = createTraderSolard();
   try {
-    const wallets = probe.db.wallets
-      .select()
-      .orderBy("id", "asc")
-      .all() as Array<{
-      name: string;
-      address: string;
-    }>;
-    if (!wallets.length) return;
-    const failures: Array<{ name: string; address: string }> = [];
-    let decrypted = 0;
-    for (const wallet of wallets) {
-      try {
-        probe.wallets.signer(wallet.address);
-        decrypted += 1;
-      } catch {
-        failures.push({ name: wallet.name, address: wallet.address });
-      }
-    }
-    if (!failures.length) return;
+    const integrity = probe.wallets.integrity();
+    if (!integrity.failures.length) return;
     clearMasterKey();
-    if (decrypted === 0) {
+    if (integrity.decrypted === 0) {
       throw new VaultOnboardingError(
         "That wallet password could not decrypt the stored wallet database.",
       );
     }
-    const affected = failures
+    const affected = integrity.failures
       .map((wallet) => `@${wallet.name} ${wallet.address}`)
       .join(", ");
     throw new VaultIntegrityError(
       `Wallet database integrity check failed: one master password must decrypt every stored signing wallet. ` +
-        `Decrypted ${decrypted}/${wallets.length}; undecryptable: ${affected}`,
+        `Decrypted ${integrity.decrypted}/${integrity.total}; undecryptable or mismatched: ${affected}`,
     );
   } finally {
     probe.close();