@umbra-privacy/sdk 2.1.1 → 3.0.0

package/dist/index.js

@@ -1,34 +1,82 @@
 export { RelayerError, getUmbraRelayer, pollClaimUntilTerminal } from './chunk-4RHXVBNI.js';
 import { getNetworkConfig, getNetworkSpecifier, getDefaultSchemeVersion, getDefaultAlgorithmVersion, getDefaultProtocolVersion, createSetComputeUnitLimitInstruction, TOKEN_2022_PROGRAM_ID, SPL_TOKEN_PROGRAM_ID } from './chunk-FQDYYTPG.js';
-import { getPoseidonAggregator, getPoseidonHasher, getAesDecryptor, getUserAccountX25519KeypairDeriver, deriveNullifierFromModifiedGenerationIndex, deriveRandomSecretFromModifiedGenerationIndex, deriveKeystreamBlindingFactor, getRescueEncryptorFromPrivateKey, getRescueKeyGeneratorFromPrivateKey, getRescueCommitmentGenerator, getModuloPowCurve25519Function, getPolynomialEvaluatorFunction, getMasterViewingKeyDeriver, getMasterViewingKeyBlindingFactorDeriver, getPoseidonPrivateKeyDeriver, getPoseidonBlindingFactorDeriver, getSecondViewingKeyDeriver, getPoseidonEncryptor, getPoseidonKeystreamGenerator, getUserCommitmentGeneratorFunction, getKeystreamCommitmentGenerator, getFiatShamirChallengeGeneratorFunction, expandModifiedGenerationIndex, getEphemeralUtxoMasterViewingKeyDeriver, getEphemeralUtxoMasterViewingKeyBlindingFactorDeriver, getEphemeralUtxoPoseidonPrivateKeyDeriver, getEphemeralUtxoPoseidonPrivateKeyBlindingFactorDeriver, getMasterViewingKeyX25519KeypairDeriver, getMintX25519KeypairDeriver, getPoseidonKeystreamBlindingFactorDeriver, getUtxoCommitmentHashGenerator, getChallengePowersFunction, getAesEncryptor, deriveProofAccountOffsetFromModifiedGenerationIndex, deriveRandomFactorForPolynomialCommitmentFromModifiedGenerationIndex, deriveRescueEncryptionCommitmentBlindingFactorFromModifiedGenerationIndex, getRescueCommitmentBlindingFactorDeriver, getPolynomialCommitmentFactorDeriver, getRescueEncryptorWithNonceFromPrivateKey, getRescueDecryptorFromPrivateKey } from './chunk-KMRROOME.js';
-export { AES_AUTH_TAG_LENGTH, AES_IV_LENGTH, AES_KEY_LENGTH, AES_METADATA_OVERHEAD, ALPHA, ALPHA_INVERSE, BASE85_LIMB_MAX, BLOCK_SIZE, CIPHER_ROUND_COUNT, FIELD_ELEMENT_BYTE_LENGTH, FIELD_PRIME, GROTH16_G1_BYTE_LENGTH, GROTH16_G2_BYTE_LENGTH, HASH_CAPACITY, HASH_DIGEST_LENGTH, HASH_RATE, HASH_ROUND_COUNT, HASH_STATE_SIZE, MASTER_VIEWING_KEY_MAX, MAX_AGGREGATOR_INPUTS, MAX_POSEIDON_INPUTS, MAX_PRF_SEEDS, NONCE_BYTES, OPTIONAL_DATA_BYTE_LENGTH, PRECOMPUTED_FIELD_INVERSES, REDUCTION_CONST, SAMPLE_BUFFER_BYTE_LENGTH, SECRET_BYTES, SHAKE256_CIPHER_SEED, X25519_BYTE_LENGTH, ZK_PROOF_BYTE_LENGTH, assertAesCiphertextWithMetadata, assertAesKey, assertAesPlaintext, assertBase85Limb, assertCurve25519KeypairResult, assertDailyViewingKey, assertEd25519Keypair, assertGenerationSeed, assertGroth16ProofA, assertGroth16ProofB, assertGroth16ProofC, assertHourlyViewingKey, assertKeccak256Hash, assertKeccak512Hash, assertMasterSeed, assertMasterViewingKey, assertMintViewingKey, assertMinuteViewingKey, assertMonthlyViewingKey, assertOptionalData32, assertPoseidonCiphertext, assertPoseidonCounter, assertPoseidonHash, assertPoseidonKey, assertPoseidonKeystream, assertPoseidonPlaintext, assertRcCiphertext, assertRcCounter, assertRcEncryptionNonce, assertRcKey, assertRcPlaintext, assertSecondViewingKey, assertSharedSecret, assertX25519Bytes, assertX25519Keypair, assertX25519PrivateKey, assertX25519PublicKey, assertYearlyViewingKey, assertZkProofBytes, buildPersonalizationString, defaultAesDecryptor, defaultAesEncryptor, deriveBn254FieldElementFromKeccak512, deriveEphemeralMasterViewingKey, deriveEphemeralMasterViewingKeyBlindingFactor, deriveEphemeralPoseidonPrivateKey, deriveEphemeralPoseidonPrivateKeyBlindingFactor, deriveKeystreamBlindingFactor, deriveModifiedGenerationIndexForReceiverClaim, deriveModifiedGenerationIndexForSenderClaim, deriveNullifierFromModifiedGenerationIndex, deriveProofAccountOffsetFromModifiedGenerationIndex, deriveRandomFactorForPolynomialCommitmentFromModifiedGenerationIndex, deriveRandomSecretFromModifiedGenerationIndex, deriveRescueEncryptionCommitmentBlindingFactorFromModifiedGenerationIndex, expandModifiedGenerationIndex, getAesDecryptor, getAesEncryptor, getBn254FieldElementFromKeccak512Deriver, getChallengePowersFunction, getDailyViewingKeyDeriver, getEphemeralMasterSeedDeriver, getEphemeralRescueCommitmentBlindingFactorDeriver, getEphemeralUtxoH2RandomSecretDeriver, getEphemeralUtxoMasterViewingKeyBlindingFactorDeriver, getEphemeralUtxoMasterViewingKeyDeriver, getEphemeralUtxoNullifierDeriver, getEphemeralUtxoPoseidonPrivateKeyBlindingFactorDeriver, getEphemeralUtxoPoseidonPrivateKeyDeriver, getFiatShamirChallengeGeneratorFunction, getFieldArithmetic, getHourlyViewingKeyDeriver, getKeystreamCommitmentGenerator, getMasterSeedBasedFieldElementDeriver, getMasterViewingKeyBlindingFactorDeriver, getMasterViewingKeyDeriver, getMasterViewingKeyX25519KeypairDeriver, getMintViewingKeyDeriver, getMintX25519KeypairDeriver, getMinuteViewingKeyDeriver, getModuloPowCurve25519Function, getMonthlyViewingKeyDeriver, getPersonalizationStringBuilder, getPolynomialCommitmentFactorDeriver, getPolynomialEvaluatorFunction, getPoseidonAggregator, getPoseidonBlindingFactorDeriver, getPoseidonDecryptor, getPoseidonEncryptor, getPoseidonHasher, getPoseidonKeystreamBlindingFactorDeriver, getPoseidonKeystreamGenerator, getPoseidonPrf, getPoseidonPrivateKeyDeriver, getPseudorandomU512Deriver, getRescueCipher, getRescueCipherFromKeyPair, getRescueCipherInstance, getRescueCommitmentBlindingFactorDeriver, getRescueCommitmentGenerator, getRescueDecryptorFromPrivateKey, getRescueEncryptorFromPrivateKey, getRescueEncryptorWithNonceFromPrivateKey, getRescueKeyGeneratorFromPrivateKey, getRescuePrimeHashFunction, getSecondViewingKeyDeriver, getUserAccountX25519KeypairDeriver, getUserCommitmentGeneratorFunction, getUtxoCommitmentHashGenerator, getYearlyViewingKeyDeriver } from './chunk-KMRROOME.js';
+import { getPoseidonAggregator, getPoseidonHasher, getAesDecryptor, getUserAccountX25519KeypairDeriver, deriveNullifierFromModifiedGenerationIndex, deriveRandomSecretFromModifiedGenerationIndex, deriveKeystreamBlindingFactor, getRescueEncryptorFromPrivateKey, getRescueKeyGeneratorFromPrivateKey, getRescueCommitmentGenerator, getModuloPowCurve25519Function, getPolynomialEvaluatorFunction, getMasterViewingKeyDeriver, getMasterViewingKeyBlindingFactorDeriver, getPoseidonPrivateKeyDeriver, getPoseidonBlindingFactorDeriver, getSecondViewingKeyDeriver, getPoseidonEncryptor, getPoseidonKeystreamGenerator, getUserCommitmentGeneratorFunction, getKeystreamCommitmentGenerator, getFiatShamirChallengeGeneratorFunction, expandModifiedGenerationIndex, getEphemeralUtxoMasterViewingKeyDeriver, getEphemeralUtxoMasterViewingKeyBlindingFactorDeriver, getEphemeralUtxoPoseidonPrivateKeyDeriver, getEphemeralUtxoPoseidonPrivateKeyBlindingFactorDeriver, getMasterViewingKeyX25519KeypairDeriver, getMintX25519KeypairDeriver, getPoseidonKeystreamBlindingFactorDeriver, getUtxoCommitmentHashGenerator, getChallengePowersFunction, getAesEncryptor, deriveProofAccountOffsetFromModifiedGenerationIndex, deriveRandomFactorForPolynomialCommitmentFromModifiedGenerationIndex, deriveRescueEncryptionCommitmentBlindingFactorFromModifiedGenerationIndex, getRescueCommitmentBlindingFactorDeriver, getPolynomialCommitmentFactorDeriver, getRescueEncryptorWithNonceFromPrivateKey, getRescueDecryptorFromPrivateKey } from './chunk-YA66JLHI.js';
+export { AES_AUTH_TAG_LENGTH, AES_IV_LENGTH, AES_KEY_LENGTH, AES_METADATA_OVERHEAD, ALPHA, ALPHA_INVERSE, BASE85_LIMB_MAX, BLOCK_SIZE, CIPHER_ROUND_COUNT, FIELD_ELEMENT_BYTE_LENGTH, FIELD_PRIME, GROTH16_G1_BYTE_LENGTH, GROTH16_G2_BYTE_LENGTH, HASH_CAPACITY, HASH_DIGEST_LENGTH, HASH_RATE, HASH_ROUND_COUNT, HASH_STATE_SIZE, MASTER_VIEWING_KEY_MAX, MAX_AGGREGATOR_INPUTS, MAX_POSEIDON_INPUTS, MAX_PRF_SEEDS, NONCE_BYTES, OPTIONAL_DATA_BYTE_LENGTH, PRECOMPUTED_FIELD_INVERSES, REDUCTION_CONST, SAMPLE_BUFFER_BYTE_LENGTH, SECRET_BYTES, SHAKE256_CIPHER_SEED, X25519_BYTE_LENGTH, ZK_PROOF_BYTE_LENGTH, assertAesCiphertextWithMetadata, assertAesKey, assertAesPlaintext, assertBase85Limb, assertCurve25519KeypairResult, assertDailyViewingKey, assertEd25519Keypair, assertGenerationSeed, assertGroth16ProofA, assertGroth16ProofB, assertGroth16ProofC, assertHourlyViewingKey, assertKeccak256Hash, assertKeccak512Hash, assertMasterSeed, assertMasterViewingKey, assertMintViewingKey, assertMinuteViewingKey, assertMonthlyViewingKey, assertOptionalData32, assertPoseidonCiphertext, assertPoseidonCounter, assertPoseidonHash, assertPoseidonKey, assertPoseidonKeystream, assertPoseidonPlaintext, assertRcCiphertext, assertRcCounter, assertRcEncryptionNonce, assertRcKey, assertRcPlaintext, assertSecondViewingKey, assertSharedSecret, assertX25519Bytes, assertX25519Keypair, assertX25519PrivateKey, assertX25519PublicKey, assertYearlyViewingKey, assertZkProofBytes, buildPersonalizationString, defaultAesDecryptor, defaultAesEncryptor, deriveBn254FieldElementFromKeccak512, deriveEphemeralMasterViewingKey, deriveEphemeralMasterViewingKeyBlindingFactor, deriveEphemeralPoseidonPrivateKey, deriveEphemeralPoseidonPrivateKeyBlindingFactor, deriveKeystreamBlindingFactor, deriveModifiedGenerationIndexForReceiverClaim, deriveModifiedGenerationIndexForSenderClaim, deriveNullifierFromModifiedGenerationIndex, deriveProofAccountOffsetFromModifiedGenerationIndex, deriveRandomFactorForPolynomialCommitmentFromModifiedGenerationIndex, deriveRandomSecretFromModifiedGenerationIndex, deriveRescueEncryptionCommitmentBlindingFactorFromModifiedGenerationIndex, expandModifiedGenerationIndex, getAesDecryptor, getAesEncryptor, getBn254FieldElementFromKeccak512Deriver, getChallengePowersFunction, getDailyViewingKeyDeriver, getEphemeralMasterSeedDeriver, getEphemeralRescueCommitmentBlindingFactorDeriver, getEphemeralUtxoH2RandomSecretDeriver, getEphemeralUtxoMasterViewingKeyBlindingFactorDeriver, getEphemeralUtxoMasterViewingKeyDeriver, getEphemeralUtxoNullifierDeriver, getEphemeralUtxoPoseidonPrivateKeyBlindingFactorDeriver, getEphemeralUtxoPoseidonPrivateKeyDeriver, getFiatShamirChallengeGeneratorFunction, getFieldArithmetic, getHourlyViewingKeyDeriver, getKeystreamCommitmentGenerator, getMasterSeedBasedFieldElementDeriver, getMasterViewingKeyBlindingFactorDeriver, getMasterViewingKeyDeriver, getMasterViewingKeyX25519KeypairDeriver, getMintViewingKeyDeriver, getMintX25519KeypairDeriver, getMinuteViewingKeyDeriver, getModuloPowCurve25519Function, getMonthlyViewingKeyDeriver, getPersonalizationStringBuilder, getPolynomialCommitmentFactorDeriver, getPolynomialEvaluatorFunction, getPoseidonAggregator, getPoseidonBlindingFactorDeriver, getPoseidonDecryptor, getPoseidonEncryptor, getPoseidonHasher, getPoseidonKeystreamBlindingFactorDeriver, getPoseidonKeystreamGenerator, getPoseidonPrf, getPoseidonPrivateKeyDeriver, getPseudorandomU512Deriver, getRescueCipher, getRescueCipherFromKeyPair, getRescueCipherInstance, getRescueCommitmentBlindingFactorDeriver, getRescueCommitmentGenerator, getRescueDecryptorFromPrivateKey, getRescueEncryptorFromPrivateKey, getRescueEncryptorWithNonceFromPrivateKey, getRescueKeyGeneratorFromPrivateKey, getRescuePrimeHashFunction, getSecondViewingKeyDeriver, getUserAccountX25519KeypairDeriver, getUserCommitmentGeneratorFunction, getUtxoCommitmentHashGenerator, getYearlyViewingKeyDeriver } from './chunk-YA66JLHI.js';
 import { splitAddressToLowHigh, createBn254FieldElement, createPoseidonKey, splitU256IntoTwoU128s, createRcPlaintext, splitX25519PublicKeyIntoTwoU128s, convertU256ToBase85Limbs, createU256, createCurve25519FieldElement, bigintToBinaryArrayLSB, generateRandomU256, generateRandomU128, createU64, extractClusterOffsetFromMxeAccount, generateRandomU64, extractTransferFeeConfig, calculateTransferFee, generateComputationOffset, extractUtcComponents, getByteAt } from './chunk-UXMQI6B7.js';
 import { findEncryptedUserAccountPda, findArciumInfrastructurePdas, findUserComplianceGrantPda, findNetworkComplianceGrantPda, findSharedComplianceGrantPda, findEncryptedTokenAccountPda, findStealthPoolPda, findUtxoInputBufferPda, findPublicUtxoInputBufferPda } from './chunk-KH3YTDKA.js';
 import './chunk-EEKF4553.js';
