@solard/cli 0.2.31 → 0.2.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solard/cli",
-  "version": "0.2.31",
+  "version": "0.2.37",
   "description": "Command-line interface for the Solard SDK.",
   "type": "module",
   "main": "./src/index.ts",
@@ -19,8 +19,8 @@
   },
   "dependencies": {
     "@solana/web3.js": "^1.98.4",
-    "@solard/core": "0.2.31",
-    "@solard/sdk": "0.2.31",
+    "@solard/core": "0.2.37",
+    "@solard/sdk": "0.2.37",
     "bs58": "^6.0.0",
     "measure-fn": "5.2.0"
   },

package/src/commands/buy.ts

@@ -131,10 +131,16 @@ export async function runSmartBuyCommand({
               .build();
       const results = await Promise.all(
         plans.map(async (plan, index) => {
-          const prepared = await slrd.prepareTradePlan(target.refs[index]!, plan, options);
-          return { ...await slrd.simulatePlan(prepared.plan),
+          const prepared = await slrd.prepareTradePlan(
+            target.refs[index]!,
+            plan,
+            options,
+          );
+          return {
+            ...(await slrd.simulatePlan(prepared.plan)),
             priorityMicroLamports: prepared.priorityMicroLamports,
-            cuLimit: prepared.plan.draft.cuLimit ?? 600_000 };
+            cuLimit: prepared.plan.draft.cuLimit ?? 600_000,
+          };
         }),
       );
       return {

package/src/commands/sell.ts

@@ -169,10 +169,16 @@ export async function runSmartSellCommand({
               .build();
       const results = await Promise.all(
         plans.map(async (plan, index) => {
-          const prepared = await slrd.prepareTradePlan(target.refs[index]!, plan, options);
-          return { ...await slrd.simulatePlan(prepared.plan),
+          const prepared = await slrd.prepareTradePlan(
+            target.refs[index]!,
+            plan,
+            options,
+          );
+          return {
+            ...(await slrd.simulatePlan(prepared.plan)),
             priorityMicroLamports: prepared.priorityMicroLamports,
-            cuLimit: prepared.plan.draft.cuLimit ?? 600_000 };
+            cuLimit: prepared.plan.draft.cuLimit ?? 600_000,
+          };
         }),
       );
       return {

package/src/commands/trade-fees.test.ts

@@ -2,14 +2,26 @@ import { expect, test } from "bun:test";
 import { tradeFeeOptions } from "./trade-fees.ts";
 
 test("native buy/sell fee flags preserve custom compute limit and price", () => {
-  expect(tradeFeeOptions(new Map([
-    ["cu-limit", "150000"], ["priority-micro-lamports", "1000000"],
-    ["trade-attempts", "4"], ["max-priority-fee-lamports", "500000"],
-  ]))).toMatchObject({ priorityFee: { cuLimit: 150_000, microLamports: 1_000_000 },
-    landing: { maxAttempts: 4, maxPriorityFeeLamports: 500_000 } });
+  expect(
+    tradeFeeOptions(
+      new Map([
+        ["cu-limit", "150000"],
+        ["priority-micro-lamports", "1000000"],
+        ["trade-attempts", "4"],
+        ["max-priority-fee-lamports", "500000"],
+      ]),
+    ),
+  ).toMatchObject({
+    priorityFee: { cuLimit: 150_000, microLamports: 1_000_000 },
+    landing: { maxAttempts: 4, maxPriorityFeeLamports: 500_000 },
+  });
 });
 
 test("invalid fee flags reject instead of being ignored", () => {
-  for (const [name, value] of [["cu-limit", "0"], ["priority-micro-lamports", "-1"], ["priority-micro-lamports", "true"]])
+  for (const [name, value] of [
+    ["cu-limit", "0"],
+    ["priority-micro-lamports", "-1"],
+    ["priority-micro-lamports", "true"],
+  ])
     expect(() => tradeFeeOptions(new Map([[name!, value!]]))).toThrow();
 });

package/src/commands/trade-fees.ts

@@ -10,9 +10,15 @@ export function tradeFeeOptions(flags: ReadonlyMap<string, string>) {
   };
   const cuLimit = number("cu-limit");
   const microLamports = number("priority-micro-lamports");
-  if (cuLimit != null && (!Number.isInteger(cuLimit) || cuLimit < 1 || cuLimit > 1_400_000))
+  if (
+    cuLimit != null &&
+    (!Number.isInteger(cuLimit) || cuLimit < 1 || cuLimit > 1_400_000)
+  )
     throw new Error("--cu-limit must be an integer between 1 and 1400000");
-  if (microLamports != null && (!Number.isSafeInteger(microLamports) || microLamports < 0))
+  if (
+    microLamports != null &&
+    (!Number.isSafeInteger(microLamports) || microLamports < 0)
+  )
     throw new Error("--priority-micro-lamports must be a non-negative integer");
   const landing: TradeLandingPolicy = {
     maxAttempts: number("trade-attempts"),

package/src/commands/transfer.test.ts

@@ -3,31 +3,88 @@ import { Keypair } from "@solana/web3.js";
 import { Solard, estimatePlanFee, type PlannedTransaction } from "@solard/core";
 import { runTransferCommand } from "./transfer.ts";
 function fixture(status: "confirmed" | "submitted" | "failed" = "confirmed") {
-  const core: Solard = Object.create(Solard.prototype); const payer = Keypair.generate();
-  const prices: number[] = []; let samples = 0;
+  const core: Solard = Object.create(Solard.prototype);
+  const payer = Keypair.generate();
+  const prices: number[] = [];
+  let samples = 0;
   core.signer = () => payer;
-  core.connection = () => ({
-    getRecentPrioritizationFees: async () => { samples++; return [200_000, 400_000, 800_000, 1_000_000].map((prioritizationFee) => ({ prioritizationFee })); },
-    getFeeForMessage: async (message: { price: number }) => ({ value: 5000 + Math.ceil(10_000 * message.price / 1_000_000) }),
-  }) as any;
-  core.compile = async (_payer, draft) => ({ draft, payer: payer.publicKey, transaction: { message: { price: draft.cuPriceMicroLamports ?? 100_000 } } }) as unknown as PlannedTransaction;
-  core.submitPlan = async (plan, sender) => { prices.push(plan.draft.cuPriceMicroLamports!); return { signature: "test-signature", executionId: 1, sender, plan, feeEstimate: await estimatePlanFee(core.connection(), plan) }; };
-  core.settleSubmission = async () => ({ signature: "test-signature", sender: "rpc", status, slot: status === "confirmed" ? 1 : null, ...(status === "confirmed" ? { feeLamports: 13000 } : {}) });
-  Object.defineProperty(core, "executions", { value: { get: () => ({ metaJson: null }) } });
+  core.connection = () =>
+    ({
+      getRecentPrioritizationFees: async () => {
+        samples++;
+        return [200_000, 400_000, 800_000, 1_000_000].map(
+          (prioritizationFee) => ({ prioritizationFee }),
+        );
+      },
+      getFeeForMessage: async (message: { price: number }) => ({
+        value: 5000 + Math.ceil((10_000 * message.price) / 1_000_000),
+      }),
+    }) as any;
+  core.compile = async (_payer, draft) =>
+    ({
+      draft,
+      payer: payer.publicKey,
+      transaction: {
+        message: { price: draft.cuPriceMicroLamports ?? 100_000 },
+      },
+    }) as unknown as PlannedTransaction;
+  core.submitPlan = async (plan, sender) => {
+    prices.push(plan.draft.cuPriceMicroLamports!);
+    return {
+      signature: "test-signature",
+      executionId: 1,
+      sender,
+      plan,
+      feeEstimate: await estimatePlanFee(core.connection(), plan),
+    };
+  };
+  core.settleSubmission = async () => ({
+    signature: "test-signature",
+    sender: "rpc",
+    status,
+    slot: status === "confirmed" ? 1 : null,
+    ...(status === "confirmed" ? { feeLamports: 13000 } : {}),
+  });
+  Object.defineProperty(core, "executions", {
+    value: { get: () => ({ metaJson: null }) },
+  });
   return { core, prices, samples: () => samples };
 }
-const flags = (extra: Array<[string, string]> = []) => new Map([["wallet", "bags"], ["sol", "2"], ["live", "true"], ...extra]);
+const flags = (extra: Array<[string, string]> = []) =>
+  new Map([["wallet", "bags"], ["sol", "2"], ["live", "true"], ...extra]);
 test("SOL transfer uses writable market fees and reports selected versus actual network fees", async () => {
   const ctx = fixture();
-  const result = await runTransferCommand({ slrd: ctx.core, values: [Keypair.generate().publicKey.toBase58()], flags: flags() });
-  expect(ctx.prices).toEqual([800_000]); expect(ctx.samples()).toBe(1);
-  expect(result.status).toBe("confirmed"); expect(result.feeEstimate).toEqual({ cuLimit: 10_000, priorityMicroLamports: 800_000, priorityFeeLamports: 8000, estimatedBaseFeeLamports: 5000, estimatedNetworkFeeLamports: 13000 });
+  const result = await runTransferCommand({
+    slrd: ctx.core,
+    values: [Keypair.generate().publicKey.toBase58()],
+    flags: flags(),
+  });
+  expect(ctx.prices).toEqual([800_000]);
+  expect(ctx.samples()).toBe(1);
+  expect(result.status).toBe("confirmed");
+  expect(result.feeEstimate).toEqual({
+    cuLimit: 10_000,
+    priorityMicroLamports: 800_000,
+    priorityFeeLamports: 8000,
+    estimatedBaseFeeLamports: 5000,
+    estimatedNetworkFeeLamports: 13000,
+  });
   expect(result.feeLamports).toBe(13000);
 });
 test("explicit zero disables transfer fee estimation and pending outcome is never repeated blindly", async () => {
   const ctx = fixture("submitted");
-  const result = await runTransferCommand({ slrd: ctx.core, values: [Keypair.generate().publicKey.toBase58()], flags: flags([["priority-micro-lamports", "0"]]) });
-  expect(ctx.prices).toEqual([0]); expect(ctx.samples()).toBe(0);
-  expect(result.status).toBe("unresolved"); expect(result.code).toBe("UNRESOLVED"); expect(result.feeLamports).toBeUndefined();
-  expect(result.feeEstimate).toMatchObject({ priorityFeeLamports: 0, estimatedNetworkFeeLamports: 5000 });
+  const result = await runTransferCommand({
+    slrd: ctx.core,
+    values: [Keypair.generate().publicKey.toBase58()],
+    flags: flags([["priority-micro-lamports", "0"]]),
+  });
+  expect(ctx.prices).toEqual([0]);
+  expect(ctx.samples()).toBe(0);
+  expect(result.status).toBe("unresolved");
+  expect(result.code).toBe("UNRESOLVED");
+  expect(result.feeLamports).toBeUndefined();
+  expect(result.feeEstimate).toMatchObject({
+    priorityFeeLamports: 0,
+    estimatedNetworkFeeLamports: 5000,
+  });
 });

package/src/commands/transfer.ts

@@ -144,7 +144,11 @@ export async function runTransferCommand({
       .priorityFee({ cuLimit, microLamports: priorityMicroLamports });
 
     if (flags.has("simulate-only")) {
-      const prepared = await slrd.prepareTradePlan(wallet, await composer.build(), executionOptions);
+      const prepared = await slrd.prepareTradePlan(
+        wallet,
+        await composer.build(),
+        executionOptions,
+      );
       const result = await slrd.simulatePlan(prepared.plan);
       return {
         mode: "simulation",
@@ -162,8 +166,18 @@ export async function runTransferCommand({
       };
     }
 
-    const execution = await slrd.executeTradePlan(wallet, () => composer.build(), via, "transfer-token", executionOptions);
-    const receipt = tradeResult(execution.receipt, execution.attempts, execution.submission.executionId);
+    const execution = await slrd.executeTradePlan(
+      wallet,
+      () => composer.build(),
+      via,
+      "transfer-token",
+      executionOptions,
+    );
+    const receipt = tradeResult(
+      execution.receipt,
+      execution.attempts,
+      execution.submission.executionId,
+    );
 
     return {
       ...receipt,
@@ -184,7 +198,11 @@ export async function runTransferCommand({
     .priorityFee({ cuLimit, microLamports: priorityMicroLamports });
 
   if (flags.has("simulate-only")) {
-    const prepared = await slrd.prepareTradePlan(wallet, await composer.build(), executionOptions);
+    const prepared = await slrd.prepareTradePlan(
+      wallet,
+      await composer.build(),
+      executionOptions,
+    );
     const result = await slrd.simulatePlan(prepared.plan);
     return {
       mode: "simulation",
@@ -198,8 +216,18 @@ export async function runTransferCommand({
     };
   }
 
-  const execution = await slrd.executeTradePlan(wallet, () => composer.build(), via, "transfer-sol", executionOptions);
-  const receipt = tradeResult(execution.receipt, execution.attempts, execution.submission.executionId);
+  const execution = await slrd.executeTradePlan(
+    wallet,
+    () => composer.build(),
+    via,
+    "transfer-sol",
+    executionOptions,
+  );
+  const receipt = tradeResult(
+    execution.receipt,
+    execution.attempts,
+    execution.submission.executionId,
+  );
 
   return { ...receipt, recipient, wallet, sol: amount };
 }