@umbra-privacy/sdk 1.0.0 → 2.0.1

package/dist/chunk-MKNCBUFA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/pda/umbra.ts","../src/common/pda/user.ts","../src/common/pda/arcium.ts","../src/common/pda/compliance.ts","../src/common/pda/global.ts","../src/common/pda/pool.ts","../src/common/pda/relayer.ts","../src/common/pda/fees.ts","../src/common/pda/zk.ts"],"names":["getAddressEncoder","getProgramDerivedAddress","sha256","getAccountOffsetEncoder"],"mappings":"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","file":"chunk-MKNCBUFA.js","sourcesContent":["/**\n * Umbra PDA (Program Derived Address) Generator Utilities\n *\n * This module provides functions for deriving Umbra protocol account addresses,\n * specifically for mixer tree accounts used in the privacy-preserving UTXO system.\n *\n * @remarks\n * ## Mixer Tree Overview\n *\n * The mixer tree is an Indexed Merkle Tree (IMT) that stores Poseidon H2 hash\n * commitments to UTXOs. Multiple mixer trees can exist, with each tree indexed\n * sequentially (0, 1, 2, ...). When a tree reaches capacity, a new tree is\n * created and becomes the active tree. Old trees remain readable for proof\n * generation and claiming.\n *\n * ## Nullifier Set Overview\n *\n * Each mixer tree has five associated nullifier set accounts (variants 0-4). These\n * accounts form an Indexed Merkle Tree of nullifiers and serve as the primary\n * double-spend prevention mechanism: before a UTXO can be claimed its\n * nullifier is checked against -- and then inserted into -- the nullifier set.\n *\n * ## UTXO Burner Accounts\n *\n * Confidential and public UTXO burner accounts act as temporary storage for\n * nullifiers during relayer-submitted claim transactions. They are scoped to\n * a `(relayer, receiver_address, offset)` triple and are created and closed\n * within the same transaction.\n *\n * ## Utility Functions\n *\n * `computeStructSeed` is re-exported from this module because every other PDA module\n * depends on it to compute seed constants.\n *\n * @see {@link findStealthPoolPda}\n * @see {@link findActiveStealthPoolPda}\n * @see {@link findNullifierSetPdas}\n * @see {@link findConfidentialNullifierBufferPda}\n * @see {@link findPublicNullifierBufferPda}\n * @see {@link computeStructSeed}\n *\n * @packageDocumentation\n * @since 2.0.0\n * @module utils/pda/umbra\n */\n\nimport { type Address, getAddressEncoder, getProgramDerivedAddress } from \"@solana/kit\";\nimport { getAccountOffsetEncoder } from \"@umbra-privacy/umbra-codama\";\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport type { U128 } from \"../../types\";\nimport { encodeU128ToU128LeBytes } from \"../converters/mathematics\";\n\n/**\n * Computes the SHA-256 hash of a struct/seed name string and returns the\n * result as a 32-byte `Uint8Array`.\n *\n * This mirrors the `sha256_seed!` macro and the `#[umbra_account]` macro used\n * in the Rust smart contract. Every PDA seed constant in the Umbra program is\n * derived as `SHA-256(struct_name_utf8)`.\n *\n * This function is also exported from the barrel (`index.ts`) for callers that\n * need to compute arbitrary struct seeds outside the SDK, for example when\n * verifying a PDA derivation manually or in tests.\n *\n * @param name - The struct or domain name to hash (UTF-8 string, e.g. `\"TokenPool\"`).\n * @returns A 32-byte `Uint8Array` containing the SHA-256 digest.\n *\n * @example\n * ```typescript\n * import { computeStructSeed } from \"@umbra-privacy/sdk\";\n *\n * const poolSeed = computeStructSeed(\"TokenPool\");\n * // poolSeed is SHA-256(\"TokenPool\") as a 32-byte Uint8Array\n * ```\n *\n * @public\n */\nexport function computeStructSeed(name: string): Uint8Array {\n  return sha256(new TextEncoder().encode(name));\n}\n\n/**\n * SHA-256 of the string `\"StealthPool\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `sha256_seed!(\"StealthPool\")` in the Rust smart contract. Used as\n * the first seed when deriving `StealthPool` PDAs.\n *\n * @internal\n */\nconst STEALTH_POOL_SEED = computeStructSeed(\"StealthPool\");\n\n/**\n * SHA-256 of the string `\"ConfidentialNullifierLinkerBuffer\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `sha256_seed!(\"ConfidentialNullifierLinkerBuffer\")` in the Rust smart contract.\n * Used as the first seed when deriving confidential UTXO burner PDAs.\n *\n * @internal\n */\nconst CONF_UTXO_BURNER_SEED = computeStructSeed(\"ConfidentialNullifierLinkerBuffer\");\n\n/**\n * SHA-256 of the string `\"PublicNullifierLinkerBuffer\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `sha256_seed!(\"PublicNullifierLinkerBuffer\")` in the Rust smart contract.\n * Used as the first seed when deriving public UTXO burner PDAs.\n *\n * @internal\n */\nconst PUB_UTXO_BURNER_SEED = computeStructSeed(\"PublicNullifierLinkerBuffer\");\n\n/**\n * SHA-256 of the string `\"Treap\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `sha256_seed!(\"Treap\")` in the Rust smart contract. Used as the\n * first seed when deriving nullifier set account PDAs.\n *\n * @internal\n */\nconst TREAP_SEED = computeStructSeed(\"Treap\");\n\n/**\n * Derives the Program Derived Address for a stealth pool (mixer tree) at the given index.\n * Seeds: [StealthPool::SEED, index_u128_le]\n *\n * The mixer tree is an Indexed Merkle Tree (IMT) that stores Poseidon H2 hash\n * commitments for UTXOs. Multiple trees can exist simultaneously, each\n * identified by a sequential integer index.\n *\n * @param index - The mixer tree index, starting from `0n`.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findStealthPoolPda } from \"@umbra-privacy/sdk\";\n *\n * const mixerTree0 = await findStealthPoolPda(0n as U128, networkConfig.programId);\n * ```\n *\n * @see {@link findActiveStealthPoolPda} for the convenience wrapper that always returns tree index 0\n * @see {@link findNullifierSetPdas} for the nullifier storage accounts associated with each tree\n * @see {@link findProtocolConfigPda} for the global account that stores the active tree index\n *\n * @public\n */\nexport async function findStealthPoolPda(index: U128, umbraProgram: Address): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [STEALTH_POOL_SEED, encodeU128ToU128LeBytes(index)],\n  });\n\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for the currently active stealth pool (tree index 0).\n * Seeds: [StealthPool::SEED, 0_u128_le]\n *\n * This is a convenience wrapper around `findStealthPoolPda(0n)` for the\n * common case where a caller needs the genesis tree address.\n *\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the PDA `Address` of tree index 0.\n *\n * @example\n * ```typescript\n * import { findActiveStealthPoolPda } from \"@umbra-privacy/sdk\";\n *\n * const activeMixer = await findActiveStealthPoolPda(networkConfig.programId);\n * ```\n *\n * @see {@link findStealthPoolPda} for arbitrary tree index derivation\n * @see {@link findProtocolConfigPda} for the account that tracks the true active index\n *\n * @public\n */\nexport async function findActiveStealthPoolPda(umbraProgram: Address): Promise<Address> {\n  return findStealthPoolPda(0n as U128, umbraProgram);\n}\n\n/**\n * Derives the Program Derived Address for a confidential nullifier buffer account.\n * Seeds: [ConfidentialNullifierLinkerBuffer::SEED, relayer_pubkey, receiver_address, offset_u128_le]\n *\n * Confidential nullifier buffer accounts are temporary storage PDAs that hold\n * the nullifier set for a batch of confidential UTXOs being claimed in a\n * single relayer-submitted transaction.\n *\n * @param relayerAddress - The relayer's public key.\n * @param receiverAddress - The receiver's public key (claim destination address).\n * @param burnerAccountOffset - The U128 offset discriminator.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findConfidentialNullifierBufferPda } from \"@umbra-privacy/sdk\";\n *\n * const burnerPda = await findConfidentialNullifierBufferPda(\n *   relayerAddress,\n *   receiverAddress,\n *   0n as U128,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findPublicNullifierBufferPda} for the public-balance variant\n * @see {@link findNullifierSetPdas} for the nullifier storage accounts the burner writes into\n *\n * @public\n */\nexport async function findConfidentialNullifierBufferPda(\n  relayerAddress: Address,\n  receiverAddress: Address,\n  burnerAccountOffset: U128,\n  umbraProgram: Address,\n): Promise<Address> {\n  const addressEncoder = getAddressEncoder();\n\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      CONF_UTXO_BURNER_SEED,\n      addressEncoder.encode(relayerAddress),\n      addressEncoder.encode(receiverAddress),\n      getAccountOffsetEncoder().encode({\n        first: BigInt(burnerAccountOffset),\n      }),\n    ],\n  });\n\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for a public nullifier buffer account.\n * Seeds: [PublicNullifierLinkerBuffer::SEED, relayer_pubkey, receiver_address, offset_u128_le]\n *\n * Public nullifier buffer accounts serve the same purpose as confidential\n * nullifier buffer accounts but for claims that deposit into a public ATA\n * rather than an encrypted balance.\n *\n * @param relayerAddress - The relayer's public key.\n * @param receiverAddress - The receiver's public key (claim destination address).\n * @param burnerAccountOffset - The U128 offset discriminator.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findPublicNullifierBufferPda } from \"@umbra-privacy/sdk\";\n *\n * const burnerPda = await findPublicNullifierBufferPda(\n *   relayerAddress,\n *   receiverAddress,\n *   0n as U128,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findConfidentialNullifierBufferPda} for the confidential-balance variant\n * @see {@link findNullifierSetPdas} for the nullifier storage accounts the burner writes into\n *\n * @public\n */\nexport async function findPublicNullifierBufferPda(\n  relayerAddress: Address,\n  receiverAddress: Address,\n  burnerAccountOffset: U128,\n  umbraProgram: Address,\n): Promise<Address> {\n  const addressEncoder = getAddressEncoder();\n\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      PUB_UTXO_BURNER_SEED,\n      addressEncoder.encode(relayerAddress),\n      addressEncoder.encode(receiverAddress),\n      getAccountOffsetEncoder().encode({\n        first: BigInt(burnerAccountOffset),\n      }),\n    ],\n  });\n\n  return pda;\n}\n\n/**\n * Return type for `findNullifierSetPdas` containing all five nullifier set\n * account addresses for a given mixer tree index.\n *\n * @remarks\n * Each mixer tree has exactly five associated nullifier set accounts (variants 0-4).\n * Together they form the Indexed Merkle Tree of nullifiers that prevents\n * double-spending. All five accounts must be passed to claim instructions\n * so the program can update the correct nullifier set node.\n *\n * @see {@link findNullifierSetPdas}\n *\n * @public\n */\nexport interface NullifierSetPdas {\n  /** Nullifier set account variant 0 (first segment of the nullifier IMT). @readonly */\n  readonly treap0: Address;\n  /** Nullifier set account variant 1 (second segment of the nullifier IMT). @readonly */\n  readonly treap1: Address;\n  /** Nullifier set account variant 2 (third segment of the nullifier IMT). @readonly */\n  readonly treap2: Address;\n  /** Nullifier set account variant 3 (fourth segment of the nullifier IMT). @readonly */\n  readonly treap3: Address;\n  /** Nullifier set account variant 4 (fifth segment of the nullifier IMT). @readonly */\n  readonly treap4: Address;\n}\n\n/**\n * Derives all five nullifier set PDAs for a given mixer tree index.\n * Seeds (per variant): [Treap::SEED, stealth_pool_index_u128_le, variant_byte]\n *\n * Nullifier set accounts implement the Indexed Merkle Tree (IMT) of nullifiers\n * used to prevent double-spending of UTXOs. There are exactly five accounts\n * per mixer tree, addressed by variant byte 0-4.\n *\n * @param stealthPoolIndex - The mixer tree index whose nullifier set PDAs to derive.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to a {@link NullifierSetPdas} object containing all\n *   five nullifier set account addresses (`treap0` through `treap4`).\n *\n * @example\n * ```typescript\n * import { findNullifierSetPdas } from \"@umbra-privacy/sdk\";\n *\n * const nullifierSetPdas = await findNullifierSetPdas(0n as U128, networkConfig.programId);\n * console.log(nullifierSetPdas.treap0, nullifierSetPdas.treap1, nullifierSetPdas.treap2);\n * ```\n *\n * @see {@link findStealthPoolPda} for the Merkle commitment tree PDAs\n * @see {@link NullifierSetPdas} for the return type shape\n *\n * @public\n */\nexport async function findNullifierSetPdas(\n  stealthPoolIndex: U128,\n  umbraProgram: Address,\n): Promise<NullifierSetPdas> {\n  const treapSeedBytes = TREAP_SEED;\n  const indexBytes = encodeU128ToU128LeBytes(stealthPoolIndex);\n\n  const derivePda = async (variant: number): Promise<Address> => {\n    const [pda] = await getProgramDerivedAddress({\n      programAddress: umbraProgram,\n      seeds: [treapSeedBytes, indexBytes, new Uint8Array([variant])],\n    });\n    return pda;\n  };\n\n  const [treap0, treap1, treap2, treap3, treap4] = await Promise.all([\n    derivePda(0),\n    derivePda(1),\n    derivePda(2),\n    derivePda(3),\n    derivePda(4),\n  ]);\n\n  return { treap0, treap1, treap2, treap3, treap4 };\n}\n","/**\n * User PDA Utilities\n *\n * This module provides functions to derive Program Derived Addresses (PDAs)\n * for user-related accounts in the Umbra protocol.\n *\n * @remarks\n * Umbra users have two distinct on-chain account types, both stored as\n * Arcium-encrypted accounts so their contents are opaque to on-chain\n * observers:\n *\n * - **`EncryptedUserAccount`** — stores the user's protocol-level state,\n *   including their registered X25519 public key and account generation index.\n *   Created once per user wallet via `RegisterUser`. Referenced by all\n *   confidential and compliance instructions that need to look up the user's\n *   encryption key.\n *\n * - **`EncryptedTokenAccount`** — stores the user's encrypted SPL token\n *   balance for a specific mint. Created once per `(user, mint)` pair via\n *   `InitialiseUserTokenAccount`. Modified by deposit, withdrawal, transfer,\n *   and claim instructions.\n *\n * Both PDAs are keyed under the Umbra program address (not the Arcium program)\n * because the Umbra program owns and manages these accounts through its\n * instruction handlers and Arcium callbacks.\n *\n * @see {@link findEncryptedUserAccountPda}\n * @see {@link findEncryptedTokenAccountPda}\n *\n * @packageDocumentation\n * @since 2.0.0\n * @module utils/pda/user\n */\n\nimport { type Address, getAddressEncoder, getProgramDerivedAddress } from \"@solana/kit\";\nimport { computeStructSeed } from \"./umbra\";\n\n/**\n * SHA-256 of the string `\"EncryptedUserAccount\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `EncryptedUserAccount::SEED` as generated by the\n * `#[umbra_account]` macro in `state/arcium/arcium_encrypted_user_account.rs`.\n * Used as the first seed when deriving encrypted user account PDAs.\n *\n * @internal\n */\nconst ENCRYPTED_USER_ACCOUNT_SEED = computeStructSeed(\"EncryptedUserAccount\");\n\n/**\n * SHA-256 of the string `\"EncryptedTokenAccount\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `EncryptedTokenAccount::SEED` as generated by the\n * `#[umbra_account]` macro in `state/arcium/arcium_encrypted_token_account.rs`.\n * Used as the first seed when deriving encrypted token account PDAs.\n *\n * @internal\n */\nconst ENCRYPTED_TOKEN_ACCOUNT_SEED = computeStructSeed(\"EncryptedTokenAccount\");\n\n/**\n * Derives the Program Derived Address for an encrypted user account.\n * Seeds: [EncryptedUserAccount::SEED, user_pubkey]\n *\n * The `EncryptedUserAccount` is the user's top-level protocol identity\n * within Umbra. It is a singleton per user wallet and stores the user's\n * registered X25519 public key and account generation index.\n *\n * @param userPubkey - The user's wallet public key (Solana Ed25519 address).\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findEncryptedUserAccountPda } from \"@umbra-privacy/sdk\";\n *\n * const userAccountPda = await findEncryptedUserAccountPda(\n *   userWalletAddress,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findEncryptedTokenAccountPda} for per-mint encrypted balance accounts\n *\n * @public\n */\nexport async function findEncryptedUserAccountPda(\n  userPubkey: Address,\n  umbraProgram: Address,\n): Promise<Address> {\n  const addressEncoder = getAddressEncoder();\n\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [ENCRYPTED_USER_ACCOUNT_SEED, addressEncoder.encode(userPubkey)],\n  });\n\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for an encrypted token account.\n * Seeds: [EncryptedTokenAccount::SEED, user_pubkey, mint_pubkey]\n *\n * The `EncryptedTokenAccount` holds the user's encrypted SPL token\n * balance for a specific mint. A separate account exists for each\n * `(user, mint)` pair.\n *\n * @param userPubkey - The user's wallet public key (Solana Ed25519 address).\n * @param mintPubkey - The SPL token mint address.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findEncryptedTokenAccountPda } from \"@umbra-privacy/sdk\";\n *\n * const tokenAccountPda = await findEncryptedTokenAccountPda(\n *   userWalletAddress,\n *   usdcMint,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findEncryptedUserAccountPda} for the top-level user identity account\n * @see {@link findTokenPoolPda} for the per-mint pool configuration that governs this account's features\n *\n * @public\n */\nexport async function findEncryptedTokenAccountPda(\n  userPubkey: Address,\n  mintPubkey: Address,\n  umbraProgram: Address,\n): Promise<Address> {\n  const addressEncoder = getAddressEncoder();\n\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      ENCRYPTED_TOKEN_ACCOUNT_SEED,\n      addressEncoder.encode(userPubkey),\n      addressEncoder.encode(mintPubkey),\n    ],\n  });\n\n  return pda;\n}\n","/**\n * Arcium PDA (Program Derived Address) Generator Utilities\n *\n * This module provides functions for deriving Arcium protocol account addresses.\n * These PDAs are used to locate various Arcium accounts on-chain, including\n * MXE accounts, computation accounts, and cluster accounts.\n *\n * @see {@link findArciumMxePda}\n * @see {@link findArciumMempoolPda}\n * @see {@link findArciumExecutingPoolPda}\n * @see {@link findArciumComputationPda}\n * @see {@link findArciumCompDefPda}\n * @see {@link findArciumClusterPda}\n * @see {@link findArciumInfrastructurePdas}\n * @see {@link computeCompDefOffset}\n *\n * @packageDocumentation\n * @since 2.0.0\n * @module utils/pda/arcium\n */\n\nimport { type Address, getAddressEncoder, getProgramDerivedAddress } from \"@solana/kit\";\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport {\n  ARCIUM_MXE_ACCOUNT_SEED,\n  ARCIUM_MEMPOOL_SEED,\n  ARCIUM_EXEC_POOL_SEED,\n  ARCIUM_COMPUTATION_SEED,\n  ARCIUM_COMP_DEF_SEED,\n  ARCIUM_CLUSTER_SEED,\n} from \"../../constants/arcium\";\nimport { type U32, assertU32, assertU64 } from \"../../types\";\nimport { encodeU32ToU32LeBytes, encodeU64ToU64LeBytes } from \"../converters/mathematics\";\n\n/* =============================================================================\n * COMPUTATION DEFINITION OFFSET DERIVATION\n * ============================================================================= */\n\n/**\n * Computes the computation definition offset from an Arcium instruction name.\n *\n * The comp-def offset uniquely identifies which comp-def account corresponds\n * to a given Umbra instruction. It is derived deterministically by taking the\n * SHA-256 hash of the instruction name and interpreting the first four bytes\n * as a little-endian u32.\n *\n * @param instructionName - The Arcium instruction name in snake_case format\n *   (e.g. `\"register_user\"`, `\"deposit_into_existing_mxe_v3\"`).\n * @returns The computation definition offset as an unsigned 32-bit integer.\n *\n * @example\n * ```typescript\n * import { computeCompDefOffset } from \"@umbra-privacy/sdk\";\n *\n * const offset = computeCompDefOffset(\"register_user\");\n *\n * const compDefPda = await findArciumCompDefPda(\n *   networkConfig.programId,\n *   networkConfig.arciumProgramAddress,\n *   offset,\n * );\n * ```\n *\n * @see {@link findArciumCompDefPda} for deriving the full comp-def PDA\n * @see {@link findArciumInfrastructurePdas} for deriving all Arcium accounts at once\n *\n * @public\n */\nexport function computeCompDefOffset(instructionName: string): number {\n  // Hash the instruction name with SHA256\n  const hash = sha256(new TextEncoder().encode(instructionName));\n\n  // Take first 4 bytes and interpret as little-endian u32\n\n  const byte0 = hash[0];\n\n  const byte1 = hash[1];\n\n  const byte2 = hash[2];\n\n  const byte3 = hash[3];\n\n  const offset = byte0 | (byte1 << 8) | (byte2 << 16) | (byte3 << 24);\n\n  // Return as unsigned 32-bit integer\n  return offset >>> 0;\n}\n\n/* =============================================================================\n * PDA DERIVATION FUNCTIONS\n * ============================================================================= */\n\n/**\n * Derives the Program Derived Address for the Arcium MXE registration account.\n * Seeds: [ARCIUM_MXE_ACCOUNT_SEED, umbra_program_pubkey] (against Arcium program)\n *\n * The MXE account is the Arcium protocol's main registration account for a\n * guest program (Umbra). Required as a read-only account on every\n * Arcium-integrated instruction.\n *\n * @param umbraProgram - The Umbra program address.\n * @param arciumProgram - The Arcium program address.\n * @returns A Promise resolving to the derived MXE account `Address`.\n *\n * @example\n * ```typescript\n * import { findArciumMxePda } from \"@umbra-privacy/sdk\";\n *\n * const mxeAccount = await findArciumMxePda(\n *   networkConfig.programId,\n *   networkConfig.arciumProgramAddress,\n * );\n * ```\n *\n * @see {@link findArciumInfrastructurePdas} for deriving all Arcium accounts at once\n *\n * @public\n */\nexport async function findArciumMxePda(\n  umbraProgram: Address,\n  arciumProgram: Address,\n): Promise<Address> {\n  const [address] = await getProgramDerivedAddress({\n    programAddress: arciumProgram,\n    seeds: [\n      new TextEncoder().encode(ARCIUM_MXE_ACCOUNT_SEED),\n      getAddressEncoder().encode(umbraProgram),\n    ],\n  });\n  return address;\n}\n\n/**\n * Derives the Program Derived Address for an Arcium cluster mempool account.\n * Seeds: [ARCIUM_MEMPOOL_SEED, cluster_offset_u32_le] (against Arcium program)\n *\n * The mempool account is a queue that holds pending computation requests\n * waiting to be picked up by cluster nodes.\n *\n * @param arciumProgram - The Arcium program address.\n * @param clusterOffset - The cluster offset (u32).\n * @returns A Promise resolving to the derived mempool account `Address`.\n *\n * @example\n * ```typescript\n * import { findArciumMempoolPda } from \"@umbra-privacy/sdk\";\n *\n * const mempoolAccount = await findArciumMempoolPda(\n *   networkConfig.arciumProgramAddress,\n *   networkConfig.clusterOffset,\n * );\n * ```\n *\n * @see {@link findArciumClusterPda} for the parent cluster account\n *\n * @public\n */\nexport async function findArciumMempoolPda(\n  arciumProgram: Address,\n  clusterOffset: number,\n): Promise<Address> {\n  assertU32(BigInt(clusterOffset));\n  const [address] = await getProgramDerivedAddress({\n    programAddress: arciumProgram,\n    seeds: [\n      new TextEncoder().encode(ARCIUM_MEMPOOL_SEED),\n      encodeU32ToU32LeBytes(BigInt(clusterOffset) as U32),\n    ],\n  });\n  return address;\n}\n\n/**\n * Derives the Program Derived Address for an Arcium cluster executing pool account.\n * Seeds: [ARCIUM_EXEC_POOL_SEED, cluster_offset_u32_le] (against Arcium program)\n *\n * The executing pool account tracks computations currently being processed\n * by cluster nodes.\n *\n * @param arciumProgram - The Arcium program address.\n * @param clusterOffset - The cluster offset (u32).\n * @returns A Promise resolving to the derived executing pool account `Address`.\n *\n * @example\n * ```typescript\n * import { findArciumExecutingPoolPda } from \"@umbra-privacy/sdk\";\n *\n * const execPoolAccount = await findArciumExecutingPoolPda(\n *   networkConfig.arciumProgramAddress,\n *   networkConfig.clusterOffset,\n * );\n * ```\n *\n * @see {@link findArciumMempoolPda} for the pending computation queue\n * @see {@link findArciumClusterPda} for the parent cluster account\n *\n * @public\n */\nexport async function findArciumExecutingPoolPda(\n  arciumProgram: Address,\n  clusterOffset: number,\n): Promise<Address> {\n  assertU32(BigInt(clusterOffset));\n  const [address] = await getProgramDerivedAddress({\n    programAddress: arciumProgram,\n    seeds: [\n      new TextEncoder().encode(ARCIUM_EXEC_POOL_SEED),\n      encodeU32ToU32LeBytes(BigInt(clusterOffset) as U32),\n    ],\n  });\n  return address;\n}\n\n/**\n * Derives the Program Derived Address for an individual Arcium computation account.\n * Seeds: [ARCIUM_COMPUTATION_SEED, cluster_offset_u32_le, computation_offset_u64_le] (against Arcium program)\n *\n * Each computation request gets its own account that stores the computation's\n * state. Created by `queue_computation` and closed when the callback executes.\n *\n * @param arciumProgram - The Arcium program address.\n * @param clusterOffset - The cluster offset (u32).\n * @param computationOffset - The computation offset (u64).\n * @returns A Promise resolving to the derived computation account `Address`.\n *\n * @example\n * ```typescript\n * import { findArciumComputationPda } from \"@umbra-privacy/sdk\";\n *\n * const computationAccount = await findArciumComputationPda(\n *   networkConfig.arciumProgramAddress,\n *   networkConfig.clusterOffset,\n *   computationOffset,\n * );\n * ```\n *\n * @see {@link findArciumInfrastructurePdas} for deriving all required accounts at once\n * @see {@link findArciumCompDefPda} for the computation definition account\n *\n * @public\n */\nexport async function findArciumComputationPda(\n  arciumProgram: Address,\n  clusterOffset: number,\n  computationOffset: bigint,\n): Promise<Address> {\n  assertU32(BigInt(clusterOffset));\n  assertU64(computationOffset);\n  const [address] = await getProgramDerivedAddress({\n    programAddress: arciumProgram,\n    seeds: [\n      new TextEncoder().encode(ARCIUM_COMPUTATION_SEED),\n      encodeU32ToU32LeBytes(BigInt(clusterOffset) as U32),\n      encodeU64ToU64LeBytes(computationOffset),\n    ],\n  });\n  return address;\n}\n\n/**\n * Derives the Program Derived Address for an Arcium computation definition account.\n * Seeds: [ARCIUM_COMP_DEF_SEED, umbra_program_pubkey, comp_def_offset_u32_le] (against Arcium program)\n *\n * A computation definition account stores the encrypted circuit program that\n * cluster nodes execute for a specific Arcium instruction. One comp-def\n * account exists per Umbra instruction that uses Arcium MPC.\n *\n * @param umbraProgram - The Umbra program address.\n * @param arciumProgram - The Arcium program address.\n * @param compDefOffset - The computation definition offset, derived via\n *   `computeCompDefOffset(instructionName)`.\n * @returns A Promise resolving to the derived comp-def account `Address`.\n *\n * @example\n * ```typescript\n * import { computeCompDefOffset, findArciumCompDefPda } from \"@umbra-privacy/sdk\";\n *\n * const offset = computeCompDefOffset(\"deposit_into_existing_mxe_v3\");\n * const compDefAccount = await findArciumCompDefPda(\n *   networkConfig.programId,\n *   networkConfig.arciumProgramAddress,\n *   offset,\n * );\n * ```\n *\n * @see {@link computeCompDefOffset} for computing the offset from an instruction name\n * @see {@link findArciumInfrastructurePdas} for deriving all required accounts at once\n *\n * @public\n */\nexport async function findArciumCompDefPda(\n  umbraProgram: Address,\n  arciumProgram: Address,\n  compDefOffset: number,\n): Promise<Address> {\n  assertU32(BigInt(compDefOffset));\n  const [address] = await getProgramDerivedAddress({\n    programAddress: arciumProgram,\n    seeds: [\n      new TextEncoder().encode(ARCIUM_COMP_DEF_SEED),\n      getAddressEncoder().encode(umbraProgram),\n      encodeU32ToU32LeBytes(BigInt(compDefOffset) as U32),\n    ],\n  });\n  return address;\n}\n\n/**\n * Derives the Program Derived Address for an Arcium cluster account.\n * Seeds: [ARCIUM_CLUSTER_SEED, cluster_offset_u32_le] (against Arcium program)\n *\n * A cluster account represents a group of Arcium MXE nodes that jointly\n * process computations using multi-party computation (MPC).\n *\n * @param arciumProgram - The Arcium program address.\n * @param clusterOffset - The cluster offset (u32).\n * @returns A Promise resolving to the derived cluster account `Address`.\n *\n * @example\n * ```typescript\n * import { findArciumClusterPda } from \"@umbra-privacy/sdk\";\n *\n * const clusterAccount = await findArciumClusterPda(\n *   networkConfig.arciumProgramAddress,\n *   networkConfig.clusterOffset,\n * );\n * ```\n *\n * @see {@link findArciumMempoolPda} for the cluster's pending computation queue\n * @see {@link findArciumExecutingPoolPda} for the cluster's active computation pool\n *\n * @public\n */\nexport async function findArciumClusterPda(\n  arciumProgram: Address,\n  clusterOffset: number,\n): Promise<Address> {\n  assertU32(BigInt(clusterOffset));\n  const [address] = await getProgramDerivedAddress({\n    programAddress: arciumProgram,\n    seeds: [\n      new TextEncoder().encode(ARCIUM_CLUSTER_SEED),\n      encodeU32ToU32LeBytes(BigInt(clusterOffset) as U32),\n    ],\n  });\n  return address;\n}\n\n/* =============================================================================\n * AGGREGATE ADDRESS GENERATION\n * ============================================================================= */\n\n/**\n * Collection of all Arcium infrastructure account addresses needed to submit\n * a computation to the Arcium MPC network.\n *\n * @see {@link findArciumInfrastructurePdas} for the function that produces this object\n *\n * @public\n */\nexport interface ArciumInfrastructurePdas {\n  /** The MXE protocol account address for the Umbra program. @readonly */\n  readonly mxeAccount: Address;\n\n  /** The mempool account address for the cluster. @readonly */\n  readonly mempoolAccount: Address;\n\n  /** The executing pool account address for the cluster. @readonly */\n  readonly executingPoolAccount: Address;\n\n  /** The computation account address for this specific computation request. @readonly */\n  readonly computationAccount: Address;\n\n  /** The computation definition account address for the target instruction. @readonly */\n  readonly compDefAccount: Address;\n\n  /** The cluster account address. @readonly */\n  readonly clusterAccount: Address;\n}\n\n/**\n * Derives all Arcium infrastructure account addresses required for a single\n * computation request.\n *\n * This is a convenience function that computes all six required Arcium PDAs in\n * parallel and returns them as an {@link ArciumInfrastructurePdas} object.\n *\n * @param umbraProgram - The Umbra program address.\n * @param arciumProgram - The Arcium program address.\n * @param clusterOffset - The cluster offset identifying which Arcium cluster to use.\n * @param computationOffset - The unique u64 offset for this specific computation.\n * @param instructionName - The snake_case Arcium instruction name used to derive\n *   the comp-def offset.\n * @returns A Promise resolving to an {@link ArciumInfrastructurePdas} object.\n *\n * @example\n * ```typescript\n * import { findArciumInfrastructurePdas } from \"@umbra-privacy/sdk\";\n *\n * const arciumAccounts = await findArciumInfrastructurePdas(\n *   networkConfig.programId,\n *   networkConfig.arciumProgramAddress,\n *   networkConfig.clusterOffset,\n *   computationOffset,\n *   \"deposit_into_existing_mxe_v3\",\n * );\n * ```\n *\n * @see {@link computeCompDefOffset} for the comp-def offset derivation\n * @see {@link ArciumInfrastructurePdas} for the return type shape\n *\n * @public\n */\nexport async function findArciumInfrastructurePdas(\n  umbraProgram: Address,\n  arciumProgram: Address,\n  clusterOffset: number,\n  computationOffset: bigint,\n  instructionName: string,\n): Promise<ArciumInfrastructurePdas> {\n  const compDefOffset = computeCompDefOffset(instructionName);\n\n  // Derive all addresses in parallel for efficiency\n  const [\n    mxeAccount,\n    mempoolAccount,\n    executingPoolAccount,\n    computationAccount,\n    compDefAccount,\n    clusterAccount,\n  ] = await Promise.all([\n    findArciumMxePda(umbraProgram, arciumProgram),\n    findArciumMempoolPda(arciumProgram, clusterOffset),\n    findArciumExecutingPoolPda(arciumProgram, clusterOffset),\n    findArciumComputationPda(arciumProgram, clusterOffset, computationOffset),\n    findArciumCompDefPda(umbraProgram, arciumProgram, compDefOffset),\n    findArciumClusterPda(arciumProgram, clusterOffset),\n  ]);\n\n  return {\n    mxeAccount,\n    mempoolAccount,\n    executingPoolAccount,\n    computationAccount,\n    compDefAccount,\n    clusterAccount,\n  };\n}\n","/**\n * Compliance Grant PDA Utilities\n *\n * This module provides functions to derive Program Derived Addresses (PDAs)\n * for compliance grant accounts in the Umbra protocol.\n *\n * @remarks\n * Umbra implements a master viewing key system that allows authorised parties\n * to decrypt encrypted user data without gaining control over funds. Three\n * grant variants exist, each modelling a different trust relationship:\n *\n * - **Network grant** — the Arcium MXE network itself can decrypt the\n *   user's data; the granter is implicitly the network. Used for regulatory\n *   or protocol-level compliance.\n * - **Shared grant** — the user explicitly shares a re-encrypted view\n *   key with the network for a specific receiver, scoped to a nonce to\n *   prevent replay.\n * - **User grant** — the user directly grants a named receiver (e.g. an\n *   auditor) the ability to read their encrypted data by re-encrypting the\n *   view key under the receiver's X25519 public key.\n *\n * All three grant PDAs share a common prefix (`VIEWING_GRANT_SEED`)\n * and are disambiguated by a variant seed (`USER_GRANT_VARIANT_SEED`, etc.).\n * The nonce component prevents one grant from accidentally overwriting another.\n *\n * @see {@link findUserComplianceGrantPda}\n * @see {@link findNetworkComplianceGrantPda}\n * @see {@link findSharedComplianceGrantPda}\n *\n * @packageDocumentation\n * @since 2.0.0\n * @module utils/pda/compliance\n */\n\nimport { type Address, getProgramDerivedAddress } from \"@solana/kit\";\nimport {\n  getArciumX25519NonceEncoder,\n  getArciumX25519PublicKeyEncoder,\n} from \"@umbra-privacy/umbra-codama\";\nimport type { RcEncryptionNonce } from \"../../types\";\n\n/**\n * Seed prefix shared by all compliance grant PDAs.\n *\n * This is the SHA-256 hash of the UTF-8 string `\"ViewingGrant\"`,\n * encoded as a 32-byte `Uint8Array`. It matches the `SEED` constant generated\n * by the `#[umbra_account]` macro on the `ViewingGrant` struct in\n * `state/arcium/arcium_compliance_grant.rs`.\n *\n * @internal\n */\nconst VIEWING_GRANT_SEED = new Uint8Array([\n  209, 198, 56, 240, 66, 199, 19, 205, 112, 18, 168, 165, 236, 235, 81, 198, 191, 71, 73, 191, 110,\n  113, 189, 97, 139, 226, 152, 252, 229, 184, 187, 253,\n]);\n\n/**\n * Variant discriminator seed for user-granted compliance grants.\n *\n * This is the SHA-256 hash of the UTF-8 string `\"UserGrant\"`, encoded as a\n * 32-byte `Uint8Array`.\n *\n * @internal\n */\nconst USER_GRANT_VARIANT_SEED = new Uint8Array([\n  184, 137, 63, 24, 18, 54, 138, 200, 151, 217, 219, 241, 119, 150, 66, 8, 27, 105, 131, 187, 58,\n  182, 24, 203, 146, 119, 188, 210, 197, 104, 238, 33,\n]);\n\n/**\n * Variant discriminator seed for network MXE compliance grants.\n *\n * This is the SHA-256 hash of the UTF-8 string `\"NetworkMxeGrant\"`, encoded\n * as a 32-byte `Uint8Array`.\n *\n * @internal\n */\nconst NETWORK_MXE_GRANT_VARIANT_SEED = new Uint8Array([\n  142, 219, 209, 143, 158, 68, 71, 58, 193, 244, 116, 159, 48, 68, 160, 95, 175, 131, 151, 209, 81,\n  213, 51, 159, 98, 98, 138, 109, 254, 69, 221, 95,\n]);\n\n/**\n * Variant discriminator seed for network shared compliance grants.\n *\n * This is the SHA-256 hash of the UTF-8 string `\"NetworkSharedGrant\"`, encoded\n * as a 32-byte `Uint8Array`.\n *\n * @internal\n */\nconst NETWORK_SHARED_GRANT_VARIANT_SEED = new Uint8Array([\n  172, 245, 86, 61, 89, 235, 170, 92, 253, 117, 241, 14, 2, 33, 164, 107, 22, 131, 100, 113, 39,\n  173, 185, 55, 254, 100, 108, 218, 180, 105, 75, 184,\n]);\n\n/**\n * Derives the Program Derived Address for a user-granted compliance grant.\n * Seeds: [ViewingGrant::SEED, UserGrant::VARIANT, granter_x25519, nonce, receiver_x25519]\n *\n * A user-granted compliance grant stores a re-encrypted view of the granter's\n * private data under the receiver's X25519 public key, enabling a specific\n * party (e.g. an auditor) to decrypt the granter's encrypted balances.\n *\n * @param granterX25519 - The 32-byte X25519 public key of the granter.\n * @param nonce - A `RcEncryptionNonce` (u128) uniquely identifying this grant issuance.\n * @param receiverX25519 - The 32-byte X25519 public key of the receiver.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findUserComplianceGrantPda } from \"@umbra-privacy/sdk\";\n *\n * const grantPda = await findUserComplianceGrantPda(\n *   granterX25519PublicKey,\n *   nonce,\n *   auditorX25519PublicKey,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findNetworkComplianceGrantPda} for network-level MXE grants\n * @see {@link findSharedComplianceGrantPda} for network shared grants\n *\n * @public\n */\nexport async function findUserComplianceGrantPda(\n  granterX25519: Uint8Array,\n  nonce: RcEncryptionNonce,\n  receiverX25519: Uint8Array,\n  umbraProgram: Address,\n): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      VIEWING_GRANT_SEED,\n      USER_GRANT_VARIANT_SEED,\n      getArciumX25519PublicKeyEncoder().encode({ first: granterX25519 }),\n      getArciumX25519NonceEncoder().encode({ first: nonce }),\n      getArciumX25519PublicKeyEncoder().encode({ first: receiverX25519 }),\n    ],\n  });\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for a network (MXE) compliance grant.\n * Seeds: [ViewingGrant::SEED, NetworkMxeGrant::VARIANT, nonce, receiver_x25519]\n *\n * A network compliance grant allows the Arcium MXE network itself to\n * decrypt a user's encrypted data. There is no explicit granter key in the\n * seeds -- the granter is implicitly the network.\n *\n * @param nonce - A `RcEncryptionNonce` (u128) uniquely identifying this grant issuance.\n * @param receiverX25519 - The 32-byte X25519 public key of the receiver.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findNetworkComplianceGrantPda } from \"@umbra-privacy/sdk\";\n *\n * const grantPda = await findNetworkComplianceGrantPda(\n *   nonce,\n *   networkX25519PublicKey,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findUserComplianceGrantPda} for user-to-auditor grants\n * @see {@link findSharedComplianceGrantPda} for network shared grants\n *\n * @public\n */\nexport async function findNetworkComplianceGrantPda(\n  nonce: RcEncryptionNonce,\n  receiverX25519: Uint8Array,\n  umbraProgram: Address,\n): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      VIEWING_GRANT_SEED,\n      NETWORK_MXE_GRANT_VARIANT_SEED,\n      getArciumX25519NonceEncoder().encode({ first: nonce }),\n      getArciumX25519PublicKeyEncoder().encode({ first: receiverX25519 }),\n    ],\n  });\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for a shared (network-shared) compliance grant.\n * Seeds: [ViewingGrant::SEED, NetworkSharedGrant::VARIANT, granter_x25519, nonce, receiver_x25519]\n *\n * A shared compliance grant is issued by a specific user to share a\n * re-encrypted view key with a named receiver via the Arcium network.\n * Unlike the network compliance grant, this variant includes the granter's\n * key so multiple users can each issue independent shared grants.\n *\n * @param granterX25519 - The 32-byte X25519 public key of the granter.\n * @param nonce - A `RcEncryptionNonce` (u128) uniquely identifying this grant issuance.\n * @param receiverX25519 - The 32-byte X25519 public key of the receiver.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findSharedComplianceGrantPda } from \"@umbra-privacy/sdk\";\n *\n * const grantPda = await findSharedComplianceGrantPda(\n *   granterX25519PublicKey,\n *   nonce,\n *   receiverX25519PublicKey,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findUserComplianceGrantPda} for direct user-to-auditor grants\n * @see {@link findNetworkComplianceGrantPda} for implicit network-level grants\n *\n * @public\n */\nexport async function findSharedComplianceGrantPda(\n  granterX25519: Uint8Array,\n  nonce: RcEncryptionNonce,\n  receiverX25519: Uint8Array,\n  umbraProgram: Address,\n): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      VIEWING_GRANT_SEED,\n      NETWORK_SHARED_GRANT_VARIANT_SEED,\n      getArciumX25519PublicKeyEncoder().encode({ first: granterX25519 }),\n      getArciumX25519NonceEncoder().encode({ first: nonce }),\n      getArciumX25519PublicKeyEncoder().encode({ first: receiverX25519 }),\n    ],\n  });\n  return pda;\n}\n","/**\n * Global PDA Utilities\n *\n * This module provides functions to derive Program Derived Addresses (PDAs)\n * for singleton program-level accounts in the Umbra protocol.\n *\n * Mirrors the smart contract's `state/global/` module, which holds\n * `ProtocolConfig` — a singleton account storing protocol-wide state.\n *\n * @remarks\n * There is exactly one `ProtocolConfig` account per Umbra program\n * deployment. It acts as the canonical source of truth for cross-instruction\n * protocol state: the index of the currently active mixer tree, global\n * feature activation flags, and the program upgrade authority. Most\n * instructions pass it as a read-only account for validation.\n *\n * @see {@link findProtocolConfigPda} for the derivation function\n * @see {@link findTokenPoolPda} for per-mint pool configuration\n *\n * @packageDocumentation\n * @since 2.0.0\n * @module utils/pda/global\n */\n\nimport { type Address, getProgramDerivedAddress } from \"@solana/kit\";\nimport { computeStructSeed } from \"./umbra\";\n\n/**\n * SHA-256 of the string `\"ProtocolConfig\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `ProtocolConfig::SEED` as generated by the `#[umbra_account]`\n * macro in `state/global/program_information.rs`. This is the sole seed used\n * when deriving the singleton `ProtocolConfig` PDA.\n *\n * @internal\n */\nconst PROTOCOL_CONFIG_SEED = computeStructSeed(\"ProtocolConfig\");\n\n/**\n * Derives the Program Derived Address for the singleton protocol configuration account.\n * Seeds: [ProtocolConfig::SEED]\n *\n * The `ProtocolConfig` account stores global configuration state including\n * the active mixer tree index, feature flags, and the upgrade authority.\n *\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findProtocolConfigPda } from \"@umbra-privacy/sdk\";\n *\n * const protocolConfig = await findProtocolConfigPda(networkConfig.programId);\n * ```\n *\n * @see {@link findTokenPoolPda} for per-mint pool configuration\n * @see {@link findStealthPoolPda} for per-index mixer tree accounts\n *\n * @public\n */\nexport async function findProtocolConfigPda(umbraProgram: Address): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [PROTOCOL_CONFIG_SEED],\n  });\n  return pda;\n}\n","/**\n * Pool PDA Utilities\n *\n * This module provides functions to derive Program Derived Addresses (PDAs)\n * for pool-related accounts in the Umbra protocol.\n *\n * Mirrors the smart contract's `state/pool/` module, which holds the `Pool`\n * account — a per-mint configuration account that enables confidentiality and\n * mixer features for a specific SPL token.\n *\n * @remarks\n * The `Pool` account is a singleton per SPL token mint. It is created by the\n * protocol administrator and acts as the root configuration object for all\n * privacy operations involving that mint. Instructions that add or remove\n * privacy features (confidentiality, mixer) modify this account.\n *\n * @see {@link findTokenPoolPda} for the derivation function\n * @see {@link findProtocolConfigPda} for the global singleton that tracks active tree index\n *\n * @packageDocumentation\n * @since 2.0.0\n * @module utils/pda/pool\n */\n\nimport { type Address, getAddressEncoder, getProgramDerivedAddress } from \"@solana/kit\";\nimport { computeStructSeed } from \"./umbra\";\n\n/**\n * SHA-256 of the string `\"TokenPool\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `Pool::SEED` as generated by the `#[umbra_account]` macro\n * in `state/pool/pool.rs`. Used as the first seed when deriving Pool PDAs.\n *\n * Also re-exported from the barrel (`index.ts`) as `TOKEN_POOL_SEED` for callers\n * that need the raw bytes — for example, to verify a PDA server-side without\n * calling `findTokenPoolPda`.\n *\n * @internal\n */\nexport const TOKEN_POOL_SEED = computeStructSeed(\"TokenPool\");\n\n/**\n * Derives the Program Derived Address for a token pool configuration account.\n * Seeds: [TokenPool::SEED, mint_pubkey]\n *\n * The `Pool` account is a per-mint singleton that stores whether\n * confidentiality and mixer features are activated for a specific SPL token.\n *\n * @param mintAddress - The SPL token mint address for this pool.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findTokenPoolPda } from \"@umbra-privacy/sdk\";\n *\n * const pool = await findTokenPoolPda(mintAddress, networkConfig.programId);\n * ```\n *\n * @see {@link TOKEN_POOL_SEED} for the raw seed bytes\n * @see {@link findProtocolConfigPda} for the global singleton account\n *\n * @public\n */\nexport async function findTokenPoolPda(mintAddress: Address, umbraProgram: Address): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [TOKEN_POOL_SEED, getAddressEncoder().encode(mintAddress)],\n  });\n  return pda;\n}\n","/**\n * Relayer PDA Utilities\n *\n * This module provides functions to derive Program Derived Addresses (PDAs)\n * for relayer-related accounts in the Umbra protocol.\n *\n * Mirrors the smart contract's `state/relayer/` module, which holds:\n * - `Relayer` — a per-relayer, per-mint account that stores the\n *   relayer's registration state and fee configuration references.\n *\n * @remarks\n * Relayers are permissioned transaction forwarders in the Umbra privacy\n * protocol. They submit user-generated proofs and encrypted payloads\n * on-chain, collecting a commission fee for the service. Each relayer must\n * register a `Relayer` for every SPL token mint they wish to support.\n *\n * The `Relayer` PDA is scoped to a `(relayer, mint)` pair so that a\n * single relayer wallet can independently manage fee configurations for\n * multiple mints without conflicting accounts.\n *\n * @see {@link findRelayerPda} for the derivation function\n * @see {@link findRelayerFeeVaultPda} for the associated fee pool derivation\n *\n * @packageDocumentation\n * @since 2.0.0\n * @module utils/pda/relayer\n */\n\nimport { type Address, getAddressEncoder, getProgramDerivedAddress } from \"@solana/kit\";\nimport { computeStructSeed } from \"./umbra\";\n\n/**\n * SHA-256 of the string `\"Relayer\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `Relayer::SEED` as generated by the `#[umbra_account]`\n * macro in `state/relayer/relayer_account.rs`. Used as the first seed when\n * deriving `Relayer` PDAs.\n *\n * @internal\n */\nconst RELAYER_SEED = computeStructSeed(\"Relayer\");\n\n/**\n * Derives the Program Derived Address for a relayer registration account.\n * Seeds: [Relayer::SEED, relayer_pubkey, mint_pubkey]\n *\n * The `Relayer` stores a relayer's registration data and fee\n * configuration for a specific SPL token mint. A unique account exists per\n * `(relayer, mint)` pair.\n *\n * @param relayerAddress - The relayer's wallet public key.\n * @param mintAddress - The SPL token mint address that this relayer supports.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findRelayerPda } from \"@umbra-privacy/sdk\";\n *\n * const relayerAccount = await findRelayerPda(\n *   relayerPublicKey,\n *   mintAddress,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findRelayerFeeVaultPda} for the associated unified fee pool\n * @see {@link findFeeSchedulePda} for the fee rate configuration account\n *\n * @public\n */\nexport async function findRelayerPda(\n  relayerAddress: Address,\n  mintAddress: Address,\n  umbraProgram: Address,\n): Promise<Address> {\n  const addressEncoder = getAddressEncoder();\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      RELAYER_SEED,\n      addressEncoder.encode(relayerAddress),\n      addressEncoder.encode(mintAddress),\n    ],\n  });\n  return pda;\n}\n","/**\n * Fees PDA Utilities\n *\n * This module provides functions to derive Program Derived Addresses (PDAs)\n * for protocol and relayer fee accounts in the Umbra protocol.\n *\n * Mirrors the smart contract's `state/fees/` module, which holds:\n * - `FeeVault` — a single account storing both protocol and relayer fees,\n *   partitioned by a domain seed into two variants:\n *   - Protocol-only pools (deposits, withdrawals, public UTXO creation)\n *   - Relayer pools (transfers, confidential/public claims)\n * - `FeeSchedule` — admin-managed fee rate config per mint\n *\n * @remarks\n * Umbra separates fee collection from fee disbursement by accumulating fees in\n * dedicated PDA accounts (`FeeVault`) that can be swept by the protocol\n * treasury or relayer at any time. The fee amount charged per instruction is\n * governed by the `FeeSchedule` account for that instruction + mint\n * pair.\n *\n * Both `FeeVault` variants and `FeeSchedule` include an\n * `offset` seed, following the canonical seed pattern:\n *\n * `SEED -> domain_seed (for fees pool) -> instructionSeed -> entity_key -> mint -> offset`\n *\n * The `offset` allows the protocol to create multiple fee pool or config\n * accounts for the same instruction + mint combination if needed in future.\n * Currently `offset` is always `0n` for `FeeSchedule` and an\n * instruction-specific constant for `FeeVault`.\n *\n * @see {@link findProtocolFeeVaultPda}\n * @see {@link findRelayerFeeVaultPda}\n * @see {@link findFeeSchedulePda}\n *\n * @packageDocumentation\n * @since 2.0.0\n * @module utils/pda/fees\n */\n\nimport { type Address, getAddressEncoder, getProgramDerivedAddress } from \"@solana/kit\";\nimport { getAccountOffsetEncoder } from \"@umbra-privacy/umbra-codama\";\nimport type { U128 } from \"../../types\";\nimport { encodeU128ToU128LeBytes } from \"../converters/mathematics\";\nimport { computeStructSeed } from \"./umbra\";\n\n/**\n * SHA-256 of the string `\"FeeVault\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `FeeVault::SEED` as generated by the `#[umbra_account]`\n * macro in `state/fees/unified_fees_pool.rs`. Used as the first seed when\n * deriving all `FeeVault` PDAs (both protocol-only and relayer variants).\n *\n * @internal\n */\nconst FEE_VAULT_SEED = computeStructSeed(\"FeeVault\");\n\n/**\n * Domain separator that identifies protocol-only fee pools.\n *\n * This is the SHA-256 hash of `\"ProtocolFees\"`, matching\n * `FeeVault::DOMAIN_PROTOCOL_FEES` (`sha256_seed!(\"ProtocolFees\")`)\n * in `state/fees/unified_fees_pool.rs`.\n *\n * @internal\n */\nconst DOMAIN_PROTOCOL_FEES = computeStructSeed(\"ProtocolFees\");\n\n/**\n * Domain separator that identifies combined protocol + relayer fee pools.\n *\n * This is the SHA-256 hash of `\"ProtocolRelayerFees\"`, matching\n * `FeeVault::DOMAIN_PROTOCOL_RELAYER_FEES`\n * (`sha256_seed!(\"ProtocolRelayerFees\")`) in `state/fees/unified_fees_pool.rs`.\n *\n * @internal\n */\nconst DOMAIN_PROTOCOL_RELAYER_FEES = computeStructSeed(\"ProtocolRelayerFees\");\n\n/**\n * SHA-256 of the string `\"FeeSchedule\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `FeeSchedule::SEED` as generated by the\n * `#[umbra_account]` macro in `state/fees/protocol_fees_configuration.rs`.\n * Used as the first seed when deriving `FeeSchedule` PDAs.\n *\n * @internal\n */\nconst FEE_SCHEDULE_SEED = computeStructSeed(\"FeeSchedule\");\n\n/**\n * SHA-256 of the string `\"RelayerFeeSchedule\"`, stored as a 32-byte `Uint8Array`.\n *\n * Matches `RelayerFeeSchedule::SEED` as generated by the `#[umbra_account]`\n * macro in `state/relayer/relayer_fees_configuration.rs`. Used as the first seed\n * when deriving `RelayerFeeSchedule` PDAs.\n *\n * @internal\n */\nconst RELAYER_FEE_SCHEDULE_SEED = computeStructSeed(\"RelayerFeeSchedule\");\n\n/**\n * Derives the Program Derived Address for a protocol-only fee vault account.\n * Seeds: [FeeVault::SEED, ProtocolFees::DOMAIN, instruction_seed, mint_pubkey, offset]\n *\n * Protocol-only fee pools accumulate the protocol's share of fees for\n * instructions that have no relayer commission component (deposits,\n * withdrawals, and public UTXO creation).\n *\n * @param instructionSeed - The instruction-specific U128 seed constant.\n * @param mintAddress - The SPL token mint address for this pool.\n * @param offset - The account offset discriminator (U128).\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the `[pda, bump]` tuple.\n *\n * @example\n * ```typescript\n * import { findProtocolFeeVaultPda } from \"@umbra-privacy/sdk\";\n *\n * const [feesPoolPda] = await findProtocolFeeVaultPda(\n *   instructionSeed as U128,\n *   mintAddress,\n *   PROTOCOL_FEES_POOL_OFFSET as U128,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findRelayerFeeVaultPda} for the relayer commission pool variant\n * @see {@link findFeeSchedulePda} for the fee rate configuration account\n *\n * @public\n */\nexport async function findProtocolFeeVaultPda(\n  instructionSeed: U128,\n  mintAddress: Address,\n  offset: U128,\n  umbraProgram: Address,\n): Promise<readonly [Address, number]> {\n  const addressEncoder = getAddressEncoder();\n  return getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      FEE_VAULT_SEED,\n      DOMAIN_PROTOCOL_FEES,\n      encodeU128ToU128LeBytes(instructionSeed),\n      addressEncoder.encode(mintAddress),\n      getAccountOffsetEncoder().encode({ first: BigInt(offset) }),\n    ],\n  });\n}\n\n/**\n * Derives the Program Derived Address for a relayer fee vault account.\n * Seeds: [FeeVault::SEED, ProtocolRelayerFees::DOMAIN, instruction_seed, relayer_pubkey, mint_pubkey, offset]\n *\n * Relayer fee pools accumulate both the protocol's share and the relayer's\n * commission for instructions that involve a relayer (claims and transfers).\n *\n * @param instructionSeed - The instruction-specific U128 seed constant.\n * @param relayerAddress - The relayer's wallet public key.\n * @param mintAddress - The SPL token mint address for this pool.\n * @param offset - The account offset discriminator (U128).\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the `[pda, bump]` tuple.\n *\n * @example\n * ```typescript\n * import { findRelayerFeeVaultPda } from \"@umbra-privacy/sdk\";\n *\n * const [unifiedFeesPoolPda] = await findRelayerFeeVaultPda(\n *   instructionSeed as U128,\n *   relayerPublicKey,\n *   mintAddress,\n *   PROTOCOL_FEES_POOL_OFFSET as U128,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findProtocolFeeVaultPda} for the protocol-only pool variant\n * @see {@link findRelayerPda} for the relayer registration account\n *\n * @public\n */\nexport async function findRelayerFeeVaultPda(\n  instructionSeed: U128,\n  relayerAddress: Address,\n  mintAddress: Address,\n  offset: U128,\n  umbraProgram: Address,\n): Promise<readonly [Address, number]> {\n  const addressEncoder = getAddressEncoder();\n  return getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      FEE_VAULT_SEED,\n      DOMAIN_PROTOCOL_RELAYER_FEES,\n      encodeU128ToU128LeBytes(instructionSeed),\n      addressEncoder.encode(relayerAddress),\n      addressEncoder.encode(mintAddress),\n      getAccountOffsetEncoder().encode({ first: BigInt(offset) }),\n    ],\n  });\n}\n\n/**\n * Derives the Program Derived Address for a protocol fee schedule account.\n * Seeds: [FeeSchedule::SEED, instruction_seed, mint_pubkey, offset]\n *\n * The `FeeSchedule` account defines the fee rates for a specific instruction\n * variant and SPL token mint. Consulted during instruction validation to\n * calculate how much the user must pay.\n *\n * @param instructionSeed - The instruction-specific U128 seed constant.\n * @param mintAddress - The SPL token mint address for this fee configuration.\n * @param offset - The account offset discriminator (U128).\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the `[pda, bump]` tuple.\n *\n * @example\n * ```typescript\n * import { findFeeSchedulePda } from \"@umbra-privacy/sdk\";\n *\n * const [feeConfigPda] = await findFeeSchedulePda(\n *   instructionSeed as U128,\n *   mintAddress,\n *   0n as U128,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findProtocolFeeVaultPda} for the corresponding fee collection account\n * @see {@link findRelayerFeeVaultPda} for the relayer fee collection account\n *\n * @public\n */\nexport async function findFeeSchedulePda(\n  instructionSeed: U128,\n  mintAddress: Address,\n  offset: U128,\n  umbraProgram: Address,\n): Promise<readonly [Address, number]> {\n  const addressEncoder = getAddressEncoder();\n  return getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      FEE_SCHEDULE_SEED,\n      encodeU128ToU128LeBytes(instructionSeed),\n      addressEncoder.encode(mintAddress),\n      getAccountOffsetEncoder().encode({ first: BigInt(offset) }),\n    ],\n  });\n}\n\n/**\n * Derives the Program Derived Address for a relayer fee schedule account.\n * Seeds: [RelayerFeeSchedule::SEED, instruction_seed, relayer_pubkey, mint_pubkey, offset]\n *\n * The `RelayerFeeSchedule` account defines the fee rates a specific relayer\n * charges for a given instruction variant and SPL token mint.\n *\n * @param instructionSeed - The instruction-specific U128 seed constant.\n * @param relayerAddress - The relayer's wallet public key.\n * @param mintAddress - The SPL token mint address for this fee configuration.\n * @param offset - The account offset discriminator (U128).\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the `[pda, bump]` tuple.\n *\n * @public\n */\nexport async function findRelayerFeeSchedulePda(\n  instructionSeed: U128,\n  relayerAddress: Address,\n  mintAddress: Address,\n  offset: U128,\n  umbraProgram: Address,\n): Promise<readonly [Address, number]> {\n  const addressEncoder = getAddressEncoder();\n  return getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      RELAYER_FEE_SCHEDULE_SEED,\n      encodeU128ToU128LeBytes(instructionSeed),\n      addressEncoder.encode(relayerAddress),\n      addressEncoder.encode(mintAddress),\n      getAccountOffsetEncoder().encode({ first: BigInt(offset) }),\n    ],\n  });\n}\n","/**\n * ZK and MPC Callback PDA Utilities\n *\n * This module provides functions to derive Program Derived Addresses (PDAs)\n * for zero-knowledge proof accounts and MPC callback data accounts in the\n * Umbra protocol.\n *\n * @see {@link findVerifyingKeyPda}\n * @see {@link findClaimInputBufferPda}\n * @see {@link findUtxoInputBufferPda}\n * @see {@link findPublicClaimInputBufferPda}\n * @see {@link findPublicClaimComputationDataPda}\n *\n * @packageDocumentation\n * @since 2.0.0\n * @module utils/pda/zk\n */\n\nimport { type Address, getAddressEncoder, getProgramDerivedAddress } from \"@solana/kit\";\nimport { getAccountOffsetEncoder } from \"@umbra-privacy/umbra-codama\";\nimport type { U128 } from \"../../types\";\nimport { encodeU128ToU128LeBytes } from \"../converters/mathematics\";\nimport { computeStructSeed } from \"./umbra\";\n\n/**\n * SHA-256 of the string `\"Groth16VerifyingKey\"`, stored as a 32-byte `Uint8Array`.\n * @internal\n */\nconst GROTH16_VERIFYING_KEY_SEED = computeStructSeed(\"Groth16VerifyingKey\");\n\n/**\n * SHA-256 of the string `\"ConfidentialClaimProofAccount\"`, stored as a 32-byte `Uint8Array`.\n * @internal\n */\nconst CONFIDENTIAL_CLAIM_PROOF_ACCOUNT_SEED = computeStructSeed(\"ConfidentialClaimProofAccount\");\n\n/**\n * SHA-256 of the string `\"ConfidentialUtxoProofAccount\"`, stored as a 32-byte `Uint8Array`.\n * @internal\n */\nconst CONFIDENTIAL_UTXO_PROOF_ACCOUNT_SEED = computeStructSeed(\"ConfidentialUtxoProofAccount\");\n\n/**\n * SHA-256 of the string `\"PublicUtxoProofAccount\"`, stored as a 32-byte `Uint8Array`.\n * @internal\n */\nconst PUBLIC_UTXO_PROOF_ACCOUNT_SEED = computeStructSeed(\"PublicUtxoProofAccount\");\n\n/**\n * SHA-256 of the string `\"PublicClaimProofAccount\"`, stored as a 32-byte `Uint8Array`.\n * @internal\n */\nconst PUBLIC_CLAIM_PROOF_ACCOUNT_SEED = computeStructSeed(\"PublicClaimProofAccount\");\n\n/**\n * SHA-256 of the string `\"PublicClaimMxeMpcCallbackData\"`, stored as a 32-byte `Uint8Array`.\n * @internal\n */\nconst PUBLIC_CLAIM_MXE_MPC_CALLBACK_DATA_SEED = computeStructSeed(\"PublicClaimMxeMpcCallbackData\");\n\n/**\n * Derives the Program Derived Address for a Groth16 verifying key account.\n * Seeds: [Groth16VerifyingKey::SEED, instruction_seed]\n *\n * Stores the on-chain Groth16 verifying key for a specific proof circuit\n * variant. Set up by the protocol administrator and read as immutable input\n * in claim and UTXO instructions.\n *\n * @param instructionSeed - The U128 seed identifying the specific verifying key.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findVerifyingKeyPda } from \"@umbra-privacy/sdk\";\n *\n * const zkVerifyingKeyAccount = await findVerifyingKeyPda(\n *   zkSeed as U128,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findClaimInputBufferPda} for the proof buffer read alongside this account\n *\n * @public\n */\nexport async function findVerifyingKeyPda(\n  instructionSeed: U128,\n  umbraProgram: Address,\n): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [GROTH16_VERIFYING_KEY_SEED, encodeU128ToU128LeBytes(instructionSeed)],\n  });\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for a confidential claim input buffer account.\n * Seeds: [ConfidentialClaimProofAccount::SEED, payer_pubkey, offset]\n *\n * An ephemeral buffer account that holds the Groth16 proof bytes and encrypted\n * public inputs required for a confidential claim instruction. Created by the\n * relayer, consumed by the claim instruction, and closed in the MPC callback.\n *\n * @param payerAddress - The relayer's public key (proof account creator).\n * @param offset - The U128 offset discriminator.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findClaimInputBufferPda } from \"@umbra-privacy/sdk\";\n *\n * const proofAccountPda = await findClaimInputBufferPda(\n *   relayerPublicKey,\n *   proofAccountOffset as U128,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findVerifyingKeyPda} for the verifying key used to check this proof\n * @see {@link findPublicClaimInputBufferPda} for the public-balance claim variant\n *\n * @public\n */\nexport async function findClaimInputBufferPda(\n  payerAddress: Address,\n  offset: U128,\n  umbraProgram: Address,\n): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      CONFIDENTIAL_CLAIM_PROOF_ACCOUNT_SEED,\n      getAddressEncoder().encode(payerAddress),\n      getAccountOffsetEncoder().encode({ first: BigInt(offset) }),\n    ],\n  });\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for a confidential UTXO input buffer account.\n * Seeds: [ConfidentialUtxoProofAccount::SEED, depositor_pubkey, offset]\n *\n * An ephemeral buffer account that holds the Groth16 proof data required to\n * create a new confidential UTXO from an existing encrypted MXE balance.\n *\n * @param depositorAddress - The depositor's public key (account creator).\n * @param offset - The U128 offset discriminator.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findUtxoInputBufferPda } from \"@umbra-privacy/sdk\";\n *\n * const proofAccountPda = await findUtxoInputBufferPda(\n *   client.signer.address,\n *   offset as U128,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findVerifyingKeyPda} for the verifying key used to check this proof\n * @see {@link findClaimInputBufferPda} for the claim-side proof buffer\n *\n * @public\n */\nexport async function findUtxoInputBufferPda(\n  depositorAddress: Address,\n  offset: U128,\n  umbraProgram: Address,\n): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      CONFIDENTIAL_UTXO_PROOF_ACCOUNT_SEED,\n      getAddressEncoder().encode(depositorAddress),\n      getAccountOffsetEncoder().encode({ first: BigInt(offset) }),\n    ],\n  });\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for a public UTXO input buffer account.\n * Seeds: [PublicUtxoProofAccount::SEED, depositor_pubkey, offset]\n *\n * An ephemeral buffer account that holds cryptographic proof data for the\n * `create_deposit_into_mixer_tree_from_public_balance` instruction.\n *\n * @param depositorAddress - The depositor's public key (account creator).\n * @param offset - The U128 offset discriminator.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @public\n */\nexport async function findPublicUtxoInputBufferPda(\n  depositorAddress: Address,\n  offset: U128,\n  umbraProgram: Address,\n): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      PUBLIC_UTXO_PROOF_ACCOUNT_SEED,\n      getAddressEncoder().encode(depositorAddress),\n      getAccountOffsetEncoder().encode({ first: BigInt(offset) }),\n    ],\n  });\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for a public claim input buffer account.\n * Seeds: [PublicClaimProofAccount::SEED, relayer_pubkey, offset]\n *\n * An ephemeral buffer account that holds the Groth16 proof data for a\n * public-balance claim instruction (claiming UTXOs into a standard SPL\n * token ATA).\n *\n * @param relayerAddress - The relayer's public key (proof account creator).\n * @param offset - The U128 offset discriminator.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the derived PDA `Address`.\n *\n * @example\n * ```typescript\n * import { findPublicClaimInputBufferPda } from \"@umbra-privacy/sdk\";\n *\n * const proofAccountPda = await findPublicClaimInputBufferPda(\n *   relayerPublicKey,\n *   proofAccountOffset as U128,\n *   networkConfig.programId,\n * );\n * ```\n *\n * @see {@link findVerifyingKeyPda} for the verifying key used to check this proof\n * @see {@link findClaimInputBufferPda} for the confidential-balance claim variant\n * @see {@link findPublicClaimComputationDataPda} for the companion MPC callback data account\n *\n * @public\n */\nexport async function findPublicClaimInputBufferPda(\n  relayerAddress: Address,\n  offset: U128,\n  umbraProgram: Address,\n): Promise<Address> {\n  const [pda] = await getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      PUBLIC_CLAIM_PROOF_ACCOUNT_SEED,\n      getAddressEncoder().encode(relayerAddress),\n      getAccountOffsetEncoder().encode({ first: BigInt(offset) }),\n    ],\n  });\n  return pda;\n}\n\n/**\n * Derives the Program Derived Address for a public claim MPC computation data account.\n * Seeds: [PublicClaimMxeMpcCallbackData::SEED, relayer_pubkey, offset]\n *\n * Stores all data needed by the Arcium MPC callback handler for a public\n * claim instruction. Initialised in the handler and closed when the callback\n * executes.\n *\n * Returns the full `[address, bump]` tuple because the canonical bump must be\n * passed as the `mpcCallbackDataCanonicalBump` instruction argument.\n *\n * @param relayerAddress - The relayer's public key.\n * @param offset - The U128 offset discriminator.\n * @param umbraProgram - The Umbra program address.\n * @returns A Promise resolving to the `[pda, bump]` tuple.\n *\n * @example\n * ```typescript\n * import { findPublicClaimComputationDataPda } from \"@umbra-privacy/sdk\";\n *\n * const [callbackDataPda, mpcCallbackDataCanonicalBump] =\n *   await findPublicClaimComputationDataPda(\n *     relayerPublicKey,\n *     0n as U128,\n *     networkConfig.programId,\n *   );\n * ```\n *\n * @see {@link findPublicClaimInputBufferPda} for the companion proof buffer account\n *\n * @public\n */\nexport async function findPublicClaimComputationDataPda(\n  relayerAddress: Address,\n  offset: U128,\n  umbraProgram: Address,\n): Promise<readonly [Address, number]> {\n  return getProgramDerivedAddress({\n    programAddress: umbraProgram,\n    seeds: [\n      PUBLIC_CLAIM_MXE_MPC_CALLBACK_DATA_SEED,\n      getAddressEncoder().encode(relayerAddress),\n      getAccountOffsetEncoder().encode({ first: BigInt(offset) }),\n    ],\n  });\n}\n"]}