-import { ComputationMonitorError, FetchUtxosError, ClaimUtxoError, RpcError, ConversionError, TransactionSigningError, TransactionError, EncryptedDepositError, CreateUtxoError, QueryError, RegistrationError, MasterSeedSigningRejectedError, EncryptedWithdrawalError } from './chunk-GP26R377.js';
-export { ClaimUtxoError, ComputationMonitorError, ConversionError, CreateUtxoError, EncryptedDepositError, EncryptedWithdrawalError, FetchUtxosError, QueryError, RegistrationError, isClaimUtxoError, isComputationMonitorError, isConversionError, isCreateUtxoError, isEncryptedDepositError, isEncryptedWithdrawalError, isFetchUtxosError, isQueryError, isRegistrationError } from './chunk-GP26R377.js';
+import { ComputationMonitorError, FetchUtxosError, ClaimUtxoError, RpcError, ConversionError, TransactionSigningError, TransactionError, EncryptedDepositError, CreateUtxoError, QueryError, RegistrationError, MasterSeedSigningRejectedError, EncryptedWithdrawalError } from './chunk-AUNYA6JP.js';
+export { ClaimUtxoError, ComputationMonitorError, ConversionError, CreateUtxoError, EncryptedDepositError, EncryptedWithdrawalError, FetchUtxosError, QueryError, RegistrationError, isClaimUtxoError, isComputationMonitorError, isConversionError, isCreateUtxoError, isEncryptedDepositError, isEncryptedWithdrawalError, isFetchUtxosError, isQueryError, isRegistrationError } from './chunk-AUNYA6JP.js';
 import { computeBn254LimbwiseSumInverse, computeBn254ModularInverse } from './chunk-OFDWNWCL.js';
 export { bn254Add, bn254ModuloPow, bn254Mul, bn254Sub, computeBn254LimbwiseSumInverse, computeBn254ModularInverse } from './chunk-OFDWNWCL.js';
 import { bn254FieldElementSampler, getBn254ModularInverter, computeBn254LimbwiseSumInverse as computeBn254LimbwiseSumInverse$1 } from './chunk-WN75ORDT.js';
 export { bn254FieldElementSampler, curve25519FieldElementSampler, curve25519ModuloAdd, curve25519ModuloInv, curve25519ModuloMul, curve25519ModuloPow, curve25519ModuloSub, getBn254FieldElementSampler, getBn254ModularAdder, getBn254ModularInverter, getBn254ModularMultiplier, getBn254ModularNegator, getBn254ModularSubtractor, getCurve25519FieldElementSampler, getCurve25519ModularAddFunction, getCurve25519ModularInvFunction, getCurve25519ModularMulFunction, getCurve25519ModularPowFunction, getCurve25519ModularSubFunction } from './chunk-WN75ORDT.js';
 import './chunk-UOFYS6M3.js';
