@smithii_io/mixoor 0.0.1

package/dist/src/index.js

@@ -0,0 +1,1484 @@
+'use strict';
+
+var kit = require('@solana/kit');
+var circomlibjs = require('circomlibjs');
+var fs = require('fs');
+var path = require('path');
+var snarkjs = require('snarkjs');
+var crypto = require('crypto');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/generated/accounts/nullifierAccount.ts
+var NULLIFIER_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  250,
+  31,
+  238,
+  177,
+  213,
+  98,
+  48,
+  172
+]);
+function getNullifierAccountDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    NULLIFIER_ACCOUNT_DISCRIMINATOR
+  );
+}
+function getNullifierAccountEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["nullifierHash", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["spentAt", kit.getI64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: NULLIFIER_ACCOUNT_DISCRIMINATOR })
+  );
+}
+function getNullifierAccountDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["nullifierHash", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["spentAt", kit.getI64Decoder()]
+  ]);
+}
+function getNullifierAccountCodec() {
+  return kit.combineCodec(
+    getNullifierAccountEncoder(),
+    getNullifierAccountDecoder()
+  );
+}
+function decodeNullifierAccount(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getNullifierAccountDecoder()
+  );
+}
+async function fetchNullifierAccount(rpc, address, config) {
+  const maybeAccount = await fetchMaybeNullifierAccount(rpc, address, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeNullifierAccount(rpc, address, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address, config);
+  return decodeNullifierAccount(maybeAccount);
+}
+async function fetchAllNullifierAccount(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeNullifierAccount(
+    rpc,
+    addresses,
+    config
+  );
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeNullifierAccount(rpc, addresses, config) {
+  const maybeAccounts = await kit.fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map(
+    (maybeAccount) => decodeNullifierAccount(maybeAccount)
+  );
+}
+function getNullifierAccountSize() {
+  return 48;
+}
+var AssetType = /* @__PURE__ */ ((AssetType2) => {
+  AssetType2[AssetType2["Sol"] = 0] = "Sol";
+  AssetType2[AssetType2["SplToken"] = 1] = "SplToken";
+  return AssetType2;
+})(AssetType || {});
+function getAssetTypeEncoder() {
+  return kit.getEnumEncoder(AssetType);
+}
+function getAssetTypeDecoder() {
+  return kit.getEnumDecoder(AssetType);
+}
+function getAssetTypeCodec() {
+  return kit.combineCodec(getAssetTypeEncoder(), getAssetTypeDecoder());
+}
+function getCommitmentInsertedEncoder() {
+  return kit.getStructEncoder([
+    ["commitment", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+    ["leafIndex", kit.getU32Encoder()],
+    ["pool", kit.getAddressEncoder()]
+  ]);
+}
+function getCommitmentInsertedDecoder() {
+  return kit.getStructDecoder([
+    ["commitment", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["leafIndex", kit.getU32Decoder()],
+    ["pool", kit.getAddressDecoder()]
+  ]);
+}
+function getCommitmentInsertedCodec() {
+  return kit.combineCodec(
+    getCommitmentInsertedEncoder(),
+    getCommitmentInsertedDecoder()
+  );
+}
+function getRootEntryEncoder() {
+  return kit.getStructEncoder([
+    ["root", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+    ["timestamp", kit.getI64Encoder()]
+  ]);
+}
+function getRootEntryDecoder() {
+  return kit.getStructDecoder([
+    ["root", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["timestamp", kit.getI64Decoder()]
+  ]);
+}
+function getRootEntryCodec() {
+  return kit.combineCodec(getRootEntryEncoder(), getRootEntryDecoder());
+}
+
+// src/generated/accounts/pool.ts
+var POOL_DISCRIMINATOR = new Uint8Array([
+  241,
+  154,
+  109,
+  4,
+  17,
+  177,
+  109,
+  188
+]);
+function getPoolDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(POOL_DISCRIMINATOR);
+}
+function getPoolEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["authority", kit.getAddressEncoder()],
+      ["mint", kit.getAddressEncoder()],
+      ["vault", kit.getAddressEncoder()],
+      ["feeCollector", kit.getAddressEncoder()],
+      ["rootHistory", kit.getArrayEncoder(getRootEntryEncoder(), { size: 30 })],
+      ["totalDeposited", kit.getU64Encoder()],
+      ["totalWithdrawn", kit.getU64Encoder()],
+      ["nextLeafIndex", kit.getU32Encoder()],
+      ["assetType", kit.getU8Encoder()],
+      ["rootHistoryIndex", kit.getU8Encoder()],
+      ["bump", kit.getU8Encoder()],
+      ["padding", kit.fixEncoderSize(kit.getBytesEncoder(), 1)]
+    ]),
+    (value) => ({ ...value, discriminator: POOL_DISCRIMINATOR })
+  );
+}
+function getPoolDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["authority", kit.getAddressDecoder()],
+    ["mint", kit.getAddressDecoder()],
+    ["vault", kit.getAddressDecoder()],
+    ["feeCollector", kit.getAddressDecoder()],
+    ["rootHistory", kit.getArrayDecoder(getRootEntryDecoder(), { size: 30 })],
+    ["totalDeposited", kit.getU64Decoder()],
+    ["totalWithdrawn", kit.getU64Decoder()],
+    ["nextLeafIndex", kit.getU32Decoder()],
+    ["assetType", kit.getU8Decoder()],
+    ["rootHistoryIndex", kit.getU8Decoder()],
+    ["bump", kit.getU8Decoder()],
+    ["padding", kit.fixDecoderSize(kit.getBytesDecoder(), 1)]
+  ]);
+}
+function getPoolCodec() {
+  return kit.combineCodec(getPoolEncoder(), getPoolDecoder());
+}
+function decodePool(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getPoolDecoder()
+  );
+}
+async function fetchPool(rpc, address, config) {
+  const maybeAccount = await fetchMaybePool(rpc, address, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybePool(rpc, address, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address, config);
+  return decodePool(maybeAccount);
+}
+async function fetchAllPool(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybePool(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybePool(rpc, addresses, config) {
+  const maybeAccounts = await kit.fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodePool(maybeAccount));
+}
+function getPoolSize() {
+  return 1360;
+}
+var VAULT_DISCRIMINATOR = new Uint8Array([
+  211,
+  8,
+  232,
+  43,
+  2,
+  152,
+  117,
+  119
+]);
+function getVaultDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(VAULT_DISCRIMINATOR);
+}
+function getVaultEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)]]),
+    (value) => ({ ...value, discriminator: VAULT_DISCRIMINATOR })
+  );
+}
+function getVaultDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)]
+  ]);
+}
+function getVaultCodec() {
+  return kit.combineCodec(getVaultEncoder(), getVaultDecoder());
+}
+function decodeVault(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getVaultDecoder()
+  );
+}
+async function fetchVault(rpc, address, config) {
+  const maybeAccount = await fetchMaybeVault(rpc, address, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeVault(rpc, address, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address, config);
+  return decodeVault(maybeAccount);
+}
+async function fetchAllVault(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeVault(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeVault(rpc, addresses, config) {
+  const maybeAccounts = await kit.fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeVault(maybeAccount));
+}
+function getVaultSize() {
+  return 8;
+}
+var MIXOOR_PROGRAM_ADDRESS = "mixmC791jTymqvJR2Zgvd8NAvXpXw99GdCW5uQcMBj8";
+var MixoorAccount = /* @__PURE__ */ ((MixoorAccount2) => {
+  MixoorAccount2[MixoorAccount2["NullifierAccount"] = 0] = "NullifierAccount";
+  MixoorAccount2[MixoorAccount2["Pool"] = 1] = "Pool";
+  MixoorAccount2[MixoorAccount2["Vault"] = 2] = "Vault";
+  return MixoorAccount2;
+})(MixoorAccount || {});
+function identifyMixoorAccount(account) {
+  const data = "data" in account ? account.data : account;
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([250, 31, 238, 177, 213, 98, 48, 172])
+    ),
+    0
+  )) {
+    return 0 /* NullifierAccount */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([241, 154, 109, 4, 17, 177, 109, 188])
+    ),
+    0
+  )) {
+    return 1 /* Pool */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([211, 8, 232, 43, 2, 152, 117, 119])
+    ),
+    0
+  )) {
+    return 2 /* Vault */;
+  }
+  throw new Error(
+    "The provided account could not be identified as a mixoor account."
+  );
+}
+var MixoorInstruction = /* @__PURE__ */ ((MixoorInstruction2) => {
+  MixoorInstruction2[MixoorInstruction2["Deposit"] = 0] = "Deposit";
+  MixoorInstruction2[MixoorInstruction2["InitializePool"] = 1] = "InitializePool";
+  MixoorInstruction2[MixoorInstruction2["Transfer"] = 2] = "Transfer";
+  return MixoorInstruction2;
+})(MixoorInstruction || {});
+function identifyMixoorInstruction(instruction) {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([242, 35, 198, 137, 82, 225, 242, 182])
+    ),
+    0
+  )) {
+    return 0 /* Deposit */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([95, 180, 10, 172, 84, 174, 232, 40])
+    ),
+    0
+  )) {
+    return 1 /* InitializePool */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([163, 52, 200, 231, 140, 3, 69, 186])
+    ),
+    0
+  )) {
+    return 2 /* Transfer */;
+  }
+  throw new Error(
+    "The provided instruction could not be identified as a mixoor instruction."
+  );
+}
+
+// src/generated/errors/mixoor.ts
+var MIXOOR_ERROR__INVALID_PROOF = 6e3;
+var MIXOOR_ERROR__UNKNOWN_ROOT = 6001;
+var MIXOOR_ERROR__INVALID_AMOUNT = 6002;
+var MIXOOR_ERROR__INSUFFICIENT_FUNDS = 6003;
+var MIXOOR_ERROR__MISSING_TOKEN_ACCOUNT = 6004;
+var MIXOOR_ERROR__OVERFLOW = 6005;
+var MIXOOR_ERROR__INVALID_PUBLIC_INPUTS = 6006;
+var MIXOOR_ERROR__INVALID_ASSET_TYPE = 6007;
+var MIXOOR_ERROR__INVALID_MERKLE_TREE_ADDRESS = 6008;
+var MIXOOR_ERROR__INVALID_MERKLE_TREE = 6009;
+var MIXOOR_ERROR__POSEIDON_HASH_ERROR = 6010;
+var MIXOOR_ERROR__MERKLE_TREE_FULL = 6011;
+var MIXOOR_ERROR__INVALID_MERKLE_PROOF = 6012;
+var mixoorErrorMessages;
+if (process.env.NODE_ENV !== "production") {
+  mixoorErrorMessages = {
+    [MIXOOR_ERROR__INSUFFICIENT_FUNDS]: `Insufficient funds`,
+    [MIXOOR_ERROR__INVALID_AMOUNT]: `Invalid amount`,
+    [MIXOOR_ERROR__INVALID_ASSET_TYPE]: `Invalid asset type deserialized`,
+    [MIXOOR_ERROR__INVALID_MERKLE_PROOF]: `Invalid merkle proof`,
+    [MIXOOR_ERROR__INVALID_MERKLE_TREE]: `Invalid merkle tree structure or out of bounds access`,
+    [MIXOOR_ERROR__INVALID_MERKLE_TREE_ADDRESS]: `Invalid merkle tree address`,
+    [MIXOOR_ERROR__INVALID_PROOF]: `Invalid proof`,
+    [MIXOOR_ERROR__INVALID_PUBLIC_INPUTS]: `Invalid number of public inputs`,
+    [MIXOOR_ERROR__MERKLE_TREE_FULL]: `Merkle tree is full`,
+    [MIXOOR_ERROR__MISSING_TOKEN_ACCOUNT]: `Missing token account`,
+    [MIXOOR_ERROR__OVERFLOW]: `Overflow`,
+    [MIXOOR_ERROR__POSEIDON_HASH_ERROR]: `Poseidon hash error`,
+    [MIXOOR_ERROR__UNKNOWN_ROOT]: `Unknown merkle root`
+  };
+}
+function getMixoorErrorMessage(code) {
+  if (process.env.NODE_ENV !== "production") {
+    return mixoorErrorMessages[code];
+  }
+  return "Error message not available in production bundles.";
+}
+function isMixoorError(error, transactionMessage, code) {
+  return kit.isProgramError(
+    error,
+    transactionMessage,
+    MIXOOR_PROGRAM_ADDRESS,
+    code
+  );
+}
+function expectSome(value) {
+  if (value === null || value === void 0) {
+    throw new Error("Expected a value but received null or undefined.");
+  }
+  return value;
+}
+function expectAddress(value) {
+  if (!value) {
+    throw new Error("Expected a Address.");
+  }
+  if (typeof value === "object" && "address" in value) {
+    return value.address;
+  }
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+}
+function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
+  return (account) => {
+    if (!account.value) {
+      return Object.freeze({
+        address: programAddress,
+        role: kit.AccountRole.READONLY
+      });
+    }
+    const writableRole = account.isWritable ? kit.AccountRole.WRITABLE : kit.AccountRole.READONLY;
+    return Object.freeze({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? kit.upgradeRoleToSigner(writableRole) : writableRole,
+      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
+    });
+  };
+}
+function isTransactionSigner(value) {
+  return !!value && typeof value === "object" && "address" in value && kit.isTransactionSigner(value);
+}
+
+// src/generated/instructions/deposit.ts
+var DEPOSIT_DISCRIMINATOR = new Uint8Array([
+  242,
+  35,
+  198,
+  137,
+  82,
+  225,
+  242,
+  182
+]);
+function getDepositDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(DEPOSIT_DISCRIMINATOR);
+}
+function getDepositInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["amount", kit.getU64Encoder()],
+      ["commitment", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["newRoot", kit.fixEncoderSize(kit.getBytesEncoder(), 32)]
+    ]),
+    (value) => ({ ...value, discriminator: DEPOSIT_DISCRIMINATOR })
+  );
+}
+function getDepositInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["amount", kit.getU64Decoder()],
+    ["commitment", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["newRoot", kit.fixDecoderSize(kit.getBytesDecoder(), 32)]
+  ]);
+}
+function getDepositInstructionDataCodec() {
+  return kit.combineCodec(
+    getDepositInstructionDataEncoder(),
+    getDepositInstructionDataDecoder()
+  );
+}
+async function getDepositInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? MIXOOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    depositor: { value: input.depositor ?? null, isWritable: true },
+    pool: { value: input.pool ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: true },
+    vault: { value: input.vault ?? null, isWritable: true },
+    depositorTokenAccount: {
+      value: input.depositorTokenAccount ?? null,
+      isWritable: true
+    },
+    vaultTokenAccount: {
+      value: input.vaultTokenAccount ?? null,
+      isWritable: true
+    },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.vault.value) {
+    accounts.vault.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        kit.getAddressEncoder().encode(expectAddress(accounts.pool.value))
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.depositor),
+      getAccountMeta(accounts.pool),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.depositorTokenAccount),
+      getAccountMeta(accounts.vaultTokenAccount),
+      getAccountMeta(accounts.systemProgram),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram)
+    ],
+    data: getDepositInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getDepositInstruction(input, config) {
+  const programAddress = config?.programAddress ?? MIXOOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    depositor: { value: input.depositor ?? null, isWritable: true },
+    pool: { value: input.pool ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: true },
+    vault: { value: input.vault ?? null, isWritable: true },
+    depositorTokenAccount: {
+      value: input.depositorTokenAccount ?? null,
+      isWritable: true
+    },
+    vaultTokenAccount: {
+      value: input.vaultTokenAccount ?? null,
+      isWritable: true
+    },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.depositor),
+      getAccountMeta(accounts.pool),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.depositorTokenAccount),
+      getAccountMeta(accounts.vaultTokenAccount),
+      getAccountMeta(accounts.systemProgram),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram)
+    ],
+    data: getDepositInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseDepositInstruction(instruction) {
+  if (instruction.accounts.length < 9) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  const getNextOptionalAccount = () => {
+    const accountMeta = getNextAccount();
+    return accountMeta.address === MIXOOR_PROGRAM_ADDRESS ? void 0 : accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      depositor: getNextAccount(),
+      pool: getNextAccount(),
+      mint: getNextAccount(),
+      vault: getNextAccount(),
+      depositorTokenAccount: getNextOptionalAccount(),
+      vaultTokenAccount: getNextOptionalAccount(),
+      systemProgram: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      associatedTokenProgram: getNextAccount()
+    },
+    data: getDepositInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var INITIALIZE_POOL_DISCRIMINATOR = new Uint8Array([
+  95,
+  180,
+  10,
+  172,
+  84,
+  174,
+  232,
+  40
+]);
+function getInitializePoolDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    INITIALIZE_POOL_DISCRIMINATOR
+  );
+}
+function getInitializePoolInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["assetType", getAssetTypeEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_POOL_DISCRIMINATOR })
+  );
+}
+function getInitializePoolInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["assetType", getAssetTypeDecoder()]
+  ]);
+}
+function getInitializePoolInstructionDataCodec() {
+  return kit.combineCodec(
+    getInitializePoolInstructionDataEncoder(),
+    getInitializePoolInstructionDataDecoder()
+  );
+}
+async function getInitializePoolInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? MIXOOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: true },
+    pool: { value: input.pool ?? null, isWritable: true },
+    vault: { value: input.vault ?? null, isWritable: true },
+    vaultAta: { value: input.vaultAta ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: true },
+    feeCollector: { value: input.feeCollector ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.pool.value) {
+    accounts.pool.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([112, 111, 111, 108])),
+        kit.getAddressEncoder().encode(expectAddress(accounts.mint.value))
+      ]
+    });
+  }
+  if (!accounts.vault.value) {
+    accounts.vault.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        kit.getAddressEncoder().encode(expectAddress(accounts.pool.value))
+      ]
+    });
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.vaultAta.value) {
+    accounts.vaultAta.value = await kit.getProgramDerivedAddress({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        kit.getAddressEncoder().encode(expectAddress(accounts.vault.value)),
+        kit.getAddressEncoder().encode(expectAddress(accounts.tokenProgram.value)),
+        kit.getAddressEncoder().encode(expectAddress(accounts.mint.value))
+      ]
+    });
+  }
+  if (!accounts.feeCollector.value) {
+    accounts.feeCollector.value = "5KgfWjGePnbFgDAuCqxB5oymuFxQskvCtrw6eYfDa7fj";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.pool),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.vaultAta),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.feeCollector),
+      getAccountMeta(accounts.systemProgram),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram)
+    ],
+    data: getInitializePoolInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getInitializePoolInstruction(input, config) {
+  const programAddress = config?.programAddress ?? MIXOOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: true },
+    pool: { value: input.pool ?? null, isWritable: true },
+    vault: { value: input.vault ?? null, isWritable: true },
+    vaultAta: { value: input.vaultAta ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: true },
+    feeCollector: { value: input.feeCollector ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.feeCollector.value) {
+    accounts.feeCollector.value = "5KgfWjGePnbFgDAuCqxB5oymuFxQskvCtrw6eYfDa7fj";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.pool),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.vaultAta),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.feeCollector),
+      getAccountMeta(accounts.systemProgram),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram)
+    ],
+    data: getInitializePoolInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseInitializePoolInstruction(instruction) {
+  if (instruction.accounts.length < 9) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      authority: getNextAccount(),
+      pool: getNextAccount(),
+      vault: getNextAccount(),
+      vaultAta: getNextAccount(),
+      mint: getNextAccount(),
+      feeCollector: getNextAccount(),
+      systemProgram: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      associatedTokenProgram: getNextAccount()
+    },
+    data: getInitializePoolInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var TRANSFER_DISCRIMINATOR = new Uint8Array([
+  163,
+  52,
+  200,
+  231,
+  140,
+  3,
+  69,
+  186
+]);
+function getTransferDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(TRANSFER_DISCRIMINATOR);
+}
+function getTransferInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["proofA", kit.fixEncoderSize(kit.getBytesEncoder(), 64)],
+      ["proofB", kit.fixEncoderSize(kit.getBytesEncoder(), 128)],
+      ["proofC", kit.fixEncoderSize(kit.getBytesEncoder(), 64)],
+      [
+        "publicInputs",
+        kit.getArrayEncoder(kit.fixEncoderSize(kit.getBytesEncoder(), 32), { size: 7 })
+      ],
+      ["nullifierHash", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["amount", kit.getU64Encoder()],
+      ["fee", kit.getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: TRANSFER_DISCRIMINATOR })
+  );
+}
+function getTransferInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["proofA", kit.fixDecoderSize(kit.getBytesDecoder(), 64)],
+    ["proofB", kit.fixDecoderSize(kit.getBytesDecoder(), 128)],
+    ["proofC", kit.fixDecoderSize(kit.getBytesDecoder(), 64)],
+    [
+      "publicInputs",
+      kit.getArrayDecoder(kit.fixDecoderSize(kit.getBytesDecoder(), 32), { size: 7 })
+    ],
+    ["nullifierHash", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["amount", kit.getU64Decoder()],
+    ["fee", kit.getU64Decoder()]
+  ]);
+}
+function getTransferInstructionDataCodec() {
+  return kit.combineCodec(
+    getTransferInstructionDataEncoder(),
+    getTransferInstructionDataDecoder()
+  );
+}
+async function getTransferInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? MIXOOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    relayer: { value: input.relayer ?? null, isWritable: true },
+    pool: { value: input.pool ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: true },
+    vault: { value: input.vault ?? null, isWritable: true },
+    nullifier: { value: input.nullifier ?? null, isWritable: true },
+    recipient: { value: input.recipient ?? null, isWritable: true },
+    vaultTokenAccount: {
+      value: input.vaultTokenAccount ?? null,
+      isWritable: true
+    },
+    recipientTokenAccount: {
+      value: input.recipientTokenAccount ?? null,
+      isWritable: true
+    },
+    feeCollector: { value: input.feeCollector ?? null, isWritable: true },
+    feeCollectorTokenAccount: {
+      value: input.feeCollectorTokenAccount ?? null,
+      isWritable: true
+    },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.vault.value) {
+    accounts.vault.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        kit.getAddressEncoder().encode(expectAddress(accounts.pool.value))
+      ]
+    });
+  }
+  if (!accounts.nullifier.value) {
+    accounts.nullifier.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([110, 117, 108, 108, 105, 102, 105, 101, 114])
+        ),
+        kit.fixEncoderSize(kit.getBytesEncoder(), 32).encode(
+          expectSome(args.nullifierHash)
+        )
+      ]
+    });
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.recipientTokenAccount.value) {
+    accounts.recipientTokenAccount.value = await kit.getProgramDerivedAddress({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        kit.getAddressEncoder().encode(expectAddress(accounts.recipient.value)),
+        kit.getAddressEncoder().encode(expectAddress(accounts.tokenProgram.value)),
+        kit.getAddressEncoder().encode(expectAddress(accounts.mint.value))
+      ]
+    });
+  }
+  if (!accounts.feeCollector.value) {
+    accounts.feeCollector.value = "5KgfWjGePnbFgDAuCqxB5oymuFxQskvCtrw6eYfDa7fj";
+  }
+  if (!accounts.feeCollectorTokenAccount.value) {
+    accounts.feeCollectorTokenAccount.value = await kit.getProgramDerivedAddress({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        kit.getAddressEncoder().encode(expectAddress(accounts.feeCollector.value)),
+        kit.getAddressEncoder().encode(expectAddress(accounts.tokenProgram.value)),
+        kit.getAddressEncoder().encode(expectAddress(accounts.mint.value))
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.relayer),
+      getAccountMeta(accounts.pool),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.nullifier),
+      getAccountMeta(accounts.recipient),
+      getAccountMeta(accounts.vaultTokenAccount),
+      getAccountMeta(accounts.recipientTokenAccount),
+      getAccountMeta(accounts.feeCollector),
+      getAccountMeta(accounts.feeCollectorTokenAccount),
+      getAccountMeta(accounts.systemProgram),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram)
+    ],
+    data: getTransferInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getTransferInstruction(input, config) {
+  const programAddress = config?.programAddress ?? MIXOOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    relayer: { value: input.relayer ?? null, isWritable: true },
+    pool: { value: input.pool ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: true },
+    vault: { value: input.vault ?? null, isWritable: true },
+    nullifier: { value: input.nullifier ?? null, isWritable: true },
+    recipient: { value: input.recipient ?? null, isWritable: true },
+    vaultTokenAccount: {
+      value: input.vaultTokenAccount ?? null,
+      isWritable: true
+    },
+    recipientTokenAccount: {
+      value: input.recipientTokenAccount ?? null,
+      isWritable: true
+    },
+    feeCollector: { value: input.feeCollector ?? null, isWritable: true },
+    feeCollectorTokenAccount: {
+      value: input.feeCollectorTokenAccount ?? null,
+      isWritable: true
+    },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.feeCollector.value) {
+    accounts.feeCollector.value = "5KgfWjGePnbFgDAuCqxB5oymuFxQskvCtrw6eYfDa7fj";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.relayer),
+      getAccountMeta(accounts.pool),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.nullifier),
+      getAccountMeta(accounts.recipient),
+      getAccountMeta(accounts.vaultTokenAccount),
+      getAccountMeta(accounts.recipientTokenAccount),
+      getAccountMeta(accounts.feeCollector),
+      getAccountMeta(accounts.feeCollectorTokenAccount),
+      getAccountMeta(accounts.systemProgram),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram)
+    ],
+    data: getTransferInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseTransferInstruction(instruction) {
+  if (instruction.accounts.length < 13) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  const getNextOptionalAccount = () => {
+    const accountMeta = getNextAccount();
+    return accountMeta.address === MIXOOR_PROGRAM_ADDRESS ? void 0 : accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      relayer: getNextAccount(),
+      pool: getNextAccount(),
+      mint: getNextAccount(),
+      vault: getNextAccount(),
+      nullifier: getNextAccount(),
+      recipient: getNextAccount(),
+      vaultTokenAccount: getNextOptionalAccount(),
+      recipientTokenAccount: getNextOptionalAccount(),
+      feeCollector: getNextAccount(),
+      feeCollectorTokenAccount: getNextOptionalAccount(),
+      systemProgram: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      associatedTokenProgram: getNextAccount()
+    },
+    data: getTransferInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var poseidon;
+async function initPoseidon() {
+  if (!poseidon) {
+    poseidon = await circomlibjs.buildPoseidon();
+  }
+  return poseidon;
+}
+var SNARK_FIELD_SIZE = BigInt(
+  "21888242871839275222246405745257275088548364400416034343698204186575808495617"
+);
+function toFieldElement(bytes) {
+  let bigInt = 0n;
+  for (let i = 0; i < bytes.length; i++) {
+    bigInt = bigInt << 8n | BigInt(bytes[i]);
+  }
+  return (bigInt % SNARK_FIELD_SIZE).toString();
+}
+async function poseidonHash(inputs) {
+  await initPoseidon();
+  const hash = poseidon(inputs.map((x) => BigInt(toFieldElement(x))));
+  const hashBigInt = poseidon.F.toObject(hash);
+  const bytes = new Uint8Array(32);
+  let temp = BigInt(hashBigInt);
+  for (let i = 31; i >= 0; i--) {
+    bytes[i] = Number(temp & BigInt(255));
+    temp = temp >> BigInt(8);
+  }
+  return bytes;
+}
+async function generateCommitment(secret, nullifier, amount, poolId) {
+  await initPoseidon();
+  const poolIdBytes = kit.getAddressEncoder().encode(poolId);
+  const secretField = BigInt(toFieldElement(secret));
+  const nullifierField = BigInt(toFieldElement(nullifier));
+  const amountField = BigInt(amount);
+  const poolIdField = BigInt(toFieldElement(Uint8Array.from(poolIdBytes)));
+  const hash = poseidon([
+    secretField,
+    nullifierField,
+    amountField,
+    poolIdField
+  ]);
+  const hashBigInt = poseidon.F.toObject(hash);
+  const bytes = new Uint8Array(32);
+  let temp = BigInt(hashBigInt);
+  for (let i = 31; i >= 0; i--) {
+    bytes[i] = Number(temp & BigInt(255));
+    temp = temp >> BigInt(8);
+  }
+  return bytes;
+}
+async function generateNullifier(nullifier, poolId) {
+  const poolIdBytes = kit.getAddressEncoder().encode(poolId);
+  return await poseidonHash([nullifier, Uint8Array.from(poolIdBytes)]);
+}
+function fieldElementToBytes(element) {
+  const bigInt = BigInt(element);
+  const bytes = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    bytes[31 - i] = Number(bigInt >> BigInt(i * 8) & BigInt(255));
+  }
+  return bytes;
+}
+function publicSignalToBytes(signal) {
+  const bigInt = BigInt(signal);
+  const bytes = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    bytes[31 - i] = Number(bigInt >> BigInt(i * 8) & BigInt(255));
+  }
+  return bytes;
+}
+function g1PointToBytes(point) {
+  const x = fieldElementToBytes(point[0]);
+  const y = fieldElementToBytes(point[1]);
+  const result = new Uint8Array(64);
+  result.set(x, 0);
+  result.set(y, 32);
+  return result;
+}
+function g2PointToBytes(point) {
+  const x1 = fieldElementToBytes(point[0][1]);
+  const x0 = fieldElementToBytes(point[0][0]);
+  const y1 = fieldElementToBytes(point[1][1]);
+  const y0 = fieldElementToBytes(point[1][0]);
+  const result = new Uint8Array(128);
+  result.set(x1, 0);
+  result.set(x0, 32);
+  result.set(y1, 64);
+  result.set(y0, 96);
+  return result;
+}
+async function generateProof(input) {
+  await initPoseidon();
+  const poolIdBytes = kit.getAddressEncoder().encode(input.poolAddress);
+  const circuitInputs = {
+    root: toFieldElement(input.root),
+    nullifierHash: toFieldElement(
+      await generateNullifier(input.nullifier, input.poolAddress)
+    ),
+    recipient: toFieldElement(input.recipient),
+    relayer: toFieldElement(input.relayer),
+    fee: input.fee,
+    refund: input.refund,
+    poolId: toFieldElement(Uint8Array.from(poolIdBytes)),
+    secret: toFieldElement(input.secret),
+    nullifier: toFieldElement(input.nullifier),
+    pathElements: input.pathElements.map((x) => toFieldElement(x)),
+    pathIndices: input.pathIndices,
+    amount: BigInt(input.amount).toString()
+  };
+  const wasmPath = path__namespace.join(
+    __dirname,
+    "../../../../circuits/build/transaction_js/transaction.wasm"
+  );
+  const zkeyPath = path__namespace.join(
+    __dirname,
+    "../../../../circuits/transaction_0001.zkey"
+  );
+  const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+    circuitInputs,
+    wasmPath,
+    zkeyPath
+  );
+  const vKeyPath = path__namespace.join(
+    __dirname,
+    "../../../../circuits/verification_key.json"
+  );
+  const isValid = await snarkjs.groth16.verify(
+    JSON.parse(fs__namespace.readFileSync(vKeyPath, "utf8")),
+    publicSignals,
+    proof
+  );
+  console.log("Local proof verification:", isValid ? "VALID \u2713" : "INVALID \u2717");
+  if (!isValid) {
+    throw new Error("Generated proof is invalid - check circuit inputs");
+  }
+  const publicInputs = publicSignals.map(
+    (signal) => publicSignalToBytes(signal)
+  );
+  console.log(
+    "DEBUG: Generated Public Inputs (Keys: root, nullifierHash, recipient, relayer, fee, refund, poolId):"
+  );
+  publicInputs.forEach((input2, i) => {
+    const hexBE = Buffer.from(input2).toString("hex");
+    const hexLE = Buffer.from(input2.slice().reverse()).toString("hex");
+    console.log(`Input ${i}: BE=${hexBE} | LE=${hexLE}`);
+  });
+  const proof_a = g1PointToBytes([proof.pi_a[0], proof.pi_a[1]]);
+  const proof_b = g2PointToBytes([
+    [proof.pi_b[0][0], proof.pi_b[0][1]],
+    [proof.pi_b[1][0], proof.pi_b[1][1]]
+  ]);
+  const proof_c = g1PointToBytes([proof.pi_c[0], proof.pi_c[1]]);
+  return {
+    proofData: {
+      proofA: proof_a,
+      proofB: proof_b,
+      proofC: proof_c
+    },
+    publicInputs
+  };
+}
+function randomBytes(size) {
+  return new Uint8Array(crypto.randomBytes(size));
+}
+function toHex(bytes) {
+  return Buffer.from(bytes).toString("hex");
+}
+function fromHex(hex) {
+  return new Uint8Array(Buffer.from(hex, "hex"));
+}
+var MerkleTree = class {
+  levels;
+  _leaves;
+  _zeros;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  poseidon;
+  initialized = false;
+  constructor(levels) {
+    this.levels = levels;
+    this._leaves = [];
+    this._zeros = [];
+  }
+  async initialize() {
+    if (this.initialized) return;
+    this.poseidon = await circomlibjs.buildPoseidon();
+    this._zeros[0] = new Uint8Array(32);
+    this.initialized = true;
+    for (let i = 1; i <= this.levels; i++) {
+      this._zeros[i] = this.hash(this._zeros[i - 1], this._zeros[i - 1]);
+    }
+  }
+  hash(left, right) {
+    if (!this.poseidon) {
+      throw new Error("MerkleTree not initialized. Call initialize() first");
+    }
+    const SNARK_FIELD_SIZE2 = BigInt(
+      "21888242871839275222246405745257275088548364400416034343698204186575808495617"
+    );
+    const leftBigInt = this.uint8ArrayToBigInt(left) % SNARK_FIELD_SIZE2;
+    const rightBigInt = this.uint8ArrayToBigInt(right) % SNARK_FIELD_SIZE2;
+    const result = this.poseidon([leftBigInt, rightBigInt]);
+    const resultBytes = this.poseidon.F.toObject(result);
+    return this.bigIntToUint8Array(BigInt(resultBytes));
+  }
+  uint8ArrayToBigInt(arr) {
+    let hex = "0x";
+    for (let i = 0; i < arr.length; i++) {
+      hex += arr[i].toString(16).padStart(2, "0");
+    }
+    return BigInt(hex);
+  }
+  bigIntToUint8Array(value) {
+    const bytes = new Uint8Array(32);
+    let temp = value;
+    for (let i = 31; i >= 0; i--) {
+      bytes[i] = Number(temp & BigInt(255));
+      temp = temp >> BigInt(8);
+    }
+    return bytes;
+  }
+  insert(leaf) {
+    if (!this.initialized) {
+      throw new Error("MerkleTree not initialized. Call initialize() first");
+    }
+    this._leaves.push(leaf);
+  }
+  root() {
+    if (!this.initialized) {
+      throw new Error("MerkleTree not initialized. Call initialize() first");
+    }
+    if (this._leaves.length === 0) {
+      return this._zeros[this.levels];
+    }
+    let currentLevel = [...this._leaves];
+    for (let level = 0; level < this.levels; level++) {
+      const nextLevel = [];
+      for (let i = 0; i < currentLevel.length; i += 2) {
+        const left = currentLevel[i];
+        const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : this._zeros[level];
+        nextLevel.push(this.hash(left, right));
+      }
+      currentLevel = nextLevel;
+    }
+    return currentLevel[0];
+  }
+  getProof(index) {
+    if (!this.initialized) {
+      throw new Error("MerkleTree not initialized. Call initialize() first");
+    }
+    if (index >= this._leaves.length) {
+      throw new Error("Leaf index out of bounds");
+    }
+    const pathElements = [];
+    const pathIndices = [];
+    let currentLevel = [...this._leaves];
+    let currentIndex = index;
+    for (let level = 0; level < this.levels; level++) {
+      const isLeft = currentIndex % 2 === 0;
+      const siblingIndex = isLeft ? currentIndex + 1 : currentIndex - 1;
+      const sibling = siblingIndex < currentLevel.length ? currentLevel[siblingIndex] : this._zeros[level];
+      pathElements.push(sibling);
+      pathIndices.push(isLeft ? 0 : 1);
+      const nextLevel = [];
+      for (let i = 0; i < currentLevel.length; i += 2) {
+        const left = currentLevel[i];
+        const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : this._zeros[level];
+        nextLevel.push(this.hash(left, right));
+      }
+      currentLevel = nextLevel;
+      currentIndex = Math.floor(currentIndex / 2);
+    }
+    return { pathElements, pathIndices };
+  }
+};
+function extractMerkleRootFromAccount(_client, _poolAddress) {
+  throw new Error(
+    "Merkle tree is off-chain now. Build it locally from CommitmentInserted events. For tests, use your MerkleTree instance: merkleTree.root()"
+  );
+}
+async function findPoolAddress(seeds, config = {}) {
+  const { programAddress = MIXOOR_PROGRAM_ADDRESS } = config;
+  return await kit.getProgramDerivedAddress({
+    programAddress,
+    seeds: ["pool", kit.getAddressEncoder().encode(seeds.mint)]
+  });
+}
+async function findMerkleTreeAddress(seeds, config = {}) {
+  const { programAddress = MIXOOR_PROGRAM_ADDRESS } = config;
+  return await kit.getProgramDerivedAddress({
+    programAddress,
+    seeds: ["merkle", kit.getAddressEncoder().encode(seeds.pool)]
+  });
+}
+async function findVaultAddress(seeds, config = {}) {
+  const { programAddress = MIXOOR_PROGRAM_ADDRESS } = config;
+  return await kit.getProgramDerivedAddress({
+    programAddress,
+    seeds: ["vault", kit.getAddressEncoder().encode(seeds.pool)]
+  });
+}
+
+exports.AssetType = AssetType;
+exports.DEPOSIT_DISCRIMINATOR = DEPOSIT_DISCRIMINATOR;
+exports.INITIALIZE_POOL_DISCRIMINATOR = INITIALIZE_POOL_DISCRIMINATOR;
+exports.MIXOOR_ERROR__INSUFFICIENT_FUNDS = MIXOOR_ERROR__INSUFFICIENT_FUNDS;
+exports.MIXOOR_ERROR__INVALID_AMOUNT = MIXOOR_ERROR__INVALID_AMOUNT;
+exports.MIXOOR_ERROR__INVALID_ASSET_TYPE = MIXOOR_ERROR__INVALID_ASSET_TYPE;
+exports.MIXOOR_ERROR__INVALID_MERKLE_PROOF = MIXOOR_ERROR__INVALID_MERKLE_PROOF;
+exports.MIXOOR_ERROR__INVALID_MERKLE_TREE = MIXOOR_ERROR__INVALID_MERKLE_TREE;
+exports.MIXOOR_ERROR__INVALID_MERKLE_TREE_ADDRESS = MIXOOR_ERROR__INVALID_MERKLE_TREE_ADDRESS;
+exports.MIXOOR_ERROR__INVALID_PROOF = MIXOOR_ERROR__INVALID_PROOF;
+exports.MIXOOR_ERROR__INVALID_PUBLIC_INPUTS = MIXOOR_ERROR__INVALID_PUBLIC_INPUTS;
+exports.MIXOOR_ERROR__MERKLE_TREE_FULL = MIXOOR_ERROR__MERKLE_TREE_FULL;
+exports.MIXOOR_ERROR__MISSING_TOKEN_ACCOUNT = MIXOOR_ERROR__MISSING_TOKEN_ACCOUNT;
+exports.MIXOOR_ERROR__OVERFLOW = MIXOOR_ERROR__OVERFLOW;
+exports.MIXOOR_ERROR__POSEIDON_HASH_ERROR = MIXOOR_ERROR__POSEIDON_HASH_ERROR;
+exports.MIXOOR_ERROR__UNKNOWN_ROOT = MIXOOR_ERROR__UNKNOWN_ROOT;
+exports.MIXOOR_PROGRAM_ADDRESS = MIXOOR_PROGRAM_ADDRESS;
+exports.MerkleTree = MerkleTree;
+exports.MixoorAccount = MixoorAccount;
+exports.MixoorInstruction = MixoorInstruction;
+exports.NULLIFIER_ACCOUNT_DISCRIMINATOR = NULLIFIER_ACCOUNT_DISCRIMINATOR;
+exports.POOL_DISCRIMINATOR = POOL_DISCRIMINATOR;
+exports.TRANSFER_DISCRIMINATOR = TRANSFER_DISCRIMINATOR;
+exports.VAULT_DISCRIMINATOR = VAULT_DISCRIMINATOR;
+exports.decodeNullifierAccount = decodeNullifierAccount;
+exports.decodePool = decodePool;
+exports.decodeVault = decodeVault;
+exports.extractMerkleRootFromAccount = extractMerkleRootFromAccount;
+exports.fetchAllMaybeNullifierAccount = fetchAllMaybeNullifierAccount;
+exports.fetchAllMaybePool = fetchAllMaybePool;
+exports.fetchAllMaybeVault = fetchAllMaybeVault;
+exports.fetchAllNullifierAccount = fetchAllNullifierAccount;
+exports.fetchAllPool = fetchAllPool;
+exports.fetchAllVault = fetchAllVault;
+exports.fetchMaybeNullifierAccount = fetchMaybeNullifierAccount;
+exports.fetchMaybePool = fetchMaybePool;
+exports.fetchMaybeVault = fetchMaybeVault;
+exports.fetchNullifierAccount = fetchNullifierAccount;
+exports.fetchPool = fetchPool;
+exports.fetchVault = fetchVault;
+exports.findMerkleTreeAddress = findMerkleTreeAddress;
+exports.findPoolAddress = findPoolAddress;
+exports.findVaultAddress = findVaultAddress;
+exports.fromHex = fromHex;
+exports.generateCommitment = generateCommitment;
+exports.generateNullifier = generateNullifier;
+exports.generateProof = generateProof;
+exports.getAssetTypeCodec = getAssetTypeCodec;
+exports.getAssetTypeDecoder = getAssetTypeDecoder;
+exports.getAssetTypeEncoder = getAssetTypeEncoder;
+exports.getCommitmentInsertedCodec = getCommitmentInsertedCodec;
+exports.getCommitmentInsertedDecoder = getCommitmentInsertedDecoder;
+exports.getCommitmentInsertedEncoder = getCommitmentInsertedEncoder;
+exports.getDepositDiscriminatorBytes = getDepositDiscriminatorBytes;
+exports.getDepositInstruction = getDepositInstruction;
+exports.getDepositInstructionAsync = getDepositInstructionAsync;
+exports.getDepositInstructionDataCodec = getDepositInstructionDataCodec;
+exports.getDepositInstructionDataDecoder = getDepositInstructionDataDecoder;
+exports.getDepositInstructionDataEncoder = getDepositInstructionDataEncoder;
+exports.getInitializePoolDiscriminatorBytes = getInitializePoolDiscriminatorBytes;
+exports.getInitializePoolInstruction = getInitializePoolInstruction;
+exports.getInitializePoolInstructionAsync = getInitializePoolInstructionAsync;
+exports.getInitializePoolInstructionDataCodec = getInitializePoolInstructionDataCodec;
+exports.getInitializePoolInstructionDataDecoder = getInitializePoolInstructionDataDecoder;
+exports.getInitializePoolInstructionDataEncoder = getInitializePoolInstructionDataEncoder;
+exports.getMixoorErrorMessage = getMixoorErrorMessage;
+exports.getNullifierAccountCodec = getNullifierAccountCodec;
+exports.getNullifierAccountDecoder = getNullifierAccountDecoder;
+exports.getNullifierAccountDiscriminatorBytes = getNullifierAccountDiscriminatorBytes;
+exports.getNullifierAccountEncoder = getNullifierAccountEncoder;
+exports.getNullifierAccountSize = getNullifierAccountSize;
+exports.getPoolCodec = getPoolCodec;
+exports.getPoolDecoder = getPoolDecoder;
+exports.getPoolDiscriminatorBytes = getPoolDiscriminatorBytes;
+exports.getPoolEncoder = getPoolEncoder;
+exports.getPoolSize = getPoolSize;
+exports.getRootEntryCodec = getRootEntryCodec;
+exports.getRootEntryDecoder = getRootEntryDecoder;
+exports.getRootEntryEncoder = getRootEntryEncoder;
+exports.getTransferDiscriminatorBytes = getTransferDiscriminatorBytes;
+exports.getTransferInstruction = getTransferInstruction;
+exports.getTransferInstructionAsync = getTransferInstructionAsync;
+exports.getTransferInstructionDataCodec = getTransferInstructionDataCodec;
+exports.getTransferInstructionDataDecoder = getTransferInstructionDataDecoder;
+exports.getTransferInstructionDataEncoder = getTransferInstructionDataEncoder;
+exports.getVaultCodec = getVaultCodec;
+exports.getVaultDecoder = getVaultDecoder;
+exports.getVaultDiscriminatorBytes = getVaultDiscriminatorBytes;
+exports.getVaultEncoder = getVaultEncoder;
+exports.getVaultSize = getVaultSize;
+exports.identifyMixoorAccount = identifyMixoorAccount;
+exports.identifyMixoorInstruction = identifyMixoorInstruction;
+exports.isMixoorError = isMixoorError;
+exports.parseDepositInstruction = parseDepositInstruction;
+exports.parseInitializePoolInstruction = parseInitializePoolInstruction;
+exports.parseTransferInstruction = parseTransferInstruction;
+exports.poseidonHash = poseidonHash;
+exports.randomBytes = randomBytes;
+exports.toHex = toHex;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map