package/dist/chunk-NKVMSABR.cjs

@@ -0,0 +1,207 @@
+'use strict';
+
+var chunkPK6SKIKE_cjs = require('./chunk-PK6SKIKE.cjs');
+var kit = require('@solana/kit');
+
+var ENDPOINTS = {
+  /** Fetches relayer address, supported mints, and active stealth pool indices. */
+  RELAYER_INFO: `/v1/relayer/info`,
+  /** Submits a claim request (relayer builds transactions from crypto data). */
+  CLAIM_SUBMIT: `/v1/claims`,
+  /** Polls claim status by request ID. `{id}` is replaced at call time. */
+  CLAIM_STATUS: `/v1/claims/{id}`
+};
+var RelayerError = class _RelayerError extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "RelayerError");
+  }
+  /** The relayer operation that failed (e.g. `"getRelayerAddress"`, `"claimSubmit"`). */
+  operation;
+  /** HTTP status code if the server responded, `undefined` for transport errors. */
+  statusCode;
+  /** Machine-readable error code from the API error body. */
+  errorCode;
+  constructor(operation, message, statusCode, errorCode, cause) {
+    super(`Relayer operation '${operation}' failed: ${message}`);
+    this.name = "RelayerError";
+    this.operation = operation;
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+    this.cause = cause;
+    if (Error.captureStackTrace !== void 0) {
+      Error.captureStackTrace(this, _RelayerError);
+    }
+  }
+};
+async function makeRequest(endpoint, fetchImpl, options) {
+  const { method = "GET", body, operation } = options;
+  try {
+    const requestInit = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    };
+    if (body !== void 0) {
+      requestInit.body = JSON.stringify(body);
+    }
+    const response = await fetchImpl(endpoint, requestInit);
+    const data = await response.json();
+    if (!response.ok) {
+      const errorData = data;
+      const message = errorData.error?.message ?? errorData.message ?? `HTTP ${String(response.status)}`;
+      const code = errorData.error?.code ?? errorData.error_code;
+      throw new RelayerError(operation, message, response.status, code);
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof RelayerError) {
+      throw error;
+    }
+    throw new RelayerError(
+      operation,
+      error instanceof Error ? error.message : "Unknown error",
+      void 0,
+      void 0,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+chunkPK6SKIKE_cjs.__name(makeRequest, "makeRequest");
+function convertClaimStatusResponse(api) {
+  return {
+    requestId: api.request_id,
+    status: api.status,
+    variant: api.variant,
+    resolvedVariant: api.resolved_variant,
+    txSignature: api.tx_signature,
+    callbackSignature: api.callback_signature,
+    computationAccount: api.computation_account,
+    failureReason: api.failure_reason,
+    createdAt: api.created_at,
+    updatedAt: api.updated_at
+  };
+}
+chunkPK6SKIKE_cjs.__name(convertClaimStatusResponse, "convertClaimStatusResponse");
+function getUmbraRelayer(args, deps) {
+  const { apiEndpoint } = args;
+  const fetchImpl = deps?.fetch ?? globalThis.fetch;
+  if (apiEndpoint === "") {
+    throw new RelayerError("initialization", "apiEndpoint must be a non-empty string");
+  }
+  const normalizedEndpoint = apiEndpoint.replace(/\/$/, "");
+  let cachedAddress = null;
+  let cachedInfo = null;
+  async function fetchInfo() {
+    if (cachedInfo !== null) {
+      return cachedInfo;
+    }
+    const response = await makeRequest(
+      `${normalizedEndpoint}${ENDPOINTS.RELAYER_INFO}`,
+      fetchImpl,
+      { operation: "getRelayerInfo" }
+    );
+    cachedInfo = response;
+    cachedAddress = kit.address(response.address);
+    return response;
+  }
+  chunkPK6SKIKE_cjs.__name(fetchInfo, "fetchInfo");
+  return {
+    apiEndpoint: normalizedEndpoint,
+    async getFeePayer() {
+      if (cachedAddress !== null) {
+        return cachedAddress;
+      }
+      const info = await fetchInfo();
+      return kit.address(info.address);
+    },
+    async getRelayerAddress() {
+      if (cachedAddress !== null) {
+        return cachedAddress;
+      }
+      const info = await fetchInfo();
+      return kit.address(info.address);
+    },
+    async getSupportedMints() {
+      const info = await fetchInfo();
+      return {
+        relayer: info.address,
+        mints: info.supported_mints,
+        count: BigInt(info.supported_mints.length)
+      };
+    },
+    async submitClaim(request) {
+      const response = await makeRequest(
+        `${normalizedEndpoint}${ENDPOINTS.CLAIM_SUBMIT}`,
+        fetchImpl,
+        { method: "POST", body: request, operation: "claimSubmit" }
+      );
+      return {
+        requestId: response.request_id,
+        status: response.status
+      };
+    },
+    async pollClaimStatus(requestId) {
+      const url = `${normalizedEndpoint}${ENDPOINTS.CLAIM_STATUS.replace("{id}", requestId)}`;
+      const response = await makeRequest(url, fetchImpl, {
+        operation: "claimStatus"
+      });
+      return convertClaimStatusResponse(response);
+    }
+  };
+}
+chunkPK6SKIKE_cjs.__name(getUmbraRelayer, "getUmbraRelayer");
+var TERMINAL_CLAIM_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "timed_out"
+]);
+async function pollClaimUntilTerminal(pollClaimStatus, requestId, options) {
+  const pollingIntervalMs = options?.pollingIntervalMs ?? 3e3;
+  const timeoutMs = options?.timeoutMs ?? 12e4;
+  const onProgress = options?.onProgress;
+  const startTime = Date.now();
+  while (true) {
+    const status = await pollClaimStatus(requestId);
+    if (onProgress !== void 0) {
+      onProgress({
+        requestId: status.requestId,
+        status: status.status,
+        resolvedVariant: status.resolvedVariant,
+        txSignature: status.txSignature,
+        callbackSignature: status.callbackSignature,
+        failureReason: status.failureReason
+      });
+    }
+    if (TERMINAL_CLAIM_STATUSES.has(status.status)) {
+      const result = {
+        requestId: status.requestId,
+        status: status.status,
+        txSignature: status.txSignature,
+        callbackSignature: status.callbackSignature,
+        resolvedVariant: status.resolvedVariant,
+        failureReason: status.failureReason
+      };
+      return result;
+    }
+    if (Date.now() - startTime >= timeoutMs) {
+      const timedOutResult = {
+        requestId: status.requestId,
+        status: "timed_out",
+        failureReason: `Polling timed out after ${String(timeoutMs)}ms (last status: ${String(status.status)})`
+      };
+      return timedOutResult;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, pollingIntervalMs);
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(pollClaimUntilTerminal, "pollClaimUntilTerminal");
+
+exports.RelayerError = RelayerError;
+exports.getUmbraRelayer = getUmbraRelayer;
+exports.pollClaimUntilTerminal = pollClaimUntilTerminal;
+//# sourceMappingURL=chunk-NKVMSABR.cjs.map
+//# sourceMappingURL=chunk-NKVMSABR.cjs.map

package/dist/chunk-NKVMSABR.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/umbra/relayer.ts"],"names":["__name","address"],"mappings":"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","file":"chunk-NKVMSABR.cjs","sourcesContent":["/**\n * Relayer Module (V2 API).\n *\n * @remarks\n * This module provides the `getUmbraRelayer` factory for creating relayer instances\n * that interact with the Umbra relayer's V2 API. The relayer builds, signs, and\n * submits claim transactions on behalf of users.\n *\n * **What is the Relayer?**\n * The Umbra relayer is a semi-trusted intermediary that submits privacy-preserving\n * transactions on behalf of users. It receives cryptographic data (ZK proofs,\n * nullifiers, linker encryptions) and builds all Solana transactions server-side.\n *\n * **Trust Model (Semi-Trusted):**\n * The relayer is SEMI-TRUSTED. It can observe transaction contents (amounts,\n * mints, timing) because it must broadcast them. However, it CANNOT:\n * - Steal funds — ZK proofs and nullifier commitments prevent double-spending\n * - Forge signatures — Transactions use cryptographic commitments verified on-chain\n * - Link sender to recipient — Merkle commitments and ZK proofs sever that link\n *\n * **API Endpoints Used:**\n * - `GET /v1/relayer/info` — Get relayer address, supported mints, active pools\n * - `POST /v1/claims` — Submit a claim request (relayer builds transactions)\n * - `GET /v1/claims/{id}` — Poll claim status\n *\n * @packageDocumentation\n */\n\nimport { address, type Address } from \"@solana/kit\";\nimport type { U32 } from \"../types\";\nimport type {\n  IUmbraRelayer,\n  GetUmbraRelayerArgs,\n  GetUmbraRelayerDeps,\n  SupportedMintsResponse,\n  ClaimRequest,\n  ClaimSubmitResponse,\n  ClaimStatusResponse,\n  ClaimStatus,\n  ClaimBatchResult,\n} from \"./interfaces\";\n\n// ============================================================================\n// Constants\n// ============================================================================\n\n/**\n * Canonical endpoint paths for all relayer API operations.\n * @internal\n */\nconst ENDPOINTS = {\n  /** Fetches relayer address, supported mints, and active stealth pool indices. */\n  RELAYER_INFO: `/v1/relayer/info`,\n  /** Submits a claim request (relayer builds transactions from crypto data). */\n  CLAIM_SUBMIT: `/v1/claims`,\n  /** Polls claim status by request ID. `{id}` is replaced at call time. */\n  CLAIM_STATUS: `/v1/claims/{id}`,\n} as const;\n\n// ============================================================================\n// Error Class\n// ============================================================================\n\n/**\n * Error class for relayer-related failures.\n *\n * @remarks\n * Thrown when relayer API calls fail due to network issues, invalid responses,\n * transaction rejections, or server errors. Provides structured fields for\n * programmatic error handling.\n *\n * @public\n */\nexport class RelayerError extends Error {\n  /** The relayer operation that failed (e.g. `\"getRelayerAddress\"`, `\"claimSubmit\"`). */\n  public readonly operation: string;\n  /** HTTP status code if the server responded, `undefined` for transport errors. */\n  public readonly statusCode: number | undefined;\n  /** Machine-readable error code from the API error body. */\n  public readonly errorCode: string | undefined;\n\n  constructor(\n    operation: string,\n    message: string,\n    statusCode?: number,\n    errorCode?: string,\n    cause?: Error,\n  ) {\n    super(`Relayer operation '${operation}' failed: ${message}`);\n    this.name = \"RelayerError\";\n    this.operation = operation;\n    this.statusCode = statusCode;\n    this.errorCode = errorCode;\n    this.cause = cause;\n\n    if (Error.captureStackTrace !== undefined) {\n      Error.captureStackTrace(this, RelayerError);\n    }\n  }\n}\n\n// ============================================================================\n// Internal Types (API Response Shapes)\n// ============================================================================\n\n/** @internal */\ninterface ApiErrorResponse {\n  error?: {\n    code: string;\n    message: string;\n  };\n  success?: false;\n  error_code?: string;\n  message?: string;\n}\n\n/** Shape of `GET /v1/relayer/info` response. @internal */\ninterface ApiRelayerInfoResponse {\n  address: string;\n  supported_mints: string[];\n  active_stealth_pool_indices: string[];\n}\n\n/** Shape of `POST /v1/claims` response. @internal */\ninterface ApiClaimSubmitResponse {\n  request_id: string;\n  status: \"received\";\n}\n\n/** Shape of `GET /v1/claims/{id}` response. @internal */\ninterface ApiClaimStatusResponse {\n  request_id: string;\n  status: string;\n  variant: string;\n  resolved_variant?: string;\n  tx_signature?: string;\n  callback_signature?: string;\n  computation_account?: string;\n  failure_reason?: string | null;\n  created_at: string;\n  updated_at: string;\n}\n\n// ============================================================================\n// Internal Helpers\n// ============================================================================\n\n/**\n * Generic HTTP request helper with structured error handling.\n * @internal\n */\nasync function makeRequest<T>(\n  endpoint: string,\n  fetchImpl: typeof globalThis.fetch,\n  options: {\n    method?: \"GET\" | \"POST\";\n    body?: unknown;\n    operation: string;\n  },\n): Promise<T> {\n  const { method = \"GET\", body, operation } = options;\n\n  try {\n    const requestInit: RequestInit = {\n      method,\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Accept: \"application/json\",\n      },\n    };\n    if (body !== undefined) {\n      requestInit.body = JSON.stringify(body);\n    }\n    const response = await fetchImpl(endpoint, requestInit);\n\n    const data = (await response.json()) as T | ApiErrorResponse;\n\n    if (!response.ok) {\n      const errorData = data as ApiErrorResponse;\n      const message =\n        errorData.error?.message ?? errorData.message ?? `HTTP ${String(response.status)}`;\n      const code = errorData.error?.code ?? errorData.error_code;\n      throw new RelayerError(operation, message, response.status, code);\n    }\n\n    return data as T;\n  } catch (error) {\n    if (error instanceof RelayerError) {\n      throw error;\n    }\n    throw new RelayerError(\n      operation,\n      error instanceof Error ? error.message : \"Unknown error\",\n      undefined,\n      undefined,\n      error instanceof Error ? error : undefined,\n    );\n  }\n}\n\n/** Converts wire-format claim status response to SDK type. @internal */\nfunction convertClaimStatusResponse(api: ApiClaimStatusResponse): ClaimStatusResponse {\n  return {\n    requestId: api.request_id,\n    status: api.status as ClaimStatus,\n    variant: api.variant as ClaimStatusResponse[\"variant\"],\n    resolvedVariant: api.resolved_variant,\n    txSignature: api.tx_signature,\n    callbackSignature: api.callback_signature,\n    computationAccount: api.computation_account,\n    failureReason: api.failure_reason,\n    createdAt: api.created_at,\n    updatedAt: api.updated_at,\n  };\n}\n\n// ============================================================================\n// Core Relayer Factory\n// ============================================================================\n\n/**\n * Creates an Umbra relayer instance.\n *\n * @remarks\n * The returned `IUmbraRelayer` object provides all methods needed by claim\n * services: relayer info, claim submission, and status polling. Pass it\n * directly as the `relayer` dependency to any claim function.\n *\n * **Address caching:**\n * `getRelayerAddress()` and `getFeePayer()` cache the result after the first\n * HTTP call. The cache is per-instance.\n *\n * @param args - Required arguments\n * @param args.apiEndpoint - The base URL of the relayer API\n * @param deps - Optional dependencies for testing\n * @param deps.fetch - Custom fetch implementation; defaults to `globalThis.fetch`\n * @returns An {@link IUmbraRelayer} instance\n *\n * @example\n * ```typescript\n * const relayer = getUmbraRelayer({ apiEndpoint: \"https://relayer.umbra.finance\" });\n *\n * // Use directly with claim functions\n * const claim = getSelfClaimableUtxoToEncryptedBalanceClaimerFunction(\n *   { client },\n *   { zkProver, relayer },\n * );\n * ```\n *\n * @public\n */\nexport function getUmbraRelayer(\n  args: GetUmbraRelayerArgs,\n  deps?: GetUmbraRelayerDeps,\n): IUmbraRelayer {\n  const { apiEndpoint } = args;\n  const fetchImpl = deps?.fetch ?? globalThis.fetch;\n\n  if (apiEndpoint === \"\") {\n    throw new RelayerError(\"initialization\", \"apiEndpoint must be a non-empty string\");\n  }\n\n  const normalizedEndpoint = apiEndpoint.replace(/\\/$/, \"\");\n\n  // Shared cache for relayer address (used by both getFeePayer and getRelayerAddress)\n  let cachedAddress: Address | null = null;\n  let cachedInfo: ApiRelayerInfoResponse | null = null;\n\n  async function fetchInfo(): Promise<ApiRelayerInfoResponse> {\n    if (cachedInfo !== null) {\n      return cachedInfo;\n    }\n    const response = await makeRequest<ApiRelayerInfoResponse>(\n      `${normalizedEndpoint}${ENDPOINTS.RELAYER_INFO}`,\n      fetchImpl,\n      { operation: \"getRelayerInfo\" },\n    );\n    cachedInfo = response;\n    cachedAddress = address(response.address);\n    return response;\n  }\n\n  return {\n    apiEndpoint: normalizedEndpoint,\n\n    async getFeePayer(): Promise<Address> {\n      if (cachedAddress !== null) {\n        return cachedAddress;\n      }\n      const info = await fetchInfo();\n      return address(info.address);\n    },\n\n    async getRelayerAddress(): Promise<Address> {\n      if (cachedAddress !== null) {\n        return cachedAddress;\n      }\n      const info = await fetchInfo();\n      return address(info.address);\n    },\n\n    async getSupportedMints(): Promise<SupportedMintsResponse> {\n      const info = await fetchInfo();\n      return {\n        relayer: info.address,\n        mints: info.supported_mints,\n        count: BigInt(info.supported_mints.length) as U32,\n      };\n    },\n\n    async submitClaim(request: ClaimRequest): Promise<ClaimSubmitResponse> {\n      const response = await makeRequest<ApiClaimSubmitResponse>(\n        `${normalizedEndpoint}${ENDPOINTS.CLAIM_SUBMIT}`,\n        fetchImpl,\n        { method: \"POST\", body: request, operation: \"claimSubmit\" },\n      );\n      return {\n        requestId: response.request_id,\n        status: response.status,\n      };\n    },\n\n    async pollClaimStatus(requestId: string): Promise<ClaimStatusResponse> {\n      const url = `${normalizedEndpoint}${ENDPOINTS.CLAIM_STATUS.replace(\"{id}\", requestId)}`;\n      const response = await makeRequest<ApiClaimStatusResponse>(url, fetchImpl, {\n        operation: \"claimStatus\",\n      });\n      return convertClaimStatusResponse(response);\n    },\n  };\n}\n\n// ============================================================================\n// Claim Polling Utility\n// ============================================================================\n\n/**\n * Terminal claim statuses. Polling stops when the status matches one of these.\n * @internal\n */\nconst TERMINAL_CLAIM_STATUSES: ReadonlySet<ClaimStatus> = new Set([\n  \"completed\",\n  \"failed\",\n  \"timed_out\",\n]);\n\n/**\n * Polls a claim request until it reaches a terminal status or times out.\n *\n * @remarks\n * Terminal statuses are: `completed`, `failed`, `timed_out`.\n * The `onProgress` callback is invoked after each poll with the latest status.\n *\n * @param pollClaimStatus - Function to poll claim status\n * @param requestId - The claim request ID to poll\n * @param options - Polling configuration\n * @returns The final {@link ClaimBatchResult}\n *\n * @public\n */\nexport async function pollClaimUntilTerminal(\n  pollClaimStatus: (requestId: string) => Promise<ClaimStatusResponse>,\n  requestId: string,\n  options?: {\n    pollingIntervalMs?: number;\n    timeoutMs?: number;\n    onProgress?: (event: {\n      readonly requestId: string;\n      readonly status: ClaimStatus;\n      readonly resolvedVariant?: string;\n      readonly txSignature?: string;\n      readonly callbackSignature?: string;\n      readonly failureReason?: string | null;\n    }) => void;\n  },\n): Promise<ClaimBatchResult> {\n  const pollingIntervalMs: number = options?.pollingIntervalMs ?? 3000;\n  const timeoutMs: number = options?.timeoutMs ?? 120_000;\n  const onProgress = options?.onProgress;\n\n  const startTime: number = Date.now();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- polling loop\n  while (true) {\n    const status: ClaimStatusResponse = await pollClaimStatus(requestId);\n\n    if (onProgress !== undefined) {\n      onProgress({\n        requestId: status.requestId,\n        status: status.status,\n        resolvedVariant: status.resolvedVariant,\n        txSignature: status.txSignature,\n        callbackSignature: status.callbackSignature,\n        failureReason: status.failureReason,\n      });\n    }\n\n    if (TERMINAL_CLAIM_STATUSES.has(status.status)) {\n      const result: ClaimBatchResult = {\n        requestId: status.requestId,\n        status: status.status,\n        txSignature: status.txSignature,\n        callbackSignature: status.callbackSignature,\n        resolvedVariant: status.resolvedVariant,\n        failureReason: status.failureReason,\n      };\n      return result;\n    }\n\n    if (Date.now() - startTime >= timeoutMs) {\n      const timedOutResult: ClaimBatchResult = {\n        requestId: status.requestId,\n        status: \"timed_out\" as ClaimStatus,\n        failureReason: `Polling timed out after ${String(timeoutMs)}ms (last status: ${String(status.status)})`,\n      };\n      return timedOutResult;\n    }\n\n    await new Promise<void>((resolve) => {\n      setTimeout(resolve, pollingIntervalMs);\n    });\n  }\n}\n"]}

