@hula-privacy/mixer 0.2.0 → 0.3.0

package/dist/index.js

@@ -0,0 +1,2587 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DOMAIN_ENCRYPTION: () => DOMAIN_ENCRYPTION,
+  DOMAIN_NULLIFIER: () => DOMAIN_NULLIFIER,
+  DOMAIN_OWNER: () => DOMAIN_OWNER,
+  DOMAIN_VIEWING: () => DOMAIN_VIEWING,
+  FIELD_PRIME: () => FIELD_PRIME,
+  HulaWallet: () => HulaWallet,
+  MAX_LEAVES: () => MAX_LEAVES,
+  MERKLE_TREE_DEPTH: () => MERKLE_TREE_DEPTH,
+  MERKLE_TREE_SEED: () => MERKLE_TREE_SEED,
+  NULLIFIER_SEED: () => NULLIFIER_SEED,
+  NUM_INPUT_UTXOS: () => NUM_INPUT_UTXOS,
+  NUM_OUTPUT_UTXOS: () => NUM_OUTPUT_UTXOS,
+  POOL_SEED: () => POOL_SEED,
+  PROGRAM_ID: () => PROGRAM_ID,
+  PROOF_SIZE: () => PROOF_SIZE,
+  RelayerClient: () => RelayerClient,
+  TOKEN_2022_PROGRAM_ID: () => TOKEN_2022_PROGRAM_ID,
+  VAULT_SEED: () => VAULT_SEED,
+  bigIntToBytes: () => bigIntToBytes,
+  bigIntToBytes32: () => bigIntToBytes32,
+  buildTransaction: () => buildTransaction,
+  buildTransactionAccounts: () => buildTransactionAccounts,
+  bytesToBigInt: () => bytesToBigInt,
+  bytesToHex: () => bytesToHex,
+  calculateBalance: () => calculateBalance,
+  computeCommitment: () => computeCommitment,
+  computeMerklePathFromLeaves: () => computeMerklePathFromLeaves,
+  computeMerkleRoot: () => computeMerkleRoot,
+  computeNullifier: () => computeNullifier,
+  computeNullifierFromKeys: () => computeNullifierFromKeys,
+  computeZeros: () => computeZeros,
+  createDummyUTXO: () => createDummyUTXO,
+  createUTXO: () => createUTXO,
+  decryptNote: () => decryptNote,
+  deriveKeys: () => deriveKeys,
+  deriveSpendingKeyFromSignature: () => deriveSpendingKeyFromSignature,
+  deserializeEncryptedNote: () => deserializeEncryptedNote,
+  deserializeUTXO: () => deserializeUTXO,
+  encryptNote: () => encryptNote,
+  fetchMerklePath: () => fetchMerklePath,
+  fetchMerkleRoot: () => fetchMerkleRoot,
+  formatCommitment: () => formatCommitment,
+  generateProof: () => generateProof,
+  generateProofInMemory: () => generateProofInMemory,
+  generateSpendingKey: () => generateSpendingKey,
+  getCircuitPaths: () => getCircuitPaths,
+  getCurrentTreeIndex: () => getCurrentTreeIndex,
+  getEmptyTreeRoot: () => getEmptyTreeRoot,
+  getKeyDerivationMessage: () => getKeyDerivationMessage,
+  getMerkleTreePDA: () => getMerkleTreePDA,
+  getNextLeafIndex: () => getNextLeafIndex,
+  getNullifierPDA: () => getNullifierPDA,
+  getPoolPDA: () => getPoolPDA,
+  getPoseidon: () => getPoseidon,
+  getRelayerClient: () => getRelayerClient,
+  getVaultPDA: () => getVaultPDA,
+  getZeroAtLevel: () => getZeroAtLevel,
+  hexToBytes: () => hexToBytes,
+  initHulaSDK: () => initHulaSDK,
+  initPoseidon: () => initPoseidon,
+  isPoseidonInitialized: () => isPoseidonInitialized,
+  parseProof: () => parseProof,
+  poseidonHash: () => poseidonHash,
+  pubkeyToBigInt: () => pubkeyToBigInt,
+  scanNotesForUTXOs: () => scanNotesForUTXOs,
+  selectUTXOs: () => selectUTXOs,
+  serializeEncryptedNote: () => serializeEncryptedNote,
+  serializeUTXO: () => serializeUTXO,
+  setCircuitPaths: () => setCircuitPaths,
+  setDefaultRelayerUrl: () => setDefaultRelayerUrl,
+  syncUTXOs: () => syncUTXOs,
+  toAnchorPublicInputs: () => toAnchorPublicInputs,
+  verifyCircuitFiles: () => verifyCircuitFiles,
+  verifyMerklePath: () => verifyMerklePath
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/wallet.ts
+var import_web34 = require("@solana/web3.js");
+var import_anchor2 = require("@coral-xyz/anchor");
+
+// src/idl.ts
+var HulaPrivacyIdl = {
+  "address": "tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA",
+  "metadata": {
+    "name": "hula_privacy",
+    "version": "0.1.0",
+    "spec": "0.1.0",
+    "description": "Privacy wallet for Solana using ZK proofs"
+  },
+  "instructions": [
+    {
+      "name": "initialize_new_tree",
+      "docs": [
+        "Initialize a new merkle tree when the current one is full"
+      ],
+      "discriminator": [
+        42,
+        154,
+        29,
+        105,
+        242,
+        162,
+        191,
+        224
+      ],
+      "accounts": [
+        {
+          "name": "payer",
+          "docs": [
+            "The payer for account creation"
+          ],
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "pool",
+          "docs": [
+            "Global privacy pool account"
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  104,
+                  117,
+                  108,
+                  97,
+                  95,
+                  112,
+                  111,
+                  111,
+                  108
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "current_tree",
+          "docs": [
+            "The current (full) merkle tree"
+          ],
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  109,
+                  101,
+                  114,
+                  107,
+                  108,
+                  101,
+                  95,
+                  116,
+                  114,
+                  101,
+                  101
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "pool.current_tree_index",
+                "account": "PrivacyPool"
+              }
+            ]
+          }
+        },
+        {
+          "name": "new_tree",
+          "docs": [
+            "New merkle tree account (PDA with tree_index)"
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  109,
+                  101,
+                  114,
+                  107,
+                  108,
+                  101,
+                  95,
+                  116,
+                  114,
+                  101,
+                  101
+                ]
+              },
+              {
+                "kind": "arg",
+                "path": "tree_index"
+              }
+            ]
+          }
+        },
+        {
+          "name": "system_program",
+          "docs": [
+            "System program"
+          ],
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [
+        {
+          "name": "tree_index",
+          "type": "u32"
+        }
+      ]
+    },
+    {
+      "name": "initialize_pool",
+      "docs": [
+        "Initialize the global privacy pool"
+      ],
+      "discriminator": [
+        95,
+        180,
+        10,
+        172,
+        84,
+        174,
+        232,
+        40
+      ],
+      "accounts": [
+        {
+          "name": "authority",
+          "docs": [
+            "The authority creating the pool (pays for account creation)"
+          ],
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "pool",
+          "docs": [
+            "Global privacy pool account (PDA)"
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  104,
+                  117,
+                  108,
+                  97,
+                  95,
+                  112,
+                  111,
+                  111,
+                  108
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "merkle_tree",
+          "docs": [
+            "Merkle tree account (PDA with tree index 0)"
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  109,
+                  101,
+                  114,
+                  107,
+                  108,
+                  101,
+                  95,
+                  116,
+                  114,
+                  101,
+                  101
+                ]
+              },
+              {
+                "kind": "const",
+                "value": [
+                  0,
+                  0,
+                  0,
+                  0
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "system_program",
+          "docs": [
+            "System program"
+          ],
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": []
+    },
+    {
+      "name": "transact",
+      "docs": [
+        "Execute a private transaction"
+      ],
+      "discriminator": [
+        217,
+        149,
+        130,
+        143,
+        221,
+        52,
+        252,
+        119
+      ],
+      "accounts": [
+        {
+          "name": "payer",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "mint"
+        },
+        {
+          "name": "pool",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  104,
+                  117,
+                  108,
+                  97,
+                  95,
+                  112,
+                  111,
+                  111,
+                  108
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "input_tree",
+          "docs": [
+            "Input tree - where the input UTXOs come from (for merkle root verification)",
+            "If None, defaults to current tree"
+          ],
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  109,
+                  101,
+                  114,
+                  107,
+                  108,
+                  101,
+                  95,
+                  116,
+                  114,
+                  101,
+                  101
+                ]
+              },
+              {
+                "kind": "arg",
+                "path": "input_tree_index.unwrap_or(pool.current_tree_index)"
+              }
+            ]
+          }
+        },
+        {
+          "name": "merkle_tree",
+          "docs": [
+            "Output tree - where new commitments will be inserted (current active tree)"
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  109,
+                  101,
+                  114,
+                  107,
+                  108,
+                  101,
+                  95,
+                  116,
+                  114,
+                  101,
+                  101
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "pool.current_tree_index",
+                "account": "PrivacyPool"
+              }
+            ]
+          }
+        },
+        {
+          "name": "vault",
+          "docs": [
+            "Vault for this mint (created if needed)"
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "mint"
+              }
+            ]
+          }
+        },
+        {
+          "name": "depositor_token_account",
+          "docs": [
+            "Depositor's token account (optional)"
+          ],
+          "writable": true,
+          "optional": true
+        },
+        {
+          "name": "depositor",
+          "signer": true,
+          "optional": true
+        },
+        {
+          "name": "recipient_token_account",
+          "docs": [
+            "Recipient's token account (optional)"
+          ],
+          "writable": true,
+          "optional": true
+        },
+        {
+          "name": "fee_recipient_token_account",
+          "docs": [
+            "Fee recipient's token account (optional)"
+          ],
+          "writable": true,
+          "optional": true
+        },
+        {
+          "name": "nullifier_account_0",
+          "docs": [
+            "Nullifier account 0 (optional - for first input UTXO)"
+          ],
+          "writable": true,
+          "optional": true
+        },
+        {
+          "name": "nullifier_account_1",
+          "docs": [
+            "Nullifier account 1 (optional - for second input UTXO)"
+          ],
+          "writable": true,
+          "optional": true
+        },
+        {
+          "name": "token_program",
+          "address": "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [
+        {
+          "name": "input_tree_index",
+          "type": {
+            "option": "u32"
+          }
+        },
+        {
+          "name": "proof",
+          "type": {
+            "array": [
+              "u8",
+              256
+            ]
+          }
+        },
+        {
+          "name": "public_inputs",
+          "type": {
+            "defined": {
+              "name": "PublicInputs"
+            }
+          }
+        },
+        {
+          "name": "encrypted_notes",
+          "type": {
+            "vec": "bytes"
+          }
+        }
+      ]
+    }
+  ],
+  "accounts": [
+    {
+      "name": "MerkleTreeAccount",
+      "discriminator": [
+        147,
+        200,
+        34,
+        248,
+        131,
+        187,
+        248,
+        253
+      ]
+    },
+    {
+      "name": "PrivacyPool",
+      "discriminator": [
+        133,
+        184,
+        191,
+        79,
+        252,
+        142,
+        190,
+        150
+      ]
+    }
+  ],
+  "errors": [
+    {
+      "code": 6e3,
+      "name": "Groth16MulFailed",
+      "msg": "Groth16 multiplication failed"
+    },
+    {
+      "code": 6001,
+      "name": "Groth16AddFailed",
+      "msg": "Groth16 addition failed"
+    },
+    {
+      "code": 6002,
+      "name": "Groth16PairingFailed",
+      "msg": "Groth16 pairing failed"
+    },
+    {
+      "code": 6003,
+      "name": "InvalidPublicInputs",
+      "msg": "Invalid public inputs"
+    },
+    {
+      "code": 6004,
+      "name": "ProofVerificationFailed",
+      "msg": "Proof verification failed"
+    },
+    {
+      "code": 6005,
+      "name": "PoolPaused",
+      "msg": "Pool is paused"
+    },
+    {
+      "code": 6006,
+      "name": "InvalidMint",
+      "msg": "Invalid mint"
+    },
+    {
+      "code": 6007,
+      "name": "Unauthorized",
+      "msg": "Unauthorized"
+    },
+    {
+      "code": 6008,
+      "name": "TreeFull",
+      "msg": "Merkle tree is full"
+    },
+    {
+      "code": 6009,
+      "name": "InvalidRoot",
+      "msg": "Invalid merkle root"
+    },
+    {
+      "code": 6010,
+      "name": "NullifierAlreadySpent",
+      "msg": "Nullifier already spent"
+    },
+    {
+      "code": 6011,
+      "name": "NullifierAlreadyUsed",
+      "msg": "Nullifier already used - double spend attempt"
+    },
+    {
+      "code": 6012,
+      "name": "MissingNullifierAccount",
+      "msg": "Missing nullifier account"
+    },
+    {
+      "code": 6013,
+      "name": "InvalidNullifierAccount",
+      "msg": "Invalid nullifier account"
+    },
+    {
+      "code": 6014,
+      "name": "InvalidPublicAmount",
+      "msg": "Invalid public amount"
+    },
+    {
+      "code": 6015,
+      "name": "ArithmeticOverflow",
+      "msg": "Arithmetic overflow"
+    },
+    {
+      "code": 6016,
+      "name": "InvalidRecipient",
+      "msg": "Invalid recipient"
+    },
+    {
+      "code": 6017,
+      "name": "InvalidFee",
+      "msg": "Invalid fee"
+    },
+    {
+      "code": 6018,
+      "name": "TreeNotFull",
+      "msg": "Tree is not full yet"
+    },
+    {
+      "code": 6019,
+      "name": "InvalidTreeIndex",
+      "msg": "Invalid tree index"
+    }
+  ],
+  "types": [
+    {
+      "name": "MerkleTreeAccount",
+      "docs": [
+        "Incremental Merkle Tree for UTXO commitments",
+        "Uses a sparse representation - only stores filled subtrees"
+      ],
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "pool",
+            "docs": [
+              "The privacy pool this tree belongs to"
+            ],
+            "type": "pubkey"
+          },
+          {
+            "name": "tree_index",
+            "docs": [
+              "Tree index (which tree in the sequence)"
+            ],
+            "type": "u32"
+          },
+          {
+            "name": "next_index",
+            "docs": [
+              "Current number of leaves inserted"
+            ],
+            "type": "u32"
+          },
+          {
+            "name": "root",
+            "docs": [
+              "Current root of the tree"
+            ],
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            "name": "filled_subtrees",
+            "docs": [
+              "Filled subtrees at each level (for incremental insertion)",
+              "filled_subtrees[i] = the rightmost filled node at level i"
+            ],
+            "type": {
+              "array": [
+                {
+                  "array": [
+                    "u8",
+                    32
+                  ]
+                },
+                10
+              ]
+            }
+          },
+          {
+            "name": "root_history",
+            "docs": [
+              "Historical roots for verification (ring buffer)",
+              "Allows verifying proofs against recent roots"
+            ],
+            "type": {
+              "array": [
+                {
+                  "array": [
+                    "u8",
+                    32
+                  ]
+                },
+                32
+              ]
+            }
+          },
+          {
+            "name": "root_history_index",
+            "docs": [
+              "Current position in root history ring buffer"
+            ],
+            "type": "u8"
+          },
+          {
+            "name": "bump",
+            "docs": [
+              "Bump seed for PDA"
+            ],
+            "type": "u8"
+          }
+        ]
+      }
+    },
+    {
+      "name": "PrivacyPool",
+      "docs": [
+        "Global Privacy Pool Account",
+        "Single pool for all tokens - vaults are created per mint lazily"
+      ],
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "authority",
+            "docs": [
+              "Authority that can update pool settings"
+            ],
+            "type": "pubkey"
+          },
+          {
+            "name": "commitment_count",
+            "docs": [
+              "Total number of commitments across all trees"
+            ],
+            "type": "u64"
+          },
+          {
+            "name": "merkle_root",
+            "docs": [
+              "Current merkle root (of the active tree)"
+            ],
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            "name": "bump",
+            "docs": [
+              "Pool bump seed"
+            ],
+            "type": "u8"
+          },
+          {
+            "name": "paused",
+            "docs": [
+              "Whether the pool is paused"
+            ],
+            "type": "bool"
+          },
+          {
+            "name": "current_tree_index",
+            "docs": [
+              "Current active tree index (0-based)"
+            ],
+            "type": "u32"
+          },
+          {
+            "name": "_reserved",
+            "docs": [
+              "Reserved for future use"
+            ],
+            "type": "bytes"
+          }
+        ]
+      }
+    },
+    {
+      "name": "PublicInputs",
+      "docs": [
+        "Public inputs for the transaction circuit"
+      ],
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "merkle_root",
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            "name": "nullifiers",
+            "type": {
+              "array": [
+                {
+                  "array": [
+                    "u8",
+                    32
+                  ]
+                },
+                2
+              ]
+            }
+          },
+          {
+            "name": "output_commitments",
+            "type": {
+              "array": [
+                {
+                  "array": [
+                    "u8",
+                    32
+                  ]
+                },
+                2
+              ]
+            }
+          },
+          {
+            "name": "public_deposit",
+            "type": "u64"
+          },
+          {
+            "name": "public_withdraw",
+            "type": "u64"
+          },
+          {
+            "name": "recipient",
+            "type": "pubkey"
+          },
+          {
+            "name": "mint_token_address",
+            "type": "pubkey"
+          },
+          {
+            "name": "fee",
+            "type": "u64"
+          }
+        ]
+      }
+    }
+  ],
+  "constants": [
+    {
+      "name": "MERKLE_TREE_SEED",
+      "type": "bytes",
+      "value": "[109, 101, 114, 107, 108, 101, 95, 116, 114, 101, 101]"
+    },
+    {
+      "name": "NULLIFIER_SEED",
+      "type": "bytes",
+      "value": "[110, 117, 108, 108, 105, 102, 105, 101, 114]"
+    },
+    {
+      "name": "POOL_SEED",
+      "type": "bytes",
+      "value": "[104, 117, 108, 97, 95, 112, 111, 111, 108]"
+    },
+    {
+      "name": "VAULT_SEED",
+      "type": "bytes",
+      "value": "[118, 97, 117, 108, 116]"
+    }
+  ]
+};
+var idl_default = HulaPrivacyIdl;
+
+// src/crypto.ts
+var import_circomlibjs = require("circomlibjs");
+var nacl = __toESM(require("tweetnacl"));
+var import_sha256 = require("@noble/hashes/sha256");
+
+// src/constants.ts
+var import_web3 = require("@solana/web3.js");
+var PROGRAM_ID = new import_web3.PublicKey("tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA");
+var TOKEN_2022_PROGRAM_ID = new import_web3.PublicKey(
+  "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+);
+var POOL_SEED = Buffer.from("hula_pool");
+var VAULT_SEED = Buffer.from("vault");
+var MERKLE_TREE_SEED = Buffer.from("merkle_tree");
+var NULLIFIER_SEED = Buffer.from("nullifier");
+var NUM_INPUT_UTXOS = 2;
+var NUM_OUTPUT_UTXOS = 2;
+var MERKLE_TREE_DEPTH = 10;
+var MAX_LEAVES = 1 << MERKLE_TREE_DEPTH;
+var PROOF_SIZE = 256;
+var DOMAIN_OWNER = 0n;
+var DOMAIN_VIEWING = 1n;
+var DOMAIN_NULLIFIER = 2n;
+var DOMAIN_ENCRYPTION = 3n;
+var FIELD_PRIME = BigInt(
+  "21888242871839275222246405745257275088548364400416034343698204186575808495617"
+);
+function getPoolPDA() {
+  return import_web3.PublicKey.findProgramAddressSync([POOL_SEED], PROGRAM_ID);
+}
+function getMerkleTreePDA(treeIndex = 0) {
+  const treeIndexBuffer = Buffer.alloc(4);
+  treeIndexBuffer.writeUInt32LE(treeIndex, 0);
+  return import_web3.PublicKey.findProgramAddressSync(
+    [MERKLE_TREE_SEED, treeIndexBuffer],
+    PROGRAM_ID
+  );
+}
+function getVaultPDA(mint) {
+  return import_web3.PublicKey.findProgramAddressSync(
+    [VAULT_SEED, mint.toBytes()],
+    PROGRAM_ID
+  );
+}
+function getNullifierPDA(nullifier) {
+  return import_web3.PublicKey.findProgramAddressSync(
+    [NULLIFIER_SEED, nullifier],
+    PROGRAM_ID
+  );
+}
+
+// src/crypto.ts
+var poseidonInstance = null;
+async function initPoseidon() {
+  if (!poseidonInstance) {
+    poseidonInstance = await (0, import_circomlibjs.buildPoseidon)();
+  }
+}
+function isPoseidonInitialized() {
+  return poseidonInstance !== null;
+}
+function getPoseidon() {
+  if (!poseidonInstance) {
+    throw new Error("Poseidon not initialized. Call initPoseidon() first.");
+  }
+  return poseidonInstance;
+}
+function poseidonHash(inputs) {
+  const poseidon = getPoseidon();
+  const hash = poseidon(inputs.map((x) => poseidon.F.e(x)));
+  return poseidon.F.toObject(hash);
+}
+function bytesToBigInt(bytes) {
+  let result = 0n;
+  for (let i = 0; i < bytes.length; i++) {
+    result = (result << 8n) + BigInt(bytes[i]);
+  }
+  return result;
+}
+function bigIntToBytes(value, length) {
+  const bytes = new Uint8Array(length);
+  let v = value;
+  for (let i = length - 1; i >= 0; i--) {
+    bytes[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return bytes;
+}
+function bigIntToBytes32(value) {
+  return bigIntToBytes(value, 32);
+}
+function hexToBytes(hex) {
+  const cleaned = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(cleaned.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(cleaned.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function pubkeyToBigInt(pubkey) {
+  return bytesToBigInt(pubkey.toBytes());
+}
+function generateSpendingKey() {
+  const randomBytes2 = nacl.randomBytes(32);
+  return bytesToBigInt(randomBytes2) % 2n ** 253n;
+}
+function deriveKeys(spendingKey) {
+  const owner = poseidonHash([spendingKey, DOMAIN_OWNER]);
+  const viewingKey = poseidonHash([spendingKey, DOMAIN_VIEWING]);
+  const nullifierKey = poseidonHash([spendingKey, DOMAIN_NULLIFIER]);
+  const encryptionSeed = poseidonHash([spendingKey, DOMAIN_ENCRYPTION]);
+  const seedBytes = bigIntToBytes(encryptionSeed, 32);
+  const hashedSeed = (0, import_sha256.sha256)(seedBytes);
+  const encryptionKeyPair = nacl.box.keyPair.fromSecretKey(hashedSeed);
+  return {
+    spendingKey,
+    owner,
+    viewingKey,
+    nullifierKey,
+    encryptionKeyPair
+  };
+}
+function deriveSpendingKeyFromSignature(signature) {
+  if (signature.length < 64) {
+    throw new Error("Signature must be at least 64 bytes");
+  }
+  const hash = (0, import_sha256.sha256)(signature);
+  return bytesToBigInt(hash) % FIELD_PRIME;
+}
+function encryptNote(noteData, recipientEncryptionPubKey) {
+  const mintPrefix = noteData.mintTokenAddress.toString(16).padStart(64, "0").slice(0, 16);
+  const payload = {
+    v: noteData.value.toString(),
+    // value
+    m: mintPrefix,
+    // mint (first 8 bytes as hex)
+    s: noteData.secret.toString()
+    // secret
+    // leafIndex omitted - recipient queries relayer with computed commitment
+  };
+  const message = new TextEncoder().encode(JSON.stringify(payload));
+  const nonce = nacl.randomBytes(24);
+  const ephemeralKeyPair = nacl.box.keyPair();
+  const ciphertext = nacl.box(
+    message,
+    nonce,
+    recipientEncryptionPubKey,
+    ephemeralKeyPair.secretKey
+  );
+  return {
+    ephemeralPubKey: ephemeralKeyPair.publicKey,
+    ciphertext,
+    nonce
+  };
+}
+function decryptNote(encryptedNote, encryptionSecretKey) {
+  try {
+    const decrypted = nacl.box.open(
+      encryptedNote.ciphertext,
+      encryptedNote.nonce,
+      encryptedNote.ephemeralPubKey,
+      encryptionSecretKey
+    );
+    if (!decrypted) return null;
+    const noteData = JSON.parse(new TextDecoder().decode(decrypted));
+    if (noteData.v !== void 0) {
+      return {
+        value: BigInt(noteData.v),
+        mintPrefix: noteData.m,
+        // First 8 bytes as hex string
+        secret: BigInt(noteData.s)
+      };
+    } else {
+      return {
+        value: BigInt(noteData.value),
+        mintPrefix: BigInt(noteData.mintTokenAddress).toString(16).padStart(64, "0").slice(0, 16),
+        secret: BigInt(noteData.secret)
+      };
+    }
+  } catch {
+    return null;
+  }
+}
+function serializeEncryptedNote(note) {
+  const totalLength = 32 + 24 + 2 + note.ciphertext.length;
+  const buffer = new Uint8Array(totalLength);
+  buffer.set(note.ephemeralPubKey, 0);
+  buffer.set(note.nonce, 32);
+  buffer[56] = note.ciphertext.length >> 8 & 255;
+  buffer[57] = note.ciphertext.length & 255;
+  buffer.set(note.ciphertext, 58);
+  return buffer;
+}
+function deserializeEncryptedNote(data) {
+  const ephemeralPubKey = data.slice(0, 32);
+  const nonce = data.slice(32, 56);
+  const ciphertextLength = data[56] << 8 | data[57];
+  const ciphertext = data.slice(58, 58 + ciphertextLength);
+  return { ephemeralPubKey, nonce, ciphertext };
+}
+function formatCommitment(value, length = 16) {
+  if (value instanceof Uint8Array) {
+    return `0x${bytesToHex(value).slice(0, length)}...`;
+  }
+  return `0x${value.toString(16).padStart(64, "0").slice(0, length)}...`;
+}
+
+// src/api.ts
+var DEFAULT_API_URL = "http://localhost:3001";
+var RelayerClient = class {
+  baseUrl;
+  constructor(baseUrl = DEFAULT_API_URL) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  async fetch(path2, init) {
+    const response = await fetch(`${this.baseUrl}${path2}`, {
+      ...init,
+      headers: {
+        "Content-Type": "application/json",
+        ...init?.headers
+      }
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(errorData.error || `HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  // ============================================================================
+  // Health & Stats
+  // ============================================================================
+  /**
+   * Health check
+   */
+  async health() {
+    return this.fetch("/health");
+  }
+  /**
+   * Get protocol stats
+   */
+  async getStats() {
+    return this.fetch("/api/stats");
+  }
+  // ============================================================================
+  // Pool
+  // ============================================================================
+  /**
+   * Get pool data
+   */
+  async getPool() {
+    return this.fetch("/api/pool");
+  }
+  // ============================================================================
+  // Trees
+  // ============================================================================
+  /**
+   * Get all merkle trees
+   */
+  async getTrees() {
+    return this.fetch("/api/trees");
+  }
+  /**
+   * Get tree by index
+   */
+  async getTree(treeIndex) {
+    return this.fetch(`/api/trees/${treeIndex}`);
+  }
+  // ============================================================================
+  // Leaves / Commitments
+  // ============================================================================
+  /**
+   * Get leaves with cursor pagination
+   */
+  async getLeaves(cursor, limit, treeIndex) {
+    const params = new URLSearchParams();
+    if (cursor) params.set("cursor", cursor);
+    if (limit) params.set("limit", String(limit));
+    if (treeIndex !== void 0) params.set("treeIndex", String(treeIndex));
+    return this.fetch(`/api/leaves?${params}`);
+  }
+  /**
+   * Get leaves after a specific index (for syncing)
+   */
+  async getLeavesAfter(treeIndex, afterLeafIndex, limit) {
+    const params = new URLSearchParams();
+    params.set("treeIndex", String(treeIndex));
+    params.set("afterLeafIndex", String(afterLeafIndex));
+    if (limit) params.set("limit", String(limit));
+    return this.fetch(`/api/leaves/after?${params}`);
+  }
+  /**
+   * Get all leaves for a tree (auto-paginated)
+   */
+  async getAllLeavesForTree(treeIndex) {
+    const allLeaves = [];
+    let cursor;
+    while (true) {
+      const response = await this.getLeaves(cursor, 100, treeIndex);
+      allLeaves.push(...response.items);
+      if (!response.hasMore || !response.nextCursor) break;
+      cursor = response.nextCursor;
+    }
+    return allLeaves;
+  }
+  /**
+   * Get all commitment values for a tree as bigints
+   */
+  async getCommitmentsForTree(treeIndex) {
+    const leaves = await this.getAllLeavesForTree(treeIndex);
+    leaves.sort((a, b) => a.leafIndex - b.leafIndex);
+    return leaves.map((l) => {
+      const commitment = l.commitment.startsWith("0x") ? l.commitment : `0x${l.commitment}`;
+      return BigInt(commitment);
+    });
+  }
+  // ============================================================================
+  // Transactions
+  // ============================================================================
+  /**
+   * Get transactions with cursor pagination
+   */
+  async getTransactions(cursor, limit, mint) {
+    const params = new URLSearchParams();
+    if (cursor) params.set("cursor", cursor);
+    if (limit) params.set("limit", String(limit));
+    if (mint) params.set("mint", mint);
+    return this.fetch(`/api/transactions?${params}`);
+  }
+  /**
+   * Get transaction by signature
+   */
+  async getTransaction(signature) {
+    return this.fetch(`/api/transactions/${signature}`);
+  }
+  // ============================================================================
+  // Nullifiers
+  // ============================================================================
+  /**
+   * Check if nullifier is spent
+   */
+  async checkNullifier(nullifier) {
+    return this.fetch(`/api/nullifiers/check?nullifier=${encodeURIComponent(nullifier)}`);
+  }
+  /**
+   * Check multiple nullifiers at once
+   */
+  async checkNullifiersBatch(nullifiers) {
+    return this.fetch("/api/nullifiers/check-batch", {
+      method: "POST",
+      body: JSON.stringify({ nullifiers })
+    });
+  }
+  // ============================================================================
+  // Encrypted Notes
+  // ============================================================================
+  /**
+   * Get encrypted notes with cursor pagination
+   */
+  async getNotes(cursor, limit, afterSlot) {
+    const params = new URLSearchParams();
+    if (cursor) params.set("cursor", cursor);
+    if (limit) params.set("limit", String(limit));
+    if (afterSlot) params.set("afterSlot", afterSlot);
+    return this.fetch(`/api/notes?${params}`);
+  }
+  /**
+   * Get all notes (auto-paginated)
+   */
+  async getAllNotes(afterSlot) {
+    const allNotes = [];
+    let cursor;
+    while (true) {
+      const response = await this.getNotes(cursor, 100, afterSlot);
+      allNotes.push(...response.items);
+      if (!response.hasMore || !response.nextCursor) break;
+      cursor = response.nextCursor;
+    }
+    return allNotes;
+  }
+};
+var defaultClient = null;
+function getRelayerClient(url) {
+  if (url) {
+    return new RelayerClient(url);
+  }
+  if (!defaultClient) {
+    defaultClient = new RelayerClient();
+  }
+  return defaultClient;
+}
+function setDefaultRelayerUrl(url) {
+  defaultClient = new RelayerClient(url);
+}
+
+// src/utxo.ts
+var import_web32 = require("@solana/web3.js");
+function computeCommitment(value, mintTokenAddress, owner, secret) {
+  return poseidonHash([value, mintTokenAddress, owner, secret]);
+}
+function computeNullifier(spendingKey, commitment, leafIndex) {
+  const nullifierKey = poseidonHash([spendingKey, DOMAIN_NULLIFIER]);
+  return poseidonHash([nullifierKey, commitment, BigInt(leafIndex)]);
+}
+function computeNullifierFromKeys(keys, commitment, leafIndex) {
+  return poseidonHash([keys.nullifierKey, commitment, BigInt(leafIndex)]);
+}
+function createUTXO(value, mintTokenAddress, owner, leafIndex, treeIndex = 0) {
+  const secret = generateSpendingKey();
+  const commitment = computeCommitment(value, mintTokenAddress, owner, secret);
+  return {
+    value,
+    mintTokenAddress,
+    owner,
+    secret,
+    commitment,
+    leafIndex,
+    treeIndex
+  };
+}
+function createDummyUTXO() {
+  return {
+    value: 0n,
+    mintTokenAddress: 0n,
+    owner: 0n,
+    secret: 0n,
+    commitment: 0n,
+    leafIndex: 0,
+    treeIndex: 0
+  };
+}
+function serializeUTXO(utxo, mint, createdTx, spent = false, spentTx) {
+  return {
+    value: utxo.value.toString(),
+    mintTokenAddress: utxo.mintTokenAddress.toString(),
+    owner: utxo.owner.toString(),
+    secret: utxo.secret.toString(),
+    commitment: utxo.commitment.toString(),
+    leafIndex: utxo.leafIndex,
+    treeIndex: utxo.treeIndex,
+    mint,
+    spent,
+    spentTx,
+    createdTx,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function deserializeUTXO(data) {
+  return {
+    value: BigInt(data.value),
+    mintTokenAddress: BigInt(data.mintTokenAddress),
+    owner: BigInt(data.owner),
+    secret: BigInt(data.secret),
+    commitment: BigInt(data.commitment),
+    leafIndex: data.leafIndex,
+    treeIndex: data.treeIndex
+  };
+}
+function scanNotesForUTXOs(notes, walletKeys, commitments) {
+  const foundUTXOs = [];
+  for (const note of notes) {
+    try {
+      const noteBytes = hexToBytes(note.encryptedData);
+      const encryptedNote = deserializeEncryptedNote(noteBytes);
+      const decrypted = decryptNote(encryptedNote, walletKeys.encryptionKeyPair.secretKey);
+      if (!decrypted) continue;
+      const mintAddress = note.mint;
+      const mintTokenAddress = pubkeyToBigInt(new import_web32.PublicKey(mintAddress));
+      const commitment = computeCommitment(
+        decrypted.value,
+        mintTokenAddress,
+        walletKeys.owner,
+        decrypted.secret
+      );
+      let foundLeafIndex;
+      const treeCommitments = commitments.get(note.treeIndex);
+      if (treeCommitments) {
+        for (const [leafIndex, onChainCommitment] of treeCommitments.entries()) {
+          if (onChainCommitment === commitment) {
+            foundLeafIndex = leafIndex;
+            break;
+          }
+        }
+      }
+      if (foundLeafIndex === void 0) {
+        continue;
+      }
+      foundUTXOs.push({
+        value: decrypted.value.toString(),
+        mintTokenAddress: mintTokenAddress.toString(),
+        owner: walletKeys.owner.toString(),
+        secret: decrypted.secret.toString(),
+        commitment: commitment.toString(),
+        leafIndex: foundLeafIndex,
+        treeIndex: note.treeIndex,
+        mint: note.mint,
+        spent: false,
+        createdTx: note.txSignature,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (err) {
+    }
+  }
+  return foundUTXOs;
+}
+async function syncUTXOs(walletKeys, existingUTXOs, relayerUrl, afterSlot) {
+  const client = getRelayerClient(relayerUrl);
+  const notes = await client.getAllNotes(afterSlot);
+  const pool = await client.getPool();
+  const commitments = /* @__PURE__ */ new Map();
+  for (let treeIndex = 0; treeIndex <= pool.currentTreeIndex; treeIndex++) {
+    const leaves = await client.getCommitmentsForTree(treeIndex);
+    const treeMap = /* @__PURE__ */ new Map();
+    leaves.forEach((commitment, index) => {
+      treeMap.set(index, commitment);
+    });
+    commitments.set(treeIndex, treeMap);
+  }
+  const newUTXOs = scanNotesForUTXOs(
+    notes.map((n) => ({
+      encryptedData: n.encryptedData,
+      treeIndex: n.treeIndex,
+      mint: n.mint,
+      txSignature: n.txSignature
+    })),
+    walletKeys,
+    commitments
+  );
+  const allUTXOs = [...newUTXOs, ...existingUTXOs];
+  const unspentUTXOs = allUTXOs.filter((u) => !u.spent);
+  const nullifiersToCheck = [];
+  const utxoByNullifier = /* @__PURE__ */ new Map();
+  for (const utxo of unspentUTXOs) {
+    const commitment = BigInt(utxo.commitment);
+    const nullifier = computeNullifier(
+      walletKeys.spendingKey,
+      commitment,
+      utxo.leafIndex
+    );
+    const nullifierStr = nullifier.toString(16).padStart(64, "0");
+    nullifiersToCheck.push(nullifierStr);
+    utxoByNullifier.set(nullifierStr, utxo.commitment);
+  }
+  const spentUTXOs = [];
+  if (nullifiersToCheck.length > 0) {
+    const batchSize = 50;
+    for (let i = 0; i < nullifiersToCheck.length; i += batchSize) {
+      const batch = nullifiersToCheck.slice(i, i + batchSize);
+      const result = await client.checkNullifiersBatch(batch);
+      for (const r of result.results) {
+        if (r.spent) {
+          const utxoId = utxoByNullifier.get(r.nullifier);
+          if (utxoId) {
+            spentUTXOs.push(utxoId);
+          }
+        }
+      }
+    }
+  }
+  return { newUTXOs, spentUTXOs };
+}
+function selectUTXOs(utxos, targetAmount, mint) {
+  const filtered = mint !== void 0 ? utxos.filter((u) => u.mintTokenAddress === mint) : utxos;
+  const sorted = [...filtered].sort((a, b) => {
+    if (a.value > b.value) return -1;
+    if (a.value < b.value) return 1;
+    return 0;
+  });
+  const selected = [];
+  let total = 0n;
+  for (const utxo of sorted) {
+    if (total >= targetAmount) break;
+    selected.push(utxo);
+    total += utxo.value;
+  }
+  if (total < targetAmount) {
+    throw new Error(
+      `Insufficient balance. Need ${targetAmount}, have ${total}`
+    );
+  }
+  return selected;
+}
+function calculateBalance(utxos, mint) {
+  const filtered = mint !== void 0 ? utxos.filter((u) => u.mintTokenAddress === mint) : utxos;
+  return filtered.reduce((sum, u) => sum + u.value, 0n);
+}
+
+// src/transaction.ts
+var import_web33 = require("@solana/web3.js");
+var import_spl_token = require("@solana/spl-token");
+var import_anchor = require("@coral-xyz/anchor");
+
+// src/merkle.ts
+var ZEROS = [];
+function computeZeros() {
+  if (!isPoseidonInitialized()) {
+    throw new Error("Poseidon not initialized. Call initPoseidon() first.");
+  }
+  if (ZEROS.length > 0) {
+    return ZEROS;
+  }
+  const zeros = [0n];
+  const poseidon = getPoseidon();
+  for (let i = 0; i < MERKLE_TREE_DEPTH; i++) {
+    const hash = poseidon([zeros[i], zeros[i]]);
+    zeros.push(poseidon.F.toObject(hash));
+  }
+  ZEROS = zeros;
+  return zeros;
+}
+function getZeroAtLevel(level) {
+  if (ZEROS.length === 0) {
+    computeZeros();
+  }
+  return ZEROS[level];
+}
+function getEmptyTreeRoot() {
+  if (ZEROS.length === 0) {
+    computeZeros();
+  }
+  return ZEROS[MERKLE_TREE_DEPTH];
+}
+function computeMerklePathFromLeaves(leafIndex, leaves) {
+  if (!isPoseidonInitialized()) {
+    throw new Error("Poseidon not initialized. Call initPoseidon() first.");
+  }
+  const zeros = computeZeros();
+  const pathElements = [];
+  const pathIndices = [];
+  const poseidon = getPoseidon();
+  let currentLevel = [...leaves];
+  const treeSize = 1 << MERKLE_TREE_DEPTH;
+  while (currentLevel.length < treeSize) {
+    currentLevel.push(zeros[0]);
+  }
+  let targetIndex = leafIndex;
+  for (let level = 0; level < MERKLE_TREE_DEPTH; level++) {
+    const isLeft = (targetIndex & 1) === 0;
+    pathIndices.push(isLeft ? 0 : 1);
+    const siblingIndex = isLeft ? targetIndex + 1 : targetIndex - 1;
+    pathElements.push(currentLevel[siblingIndex]);
+    const nextLevel = [];
+    for (let i = 0; i < currentLevel.length; i += 2) {
+      const left = currentLevel[i];
+      const right = currentLevel[i + 1] ?? zeros[level];
+      const hash = poseidon([left, right]);
+      nextLevel.push(poseidon.F.toObject(hash));
+    }
+    currentLevel = nextLevel;
+    targetIndex = Math.floor(targetIndex / 2);
+  }
+  return { pathElements, pathIndices, root: currentLevel[0] };
+}
+function computeMerkleRoot(leaves) {
+  if (leaves.length === 0) {
+    return getEmptyTreeRoot();
+  }
+  const { root } = computeMerklePathFromLeaves(0, leaves);
+  return root;
+}
+function verifyMerklePath(leafValue, path2) {
+  if (!isPoseidonInitialized()) {
+    throw new Error("Poseidon not initialized. Call initPoseidon() first.");
+  }
+  let current = leafValue;
+  const poseidon = getPoseidon();
+  for (let i = 0; i < path2.pathElements.length; i++) {
+    const sibling = path2.pathElements[i];
+    const isLeft = path2.pathIndices[i] === 0;
+    const left = isLeft ? current : sibling;
+    const right = isLeft ? sibling : current;
+    const hash = poseidon([left, right]);
+    current = poseidon.F.toObject(hash);
+  }
+  return current === path2.root;
+}
+async function fetchMerklePath(treeIndex, leafIndex, relayerUrl) {
+  const client = getRelayerClient(relayerUrl);
+  const leaves = await client.getCommitmentsForTree(treeIndex);
+  if (leafIndex >= leaves.length) {
+    throw new Error(`Leaf index ${leafIndex} not found in tree ${treeIndex} (has ${leaves.length} leaves)`);
+  }
+  return computeMerklePathFromLeaves(leafIndex, leaves);
+}
+async function fetchMerkleRoot(treeIndex, relayerUrl) {
+  const client = getRelayerClient(relayerUrl);
+  const tree = await client.getTree(treeIndex);
+  const rootStr = tree.root.startsWith("0x") ? tree.root : `0x${tree.root}`;
+  return BigInt(rootStr);
+}
+async function getNextLeafIndex(treeIndex, relayerUrl) {
+  const client = getRelayerClient(relayerUrl);
+  const tree = await client.getTree(treeIndex);
+  return tree.nextIndex;
+}
+async function getCurrentTreeIndex(relayerUrl) {
+  const client = getRelayerClient(relayerUrl);
+  const pool = await client.getPool();
+  return pool.currentTreeIndex;
+}
+
+// src/proof.ts
+var import_fs = require("fs");
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"));
+var circuitWasmPath = null;
+var circuitZkeyPath = null;
+function setCircuitPaths(wasmPath, zkeyPath) {
+  circuitWasmPath = wasmPath;
+  circuitZkeyPath = zkeyPath;
+}
+function getCircuitPaths() {
+  if (circuitWasmPath && circuitZkeyPath) {
+    return { wasmPath: circuitWasmPath, zkeyPath: circuitZkeyPath };
+  }
+  const possibleBasePaths = [
+    import_path.default.join(process.cwd(), "circuits", "build"),
+    import_path.default.join(process.cwd(), "..", "circuits", "build"),
+    import_path.default.join(process.cwd(), "assets")
+  ];
+  for (const basePath of possibleBasePaths) {
+    const wasmPath = import_path.default.join(basePath, "transaction_js", "transaction.wasm");
+    const zkeyPath = import_path.default.join(basePath, "keys", "transaction_final.zkey");
+    if ((0, import_fs.existsSync)(wasmPath) && (0, import_fs.existsSync)(zkeyPath)) {
+      return { wasmPath, zkeyPath };
+    }
+    const altWasmPath = import_path.default.join(basePath, "transaction.wasm");
+    const altZkeyPath = import_path.default.join(basePath, "transaction_final.zkey");
+    if ((0, import_fs.existsSync)(altWasmPath) && (0, import_fs.existsSync)(altZkeyPath)) {
+      return { wasmPath: altWasmPath, zkeyPath: altZkeyPath };
+    }
+  }
+  throw new Error(
+    "Circuit files not found. Either:\n1. Run 'make' in circuits/ directory to build them, or\n2. Call setCircuitPaths() with the correct paths"
+  );
+}
+function verifyCircuitFiles() {
+  const { wasmPath, zkeyPath } = getCircuitPaths();
+  if (!(0, import_fs.existsSync)(wasmPath)) {
+    throw new Error(`Circuit WASM not found: ${wasmPath}`);
+  }
+  if (!(0, import_fs.existsSync)(zkeyPath)) {
+    throw new Error(`Circuit zkey not found: ${zkeyPath}`);
+  }
+}
+function toBigEndianBytes(decimalStr) {
+  let hex = BigInt(decimalStr).toString(16);
+  hex = hex.padStart(64, "0");
+  const bytes = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function parseProof(proofJson) {
+  const proof = new Uint8Array(PROOF_SIZE);
+  const pi_a_x = toBigEndianBytes(proofJson.pi_a[0]);
+  const pi_a_y = toBigEndianBytes(proofJson.pi_a[1]);
+  proof.set(pi_a_x, 0);
+  proof.set(pi_a_y, 32);
+  const pi_b_x0 = toBigEndianBytes(proofJson.pi_b[0][1]);
+  const pi_b_x1 = toBigEndianBytes(proofJson.pi_b[0][0]);
+  const pi_b_y0 = toBigEndianBytes(proofJson.pi_b[1][1]);
+  const pi_b_y1 = toBigEndianBytes(proofJson.pi_b[1][0]);
+  proof.set(pi_b_x0, 64);
+  proof.set(pi_b_x1, 96);
+  proof.set(pi_b_y0, 128);
+  proof.set(pi_b_y1, 160);
+  const pi_c_x = toBigEndianBytes(proofJson.pi_c[0]);
+  const pi_c_y = toBigEndianBytes(proofJson.pi_c[1]);
+  proof.set(pi_c_x, 192);
+  proof.set(pi_c_y, 224);
+  return proof;
+}
+async function generateProof(circuitInputs) {
+  verifyCircuitFiles();
+  const { wasmPath, zkeyPath } = getCircuitPaths();
+  const tempDir = import_path.default.dirname(zkeyPath);
+  const timestamp = Date.now();
+  const inputPath = import_path.default.join(tempDir, `temp_input_${timestamp}.json`);
+  const witnessPath = import_path.default.join(tempDir, `temp_witness_${timestamp}.wtns`);
+  const proofPath = import_path.default.join(tempDir, `temp_proof_${timestamp}.json`);
+  const publicPath = import_path.default.join(tempDir, `temp_public_${timestamp}.json`);
+  try {
+    (0, import_fs.writeFileSync)(inputPath, JSON.stringify(circuitInputs));
+    const witnessGenScript = import_path.default.join(
+      import_path.default.dirname(wasmPath),
+      "generate_witness.cjs"
+    );
+    if (!(0, import_fs.existsSync)(witnessGenScript)) {
+      throw new Error(`Witness generation script not found: ${witnessGenScript}`);
+    }
+    (0, import_child_process.execSync)(`node ${witnessGenScript} ${wasmPath} ${inputPath} ${witnessPath}`, {
+      stdio: "pipe",
+      cwd: tempDir
+    });
+    (0, import_child_process.execSync)(
+      `npx snarkjs groth16 prove ${zkeyPath} ${witnessPath} ${proofPath} ${publicPath}`,
+      {
+        stdio: "pipe",
+        cwd: tempDir
+      }
+    );
+    const proofJson = JSON.parse((0, import_fs.readFileSync)(proofPath, "utf-8"));
+    const publicSignals = JSON.parse((0, import_fs.readFileSync)(publicPath, "utf-8"));
+    const proof = parseProof(proofJson);
+    return { proof, publicSignals };
+  } finally {
+    const cleanup = (filePath) => {
+      try {
+        if ((0, import_fs.existsSync)(filePath)) (0, import_fs.unlinkSync)(filePath);
+      } catch {
+      }
+    };
+    cleanup(inputPath);
+    cleanup(witnessPath);
+    cleanup(proofPath);
+    cleanup(publicPath);
+  }
+}
+async function generateProofInMemory(circuitInputs) {
+  verifyCircuitFiles();
+  const { wasmPath, zkeyPath } = getCircuitPaths();
+  const snarkjs = await import("snarkjs");
+  const { proof: proofData, publicSignals } = await snarkjs.groth16.fullProve(
+    circuitInputs,
+    wasmPath,
+    zkeyPath
+  );
+  const proof = parseProof(proofData);
+  return { proof, publicSignals };
+}
+
+// src/transaction.ts
+async function buildTransaction(request, walletKeys, relayerUrl) {
+  const client = getRelayerClient(relayerUrl);
+  const pool = await client.getPool();
+  const currentTreeIndex = pool.currentTreeIndex;
+  const depositAmount = request.depositAmount ?? 0n;
+  const withdrawAmount = request.withdrawAmount ?? 0n;
+  const fee = request.fee ?? 0n;
+  const inputUtxos = request.inputUtxos ?? [];
+  const outputs = request.outputs ?? [];
+  if (depositAmount === 0n && inputUtxos.length === 0) {
+    throw new Error("Either depositAmount or inputUtxos is required");
+  }
+  if (withdrawAmount > 0n && !request.recipient) {
+    throw new Error("recipient is required when withdrawing");
+  }
+  let inputTreeIndex = currentTreeIndex;
+  if (inputUtxos.length > 0) {
+    inputTreeIndex = inputUtxos[0].treeIndex;
+    for (const utxo of inputUtxos) {
+      if (utxo.treeIndex !== inputTreeIndex) {
+        throw new Error("All input UTXOs must be from the same tree");
+      }
+    }
+  }
+  const leaves = await client.getCommitmentsForTree(inputTreeIndex);
+  let merkleRoot;
+  if (inputUtxos.length > 0) {
+    merkleRoot = await fetchMerkleRoot(inputTreeIndex, relayerUrl);
+  } else {
+    merkleRoot = await fetchMerkleRoot(currentTreeIndex, relayerUrl);
+  }
+  const nextLeafIndex = await getNextLeafIndex(currentTreeIndex, relayerUrl);
+  const totalInputValue = inputUtxos.reduce((sum, u) => sum + u.value, 0n);
+  const totalAvailable = totalInputValue + depositAmount;
+  const mintBigInt = pubkeyToBigInt(request.mint);
+  const outputUtxos = [];
+  let totalOutputValue = 0n;
+  let outputIndex = 0;
+  for (const output of outputs) {
+    const owner = output.owner === "self" ? walletKeys.owner : output.owner;
+    const utxo = createUTXO(
+      output.amount,
+      mintBigInt,
+      owner,
+      nextLeafIndex + outputIndex,
+      currentTreeIndex
+    );
+    outputUtxos.push(utxo);
+    totalOutputValue += output.amount;
+    outputIndex++;
+  }
+  const totalOut = withdrawAmount + fee + totalOutputValue;
+  const changeAmount = totalAvailable - totalOut;
+  if (changeAmount < 0n) {
+    throw new Error(
+      `Insufficient value. Have ${totalAvailable} (inputs: ${totalInputValue}, deposit: ${depositAmount}), need ${totalOut} (outputs: ${totalOutputValue}, withdraw: ${withdrawAmount}, fee: ${fee})`
+    );
+  }
+  if (changeAmount > 0n) {
+    if (outputUtxos.length >= NUM_OUTPUT_UTXOS) {
+      throw new Error("No output slot available for change");
+    }
+    const changeUtxo = createUTXO(
+      changeAmount,
+      mintBigInt,
+      walletKeys.owner,
+      nextLeafIndex + outputIndex,
+      currentTreeIndex
+    );
+    outputUtxos.push(changeUtxo);
+    totalOutputValue += changeAmount;
+  }
+  while (outputUtxos.length < NUM_OUTPUT_UTXOS) {
+    outputUtxos.push(createDummyUTXO());
+  }
+  const circuitInputs = buildCircuitInputs(
+    merkleRoot,
+    inputUtxos,
+    outputUtxos,
+    walletKeys,
+    leaves,
+    depositAmount,
+    withdrawAmount,
+    request.recipient ?? import_web33.PublicKey.default,
+    request.mint,
+    fee
+  );
+  const { proof } = await generateProof(circuitInputs);
+  const nullifiers = circuitInputs.nullifiers.map((n) => BigInt(n));
+  const publicInputs = {
+    merkleRoot: Array.from(bigIntToBytes32(merkleRoot)),
+    nullifiers: nullifiers.map((n) => Array.from(bigIntToBytes32(n))),
+    outputCommitments: outputUtxos.map((u) => Array.from(bigIntToBytes32(u.commitment))),
+    publicDeposit: depositAmount,
+    publicWithdraw: withdrawAmount,
+    recipient: request.recipient ?? import_web33.PublicKey.default,
+    mintTokenAddress: request.mint,
+    fee
+  };
+  const encryptedNotes = [];
+  for (let i = 0; i < outputs.length; i++) {
+    const output = outputs[i];
+    const utxo = outputUtxos[i];
+    if (output.encryptionPubKey && utxo.value > 0n) {
+      const encrypted = encryptNote(
+        {
+          value: utxo.value,
+          mintTokenAddress: utxo.mintTokenAddress,
+          secret: utxo.secret
+          // leafIndex omitted - recipient queries relayer with computed commitment
+        },
+        output.encryptionPubKey
+      );
+      encryptedNotes.push(Buffer.from(serializeEncryptedNote(encrypted)));
+    }
+  }
+  if (changeAmount > 0n) {
+    const changeIndex = outputs.length;
+    const changeUtxo = outputUtxos[changeIndex];
+    const encrypted = encryptNote(
+      {
+        value: changeUtxo.value,
+        mintTokenAddress: changeUtxo.mintTokenAddress,
+        secret: changeUtxo.secret
+        // leafIndex omitted - we already know it locally
+      },
+      walletKeys.encryptionKeyPair.publicKey
+    );
+    encryptedNotes.push(Buffer.from(serializeEncryptedNote(encrypted)));
+  }
+  return {
+    proof,
+    publicInputs,
+    encryptedNotes,
+    outputUtxos: outputUtxos.filter((u) => u.value > 0n),
+    nullifiers,
+    inputTreeIndex,
+    outputTreeIndex: currentTreeIndex
+  };
+}
+function buildCircuitInputs(merkleRoot, inputUtxos, outputUtxos, walletKeys, leaves, depositAmount, withdrawAmount, recipient, mint, fee) {
+  const inputSpendingKeys = [];
+  const inputValues = [];
+  const inputSecrets = [];
+  const inputLeafIndices = [];
+  const inputPathElements = [];
+  const inputPathIndices = [];
+  const nullifiers = [];
+  for (let i = 0; i < NUM_INPUT_UTXOS; i++) {
+    if (i < inputUtxos.length) {
+      const utxo = inputUtxos[i];
+      inputSpendingKeys.push(walletKeys.spendingKey.toString());
+      inputValues.push(utxo.value.toString());
+      inputSecrets.push(utxo.secret.toString());
+      inputLeafIndices.push(utxo.leafIndex.toString());
+      const { pathElements, pathIndices } = computeMerklePathFromLeaves(
+        utxo.leafIndex,
+        leaves
+      );
+      inputPathElements.push(pathElements.map((e) => e.toString()));
+      inputPathIndices.push(pathIndices);
+      const nullifier = computeNullifier(
+        walletKeys.spendingKey,
+        utxo.commitment,
+        utxo.leafIndex
+      );
+      nullifiers.push(nullifier.toString());
+    } else {
+      inputSpendingKeys.push("0");
+      inputValues.push("0");
+      inputSecrets.push("0");
+      inputLeafIndices.push("0");
+      inputPathElements.push(Array(MERKLE_TREE_DEPTH).fill("0"));
+      inputPathIndices.push(Array(MERKLE_TREE_DEPTH).fill(0));
+      nullifiers.push("0");
+    }
+  }
+  return {
+    merkleRoot: merkleRoot.toString(),
+    nullifiers,
+    outputCommitments: outputUtxos.map((u) => u.commitment.toString()),
+    publicDeposit: depositAmount.toString(),
+    publicWithdraw: withdrawAmount.toString(),
+    recipient: pubkeyToBigInt(recipient).toString(),
+    mintTokenAddress: pubkeyToBigInt(mint).toString(),
+    fee: fee.toString(),
+    inputSpendingKeys,
+    inputValues,
+    inputSecrets,
+    inputLeafIndices,
+    inputPathElements,
+    inputPathIndices,
+    outputValues: outputUtxos.map((u) => u.value.toString()),
+    outputOwners: outputUtxos.map((u) => u.owner.toString()),
+    outputSecrets: outputUtxos.map((u) => u.secret.toString())
+  };
+}
+function buildTransactionAccounts(builtTx, payer, mint, depositAmount, withdrawAmount, recipient) {
+  const [poolPda] = getPoolPDA();
+  const [vaultPda] = getVaultPDA(mint);
+  const [inputTreePda] = getMerkleTreePDA(builtTx.inputTreeIndex);
+  const [outputTreePda] = getMerkleTreePDA(builtTx.outputTreeIndex);
+  const preInstructions = [];
+  let depositorTokenAccount = null;
+  let depositor = null;
+  if (depositAmount > 0n) {
+    depositorTokenAccount = (0, import_spl_token.getAssociatedTokenAddressSync)(
+      mint,
+      payer,
+      false,
+      TOKEN_2022_PROGRAM_ID
+    );
+    depositor = payer;
+  }
+  let recipientTokenAccount = null;
+  if (withdrawAmount > 0n && recipient) {
+    recipientTokenAccount = (0, import_spl_token.getAssociatedTokenAddressSync)(
+      mint,
+      recipient,
+      false,
+      TOKEN_2022_PROGRAM_ID
+    );
+    const createAtaIx = (0, import_spl_token.createAssociatedTokenAccountIdempotentInstruction)(
+      payer,
+      recipientTokenAccount,
+      recipient,
+      mint,
+      TOKEN_2022_PROGRAM_ID
+    );
+    preInstructions.push(createAtaIx);
+  }
+  const nullifierPdas = [];
+  for (const nullifier of builtTx.nullifiers) {
+    if (nullifier === 0n) {
+      nullifierPdas.push(null);
+    } else {
+      const nullifierBytes = bigIntToBytes32(nullifier);
+      const [nullifierPda] = getNullifierPDA(nullifierBytes);
+      nullifierPdas.push(nullifierPda);
+    }
+  }
+  const inputTreeIndex = builtTx.inputTreeIndex !== builtTx.outputTreeIndex ? builtTx.inputTreeIndex : null;
+  return {
+    accounts: {
+      payer,
+      mint,
+      pool: poolPda,
+      inputTree: inputTreePda,
+      merkleTree: outputTreePda,
+      vault: vaultPda,
+      depositorTokenAccount,
+      depositor,
+      recipientTokenAccount,
+      feeRecipientTokenAccount: null,
+      // TODO: Add fee recipient support
+      nullifierAccount0: nullifierPdas[0] ?? null,
+      nullifierAccount1: nullifierPdas[1] ?? null,
+      tokenProgram: TOKEN_2022_PROGRAM_ID,
+      systemProgram: import_web33.SystemProgram.programId
+    },
+    preInstructions,
+    inputTreeIndex
+  };
+}
+function toAnchorPublicInputs(builtTx) {
+  return {
+    merkleRoot: builtTx.publicInputs.merkleRoot,
+    nullifiers: builtTx.publicInputs.nullifiers,
+    outputCommitments: builtTx.publicInputs.outputCommitments,
+    publicDeposit: new import_anchor.BN(builtTx.publicInputs.publicDeposit.toString()),
+    publicWithdraw: new import_anchor.BN(builtTx.publicInputs.publicWithdraw.toString()),
+    recipient: builtTx.publicInputs.recipient,
+    mintTokenAddress: builtTx.publicInputs.mintTokenAddress,
+    fee: new import_anchor.BN(builtTx.publicInputs.fee.toString())
+  };
+}
+
+// src/wallet.ts
+var COMPUTE_UNITS = 4e5;
+var COMPUTE_UNIT_PRICE = 1;
+var HulaWallet = class _HulaWallet {
+  connection;
+  relayerUrl;
+  programId;
+  keys;
+  signer;
+  utxos = [];
+  lastSyncedSlot = "0";
+  initialized = false;
+  constructor(connection, relayerUrl, programId, keys, signer) {
+    this.connection = connection;
+    this.relayerUrl = relayerUrl;
+    this.programId = programId;
+    this.keys = keys;
+    this.signer = signer;
+  }
+  /**
+   * Create a new wallet with a random spending key
+   */
+  static async create(config) {
+    await initPoseidon();
+    const connection = new import_web34.Connection(config.rpcUrl, "confirmed");
+    const relayerUrl = config.relayerUrl;
+    const programId = config.programId ?? new import_web34.PublicKey("tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA");
+    setDefaultRelayerUrl(relayerUrl);
+    const spendingKey = generateSpendingKey();
+    const keys = deriveKeys(spendingKey);
+    const wallet = new _HulaWallet(connection, relayerUrl, programId, keys);
+    wallet.initialized = true;
+    return wallet;
+  }
+  /**
+   * Create a wallet from a Solana keypair
+   * 
+   * Derives the spending key deterministically from the keypair's secret key.
+   */
+  static async fromKeypair(keypair, config) {
+    await initPoseidon();
+    const connection = new import_web34.Connection(config.rpcUrl, "confirmed");
+    const relayerUrl = config.relayerUrl;
+    const programId = config.programId ?? new import_web34.PublicKey("tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA");
+    setDefaultRelayerUrl(relayerUrl);
+    const spendingKey = deriveSpendingKeyFromSignature(keypair.secretKey);
+    const keys = deriveKeys(spendingKey);
+    const wallet = new _HulaWallet(connection, relayerUrl, programId, keys, keypair);
+    wallet.initialized = true;
+    return wallet;
+  }
+  /**
+   * Create a wallet from an existing spending key
+   */
+  static async fromSpendingKey(spendingKey, config) {
+    await initPoseidon();
+    const connection = new import_web34.Connection(config.rpcUrl, "confirmed");
+    const relayerUrl = config.relayerUrl;
+    const programId = config.programId ?? new import_web34.PublicKey("tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA");
+    setDefaultRelayerUrl(relayerUrl);
+    const keys = deriveKeys(spendingKey);
+    const wallet = new _HulaWallet(connection, relayerUrl, programId, keys);
+    wallet.initialized = true;
+    return wallet;
+  }
+  /**
+   * Create a wallet from a Solana signature (deterministic derivation)
+   * 
+   * This allows recovery as long as the user can sign with their Solana wallet.
+   */
+  static async fromSignature(signature, config) {
+    await initPoseidon();
+    const connection = new import_web34.Connection(config.rpcUrl, "confirmed");
+    const relayerUrl = config.relayerUrl;
+    const programId = config.programId ?? new import_web34.PublicKey("tnJ9AAxNau3BRBTe7NzXpv8DeYyiogvGd8YPnCiuarA");
+    setDefaultRelayerUrl(relayerUrl);
+    const spendingKey = deriveSpendingKeyFromSignature(signature);
+    const keys = deriveKeys(spendingKey);
+    const wallet = new _HulaWallet(connection, relayerUrl, programId, keys);
+    wallet.initialized = true;
+    return wallet;
+  }
+  // ============================================================================
+  // Getters
+  // ============================================================================
+  /**
+   * Get wallet's owner hash (public identifier)
+   */
+  get owner() {
+    return this.keys.owner;
+  }
+  /**
+   * Get wallet's owner hash as hex string
+   */
+  getOwnerHash() {
+    return "0x" + this.keys.owner.toString(16).padStart(64, "0");
+  }
+  /**
+   * Get wallet's encryption public key as hex string
+   */
+  getEncryptionPublicKey() {
+    return "0x" + Buffer.from(this.keys.encryptionKeyPair.publicKey).toString("hex");
+  }
+  /**
+   * Get wallet's encryption public key as bytes
+   */
+  get encryptionPublicKey() {
+    return this.keys.encryptionKeyPair.publicKey;
+  }
+  /**
+   * Get spending key (CAREFUL - this is sensitive!)
+   */
+  get spendingKey() {
+    return this.keys.spendingKey;
+  }
+  /**
+   * Get all wallet keys
+   */
+  get walletKeys() {
+    return this.keys;
+  }
+  /**
+   * Get the connection
+   */
+  getConnection() {
+    return this.connection;
+  }
+  /**
+   * Get the signer keypair (if available)
+   */
+  getSigner() {
+    return this.signer;
+  }
+  /**
+   * Set the signer keypair
+   */
+  setSigner(signer) {
+    this.signer = signer;
+  }
+  // ============================================================================
+  // UTXO Management
+  // ============================================================================
+  /**
+   * Sync wallet with relayer
+   * 
+   * Fetches new encrypted notes and checks for spent UTXOs.
+   */
+  async sync(onProgress) {
+    if (!this.initialized) {
+      throw new Error("Wallet not initialized");
+    }
+    onProgress?.({ stage: "notes", current: 0, total: 100 });
+    try {
+      const { newUTXOs, spentUTXOs } = await syncUTXOs(
+        this.keys,
+        this.utxos,
+        this.relayerUrl,
+        this.lastSyncedSlot !== "0" ? this.lastSyncedSlot : void 0
+      );
+      this.utxos.push(...newUTXOs);
+      for (const spentId of spentUTXOs) {
+        const utxo = this.utxos.find((u) => u.commitment === spentId);
+        if (utxo) {
+          utxo.spent = true;
+        }
+      }
+      const client = getRelayerClient(this.relayerUrl);
+      const stats = await client.getStats();
+      this.lastSyncedSlot = Date.now().toString();
+      onProgress?.({ stage: "complete", current: 100, total: 100 });
+      return {
+        newUtxos: newUTXOs.length,
+        spentUtxos: spentUTXOs.length,
+        errors: []
+      };
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : "Sync failed";
+      onProgress?.({ stage: "complete", current: 100, total: 100 });
+      return {
+        newUtxos: 0,
+        spentUtxos: 0,
+        errors: [errorMsg]
+      };
+    }
+  }
+  /**
+   * Get all unspent UTXOs
+   */
+  getUnspentUTXOs() {
+    return this.utxos.filter((u) => !u.spent).map(deserializeUTXO);
+  }
+  /**
+   * Get all UTXOs (including spent)
+   */
+  getAllUTXOs() {
+    return [...this.utxos];
+  }
+  /**
+   * Get balance for a specific mint
+   */
+  getBalance(mint) {
+    const mintBigInt = pubkeyToBigInt(mint);
+    const unspent = this.getUnspentUTXOs();
+    return calculateBalance(unspent, mintBigInt);
+  }
+  /**
+   * Import UTXOs (for wallet recovery or manual import)
+   */
+  importUTXOs(utxos) {
+    this.utxos.push(...utxos);
+  }
+  /**
+   * Export UTXOs for backup
+   */
+  exportUTXOs() {
+    return [...this.utxos];
+  }
+  // ============================================================================
+  // Transaction Building
+  // ============================================================================
+  /**
+   * Deposit tokens into the privacy pool
+   * 
+   * @param mint - Token mint address
+   * @param amount - Amount in raw token units
+   * @returns Transaction signature
+   */
+  async deposit(mint, amount) {
+    if (!this.signer) {
+      throw new Error("No signer available. Use fromKeypair() or setSigner() to set a signer.");
+    }
+    const builtTx = await buildTransaction(
+      {
+        mint,
+        depositAmount: amount,
+        outputs: []
+        // Change will be created automatically
+      },
+      this.keys,
+      this.relayerUrl
+    );
+    const { accounts, preInstructions, inputTreeIndex } = buildTransactionAccounts(
+      builtTx,
+      this.signer.publicKey,
+      mint,
+      amount,
+      0n
+    );
+    const allPreInstructions = [
+      import_web34.ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNITS }),
+      import_web34.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: COMPUTE_UNIT_PRICE }),
+      ...preInstructions
+    ];
+    const wallet = new import_anchor2.Wallet(this.signer);
+    const provider = new import_anchor2.AnchorProvider(this.connection, wallet, { commitment: "confirmed" });
+    const program = new import_anchor2.Program(idl_default, provider);
+    const publicInputs = toAnchorPublicInputs(builtTx);
+    const signature = await program.methods.transact(
+      inputTreeIndex,
+      Array.from(builtTx.proof),
+      publicInputs,
+      builtTx.encryptedNotes
+    ).accounts(accounts).preInstructions(allPreInstructions).signers([this.signer]).rpc();
+    return signature;
+  }
+  /**
+   * Transfer tokens privately to another user
+   * 
+   * @param mint - Token mint address
+   * @param amount - Amount in raw token units
+   * @param recipientOwner - Recipient's owner hash (bigint)
+   * @param recipientEncryptionPubKey - Recipient's encryption public key
+   * @returns Transaction signature
+   */
+  async transfer(mint, amount, recipientOwner, recipientEncryptionPubKey) {
+    if (!this.signer) {
+      throw new Error("No signer available. Use fromKeypair() or setSigner() to set a signer.");
+    }
+    const mintBigInt = pubkeyToBigInt(mint);
+    const unspent = this.getUnspentUTXOs().filter(
+      (u) => u.mintTokenAddress === mintBigInt
+    );
+    const inputUtxos = selectUTXOs(unspent, amount, mintBigInt);
+    const builtTx = await buildTransaction(
+      {
+        mint,
+        inputUtxos,
+        outputs: [
+          {
+            owner: recipientOwner,
+            amount,
+            encryptionPubKey: recipientEncryptionPubKey
+          }
+        ]
+      },
+      this.keys,
+      this.relayerUrl
+    );
+    const { accounts, preInstructions, inputTreeIndex } = buildTransactionAccounts(
+      builtTx,
+      this.signer.publicKey,
+      mint,
+      0n,
+      0n
+    );
+    const allPreInstructions = [
+      import_web34.ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNITS }),
+      import_web34.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: COMPUTE_UNIT_PRICE }),
+      ...preInstructions
+    ];
+    const wallet = new import_anchor2.Wallet(this.signer);
+    const provider = new import_anchor2.AnchorProvider(this.connection, wallet, { commitment: "confirmed" });
+    const program = new import_anchor2.Program(idl_default, provider);
+    const publicInputs = toAnchorPublicInputs(builtTx);
+    const signature = await program.methods.transact(
+      inputTreeIndex,
+      Array.from(builtTx.proof),
+      publicInputs,
+      builtTx.encryptedNotes
+    ).accounts(accounts).preInstructions(allPreInstructions).signers([this.signer]).rpc();
+    for (const utxo of inputUtxos) {
+      const serialized = this.utxos.find((u) => u.commitment === utxo.commitment.toString());
+      if (serialized) {
+        serialized.spent = true;
+        serialized.spentTx = signature;
+      }
+    }
+    return signature;
+  }
+  /**
+   * Withdraw tokens from the privacy pool to a public address
+   * 
+   * @param mint - Token mint address
+   * @param amount - Amount in raw token units
+   * @param recipient - Public key to receive the tokens
+   * @returns Transaction signature
+   */
+  async withdraw(mint, amount, recipient) {
+    if (!this.signer) {
+      throw new Error("No signer available. Use fromKeypair() or setSigner() to set a signer.");
+    }
+    const mintBigInt = pubkeyToBigInt(mint);
+    const unspent = this.getUnspentUTXOs().filter(
+      (u) => u.mintTokenAddress === mintBigInt
+    );
+    const inputUtxos = selectUTXOs(unspent, amount, mintBigInt);
+    const builtTx = await buildTransaction(
+      {
+        mint,
+        inputUtxos,
+        withdrawAmount: amount,
+        recipient
+      },
+      this.keys,
+      this.relayerUrl
+    );
+    const { accounts, preInstructions, inputTreeIndex } = buildTransactionAccounts(
+      builtTx,
+      this.signer.publicKey,
+      mint,
+      0n,
+      amount,
+      recipient
+    );
+    const allPreInstructions = [
+      import_web34.ComputeBudgetProgram.setComputeUnitLimit({ units: COMPUTE_UNITS }),
+      import_web34.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: COMPUTE_UNIT_PRICE }),
+      ...preInstructions
+    ];
+    const wallet = new import_anchor2.Wallet(this.signer);
+    const provider = new import_anchor2.AnchorProvider(this.connection, wallet, { commitment: "confirmed" });
+    const program = new import_anchor2.Program(idl_default, provider);
+    const publicInputs = toAnchorPublicInputs(builtTx);
+    const signature = await program.methods.transact(
+      inputTreeIndex,
+      Array.from(builtTx.proof),
+      publicInputs,
+      builtTx.encryptedNotes
+    ).accounts(accounts).preInstructions(allPreInstructions).signers([this.signer]).rpc();
+    for (const utxo of inputUtxos) {
+      const serialized = this.utxos.find((u) => u.commitment === utxo.commitment.toString());
+      if (serialized) {
+        serialized.spent = true;
+        serialized.spentTx = signature;
+      }
+    }
+    return signature;
+  }
+  /**
+   * Build a custom transaction
+   */
+  async buildTransaction(request) {
+    const tx = await buildTransaction(request, this.keys, this.relayerUrl);
+    const { preInstructions } = buildTransactionAccounts(
+      tx,
+      import_web34.PublicKey.default,
+      request.mint,
+      request.depositAmount ?? 0n,
+      request.withdrawAmount ?? 0n,
+      request.recipient
+    );
+    return { transaction: tx, instructions: preInstructions };
+  }
+  // ============================================================================
+  // Transaction Submission
+  // ============================================================================
+  /**
+   * Submit a transaction using an Anchor program
+   * 
+   * @param program - Anchor program instance (any type to avoid IDL complexity)
+   * @param payer - Keypair for signing
+   * @param builtTx - Built transaction from buildTransaction()
+   * @param mint - Token mint
+   * @param depositAmount - Amount being deposited (if any)
+   * @param withdrawAmount - Amount being withdrawn (if any)
+   * @param recipient - Recipient for withdrawal (if any)
+   */
+  async submitTransaction(program, payer, builtTx, mint, depositAmount = 0n, withdrawAmount = 0n, recipient) {
+    const { accounts, preInstructions, inputTreeIndex } = buildTransactionAccounts(
+      builtTx,
+      payer.publicKey,
+      mint,
+      depositAmount,
+      withdrawAmount,
+      recipient
+    );
+    const publicInputs = toAnchorPublicInputs(builtTx);
+    const tx = await program.methods.transact(
+      inputTreeIndex,
+      Array.from(builtTx.proof),
+      publicInputs,
+      builtTx.encryptedNotes
+    ).accounts(accounts).preInstructions(preInstructions).signers([payer]).rpc();
+    for (const _utxo of builtTx.outputUtxos) {
+    }
+    return tx;
+  }
+};
+function getKeyDerivationMessage() {
+  return new TextEncoder().encode("Hula Privacy Wallet Key Derivation v1");
+}
+async function initHulaSDK() {
+  if (!isPoseidonInitialized()) {
+    await initPoseidon();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DOMAIN_ENCRYPTION,
+  DOMAIN_NULLIFIER,
+  DOMAIN_OWNER,
+  DOMAIN_VIEWING,
+  FIELD_PRIME,
+  HulaWallet,
+  MAX_LEAVES,
+  MERKLE_TREE_DEPTH,
+  MERKLE_TREE_SEED,
+  NULLIFIER_SEED,
+  NUM_INPUT_UTXOS,
+  NUM_OUTPUT_UTXOS,
+  POOL_SEED,
+  PROGRAM_ID,
+  PROOF_SIZE,
+  RelayerClient,
+  TOKEN_2022_PROGRAM_ID,
+  VAULT_SEED,
+  bigIntToBytes,
+  bigIntToBytes32,
+  buildTransaction,
+  buildTransactionAccounts,
+  bytesToBigInt,
+  bytesToHex,
+  calculateBalance,
+  computeCommitment,
+  computeMerklePathFromLeaves,
+  computeMerkleRoot,
+  computeNullifier,
+  computeNullifierFromKeys,
+  computeZeros,
+  createDummyUTXO,
+  createUTXO,
+  decryptNote,
+  deriveKeys,
+  deriveSpendingKeyFromSignature,
+  deserializeEncryptedNote,
+  deserializeUTXO,
+  encryptNote,
+  fetchMerklePath,
+  fetchMerkleRoot,
+  formatCommitment,
+  generateProof,
+  generateProofInMemory,
+  generateSpendingKey,
+  getCircuitPaths,
+  getCurrentTreeIndex,
+  getEmptyTreeRoot,
+  getKeyDerivationMessage,
+  getMerkleTreePDA,
+  getNextLeafIndex,
+  getNullifierPDA,
+  getPoolPDA,
+  getPoseidon,
+  getRelayerClient,
+  getVaultPDA,
+  getZeroAtLevel,
+  hexToBytes,
+  initHulaSDK,
+  initPoseidon,
+  isPoseidonInitialized,
+  parseProof,
+  poseidonHash,
+  pubkeyToBigInt,
+  scanNotesForUTXOs,
+  selectUTXOs,
+  serializeEncryptedNote,
+  serializeUTXO,
+  setCircuitPaths,
+  setDefaultRelayerUrl,
+  syncUTXOs,
+  toAnchorPublicInputs,
+  verifyCircuitFiles,
+  verifyMerklePath
+});