-import { decodeU128LeBytesToU128, decodeU64LeBytesToU64, encodeU256ToU256BeBytes, decodeU256BeBytesToU256, encodeU128ToU128LeBytes, encodeU256ToU256LeBytes, decodeU256LeBytesToU256, encodeU64ToU64LeBytes } from './chunk-FQX6ZYGJ.js';
+import { decodeU64LeBytesToU64, decodeU128LeBytesToU128, encodeU256ToU256BeBytes, decodeU256BeBytesToU256, encodeU128ToU128LeBytes, encodeU256ToU256LeBytes, decodeU256LeBytesToU256, encodeU64ToU64LeBytes } from './chunk-FQX6ZYGJ.js';
 import { CryptographyError } from './chunk-5KPQXPQM.js';
 import './chunk-4TZVXB5G.js';
 import { getRpcAccountInfoProvider, getRpcBlockhashProvider, getWebsocketTransactionForwarder, getRpcEpochInfoProvider, lookupAltEntry, buildAltAddressesRecord } from './chunk-HA5FLM63.js';
 export { createInMemorySigner, createSignerFromKeyPair, createSignerFromPrivateKeyBytes, createSignerFromWalletAccount, getPollingTransactionForwarder, getRpcAccountInfoProvider, getRpcBlockhashProvider, getRpcEpochInfoProvider, getWebsocketTransactionForwarder } from './chunk-HA5FLM63.js';
 import { base64ToUint8Array, sleep } from './chunk-TLR7A64G.js';
 import { assertTransactionSignature, assertYear, assertMonth, assertDay, assertHour, assertMinute, assertSecond } from './chunk-DD2WCK4C.js';
-import { assertMasterSeed, assertU256LeBytes, assertU128LeBytes, assertAesKey, assertX25519PrivateKey, assertU128, assertU256, MathematicsAssertionError, assertU64, assertBn254FieldElement, assertCurve25519FieldElement, assertRcEncryptionNonce, assertU512BeBytes, assertGroth16ProofA, assertGroth16ProofB, assertGroth16ProofC, assertOptionalData32, assertBase85Limb, assertPoseidonPlaintext, assertPoseidonKey, assertRcPlaintext, assertRcCiphertext, assertRcKey, assertAesPlaintext, assertX25519PublicKey, CURVE25519_FIELD_PRIME } from './chunk-CFTW5WNG.js';
+import { assertMasterSeed, assertAesKey, assertX25519PrivateKey, assertU128, assertU256, MathematicsAssertionError, assertU256LeBytes, assertU64, assertBn254FieldElement, assertCurve25519FieldElement, assertRcEncryptionNonce, assertU512BeBytes, assertGroth16ProofA, assertGroth16ProofB, assertGroth16ProofC, assertOptionalData32, assertBase85Limb, assertPoseidonPlaintext, assertPoseidonKey, assertRcPlaintext, assertRcCiphertext, assertRcKey, assertAesPlaintext, assertX25519PublicKey, CURVE25519_FIELD_PRIME } from './chunk-CFTW5WNG.js';
 import { __name } from './chunk-7QVYU63E.js';
 import { kmac256 } from '@noble/hashes/sha3-addons.js';
 import { createSolanaRpcSubscriptions, createSolanaRpc, getAddressDecoder, createKeyPairSignerFromPrivateKeyBytes, createNoopSigner, pipe, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, partiallySignTransactionMessageWithSigners, compressTransactionMessageUsingAddressLookupTables, getSignatureFromTransaction, getAddressEncoder, compileTransaction, fetchEncodedAccount } from '@solana/kit';
 import { getClaimComputationRentInstruction, decodeComputationAccount, ComputationStatus } from '@umbra-privacy/arcium-codama';
-import { ReadServiceClient } from '@umbra-privacy/indexer-read-service-client';
 import { x25519 } from '@noble/curves/ed25519.js';
 import { keccak_256 } from '@noble/hashes/sha3.js';
 import { getCreateUserGrantInstructionAsync, getDeleteUserGrantInstructionAsync, getReencryptUserGrantV11InstructionAsync, getReencryptNetworkGrantForNetworkBalanceV11InstructionAsync, getReencryptNetworkGrantForSharedBalanceV11InstructionAsync, decodeEncryptedTokenAccount, getConvertNetworkBalanceToSharedBalanceV11InstructionAsync, getReencryptSharedBalanceV11InstructionAsync, decodeEncryptedUserAccount, getResetSharedEncryptedTokenAccountQueueV11InstructionAsync, getResetNetworkEncryptedTokenAccountQueueV11InstructionAsync, getDepositFromPublicBalanceIntoExistingSharedBalanceV11InstructionAsync, getDepositFromPublicBalanceIntoNewSharedBalanceV11InstructionAsync, getDepositFromPublicBalanceIntoExistingNetworkBalanceV11InstructionAsync, getDepositFromPublicBalanceIntoNewNetworkBalanceV11InstructionAsync, getCloseStealthPoolDepositInputBufferInstructionAsync, getCreateStealthPoolDepositInputBufferInstructionAsync, getDepositIntoStealthPoolFromSharedBalanceV11InstructionAsync, getClosePublicStealthPoolDepositInputBufferInstructionAsync, getCreatePublicStealthPoolDepositInputBufferInstructionAsync, getDepositIntoStealthPoolFromPublicBalanceInstructionAsync, getClaimStagedSolFromPoolInstructionAsync, getClaimStagedSplFromPoolInstructionAsync, getEncryptedUserAccountSize, ENCRYPTED_USER_ACCOUNT_DISCRIMINATOR, getInitialiseEncryptedUserAccountInstructionAsync, getRegisterTokenPublicKeyInstructionAsync, getRegisterUserForAnonymousUsageV11InstructionAsync, getUpdateRandomGenerationSeedInstructionAsync, getUpdateTokenAccountRandomGenerationSeedInstructionAsync, getWithdrawFromSharedBalanceIntoPublicBalanceV11InstructionAsync } from '@umbra-privacy/umbra-codama';
 
