@umbra-privacy/sdk 2.0.1 → 2.0.3

package/dist/utils/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var chunkZY3TSHMJ_cjs = require('../chunk-ZY3TSHMJ.cjs');
-var chunkCFFLOE7D_cjs = require('../chunk-CFFLOE7D.cjs');
+var chunkUEI7SYH6_cjs = require('../chunk-UEI7SYH6.cjs');
 require('../chunk-TQQZGNOI.cjs');
 var chunkDMPMQ74B_cjs = require('../chunk-DMPMQ74B.cjs');
 var chunk5GUSMQ74_cjs = require('../chunk-5GUSMQ74.cjs');
@@ -1047,135 +1047,135 @@ Object.defineProperty(exports, "splitX25519PublicKeyIntoTwoU128s", {
 });
 Object.defineProperty(exports, "TOKEN_POOL_SEED", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.TOKEN_POOL_SEED; }
+  get: function () { return chunkUEI7SYH6_cjs.TOKEN_POOL_SEED; }
 });
 Object.defineProperty(exports, "computeCompDefOffset", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.computeCompDefOffset; }
+  get: function () { return chunkUEI7SYH6_cjs.computeCompDefOffset; }
 });
 Object.defineProperty(exports, "computeStructSeed", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.computeStructSeed; }
+  get: function () { return chunkUEI7SYH6_cjs.computeStructSeed; }
 });
 Object.defineProperty(exports, "findActiveStealthPoolPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findActiveStealthPoolPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findActiveStealthPoolPda; }
 });
 Object.defineProperty(exports, "findArciumClusterPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findArciumClusterPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findArciumClusterPda; }
 });
 Object.defineProperty(exports, "findArciumCompDefPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findArciumCompDefPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findArciumCompDefPda; }
 });
 Object.defineProperty(exports, "findArciumComputationPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findArciumComputationPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findArciumComputationPda; }
 });
 Object.defineProperty(exports, "findArciumExecutingPoolPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findArciumExecutingPoolPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findArciumExecutingPoolPda; }
 });
 Object.defineProperty(exports, "findArciumInfrastructurePdas", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findArciumInfrastructurePdas; }
+  get: function () { return chunkUEI7SYH6_cjs.findArciumInfrastructurePdas; }
 });
 Object.defineProperty(exports, "findArciumMempoolPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findArciumMempoolPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findArciumMempoolPda; }
 });
 Object.defineProperty(exports, "findArciumMxePda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findArciumMxePda; }
+  get: function () { return chunkUEI7SYH6_cjs.findArciumMxePda; }
 });
 Object.defineProperty(exports, "findClaimInputBufferPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findClaimInputBufferPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findClaimInputBufferPda; }
 });
 Object.defineProperty(exports, "findConfidentialNullifierBufferPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findConfidentialNullifierBufferPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findConfidentialNullifierBufferPda; }
 });
 Object.defineProperty(exports, "findEncryptedTokenAccountPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findEncryptedTokenAccountPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findEncryptedTokenAccountPda; }
 });
 Object.defineProperty(exports, "findEncryptedUserAccountPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findEncryptedUserAccountPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findEncryptedUserAccountPda; }
 });
 Object.defineProperty(exports, "findFeeSchedulePda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findFeeSchedulePda; }
+  get: function () { return chunkUEI7SYH6_cjs.findFeeSchedulePda; }
 });
 Object.defineProperty(exports, "findNetworkComplianceGrantPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findNetworkComplianceGrantPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findNetworkComplianceGrantPda; }
 });
 Object.defineProperty(exports, "findNullifierSetPdas", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findNullifierSetPdas; }