package/dist/chunk-OFDWNWCL.js

@@ -0,0 +1,70 @@
+import { BN254_FIELD_PRIME, assertBn254FieldElement } from './chunk-WN75ORDT.js';
+import { CryptographyError } from './chunk-5KPQXPQM.js';
+import { __name } from './chunk-7QVYU63E.js';
+
+// src/math/bn254/operations.ts
+function modulePow(base, exp, modulus) {
+  if (modulus === 1n) {
+    return 0n;
+  }
+  let result = 1n;
+  base = (base % modulus + modulus) % modulus;
+  while (exp > 0n) {
+    if (exp % 2n === 1n) {
+      result = result * base % modulus;
+    }
+    exp = exp >> 1n;
+    base = base * base % modulus;
+  }
+  return result;
+}
+__name(modulePow, "modulePow");
+function computeBn254ModularInverse(value) {
+  const normalizedValue = (BigInt(value) % BN254_FIELD_PRIME + BN254_FIELD_PRIME) % BN254_FIELD_PRIME;
+  if (normalizedValue === 0n) {
+    throw new CryptographyError("Cannot compute inverse of zero in BN254 field");
+  }
+  const inverse = modulePow(normalizedValue, BN254_FIELD_PRIME - 2n, BN254_FIELD_PRIME);
+  assertBn254FieldElement(inverse, "inverse");
+  return inverse;
+}
+__name(computeBn254ModularInverse, "computeBn254ModularInverse");
+function computeBn254LimbwiseSumInverse(limbs) {
+  const sum = (BigInt(limbs[0]) + BigInt(limbs[1]) + BigInt(limbs[2])) % BN254_FIELD_PRIME;
+  if (sum === 0n) {
+    throw new CryptographyError("Cannot compute inverse: sum of limbs is zero");
+  }
+  const inverse = modulePow(sum, BN254_FIELD_PRIME - 2n, BN254_FIELD_PRIME);
+  assertBn254FieldElement(inverse, "inverse");
+  return inverse;
+}
+__name(computeBn254LimbwiseSumInverse, "computeBn254LimbwiseSumInverse");
+function bn254ModuloPow(base, exp) {
+  const result = modulePow(BigInt(base), exp, BN254_FIELD_PRIME);
+  assertBn254FieldElement(result, "result");
+  return result;
+}
+__name(bn254ModuloPow, "bn254ModuloPow");
+function bn254Add(a, b) {
+  const result = (BigInt(a) + BigInt(b)) % BN254_FIELD_PRIME;
+  assertBn254FieldElement(result, "result");
+  return result;
+}
+__name(bn254Add, "bn254Add");
+function bn254Sub(a, b) {
+  const diff = BigInt(a) - BigInt(b);
+  const result = (diff % BN254_FIELD_PRIME + BN254_FIELD_PRIME) % BN254_FIELD_PRIME;
+  assertBn254FieldElement(result, "result");
+  return result;
+}
+__name(bn254Sub, "bn254Sub");
+function bn254Mul(a, b) {
+  const result = BigInt(a) * BigInt(b) % BN254_FIELD_PRIME;
+  assertBn254FieldElement(result, "result");
+  return result;
+}
+__name(bn254Mul, "bn254Mul");
+
+export { bn254Add, bn254ModuloPow, bn254Mul, bn254Sub, computeBn254LimbwiseSumInverse, computeBn254ModularInverse };
+//# sourceMappingURL=chunk-OFDWNWCL.js.map
+//# sourceMappingURL=chunk-OFDWNWCL.js.map

