@shuffle-protocol/sdk 0.1.0

package/dist/client.js

@@ -0,0 +1,691 @@
+"use strict";
+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.ShuffleClient = void 0;
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const client_1 = require("@arcium-hq/client");
+const crypto_1 = require("crypto");
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+const encryption_1 = require("./encryption");
+const shuffle_protocol_json_1 = __importDefault(require("./idl/shuffle_protocol.json"));
+class ShuffleClient {
+    constructor(config) {
+        // Encryption state (set via initEncryption)
+        this.cipher = null;
+        this.encryptionPublicKey = null;
+        this.connection = config.connection;
+        this.wallet = config.wallet;
+        this.programId = config.programId || constants_1.PROGRAM_ID;
+        this.clusterOffset = config.clusterOffset ?? 0; // Default to 0 for localnet
+        this.provider = new anchor.AnchorProvider(this.connection, this.wallet, {
+            commitment: "confirmed",
+            skipPreflight: true,
+        });
+        // Create a modified IDL with the correct program address
+        const idlWithAddress = { ...shuffle_protocol_json_1.default, address: this.programId.toBase58() };
+        this.program = new anchor_1.Program(idlWithAddress, this.provider);
+    }
+    /** Async factory — creates and initializes the client */
+    static async create(config) {
+        const client = new ShuffleClient(config);
+        await client.initialize();
+        return client;
+    }
+    async initialize() {
+        this.clusterAccount = (0, client_1.getClusterAccAddress)(this.clusterOffset);
+        [this.poolPDA] = (0, pda_1.getPoolPDA)(this.programId);
+        [this.batchAccumulatorPDA] = (0, pda_1.getBatchAccumulatorPDA)(this.programId);
+        this.mxePublicKey = await (0, encryption_1.fetchMXEPublicKey)(this.provider, this.programId);
+    }
+    /** Get the MXE public key (needed for cipher creation) */
+    getMXEPublicKey() {
+        return this.mxePublicKey;
+    }
+    /** Get the underlying Anchor program */
+    getProgram() {
+        return this.program;
+    }
+    /**
+     * Initialize encryption from a user's x25519 private key.
+     * Creates the cipher and derives the public key.
+     * Call this after create() to enable encrypted operations.
+     */
+    initEncryption(privateKey) {
+        const keypair = require("@arcium-hq/client").x25519;
+        this.encryptionPublicKey = keypair.getPublicKey(privateKey);
+        this.cipher = (0, encryption_1.createCipher)(privateKey, this.mxePublicKey);
+    }
+    /** Get the encryption public key (available after initEncryption) */
+    getEncryptionPublicKey() {
+        return this.encryptionPublicKey;
+    }
+    /** Get the cipher (available after initEncryption) */
+    getCipher() {
+        return this.cipher;
+    }
+    _requireEncryption() {
+        if (!this.cipher || !this.encryptionPublicKey) {
+            throw new Error("Encryption not initialized. Call initEncryption(privateKey) first.");
+        }
+        return { cipher: this.cipher, pubkey: this.encryptionPublicKey };
+    }
+    // =========================================================================
+    // ACCOUNT METHODS
+    // =========================================================================
+    /** Create a new user privacy account. Uses internal encryption if initialized. */
+    async createUserAccount(encryptionPublicKey) {
+        const pubkey = encryptionPublicKey || this._requireEncryption().pubkey;
+        const enc = this.cipher || (0, encryption_1.createCipher)((0, encryption_1.generateEncryptionKeypair)().privateKey, this.mxePublicKey);
+        const owner = this.wallet.publicKey;
+        const [userAccountPDA] = (0, pda_1.getUserAccountPDA)(this.programId, owner);
+        const initialNonce = (0, crypto_1.randomBytes)(16);
+        const encryptedZero = enc.encrypt([BigInt(0)], initialNonce);
+        const initialBalances = [
+            Array.from(encryptedZero[0]),
+            Array.from(encryptedZero[0]),
+            Array.from(encryptedZero[0]),
+            Array.from(encryptedZero[0]),
+        ];
+        const sig = await this.program.methods
+            .createUserAccount(Array.from(pubkey), initialBalances, (0, encryption_1.nonceToBN)(initialNonce))
+            .accounts({
+            payer: owner,
+            owner: owner,
+            userAccount: userAccountPDA,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .rpc({ commitment: "confirmed" });
+        return sig;
+    }
+    /** Fetch UserProfile data for an owner */
+    async fetchUserAccount(owner) {
+        const target = owner || this.wallet.publicKey;
+        const [userAccountPDA] = (0, pda_1.getUserAccountPDA)(this.programId, target);
+        return this.program.account.userProfile.fetch(userAccountPDA);
+    }
+    /** Check if account exists */
+    async accountExists(owner) {
+        try {
+            await this.fetchUserAccount(owner);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // =========================================================================
+    // BALANCE METHODS
+    // =========================================================================
+    /** Deposit tokens into the protocol (add_balance). Uses internal encryption if params omitted. */
+    async deposit(assetId, amount, cipher, encryptionPublicKey) {
+        const enc = cipher || this._requireEncryption().cipher;
+        const pubkey = encryptionPublicKey || this._requireEncryption().pubkey;
+        const owner = this.wallet.publicKey;
+        const [userAccountPDA] = (0, pda_1.getUserAccountPDA)(this.programId, owner);
+        const assetSeed = constants_1.VAULT_ASSET_SEEDS[assetId];
+        const [vaultPDA] = (0, pda_1.getVaultPDA)(this.programId, assetSeed);
+        // Get the pool to find the correct mint
+        const pool = await this.program.account.pool.fetch(this.poolPDA);
+        const mints = [pool.usdcMint, pool.tslaMint, pool.spyMint, pool.aaplMint];
+        const mint = mints[assetId];
+        // Find user's token account for this mint
+        const { getAssociatedTokenAddress } = await Promise.resolve().then(() => __importStar(require("@solana/spl-token")));
+        const userTokenAccount = await getAssociatedTokenAddress(mint, owner);
+        const nonce = (0, crypto_1.randomBytes)(16);
+        const encrypted = (0, encryption_1.encryptValue)(enc, BigInt(amount), nonce);
+        const computationOffset = this._generateComputationOffset();
+        const sig = await this.program.methods
+            .addBalance(computationOffset, Array.from(encrypted.ciphertext), Array.from(pubkey), (0, encryption_1.nonceToBN)(nonce), new anchor.BN(amount), assetId)
+            .accountsPartial({
+            payer: owner,
+            user: owner,
+            pool: this.poolPDA,
+            userAccount: userAccountPDA,
+            userTokenAccount,
+            vault: vaultPDA,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            ...this._getArciumAccounts("add_balance", computationOffset),
+        })
+            .rpc({ skipPreflight: true, commitment: "confirmed" });
+        await this._awaitComputation(computationOffset);
+        return sig;
+    }
+    /** Withdraw tokens from the protocol (sub_balance). Uses internal encryption if params omitted. */
+    async withdraw(assetId, amount, cipher, encryptionPublicKey) {
+        const enc = cipher || this._requireEncryption().cipher;
+        const pubkey = encryptionPublicKey || this._requireEncryption().pubkey;
+        const owner = this.wallet.publicKey;
+        const [userAccountPDA] = (0, pda_1.getUserAccountPDA)(this.programId, owner);
+        const assetSeed = constants_1.VAULT_ASSET_SEEDS[assetId];
+        const [vaultPDA] = (0, pda_1.getVaultPDA)(this.programId, assetSeed);
+        const pool = await this.program.account.pool.fetch(this.poolPDA);
+        const mints = [pool.usdcMint, pool.tslaMint, pool.spyMint, pool.aaplMint];
+        const mint = mints[assetId];
+        const { getAssociatedTokenAddress } = await Promise.resolve().then(() => __importStar(require("@solana/spl-token")));
+        const recipientTokenAccount = await getAssociatedTokenAddress(mint, owner);
+        const nonce = (0, crypto_1.randomBytes)(16);
+        const encrypted = (0, encryption_1.encryptValue)(enc, BigInt(amount), nonce);
+        const computationOffset = this._generateComputationOffset();
+        const sig = await this.program.methods
+            .subBalance(computationOffset, Array.from(encrypted.ciphertext), Array.from(pubkey), (0, encryption_1.nonceToBN)(nonce), new anchor.BN(amount), assetId)
+            .accountsPartial({
+            payer: owner,
+            user: owner,
+            pool: this.poolPDA,
+            userAccount: userAccountPDA,
+            recipientTokenAccount,
+            vault: vaultPDA,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            ...this._getArciumAccounts("sub_balance", computationOffset),
+        })
+            .rpc({ skipPreflight: true, commitment: "confirmed" });
+        await this._awaitComputation(computationOffset);
+        return sig;
+    }
+    /** Decrypt all 4 asset balances from on-chain account. Uses internal cipher if param omitted. */
+    async getBalance(cipher, owner) {
+        const enc = cipher || this._requireEncryption().cipher;
+        const account = await this.fetchUserAccount(owner);
+        const nonceToBytes = (n) => {
+            const bn = new anchor.BN(n.toString());
+            return new Uint8Array(bn.toArray("le", 16));
+        };
+        return {
+            usdc: (0, encryption_1.decryptValue)(enc, new Uint8Array(account.usdcCredit), nonceToBytes(account.usdcNonce)),
+            tsla: (0, encryption_1.decryptValue)(enc, new Uint8Array(account.tslaCredit), nonceToBytes(account.tslaNonce)),
+            spy: (0, encryption_1.decryptValue)(enc, new Uint8Array(account.spyCredit), nonceToBytes(account.spyNonce)),
+            aapl: (0, encryption_1.decryptValue)(enc, new Uint8Array(account.aaplCredit), nonceToBytes(account.aaplNonce)),
+        };
+    }
+    /** Get unshielded (normal SPL token) balances from wallet */
+    async getUnshieldedBalances(owner) {
+        const userPubkey = owner || this.wallet.publicKey;
+        // Fetch pool to get mint addresses
+        const poolAccount = await this.program.account.pool.fetch(this.poolPDA);
+        const mints = {
+            usdc: poolAccount.usdcMint,
+            tsla: poolAccount.tslaMint,
+            spy: poolAccount.spyMint,
+            aapl: poolAccount.aaplMint,
+        };
+        const getTokenBalance = async (mint) => {
+            try {
+                const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, userPubkey);
+                const account = await (0, spl_token_1.getAccount)(this.connection, ata);
+                return account.amount;
+            }
+            catch (e) {
+                // Return 0 if account doesn't exist
+                if (e instanceof spl_token_1.TokenAccountNotFoundError) {
+                    return BigInt(0);
+                }
+                throw e;
+            }
+        };
+        const [usdc, tsla, spy, aapl] = await Promise.all([
+            getTokenBalance(mints.usdc),
+            getTokenBalance(mints.tsla),
+            getTokenBalance(mints.spy),
+            getTokenBalance(mints.aapl),
+        ]);
+        return { usdc, tsla, spy, aapl };
+    }
+    /** Internal P2P transfer (USDC only). Uses internal encryption if params omitted. */
+    async transfer(recipientPubkey, amount, cipher, encryptionPublicKey) {
+        const enc = cipher || this._requireEncryption().cipher;
+        const pubkey = encryptionPublicKey || this._requireEncryption().pubkey;
+        const sender = this.wallet.publicKey;
+        const [senderAccountPDA] = (0, pda_1.getUserAccountPDA)(this.programId, sender);
+        const [recipientAccountPDA] = (0, pda_1.getUserAccountPDA)(this.programId, recipientPubkey);
+        const nonce = (0, crypto_1.randomBytes)(16);
+        const encrypted = (0, encryption_1.encryptValue)(enc, BigInt(amount), nonce);
+        const computationOffset = this._generateComputationOffset();
+        const sig = await this.program.methods
+            .internalTransfer(computationOffset, Array.from(encrypted.ciphertext), Array.from(pubkey), (0, encryption_1.nonceToBN)(nonce))
+            .accountsPartial({
+            payer: sender,
+            sender: sender,
+            senderAccount: senderAccountPDA,
+            recipientAccount: recipientAccountPDA,
+            ...this._getArciumAccounts("transfer", computationOffset),
+        })
+            .rpc({ skipPreflight: true, commitment: "confirmed" });
+        await this._awaitComputation(computationOffset);
+        return sig;
+    }
+    // =========================================================================
+    // ORDER METHODS
+    // =========================================================================
+    /**
+     * Initialize batch state with encrypted zeros.
+     * This must be called before the first order of each new batch.
+     * After batch execution, the batch state needs to be re-initialized for the next batch.
+     */
+    async initBatchState() {
+        const owner = this.wallet.publicKey;
+        const computationOffset = this._generateComputationOffset();
+        const sig = await this.program.methods
+            .initBatchState(computationOffset)
+            .accountsPartial({
+            payer: owner,
+            batchAccumulator: this.batchAccumulatorPDA,
+            ...this._getArciumAccounts("init_batch_state", computationOffset),
+        })
+            .rpc({ skipPreflight: true, commitment: "confirmed" });
+        await this._awaitComputation(computationOffset);
+        return sig;
+    }
+    /**
+     * Place an encrypted order in the current batch.
+     * Automatically initializes batch state if needed (first order of a new batch).
+     * Uses internal encryption if params omitted.
+     */
+    async placeOrder(pairId, direction, amount, sourceAssetId, cipher, encryptionPublicKey) {
+        // Lazy check: If mxe_nonce is 0, batch state needs initialization
+        // (mxe_nonce is set by init_batch_state callback, 0 means not yet initialized)
+        const batchInfo = await this.getBatchInfo();
+        if (batchInfo.mxeNonce === "0") {
+            console.log("[SDK] Initializing batch state for new batch...");
+            await this.initBatchState();
+            console.log("[SDK] Batch state initialized");
+        }
+        const enc = cipher || this._requireEncryption().cipher;
+        const pubkey = encryptionPublicKey || this._requireEncryption().pubkey;
+        const owner = this.wallet.publicKey;
+        const [userAccountPDA] = (0, pda_1.getUserAccountPDA)(this.programId, owner);
+        const orderNonce = (0, crypto_1.randomBytes)(16);
+        // Encrypt OrderInput struct fields together in a single call
+        // The circuit expects Enc<Shared, OrderInput> where OrderInput = { pair_id: u8, direction: u8, amount: u64 }
+        const encryptedOrderInput = enc.encrypt([BigInt(pairId), BigInt(direction), BigInt(amount)], orderNonce);
+        const computationOffset = this._generateComputationOffset();
+        const sig = await this.program.methods
+            .placeOrder(computationOffset, Array.from(encryptedOrderInput[0]), Array.from(encryptedOrderInput[1]), Array.from(encryptedOrderInput[2]), Array.from(pubkey), (0, encryption_1.nonceToBN)(orderNonce), sourceAssetId)
+            .accountsPartial({
+            payer: owner,
+            user: owner,
+            userAccount: userAccountPDA,
+            batchAccumulator: this.batchAccumulatorPDA,
+            ...this._getArciumAccounts("accumulate_order", computationOffset),
+        })
+            .rpc({ skipPreflight: true, commitment: "confirmed" });
+        await this._awaitComputation(computationOffset);
+        return sig;
+    }
+    /** Get current pending order info, or null */
+    async getPendingOrder(owner) {
+        const account = await this.fetchUserAccount(owner);
+        if (!account.pendingOrder)
+            return null;
+        const order = account.pendingOrder;
+        return {
+            batchId: order.batchId.toNumber(),
+            pairId: Array.from(order.pairId),
+            direction: Array.from(order.direction),
+            encryptedAmount: Array.from(order.encryptedAmount),
+        };
+    }
+    /**
+     * Get decrypted pending order info.
+     * Decrypts pairId, direction, and amount using user's cipher.
+     * The order nonce is stored on-chain, so no need to save it locally.
+     *
+     * @param cipher - Optional cipher (uses internal if omitted)
+     * @param owner - Optional owner pubkey (uses wallet if omitted)
+     */
+    async getDecryptedOrder(cipher, owner) {
+        const enc = cipher || this._requireEncryption().cipher;
+        const account = await this.fetchUserAccount(owner);
+        if (!account.pendingOrder)
+            return null;
+        const order = account.pendingOrder;
+        // Get the nonce from the on-chain account
+        const orderNonce = new anchor.BN(order.orderNonce.toString());
+        const nonceBytes = new Uint8Array(orderNonce.toArray("le", 16));
+        // Decrypt the order fields using the user's cipher
+        // Orders are encrypted with Enc<Shared,*> so user can decrypt
+        // All fields were encrypted together, so decrypt together
+        const decryptedFields = enc.decrypt([
+            Array.from(order.pairId),
+            Array.from(order.direction),
+            Array.from(order.encryptedAmount),
+        ], nonceBytes);
+        return {
+            batchId: order.batchId.toNumber(),
+            pairId: Number(decryptedFields[0]),
+            direction: Number(decryptedFields[1]),
+            amount: decryptedFields[2],
+        };
+    }
+    /** Cancel pending order — not yet implemented */
+    async cancelOrder() {
+        throw new Error("Not implemented (Phase 11)");
+    }
+    // =========================================================================
+    // BATCH EXECUTION
+    // =========================================================================
+    /** Execute the current batch when 8+ orders are accumulated. Anyone can call this. */
+    async executeBatch() {
+        const batch = await this.getBatchInfo();
+        if (batch.orderCount < 8) {
+            throw new Error(`Not enough orders: ${batch.orderCount}/8. Need 8 orders to execute.`);
+        }
+        const batchId = batch.batchId;
+        const [batchLogPDA] = (0, pda_1.getBatchLogPDA)(this.programId, batchId);
+        // Derive vault PDAs
+        const [vaultUsdcPDA] = (0, pda_1.getVaultPDA)(this.programId, "usdc");
+        const [vaultTslaPDA] = (0, pda_1.getVaultPDA)(this.programId, "tsla");
+        const [vaultSpyPDA] = (0, pda_1.getVaultPDA)(this.programId, "spy");
+        const [vaultAaplPDA] = (0, pda_1.getVaultPDA)(this.programId, "aapl");
+        // Derive reserve PDAs
+        const [reserveUsdcPDA] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reserve"), Buffer.from("usdc")], this.programId);
+        const [reserveTslaPDA] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reserve"), Buffer.from("tsla")], this.programId);
+        const [reserveSpyPDA] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reserve"), Buffer.from("spy")], this.programId);
+        const [reserveAaplPDA] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reserve"), Buffer.from("aapl")], this.programId);
+        const computationOffset = this._generateComputationOffset();
+        const owner = this.wallet.publicKey;
+        const sig = await this.program.methods
+            .executeBatch(computationOffset)
+            .accountsPartial({
+            payer: owner,
+            caller: owner,
+            pool: this.poolPDA,
+            batchAccumulator: this.batchAccumulatorPDA,
+            batchLog: batchLogPDA,
+            // Vault accounts
+            vaultUsdc: vaultUsdcPDA,
+            vaultTsla: vaultTslaPDA,
+            vaultSpy: vaultSpyPDA,
+            vaultAapl: vaultAaplPDA,
+            // Reserve accounts
+            reserveUsdc: reserveUsdcPDA,
+            reserveTsla: reserveTslaPDA,
+            reserveSpy: reserveSpyPDA,
+            reserveAapl: reserveAaplPDA,
+            // Token program
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            // Arcium accounts
+            ...this._getArciumAccounts("reveal_batch", computationOffset),
+        })
+            .rpc({ skipPreflight: true, commitment: "confirmed" });
+        // Wait for MPC computation
+        await this._awaitComputation(computationOffset);
+        return sig;
+    }
+    // =========================================================================
+    // SETTLEMENT METHODS
+    // =========================================================================
+    /** Settle a pending order after batch execution. Uses internal encryption if param omitted. */
+    async settleOrder(pairId, direction, encryptionPublicKey) {
+        const pubkey = encryptionPublicKey || this._requireEncryption().pubkey;
+        const owner = this.wallet.publicKey;
+        const [userAccountPDA] = (0, pda_1.getUserAccountPDA)(this.programId, owner);
+        const account = await this.fetchUserAccount();
+        if (!account.pendingOrder)
+            throw new Error("No pending order to settle");
+        const batchId = account.pendingOrder.batchId.toNumber();
+        const [batchLogPDA] = (0, pda_1.getBatchLogPDA)(this.programId, batchId);
+        const settlementNonce = (0, crypto_1.randomBytes)(16);
+        const computationOffset = this._generateComputationOffset();
+        const sig = await this.program.methods
+            .settleOrder(computationOffset, Array.from(pubkey), (0, encryption_1.nonceToBN)(settlementNonce), pairId, direction)
+            .accountsPartial({
+            payer: owner,
+            user: owner,
+            userAccount: userAccountPDA,
+            batchLog: batchLogPDA,
+            ...this._getArciumAccounts("calculate_payout", computationOffset),
+        })
+            .rpc({ skipPreflight: true, commitment: "confirmed" });
+        await this._awaitComputation(computationOffset);
+        return sig;
+    }
+    // =========================================================================
+    // QUERY METHODS
+    // =========================================================================
+    /** Fetch current batch accumulator state */
+    async getBatchInfo() {
+        const batch = await this.program.account.batchAccumulator.fetch(this.batchAccumulatorPDA);
+        return {
+            batchId: batch.batchId.toNumber(),
+            orderCount: batch.orderCount,
+            mxeNonce: batch.mxeNonce.toString(),
+        };
+    }
+    /** Fetch historical batch log */
+    async getBatchLog(batchId) {
+        const [batchLogPDA] = (0, pda_1.getBatchLogPDA)(this.programId, batchId);
+        const log = await this.program.account.batchLog.fetch(batchLogPDA);
+        // Note: Anchor uses camelCase field names (converted from Rust's snake_case)
+        const results = log.results.map((r) => ({
+            totalAIn: r.totalAIn ?? r.total_a_in,
+            totalBIn: r.totalBIn ?? r.total_b_in,
+            finalPoolA: r.finalPoolA ?? r.final_pool_a,
+            finalPoolB: r.finalPoolB ?? r.final_pool_b,
+        }));
+        return {
+            batchId: log.batchId?.toNumber() ?? log.batch_id?.toNumber(),
+            results,
+        };
+    }
+    /**
+     * Fetch all historical batch logs.
+     * Iterates from batch 1 to the current batch ID and returns all found logs.
+     * @returns Array of BatchResult for all executed batches
+     */
+    async getAllBatchLogs() {
+        const batchInfo = await this.getBatchInfo();
+        const currentBatchId = batchInfo.batchId;
+        // Batch IDs start at 1 and increment. Current batchId is the next batch to be executed.
+        // So executed batches are 1 to (currentBatchId - 1)
+        const logs = [];
+        for (let batchId = 1; batchId < currentBatchId; batchId++) {
+            try {
+                const log = await this.getBatchLog(batchId);
+                logs.push(log);
+            }
+            catch (e) {
+                // BatchLog doesn't exist - skip
+                // This can happen if batch was never executed or PDA doesn't exist
+                continue;
+            }
+        }
+        return logs;
+    }
+    /**
+     * Estimate payout for a pending order after batch execution.
+     * Uses client-side calculation: payout = (orderAmount / totalInput) * finalPoolOutput
+     *
+     * @param cipher - Optional cipher (uses internal if omitted)
+     * @param owner - Optional owner pubkey (uses wallet if omitted)
+     * @returns EstimatedPayout or null if no pending order or batch not executed
+     */
+    async estimatePayout(cipher, owner) {
+        // Get decrypted order info
+        const order = await this.getDecryptedOrder(cipher, owner);
+        if (!order)
+            return null;
+        // Try to fetch batch log (may not exist if batch not executed)
+        let batchLog;
+        try {
+            batchLog = await this.getBatchLog(order.batchId);
+        }
+        catch (e) {
+            // BatchLog doesn't exist yet - batch not executed
+            return null;
+        }
+        const pairResult = batchLog.results[order.pairId];
+        // Determine totals based on direction
+        // direction 0 = A_to_B (sell A, get B)
+        // direction 1 = B_to_A (sell B, get A)
+        const totalInput = order.direction === 0
+            ? BigInt(pairResult.totalAIn.toString())
+            : BigInt(pairResult.totalBIn.toString());
+        const finalPoolOutput = order.direction === 0
+            ? BigInt(pairResult.finalPoolB.toString())
+            : BigInt(pairResult.finalPoolA.toString());
+        // Prevent division by zero
+        if (totalInput === 0n) {
+            return null;
+        }
+        // Calculate pro-rata payout: (orderAmount * finalPoolOutput) / totalInput
+        const orderAmount = order.amount;
+        const estimatedPayout = (orderAmount * finalPoolOutput) / totalInput;
+        // Determine output asset ID based on pair and direction
+        // Simplified: for now, use rough mapping
+        // TODO: Implement proper pair -> asset mapping
+        const outputAssetId = this._getOutputAssetId(order.pairId, order.direction);
+        return {
+            batchId: order.batchId,
+            pairId: order.pairId,
+            direction: order.direction,
+            orderAmount,
+            totalInput,
+            finalPoolOutput,
+            estimatedPayout,
+            outputAssetId,
+        };
+    }
+    /**
+     * Get effective balance for an asset, including pending payout.
+     * Combines current on-chain balance with estimated payout from pending order.
+     *
+     * @param assetId - Asset to check (0=USDC, 1=TSLA, 2=SPY, 3=AAPL)
+     * @param cipher - Optional cipher (uses internal if omitted)
+     * @param owner - Optional owner pubkey (uses wallet if omitted)
+     * @returns EffectiveBalance with current, pending, and total
+     */
+    async getEffectiveBalance(assetId, cipher, owner) {
+        const enc = cipher || this._requireEncryption().cipher;
+        // Get current on-chain balances for all assets
+        const balances = await this.getBalance(enc, owner);
+        // Extract the specific asset balance
+        const assetLabels = {
+            [constants_1.AssetId.USDC]: 'usdc',
+            [constants_1.AssetId.TSLA]: 'tsla',
+            [constants_1.AssetId.SPY]: 'spy',
+            [constants_1.AssetId.AAPL]: 'aapl',
+        };
+        const currentBalance = balances[assetLabels[assetId]];
+        // Try to estimate pending payout
+        const payout = await this.estimatePayout(enc, owner);
+        let pendingPayout = 0n;
+        let hasPendingOrder = false;
+        if (payout && payout.outputAssetId === assetId) {
+            pendingPayout = payout.estimatedPayout;
+            hasPendingOrder = true;
+        }
+        else if (payout) {
+            // Has pending order but for different asset
+            hasPendingOrder = true;
+        }
+        return {
+            currentBalance,
+            pendingPayout,
+            effectiveBalance: currentBalance + pendingPayout,
+            hasPendingOrder,
+        };
+    }
+    /**
+     * Helper to determine output asset ID based on pair and direction
+     */
+    _getOutputAssetId(pairId, direction) {
+        // Pair mapping (from constants):
+        // TSLA_USDC = 0, SPY_USDC = 1, AAPL_USDC = 2
+        // TSLA_SPY = 3, TSLA_AAPL = 4, SPY_AAPL = 5
+        //
+        // Direction: 0 = A_to_B (sell A, get B), 1 = B_to_A (sell B, get A)
+        const pairAssets = [
+            [constants_1.AssetId.TSLA, constants_1.AssetId.USDC], // pair 0: TSLA/USDC
+            [constants_1.AssetId.SPY, constants_1.AssetId.USDC], // pair 1: SPY/USDC
+            [constants_1.AssetId.AAPL, constants_1.AssetId.USDC], // pair 2: AAPL/USDC
+            [constants_1.AssetId.TSLA, constants_1.AssetId.SPY], // pair 3: TSLA/SPY
+            [constants_1.AssetId.TSLA, constants_1.AssetId.AAPL], // pair 4: TSLA/AAPL
+            [constants_1.AssetId.SPY, constants_1.AssetId.AAPL], // pair 5: SPY/AAPL
+        ];
+        const [assetA, assetB] = pairAssets[pairId] || [constants_1.AssetId.USDC, constants_1.AssetId.USDC];
+        // If selling A (direction 0), user gets B. If selling B (direction 1), user gets A.
+        return direction === 0 ? assetB : assetA;
+    }
+    /** Fetch pool account data */
+    async getPoolInfo() {
+        return this.program.account.pool.fetch(this.poolPDA);
+    }
+    // =========================================================================
+    // INTERNAL HELPERS
+    // =========================================================================
+    _getArciumAccounts(compDefName, computationOffset) {
+        return {
+            signPdaAccount: web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("ArciumSignerAccount")], this.programId)[0],
+            mxeAccount: (0, client_1.getMXEAccAddress)(this.programId),
+            mempoolAccount: (0, client_1.getMempoolAccAddress)(this.clusterOffset),
+            executingPool: (0, client_1.getExecutingPoolAccAddress)(this.clusterOffset),
+            computationAccount: (0, client_1.getComputationAccAddress)(this.clusterOffset, computationOffset),
+            compDefAccount: (0, client_1.getCompDefAccAddress)(this.programId, Buffer.from((0, client_1.getCompDefAccOffset)(compDefName)).readUInt32LE()),
+            clusterAccount: this.clusterAccount,
+        };
+    }
+    async _awaitComputation(offset, timeoutMs = 60000, maxRetries = 3) {
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const result = await Promise.race([
+                    (0, client_1.awaitComputationFinalization)(this.provider, offset, this.programId, "confirmed"),
+                    new Promise((_, reject) => {
+                        setTimeout(() => reject(new Error(`MPC timeout (attempt ${attempt}/${maxRetries})`)), timeoutMs);
+                    }),
+                ]);
+                return result;
+            }
+            catch (error) {
+                if (error.message.includes("timeout") && attempt < maxRetries) {
+                    await new Promise((r) => setTimeout(r, 2000));
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error("MPC computation failed after all retries");
+    }
+    _generateComputationOffset() {
+        return new anchor.BN((0, crypto_1.randomBytes)(8), "hex");
+    }
+}
+exports.ShuffleClient = ShuffleClient;