@shuffle-protocol/sdk 0.1.0

package/dist/cli/commands.js

@@ -0,0 +1,1229 @@
+"use strict";
+/**
+ * CLI Command Implementations
+ *
+ * Each command function handles both real and mock mode operations.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+exports.balanceCommand = balanceCommand;
+exports.depositCommand = depositCommand;
+exports.withdrawCommand = withdrawCommand;
+exports.transferCommand = transferCommand;
+exports.orderCommand = orderCommand;
+exports.settleCommand = settleCommand;
+exports.executeCommand = executeCommand;
+exports.statusCommand = statusCommand;
+exports.faucetCommand = faucetCommand;
+exports.airdropCommand = airdropCommand;
+exports.historyCommand = historyCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const web3_js_1 = require("@solana/web3.js");
+const config_1 = require("./config");
+const output_1 = require("./output");
+const devnet_1 = require("./devnet");
+const constants_1 = require("../constants");
+// ============================================================================
+// ACCOUNT COMMANDS
+// ============================================================================
+/**
+ * shuffle init - Create privacy account
+ */
+async function initCommand() {
+    const config = (0, config_1.getConfig)();
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const progress = (0, output_1.createProgressSpinner)([
+            "Generating encryption keypair...",
+            "Creating privacy account on-chain...",
+            "Initializing encrypted balances...",
+        ]);
+        progress.start();
+        await (0, devnet_1.mockDelay)("medium");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("medium");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("fast");
+        (0, devnet_1.updateMockState)({ accountExists: true });
+        progress.succeed("Privacy account created!");
+        console.log();
+        console.log(chalk_1.default.gray(`  Wallet: ${config.wallet.publicKey.toBase58().slice(0, 20)}...`));
+        console.log(chalk_1.default.gray(`  Network: ${config.network}`));
+        console.log();
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        const exists = await config.shuffleClient.accountExists();
+        if (exists) {
+            (0, output_1.printInfo)("Privacy account already exists!");
+            return;
+        }
+        const sig = await (0, output_1.withSpinner)("Creating privacy account...", () => config.shuffleClient.createUserAccount(), "Privacy account created!");
+        (0, output_1.printTxSuccess)(sig, config.network);
+    }
+    catch (e) {
+        (0, output_1.printError)(e.message);
+    }
+}
+/**
+ * shuffle balance - View encrypted balances
+ */
+async function balanceCommand() {
+    const config = (0, config_1.getConfig)();
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const state = (0, devnet_1.getMockState)();
+        if (!state.accountExists) {
+            (0, output_1.printError)("Account not found. Run 'shuffle init' first.");
+            return;
+        }
+        await (0, output_1.withSpinner)("Decrypting balances with MPC...", () => (0, devnet_1.mockDelay)("fast"), "Balances decrypted!");
+        // Mock unshielded balances (0 for demo)
+        const unshielded = { usdc: 0n, tsla: 0n, spy: 0n, aapl: 0n };
+        // Mock pending payout (if there's an executed order, show payout)
+        // For demo: if pendingOrder exists and batch was "executed" (batchId > order.batchId)
+        const pendingPayout = state.pendingOrder && state.batchId > state.pendingOrder.batchId
+            ? { amount: state.pendingOrder.amount / 10n, assetId: state.pendingOrder.pairId === 0 ? 1 : 2 }
+            : null;
+        (0, output_1.printBalanceTable)(state.balances, unshielded, pendingPayout);
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        // Fetch shielded, unshielded, and estimated payout (for lazy settlement)
+        const [shielded, unshielded, estimatedPayout] = await (0, output_1.withSpinner)("Fetching balances...", async () => {
+            const shieldedBalances = await config.shuffleClient.getBalance();
+            const unshieldedBalances = await config.shuffleClient.getUnshieldedBalances();
+            const payout = await config.shuffleClient.estimatePayout();
+            return [shieldedBalances, unshieldedBalances, payout];
+        }, "Balances loaded!");
+        // Pass pending payout to display it directly in the balance (cyan color)
+        const pendingPayout = estimatedPayout
+            ? { amount: estimatedPayout.estimatedPayout, assetId: estimatedPayout.outputAssetId }
+            : null;
+        (0, output_1.printBalanceTable)(shielded, unshielded, pendingPayout);
+    }
+    catch (e) {
+        // If account doesn't exist, show only unshielded
+        if (e.message?.includes("Account does not exist") || e.message?.includes("not found")) {
+            try {
+                const unshielded = await config.shuffleClient.getUnshieldedBalances();
+                console.log(chalk_1.default.yellow("\n  ⚠ No shielded account. Run 'shuffle init' to create one.\n"));
+                (0, output_1.printBalanceTable)({ usdc: BigInt(0), tsla: BigInt(0), spy: BigInt(0), aapl: BigInt(0) }, unshielded);
+            }
+            catch {
+                (0, output_1.printError)("Privacy account not found. Run 'shuffle init' first.");
+            }
+        }
+        else {
+            (0, output_1.printError)(e.message);
+        }
+    }
+}
+// ============================================================================
+// TOKEN COMMANDS
+// ============================================================================
+/**
+ * Parse asset name to AssetId
+ */
+function parseAsset(asset) {
+    const upper = asset.toUpperCase();
+    const mapping = {
+        USDC: constants_1.AssetId.USDC,
+        TSLA: constants_1.AssetId.TSLA,
+        SPY: constants_1.AssetId.SPY,
+        AAPL: constants_1.AssetId.AAPL,
+    };
+    if (!(upper in mapping)) {
+        throw new Error(`Invalid asset: ${asset}. Use: USDC, TSLA, SPY, AAPL`);
+    }
+    return mapping[upper];
+}
+/**
+ * shuffle deposit <asset> <amount>
+ */
+async function depositCommand(asset, amountStr) {
+    const config = (0, config_1.getConfig)();
+    const amount = parseFloat(amountStr);
+    if (isNaN(amount) || amount <= 0) {
+        (0, output_1.printError)("Invalid amount. Must be a positive number.");
+        return;
+    }
+    let assetId;
+    try {
+        assetId = parseAsset(asset);
+    }
+    catch (e) {
+        (0, output_1.printError)(e.message);
+        return;
+    }
+    const amountRaw = BigInt(Math.floor(amount * 1000000)); // 6 decimals
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const state = (0, devnet_1.getMockState)();
+        if (!state.accountExists) {
+            (0, output_1.printError)("Account not found. Run 'shuffle init' first.");
+            return;
+        }
+        const progress = (0, output_1.createProgressSpinner)([
+            `Encrypting ${amount} ${asset}...`,
+            "Transferring tokens to protocol vault...",
+            "Updating encrypted balance via MPC...",
+        ]);
+        progress.start();
+        await (0, devnet_1.mockDelay)("fast");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("medium");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("slow");
+        // Update mock balance
+        const key = asset.toLowerCase();
+        state.balances[key] += amountRaw;
+        (0, devnet_1.updateMockState)({ balances: state.balances });
+        progress.succeed(`Shielded ${amount.toLocaleString()} ${asset}!`);
+        (0, output_1.printTxSuccess)((0, devnet_1.mockSignature)(), config.network);
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        const sig = await (0, output_1.withSpinner)(`Shielding ${amount} ${asset}...`, () => config.shuffleClient.deposit(assetId, Math.floor(amount * 1000000)), `Shielded ${amount.toLocaleString()} ${asset}!`);
+        (0, output_1.printTxSuccess)(sig, config.network);
+    }
+    catch (e) {
+        // Provide user-friendly error messages
+        const msg = e.message || "";
+        if (msg.includes("Unknown action") || msg.includes("undefined")) {
+            (0, output_1.printError)(`No ${asset} tokens in your wallet. Use 'shuffle faucet ${amount}' first!`);
+        }
+        else if (msg.includes("insufficient") || msg.includes("0x1")) {
+            (0, output_1.printError)(`Insufficient ${asset} balance. Get tokens with 'shuffle faucet <amount>' first.`);
+        }
+        else if (msg.includes("Account does not exist")) {
+            (0, output_1.printError)("Privacy account not found. Run 'shuffle init' first.");
+        }
+        else {
+            (0, output_1.printError)(msg);
+        }
+    }
+}
+/**
+ * shuffle withdraw <asset> <amount>
+ */
+async function withdrawCommand(asset, amountStr) {
+    const config = (0, config_1.getConfig)();
+    const amount = parseFloat(amountStr);
+    if (isNaN(amount) || amount <= 0) {
+        (0, output_1.printError)("Invalid amount. Must be a positive number.");
+        return;
+    }
+    let assetId;
+    try {
+        assetId = parseAsset(asset);
+    }
+    catch (e) {
+        (0, output_1.printError)(e.message);
+        return;
+    }
+    const amountRaw = BigInt(Math.floor(amount * 1000000));
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const state = (0, devnet_1.getMockState)();
+        if (!state.accountExists) {
+            (0, output_1.printError)("Account not found. Run 'shuffle init' first.");
+            return;
+        }
+        const key = asset.toLowerCase();
+        if (state.balances[key] < amountRaw) {
+            (0, output_1.printError)(`Insufficient ${asset} balance.`);
+            return;
+        }
+        const progress = (0, output_1.createProgressSpinner)([
+            "Proving withdrawal via MPC...",
+            "Decrypting balance check...",
+            `Transferring ${amount} ${asset} to your wallet...`,
+        ]);
+        progress.start();
+        await (0, devnet_1.mockDelay)("slow");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("medium");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("fast");
+        state.balances[key] -= amountRaw;
+        (0, devnet_1.updateMockState)({ balances: state.balances });
+        progress.succeed(`Unshielded ${amount.toLocaleString()} ${asset}!`);
+        (0, output_1.printTxSuccess)((0, devnet_1.mockSignature)(), config.network);
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        // Check shielded balance before attempting withdraw
+        const assetLabels = {
+            [constants_1.AssetId.USDC]: 'usdc',
+            [constants_1.AssetId.TSLA]: 'tsla',
+            [constants_1.AssetId.SPY]: 'spy',
+            [constants_1.AssetId.AAPL]: 'aapl',
+        };
+        const [shielded, unshielded] = await Promise.all([
+            config.shuffleClient.getBalance(),
+            config.shuffleClient.getUnshieldedBalances(),
+        ]);
+        const assetKey = assetLabels[assetId];
+        const shieldedBalance = shielded[assetKey];
+        const unshieldedBalance = unshielded[assetKey];
+        const shieldedFormatted = (Number(shieldedBalance) / 1000000).toFixed(2);
+        const unshieldedFormatted = (Number(unshieldedBalance) / 1000000).toFixed(2);
+        if (shieldedBalance < amountRaw) {
+            console.log();
+            (0, output_1.printError)(`Insufficient shielded ${asset.toUpperCase()} balance!`);
+            console.log(chalk_1.default.gray(`\n  Your shielded balance: ${chalk_1.default.white(shieldedFormatted)} ${asset.toUpperCase()}`));
+            console.log(chalk_1.default.gray(`  Requested amount:      ${chalk_1.default.white(amount.toFixed(2))} ${asset.toUpperCase()}\n`));
+            if (shieldedBalance > 0n) {
+                console.log(chalk_1.default.yellow(`  💡 You can unshield up to ${shieldedFormatted} ${asset.toUpperCase()}`));
+                console.log(chalk_1.default.gray(`     Try: shuffle unshield ${asset.toLowerCase()} ${shieldedFormatted}\n`));
+            }
+            return;
+        }
+        const sig = await (0, output_1.withSpinner)(`Unshielding ${amount} ${asset}...`, () => config.shuffleClient.withdraw(assetId, Math.floor(amount * 1000000)), `Unshielded ${amount.toLocaleString()} ${asset}!`);
+        (0, output_1.printTxSuccess)(sig, config.network);
+    }
+    catch (e) {
+        // Provide user-friendly error messages
+        const msg = e.message || "";
+        if (msg.includes("Unknown action") || msg.includes("undefined")) {
+            (0, output_1.printError)(`Insufficient ${asset} balance! Check your balance with 'shuffle balance'.`);
+        }
+        else if (msg.includes("insufficient") || msg.includes("0x1")) {
+            (0, output_1.printError)(`Insufficient ${asset} balance to withdraw ${amount}. Check your balance first.`);
+        }
+        else if (msg.includes("Account does not exist")) {
+            (0, output_1.printError)("Privacy account not found. Run 'shuffle init' first.");
+        }
+        else if (msg.includes("custom program error")) {
+            (0, output_1.printError)(`Cannot withdraw ${amount} ${asset}. Your balance may be too low.`);
+        }
+        else {
+            (0, output_1.printError)(msg);
+        }
+    }
+}
+/**
+ * shuffle transfer <address> <amount>
+ */
+async function transferCommand(address, amountStr) {
+    const config = (0, config_1.getConfig)();
+    const amount = parseFloat(amountStr);
+    if (isNaN(amount) || amount <= 0) {
+        (0, output_1.printError)("Invalid amount. Must be a positive number.");
+        return;
+    }
+    let recipientPubkey;
+    try {
+        recipientPubkey = new web3_js_1.PublicKey(address);
+    }
+    catch {
+        (0, output_1.printError)("Invalid Solana address.");
+        return;
+    }
+    const amountRaw = BigInt(Math.floor(amount * 1000000));
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const state = (0, devnet_1.getMockState)();
+        if (!state.accountExists) {
+            (0, output_1.printError)("Account not found. Run 'shuffle init' first.");
+            return;
+        }
+        if (state.balances.usdc < amountRaw) {
+            (0, output_1.printError)("Insufficient USDC balance.");
+            return;
+        }
+        const progress = (0, output_1.createProgressSpinner)([
+            "Encrypting transfer amount...",
+            "Computing private transfer via MPC...",
+            "Updating both accounts' balances...",
+        ]);
+        progress.start();
+        await (0, devnet_1.mockDelay)("fast");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("slow");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("medium");
+        state.balances.usdc -= amountRaw;
+        (0, devnet_1.updateMockState)({ balances: state.balances });
+        progress.succeed(`Transferred ${amount.toLocaleString()} USDC privately!`);
+        console.log(chalk_1.default.gray(`  To: ${address.slice(0, 20)}...`));
+        (0, output_1.printTxSuccess)((0, devnet_1.mockSignature)(), config.network);
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        // Check shielded USDC balance before transfer
+        const [shielded, unshielded] = await Promise.all([
+            config.shuffleClient.getBalance(),
+            config.shuffleClient.getUnshieldedBalances(),
+        ]);
+        const shieldedBalance = shielded.usdc;
+        const unshieldedBalance = unshielded.usdc;
+        const shieldedFormatted = (Number(shieldedBalance) / 1000000).toFixed(2);
+        const unshieldedFormatted = (Number(unshieldedBalance) / 1000000).toFixed(2);
+        if (shieldedBalance < amountRaw) {
+            console.log();
+            (0, output_1.printError)(`Insufficient shielded USDC balance!`);
+            console.log(chalk_1.default.gray(`\n  Your shielded balance: ${chalk_1.default.white(shieldedFormatted)} USDC`));
+            console.log(chalk_1.default.gray(`  Requested amount:      ${chalk_1.default.white(amount.toFixed(2))} USDC\n`));
+            if (unshieldedBalance > 0n) {
+                console.log(chalk_1.default.yellow(`  💡 You have ${unshieldedFormatted} USDC unshielded in your wallet.`));
+                console.log(chalk_1.default.gray(`     Shield it first with: shuffle shield usdc ${unshieldedFormatted}\n`));
+            }
+            return;
+        }
+        const sig = await (0, output_1.withSpinner)(`Transferring ${amount} USDC privately...`, () => config.shuffleClient.transfer(recipientPubkey, Math.floor(amount * 1000000)), `Transferred ${amount.toLocaleString()} USDC!`);
+        (0, output_1.printTxSuccess)(sig, config.network);
+    }
+    catch (e) {
+        // Provide user-friendly error messages
+        const msg = e.message || "";
+        if (msg.includes("Unknown action") || msg.includes("undefined")) {
+            (0, output_1.printError)(`Insufficient USDC balance for transfer! Check your balance with 'shuffle balance'.`);
+        }
+        else if (msg.includes("insufficient") || msg.includes("0x1")) {
+            (0, output_1.printError)(`Insufficient USDC balance to transfer ${amount}. Check your balance first.`);
+        }
+        else if (msg.includes("Account does not exist") || msg.includes("not found")) {
+            (0, output_1.printError)("Recipient doesn't have a Shuffle account. They need to run 'shuffle init' first.");
+        }
+        else if (msg.includes("invalid public key")) {
+            (0, output_1.printError)("Invalid recipient address. Please check and try again.");
+        }
+        else {
+            (0, output_1.printError)(msg);
+        }
+    }
+}
+// ============================================================================
+// TRADING COMMANDS
+// ============================================================================
+/**
+ * Parse pair name to PairId
+ */
+function parsePair(pair) {
+    const upper = pair.toUpperCase().replace("/", "_");
+    const mapping = {
+        TSLA_USDC: constants_1.PairId.TSLA_USDC,
+        SPY_USDC: constants_1.PairId.SPY_USDC,
+        AAPL_USDC: constants_1.PairId.AAPL_USDC,
+        TSLA_SPY: constants_1.PairId.TSLA_SPY,
+        TSLA_AAPL: constants_1.PairId.TSLA_AAPL,
+        SPY_AAPL: constants_1.PairId.SPY_AAPL,
+    };
+    if (!(upper in mapping)) {
+        throw new Error(`Invalid pair: ${pair}. Use: TSLA_USDC, SPY_USDC, AAPL_USDC, TSLA_SPY, TSLA_AAPL, SPY_AAPL`);
+    }
+    return mapping[upper];
+}
+/**
+ * Parse direction string to Direction enum
+ */
+function parseDirection(dir) {
+    const lower = dir.toLowerCase();
+    // "buy" means buying the BASE token (e.g., TSLA in TSLA/USDC)
+    // That means selling the QUOTE token (USDC) → BtoA direction
+    if (lower === "buy" || lower === "b_to_a" || lower === "1") {
+        return constants_1.Direction.BtoA;
+    }
+    // "sell" means selling the BASE token (e.g., TSLA in TSLA/USDC)
+    // That means buying the QUOTE token (USDC) → AtoB direction
+    if (lower === "sell" || lower === "a_to_b" || lower === "0") {
+        return constants_1.Direction.AtoB;
+    }
+    throw new Error(`Invalid direction: ${dir}. Use: buy, sell`);
+}
+/**
+ * Infer source asset from pair and direction
+ */
+function inferSourceAsset(pairId, direction) {
+    // Pair definitions: [baseAsset, quoteAsset]
+    const pairAssets = {
+        [constants_1.PairId.TSLA_USDC]: [constants_1.AssetId.TSLA, constants_1.AssetId.USDC],
+        [constants_1.PairId.SPY_USDC]: [constants_1.AssetId.SPY, constants_1.AssetId.USDC],
+        [constants_1.PairId.AAPL_USDC]: [constants_1.AssetId.AAPL, constants_1.AssetId.USDC],
+        [constants_1.PairId.TSLA_SPY]: [constants_1.AssetId.TSLA, constants_1.AssetId.SPY],
+        [constants_1.PairId.TSLA_AAPL]: [constants_1.AssetId.TSLA, constants_1.AssetId.AAPL],
+        [constants_1.PairId.SPY_AAPL]: [constants_1.AssetId.SPY, constants_1.AssetId.AAPL],
+    };
+    const [base, quote] = pairAssets[pairId];
+    // AtoB = selling A (base) for B (quote), so source is base
+    // BtoA = selling B (quote) for A (base), so source is quote
+    return direction === constants_1.Direction.AtoB ? base : quote;
+}
+/**
+ * shuffle order [pair] [direction] [amount]
+ * Interactive mode if no args provided
+ */
+async function orderCommand(pair, direction, amountStr) {
+    const config = (0, config_1.getConfig)();
+    // If all args provided, use direct mode
+    if (pair && direction && amountStr) {
+        return executeDirectOrder(config, pair, direction, amountStr);
+    }
+    // Interactive mode
+    return executeInteractiveOrder(config);
+}
+/**
+ * Execute order with direct CLI arguments (original behavior)
+ */
+async function executeDirectOrder(config, pair, direction, amountStr) {
+    const amount = parseFloat(amountStr);
+    if (isNaN(amount) || amount <= 0) {
+        (0, output_1.printError)("Invalid amount. Must be a positive number.");
+        return;
+    }
+    let pairId;
+    let dir;
+    try {
+        pairId = parsePair(pair);
+        dir = parseDirection(direction);
+    }
+    catch (e) {
+        (0, output_1.printError)(e.message);
+        return;
+    }
+    const amountRaw = BigInt(Math.floor(amount * 1000000));
+    const sourceAsset = inferSourceAsset(pairId, dir);
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const state = (0, devnet_1.getMockState)();
+        if (!state.accountExists) {
+            (0, output_1.printError)("Account not found. Run 'shuffle init' first.");
+            return;
+        }
+        if (state.pendingOrder) {
+            (0, output_1.printError)("You have a pending order. Settle it first with 'shuffle settle'.");
+            return;
+        }
+        const progress = (0, output_1.createProgressSpinner)([
+            "Encrypting order details...",
+            "Submitting to batch aggregator...",
+            "Accumulating in MPC cluster...",
+            "Order encrypted and queued!",
+        ]);
+        progress.start();
+        await (0, devnet_1.mockDelay)("fast");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("medium");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("slow");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("fast");
+        (0, devnet_1.updateMockState)({
+            pendingOrder: {
+                batchId: state.batchId,
+                pairId,
+                direction: dir,
+                amount: amountRaw,
+            },
+        });
+        progress.succeed("Order placed!");
+        console.log();
+        console.log(chalk_1.default.gray(`  Pair:      ${pair.toUpperCase()}`));
+        console.log(chalk_1.default.gray(`  Direction: ${direction === "buy" ? "BUY" : "SELL"}`));
+        console.log(chalk_1.default.gray(`  Amount:    ${amount.toLocaleString()}`));
+        console.log(chalk_1.default.gray(`  Batch:     #${state.batchId}`));
+        console.log();
+        (0, output_1.printSuccess)("Your order is encrypted and hidden until batch execution!");
+        (0, output_1.printTxSuccess)((0, devnet_1.mockSignature)(), config.network);
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        // Check if user already has a pending order
+        const existingOrder = await config.shuffleClient.getDecryptedOrder();
+        if (existingOrder) {
+            const pairLabels = ["TSLA/USDC", "SPY/USDC", "AAPL/USDC"];
+            const dirLabel = existingOrder.direction === 0 ? "BUY" : "SELL";
+            const orderAmount = (Number(existingOrder.amount) / 1000000).toFixed(2);
+            console.log();
+            (0, output_1.printError)("You already have a pending order!");
+            console.log(chalk_1.default.gray(`\n  Pending order: ${chalk_1.default.white(dirLabel)} ${pairLabels[existingOrder.pairId] || "Unknown"}`));
+            console.log(chalk_1.default.gray(`  Amount:        ${chalk_1.default.white(orderAmount)} USDC`));
+            console.log(chalk_1.default.gray(`  Batch ID:      ${chalk_1.default.white(existingOrder.batchId)}\n`));
+            console.log(chalk_1.default.yellow(`  💡 Wait for batch execution, then settle with: shuffle settle`));
+            console.log(chalk_1.default.gray(`     Check status with: shuffle status\n`));
+            return;
+        }
+        // Check shielded USDC balance before placing order
+        // Orders use USDC as the source asset (buying TSLA/SPY with USDC)
+        const [shielded, unshielded] = await Promise.all([
+            config.shuffleClient.getBalance(),
+            config.shuffleClient.getUnshieldedBalances(),
+        ]);
+        const amountRaw = BigInt(Math.floor(amount * 1000000));
+        const shieldedBalance = shielded.usdc;
+        const unshieldedBalance = unshielded.usdc;
+        const shieldedFormatted = (Number(shieldedBalance) / 1000000).toFixed(2);
+        const unshieldedFormatted = (Number(unshieldedBalance) / 1000000).toFixed(2);
+        if (shieldedBalance < amountRaw) {
+            console.log();
+            (0, output_1.printError)(`Insufficient shielded USDC balance for this order!`);
+            console.log(chalk_1.default.gray(`\n  Your shielded balance: ${chalk_1.default.white(shieldedFormatted)} USDC`));
+            console.log(chalk_1.default.gray(`  Order amount:          ${chalk_1.default.white(amount.toFixed(2))} USDC\n`));
+            if (unshieldedBalance > 0n) {
+                console.log(chalk_1.default.yellow(`  💡 You have ${unshieldedFormatted} USDC unshielded in your wallet.`));
+                console.log(chalk_1.default.gray(`     Shield it first with: shuffle shield usdc ${unshieldedFormatted}\n`));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`  💡 Get USDC with: shuffle faucet ${amount}`));
+                console.log(chalk_1.default.gray(`     Then shield it: shuffle shield usdc ${amount}\n`));
+            }
+            return;
+        }
+        const sig = await (0, output_1.withSpinner)("Placing encrypted order...", () => config.shuffleClient.placeOrder(pairId, dir, Math.floor(amount * 1000000), sourceAsset), "Order placed!");
+        (0, output_1.printTxSuccess)(sig, config.network);
+    }
+    catch (e) {
+        // Provide user-friendly error messages
+        const msg = e.message || "";
+        if (msg.includes("Unknown action") || msg.includes("undefined")) {
+            (0, output_1.printError)("You already have a pending order! Wait for batch execution or settle first with 'shuffle settle'.");
+        }
+        else if (msg.includes("already in use") || msg.includes("0x0")) {
+            (0, output_1.printError)("You already have a pending order in this batch. Wait for it to be settled.");
+        }
+        else if (msg.includes("insufficient") || msg.includes("balance")) {
+            (0, output_1.printError)("Insufficient balance for this order. Check your balance with 'shuffle balance'.");
+        }
+        else if (msg.includes("Account does not exist")) {
+            (0, output_1.printError)("Privacy account not found. Run 'shuffle init' first.");
+        }
+        else {
+            (0, output_1.printError)(msg);
+        }
+    }
+}
+/**
+ * Interactive order flow - asks user for each parameter
+ */
+async function executeInteractiveOrder(config) {
+    // @ts-ignore - inquirer types available after npm install
+    const inquirer = (await Promise.resolve().then(() => __importStar(require("inquirer")))).default;
+    (0, output_1.printHeader)("New Order");
+    console.log(chalk_1.default.gray("  Let's set up your private order!\n"));
+    // Check connection
+    if (!config.mockMode && !config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    // Check for existing pending order BEFORE interactive prompts
+    if (!config.mockMode && config.shuffleClient) {
+        try {
+            const existingOrder = await config.shuffleClient.getDecryptedOrder();
+            if (existingOrder) {
+                const pairLabels = ["TSLA/USDC", "SPY/USDC", "AAPL/USDC"];
+                const dirLabel = existingOrder.direction === 0 ? "BUY" : "SELL";
+                const orderAmount = (Number(existingOrder.amount) / 1000000).toFixed(2);
+                (0, output_1.printError)("You already have a pending order!");
+                console.log(chalk_1.default.gray(`\n  Pending order: ${chalk_1.default.white(dirLabel)} ${pairLabels[existingOrder.pairId] || "Unknown"}`));
+                console.log(chalk_1.default.gray(`  Amount:        ${chalk_1.default.white(orderAmount)} USDC`));
+                console.log(chalk_1.default.gray(`  Batch ID:      ${chalk_1.default.white(existingOrder.batchId)}\n`));
+                console.log(chalk_1.default.yellow(`  💡 Wait for batch execution, then settle with: shuffle settle`));
+                console.log(chalk_1.default.gray(`     Check status with: shuffle status\n`));
+                return;
+            }
+        }
+        catch (e) {
+            // Continue if check fails - will be caught later
+        }
+    }
+    // Available tokens (the ones user can BUY)
+    const allTokens = [
+        { name: "TSLA - Tesla Stock Token", value: "TSLA" },
+        { name: "SPY - S&P 500 ETF Token", value: "SPY" },
+        { name: "AAPL - Apple Stock Token", value: "AAPL" },
+        { name: "USDC - US Dollar Coin", value: "USDC" },
+    ];
+    // Step 1: What do you want to BUY?
+    const { buyToken } = await inquirer.prompt([{
+            type: "list",
+            name: "buyToken",
+            message: chalk_1.default.cyan("🎯 What token do you want to BUY?"),
+            choices: allTokens,
+            pageSize: 5,
+        }]);
+    // Step 2: Get user's balances to show what they CAN pay with
+    let balances = null;
+    if (config.mockMode) {
+        const state = (0, devnet_1.getMockState)();
+        balances = state.balances;
+    }
+    else {
+        try {
+            balances = await (0, output_1.withSpinner)("Checking your balances...", () => config.shuffleClient.getBalance(), "Balances loaded!");
+        }
+        catch (e) {
+            (0, output_1.printError)("Could not fetch balances. Run 'shuffle init' first.");
+            return;
+        }
+    }
+    // Filter: only show tokens user has balance in AND are different from buy token
+    const paymentOptions = [];
+    const tokenBalances = {
+        USDC: balances.usdc,
+        TSLA: balances.tsla,
+        SPY: balances.spy,
+        AAPL: balances.aapl,
+    };
+    for (const [token, balance] of Object.entries(tokenBalances)) {
+        if (token !== buyToken && balance > 0n) {
+            const displayBal = (Number(balance) / 1000000).toLocaleString("en-US", {
+                minimumFractionDigits: 2,
+                maximumFractionDigits: 6
+            });
+            paymentOptions.push({
+                name: `${token} (${displayBal} available)`,
+                value: token,
+                balance: Number(balance),
+            });
+        }
+    }
+    if (paymentOptions.length === 0) {
+        (0, output_1.printError)(`You don't have any tokens to pay with! Use 'shuffle faucet 100' to get USDC.`);
+        return;
+    }
+    // Step 3: What do you want to PAY with?
+    const { payToken } = await inquirer.prompt([{
+            type: "list",
+            name: "payToken",
+            message: chalk_1.default.cyan(`💰 What token do you want to PAY with for ${buyToken}?`),
+            choices: paymentOptions.map(p => ({ name: p.name, value: p.value })),
+            pageSize: 5,
+        }]);
+    const maxBalance = Number(tokenBalances[payToken]) / 1000000;
+    // Step 4: How much?
+    const { amount } = await inquirer.prompt([{
+            type: "input",
+            name: "amount",
+            message: chalk_1.default.cyan(`📊 How much ${payToken} do you want to spend? (max: ${maxBalance.toLocaleString()})`),
+            validate: (input) => {
+                const num = parseFloat(input);
+                if (isNaN(num) || num <= 0)
+                    return "Please enter a positive number";
+                if (num > maxBalance)
+                    return `Maximum available: ${maxBalance.toLocaleString()}`;
+                return true;
+            },
+        }]);
+    // Step 5: Confirmation
+    console.log();
+    console.log(chalk_1.default.bold.white("  📋 Order Summary:"));
+    console.log(chalk_1.default.gray(`     ├─ Buy:  ${chalk_1.default.green(buyToken)}`));
+    console.log(chalk_1.default.gray(`     ├─ Pay:  ${chalk_1.default.yellow(amount)} ${payToken}`));
+    console.log(chalk_1.default.gray(`     └─ Type: Private batch order`));
+    console.log();
+    const { confirm } = await inquirer.prompt([{
+            type: "confirm",
+            name: "confirm",
+            message: chalk_1.default.cyan("Confirm and place order?"),
+            default: true,
+        }]);
+    if (!confirm) {
+        (0, output_1.printInfo)("Order cancelled.");
+        return;
+    }
+    // Convert to pair and direction
+    const pairInfo = convertToPairAndDirection(buyToken, payToken);
+    if (!pairInfo) {
+        (0, output_1.printError)(`Trading pair ${buyToken}/${payToken} not supported.`);
+        return;
+    }
+    // Execute the order
+    await executeDirectOrder(config, pairInfo.pair, pairInfo.direction, amount);
+}
+/**
+ * Convert buy/pay tokens to pair and direction
+ */
+function convertToPairAndDirection(buyToken, payToken) {
+    // Define valid pairs: [base, quote] where base is first token in pair name
+    const pairs = [
+        { pair: "TSLA_USDC", base: "TSLA", quote: "USDC" },
+        { pair: "SPY_USDC", base: "SPY", quote: "USDC" },
+        { pair: "AAPL_USDC", base: "AAPL", quote: "USDC" },
+        { pair: "TSLA_SPY", base: "TSLA", quote: "SPY" },
+        { pair: "TSLA_AAPL", base: "TSLA", quote: "AAPL" },
+        { pair: "SPY_AAPL", base: "SPY", quote: "AAPL" },
+    ];
+    for (const p of pairs) {
+        // Buying base, paying quote = BtoA (quote → base)
+        if (buyToken === p.base && payToken === p.quote) {
+            return { pair: p.pair, direction: "buy" };
+        }
+        // Buying quote, paying base = AtoB (base → quote)
+        if (buyToken === p.quote && payToken === p.base) {
+            return { pair: p.pair, direction: "sell" };
+        }
+    }
+    return null;
+}
+/**
+ * shuffle settle - Settle pending order
+ */
+async function settleCommand() {
+    const config = (0, config_1.getConfig)();
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const state = (0, devnet_1.getMockState)();
+        if (!state.accountExists) {
+            (0, output_1.printError)("Account not found. Run 'shuffle init' first.");
+            return;
+        }
+        if (!state.pendingOrder) {
+            (0, output_1.printError)("No pending order to settle.");
+            return;
+        }
+        const progress = (0, output_1.createProgressSpinner)([
+            "Fetching batch execution results...",
+            "Calculating your pro-rata payout via MPC...",
+            "Updating encrypted balance...",
+        ]);
+        progress.start();
+        await (0, devnet_1.mockDelay)("fast");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("slow");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("medium");
+        // Simulate payout (slightly different amount due to "slippage")
+        const payoutAmount = (state.pendingOrder.amount * 99n) / 100n;
+        const assetLabels = ["USDC", "TSLA", "SPY", "AAPL"];
+        const outputAsset = state.pendingOrder.direction === 0 ? 0 : 1; // simplified
+        state.balances.usdc += payoutAmount; // Simplified: always pay in USDC
+        (0, devnet_1.updateMockState)({
+            balances: state.balances,
+            pendingOrder: null,
+            batchId: state.batchId + 1,
+        });
+        const payoutDisplay = (Number(payoutAmount) / 1000000).toLocaleString();
+        progress.succeed(`Settled! Received ${payoutDisplay} USDC`);
+        (0, output_1.printTxSuccess)((0, devnet_1.mockSignature)(), config.network);
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        const order = await config.shuffleClient.getDecryptedOrder();
+        if (!order) {
+            (0, output_1.printError)("No pending order to settle.");
+            return;
+        }
+        const sig = await (0, output_1.withSpinner)("Settling order...", () => config.shuffleClient.settleOrder(order.pairId, order.direction), "Order settled!");
+        (0, output_1.printTxSuccess)(sig, config.network);
+    }
+    catch (e) {
+        // Provide user-friendly error messages
+        const msg = e.message || "";
+        if (msg.includes("Unknown action") || msg.includes("undefined")) {
+            (0, output_1.printError)("No pending order to settle. Place an order first with 'shuffle order'.");
+        }
+        else if (msg.includes("not found") || msg.includes("Account does not exist")) {
+            (0, output_1.printError)("Privacy account not found. Run 'shuffle init' first.");
+        }
+        else if (msg.includes("batch") || msg.includes("executed")) {
+            (0, output_1.printError)("Batch not yet executed. Wait for batch execution before settling.");
+        }
+        else {
+            (0, output_1.printError)(msg);
+        }
+    }
+}
+/**
+ * shuffle execute - Trigger batch execution
+ */
+async function executeCommand() {
+    const config = (0, config_1.getConfig)();
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const state = (0, devnet_1.getMockState)();
+        const progress = (0, output_1.createProgressSpinner)([
+            "Checking batch status...",
+            "Triggering batch execution...",
+            "Waiting for MPC computation...",
+            "Batch executed!",
+        ]);
+        progress.start();
+        await (0, devnet_1.mockDelay)("fast");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("medium");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("slow");
+        progress.nextStep();
+        (0, devnet_1.updateMockState)({ batchId: state.batchId + 1 });
+        progress.succeed("Batch executed successfully!");
+        (0, output_1.printTxSuccess)((0, devnet_1.mockSignature)(), config.network);
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        // First check batch status
+        const batch = await config.shuffleClient.getBatchInfo();
+        console.log(chalk_1.default.gray(`\n  Current batch: #${batch.batchId}`));
+        console.log(chalk_1.default.gray(`  Orders: ${batch.orderCount}/8\n`));
+        if (batch.orderCount < 8) {
+            (0, output_1.printError)(`Not enough orders: ${batch.orderCount}/8. Need 8 orders to execute.`);
+            return;
+        }
+        const sig = await (0, output_1.withSpinner)("Executing batch (this may take ~60 seconds)...", () => config.shuffleClient.executeBatch(), "Batch executed!");
+        (0, output_1.printSuccess)(`Batch #${batch.batchId} executed successfully!`);
+        (0, output_1.printTxSuccess)(sig, config.network);
+        console.log(chalk_1.default.cyan("\n  Users can now settle their orders with 'shuffle settle'\n"));
+    }
+    catch (e) {
+        const msg = e.message || "";
+        if (msg.includes("Not enough orders")) {
+            (0, output_1.printError)(msg);
+        }
+        else if (msg.includes("already executed")) {
+            (0, output_1.printError)("Batch already executed. Orders have been reset for the next batch.");
+        }
+        else {
+            (0, output_1.printError)(msg);
+        }
+    }
+}
+/**
+ * shuffle status - View batch and order status
+ */
+async function statusCommand() {
+    const config = (0, config_1.getConfig)();
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const state = (0, devnet_1.getMockState)();
+        if (!state.accountExists) {
+            (0, output_1.printError)("Account not found. Run 'shuffle init' first.");
+            return;
+        }
+        await (0, output_1.withSpinner)("Fetching status...", () => (0, devnet_1.mockDelay)("fast"), "Status retrieved!");
+        (0, output_1.printHeader)("Batch Status");
+        (0, output_1.printBatchStatus)({
+            batchId: state.batchId,
+            orderCount: state.pendingOrder ? 1 : 0,
+        });
+        console.log();
+        (0, output_1.printHeader)("Your Order Status");
+        if (!state.pendingOrder) {
+            console.log(chalk_1.default.gray("  No pending order\n"));
+        }
+        else {
+            const pairLabels = ["TSLA/USDC", "SPY/USDC", "AAPL/USDC"];
+            const dirLabel = state.pendingOrder.direction === 0 ? "BUY" : "SELL";
+            const orderAmount = (Number(state.pendingOrder.amount) / 1000000).toFixed(2);
+            const isExecuted = state.batchId > state.pendingOrder.batchId;
+            console.log(chalk_1.default.gray(`  Pair:      ${chalk_1.default.white(pairLabels[state.pendingOrder.pairId] || "Unknown")}`));
+            console.log(chalk_1.default.gray(`  Direction: ${chalk_1.default.white(dirLabel)}`));
+            console.log(chalk_1.default.gray(`  Amount:    ${chalk_1.default.white(orderAmount)} USDC`));
+            console.log(chalk_1.default.gray(`  Batch ID:  ${chalk_1.default.white(state.pendingOrder.batchId)}`));
+            if (isExecuted) {
+                const payoutAmount = (Number(state.pendingOrder.amount) / 10000000).toFixed(2);
+                const outputAsset = state.pendingOrder.pairId === 0 ? "TSLA" : "SPY";
+                console.log();
+                console.log(chalk_1.default.green(`  ✓ Executed`));
+                console.log(chalk_1.default.gray(`  Payout: ${chalk_1.default.cyan(payoutAmount)} ${outputAsset}`));
+            }
+            else {
+                console.log();
+                console.log(chalk_1.default.yellow(`  ⏳ Pending`));
+            }
+        }
+        console.log();
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        const [batchInfo, order, estimatedPayout] = await Promise.all([
+            config.shuffleClient.getBatchInfo(),
+            config.shuffleClient.getDecryptedOrder(),
+            config.shuffleClient.estimatePayout(),
+        ]);
+        (0, output_1.printHeader)("Batch Status");
+        (0, output_1.printBatchStatus)(batchInfo);
+        console.log();
+        (0, output_1.printHeader)("Your Order Status");
+        if (!order) {
+            console.log(chalk_1.default.gray("  No pending order\n"));
+        }
+        else {
+            const pairLabels = ["TSLA/USDC", "SPY/USDC", "AAPL/USDC"];
+            const dirLabel = order.direction === 0 ? "BUY" : "SELL";
+            const orderAmount = (Number(order.amount) / 1000000).toFixed(2);
+            // Check if batch was executed by seeing if estimatePayout returned a value
+            const isExecuted = estimatedPayout !== null;
+            console.log(chalk_1.default.gray(`  Pair:      ${chalk_1.default.white(pairLabels[order.pairId] || "Unknown")}`));
+            console.log(chalk_1.default.gray(`  Direction: ${chalk_1.default.white(dirLabel)}`));
+            console.log(chalk_1.default.gray(`  Amount:    ${chalk_1.default.white(orderAmount)} USDC`));
+            console.log(chalk_1.default.gray(`  Batch ID:  ${chalk_1.default.white(order.batchId)}`));
+            if (isExecuted) {
+                const payoutAmount = (Number(estimatedPayout.estimatedPayout) / 1000000).toFixed(2);
+                const outputAsset = ["USDC", "TSLA", "SPY", "AAPL"][estimatedPayout.outputAssetId] || "tokens";
+                console.log();
+                console.log(chalk_1.default.green(`  ✓ Executed`));
+                console.log(chalk_1.default.gray(`  Payout: ${chalk_1.default.cyan(payoutAmount)} ${outputAsset}`));
+            }
+            else {
+                console.log();
+                console.log(chalk_1.default.yellow(`  ⏳ Pending`));
+            }
+        }
+        console.log();
+    }
+    catch (e) {
+        // Provide user-friendly error messages
+        const msg = e.message || "";
+        if (msg.includes("Account does not exist") || msg.includes("not found")) {
+            (0, output_1.printError)("Privacy account not found. Run 'shuffle init' first.");
+        }
+        else {
+            (0, output_1.printError)(msg);
+        }
+    }
+}
+// ============================================================================
+// DEVNET COMMANDS
+// ============================================================================
+/**
+ * shuffle faucet <amount> - Mint USDC to wallet
+ */
+async function faucetCommand(amountStr) {
+    const config = (0, config_1.getConfig)();
+    const amount = parseFloat(amountStr);
+    if (isNaN(amount) || amount <= 0) {
+        (0, output_1.printError)("Invalid amount. Must be a positive number.");
+        return;
+    }
+    const amountRaw = BigInt(Math.floor(amount * 1000000));
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        const state = (0, devnet_1.getMockState)();
+        const progress = (0, output_1.createProgressSpinner)([
+            "Connecting to USDC faucet...",
+            `Minting ${amount.toLocaleString()} USDC to your wallet...`,
+            "Tokens received!",
+        ]);
+        progress.start();
+        await (0, devnet_1.mockDelay)("fast");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("medium");
+        progress.nextStep();
+        await (0, devnet_1.mockDelay)("fast");
+        // In mock mode, also update account balance if it exists
+        if (state.accountExists) {
+            state.balances.usdc += amountRaw;
+            (0, devnet_1.updateMockState)({ balances: state.balances });
+        }
+        progress.succeed(`Received ${amount.toLocaleString()} USDC!`);
+        console.log(chalk_1.default.gray(`  Token: ${devnet_1.DEVNET_CONFIG.mints.USDC.toBase58().slice(0, 20)}...`));
+        (0, output_1.printTxSuccess)((0, devnet_1.mockSignature)(), config.network);
+        return;
+    }
+    // Real mode - mint USDC via ShuffleClient
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected to Shuffle protocol");
+        return;
+    }
+    try {
+        const sig = await (0, output_1.withSpinner)(`Minting ${amount.toLocaleString()} USDC to your wallet...`, async () => {
+            // Use the client's mintToWallet method if available, otherwise show helpful error
+            if (typeof config.shuffleClient.mintUsdcToWallet === "function") {
+                return await config.shuffleClient.mintUsdcToWallet(Math.floor(amount * 1000000));
+            }
+            // Fallback: try to get mint and mint directly
+            const { mintTo, getOrCreateAssociatedTokenAccount } = await Promise.resolve().then(() => __importStar(require("@solana/spl-token")));
+            const { Keypair } = await Promise.resolve().then(() => __importStar(require("@solana/web3.js")));
+            const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+            const path = await Promise.resolve().then(() => __importStar(require("path")));
+            const os = await Promise.resolve().then(() => __importStar(require("os")));
+            const pool = await config.shuffleClient.program.account.pool.fetch(config.shuffleClient.poolPDA);
+            const usdcMint = pool.usdcMint;
+            const connection = config.connection;
+            // Load the DEFAULT keypair (has mint authority) instead of current user
+            const defaultKeypairPath = path.join(os.homedir(), ".config", "solana", "id.json");
+            if (!fs.existsSync(defaultKeypairPath)) {
+                throw new Error("Main wallet not found. Faucet requires default Solana keypair with mint authority.");
+            }
+            const defaultRaw = JSON.parse(fs.readFileSync(defaultKeypairPath, "utf-8"));
+            const mintAuthority = Keypair.fromSecretKey(Uint8Array.from(defaultRaw));
+            // Current user's public key (where tokens will go)
+            const recipientPubkey = config.wallet.publicKey;
+            // Get or create user's token account (use mint authority as payer since they have SOL)
+            const tokenAccount = await getOrCreateAssociatedTokenAccount(connection, mintAuthority, // payer
+            usdcMint, recipientPubkey // owner (the current user profile)
+            );
+            // Mint tokens using the mint authority
+            const mintSig = await mintTo(connection, mintAuthority, usdcMint, tokenAccount.address, mintAuthority, // mint authority
+            Math.floor(amount * 1000000));
+            return mintSig;
+        }, `Received ${amount.toLocaleString()} USDC!`);
+        (0, output_1.printTxSuccess)(sig, config.network);
+    }
+    catch (e) {
+        // Improve error messages
+        if (e.message?.includes("mint authority")) {
+            (0, output_1.printError)("Cannot mint: you don't have mint authority. Only works on localnet.");
+        }
+        else if (e.message?.includes("insufficient funds")) {
+            (0, output_1.printError)("Insufficient SOL for transaction fees. Request an airdrop first with 'shuffle airdrop'.");
+        }
+        else {
+            (0, output_1.printError)(e.message || "Faucet failed");
+        }
+    }
+}
+/**
+ * shuffle airdrop [amount] - Airdrop SOL on localnet
+ */
+async function airdropCommand(amountStr) {
+    const config = (0, config_1.getConfig)();
+    const amount = amountStr ? parseFloat(amountStr) : 2; // Default 2 SOL
+    if (isNaN(amount) || amount <= 0) {
+        (0, output_1.printError)("Invalid amount. Must be a positive number.");
+        return;
+    }
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        await (0, devnet_1.mockDelay)("fast");
+        (0, output_1.printSuccess)(`Airdropped ${amount} SOL (mock)`);
+        return;
+    }
+    // Real mode
+    if (!config.connection) {
+        (0, output_1.printError)("Not connected");
+        return;
+    }
+    try {
+        const pubkey = config.wallet.publicKey;
+        console.log(chalk_1.default.gray(`\n  Wallet: ${pubkey.toBase58()}`));
+        const sig = await (0, output_1.withSpinner)(`Requesting ${amount} SOL airdrop...`, async () => {
+            const signature = await config.connection.requestAirdrop(pubkey, amount * 1000000000 // Convert SOL to lamports
+            );
+            // Wait for confirmation
+            await config.connection.confirmTransaction(signature, "confirmed");
+            return signature;
+        }, `Received ${amount} SOL!`);
+        const balance = await config.connection.getBalance(pubkey);
+        console.log(chalk_1.default.gray(`  Balance: ${(balance / 1000000000).toFixed(4)} SOL\n`));
+        (0, output_1.printTxSuccess)(sig, config.network);
+    }
+    catch (e) {
+        if (e.message?.includes("airdrop request")) {
+            (0, output_1.printError)("Airdrop limit reached. Try again later or use a different network.");
+        }
+        else {
+            (0, output_1.printError)(e.message || "Airdrop failed");
+        }
+    }
+}
+/**
+ * shuffle history - Show all executed batch logs
+ */
+async function historyCommand() {
+    const config = (0, config_1.getConfig)();
+    if (config.mockMode) {
+        (0, output_1.printMockWarning)();
+        await (0, devnet_1.mockDelay)("fast");
+        // Mock data for demo
+        const mockLogs = [
+            {
+                batchId: 1,
+                results: [
+                    { totalAIn: { toString: () => "1000000" }, totalBIn: { toString: () => "250000" }, finalPoolA: { toString: () => "750000" }, finalPoolB: { toString: () => "250000" } },
+                    { totalAIn: { toString: () => "0" }, totalBIn: { toString: () => "0" }, finalPoolA: { toString: () => "0" }, finalPoolB: { toString: () => "0" } },
+                    { totalAIn: { toString: () => "0" }, totalBIn: { toString: () => "0" }, finalPoolA: { toString: () => "0" }, finalPoolB: { toString: () => "0" } },
+                    { totalAIn: { toString: () => "0" }, totalBIn: { toString: () => "0" }, finalPoolA: { toString: () => "0" }, finalPoolB: { toString: () => "0" } },
+                    { totalAIn: { toString: () => "0" }, totalBIn: { toString: () => "0" }, finalPoolA: { toString: () => "0" }, finalPoolB: { toString: () => "0" } },
+                    { totalAIn: { toString: () => "0" }, totalBIn: { toString: () => "0" }, finalPoolA: { toString: () => "0" }, finalPoolB: { toString: () => "0" } },
+                ],
+            },
+        ];
+        (0, output_1.printBatchHistory)(mockLogs);
+        return;
+    }
+    // Real mode
+    if (!config.shuffleClient) {
+        (0, output_1.printError)("Not connected. Run 'shuffle balance' first to initialize.");
+        return;
+    }
+    try {
+        const logs = await (0, output_1.withSpinner)("Fetching batch history...", () => config.shuffleClient.getAllBatchLogs(), "History loaded!");
+        (0, output_1.printBatchHistory)(logs);
+    }
+    catch (e) {
+        (0, output_1.printError)(e.message || "Failed to fetch batch history");
+    }
+}