package/dist/chunk-OFDWNWCL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/bn254/operations.ts"],"names":[],"mappings":"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","file":"chunk-OFDWNWCL.js","sourcesContent":["/**\n * BN254 Field Operations Module\n *\n * This module provides higher-level arithmetic operations over the BN254 scalar\n * field F_r, including modular exponentiation, multiplicative inverse computation,\n * and the basic field operations (add, subtract, multiply). These functions build\n * on the branded type system defined in `types.ts` and are intended for use in\n * cryptographic protocols such as Groth16 proof generation, Fiat-Shamir challenges,\n * and ZK circuit witness computation.\n *\n * @remarks\n * ## BN254 and the Scalar Field\n *\n * The BN254 curve (also known as alt_bn128 or bn256) is a pairing-friendly\n * elliptic curve whose scalar field has prime order:\n * ```\n * r = 21888242871839275222246405745257275088548364400416034343698204186575808495617\n * ```\n * All operations in this module reduce their results modulo `r`, ensuring that\n * outputs are always valid field elements in the range `[0, r-1]`.\n *\n * ## Performance Characteristics\n *\n * - `bn254Add`, `bn254Sub`, `bn254Mul`: O(1) — single BigInt operation + reduction\n * - `bn254ModuloPow`: O(log exp) squarings and multiplications via square-and-multiply\n * - `computeBn254ModularInverse`: O(log p) — Fermat exponentiation with p-2 as exponent\n * - `computeBn254LimbwiseSumInverse`: O(log p) — three additions followed by inversion\n *\n * ## Security Note\n *\n * The inverse functions use Fermat's Little Theorem (`a^(p-2) mod p`) rather than\n * the Extended Euclidean Algorithm. This choice trades a small performance overhead\n * for a simpler, more auditable implementation. The underlying `modulePow` helper\n * is intentionally non-constant-time (uses the `bigint` `%` operator internally);\n * for constant-time arithmetic, use the functions in `field-arithmetic.ts`.\n *\n * @see {@link ./field-arithmetic} Constant-time field arithmetic\n * @see {@link ./types} BN254 field element types and validation\n *\n * @packageDocumentation\n * @module math/bn254/operations\n */\n\nimport { type Bn254FieldElement, assertBn254FieldElement, BN254_FIELD_PRIME } from \"./types\";\nimport type { Base85Limb } from \"../../crypto/poseidon/types\";\nimport { CryptographyError } from \"../../crypto/errors\";\n\n/**\n * Computes modular exponentiation: `base^exp mod modulus` using the\n * square-and-multiply (binary exponentiation) algorithm.\n *\n * @remarks\n * This is a general-purpose helper used internally by the BN254-specific\n * exported functions. It handles negative bases by first normalizing to the\n * canonical representative in `[0, modulus - 1]` via `((base % modulus) + modulus) % modulus`.\n *\n * ## Algorithm: Square-and-Multiply\n *\n * The square-and-multiply algorithm achieves O(log exp) multiplications by\n * processing the bits of the exponent from least significant to most significant:\n * ```\n * result = 1\n * while exp > 0:\n *   if exp is odd: result = result * base mod modulus\n *   exp = exp >> 1\n *   base = base * base mod modulus\n * ```\n *\n * ## Special Case\n *\n * When `modulus === 1n`, all values are congruent to 0 modulo 1, so the function\n * immediately returns `0n`.\n *\n * @param base - The base value (any integer; negative values are normalized)\n * @param exp - The exponent (must be a non-negative `bigint`)\n * @param modulus - The modulus (must be a positive `bigint`)\n * @returns `base^exp mod modulus`, always in the range `[0, modulus - 1]`\n *\n * @example\n * ```typescript\n * // Internal usage — not exported. Used by bn254ModuloPow and the inverse functions.\n * const result = modulePow(2n, 10n, 1000n); // 1024 mod 1000 = 24\n * const fermat = modulePow(7n, BN254_FIELD_PRIME - 2n, BN254_FIELD_PRIME); // 7^-1 mod p\n * ```\n *\n * @internal\n */\nfunction modulePow(base: bigint, exp: bigint, modulus: bigint): bigint {\n  if (modulus === 1n) {\n    return 0n;\n  }\n  let result = 1n;\n  base = ((base % modulus) + modulus) % modulus;\n  while (exp > 0n) {\n    if (exp % 2n === 1n) {\n      result = (result * base) % modulus;\n    }\n    exp = exp >> 1n;\n    base = (base * base) % modulus;\n  }\n  return result;\n}\n\n/**\n * Computes the multiplicative inverse of a BN254 field element using\n * Fermat's Little Theorem.\n *\n * @remarks\n * ## Mathematical Background\n *\n * For a prime field F_p, every non-zero element `a` has a unique multiplicative\n * inverse `a^(-1)` satisfying:\n * ```\n * a * a^(-1) ≡ 1  (mod p)\n * ```\n *\n * By Fermat's Little Theorem, for prime `p` and `a != 0 (mod p)`:\n * ```\n * a^(p-1) ≡ 1  (mod p)\n * ```\n * Multiplying both sides by `a^(-1)`:\n * ```\n * a^(p-2) ≡ a^(-1)  (mod p)\n * ```\n *\n * This function evaluates `a^(p-2) mod p` via the square-and-multiply algorithm\n * in O(log p) field multiplications (approximately 254 squarings for BN254).\n *\n * ## Input Normalization\n *\n * The input is first normalized to its canonical representative in `[0, p-1]`\n * via double reduction. If the normalized value is `0n`, there is no inverse and\n * a `CryptographyError` is thrown.\n *\n * ## Complexity\n *\n * O(log p) ≈ O(254) field multiplications (squarings and multiplications via\n * the square-and-multiply algorithm on a 254-bit exponent `p-2`).\n *\n * @param value - The BN254 field element to invert. Must be non-zero in the field.\n * @returns The multiplicative inverse of `value` in `[1, BN254_FIELD_PRIME - 1]`.\n *\n * @throws {CryptographyError} If `value` is congruent to zero modulo the field prime,\n *   because zero has no multiplicative inverse in any field.\n *\n * @example\n * ```typescript\n * import {\n *   computeBn254ModularInverse,\n *   bn254Mul,\n *   BN254_FIELD_PRIME,\n * } from \"@umbra/sdk\";\n * import { assertBn254FieldElement } from \"@umbra/sdk\";\n *\n * const a = 12345n;\n * assertBn254FieldElement(a, \"a\");\n *\n * const aInv = computeBn254ModularInverse(a);\n *\n * // Verify: a * a^(-1) = 1 (mod p)\n * const product = bn254Mul(a, aInv);\n * console.log(product === 1n); // true\n *\n * // Division by a: b / a = b * a^(-1) mod p\n * const b = 99999n;\n * assertBn254FieldElement(b, \"b\");\n * const quotient = bn254Mul(b, aInv); // b / a mod p\n * ```\n *\n * @see {@link bn254ModuloPow} For general modular exponentiation in the BN254 field\n * @see {@link computeBn254LimbwiseSumInverse} For the inverse of a Base85 limb sum\n *\n * @public\n */\nexport function computeBn254ModularInverse(value: Bn254FieldElement): Bn254FieldElement {\n  // Ensure the value is in the field\n  const normalizedValue =\n    ((BigInt(value) % BN254_FIELD_PRIME) + BN254_FIELD_PRIME) % BN254_FIELD_PRIME;\n\n  if (normalizedValue === 0n) {\n    throw new CryptographyError(\"Cannot compute inverse of zero in BN254 field\");\n  }\n\n  // Use Fermat's Little Theorem: a^(-1) = a^(p-2) mod p\n  const inverse = modulePow(normalizedValue, BN254_FIELD_PRIME - 2n, BN254_FIELD_PRIME);\n\n  assertBn254FieldElement(inverse, \"inverse\");\n  return inverse;\n}\n\n/**\n * Computes the multiplicative inverse of the sum of three Base85 limbs in the\n * BN254 scalar field.\n *\n * @remarks\n * ## Context: Base85 Limb Representation\n *\n * In ZK circuits that use the Circom/Groth16 toolchain, 255-bit field element\n * inputs are commonly represented as three 85-bit limbs (sometimes called\n * \"Base85 limbs\") to allow efficient constraint generation. Each limb holds\n * a 85-bit chunk of the full value:\n * ```\n * full_value = limbs[0] + limbs[1] * 2^85 + limbs[2] * 2^170\n * ```\n *\n * ## Circuit Non-Zero Validation\n *\n * Proving that a value is non-zero in a ZK circuit requires the circuit to\n * supply the multiplicative inverse of that value as an auxiliary witness.\n * When the value is represented in limbwise form, the circuit sometimes needs\n * the inverse of the *sum of the limbs* rather than the inverse of the\n * reconstructed value. This function computes exactly that:\n * ```\n * sum = (limbs[0] + limbs[1] + limbs[2]) mod p\n * result = sum^(-1) mod p\n * ```\n *\n * ## Why Limbwise Sum Instead of Reconstructed Value?\n *\n * The sum `limbs[0] + limbs[1] + limbs[2]` is a cheaper operation in\n * the circuit compared to the full positional reconstruction\n * `limbs[0] + limbs[1]*2^85 + limbs[2]*2^170`. The sum-based non-zero check\n * works because if all three limbs are zero, their sum is also zero; otherwise\n * the sum is guaranteed to be non-zero (given the limb range constraints enforced\n * by the circuit).\n *\n * @param limbs - A tuple of three `Base85Limb` values: `[low, middle, high]`.\n *   Each limb must be in the range `[0, 2^85 - 1]`.\n * @returns The multiplicative inverse of `(limbs[0] + limbs[1] + limbs[2]) mod p`\n *   as a `Bn254FieldElement` in the range `[1, BN254_FIELD_PRIME - 1]`.\n *\n * @throws {CryptographyError} If the sum of all three limbs is congruent to zero\n *   modulo the BN254 field prime, meaning no inverse exists.\n *\n * @example\n * ```typescript\n * import {\n *   computeBn254LimbwiseSumInverse,\n *   BN254_FIELD_PRIME,\n * } from \"@umbra/sdk\";\n * import { assertBase85Limb } from \"@umbra/sdk\";\n *\n * const low  = 0x1234n;\n * const mid  = 0x5678n;\n * const high = 0x9ABCn;\n * assertBase85Limb(low,  \"low\");\n * assertBase85Limb(mid,  \"mid\");\n * assertBase85Limb(high, \"high\");\n *\n * const inverse = computeBn254LimbwiseSumInverse([low, mid, high]);\n *\n * // Verify: (low + mid + high) * inverse ≡ 1 (mod p)\n * const sum = (low + mid + high) % BN254_FIELD_PRIME;\n * const check = (sum * inverse) % BN254_FIELD_PRIME;\n * console.log(check === 1n); // true\n * ```\n *\n * @see {@link computeBn254ModularInverse} For inverting a single field element\n * @see {@link Base85Limb} The branded limb type from `crypto/poseidon/types`\n *\n * @public\n */\nexport function computeBn254LimbwiseSumInverse(\n  limbs: [Base85Limb, Base85Limb, Base85Limb],\n): Bn254FieldElement {\n  // Sum the limbs\n  const sum = (BigInt(limbs[0]) + BigInt(limbs[1]) + BigInt(limbs[2])) % BN254_FIELD_PRIME;\n\n  if (sum === 0n) {\n    throw new CryptographyError(\"Cannot compute inverse: sum of limbs is zero\");\n  }\n\n  // Compute the inverse\n  const inverse = modulePow(sum, BN254_FIELD_PRIME - 2n, BN254_FIELD_PRIME);\n\n  assertBn254FieldElement(inverse, \"inverse\");\n  return inverse;\n}\n\n/**\n * Computes modular exponentiation in the BN254 scalar field: `base^exp mod p`.\n *\n * @remarks\n * This is a type-safe wrapper around the internal `modulePow` helper that\n * constrains both the input and output to the BN254 scalar field. It delegates\n * to the square-and-multiply algorithm with O(log exp) multiplications.\n *\n * ## Typical Use Cases\n *\n * - Computing powers of a Fiat-Shamir challenge scalar\n * - Evaluating polynomial commitments at a challenge point\n * - Batch inversion via exponentiation (less efficient than Extended GCD but simpler)\n *\n * ## Exponent Sign\n *\n * The exponent must be a non-negative `bigint`. Negative exponents are not supported;\n * use `computeBn254ModularInverse` for `base^(-1)` and compose with `bn254ModuloPow`\n * for general negative powers.\n *\n * @param base - The base field element in `[0, BN254_FIELD_PRIME - 1]`.\n * @param exp - The non-negative integer exponent (a plain `bigint`, not necessarily in the field).\n * @returns `base^exp mod BN254_FIELD_PRIME` as a `Bn254FieldElement`.\n *\n * @example\n * ```typescript\n * import { bn254ModuloPow, assertBn254FieldElement } from \"@umbra/sdk\";\n *\n * const challenge = 999n;\n * assertBn254FieldElement(challenge, \"challenge\");\n *\n * // Compute challenge^3 mod p (evaluating a cubic polynomial coefficient)\n * const cubed = bn254ModuloPow(challenge, 3n);\n *\n * // Compute challenge^0 = 1 (identity)\n * const identity = bn254ModuloPow(challenge, 0n);\n * console.log(identity === 1n); // true\n * ```\n *\n * @see {@link computeBn254ModularInverse} For the special case exp = -1\n * @see {@link bn254Mul} For a single multiplication\n *\n * @public\n */\nexport function bn254ModuloPow(base: Bn254FieldElement, exp: bigint): Bn254FieldElement {\n  const result = modulePow(BigInt(base), exp, BN254_FIELD_PRIME);\n  assertBn254FieldElement(result, \"result\");\n  return result;\n}\n\n/**\n * Computes the sum of two BN254 scalar field elements modulo the field prime.\n *\n * @remarks\n * ## Formula\n *\n * ```\n * result = (a + b) mod BN254_FIELD_PRIME\n * ```\n *\n * Because both `a` and `b` are in `[0, p-1]`, their sum is in `[0, 2p-2]`,\n * which requires at most one modular reduction step. This is implemented directly\n * via JavaScript's `%` operator on `bigint`.\n *\n * ## Overflow Behavior\n *\n * JavaScript `bigint` arithmetic is arbitrary precision, so there is no risk of\n * overflow. The modular reduction always yields a result in `[0, p-1]`.\n *\n * @param a - First summand, a valid BN254 field element in `[0, BN254_FIELD_PRIME - 1]`.\n * @param b - Second summand, a valid BN254 field element in `[0, BN254_FIELD_PRIME - 1]`.\n * @returns `(a + b) mod BN254_FIELD_PRIME` as a `Bn254FieldElement`.\n *\n * @example\n * ```typescript\n * import { bn254Add, assertBn254FieldElement, BN254_FIELD_PRIME } from \"@umbra/sdk\";\n *\n * const a = 10n;\n * const b = 20n;\n * assertBn254FieldElement(a, \"a\");\n * assertBn254FieldElement(b, \"b\");\n *\n * const sum = bn254Add(a, b);\n * console.log(sum === 30n); // true\n *\n * // Demonstrates wraparound at the field boundary\n * const nearPrime = BN254_FIELD_PRIME - 1n;\n * assertBn254FieldElement(nearPrime, \"nearPrime\");\n * const wrapped = bn254Add(nearPrime, b);\n * // (p - 1 + 20) mod p = 19\n * console.log(wrapped === 19n); // true\n * ```\n *\n * @see {@link bn254Sub} For modular subtraction\n * @see {@link bn254Mul} For modular multiplication\n *\n * @public\n */\nexport function bn254Add(a: Bn254FieldElement, b: Bn254FieldElement): Bn254FieldElement {\n  const result = (BigInt(a) + BigInt(b)) % BN254_FIELD_PRIME;\n  assertBn254FieldElement(result, \"result\");\n  return result;\n}\n\n/**\n * Computes the difference of two BN254 scalar field elements modulo the field prime.\n *\n * @remarks\n * ## Formula\n *\n * ```\n * result = (a - b) mod BN254_FIELD_PRIME\n * ```\n *\n * Because `a - b` can be negative when `b > a`, the result is obtained by\n * adding the prime before taking the modulo to ensure canonicalization into\n * `[0, p-1]`:\n * ```\n * diff = a - b\n * result = ((diff % p) + p) % p\n * ```\n *\n * This pattern handles both the case where `a >= b` (no wrap-around needed)\n * and the case where `a < b` (wrap-around by adding `p`).\n *\n * @param a - Minuend, a valid BN254 field element in `[0, BN254_FIELD_PRIME - 1]`.\n * @param b - Subtrahend, a valid BN254 field element in `[0, BN254_FIELD_PRIME - 1]`.\n * @returns `(a - b) mod BN254_FIELD_PRIME` as a `Bn254FieldElement` in `[0, p-1]`.\n *\n * @example\n * ```typescript\n * import { bn254Sub, assertBn254FieldElement, BN254_FIELD_PRIME } from \"@umbra/sdk\";\n *\n * const a = 30n;\n * const b = 10n;\n * assertBn254FieldElement(a, \"a\");\n * assertBn254FieldElement(b, \"b\");\n *\n * const diff = bn254Sub(a, b);\n * console.log(diff === 20n); // true\n *\n * // Underflow wraps around the field prime\n * const small = 5n;\n * assertBn254FieldElement(small, \"small\");\n * const wrapped = bn254Sub(small, b);\n * // (5 - 10 + p) mod p = p - 5\n * console.log(wrapped === BN254_FIELD_PRIME - 5n); // true\n * ```\n *\n * @see {@link bn254Add} For modular addition\n * @see {@link bn254Mul} For modular multiplication\n *\n * @public\n */\nexport function bn254Sub(a: Bn254FieldElement, b: Bn254FieldElement): Bn254FieldElement {\n  const diff = BigInt(a) - BigInt(b);\n  const result = ((diff % BN254_FIELD_PRIME) + BN254_FIELD_PRIME) % BN254_FIELD_PRIME;\n  assertBn254FieldElement(result, \"result\");\n  return result;\n}\n\n/**\n * Computes the product of two BN254 scalar field elements modulo the field prime.\n *\n * @remarks\n * ## Formula\n *\n * ```\n * result = (a * b) mod BN254_FIELD_PRIME\n * ```\n *\n * Because both `a` and `b` are approximately 254-bit values, their product is\n * approximately 508 bits before reduction. JavaScript's `bigint` type handles\n * arbitrary precision arithmetic natively, so no overflow occurs. The result\n * is reduced to `[0, p-1]` via a single `%` operation.\n *\n * ## Performance Note\n *\n * This function uses JavaScript's built-in `bigint` multiplication, which is not\n * constant-time. For cryptographic contexts where timing side-channels are a\n * concern (e.g., secret-key operations), use `bn254ModuloMul` from\n * `field-arithmetic.ts` which uses constant-time Montgomery multiplication.\n *\n * @param a - First factor, a valid BN254 field element in `[0, BN254_FIELD_PRIME - 1]`.\n * @param b - Second factor, a valid BN254 field element in `[0, BN254_FIELD_PRIME - 1]`.\n * @returns `(a * b) mod BN254_FIELD_PRIME` as a `Bn254FieldElement`.\n *\n * @example\n * ```typescript\n * import { bn254Mul, assertBn254FieldElement, BN254_FIELD_PRIME } from \"@umbra/sdk\";\n *\n * const a = 7n;\n * const b = 8n;\n * assertBn254FieldElement(a, \"a\");\n * assertBn254FieldElement(b, \"b\");\n *\n * const product = bn254Mul(a, b);\n * console.log(product === 56n); // true\n *\n * // Product of two large field elements wraps around\n * const large = BN254_FIELD_PRIME - 1n;\n * assertBn254FieldElement(large, \"large\");\n * const result = bn254Mul(large, 2n as unknown as typeof large);\n * // (p - 1) * 2 mod p = p - 2\n * console.log(result === BN254_FIELD_PRIME - 2n); // true\n * ```\n *\n * @see {@link bn254Add} For modular addition\n * @see {@link bn254Sub} For modular subtraction\n * @see {@link computeBn254ModularInverse} For multiplicative inverse (division)\n *\n * @public\n */\nexport function bn254Mul(a: Bn254FieldElement, b: Bn254FieldElement): Bn254FieldElement {\n  const result = (BigInt(a) * BigInt(b)) % BN254_FIELD_PRIME;\n  assertBn254FieldElement(result, \"result\");\n  return result;\n}\n"]}