naracli 0.1.0

package/src/pool.ts

@@ -0,0 +1,259 @@
+import {
+  Keypair,
+  PublicKey,
+  Transaction,
+  VersionedTransaction,
+} from "@solana/web3.js";
+import { NATIVE_MINT } from "@solana/spl-token";
+import BN from "bn.js";
+import { deriveDbcPoolAddress } from "@meteora-ag/dynamic-bonding-curve-sdk";
+import { NaraSDK } from "./client";
+
+export interface CreatePoolParams {
+  name: string;
+  symbol: string;
+  uri: string;
+  configAddress: string;
+  payer: PublicKey;
+  poolCreator: PublicKey;
+}
+
+export interface CreatePoolResult {
+  /** Pool address */
+  poolAddress: string;
+  /** Token address (baseMint) */
+  baseMint: string;
+  /** Unsigned transaction for pool creation (returns VersionedTransaction if ALT is configured) */
+  transaction: Transaction | VersionedTransaction;
+  /** baseMint keypair (requires signature) */
+  baseMintKeypair: Keypair;
+}
+
+export interface CreatePoolWithFirstBuyParams extends CreatePoolParams {
+  /** Initial buy amount in SOL */
+  initialBuyAmountSOL: number;
+  /** Buyer (defaults to payer) */
+  buyer?: PublicKey;
+  /** Token receiver (defaults to buyer) */
+  receiver?: PublicKey;
+  /** Slippage in basis points (default 100 = 1%) */
+  slippageBps?: number;
+}
+
+export interface CreatePoolWithFirstBuyResult {
+  /** Pool address */
+  poolAddress: string;
+  /** Token address (baseMint) */
+  baseMint: string;
+  /** Pool creation transaction (returns VersionedTransaction if ALT is configured) */
+  createPoolTx: Transaction | VersionedTransaction;
+  /** First buy transaction (returns VersionedTransaction if ALT is configured) */
+  firstBuyTx: Transaction | VersionedTransaction;
+  /** baseMint keypair (requires signature) */
+  baseMintKeypair: Keypair;
+  /** Buy information */
+  buyInfo: {
+    amountIn: string;
+    minimumAmountOut: string;
+  };
+}
+
+/**
+ * Create token pool transaction (returns unsigned transaction)
+ *
+ * Note: If you want to make an initial buy, wait for this transaction to confirm
+ * before using the buyToken() function
+ *
+ * @param sdk NaraSDK SDK instance
+ * @param params Pool parameters
+ * @returns Pool address, token address, unsigned transaction, and baseMint keypair
+ */
+export async function createPool(
+  sdk: NaraSDK,
+  params: CreatePoolParams
+): Promise<CreatePoolResult> {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+
+  const baseMint = Keypair.generate();
+  const configPubkey = new PublicKey(params.configAddress);
+
+  // Create pool transaction
+  const createPoolTx = await client.pool.createPool({
+    baseMint: baseMint.publicKey,
+    config: configPubkey,
+    name: params.name,
+    symbol: params.symbol,
+    uri: params.uri,
+    payer: params.payer,
+    poolCreator: params.poolCreator,
+  });
+
+  // Get latest blockhash
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  createPoolTx.recentBlockhash = blockhash;
+  createPoolTx.feePayer = params.payer;
+
+  // Derive pool address
+  const poolPubkey = deriveDbcPoolAddress(
+    NATIVE_MINT,
+    baseMint.publicKey,
+    configPubkey
+  );
+
+  // Compile transaction with ALT if configured
+  const compiledTx = await sdk.compileTransactionWithALT(
+    createPoolTx,
+    params.payer
+  );
+
+  return {
+    poolAddress: poolPubkey.toBase58(),
+    baseMint: baseMint.publicKey.toBase58(),
+    transaction: compiledTx,
+    baseMintKeypair: baseMint,
+  };
+}
+
+/**
+ * Create token pool and perform first buy (one-step completion)
+ *
+ * Uses SDK's createPoolWithFirstBuy method to complete creation and buy in one transaction
+ *
+ * @param sdk NaraSDK SDK instance
+ * @param params Pool and buy parameters
+ * @returns Pool address, token address, unsigned transactions, and baseMint keypair
+ */
+export async function createPoolWithFirstBuy(
+  sdk: NaraSDK,
+  params: CreatePoolWithFirstBuyParams
+): Promise<CreatePoolWithFirstBuyResult> {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+
+  const baseMint = Keypair.generate();
+  const configPubkey = new PublicKey(params.configAddress);
+  const buyer = params.buyer ?? params.payer;
+  const receiver = params.receiver ?? buyer;
+
+  // Calculate buy amount
+  const buyAmount = new BN(params.initialBuyAmountSOL * 1e9); // SOL to lamports
+  const slippageBps = params.slippageBps ?? 100;
+
+  // For first buy, use conservative minimumAmountOut
+  // Set to 0 since this is the first buy with optimal price
+  const minimumAmountOut = new BN(0);
+
+  // Use SDK's createPoolWithFirstBuy method
+  const result = await client.pool.createPoolWithFirstBuy({
+    createPoolParam: {
+      baseMint: baseMint.publicKey,
+      config: configPubkey,
+      name: params.name,
+      symbol: params.symbol,
+      uri: params.uri,
+      payer: params.payer,
+      poolCreator: params.poolCreator,
+    },
+    firstBuyParam: {
+      buyer,
+      receiver,
+      buyAmount,
+      minimumAmountOut,
+      referralTokenAccount: null,
+    },
+  });
+
+  // Get latest blockhash
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+
+  // Combine two transactions into one
+  const combinedTx = new Transaction();
+
+  // Add pool creation instructions
+  combinedTx.add(...result.createPoolTx.instructions);
+
+  // If first buy transaction exists, add buy instructions
+  if (result.swapBuyTx) {
+    combinedTx.add(...result.swapBuyTx.instructions);
+  }
+
+  // Set transaction metadata
+  combinedTx.recentBlockhash = blockhash;
+  combinedTx.feePayer = params.payer;
+
+  // Derive pool address
+  const poolPubkey = deriveDbcPoolAddress(
+    NATIVE_MINT,
+    baseMint.publicKey,
+    configPubkey
+  );
+
+  // Compile transaction with ALT if configured
+  const compiledTx = await sdk.compileTransactionWithALT(
+    combinedTx,
+    params.payer
+  );
+
+  return {
+    poolAddress: poolPubkey.toBase58(),
+    baseMint: baseMint.publicKey.toBase58(),
+    createPoolTx: compiledTx, // Return combined transaction
+    firstBuyTx: compiledTx, // Same as createPoolTx since they are combined
+    baseMintKeypair: baseMint,
+    buyInfo: {
+      amountIn: buyAmount.toString(),
+      minimumAmountOut: minimumAmountOut.toString(),
+    },
+  };
+}
+
+/**
+ * Get pool information
+ * @param sdk NaraSDK SDK instance
+ * @param tokenAddress Token address (baseMint)
+ * @returns Pool information
+ */
+export async function getPoolInfo(sdk: NaraSDK, tokenAddress: string) {
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey(tokenAddress);
+
+  // Get pool by token (baseMint) address
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${tokenAddress}`);
+  }
+
+  return {
+    ...poolAccount.account,
+    poolAddress: poolAccount.publicKey.toBase58(),
+  };
+}
+
+/**
+ * Get pool curve progress
+ * @param sdk NaraSDK SDK instance
+ * @param tokenAddress Token address (baseMint)
+ * @returns Curve progress information
+ */
+export async function getPoolProgress(sdk: NaraSDK, tokenAddress: string) {
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey(tokenAddress);
+
+  // Get pool by token (baseMint) address
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${tokenAddress}`);
+  }
+
+  const progress = await client.state.getPoolCurveProgress(
+    poolAccount.publicKey
+  );
+  const pool = poolAccount.account;
+
+  return {
+    progress,
+    quoteReserve: pool.quoteReserve?.toString() ?? "0",
+    isMigrated: pool.isMigrated ?? false,
+  };
+}

