naracli 0.1.0

package/src/cli/commands/pool.ts

@@ -0,0 +1,364 @@
+/**
+ * Pool commands
+ */
+
+import { Command } from "commander";
+import { NaraSDK } from "../../client";
+import { DEFAULT_DBC_CONFIG_ADDRESS } from "../../constants";
+import {
+  createPool,
+  createPoolWithFirstBuy,
+  getPoolInfo,
+  getPoolProgress,
+} from "../../pool";
+import { loadWallet, getRpcUrl } from "../utils/wallet";
+import {
+  validatePublicKey,
+  validateRequired,
+  validatePositiveNumber,
+  validateNonNegativeNumber,
+} from "../utils/validation";
+import {
+  handleTransaction,
+  printTransactionResult,
+} from "../utils/transaction";
+import { formatOutput, printError, printInfo } from "../utils/output";
+import type {
+  PoolCreateOptions,
+  PoolCreateWithBuyOptions,
+  PoolInfoOptions,
+} from "../types";
+
+/**
+ * Register pool commands
+ * @param program Commander program
+ */
+export function registerPoolCommands(program: Command): void {
+  const pool = program.command("pool").description("Pool management commands");
+
+  // pool create
+  pool
+    .command("create")
+    .description("Create a new token pool")
+    .requiredOption("-n, --name <string>", "Token name")
+    .requiredOption("-s, --symbol <string>", "Token symbol")
+    .requiredOption("-u, --uri <string>", "Metadata URI")
+    .requiredOption(
+      "--dbc-config <address>",
+      "DBC config address (or set DBC_CONFIG_ADDRESS env)"
+    )
+    .option("--creator <address>", "Pool creator address")
+    .option("-e, --export-tx", "Export unsigned transaction", false)
+    .action(async (options: PoolCreateOptions) => {
+      try {
+        await handlePoolCreate(options);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // pool create-with-buy
+  pool
+    .command("create-with-buy")
+    .description("Create a new token pool with initial buy")
+    .requiredOption("-n, --name <string>", "Token name")
+    .requiredOption("-s, --symbol <string>", "Token symbol")
+    .requiredOption("-u, --uri <string>", "Metadata URI")
+    .requiredOption(
+      "--dbc-config <address>",
+      "DBC config address (or set DBC_CONFIG_ADDRESS env)"
+    )
+    .requiredOption("--amount <number>", "Initial buy amount in NSO")
+    .option("--creator <address>", "Pool creator address")
+    .option("--buyer <address>", "Buyer address")
+    .option("--receiver <address>", "Token receiver address")
+    .option("--slippage <number>", "Slippage in basis points", "100")
+    .option("-e, --export-tx", "Export unsigned transaction", false)
+    .action(async (options: PoolCreateWithBuyOptions) => {
+      try {
+        await handlePoolCreateWithBuy(options);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // pool info
+  pool
+    .command("info <token-address>")
+    .description("Get pool information")
+    .action(async (tokenAddress: string, options: PoolInfoOptions) => {
+      try {
+        await handlePoolInfo(tokenAddress, options);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // pool progress
+  pool
+    .command("progress <token-address>")
+    .description("Get bonding curve progress")
+    .action(async (tokenAddress: string, options: PoolInfoOptions) => {
+      try {
+        await handlePoolProgress(tokenAddress, options);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * Handle pool create command
+ * @param options Command options
+ */
+async function handlePoolCreate(options: PoolCreateOptions): Promise<void> {
+  // Load wallet
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Wallet: ${wallet.publicKey.toBase58()}`);
+
+  // Initialize SDK
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed",
+  });
+
+  // Get config address from option or env
+  const configAddress =
+    options.dbcConfig || DEFAULT_DBC_CONFIG_ADDRESS;
+  if (!configAddress) {
+    throw new Error(
+      "DBC config address is required. Use --dbc-config flag or set DBC_CONFIG_ADDRESS environment variable."
+    );
+  }
+
+  // Parse addresses
+  const configPubkey = validatePublicKey(configAddress);
+  const creator = options.creator
+    ? validatePublicKey(options.creator)
+    : wallet.publicKey;
+
+  printInfo("Creating token pool...");
+
+  // Create pool
+  const result = await createPool(sdk, {
+    name: options.name,
+    symbol: options.symbol,
+    uri: options.uri,
+    configAddress,
+    payer: wallet.publicKey,
+    poolCreator: creator,
+  });
+
+  printInfo(`Pool address: ${result.poolAddress}`);
+  printInfo(`Token address: ${result.baseMint}`);
+
+  // Handle transaction
+  const txResult = await handleTransaction(
+    sdk,
+    result.transaction,
+    [wallet, result.baseMintKeypair], // Both wallet and baseMint keypair need to sign
+    options.exportTx || false
+  );
+
+  // Output result
+  if (options.json) {
+    const output = {
+      poolAddress: result.poolAddress,
+      tokenAddress: result.baseMint,
+      ...(txResult.signature && { signature: txResult.signature }),
+      ...(txResult.base64 && { transaction: txResult.base64 }),
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`\nPool Address: ${result.poolAddress}`);
+    console.log(`Token Address: ${result.baseMint}`);
+    printTransactionResult(txResult, false);
+
+    if (txResult.signature) {
+      printInfo("\nSave this token address for buying/selling:");
+      console.log(`export TOKEN_ADDRESS="${result.baseMint}"`);
+    }
+  }
+}
+
+/**
+ * Handle pool create-with-buy command
+ * @param options Command options
+ */
+async function handlePoolCreateWithBuy(
+  options: PoolCreateWithBuyOptions
+): Promise<void> {
+  // Load wallet
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Wallet: ${wallet.publicKey.toBase58()}`);
+
+  // Initialize SDK
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed",
+  });
+
+  // Get config address from option or env
+  const configAddress =
+    options.dbcConfig || DEFAULT_DBC_CONFIG_ADDRESS;
+  if (!configAddress) {
+    throw new Error(
+      "DBC config address is required. Use --dbc-config flag or set DBC_CONFIG_ADDRESS environment variable."
+    );
+  }
+
+  // Parse addresses
+  const configPubkey = validatePublicKey(configAddress);
+  const creator = options.creator
+    ? validatePublicKey(options.creator)
+    : wallet.publicKey;
+  const buyer = options.buyer
+    ? validatePublicKey(options.buyer)
+    : wallet.publicKey;
+  const receiver = options.receiver
+    ? validatePublicKey(options.receiver)
+    : buyer;
+
+  // Parse numbers
+  const amount = validatePositiveNumber(options.amount, "amount");
+  const slippage = validateNonNegativeNumber(
+    options.slippage || "100",
+    "slippage"
+  );
+
+  printInfo("Creating token pool with initial buy...");
+  printInfo(`Initial buy amount: ${amount} NSO`);
+
+  // Create pool with first buy
+  const result = await createPoolWithFirstBuy(sdk, {
+    name: options.name,
+    symbol: options.symbol,
+    uri: options.uri,
+    configAddress,
+    payer: wallet.publicKey,
+    poolCreator: creator,
+    initialBuyAmountSOL: amount,
+    buyer,
+    receiver,
+    slippageBps: slippage,
+  });
+
+  printInfo(`Pool address: ${result.poolAddress}`);
+  printInfo(`Token address: ${result.baseMint}`);
+
+  // Handle transaction
+  const txResult = await handleTransaction(
+    sdk,
+    result.createPoolTx,
+    [wallet, result.baseMintKeypair], // Both wallet and baseMint keypair need to sign
+    options.exportTx || false
+  );
+
+  // Output result
+  if (options.json) {
+    const output = {
+      poolAddress: result.poolAddress,
+      tokenAddress: result.baseMint,
+      buyInfo: result.buyInfo,
+      ...(txResult.signature && { signature: txResult.signature }),
+      ...(txResult.base64 && { transaction: txResult.base64 }),
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`\nPool Address: ${result.poolAddress}`);
+    console.log(`Token Address: ${result.baseMint}`);
+    console.log(`\nBuy Info:`);
+    console.log(`  Amount In: ${(parseInt(result.buyInfo.amountIn) / 1e9).toFixed(4)} NSO`);
+    console.log(`  Minimum Out: ${result.buyInfo.minimumAmountOut} tokens (smallest unit)`);
+    printTransactionResult(txResult, false);
+
+    if (txResult.signature) {
+      printInfo("\nSave this token address for buying/selling:");
+      console.log(`export TOKEN_ADDRESS="${result.baseMint}"`);
+    }
+  }
+}
+
+/**
+ * Handle pool info command
+ * @param tokenAddress Token address
+ * @param options Command options
+ */
+async function handlePoolInfo(
+  tokenAddress: string,
+  options: PoolInfoOptions
+): Promise<void> {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+
+  printInfo(`Using RPC: ${rpcUrl}`);
+
+  // Validate address
+  validatePublicKey(tokenAddress);
+
+  // Initialize SDK
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed",
+  });
+
+  printInfo("Fetching pool information...");
+
+  // Get pool info
+  const poolInfo = await getPoolInfo(sdk, tokenAddress);
+
+  // Output result
+  formatOutput(poolInfo, options.json || false);
+}
+
+/**
+ * Handle pool progress command
+ * @param tokenAddress Token address
+ * @param options Command options
+ */
+async function handlePoolProgress(
+  tokenAddress: string,
+  options: PoolInfoOptions
+): Promise<void> {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+
+  printInfo(`Using RPC: ${rpcUrl}`);
+
+  // Validate address
+  validatePublicKey(tokenAddress);
+
+  // Initialize SDK
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed",
+  });
+
+  printInfo("Fetching bonding curve progress...");
+
+  // Get pool progress
+  const progress = await getPoolProgress(sdk, tokenAddress);
+
+  // Format progress as percentage for human-readable output
+  const output = {
+    progress: `${(progress.progress * 100).toFixed(2)}%`,
+    progressRaw: progress.progress,
+    quoteReserve: progress.quoteReserve,
+    isMigrated: progress.isMigrated,
+  };
+
+  // Output result
+  if (options.json) {
+    console.log(JSON.stringify(progress, null, 2));
+  } else {
+    formatOutput(output, false);
+  }
+}

package/src/cli/commands/quest.ts

@@ -0,0 +1,312 @@
+/**
+ * Quest commands - interact with nara-quest on-chain quiz
+ */
+
+import { Command } from "commander";
+import { Connection, Keypair } from "@solana/web3.js";
+import { loadWallet, getRpcUrl } from "../utils/wallet";
+import {
+  formatOutput,
+  printError,
+  printInfo,
+  printSuccess,
+  printWarning,
+} from "../utils/output";
+import type { GlobalOptions } from "../types";
+import { DEFAULT_QUEST_RELAY_URL } from "../../constants";
+import {
+  getQuestInfo,
+  hasAnswered,
+  generateProof,
+  submitAnswer,
+  submitAnswerViaRelay,
+  parseQuestReward,
+} from "../../quest";
+
+// ─── Anchor error parsing ────────────────────────────────────────
+const QUEST_ERRORS: Record<number, string> = {
+  6000: "unauthorized",
+  6001: "poolNotActive",
+  6002: "deadlineExpired",
+  6003: "invalidProof",
+  6004: "invalidDeadline",
+  6005: "insufficientReward",
+  6006: "insufficientPoolBalance",
+  6007: "questionTooLong",
+  6008: "alreadyAnswered",
+};
+
+function anchorErrorCode(err: any): string {
+  const code = err?.error?.errorCode?.code;
+  if (code) return code;
+  const raw = err?.message ?? JSON.stringify(err) ?? "";
+  const m = raw.match(/"Custom":(\d+)/);
+  if (m) return QUEST_ERRORS[parseInt(m[1])] ?? "";
+  return "";
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────
+function formatTimeRemaining(seconds: number): string {
+  if (seconds <= 0) return "expired";
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  if (m > 0) return `${m}m ${s}s`;
+  return `${s}s`;
+}
+
+// ─── Command: quest get ──────────────────────────────────────────
+async function handleQuestGet(options: GlobalOptions) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  const connection = new Connection(rpcUrl, "confirmed");
+
+  let wallet: Keypair;
+  try {
+    wallet = await loadWallet(options.wallet);
+  } catch {
+    wallet = Keypair.generate();
+  }
+
+  let quest;
+  try {
+    quest = await getQuestInfo(connection, wallet);
+  } catch (err: any) {
+    printError(`Failed to fetch quest info: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (!quest.active) {
+    printWarning("No active quest at the moment");
+    if (options.json) {
+      formatOutput({ active: false }, true);
+    }
+    return;
+  }
+
+  const data = {
+    round: quest.round,
+    questionId: quest.questionId,
+    question: quest.question,
+    rewardPerWinner: `${quest.rewardPerWinner} NSO`,
+    totalReward: `${quest.totalReward} NSO`,
+    rewardSlots: `${quest.winnerCount}/${quest.rewardCount}`,
+    remainingRewardSlots: quest.remainingSlots,
+    deadline: new Date(quest.deadline * 1000).toLocaleString(),
+    timeRemaining: formatTimeRemaining(quest.timeRemaining),
+    expired: quest.expired,
+  };
+
+  if (options.json) {
+    formatOutput(data, true);
+  } else {
+    console.log("");
+    console.log(`  Question: ${quest.question}`);
+    console.log(`  Round: #${quest.round}`);
+    console.log(`  Reward per winner: ${quest.rewardPerWinner} NSO`);
+    console.log(`  Total reward: ${quest.totalReward} NSO`);
+    console.log(
+      `  Reward slots: ${quest.winnerCount}/${quest.rewardCount} (${quest.remainingSlots} remaining)`
+    );
+    console.log(`  Deadline: ${new Date(quest.deadline * 1000).toLocaleString()}`);
+    if (quest.timeRemaining > 0) {
+      console.log(`  Time remaining: ${formatTimeRemaining(quest.timeRemaining)}`);
+    } else {
+      printWarning("Quest has expired");
+    }
+    console.log("");
+  }
+}
+
+// ─── Command: quest answer ───────────────────────────────────────
+async function handleQuestAnswer(
+  answer: string,
+  options: GlobalOptions & { relay?: string }
+) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  const connection = new Connection(rpcUrl, "confirmed");
+  const wallet = await loadWallet(options.wallet);
+
+  // 1. Fetch quest info
+  let quest;
+  try {
+    quest = await getQuestInfo(connection, wallet);
+  } catch (err: any) {
+    printError(`Failed to fetch quest info: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (!quest.active) {
+    printError("No active quest at the moment");
+    process.exit(1);
+  }
+
+  if (quest.expired) {
+    printError("Quest has expired");
+    process.exit(1);
+  }
+
+  // 2. Check if already answered this round
+  const alreadyAnswered = await hasAnswered(connection, wallet);
+  if (alreadyAnswered) {
+    printWarning("You have already answered this round");
+    process.exit(0);
+  }
+
+  // 3. Generate ZK proof
+  printInfo("Generating ZK proof...");
+
+  let proof;
+  try {
+    proof = await generateProof(answer, quest.answerHash, wallet.publicKey);
+  } catch (err: any) {
+    if (err.message?.includes("Assert Failed")) {
+      printError("Wrong answer");
+    } else {
+      printError(`ZK proof generation failed: ${err.message}`);
+    }
+    process.exit(1);
+  }
+
+  // 4. Check deadline again after proof generation
+  const nowAfterProof = Math.floor(Date.now() / 1000);
+  if (nowAfterProof >= quest.deadline) {
+    printError("Quest expired during proof generation");
+    process.exit(1);
+  }
+
+  // 5. Submit answer
+  if (options.relay) {
+    // Relay (gasless) submission
+    printInfo("Submitting answer via relay...");
+    try {
+      const relayResult = await submitAnswerViaRelay(
+        options.relay,
+        wallet.publicKey,
+        proof.hex
+      );
+      printSuccess("Answer submitted via relay!");
+      console.log(`  Transaction: ${relayResult.txHash}`);
+      await handleReward(connection, relayResult.txHash, options);
+    } catch (err: any) {
+      printError(`Relay submission failed: ${err.message}`);
+      process.exit(1);
+    }
+  } else {
+    // Direct on-chain submission
+    printInfo("Submitting answer...");
+    try {
+      const result = await submitAnswer(connection, wallet, proof.solana);
+      printSuccess("Answer submitted!");
+      console.log(`  Transaction: ${result.signature}`);
+      await handleReward(connection, result.signature, options);
+    } catch (err: any) {
+      handleSubmitError(err);
+    }
+  }
+}
+
+// ─── Parse reward from transaction ───────────────────────────────
+async function handleReward(
+  connection: Connection,
+  txSignature: string,
+  options: GlobalOptions
+) {
+  printInfo("Fetching transaction details...");
+
+  let reward;
+  try {
+    reward = await parseQuestReward(connection, txSignature);
+  } catch {
+    printWarning("Failed to fetch transaction details. Please check manually later.");
+    console.log(
+      `  https://solscan.io/tx/${txSignature}?cluster=devnet`
+    );
+    return;
+  }
+
+  if (reward.rewarded) {
+    printSuccess(`Congratulations! Reward received: ${reward.rewardNso} NSO (winner ${reward.winner})`);
+    if (options.json) {
+      formatOutput(
+        {
+          signature: txSignature,
+          rewarded: true,
+          rewardLamports: reward.rewardLamports,
+          rewardNso: reward.rewardNso,
+          winner: reward.winner,
+        },
+        true
+      );
+    }
+  } else {
+    printWarning("Correct answer, but no reward — all reward slots have been claimed");
+    if (options.json) {
+      formatOutput(
+        { signature: txSignature, rewarded: false, rewardLamports: 0 },
+        true
+      );
+    }
+  }
+}
+
+// ─── Error handling ──────────────────────────────────────────────
+function handleSubmitError(err: any) {
+  const errCode = anchorErrorCode(err);
+  switch (errCode) {
+    case "alreadyAnswered":
+      printWarning("You have already answered this round");
+      break;
+    case "deadlineExpired":
+      printError("Quest has expired");
+      break;
+    case "invalidProof":
+      printError("Wrong answer (ZK proof verification failed)");
+      break;
+    case "poolNotActive":
+      printError("No active quest at the moment");
+      break;
+    default:
+      printError(`Failed to submit answer: ${err.message ?? String(err)}`);
+      if (err.logs) {
+        console.log("  Logs:");
+        err.logs.slice(-5).forEach((l: string) => console.log(`    ${l}`));
+      }
+  }
+  process.exit(1);
+}
+
+// ─── Register commands ───────────────────────────────────────────
+export function registerQuestCommands(program: Command): void {
+  const quest = program
+    .command("quest")
+    .description("Quest commands");
+
+  // quest get
+  quest
+    .command("get")
+    .description("Get current quest info")
+    .action(async (_opts: any, cmd: Command) => {
+      try {
+        const globalOpts = cmd.optsWithGlobals() as GlobalOptions;
+        await handleQuestGet(globalOpts);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // quest answer
+  quest
+    .command("answer <answer>")
+    .description("Submit an answer")
+    .option("--relay [url]", `Submit via relay service, gasless (default: ${DEFAULT_QUEST_RELAY_URL})`)
+    .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 });
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+}