naracli 0.1.0

package/dist/nara-cli.mjs

@@ -0,0 +1,2631 @@
+#!/usr/bin/env node
+
+// bin/nara-cli.ts
+import { Command as Command8 } from "commander";
+
+// src/cli/index.ts
+import "commander";
+
+// src/cli/commands/config.ts
+import "commander";
+
+// src/client.ts
+import {
+  Connection,
+  PublicKey,
+  MessageV0,
+  VersionedTransaction
+} from "@solana/web3.js";
+import { DynamicBondingCurveClient } from "@meteora-ag/dynamic-bonding-curve-sdk";
+var NaraSDK = class {
+  connection;
+  client;
+  addressLookupTableAddresses;
+  constructor(config) {
+    this.connection = new Connection(
+      config.rpcUrl,
+      config.commitment || "confirmed"
+    );
+    this.client = new DynamicBondingCurveClient(
+      this.connection,
+      config.commitment || "confirmed"
+    );
+    this.addressLookupTableAddresses = (config.addressLookupTableAddresses || []).map((addr) => new PublicKey(addr));
+  }
+  getConnection() {
+    return this.connection;
+  }
+  getClient() {
+    return this.client;
+  }
+  getAddressLookupTableAddresses() {
+    return this.addressLookupTableAddresses;
+  }
+  /**
+   * Compile transaction with Address Lookup Tables
+   * Converts Transaction to VersionedTransaction if ALT is configured
+   * @param transaction Original transaction
+   * @param feePayer Fee payer public key
+   * @returns VersionedTransaction or original Transaction
+   */
+  async compileTransactionWithALT(transaction, feePayer) {
+    if (this.addressLookupTableAddresses.length === 0) {
+      return transaction;
+    }
+    const lookupTableAccounts = [];
+    for (const address of this.addressLookupTableAddresses) {
+      const accountInfo = await this.connection.getAddressLookupTable(address);
+      if (accountInfo.value) {
+        lookupTableAccounts.push(accountInfo.value);
+      }
+    }
+    if (lookupTableAccounts.length === 0) {
+      return transaction;
+    }
+    const { blockhash } = await this.connection.getLatestBlockhash(
+      this.connection.commitment
+    );
+    const messageV0 = MessageV0.compile({
+      payerKey: feePayer,
+      instructions: transaction.instructions,
+      recentBlockhash: blockhash,
+      addressLookupTableAccounts: lookupTableAccounts
+    });
+    return new VersionedTransaction(messageV0);
+  }
+};
+
+// src/config.ts
+import { Keypair } from "@solana/web3.js";
+import {
+  buildCurveWithMarketCap,
+  ActivationType,
+  CollectFeeMode,
+  BaseFeeMode,
+  MigrationFeeOption,
+  MigrationOption,
+  TokenDecimal,
+  TokenType,
+  TokenUpdateAuthorityOption
+} from "@meteora-ag/dynamic-bonding-curve-sdk";
+import { NATIVE_MINT } from "@solana/spl-token";
+async function createConfig(sdk, options) {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+  const config = Keypair.generate();
+  const curveConfig = buildCurveWithMarketCap({
+    totalTokenSupply: options.totalTokenSupply ?? 1e9,
+    // Total token supply
+    initialMarketCap: options.initialMarketCap ?? 30,
+    // Initial market cap
+    migrationMarketCap: options.migrationMarketCap ?? 540,
+    // Migration market cap threshold
+    migrationOption: MigrationOption.MET_DAMM_V2,
+    // Migration option: use Meteora DAMM V2
+    tokenBaseDecimal: TokenDecimal.SIX,
+    // Base token decimals: 6
+    tokenQuoteDecimal: TokenDecimal.NINE,
+    // Quote token decimals: 9 (SOL)
+    // Locked vesting parameters
+    lockedVestingParams: {
+      totalLockedVestingAmount: 0,
+      // Total locked vesting amount
+      numberOfVestingPeriod: 0,
+      // Number of vesting periods
+      cliffUnlockAmount: 0,
+      // Cliff unlock amount
+      totalVestingDuration: 0,
+      // Total vesting duration
+      cliffDurationFromMigrationTime: 0
+      // Cliff duration from migration time
+    },
+    // Base fee parameters
+    baseFeeParams: {
+      baseFeeMode: BaseFeeMode.FeeSchedulerLinear,
+      // Fee mode: linear scheduler
+      feeSchedulerParam: {
+        startingFeeBps: 100,
+        // Starting fee (basis points): 1%
+        endingFeeBps: 100,
+        // Ending fee (basis points): 1%
+        numberOfPeriod: 0,
+        // Number of periods
+        totalDuration: 0
+        // Total duration
+      }
+    },
+    dynamicFeeEnabled: true,
+    // Enable dynamic fees
+    activationType: ActivationType.Slot,
+    // Activation type: slot-based
+    collectFeeMode: CollectFeeMode.QuoteToken,
+    // Fee collection mode: quote token
+    migrationFeeOption: MigrationFeeOption.FixedBps25,
+    // Migration fee option: fixed 1%
+    tokenType: TokenType.SPL,
+    // Token type: SPL token
+    partnerLiquidityPercentage: 0,
+    // Partner liquidity percentage
+    creatorLiquidityPercentage: 0,
+    // Creator liquidity percentage
+    partnerPermanentLockedLiquidityPercentage: 100,
+    // Partner permanent locked liquidity: 100%
+    creatorPermanentLockedLiquidityPercentage: 0,
+    // Creator permanent locked liquidity: 0%
+    creatorTradingFeePercentage: 0,
+    // Creator trading fee percentage: 0%
+    leftover: 0,
+    // Leftover token amount
+    tokenUpdateAuthority: TokenUpdateAuthorityOption.Immutable,
+    // Token update authority: immutable
+    // Migration fee
+    migrationFee: {
+      feePercentage: 0,
+      // Fee percentage
+      creatorFeePercentage: 0
+      // Creator fee percentage
+    },
+    poolCreationFee: 0.1,
+    // Pool creation fee
+    enableFirstSwapWithMinFee: true
+    // Enable first swap with minimum fee
+  });
+  const transaction = await client.partner.createConfig({
+    config: config.publicKey,
+    // Config public key
+    feeClaimer: options.feeClaimer,
+    // Fee claimer
+    leftoverReceiver: options.leftoverReceiver,
+    // Leftover receiver
+    payer: options.payer,
+    // Payer
+    quoteMint: NATIVE_MINT,
+    // Quote mint: native SOL
+    ...curveConfig
+    // Curve config parameters
+  });
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  transaction.recentBlockhash = blockhash;
+  transaction.feePayer = options.payer;
+  transaction.partialSign(config);
+  return {
+    configAddress: config.publicKey.toBase58(),
+    // Config address
+    transaction,
+    // Unsigned transaction (already has config's partial signature)
+    configKeypair: config
+    // Config keypair
+  };
+}
+
+// src/cli/utils/wallet.ts
+import { Keypair as Keypair2 } from "@solana/web3.js";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// src/constants.ts
+var DEFAULT_RPC_URL = process.env.RPC_URL || "https://mainnet-api.nara.build/";
+var DEFAULT_DBC_CONFIG_ADDRESS = process.env.DBC_CONFIG_ADDRESS || "";
+var DEFAULT_WALLET_PATH = process.env.WALLET_PATH || "~/.config/nara/id.json";
+var DEFAULT_QUEST_RELAY_URL = process.env.QUEST_RELAY_URL || "https://quest-api.nara.build/";
+
+// src/cli/utils/wallet.ts
+var DEFAULT_WALLET_PATH2 = DEFAULT_WALLET_PATH.startsWith("~") ? join(homedir(), DEFAULT_WALLET_PATH.slice(1)) : DEFAULT_WALLET_PATH;
+async function loadWallet(walletPath) {
+  const path = walletPath || DEFAULT_WALLET_PATH2;
+  try {
+    const fs = await import("node:fs/promises");
+    const file = await fs.readFile(path, "utf-8");
+    const data = JSON.parse(file);
+    if (Array.isArray(data)) {
+      return Keypair2.fromSecretKey(new Uint8Array(data));
+    } else if (data.secretKey) {
+      return Keypair2.fromSecretKey(new Uint8Array(data.secretKey));
+    } else {
+      throw new Error(
+        "Invalid wallet file format. Expected array or object with secretKey field."
+      );
+    }
+  } catch (error) {
+    if (!walletPath) {
+      throw new Error(
+        `Wallet not found. Please create a wallet at ${DEFAULT_WALLET_PATH2} or use --wallet flag to specify a different path.`
+      );
+    } else {
+      throw new Error(`Failed to load wallet from ${path}: ${error.message}`);
+    }
+  }
+}
+function getRpcUrl(rpcUrl) {
+  return rpcUrl || DEFAULT_RPC_URL;
+}
+
+// src/cli/utils/validation.ts
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+function validatePublicKey(address) {
+  try {
+    return new PublicKey3(address);
+  } catch (error) {
+    throw new Error(`Invalid Solana address: ${address}`);
+  }
+}
+function validatePositiveNumber(value, name) {
+  const num = typeof value === "string" ? parseFloat(value) : value;
+  if (isNaN(num)) {
+    throw new Error(`${name} must be a valid number`);
+  }
+  if (num <= 0) {
+    throw new Error(`${name} must be greater than 0`);
+  }
+  return num;
+}
+function validateNonNegativeNumber(value, name) {
+  const num = typeof value === "string" ? parseFloat(value) : value;
+  if (isNaN(num)) {
+    throw new Error(`${name} must be a valid number`);
+  }
+  if (num < 0) {
+    throw new Error(`${name} must be non-negative`);
+  }
+  return num;
+}
+function validateSwapMode(mode) {
+  const validModes = ["exact-in", "partial-fill", "exact-out"];
+  const normalized = mode.toLowerCase();
+  if (!validModes.includes(normalized)) {
+    throw new Error(
+      `Invalid swap mode: ${mode}. Must be one of: ${validModes.join(", ")}`
+    );
+  }
+  return normalized;
+}
+function validateDirection(direction) {
+  const validDirections = ["buy", "sell"];
+  const normalized = direction.toLowerCase();
+  if (!validDirections.includes(normalized)) {
+    throw new Error(
+      `Invalid direction: ${direction}. Must be one of: ${validDirections.join(
+        ", "
+      )}`
+    );
+  }
+  return normalized;
+}
+
+// src/cli/utils/transaction.ts
+import {
+  sendAndConfirmTransaction,
+  VersionedTransaction as VersionedTransaction2
+} from "@solana/web3.js";
+
+// src/cli/utils/output.ts
+function formatOutput(data, jsonMode = false) {
+  if (jsonMode) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    formatHumanReadable(data);
+  }
+}
+function formatHumanReadable(data) {
+  if (typeof data === "object" && data !== null) {
+    for (const [key, value] of Object.entries(data)) {
+      const label = formatLabel(key);
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        console.log(`
+${label}:`);
+        formatHumanReadable(value);
+      } else {
+        console.log(`${label}: ${formatValue(value)}`);
+      }
+    }
+  } else {
+    console.log(data);
+  }
+}
+function formatLabel(key) {
+  const words = key.replace(/([A-Z])/g, " $1").trim();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return "N/A";
+  }
+  if (typeof value === "boolean") {
+    return value ? "Yes" : "No";
+  }
+  if (typeof value === "number") {
+    if (value >= 1e3) {
+      return value.toLocaleString();
+    }
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.join(", ");
+  }
+  return value.toString();
+}
+function printSuccess(message) {
+  console.log(`\u2705 ${message}`);
+}
+function printError(message) {
+  console.error(`\u274C Error: ${message}`);
+}
+function printInfo(message) {
+  console.log(`\u2139\uFE0F  ${message}`);
+}
+function printWarning(message) {
+  console.log(`\u26A0\uFE0F  ${message}`);
+}
+
+// src/cli/utils/transaction.ts
+async function handleTransaction(sdk, transaction, signers, exportMode = false) {
+  if (exportMode) {
+    return exportTransaction(transaction);
+  }
+  return await signAndSendTransaction(sdk, transaction, signers);
+}
+function exportTransaction(transaction) {
+  try {
+    const serialized = transaction.serialize({
+      requireAllSignatures: false,
+      verifySignatures: false
+    });
+    const base64 = Buffer.from(serialized).toString("base64");
+    return { base64 };
+  } catch (error) {
+    throw new Error(`Failed to serialize transaction: ${error.message}`);
+  }
+}
+async function signAndSendTransaction(sdk, transaction, signers) {
+  const connection = sdk.getConnection();
+  try {
+    printInfo("Signing transaction...");
+    let signature;
+    if (transaction instanceof VersionedTransaction2) {
+      transaction.sign(signers);
+      printInfo("Sending transaction...");
+      signature = await connection.sendTransaction(transaction, {
+        maxRetries: 3
+      });
+      printInfo("Confirming transaction...");
+      await connection.confirmTransaction(signature, "confirmed");
+    } else {
+      printInfo("Sending transaction...");
+      signature = await sendAndConfirmTransaction(
+        connection,
+        transaction,
+        signers,
+        {
+          commitment: "confirmed",
+          skipPreflight: true
+        }
+      );
+    }
+    return { signature };
+  } catch (error) {
+    throw new Error(`Transaction failed: ${error.message}`);
+  }
+}
+function printTransactionResult(result, jsonMode = false) {
+  if (result.signature) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ signature: result.signature }, null, 2));
+    } else {
+      printSuccess("Transaction successful!");
+      console.log(`Signature: ${result.signature}`);
+      console.log(
+        `View on Solscan: https://solscan.io/tx/${result.signature}?cluster=devnet`
+      );
+    }
+  } else if (result.base64) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ transaction: result.base64 }, null, 2));
+    } else {
+      printSuccess("Transaction exported!");
+      console.log(`
+Base64 transaction:
+${result.base64}`);
+    }
+  }
+}
+
+// src/cli/commands/config.ts
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("Configuration management commands");
+  config.command("create").description("Create a bonding curve configuration").option("--fee-claimer <address>", "Fee claimer wallet address").option(
+    "--leftover-receiver <address>",
+    "Leftover token receiver wallet address"
+  ).option(
+    "--total-supply <number>",
+    "Total token supply",
+    "1000000000"
+  ).option("--initial-mcap <number>", "Initial market cap", "30").option("--migration-mcap <number>", "Migration market cap", "540").option("-e, --export-tx", "Export unsigned transaction", false).action(async (options) => {
+    try {
+      await handleConfigCreate(options);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+}
+async function handleConfigCreate(options) {
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Wallet: ${wallet.publicKey.toBase58()}`);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  const feeClaimer = options.feeClaimer ? validatePublicKey(options.feeClaimer) : wallet.publicKey;
+  const leftoverReceiver = options.leftoverReceiver ? validatePublicKey(options.leftoverReceiver) : wallet.publicKey;
+  const totalTokenSupply = parseInt(String(options.totalSupply || "1000000000"));
+  const initialMarketCap = parseFloat(String(options.initialMcap || "30"));
+  const migrationMarketCap = parseFloat(String(options.migrationMcap || "540"));
+  printInfo("Creating bonding curve configuration...");
+  const result = await createConfig(sdk, {
+    feeClaimer,
+    leftoverReceiver,
+    payer: wallet.publicKey,
+    totalTokenSupply,
+    initialMarketCap,
+    migrationMarketCap
+  });
+  printInfo(`Config address: ${result.configAddress}`);
+  const txResult = await handleTransaction(
+    sdk,
+    result.transaction,
+    [wallet, result.configKeypair],
+    // Both wallet and config keypair need to sign
+    options.exportTx || false
+  );
+  if (options.json) {
+    const output = {
+      configAddress: result.configAddress,
+      ...txResult.signature && { signature: txResult.signature },
+      ...txResult.base64 && { transaction: txResult.base64 }
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+Config Address: ${result.configAddress}`);
+    printTransactionResult(txResult, false);
+    if (txResult.signature) {
+      printInfo("\nSave this DBC config address for creating pools:");
+      console.log(`export DBC_CONFIG_ADDRESS="${result.configAddress}"`);
+    }
+  }
+}
+
+// src/cli/commands/pool.ts
+import "commander";
+
+// src/pool.ts
+import {
+  Keypair as Keypair4,
+  PublicKey as PublicKey4,
+  Transaction as Transaction4
+} from "@solana/web3.js";
+import { NATIVE_MINT as NATIVE_MINT2 } from "@solana/spl-token";
+import BN from "bn.js";
+import { deriveDbcPoolAddress } from "@meteora-ag/dynamic-bonding-curve-sdk";
+async function createPool(sdk, params) {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+  const baseMint = Keypair4.generate();
+  const configPubkey = new PublicKey4(params.configAddress);
+  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
+  });
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  createPoolTx.recentBlockhash = blockhash;
+  createPoolTx.feePayer = params.payer;
+  const poolPubkey = deriveDbcPoolAddress(
+    NATIVE_MINT2,
+    baseMint.publicKey,
+    configPubkey
+  );
+  const compiledTx = await sdk.compileTransactionWithALT(
+    createPoolTx,
+    params.payer
+  );
+  return {
+    poolAddress: poolPubkey.toBase58(),
+    baseMint: baseMint.publicKey.toBase58(),
+    transaction: compiledTx,
+    baseMintKeypair: baseMint
+  };
+}
+async function createPoolWithFirstBuy(sdk, params) {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+  const baseMint = Keypair4.generate();
+  const configPubkey = new PublicKey4(params.configAddress);
+  const buyer = params.buyer ?? params.payer;
+  const receiver = params.receiver ?? buyer;
+  const buyAmount = new BN(params.initialBuyAmountSOL * 1e9);
+  const slippageBps = params.slippageBps ?? 100;
+  const minimumAmountOut = new BN(0);
+  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
+    }
+  });
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  const combinedTx = new Transaction4();
+  combinedTx.add(...result.createPoolTx.instructions);
+  if (result.swapBuyTx) {
+    combinedTx.add(...result.swapBuyTx.instructions);
+  }
+  combinedTx.recentBlockhash = blockhash;
+  combinedTx.feePayer = params.payer;
+  const poolPubkey = deriveDbcPoolAddress(
+    NATIVE_MINT2,
+    baseMint.publicKey,
+    configPubkey
+  );
+  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()
+    }
+  };
+}
+async function getPoolInfo(sdk, tokenAddress) {
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey4(tokenAddress);
+  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()
+  };
+}
+async function getPoolProgress(sdk, tokenAddress) {
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey4(tokenAddress);
+  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
+  };
+}
+
+// src/cli/commands/pool.ts
+function registerPoolCommands(program2) {
+  const pool = program2.command("pool").description("Pool management commands");
+  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) => {
+    try {
+      await handlePoolCreate(options);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+  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) => {
+    try {
+      await handlePoolCreateWithBuy(options);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+  pool.command("info <token-address>").description("Get pool information").action(async (tokenAddress, options) => {
+    try {
+      await handlePoolInfo(tokenAddress, options);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+  pool.command("progress <token-address>").description("Get bonding curve progress").action(async (tokenAddress, options) => {
+    try {
+      await handlePoolProgress(tokenAddress, options);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+}
+async function handlePoolCreate(options) {
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Wallet: ${wallet.publicKey.toBase58()}`);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  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."
+    );
+  }
+  const configPubkey = validatePublicKey(configAddress);
+  const creator = options.creator ? validatePublicKey(options.creator) : wallet.publicKey;
+  printInfo("Creating token 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}`);
+  const txResult = await handleTransaction(
+    sdk,
+    result.transaction,
+    [wallet, result.baseMintKeypair],
+    // Both wallet and baseMint keypair need to sign
+    options.exportTx || false
+  );
+  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(`
+Pool 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}"`);
+    }
+  }
+}
+async function handlePoolCreateWithBuy(options) {
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Wallet: ${wallet.publicKey.toBase58()}`);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  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."
+    );
+  }
+  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;
+  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`);
+  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}`);
+  const txResult = await handleTransaction(
+    sdk,
+    result.createPoolTx,
+    [wallet, result.baseMintKeypair],
+    // Both wallet and baseMint keypair need to sign
+    options.exportTx || false
+  );
+  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(`
+Pool Address: ${result.poolAddress}`);
+    console.log(`Token Address: ${result.baseMint}`);
+    console.log(`
+Buy 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}"`);
+    }
+  }
+}
+async function handlePoolInfo(tokenAddress, options) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  validatePublicKey(tokenAddress);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  printInfo("Fetching pool information...");
+  const poolInfo = await getPoolInfo(sdk, tokenAddress);
+  formatOutput(poolInfo, options.json || false);
+}
+async function handlePoolProgress(tokenAddress, options) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  validatePublicKey(tokenAddress);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  printInfo("Fetching bonding curve progress...");
+  const progress = await getPoolProgress(sdk, tokenAddress);
+  const output = {
+    progress: `${(progress.progress * 100).toFixed(2)}%`,
+    progressRaw: progress.progress,
+    quoteReserve: progress.quoteReserve,
+    isMigrated: progress.isMigrated
+  };
+  if (options.json) {
+    console.log(JSON.stringify(progress, null, 2));
+  } else {
+    formatOutput(output, false);
+  }
+}
+
+// src/cli/commands/swap.ts
+import "commander";
+import BN3 from "bn.js";
+
+// src/swap.ts
+import { PublicKey as PublicKey5 } from "@solana/web3.js";
+import BN2 from "bn.js";
+import {
+  deriveDammV2PoolAddress,
+  DAMM_V2_MIGRATION_FEE_ADDRESS
+} from "@meteora-ag/dynamic-bonding-curve-sdk";
+import { NATIVE_MINT as NATIVE_MINT3, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import {
+  CpAmm,
+  SwapMode as CpAmmSwapMode,
+  getCurrentPoint
+} from "@meteora-ag/cp-amm-sdk";
+async function checkPoolMigration(sdk, tokenAddress) {
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey5(tokenAddress);
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${tokenAddress}`);
+  }
+  if (poolAccount.account.isMigrated) {
+    const virtualPool = poolAccount.account;
+    const poolConfig = await client.state.getPoolConfig(virtualPool.config);
+    const migrationFeeOption = poolConfig.migrationFeeOption || 0;
+    const dammConfig = DAMM_V2_MIGRATION_FEE_ADDRESS[migrationFeeOption];
+    if (!dammConfig) {
+      throw new Error(
+        `Invalid migration fee option: ${migrationFeeOption}. Cannot determine DAMM V2 config address.`
+      );
+    }
+    const dammV2Pool = deriveDammV2PoolAddress(
+      dammConfig,
+      NATIVE_MINT3,
+      // tokenA = SOL
+      tokenPubkey
+      // tokenB = token
+    );
+    const connection = sdk.getConnection();
+    const poolAccountInfo = await connection.getAccountInfo(dammV2Pool);
+    if (!poolAccountInfo) {
+      return { isMigrated: false };
+    }
+    return {
+      isMigrated: true,
+      dammV2Pool,
+      dammConfig
+    };
+  }
+  return { isMigrated: false };
+}
+async function getSwapQuote(sdk, tokenAddress, amountIn, swapBaseForQuote, slippageBps = 100) {
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey5(tokenAddress);
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${tokenAddress}`);
+  }
+  const virtualPool = poolAccount.account;
+  const poolConfig = await client.state.getPoolConfig(virtualPool.config);
+  const quote = client.pool.swapQuote({
+    virtualPool,
+    config: poolConfig,
+    swapBaseForQuote,
+    amountIn,
+    slippageBps,
+    hasReferral: false,
+    eligibleForFirstSwapWithMinFee: false,
+    currentPoint: new BN2(0)
+  });
+  const quoteResult = quote;
+  return {
+    amountIn: amountIn.toString(),
+    outputAmount: quoteResult.outputAmount.toString(),
+    minimumAmountOut: quote.minimumAmountOut.toString(),
+    nextSqrtPrice: quoteResult.nextSqrtPrice.toString(),
+    tradingFee: quoteResult.tradingFee.toString(),
+    protocolFee: quoteResult.protocolFee.toString(),
+    referralFee: quoteResult.referralFee.toString()
+  };
+}
+async function buyToken(sdk, params) {
+  const client = sdk.getClient();
+  const connection = sdk.getConnection();
+  const tokenPubkey = new PublicKey5(params.tokenAddress);
+  const amountIn = new BN2(params.amountInSOL * 1e9);
+  const slippageBps = params.slippageBps ?? 100;
+  const swapMode = params.swapMode ?? 1 /* PartialFill */;
+  const migrationInfo = await checkPoolMigration(sdk, params.tokenAddress);
+  if (migrationInfo.isMigrated && migrationInfo.dammV2Pool) {
+    console.log("\u{1F680} Pool launched to DAMM V2, using CP-AMM for swap");
+    const cpAmm = new CpAmm(connection);
+    const poolState = await cpAmm.fetchPoolState(migrationInfo.dammV2Pool);
+    const currentPoint = await getCurrentPoint(
+      connection,
+      poolState.activationType
+    );
+    const isAToB = poolState.tokenAMint.equals(NATIVE_MINT3);
+    const inputTokenMint = isAToB ? poolState.tokenAMint : poolState.tokenBMint;
+    const cpAmmSwapMode = swapMode === 1 /* PartialFill */ ? CpAmmSwapMode.PartialFill : swapMode === 2 /* ExactOut */ ? CpAmmSwapMode.ExactOut : CpAmmSwapMode.ExactIn;
+    const quoteBaseParams = {
+      inputTokenMint,
+      slippage: slippageBps / 1e4,
+      currentPoint,
+      poolState,
+      tokenADecimal: 9,
+      // SOL decimals
+      tokenBDecimal: 6,
+      // Token decimals (assumed)
+      hasReferral: false
+    };
+    let quote2;
+    if (cpAmmSwapMode === CpAmmSwapMode.ExactOut) {
+      quote2 = cpAmm.getQuote2({
+        ...quoteBaseParams,
+        swapMode: cpAmmSwapMode,
+        amountOut: amountIn
+        // ExactOut: desired output amount
+      });
+    } else {
+      quote2 = cpAmm.getQuote2({
+        ...quoteBaseParams,
+        swapMode: cpAmmSwapMode,
+        amountIn
+      });
+    }
+    const swapBaseParams = {
+      payer: params.owner,
+      pool: migrationInfo.dammV2Pool,
+      inputTokenMint,
+      outputTokenMint: isAToB ? poolState.tokenBMint : poolState.tokenAMint,
+      tokenAMint: poolState.tokenAMint,
+      tokenBMint: poolState.tokenBMint,
+      tokenAVault: poolState.tokenAVault,
+      tokenBVault: poolState.tokenBVault,
+      tokenAProgram: TOKEN_PROGRAM_ID,
+      tokenBProgram: TOKEN_PROGRAM_ID,
+      referralTokenAccount: null,
+      poolState
+    };
+    let transaction2;
+    if (cpAmmSwapMode === CpAmmSwapMode.ExactOut) {
+      transaction2 = await cpAmm.swap2({
+        ...swapBaseParams,
+        swapMode: cpAmmSwapMode,
+        amountOut: amountIn,
+        maximumAmountIn: quote2.maxSwapInAmount || amountIn.muln(2)
+        // 2x as max
+      });
+    } else {
+      transaction2 = await cpAmm.swap2({
+        ...swapBaseParams,
+        swapMode: cpAmmSwapMode,
+        amountIn,
+        minimumAmountOut: quote2.minSwapOutAmount || new BN2(0)
+      });
+    }
+    const compiledTx2 = await sdk.compileTransactionWithALT(
+      transaction2,
+      params.owner
+    );
+    return {
+      transaction: compiledTx2,
+      amountIn: quote2.swapInAmount?.toString() || amountIn.toString(),
+      expectedAmountOut: quote2.swapOutAmount?.toString() || "0",
+      minimumAmountOut: quote2.minSwapOutAmount?.toString() || "0"
+    };
+  }
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${params.tokenAddress}`);
+  }
+  let quote;
+  try {
+    quote = await getSwapQuote(
+      sdk,
+      params.tokenAddress,
+      amountIn,
+      false,
+      slippageBps
+    );
+  } catch (err) {
+    if (swapMode === 1 /* PartialFill */ && err.message?.includes("Insufficient Liquidity")) {
+      console.warn("\u26A0\uFE0F  Insufficient liquidity, using PartialFill mode to accept any available amount");
+      quote = {
+        amountIn: amountIn.toString(),
+        outputAmount: "0",
+        minimumAmountOut: "0",
+        nextSqrtPrice: "0",
+        tradingFee: "0",
+        protocolFee: "0",
+        referralFee: "0"
+      };
+    } else {
+      throw err;
+    }
+  }
+  let transaction;
+  if (swapMode === 1 /* PartialFill */) {
+    transaction = await client.pool.swap2({
+      owner: params.owner,
+      pool: poolAccount.publicKey,
+      swapBaseForQuote: false,
+      referralTokenAccount: null,
+      swapMode: 1 /* PartialFill */,
+      amountIn,
+      minimumAmountOut: new BN2(quote.minimumAmountOut)
+    });
+  } else if (swapMode === 2 /* ExactOut */) {
+    transaction = await client.pool.swap2({
+      owner: params.owner,
+      pool: poolAccount.publicKey,
+      swapBaseForQuote: false,
+      referralTokenAccount: null,
+      swapMode: 2 /* ExactOut */,
+      amountOut: new BN2(quote.outputAmount),
+      maximumAmountIn: amountIn
+    });
+  } else {
+    transaction = await client.pool.swap2({
+      owner: params.owner,
+      pool: poolAccount.publicKey,
+      swapBaseForQuote: false,
+      referralTokenAccount: null,
+      swapMode: 0 /* ExactIn */,
+      amountIn,
+      minimumAmountOut: new BN2(quote.minimumAmountOut)
+    });
+  }
+  const compiledTx = await sdk.compileTransactionWithALT(
+    transaction,
+    params.owner
+  );
+  return {
+    transaction: compiledTx,
+    amountIn: amountIn.toString(),
+    expectedAmountOut: quote.outputAmount,
+    minimumAmountOut: quote.minimumAmountOut
+  };
+}
+async function sellToken(sdk, params) {
+  const client = sdk.getClient();
+  const connection = sdk.getConnection();
+  const tokenPubkey = new PublicKey5(params.tokenAddress);
+  const tokenDecimals = params.tokenDecimals ?? 6;
+  const amountIn = new BN2(params.amountInToken * 10 ** tokenDecimals);
+  const slippageBps = params.slippageBps ?? 100;
+  const swapMode = params.swapMode ?? 1 /* PartialFill */;
+  const migrationInfo = await checkPoolMigration(sdk, params.tokenAddress);
+  if (migrationInfo.isMigrated && migrationInfo.dammV2Pool) {
+    console.log("\u{1F680} Pool launched to DAMM V2, using CP-AMM for swap");
+    const cpAmm = new CpAmm(connection);
+    const poolState = await cpAmm.fetchPoolState(migrationInfo.dammV2Pool);
+    const currentPoint = await getCurrentPoint(
+      connection,
+      poolState.activationType
+    );
+    const isAToB = poolState.tokenAMint.equals(tokenPubkey);
+    const inputTokenMint = isAToB ? poolState.tokenAMint : poolState.tokenBMint;
+    const cpAmmSwapMode = swapMode === 1 /* PartialFill */ ? CpAmmSwapMode.PartialFill : swapMode === 2 /* ExactOut */ ? CpAmmSwapMode.ExactOut : CpAmmSwapMode.ExactIn;
+    const quoteBaseParams = {
+      inputTokenMint,
+      slippage: slippageBps / 1e4,
+      currentPoint,
+      poolState,
+      tokenADecimal: 9,
+      // SOL decimals
+      tokenBDecimal: tokenDecimals,
+      hasReferral: false
+    };
+    let quote2;
+    if (cpAmmSwapMode === CpAmmSwapMode.ExactOut) {
+      quote2 = cpAmm.getQuote2({
+        ...quoteBaseParams,
+        swapMode: cpAmmSwapMode,
+        amountOut: amountIn
+        // ExactOut: desired output amount
+      });
+    } else {
+      quote2 = cpAmm.getQuote2({
+        ...quoteBaseParams,
+        swapMode: cpAmmSwapMode,
+        amountIn
+      });
+    }
+    const swapBaseParams = {
+      payer: params.owner,
+      pool: migrationInfo.dammV2Pool,
+      inputTokenMint,
+      outputTokenMint: isAToB ? poolState.tokenBMint : poolState.tokenAMint,
+      tokenAMint: poolState.tokenAMint,
+      tokenBMint: poolState.tokenBMint,
+      tokenAVault: poolState.tokenAVault,
+      tokenBVault: poolState.tokenBVault,
+      tokenAProgram: TOKEN_PROGRAM_ID,
+      tokenBProgram: TOKEN_PROGRAM_ID,
+      referralTokenAccount: null,
+      poolState
+    };
+    let transaction2;
+    if (cpAmmSwapMode === CpAmmSwapMode.ExactOut) {
+      transaction2 = await cpAmm.swap2({
+        ...swapBaseParams,
+        swapMode: cpAmmSwapMode,
+        amountOut: amountIn,
+        maximumAmountIn: quote2.maxSwapInAmount || amountIn.muln(2)
+      });
+    } else {
+      transaction2 = await cpAmm.swap2({
+        ...swapBaseParams,
+        swapMode: cpAmmSwapMode,
+        amountIn,
+        minimumAmountOut: quote2.minSwapOutAmount || new BN2(0)
+      });
+    }
+    const compiledTx2 = await sdk.compileTransactionWithALT(
+      transaction2,
+      params.owner
+    );
+    return {
+      transaction: compiledTx2,
+      amountIn: quote2.swapInAmount?.toString() || amountIn.toString(),
+      expectedAmountOut: quote2.swapOutAmount?.toString() || "0",
+      minimumAmountOut: quote2.minSwapOutAmount?.toString() || "0"
+    };
+  }
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${params.tokenAddress}`);
+  }
+  let quote;
+  try {
+    quote = await getSwapQuote(
+      sdk,
+      params.tokenAddress,
+      amountIn,
+      true,
+      slippageBps
+    );
+  } catch (err) {
+    if (swapMode === 1 /* PartialFill */ && err.message?.includes("Insufficient Liquidity")) {
+      console.warn("\u26A0\uFE0F  Insufficient liquidity, using PartialFill mode to accept any available amount");
+      quote = {
+        amountIn: amountIn.toString(),
+        outputAmount: "0",
+        minimumAmountOut: "0",
+        nextSqrtPrice: "0",
+        tradingFee: "0",
+        protocolFee: "0",
+        referralFee: "0"
+      };
+    } else {
+      throw err;
+    }
+  }
+  let transaction;
+  if (swapMode === 1 /* PartialFill */) {
+    transaction = await client.pool.swap2({
+      owner: params.owner,
+      pool: poolAccount.publicKey,
+      swapBaseForQuote: true,
+      // Token -> SOL (sell)
+      referralTokenAccount: null,
+      swapMode: 1 /* PartialFill */,
+      amountIn,
+      minimumAmountOut: new BN2(quote.minimumAmountOut)
+    });
+  } else if (swapMode === 2 /* ExactOut */) {
+    transaction = await client.pool.swap2({
+      owner: params.owner,
+      pool: poolAccount.publicKey,
+      swapBaseForQuote: true,
+      referralTokenAccount: null,
+      swapMode: 2 /* ExactOut */,
+      amountOut: new BN2(quote.outputAmount),
+      maximumAmountIn: amountIn
+    });
+  } else {
+    transaction = await client.pool.swap2({
+      owner: params.owner,
+      pool: poolAccount.publicKey,
+      swapBaseForQuote: true,
+      referralTokenAccount: null,
+      swapMode: 0 /* ExactIn */,
+      amountIn,
+      minimumAmountOut: new BN2(quote.minimumAmountOut)
+    });
+  }
+  const compiledTx = await sdk.compileTransactionWithALT(
+    transaction,
+    params.owner
+  );
+  return {
+    transaction: compiledTx,
+    amountIn: amountIn.toString(),
+    expectedAmountOut: quote.outputAmount,
+    minimumAmountOut: quote.minimumAmountOut
+  };
+}
+
+// src/cli/commands/swap.ts
+function registerSwapCommands(program2) {
+  const swap = program2.command("swap").description("Token swap commands");
+  swap.command("buy <token-address> <amount>").description("Buy tokens with NSO").option("--slippage <number>", "Slippage in basis points", "100").option(
+    "--mode <mode>",
+    "Swap mode: exact-in|partial-fill|exact-out",
+    "partial-fill"
+  ).option("-e, --export-tx", "Export unsigned transaction", false).action(
+    async (tokenAddress, amount, options) => {
+      try {
+        await handleSwapBuy(tokenAddress, amount, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+  swap.command("sell <token-address> <amount>").description("Sell tokens for NSO").option("--decimals <number>", "Token decimals", "6").option("--slippage <number>", "Slippage in basis points", "100").option(
+    "--mode <mode>",
+    "Swap mode: exact-in|partial-fill|exact-out",
+    "partial-fill"
+  ).option("-e, --export-tx", "Export unsigned transaction", false).action(
+    async (tokenAddress, amount, options) => {
+      try {
+        await handleSwapSell(tokenAddress, amount, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+  swap.command("quote <token-address> <amount> <direction>").description("Get swap quote (direction: buy|sell)").option("--decimals <number>", "Token decimals (for sell only)", "6").option("--slippage <number>", "Slippage in basis points", "100").action(
+    async (tokenAddress, amount, direction, options) => {
+      try {
+        await handleSwapQuote(tokenAddress, amount, direction, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+}
+function parseSwapMode(mode) {
+  const normalized = validateSwapMode(mode);
+  switch (normalized) {
+    case "exact-in":
+      return 0 /* ExactIn */;
+    case "partial-fill":
+      return 1 /* PartialFill */;
+    case "exact-out":
+      return 2 /* ExactOut */;
+    default:
+      return 1 /* PartialFill */;
+  }
+}
+async function handleSwapBuy(tokenAddress, amount, options) {
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Wallet: ${wallet.publicKey.toBase58()}`);
+  validatePublicKey(tokenAddress);
+  const amountInSOL = validatePositiveNumber(amount, "amount");
+  const slippage = validateNonNegativeNumber(
+    options.slippage || "100",
+    "slippage"
+  );
+  const swapMode = parseSwapMode(options.mode || "partial-fill");
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  printInfo(`Buying tokens with ${amountInSOL} NSO...`);
+  const result = await buyToken(sdk, {
+    tokenAddress,
+    amountInSOL,
+    owner: wallet.publicKey,
+    slippageBps: slippage,
+    swapMode
+  });
+  printInfo(`Expected output: ${result.expectedAmountOut} tokens (smallest unit)`);
+  printInfo(`Minimum output: ${result.minimumAmountOut} tokens (smallest unit)`);
+  const txResult = await handleTransaction(
+    sdk,
+    result.transaction,
+    [wallet],
+    options.exportTx || false
+  );
+  if (options.json) {
+    const output = {
+      amountIn: result.amountIn,
+      expectedAmountOut: result.expectedAmountOut,
+      minimumAmountOut: result.minimumAmountOut,
+      ...txResult.signature && { signature: txResult.signature },
+      ...txResult.base64 && { transaction: txResult.base64 }
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+Swap Details:`);
+    console.log(`  Input: ${(parseInt(result.amountIn) / 1e9).toFixed(4)} NSO`);
+    console.log(`  Expected Output: ${result.expectedAmountOut} tokens`);
+    console.log(`  Minimum Output: ${result.minimumAmountOut} tokens`);
+    printTransactionResult(txResult, false);
+  }
+}
+async function handleSwapSell(tokenAddress, amount, options) {
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Wallet: ${wallet.publicKey.toBase58()}`);
+  validatePublicKey(tokenAddress);
+  const amountInToken = validatePositiveNumber(amount, "amount");
+  const decimals = parseInt(String(options.decimals || "6"));
+  const slippage = validateNonNegativeNumber(
+    options.slippage || "100",
+    "slippage"
+  );
+  const swapMode = parseSwapMode(options.mode || "partial-fill");
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  printInfo(`Selling ${amountInToken} tokens...`);
+  const result = await sellToken(sdk, {
+    tokenAddress,
+    amountInToken,
+    owner: wallet.publicKey,
+    tokenDecimals: decimals,
+    slippageBps: slippage,
+    swapMode
+  });
+  printInfo(`Expected output: ${(parseInt(result.expectedAmountOut) / 1e9).toFixed(4)} NSO`);
+  printInfo(`Minimum output: ${(parseInt(result.minimumAmountOut) / 1e9).toFixed(4)} NSO`);
+  const txResult = await handleTransaction(
+    sdk,
+    result.transaction,
+    [wallet],
+    options.exportTx || false
+  );
+  if (options.json) {
+    const output = {
+      amountIn: result.amountIn,
+      expectedAmountOut: result.expectedAmountOut,
+      minimumAmountOut: result.minimumAmountOut,
+      ...txResult.signature && { signature: txResult.signature },
+      ...txResult.base64 && { transaction: txResult.base64 }
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+Swap Details:`);
+    console.log(`  Input: ${result.amountIn} tokens`);
+    console.log(`  Expected Output: ${(parseInt(result.expectedAmountOut) / 1e9).toFixed(4)} NSO`);
+    console.log(`  Minimum Output: ${(parseInt(result.minimumAmountOut) / 1e9).toFixed(4)} NSO`);
+    printTransactionResult(txResult, false);
+  }
+}
+async function handleSwapQuote(tokenAddress, amount, direction, options) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  validatePublicKey(tokenAddress);
+  const amountNum = validatePositiveNumber(amount, "amount");
+  const dir = validateDirection(direction);
+  const decimals = parseInt(String(options.decimals || "6"));
+  const slippage = validateNonNegativeNumber(
+    options.slippage || "100",
+    "slippage"
+  );
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  const swapBaseForQuote = dir === "sell";
+  const amountIn = swapBaseForQuote ? new BN3(amountNum * 10 ** decimals) : new BN3(amountNum * 1e9);
+  printInfo(`Getting ${dir} quote for ${amountNum} ${swapBaseForQuote ? "tokens" : "NSO"}...`);
+  const quote = await getSwapQuote(
+    sdk,
+    tokenAddress,
+    amountIn,
+    swapBaseForQuote,
+    slippage
+  );
+  if (options.json) {
+    console.log(JSON.stringify(quote, null, 2));
+  } else {
+    console.log(`
+Quote:`);
+    if (swapBaseForQuote) {
+      console.log(`  Input: ${(parseInt(quote.amountIn) / 10 ** decimals).toFixed(4)} tokens`);
+      console.log(`  Expected Output: ${(parseInt(quote.outputAmount) / 1e9).toFixed(4)} NSO`);
+      console.log(`  Minimum Output: ${(parseInt(quote.minimumAmountOut) / 1e9).toFixed(4)} NSO`);
+    } else {
+      console.log(`  Input: ${(parseInt(quote.amountIn) / 1e9).toFixed(4)} NSO`);
+      console.log(`  Expected Output: ${quote.outputAmount} tokens (smallest unit)`);
+      console.log(`  Minimum Output: ${quote.minimumAmountOut} tokens (smallest unit)`);
+    }
+    console.log(`  Trading Fee: ${quote.tradingFee}`);
+    console.log(`  Protocol Fee: ${quote.protocolFee}`);
+  }
+}
+
+// src/cli/commands/migrate.ts
+import "commander";
+
+// src/migrate.ts
+import {
+  PublicKey as PublicKey6
+} from "@solana/web3.js";
+import "bn.js";
+import { DAMM_V2_MIGRATION_FEE_ADDRESS as DAMM_V2_MIGRATION_FEE_ADDRESS2 } from "@meteora-ag/dynamic-bonding-curve-sdk";
+async function migrateToDAMMV2(sdk, params) {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey6(params.tokenAddress);
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${params.tokenAddress}`);
+  }
+  if (poolAccount.account.isMigrated) {
+    throw new Error("Pool has already been migrated");
+  }
+  const virtualPool = poolAccount.account;
+  const poolConfig = await client.state.getPoolConfig(virtualPool.config);
+  const migrationFeeOption = poolConfig.migrationFeeOption || 0;
+  const dammConfig = DAMM_V2_MIGRATION_FEE_ADDRESS2[migrationFeeOption];
+  if (!dammConfig) {
+    throw new Error(
+      `Invalid migration fee option: ${migrationFeeOption}. Cannot determine DAMM config address.`
+    );
+  }
+  const result = await client.migration.migrateToDammV2({
+    payer: params.payer,
+    virtualPool: poolAccount.publicKey,
+    dammConfig
+  });
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  result.transaction.recentBlockhash = blockhash;
+  result.transaction.feePayer = params.payer;
+  const compiledTx = await sdk.compileTransactionWithALT(
+    result.transaction,
+    params.payer
+  );
+  return {
+    transaction: compiledTx,
+    firstPositionNftKeypair: result.firstPositionNftKeypair,
+    secondPositionNftKeypair: result.secondPositionNftKeypair,
+    poolAddress: poolAccount.publicKey.toBase58()
+  };
+}
+async function createLocker(sdk, params) {
+  const connection = sdk.getConnection();
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey6(params.tokenAddress);
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    throw new Error(`Pool not found for token: ${params.tokenAddress}`);
+  }
+  const transaction = await client.migration.createLocker({
+    payer: params.payer,
+    virtualPool: poolAccount.publicKey
+  });
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  transaction.recentBlockhash = blockhash;
+  transaction.feePayer = params.payer;
+  const compiledTx = await sdk.compileTransactionWithALT(
+    transaction,
+    params.payer
+  );
+  return {
+    transaction: compiledTx,
+    poolAddress: poolAccount.publicKey.toBase58()
+  };
+}
+async function canMigrate(sdk, tokenAddress) {
+  const client = sdk.getClient();
+  const tokenPubkey = new PublicKey6(tokenAddress);
+  const poolAccount = await client.state.getPoolByBaseMint(tokenPubkey);
+  if (!poolAccount) {
+    return {
+      canMigrate: false,
+      reason: "Pool not found",
+      progress: 0
+    };
+  }
+  if (poolAccount.account.isMigrated) {
+    return {
+      canMigrate: false,
+      reason: "Pool has already been migrated",
+      progress: 1
+    };
+  }
+  const progress = await client.state.getPoolCurveProgress(
+    poolAccount.publicKey
+  );
+  if (progress >= 1) {
+    return {
+      canMigrate: true,
+      progress
+    };
+  }
+  return {
+    canMigrate: false,
+    reason: `Curve not complete. Current progress: ${(progress * 100).toFixed(2)}%`,
+    progress
+  };
+}
+
+// src/cli/commands/migrate.ts
+function registerMigrateCommands(program2) {
+  const migrate = program2.command("migrate").description("Pool migration commands");
+  migrate.command("launch <token-address>").description("Migrate pool to DAMM V2 (graduation)").option("-e, --export-tx", "Export unsigned transaction", false).action(
+    async (tokenAddress, options) => {
+      try {
+        await handleMigrateLaunch(tokenAddress, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+  migrate.command("create-locker <token-address>").description("Create locker for pools with vesting").option("-e, --export-tx", "Export unsigned transaction", false).action(
+    async (tokenAddress, options) => {
+      try {
+        await handleMigrateCreateLocker(tokenAddress, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+  migrate.command("check <token-address>").description("Check if pool can be migrated").action(
+    async (tokenAddress, options) => {
+      try {
+        await handleMigrateCheck(tokenAddress, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+}
+async function handleMigrateLaunch(tokenAddress, options) {
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Wallet: ${wallet.publicKey.toBase58()}`);
+  validatePublicKey(tokenAddress);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  printInfo("Checking if pool can be migrated...");
+  const checkResult = await canMigrate(sdk, tokenAddress);
+  if (!checkResult.canMigrate) {
+    printError(`Cannot migrate: ${checkResult.reason}`);
+    process.exit(1);
+  }
+  printSuccess("Pool is ready for migration!");
+  printInfo("Migrating pool to DAMM V2...");
+  const result = await migrateToDAMMV2(sdk, {
+    tokenAddress,
+    payer: wallet.publicKey
+  });
+  printInfo(`Pool address: ${result.poolAddress}`);
+  const txResult = await handleTransaction(
+    sdk,
+    result.transaction,
+    [wallet, result.firstPositionNftKeypair, result.secondPositionNftKeypair],
+    options.exportTx || false
+  );
+  if (options.json) {
+    const output = {
+      poolAddress: result.poolAddress,
+      ...txResult.signature && { signature: txResult.signature },
+      ...txResult.base64 && { transaction: txResult.base64 }
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+Pool Address: ${result.poolAddress}`);
+    printTransactionResult(txResult, false);
+    if (txResult.signature) {
+      printSuccess("\nPool successfully migrated to DAMM V2!");
+      printInfo("Pool is now a constant product AMM with full liquidity.");
+    }
+  }
+}
+async function handleMigrateCreateLocker(tokenAddress, options) {
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Wallet: ${wallet.publicKey.toBase58()}`);
+  validatePublicKey(tokenAddress);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  printInfo("Creating locker for pool with vesting parameters...");
+  const result = await createLocker(sdk, {
+    tokenAddress,
+    payer: wallet.publicKey
+  });
+  printInfo(`Pool address: ${result.poolAddress}`);
+  const txResult = await handleTransaction(
+    sdk,
+    result.transaction,
+    [wallet],
+    options.exportTx || false
+  );
+  if (options.json) {
+    const output = {
+      poolAddress: result.poolAddress,
+      ...txResult.signature && { signature: txResult.signature },
+      ...txResult.base64 && { transaction: txResult.base64 }
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+Pool Address: ${result.poolAddress}`);
+    printTransactionResult(txResult, false);
+    if (txResult.signature) {
+      printSuccess("\nLocker created successfully!");
+      printInfo("You can now proceed with migrating the pool.");
+    }
+  }
+}
+async function handleMigrateCheck(tokenAddress, options) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  validatePublicKey(tokenAddress);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  printInfo("Checking migration status...");
+  const result = await canMigrate(sdk, tokenAddress);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`
+Migration Status:`);
+    console.log(`  Can Migrate: ${result.canMigrate ? "Yes" : "No"}`);
+    console.log(`  Progress: ${(result.progress * 100).toFixed(2)}%`);
+    if (result.reason) {
+      console.log(`  Reason: ${result.reason}`);
+    }
+    if (result.canMigrate) {
+      printSuccess("\nPool is ready for migration!");
+      printInfo("Run: nara-cli migrate launch <token-address>");
+    } else {
+      printWarning("\nPool is not ready for migration yet.");
+      if (result.progress < 1) {
+        printInfo(`Curve completion required: 100% (current: ${(result.progress * 100).toFixed(2)}%)`);
+      }
+    }
+  }
+}
+
+// src/cli/commands/wallet.ts
+import "commander";
+import {
+  Keypair as Keypair6,
+  LAMPORTS_PER_SOL,
+  SystemProgram,
+  Transaction as Transaction7
+} from "@solana/web3.js";
+import {
+  getAssociatedTokenAddress,
+  createTransferInstruction,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2
+} from "@solana/spl-token";
+import * as bip39 from "bip39";
+import { derivePath } from "ed25519-hd-key";
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { mkdir } from "node:fs/promises";
+import bs58 from "bs58";
+var DEFAULT_WALLET_PATH3 = DEFAULT_WALLET_PATH.startsWith("~") ? join2(homedir2(), DEFAULT_WALLET_PATH.slice(1)) : DEFAULT_WALLET_PATH;
+function registerWalletCommands(program2) {
+  const wallet = program2.command("wallet").description("Wallet management commands");
+  wallet.command("create").description("Create a new wallet").option("-o, --output <path>", "Output path for wallet file (default: ~/.config/nara/id.json)").action(async (options) => {
+    try {
+      await handleWalletCreate(options);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+  wallet.command("import").description("Import a wallet from mnemonic or private key").option("-m, --mnemonic <phrase>", "Mnemonic phrase (12 or 24 words)").option("-k, --private-key <key>", "Private key (base58 or JSON array)").option("-o, --output <path>", "Output path for wallet file (default: ~/.config/nara/id.json)").action(async (options) => {
+    try {
+      await handleWalletImport(options);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+  wallet.command("address").description("Show wallet address").action(async (options) => {
+    try {
+      await handleWalletAddress(options);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+  wallet.command("balance").description("Check NSO balance").argument("[address]", "Wallet address (optional, defaults to current wallet)").action(async (address, options) => {
+    try {
+      await handleWalletBalance(address, options);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+  wallet.command("token-balance <token-address>").description("Check token balance").option("--owner <address>", "Owner address (optional, defaults to current wallet)").action(
+    async (tokenAddress, options) => {
+      try {
+        await handleTokenBalance(tokenAddress, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+  wallet.command("tx-status <signature>").description("Check transaction status").action(
+    async (signature, options) => {
+      try {
+        await handleTxStatus(signature, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+  wallet.command("transfer <to> <amount>").description("Transfer NSO to another wallet").option("-e, --export-tx", "Export unsigned transaction", false).action(
+    async (to, amount, options) => {
+      try {
+        await handleTransferSol(to, amount, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+  wallet.command("transfer-token <token-address> <to> <amount>").description("Transfer tokens to another wallet").option("--decimals <number>", "Token decimals", "6").option("-e, --export-tx", "Export unsigned transaction", false).action(
+    async (tokenAddress, to, amount, options) => {
+      try {
+        await handleTransferToken(tokenAddress, to, amount, options);
+      } catch (error) {
+        printError(error.message);
+        process.exit(1);
+      }
+    }
+  );
+}
+async function handleWalletBalance(address, options) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  const connection = sdk.getConnection();
+  let pubkey;
+  if (address) {
+    pubkey = validatePublicKey(address);
+  } else {
+    const wallet = await loadWallet(options.wallet);
+    pubkey = wallet.publicKey;
+  }
+  printInfo(`Checking balance for: ${pubkey.toBase58()}`);
+  const balance = await connection.getBalance(pubkey);
+  const balanceSOL = balance / LAMPORTS_PER_SOL;
+  if (options.json) {
+    const output = {
+      address: pubkey.toBase58(),
+      balance: balanceSOL,
+      lamports: balance
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+Wallet: ${pubkey.toBase58()}`);
+    console.log(`Balance: ${balanceSOL.toFixed(4)} NSO (${balance.toLocaleString()} lamports)`);
+  }
+}
+async function handleTokenBalance(tokenAddress, options) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  const tokenMint = validatePublicKey(tokenAddress);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  const connection = sdk.getConnection();
+  let owner;
+  if (options.owner) {
+    owner = validatePublicKey(options.owner);
+  } else {
+    const wallet = await loadWallet(options.wallet);
+    owner = wallet.publicKey;
+  }
+  printInfo(`Owner: ${owner.toBase58()}`);
+  printInfo(`Token: ${tokenAddress}`);
+  const tokenAccount = await getAssociatedTokenAddress(tokenMint, owner);
+  try {
+    const accountInfo = await connection.getTokenAccountBalance(tokenAccount);
+    const balance = accountInfo.value;
+    if (options.json) {
+      const output = {
+        owner: owner.toBase58(),
+        tokenAddress,
+        tokenAccount: tokenAccount.toBase58(),
+        balance: balance.uiAmountString,
+        amount: balance.amount,
+        decimals: balance.decimals
+      };
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      console.log(`
+Token Account: ${tokenAccount.toBase58()}`);
+      console.log(`Balance: ${balance.uiAmountString || "0"} tokens`);
+      console.log(`Amount: ${balance.amount} (smallest unit)`);
+      console.log(`Decimals: ${balance.decimals}`);
+    }
+  } catch (error) {
+    if (error.message?.includes("could not find account")) {
+      if (options.json) {
+        const output = {
+          owner: owner.toBase58(),
+          tokenAddress,
+          tokenAccount: tokenAccount.toBase58(),
+          balance: "0",
+          amount: "0"
+        };
+        console.log(JSON.stringify(output, null, 2));
+      } else {
+        printInfo("\nToken account does not exist yet.");
+        console.log(`Balance: 0 tokens`);
+        console.log(`Token Account (will be created on first transfer): ${tokenAccount.toBase58()}`);
+      }
+    } else {
+      throw error;
+    }
+  }
+}
+async function handleTxStatus(signature, options) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`Checking transaction: ${signature}`);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  const connection = sdk.getConnection();
+  const status = await connection.getSignatureStatus(signature);
+  if (!status || !status.value) {
+    if (options.json) {
+      console.log(JSON.stringify({ signature, status: "not_found" }, null, 2));
+    } else {
+      printError("Transaction not found");
+    }
+    return;
+  }
+  const transaction = await connection.getTransaction(signature, {
+    maxSupportedTransactionVersion: 0
+  });
+  const output = {
+    signature,
+    status: status.value.confirmationStatus || "unknown",
+    slot: status.value.slot,
+    confirmations: status.value.confirmations
+  };
+  if (status.value.err) {
+    output.error = status.value.err;
+    output.success = false;
+  } else {
+    output.success = true;
+  }
+  if (transaction) {
+    output.blockTime = transaction.blockTime;
+    output.fee = transaction.meta?.fee;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+Transaction: ${signature}`);
+    console.log(`Status: ${output.status}`);
+    console.log(`Success: ${output.success ? "Yes" : "No"}`);
+    console.log(`Slot: ${output.slot}`);
+    if (output.confirmations !== null) {
+      console.log(`Confirmations: ${output.confirmations}`);
+    }
+    if (output.blockTime) {
+      const date = new Date(output.blockTime * 1e3);
+      console.log(`Time: ${date.toISOString()}`);
+    }
+    if (output.fee) {
+      console.log(`Fee: ${output.fee / LAMPORTS_PER_SOL} NSO`);
+    }
+    if (output.error) {
+      console.log(`Error: ${JSON.stringify(output.error)}`);
+    }
+    console.log(
+      `
+View on Solscan: https://solscan.io/tx/${signature}?cluster=devnet`
+    );
+  }
+}
+async function handleTransferSol(to, amount, options) {
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`From: ${wallet.publicKey.toBase58()}`);
+  const recipient = validatePublicKey(to);
+  const amountSOL = validatePositiveNumber(amount, "amount");
+  const lamports = Math.floor(amountSOL * LAMPORTS_PER_SOL);
+  printInfo(`To: ${recipient.toBase58()}`);
+  printInfo(`Amount: ${amountSOL} NSO`);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  const connection = sdk.getConnection();
+  const transferInstruction = SystemProgram.transfer({
+    fromPubkey: wallet.publicKey,
+    toPubkey: recipient,
+    lamports
+  });
+  const transaction = new Transaction7().add(transferInstruction);
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  transaction.recentBlockhash = blockhash;
+  transaction.feePayer = wallet.publicKey;
+  const txResult = await handleTransaction(
+    sdk,
+    transaction,
+    [wallet],
+    options.exportTx || false
+  );
+  if (options.json) {
+    const output = {
+      from: wallet.publicKey.toBase58(),
+      to: recipient.toBase58(),
+      amount: amountSOL,
+      lamports,
+      ...txResult.signature && { signature: txResult.signature },
+      ...txResult.base64 && { transaction: txResult.base64 }
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+Transfer Details:`);
+    console.log(`  From: ${wallet.publicKey.toBase58()}`);
+    console.log(`  To: ${recipient.toBase58()}`);
+    console.log(`  Amount: ${amountSOL} NSO`);
+    printTransactionResult(txResult, false);
+  }
+}
+async function handleTransferToken(tokenAddress, to, amount, options) {
+  const wallet = await loadWallet(options.wallet);
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  printInfo(`Using RPC: ${rpcUrl}`);
+  printInfo(`From: ${wallet.publicKey.toBase58()}`);
+  const tokenMint = validatePublicKey(tokenAddress);
+  const recipient = validatePublicKey(to);
+  const amountInToken = validatePositiveNumber(amount, "amount");
+  const decimals = parseInt(String(options.decimals || "6"));
+  const amountInSmallestUnit = Math.floor(amountInToken * 10 ** decimals);
+  printInfo(`To: ${recipient.toBase58()}`);
+  printInfo(`Token: ${tokenAddress}`);
+  printInfo(`Amount: ${amountInToken} tokens`);
+  const sdk = new NaraSDK({
+    rpcUrl,
+    commitment: "confirmed"
+  });
+  const connection = sdk.getConnection();
+  const sourceAccount = await getAssociatedTokenAddress(
+    tokenMint,
+    wallet.publicKey
+  );
+  const destinationAccount = await getAssociatedTokenAddress(
+    tokenMint,
+    recipient
+  );
+  const transferInstruction = createTransferInstruction(
+    sourceAccount,
+    destinationAccount,
+    wallet.publicKey,
+    amountInSmallestUnit,
+    [],
+    TOKEN_PROGRAM_ID2
+  );
+  const transaction = new Transaction7().add(transferInstruction);
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  transaction.recentBlockhash = blockhash;
+  transaction.feePayer = wallet.publicKey;
+  const txResult = await handleTransaction(
+    sdk,
+    transaction,
+    [wallet],
+    options.exportTx || false
+  );
+  if (options.json) {
+    const output = {
+      from: wallet.publicKey.toBase58(),
+      to: recipient.toBase58(),
+      tokenAddress,
+      amount: amountInToken,
+      amountSmallestUnit: amountInSmallestUnit.toString(),
+      decimals,
+      ...txResult.signature && { signature: txResult.signature },
+      ...txResult.base64 && { transaction: txResult.base64 }
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+Token Transfer Details:`);
+    console.log(`  From: ${wallet.publicKey.toBase58()}`);
+    console.log(`  To: ${recipient.toBase58()}`);
+    console.log(`  Token: ${tokenAddress}`);
+    console.log(`  Amount: ${amountInToken} tokens`);
+    printTransactionResult(txResult, false);
+  }
+}
+async function handleWalletCreate(options) {
+  const outputPath = options.output || DEFAULT_WALLET_PATH3;
+  if (await Bun.file(outputPath).exists()) {
+    throw new Error(
+      `Wallet file already exists at ${outputPath}. Please use a different path or remove the existing file first.`
+    );
+  }
+  const mnemonic = bip39.generateMnemonic(128);
+  const seed = await bip39.mnemonicToSeed(mnemonic);
+  const derivedSeed = derivePath("m/44'/501'/0'/0'", seed.toString("hex")).key;
+  const keypair = Keypair6.fromSeed(derivedSeed);
+  const dir = outputPath.substring(0, outputPath.lastIndexOf("/"));
+  await mkdir(dir, { recursive: true });
+  const walletData = Array.from(keypair.secretKey);
+  await Bun.write(outputPath, JSON.stringify(walletData, null, 2));
+  console.log("\n\u2705 Wallet created successfully!");
+  console.log(`
+\u{1F4C1} Wallet saved to: ${outputPath}`);
+  console.log(`\u{1F511} Public Key: ${keypair.publicKey.toBase58()}`);
+  printWarning("\n\u26A0\uFE0F  IMPORTANT: Save your mnemonic phrase securely!");
+  printWarning("\u26A0\uFE0F  You will need it to recover your wallet.");
+  console.log("\n\u{1F4DD} Mnemonic phrase (12 words):");
+  console.log(`
+${mnemonic}
+`);
+  printWarning("\u26A0\uFE0F  Never share your mnemonic phrase with anyone!");
+  printWarning("\u26A0\uFE0F  Anyone with your mnemonic can access your funds.\n");
+}
+async function handleWalletImport(options) {
+  const outputPath = options.output || DEFAULT_WALLET_PATH3;
+  if (await Bun.file(outputPath).exists()) {
+    throw new Error(
+      `Wallet file already exists at ${outputPath}. Please use a different path or remove the existing file first.`
+    );
+  }
+  let keypair;
+  if (options.mnemonic) {
+    const mnemonic = options.mnemonic.trim();
+    if (!bip39.validateMnemonic(mnemonic)) {
+      throw new Error("Invalid mnemonic phrase. Please check your words and try again.");
+    }
+    const seed = await bip39.mnemonicToSeed(mnemonic);
+    const derivedSeed = derivePath("m/44'/501'/0'/0'", seed.toString("hex")).key;
+    keypair = Keypair6.fromSeed(derivedSeed);
+    printInfo("Importing wallet from mnemonic...");
+  } else if (options.privateKey) {
+    const privateKey = options.privateKey.trim();
+    try {
+      if (privateKey.startsWith("[")) {
+        const data = JSON.parse(privateKey);
+        keypair = Keypair6.fromSecretKey(new Uint8Array(data));
+      } else {
+        keypair = Keypair6.fromSecretKey(bs58.decode(privateKey));
+      }
+      printInfo("Importing wallet from private key...");
+    } catch (error) {
+      throw new Error(`Invalid private key format: ${error.message}`);
+    }
+  } else {
+    throw new Error("Please provide either --mnemonic or --private-key option.");
+  }
+  const dir = outputPath.substring(0, outputPath.lastIndexOf("/"));
+  await mkdir(dir, { recursive: true });
+  const walletData = Array.from(keypair.secretKey);
+  await Bun.write(outputPath, JSON.stringify(walletData, null, 2));
+  console.log("\n\u2705 Wallet imported successfully!");
+  console.log(`
+\u{1F4C1} Wallet saved to: ${outputPath}`);
+  console.log(`\u{1F511} Public Key: ${keypair.publicKey.toBase58()}
+`);
+}
+async function handleWalletAddress(options) {
+  const wallet = await loadWallet(options.wallet);
+  if (options.json) {
+    const output = {
+      address: wallet.publicKey.toBase58()
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.log(`
+\u{1F511} Wallet Address: ${wallet.publicKey.toBase58()}
+`);
+  }
+}
+
+// src/cli/commands/quest.ts
+import "commander";
+import { Connection as Connection3, Keypair as Keypair8 } from "@solana/web3.js";
+
+// src/quest.ts
+import {
+  Keypair as Keypair7,
+  LAMPORTS_PER_SOL as LAMPORTS_PER_SOL2,
+  PublicKey as PublicKey8
+} from "@solana/web3.js";
+import * as anchor from "@coral-xyz/anchor";
+import { Program, AnchorProvider, Wallet } from "@coral-xyz/anchor";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join as join3 } from "path";
+import { existsSync } from "fs";
+var _require = createRequire(import.meta.url);
+var BN254_FIELD = 21888242871839275222246405745257275088696311157297823662689037894645226208583n;
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function findZkFile(name) {
+  const srcPath = join3(__dirname, "cli/zk", name);
+  if (existsSync(srcPath)) return srcPath;
+  const distPath = join3(__dirname, "zk", name);
+  if (existsSync(distPath)) return distPath;
+  return srcPath;
+}
+var DEFAULT_CIRCUIT_WASM = findZkFile("answer_proof.wasm");
+var DEFAULT_ZKEY = findZkFile("answer_proof_final.zkey");
+function toBigEndian32(v) {
+  return Buffer.from(v.toString(16).padStart(64, "0"), "hex");
+}
+function answerToField(answer) {
+  return BigInt("0x" + Buffer.from(answer, "utf-8").toString("hex")) % BN254_FIELD;
+}
+function hashBytesToFieldStr(hashBytes) {
+  return BigInt("0x" + Buffer.from(hashBytes).toString("hex")).toString();
+}
+function pubkeyToCircuitInputs(pubkey) {
+  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) {
+  const negY = (y) => toBigEndian32(BN254_FIELD - BigInt(y));
+  const be = (s) => 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) {
+  const negY = (y) => toBigEndian32(BN254_FIELD - BigInt(y));
+  const be = (s) => 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")
+  };
+}
+async function silentProve(snarkjs, input, wasmPath, zkeyPath) {
+  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;
+  }
+}
+function createProgram(connection, wallet) {
+  const idlPath = existsSync(join3(__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(idl, provider);
+}
+function getPoolPda(programId) {
+  const [pda] = PublicKey8.findProgramAddressSync(
+    [Buffer.from("pool")],
+    programId
+  );
+  return pda;
+}
+function getWinnerRecordPda(programId, user) {
+  const [pda] = PublicKey8.findProgramAddressSync(
+    [Buffer.from("winner"), user.toBuffer()],
+    programId
+  );
+  return pda;
+}
+async function getQuestInfo(connection, wallet) {
+  const kp = wallet ?? Keypair7.generate();
+  const program2 = createProgram(connection, kp);
+  const poolPda = getPoolPda(program2.programId);
+  const pool = await program2.account.pool.fetch(poolPda);
+  const now = Math.floor(Date.now() / 1e3);
+  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_SOL2,
+    totalReward: pool.rewardAmount.toNumber() / LAMPORTS_PER_SOL2,
+    rewardCount: pool.rewardCount,
+    winnerCount: pool.winnerCount,
+    remainingSlots: Math.max(0, pool.rewardCount - pool.winnerCount),
+    deadline,
+    timeRemaining: secsLeft,
+    expired: secsLeft <= 0
+  };
+}
+async function hasAnswered(connection, wallet) {
+  const program2 = createProgram(connection, wallet);
+  const quest = await getQuestInfo(connection, wallet);
+  const winnerPda = getWinnerRecordPda(program2.programId, wallet.publicKey);
+  try {
+    const wr = await program2.account.winnerRecord.fetch(winnerPda);
+    return wr.round.toString() === quest.round;
+  } catch {
+    return false;
+  }
+}
+async function generateProof(answer, answerHash, userPubkey, options) {
+  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)
+  };
+}
+async function submitAnswer(connection, wallet, proof) {
+  const program2 = createProgram(connection, wallet);
+  const signature = await program2.methods.submitAnswer(proof.proofA, proof.proofB, proof.proofC).accounts({ user: wallet.publicKey, payer: wallet.publicKey }).signers([wallet]).rpc({ skipPreflight: true });
+  return { signature };
+}
+async function submitAnswerViaRelay(relayUrl, userPubkey, proof) {
+  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();
+  if (!res.ok) {
+    throw new Error(`Relay submission failed: ${data.error ?? `HTTP ${res.status}`}`);
+  }
+  return { txHash: data.txHash };
+}
+async function parseQuestReward(connection, txSignature, retries = 10) {
+  await new Promise((r) => setTimeout(r, 2e3));
+  let txInfo;
+  for (let i = 0; i < retries; i++) {
+    try {
+      txInfo = await connection.getTransaction(txSignature, {
+        commitment: "confirmed",
+        maxSupportedTransactionVersion: 0
+      });
+      if (txInfo) break;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  if (!txInfo) {
+    throw new Error("Failed to fetch transaction details");
+  }
+  let rewardLamports = 0;
+  let winner = "";
+  const logs = 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_SOL2,
+    winner
+  };
+}
+
+// src/cli/commands/quest.ts
+var QUEST_ERRORS = {
+  6e3: "unauthorized",
+  6001: "poolNotActive",
+  6002: "deadlineExpired",
+  6003: "invalidProof",
+  6004: "invalidDeadline",
+  6005: "insufficientReward",
+  6006: "insufficientPoolBalance",
+  6007: "questionTooLong",
+  6008: "alreadyAnswered"
+};
+function anchorErrorCode(err) {
+  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 "";
+}
+function formatTimeRemaining(seconds) {
+  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`;
+}
+async function handleQuestGet(options) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  const connection = new Connection3(rpcUrl, "confirmed");
+  let wallet;
+  try {
+    wallet = await loadWallet(options.wallet);
+  } catch {
+    wallet = Keypair8.generate();
+  }
+  let quest;
+  try {
+    quest = await getQuestInfo(connection, wallet);
+  } catch (err) {
+    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 * 1e3).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 * 1e3).toLocaleString()}`);
+    if (quest.timeRemaining > 0) {
+      console.log(`  Time remaining: ${formatTimeRemaining(quest.timeRemaining)}`);
+    } else {
+      printWarning("Quest has expired");
+    }
+    console.log("");
+  }
+}
+async function handleQuestAnswer(answer, options) {
+  const rpcUrl = getRpcUrl(options.rpcUrl);
+  const connection = new Connection3(rpcUrl, "confirmed");
+  const wallet = await loadWallet(options.wallet);
+  let quest;
+  try {
+    quest = await getQuestInfo(connection, wallet);
+  } catch (err) {
+    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);
+  }
+  const alreadyAnswered = await hasAnswered(connection, wallet);
+  if (alreadyAnswered) {
+    printWarning("You have already answered this round");
+    process.exit(0);
+  }
+  printInfo("Generating ZK proof...");
+  let proof;
+  try {
+    proof = await generateProof(answer, quest.answerHash, wallet.publicKey);
+  } catch (err) {
+    if (err.message?.includes("Assert Failed")) {
+      printError("Wrong answer");
+    } else {
+      printError(`ZK proof generation failed: ${err.message}`);
+    }
+    process.exit(1);
+  }
+  const nowAfterProof = Math.floor(Date.now() / 1e3);
+  if (nowAfterProof >= quest.deadline) {
+    printError("Quest expired during proof generation");
+    process.exit(1);
+  }
+  if (options.relay) {
+    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) {
+      printError(`Relay submission failed: ${err.message}`);
+      process.exit(1);
+    }
+  } else {
+    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) {
+      handleSubmitError(err);
+    }
+  }
+}
+async function handleReward(connection, txSignature, options) {
+  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 \u2014 all reward slots have been claimed");
+    if (options.json) {
+      formatOutput(
+        { signature: txSignature, rewarded: false, rewardLamports: 0 },
+        true
+      );
+    }
+  }
+}
+function handleSubmitError(err) {
+  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) => console.log(`    ${l}`));
+      }
+  }
+  process.exit(1);
+}
+function registerQuestCommands(program2) {
+  const quest = program2.command("quest").description("Quest commands");
+  quest.command("get").description("Get current quest info").action(async (_opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      await handleQuestGet(globalOpts);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+  quest.command("answer <answer>").description("Submit an answer").option("--relay [url]", `Submit via relay service, gasless (default: ${DEFAULT_QUEST_RELAY_URL})`).action(async (answer, opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const relayUrl = opts.relay === true ? DEFAULT_QUEST_RELAY_URL : opts.relay;
+      await handleQuestAnswer(answer, { ...globalOpts, relay: relayUrl });
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/index.ts
+function registerCommands(program2) {
+  registerConfigCommands(program2);
+  registerPoolCommands(program2);
+  registerSwapCommands(program2);
+  registerMigrateCommands(program2);
+  registerWalletCommands(program2);
+  registerQuestCommands(program2);
+}
+
+// bin/nara-cli.ts
+var program = new Command8();
+program.name("nara-cli").description("CLI for the Nara chain (Solana-compatible)").version("0.1.0");
+program.option("-r, --rpc-url <url>", "RPC endpoint URL").option("-w, --wallet <path>", "Path to wallet keypair JSON file").option("-j, --json", "Output in JSON format");
+registerCommands(program);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}