naracli 1.0.37 → 1.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naracli",
-  "version": "1.0.37",
+  "version": "1.0.44",
   "description": "CLI for the Nara chain (Solana-compatible)",
   "module": "index.ts",
   "main": "index.ts",
@@ -56,7 +56,8 @@
     "bs58": "^6.0.0",
     "commander": "^12.1.0",
     "ed25519-hd-key": "^1.3.0",
-    "nara-sdk": "^1.0.37",
+    "nara-sdk": "^1.0.44",
     "picocolors": "^1.1.1"
-  }
+  },
+  "packageManager": "pnpm@10.27.0+sha512.72d699da16b1179c14ba9e64dc71c9a40988cbdc65c264cb0e489db7de917f20dcf4d64d8723625f2969ba52d4b7e2a1170682d9ac2a5dcaeaab732b7e16f04a"
 }

package/src/cli/commands/agent.ts

@@ -15,6 +15,7 @@ import {
 import type { GlobalOptions } from "../types";
 import {
   registerAgent,
+  registerAgentWithReferral,
   getAgentInfo,
   getAgentMemory,
   setBio,
@@ -24,6 +25,7 @@ import {
   transferAgentAuthority,
   deleteAgent,
   logActivity,
+  logActivityWithReferral,
   setReferral as setReferralOnChain,
 } from "nara-sdk";
 import { readFileSync } from "node:fs";
@@ -39,7 +41,9 @@ async function handleAgentRegister(agentId: string, options: GlobalOptions & { r
   const wallet = await loadWallet(options.wallet);
 
   if (!options.json) printInfo(`Registering agent "${agentId}"...`);
-  const result = await registerAgent(connection, wallet, agentId, undefined, options.referral);
+  const result = options.referral
+    ? await registerAgentWithReferral(connection, wallet, agentId, options.referral)
+    : await registerAgent(connection, wallet, agentId);
   if (!options.json) printSuccess(`Agent "${agentId}" registered!`);
   addAgentId(agentId, rpcUrl);
 
@@ -255,7 +259,9 @@ async function handleAgentLog(
   const referral = options.referral;
 
   if (!options.json) printInfo(`Logging activity for "${agentId}"...`);
-  const signature = await logActivity(connection, wallet, agentId, model, activity, log, undefined, referral);
+  const signature = referral
+    ? await logActivityWithReferral(connection, wallet, agentId, model, activity, log, referral)
+    : await logActivity(connection, wallet, agentId, model, activity, log);
   if (!options.json) printSuccess("Activity logged!");
 
   if (options.json) {

package/src/cli/commands/quest.ts

@@ -20,7 +20,11 @@ import {
   submitAnswer,
   submitAnswerViaRelay,
   parseQuestReward,
+  stake as questStake,
+  unstake as questUnstake,
+  getStakeInfo,
   type ActivityLog,
+  type StakeInfo,
 } from "nara-sdk";
 import { loadNetworkConfig } from "../utils/agent-config";
 
@@ -34,9 +38,12 @@ const QUEST_ERRORS: Record<number, string> = {
   6003: "invalidProof",
   6004: "invalidDeadline",
   6005: "insufficientReward",
-  6006: "insufficientPoolBalance",
-  6007: "questionTooLong",
-  6008: "alreadyAnswered",
+  6006: "questionTooLong",
+  6007: "alreadyAnswered",
+  6008: "invalidMinRewardCount",
+  6009: "invalidMaxRewardCount",
+  6010: "unstakeNotReady",
+  6011: "insufficientStakeBalance",
 };
 
 function anchorErrorCode(err: any): string {
@@ -85,9 +92,8 @@ async function handleQuestGet(options: GlobalOptions) {
     return;
   }
 
-  const data = {
+  const data: Record<string, any> = {
     round: quest.round,
-    questionId: quest.questionId,
     question: quest.question,
     difficulty: quest.difficulty,
     rewardPerWinner: `${quest.rewardPerWinner} NARA`,
@@ -97,6 +103,8 @@ async function handleQuestGet(options: GlobalOptions) {
     deadline: new Date(quest.deadline * 1000).toLocaleString(),
     timeRemaining: formatTimeRemaining(quest.timeRemaining),
     expired: quest.expired,
+    stakeRequirement: `${quest.stakeRequirement} NARA`,
+    minWinnerStake: `${quest.minWinnerStake} NARA`,
   };
 
   if (options.json) {
@@ -111,6 +119,10 @@ async function handleQuestGet(options: GlobalOptions) {
     console.log(
       `  Reward slots: ${quest.winnerCount}/${quest.rewardCount} (${quest.remainingSlots} remaining)`
     );
+    if (quest.stakeRequirement > 0) {
+      console.log(`  Stake requirement: ${quest.stakeRequirement} NARA`);
+      console.log(`  Min winner stake: ${quest.minWinnerStake} NARA`);
+    }
     console.log(`  Deadline: ${new Date(quest.deadline * 1000).toLocaleString()}`);
     if (quest.timeRemaining > 0) {
       console.log(`  Time remaining: ${formatTimeRemaining(quest.timeRemaining)}`);
@@ -124,7 +136,7 @@ async function handleQuestGet(options: GlobalOptions) {
 // ─── Command: quest answer ───────────────────────────────────────
 async function handleQuestAnswer(
   answer: string,
-  options: GlobalOptions & { relay?: string; agent?: string; model?: string; referral?: string }
+  options: GlobalOptions & { relay?: string; agent?: string; model?: string; referral?: string; stake?: string }
 ) {
   const rpcUrl = getRpcUrl(options.rpcUrl);
   const connection = new Connection(rpcUrl, "confirmed");
@@ -210,7 +222,8 @@ async function handleQuestAnswer(
       if (configAgentId) {
         activityLog = { agentId: configAgentId, activity: "PoMI", model, log: "", referralAgentId: referral };
       }
-      const result = await submitAnswer(connection, wallet, proof.solana, agent, model, undefined, activityLog);
+      const stakeOpt = options.stake === "auto" ? "auto" : options.stake ? parseFloat(options.stake) : undefined;
+      const result = await submitAnswer(connection, wallet, proof.solana, agent, model, stakeOpt !== undefined ? { stake: stakeOpt } : undefined, activityLog);
       printSuccess("Answer submitted!");
       console.log(`  Transaction: ${result.signature}`);
       await handleReward(connection, result.signature, options);
@@ -220,6 +233,78 @@ async function handleQuestAnswer(
   }
 }
 
+// ─── Command: quest stake ────────────────────────────────────────
+async function handleQuestStake(amount: string, options: GlobalOptions) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  const connection = new Connection(rpcUrl, "confirmed");
+  const wallet = await loadWallet(options.wallet);
+
+  const n = parseFloat(amount);
+  if (isNaN(n) || n <= 0) {
+    printError("Amount must be a positive number");
+    process.exit(1);
+  }
+
+  if (!options.json) printInfo(`Staking ${n} NARA...`);
+  const signature = await questStake(connection, wallet, n);
+  if (!options.json) printSuccess(`Staked ${n} NARA!`);
+
+  if (options.json) {
+    formatOutput({ amount: n, signature }, true);
+  } else {
+    console.log(`  Transaction: ${signature}`);
+  }
+}
+
+// ─── Command: quest unstake ─────────────────────────────────────
+async function handleQuestUnstake(amount: string, options: GlobalOptions) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  const connection = new Connection(rpcUrl, "confirmed");
+  const wallet = await loadWallet(options.wallet);
+
+  const n = parseFloat(amount);
+  if (isNaN(n) || n <= 0) {
+    printError("Amount must be a positive number");
+    process.exit(1);
+  }
+
+  if (!options.json) printInfo(`Unstaking ${n} NARA...`);
+  const signature = await questUnstake(connection, wallet, n);
+  if (!options.json) printSuccess(`Unstaked ${n} NARA!`);
+
+  if (options.json) {
+    formatOutput({ amount: n, signature }, true);
+  } else {
+    console.log(`  Transaction: ${signature}`);
+  }
+}
+
+// ─── Command: quest stake-info ──────────────────────────────────
+async function handleQuestStakeInfo(options: GlobalOptions) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  const connection = new Connection(rpcUrl, "confirmed");
+  const wallet = await loadWallet(options.wallet);
+
+  const stakeInfo = await getStakeInfo(connection, wallet.publicKey);
+  if (!stakeInfo) {
+    if (options.json) {
+      formatOutput({ staked: false, amount: 0 }, true);
+    } else {
+      printInfo("No stake record found");
+    }
+    return;
+  }
+
+  if (options.json) {
+    formatOutput({ staked: true, amount: stakeInfo.amount, stakeRound: stakeInfo.stakeRound }, true);
+  } else {
+    console.log("");
+    console.log(`  Staked: ${stakeInfo.amount} NARA`);
+    console.log(`  Stake round: ${stakeInfo.stakeRound}`);
+    console.log("");
+  }
+}
+
 // ─── Parse reward from transaction ───────────────────────────────
 async function handleReward(
   connection: Connection,
@@ -280,6 +365,12 @@ function handleSubmitError(err: any) {
     case "poolNotActive":
       printError("No active quest at the moment");
       break;
+    case "unstakeNotReady":
+      printError("Cannot unstake until round advances or deadline passes");
+      break;
+    case "insufficientStakeBalance":
+      printError("Unstake amount exceeds staked balance");
+      break;
     default:
       printError(`Failed to submit answer: ${err.message ?? String(err)}`);
       if (err.logs) {
@@ -318,11 +409,55 @@ export function registerQuestCommands(program: Command): void {
     .option("--agent <name>", "Agent identifier (default: naracli)")
     .option("--model <name>", "Model identifier")
     .option("--referral <agent-id>", "Referral agent ID")
+    .option("--stake [amount]", 'Stake NARA before answering ("auto" to top-up to requirement, or a number)')
     .action(async (answer: string, opts: any, cmd: Command) => {
       try {
         const globalOpts = cmd.optsWithGlobals() as GlobalOptions;
         const relayUrl = opts.relay === true ? DEFAULT_QUEST_RELAY_URL : opts.relay;
-        await handleQuestAnswer(answer, { ...globalOpts, relay: relayUrl, agent: opts.agent, model: opts.model, referral: opts.referral });
+        const stakeVal = opts.stake === true ? "auto" : opts.stake;
+        await handleQuestAnswer(answer, { ...globalOpts, relay: relayUrl, agent: opts.agent, model: opts.model, referral: opts.referral, stake: stakeVal });
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // quest stake
+  quest
+    .command("stake <amount>")
+    .description("Stake NARA to participate in quests")
+    .action(async (amount: string, _opts: any, cmd: Command) => {
+      try {
+        const globalOpts = cmd.optsWithGlobals() as GlobalOptions;
+        await handleQuestStake(amount, globalOpts);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // quest unstake
+  quest
+    .command("unstake <amount>")
+    .description("Unstake NARA (available after round advances or deadline passes)")
+    .action(async (amount: string, _opts: any, cmd: Command) => {
+      try {
+        const globalOpts = cmd.optsWithGlobals() as GlobalOptions;
+        await handleQuestUnstake(amount, globalOpts);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // quest stake-info
+  quest
+    .command("stake-info")
+    .description("Get your current quest stake info")
+    .action(async (_opts: any, cmd: Command) => {
+      try {
+        const globalOpts = cmd.optsWithGlobals() as GlobalOptions;
+        await handleQuestStakeInfo(globalOpts);
       } catch (error: any) {
         printError(error.message);
         process.exit(1);

package/src/tests/helpers.ts

@@ -7,6 +7,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
+import type { Connection } from "@solana/web3.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CLI = join(__dirname, "../../bin/nara-cli.ts");
@@ -57,3 +58,22 @@ export const hasWallet = existsSync(join(homedir(), ".config", "nara", "id.json"
 export function uniqueName(prefix: string): string {
   return `${prefix}-${Date.now().toString(36)}`;
 }
+
+/**
+ * Poll for transaction confirmation (avoids WebSocket-based confirmTransaction
+ * which fails with TLS errors on some networks).
+ */
+export async function pollConfirmation(
+  connection: Connection,
+  signature: string,
+  maxRetries = 30,
+  intervalMs = 1000
+): Promise<void> {
+  for (let i = 0; i < maxRetries; i++) {
+    const { value } = await connection.getSignatureStatuses([signature]);
+    const status = value[0]?.confirmationStatus;
+    if (status === "confirmed" || status === "finalized") return;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  throw new Error(`Transaction ${signature} not confirmed after ${maxRetries}s`);
+}

package/src/tests/quest-referral.test.ts

@@ -22,7 +22,7 @@ import { fileURLToPath } from "node:url";
 import { Connection, Keypair, LAMPORTS_PER_SOL, SystemProgram, Transaction } from "@solana/web3.js";
 import bs58 from "bs58";
 import { DEFAULT_AGENT_REGISTRY_PROGRAM_ID, getQuestInfo, getAgentRecord } from "nara-sdk";
-import { runCli, hasWallet } from "./helpers.js";
+import { runCli, hasWallet, pollConfirmation } from "./helpers.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -80,7 +80,7 @@ describe("quest referral (on-chain)", { skip: !hasWallet ? "no PRIVATE_KEY" : un
     transferTx.recentBlockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
     transferTx.sign(mainWallet);
     const sig = await connection.sendRawTransaction(transferTx.serialize());
-    await connection.confirmTransaction(sig, "confirmed");
+    await pollConfirmation(connection, sig);
     console.log(`  Transfer tx: ${sig}`);
   });
 
@@ -106,9 +106,11 @@ describe("quest referral (on-chain)", { skip: !hasWallet ? "no PRIVATE_KEY" : un
     console.log("  Referral agent registered");
   });
 
-  it("registers main agent", async () => {
-    console.log(`  Registering main agent "${mainAgentId}"...`);
-    const { stdout, stderr, exitCode } = await runCli(["agent", "register", mainAgentId]);
+  it("registers main agent with referral", async () => {
+    console.log(`  Registering main agent "${mainAgentId}" with referral "${referralAgentId}"...`);
+    const { stdout, stderr, exitCode } = await runCli([
+      "agent", "register", mainAgentId, "--referral", referralAgentId,
+    ]);
     const output = stdout + stderr;
     if (output.includes("already") || output.includes("in use")) {
       console.log("  Agent already exists, continuing");
@@ -116,7 +118,7 @@ describe("quest referral (on-chain)", { skip: !hasWallet ? "no PRIVATE_KEY" : un
     }
     assert.equal(exitCode, 0, `Failed: ${stderr}`);
     assert.ok(output.includes("registered") || output.includes("Transaction"), "should confirm registration");
-    console.log("  Main agent registered");
+    console.log("  Main agent registered with referral");
   });
 
   it("answers quest with --referral", async () => {
@@ -162,7 +164,7 @@ describe("quest referral (on-chain)", { skip: !hasWallet ? "no PRIVATE_KEY" : un
     // Extract transaction signature
     const txMatch = output.match(/Transaction:\s+(\S+)/);
     assert.ok(txMatch, "should show transaction signature");
-    const txSig = txMatch![1];
+    const txSig = txMatch![1]!;
     console.log(`  Transaction: ${txSig}`);
 
     // Verify transaction succeeded on-chain
@@ -204,25 +206,16 @@ describe("quest referral (on-chain)", { skip: !hasWallet ? "no PRIVATE_KEY" : un
     console.log("  Answer submitted with referral successfully");
   });
 
-  it("verifies on-chain agent points", async () => {
+  it("verifies on-chain agent records", async () => {
     try {
       const mainRecord = await getAgentRecord(connection, mainAgentId);
-      console.log(`  Main agent points: ${mainRecord.points}`);
+      console.log(`  Main agent: ${mainRecord.agentId}, referral: ${mainRecord.referralId ?? "(none)"}`);
 
       const referralRecord = await getAgentRecord(connection, referralAgentId);
-      console.log(`  Referral agent points: ${referralRecord.points}`);
-
-      if (mainRecord.points > 0) {
-        console.log("  OK: Main agent earned points");
-      } else {
-        console.log("  WARN: Main agent has 0 points (quest may not have been answered in this run)");
-      }
-
-      if (referralRecord.points > 0) {
-        console.log("  OK: Referral agent earned referral points");
-      } else {
-        console.log("  WARN: Referral agent has 0 points");
-      }
+      console.log(`  Referral agent: ${referralRecord.agentId}`);
+
+      // Points are now minted as SPL tokens (Token-2022), not stored on AgentRecord
+      console.log("  OK: Both agent records exist on-chain");
     } catch (err: any) {
       console.log(`  (skipped: ${err.message})`);
     }

package/src/tests/quest.test.ts

@@ -94,7 +94,7 @@ describe("quest proof generation", () => {
 
     // Generate proof with a random pubkey (we're just testing proof generation)
     const testKeypair = Keypair.generate();
-    const proof = await generateProof(match.answer, quest.answerHash, testKeypair.publicKey);
+    const proof = await generateProof(match.answer, quest.answerHash, testKeypair.publicKey, quest.round);
 
     assert.ok(proof.solana.proofA.length > 0, "proofA should not be empty");
     assert.ok(proof.solana.proofB.length > 0, "proofB should not be empty");