@veil-cash/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1840 @@
+import { ethers } from 'ethers';
+import * as crypto from 'crypto';
+import { encodeFunctionData, parseEther, parseUnits, createPublicClient, http, formatEther, formatUnits } from 'viem';
+import { base } from 'viem/chains';
+import MerkleTree from 'fixed-merkle-tree-legacy';
+import { groth16 } from 'snarkjs';
+import * as path from 'path';
+import * as fs from 'fs';
+import { fileURLToPath } from 'url';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var circomlib = __require("circomlib");
+var poseidon = circomlib.poseidon;
+var FIELD_SIZE = BigInt(
+  "21888242871839275222246405745257275088548364400416034343698204186575808495617"
+);
+var poseidonHash = (items) => BigInt(poseidon(items).toString());
+var poseidonHash2 = (a, b) => poseidonHash([a, b]);
+var randomBN = (nbytes = 31) => {
+  const bytes = crypto.randomBytes(nbytes);
+  let hex = "0x";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return BigInt(hex);
+};
+function toFixedHex(number, length = 32) {
+  let hexValue;
+  if (number instanceof Buffer) {
+    hexValue = number.toString("hex");
+  } else {
+    let bigIntValue = BigInt(number);
+    if (bigIntValue < 0n) {
+      const maxValue = 1n << BigInt(length * 8);
+      bigIntValue = maxValue + bigIntValue;
+    }
+    hexValue = bigIntValue.toString(16);
+  }
+  return "0x" + hexValue.padStart(length * 2, "0");
+}
+var toBuffer = (value, length) => {
+  const bigIntValue = BigInt(value);
+  const hex = bigIntValue.toString(16).padStart(length * 2, "0");
+  return Buffer.from(hex, "hex");
+};
+function getExtDataHash(extData) {
+  const { ethers: ethers2 } = __require("ethers");
+  const abi = ethers2.AbiCoder.defaultAbiCoder();
+  const encodedData = abi.encode(
+    ["tuple(address,int256,address,uint256,bytes,bytes)"],
+    [[
+      extData.recipient,
+      extData.extAmount,
+      extData.relayer,
+      extData.fee,
+      extData.encryptedOutput1,
+      extData.encryptedOutput2
+    ]]
+  );
+  const hash = ethers2.keccak256(encodedData);
+  return BigInt(hash) % FIELD_SIZE;
+}
+function shuffle(array) {
+  let currentIndex = array.length;
+  let randomIndex;
+  while (currentIndex !== 0) {
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex--;
+    [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
+  }
+  return array;
+}
+
+// src/keypair.ts
+var ethSigUtil = __require("eth-sig-util");
+function packEncryptedMessage(encryptedMessage) {
+  const nonceBuf = Buffer.from(encryptedMessage.nonce, "base64");
+  const ephemPublicKeyBuf = Buffer.from(encryptedMessage.ephemPublicKey, "base64");
+  const ciphertextBuf = Buffer.from(encryptedMessage.ciphertext, "base64");
+  const messageBuff = Buffer.concat([
+    Buffer.alloc(24 - nonceBuf.length),
+    nonceBuf,
+    Buffer.alloc(32 - ephemPublicKeyBuf.length),
+    ephemPublicKeyBuf,
+    ciphertextBuf
+  ]);
+  return "0x" + messageBuff.toString("hex");
+}
+function unpackEncryptedMessage(encryptedMessage) {
+  if (encryptedMessage.slice(0, 2) === "0x") {
+    encryptedMessage = encryptedMessage.slice(2);
+  }
+  const messageBuff = Buffer.from(encryptedMessage, "hex");
+  const nonceBuf = messageBuff.slice(0, 24);
+  const ephemPublicKeyBuf = messageBuff.slice(24, 56);
+  const ciphertextBuf = messageBuff.slice(56);
+  return {
+    version: "x25519-xsalsa20-poly1305",
+    nonce: nonceBuf.toString("base64"),
+    ephemPublicKey: ephemPublicKeyBuf.toString("base64"),
+    ciphertext: ciphertextBuf.toString("base64")
+  };
+}
+var Keypair = class _Keypair {
+  /** Private key (null if created from public deposit key only) */
+  privkey;
+  /** Public key (Poseidon hash of private key) */
+  pubkey;
+  /** x25519 encryption public key */
+  encryptionKey;
+  /**
+   * Create a new Keypair
+   * @param privkey - Optional private key. If not provided, generates a random one.
+   */
+  constructor(privkey = ethers.Wallet.createRandom().privateKey) {
+    this.privkey = privkey;
+    this.pubkey = poseidonHash([this.privkey]);
+    this.encryptionKey = ethSigUtil.getEncryptionPublicKey(privkey.slice(2));
+  }
+  /**
+   * Get the deposit key for this keypair
+   * This is what you register on-chain
+   * @returns Deposit key as hex string (130 chars with 0x prefix)
+   */
+  toString() {
+    return toFixedHex(this.pubkey) + Buffer.from(this.encryptionKey, "base64").toString("hex");
+  }
+  /**
+   * Alias for toString() - returns the deposit key
+   * @returns Deposit key as hex string
+   */
+  depositKey() {
+    return this.toString();
+  }
+  /**
+   * Create a Keypair from a public deposit key (without private key)
+   * Useful for sending transfers to other users
+   * @param str - Deposit key (128 or 130 hex chars)
+   * @returns Keypair instance (privkey will be null)
+   */
+  static fromString(str) {
+    if (str.length === 130) {
+      str = str.slice(2);
+    }
+    if (str.length !== 128) {
+      throw new Error("Invalid deposit key length. Expected 128 hex chars (or 130 with 0x prefix)");
+    }
+    return Object.assign(new _Keypair(), {
+      privkey: null,
+      pubkey: BigInt("0x" + str.slice(0, 64)),
+      encryptionKey: Buffer.from(str.slice(64, 128), "hex").toString("base64")
+    });
+  }
+  /**
+   * Sign a message using the private key
+   * @param commitment - Commitment hash
+   * @param merklePath - Merkle path
+   * @returns Signature as bigint
+   */
+  sign(commitment, merklePath) {
+    if (!this.privkey) {
+      throw new Error("Cannot sign without private key");
+    }
+    return poseidonHash([this.privkey, commitment, merklePath]);
+  }
+  /**
+   * Encrypt data using the encryption key
+   * @param bytes - Data to encrypt
+   * @returns Encrypted data as hex string
+   */
+  encrypt(bytes) {
+    return packEncryptedMessage(
+      ethSigUtil.encrypt(
+        this.encryptionKey,
+        { data: bytes.toString("base64") },
+        "x25519-xsalsa20-poly1305"
+      )
+    );
+  }
+  /**
+   * Decrypt data using the private key
+   * @param data - Encrypted data as hex string
+   * @returns Decrypted data as Buffer
+   */
+  decrypt(data) {
+    if (!this.privkey) {
+      throw new Error("Cannot decrypt without private key");
+    }
+    return Buffer.from(
+      ethSigUtil.decrypt(unpackEncryptedMessage(data), this.privkey.slice(2)),
+      "base64"
+    );
+  }
+};
+
+// src/utxo.ts
+var Utxo = class _Utxo {
+  amount;
+  blinding;
+  keypair;
+  index;
+  _commitment;
+  _nullifier;
+  /**
+   * Create a new UTXO
+   * @param params - UTXO parameters
+   */
+  constructor(params = {}) {
+    const { amount = 0, keypair = new Keypair(), blinding = randomBN(), index } = params;
+    this.amount = BigInt(amount);
+    this.blinding = BigInt(blinding);
+    this.keypair = keypair;
+    this.index = index;
+  }
+  /**
+   * Get the commitment for this UTXO
+   * commitment = poseidonHash([amount, pubkey, blinding])
+   * @returns Commitment as bigint
+   */
+  getCommitment() {
+    if (!this._commitment) {
+      this._commitment = poseidonHash([this.amount, this.keypair.pubkey, this.blinding]);
+    }
+    return this._commitment;
+  }
+  /**
+   * Get the nullifier for this UTXO
+   * Requires index and private key to be set
+   * nullifier = poseidonHash([commitment, index, signature])
+   * @returns Nullifier as bigint
+   */
+  getNullifier() {
+    if (!this._nullifier) {
+      if (this.amount > 0n && (this.index === void 0 || !this.keypair.privkey)) {
+        throw new Error("Cannot compute nullifier without UTXO index or private key");
+      }
+      const signature = this.keypair.privkey ? this.keypair.sign(this.getCommitment(), this.index || 0) : 0n;
+      this._nullifier = poseidonHash([this.getCommitment(), this.index || 0, signature]);
+    }
+    return this._nullifier;
+  }
+  /**
+   * Encrypt UTXO data using the keypair
+   * @returns Encrypted data as 0x-prefixed hex string
+   */
+  encrypt() {
+    const bytes = Buffer.concat([
+      toBuffer(this.amount, 31),
+      toBuffer(this.blinding, 31)
+    ]);
+    return this.keypair.encrypt(bytes);
+  }
+  /**
+   * Decrypt an encrypted output to create a UTXO
+   * Only succeeds if the keypair owns this UTXO
+   * 
+   * @param data - Encrypted output as hex string
+   * @param keypair - Keypair to decrypt with
+   * @returns Decrypted UTXO
+   * @throws If decryption fails (wrong keypair)
+   */
+  static decrypt(data, keypair) {
+    const buf = keypair.decrypt(data);
+    return new _Utxo({
+      amount: BigInt("0x" + buf.slice(0, 31).toString("hex")),
+      blinding: BigInt("0x" + buf.slice(31, 62).toString("hex")),
+      keypair
+    });
+  }
+};
+
+// src/addresses.ts
+var ADDRESSES = {
+  entry: "0xc2535c547B64b997A4BD9202E1663deaF11c78a5",
+  ethPool: "0x293dCda114533FF8f477271c5cA517209FFDEEe7",
+  ethQueue: "0xA4a926A2E7a22c38e8DFC6744A61a6aA8b06B230",
+  usdcPool: "0x5c50d58E49C59d112680c187De2Bf989d2a91242",
+  usdcQueue: "0x5530241b24504bF05C9a22e95A1F5458888e6a9B",
+  usdcToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  chainId: 8453,
+  relayUrl: "https://veil-relay.up.railway.app"
+};
+var POOL_CONFIG = {
+  eth: {
+    decimals: 18,
+    displayDecimals: 4,
+    symbol: "ETH",
+    name: "Ethereum"
+  },
+  usdc: {
+    decimals: 6,
+    displayDecimals: 2,
+    symbol: "USDC",
+    name: "USD Coin"
+  }
+};
+function getAddresses() {
+  return ADDRESSES;
+}
+function getRelayUrl() {
+  return ADDRESSES.relayUrl;
+}
+
+// src/abi.ts
+var ENTRY_ABI = [
+  // ============ ERRORS ============
+  { inputs: [], name: "DepositsDisabled", type: "error" },
+  { inputs: [], name: "FeeTransferFailed", type: "error" },
+  { inputs: [], name: "InvalidDepositKey", type: "error" },
+  { inputs: [], name: "InvalidDepositKeyForUser", type: "error" },
+  { inputs: [], name: "InvalidInitialization", type: "error" },
+  { inputs: [], name: "MinimumDepositNotMet", type: "error" },
+  { inputs: [], name: "NotAllowedToDeposit", type: "error" },
+  { inputs: [], name: "NotInitializing", type: "error" },
+  { inputs: [], name: "OnlyOperatorAllowed", type: "error" },
+  { inputs: [], name: "OnlyOwnerCanRegister", type: "error" },
+  { inputs: [], name: "OnlyQueueContractAllowed", type: "error" },
+  { inputs: [{ name: "owner", type: "address" }], name: "OwnableInvalidOwner", type: "error" },
+  { inputs: [{ name: "account", type: "address" }], name: "OwnableUnauthorizedAccount", type: "error" },
+  { inputs: [], name: "ReentrancyGuardReentrantCall", type: "error" },
+  { inputs: [], name: "USDCTransferFailed", type: "error" },
+  { inputs: [], name: "UserAlreadyRegistered", type: "error" },
+  { inputs: [], name: "UserNotRegistered", type: "error" },
+  // ============ EVENTS ============
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: false, name: "key", type: "bytes" }
+    ],
+    name: "DepositKey",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "depositor", type: "address" },
+      { indexed: false, name: "amount", type: "uint256" }
+    ],
+    name: "DepositedETH",
+    type: "event"
+  },
+  // ============ FUNCTIONS ============
+  // Register deposit key
+  {
+    inputs: [
+      {
+        components: [
+          { name: "owner", type: "address" },
+          { name: "depositKey", type: "bytes" }
+        ],
+        name: "_account",
+        type: "tuple"
+      }
+    ],
+    name: "register",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // Queue ETH deposit
+  {
+    inputs: [{ name: "_depositKey", type: "bytes" }],
+    name: "queueETH",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  // Queue USDC deposit
+  {
+    inputs: [
+      { name: "_amount", type: "uint256" },
+      { name: "_depositKey", type: "bytes" }
+    ],
+    name: "queueUSDC",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // Read deposit keys
+  {
+    inputs: [{ name: "", type: "address" }],
+    name: "depositKeys",
+    outputs: [{ name: "", type: "bytes" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Check if deposits are enabled
+  {
+    inputs: [],
+    name: "depositETHEnabled",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Get deposit fee
+  {
+    inputs: [],
+    name: "depositFee",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Get minimum deposit
+  {
+    inputs: [],
+    name: "minimumDeposit",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Calculate fee and net deposit
+  {
+    inputs: [{ name: "_totalAmount", type: "uint256" }],
+    name: "getFeeAndNetDeposit",
+    outputs: [
+      { name: "netDeposit", type: "uint256" },
+      { name: "fee", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Calculate deposit amount with fee
+  {
+    inputs: [{ name: "_netDepositAmount", type: "uint256" }],
+    name: "getDepositAmountWithFee",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Check if user is allowed depositor
+  {
+    inputs: [{ name: "_depositor", type: "address" }],
+    name: "isAllowedDepositor",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var QUEUE_ABI = [
+  // Get all pending deposit nonces
+  {
+    inputs: [],
+    name: "getPendingDeposits",
+    outputs: [{ name: "nonces", type: "uint256[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Get deposit details by nonce
+  {
+    inputs: [{ name: "_nonce", type: "uint256" }],
+    name: "getDeposit",
+    outputs: [
+      {
+        components: [
+          { name: "fallbackReceiver", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "fee", type: "uint256" },
+          { name: "shieldAmount", type: "uint256" },
+          { name: "timestamp", type: "uint256" },
+          { name: "status", type: "uint8" },
+          { name: "depositKey", type: "bytes" }
+        ],
+        name: "deposit",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Get current nonce counter
+  {
+    inputs: [],
+    name: "depositQueueNonce",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Get pending count
+  {
+    inputs: [],
+    name: "getPendingCount",
+    outputs: [{ name: "count", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var POOL_ABI = [
+  // ============ ERRORS ============
+  { inputs: [], name: "CannotWithdrawToZeroAddress", type: "error" },
+  { inputs: [], name: "ETHTransferFailed", type: "error" },
+  { inputs: [], name: "IncorrectExternalDataHash", type: "error" },
+  { inputs: [], name: "InputAlreadySpent", type: "error" },
+  { inputs: [], name: "InvalidExtAmount", type: "error" },
+  { inputs: [], name: "InvalidFee", type: "error" },
+  { inputs: [], name: "InvalidMerkleRoot", type: "error" },
+  { inputs: [], name: "InvalidPublicAmount", type: "error" },
+  { inputs: [], name: "InvalidRange", type: "error" },
+  { inputs: [], name: "InvalidTransactionProof", type: "error" },
+  { inputs: [], name: "OnlyForDeposits", type: "error" },
+  { inputs: [], name: "OnlyForTransfers", type: "error" },
+  { inputs: [], name: "OnlyForWithdrawals", type: "error" },
+  { inputs: [], name: "OnlyValidatorContractAllowed", type: "error" },
+  { inputs: [], name: "OnlyWETHContractAllowed", type: "error" },
+  { inputs: [{ name: "owner", type: "address" }], name: "OwnableInvalidOwner", type: "error" },
+  { inputs: [{ name: "account", type: "address" }], name: "OwnableUnauthorizedAccount", type: "error" },
+  { inputs: [], name: "ProofAmountMismatch", type: "error" },
+  { inputs: [], name: "ReentrancyGuardReentrantCall", type: "error" },
+  { inputs: [], name: "UnsupportedInputCount", type: "error" },
+  { inputs: [], name: "WETHDepositFailed", type: "error" },
+  { inputs: [], name: "WETHUnwrapFailed", type: "error" },
+  // ============ EVENTS ============
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: false, name: "commitment", type: "bytes32" },
+      { indexed: false, name: "index", type: "uint256" },
+      { indexed: false, name: "encryptedOutput", type: "bytes" }
+    ],
+    name: "NewCommitment",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, name: "nullifier", type: "bytes32" }],
+    name: "NewNullifier",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "previousOwner", type: "address" },
+      { indexed: true, name: "newOwner", type: "address" }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: true, name: "newValidatorContract", type: "address" }],
+    name: "ValidatorContractUpdated",
+    type: "event"
+  },
+  // ============ VIEW FUNCTIONS ============
+  {
+    inputs: [],
+    name: "FIELD_SIZE",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "ROOT_HISTORY_SIZE",
+    outputs: [{ name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "ZERO_VALUE",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "", type: "uint256" }],
+    name: "commitments",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "currentRootIndex",
+    outputs: [{ name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "", type: "uint256" }],
+    name: "encryptedOutputs",
+    outputs: [{ name: "", type: "bytes" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "", type: "uint256" }],
+    name: "filledSubtrees",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "startIndex", type: "uint256" },
+      { name: "endIndex", type: "uint256" }
+    ],
+    name: "getCommitments",
+    outputs: [{ name: "", type: "bytes32[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "startIndex", type: "uint256" },
+      { name: "endIndex", type: "uint256" }
+    ],
+    name: "getEncryptedOutputs",
+    outputs: [{ name: "", type: "bytes[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getLastRoot",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "_left", type: "bytes32" },
+      { name: "_right", type: "bytes32" }
+    ],
+    name: "hashLeftRight",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "hasher",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "_root", type: "bytes32" }],
+    name: "isKnownRoot",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "_nullifierHash", type: "bytes32" }],
+    name: "isSpent",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "levels",
+    outputs: [{ name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "nextIndex",
+    outputs: [{ name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "", type: "bytes32" }],
+    name: "nullifierHashes",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "", type: "uint256" }],
+    name: "roots",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "validatorContract",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "verifier16",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "verifier2",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "weth",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "i", type: "uint256" }],
+    name: "zeros",
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "pure",
+    type: "function"
+  },
+  // ============ PURE FUNCTIONS ============
+  {
+    inputs: [
+      { name: "_extAmount", type: "int256" },
+      { name: "_fee", type: "uint256" }
+    ],
+    name: "calculatePublicAmount",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "pure",
+    type: "function"
+  },
+  // ============ WRITE FUNCTIONS ============
+  {
+    inputs: [
+      {
+        components: [
+          { name: "proof", type: "bytes" },
+          { name: "root", type: "bytes32" },
+          { name: "inputNullifiers", type: "bytes32[]" },
+          { name: "outputCommitments", type: "bytes32[2]" },
+          { name: "publicAmount", type: "uint256" },
+          { name: "extDataHash", type: "bytes32" }
+        ],
+        name: "_args",
+        type: "tuple"
+      },
+      {
+        components: [
+          { name: "recipient", type: "address" },
+          { name: "extAmount", type: "int256" },
+          { name: "relayer", type: "address" },
+          { name: "fee", type: "uint256" },
+          { name: "encryptedOutput1", type: "bytes" },
+          { name: "encryptedOutput2", type: "bytes" }
+        ],
+        name: "_extData",
+        type: "tuple"
+      }
+    ],
+    name: "depositETH",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { name: "proof", type: "bytes" },
+          { name: "root", type: "bytes32" },
+          { name: "inputNullifiers", type: "bytes32[]" },
+          { name: "outputCommitments", type: "bytes32[2]" },
+          { name: "publicAmount", type: "uint256" },
+          { name: "extDataHash", type: "bytes32" }
+        ],
+        name: "_args",
+        type: "tuple"
+      },
+      {
+        components: [
+          { name: "recipient", type: "address" },
+          { name: "extAmount", type: "int256" },
+          { name: "relayer", type: "address" },
+          { name: "fee", type: "uint256" },
+          { name: "encryptedOutput1", type: "bytes" },
+          { name: "encryptedOutput2", type: "bytes" }
+        ],
+        name: "_extData",
+        type: "tuple"
+      }
+    ],
+    name: "transactETH",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { name: "proof", type: "bytes" },
+          { name: "root", type: "bytes32" },
+          { name: "inputNullifiers", type: "bytes32[]" },
+          { name: "outputCommitments", type: "bytes32[2]" },
+          { name: "publicAmount", type: "uint256" },
+          { name: "extDataHash", type: "bytes32" }
+        ],
+        name: "_args",
+        type: "tuple"
+      },
+      {
+        components: [
+          { name: "recipient", type: "address" },
+          { name: "extAmount", type: "int256" },
+          { name: "relayer", type: "address" },
+          { name: "fee", type: "uint256" },
+          { name: "encryptedOutput1", type: "bytes" },
+          { name: "encryptedOutput2", type: "bytes" }
+        ],
+        name: "_extData",
+        type: "tuple"
+      }
+    ],
+    name: "withdrawETH",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { name: "proof", type: "bytes" },
+          { name: "root", type: "bytes32" },
+          { name: "inputNullifiers", type: "bytes32[]" },
+          { name: "outputCommitments", type: "bytes32[2]" },
+          { name: "publicAmount", type: "uint256" },
+          { name: "extDataHash", type: "bytes32" }
+        ],
+        name: "_args",
+        type: "tuple"
+      }
+    ],
+    name: "verifyProof",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "newOwner", type: "address" }],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "_newValidator", type: "address" }],
+    name: "updateValidatorContract",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // ============ RECEIVE ============
+  { stateMutability: "payable", type: "receive" }
+];
+var ERC20_ABI = [
+  {
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/deposit.ts
+function buildRegisterTx(depositKey, ownerAddress) {
+  const addresses = getAddresses();
+  const data = encodeFunctionData({
+    abi: ENTRY_ABI,
+    functionName: "register",
+    args: [{
+      owner: ownerAddress,
+      depositKey
+    }]
+  });
+  return {
+    to: addresses.entry,
+    data
+  };
+}
+function buildDepositETHTx(options) {
+  const { depositKey, amount } = options;
+  const addresses = getAddresses();
+  const value = parseEther(amount);
+  const data = encodeFunctionData({
+    abi: ENTRY_ABI,
+    functionName: "queueETH",
+    args: [depositKey]
+  });
+  return {
+    to: addresses.entry,
+    data,
+    value
+  };
+}
+function buildApproveUSDCTx(options) {
+  const { amount } = options;
+  const addresses = getAddresses();
+  const amountWei = parseUnits(amount, POOL_CONFIG.usdc.decimals);
+  const data = encodeFunctionData({
+    abi: ERC20_ABI,
+    functionName: "approve",
+    args: [addresses.entry, amountWei]
+  });
+  return {
+    to: addresses.usdcToken,
+    data
+  };
+}
+function buildDepositUSDCTx(options) {
+  const { depositKey, amount } = options;
+  const addresses = getAddresses();
+  const amountWei = parseUnits(amount, POOL_CONFIG.usdc.decimals);
+  const data = encodeFunctionData({
+    abi: ENTRY_ABI,
+    functionName: "queueUSDC",
+    args: [amountWei, depositKey]
+  });
+  return {
+    to: addresses.entry,
+    data
+  };
+}
+function buildDepositTx(options) {
+  const { token = "ETH", ...rest } = options;
+  if (token === "USDC") {
+    return buildDepositUSDCTx(rest);
+  }
+  return buildDepositETHTx(rest);
+}
+var DEPOSIT_STATUS_MAP = {
+  0: "pending",
+  1: "accepted",
+  2: "rejected",
+  3: "refunded"
+};
+async function getQueueBalance(options) {
+  const { address, rpcUrl, onProgress } = options;
+  const addresses = getAddresses();
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(rpcUrl)
+  });
+  onProgress?.("Fetching pending deposits...");
+  const pendingNonces = await publicClient.readContract({
+    address: addresses.ethQueue,
+    abi: QUEUE_ABI,
+    functionName: "getPendingDeposits"
+  });
+  onProgress?.("Queue status", `${pendingNonces.length} pending deposits in queue`);
+  const pendingDeposits = [];
+  let totalQueueBalance = 0n;
+  for (let i = 0; i < pendingNonces.length; i++) {
+    const nonce = pendingNonces[i];
+    onProgress?.("Checking deposit", `${i + 1}/${pendingNonces.length}`);
+    const deposit = await publicClient.readContract({
+      address: addresses.ethQueue,
+      abi: QUEUE_ABI,
+      functionName: "getDeposit",
+      args: [nonce]
+    });
+    if (deposit.fallbackReceiver.toLowerCase() === address.toLowerCase()) {
+      totalQueueBalance += deposit.amountIn;
+      pendingDeposits.push({
+        nonce: nonce.toString(),
+        status: DEPOSIT_STATUS_MAP[deposit.status] || "pending",
+        amount: formatEther(deposit.amountIn),
+        amountWei: deposit.amountIn.toString(),
+        timestamp: new Date(Number(deposit.timestamp) * 1e3).toISOString()
+      });
+    }
+  }
+  if (pendingDeposits.length > 0) {
+    onProgress?.("Found", `${pendingDeposits.length} deposits for your address`);
+  }
+  return {
+    address,
+    queueBalance: formatEther(totalQueueBalance),
+    queueBalanceWei: totalQueueBalance.toString(),
+    pendingDeposits,
+    pendingCount: pendingDeposits.length
+  };
+}
+async function getPrivateBalance(options) {
+  const { keypair, rpcUrl, onProgress } = options;
+  const addresses = getAddresses();
+  if (!keypair.privkey) {
+    throw new Error("Keypair must have a private key to calculate private balance");
+  }
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(rpcUrl)
+  });
+  onProgress?.("Fetching pool index...");
+  const nextIndex = await publicClient.readContract({
+    address: addresses.ethPool,
+    abi: POOL_ABI,
+    functionName: "nextIndex"
+  });
+  onProgress?.("Pool index", `${nextIndex} commitments`);
+  if (nextIndex === 0) {
+    return {
+      privateBalance: "0",
+      privateBalanceWei: "0",
+      utxoCount: 0,
+      spentCount: 0,
+      unspentCount: 0,
+      utxos: []
+    };
+  }
+  const BATCH_SIZE = 5e3;
+  const allEncryptedOutputs = [];
+  const totalBatches = Math.ceil(nextIndex / BATCH_SIZE);
+  for (let start = 0; start < nextIndex; start += BATCH_SIZE) {
+    const end = Math.min(start + BATCH_SIZE, nextIndex);
+    const batchNum = Math.floor(start / BATCH_SIZE) + 1;
+    onProgress?.("Fetching encrypted outputs", `batch ${batchNum}/${totalBatches} (${start}-${end})`);
+    const batch = await publicClient.readContract({
+      address: addresses.ethPool,
+      abi: POOL_ABI,
+      functionName: "getEncryptedOutputs",
+      args: [BigInt(start), BigInt(end)]
+    });
+    allEncryptedOutputs.push(...batch);
+  }
+  onProgress?.("Decrypting outputs", `scanning ${allEncryptedOutputs.length} outputs...`);
+  const decryptedUtxos = [];
+  for (let i = 0; i < allEncryptedOutputs.length; i++) {
+    try {
+      const utxo = Utxo.decrypt(allEncryptedOutputs[i], keypair);
+      utxo.index = i;
+      if (utxo.amount > 0n) {
+        decryptedUtxos.push({ utxo, index: i });
+      }
+    } catch {
+    }
+  }
+  onProgress?.("Found UTXOs", `${decryptedUtxos.length} belonging to you`);
+  const utxoInfos = [];
+  let totalBalance = 0n;
+  let spentCount = 0;
+  let unspentCount = 0;
+  for (let i = 0; i < decryptedUtxos.length; i++) {
+    const { utxo, index } = decryptedUtxos[i];
+    onProgress?.("Checking spent status", `UTXO ${i + 1}/${decryptedUtxos.length}`);
+    const nullifier = utxo.getNullifier();
+    const nullifierHex = toFixedHex(nullifier);
+    const isSpent = await publicClient.readContract({
+      address: addresses.ethPool,
+      abi: POOL_ABI,
+      functionName: "isSpent",
+      args: [nullifierHex]
+    });
+    utxoInfos.push({
+      index,
+      amount: formatEther(utxo.amount),
+      amountWei: utxo.amount.toString(),
+      isSpent
+    });
+    if (isSpent) {
+      spentCount++;
+    } else {
+      unspentCount++;
+      totalBalance += utxo.amount;
+    }
+  }
+  return {
+    privateBalance: formatEther(totalBalance),
+    privateBalanceWei: totalBalance.toString(),
+    utxoCount: decryptedUtxos.length,
+    spentCount,
+    unspentCount,
+    utxos: utxoInfos
+  };
+}
+var MERKLE_TREE_HEIGHT = 23;
+async function buildMerkleTree(commitments) {
+  const leaves = commitments.map((commitment) => toFixedHex(commitment));
+  const hashFunction = (left, right) => {
+    const result = poseidonHash2(left, right);
+    return result.toString();
+  };
+  const tree = new MerkleTree(MERKLE_TREE_HEIGHT, leaves, { hashFunction });
+  return tree;
+}
+function getMerklePath(tree, commitment) {
+  const commitmentHex = toFixedHex(commitment);
+  const index = tree.indexOf(commitmentHex);
+  if (index < 0) {
+    throw new Error(`Commitment ${commitmentHex} not found in merkle tree`);
+  }
+  const { pathElements } = tree.path(index);
+  return {
+    pathElements: pathElements.map((el) => BigInt(el)),
+    pathIndices: index
+  };
+}
+var utils = null;
+try {
+  const ffjavascript = __require("ffjavascript");
+  utils = ffjavascript.utils;
+} catch {
+  console.warn("ffjavascript not found. Proof generation may not work.");
+}
+function findKeysDirectory() {
+  const possiblePaths = [
+    // When running from package (installed via npm)
+    path.resolve(__dirname, "..", "keys"),
+    path.resolve(__dirname, "..", "..", "keys"),
+    // When running from source
+    path.resolve(process.cwd(), "keys")
+    // ESM module path
+  ];
+  try {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const currentDir = path.dirname(currentFilePath);
+    possiblePaths.unshift(path.resolve(currentDir, "..", "keys"));
+  } catch {
+  }
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p) && fs.existsSync(path.join(p, "transaction2.wasm"))) {
+      return p;
+    }
+  }
+  throw new Error(
+    "Circuit keys not found. Expected to find keys/ directory with transaction2.wasm and transaction2.zkey files."
+  );
+}
+async function prove(input, circuitName) {
+  if (!utils) {
+    throw new Error("ffjavascript is required for proof generation. Please install it: npm install ffjavascript");
+  }
+  const keysDir = findKeysDirectory();
+  const wasmPath = path.join(keysDir, `${circuitName}.wasm`);
+  const zkeyPath = path.join(keysDir, `${circuitName}.zkey`);
+  if (!fs.existsSync(wasmPath)) {
+    throw new Error(`Circuit WASM file not found: ${wasmPath}`);
+  }
+  if (!fs.existsSync(zkeyPath)) {
+    throw new Error(`Circuit zkey file not found: ${zkeyPath}`);
+  }
+  const result = await groth16.fullProve(
+    utils.stringifyBigInts(input),
+    wasmPath,
+    zkeyPath
+  );
+  const proof = result.proof;
+  return "0x" + toFixedHex(proof.pi_a[0]).slice(2) + toFixedHex(proof.pi_a[1]).slice(2) + toFixedHex(proof.pi_b[0][1]).slice(2) + toFixedHex(proof.pi_b[0][0]).slice(2) + toFixedHex(proof.pi_b[1][1]).slice(2) + toFixedHex(proof.pi_b[1][0]).slice(2) + toFixedHex(proof.pi_c[0]).slice(2) + toFixedHex(proof.pi_c[1]).slice(2);
+}
+var CIRCUIT_CONFIG = {
+  transaction2: { maxInputs: 2, maxOutputs: 2 },
+  transaction16: { maxInputs: 16, maxOutputs: 2 }
+};
+function selectCircuit(inputCount) {
+  if (inputCount <= 2) {
+    return "transaction2";
+  } else if (inputCount <= 16) {
+    return "transaction16";
+  } else {
+    throw new Error(`Too many inputs: ${inputCount}. Maximum supported is 16.`);
+  }
+}
+
+// src/transaction.ts
+async function getProof({
+  inputs,
+  outputs,
+  tree,
+  extAmount,
+  fee,
+  recipient,
+  relayer,
+  onProgress
+}) {
+  inputs = shuffle([...inputs]);
+  outputs = shuffle([...outputs]);
+  onProgress?.("Building merkle paths...");
+  const inputMerklePathIndices = [];
+  const inputMerklePathElements = [];
+  for (const input of inputs) {
+    if (input.amount > 0n) {
+      const inputIndex = tree.indexOf(toFixedHex(input.getCommitment()));
+      if (inputIndex < 0) {
+        throw new Error(`Input commitment ${toFixedHex(input.getCommitment())} was not found in merkle tree`);
+      }
+      input.index = inputIndex;
+      inputMerklePathIndices.push(inputIndex);
+      inputMerklePathElements.push(
+        tree.path(inputIndex).pathElements.map((el) => BigInt(el))
+      );
+    } else {
+      inputMerklePathIndices.push(0);
+      inputMerklePathElements.push(new Array(tree.levels).fill(0));
+    }
+  }
+  onProgress?.("Encrypting outputs...");
+  const extData = {
+    recipient: toFixedHex(recipient, 20),
+    extAmount: extAmount.toString(),
+    relayer: toFixedHex(relayer, 20),
+    fee: fee.toString(),
+    encryptedOutput1: outputs[0].encrypt(),
+    encryptedOutput2: outputs[1].encrypt()
+  };
+  const extDataHashInput = {
+    recipient,
+    extAmount,
+    relayer,
+    fee,
+    encryptedOutput1: extData.encryptedOutput1,
+    encryptedOutput2: extData.encryptedOutput2
+  };
+  const extDataHash = getExtDataHash(extDataHashInput);
+  const proofInput = {
+    root: BigInt(tree.root()),
+    inputNullifier: inputs.map((x) => x.getNullifier()),
+    outputCommitment: outputs.map((x) => x.getCommitment()),
+    publicAmount: ((BigInt(extAmount) - BigInt(fee) + FIELD_SIZE) % FIELD_SIZE).toString(),
+    extDataHash,
+    // Input UTXO data
+    inAmount: inputs.map((x) => x.amount),
+    inPrivateKey: inputs.map((x) => x.keypair.privkey),
+    inBlinding: inputs.map((x) => x.blinding),
+    inPathIndices: inputMerklePathIndices,
+    inPathElements: inputMerklePathElements,
+    // Output UTXO data
+    outAmount: outputs.map((x) => x.amount),
+    outBlinding: outputs.map((x) => x.blinding),
+    outPubkey: outputs.map((x) => x.keypair.pubkey)
+  };
+  onProgress?.("Generating ZK proof...", `${inputs.length} inputs`);
+  const circuitName = selectCircuit(inputs.length);
+  const proof = await prove(proofInput, circuitName);
+  const args = {
+    proof,
+    root: toFixedHex(proofInput.root),
+    inputNullifiers: inputs.map((x) => toFixedHex(x.getNullifier())),
+    outputCommitments: outputs.map((x) => toFixedHex(x.getCommitment())),
+    publicAmount: toFixedHex(proofInput.publicAmount),
+    extDataHash: toFixedHex(extDataHash)
+  };
+  onProgress?.("Proof generated successfully");
+  return {
+    args,
+    extData
+  };
+}
+async function prepareTransaction({
+  commitments,
+  inputs = [],
+  outputs = [],
+  fee = 0,
+  recipient = 0,
+  relayer = 0,
+  onProgress
+}) {
+  if (inputs.length > 16 || outputs.length > 2) {
+    throw new Error("Incorrect inputs/outputs count. Maximum: 16 inputs, 2 outputs.");
+  }
+  while (inputs.length !== 2 && inputs.length < 16) {
+    inputs.push(new Utxo());
+  }
+  while (outputs.length < 2) {
+    outputs.push(new Utxo());
+  }
+  const extAmount = BigInt(fee) + outputs.reduce((sum, x) => sum + x.amount, 0n) - inputs.reduce((sum, x) => sum + x.amount, 0n);
+  onProgress?.("Building merkle tree...");
+  const tree = await buildMerkleTree(commitments);
+  const result = await getProof({
+    inputs,
+    outputs,
+    tree,
+    extAmount,
+    fee: BigInt(fee),
+    recipient: String(recipient),
+    relayer: String(relayer),
+    onProgress
+  });
+  return result;
+}
+
+// src/relay.ts
+var RelayError = class extends Error {
+  /** HTTP status code */
+  statusCode;
+  /** Seconds until rate limit resets (only for 429 errors) */
+  retryAfter;
+  /** Network the error occurred on */
+  network;
+  constructor(message, statusCode, retryAfter, network) {
+    super(message);
+    this.name = "RelayError";
+    this.statusCode = statusCode;
+    this.retryAfter = retryAfter;
+    this.network = network;
+  }
+};
+async function submitRelay(options) {
+  const {
+    type,
+    pool = "eth",
+    proofArgs,
+    extData,
+    metadata,
+    relayUrl: customRelayUrl
+  } = options;
+  if (type !== "withdraw" && type !== "transfer") {
+    throw new RelayError('Invalid type. Must be "withdraw" or "transfer"', 400);
+  }
+  if (pool !== "eth" && pool !== "usdc") {
+    throw new RelayError('Invalid pool. Must be "eth" or "usdc"', 400);
+  }
+  if (!proofArgs || !extData) {
+    throw new RelayError("Missing proofArgs or extData", 400);
+  }
+  const relayUrl = customRelayUrl || getRelayUrl();
+  const endpoint = `${relayUrl}/relay/${pool}`;
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      type,
+      proofArgs,
+      extData,
+      metadata
+    })
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    const errorData = data;
+    throw new RelayError(
+      errorData.error || errorData.message || "Relay request failed",
+      response.status,
+      errorData.retryAfter,
+      errorData.network
+    );
+  }
+  return data;
+}
+async function checkRelayHealth(relayUrl) {
+  const url = relayUrl || getRelayUrl();
+  const response = await fetch(`${url}/health`);
+  if (!response.ok) {
+    throw new RelayError("Relay service health check failed", response.status);
+  }
+  return response.json();
+}
+async function getRelayInfo(relayUrl) {
+  const url = relayUrl || getRelayUrl();
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new RelayError("Failed to get relay service info", response.status);
+  }
+  return response.json();
+}
+
+// src/withdraw.ts
+function selectUtxosForWithdraw(utxos, amount, decimals = 18) {
+  const withdrawWei = parseUnits(amount, decimals);
+  const sortedUtxos = [...utxos].sort((a, b) => Number(b.amount - a.amount));
+  let totalSelected = 0n;
+  const selectedUtxos = [];
+  for (const utxo of sortedUtxos) {
+    selectedUtxos.push(utxo);
+    totalSelected += utxo.amount;
+    if (totalSelected >= withdrawWei) {
+      break;
+    }
+  }
+  if (totalSelected < withdrawWei) {
+    throw new Error(
+      `Insufficient balance. Need ${amount}, have ${formatUnits(totalSelected, decimals)}`
+    );
+  }
+  const changeAmount = totalSelected - withdrawWei;
+  return { selectedUtxos, totalSelected, changeAmount };
+}
+async function fetchCommitments(rpcUrl, poolAddress, onProgress) {
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(rpcUrl)
+  });
+  onProgress?.("Fetching commitment count...");
+  const nextIndex = await publicClient.readContract({
+    address: poolAddress,
+    abi: POOL_ABI,
+    functionName: "nextIndex"
+  });
+  if (nextIndex === 0) {
+    return [];
+  }
+  const BATCH_SIZE = 5e3;
+  const commitments = [];
+  const totalBatches = Math.ceil(nextIndex / BATCH_SIZE);
+  for (let start = 0; start < nextIndex; start += BATCH_SIZE) {
+    const end = Math.min(start + BATCH_SIZE, nextIndex);
+    const batchNum = Math.floor(start / BATCH_SIZE) + 1;
+    onProgress?.("Fetching commitments", `batch ${batchNum}/${totalBatches}`);
+    const batch = await publicClient.readContract({
+      address: poolAddress,
+      abi: POOL_ABI,
+      functionName: "getCommitments",
+      args: [BigInt(start), BigInt(end)]
+    });
+    commitments.push(...batch.map((c) => c.toString()));
+  }
+  return commitments;
+}
+async function buildWithdrawProof(options) {
+  const {
+    amount,
+    recipient,
+    keypair,
+    rpcUrl,
+    onProgress
+  } = options;
+  const addresses = getAddresses();
+  const poolConfig = POOL_CONFIG.eth;
+  const poolAddress = addresses.ethPool;
+  onProgress?.("Fetching your UTXOs...");
+  const balanceResult = await getPrivateBalance({
+    keypair,
+    rpcUrl,
+    onProgress
+  });
+  const unspentUtxoInfos = balanceResult.utxos.filter((u) => !u.isSpent);
+  if (unspentUtxoInfos.length === 0) {
+    throw new Error("No unspent UTXOs available for withdrawal");
+  }
+  onProgress?.("Preparing UTXOs...");
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(rpcUrl)
+  });
+  const utxos = [];
+  for (const utxoInfo of unspentUtxoInfos) {
+    const encryptedOutputs = await publicClient.readContract({
+      address: poolAddress,
+      abi: POOL_ABI,
+      functionName: "getEncryptedOutputs",
+      args: [BigInt(utxoInfo.index), BigInt(utxoInfo.index + 1)]
+    });
+    if (encryptedOutputs.length > 0) {
+      try {
+        const utxo = Utxo.decrypt(encryptedOutputs[0], keypair);
+        utxo.index = utxoInfo.index;
+        utxos.push(utxo);
+      } catch {
+      }
+    }
+  }
+  if (utxos.length === 0) {
+    throw new Error("Failed to decrypt UTXOs");
+  }
+  onProgress?.("Selecting UTXOs...");
+  const { selectedUtxos, changeAmount } = selectUtxosForWithdraw(
+    utxos,
+    amount,
+    poolConfig.decimals
+  );
+  const outputs = [];
+  if (changeAmount > 0n) {
+    const changeUtxo = new Utxo({
+      amount: changeAmount,
+      keypair
+    });
+    outputs.push(changeUtxo);
+  }
+  const commitments = await fetchCommitments(rpcUrl, poolAddress, onProgress);
+  onProgress?.("Building ZK proof...");
+  const result = await prepareTransaction({
+    commitments,
+    inputs: selectedUtxos,
+    outputs,
+    fee: 0,
+    recipient,
+    relayer: "0x0000000000000000000000000000000000000000",
+    onProgress
+  });
+  return {
+    proofArgs: {
+      proof: result.args.proof,
+      root: result.args.root,
+      inputNullifiers: result.args.inputNullifiers,
+      outputCommitments: result.args.outputCommitments,
+      publicAmount: result.args.publicAmount,
+      extDataHash: result.args.extDataHash
+    },
+    extData: result.extData,
+    inputCount: selectedUtxos.length,
+    outputCount: outputs.length,
+    amount
+  };
+}
+async function withdraw(options) {
+  const { amount, recipient, onProgress } = options;
+  const proof = await buildWithdrawProof(options);
+  onProgress?.("Submitting to relay...");
+  const relayResult = await submitRelay({
+    type: "withdraw",
+    pool: "eth",
+    proofArgs: proof.proofArgs,
+    extData: proof.extData,
+    metadata: {
+      amount,
+      recipient,
+      inputUtxoCount: proof.inputCount,
+      outputUtxoCount: proof.outputCount
+    }
+  });
+  return {
+    success: relayResult.success,
+    transactionHash: relayResult.transactionHash,
+    blockNumber: relayResult.blockNumber,
+    amount,
+    recipient
+  };
+}
+async function checkRecipientRegistration(address, rpcUrl) {
+  const addresses = getAddresses();
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(rpcUrl)
+  });
+  const depositKey = await publicClient.readContract({
+    address: addresses.entry,
+    abi: ENTRY_ABI,
+    functionName: "depositKeys",
+    args: [address]
+  });
+  const isRegistered = !!(depositKey && depositKey !== "0x" && depositKey.length > 2);
+  return {
+    isRegistered,
+    depositKey: isRegistered ? depositKey : void 0
+  };
+}
+async function fetchCommitments2(rpcUrl, poolAddress, onProgress) {
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(rpcUrl)
+  });
+  onProgress?.("Fetching commitment count...");
+  const nextIndex = await publicClient.readContract({
+    address: poolAddress,
+    abi: POOL_ABI,
+    functionName: "nextIndex"
+  });
+  if (nextIndex === 0) {
+    return [];
+  }
+  const BATCH_SIZE = 5e3;
+  const commitments = [];
+  const totalBatches = Math.ceil(nextIndex / BATCH_SIZE);
+  for (let start = 0; start < nextIndex; start += BATCH_SIZE) {
+    const end = Math.min(start + BATCH_SIZE, nextIndex);
+    const batchNum = Math.floor(start / BATCH_SIZE) + 1;
+    onProgress?.("Fetching commitments", `batch ${batchNum}/${totalBatches}`);
+    const batch = await publicClient.readContract({
+      address: poolAddress,
+      abi: POOL_ABI,
+      functionName: "getCommitments",
+      args: [BigInt(start), BigInt(end)]
+    });
+    commitments.push(...batch.map((c) => c.toString()));
+  }
+  return commitments;
+}
+async function buildTransferProof(options) {
+  const {
+    amount,
+    recipientAddress,
+    senderKeypair,
+    rpcUrl,
+    onProgress
+  } = options;
+  const addresses = getAddresses();
+  const poolConfig = POOL_CONFIG.eth;
+  const poolAddress = addresses.ethPool;
+  onProgress?.("Checking recipient registration...");
+  const { isRegistered, depositKey } = await checkRecipientRegistration(
+    recipientAddress,
+    rpcUrl
+  );
+  if (!isRegistered || !depositKey) {
+    throw new Error(`Recipient ${recipientAddress} is not registered. They need to register first.`);
+  }
+  onProgress?.("Fetching your UTXOs...");
+  const balanceResult = await getPrivateBalance({
+    keypair: senderKeypair,
+    rpcUrl,
+    onProgress
+  });
+  const unspentUtxoInfos = balanceResult.utxos.filter((u) => !u.isSpent);
+  if (unspentUtxoInfos.length === 0) {
+    throw new Error("No unspent UTXOs available for transfer");
+  }
+  onProgress?.("Preparing UTXOs...");
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(rpcUrl)
+  });
+  const utxos = [];
+  for (const utxoInfo of unspentUtxoInfos) {
+    const encryptedOutputs = await publicClient.readContract({
+      address: poolAddress,
+      abi: POOL_ABI,
+      functionName: "getEncryptedOutputs",
+      args: [BigInt(utxoInfo.index), BigInt(utxoInfo.index + 1)]
+    });
+    if (encryptedOutputs.length > 0) {
+      try {
+        const utxo = Utxo.decrypt(encryptedOutputs[0], senderKeypair);
+        utxo.index = utxoInfo.index;
+        utxos.push(utxo);
+      } catch {
+      }
+    }
+  }
+  if (utxos.length === 0) {
+    throw new Error("Failed to decrypt UTXOs");
+  }
+  onProgress?.("Selecting UTXOs...");
+  const { selectedUtxos, changeAmount } = selectUtxosForWithdraw(
+    utxos,
+    amount,
+    poolConfig.decimals
+  );
+  const outputs = [];
+  const transferWei = parseUnits(amount, poolConfig.decimals);
+  const recipientKeypair = Keypair.fromString(depositKey);
+  const recipientUtxo = new Utxo({
+    amount: transferWei,
+    keypair: recipientKeypair
+  });
+  outputs.push(recipientUtxo);
+  if (changeAmount > 0n) {
+    const changeUtxo = new Utxo({
+      amount: changeAmount,
+      keypair: senderKeypair
+    });
+    outputs.push(changeUtxo);
+  }
+  const commitments = await fetchCommitments2(rpcUrl, poolAddress, onProgress);
+  onProgress?.("Building ZK proof...");
+  const result = await prepareTransaction({
+    commitments,
+    inputs: selectedUtxos,
+    outputs,
+    fee: 0,
+    recipient: "0x0000000000000000000000000000000000000000",
+    relayer: "0x0000000000000000000000000000000000000000",
+    onProgress
+  });
+  return {
+    proofArgs: {
+      proof: result.args.proof,
+      root: result.args.root,
+      inputNullifiers: result.args.inputNullifiers,
+      outputCommitments: result.args.outputCommitments,
+      publicAmount: result.args.publicAmount,
+      extDataHash: result.args.extDataHash
+    },
+    extData: result.extData,
+    inputCount: selectedUtxos.length,
+    outputCount: outputs.length,
+    amount
+  };
+}
+async function transfer(options) {
+  const { amount, recipientAddress, onProgress } = options;
+  const proof = await buildTransferProof(options);
+  onProgress?.("Submitting to relay...");
+  const relayResult = await submitRelay({
+    type: "transfer",
+    pool: "eth",
+    proofArgs: proof.proofArgs,
+    extData: proof.extData,
+    metadata: {
+      amount,
+      recipient: recipientAddress,
+      inputUtxoCount: proof.inputCount,
+      outputUtxoCount: proof.outputCount
+    }
+  });
+  return {
+    success: relayResult.success,
+    transactionHash: relayResult.transactionHash,
+    blockNumber: relayResult.blockNumber,
+    amount,
+    recipient: recipientAddress
+  };
+}
+async function mergeUtxos(options) {
+  const { amount, keypair, rpcUrl, onProgress } = options;
+  const addresses = getAddresses();
+  const poolConfig = POOL_CONFIG.eth;
+  const poolAddress = addresses.ethPool;
+  onProgress?.("Fetching your UTXOs...");
+  const balanceResult = await getPrivateBalance({
+    keypair,
+    rpcUrl,
+    onProgress
+  });
+  const unspentUtxoInfos = balanceResult.utxos.filter((u) => !u.isSpent);
+  if (unspentUtxoInfos.length === 0) {
+    throw new Error("No unspent UTXOs available for merge");
+  }
+  onProgress?.("Preparing UTXOs...");
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(rpcUrl)
+  });
+  const utxos = [];
+  for (const utxoInfo of unspentUtxoInfos) {
+    const encryptedOutputs = await publicClient.readContract({
+      address: poolAddress,
+      abi: POOL_ABI,
+      functionName: "getEncryptedOutputs",
+      args: [BigInt(utxoInfo.index), BigInt(utxoInfo.index + 1)]
+    });
+    if (encryptedOutputs.length > 0) {
+      try {
+        const utxo = Utxo.decrypt(encryptedOutputs[0], keypair);
+        utxo.index = utxoInfo.index;
+        utxos.push(utxo);
+      } catch {
+      }
+    }
+  }
+  if (utxos.length === 0) {
+    throw new Error("Failed to decrypt UTXOs");
+  }
+  onProgress?.("Selecting UTXOs...");
+  const { selectedUtxos, changeAmount } = selectUtxosForWithdraw(
+    utxos,
+    amount,
+    poolConfig.decimals
+  );
+  const outputs = [];
+  const mergeWei = parseUnits(amount, poolConfig.decimals);
+  const mergedUtxo = new Utxo({
+    amount: mergeWei,
+    keypair
+  });
+  outputs.push(mergedUtxo);
+  if (changeAmount > 0n) {
+    const changeUtxo = new Utxo({
+      amount: changeAmount,
+      keypair
+    });
+    outputs.push(changeUtxo);
+  }
+  const commitments = await fetchCommitments2(rpcUrl, poolAddress, onProgress);
+  onProgress?.("Building ZK proof...");
+  const result = await prepareTransaction({
+    commitments,
+    inputs: selectedUtxos,
+    outputs,
+    fee: 0,
+    recipient: "0x0000000000000000000000000000000000000000",
+    relayer: "0x0000000000000000000000000000000000000000",
+    onProgress
+  });
+  onProgress?.("Submitting to relay...");
+  const relayResult = await submitRelay({
+    type: "transfer",
+    pool: "eth",
+    proofArgs: {
+      proof: result.args.proof,
+      root: result.args.root,
+      inputNullifiers: result.args.inputNullifiers,
+      outputCommitments: result.args.outputCommitments,
+      publicAmount: result.args.publicAmount,
+      extDataHash: result.args.extDataHash
+    },
+    extData: result.extData,
+    metadata: {
+      amount,
+      inputUtxoCount: selectedUtxos.length,
+      outputUtxoCount: outputs.length
+    }
+  });
+  return {
+    success: relayResult.success,
+    transactionHash: relayResult.transactionHash,
+    blockNumber: relayResult.blockNumber,
+    amount,
+    recipient: "self"
+  };
+}
+
+export { ADDRESSES, CIRCUIT_CONFIG, ENTRY_ABI, ERC20_ABI, FIELD_SIZE, Keypair, MERKLE_TREE_HEIGHT, POOL_ABI, POOL_CONFIG, QUEUE_ABI, RelayError, Utxo, buildApproveUSDCTx, buildDepositETHTx, buildDepositTx, buildDepositUSDCTx, buildMerkleTree, buildRegisterTx, buildTransferProof, buildWithdrawProof, checkRecipientRegistration, checkRelayHealth, getAddresses, getExtDataHash, getMerklePath, getPrivateBalance, getQueueBalance, getRelayInfo, getRelayUrl, mergeUtxos, packEncryptedMessage, poseidonHash, poseidonHash2, prepareTransaction, prove, randomBN, selectCircuit, selectUtxosForWithdraw, shuffle, submitRelay, toBuffer, toFixedHex, transfer, unpackEncryptedMessage, withdraw };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map