@solard/cli 0.2.13 → 0.2.15

package/src/meteora-commands.ts

@@ -1,8 +1,10 @@
-import type {
-  MeteoraPreparedTransactions,
-  MeteoraStrategy,
-  MeteoraTimeframe,
-  Solard,
+import {
+  executeRegistryMeteoraLiquidation,
+  planRegistryMeteoraLiquidation,
+  type MeteoraPreparedTransactions,
+  type MeteoraStrategy,
+  type MeteoraTimeframe,
+  type Solard,
 } from "@solard/sdk";
 
 const WSOL = "So11111111111111111111111111111111111111112";
@@ -24,6 +26,14 @@ function flag(flags: Flags, key: string): string | undefined {
   return value && value !== "true" ? value : undefined;
 }
 
+function csv(value: string | undefined): string[] {
+  if (!value || value === "true") return [];
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
 function requiredFlag(flags: Flags, key: string): string {
   const value = flag(flags, key);
   if (!value) throw new Error(`Missing --${key} <value>`);
@@ -349,6 +359,7 @@ function positionsTable(result: AnyRow): string {
       pad("RANGE", 14),
       pad("ACTIVE", 7, "right"),
       pad("IN", 3),
+      pad("FUNDED", 9, "right"),
       pad("X", 16, "right"),
       pad("Y", 14, "right"),
       pad("FEE X", 12, "right"),
@@ -364,6 +375,19 @@ function positionsTable(result: AnyRow): string {
         pad(`${row.lowerBin ?? "?"}..${row.upperBin ?? "?"}`, 14),
         pad(row.activeBin ?? "-", 7, "right"),
         pad(row.inRange ? "yes" : "no", 3),
+        pad(
+          row.liquidityCoverage?.expectedBinCount != null
+            ? `${row.liquidityCoverage?.fundedBinIds?.length ?? 0}/${row.liquidityCoverage.expectedBinCount}${
+                row.liquidityCoverage.fullRangeFunded === false
+                  ? "!"
+                  : row.liquidityCoverage.fullRangeFunded == null
+                    ? "?"
+                    : ""
+              }`
+            : "?",
+          9,
+          "right",
+        ),
         pad(rawUiText(row.totalXRaw ?? row.xRaw, xd), 16, "right"),
         pad(rawUiText(row.totalYRaw ?? row.yRaw, yd), 14, "right"),
         pad(rawUiText(row.feeXRaw, xd), 12, "right"),
@@ -1517,6 +1541,53 @@ function closeAllHuman(result: AnyRow): string {
   return lines.join("\n") + "\n";
 }
 
+function registryMeteoraPlanHuman(plan: AnyRow, live = false): string {
+  const positions = Array.isArray(plan.positions) ? plan.positions : [];
+  const errors = Array.isArray(plan.scanErrors) ? plan.scanErrors : [];
+  const pools = new Set(positions.map((row: AnyRow) => String(row.pool ?? "")))
+    .size;
+  const lines = [
+    `METEORA ${live ? "CLOSE ALL" : "POSITIONS"}`,
+    `Wallets scanned: ${Number(plan.walletsScanned ?? 0)}`,
+    `Pools: ${pools}`,
+    `Positions: ${positions.length}`,
+    "",
+  ];
+  if (positions.length) {
+    lines.push(
+      "WALLET            POOL             POSITION         X RAW           Y RAW",
+    );
+    for (const row of positions) {
+      lines.push(
+        `${String(row.walletName ?? "-")
+          .slice(0, 16)
+          .padEnd(17)} ` +
+          `${String(row.pool ?? "-")
+            .slice(0, 16)
+            .padEnd(17)} ` +
+          `${String(row.position ?? "-")
+            .slice(0, 16)
+            .padEnd(17)} ` +
+          `${String(row.totalXRaw ?? "0").padEnd(15)} ${String(row.totalYRaw ?? "0")}`,
+      );
+    }
+  } else {
+    lines.push("No open Meteora positions found.");
+  }
+  if (errors.length) {
+    lines.push("", `Scan errors: ${errors.length}`);
+    for (const row of errors) {
+      lines.push(
+        `  @${String(row.walletName ?? "-")}: ${String(row.error ?? "unknown error")}`,
+      );
+    }
+  }
+  if (!live && positions.length) {
+    lines.push("", "Preview only. Add --live to close every listed position.");
+  }
+  return lines.join("\n") + "\n";
+}
+
 export async function handleMeteoraCommand(args: {
   slrd: Solard;
   values: string[];
@@ -1538,6 +1609,7 @@ export async function handleMeteoraCommand(args: {
         `  slrd meteora candles <pool> [--timeframe 5m] [--start-time unix] [--end-time unix]\n` +
         `  slrd meteora active-bin <pool>\n` +
         `  slrd meteora positions --wallet <wallet|address> [--pool <pool>]\n` +
+        `  slrd meteora positions --all-wallets\n` +
         `  slrd meteora position <position> (--wallet <wallet|address> | --pool <pool>)\n` +
         `  slrd meteora portfolio --wallet <wallet|address> [--open]\n` +
         `  slrd meteora history <position>\n` +
@@ -1549,6 +1621,8 @@ export async function handleMeteoraCommand(args: {
         `  slrd meteora remove <position> --wallet <wallet> [--bps 10000] [--pool <pool>] [--live]\n` +
         `  slrd meteora close <position> --wallet <wallet> [--pool <pool>] [--live]\n` +
         `  slrd meteora close-all <pool> --wallet <wallet> [--live]\n` +
+        `  slrd meteora close-all --wallet <wallet> --all-pools [--live]\n` +
+        `  slrd meteora close-all --all-wallets --all-pools [--live]\n` +
         `  slrd meteora move <position> --wallet <wallet> [--pool <pool>] [--bins N] [--haircut-bps 100] [--live]\n` +
         `  slrd meteora migrate <position> --wallet <wallet> --to-pool <pool> [--from-pool <source-pool>] [--bins N] [--haircut-bps 100] [--live]\n` +
         `  slrd meteora claim <position> --wallet <wallet> [--kind fees|rewards|all] [--pool <pool>] [--live]\n` +
@@ -2009,6 +2083,23 @@ export async function handleMeteoraCommand(args: {
   }
 
   if (action === "positions") {
+    if (flags.has("all-wallets")) {
+      if (flag(flags, "wallet") || flag(flags, "pool")) {
+        throw new Error(
+          "--all-wallets cannot be combined with --wallet or --pool",
+        );
+      }
+      const result = await planRegistryMeteoraLiquidation(slrd, {
+        delayMs: Math.max(0, integerFlag(flags, "delay-ms", 100)!),
+      });
+      emit(
+        flags.has("json")
+          ? json(result) + "\n"
+          : registryMeteoraPlanHuman(result as AnyRow),
+      );
+      return;
+    }
+
     const walletRef = requiredFlag(flags, "wallet");
     const wallet = publicWalletAddress(slrd, walletRef);
     const pool = flag(flags, "pool");
@@ -2196,10 +2287,61 @@ export async function handleMeteoraCommand(args: {
   }
 
   if (action === "close-all") {
+    if (flags.has("all-pools")) {
+      const allWallets = flags.has("all-wallets");
+      const wallet = flag(flags, "wallet");
+      const walletList = csv(flag(flags, "wallets"));
+      if (allWallets && (wallet || walletList.length)) {
+        throw new Error(
+          "--all-wallets cannot be combined with --wallet or --wallets",
+        );
+      }
+      if (!allWallets && !wallet && !walletList.length) {
+        throw new Error(
+          "Use --wallet <wallet>, --wallets <w1,w2>, or --all-wallets with --all-pools",
+        );
+      }
+      const walletRefs = allWallets
+        ? undefined
+        : wallet
+          ? [wallet]
+          : walletList;
+      const options = {
+        walletRefs,
+        delayMs: Math.max(0, integerFlag(flags, "delay-ms", 100)!),
+        continueOnError: flags.has("continue-on-error"),
+      };
+      const plan = await planRegistryMeteoraLiquidation(slrd, options);
+      if (!flags.has("live")) {
+        emit(
+          flags.has("json")
+            ? json({ live: false, ...plan }) + "\n"
+            : registryMeteoraPlanHuman(plan as AnyRow),
+        );
+        return;
+      }
+      const results = await executeRegistryMeteoraLiquidation(
+        slrd,
+        plan,
+        options,
+      );
+      const output = { live: true, ...plan, results };
+      emit(
+        flags.has("json")
+          ? json(output) + "\n"
+          : registryMeteoraPlanHuman(plan as AnyRow, true) +
+              `Closed: ${results.length}/${plan.positions.length}\n`,
+      );
+      return;
+    }
+
+    if (flags.has("all-wallets")) {
+      throw new Error("--all-wallets requires --all-pools");
+    }
     const pool = values[1] ?? flag(flags, "pool");
     if (!pool)
       throw new Error(
-        "Usage: slrd meteora close-all <pool> --wallet <wallet> [--live]",
+        "Usage: slrd meteora close-all <pool> --wallet <wallet> [--live] or slrd meteora close-all --all-wallets --all-pools [--live]",
       );
     const walletRef = requiredFlag(flags, "wallet");
     const walletAddress = publicWalletAddress(slrd, walletRef);

package/src/pump/external-deployment-cli.ts

@@ -0,0 +1,136 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+import {
+  buildPumpExternalDeployment,
+  createTraderSolard,
+  type PumpExternalDeploymentBuild,
+} from "@solard/sdk";
+
+export type ExternalPumpFlags = Map<string, string>;
+
+function parse(argv: string[]): ExternalPumpFlags {
+  const flags = new Map<string, string>();
+  for (let index = 0; index < argv.length; index += 1) {
+    const item = argv[index]!;
+    if (!item.startsWith("--")) continue;
+    const [key, inline] = item.slice(2).split("=", 2);
+    if (inline != null) flags.set(key!, inline);
+    else if (argv[index + 1] && !argv[index + 1]!.startsWith("--"))
+      flags.set(key!, argv[++index]!);
+    else flags.set(key!, "true");
+  }
+  return flags;
+}
+
+function value(flags: ExternalPumpFlags, key: string): string | undefined {
+  const result = flags.get(key);
+  return result && result !== "true" ? result : undefined;
+}
+
+function required(flags: ExternalPumpFlags, key: string): string {
+  const result = value(flags, key);
+  if (!result) throw new Error(`Missing --${key} <value>`);
+  return result;
+}
+
+function integer(
+  flags: ExternalPumpFlags,
+  key: string,
+  fallback: number,
+): number {
+  const raw = value(flags, key);
+  if (raw == null) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    throw new Error(`Invalid --${key}: ${raw}`);
+  return Math.trunc(parsed);
+}
+
+function printable(build: PumpExternalDeploymentBuild) {
+  return {
+    version: build.version,
+    launchpad: build.launchpad,
+    transactionBase64: build.transactionBase64,
+    payer: build.payer,
+    mint: build.mint,
+    beneficiary: build.beneficiary,
+    pair: build.quoteKind === "native-sol" ? "SOL" : build.quoteMint,
+    quoteMint: build.quoteMint,
+    quoteKind: build.quoteKind,
+    quoteDecimals: build.quoteDecimals,
+    quoteTokenProgram: build.quoteTokenProgram,
+    requiredSignerPubkeys: build.requiredSignerPubkeys,
+    partialSignerPubkeys: build.partialSignerPubkeys,
+    missingSignerPubkeys: build.missingSignerPubkeys,
+    blockhash: build.blockhash,
+    lastValidBlockHeight: build.lastValidBlockHeight,
+    serializedSize: build.serializedSize,
+    token: build.token,
+    broadcast: false,
+  };
+}
+
+/**
+ * Prepare a Pump create_v2 transaction for Phantom or another external wallet.
+ * No persisted Solard signing wallet is opened or decrypted, and nothing is sent.
+ */
+export async function runPumpExternalDeploymentFromArgs(
+  argv: string[],
+): Promise<ReturnType<typeof printable>> {
+  const flags = parse(argv);
+  if (flags.has("live")) {
+    throw new Error(
+      "External-wallet preparation never broadcasts. Remove --live, sign transactionBase64 with Phantom, then broadcast from the wallet/frontend.",
+    );
+  }
+
+  const payer = required(flags, "payer");
+  const name = required(flags, "name");
+  const symbol = required(flags, "symbol");
+  const uri = required(flags, "uri");
+  const pair = value(flags, "pair") ?? value(flags, "quote-mint") ?? "SOL";
+  const beneficiary = value(flags, "beneficiary") ?? payer;
+
+  const slrd = createTraderSolard();
+  try {
+    const build = await buildPumpExternalDeployment({
+      connection: slrd.connection(),
+      payer,
+      name,
+      symbol,
+      uri,
+      pair,
+      beneficiary,
+      mayhemMode: flags.has("mayhem"),
+      cashback: flags.has("cashback"),
+      cuLimit: integer(flags, "cu-limit", 600_000),
+      priorityMicroLamports: integer(flags, "priority-micro-lamports", 0),
+    });
+    const output = printable(build);
+    const encoded = `${JSON.stringify(output, null, 2)}\n`;
+    const out = value(flags, "out");
+    if (out) {
+      const path = resolve(out);
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, encoded, { flag: "w" });
+      process.stdout.write(
+        `🦉 prepared Pump deployment\n` +
+          `  mint         ${build.mint}\n` +
+          `  payer        ${build.payer}  (Phantom signature required)\n` +
+          `  beneficiary  ${build.beneficiary}\n` +
+          `  pair         ${build.quoteKind === "native-sol" ? "SOL" : build.quoteMint}\n` +
+          `  mint signer  signed\n` +
+          `  broadcast    NO\n` +
+          `  output       ${path}\n`,
+      );
+    } else {
+      // The transaction is the product of this command, so stdout is machine-ready
+      // JSON by default when no explicit output file is supplied.
+      process.stdout.write(encoded);
+    }
+    return output;
+  } finally {
+    slrd.close();
+  }
+}

package/src/pump/token-launch-cli.ts

@@ -10,6 +10,7 @@ import {
   cleanVanitySuffix,
   defaultVanityMaxAttempts,
   executePumpTokenLaunch,
+  findExternalContact,
   generateMintKeypairWithSuffix,
   installPumpLaunchSenders,
   loadExplicitBuyerAllocations,
@@ -18,6 +19,7 @@ import {
   parseArmedBuyerEndpoint,
   PUMP_PROGRAM_ID,
   preparePumpTokenLaunch,
+  resolvePumpQuoteAsset,
   pumpLaunchEnvironment,
   releaseArmedBuyerEndpoints,
   releaseVanityMintReservation,
@@ -35,6 +37,7 @@ import {
   type PumpLaunchEnvironment,
   type PumpTokenLaunchPlan,
   type PumpTokenLaunchResult,
+  type QuoteAsset,
   type SendReceipt,
   type SimulationResult,
   type Solard,
@@ -73,7 +76,10 @@ export type PumpTokenLaunchCliOptions = {
 export type PumpTokenLaunchCliResult = {
   createdAt: string;
   live: boolean;
+  /** Transaction payer / local signing wallet. */
   creator: string;
+  /** On-chain Pump creator fee/reward beneficiary. */
+  beneficiary: string;
   buyerGroup: string | null;
   buyPlan?: string | null;
   transport: Record<string, unknown>;
@@ -82,6 +88,10 @@ export type PumpTokenLaunchCliResult = {
     metadataUri: string;
     mint: string;
     feeMode: "creator-fees";
+    pair: "SOL" | "USDC" | "mint";
+    quoteMint: string;
+    quoteDecimals: number;
+    beneficiary: string;
     cashback: boolean;
     mayhemMode: boolean;
     vanityMintSuffix?: string | null;
@@ -1125,6 +1135,8 @@ export async function preparePumpTokenLaunchFromFlags(args: {
   flags: Flags;
   token: TokenMetadata;
   creator: string;
+  creatorBeneficiary?: PublicKey;
+  quoteAsset?: QuoteAsset;
   env?: PumpLaunchEnvironment;
   options?: PumpTokenLaunchCliOptions;
   mint?: Keypair;
@@ -1226,6 +1238,8 @@ export async function preparePumpTokenLaunchFromFlags(args: {
     ),
     senderPolicy: env.policy,
     mint: args.mint,
+    creatorBeneficiary: args.creatorBeneficiary,
+    quoteAsset: args.quoteAsset,
     cashback: args.cashback ?? args.token.cashback ?? false,
     mayhemMode: args.mayhemMode ?? args.token.mayhemMode ?? false,
   });
@@ -1238,6 +1252,37 @@ function vanitySuffixFromFlags(flags: Flags): string | null {
   return null;
 }
 
+function resolvePublicAddress(
+  slrd: Solard,
+  value: string | undefined,
+  fallback: PublicKey,
+  label: string,
+): PublicKey {
+  if (!value || value === "true") return fallback;
+  try {
+    return slrd.resolveWallet(value).address;
+  } catch {
+    // Stored wallet refs are convenient but not required for a beneficiary.
+  }
+  const contact = findExternalContact(value);
+  if (contact) return new PublicKey(contact.address);
+  try {
+    return new PublicKey(value);
+  } catch {
+    throw new Error(
+      `Invalid ${label} ${JSON.stringify(value)}. Use a stored wallet, contact, or Solana address.`,
+    );
+  }
+}
+
+function pairLabel(quoteAsset: QuoteAsset): "SOL" | "USDC" | "mint" {
+  if (quoteAsset.kind === "native-sol") return "SOL";
+  return quoteAsset.mint.toBase58() ===
+    "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+    ? "USDC"
+    : "mint";
+}
+
 function envNumber(name: string, fallback: number): number {
   const raw = process.env[name]?.trim();
   if (!raw) return fallback;
@@ -1479,6 +1524,31 @@ export async function runPumpTokenLaunchFromArgs(
   const slrd = createTraderSolard({ rpcUrl: env.rpcUrl });
   installPumpLaunchSenders(slrd, env);
 
+  const payerAddress = slrd.resolveWallet(creator).address;
+  const beneficiary = resolvePublicAddress(
+    slrd,
+    first(flags, "beneficiary"),
+    payerAddress,
+    "--beneficiary",
+  );
+  const pairInput = first(flags, "pair") ?? first(flags, "quote-mint") ?? "SOL";
+  const quoteAsset = await resolvePumpQuoteAsset(slrd.connection(), pairInput);
+  const creatorBuyLamports = optionalSol(
+    flags,
+    "creator-buy-sol",
+    "creator-buy-lamports",
+    0n,
+  );
+  if (
+    quoteAsset.kind !== "native-sol" &&
+    (hasBuyers || creatorBuyLamports > 0n)
+  ) {
+    throw new Error(
+      `Pump ${pairLabel(quoteAsset)}-paired launches currently support deploy-only creation. ` +
+        "Buyer plans and --creator-buy-sol are SOL-denominated; Solard will not reinterpret them as quote-token amounts.",
+    );
+  }
+
   if (vanityMint) {
     await assertPumpMintIsUnused({
       slrd,
@@ -1519,6 +1589,8 @@ export async function runPumpTokenLaunchFromArgs(
       flags,
       token,
       creator,
+      creatorBeneficiary: beneficiary,
+      quoteAsset,
       env,
       options,
       mint: vanityMint,
@@ -1534,6 +1606,10 @@ export async function runPumpTokenLaunchFromArgs(
         name: input.name,
         symbol: input.symbol,
         mint,
+        beneficiary: beneficiary.toBase58(),
+        pair: pairLabel(quoteAsset),
+        quoteMint: quoteAsset.mint.toBase58(),
+        quoteDecimals: quoteAsset.decimals,
         metadataUri: uri,
         website: input.website ?? null,
         twitter: input.twitter ?? null,
@@ -1559,12 +1635,7 @@ export async function runPumpTokenLaunchFromArgs(
       vanityMintSuffix,
       vanityMintAttempts,
       vanityMintElapsedMs,
-      creatorBuyLamports: optionalSol(
-        flags,
-        "creator-buy-sol",
-        "creator-buy-lamports",
-        0n,
-      ),
+      creatorBuyLamports,
       buyerGroup: group ?? null,
       buyPlan:
         first(flags, "buy-plan") ??
@@ -1674,6 +1745,7 @@ export async function runPumpTokenLaunchFromArgs(
       createdAt: new Date().toISOString(),
       live,
       creator,
+      beneficiary: beneficiary.toBase58(),
       buyerGroup: group ?? null,
       buyPlan:
         first(flags, "buy-plan") ??
@@ -1702,6 +1774,10 @@ export async function runPumpTokenLaunchFromArgs(
         metadataUri: uri,
         mint,
         feeMode: "creator-fees",
+        pair: pairLabel(quoteAsset),
+        quoteMint: quoteAsset.mint.toBase58(),
+        quoteDecimals: quoteAsset.decimals,
+        beneficiary: beneficiary.toBase58(),
         cashback,
         mayhemMode,
         vanityMintSuffix,