@solard/cli 0.2.19 → 0.2.20

package/src/index.ts

@@ -279,6 +279,8 @@ function commandNeedsSigningVault(
     if (values[0] === "resume") return true;
     return flags.has("live");
   }
+  if (command === "reclaim") return flags.has("live") || flags.has("simulate");
+  if (command === "unwrap" && values[0] === "wsol") return true;
   if (
     [
       "import",
@@ -317,6 +319,7 @@ function commandNeedsSigningVault(
       "spam-buy",
       "buy-spam",
       "run",
+      "strategy",
     ].includes(command)
   )
     return true;
@@ -363,7 +366,9 @@ External contacts (public addresses only; never signing wallets or group members
   slrd token <token_ca> [name] [--metadata-json <json>]
   slrd token set <token|ca> [--pool <address>] [--quote-mint <mint>] [--quote-program <program>] [--metadata-json <json>]
   slrd token refresh <token|ca>
-  slrd token backfill <ca> [--replace] [--confirmed] [--batch-size 100] [--rpc-concurrency 3] [--max-signatures N] [--json]
+  slrd token backfill <ca> [--max-signatures N] [--json]  Index signatures only; no transaction hydration by default
+  slrd token backfill <ca> --materialize [--price-sample-ms 1000] [--replace] [--rpc-concurrency 2]
+  slrd token backfill <ca> --exact [--replace] [--rpc-concurrency 2]
                                                         Durable exact trades + sparse 1s candle materialization from creation
   slrd token trades <ca> [--from-start] [--min-sol N] [--owner <wallet>] [--side buy|sell] [--limit N] [--json]
   slrd token analyze <ca> [--top N] [--json]
@@ -380,8 +385,18 @@ 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
+Shared market feed
+  slrd feed serve [--host 127.0.0.1] [--port 8788] [--rpc-rps 5] [--rpc-read-rps 2] [--max-fallback-subs 200]
+                                                        One upstream Pump/PumpSwap/LaunchLab feed shared by watchers, agents, and future UI clients
+
+Launch discovery
+  slrd launch watch [--venue pump,raydium-launchlab] [--min-mcap 5000] [--ath-step-pct 20] [--track-ttl 30m] [--feed ws://127.0.0.1:8788/ws] [--show-new] [--prices] [--json]
+                                                        Consume the shared feed; ignore Pump Mayhem and notify on first $5k cross and each +20% notified ATH step
+
+Pump discovery
   slrd pump pairs [--json]                              Read Pump-supported quote mints from the on-chain Global account
+  slrd pump watch [--min-mcap 5000] [--ath-step-pct 20] [--track-ttl 30m] [--feed ws://127.0.0.1:8788/ws] [--show-new] [--prices] [--json]
+                                                        Compatibility alias for: slrd launch watch --venue pump
 
 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]
@@ -414,7 +429,7 @@ Transfers and consolidation
   slrd sweep sol ...                                    Compatibility alias; --max-balance-sol remains accepted
 
 Token liquidation
-  slrd liquidate tokens [--except <token|mint>] [--wallets <a,b,...>] [--except-wallet <wallet>] [--except-wallets <a,b,...>] [--slippage-bps 1500] [--no-jupiter] [--burn-unsellable] [--simulate | --live]
+  slrd liquidate tokens [--except <token|mint>] [--wallets <a,b,...>] [--except-wallet <wallet>] [--except-wallets <a,b,...>] [--slippage-bps 1500] [--no-jupiter] [--burn-unsellable] [--rounds 3] [--simulate | --live]
                                                         Sell all supported tokens unless protected with --except; excluded wallets are not scanned or touched
 
 RPC
@@ -435,7 +450,12 @@ Trading
   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]
   slrd sell <token|ca> (--wallet <wallet> | --wallets <w1,w2> | --group <name>) [--bps 10000] [--venue auto|native|jupiter] [--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] [--continue-on-error] [--simulate-only]
+  slrd unwrap-wsol (--all-wallets | --wallet <wallet> | --wallets <w1,w2> | --group <name>) [--sender rpc|helius|jito] [--ignore-missing] [--simulate-only]
+                                                        Close every owned WSOL token account, including non-ATA WSOL accounts
+  slrd reclaim inspect --all-wallets                    List Loader-v3 buffers/programs controlled by stored wallets
+  slrd reclaim buffers --all-wallets [--simulate | --live]
+  slrd reclaim programs --all-wallets [--simulate | --live --confirm-program-close]
+  slrd reclaim all --all-wallets [--simulate | --live --confirm-program-close]
   slrd claim <token|ca> --wallet <wallet> [--sender rpc|helius|jito]
   slrd transfer-many --wallet <wallet> (--token <mint>|--sol) --file <allocations.json> [--id <stable-id> --live]
   slrd transfer-many status <stable-id>
@@ -450,10 +470,14 @@ Trading
   slrd rewards claim <token|ca> --wallet <fee-payer> [--id <stable-claim-id> --basis <reward-basis.json>]
   slrd rewards claim-status <stable-claim-id>
 
-Scripts (strategies stay outside the kernel)
+Scripts and event strategies
   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 strategy run <file.ts> --token <mint|alias> --wallet <wallet> [--params <json>] [--feed ws://127.0.0.1:8788/ws] [--live]
+                                                        Run an onPrice strategy from the shared feed; wallet/execution state remains isolated per agent
+  slrd strategy backtest <file.ts> --token <mint> [--params <json>] [--capital-sol 1] [--price-sample 5s] [--sol-usd N] [--json]
+                                                        Replay the same strategy file over durable token history
 
 Meteora DLMM
   slrd meteora discover --timeframe 30m --sort fee-active-tvl --limit 20
@@ -490,6 +514,9 @@ Watching
   slrd watch list
 
 Transactions and ALTs
+  slrd tx stream --wallet <wallet|address> [--finalized] [--jsonl]
+  slrd tx stream --wallets <a,b,c> [--finalized] [--jsonl]
+                                                        Stream every transaction mentioning the selected wallets until Ctrl+C
   slrd history
   slrd jito tip-accounts [--endpoint <block-engine-url>]
   slrd alt add <address> [label]
@@ -791,6 +818,24 @@ async function main() {
     process.exitCode = await runScript(script, scriptArgs);
     return;
   }
+  if (command === "feed" && values[0] === "serve") {
+    const { runPriceFeedServerCommand } =
+      await import("./price-feed-server.ts");
+    await runPriceFeedServerCommand({ flags, emit });
+    return;
+  }
+  if (command === "strategy" && values[0] === "backtest") {
+    const { runStrategyBacktestCommand } =
+      await import("./strategy-backtest-command.ts");
+    await runStrategyBacktestCommand({ values, flags, emit });
+    return;
+  }
+  if (command === "strategy" && values[0] === "run") {
+    const { runTradeStrategyCommand } =
+      await import("./trade-strategy-command.ts");
+    await runTradeStrategyCommand({ values, flags, emit });
+    return;
+  }
   if (
     (command === "prepare" && values[0] === "pump") ||
     (command === "launch" &&
@@ -803,6 +848,11 @@ async function main() {
     await runPumpExternalDeploymentFromArgs(externalArgs);
     return;
   }
+  if (command === "launch" && values[0] === "watch") {
+    const { runLaunchWatchCommand } = await import("./launch-watch-command.ts");
+    await runLaunchWatchCommand({ flags, emit });
+    return;
+  }
   if (
     command === "launch" &&
     (values[0] === "pump" || values[0] === "pump-token")
@@ -831,6 +881,11 @@ async function main() {
     });
     return;
   }
+  if (command === "pump" && values[0] === "watch") {
+    const { runPumpWatchCommand } = await import("./pump-watch-command.ts");
+    await runPumpWatchCommand({ flags, emit });
+    return;
+  }
   if (command === "jito" && values[0] === "tip-accounts") {
     const endpoint = (
       flags.get("endpoint") ??
@@ -879,6 +934,12 @@ async function main() {
       return;
     }
 
+    if (command === "reclaim") {
+      const { runReclaimCommand } = await import("./reclaim-command.ts");
+      await runReclaimCommand({ slrd, values, flags, emit });
+      return;
+    }
+
     if (command === "meteora") {
       await handleMeteoraCommand({ slrd, values, flags, emit });
       return;
@@ -1312,7 +1373,7 @@ async function main() {
         try {
           const tx = await connection.getTransaction(entry.signature, {
             commitment: "confirmed",
-            maxSupportedTransactionVersion: 0,
+            maxSupportedTransactionVersion: 1,
           });
           const fee = tx?.meta?.fee;
           const payer = txAccountKeys(tx)[0] ?? "";
@@ -1376,6 +1437,328 @@ async function main() {
         );
       return;
     }
+    if (command === "tx" && values[0] === "stream") {
+      const walletFlag = flags.get("wallet");
+      const walletRefs = [
+        ...(walletFlag && walletFlag !== "true" ? [walletFlag] : []),
+        ...csv(flags.get("wallets")),
+      ];
+      if (walletRefs.length === 0) {
+        throw new Error(
+          "Usage: slrd tx stream --wallet <wallet|address> | --wallets <a,b,c> [--finalized] [--jsonl]",
+        );
+      }
+
+      const { PublicKey } = await import("@solana/web3.js");
+      const connection = slrd.connection();
+      const commitment = flags.has("finalized") ? "finalized" : "confirmed";
+      const enrichAttempts = Math.max(
+        1,
+        Math.min(20, Math.trunc(int(flags, "enrich-attempts", 8) ?? 8)),
+      );
+      const enrichDelayMs = Math.max(
+        50,
+        Math.trunc(int(flags, "enrich-delay-ms", 250) ?? 250),
+      );
+
+      type StreamWallet = {
+        ref: string;
+        name: string | null;
+        address: string;
+        publicKey: InstanceType<typeof PublicKey>;
+      };
+
+      const byAddress = new Map<string, StreamWallet>();
+      for (const ref of walletRefs) {
+        let name: string | null = null;
+        let publicKey: InstanceType<typeof PublicKey>;
+        try {
+          const resolved = slrd.resolveWallet(ref);
+          publicKey = resolved.address;
+          name = resolved.row?.name ?? null;
+        } catch {
+          try {
+            publicKey = new PublicKey(ref);
+          } catch {
+            throw new Error(`Unknown wallet or invalid Solana address: ${ref}`);
+          }
+        }
+        const address = publicKey.toBase58();
+        if (!byAddress.has(address)) {
+          byAddress.set(address, { ref, name, address, publicKey });
+        }
+      }
+      const watched = [...byAddress.values()];
+      const watchedAddresses = new Set(watched.map((row) => row.address));
+      const labelFor = (row: StreamWallet) =>
+        row.name ? `@${row.name}` : shortKey(row.address);
+
+      type PendingSignature = {
+        signature: string;
+        observedSlot: number | null;
+      };
+
+      const queue: PendingSignature[] = [];
+      const queued = new Set<string>();
+      const seen = new Set<string>();
+      const seenOrder: string[] = [];
+      const listenerIds: number[] = [];
+      let processing = false;
+      let stopped = false;
+      let stopResolve: (() => void) | null = null;
+
+      const rememberSeen = (signature: string) => {
+        if (seen.has(signature)) return;
+        seen.add(signature);
+        seenOrder.push(signature);
+        while (seenOrder.length > 20_000) {
+          const oldest = seenOrder.shift();
+          if (oldest) seen.delete(oldest);
+        }
+      };
+
+      const transactionWithRetry = async (signature: string) => {
+        for (let attempt = 1; attempt <= enrichAttempts; attempt += 1) {
+          const tx = await connection.getTransaction(signature, {
+            commitment,
+            maxSupportedTransactionVersion: 1,
+          });
+          if (tx) return tx;
+          if (attempt < enrichAttempts) {
+            await new Promise((resolve) => setTimeout(resolve, enrichDelayMs));
+          }
+        }
+        return null;
+      };
+
+      const printTransaction = async (
+        item: PendingSignature,
+      ): Promise<void> => {
+        const tx = await transactionWithRetry(item.signature);
+        if (!tx?.meta) {
+          const unavailable = {
+            type: "transaction",
+            signature: item.signature,
+            slot: item.observedSlot,
+            commitment,
+            status: "unavailable",
+            wallets: [],
+          };
+          if (flags.has("jsonl")) emit(JSON.stringify(unavailable) + "\n");
+          else
+            emit(
+              `${new Date().toISOString()}  UNAVAILABLE  ${item.signature}  slot=${item.observedSlot ?? "?"}\n`,
+            );
+          return;
+        }
+
+        const keys = txAccountKeys(tx);
+        const keySet = new Set(keys);
+        const touched = watched.filter((row) => keySet.has(row.address));
+        if (touched.length === 0) return;
+
+        const feeLamports =
+          typeof tx.meta.fee === "number" && Number.isFinite(tx.meta.fee)
+            ? BigInt(Math.trunc(tx.meta.fee))
+            : 0n;
+        const payer = keys[0] ?? null;
+        const status = tx.meta.err ? "failed" : "confirmed";
+        const at =
+          tx.blockTime == null
+            ? new Date().toISOString()
+            : new Date(tx.blockTime * 1_000).toISOString();
+
+        const walletRows = touched.map((wallet) => {
+          const walletIndex = keys.indexOf(wallet.address);
+          let nativeDeltaLamports: bigint | null = null;
+          if (
+            walletIndex >= 0 &&
+            typeof tx.meta!.preBalances?.[walletIndex] === "number" &&
+            typeof tx.meta!.postBalances?.[walletIndex] === "number"
+          ) {
+            nativeDeltaLamports =
+              BigInt(Math.trunc(tx.meta!.postBalances[walletIndex]!)) -
+              BigInt(Math.trunc(tx.meta!.preBalances[walletIndex]!));
+          }
+
+          const tokenDeltas = [...txWalletTokenBalances(tx, wallet.address)]
+            .map(([mint, balance]) => ({
+              mint,
+              decimals: balance.decimals,
+              deltaRaw: balance.post - balance.pre,
+            }))
+            .filter((row) => row.deltaRaw !== 0n)
+            .sort((left, right) => {
+              const leftAbs =
+                left.deltaRaw < 0n ? -left.deltaRaw : left.deltaRaw;
+              const rightAbs =
+                right.deltaRaw < 0n ? -right.deltaRaw : right.deltaRaw;
+              return leftAbs === rightAbs
+                ? left.mint.localeCompare(right.mint)
+                : leftAbs > rightAbs
+                  ? -1
+                  : 1;
+            });
+
+          return {
+            ref: wallet.ref,
+            name: wallet.name,
+            address: wallet.address,
+            nativeDeltaLamports,
+            feePaidLamports: payer === wallet.address ? feeLamports : 0n,
+            tokenDeltas,
+          };
+        });
+
+        if (flags.has("jsonl")) {
+          emit(
+            JSON.stringify(
+              {
+                type: "transaction",
+                at,
+                signature: item.signature,
+                slot: tx.slot ?? item.observedSlot,
+                commitment,
+                status,
+                error: tx.meta.err ?? null,
+                feeLamports,
+                feePayer: payer,
+                wallets: walletRows,
+              },
+              (_, value) =>
+                typeof value === "bigint" ? value.toString() : value,
+            ) + "\n",
+          );
+          return;
+        }
+
+        emit(
+          `\n${at}  ${status.toUpperCase()}  slot=${tx.slot ?? item.observedSlot ?? "?"}\n` +
+            `SIG  ${item.signature}\n` +
+            `FEE  ${formatRaw(feeLamports, 9)} SOL  payer=${payer ?? "?"}\n`,
+        );
+
+        for (const row of walletRows) {
+          const wallet = byAddress.get(row.address)!;
+          emit(`  ${labelFor(wallet)}  ${row.address}\n`);
+          emit(
+            `    SOL    ${
+              row.nativeDeltaLamports == null
+                ? "n/a"
+                : `${formatSignedRaw(row.nativeDeltaLamports, 9)} SOL`
+            }${
+              row.feePaidLamports > 0n
+                ? `  (paid fee ${formatRaw(row.feePaidLamports, 9)} SOL)`
+                : ""
+            }\n`,
+          );
+          if (row.tokenDeltas.length === 0) {
+            emit("    TOKEN  no wallet-owned SPL balance delta\n");
+          } else {
+            for (const delta of row.tokenDeltas) {
+              const tokenLabel =
+                delta.mint === NATIVE_SOL_MINT
+                  ? "WSOL"
+                  : delta.mint === CANONICAL_USDC_MINT
+                    ? "USDC"
+                    : shortKey(delta.mint);
+              emit(
+                `    TOKEN  ${formatSignedRaw(delta.deltaRaw, delta.decimals)} ${tokenLabel}  ${delta.mint}\n`,
+              );
+            }
+          }
+        }
+
+        if (tx.meta.err) {
+          emit(`  ERROR  ${JSON.stringify(tx.meta.err)}\n`);
+        }
+      };
+
+      const drain = async (): Promise<void> => {
+        if (processing) return;
+        processing = true;
+        try {
+          while (!stopped && queue.length > 0) {
+            const item = queue.shift()!;
+            queued.delete(item.signature);
+            if (seen.has(item.signature)) continue;
+            try {
+              await printTransaction(item);
+            } catch (error) {
+              const message =
+                error instanceof Error ? error.message : String(error);
+              if (flags.has("jsonl")) {
+                emit(
+                  JSON.stringify({
+                    type: "stream-error",
+                    signature: item.signature,
+                    error: message,
+                  }) + "\n",
+                );
+              } else {
+                process.stderr.write(
+                  `${OWL} tx stream ${item.signature}: ${message}\n`,
+                );
+              }
+            } finally {
+              rememberSeen(item.signature);
+            }
+          }
+        } finally {
+          processing = false;
+          if (!stopped && queue.length > 0) void drain();
+        }
+      };
+
+      const enqueue = (signature: string, observedSlot: number | null) => {
+        if (stopped || seen.has(signature) || queued.has(signature)) return;
+        queued.add(signature);
+        queue.push({ signature, observedSlot });
+        void drain();
+      };
+
+      if (!flags.has("jsonl")) {
+        emit(
+          `TX STREAM  wallets=${watched.length}  commitment=${commitment}  Ctrl+C to stop\n`,
+        );
+        for (const wallet of watched) {
+          emit(`  ${labelFor(wallet)}  ${wallet.address}\n`);
+        }
+        emit("\n");
+      }
+
+      for (const wallet of watched) {
+        const id = connection.onLogs(
+          wallet.publicKey,
+          (logs, context) => {
+            // Stream failed transactions too. The transaction metadata below
+            // is the authoritative status/error source.
+            enqueue(logs.signature, context?.slot ?? null);
+          },
+          commitment,
+        );
+        listenerIds.push(id);
+      }
+
+      await new Promise<void>((resolve) => {
+        stopResolve = resolve;
+        const stop = () => {
+          if (stopped) return;
+          stopped = true;
+          resolve();
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+      });
+
+      await Promise.allSettled(
+        listenerIds.map((id) => connection.removeOnLogsListener(id)),
+      );
+
+      if (!flags.has("jsonl")) emit("TX STREAM STOPPED\n");
+      return;
+    }
+
     if (command === "sol-flow" || (command === "tx" && values[0] === "flow")) {
       const walletRef = need(flags, "wallet");
       const wallet = slrd.resolveWallet(walletRef);
@@ -1427,7 +1810,7 @@ async function main() {
         try {
           const tx = await connection.getTransaction(entry.signature, {
             commitment: "confirmed",
-            maxSupportedTransactionVersion: 0,
+            maxSupportedTransactionVersion: 1,
           });
           if (!tx?.meta) {
             rows.push({
@@ -1903,7 +2286,6 @@ async function main() {
         : flags.has("simulate")
           ? "SIMULATE"
           : "PLAN";
-
       emit(`LIQUIDATE ${mode}\n`);
       for (const ref of except) {
         const mint = resolveTokenMintForPolicy(slrd, ref);
@@ -1969,6 +2351,15 @@ async function main() {
             emit(
               `ROUTE    ${event.index}/${event.total}  ${shortKey(event.mint)}\n`,
             );
+          } else if (event.stage === "consolidation-start") {
+            showAction("MOVE", event.index, event.total, event.action);
+            emit(
+              `         consolidate ${event.accounts} non-ATA account(s), raw=${event.amountRaw.toString()} -> ATA\n`,
+            );
+          } else if (event.stage === "consolidation-done") {
+            emit(
+              `MOVED    ${event.index}/${event.total}  @${event.action.walletName}  ${shortKey(event.action.mint)}  accounts=${event.accounts} signatures=${event.signatures.length}\n`,
+            );
           } else if (event.stage === "action-start") {
             showAction(
               flags.has("simulate") ? "SIM " : "DO  ",
@@ -1992,12 +2383,19 @@ async function main() {
         },
       };
 
-      const plan = await planRegistryTokenLiquidation(slrd, options);
-      emit(
-        `PLAN     native=${plan.totals.sell}  jupiter=${plan.totals.jupiterSell}  ` +
-          `unwrap=${plan.totals.unwrapWsol}  close-empty-now=${plan.totals.closeEmpty}  ` +
-          `keep=${plan.totals.keepProtected}  unsupported=${plan.totals.skipUnsupported}\n`,
-      );
+      const emitPlan = (
+        plan: Awaited<ReturnType<typeof planRegistryTokenLiquidation>>,
+        prefix = "PLAN    ",
+      ) => {
+        emit(
+          `${prefix} native=${plan.totals.sell}  jupiter=${plan.totals.jupiterSell}  ` +
+            `unwrap=${plan.totals.unwrapWsol}  close-empty-now=${plan.totals.closeEmpty}  ` +
+            `keep=${plan.totals.keepProtected}  unsupported=${plan.totals.skipUnsupported}\n`,
+        );
+      };
+
+      let plan = await planRegistryTokenLiquidation(slrd, options);
+      emitPlan(plan);
 
       if (!flags.has("simulate") && !flags.has("live")) {
         const actionable = plan.actions.filter(
@@ -2052,9 +2450,43 @@ async function main() {
         return;
       }
 
-      const results = flags.has("simulate")
-        ? await simulateRegistryTokenLiquidation(slrd, plan, options)
-        : await executeRegistryTokenLiquidation(slrd, plan, options);
+      let results: Awaited<ReturnType<typeof executeRegistryTokenLiquidation>> =
+        [];
+      let finalPlan = plan;
+
+      if (flags.has("simulate")) {
+        results = await simulateRegistryTokenLiquidation(slrd, plan, options);
+      } else {
+        const maxRounds = Math.max(
+          1,
+          Math.min(6, int(flags, "rounds", 3) ?? 3),
+        );
+        for (let round = 1; round <= maxRounds; round += 1) {
+          if (round > 1) {
+            emit(`RESCAN   liquidation round ${round}/${maxRounds}\n`);
+            emitPlan(plan, "PLAN-R  ");
+          }
+          results.push(
+            ...(await executeRegistryTokenLiquidation(slrd, plan, options)),
+          );
+          finalPlan = await planRegistryTokenLiquidation(slrd, options);
+          const retryable = finalPlan.actions.filter(
+            (action) =>
+              action.amountRaw > 0n &&
+              (action.kind === "sell" ||
+                action.kind === "jupiter-sell" ||
+                action.kind === "unwrap-wsol" ||
+                (options.burnUnsellable && action.kind === "skip-unsupported")),
+          );
+          if (!retryable.length) break;
+          if (round < maxRounds) {
+            emit(
+              `RESIDUAL ${retryable.length} positive holding(s) appeared/remain after round ${round}; rescanning and retrying\n`,
+            );
+            plan = finalPlan;
+          }
+        }
+      }
 
       const failed = results.filter((result) => Boolean(result.error)).length;
       const succeeded = results.filter((result) => !result.error);
@@ -2073,12 +2505,39 @@ async function main() {
       const reclaimedRentLamports = succeeded
         .filter((result) => result.action.kind === "close-empty")
         .reduce((sum, result) => sum + (result.action.rentLamports ?? 0n), 0n);
+
+      const residual = flags.has("live")
+        ? finalPlan.actions.filter(
+            (action) =>
+              action.amountRaw > 0n &&
+              action.kind !== "keep-protected" &&
+              action.kind !== "close-empty",
+          )
+        : [];
+
       emit(
         `DONE     ok=${succeeded.length}  failed=${failed}  ` +
           `native-sold=${soldNative}  jupiter-sold=${soldJupiter}  ` +
           `unwrapped=${unwrapped}  closed-empty=${closedEmpty}  ` +
+          `residual=${residual.length}  ` +
           `reclaimed-rent≈${(Number(reclaimedRentLamports) / 1e9).toFixed(6)} SOL\n`,
       );
+
+      if (residual.length) {
+        for (const action of residual.slice(0, 12)) {
+          const label = action.symbol ?? action.name ?? shortKey(action.mint);
+          emit(
+            `REMAIN   @${action.walletName}  ${label}  ${action.amountUi}  ` +
+              `${action.mint}${action.reason ? `  ${action.reason}` : ""}\n`,
+          );
+        }
+        if (residual.length > 12)
+          emit(`REMAIN   ... ${residual.length - 12} more holding(s)\n`);
+        emit(
+          `INCOMPLETE positive unprotected token balances remain after the final fresh scan\n`,
+        );
+        process.exitCode = 1;
+      }
       return;
     }
 
@@ -2163,6 +2622,25 @@ async function main() {
         throw new Error("Use either --simulate or --live, not both");
       }
 
+      const sweepMode = flags.has("live")
+        ? "LIVE"
+        : flags.has("simulate")
+          ? "SIMULATE"
+          : "PLAN";
+
+      if (!flags.has("json") && (flags.has("live") || flags.has("simulate"))) {
+        const initialDestinationLabel = destination.contactName
+          ? `${destination.contactName} (${destination.address})`
+          : destination.walletName
+            ? `${destination.walletName} (${destination.address})`
+            : destination.address;
+        emit(`SWEEP ${sweepMode} -> ${initialDestinationLabel}\n`);
+        if (maxBalanceSol != null) emit(`Threshold: < ${maxBalanceSol} SOL\n`);
+        emit(
+          "PLAN  reading confirmed wallet balances and estimating transfer fee...\n",
+        );
+      }
+
       const options = {
         destination: destination.address,
         excludeGroups,
@@ -2182,6 +2660,18 @@ async function main() {
           Math.trunc(int(flags, "rpc-delay-ms", 75) ?? 75),
         ),
         delayMs: int(flags, "delay-ms", 0) ?? 0,
+        maxAttempts: Math.max(
+          1,
+          Math.trunc(int(flags, "sweep-attempts", 3) ?? 3),
+        ),
+        confirmationTimeoutMs: Math.max(
+          1_000,
+          Math.trunc(int(flags, "confirm-timeout-ms", 15_000) ?? 15_000),
+        ),
+        confirmationPollMs: Math.max(
+          250,
+          Math.trunc(int(flags, "confirm-poll-ms", 750) ?? 750),
+        ),
         onProgress:
           !flags.has("json") && flags.has("live")
             ? (event: any) => {
@@ -2190,9 +2680,17 @@ async function main() {
                     `SEND ${event.index}/${event.total}  @${event.row.walletName}  ` +
                       `${formatRaw(event.row.sendLamports, 9)} SOL\n`,
                   );
+                } else if (event.stage === "wallet-pending") {
+                  emit(
+                    `WAIT ${event.index}/${event.total}  @${event.row.walletName}  ` +
+                      `attempt=${event.attempt}/${event.maxAttempts}  ` +
+                      `${event.reason}\n`,
+                  );
                 } else if (event.stage === "wallet-done") {
                   emit(
-                    `OK   ${event.index}/${event.total}  @${event.row.walletName}\n`,
+                    `OK   ${event.index}/${event.total}  @${event.row.walletName}  ` +
+                      `remaining=${formatRaw(event.remainingLamports, 9)} SOL` +
+                      `${event.receipt?.status ? `  status=${event.receipt.status}` : "  state=already-settled"}\n`,
                   );
                 } else if (event.stage === "wallet-error") {
                   emit(
@@ -2204,7 +2702,9 @@ async function main() {
             : undefined,
       };
       const plan = await planRegistrySolSweep(slrd, options);
-      const sendRows = plan.rows.filter((row) => row.sendLamports > 0n);
+      const sendRows = plan.rows.filter(
+        (row) => row.sendLamports > 0n && !row.skippedReason,
+      );
       const destinationLabel = destination.contactName
         ? `${destination.contactName} (${plan.destination})`
         : destination.walletName
@@ -2275,6 +2775,12 @@ async function main() {
       }
 
       if (flags.has("simulate")) {
+        if (!flags.has("json")) {
+          emit(
+            `PLAN  eligible=${sendRows.length}/${plan.rows.length}  ` +
+              `total=${formatRaw(plan.totalSendLamports, 9)} SOL\n`,
+          );
+        }
         const results = await simulateRegistrySolSweep(slrd, plan, options);
         if (flags.has("json")) {
           emit(json({ ...printablePlan, results }) + "\n");
@@ -2299,6 +2805,16 @@ async function main() {
         return;
       }
 
+      if (!flags.has("json")) {
+        emit(
+          `PLAN  eligible=${sendRows.length}/${plan.rows.length}  ` +
+            `total=${formatRaw(plan.totalSendLamports, 9)} SOL\n`,
+        );
+        if (sendRows.length === 0) {
+          emit("Nothing to sweep.\n");
+        }
+      }
+
       const receipts = await executeRegistrySolSweep(slrd, plan, options);
       if (flags.has("json")) {
         emit(json({ ...printablePlan, receipts }) + "\n");
@@ -2339,150 +2855,183 @@ async function main() {
       command === "unwrap-wsol" ||
       (command === "unwrap" && values[0] === "wsol")
     ) {
-      const targets = targetWallets(
-        slrd,
-        flags,
-        "Usage: slrd unwrap-wsol (--wallet <wallet> | --wallets <w1,w2> | --group <group>).",
-      );
+      const allWallets = flags.has("all-wallets");
+      const explicitSelectors = [
+        Boolean(flags.get("wallet")),
+        csv(flags.get("wallets")).length > 0,
+        Boolean(flags.get("group")),
+      ].filter(Boolean).length;
+      if (allWallets && explicitSelectors > 0)
+        throw new Error(
+          "Use --all-wallets or a specific wallet selector, not both.",
+        );
+      const targets = allWallets
+        ? {
+            mode: "all-wallets" as const,
+            refs: slrd.wallets.list().map((wallet) => wallet.name),
+          }
+        : targetWallets(
+            slrd,
+            flags,
+            "Usage: slrd unwrap-wsol (--all-wallets | --wallet <wallet> | --wallets <w1,w2> | --group <group>).",
+          );
       const destination = flags.get("destination");
       if (destination && targets.refs.length !== 1)
         throw new Error(
           "--destination is only supported with a single --wallet unwrap.",
         );
-      const unwrapOptions = {
-        via: flags.get("sender") ?? "rpc",
-        destination,
-        skipMissing: flags.has("ignore-missing") || flags.has("skip-missing"),
-        skipSimulation: flags.has("skip-simulation"),
-        skipPreflight:
-          flags.has("skip-preflight") || flags.has("skip-simulation"),
-      };
-
-      const multiWallet = targets.refs.length > 1;
+      const skipMissing =
+        allWallets || flags.has("ignore-missing") || flags.has("skip-missing");
+      const via = flags.get("sender") ?? "rpc";
+      const skipSimulation = flags.has("skip-simulation");
+      const skipPreflight = flags.has("skip-preflight") || skipSimulation;
       const failFast = flags.has("fail-fast");
+      const results: Array<Record<string, unknown>> = [];
 
-      // Multi-wallet/group unwrap is resilient by default. Do not let one
-      // undecryptable wallet prevent unrelated wallets from recovering WSOL.
-      // With --ignore-missing, probe the WSOL ATA using only the public wallet
-      // address BEFORE asking the vault to decrypt the signer.
-      if (multiWallet && !failFast) {
-        const results: Array<Record<string, unknown>> = [];
-
-        for (const walletRef of targets.refs) {
-          const resolved = slrd.resolveWallet(walletRef);
-          const address = resolved.address.toBase58();
-          const label = resolved.row?.name ? `@${resolved.row.name}` : address;
-
-          if (unwrapOptions.skipMissing) {
-            const wsolAccount = wrappedSolAta(resolved.address);
-            const account = await slrd
-              .connection()
-              .getAccountInfo(wsolAccount, "confirmed");
-
-            if (!account) {
-              results.push({
-                wallet: walletRef,
-                address,
-                ok: true,
-                skipped: "missing-wsol",
-                wsolAccount: wsolAccount.toBase58(),
+      for (const walletRef of targets.refs) {
+        const resolved = slrd.resolveWallet(walletRef);
+        const address = resolved.address.toBase58();
+        const label = resolved.row?.name ? `@${resolved.row.name}` : address;
+        try {
+          const accounts = (await slrd.tokenAccounts(address)).filter(
+            (account) => account.mint === NATIVE_SOL_MINT,
+          );
+          if (!accounts.length) {
+            if (!skipMissing && targets.refs.length === 1)
+              throw new Error(`No WSOL token accounts exist for ${address}`);
+            results.push({
+              wallet: walletRef,
+              address,
+              ok: true,
+              skipped: "missing-wsol",
+            });
+            continue;
+          }
+
+          let closed = 0;
+          let unwrappedRaw = 0n;
+          const accountResults: Array<Record<string, unknown>> = [];
+          for (const account of accounts) {
+            if (account.closeAuthority && account.closeAuthority !== address) {
+              const error = `WSOL account ${account.address} has close authority ${account.closeAuthority}`;
+              accountResults.push({
+                account: account.address,
+                ok: false,
+                error,
               });
+              if (failFast) throw new Error(error);
               continue;
             }
-          }
-
-          try {
-            if (flags.has("simulate-only")) {
-              const plan = await slrd
+            try {
+              const composer = slrd
                 .tx(walletRef)
-                .unwrapWsol({ skipMissing: unwrapOptions.skipMissing })
-                .build();
-              const simulation = await slrd.simulatePlan(plan);
-              results.push({
-                wallet: walletRef,
-                address,
-                ok: simulation.success,
-                mode: "simulation",
-                simulation,
-              });
-            } else {
-              const receipt = await slrd.unwrapWsol(walletRef, unwrapOptions);
-              results.push({
-                wallet: walletRef,
-                address,
-                ok: true,
-                receipt,
+                .closeTokenAccountAddress(
+                  account.address,
+                  account.tokenProgram,
+                  {
+                    destination,
+                  },
+                );
+              if (flags.has("simulate-only")) {
+                const plan = await composer.build();
+                const simulation = await slrd.simulatePlan(plan);
+                if (!simulation.success) throw new Error("simulation failed");
+                accountResults.push({
+                  account: account.address,
+                  amountRaw: account.amountRaw,
+                  ok: true,
+                  mode: "simulation",
+                  simulation,
+                });
+              } else {
+                const receipt = await composer.send({
+                  via,
+                  kind: "unwrap-wsol:account",
+                  skipSimulation,
+                  skipPreflight,
+                });
+                const { PublicKey } = await import("@solana/web3.js");
+                let closedOnChain = false;
+                for (let attempt = 0; attempt < 6; attempt += 1) {
+                  const current = await slrd
+                    .connection()
+                    .getAccountInfo(
+                      new PublicKey(account.address),
+                      "confirmed",
+                    );
+                  if (!current || current.lamports === 0) {
+                    closedOnChain = true;
+                    break;
+                  }
+                  if (attempt < 5)
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                }
+                if (!closedOnChain)
+                  throw new Error(
+                    `WSOL account ${account.address} still exists after close`,
+                  );
+                accountResults.push({
+                  account: account.address,
+                  amountRaw: account.amountRaw,
+                  ok: true,
+                  receipt,
+                });
+              }
+              closed += 1;
+              unwrappedRaw += BigInt(account.amountRaw);
+            } catch (error) {
+              const message =
+                error instanceof Error ? error.message : String(error);
+              accountResults.push({
+                account: account.address,
+                ok: false,
+                error: message,
               });
+              if (failFast) throw error;
             }
-          } catch (error) {
-            const message =
-              error instanceof Error ? error.message : String(error);
-            results.push({
-              wallet: walletRef,
-              address,
-              ok: false,
-              error: message,
-            });
-            process.stderr.write(
-              `${OWL} unwrap-wsol ${label} (${address}) failed: ${message}\n`,
-            );
           }
+          const failedAccounts = accountResults.filter(
+            (row) => row.ok === false,
+          ).length;
+          results.push({
+            wallet: walletRef,
+            address,
+            ok: failedAccounts === 0,
+            closed,
+            failedAccounts,
+            unwrappedRaw,
+            accounts: accountResults,
+          });
+        } catch (error) {
+          const message =
+            error instanceof Error ? error.message : String(error);
+          results.push({
+            wallet: walletRef,
+            address,
+            ok: false,
+            error: message,
+          });
+          process.stderr.write(
+            `${OWL} unwrap-wsol ${label} (${address}) failed: ${message}\n`,
+          );
+          if (failFast) throw error;
         }
-
-        const succeeded = results.filter(
-          (row) => row.ok === true && !row.skipped,
-        ).length;
-        const skipped = results.filter((row) => Boolean(row.skipped)).length;
-        const failed = results.filter((row) => row.ok === false).length;
-
-        emit(
-          json({
-            mode: flags.has("simulate-only")
-              ? "wallet-by-wallet-simulation"
-              : "wallet-by-wallet",
-            target: targets,
-            summary: {
-              total: results.length,
-              succeeded,
-              skipped,
-              failed,
-            },
-            results,
-          }) + "\n",
-        );
-        return;
-      }
-
-      // Single-wallet unwrap remains fail-fast. --fail-fast also preserves the
-      // old batch behavior for callers that explicitly want all-or-nothing.
-      if (flags.has("simulate-only")) {
-        const plans =
-          targets.refs.length === 1
-            ? [
-                await slrd
-                  .tx(targets.refs[0]!)
-                  .unwrapWsol({
-                    destination,
-                    skipMissing: unwrapOptions.skipMissing,
-                  })
-                  .build(),
-              ]
-            : await slrd
-                .composeMany(targets.refs)
-                .unwrapWsol({ skipMissing: unwrapOptions.skipMissing })
-                .build();
-        const results = await Promise.all(
-          plans.map((plan) => slrd.simulatePlan(plan)),
-        );
-        emit(json({ mode: "simulation", target: targets, results }) + "\n");
-        return;
       }
 
-      const receipts =
-        targets.refs.length === 1
-          ? await slrd.unwrapWsol(targets.refs[0]!, unwrapOptions)
-          : await slrd.unwrapWsolMany(targets.refs, unwrapOptions);
-      emit(json(receipts) + "\n");
+      const succeeded = results.filter(
+        (row) => row.ok === true && !row.skipped,
+      ).length;
+      const skipped = results.filter((row) => Boolean(row.skipped)).length;
+      const failed = results.filter((row) => row.ok === false).length;
+      emit(
+        json({
+          mode: flags.has("simulate-only") ? "simulation" : "live",
+          target: targets,
+          summary: { total: results.length, succeeded, skipped, failed },
+          results,
+        }) + "\n",
+      );
+      if (failed) process.exitCode = 1;
       return;
     }
     if (command === "rewards") {