+  get: function () { return chunkUEI7SYH6_cjs.findNullifierSetPdas; }
 });
 Object.defineProperty(exports, "findProtocolConfigPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findProtocolConfigPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findProtocolConfigPda; }
 });
 Object.defineProperty(exports, "findProtocolFeeVaultPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findProtocolFeeVaultPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findProtocolFeeVaultPda; }
 });
 Object.defineProperty(exports, "findPublicClaimComputationDataPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findPublicClaimComputationDataPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findPublicClaimComputationDataPda; }
 });
 Object.defineProperty(exports, "findPublicClaimInputBufferPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findPublicClaimInputBufferPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findPublicClaimInputBufferPda; }
 });
 Object.defineProperty(exports, "findPublicNullifierBufferPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findPublicNullifierBufferPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findPublicNullifierBufferPda; }
 });
 Object.defineProperty(exports, "findPublicUtxoInputBufferPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findPublicUtxoInputBufferPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findPublicUtxoInputBufferPda; }
 });
 Object.defineProperty(exports, "findRelayerFeeSchedulePda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findRelayerFeeSchedulePda; }
+  get: function () { return chunkUEI7SYH6_cjs.findRelayerFeeSchedulePda; }
 });
 Object.defineProperty(exports, "findRelayerFeeVaultPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findRelayerFeeVaultPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findRelayerFeeVaultPda; }
 });
 Object.defineProperty(exports, "findRelayerPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findRelayerPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findRelayerPda; }
 });
 Object.defineProperty(exports, "findSharedComplianceGrantPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findSharedComplianceGrantPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findSharedComplianceGrantPda; }
 });
 Object.defineProperty(exports, "findStealthPoolPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findStealthPoolPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findStealthPoolPda; }
 });
 Object.defineProperty(exports, "findTokenPoolPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findTokenPoolPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findTokenPoolPda; }
 });
 Object.defineProperty(exports, "findUserComplianceGrantPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findUserComplianceGrantPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findUserComplianceGrantPda; }
 });
 Object.defineProperty(exports, "findUtxoInputBufferPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findUtxoInputBufferPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findUtxoInputBufferPda; }
 });
 Object.defineProperty(exports, "findVerifyingKeyPda", {
   enumerable: true,
-  get: function () { return chunkCFFLOE7D_cjs.findVerifyingKeyPda; }
+  get: function () { return chunkUEI7SYH6_cjs.findVerifyingKeyPda; }
 });
 Object.defineProperty(exports, "ConversionError", {
   enumerable: true,

package/dist/utils/index.js

@@ -1,5 +1,5 @@
 export { bigintToBinaryArrayLSB, calculateNetAmountAfterFee, calculateTransferFee, convertBn254FieldElementToCurve25519FieldElement, convertBn254FieldElementToDailyViewingKey, convertBn254FieldElementToMasterViewingKey, convertBn254FieldElementToMintViewingKey, convertBn254FieldElementToMonthlyViewingKey, convertBn254FieldElementToPoseidonCiphertext, convertBn254FieldElementToPoseidonHash, convertBn254FieldElementToPoseidonKey, convertBn254FieldElementToPoseidonPlaintext, convertBn254FieldElementToU256, convertBn254FieldElementToYearlyViewingKey, convertCurve25519FieldElementToBn254FieldElement, convertCurve25519FieldElementToRcCiphertext, convertCurve25519FieldElementToRcCounter, convertCurve25519FieldElementToRcKey, convertCurve25519FieldElementToRcPlaintext, convertCurve25519FieldElementToU256, convertI1024ToI128, convertI1024ToI16, convertI1024ToI256, convertI1024ToI32, convertI1024ToI512, convertI1024ToI64, convertI1024ToI8, convertI1024ToNumber, convertI1024ToU1024, convertI128ToI1024, convertI128ToI16, convertI128ToI256, convertI128ToI32, convertI128ToI512, convertI128ToI64, convertI128ToI8, convertI128ToNumber, convertI128ToU128, convertI16ToI1024, convertI16ToI128, convertI16ToI256, convertI16ToI32, convertI16ToI512, convertI16ToI64, convertI16ToI8, convertI16ToNumber, convertI16ToU16, convertI256ToI1024, convertI256ToI128, convertI256ToI16, convertI256ToI32, convertI256ToI512, convertI256ToI64, convertI256ToI8, convertI256ToNumber, convertI256ToU256, convertI32ToI1024, convertI32ToI128, convertI32ToI16, convertI32ToI256, convertI32ToI512, convertI32ToI64, convertI32ToI8, convertI32ToNumber, convertI32ToU32, convertI512ToI1024, convertI512ToI128, convertI512ToI16, convertI512ToI256, convertI512ToI32, convertI512ToI64, convertI512ToI8, convertI512ToNumber, convertI512ToU512, convertI64ToI1024, convertI64ToI128, convertI64ToI16, convertI64ToI256, convertI64ToI32, convertI64ToI512, convertI64ToI8, convertI64ToNumber, convertI64ToU64, convertI8ToI1024, convertI8ToI128, convertI8ToI16, convertI8ToI256, convertI8ToI32, convertI8ToI512, convertI8ToI64, convertI8ToNumber, convertI8ToU8, convertNumberToI1024, convertNumberToI128, convertNumberToI16, convertNumberToI256, convertNumberToI32, convertNumberToI512, convertNumberToI64, convertNumberToI8, convertNumberToU1024, convertNumberToU128, convertNumberToU16, convertNumberToU256, convertNumberToU32, convertNumberToU512, convertNumberToU64, convertNumberToU8, convertPoseidonCiphertextToBn254FieldElement, convertPoseidonCiphertextToU256, convertPoseidonHashToBn254FieldElement, convertPoseidonHashToU256, convertPoseidonKeyToBn254FieldElement, convertPoseidonKeyToU256, convertPoseidonPlaintextToBn254FieldElement, convertPoseidonPlaintextToU256, convertRcCiphertextToCurve25519FieldElement, convertRcCiphertextToU256, convertRcCounterToCurve25519FieldElement, convertRcCounterToU256, convertRcEncryptionNonceToU128, convertRcKeyToCurve25519FieldElement, convertRcKeyToU256, convertRcPlaintextToCurve25519FieldElement, convertRcPlaintextToU256, convertSharedSecretToX25519Bytes, convertU1024ToI1024, convertU1024ToNumber, convertU1024ToU128, convertU1024ToU16, convertU1024ToU256, convertU1024ToU32, convertU1024ToU512, convertU1024ToU64, convertU1024ToU8, convertU128ToI128, convertU128ToNumber, convertU128ToRcEncryptionNonce, convertU128ToU1024, convertU128ToU16, convertU128ToU256, convertU128ToU32, convertU128ToU512, convertU128ToU64, convertU128ToU8, convertU16ToI16, convertU16ToNumber, convertU16ToU1024, convertU16ToU128, convertU16ToU256, convertU16ToU32, convertU16ToU512, convertU16ToU64, convertU16ToU8, convertU256ToBase85Limbs, convertU256ToBn254FieldElement, convertU256ToCurve25519FieldElement, convertU256ToI256, convertU256ToNumber, convertU256ToPoseidonCiphertext, convertU256ToPoseidonHash, convertU256ToPoseidonKey, convertU256ToPoseidonPlaintext, convertU256ToRcCiphertext, convertU256ToRcCounter, convertU256ToRcKey, convertU256ToRcPlaintext, convertU256ToU1024, convertU256ToU128, convertU256ToU16, convertU256ToU32, convertU256ToU512, convertU256ToU64, convertU256ToU8, convertU32ToI32, convertU32ToNumber, convertU32ToU1024, convertU32ToU128, convertU32ToU16, convertU32ToU256, convertU32ToU512, convertU32ToU64, convertU32ToU8, convertU512ToI512, convertU512ToNumber, convertU512ToU1024, convertU512ToU128, convertU512ToU16, convertU512ToU256, convertU512ToU32, convertU512ToU64, convertU512ToU8, convertU64ToI64, convertU64ToNumber, convertU64ToU1024, convertU64ToU128, convertU64ToU16, convertU64ToU256, convertU64ToU32, convertU64ToU512, convertU64ToU8, convertU8ToI8, convertU8ToNumber, convertU8ToU1024, convertU8ToU128, convertU8ToU16, convertU8ToU256, convertU8ToU32, convertU8ToU512, convertU8ToU64, convertX25519BytesToSharedSecret, convertX25519BytesToX25519PrivateKey, convertX25519BytesToX25519PublicKey, convertX25519PrivateKeyToX25519Bytes, convertX25519PublicKeyToX25519Bytes, createBase85Limb, createBn254FieldElement, createCurve25519FieldElement, createMicroLamportsPerAcu, createOptionalData32, createPoseidonKey, createRcCiphertext, createRcEncryptionNonce, createRcKey, createRcPlaintext, createU128, createU256, createU32, createU64, decodeBeBytesToBn254FieldElement, decodeBeBytesToCurve25519FieldElement, decodeBeBytesToRcEncryptionNonce, decodeLeBytesToBn254FieldElement, decodeLeBytesToCurve25519FieldElement, decodeLeBytesToRcEncryptionNonce, defaultExtractUtcComponents, defaultGetUtcNow, encodeBn254FieldElementToBeBytes, encodeBn254FieldElementToLeBytes, encodeCurve25519FieldElementToBeBytes, encodeCurve25519FieldElementToLeBytes, encodeRcEncryptionNonceToBeBytes, encodeRcEncryptionNonceToLeBytes, extractClusterOffsetFromMxeAccount, extractTransferFeeConfig, extractUtcComponents, generateComputationOffset, generateRandomNonce, generateRandomU128, generateRandomU256, generateRandomU64, getByteAt, getExtractUtcComponentsFunction, getUtcNow, getUtcNowFunction, splitAddressToLowHigh, splitU256IntoTwoU128s, splitX25519PublicKeyIntoTwoU128s } from '../chunk-UXMQI6B7.js';
-export { TOKEN_POOL_SEED, computeCompDefOffset, computeStructSeed, findActiveStealthPoolPda, findArciumClusterPda, findArciumCompDefPda, findArciumComputationPda, findArciumExecutingPoolPda, findArciumInfrastructurePdas, findArciumMempoolPda, findArciumMxePda, findClaimInputBufferPda, findConfidentialNullifierBufferPda, findEncryptedTokenAccountPda, findEncryptedUserAccountPda, findFeeSchedulePda, findNetworkComplianceGrantPda, findNullifierSetPdas, findProtocolConfigPda, findProtocolFeeVaultPda, findPublicClaimComputationDataPda, findPublicClaimInputBufferPda, findPublicNullifierBufferPda, findPublicUtxoInputBufferPda, findRelayerFeeSchedulePda, findRelayerFeeVaultPda, findRelayerPda, findSharedComplianceGrantPda, findStealthPoolPda, findTokenPoolPda, findUserComplianceGrantPda, findUtxoInputBufferPda, findVerifyingKeyPda } from '../chunk-MKNCBUFA.js';
+export { TOKEN_POOL_SEED, computeCompDefOffset, computeStructSeed, findActiveStealthPoolPda, findArciumClusterPda, findArciumCompDefPda, findArciumComputationPda, findArciumExecutingPoolPda, findArciumInfrastructurePdas, findArciumMempoolPda, findArciumMxePda, findClaimInputBufferPda, findConfidentialNullifierBufferPda, findEncryptedTokenAccountPda, findEncryptedUserAccountPda, findFeeSchedulePda, findNetworkComplianceGrantPda, findNullifierSetPdas, findProtocolConfigPda, findProtocolFeeVaultPda, findPublicClaimComputationDataPda, findPublicClaimInputBufferPda, findPublicNullifierBufferPda, findPublicUtxoInputBufferPda, findRelayerFeeSchedulePda, findRelayerFeeVaultPda, findRelayerPda, findSharedComplianceGrantPda, findStealthPoolPda, findTokenPoolPda, findUserComplianceGrantPda, findUtxoInputBufferPda, findVerifyingKeyPda } from '../chunk-KH3YTDKA.js';
 import '../chunk-EEKF4553.js';
 export { ConversionError, assertBigintInRange, assertByteLength, assertNumberInRange, createBytes, createSharedSecret, createU1024BeBytes, createU1024LeBytes, createU128BeBytes, createU128LeBytes, createU16BeBytes, createU16LeBytes, createU256BeBytes, createU256LeBytes, createU32BeBytes, createU32LeBytes, createU512BeBytes, createU512LeBytes, createU64BeBytes, createU64LeBytes, createU8BeBytes, createU8LeBytes, createX25519Bytes, createX25519PrivateKey, createX25519PublicKey, isConversionError } from '../chunk-UOFYS6M3.js';
 export { convertU1024BeBytesToU1024LeBytes, convertU1024LeBytesToU1024BeBytes, convertU128BeBytesToU128LeBytes, convertU128LeBytesToU128BeBytes, convertU16BeBytesToU16LeBytes, convertU16LeBytesToU16BeBytes, convertU256BeBytesToU256LeBytes, convertU256LeBytesToU256BeBytes, convertU32BeBytesToU32LeBytes, convertU32LeBytesToU32BeBytes, convertU512BeBytesToU512LeBytes, convertU512LeBytesToU512BeBytes, convertU64BeBytesToU64LeBytes, convertU64LeBytesToU64BeBytes, convertU8BeBytesToU8LeBytes, convertU8LeBytesToU8BeBytes, decodeU1024BeBytesToU1024, decodeU1024LeBytesToU1024, decodeU128BeBytesToU128, decodeU128LeBytesToU128, decodeU16BeBytesToU16, decodeU16LeBytesToU16, decodeU256BeBytesToU256, decodeU256LeBytesToU256, decodeU32BeBytesToU32, decodeU32LeBytesToU32, decodeU512BeBytesToU512, decodeU512LeBytesToU512, decodeU64BeBytesToU64, decodeU64LeBytesToU64, decodeU8BeBytesToU8, decodeU8LeBytesToU8, encodeU1024ToU1024BeBytes, encodeU1024ToU1024LeBytes, encodeU128ToU128BeBytes, encodeU128ToU128LeBytes, encodeU16ToU16BeBytes, encodeU16ToU16LeBytes, encodeU256ToU256BeBytes, encodeU256ToU256LeBytes, encodeU32ToU32BeBytes, encodeU32ToU32LeBytes, encodeU512ToU512BeBytes, encodeU512ToU512LeBytes, encodeU64ToU64BeBytes, encodeU64ToU64LeBytes, encodeU8ToU8BeBytes, encodeU8ToU8LeBytes } from '../chunk-FQX6ZYGJ.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umbra-privacy/sdk",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "A comprehensive TypeScript SDK for Umbra Privacy",
   "author": "",
   "license": "MIT",
@@ -148,28 +148,16 @@
     "LICENSE"
   ],
   "sideEffects": false,
-  "scripts": {
-    "build": "tsup",
-    "build:watch": "tsup --watch",
-    "dev": "tsup --watch",
-    "clean": "rm -rf dist node_modules/.cache",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint . --max-warnings 0",
-    "lint:fix": "eslint . --fix",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
-  },
   "dependencies": {
     "@noble/ciphers": "^2.1.1",
     "@noble/curves": "^2.0.1",
     "@noble/hashes": "^2.0.1",
     "@solana/kit": "^6.0.1",
     "@solana/wallet-standard-features": "^1.3.0",
-    "@umbra-privacy/arcium-codama": "workspace:*",
-    "@umbra-privacy/umbra-codama": "workspace:*",
-    "@umbra-privacy/indexer-read-service-client": "workspace:*",
-    "@wallet-standard/core": "^1.1.0"
+    "@wallet-standard/core": "^1.1.0",
+    "@umbra-privacy/umbra-codama": "2.0.1",
+    "@umbra-privacy/indexer-read-service-client": "2.0.1",
+    "@umbra-privacy/arcium-codama": "2.0.1"
   },
   "devDependencies": {
     "@arcium-hq/client": "0.8.3",
@@ -208,5 +196,17 @@
     "typescript",
     "solana",
     "cryptography"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist node_modules/.cache",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  }
+}

package/dist/chunk-CFFLOE7D.cjs.map

@@ -1 +0,0 @@
-{"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":["sha256","__name","getProgramDerivedAddress","encodeU128ToU128LeBytes","getAddressEncoder","getAccountOffsetEncoder","ARCIUM_MXE_ACCOUNT_SEED","assertU32","ARCIUM_MEMPOOL_SEED","encodeU32ToU32LeBytes","ARCIUM_EXEC_POOL_SEED","assertU64","ARCIUM_COMPUTATION_SEED","encodeU64ToU64LeBytes","ARCIUM_COMP_DEF_SEED","ARCIUM_CLUSTER_SEED","getArciumX25519PublicKeyEncoder","getArciumX25519NonceEncoder"],"mappings":"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","file":"chunk-CFFLOE7D.cjs","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"]}