+// src/umbra/constants.ts
+var UMBRA_MESSAGE_TO_SIGN = `Umbra Protocol – User Consent & Acknowledgement
+
+Please read carefully before continuing. Umbra is a non-custodial, open-source protocol. Umbra does not hold, control, manage, or access your digital assets, private keys, viewing keys, transactions, or personal data. All interactions with the Umbra protocol occur through autonomous smart contracts and wallet-signed transactions executed directly on the blockchain.
+
+By using the Umbra protocol, you acknowledge and agree that:
+
+1. You are solely responsible for managing your wallet, private keys, privacy settings, viewing key disclosures, and any transactions or interactions you authorize.
+2. Blockchain transactions are generally irreversible, and smart contracts may contain bugs, vulnerabilities, or unintended behavior.
+3. Errors, misuse, misconfiguration, third-party tools, relayers, or loss of keys may result in permanent and unrecoverable loss of assets or privacy.
+4. Privacy features are designed to enhance confidentiality but do not guarantee absolute or unconditional anonymity.
+5. Transactions may involve independent relayers or third-party infrastructure that Umbra does not operate, control, or supervise.
+6. By clicking "I Agree", you confirm that you have read, understood, and accepted all applicable terms, policies, risk disclosures, notices, and other documentation governing your access to and use of the Umbra protocol, as published or made available by Umbra from time to time.
+
+You acknowledge that such documentation may be updated or modified, and that continued access to or use of the Umbra Protocol constitutes acceptance of the then-current versions. If you do not agree, do not proceed and discontinue use of the Umbra protocol.`;
+var FEE_OFFSETS = {
+  /**
+   * Offset used in `FeeVault` PDA derivation for the unified protocol fees pool.
+   *
+   * @remarks
+   * Passed as the final seed to `findProtocolFeeVaultPda` and
+   * `findRelayerFeeVaultPda`. Currently `0n`.
+   *
+   * @readonly
+   */
+  PROTOCOL_FEES_POOL: 0n,
+  /**
+   * Offset used in `FeeSchedule` PDA derivation.
+   *
+   * @remarks
+   * Passed as the final seed to `findFeeSchedulePda`. Currently `0n`.
+   *
+   * @readonly
+   */
+  PROTOCOL_FEES_CONFIG: 0n,
+  /**
+   * Offset used in relayer fee configuration PDA derivation.
+   *
+   * @remarks
+   * Passed as the offset seed when looking up the relayer's fee configuration account.
+   * Currently `0n`.
+   *
+   * @readonly
+   */
+  RELAYER_FEES_CONFIG: 0n
+};
+var BPS_DIVISOR = 16384n;
+
+// src/common/storage.ts
 function getDefaultMasterSeedStorage() {
   let cachedSeed = null;
   return {
@@ -49,8 +97,7 @@ var MASTER_SEED_DOMAIN = new TextEncoder().encode("Umbra Privacy - MasterSeedGen
 var SEED_PERSONALIZATION = new TextEncoder().encode("umbra/1.0.0|kmac256/1.0.0|kdf/1.0.0|seed");
 function getDefaultMasterSeedGenerator(signer) {
   return async () => {
-    const message = `Umbra Privacy - Master Seed Generation - ${signer.address}`;
-    const messageBytes = new TextEncoder().encode(message);
+    const messageBytes = new TextEncoder().encode(UMBRA_MESSAGE_TO_SIGN);
     const signature = await signer.signMessage(messageBytes);
     const seed = kmac256(
       MASTER_SEED_DOMAIN,
@@ -96,7 +143,10 @@ function notificationValueToEncodedAccount(address, value) {
 __name(notificationValueToEncodedAccount, "notificationValueToEncodedAccount");
 function checkAborted(signal) {
   if (signal?.aborted) {
-    throw new ComputationMonitorError("timeout", "Computation monitoring cancelled via AbortSignal");
+    throw new ComputationMonitorError(
+      "timeout",
+      "Computation monitoring cancelled via AbortSignal"
+    );
   }
 }
 __name(checkAborted, "checkAborted");
@@ -158,6 +208,13 @@ function buildPrunedResult(startTime, queuedSlot, currentSlot, onProgress) {
   };
 }
 __name(buildPrunedResult, "buildPrunedResult");
+function buildTimedOutResult(startTime) {
+  return {
+    status: "timed-out",
+    elapsedMs: Date.now() - startTime
+  };
+}
+__name(buildTimedOutResult, "buildTimedOutResult");
 function getWebsocketComputationMonitor(config, deps) {
   const { rpcUrl, rpcSubscriptionsUrl } = config;
   const {
@@ -166,7 +223,7 @@ function getWebsocketComputationMonitor(config, deps) {
   } = deps ?? {};
   const rpc = createRpc(rpcUrl);
   const rpcSubscriptions = createRpcSubscriptions(rpcSubscriptionsUrl);
-  async function monitorComputation(computationAddress, options) {
+  async function prepareMonitor(computationAddress, options) {
     const {
       maxSlotWindow = DEFAULT_MAX_SLOT_WINDOW,
       safetyTimeoutMs = DEFAULT_SAFETY_TIMEOUT_MS,
@@ -175,126 +232,128 @@ function getWebsocketComputationMonitor(config, deps) {
       commitment = "confirmed",
       signal: externalSignal
     } = options ?? {};
-    const startTime = Date.now();
-    let queuedSlot = null;
-    try {
-      const currentAccount = await fetchEncodedAccount(rpc, computationAddress, { commitment });
-      if (currentAccount.exists) {
-        const decoded = decodeComputationAccount(currentAccount);
-        queuedSlot = decoded.data.slot;
-        if (decoded.data.status === ComputationStatus.Finalized) {
-          return buildFinalizedResult(
-            rpc,
-            computationAddress,
-            startTime,
-            queuedSlot,
-            shouldRetrieveSignature,
-            onProgress
-          );
-        }
-        onProgress?.({ type: "queued", queuedSlot });
-        const currentSlot = await fetchCurrentSlot(rpc, commitment);
-        if (isSlotWindowExceeded(queuedSlot, currentSlot, maxSlotWindow)) {
-          return buildPrunedResult(startTime, queuedSlot, currentSlot, onProgress);
-        }
-      }
-    } catch (error) {
-      if (error instanceof ComputationMonitorError) {
-        throw error;
-      }
-    }
-    checkAborted(externalSignal);
     const abortController = new AbortController();
-    const safetyTimeoutId = setTimeout(() => abortController.abort(), safetyTimeoutMs);
-    const onExternalAbort = /* @__PURE__ */ __name(() => abortController.abort(), "onExternalAbort");
-    externalSignal?.addEventListener("abort", onExternalAbort, { once: true });
-    let slotCheckIntervalId = null;
-    let pruneDetected = null;
-    if (queuedSlot !== null) {
-      const capturedQueuedSlot = queuedSlot;
-      slotCheckIntervalId = setInterval(async () => {
-        try {
-          const currentSlot = await fetchCurrentSlot(rpc, commitment);
-          if (isSlotWindowExceeded(capturedQueuedSlot, currentSlot, maxSlotWindow)) {
-            pruneDetected = buildPrunedResult(startTime, capturedQueuedSlot, currentSlot, onProgress);
-            abortController.abort();
-          }
-        } catch {
-        }
-      }, 5e3);
+    let cleaned = false;
+    function cleanup() {
+      if (cleaned) return;
+      cleaned = true;
+      abortController.abort();
     }
+    __name(cleanup, "cleanup");
+    let notifications;
     try {
-      const notifications = await rpcSubscriptions.accountNotifications(computationAddress, { encoding: "base64", commitment }).subscribe({ abortSignal: abortController.signal });
-      for await (const notification of notifications) {
-        try {
-          const encodedAccount = notificationValueToEncodedAccount(
-            computationAddress,
-            notification.value
-          );
-          const decoded = decodeComputationAccount(encodedAccount);
-          if (queuedSlot === null) {
-            queuedSlot = decoded.data.slot;
-            onProgress?.({ type: "queued", queuedSlot });
-          }
-          if (decoded.data.status === ComputationStatus.Finalized) {
-            return buildFinalizedResult(
-              rpc,
+      notifications = await rpcSubscriptions.accountNotifications(computationAddress, { encoding: "base64", commitment }).subscribe({ abortSignal: abortController.signal });
+    } catch (error) {
+      cleanup();
+      throw new ComputationMonitorError(
+        "subscription",
+        "Failed to establish WebSocket subscription",
+        error instanceof Error ? error : void 0
+      );
+    }
+    async function awaitComputation() {
+      const startTime = Date.now();
+      let queuedSlot = null;
+      let receivedFirstNotification = false;
+      checkAborted(externalSignal);
+      const safetyTimeoutId = setTimeout(() => abortController.abort(), safetyTimeoutMs);
+      const onExternalAbort = /* @__PURE__ */ __name(() => abortController.abort(), "onExternalAbort");
+      externalSignal?.addEventListener("abort", onExternalAbort, { once: true });
+      let slotCheckIntervalId = null;
+      let pruneDetected = null;
+      try {
+        for await (const notification of notifications) {
+          try {
+            const encodedAccount = notificationValueToEncodedAccount(
               computationAddress,
-              startTime,
-              queuedSlot,
-              shouldRetrieveSignature,
-              onProgress
+              notification.value
             );
+            const decoded = decodeComputationAccount(encodedAccount);
+            if (!receivedFirstNotification) {
+              receivedFirstNotification = true;
+              queuedSlot = decoded.data.slot;
+              const capturedQueuedSlot = queuedSlot;
+              slotCheckIntervalId = setInterval(async () => {
+                try {
+                  const currentSlot = await fetchCurrentSlot(rpc, commitment);
+                  if (isSlotWindowExceeded(capturedQueuedSlot, currentSlot, maxSlotWindow)) {
+                    pruneDetected = buildPrunedResult(
+                      startTime,
+                      capturedQueuedSlot,
+                      currentSlot,
+                      onProgress
+                    );
+                    abortController.abort();
+                  }
+                } catch {
+                }
+              }, 5e3);
+              if (decoded.data.status === ComputationStatus.Finalized) {
+                return buildFinalizedResult(
+                  rpc,
+                  computationAddress,
+                  startTime,
+                  queuedSlot,
+                  shouldRetrieveSignature,
+                  onProgress
+                );
+              }
+              continue;
+            }
+            if (decoded.data.status === ComputationStatus.Finalized) {
+              return buildFinalizedResult(
+                rpc,
+                computationAddress,
+                startTime,
+                queuedSlot,
+                shouldRetrieveSignature,
+                onProgress
+              );
+            }
+          } catch {
+            continue;
           }
-        } catch {
-          continue;
         }
-      }
-      if (pruneDetected) {
-        return pruneDetected;
-      }
-      throw new ComputationMonitorError(
-        "timeout",
-        `Safety timeout: computation monitoring exceeded ${String(safetyTimeoutMs)}ms`
-      );
-    } catch (error) {
-      if (error instanceof ComputationMonitorError) {
-        throw error;
-      }
-      if (pruneDetected) {
-        return pruneDetected;
-      }
-      if (abortController.signal.aborted) {
+        if (pruneDetected) {
+          return pruneDetected;
+        }
+        return buildTimedOutResult(startTime);
+      } catch (error) {
+        if (error instanceof ComputationMonitorError) {
+          throw error;
+        }
+        if (pruneDetected) {
+          return pruneDetected;
+        }
+        if (abortController.signal.aborted) {
+          return buildTimedOutResult(startTime);
+        }
         throw new ComputationMonitorError(
-          "timeout",
-          `Safety timeout: computation monitoring exceeded ${String(safetyTimeoutMs)}ms`
+          "subscription",
+          "WebSocket subscription failed",
+          error instanceof Error ? error : void 0
         );
+      } finally {
+        clearTimeout(safetyTimeoutId);
+        if (slotCheckIntervalId !== null) {
+          clearInterval(slotCheckIntervalId);
+        }
+        externalSignal?.removeEventListener("abort", onExternalAbort);
+        cleanup();
       }
-      throw new ComputationMonitorError(
-        "subscription",
-        "WebSocket subscription failed",
-        error instanceof Error ? error : void 0
-      );
-    } finally {
-      clearTimeout(safetyTimeoutId);
-      if (slotCheckIntervalId !== null) {
-        clearInterval(slotCheckIntervalId);
-      }
-      externalSignal?.removeEventListener("abort", onExternalAbort);
-      abortController.abort();
     }
+    __name(awaitComputation, "awaitComputation");
+    return { awaitComputation, cleanup };
   }
-  __name(monitorComputation, "monitorComputation");
-  return {
-    awaitComputation: monitorComputation
-  };
+  __name(prepareMonitor, "prepareMonitor");
+  return { prepareMonitor };
 }
 __name(getWebsocketComputationMonitor, "getWebsocketComputationMonitor");
 function getPollingComputationMonitor(config, deps) {
   const { rpcUrl } = config;
   const { createRpc = createSolanaRpc } = deps ?? {};
   const rpc = createRpc(rpcUrl);
-  async function monitorComputation(computationAddress, options) {
+  async function prepareMonitor(computationAddress, options) {
     const {
       maxSlotWindow = DEFAULT_MAX_SLOT_WINDOW,
       safetyTimeoutMs = DEFAULT_SAFETY_TIMEOUT_MS,
@@ -304,360 +363,77 @@ function getPollingComputationMonitor(config, deps) {
       commitment = "confirmed",
       signal: externalSignal
     } = options ?? {};
-    const startTime = Date.now();
-    let queuedSlot = null;
-    let queuedEventFired = false;
-    while (Date.now() - startTime < safetyTimeoutMs) {
-      checkAborted(externalSignal);
-      try {
-        const [maybeAccount, currentSlot] = await Promise.all([
-          fetchEncodedAccount(rpc, computationAddress, { commitment }),
-          fetchCurrentSlot(rpc, commitment)
-        ]);
-        if (!maybeAccount.exists) {
-          await sleep(pollingIntervalMs);
-          continue;
-        }
-        const decoded = decodeComputationAccount(maybeAccount);
-        if (queuedSlot === null) {
-          queuedSlot = decoded.data.slot;
-        }
-        if (!queuedEventFired && decoded.data.status === ComputationStatus.Queued) {
-          onProgress?.({ type: "queued", queuedSlot });
-          queuedEventFired = true;
-        }
-        if (decoded.data.status === ComputationStatus.Finalized) {
-          return buildFinalizedResult(
-            rpc,
-            computationAddress,
-            startTime,
-            queuedSlot,
-            shouldRetrieveSignature,
-            onProgress
-          );
-        }
-        if (isSlotWindowExceeded(queuedSlot, currentSlot, maxSlotWindow)) {
-          return buildPrunedResult(startTime, queuedSlot, currentSlot, onProgress);
+    let aborted = false;
+    function cleanup() {
+      aborted = true;
+    }
+    __name(cleanup, "cleanup");
+    async function awaitComputation() {
+      const startTime = Date.now();
+      let queuedSlot = null;
+      let receivedFirstDecode = false;
+      while (Date.now() - startTime < safetyTimeoutMs) {
+        if (aborted) {
+          return buildTimedOutResult(startTime);
         }
-      } catch (error) {
-        if (error instanceof ComputationMonitorError) {
-          throw error;
+        checkAborted(externalSignal);
+        try {
+          const [maybeAccount, currentSlot] = await Promise.all([
+            fetchEncodedAccount(rpc, computationAddress, { commitment }),
+            fetchCurrentSlot(rpc, commitment)
+          ]);
+          if (!maybeAccount.exists) {
+            await sleep(pollingIntervalMs);
+            continue;
+          }
+          const decoded = decodeComputationAccount(maybeAccount);
+          if (queuedSlot === null) {
+            queuedSlot = decoded.data.slot;
+          }
+          if (!receivedFirstDecode) {
+            receivedFirstDecode = true;
+            if (decoded.data.status === ComputationStatus.Finalized) {
+              return buildFinalizedResult(
+                rpc,
+                computationAddress,
+                startTime,
+                queuedSlot,
+                shouldRetrieveSignature,
+                onProgress
+              );
+            }
+            await sleep(pollingIntervalMs);
+            continue;
+          }
+          if (decoded.data.status === ComputationStatus.Finalized) {
+            return buildFinalizedResult(
+              rpc,
+              computationAddress,
+              startTime,
+              queuedSlot,
+              shouldRetrieveSignature,
+              onProgress
+            );
+          }
+          if (isSlotWindowExceeded(queuedSlot, currentSlot, maxSlotWindow)) {
+            return buildPrunedResult(startTime, queuedSlot, currentSlot, onProgress);
+          }
+        } catch (error) {
+          if (error instanceof ComputationMonitorError) {
+            throw error;
+          }
         }
+        await sleep(pollingIntervalMs);
       }
-      await sleep(pollingIntervalMs);
+      return buildTimedOutResult(startTime);
     }
-    throw new ComputationMonitorError(
-      "timeout",
-      `Safety timeout: computation monitoring exceeded ${String(safetyTimeoutMs)}ms`
-    );
+    __name(awaitComputation, "awaitComputation");
+    return { awaitComputation, cleanup };
   }
-  __name(monitorComputation, "monitorComputation");
-  return {
-    awaitComputation: monitorComputation
-  };
+  __name(prepareMonitor, "prepareMonitor");
+  return { prepareMonitor };
 }
 __name(getPollingComputationMonitor, "getPollingComputationMonitor");
-var DEFAULT_UTXO_LIMIT = 1000n;
-var MAX_UTXO_LIMIT = 5000n;
-var IndexerError = class _IndexerError extends Error {
-  static {
-    __name(this, "IndexerError");
-  }
-  /**
-   * The indexer operation that failed.
-   *
-   * @remarks
-   * This is a short camelCase label identifying which high-level operation
-   * triggered the error (e.g. `"fetchMerkleProof"`, `"fetchUtxoData"`,
-   * `"base64Conversion"`).
-   *
-   * @readonly
-   */
-  operation;
-  /**
-   * HTTP status code if available.
-   *
-   * @remarks
-   * Present when the server responded with an HTTP error (4xx or 5xx).
-   * `undefined` for transport-level failures such as network timeouts or
-   * DNS resolution failures.
-   *
-   * @readonly
-   */
-  statusCode;
-  /**
-   * Creates a new IndexerError.
-   *
-   * @param operation - The operation that failed (e.g. `"fetchMerkleProof"`)
-   * @param message - Descriptive error message for display to users or logs
-   * @param statusCode - Optional HTTP status code (undefined for network failures)
-   * @param cause - Optional underlying error that triggered this one
-   */
-  constructor(operation, message, statusCode, cause) {
-    super(`Indexer operation '${operation}' failed: ${message}`);
-    this.name = "IndexerError";
-    this.operation = operation;
-    this.statusCode = statusCode;
-    this.cause = cause;
-    if (Error.captureStackTrace !== void 0) {
-      Error.captureStackTrace(this, _IndexerError);
-    }
-  }
-};
-function base64ToBytes(base64) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(base64, "base64");
-  }
-  const binaryString = atob(base64);
-  const bytes = new Uint8Array(binaryString.length);
-  for (let index = 0; index < binaryString.length; index++) {
-    bytes[index] = binaryString.codePointAt(index) ?? 0;
-  }
-  return bytes;
-}
-__name(base64ToBytes, "base64ToBytes");
-function base64ToU256LeBytes(base64) {
-  const bytes = base64ToBytes(base64);
-  if (bytes.length !== 32) {
-    throw new IndexerError(
-      "base64Conversion",
-      `Invalid byte length: expected 32 bytes, got ${String(bytes.length)}`
-    );
-  }
-  assertU256LeBytes(bytes);
-  return bytes;
-}
-__name(base64ToU256LeBytes, "base64ToU256LeBytes");
-function base64ToX25519PublicKey(base64) {
-  const bytes = base64ToBytes(base64);
-  if (bytes.length !== 32) {
-    throw new IndexerError(
-      "base64Conversion",
-      `Invalid X25519 public key length: expected 32 bytes, got ${String(bytes.length)}`
-    );
-  }
-  return bytes;
-}
-__name(base64ToX25519PublicKey, "base64ToX25519PublicKey");
-function base64ToAesCiphertext(base64) {
-  return base64ToBytes(base64);
-}
-__name(base64ToAesCiphertext, "base64ToAesCiphertext");
-function splitAddressBase64(base64) {
-  const bytes = base64ToBytes(base64);
-  if (bytes.length !== 32) {
-    throw new IndexerError(
-      "addressSplit",
-      `Invalid address length: expected 32 bytes, got ${String(bytes.length)}`
-    );
-  }
-  const lowBytes = bytes.slice(0, 16);
-  const highBytes = bytes.slice(16, 32);
-  assertU128LeBytes(lowBytes);
-  assertU128LeBytes(highBytes);
-  return {
-    low: decodeU128LeBytesToU128(lowBytes),
-    high: decodeU128LeBytesToU128(highBytes)
-  };
-}
-__name(splitAddressBase64, "splitAddressBase64");
-function getMerkleProofFetcher(args, deps) {
-  const { apiEndpoint } = args;
-  const client = new ReadServiceClient({ endpoint: apiEndpoint, fetch: deps?.fetch });
-  return /* @__PURE__ */ __name(async function fetchMerkleProof(treeIndex, insertionIndices) {
-    if (insertionIndices.length === 0) {
-      return /* @__PURE__ */ new Map();
-    }
-    if (treeIndex < 0n) {
-      throw new IndexerError(
-        "fetchMerkleProof",
-        `Invalid tree index: ${String(treeIndex)}. Must be non-negative.`
-      );
-    }
-    const results = /* @__PURE__ */ new Map();
-    const fetchPromises = insertionIndices.map(async (insertionIndex) => {
-      if (insertionIndex < 0n) {
-        throw new IndexerError(
-          "fetchMerkleProof",
-          `Invalid insertion index: ${String(insertionIndex)}. Must be non-negative.`
-        );
-      }
-      let data;
-      try {
-        data = await client.getProof(treeIndex, insertionIndex);
-      } catch (error) {
-        throw new IndexerError(
-          "fetchMerkleProof",
-          `Failed to fetch proof for leaf ${String(insertionIndex)}: ${error instanceof Error ? error.message : String(error)}`,
-          void 0,
-          error instanceof Error ? error : void 0
-        );
-      }
-      const merkleRoot = base64ToU256LeBytes(data.root);
-      const merklePath = data.proof.map((hash) => base64ToU256LeBytes(hash));
-      const leaf = base64ToU256LeBytes(data.leaf);
-      return {
-        insertionIndex,
-        data: {
-          merkleRoot,
-          treeIndex: data.tree_index,
-          insertionIndex: data.insertion_index,
-          merklePath,
-          leaf
-        }
-      };
-    });
-    const proofResults = await Promise.all(fetchPromises);
-    for (const { insertionIndex, data } of proofResults) {
-      results.set(insertionIndex, data);
-    }
-    return results;
-  }, "fetchMerkleProof");
-}
-__name(getMerkleProofFetcher, "getMerkleProofFetcher");
-function getBatchMerkleProofFetcher(args, deps) {
-  const { apiEndpoint } = args;
-  const client = new ReadServiceClient({ endpoint: apiEndpoint, fetch: deps?.fetch });
-  return /* @__PURE__ */ __name(async function fetchBatchMerkleProof(treeIndex, insertionIndices) {
-    if (insertionIndices.length === 0) {
-      return { root: new Uint8Array(32), proofs: /* @__PURE__ */ new Map() };
-    }
-    if (treeIndex < 0n) {
-      throw new IndexerError(
-        "fetchBatchMerkleProof",
-        `Invalid tree index: ${String(treeIndex)}. Must be non-negative.`
-      );
-    }
-    for (const idx of insertionIndices) {
-      if (idx < 0n) {
-        throw new IndexerError(
-          "fetchBatchMerkleProof",
-          `Invalid insertion index: ${String(idx)}. Must be non-negative.`
-        );
-      }
-    }
-    let data;
-    try {
-      data = await client.getBatchProof(
-        treeIndex,
-        insertionIndices.map((idx) => BigInt(idx))
-      );
-    } catch (error) {
-      throw new IndexerError(
-        "fetchBatchMerkleProof",
-        `Failed to fetch batch proofs: ${error instanceof Error ? error.message : String(error)}`,
-        void 0,
-        error instanceof Error ? error : void 0
-      );
-    }
-    const root = base64ToU256LeBytes(data.root);
-    const proofs = /* @__PURE__ */ new Map();
-    for (const entry of data.proofs) {
-      proofs.set(entry.insertion_index, {
-        merklePath: entry.proof.map((hash) => base64ToU256LeBytes(hash)),
-        leaf: base64ToU256LeBytes(entry.leaf)
-      });
-    }
-    return { root, proofs };
-  }, "fetchBatchMerkleProof");
-}
-__name(getBatchMerkleProofFetcher, "getBatchMerkleProofFetcher");
-function getUtxoDataFetcher(args, deps) {
-  const { apiEndpoint } = args;
-  const client = new ReadServiceClient({ endpoint: apiEndpoint, fetch: deps?.fetch });
-  return /* @__PURE__ */ __name(async function fetchUtxoData(startIndex, endIndex, limit) {
-    if (startIndex < 0n) {
-      throw new IndexerError(
-        "fetchUtxoData",
-        `Invalid start index: ${String(startIndex)}. Must be non-negative.`
-      );
-    }
-    if (endIndex !== void 0 && endIndex < startIndex) {
-      throw new IndexerError(
-        "fetchUtxoData",
-        `Invalid end index: ${String(endIndex)}. Must be >= start index (${String(startIndex)}).`
-      );
-    }
-    const effectiveLimit = limit ?? DEFAULT_UTXO_LIMIT;
-    if (effectiveLimit < 1n || effectiveLimit > MAX_UTXO_LIMIT) {
-      throw new IndexerError(
-        "fetchUtxoData",
-        `Invalid limit: ${String(effectiveLimit)}. Must be between 1 and ${String(MAX_UTXO_LIMIT)}.`
-      );
-    }
-    let response;
-    try {
-      response = await client.getUtxoData({
-        start: startIndex,
-        end: endIndex,
-        limit: effectiveLimit
-      });
-    } catch (error) {
-      throw new IndexerError(
-        "fetchUtxoData",
-        `Network error: ${error instanceof Error ? error.message : String(error)}`,
-        void 0,
-        error instanceof Error ? error : void 0
-      );
-    }
-    const items = /* @__PURE__ */ new Map();
-    for (const item of response.items) {
-      try {
-        const senderAddress = splitAddressBase64(item.h1_sender_address);
-        const mintAddress = splitAddressBase64(item.h1_mint_address);
-        const timestamp = {
-          year: item.h1_year,
-          month: item.h1_month,
-          day: item.h1_day,
-          hour: item.h1_hour,
-          minute: item.h1_minute,
-          second: item.h1_second
-        };
-        const h1Components = {
-          version: BigInt(item.h1_version),
-          commitmentIndex: BigInt(item.h1_commitment_index),
-          senderAddressLow: senderAddress.low,
-          senderAddressHigh: senderAddress.high,
-          relayerFixedSolFees: item.h1_relayer_fixed_sol_fees,
-          mintAddressLow: mintAddress.low,
-          mintAddressHigh: mintAddress.high,
-          timestamp,
-          poolVolumeSpl: item.h1_pool_volume_spl,
-          poolVolumeSol: item.h1_pool_volume_sol
-        };
-        const utxoItem = {
-          absoluteIndex: item.absolute_index,
-          treeIndex: item.tree_index,
-          insertionIndex: item.insertion_index,
-          finalCommitment: base64ToU256LeBytes(item.final_commitment),
-          h1Components,
-          h1Hash: base64ToU256LeBytes(item.h1_hash),
-          h2Hash: base64ToU256LeBytes(item.h2_hash),
-          aesEncryptedData: base64ToAesCiphertext(item.aes_encrypted_data),
-          depositorX25519PublicKey: base64ToX25519PublicKey(item.depositor_x25519_public_key),
-          timestamp: item.timestamp,
-          slot: item.slot,
-          eventType: item.event_type
-        };
-        items.set(item.insertion_index, utxoItem);
-      } catch (error) {
-        throw new IndexerError(
-          "fetchUtxoData",
-          `Failed to parse UTXO data for index ${String(item.absolute_index)}: ${error instanceof Error ? error.message : String(error)}`,
-          void 0,
-          error instanceof Error ? error : void 0
-        );
-      }
-    }
-    return {
-      items,
-      hasMore: response.has_more,
-      nextCursor: response.next_cursor ?? void 0,
-      totalCount: response.total_count
-    };
-  }, "fetchUtxoData");
-}
-__name(getUtxoDataFetcher, "getUtxoDataFetcher");
 
 // src/umbra/client.ts
 var notImplementedGenerator = /* @__PURE__ */ __name(async () => {
@@ -701,15 +477,15 @@ async function getUmbraClient(args, deps) {
     rpcUrl,
     rpcSubscriptionsUrl
   });
-  const fetchMerkleProof = indexerApiEndpoint !== void 0 && indexerApiEndpoint !== "" ? getMerkleProofFetcher({
-    apiEndpoint: indexerApiEndpoint
-  }) : void 0;
-  const fetchBatchMerkleProof = indexerApiEndpoint !== void 0 && indexerApiEndpoint !== "" ? getBatchMerkleProofFetcher({
-    apiEndpoint: indexerApiEndpoint
-  }) : void 0;
-  const fetchUtxoData = indexerApiEndpoint !== void 0 && indexerApiEndpoint !== "" ? getUtxoDataFetcher({
-    apiEndpoint: indexerApiEndpoint
-  }) : void 0;
+  let fetchMerkleProof;
+  let fetchBatchMerkleProof;
+  let fetchUtxoData;
+  if (indexerApiEndpoint !== void 0 && indexerApiEndpoint !== "") {
+    const { getMerkleProofFetcher, getBatchMerkleProofFetcher, getUtxoDataFetcher } = await import('./indexer-NHZDFABY.js');
+    fetchMerkleProof = getMerkleProofFetcher({ apiEndpoint: indexerApiEndpoint });
+    fetchBatchMerkleProof = getBatchMerkleProofFetcher({ apiEndpoint: indexerApiEndpoint });
+    fetchUtxoData = getUtxoDataFetcher({ apiEndpoint: indexerApiEndpoint });
+  }
   const defaultMasterSeedStorage = getDefaultMasterSeedStorage();
   const defaultMasterSeedGenerator = getDefaultMasterSeedGenerator(signer);
   const masterSeedLoad = deps?.masterSeedStorage?.load ?? defaultMasterSeedStorage.load;
@@ -806,54 +582,6 @@ async function getUmbraClient(args, deps) {
 }
 __name(getUmbraClient, "getUmbraClient");
 
-// src/umbra/constants.ts
-var UMBRA_MESSAGE_TO_SIGN = `Umbra Protocol – User Consent & Acknowledgement
-
-Please read carefully before continuing. Umbra is a non-custodial, open-source protocol. Umbra does not hold, control, manage, or access your digital assets, private keys, viewing keys, transactions, or personal data. All interactions with the Umbra protocol occur through autonomous smart contracts and wallet-signed transactions executed directly on the blockchain.
-
-By using the Umbra protocol, you acknowledge and agree that:
-
-1. You are solely responsible for managing your wallet, private keys, privacy settings, viewing key disclosures, and any transactions or interactions you authorize.
-2. Blockchain transactions are generally irreversible, and smart contracts may contain bugs, vulnerabilities, or unintended behavior.
-3. Errors, misuse, misconfiguration, third-party tools, relayers, or loss of keys may result in permanent and unrecoverable loss of assets or privacy.
-4. Privacy features are designed to enhance confidentiality but do not guarantee absolute or unconditional anonymity.
-5. Transactions may involve independent relayers or third-party infrastructure that Umbra does not operate, control, or supervise.
-6. By clicking "I Agree", you confirm that you have read, understood, and accepted all applicable terms, policies, risk disclosures, notices, and other documentation governing your access to and use of the Umbra protocol, as published or made available by Umbra from time to time.
-
-You acknowledge that such documentation may be updated or modified, and that continued access to or use of the Umbra Protocol constitutes acceptance of the then-current versions. If you do not agree, do not proceed and discontinue use of the Umbra protocol.`;
-var FEE_OFFSETS = {
-  /**
-   * Offset used in `FeeVault` PDA derivation for the unified protocol fees pool.
-   *
-   * @remarks
-   * Passed as the final seed to `findProtocolFeeVaultPda` and
-   * `findRelayerFeeVaultPda`. Currently `0n`.
-   *
-   * @readonly
-   */
-  PROTOCOL_FEES_POOL: 0n,
-  /**
-   * Offset used in `FeeSchedule` PDA derivation.
-   *
-   * @remarks
-   * Passed as the final seed to `findFeeSchedulePda`. Currently `0n`.
-   *
-   * @readonly
-   */
-  PROTOCOL_FEES_CONFIG: 0n,
-  /**
-   * Offset used in relayer fee configuration PDA derivation.
-   *
-   * @remarks
-   * Passed as the offset seed when looking up the relayer's fee configuration account.
-   * Currently `0n`.
-   *
-   * @readonly
-   */
-  RELAYER_FEES_CONFIG: 0n
-};
-var BPS_DIVISOR = 16384n;
-
 // src/umbra/fee-provider.ts
 var TREE_DEPTH = 4;
 var MAX_LEAVES = 1 << TREE_DEPTH;
@@ -5849,71 +5577,85 @@ async function signTransactionMessage(signer, transactionMessage) {
 __name(signTransactionMessage, "signTransactionMessage");
 async function forwardAndMonitor(config, signedTransaction, callbacks, awaitCallback) {
   const { transactionForwarder, computationMonitor } = config;
-  if (callbacks?.pre !== void 0) {
-    await callbacks.pre(signedTransaction);
-  }
-  const txSignature = getSignatureFromTransaction(signedTransaction);
-  await transactionForwarder.forwardSequentially([signedTransaction]);
-  if (callbacks?.post !== void 0) {
-    await callbacks.post(signedTransaction, txSignature);
-  }
-  if (awaitCallback === void 0) {
-    return { signature: txSignature, signedTransaction };
-  }
-  if (computationMonitor === void 0) {
-    throw new Error(
-      "awaitCallback was provided but no computationMonitor is configured on the client. Pass a computationMonitor when creating the Umbra client, or omit awaitCallback to use fire-and-forget mode."
+  const txSignature = getSignatureFromTransaction(
+    signedTransaction
+  );
+  let prepared;
+  if (awaitCallback !== void 0) {
+    if (computationMonitor === void 0) {
+      throw new Error(
+        "awaitCallback was provided but no computationMonitor is configured on the client. Pass a computationMonitor when creating the Umbra client, or omit awaitCallback to use fire-and-forget mode."
+      );
+    }
+    const baseMonitorOptions = {
+      maxSlotWindow: awaitCallback.maxSlotWindow,
+      safetyTimeoutMs: awaitCallback.safetyTimeoutMs,
+      onProgress: awaitCallback.onProgress,
+      commitment: awaitCallback.computationMonitorCommitment ?? "confirmed",
+      retrieveCallbackSignature: awaitCallback.retrieveCallbackSignature ?? false
+    };
+    prepared = await computationMonitor.prepareMonitor(
+      awaitCallback.computationAccountAddress,
+      baseMonitorOptions
     );
   }
-  const baseMonitorOptions = {
-    maxSlotWindow: awaitCallback.maxSlotWindow,
-    safetyTimeoutMs: awaitCallback.safetyTimeoutMs,
-    onProgress: awaitCallback.onProgress,
-    commitment: awaitCallback.computationMonitorCommitment ?? "confirmed"
-  };
-  const callbackResult = awaitCallback.retrieveCallbackSignature === true ? await computationMonitor.awaitComputation(
-    awaitCallback.computationAccountAddress,
-    { ...baseMonitorOptions, retrieveCallbackSignature: true }
-  ) : await computationMonitor.awaitComputation(
-    awaitCallback.computationAccountAddress,
-    { ...baseMonitorOptions, retrieveCallbackSignature: false }
-  );
-  let rentClaimSignature;
-  let rentClaimError;
-  if (awaitCallback.reclaimComputationRent !== false && callbackResult.status === "finalized") {
-    if (awaitCallback.computationOffset === void 0 || awaitCallback.clusterOffset === void 0) {
-      rentClaimError = "Rent reclaim skipped: computationOffset or clusterOffset was not provided by the service";
-    } else {
-      try {
-        const noopSigner = createNoopSigner(config.signer.address);
-        const rentClaimIx = getClaimComputationRentInstruction({
-          signer: noopSigner,
-          comp: awaitCallback.computationAccountAddress,
-          compOffset: awaitCallback.computationOffset,
-          clusterOffset: awaitCallback.clusterOffset
-        });
-        const rentClaimBlockhash = await config.getLatestBlockhash({
-          commitment: awaitCallback.rentReclaimBlockhashCommitment ?? "confirmed"
-        });
-        const rentClaimTxMsg = buildTransactionMessage(
-          config.signer,
-          rentClaimBlockhash,
-          [rentClaimIx]
-        );
-        const rentClaimTx = await signTransactionMessage(config.signer, rentClaimTxMsg);
-        rentClaimSignature = await config.transactionForwarder.fireAndForget(rentClaimTx);
-      } catch (error) {
-        rentClaimError = error instanceof Error ? error.message : String(error);
+  try {
+    if (callbacks?.pre !== void 0) {
+      await callbacks.pre(signedTransaction);
+    }
+    await transactionForwarder.forwardSequentially([signedTransaction]);
+    if (callbacks?.post !== void 0) {
+      await callbacks.post(signedTransaction, txSignature);
+    }
+    if (prepared === void 0 || awaitCallback === void 0) {
+      return { signature: txSignature, signedTransaction };
+    }
+    const callbackResult = await prepared.awaitComputation();
+    let rentClaimSignature;
+    let rentClaimError;
+    if (awaitCallback.reclaimComputationRent !== false) {
+      if (awaitCallback.computationOffset === void 0 || awaitCallback.clusterOffset === void 0) {
+        rentClaimError = "Rent reclaim skipped: computationOffset or clusterOffset was not provided by the service";
+      } else {
+        try {
+          const noopSigner = createNoopSigner(config.signer.address);
+          const rentClaimIx = getClaimComputationRentInstruction({
+            signer: noopSigner,
+            comp: awaitCallback.computationAccountAddress,
+            compOffset: awaitCallback.computationOffset,
+            clusterOffset: awaitCallback.clusterOffset
+          });
+          const rentClaimBlockhash = await config.getLatestBlockhash({
+            commitment: awaitCallback.rentReclaimBlockhashCommitment ?? "confirmed"
+          });
+          const rentClaimTxMsg = buildTransactionMessage(config.signer, rentClaimBlockhash, [
+            rentClaimIx
+          ]);
+          const rentClaimTx = await signTransactionMessage(config.signer, rentClaimTxMsg);
+          rentClaimSignature = await config.transactionForwarder.fireAndForget(rentClaimTx);
+        } catch (error) {
+          rentClaimError = error instanceof Error ? error.message : String(error);
+        }
       }
     }
+    return {
+      signature: txSignature,
+      signedTransaction,
+      callbackResult,
+      rentClaimSignature,
+      rentClaimError
+    };
+  } finally {
+    prepared?.cleanup();
   }
-  return { signature: txSignature, signedTransaction, callbackResult, rentClaimSignature, rentClaimError };
 }
 __name(forwardAndMonitor, "forwardAndMonitor");
 async function executeComputationTransaction(config, options, awaitCallback) {
   const { signer, getLatestBlockhash } = config;
   const { instruction, preInstructions, altEntry, callbacks, blockhashCommitment } = options;
-  const latestBlockhash = await getLatestBlockhash({ commitment: blockhashCommitment ?? "confirmed" });
+  const latestBlockhash = await getLatestBlockhash({
+    commitment: blockhashCommitment ?? "confirmed"
+  });
   const allInstructions = preInstructions === void 0 ? [instruction] : [...preInstructions, instruction];
   const transactionMessage = buildTransactionMessage(
     signer,
@@ -5970,6 +5712,7 @@ function getPublicBalanceToEncryptedBalanceDirectDepositorFunction(args, deps) {
       if ("callbackResult" in result) {
         return {
           queueSignature: result.signature,
+          callbackStatus: result.callbackResult.status,
           callbackSignature: "callbackSignature" in result.callbackResult ? result.callbackResult.callbackSignature : void 0,
           callbackElapsedMs: result.callbackResult.elapsedMs,
           rentClaimSignature: result.rentClaimSignature,
@@ -7101,6 +6844,7 @@ function getEncryptedBalanceToSelfClaimableUtxoCreatorFunction(args, deps) {
         return {
           signedTransaction: result2.signedTransaction,
           signature: result2.signature,
+          callbackStatus: callbackResult?.status,
           callbackSignature,
           callbackElapsedMs: callbackResult?.elapsedMs,
           rentClaimSignature,
@@ -7279,6 +7023,7 @@ function getEncryptedBalanceToSelfClaimableUtxoCreatorFunction(args, deps) {
         closeProofAccountSignature: closeResult?.signature,
         createProofAccountSignature: proofAccountResult.signature,
         queueSignature: utxoResult.signature,
+        callbackStatus: utxoResult.callbackStatus,
         callbackSignature: utxoResult.callbackSignature,
         callbackElapsedMs: utxoResult.callbackElapsedMs,
         rentClaimSignature: utxoResult.rentClaimSignature,
@@ -8091,6 +7836,7 @@ function getEncryptedBalanceToReceiverClaimableUtxoCreatorFunction(args, deps) {
         return {
           signedTransaction: result2.signedTransaction,
           signature: result2.signature,
+          callbackStatus: callbackResult?.status,
           callbackSignature,
           callbackElapsedMs: callbackResult?.elapsedMs,
           rentClaimSignature,
@@ -8265,6 +8011,7 @@ function getEncryptedBalanceToReceiverClaimableUtxoCreatorFunction(args, deps) {
         closeProofAccountSignature: closeResult?.signature,
         createProofAccountSignature: proofAccountResult.signature,
         queueSignature: utxoResult.signature,
+        callbackStatus: utxoResult.callbackStatus,
         callbackSignature: utxoResult.callbackSignature,
         callbackElapsedMs: utxoResult.callbackElapsedMs,
         rentClaimSignature: utxoResult.rentClaimSignature,
@@ -10483,6 +10230,7 @@ function getEncryptedBalanceToPublicBalanceDirectWithdrawerFunction(args, deps)
       if ("callbackResult" in result) {
         return {
           queueSignature: result.signature,
+          callbackStatus: result.callbackResult.status,
           callbackSignature: "callbackSignature" in result.callbackResult ? result.callbackResult.callbackSignature : void 0,
           callbackElapsedMs: result.callbackResult.elapsedMs,
           rentClaimSignature: result.rentClaimSignature,
@@ -10643,6 +10391,6 @@ function getEncryptedBalanceToPublicBalanceDirectWithdrawerFunction(args, deps)
 }
 __name(getEncryptedBalanceToPublicBalanceDirectWithdrawerFunction, "getEncryptedBalanceToPublicBalanceDirectWithdrawerFunction");
 
-export { BPS_DIVISOR, DEFAULT_MAX_SLOT_WINDOW, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_SAFETY_TIMEOUT_MS, DEFAULT_SIGNATURE_RETRIEVAL_LIMIT, FEE_OFFSETS, IndexerError, UMBRA_MESSAGE_TO_SIGN, buildTransactionMessage, calculateFee, enrichWithMerkleProof, executeComputationTransaction, extractMerklePath, extractSignatures, feeSlabResultToInstructionFields, forwardAndMonitor, getBatchMerkleProofFetcher, getClaimableUtxoScannerFunction, getComplianceGrantIssuerFunction, getComplianceGrantRevokerFunction, getDefaultKeyLoader, getDefaultKeyStorer, getDefaultMasterSeedGenerator, getDefaultMasterSeedStorage, getEncryptedBalanceQuerierFunction, getEncryptedBalanceToPublicBalanceDirectWithdrawerFunction, getEncryptedBalanceToReceiverClaimableUtxoCreatorFunction, getEncryptedBalanceToSelfClaimableUtxoCreatorFunction, getHardcodedClaimUtxoProtocolFeeProvider, getHardcodedClaimUtxoRelayerFeeProvider, getHardcodedCreateUtxoProtocolFeeProvider, getHardcodedDepositProtocolFeeProvider, getHardcodedWithdrawalProtocolFeeProvider, getMasterViewingKeyRotatorFunction, getMerkleProofFetcher, getMintEncryptionKeyRotatorFunction, getNetworkCiphertextReencryptorForNetworkGrantFunction, getNetworkComplianceGrantQuerierFunction, getNetworkEncryptionToSharedEncryptionConverterFunction, getPollingComputationMonitor, getPublicBalanceToEncryptedBalanceDirectDepositorFunction, getPublicBalanceToReceiverClaimableUtxoCreatorFunction, getPublicBalanceToSelfClaimableUtxoCreatorFunction, getReceiverClaimableUtxoToEncryptedBalanceClaimerFunction, getSelfClaimableUtxoToEncryptedBalanceClaimerFunction, getSelfClaimableUtxoToPublicBalanceClaimerFunction, getSharedCiphertextReencryptorForNetworkGrantFunction, getSharedCiphertextReencryptorForUserGrantFunction, getSharedComplianceGrantQuerierFunction, getStagedSolRecovererFunction, getStagedSplRecovererFunction, getTokenEntropySeedRotatorFunction, getUmbraClient, getUserAccountQuerierFunction, getUserComplianceGrantQuerierFunction, getUserEncryptionKeyRotatorFunction, getUserEntropySeedRotatorFunction, getUserRegistrationFunction, getUtxoDataFetcher, getWebsocketComputationMonitor, leafIndexToPathIndices, protocolFeeSlabResultToInstructionFields, relayerFeeSlabResultToInstructionFields, signTransactionMessage };
+export { BPS_DIVISOR, DEFAULT_MAX_SLOT_WINDOW, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_SAFETY_TIMEOUT_MS, DEFAULT_SIGNATURE_RETRIEVAL_LIMIT, FEE_OFFSETS, UMBRA_MESSAGE_TO_SIGN, buildTransactionMessage, calculateFee, enrichWithMerkleProof, executeComputationTransaction, extractMerklePath, extractSignatures, feeSlabResultToInstructionFields, forwardAndMonitor, getClaimableUtxoScannerFunction, getComplianceGrantIssuerFunction, getComplianceGrantRevokerFunction, getDefaultKeyLoader, getDefaultKeyStorer, getDefaultMasterSeedGenerator, getDefaultMasterSeedStorage, getEncryptedBalanceQuerierFunction, getEncryptedBalanceToPublicBalanceDirectWithdrawerFunction, getEncryptedBalanceToReceiverClaimableUtxoCreatorFunction, getEncryptedBalanceToSelfClaimableUtxoCreatorFunction, getHardcodedClaimUtxoProtocolFeeProvider, getHardcodedClaimUtxoRelayerFeeProvider, getHardcodedCreateUtxoProtocolFeeProvider, getHardcodedDepositProtocolFeeProvider, getHardcodedWithdrawalProtocolFeeProvider, getMasterViewingKeyRotatorFunction, getMintEncryptionKeyRotatorFunction, getNetworkCiphertextReencryptorForNetworkGrantFunction, getNetworkComplianceGrantQuerierFunction, getNetworkEncryptionToSharedEncryptionConverterFunction, getPollingComputationMonitor, getPublicBalanceToEncryptedBalanceDirectDepositorFunction, getPublicBalanceToReceiverClaimableUtxoCreatorFunction, getPublicBalanceToSelfClaimableUtxoCreatorFunction, getReceiverClaimableUtxoToEncryptedBalanceClaimerFunction, getSelfClaimableUtxoToEncryptedBalanceClaimerFunction, getSelfClaimableUtxoToPublicBalanceClaimerFunction, getSharedCiphertextReencryptorForNetworkGrantFunction, getSharedCiphertextReencryptorForUserGrantFunction, getSharedComplianceGrantQuerierFunction, getStagedSolRecovererFunction, getStagedSplRecovererFunction, getTokenEntropySeedRotatorFunction, getUmbraClient, getUserAccountQuerierFunction, getUserComplianceGrantQuerierFunction, getUserEncryptionKeyRotatorFunction, getUserEntropySeedRotatorFunction, getUserRegistrationFunction, getWebsocketComputationMonitor, leafIndexToPathIndices, protocolFeeSlabResultToInstructionFields, relayerFeeSlabResultToInstructionFields, signTransactionMessage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map