package/src/quest.ts

@@ -0,0 +1,379 @@
+/**
+ * Quest SDK - interact with nara-quest on-chain quiz
+ */
+
+import {
+  Connection,
+  Keypair,
+  LAMPORTS_PER_SOL,
+  PublicKey,
+} from "@solana/web3.js";
+import * as anchor from "@coral-xyz/anchor";
+import { Program, AnchorProvider, Wallet } from "@coral-xyz/anchor";
+import type { NaraQuest } from "./cli/quest/nara_quest_types";
+
+import { createRequire } from "module";
+const _require = createRequire(import.meta.url);
+
+// ─── ZK constants ────────────────────────────────────────────────
+const BN254_FIELD =
+  21888242871839275222246405745257275088696311157297823662689037894645226208583n;
+
+import { fileURLToPath } from "url";
+import { dirname, join, resolve } from "path";
+import { existsSync } from "fs";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function findZkFile(name: string): string {
+  // 1. src/cli/zk/ (dev mode, running from src/)
+  const srcPath = join(__dirname, "cli/zk", name);
+  if (existsSync(srcPath)) return srcPath;
+  // 2. dist/zk/ (published, running from dist/)
+  const distPath = join(__dirname, "zk", name);
+  if (existsSync(distPath)) return distPath;
+  // 3. Fallback to src path (will error at runtime if missing)
+  return srcPath;
+}
+
+const DEFAULT_CIRCUIT_WASM = findZkFile("answer_proof.wasm");
+const DEFAULT_ZKEY = findZkFile("answer_proof_final.zkey");
+
+// ─── Types ───────────────────────────────────────────────────────
+
+export interface QuestInfo {
+  active: boolean;
+  round: string;
+  questionId: string;
+  question: string;
+  answerHash: number[];
+  rewardPerWinner: number;
+  totalReward: number;
+  rewardCount: number;
+  winnerCount: number;
+  remainingSlots: number;
+  deadline: number;
+  timeRemaining: number;
+  expired: boolean;
+}
+
+export interface ZkProof {
+  proofA: number[];
+  proofB: number[];
+  proofC: number[];
+}
+
+export interface ZkProofHex {
+  proofA: string;
+  proofB: string;
+  proofC: string;
+}
+
+export interface SubmitAnswerResult {
+  signature: string;
+}
+
+export interface SubmitRelayResult {
+  txHash: string;
+}
+
+export interface QuestProveOptions {
+  circuitWasmPath?: string;
+  zkeyPath?: string;
+}
+
+// ─── ZK utilities ────────────────────────────────────────────────
+
+function toBigEndian32(v: bigint): Buffer {
+  return Buffer.from(v.toString(16).padStart(64, "0"), "hex");
+}
+
+function answerToField(answer: string): bigint {
+  return (
+    BigInt("0x" + Buffer.from(answer, "utf-8").toString("hex")) % BN254_FIELD
+  );
+}
+
+function hashBytesToFieldStr(hashBytes: number[]): string {
+  return BigInt("0x" + Buffer.from(hashBytes).toString("hex")).toString();
+}
+
+function pubkeyToCircuitInputs(pubkey: PublicKey): {
+  lo: string;
+  hi: string;
+} {
+  const bytes = pubkey.toBuffer();
+  return {
+    lo: BigInt("0x" + bytes.subarray(16, 32).toString("hex")).toString(),
+    hi: BigInt("0x" + bytes.subarray(0, 16).toString("hex")).toString(),
+  };
+}
+
+function proofToSolana(proof: any): ZkProof {
+  const negY = (y: string) => toBigEndian32(BN254_FIELD - BigInt(y));
+  const be = (s: string) => toBigEndian32(BigInt(s));
+  return {
+    proofA: Array.from(
+      Buffer.concat([be(proof.pi_a[0]), negY(proof.pi_a[1])])
+    ),
+    proofB: Array.from(
+      Buffer.concat([
+        be(proof.pi_b[0][1]),
+        be(proof.pi_b[0][0]),
+        be(proof.pi_b[1][1]),
+        be(proof.pi_b[1][0]),
+      ])
+    ),
+    proofC: Array.from(
+      Buffer.concat([be(proof.pi_c[0]), be(proof.pi_c[1])])
+    ),
+  };
+}
+
+function proofToHex(proof: any): ZkProofHex {
+  const negY = (y: string) => toBigEndian32(BN254_FIELD - BigInt(y));
+  const be = (s: string) => toBigEndian32(BigInt(s));
+  return {
+    proofA: Buffer.concat([be(proof.pi_a[0]), negY(proof.pi_a[1])]).toString("hex"),
+    proofB: Buffer.concat([
+      be(proof.pi_b[0][1]),
+      be(proof.pi_b[0][0]),
+      be(proof.pi_b[1][1]),
+      be(proof.pi_b[1][0]),
+    ]).toString("hex"),
+    proofC: Buffer.concat([be(proof.pi_c[0]), be(proof.pi_c[1])]).toString("hex"),
+  };
+}
+
+// Suppress console output from snarkjs WASM during proof generation.
+async function silentProve(snarkjs: any, input: Record<string, string>, wasmPath: string, zkeyPath: string) {
+  const savedLog = console.log;
+  const savedError = console.error;
+  console.log = () => {};
+  console.error = () => {};
+  try {
+    return await snarkjs.groth16.fullProve(input, wasmPath, zkeyPath, null, null, { singleThread: true });
+  } finally {
+    console.log = savedLog;
+    console.error = savedError;
+  }
+}
+
+// ─── Anchor helpers ──────────────────────────────────────────────
+
+function createProgram(
+  connection: Connection,
+  wallet: Keypair
+): Program<NaraQuest> {
+  const idlPath = existsSync(join(__dirname, "cli/quest/nara_quest.json"))
+    ? "./cli/quest/nara_quest.json"
+    : "./quest/nara_quest.json";
+  const idl = _require(idlPath);
+  const provider = new AnchorProvider(
+    connection,
+    new Wallet(wallet),
+    { commitment: "confirmed" }
+  );
+  anchor.setProvider(provider);
+  return new Program<NaraQuest>(idl as any, provider);
+}
+
+function getPoolPda(programId: PublicKey): PublicKey {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("pool")],
+    programId
+  );
+  return pda;
+}
+
+function getWinnerRecordPda(
+  programId: PublicKey,
+  user: PublicKey
+): PublicKey {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("winner"), user.toBuffer()],
+    programId
+  );
+  return pda;
+}
+
+// ─── SDK functions ───────────────────────────────────────────────
+
+/**
+ * Get the current active quest info
+ */
+export async function getQuestInfo(
+  connection: Connection,
+  wallet?: Keypair
+): Promise<QuestInfo> {
+  const kp = wallet ?? Keypair.generate();
+  const program = createProgram(connection, kp);
+  const poolPda = getPoolPda(program.programId);
+  const pool = await program.account.pool.fetch(poolPda);
+
+  const now = Math.floor(Date.now() / 1000);
+  const deadline = pool.deadline.toNumber();
+  const secsLeft = deadline - now;
+
+  return {
+    active: pool.isActive,
+    round: pool.round.toString(),
+    questionId: pool.questionId.toString(),
+    question: pool.question,
+    answerHash: Array.from(pool.answerHash),
+    rewardPerWinner: pool.rewardPerWinner.toNumber() / LAMPORTS_PER_SOL,
+    totalReward: pool.rewardAmount.toNumber() / LAMPORTS_PER_SOL,
+    rewardCount: pool.rewardCount,
+    winnerCount: pool.winnerCount,
+    remainingSlots: Math.max(0, pool.rewardCount - pool.winnerCount),
+    deadline,
+    timeRemaining: secsLeft,
+    expired: secsLeft <= 0,
+  };
+}
+
+/**
+ * Check if the user has already answered the current round
+ */
+export async function hasAnswered(
+  connection: Connection,
+  wallet: Keypair
+): Promise<boolean> {
+  const program = createProgram(connection, wallet);
+  const quest = await getQuestInfo(connection, wallet);
+  const winnerPda = getWinnerRecordPda(program.programId, wallet.publicKey);
+  try {
+    const wr = await program.account.winnerRecord.fetch(winnerPda);
+    return wr.round.toString() === quest.round;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Generate a ZK proof for a quest answer.
+ * Throws if the answer is wrong (circuit assertion fails).
+ */
+export async function generateProof(
+  answer: string,
+  answerHash: number[],
+  userPubkey: PublicKey,
+  options?: QuestProveOptions
+): Promise<{ solana: ZkProof; hex: ZkProofHex }> {
+  const wasmPath = options?.circuitWasmPath ?? process.env.QUEST_CIRCUIT_WASM ?? DEFAULT_CIRCUIT_WASM;
+  const zkeyPath = options?.zkeyPath ?? process.env.QUEST_ZKEY ?? DEFAULT_ZKEY;
+
+  const snarkjs = await import("snarkjs");
+  const answerHashFieldStr = hashBytesToFieldStr(answerHash);
+  const { lo, hi } = pubkeyToCircuitInputs(userPubkey);
+
+  const result = await silentProve(
+    snarkjs,
+    {
+      answer: answerToField(answer).toString(),
+      answer_hash: answerHashFieldStr,
+      pubkey_lo: lo,
+      pubkey_hi: hi,
+    },
+    wasmPath,
+    zkeyPath
+  );
+
+  return {
+    solana: proofToSolana(result.proof),
+    hex: proofToHex(result.proof),
+  };
+}
+
+/**
+ * Submit a quest answer on-chain (direct submission, requires gas)
+ */
+export async function submitAnswer(
+  connection: Connection,
+  wallet: Keypair,
+  proof: ZkProof
+): Promise<SubmitAnswerResult> {
+  const program = createProgram(connection, wallet);
+  const signature = await program.methods
+    .submitAnswer(proof.proofA as any, proof.proofB as any, proof.proofC as any)
+    .accounts({ user: wallet.publicKey, payer: wallet.publicKey })
+    .signers([wallet])
+    .rpc({ skipPreflight: true });
+
+  return { signature };
+}
+
+/**
+ * Submit a quest answer via relay (gasless submission)
+ */
+export async function submitAnswerViaRelay(
+  relayUrl: string,
+  userPubkey: PublicKey,
+  proof: ZkProofHex
+): Promise<SubmitRelayResult> {
+  const base = relayUrl.replace(/\/+$/, "");
+  const res = await fetch(`${base}/submit-answer`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      user: userPubkey.toBase58(),
+      proofA: proof.proofA,
+      proofB: proof.proofB,
+      proofC: proof.proofC,
+    }),
+  });
+
+  const data = (await res.json()) as any;
+  if (!res.ok) {
+    throw new Error(`Relay submission failed: ${data.error ?? `HTTP ${res.status}`}`);
+  }
+
+  return { txHash: data.txHash };
+}
+
+/**
+ * Parse reward info from a quest transaction's log messages
+ */
+export async function parseQuestReward(
+  connection: Connection,
+  txSignature: string,
+  retries = 10
+): Promise<{ rewarded: boolean; rewardLamports: number; rewardNso: number; winner: string }> {
+  await new Promise((r) => setTimeout(r, 2000));
+
+  let txInfo: any;
+  for (let i = 0; i < retries; i++) {
+    try {
+      txInfo = await connection.getTransaction(txSignature, {
+        commitment: "confirmed",
+        maxSupportedTransactionVersion: 0,
+      });
+      if (txInfo) break;
+    } catch {
+      // retry
+    }
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+
+  if (!txInfo) {
+    throw new Error("Failed to fetch transaction details");
+  }
+
+  let rewardLamports = 0;
+  let winner = "";
+  const logs: string[] = txInfo.meta?.logMessages ?? [];
+  for (const log of logs) {
+    const m = log.match(/reward (\d+) lamports \(winner (\d+\/\d+)\)/);
+    if (m) {
+      rewardLamports = parseInt(m[1]!);
+      winner = m[2]!;
+      break;
+    }
+  }
+
+  return {
+    rewarded: rewardLamports > 0,
+    rewardLamports,
+    rewardNso: rewardLamports / LAMPORTS_PER_SOL,
+    winner,
+  };
+}