@arcanetech/privacy-sdk-stellar 0.2.3 → 0.4.1

package/dist/node.js

@@ -3,12 +3,8 @@ import "@arcanetech/privacy-sdk-core";
 
 // src/assets/load-node.ts
 async function loadNodeAssets(assets) {
-  const [sdkWasm, circuitWasm, provingKey] = await Promise.all([
-    readAssetFile(assets.sdkWasmPath),
-    readAssetFile(assets.circuitWasmPath),
-    readAssetFile(assets.provingKeyPath)
-  ]);
-  return { sdkWasm, circuitWasm, provingKey };
+  const sdkWasm = await readAssetFile(assets.sdkWasmPath);
+  return { sdkWasm };
 }
 async function readAssetFile(path) {
   const { readFile } = await import("fs/promises");
@@ -62,16 +58,6 @@ import {
 import {
   unsupportedDisclosureError
 } from "@arcanetech/privacy-sdk-core";
-
-// src/transact/transfer-source/types.ts
-function isPendingClaimSource(from) {
-  return typeof from === "object" && "kind" in from && from.kind === "pendingClaim";
-}
-function isPrivateAddressTransferFrom(from) {
-  return typeof from === "string";
-}
-
-// src/policy/disclosure-routes.ts
 function validatePublicRecipientTransferDisclosure(disclosure) {
   const errors = [];
   const fields = [
@@ -98,38 +84,9 @@ function validatePublicRecipientTransferDisclosure(disclosure) {
   }
   return errors;
 }
-function validatePendingClaimTransferDisclosure(disclosure) {
-  const errors = [];
-  const fields = [
-    "senderAddress",
-    "assetAddress",
-    "amount"
-  ];
-  const messages = {
-    senderAddress: "Pending claim transfers must publish the sender address.",
-    assetAddress: "Pending claim transfers must publish the asset identifier.",
-    amount: "Pending claim transfers must publish the transfer amount."
-  };
-  for (const field of fields) {
-    if (disclosure[field] === "private") {
-      errors.push(
-        unsupportedDisclosureError(
-          field,
-          "private",
-          ["public"],
-          messages[field] ?? "This transfer route requires public disclosure."
-        )
-      );
-    }
-  }
-  return errors;
-}
 function isPublicStellarRecipientTransfer(intent) {
   return intent.disclosure.recipientAddress === "public";
 }
-function isPendingClaimTransfer(intent) {
-  return isPendingClaimSource(intent.from);
-}
 
 // src/policy/disclosure.ts
 function isPublicWithdrawRoute(intent) {
@@ -152,9 +109,6 @@ function validateStellarDisclosure(kind, intent) {
   if (kind === "transfer" && isPublicStellarRecipientTransfer(intent)) {
     errors.push(...validatePublicRecipientTransferDisclosure(intent.disclosure));
   }
-  if (kind === "transfer" && isPendingClaimTransfer(intent)) {
-    errors.push(...validatePendingClaimTransferDisclosure(intent.disclosure));
-  }
   if (kind === "withdraw" && isPublicWithdrawRoute(intent)) {
     rejectPrivatePublicRouteFields(
       intent,
@@ -350,118 +304,26 @@ function handleSubmissionFailure(error, options, eventId) {
 }
 
 // src/adapters/record-selection.ts
-import { insufficientStateError as insufficientStateError3 } from "@arcanetech/privacy-sdk-core";
+import { insufficientStateError as insufficientStateError2 } from "@arcanetech/privacy-sdk-core";
 
-// src/transact/transfer-source/resolve.ts
-import { Buffer as Buffer2 } from "buffer";
-import {
-  insufficientStateError,
-  invalidIntentError
-} from "@arcanetech/privacy-sdk-core";
-var FIELD_HEX_LENGTH = 64;
-var SCALAR_HEX_PATTERN = new RegExp(`^(0x)?[0-9a-f]{${FIELD_HEX_LENGTH}}$`, "iu");
-function hexToDecimal(hex) {
-  const clean = (hex ?? "").trim().replace(/^0x/u, "");
-  return BigInt(`0x${clean || "0"}`).toString();
-}
-function recoveryScalarHexFromClaim(claim) {
-  const encoded = claim.encryptedRecoveryBase64?.trim();
-  if (!encoded) {
-    throw invalidIntentError(
-      "from",
-      "Pending claim is missing encrypted recovery data."
-    );
-  }
-  const scalar = Buffer2.from(encoded, "base64").toString("utf8").trim();
-  if (!SCALAR_HEX_PATTERN.test(scalar)) {
-    throw invalidIntentError("from", "Pending claim recovery payload is not a scalar.");
-  }
-  return scalar.replace(/^0x/iu, "");
-}
-function pendingClaimToCoin(claim) {
-  return {
-    value: claim.amount.toString(),
-    nullifier: hexToDecimal(claim.nullifierFieldHex),
-    secret: hexToDecimal(claim.secretHex),
-    commitment: hexToDecimal(claim.commitmentHex),
-    asset_hi: hexToDecimal(claim.assetHiHex),
-    asset_lo: hexToDecimal(claim.assetLoHex)
-  };
-}
-function pendingClaimToConsumedRecord(input) {
-  const coin = pendingClaimToCoin(input.claim);
-  const nullifierHex = input.claim.nullifierHex ?? input.claim.futureNullifierHashHex;
-  return {
-    id: `pending-claim-${input.claim.id}`,
-    owner: input.walletPublicKey.trim(),
-    asset: input.claim.asset,
-    amount: input.claim.amount,
-    consumed: false,
-    status: "finalized",
-    poolContract: input.poolContract,
-    coinNote: coin,
-    ...input.claim.commitmentHex ? { commitmentHex: input.claim.commitmentHex } : {},
-    ...nullifierHex ? { nullifierHex } : {}
-  };
-}
-function readPendingClaimFromSource(source) {
-  if ("claim" in source) {
-    return source.claim;
-  }
-  return void 0;
-}
-async function resolvePendingClaimSource(input) {
-  const embedded = readPendingClaimFromSource(input.from);
-  if (embedded) {
-    return embedded;
-  }
-  if (!("claimId" in input.from)) {
-    throw invalidIntentError("from", "Pending claim id is required.");
-  }
-  const claimId = input.from.claimId.trim();
-  if (!claimId) {
-    throw invalidIntentError("from", "Pending claim id is required.");
-  }
-  const claims = await input.getPendingClaims();
-  const claim = claims.items.find((entry) => entry.id === claimId);
-  if (!claim) {
-    throw insufficientStateError(
-      "pending_claim_not_found",
-      "Pending claim was not found in local state.",
-      { claimId }
-    );
-  }
-  return claim;
-}
-function assertPendingClaimOwner(input) {
-  const owner = input.claim.owner.trim();
-  const wallet = input.walletPublicKey.trim();
-  if (owner !== wallet) {
-    throw insufficientStateError(
-      "pending_claim_owner_mismatch",
-      "Pending claim owner does not match the connected wallet.",
-      { claimOwner: owner, walletPublicKey: wallet }
-    );
-  }
+// src/transact/transfer-source/types.ts
+function isPrivateAddressTransferFrom(from) {
+  return typeof from === "string";
 }
+
+// src/transact/transfer-source/resolve.ts
 function readTransferFromPrivateAddress(from) {
-  if (isPendingClaimSource(from)) {
-    throw invalidIntentError(
-      "from",
-      "Private address is unavailable for a pending claim transfer source."
-    );
-  }
   return from.trim();
 }
 
-// src/transact/transfer-source/verify.ts
-import { executionError as executionError3 } from "@arcanetech/privacy-sdk-core";
+// src/transact/transfer-source/verify-private-records.ts
+import { executionError as executionError3, insufficientStateError } from "@arcanetech/privacy-sdk-core";
 
 // src/contracts/pool/pool-domain-service.ts
-import { Buffer as Buffer3 } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 function hexToBuffer(hex) {
   const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-  return Buffer3.from(clean, "hex");
+  return Buffer2.from(clean, "hex");
 }
 async function readNullifierConsumedOnChain(input) {
   const client = input.contractContext.createPoolClient({
@@ -504,7 +366,7 @@ function createInternalPoolContractClient(input) {
     networkPassphrase: input.networkPassphrase,
     walletPublicKey: input.walletPublicKey
   });
-  return new PrivacyPoolContractClient({
+  const client = new PrivacyPoolContractClient({
     contractId: input.contractId,
     networkPassphrase: input.networkPassphrase,
     rpcUrl: input.sorobanRpcUrl,
@@ -512,6 +374,7 @@ function createInternalPoolContractClient(input) {
     publicKey: input.walletPublicKey,
     signTransaction: signBinding
   });
+  return client;
 }
 
 // src/contracts/registry/create-registry-client.ts
@@ -574,15 +437,45 @@ function readPoolClientFactory(environment) {
   return requireContractContext(environment).createPoolClient;
 }
 
+// src/transact/private-address/record-coin.ts
+function requireCoinNoteFromRecord(record) {
+  if (!record.coinNote) {
+    throw new Error(`Private record ${record.id} is missing coin note data.`);
+  }
+  return record.coinNote;
+}
+function findCommitmentLeafIndex(commitments, commitment) {
+  return commitments.indexOf(commitment);
+}
+function buildPrivateRecordFromDeposit(input) {
+  return {
+    id: input.commitmentHex,
+    owner: input.owner,
+    asset: input.assetId,
+    amount: input.amount,
+    consumed: false,
+    status: input.status ?? "pending",
+    poolContract: input.poolContract,
+    commitmentHex: input.commitmentHex,
+    privateAddress: input.privateAddress,
+    amountDisplay: input.amountDisplay,
+    coinNote: input.coin,
+    depositScalarHex: input.depositScalarHex,
+    precommitementHex: input.precommitementHex,
+    ...input.txHash ? { txHash: input.txHash } : {}
+  };
+}
+
 // src/transact/pool/service.ts
 import {
+  PrivacyPoolSDK as PrivacyPoolSDK2,
   decodeDecodedEphemeralKey,
   randomFrDecimal253,
   scalarHexToFrDecimal as scalarHexToFrDecimal2
-} from "@auditable/privacy-pool-zk-sdk";
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
 
 // src/transact/merkle/field-decimal.ts
-import { Buffer as Buffer5 } from "buffer";
+import { Buffer as Buffer4 } from "buffer";
 var BN254 = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
 var MERKLE_ROOT_BYTE_LENGTH = 32;
 var DECIMAL_STRING_RADIX = 10;
@@ -592,7 +485,7 @@ function merkleRootBufferToFrDecimal(root) {
       `expected ${MERKLE_ROOT_BYTE_LENGTH}-byte merkle root, got ${root.length}`
     );
   }
-  const hex = Buffer5.from(root).toString("hex");
+  const hex = Buffer4.from(root).toString("hex");
   return (BigInt(`0x${hex}`) % BN254).toString(DECIMAL_STRING_RADIX);
 }
 
@@ -602,8 +495,12 @@ import {
   decodeStealthAddress,
   encodeStealthAddress,
   recipientPublicKeysDecimalFromStealthAddress
-} from "@auditable/privacy-pool-zk-sdk";
-import { DEFAULT_STEALTH_SIGN_NONCE } from "@auditable/privacy-pool-zk-sdk";
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
+import { DEFAULT_STEALTH_SIGN_NONCE } from "@arcanetech/stellar-privacy-pool-zk-sdk";
+import {
+  OWNER_BOUND_NOTE_SCHEMA_VERSION,
+  spendScalarHexFromStellarSignature
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
 function decodePrivateAddress(value) {
   const decodeAddress = decodeStealthAddress;
   return decodeAddress(value);
@@ -632,26 +529,26 @@ function privateAddressSdk(sdk) {
     );
   }
   return {
-    generatePrivateAddressFromStellarSignature: (signature) => generator.call(sdk, signature)
+    generatePrivateAddressFromStellarSignature: (signature, domain) => generator.call(sdk, signature, domain)
   };
 }
 
 // src/transact/proofs/withdraw/transact-proof.ts
-import { withdrawObjectFromMerkleWitness as withdrawObjectFromMerkleWitness2 } from "@auditable/privacy-pool-zk-sdk";
+import { withdrawObjectFromMerkleWitness as withdrawObjectFromMerkleWitness2 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
 
 // src/transact/proofs/transaction-input.ts
-import { Buffer as Buffer7 } from "buffer";
+import { Buffer as Buffer6 } from "buffer";
 import { StrKey as StrKey2 } from "@stellar/stellar-sdk";
 
 // src/transact/stellar/token-contract.ts
-import { Buffer as Buffer6 } from "buffer";
+import { Buffer as Buffer5 } from "buffer";
 import { StrKey } from "@stellar/stellar-sdk";
 var CONTRACT_ID_BYTE_LENGTH = 32;
 var HEX_CHARS_PER_BYTE = 2;
 var CONTRACT_ID_HEX_CHAR_LENGTH = CONTRACT_ID_BYTE_LENGTH * HEX_CHARS_PER_BYTE;
 var CONTRACT_ID_HEX = /^(?:0x)?([0-9a-f]{64})$/i;
 function encodeContractFromHex(hexPayload) {
-  return StrKey.encodeContract(Buffer6.from(hexPayload, "hex"));
+  return StrKey.encodeContract(Buffer5.from(hexPayload, "hex"));
 }
 function normalizeSorobanContractId(raw) {
   const trimmed = raw.trim();
@@ -677,10 +574,14 @@ function resolveTokenContractId(tokenContractRaw) {
 }
 
 // src/transact/proofs/transaction-input.ts
+var ZERO_PUBLIC_WITHDRAW_ADDRESS = {
+  withdrawAddressHi: "0",
+  withdrawAddressLo: "0"
+};
 var CONTRACT_ADDRESS_HALF_BYTES = 16;
 var CONTRACT_ADDRESS_BYTES = 32;
 function bytes16ToDecimal(bytes) {
-  return BigInt(`0x${Buffer7.from(bytes).toString("hex")}`).toString();
+  return BigInt(`0x${Buffer6.from(bytes).toString("hex")}`).toString();
 }
 function tokenAddressFrParts(tokenAddress) {
   const normalized = resolveTokenContractId(tokenAddress);
@@ -696,98 +597,116 @@ function withTokenAddressPublicInputs(base, tokenAddress) {
   return {
     ...base,
     tokenAddressHi: hi,
-    tokenAddressLo: lo
+    tokenAddressLo: lo,
+    withdrawAddressHi: base.withdrawAddressHi ?? ZERO_PUBLIC_WITHDRAW_ADDRESS.withdrawAddressHi,
+    withdrawAddressLo: base.withdrawAddressLo ?? ZERO_PUBLIC_WITHDRAW_ADDRESS.withdrawAddressLo,
+    escrowRecipientHi: base.escrowRecipientHi ?? "0",
+    escrowRecipientLo: base.escrowRecipientLo ?? "0",
+    sweepOutputOwnerPubX: base.sweepOutputOwnerPubX ?? "0",
+    sweepOutputOwnerPubY: base.sweepOutputOwnerPubY ?? "0"
+  };
+}
+function publicWithdrawAddressLimbs(parameters) {
+  if (parameters.publicWithdrawalAmount === "0") {
+    return {
+      withdrawAddressHi: ZERO_PUBLIC_WITHDRAW_ADDRESS.withdrawAddressHi,
+      withdrawAddressLo: ZERO_PUBLIC_WITHDRAW_ADDRESS.withdrawAddressLo
+    };
+  }
+  return {
+    withdrawAddressHi: parameters.destinationHi,
+    withdrawAddressLo: parameters.destinationLo
   };
 }
 function tokenAddressToAssetLeg(tokenAddress) {
   const { hi, lo } = tokenAddressFrParts(tokenAddress);
   return [hi, lo];
 }
-function buildZeroPublicLegs() {
+function buildZeroPublicLegs(publicNInputs = 1, publicNOutputs = 1) {
   return {
-    publicWithdrawnAssets: [["0", "0"]],
-    publicDepositedAssets: [["0", "0"]],
-    publicDeposits: ["0"],
-    publicWithdrawals: ["0"]
+    publicWithdrawnAssets: Array.from(
+      { length: publicNOutputs },
+      () => ["0", "0"]
+    ),
+    publicDepositedAssets: Array.from(
+      { length: publicNInputs },
+      () => ["0", "0"]
+    ),
+    publicDeposits: Array.from({ length: publicNInputs }, () => "0"),
+    publicWithdrawals: Array.from({ length: publicNOutputs }, () => "0")
   };
 }
-function buildPublicDepositLegs(tokenAddress, amount) {
-  const legs = buildZeroPublicLegs();
+function buildPublicDepositLegs(tokenAddress, amount, publicNInputs = 1, publicNOutputs = 1) {
+  const legs = buildZeroPublicLegs(publicNInputs, publicNOutputs);
   return {
     ...legs,
-    publicDepositedAssets: [tokenAddressToAssetLeg(tokenAddress)],
-    publicDeposits: [amount]
+    publicDepositedAssets: [
+      tokenAddressToAssetLeg(tokenAddress),
+      ...legs.publicDepositedAssets.slice(1)
+    ],
+    publicDeposits: [amount, ...legs.publicDeposits.slice(1)]
   };
 }
-function buildPublicWithdrawLegs(tokenAddress, amount) {
-  const legs = buildZeroPublicLegs();
+function buildPublicWithdrawLegs(tokenAddress, amount, publicNInputs = 1, publicNOutputs = 1) {
+  const legs = buildZeroPublicLegs(publicNInputs, publicNOutputs);
   return {
     ...legs,
-    publicWithdrawnAssets: [tokenAddressToAssetLeg(tokenAddress)],
-    publicWithdrawals: [amount]
+    publicWithdrawnAssets: [
+      tokenAddressToAssetLeg(tokenAddress),
+      ...legs.publicWithdrawnAssets.slice(1)
+    ],
+    publicWithdrawals: [amount, ...legs.publicWithdrawals.slice(1)]
   };
 }
 
-// src/transact/proofs/confidential/helpers.ts
+// src/transact/zk/slots.ts
 import {
-  ed25519PubkeyPayloadHexToWithdrawFrDecimals,
-  withdrawObjectFromMerkleWitness
-} from "@auditable/privacy-pool-zk-sdk";
-import { StrKey as StrKey3 } from "@stellar/stellar-sdk";
-import { Buffer as Buffer8 } from "buffer";
-
-// src/transact/encoding/priv-key-scalar-from-recipient-hex.ts
-import { BN254_BABYJUB_SCALAR_MAX_EXCLUSIVE } from "@auditable/privacy-pool-zk-sdk";
-var SCALAR_HEX_CHAR_LENGTH = 64;
-var DECIMAL_RADIX = 10;
-var BIGINT_ONE = 1n;
-function normalizeRecipientScalarHex(hexInput) {
-  const trimmed = hexInput.trim().replace(/^0x/iu, "");
-  if (!/^[0-9a-f]*$/iu.test(trimmed)) {
-    throw new Error("recipient scalar hex must be hexadecimal");
-  }
-  const withLeadingNibble = trimmed.length % 2 === 0 ? trimmed : `0${trimmed}`;
-  const lower = withLeadingNibble.toLowerCase();
-  const padded = lower.padStart(SCALAR_HEX_CHAR_LENGTH, "0").slice(-SCALAR_HEX_CHAR_LENGTH);
-  if (padded.length !== SCALAR_HEX_CHAR_LENGTH) {
+  padDepositSlots,
+  padPublicLegs,
+  padWithdrawSlots
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
+function padWithdrawSlotsToLayout(sdk, slots) {
+  return padWithdrawSlots(slots, sdk.getLayout().nIns);
+}
+function padDepositSlotsToLayout(sdk, slots) {
+  return padDepositSlots(slots, sdk.getLayout().nOuts);
+}
+function padPublicLegsToLayout(sdk, legs) {
+  const { publicNInputs, publicNOutputs } = sdk.getLayout();
+  return padPublicLegs(legs, publicNInputs, publicNOutputs);
+}
+function padStrings(values, length, fill) {
+  if (values.length > length) {
     throw new Error(
-      `recipient scalar hex must fit 32 bytes (${SCALAR_HEX_CHAR_LENGTH} hex chars)`
+      `expected at most ${String(length)} application-id slots, got ${String(values.length)}`
     );
   }
-  return padded;
+  return [...values, ...Array.from({ length: length - values.length }, () => fill)];
 }
-function privKeyScalarDecimalFromRecipientScalarHex(hexInput) {
-  const hex = normalizeRecipientScalarHex(hexInput);
-  const value = BigInt(`0x${hex}`);
-  const mask = BN254_BABYJUB_SCALAR_MAX_EXCLUSIVE - BIGINT_ONE;
-  return (value & mask).toString(DECIMAL_RADIX);
+function buildApplicationIdHints(input) {
+  const { nIns, nOuts } = input.sdk.getLayout();
+  return [
+    ...padStrings(input.inputIds, nIns, "0"),
+    ...padStrings(input.outputIds, nOuts, "0")
+  ];
+}
+function uniformApplicationIdHints(applicationId, nAuditSlots) {
+  return Array.from({ length: nAuditSlots }, () => applicationId);
 }
 
 // src/transact/proofs/confidential/helpers.ts
+import { withdrawObjectFromMerkleWitness } from "@arcanetech/stellar-privacy-pool-zk-sdk";
 var MIN_CONFIDENTIAL_TRANSFER_STROOPS = 1n;
 var ZERO_STROOPS = 0n;
-function leafEphemeralCoords(xHex, yHex) {
-  const coords = {};
-  Object.defineProperty(coords, "x", {
-    value: xHex,
-    enumerable: true,
-    writable: true
-  });
-  Object.defineProperty(coords, "y", {
-    value: yHex,
-    enumerable: true,
-    writable: true
-  });
-  return coords;
-}
 function withdrawWitnessForCoin(parameters) {
-  const { sdk, coin, state, xHex, yHex } = parameters;
+  const { sdk, coin, state } = parameters;
   const witness = sdk.buildWithdrawMerkleWitness(coin, state);
   const withdrawApplicationId = coin.application_id ?? parameters.applicationId;
   const withdrawObject = withdrawObjectFromMerkleWitness(
     witness,
-    leafEphemeralCoords(xHex, yHex),
-    withdrawApplicationId
+    parameters.ownerPubHex,
+    withdrawApplicationId,
+    parameters.privKeyScalar
   );
   return { witness, withdrawObject };
 }
@@ -796,16 +715,16 @@ function dualWithdrawLegsWithSharedRoot(parameters) {
     sdk: parameters.sdk,
     coin: parameters.coinA,
     state: parameters.state,
-    xHex: parameters.ephemeralA.xHex,
-    yHex: parameters.ephemeralA.yHex,
+    ownerPubHex: parameters.ownerPubHex,
+    privKeyScalar: parameters.privKeyScalar,
     applicationId: parameters.applicationId
   });
   const legB = withdrawWitnessForCoin({
     sdk: parameters.sdk,
     coin: parameters.coinB,
     state: parameters.state,
-    xHex: parameters.ephemeralB.xHex,
-    yHex: parameters.ephemeralB.yHex,
+    ownerPubHex: parameters.ownerPubHex,
+    privKeyScalar: parameters.privKeyScalar,
     applicationId: parameters.applicationId
   });
   if (legA.witness.stateRoot !== legB.witness.stateRoot) {
@@ -813,15 +732,6 @@ function dualWithdrawLegsWithSharedRoot(parameters) {
   }
   return { legA, legB };
 }
-function senderWithdrawFrAndScalar(parameters) {
-  const pkRaw = StrKey3.decodeEd25519PublicKey(parameters.senderGAddress);
-  const pkHex = Buffer8.from(pkRaw).toString("hex");
-  const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals(pkHex);
-  const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
-    parameters.senderPrivKeyScalarHex
-  );
-  return { hi, lo, privKeyScalar };
-}
 function requireChangeRecipientWhenPartial(changeStroops, selfPrivateAddressStpl1ForChange) {
   if (changeStroops > ZERO_STROOPS) {
     const stpl1 = selfPrivateAddressStpl1ForChange?.trim() ?? "";
@@ -846,15 +756,15 @@ function changeStroopsAfterDualTransfer(transferStroops, totalNotes) {
 import {
   DEMO_AUDIT_PUBLIC_KEY,
   resolveTransactionAuditParams
-} from "@auditable/privacy-pool-zk-sdk";
-import { Buffer as Buffer9 } from "buffer";
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
+import { Buffer as Buffer7 } from "buffer";
 var UNCOMPRESSED_PREFIX = "04";
 var UNCOMPRESSED_HEX_LENGTH = 130;
 var XY_HEX_LENGTH = 128;
 var X_OFFSET_END = 32;
 var Y_OFFSET_START = 32;
 var Y_OFFSET_END = 64;
-var DECIMAL_RADIX2 = 10;
+var DECIMAL_RADIX = 10;
 var BN254_FR_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
 var BABYJUBJUB_A = 168700n;
 var BABYJUBJUB_D = 168696n;
@@ -874,13 +784,13 @@ function parseAuditPublicKeyFromEnvHex(raw) {
       "Audit public key must be uncompressed 65-byte hex (04 + X + Y) or 64-byte X+Y hex"
     );
   }
-  const bytes = Buffer9.from(payload, "hex");
+  const bytes = Buffer7.from(payload, "hex");
   const auditPublicKeyXDecimal = BigInt(
     `0x${bytes.subarray(0, X_OFFSET_END).toString("hex")}`
-  ).toString(DECIMAL_RADIX2);
+  ).toString(DECIMAL_RADIX);
   const auditPublicKeyYDecimal = BigInt(
     `0x${bytes.subarray(Y_OFFSET_START, Y_OFFSET_END).toString("hex")}`
-  ).toString(DECIMAL_RADIX2);
+  ).toString(DECIMAL_RADIX);
   if (!passesBabyJubCurveCheck(
     BigInt(auditPublicKeyXDecimal),
     BigInt(auditPublicKeyYDecimal)
@@ -892,7 +802,8 @@ function parseAuditPublicKeyFromEnvHex(raw) {
 function buildPoolTransactionAuditParameters(input) {
   return resolveTransactionAuditParams(
     input.applicationId,
-    input.auditPublicKey ?? DEMO_AUDIT_PUBLIC_KEY
+    input.auditPublicKey ?? DEMO_AUDIT_PUBLIC_KEY,
+    input.nAuditSlots
   );
 }
 function resolvePoolApplicationId(applicationId) {
@@ -906,24 +817,24 @@ function resolvePoolApplicationId(applicationId) {
 }
 
 // src/transact/proofs/withdraw/helpers.ts
-import { ed25519PubkeyPayloadHexToWithdrawFrDecimals as ed25519PubkeyPayloadHexToWithdrawFrDecimals2 } from "@auditable/privacy-pool-zk-sdk";
+import { ed25519PubkeyPayloadHexToWithdrawFrDecimals } from "@arcanetech/stellar-privacy-pool-zk-sdk";
 
 // src/transact/stellar/account.ts
-import { StrKey as StrKey4 } from "@stellar/stellar-sdk";
-import { Buffer as Buffer10 } from "buffer";
+import { StrKey as StrKey3 } from "@stellar/stellar-sdk";
+import { Buffer as Buffer8 } from "buffer";
 var MUXED_ACCOUNT_ID_BYTE_LENGTH = 8;
 var ED25519_PUBLIC_KEY_BYTE_LENGTH = 32;
 function ed25519HexFromGAddress(trimmed) {
   try {
-    const raw = StrKey4.decodeEd25519PublicKey(trimmed);
-    return Buffer10.from(raw).toString("hex");
+    const raw = StrKey3.decodeEd25519PublicKey(trimmed);
+    return Buffer8.from(raw).toString("hex");
   } catch {
     return void 0;
   }
 }
 function ed25519HexFromMuxedAddress(trimmed) {
   try {
-    const raw = StrKey4.decodeMed25519PublicKey(trimmed);
+    const raw = StrKey3.decodeMed25519PublicKey(trimmed);
     if (raw.length === MUXED_ACCOUNT_ID_BYTE_LENGTH + ED25519_PUBLIC_KEY_BYTE_LENGTH) {
       return raw.subarray(MUXED_ACCOUNT_ID_BYTE_LENGTH).toString("hex");
     }
@@ -948,29 +859,29 @@ function ed25519PublicKeyHexFromStellarAccount(address) {
   throw new Error("Invalid destination Stellar address");
 }
 
-// src/transact/encoding/ephemeral-key.ts
-var HEX_64_RE = /^[\da-f]{64}$/iu;
-function normalizeCoordinate(value) {
-  const hex = value.trim().replace(/^0x/iu, "").toLowerCase();
-  if (!HEX_64_RE.test(hex)) {
-    throw new Error("Ephemeral key coordinate must be a 32-byte hex string.");
+// src/transact/encoding/priv-key-scalar-from-recipient-hex.ts
+import { canonicalBabyJubScalarFromInteger } from "@arcanetech/stellar-privacy-pool-zk-sdk";
+var SCALAR_HEX_CHAR_LENGTH = 64;
+var DECIMAL_RADIX2 = 10;
+function normalizeRecipientScalarHex(hexInput) {
+  const trimmed = hexInput.trim().replace(/^0x/iu, "");
+  if (!/^[0-9a-f]*$/iu.test(trimmed)) {
+    throw new Error("recipient scalar hex must be hexadecimal");
   }
-  return hex;
-}
-function parseEphemeralKeyString(input) {
-  const [xRaw, yRaw, extra] = input.split(":");
-  if (!xRaw || !yRaw || extra !== void 0) {
+  const withLeadingNibble = trimmed.length % 2 === 0 ? trimmed : `0${trimmed}`;
+  const lower = withLeadingNibble.toLowerCase();
+  const padded = lower.padStart(SCALAR_HEX_CHAR_LENGTH, "0").slice(-SCALAR_HEX_CHAR_LENGTH);
+  if (padded.length !== SCALAR_HEX_CHAR_LENGTH) {
     throw new Error(
-      'Ephemeral key must be a string in "xHex:yHex" format (32-byte hex each).'
+      `recipient scalar hex must fit 32 bytes (${SCALAR_HEX_CHAR_LENGTH} hex chars)`
     );
   }
-  return {
-    xHex: normalizeCoordinate(xRaw),
-    yHex: normalizeCoordinate(yRaw)
-  };
+  return padded;
 }
-function serializeEphemeralKeyString(point) {
-  return `${normalizeCoordinate(point.xHex)}:${normalizeCoordinate(point.yHex)}`;
+function privKeyScalarDecimalFromRecipientScalarHex(hexInput) {
+  const hex = normalizeRecipientScalarHex(hexInput);
+  const value = BigInt(`0x${hex}`);
+  return canonicalBabyJubScalarFromInteger(value).toString(DECIMAL_RADIX2);
 }
 
 // src/transact/proofs/withdraw/helpers.ts
@@ -978,7 +889,7 @@ function destinationWithdrawFrAndScalar(parameters) {
   const pkHex = ed25519PublicKeyHexFromStellarAccount(
     parameters.destinationStellarAddress
   );
-  const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals2(pkHex);
+  const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals(pkHex);
   const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
     parameters.privKeyScalarHex
   );
@@ -992,8 +903,11 @@ function buildWithdrawPublicInput(parameters) {
   return withTokenAddressPublicInputs(
     {
       stateRoot: parameters.stateRoot,
-      withdrawAddressHi: hi,
-      withdrawAddressLo: lo,
+      ...publicWithdrawAddressLimbs({
+        publicWithdrawalAmount: parameters.publicWithdrawalAmount,
+        destinationHi: hi,
+        destinationLo: lo
+      }),
       privKeyScalar
     },
     parameters.tokenAddress
@@ -1001,7 +915,7 @@ function buildWithdrawPublicInput(parameters) {
 }
 async function resolveWithdrawChangeDeposits(parameters) {
   if (parameters.changeStroops <= ZERO_STROOPS) {
-    return { deposits: ["dummy", "dummy"] };
+    return { deposits: [] };
   }
   const stpl1 = parameters.changePrivateAddressStpl1?.trim() ?? "";
   if (!stpl1) {
@@ -1015,7 +929,7 @@ async function resolveWithdrawChangeDeposits(parameters) {
     tokenAddress: parameters.tokenAddress
   });
   return {
-    deposits: [slot.deposit, "dummy"],
+    deposits: [slot.deposit],
     changeCoin: {
       commitment_hex: slot.commitment_hex,
       coin: slot.coin,
@@ -1040,14 +954,14 @@ function buildDualWithdrawPublicInput(parameters) {
     stateRoot: parameters.stateRoot,
     destinationStellarAddress: parameters.destinationStellarAddress,
     privKeyScalarHex: parameters.privKeyScalarHex,
-    tokenAddress: parameters.tokenAddress
+    tokenAddress: parameters.tokenAddress,
+    publicWithdrawalAmount: parameters.publicWithdrawalAmount
   });
 }
 async function prepareDualWithdrawProofInputs(parameters) {
-  const totalNotes = BigInt(parameters.coinA.value) + BigInt(parameters.coinB.value);
   const changeStroops = validateDualWithdrawAmounts(
     parameters.withdrawAmountStroops,
-    totalNotes,
+    BigInt(parameters.coinA.value) + BigInt(parameters.coinB.value),
     parameters.changePrivateAddressStpl1
   );
   const { legA, legB } = dualWithdrawLegsWithSharedRoot({
@@ -1055,8 +969,12 @@ async function prepareDualWithdrawProofInputs(parameters) {
     coinA: parameters.coinA,
     coinB: parameters.coinB,
     state: parameters.state,
-    ephemeralA: parseEphemeralKeyString(parameters.ephemeralAKey),
-    ephemeralB: parseEphemeralKeyString(parameters.ephemeralBKey),
+    ownerPubHex: parameters.sdk.ecdhEphemeralPublicKeyFromScalarHex(
+      parameters.privKeyScalarHex
+    ),
+    privKeyScalar: privKeyScalarDecimalFromRecipientScalarHex(
+      parameters.privKeyScalarHex
+    ),
     applicationId: parameters.applicationId
   });
   const { deposits, changeCoin } = await resolveWithdrawChangeDeposits({
@@ -1069,17 +987,19 @@ async function prepareDualWithdrawProofInputs(parameters) {
     destinationStellarAddress: parameters.destinationStellarAddress,
     privKeyScalarHex: parameters.privKeyScalarHex,
     tokenAddress: parameters.tokenAddress,
-    stateRoot: legA.witness.stateRoot
+    stateRoot: legA.witness.stateRoot,
+    publicWithdrawalAmount: parameters.withdrawAmountStroops.toString()
   });
   const audit = buildPoolTransactionAuditParameters({
     applicationId: parameters.applicationId,
+    nAuditSlots: parameters.sdk.getLayout().nAuditSlots,
     ...parameters.auditPublicKey ? { auditPublicKey: parameters.auditPublicKey } : {}
   });
   return {
     publicInput,
     audit,
-    withdrawLegs: [legA.withdrawObject, legB.withdrawObject],
     deposits,
+    withdrawLegs: [legA.withdrawObject, legB.withdrawObject],
     ...changeCoin ? { changeCoin } : {}
   };
 }
@@ -1097,35 +1017,49 @@ function validateSingleWithdrawAmounts(withdrawAmountStroops, noteStroops) {
 async function proveSingleWithdrawTransaction(parameters) {
   return parameters.sdk.proveTransaction(
     parameters.publicInput,
-    buildPublicWithdrawLegs(
-      parameters.tokenAddress,
-      parameters.withdrawAmountStroops.toString()
+    padPublicLegsToLayout(
+      parameters.sdk,
+      buildPublicWithdrawLegs(
+        parameters.tokenAddress,
+        parameters.withdrawAmountStroops.toString()
+      )
     ),
-    [parameters.primaryWithdraw, "dummy"],
-    parameters.deposits,
+    padWithdrawSlotsToLayout(parameters.sdk, [parameters.primaryWithdraw]),
+    padDepositSlotsToLayout(parameters.sdk, parameters.deposits),
     parameters.audit
   );
 }
 function buildPrimaryWithdrawForCoin(parameters) {
-  const ephemeralPoint = parseEphemeralKeyString(parameters.depositorEphemeralKey);
   const witness = parameters.sdk.buildWithdrawMerkleWitness(
     parameters.coin,
     parameters.state
   );
+  const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
+    parameters.privKeyScalarHex
+  );
+  const ownerPubHex = parameters.sdk.ecdhEphemeralPublicKeyFromScalarHex(
+    parameters.privKeyScalarHex
+  );
   const primaryWithdraw = withdrawObjectFromMerkleWitness2(
     witness,
-    leafEphemeralCoords(ephemeralPoint.xHex, ephemeralPoint.yHex),
-    parameters.applicationId
+    ownerPubHex,
+    parameters.applicationId,
+    privKeyScalar
   );
   return { witness, primaryWithdraw };
 }
 async function prepareSingleWithdrawProofInputs(parameters) {
-  const noteStroops = BigInt(parameters.coin.value);
   const changeStroops = validateSingleWithdrawAmounts(
     parameters.withdrawAmountStroops,
-    noteStroops
+    BigInt(parameters.coin.value)
   );
-  const { witness, primaryWithdraw } = buildPrimaryWithdrawForCoin(parameters);
+  const { witness, primaryWithdraw } = buildPrimaryWithdrawForCoin({
+    sdk: parameters.sdk,
+    applicationId: parameters.applicationId,
+    coin: parameters.coin,
+    state: parameters.state,
+    privKeyScalarHex: parameters.privKeyScalarHex
+  });
   const { deposits, changeCoin } = await resolveWithdrawChangeDeposits({
     changeStroops,
     changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
@@ -1136,18 +1070,19 @@ async function prepareSingleWithdrawProofInputs(parameters) {
     stateRoot: witness.stateRoot,
     destinationStellarAddress: parameters.destinationStellarAddress,
     privKeyScalarHex: parameters.privKeyScalarHex,
-    tokenAddress: parameters.tokenAddress
-  });
-  const audit = buildPoolTransactionAuditParameters({
-    applicationId: parameters.applicationId,
-    ...parameters.auditPublicKey ? { auditPublicKey: parameters.auditPublicKey } : {}
+    tokenAddress: parameters.tokenAddress,
+    publicWithdrawalAmount: parameters.withdrawAmountStroops.toString()
   });
   return {
     primaryWithdraw,
     deposits,
     changeCoin,
     publicInput,
-    audit
+    audit: buildPoolTransactionAuditParameters({
+      applicationId: parameters.applicationId,
+      nAuditSlots: parameters.sdk.getLayout().nAuditSlots,
+      ...parameters.auditPublicKey ? { auditPublicKey: parameters.auditPublicKey } : {}
+    })
   };
 }
 async function proveWithdrawTransact(parameters) {
@@ -1163,12 +1098,11 @@ async function proveWithdrawTransact(parameters) {
   });
   return {
     ...proof,
-    applicationIdsPlaintext: [
-      parameters.applicationId,
-      "0",
-      changeCoin ? parameters.applicationId : "0",
-      "0"
-    ],
+    applicationIdsPlaintext: buildApplicationIdHints({
+      sdk: parameters.sdk,
+      inputIds: [parameters.applicationId],
+      outputIds: [changeCoin ? parameters.applicationId : "0"]
+    }),
     ...changeCoin ? { changeCoin } : {}
   };
 }
@@ -1176,33 +1110,143 @@ async function proveWithdrawTransactDual(parameters) {
   const { publicInput, audit, withdrawLegs, deposits, changeCoin } = await prepareDualWithdrawProofInputs(parameters);
   const proof = await parameters.sdk.proveTransaction(
     publicInput,
-    buildPublicWithdrawLegs(
-      parameters.tokenAddress,
-      parameters.withdrawAmountStroops.toString()
+    padPublicLegsToLayout(
+      parameters.sdk,
+      buildPublicWithdrawLegs(
+        parameters.tokenAddress,
+        parameters.withdrawAmountStroops.toString()
+      )
     ),
-    withdrawLegs,
-    deposits,
+    padWithdrawSlotsToLayout(parameters.sdk, withdrawLegs),
+    padDepositSlotsToLayout(parameters.sdk, deposits),
     audit
   );
   return {
     ...proof,
-    applicationIdsPlaintext: [
-      audit.applicationId,
-      audit.applicationId,
-      changeCoin ? audit.applicationId : "0",
-      "0"
-    ],
+    applicationIdsPlaintext: buildApplicationIdHints({
+      sdk: parameters.sdk,
+      inputIds: [audit.applicationId, audit.applicationId],
+      outputIds: [changeCoin ? audit.applicationId : "0"]
+    }),
     ...changeCoin ? { changeCoin } : {}
   };
 }
 
 // src/transact/pool/service.ts
 import "buffer";
-import { PrivacyPoolSDK as PrivacyPoolSdkClass } from "@auditable/privacy-pool-zk-sdk";
+
+// src/transact/zk/circuit-config.ts
+import {
+  BundledZkCircuit
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
+
+// src/transact/environment/zk-config-nonce.ts
+var BINDING_ZK_NONCE = 3n;
+var SIX_BY_SIX_BINDING_ZK_NONCE = 7n;
+var DEFAULT_ZK_CONFIG_NONCE = BINDING_ZK_NONCE;
+function resolveZkConfigNonce(transactEnvironment) {
+  return transactEnvironment.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
+}
+
+// src/transact/zk/circuit-config.ts
+import { BundledZkCircuit as BundledZkCircuit2 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
+var DEFAULT_STELLAR_ZK_CIRCUITS = {
+  [BINDING_ZK_NONCE.toString()]: {
+    nIns: 2,
+    nOuts: 2,
+    publicNInputs: 1,
+    publicNOutputs: 1,
+    circuit: BundledZkCircuit.TwoByTwo
+  },
+  [SIX_BY_SIX_BINDING_ZK_NONCE.toString()]: {
+    nIns: 6,
+    nOuts: 6,
+    publicNInputs: 1,
+    publicNOutputs: 1,
+    circuit: BundledZkCircuit.SixBySix
+  }
+};
+function isBundledDefinition(definition) {
+  return "circuit" in definition;
+}
+async function fetchBuffer(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ZK artifact ${url}: ${String(response.status)}`);
+  }
+  return response.arrayBuffer();
+}
+async function materializeDefinition(definition) {
+  if (isBundledDefinition(definition)) {
+    const bundled = {
+      nIns: definition.nIns,
+      nOuts: definition.nOuts,
+      publicNInputs: definition.publicNInputs,
+      publicNOutputs: definition.publicNOutputs,
+      circuit: definition.circuit
+    };
+    return bundled;
+  }
+  const [zkey, circuitGraph, r1cs, provingKey] = await Promise.all([
+    fetchBuffer(definition.zkeyUrl),
+    fetchBuffer(definition.circuitGraphUrl),
+    fetchBuffer(definition.r1csUrl),
+    fetchBuffer(definition.provingKeyUrl)
+  ]);
+  const custom = {
+    nIns: definition.nIns,
+    nOuts: definition.nOuts,
+    publicNInputs: definition.publicNInputs,
+    publicNOutputs: definition.publicNOutputs,
+    zkey,
+    circuitGraph,
+    r1cs,
+    provingKey
+  };
+  return custom;
+}
+async function materializeSelectedZkCircuit(circuits, nonce) {
+  const map = stellarCircuitsOrDefault(circuits);
+  const key = nonce.toString();
+  const definition = Object.entries(map).find(([nonceKey]) => nonceKey === key)?.[1];
+  if (!definition) {
+    throw new Error(`no zk circuit configured for nonce ${key}`);
+  }
+  return { [key]: await materializeDefinition(definition) };
+}
+function stellarCircuitsOrDefault(circuits) {
+  return circuits ?? DEFAULT_STELLAR_ZK_CIRCUITS;
+}
+function optionalZkArtifactBaseUrl(value) {
+  if (value === void 0) {
+    return {};
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return {};
+  }
+  let withoutSlash = trimmed;
+  while (withoutSlash.endsWith("/")) {
+    withoutSlash = withoutSlash.slice(0, -1);
+  }
+  return { zkArtifactBaseUrl: withoutSlash };
+}
 
 // src/transact/pool/aligned-deposit.ts
-import { PrivacyPoolSDK, scalarHexToFrDecimal } from "@auditable/privacy-pool-zk-sdk";
+import {
+  PrivacyPoolSDK,
+  scalarHexToFrDecimal
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
 var SAMPLE_SCALAR_ATTEMPTS = 10;
+function escrowDepositFields(parameters) {
+  if (!parameters.recipientHi || !parameters.recipientLo) {
+    return {};
+  }
+  return {
+    ...parameters.escrowNonce ? { escrowNonce: parameters.escrowNonce } : {},
+    recipientStellar: [parameters.recipientHi, parameters.recipientLo]
+  };
+}
 function sampleValidDepositScalarHex() {
   for (let index = 0; index < SAMPLE_SCALAR_ATTEMPTS; index++) {
     const candidate = PrivacyPoolSDK.generateRandomScalarHex32();
@@ -1218,17 +1262,12 @@ function sampleValidDepositScalarHex() {
 async function buildAlignedDepositSlotForSdk(sdk, applicationId, parameters) {
   const privateAddressPoint = decodePrivateAddress(parameters.privateAddressStpl1);
   const scalarHex = sampleValidDepositScalarHex();
-  const shared = sdk.ecdhSharedKey(
-    scalarHex,
-    privateAddressPoint.x,
-    privateAddressPoint.y
-  );
   const [assetHi, assetLo] = tokenAddressToAssetLeg(parameters.tokenAddress);
   const resolvedApplicationId = resolvePoolApplicationId(applicationId);
-  const generated = sdk.generateCoinForDepositWithSharedHex(
+  const generated = sdk.generateCoinForDepositWithOwnerPubHex(
     scalarHex,
-    shared.x,
-    shared.y,
+    privateAddressPoint.x,
+    privateAddressPoint.y,
     parameters.amountStroops,
     assetHi,
     assetLo,
@@ -1243,27 +1282,34 @@ async function buildAlignedDepositSlotForSdk(sdk, applicationId, parameters) {
     ephemeralKeyScalar: scalarHexToFrDecimal(scalarHex),
     asset: [generated.coin.asset_hi, generated.coin.asset_lo],
     applicationId: resolvedApplicationId,
-    recipientPublicKeys
+    recipientPublicKeys,
+    ...escrowDepositFields(parameters)
   };
   return {
     deposit,
     commitment_hex: generated.commitment_hex,
     coin: generated.coin,
     depositScalarHex: scalarHex,
-    precommitementHex: generated.precommitement_hex
+    precommitementHex: generated.precommitementHex
   };
 }
 
 // src/transact/pool/service.ts
 var PrivacyPoolService = class {
-  constructor(assets, applicationId, auditPublicKey) {
+  constructor(assets, applicationId, auditPublicKey, zkCircuits, zkConfigNonce, zkArtifactBaseUrl) {
     this.assets = assets;
     this.applicationId = applicationId;
     this.auditPublicKey = auditPublicKey;
+    this.zkCircuits = zkCircuits;
+    this.zkConfigNonce = zkConfigNonce;
+    this.zkArtifactBaseUrl = zkArtifactBaseUrl;
   }
   assets;
   applicationId;
   auditPublicKey;
+  zkCircuits;
+  zkConfigNonce;
+  zkArtifactBaseUrl;
   sdk = void 0;
   initPromise = void 0;
   async ensureInit() {
@@ -1279,10 +1325,16 @@ var PrivacyPoolService = class {
           "PrivacyPoolService requires browser ZK assets before initialization."
         );
       }
-      this.sdk = await PrivacyPoolSdkClass.init({
+      const zkConfigNonce = this.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
+      const zkCircuits = await materializeSelectedZkCircuit(
+        this.zkCircuits,
+        zkConfigNonce
+      );
+      this.sdk = await PrivacyPoolSDK2.init({
         wasmBinary: this.assets.sdkWasm,
-        circuitWasm: this.assets.circuitWasm,
-        zkey: this.assets.provingKey
+        zkCircuits,
+        zkConfigNonce,
+        ...optionalZkArtifactBaseUrl(this.zkArtifactBaseUrl)
       });
     })();
     return this.initPromise;
@@ -1300,22 +1352,17 @@ var PrivacyPoolService = class {
   getApplicationId() {
     return resolvePoolApplicationId(this.applicationId);
   }
-  async generatePrivateAddressFromStellarSignature(signature) {
-    await this.ensureInit();
-    if (!this.sdk) {
-      throw new Error("SDK not initialized");
-    }
-    return privateAddressSdk(this.sdk).generatePrivateAddressFromStellarSignature(
-      signature
+  async generatePrivateAddressFromStellarSignature(signature, domain) {
+    const sdk = await this.getInitializedSdk();
+    return privateAddressSdk(sdk).generatePrivateAddressFromStellarSignature(
+      signature,
+      domain
     );
   }
   async sharedSecretX(recipientScalarHex, ephemeralKeyEncoded) {
-    await this.ensureInit();
-    if (!this.sdk) {
-      throw new Error("SDK not initialized");
-    }
+    const sdk = await this.getInitializedSdk();
     const ephemeralKey = decodeDecodedEphemeralKey(ephemeralKeyEncoded);
-    const shared = this.sdk.sharedSecretFromRecipientPreimage({
+    const shared = sdk.sharedSecretFromRecipientPreimage({
       recipientScalar: recipientScalarHex,
       ephemeralKey
     });
@@ -1338,6 +1385,7 @@ var PrivacyPoolService = class {
     const applicationId = this.getApplicationId();
     const audit = buildPoolTransactionAuditParameters({
       applicationId,
+      nAuditSlots: sdk.getLayout().nAuditSlots,
       ...this.auditPublicKey ? { auditPublicKey: this.auditPublicKey } : {}
     });
     const deposit = {
@@ -1351,38 +1399,35 @@ var PrivacyPoolService = class {
     const publicInput = withTokenAddressPublicInputs(
       {
         stateRoot,
-        withdrawAddressHi: "0",
-        withdrawAddressLo: "0",
         privKeyScalar: randomFrDecimal253()
       },
       parameters.tokenAddress
     );
     const proof = await sdk.proveTransaction(
       publicInput,
-      buildPublicDepositLegs(parameters.tokenAddress, parameters.coin.value),
-      ["dummy", "dummy"],
-      [deposit, "dummy"],
+      padPublicLegsToLayout(
+        sdk,
+        buildPublicDepositLegs(parameters.tokenAddress, parameters.coin.value)
+      ),
+      padWithdrawSlotsToLayout(sdk, []),
+      padDepositSlotsToLayout(sdk, [deposit]),
       audit
     );
-    const applicationIdsPlaintext = [
-      "0",
-      "0",
-      applicationId,
-      "0"
-    ];
+    const applicationIdsPlaintext = buildApplicationIdHints({
+      sdk,
+      inputIds: [],
+      outputIds: [applicationId]
+    });
     return { ...proof, applicationIdsPlaintext };
   }
-  async calculateNullifierHash(nullifier) {
+  async calculateNullifierHash(nullifier, privKeyScalar) {
     const sdk = await this.getInitializedSdk();
-    return sdk.calculateNullifierHash(nullifier);
+    return sdk.calculateNullifierHash(nullifier, privKeyScalar);
   }
   async prepareWithdrawTransactProof(parameters) {
-    await this.ensureInit();
-    if (!this.sdk) {
-      throw new Error("SDK not initialized");
-    }
+    const sdk = await this.getInitializedSdk();
     return proveWithdrawTransact({
-      sdk: this.sdk,
+      sdk,
       applicationId: this.getApplicationId(),
       buildAlignedDepositSlot: (input) => this.buildAlignedDepositSlot(input),
       ...this.auditPublicKey ? { auditPublicKey: this.auditPublicKey } : {},
@@ -1390,12 +1435,9 @@ var PrivacyPoolService = class {
     });
   }
   async prepareWithdrawTransactProofDual(parameters) {
-    await this.ensureInit();
-    if (!this.sdk) {
-      throw new Error("SDK not initialized");
-    }
+    const sdk = await this.getInitializedSdk();
     return proveWithdrawTransactDual({
-      sdk: this.sdk,
+      sdk,
       applicationId: this.getApplicationId(),
       buildAlignedDepositSlot: (input) => this.buildAlignedDepositSlot(input),
       ...this.auditPublicKey ? { auditPublicKey: this.auditPublicKey } : {},
@@ -1418,7 +1460,10 @@ function createPrivacyPoolService(input) {
   return new PrivacyPoolService(
     input?.assets,
     input?.applicationId,
-    input?.auditPublicKey
+    input?.auditPublicKey,
+    input?.zkCircuits,
+    input?.zkConfigNonce,
+    input?.zkArtifactBaseUrl
   );
 }
 var configuredPrivacyPoolService;
@@ -1434,81 +1479,245 @@ function getPrivacyPoolService() {
   return configuredPrivacyPoolService;
 }
 
-// src/transact/transfer-source/verify.ts
-async function verifyPendingClaimBeforeExecute(input) {
-  try {
-    assertPendingClaimOwner({
-      claim: input.claim,
-      walletPublicKey: input.walletPublicKey
+// src/transact/merkle/fetch-contract.ts
+import { Buffer as Buffer11 } from "buffer";
+
+// src/transact/merkle/encoding.ts
+import "buffer";
+var FR_ORDER = 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n;
+function bufferToDecimal(buf) {
+  const hex = buf.toString("hex");
+  const bigintFromHex = BigInt(`0x${hex}`);
+  const reduced = bigintFromHex % FR_ORDER;
+  return reduced.toString();
+}
+function commitmentsBuffersToDecimal(buffers) {
+  return buffers.map((bufferRow) => bufferToDecimal(bufferRow));
+}
+
+// src/transact/merkle/state-port.ts
+function poolMerkleStateToCachedView(state) {
+  return {
+    commitments: state.commitments,
+    updatedAt: state.updatedAt,
+    merkleRootHex: state.merkleRootHex
+  };
+}
+
+// src/transact/merkle/fetch-contract.ts
+function normalizeCommitmentBuffers(rawBuffers) {
+  return rawBuffers.map(
+    (bufferRow) => Buffer11.isBuffer(bufferRow) ? bufferRow : Buffer11.from(bufferRow)
+  );
+}
+function mergeContractMerkleWithCache(parameters) {
+  const cachedCount = parameters.cachedState?.commitments.length ?? 0;
+  const shouldPreferContract = parameters.contractCount > cachedCount || !parameters.cachedState || cachedCount === 0;
+  if (shouldPreferContract) {
+    const updatedAt = Date.now();
+    void parameters.poolMerkleState?.set({
+      poolContract: parameters.poolContractId,
+      commitments: parameters.contractCommitments,
+      commitmentCount: parameters.contractCount,
+      merkleRootHex: parameters.merkleRootHex,
+      updatedAt
     });
-    const coin = pendingClaimToCoin(input.claim);
-    const nullifierHashHex = await getPrivacyPoolService().calculateNullifierHash(
-      coin.nullifier
-    );
-    const contractContext = requireContractContext(input.environment);
-    const poolContractId = input.poolContractId?.trim() || contractContext.network.poolContract;
-    const spent = await readNullifierConsumedOnChain({
-      contractContext,
-      poolContractId,
-      walletPublicKey: input.walletPublicKey.trim(),
-      nullifierHashHex
+    return {
+      commitments: parameters.contractCommitments,
+      updatedAt,
+      merkleRootHex: parameters.merkleRootHex,
+      commitmentCount: parameters.contractCount
+    };
+  }
+  return {
+    commitments: parameters.cachedState.commitments,
+    updatedAt: parameters.cachedState.updatedAt,
+    merkleRootHex: parameters.cachedState.merkleRootHex ?? parameters.merkleRootHex,
+    commitmentCount: parameters.cachedState.commitments.length
+  };
+}
+async function readCachedPoolMerkleView(poolMerkleState, poolContractId) {
+  if (!poolMerkleState) {
+    return void 0;
+  }
+  const cached = await poolMerkleState.get(poolContractId);
+  return cached ? poolMerkleStateToCachedView(cached) : void 0;
+}
+async function fetchAndMergeMerkleState(parameters) {
+  const client = readPoolClientFactory(parameters.transactEnvironment)({
+    contractId: parameters.poolContractId,
+    walletPublicKey: parameters.walletPublicKey,
+    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
+    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
+  });
+  const commitmentsRead = await client.get_commitments();
+  const rawBuffers = commitmentsRead.result;
+  const buffers = normalizeCommitmentBuffers(rawBuffers);
+  const contractCommitments = commitmentsBuffersToDecimal(buffers);
+  const contractCount = contractCommitments.length;
+  const rootRead = await client.get_merkle_root();
+  const merkleRootBuffer = rootRead.result;
+  const merkleRootHex = Buffer11.from(merkleRootBuffer).toString("hex");
+  const cachedState = await readCachedPoolMerkleView(
+    parameters.poolMerkleState,
+    parameters.poolContractId
+  );
+  return mergeContractMerkleWithCache({
+    poolContractId: parameters.poolContractId,
+    contractCommitments,
+    contractCount,
+    merkleRootHex,
+    cachedState,
+    ...parameters.poolMerkleState ? { poolMerkleState: parameters.poolMerkleState } : {}
+  });
+}
+async function readLeafEphemeralHex(parameters) {
+  const cached = await parameters.leafEphemeral?.get({
+    poolContract: parameters.poolContractId,
+    leafIndex: parameters.leafIndex
+  });
+  if (cached?.xHex && cached.yHex) {
+    return { xHex: cached.xHex, yHex: cached.yHex };
+  }
+  const client = readPoolClientFactory(parameters.transactEnvironment)({
+    contractId: parameters.poolContractId,
+    walletPublicKey: parameters.walletPublicKey,
+    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
+    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
+  });
+  const read = await client.get_leaf_ephemeral({ leaf_index: parameters.leafIndex });
+  const coords = read.result;
+  if (!coords?.x || !coords?.y) {
+    throw new Error("Missing leaf ephemeral key on contract");
+  }
+  const xHex = Buffer11.from(coords.x).toString("hex");
+  const yHex = Buffer11.from(coords.y).toString("hex");
+  await parameters.leafEphemeral?.set({
+    poolContract: parameters.poolContractId,
+    leafIndex: parameters.leafIndex,
+    xHex,
+    yHex,
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { xHex, yHex };
+}
+
+// src/transact/engine/prepare/shared.ts
+async function resolveTokenContractId2(environment, assetId) {
+  if (environment.resolveTokenContractId) {
+    return environment.resolveTokenContractId(assetId);
+  }
+  throw new Error(`Token contract is not configured for asset ${assetId}.`);
+}
+async function resolveWalletPublicKey(environment, prepared) {
+  if (environment.resolveWalletPublicKey) {
+    return environment.resolveWalletPublicKey();
+  }
+  if (prepared.kind === "deposit") {
+    const depositIntent = prepared.intent;
+    return depositIntent.from;
+  }
+  throw new Error("Wallet public key resolver is not configured.");
+}
+async function resolveSenderPrivKeyScalarHex(environment, privateAddressStpl1, owner) {
+  const cached = await readSenderPrivKeyScalarHex(
+    environment,
+    privateAddressStpl1,
+    owner
+  );
+  if (cached) {
+    return cached;
+  }
+  if (environment.ensureSenderPrivKeyScalarHex) {
+    return environment.ensureSenderPrivKeyScalarHex(privateAddressStpl1);
+  }
+  if (!environment.resolveSenderPrivKeyScalarHex) {
+    throw new Error("Sender private key scalar resolver is not configured.");
+  }
+  return environment.resolveSenderPrivKeyScalarHex(privateAddressStpl1);
+}
+async function readSenderPrivKeyScalarHex(environment, privateAddressStpl1, owner) {
+  if (owner && environment.resolveSenderPrivKeyScalarFromState) {
+    const fromState = await environment.resolveSenderPrivKeyScalarFromState({
+      owner,
+      privateAddressStpl1
     });
-    if (spent) {
-      throw executionError3(
-        "Pending claim nullifier was already spent on-chain.",
-        "validation",
-        { reason: "pending_claim_nullifier_spent" }
-      );
+    if (fromState?.trim()) {
+      return fromState.trim();
     }
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "insufficient_state") {
-      throw executionError3(
-        error instanceof Error ? error.message : "Pending claim owner mismatch.",
-        "validation",
-        { reason: "pending_claim_owner_mismatch" }
-      );
+  }
+  if (environment.readSenderPrivKeyScalarHex) {
+    const cached = await environment.readSenderPrivKeyScalarHex(privateAddressStpl1);
+    if (cached?.trim()) {
+      return cached.trim();
     }
-    throw error;
   }
+  return void 0;
 }
-
-// src/transact/transfer-source/verify-private-records.ts
-import { executionError as executionError4, insufficientStateError as insufficientStateError2 } from "@arcanetech/privacy-sdk-core";
-
-// src/transact/private-address/record-coin.ts
-function requireCoinNoteFromRecord(record) {
-  if (!record.coinNote) {
-    throw new Error(`Private record ${record.id} is missing coin note data.`);
+async function ensureSenderPrivKeyScalarHex(environment, privateAddressStpl1, owner) {
+  const cached = await readSenderPrivKeyScalarHex(
+    environment,
+    privateAddressStpl1,
+    owner
+  );
+  if (cached) {
+    return cached;
   }
-  return record.coinNote;
+  if (environment.ensureSenderPrivKeyScalarHex) {
+    return environment.ensureSenderPrivKeyScalarHex(privateAddressStpl1);
+  }
+  return resolveSenderPrivKeyScalarHex(environment, privateAddressStpl1, owner);
 }
-function findCommitmentLeafIndex(commitments, commitment) {
-  return commitments.indexOf(commitment);
+async function loadMerkleState(environment, walletPublicKey) {
+  const merged = await fetchAndMergeMerkleState({
+    poolContractId: environment.network.poolContract,
+    walletPublicKey,
+    transactEnvironment: environment,
+    ...environment.poolMerkleState ? { poolMerkleState: environment.poolMerkleState } : {}
+  });
+  return { commitments: merged.commitments };
 }
-function buildPrivateRecordFromDeposit(input) {
+function enrichPreparedOperation(prepared, outputRecords, artifacts) {
   return {
-    id: input.commitmentHex,
-    owner: input.owner,
-    asset: input.assetId,
-    amount: input.amount,
-    consumed: false,
-    status: input.status ?? "pending",
-    poolContract: input.poolContract,
-    commitmentHex: input.commitmentHex,
-    privateAddress: input.privateAddress,
-    amountDisplay: input.amountDisplay,
-    coinNote: input.coin,
-    depositScalarHex: input.depositScalarHex,
-    precommitementHex: input.precommitementHex,
-    ...input.txHash ? { txHash: input.txHash } : {}
+    ...prepared,
+    outputRecords,
+    transactArtifacts: artifacts,
+    submissionPayload: {
+      operationId: crypto.randomUUID(),
+      signed: false
+    }
   };
 }
 
 // src/transact/transfer-source/verify-private-records.ts
+async function resolveNullifierSpendScalarHex(input) {
+  const stamped = input.spendScalarHex?.trim();
+  if (stamped) {
+    return stamped;
+  }
+  const privateAddress = input.record.privateAddress?.trim();
+  if (!privateAddress) {
+    throw executionError3(
+      "Private record is missing a private address; cannot derive the owner-bound spend scalar.",
+      "validation",
+      {
+        reason: "private_record_missing_private_address",
+        recordId: input.record.id
+      }
+    );
+  }
+  return ensureSenderPrivKeyScalarHex(
+    input.environment,
+    privateAddress,
+    input.walletPublicKey
+  );
+}
 async function readPrivateRecordNullifierSpendStatus(input) {
   const coin = requireCoinNoteFromRecord(input.record);
+  const scalarHex = await resolveNullifierSpendScalarHex(input);
   const nullifierHashHex = await getPrivacyPoolService().calculateNullifierHash(
-    coin.nullifier
+    coin.nullifier,
+    privKeyScalarDecimalFromRecipientScalarHex(scalarHex)
   );
   const contractContext = requireContractContext(input.environment);
   const poolContractId = input.poolContractId?.trim() || contractContext.network.poolContract;
@@ -1526,10 +1735,11 @@ async function verifyPrivateRecordsNullifiersBeforeExecute(input) {
       record,
       environment: input.environment,
       walletPublicKey: input.walletPublicKey,
-      ...input.poolContractId ? { poolContractId: input.poolContractId } : {}
+      ...input.poolContractId ? { poolContractId: input.poolContractId } : {},
+      ...input.spendScalarHex ? { spendScalarHex: input.spendScalarHex } : {}
     });
     if (status.spent) {
-      throw executionError4(
+      throw executionError3(
         "Private input note nullifier was already spent on-chain.",
         "validation",
         {
@@ -1549,10 +1759,11 @@ async function assertPrivateRecordsNullifiersAvailable(input) {
     const coin = requireCoinNoteFromRecord(record);
     const spent = await input.checkNullifierSpent({
       nullifier: coin.nullifier,
-      walletPublicKey: input.walletPublicKey
+      walletPublicKey: input.walletPublicKey,
+      ...record.privateAddress ? { privateAddressStpl1: record.privateAddress } : {}
     });
     if (spent) {
-      throw insufficientStateError2(
+      throw insufficientStateError(
         "private_record_nullifier_spent",
         "Private input note nullifier was already spent on-chain.",
         { recordId: record.id }
@@ -1564,15 +1775,6 @@ async function assertPrivateRecordsNullifiersAvailable(input) {
 // src/adapters/transfer-output-records.ts
 function buildTransferOutputRecords(intent, consumedTotal, walletPublicKey) {
   const recipientOwner = recipientOutputOwner(intent, walletPublicKey);
-  if (isPendingClaimSource(intent.from)) {
-    return [
-      createOutputRecord({
-        ...recipientOwner,
-        asset: intent.asset,
-        amount: intent.amount
-      })
-    ];
-  }
   const changeAmount = consumedTotal - intent.amount;
   const outputs = [
     createOutputRecord({
@@ -1679,7 +1881,8 @@ async function filterUnspentPrivateRecords(input) {
     const coin = requireCoinNoteFromRecord(record);
     const spent = await input.checkNullifierSpent({
       nullifier: coin.nullifier,
-      walletPublicKey: input.walletPublicKey
+      walletPublicKey: input.walletPublicKey,
+      ...record.privateAddress ? { privateAddressStpl1: record.privateAddress } : {}
     });
     if (!spent) {
       unspent.push(record);
@@ -1696,15 +1899,15 @@ function pickRecordsForSpendAmount(input) {
     if (selectedTotal >= input.amount) {
       return selected;
     }
-    if (input.kind === "transfer" && selected.length >= 2) {
-      throw insufficientStateError3(
+    if ((input.kind === "transfer" || input.kind === "withdraw") && selected.length >= 2) {
+      throw insufficientStateError2(
         "missing_private_records",
         "Storage does not contain enough private records for this operation.",
         { requestedAmount: input.amount, availableAmount: selectedTotal }
       );
     }
   }
-  throw insufficientStateError3(
+  throw insufficientStateError2(
     "missing_private_records",
     "Storage does not contain enough private records for this operation.",
     { requestedAmount: input.amount, availableAmount: selectedTotal }
@@ -1713,7 +1916,7 @@ function pickRecordsForSpendAmount(input) {
 async function selectPrivateRecords(input) {
   const from = input.intent.from;
   if (!isPrivateAddressTransferFrom(from)) {
-    throw insufficientStateError3(
+    throw insufficientStateError2(
       "invalid_transfer_source",
       "Private record selection requires a private address transfer source."
     );
@@ -1731,7 +1934,7 @@ async function selectPrivateRecords(input) {
     checkNullifierSpent: input.checkNullifierSpent
   }) : locallyAvailable;
   if (available.length === 0) {
-    throw insufficientStateError3(
+    throw insufficientStateError2(
       "missing_private_records",
       "Storage does not contain enough private records for this operation.",
       { requestedAmount: input.intent.amount, availableAmount: 0n }
@@ -1759,11 +1962,10 @@ function buildSpendOutputRecords(input) {
 }
 
 // src/adapters/transfer-prepare.ts
-import { insufficientStateError as insufficientStateError4 } from "@arcanetech/privacy-sdk-core";
 async function prepareTransferOperation(intent, deps) {
+  const spend = await resolvePrivateAddressSpend(intent, deps);
   const walletAddress = await deps.wallet.getAddress();
   const walletPublicKey = walletAddress.trim();
-  const spend = isPendingClaimSource(intent.from) ? await resolvePendingClaimSpend(intent, deps, walletPublicKey) : await resolvePrivateAddressSpend(intent, deps);
   const consumedTotal = sumRecordAmounts(spend.consumedRecords);
   const prepared = {
     kind: "transfer",
@@ -1778,40 +1980,6 @@ async function prepareTransferOperation(intent, deps) {
   };
   return deps.engine.prepare(prepared);
 }
-async function resolvePendingClaimSpend(intent, deps, walletPublicKey) {
-  if (!deps.getPendingClaims) {
-    throw insufficientStateError4(
-      "pending_claim_state_unavailable",
-      "Pending claim state is not available for this transfer."
-    );
-  }
-  const claim = await resolvePendingClaimSource({
-    from: intent.from,
-    walletPublicKey,
-    getPendingClaims: deps.getPendingClaims
-  });
-  assertPendingClaimOwner({ claim, walletPublicKey });
-  await assertPendingClaimNullifierAvailable({
-    claim,
-    walletPublicKey,
-    ...deps.checkNullifierSpent ? { checkNullifierSpent: deps.checkNullifierSpent } : {}
-  });
-  validatePendingClaimIntentMatches(claim, intent);
-  return {
-    consumedRecords: [
-      pendingClaimToConsumedRecord({
-        claim,
-        walletPublicKey,
-        poolContract: deps.poolContract
-      })
-    ],
-    transactArtifacts: {
-      pendingClaim: claim,
-      spendSource: "pendingClaim",
-      executeFinalizeRequired: true
-    }
-  };
-}
 async function resolvePrivateAddressSpend(intent, deps) {
   const walletAddress = await deps.wallet.getAddress();
   const walletPublicKey = walletAddress.trim();
@@ -1834,37 +2002,6 @@ async function resolvePrivateAddressSpend(intent, deps) {
     }
   };
 }
-function validatePendingClaimIntentMatches(claim, intent) {
-  if (claim.amount !== intent.amount) {
-    throw insufficientStateError4(
-      "pending_claim_amount_mismatch",
-      "Transfer amount must match the pending claim amount.",
-      { claimAmount: claim.amount, requestedAmount: intent.amount }
-    );
-  }
-  if (claim.asset !== intent.asset) {
-    throw insufficientStateError4(
-      "pending_claim_asset_mismatch",
-      "Transfer asset must match the pending claim asset."
-    );
-  }
-}
-async function assertPendingClaimNullifierAvailable(input) {
-  if (!input.checkNullifierSpent) {
-    return;
-  }
-  const nullifier = pendingClaimToCoin(input.claim).nullifier;
-  const spent = await input.checkNullifierSpent({
-    nullifier,
-    walletPublicKey: input.walletPublicKey
-  });
-  if (spent) {
-    throw insufficientStateError4(
-      "pending_claim_nullifier_spent",
-      "Pending claim nullifier was already spent on-chain."
-    );
-  }
-}
 
 // src/adapters/network.ts
 function createStellarNetworkAdapter(deps) {
@@ -1948,9 +2085,6 @@ async function prepareOperation(input) {
 // src/state/foundation/paths.ts
 var STELLAR_STATE_PATHS = {
   privateRecords: "$.privateRecords",
-  pendingClaimsItems: "$.pendingClaims.items",
-  pendingClaimsPagination: "$.pendingClaims.pagination",
-  pendingClaimsCountByOwner: "$.pendingClaims.countByOwner",
   registryPrivateAddresses: "$.registry.privateAddresses",
   registryRegisteredAddresses: "$.registry.registeredAddresses",
   registryLookups: "$.registry.lookups",
@@ -1970,25 +2104,6 @@ var STELLAR_STATE_PATHS = {
 
 // src/state/schemas/shared.ts
 import { z } from "zod";
-var pendingClaimSchema = z.object({
-  id: z.string().min(1),
-  owner: z.string().min(1),
-  asset: z.string().min(1),
-  amount: z.coerce.bigint(),
-  createdAt: z.string().min(1),
-  poolTxId: z.string().optional(),
-  commitmentHex: z.string().optional(),
-  nullifierHex: z.string().optional(),
-  futureNullifierHashHex: z.string().optional(),
-  assetHiHex: z.string().optional(),
-  assetLoHex: z.string().optional(),
-  nullifierFieldHex: z.string().optional(),
-  secretHex: z.string().optional(),
-  tempPublicKeyXHex: z.string().optional(),
-  tempPublicKeyYHex: z.string().optional(),
-  encryptedRecoveryBase64: z.string().optional(),
-  createdAtLedger: z.number().int().optional()
-});
 var paginationSchema = z.object({
   total: z.number().int().nonnegative(),
   page: z.number().int().positive(),
@@ -2158,26 +2273,6 @@ function normalizePublicBalancesFromEntries(value, owner) {
   }).filter((balance) => balance !== void 0);
 }
 
-// src/state/read/normalize/claims.ts
-function normalizePendingClaimsState(value) {
-  if (typeof value !== "object" || value === null) {
-    return { items: [] };
-  }
-  const record = value;
-  const items = Array.isArray(record.items) ? record.items.flatMap((item) => {
-    const parsed = pendingClaimSchema.safeParse(item);
-    return parsed.success ? [withoutUndefinedFields(parsed.data)] : [];
-  }) : [];
-  const paginationResult = paginationSchema.safeParse(record.pagination);
-  if (paginationResult.success) {
-    return { items, pagination: paginationResult.data };
-  }
-  return { items };
-}
-function normalizePendingClaimsCount(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
-}
-
 // src/state/read/normalize/deliveries.ts
 function normalizeIncomingDeliveries(value) {
   const entries = typeof value === "object" && value !== null && !Array.isArray(value) ? Object.values(value) : value;
@@ -2300,8 +2395,7 @@ import { registerArrayFilterItemSchema } from "@arcanetech/privacy-sdk-core/stat
 
 // src/state/filters/ops.ts
 var stellarArrayFilterSchemaKeys = {
-  privateRecord: "privateRecord",
-  pendingClaim: "pendingClaim"
+  privateRecord: "privateRecord"
 };
 function rejectPrivateRecordsByIds(ids) {
   return {
@@ -2327,56 +2421,6 @@ function rejectConsumedPrivateRecords() {
     }
   };
 }
-function rejectPendingClaimsByOwner(owner) {
-  return {
-    opType: "arrayFilter",
-    jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
-    itemSchemaKey: stellarArrayFilterSchemaKeys.pendingClaim,
-    rejectWhen: {
-      op: "fieldEquals",
-      field: "owner",
-      value: owner
-    }
-  };
-}
-function rejectPendingClaimsByIds(ids) {
-  return {
-    opType: "arrayFilter",
-    jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
-    itemSchemaKey: stellarArrayFilterSchemaKeys.pendingClaim,
-    rejectWhen: {
-      op: "fieldIn",
-      field: "id",
-      values: ids
-    }
-  };
-}
-function rejectPendingClaimsByOwnerAndAsset(input) {
-  const matches = [];
-  if (input.owner !== void 0) {
-    matches.push({
-      op: "fieldEquals",
-      field: "owner",
-      value: input.owner
-    });
-  }
-  if (input.asset !== void 0) {
-    matches.push({
-      op: "fieldEquals",
-      field: "asset",
-      value: input.asset
-    });
-  }
-  return {
-    opType: "arrayFilter",
-    jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
-    itemSchemaKey: stellarArrayFilterSchemaKeys.pendingClaim,
-    rejectWhen: {
-      op: "and",
-      matches
-    }
-  };
-}
 
 // src/state/filters/register-schemas.ts
 var registered = false;
@@ -2388,24 +2432,12 @@ function registerStellarArrayFilterSchemas() {
     stellarArrayFilterSchemaKeys.privateRecord,
     privateRecordSchema
   );
-  registerArrayFilterItemSchema(
-    stellarArrayFilterSchemaKeys.pendingClaim,
-    pendingClaimSchema
-  );
   registered = true;
 }
 
 // src/state/bridge/call-types.ts
 import "@arcanetech/privacy-sdk-core/state";
 var stellarStateCallTypes = {
-  pendingClaims: "pendingClaims",
-  clearPendingClaims: "clearPendingClaims",
-  readPendingClaims: "readPendingClaims",
-  replacePendingClaimsPage: "replacePendingClaimsPage",
-  upsertPendingClaims: "upsertPendingClaims",
-  removePendingClaims: "removePendingClaims",
-  setPendingClaimsCount: "setPendingClaimsCount",
-  readPendingClaimsCount: "readPendingClaimsCount",
   readStellarAddressRegistered: "readStellarAddressRegistered",
   readCachedPrivateAddress: "readCachedPrivateAddress",
   readRegistryLookup: "readRegistryLookup",
@@ -2583,243 +2615,59 @@ var readPublicBalancesSchema = z4.object({
 var setPublicBalanceSchema = z4.object({
   type: z4.literal(stellarStateCallTypes.setPublicBalance),
   balance: publicBalanceSchema
-}).transform(({ type, balance }) => ({
-  type,
-  operations: [
-    {
-      opType: "recordSet",
-      jsonPath: STELLAR_STATE_PATHS.publicBalances,
-      key: ownerAssetKey(balance.owner, balance.asset),
-      value: balance
-    }
-  ]
-}));
-var setPublicBalancesSchema = z4.object({
-  type: z4.literal(stellarStateCallTypes.setPublicBalances),
-  owner: z4.string().min(1),
-  balances: z4.array(publicBalanceSchema)
-}).transform(({ type, owner, balances }) => ({
-  type,
-  operations: balances.map((balance) => ({
-    opType: "recordSet",
-    jsonPath: STELLAR_STATE_PATHS.publicBalances,
-    key: ownerAssetKey(owner, balance.asset),
-    value: { ...balance, owner }
-  }))
-}));
-
-// src/state/definitions/balances.ts
-var stellarBalancesStateDefinitions = [
-  {
-    type: stellarStateCallTypes.readPublicBalance,
-    mode: "read",
-    schema: readPublicBalanceSchema
-  },
-  {
-    type: stellarStateCallTypes.readPublicBalances,
-    mode: "read",
-    schema: readPublicBalancesSchema
-  },
-  {
-    type: stellarStateCallTypes.setPublicBalance,
-    mode: "write",
-    schema: setPublicBalanceSchema
-  },
-  {
-    type: stellarStateCallTypes.setPublicBalances,
-    mode: "write",
-    schema: setPublicBalancesSchema
-  }
-];
-
-// src/state/schemas/claims/write.ts
-import { z as z5 } from "zod";
-var pendingClaimsWriteSchema = z5.object({
-  type: z5.literal(stellarStateCallTypes.pendingClaims),
-  claims: z5.array(pendingClaimSchema),
-  paginationInfo: paginationSchema
-}).transform(({ type, claims, paginationInfo }) => ({
-  type,
-  operations: [
-    {
-      opType: "arrayPush",
-      jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
-      items: claims
-    },
-    {
-      opType: "primitiveSet",
-      jsonPath: STELLAR_STATE_PATHS.pendingClaimsPagination,
-      value: paginationInfo
-    }
-  ]
-}));
-var clearPendingClaimsSchema = z5.object({
-  type: z5.literal(stellarStateCallTypes.clearPendingClaims),
-  owner: z5.string().optional(),
-  asset: z5.string().optional()
-}).transform(({ type, owner, asset }) => {
-  if (owner === void 0 && asset === void 0) {
-    return {
-      type,
-      operations: [
-        {
-          opType: "arrayClean",
-          jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems
-        }
-      ]
-    };
-  }
-  return {
-    type,
-    operations: [rejectPendingClaimsByOwnerAndAsset({ owner, asset })]
-  };
-});
-var readPendingClaimsSchema = z5.object({
-  type: z5.literal(stellarStateCallTypes.readPendingClaims)
-}).transform(({ type }) => ({
-  type,
-  operations: [
-    {
-      opType: "primitiveGet",
-      jsonPath: "$.pendingClaims"
-    }
-  ]
-}));
-
-// src/state/schemas/claims/page.ts
-import { z as z6 } from "zod";
-var pendingClaimBridgeItemSchema = pendingClaimSchema;
-var replacePendingClaimsPageSchema = z6.object({
-  type: z6.literal(stellarStateCallTypes.replacePendingClaimsPage),
-  owner: z6.string().min(1),
-  claims: z6.array(pendingClaimBridgeItemSchema),
-  paginationInfo: z6.object({
-    total: z6.number().int().nonnegative(),
-    page: z6.number().int().positive(),
-    pageSize: z6.number().int().positive(),
-    hasMore: z6.boolean()
-  }),
-  count: z6.number().int().nonnegative().optional()
-}).transform(({ type, owner, claims, paginationInfo, count }) => ({
-  type,
-  operations: [
-    rejectPendingClaimsByOwner(owner),
-    {
-      opType: "arrayPush",
-      jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
-      items: claims
-    },
-    {
-      opType: "primitiveSet",
-      jsonPath: STELLAR_STATE_PATHS.pendingClaimsPagination,
-      value: paginationInfo
-    },
-    {
-      opType: "recordSet",
-      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
-      key: owner,
-      value: count ?? paginationInfo.total
-    }
-  ]
-}));
-var upsertPendingClaimsSchema = z6.object({
-  type: z6.literal(stellarStateCallTypes.upsertPendingClaims),
-  claims: z6.array(pendingClaimBridgeItemSchema)
-}).transform(({ type, claims }) => ({
-  type,
-  operations: [
-    rejectPendingClaimsByIds(claims.map((claim) => claim.id)),
-    {
-      opType: "arrayPush",
-      jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
-      items: claims
-    }
-  ]
-}));
-var removePendingClaimsSchema = z6.object({
-  type: z6.literal(stellarStateCallTypes.removePendingClaims),
-  ids: z6.array(z6.string().min(1))
-}).transform(({ type, ids }) => ({
-  type,
-  operations: [rejectPendingClaimsByIds(ids)]
-}));
-var readPendingClaimsCountSchema = z6.object({
-  type: z6.literal(stellarStateCallTypes.readPendingClaimsCount),
-  owner: z6.string().min(1)
-}).transform(({ type, owner }) => ({
-  type,
-  operations: [
-    {
-      opType: "recordGet",
-      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
-      key: owner
-    }
-  ]
-}));
-var setPendingClaimsCountSchema = z6.object({
-  type: z6.literal(stellarStateCallTypes.setPendingClaimsCount),
-  owner: z6.string().min(1),
-  count: z6.number().int().nonnegative()
-}).transform(({ type, owner, count }) => ({
+}).transform(({ type, balance }) => ({
   type,
   operations: [
     {
       opType: "recordSet",
-      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
-      key: owner,
-      value: count
+      jsonPath: STELLAR_STATE_PATHS.publicBalances,
+      key: ownerAssetKey(balance.owner, balance.asset),
+      value: balance
     }
   ]
 }));
+var setPublicBalancesSchema = z4.object({
+  type: z4.literal(stellarStateCallTypes.setPublicBalances),
+  owner: z4.string().min(1),
+  balances: z4.array(publicBalanceSchema)
+}).transform(({ type, owner, balances }) => ({
+  type,
+  operations: balances.map((balance) => ({
+    opType: "recordSet",
+    jsonPath: STELLAR_STATE_PATHS.publicBalances,
+    key: ownerAssetKey(owner, balance.asset),
+    value: { ...balance, owner }
+  }))
+}));
 
-// src/state/definitions/claims.ts
-var stellarClaimsStateDefinitions = [
-  {
-    type: stellarStateCallTypes.pendingClaims,
-    mode: "write",
-    schema: pendingClaimsWriteSchema
-  },
-  {
-    type: stellarStateCallTypes.clearPendingClaims,
-    mode: "write",
-    schema: clearPendingClaimsSchema
-  },
+// src/state/definitions/balances.ts
+var stellarBalancesStateDefinitions = [
   {
-    type: stellarStateCallTypes.readPendingClaims,
+    type: stellarStateCallTypes.readPublicBalance,
     mode: "read",
-    schema: readPendingClaimsSchema
-  },
-  {
-    type: stellarStateCallTypes.replacePendingClaimsPage,
-    mode: "write",
-    schema: replacePendingClaimsPageSchema
+    schema: readPublicBalanceSchema
   },
   {
-    type: stellarStateCallTypes.upsertPendingClaims,
-    mode: "write",
-    schema: upsertPendingClaimsSchema
+    type: stellarStateCallTypes.readPublicBalances,
+    mode: "read",
+    schema: readPublicBalancesSchema
   },
   {
-    type: stellarStateCallTypes.removePendingClaims,
+    type: stellarStateCallTypes.setPublicBalance,
     mode: "write",
-    schema: removePendingClaimsSchema
-  },
-  {
-    type: stellarStateCallTypes.readPendingClaimsCount,
-    mode: "read",
-    schema: readPendingClaimsCountSchema
+    schema: setPublicBalanceSchema
   },
   {
-    type: stellarStateCallTypes.setPendingClaimsCount,
+    type: stellarStateCallTypes.setPublicBalances,
     mode: "write",
-    schema: setPendingClaimsCountSchema
+    schema: setPublicBalancesSchema
   }
 ];
 
 // src/state/schemas/claims/deliveries.ts
-import { z as z7 } from "zod";
-var readIncomingDeliveriesSchema = z7.object({
-  type: z7.literal(stellarStateCallTypes.readIncomingDeliveries)
+import { z as z5 } from "zod";
+var readIncomingDeliveriesSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.readIncomingDeliveries)
 }).transform(({ type }) => ({
   type,
   operations: [
@@ -2829,9 +2677,9 @@ var readIncomingDeliveriesSchema = z7.object({
     }
   ]
 }));
-var upsertIncomingDeliveriesSchema = z7.object({
-  type: z7.literal(stellarStateCallTypes.upsertIncomingDeliveries),
-  deliveries: z7.array(incomingDeliverySchema)
+var upsertIncomingDeliveriesSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.upsertIncomingDeliveries),
+  deliveries: z5.array(incomingDeliverySchema)
 }).transform(({ type, deliveries }) => ({
   type,
   operations: deliveries.map((delivery) => ({
@@ -2841,10 +2689,10 @@ var upsertIncomingDeliveriesSchema = z7.object({
     value: delivery
   }))
 }));
-var readDeliverySyncStateSchema = z7.object({
-  type: z7.literal(stellarStateCallTypes.readDeliverySyncState),
-  privateAddress: z7.string().min(1),
-  asset: z7.string().min(1)
+var readDeliverySyncStateSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.readDeliverySyncState),
+  privateAddress: z5.string().min(1),
+  asset: z5.string().min(1)
 }).transform(({ type, privateAddress, asset }) => ({
   type,
   operations: [
@@ -2855,8 +2703,8 @@ var readDeliverySyncStateSchema = z7.object({
     }
   ]
 }));
-var setDeliverySyncStateSchema = z7.object({
-  type: z7.literal(stellarStateCallTypes.setDeliverySyncState),
+var setDeliverySyncStateSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.setDeliverySyncState),
   syncState: deliverySyncStateSchema
 }).transform(({ type, syncState }) => ({
   type,
@@ -2895,10 +2743,10 @@ var stellarDeliveriesStateDefinitions = [
 ];
 
 // src/state/schemas/pool/merkle.ts
-import { z as z8 } from "zod";
-var readPoolMerkleStateSchema = z8.object({
-  type: z8.literal(stellarStateCallTypes.readPoolMerkleState),
-  poolContract: z8.string().min(1)
+import { z as z6 } from "zod";
+var readPoolMerkleStateSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.readPoolMerkleState),
+  poolContract: z6.string().min(1)
 }).transform(({ type, poolContract }) => ({
   type,
   operations: [
@@ -2909,8 +2757,8 @@ var readPoolMerkleStateSchema = z8.object({
     }
   ]
 }));
-var setPoolMerkleStateSchema = z8.object({
-  type: z8.literal(stellarStateCallTypes.setPoolMerkleState),
+var setPoolMerkleStateSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.setPoolMerkleState),
   state: poolMerkleStateSchema
 }).transform(({ type, state }) => ({
   type,
@@ -2923,10 +2771,10 @@ var setPoolMerkleStateSchema = z8.object({
     }
   ]
 }));
-var readLeafEphemeralSchema = z8.object({
-  type: z8.literal(stellarStateCallTypes.readLeafEphemeral),
-  poolContract: z8.string().min(1),
-  leafIndex: z8.number().int().nonnegative()
+var readLeafEphemeralSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.readLeafEphemeral),
+  poolContract: z6.string().min(1),
+  leafIndex: z6.number().int().nonnegative()
 }).transform(({ type, poolContract, leafIndex }) => ({
   type,
   operations: [
@@ -2937,8 +2785,8 @@ var readLeafEphemeralSchema = z8.object({
     }
   ]
 }));
-var setLeafEphemeralSchema = z8.object({
-  type: z8.literal(stellarStateCallTypes.setLeafEphemeral),
+var setLeafEphemeralSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.setLeafEphemeral),
   ephemeral: leafEphemeralSchema
 }).transform(({ type, ephemeral }) => ({
   type,
@@ -2977,9 +2825,9 @@ var stellarPoolStateDefinitions = [
 ];
 
 // src/state/schemas/records/private.ts
-import { z as z9 } from "zod";
-var listPrivateRecordsSchema = z9.object({
-  type: z9.literal(stellarStateCallTypes.listPrivateRecords)
+import { z as z7 } from "zod";
+var listPrivateRecordsSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.listPrivateRecords)
 }).transform(({ type }) => ({
   type,
   operations: [
@@ -2989,9 +2837,9 @@ var listPrivateRecordsSchema = z9.object({
     }
   ]
 }));
-var savePrivateRecordsSchema = z9.object({
-  type: z9.literal(stellarStateCallTypes.savePrivateRecords),
-  records: z9.array(privateRecordSchema)
+var savePrivateRecordsSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.savePrivateRecords),
+  records: z7.array(privateRecordSchema)
 }).transform(({ type, records }) => ({
   type,
   operations: [
@@ -3002,9 +2850,9 @@ var savePrivateRecordsSchema = z9.object({
     }
   ]
 }));
-var replacePrivateRecordsSchema = z9.object({
-  type: z9.literal(stellarStateCallTypes.replacePrivateRecords),
-  records: z9.array(privateRecordSchema)
+var replacePrivateRecordsSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.replacePrivateRecords),
+  records: z7.array(privateRecordSchema)
 }).transform(({ type, records }) => ({
   type,
   operations: [
@@ -3019,18 +2867,18 @@ var replacePrivateRecordsSchema = z9.object({
     }
   ]
 }));
-var pruneConsumedPrivateRecordsSchema = z9.object({
-  type: z9.literal(stellarStateCallTypes.pruneConsumedPrivateRecords)
+var pruneConsumedPrivateRecordsSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.pruneConsumedPrivateRecords)
 }).transform(({ type }) => ({
   type,
   operations: [rejectConsumedPrivateRecords()]
 }));
 
 // src/state/schemas/records/transactions.ts
-import { z as z10 } from "zod";
-var upsertPrivateRecordsSchema = z10.object({
-  type: z10.literal(stellarStateCallTypes.upsertPrivateRecords),
-  records: z10.array(privateRecordSchema)
+import { z as z8 } from "zod";
+var upsertPrivateRecordsSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.upsertPrivateRecords),
+  records: z8.array(privateRecordSchema)
 }).transform(({ type, records }) => ({
   type,
   operations: [
@@ -3042,9 +2890,9 @@ var upsertPrivateRecordsSchema = z10.object({
     }
   ]
 }));
-var readTransactionStatusSchema = z10.object({
-  type: z10.literal(stellarStateCallTypes.readTransactionStatus),
-  txHash: z10.string().min(1)
+var readTransactionStatusSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.readTransactionStatus),
+  txHash: z8.string().min(1)
 }).transform(({ type, txHash }) => ({
   type,
   operations: [
@@ -3055,8 +2903,8 @@ var readTransactionStatusSchema = z10.object({
     }
   ]
 }));
-var setTransactionStatusSchema = z10.object({
-  type: z10.literal(stellarStateCallTypes.setTransactionStatus),
+var setTransactionStatusSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.setTransactionStatus),
   status: transactionStatusSchema
 }).transform(({ type, status }) => ({
   type,
@@ -3069,9 +2917,9 @@ var setTransactionStatusSchema = z10.object({
     }
   ]
 }));
-var clearTransactionStatusSchema = z10.object({
-  type: z10.literal(stellarStateCallTypes.clearTransactionStatus),
-  txHash: z10.string().min(1)
+var clearTransactionStatusSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.clearTransactionStatus),
+  txHash: z8.string().min(1)
 }).transform(({ type, txHash }) => ({
   type,
   operations: [
@@ -3113,10 +2961,10 @@ var stellarRecordsStateDefinitions = [
 ];
 
 // src/state/schemas/registry/lookup.ts
-import { z as z11 } from "zod";
-var readStellarAddressRegisteredSchema = z11.object({
-  type: z11.literal(stellarStateCallTypes.readStellarAddressRegistered),
-  address: z11.string().min(1)
+import { z as z9 } from "zod";
+var readStellarAddressRegisteredSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.readStellarAddressRegistered),
+  address: z9.string().min(1)
 }).transform(({ type, address }) => ({
   type,
   operations: [
@@ -3127,9 +2975,9 @@ var readStellarAddressRegisteredSchema = z11.object({
     }
   ]
 }));
-var readCachedPrivateAddressSchema = z11.object({
-  type: z11.literal(stellarStateCallTypes.readCachedPrivateAddress),
-  address: z11.string().min(1)
+var readCachedPrivateAddressSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.readCachedPrivateAddress),
+  address: z9.string().min(1)
 }).transform(({ type, address }) => ({
   type,
   operations: [
@@ -3140,11 +2988,11 @@ var readCachedPrivateAddressSchema = z11.object({
     }
   ]
 }));
-var saveRegisteredPrivateAddressSchema = z11.object({
-  type: z11.literal(stellarStateCallTypes.saveRegisteredPrivateAddress),
-  address: z11.string().min(1),
-  privateAddress: z11.string().min(1),
-  registered: z11.boolean()
+var saveRegisteredPrivateAddressSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.saveRegisteredPrivateAddress),
+  address: z9.string().min(1),
+  privateAddress: z9.string().min(1),
+  registered: z9.boolean()
 }).transform(({ type, address, privateAddress, registered: registered2 }) => {
   const lookup = registryLookupSchema.parse({
     owner: address,
@@ -3176,9 +3024,9 @@ var saveRegisteredPrivateAddressSchema = z11.object({
     ]
   };
 });
-var invalidateRegisteredAddressSchema = z11.object({
-  type: z11.literal(stellarStateCallTypes.invalidateRegisteredAddress),
-  address: z11.string().min(1)
+var invalidateRegisteredAddressSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.invalidateRegisteredAddress),
+  address: z9.string().min(1)
 }).transform(({ type, address }) => ({
   type,
   operations: [
@@ -3199,9 +3047,9 @@ var invalidateRegisteredAddressSchema = z11.object({
     }
   ]
 }));
-var readRegistryLookupSchema = z11.object({
-  type: z11.literal(stellarStateCallTypes.readRegistryLookup),
-  address: z11.string().min(1)
+var readRegistryLookupSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.readRegistryLookup),
+  address: z9.string().min(1)
 }).transform(({ type, address }) => ({
   type,
   operations: [
@@ -3212,8 +3060,8 @@ var readRegistryLookupSchema = z11.object({
     }
   ]
 }));
-var saveRegistryLookupSchema = z11.object({
-  type: z11.literal(stellarStateCallTypes.saveRegistryLookup),
+var saveRegistryLookupSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.saveRegistryLookup),
   lookup: registryLookupSchema
 }).transform(({ type, lookup }) => {
   const operations = [
@@ -3249,9 +3097,9 @@ var saveRegistryLookupSchema = z11.object({
   }
   return { type, operations };
 });
-var invalidateRegistryLookupSchema = z11.object({
-  type: z11.literal(stellarStateCallTypes.invalidateRegistryLookup),
-  address: z11.string().min(1)
+var invalidateRegistryLookupSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.invalidateRegistryLookup),
+  address: z9.string().min(1)
 }).transform(({ type, address }) => ({
   type,
   operations: [
@@ -3332,9 +3180,9 @@ var stellarTransactionStateDefinitions = [
 ];
 
 // src/state/schemas/wallet/scalar.ts
-import { z as z12 } from "zod";
-var saveWalletPrivateAddressScalarSchema = z12.object({
-  type: z12.literal(stellarStateCallTypes.saveWalletPrivateAddressScalar),
+import { z as z10 } from "zod";
+var saveWalletPrivateAddressScalarSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.saveWalletPrivateAddressScalar),
   scalar: walletPrivateAddressScalarSchema
 }).transform(({ type, scalar }) => ({
   type,
@@ -3347,10 +3195,10 @@ var saveWalletPrivateAddressScalarSchema = z12.object({
     }
   ]
 }));
-var readWalletPrivateAddressScalarSchema = z12.object({
-  type: z12.literal(stellarStateCallTypes.readWalletPrivateAddressScalar),
-  owner: z12.string().min(1),
-  nonce: z12.string().min(1)
+var readWalletPrivateAddressScalarSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.readWalletPrivateAddressScalar),
+  owner: z10.string().min(1),
+  nonce: z10.string().min(1)
 }).transform(({ type, owner, nonce }) => ({
   type,
   operations: [
@@ -3363,9 +3211,9 @@ var readWalletPrivateAddressScalarSchema = z12.object({
 }));
 
 // src/state/schemas/wallet/private-address.ts
-import { z as z13 } from "zod";
-var saveWalletPrivateAddressRecordSchema = z13.object({
-  type: z13.literal(stellarStateCallTypes.saveWalletPrivateAddressRecord),
+import { z as z11 } from "zod";
+var saveWalletPrivateAddressRecordSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.saveWalletPrivateAddressRecord),
   record: walletPrivateAddressRecordSchema
 }).transform(({ type, record }) => ({
   type,
@@ -3378,10 +3226,10 @@ var saveWalletPrivateAddressRecordSchema = z13.object({
     }
   ]
 }));
-var readWalletPrivateAddressRecordSchema = z13.object({
-  type: z13.literal(stellarStateCallTypes.readWalletPrivateAddressRecord),
-  owner: z13.string().min(1),
-  nonce: z13.string().min(1)
+var readWalletPrivateAddressRecordSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.readWalletPrivateAddressRecord),
+  owner: z11.string().min(1),
+  nonce: z11.string().min(1)
 }).transform(({ type, owner, nonce }) => ({
   type,
   operations: [
@@ -3392,10 +3240,10 @@ var readWalletPrivateAddressRecordSchema = z13.object({
     }
   ]
 }));
-var setWalletDefaultPrivateAddressNonceSchema = z13.object({
-  type: z13.literal(stellarStateCallTypes.setWalletDefaultPrivateAddressNonce),
-  owner: z13.string().min(1),
-  nonce: z13.string().min(1)
+var setWalletDefaultPrivateAddressNonceSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.setWalletDefaultPrivateAddressNonce),
+  owner: z11.string().min(1),
+  nonce: z11.string().min(1)
 }).transform(({ type, owner, nonce }) => ({
   type,
   operations: [
@@ -3407,9 +3255,9 @@ var setWalletDefaultPrivateAddressNonceSchema = z13.object({
     }
   ]
 }));
-var readWalletDefaultPrivateAddressNonceSchema = z13.object({
-  type: z13.literal(stellarStateCallTypes.readWalletDefaultPrivateAddressNonce),
-  owner: z13.string().min(1)
+var readWalletDefaultPrivateAddressNonceSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.readWalletDefaultPrivateAddressNonce),
+  owner: z11.string().min(1)
 }).transform(({ type, owner }) => ({
   type,
   operations: [
@@ -3420,10 +3268,10 @@ var readWalletDefaultPrivateAddressNonceSchema = z13.object({
     }
   ]
 }));
-var deleteWalletPrivateAddressScalarSchema = z13.object({
-  type: z13.literal(stellarStateCallTypes.deleteWalletPrivateAddressScalar),
-  owner: z13.string().min(1),
-  nonce: z13.string().min(1)
+var deleteWalletPrivateAddressScalarSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.deleteWalletPrivateAddressScalar),
+  owner: z11.string().min(1),
+  nonce: z11.string().min(1)
 }).transform(({ type, owner, nonce }) => ({
   type,
   operations: [
@@ -3477,7 +3325,6 @@ var stellarWalletStateDefinitions = [
 // src/state/definitions/index.ts
 registerStellarArrayFilterSchemas();
 var stellarStateDefinitions = [
-  ...stellarClaimsStateDefinitions,
   ...stellarRegistryStateDefinitions,
   ...stellarAssetsStateDefinitions,
   ...stellarBalancesStateDefinitions,
@@ -3608,108 +3455,6 @@ function createAssetsService(context) {
   };
 }
 
-// src/state/service/claims/read-methods.ts
-function createClaimsReadMethods(context) {
-  const { bridge } = context;
-  async function getPendingClaims(filter = {}) {
-    const value = await bridge.read({
-      type: stellarStateCallTypes.readPendingClaims
-    });
-    const state = normalizePendingClaimsState(value);
-    const items = state.items.filter((claim) => {
-      if (filter.owner !== void 0 && claim.owner !== filter.owner) {
-        return false;
-      }
-      if (filter.asset !== void 0 && claim.asset !== filter.asset) {
-        return false;
-      }
-      return true;
-    });
-    if (state.pagination !== void 0) {
-      return { items, pagination: state.pagination };
-    }
-    return { items };
-  }
-  return {
-    getPendingClaims,
-    async getPendingClaimsCount(owner) {
-      const value = await bridge.read({
-        type: stellarStateCallTypes.readPendingClaimsCount,
-        owner
-      });
-      const count = normalizePendingClaimsCount(value);
-      if (count !== void 0) {
-        return count;
-      }
-      const claims = await getPendingClaims({ owner });
-      return claims.items.length;
-    }
-  };
-}
-
-// src/state/service/claims/write-methods.ts
-function appendPendingClaims(bridge, claims, paginationInfo) {
-  return bridge.write({
-    type: stellarStateCallTypes.pendingClaims,
-    claims,
-    paginationInfo
-  });
-}
-function replacePendingClaimsPage(bridge, input) {
-  return bridge.write({
-    type: stellarStateCallTypes.replacePendingClaimsPage,
-    owner: input.owner,
-    claims: input.claims,
-    paginationInfo: input.paginationInfo,
-    ...input.count === void 0 ? {} : { count: input.count }
-  });
-}
-function upsertPendingClaims(bridge, claims) {
-  return bridge.write({
-    type: stellarStateCallTypes.upsertPendingClaims,
-    claims
-  });
-}
-function removePendingClaims(bridge, ids) {
-  return bridge.write({
-    type: stellarStateCallTypes.removePendingClaims,
-    ids
-  });
-}
-function clearPendingClaims(bridge, input = {}) {
-  return bridge.write({
-    type: stellarStateCallTypes.clearPendingClaims,
-    ...input.owner === void 0 ? {} : { owner: input.owner },
-    ...input.asset === void 0 ? {} : { asset: input.asset }
-  });
-}
-function setPendingClaimsCount(bridge, owner, count) {
-  return bridge.write({
-    type: stellarStateCallTypes.setPendingClaimsCount,
-    owner,
-    count
-  });
-}
-function createClaimsWriteMethods(context) {
-  const { bridge } = context;
-  return {
-    appendPendingClaims: (claims, paginationInfo) => appendPendingClaims(bridge, claims, paginationInfo),
-    replacePendingClaimsPage: (input) => replacePendingClaimsPage(bridge, input),
-    upsertPendingClaims: (claims) => upsertPendingClaims(bridge, claims),
-    removePendingClaims: (ids) => removePendingClaims(bridge, ids),
-    clearPendingClaims: (input = {}) => clearPendingClaims(bridge, input),
-    setPendingClaimsCount: (owner, count) => setPendingClaimsCount(bridge, owner, count)
-  };
-}
-
-// src/state/service/claims/index.ts
-function createClaimsService(context) {
-  return {
-    ...createClaimsWriteMethods(context),
-    ...createClaimsReadMethods(context)
-  };
-}
-
 // src/state/service/deliveries/incoming-methods.ts
 function createIncomingDeliveryMethods(context) {
   const { bridge } = context;
@@ -4235,7 +3980,6 @@ function composeStellarStateService(adapter) {
     ...createWalletAddressService(base),
     ...createPoolMerkleService(base),
     ...createPoolEphemeralService(base),
-    ...createClaimsService(base),
     ...createDeliveriesService(base),
     ...createRecordsService(base)
   };
@@ -4402,22 +4146,63 @@ async function registerPrivateAddressOnChain(input) {
   return transactionHash;
 }
 
-// src/transact/onboarding/recipient.ts
-import { PrivacyPoolSDK as PrivacyPoolSDK3 } from "@auditable/privacy-pool-zk-sdk";
+// src/contracts/registry/resolve-transfer-recipient.ts
+import { StrKey as StrKey5 } from "@stellar/stellar-sdk";
+
+// src/transact/escrow/derived-escrow-recipient.ts
+import { Buffer as Buffer13 } from "buffer";
+import { StrKey as StrKey4 } from "@stellar/stellar-sdk";
+import {
+  derivedEscrowKey,
+  ed25519PubkeyPayloadHexToWithdrawFrDecimals as ed25519PubkeyPayloadHexToWithdrawFrDecimals2,
+  sampleDerivedEscrowKey
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
 var COORDINATE_HEX_LENGTH2 = 64;
-async function generateTemporaryRecipientPrivateAddress() {
-  await getPrivacyPoolService().getInitializedSdk();
-  const temporaryScalarHex = PrivacyPoolSDK3.generateRandomScalarHex32();
-  const sdk = await getPrivacyPoolService().getInitializedSdk();
-  const point = sdk.ecdhEphemeralPublicKeyFromScalarHex(temporaryScalarHex);
-  const publicKeyXHex = point.x.padStart(COORDINATE_HEX_LENGTH2, "0");
-  const publicKeyYHex = point.y.padStart(COORDINATE_HEX_LENGTH2, "0");
+function stellarAccountToFieldLimbs(stellarAddress) {
+  const pkRaw = StrKey4.decodeEd25519PublicKey(stellarAddress.trim());
+  const pkHex = Buffer13.from(pkRaw).toString("hex");
+  const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals2(pkHex);
+  return { recipientHi: hi, recipientLo: lo };
+}
+function padCoordinateHex(value) {
+  return value.replace(/^0x/iu, "").padStart(COORDINATE_HEX_LENGTH2, "0");
+}
+async function deriveEscrowRecipientFromStellarAddress(input) {
+  const recipientStellarAddress = input.recipientStellarAddress.trim();
+  if (!StrKey4.isValidEd25519PublicKey(recipientStellarAddress)) {
+    throw new Error("Escrow recipient must be a Stellar G-address.");
+  }
+  const { recipientHi, recipientLo } = stellarAccountToFieldLimbs(
+    recipientStellarAddress
+  );
+  const deriveKey = input.deriveKey ?? derivedEscrowKey;
+  let nonceDecimal;
+  let key;
+  if (input.nonceDecimal) {
+    nonceDecimal = input.nonceDecimal;
+    key = await deriveKey(
+      BigInt(nonceDecimal),
+      BigInt(recipientHi),
+      BigInt(recipientLo)
+    );
+  } else {
+    const sampled = await sampleDerivedEscrowKey(
+      BigInt(recipientHi),
+      BigInt(recipientLo)
+    );
+    nonceDecimal = sampled.nonce.toString();
+    key = sampled.key;
+  }
   return {
-    temporaryScalarHex,
-    temporaryPrivateAddressStpl1: encodePrivateAddressFromHexCoordinates(
-      publicKeyXHex,
-      publicKeyYHex
-    )
+    nonceDecimal,
+    recipientHi,
+    recipientLo,
+    recipientStellarAddress,
+    privateAddressStpl1: encodePrivateAddressFromHexCoordinates(
+      padCoordinateHex(key.pointXHex),
+      padCoordinateHex(key.pointYHex)
+    ),
+    scalarHex: padCoordinateHex(key.scalarHex)
   };
 }
 
@@ -4436,11 +4221,23 @@ async function resolveTransferRecipientFromChain(input) {
       recipientStellarAddress
     };
   }
-  const temporaryKey = await generateTemporaryRecipientPrivateAddress();
+  if (!StrKey5.isValidEd25519PublicKey(recipientStellarAddress)) {
+    throw new Error(
+      "Transfers to unregistered recipients require a Stellar G-address."
+    );
+  }
+  const escrow = await deriveEscrowRecipientFromStellarAddress({
+    recipientStellarAddress
+  });
   return {
-    recipientPrivateAddressStpl1: temporaryKey.temporaryPrivateAddressStpl1,
+    recipientPrivateAddressStpl1: escrow.privateAddressStpl1,
     recipientStellarAddress,
-    temporaryRecipientKey: temporaryKey
+    escrowSend: {
+      nonceDecimal: escrow.nonceDecimal,
+      recipientHi: escrow.recipientHi,
+      recipientLo: escrow.recipientLo,
+      recipientStellarAddress
+    }
   };
 }
 
@@ -4448,7 +4245,7 @@ async function resolveTransferRecipientFromChain(input) {
 import { Api } from "@stellar/stellar-sdk/rpc";
 
 // src/rpc/soroban-transaction-meta.ts
-import { Address, StrKey as StrKey5 } from "@stellar/stellar-sdk";
+import { Address, StrKey as StrKey6 } from "@stellar/stellar-sdk";
 var BIGINT_SHIFT_64 = 64n;
 var TRANSACTION_META_SWITCH_SOROBAN_V3 = 3;
 var TRANSACTION_META_SWITCH_SOROBAN_V4 = 4;
@@ -4492,7 +4289,7 @@ function extractAmountFromScValue(value) {
   return void 0;
 }
 function contractIdToString(contractId) {
-  return StrKey5.encodeContract(Buffer.from(contractId));
+  return StrKey6.encodeContract(Buffer.from(contractId));
 }
 function scAddressToContractString(address) {
   if (address.switch().name !== "scAddressTypeContract") {
@@ -4816,7 +4613,8 @@ async function checkPrivateRecordSpendStatusWithEnvironment(input) {
   const environment = requireNetworkEnvironment(input.transactEnvironment);
   const contractContext = requireContractContext(environment);
   const nullifierHashHex = await getPrivacyPoolService().calculateNullifierHash(
-    input.nullifier
+    input.nullifier,
+    privKeyScalarDecimalFromRecipientScalarHex(input.privKeyScalarHex)
   );
   const poolContractId = input.poolContractId?.trim() || contractContext.network.poolContract;
   const spent = await readNullifierConsumedOnChain({
@@ -4865,148 +4663,38 @@ async function getTransactionDetailsWithEnvironment(input) {
   if ("kind" in details) {
     throw new Error(details.message);
   }
-  return details;
-}
-
-// src/client/nullifier-checker.ts
-function createNullifierSpentChecker(transactEnvironment) {
-  if (!transactEnvironment) {
-    return;
-  }
-  return async ({
-    nullifier,
-    walletPublicKey
-  }) => {
-    const status = await checkPrivateRecordSpendStatusWithEnvironment({
-      transactEnvironment,
-      nullifier,
-      walletPublicKey
-    });
-    return status.spent;
-  };
-}
-
-// src/transact/merkle/fetch-contract.ts
-import { Buffer as Buffer14 } from "buffer";
-
-// src/transact/merkle/encoding.ts
-import "buffer";
-var FR_ORDER = 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n;
-function bufferToDecimal(buf) {
-  const hex = buf.toString("hex");
-  const bigintFromHex = BigInt(`0x${hex}`);
-  const reduced = bigintFromHex % FR_ORDER;
-  return reduced.toString();
-}
-function commitmentsBuffersToDecimal(buffers) {
-  return buffers.map((bufferRow) => bufferToDecimal(bufferRow));
-}
-
-// src/transact/merkle/state-port.ts
-function poolMerkleStateToCachedView(state) {
-  return {
-    commitments: state.commitments,
-    updatedAt: state.updatedAt,
-    merkleRootHex: state.merkleRootHex
-  };
-}
-
-// src/transact/merkle/fetch-contract.ts
-function normalizeCommitmentBuffers(rawBuffers) {
-  return rawBuffers.map(
-    (bufferRow) => Buffer14.isBuffer(bufferRow) ? bufferRow : Buffer14.from(bufferRow)
-  );
-}
-function mergeContractMerkleWithCache(parameters) {
-  const cachedCount = parameters.cachedState?.commitments.length ?? 0;
-  const shouldPreferContract = parameters.contractCount > cachedCount || !parameters.cachedState || cachedCount === 0;
-  if (shouldPreferContract) {
-    const updatedAt = Date.now();
-    void parameters.poolMerkleState?.set({
-      poolContract: parameters.poolContractId,
-      commitments: parameters.contractCommitments,
-      commitmentCount: parameters.contractCount,
-      merkleRootHex: parameters.merkleRootHex,
-      updatedAt
-    });
-    return {
-      commitments: parameters.contractCommitments,
-      updatedAt,
-      merkleRootHex: parameters.merkleRootHex,
-      commitmentCount: parameters.contractCount
-    };
-  }
-  return {
-    commitments: parameters.cachedState.commitments,
-    updatedAt: parameters.cachedState.updatedAt,
-    merkleRootHex: parameters.cachedState.merkleRootHex ?? parameters.merkleRootHex,
-    commitmentCount: parameters.cachedState.commitments.length
-  };
-}
-async function readCachedPoolMerkleView(poolMerkleState, poolContractId) {
-  if (!poolMerkleState) {
-    return void 0;
-  }
-  const cached = await poolMerkleState.get(poolContractId);
-  return cached ? poolMerkleStateToCachedView(cached) : void 0;
-}
-async function fetchAndMergeMerkleState(parameters) {
-  const client = readPoolClientFactory(parameters.transactEnvironment)({
-    contractId: parameters.poolContractId,
-    walletPublicKey: parameters.walletPublicKey,
-    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
-    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
-  });
-  const commitmentsRead = await client.get_commitments();
-  const rawBuffers = commitmentsRead.result;
-  const buffers = normalizeCommitmentBuffers(rawBuffers);
-  const contractCommitments = commitmentsBuffersToDecimal(buffers);
-  const contractCount = contractCommitments.length;
-  const rootRead = await client.get_merkle_root();
-  const merkleRootBuffer = rootRead.result;
-  const merkleRootHex = Buffer14.from(merkleRootBuffer).toString("hex");
-  const cachedState = await readCachedPoolMerkleView(
-    parameters.poolMerkleState,
-    parameters.poolContractId
-  );
-  return mergeContractMerkleWithCache({
-    poolContractId: parameters.poolContractId,
-    contractCommitments,
-    contractCount,
-    merkleRootHex,
-    cachedState,
-    ...parameters.poolMerkleState ? { poolMerkleState: parameters.poolMerkleState } : {}
-  });
-}
-async function readLeafEphemeralHex(parameters) {
-  const cached = await parameters.leafEphemeral?.get({
-    poolContract: parameters.poolContractId,
-    leafIndex: parameters.leafIndex
-  });
-  if (cached?.xHex && cached.yHex) {
-    return { xHex: cached.xHex, yHex: cached.yHex };
-  }
-  const client = readPoolClientFactory(parameters.transactEnvironment)({
-    contractId: parameters.poolContractId,
-    walletPublicKey: parameters.walletPublicKey,
-    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
-    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
-  });
-  const read = await client.get_leaf_ephemeral({ leaf_index: parameters.leafIndex });
-  const coords = read.result;
-  if (!coords?.x || !coords?.y) {
-    throw new Error("Missing leaf ephemeral key on contract");
+  return details;
+}
+
+// src/client/nullifier-checker.ts
+function createNullifierSpentChecker(transactEnvironment) {
+  if (!transactEnvironment) {
+    return;
   }
-  const xHex = Buffer14.from(coords.x).toString("hex");
-  const yHex = Buffer14.from(coords.y).toString("hex");
-  await parameters.leafEphemeral?.set({
-    poolContract: parameters.poolContractId,
-    leafIndex: parameters.leafIndex,
-    xHex,
-    yHex,
-    cachedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  return { xHex, yHex };
+  return async ({
+    nullifier,
+    walletPublicKey,
+    privKeyScalarHex,
+    privateAddressStpl1
+  }) => {
+    const addressHint = privateAddressStpl1?.trim() ?? "";
+    const resolvedFromEnsure = transactEnvironment.ensureSenderPrivKeyScalarHex ? await transactEnvironment.ensureSenderPrivKeyScalarHex(addressHint) : void 0;
+    const resolvedFromState = addressHint && transactEnvironment.resolveSenderPrivKeyScalarFromState ? await transactEnvironment.resolveSenderPrivKeyScalarFromState({
+      owner: walletPublicKey,
+      privateAddressStpl1: addressHint
+    }) : void 0;
+    const resolvedScalarHex = privKeyScalarHex?.trim() || resolvedFromEnsure?.trim() || resolvedFromState?.trim();
+    if (!resolvedScalarHex) {
+      throw new Error("Spend scalar is required to check owner-bound nullifiers.");
+    }
+    const status = await checkPrivateRecordSpendStatusWithEnvironment({
+      transactEnvironment,
+      nullifier,
+      walletPublicKey,
+      privKeyScalarHex: resolvedScalarHex
+    });
+    return status.spent;
+  };
 }
 
 // src/client/pool-sync.ts
@@ -5131,7 +4819,6 @@ function createOperationsFacet(config, state) {
       wallet: config.wallet,
       engine: config.transactEngine,
       poolContract: config.network.poolContract,
-      getPendingClaims: () => state.getPendingClaims(),
       ...checkNullifierSpent ? { checkNullifierSpent } : {}
     }),
     policy: createStellarPolicyAdapter(config.policy)
@@ -5175,103 +4862,6 @@ function createAssetsStateDelegates(state) {
   };
 }
 
-// src/state/claims/backend.ts
-var DEFAULT_PENDING_CLAIMS_PAGE_SIZE = 20;
-async function fetchPendingClaimsBackendPage(input) {
-  const page = input.page ?? 1;
-  const limit = input.pageSize ?? DEFAULT_PENDING_CLAIMS_PAGE_SIZE;
-  const params = new URLSearchParams({
-    ownerAddress: input.ownerAddress,
-    page: String(page),
-    limit: String(limit)
-  });
-  const baseUrl = input.backendBaseUrl.replace(/\/$/, "");
-  const response = await fetch(`${baseUrl}/pending-claims?${params.toString()}`);
-  if (!response.ok) {
-    throw new Error(`Pending claims request failed: ${response.status}`);
-  }
-  return response.json();
-}
-async function fetchPendingClaimsBackendCount(input) {
-  const params = new URLSearchParams({
-    ownerAddress: input.ownerAddress
-  });
-  const baseUrl = input.backendBaseUrl.replace(/\/$/, "");
-  const response = await fetch(`${baseUrl}/pending-claims/count?${params.toString()}`);
-  if (!response.ok) {
-    throw new Error(`Pending claims count request failed: ${response.status}`);
-  }
-  const payload = await response.json();
-  return payload.count;
-}
-function mapBackendPendingClaimItem(item, asset = "") {
-  return {
-    id: String(item.id),
-    owner: item.ownerAddress,
-    asset,
-    amount: BigInt(item.noteValue),
-    createdAt: item.createdAt,
-    poolTxId: item.poolTxId,
-    commitmentHex: item.commitmentHex,
-    nullifierHex: item.nullifierHex,
-    futureNullifierHashHex: item.futureNullifierHashHex,
-    assetHiHex: item.assetHiHex,
-    assetLoHex: item.assetLoHex,
-    nullifierFieldHex: item.nullifierFieldHex,
-    secretHex: item.secretHex,
-    tempPublicKeyXHex: item.tempPublicKeyXHex,
-    tempPublicKeyYHex: item.tempPublicKeyYHex,
-    encryptedRecoveryBase64: item.encryptedRecoveryBase64,
-    createdAtLedger: item.createdAtLedger
-  };
-}
-function mapBackendPendingClaimsPage(response, asset = "") {
-  return {
-    claims: response.data.map((item) => mapBackendPendingClaimItem(item, asset)),
-    paginationInfo: {
-      total: response.meta.total,
-      page: response.meta.page,
-      pageSize: response.meta.limit,
-      hasMore: response.meta.page < response.meta.totalPages
-    }
-  };
-}
-
-// src/state/claims/sync-from-backend.ts
-async function syncPendingClaimsFromBackend(stateService, input) {
-  const response = await fetchPendingClaimsBackendPage(input);
-  const { claims, paginationInfo } = mapBackendPendingClaimsPage(
-    response,
-    input.asset ?? ""
-  );
-  await stateService.replacePendingClaimsPage({
-    owner: input.ownerAddress,
-    claims,
-    paginationInfo,
-    count: paginationInfo.total
-  });
-}
-async function syncPendingClaimsCountFromBackend(stateService, ownerAddress, input) {
-  const count = await fetchPendingClaimsBackendCount(input);
-  await stateService.setPendingClaimsCount(ownerAddress, count);
-}
-
-// src/client/state-delegates/claims.ts
-function createClaimsStateDelegates(state) {
-  return {
-    appendPendingClaims: (claims, paginationInfo) => state.appendPendingClaims(claims, paginationInfo),
-    loadPendingClaimsFromBackend: (input) => syncPendingClaimsFromBackend(state, input),
-    loadPendingClaimsCountFromBackend: (input) => syncPendingClaimsCountFromBackend(state, input.ownerAddress, input),
-    replacePendingClaimsPage: (input) => state.replacePendingClaimsPage(input),
-    upsertPendingClaims: (claims) => state.upsertPendingClaims(claims),
-    removePendingClaims: (ids) => state.removePendingClaims(ids),
-    clearPendingClaims: (input = {}) => state.clearPendingClaims(input),
-    getPendingClaims: (filter = {}) => state.getPendingClaims(filter),
-    getPendingClaimsCount: (owner) => state.getPendingClaimsCount(owner),
-    setPendingClaimsCount: (owner, count) => state.setPendingClaimsCount(owner, count)
-  };
-}
-
 // src/client/state-delegates/deliveries.ts
 function createDeliveriesStateDelegates(state) {
   return {
@@ -5336,7 +4926,6 @@ function createStateDelegates(state) {
     ...createAssetsStateDelegates(state),
     ...createRegistryStateDelegates(state),
     ...createPoolStateDelegates(state),
-    ...createClaimsStateDelegates(state),
     ...createDeliveriesStateDelegates(state),
     ...createRecordsStateDelegates(state)
   };
@@ -5463,91 +5052,14 @@ function createStellarPrivacyClientFromResolvedConfig(config) {
 }
 
 // src/transact/engine/default-factory.ts
-import { PrivacyPoolSDK as PrivacyPoolSDK4 } from "@auditable/privacy-pool-zk-sdk";
+import { PrivacyPoolSDK as PrivacyPoolSDK3 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
 
-// src/transact/engine/prepare/shared.ts
-async function resolveTokenContractId2(environment, assetId) {
-  if (environment.resolveTokenContractId) {
-    return environment.resolveTokenContractId(assetId);
-  }
-  throw new Error(`Token contract is not configured for asset ${assetId}.`);
-}
-async function resolveWalletPublicKey(environment, prepared) {
-  if (environment.resolveWalletPublicKey) {
-    return environment.resolveWalletPublicKey();
-  }
-  if (prepared.kind === "deposit") {
-    const depositIntent = prepared.intent;
-    return depositIntent.from;
-  }
-  throw new Error("Wallet public key resolver is not configured.");
-}
-async function resolveSenderPrivKeyScalarHex(environment, privateAddressStpl1, owner) {
-  const cached = await readSenderPrivKeyScalarHex(
-    environment,
-    privateAddressStpl1,
-    owner
-  );
-  if (cached) {
-    return cached;
-  }
-  if (environment.ensureSenderPrivKeyScalarHex) {
-    return environment.ensureSenderPrivKeyScalarHex(privateAddressStpl1);
-  }
-  if (!environment.resolveSenderPrivKeyScalarHex) {
-    throw new Error("Sender private key scalar resolver is not configured.");
-  }
-  return environment.resolveSenderPrivKeyScalarHex(privateAddressStpl1);
-}
-async function readSenderPrivKeyScalarHex(environment, privateAddressStpl1, owner) {
-  if (owner && environment.resolveSenderPrivKeyScalarFromState) {
-    const fromState = await environment.resolveSenderPrivKeyScalarFromState({
-      owner,
-      privateAddressStpl1
-    });
-    if (fromState?.trim()) {
-      return fromState.trim();
-    }
-  }
-  if (environment.readSenderPrivKeyScalarHex) {
-    const cached = await environment.readSenderPrivKeyScalarHex(privateAddressStpl1);
-    if (cached?.trim()) {
-      return cached.trim();
-    }
-  }
-  return void 0;
-}
-async function ensureSenderPrivKeyScalarHex(environment, privateAddressStpl1, owner) {
-  const cached = await readSenderPrivKeyScalarHex(
-    environment,
-    privateAddressStpl1,
-    owner
-  );
-  if (cached) {
-    return cached;
-  }
-  if (environment.ensureSenderPrivKeyScalarHex) {
-    return environment.ensureSenderPrivKeyScalarHex(privateAddressStpl1);
-  }
-  return resolveSenderPrivKeyScalarHex(environment, privateAddressStpl1, owner);
-}
-async function loadMerkleState(environment, walletPublicKey) {
-  const merged = await fetchAndMergeMerkleState({
-    poolContractId: environment.network.poolContract,
-    walletPublicKey,
-    transactEnvironment: environment,
-    ...environment.poolMerkleState ? { poolMerkleState: environment.poolMerkleState } : {}
-  });
-  return { commitments: merged.commitments };
-}
-function enrichPreparedOperation(prepared, outputRecords, artifacts) {
+// src/transact/pool/proof-types.ts
+function ciphertextArtifactsFromProof(proof) {
   return {
-    ...prepared,
-    outputRecords,
-    transactArtifacts: artifacts,
-    submissionPayload: {
-      operationId: crypto.randomUUID(),
-      signed: false
+    ...proof.ciphertext_hex === void 0 ? {} : { ciphertextHex: proof.ciphertext_hex },
+    ...proof.output_note_ephemeral_scalars === void 0 ? {} : {
+      outputNoteEphemeralScalars: [...proof.output_note_ephemeral_scalars]
     }
   };
 }
@@ -5602,6 +5114,7 @@ async function prepareDepositOperation(prepared, environment, poolService) {
   return enrichPreparedOperation(prepared, [outputRecord], {
     proofHex: depositProof.proof.proof_hex,
     publicHex: depositProof.proof.public_hex,
+    ...ciphertextArtifactsFromProof(depositProof.proof),
     applicationIdsPlaintext: depositProof.proof.applicationIdsPlaintext,
     tokenAddress,
     depositScalarHex: depositProof.depositScalarHex,
@@ -5611,6 +5124,42 @@ async function prepareDepositOperation(prepared, environment, poolService) {
   });
 }
 
+// src/transact/engine/prepare/transfer-helpers.ts
+import { StrKey as StrKey7 } from "@stellar/stellar-sdk";
+function isStellarAccountRecipient(prepared) {
+  return prepared.kind === "transfer" && StrKey7.isValidEd25519PublicKey(prepared.intent.to.trim());
+}
+async function stampEscrowSendArtifacts(prepared, environment, walletPublicKey) {
+  if (!isStellarAccountRecipient(prepared)) {
+    return {};
+  }
+  if (!environment.resolveTransferRecipientAtExecute) {
+    return {};
+  }
+  const recipient = await environment.resolveTransferRecipientAtExecute({
+    recipientStellarAddress: prepared.intent.to.trim(),
+    walletPublicKey
+  });
+  if (!recipient.escrowSend) {
+    return {};
+  }
+  return { escrowSend: true, spendSource: "escrow" };
+}
+async function resolveTransferRecipientForExecute(prepared, environment, walletPublicKey) {
+  if (!isStellarAccountRecipient(prepared)) {
+    return {
+      recipientPrivateAddressStpl1: prepared.intent.to.trim()
+    };
+  }
+  if (!environment.resolveTransferRecipientAtExecute) {
+    throw new Error("Transfer recipient resolver is not configured.");
+  }
+  return environment.resolveTransferRecipientAtExecute({
+    recipientStellarAddress: prepared.intent.to.trim(),
+    walletPublicKey
+  });
+}
+
 // src/transact/engine/prepare/spend.ts
 async function prepareSpendOperation(prepared, environment) {
   const walletPublicKey = await resolveWalletPublicKey(environment, prepared);
@@ -5621,18 +5170,52 @@ async function prepareSpendOperation(prepared, environment) {
       ...prepared.transactArtifacts,
       tokenAddress,
       walletPublicKey,
-      executeFinalizeRequired: true
+      executeFinalizeRequired: true,
+      ...await stampEscrowSendArtifacts(prepared, environment, walletPublicKey)
     }
   };
 }
 var prepareTransferOperation2 = prepareSpendOperation;
 var prepareWithdrawOperation = prepareSpendOperation;
 
+// src/transact/encoding/ephemeral-key.ts
+var HEX_64_RE = /^[\da-f]{64}$/iu;
+function normalizeCoordinate(value) {
+  const hex = value.trim().replace(/^0x/iu, "").toLowerCase();
+  if (!HEX_64_RE.test(hex)) {
+    throw new Error("Ephemeral key coordinate must be a 32-byte hex string.");
+  }
+  return hex;
+}
+function serializeEphemeralKeyString(point) {
+  return `${normalizeCoordinate(point.xHex)}:${normalizeCoordinate(point.yHex)}`;
+}
+
+// src/transact/escrow/require-escrow-spend-scalar.ts
+function isEscrowSweepSpend(artifacts) {
+  return artifacts?.spendSource === "escrow" && artifacts.escrowSend !== true;
+}
+function requireEscrowSpendScalarHex(artifacts) {
+  if (!isEscrowSweepSpend(artifacts)) {
+    throw new Error("Escrow sweep requires spendSource escrow.");
+  }
+  const hex = artifacts?.escrowSpendScalarHex?.trim();
+  if (!hex) {
+    throw new Error("Escrow sweep requires the reconstructed note owner scalar.");
+  }
+  return hex;
+}
+function nullifierCheckSpendScalarHex(artifacts) {
+  if (!isEscrowSweepSpend(artifacts)) {
+    return void 0;
+  }
+  return requireEscrowSpendScalarHex(artifacts);
+}
+
 // src/transact/engine/spend-proof-context.ts
 async function resolveSenderPrivKeyScalarHex2(input) {
-  const pendingClaim = input.prepared.transactArtifacts?.pendingClaim;
-  if (pendingClaim) {
-    return recoveryScalarHexFromClaim(pendingClaim);
+  if (isEscrowSweepSpend(input.prepared.transactArtifacts)) {
+    return requireEscrowSpendScalarHex(input.prepared.transactArtifacts);
   }
   if (input.prepared.kind !== "transfer" && input.prepared.kind !== "withdraw") {
     throw new Error("Spend execution requires a transfer or withdraw intent.");
@@ -5681,8 +5264,7 @@ async function buildSpendProofContextAtExecute(input) {
     commitments,
     ephemeral,
     senderPrivKeyScalarHex,
-    recipientPrivateAddressStpl1: input.recipientPrivateAddressStpl1,
-    pendingClaim: input.prepared.transactArtifacts?.pendingClaim
+    recipientPrivateAddressStpl1: input.recipientPrivateAddressStpl1
   };
 }
 async function readCoinEphemeralForRecord(input) {
@@ -5701,14 +5283,19 @@ async function readCoinEphemeralForRecord(input) {
   return { coin, ephemeral };
 }
 
-// src/transact/onboarding/recipient-change-deposits.ts
-async function buildPaddingDepositPair(recipientPrivateAddressStpl1, tokenAddress, recipientDeposit) {
-  const paddingSlot = await getPrivacyPoolService().buildAlignedDepositSlot({
-    privateAddressStpl1: recipientPrivateAddressStpl1,
-    amountStroops: ZERO_STROOPS,
-    tokenAddress
-  });
-  return [recipientDeposit, paddingSlot.deposit];
+// src/transact/proofs/confidential/recipient-change-deposits.ts
+function escrowOutputFields(input) {
+  if (!input.escrowSend) {
+    return {};
+  }
+  return {
+    escrowNonce: input.escrowSend.nonceDecimal,
+    recipientHi: input.escrowSend.recipientHi,
+    recipientLo: input.escrowSend.recipientLo
+  };
+}
+function paddingDepositPair(recipientDeposit) {
+  return [recipientDeposit, "dummy"];
 }
 async function buildChangeDepositPair(parameters) {
   const changeSlot = await getPrivacyPoolService().buildAlignedDepositSlot({
@@ -5727,24 +5314,24 @@ async function buildChangeDepositPair(parameters) {
   };
 }
 async function buildRecipientAndOptionalChangeDeposits(parameters) {
+  const escrow = {
+    ...parameters.escrowSend ? { escrowSend: parameters.escrowSend } : {},
+    ...parameters.escrowClaimantLimbs ? { escrowClaimantLimbs: parameters.escrowClaimantLimbs } : {}
+  };
   const recipientPrivateAddress = parameters.recipientPrivateAddressStpl1.trim();
   const recipientSlot = await getPrivacyPoolService().buildAlignedDepositSlot({
     privateAddressStpl1: recipientPrivateAddress,
     amountStroops: parameters.transferStroops,
-    tokenAddress: parameters.tokenAddress
+    tokenAddress: parameters.tokenAddress,
+    ...escrowOutputFields(escrow)
   });
   if (parameters.changeStroops <= ZERO_STROOPS) {
     return {
       recipientSlot,
-      deposits: await buildPaddingDepositPair(
-        recipientPrivateAddress,
-        parameters.tokenAddress,
-        recipientSlot.deposit
-      )
+      deposits: paddingDepositPair(recipientSlot.deposit)
     };
   }
   const changeResult = await buildChangeDepositPair({
-    recipientPrivateAddressStpl1: recipientPrivateAddress,
     selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
     changeStroops: parameters.changeStroops,
     tokenAddress: parameters.tokenAddress,
@@ -5766,20 +5353,61 @@ function generatedOutputCoinFromSlot(slot) {
     precommitementHex: slot.precommitementHex
   };
 }
+function publicEscrowRecipientLimbs(parameters) {
+  const limbs = parameters.escrowClaimantLimbs;
+  if (!limbs) {
+    return void 0;
+  }
+  return {
+    escrowRecipientHi: limbs.recipientHi,
+    escrowRecipientLo: limbs.recipientLo
+  };
+}
+function sweepWithdrawStamp(parameters) {
+  const publicLimbs = publicEscrowRecipientLimbs(parameters);
+  if (!publicLimbs) {
+    return void 0;
+  }
+  return {
+    ...publicLimbs,
+    ...parameters.escrowClaimantLimbs?.nonceDecimal ? { escrowNonce: parameters.escrowClaimantLimbs.nonceDecimal } : {}
+  };
+}
+function stampWithdrawEscrowLimbs(withdrawObject, limbs) {
+  if (!limbs) {
+    return withdrawObject;
+  }
+  return {
+    ...withdrawObject,
+    recipientStellar: [limbs.escrowRecipientHi, limbs.escrowRecipientLo],
+    ...limbs.escrowNonce ? { escrowNonce: limbs.escrowNonce } : {}
+  };
+}
+function sweepOutputOwnerFields(parameters) {
+  if (!parameters.escrowClaimantLimbs) {
+    return void 0;
+  }
+  const [sweepOutputOwnerPubX, sweepOutputOwnerPubY] = recipientPublicKeysDecimalFromPrivateAddress(
+    parameters.recipientPrivateAddressStpl1
+  );
+  return { sweepOutputOwnerPubX, sweepOutputOwnerPubY };
+}
 async function buildTransferDepositsAndPublicInput(parameters) {
   const { recipientSlot, deposits, changeCoin } = await buildRecipientAndOptionalChangeDeposits({
     recipientPrivateAddressStpl1: parameters.recipientPrivateAddressStpl1,
     transferStroops: parameters.transferStroops,
     changeStroops: parameters.changeStroops,
     selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
-    tokenAddress: parameters.tokenAddress
+    tokenAddress: parameters.tokenAddress,
+    ...parameters.escrowSend ? { escrowSend: parameters.escrowSend } : {},
+    ...parameters.escrowClaimantLimbs ? { escrowClaimantLimbs: parameters.escrowClaimantLimbs } : {}
   });
   const publicInput = withTokenAddressPublicInputs(
     {
       stateRoot: parameters.stateRoot,
-      withdrawAddressHi: parameters.withdrawAddressHi,
-      withdrawAddressLo: parameters.withdrawAddressLo,
-      privKeyScalar: parameters.privKeyScalar
+      privKeyScalar: parameters.privKeyScalar,
+      ...publicEscrowRecipientLimbs(parameters),
+      ...sweepOutputOwnerFields(parameters)
     },
     parameters.tokenAddress
   );
@@ -5791,10 +5419,6 @@ async function buildTransferDepositsAndPublicInput(parameters) {
   };
 }
 async function buildSenderTransferDepositsAndPublicInput(parameters) {
-  const { hi, lo, privKeyScalar } = senderWithdrawFrAndScalar({
-    senderGAddress: parameters.senderGAddress,
-    senderPrivKeyScalarHex: parameters.senderPrivKeyScalarHex
-  });
   return buildTransferDepositsAndPublicInput({
     recipientPrivateAddressStpl1: parameters.recipientPrivateAddressStpl1,
     transferStroops: parameters.transferStroops,
@@ -5802,31 +5426,55 @@ async function buildSenderTransferDepositsAndPublicInput(parameters) {
     selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
     tokenAddress: parameters.tokenAddress,
     stateRoot: parameters.stateRoot,
-    withdrawAddressHi: hi,
-    withdrawAddressLo: lo,
-    privKeyScalar
+    privKeyScalar: privKeyScalarDecimalFromRecipientScalarHex(
+      parameters.senderPrivKeyScalarHex
+    ),
+    ...parameters.escrowSend ? { escrowSend: parameters.escrowSend } : {},
+    ...parameters.escrowClaimantLimbs ? { escrowClaimantLimbs: parameters.escrowClaimantLimbs } : {}
   });
 }
 
 // src/transact/proofs/confidential/dual.ts
-function buildDualTransferApplicationIds(applicationId, changeCoin) {
-  return [
-    applicationId,
-    applicationId,
-    applicationId,
-    changeCoin ? applicationId : "0"
-  ];
+function confidentialEscrowFields(parameters) {
+  return {
+    ...parameters.escrowSend ? { escrowSend: parameters.escrowSend } : {},
+    ...parameters.escrowClaimantLimbs ? { escrowClaimantLimbs: parameters.escrowClaimantLimbs } : {}
+  };
+}
+function stampDualWithdrawLegs(legs, parameters) {
+  const escrowLimbs = sweepWithdrawStamp(confidentialEscrowFields(parameters));
+  return {
+    legA: {
+      ...legs.legA,
+      withdrawObject: stampWithdrawEscrowLimbs(legs.legA.withdrawObject, escrowLimbs)
+    },
+    legB: {
+      ...legs.legB,
+      withdrawObject: stampWithdrawEscrowLimbs(legs.legB.withdrawObject, escrowLimbs)
+    }
+  };
+}
+function buildDualTransferApplicationIds(sdk, applicationId, changeCoin) {
+  return buildApplicationIdHints({
+    sdk,
+    inputIds: [applicationId, applicationId],
+    outputIds: [applicationId, changeCoin ? applicationId : "0"]
+  });
 }
 async function proveDualConfidentialTransfer(parameters) {
   const audit = buildPoolTransactionAuditParameters({
     applicationId: parameters.applicationId,
+    nAuditSlots: parameters.sdk.getLayout().nAuditSlots,
     ...parameters.auditPublicKey ? { auditPublicKey: parameters.auditPublicKey } : {}
   });
   return parameters.sdk.proveTransaction(
     parameters.publicInput,
-    buildZeroPublicLegs(),
-    [parameters.legA.withdrawObject, parameters.legB.withdrawObject],
-    parameters.deposits,
+    padPublicLegsToLayout(parameters.sdk, buildZeroPublicLegs()),
+    padWithdrawSlotsToLayout(parameters.sdk, [
+      parameters.legA.withdrawObject,
+      parameters.legB.withdrawObject
+    ]),
+    padDepositSlotsToLayout(parameters.sdk, parameters.deposits),
     audit
   );
 }
@@ -5840,24 +5488,33 @@ async function buildDualTransferProofContext(parameters, applicationId, sdk) {
     changeStroops,
     parameters.selfPrivateAddressStpl1ForChange
   );
-  const { legA, legB } = dualWithdrawLegsWithSharedRoot({
-    sdk,
-    coinA: parameters.coinA,
-    coinB: parameters.coinB,
-    state: parameters.state,
-    ephemeralA: parseEphemeralKeyString(parameters.ephemeralAKey),
-    ephemeralB: parseEphemeralKeyString(parameters.ephemeralBKey),
-    applicationId
-  });
+  const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
+    parameters.senderPrivKeyScalarHex
+  );
+  const ownerPubHex = sdk.ecdhEphemeralPublicKeyFromScalarHex(
+    parameters.senderPrivKeyScalarHex
+  );
+  const { legA, legB } = stampDualWithdrawLegs(
+    dualWithdrawLegsWithSharedRoot({
+      sdk,
+      coinA: parameters.coinA,
+      coinB: parameters.coinB,
+      state: parameters.state,
+      ownerPubHex,
+      privKeyScalar,
+      applicationId
+    }),
+    parameters
+  );
   const transferInputs = await buildSenderTransferDepositsAndPublicInput({
-    senderGAddress: parameters.senderGAddress,
     senderPrivKeyScalarHex: parameters.senderPrivKeyScalarHex,
     recipientPrivateAddressStpl1: parameters.recipientPrivateAddressStpl1,
     transferStroops: parameters.transferStroops,
     changeStroops,
     selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
     tokenAddress: parameters.tokenAddress,
-    stateRoot: legA.witness.stateRoot
+    stateRoot: legA.witness.stateRoot,
+    ...confidentialEscrowFields(parameters)
   });
   return { legA, legB, applicationId, ...transferInputs };
 }
@@ -5885,7 +5542,11 @@ async function prepareConfidentialTransferProofDual(parameters) {
   }));
   return {
     ...proof,
-    applicationIdsPlaintext: buildDualTransferApplicationIds(applicationId, changeCoin),
+    applicationIdsPlaintext: buildDualTransferApplicationIds(
+      sdk,
+      applicationId,
+      changeCoin
+    ),
     recipientCoin: generatedOutputCoinFromSlot(recipientSlot),
     ...changeCoin ? { changeCoin } : {}
   };
@@ -5903,51 +5564,72 @@ function validateSingleCoinTransferAmounts(transferStroops, noteStroops, selfPri
   requireChangeRecipientWhenPartial(changeStroops, selfPrivateAddressStpl1ForChange);
   return changeStroops;
 }
-function buildSingleTransferApplicationIds(applicationId, changeCoin) {
-  return [applicationId, "0", applicationId, changeCoin ? applicationId : "0"];
+function buildSingleTransferApplicationIds(sdk, applicationId, changeCoin) {
+  return buildApplicationIdHints({
+    sdk,
+    inputIds: [applicationId],
+    outputIds: [applicationId, changeCoin ? applicationId : "0"]
+  });
 }
 function buildTransferAuditParameters(parameters) {
   const auditPublicKey = parameters.poolService.getAuditPublicKey();
   return buildPoolTransactionAuditParameters({
     applicationId: parameters.applicationId,
+    nAuditSlots: parameters.nAuditSlots,
     ...auditPublicKey ? { auditPublicKey } : {}
   });
 }
 async function proveTransaction(parameters) {
   return parameters.sdk.proveTransaction(
     parameters.publicInput,
-    buildZeroPublicLegs(),
-    [parameters.withdrawObject, "dummy"],
-    parameters.deposits,
+    padPublicLegsToLayout(parameters.sdk, buildZeroPublicLegs()),
+    padWithdrawSlotsToLayout(parameters.sdk, [parameters.withdrawObject]),
+    padDepositSlotsToLayout(parameters.sdk, parameters.deposits),
     parameters.audit
   );
 }
+function confidentialEscrowFields2(input) {
+  return {
+    ...input.escrowSend ? { escrowSend: input.escrowSend } : {},
+    ...input.escrowClaimantLimbs ? { escrowClaimantLimbs: input.escrowClaimantLimbs } : {}
+  };
+}
 async function buildTransferProofInputs(parameters) {
   const changeStroops = validateSingleCoinTransferAmounts(
     parameters.input.transferStroops,
     parameters.noteStroops,
     parameters.input.selfPrivateAddressStpl1ForChange
   );
+  const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
+    parameters.input.senderPrivKeyScalarHex
+  );
   const { witness, withdrawObject } = withdrawWitnessForCoin({
     sdk: parameters.sdk,
     coin: parameters.input.coin,
     state: parameters.input.state,
-    ...parseEphemeralKeyString(parameters.input.depositorEphemeralKey),
+    ownerPubHex: parameters.sdk.ecdhEphemeralPublicKeyFromScalarHex(
+      parameters.input.senderPrivKeyScalarHex
+    ),
+    privKeyScalar,
     applicationId: parameters.applicationId
   });
+  const stampedWithdraw = stampWithdrawEscrowLimbs(
+    withdrawObject,
+    sweepWithdrawStamp(confidentialEscrowFields2(parameters.input))
+  );
   const { recipientSlot, deposits, changeCoin, publicInput } = await buildSenderTransferDepositsAndPublicInput({
-    senderGAddress: parameters.input.senderGAddress,
     senderPrivKeyScalarHex: parameters.input.senderPrivKeyScalarHex,
     recipientPrivateAddressStpl1: parameters.input.recipientPrivateAddressStpl1,
     transferStroops: parameters.input.transferStroops,
     changeStroops,
     selfPrivateAddressStpl1ForChange: parameters.input.selfPrivateAddressStpl1ForChange,
     tokenAddress: parameters.input.tokenAddress,
-    stateRoot: witness.stateRoot
+    stateRoot: witness.stateRoot,
+    ...confidentialEscrowFields2(parameters.input)
   });
   return {
     witness,
-    withdrawObject,
+    withdrawObject: stampedWithdraw,
     recipientSlot,
     deposits,
     changeCoin,
@@ -5965,7 +5647,11 @@ async function prepareConfidentialTransferProof(parameters) {
     input: parameters,
     noteStroops
   });
-  const audit = buildTransferAuditParameters({ poolService, applicationId });
+  const audit = buildTransferAuditParameters({
+    poolService,
+    applicationId,
+    nAuditSlots: sdk.getLayout().nAuditSlots
+  });
   const proof = await proveTransaction({
     sdk,
     publicInput,
@@ -5976,6 +5662,7 @@ async function prepareConfidentialTransferProof(parameters) {
   return {
     ...proof,
     applicationIdsPlaintext: buildSingleTransferApplicationIds(
+      sdk,
       applicationId,
       changeCoin
     ),
@@ -5984,95 +5671,26 @@ async function prepareConfidentialTransferProof(parameters) {
   };
 }
 
-// src/transact/engine/prepare/transfer-helpers.ts
-function isPublicRecipientTransfer(prepared) {
-  return prepared.kind === "transfer" && prepared.intent.disclosure.recipientAddress === "public";
-}
-async function resolveTransferRecipientForExecute(prepared, environment, walletPublicKey) {
-  if (!isPublicRecipientTransfer(prepared)) {
-    return {
-      recipientPrivateAddressStpl1: prepared.intent.to.trim()
-    };
-  }
-  if (!environment.resolveTransferRecipientAtExecute) {
-    throw new Error("Transfer recipient resolver is not configured.");
-  }
-  return environment.resolveTransferRecipientAtExecute({
-    recipientStellarAddress: prepared.intent.to.trim(),
-    walletPublicKey
-  });
-}
-async function resolveTransferOnboardingAtExecute(input) {
-  if (input.prepared.transactArtifacts?.onboarding) {
-    return input.prepared.transactArtifacts.onboarding;
-  }
-  if (!input.recipient.temporaryRecipientKey || !input.environment.buildTransferOnboardingAtExecute) {
-    return;
-  }
-  return input.environment.buildTransferOnboardingAtExecute({
-    ownerStellarAddress: input.recipient.recipientStellarAddress ?? input.prepared.intent.to.trim(),
-    temporaryRecipientKey: input.recipient.temporaryRecipientKey,
-    recipientNote: {
-      tokenAddress: input.tokenAddress,
-      nullifier: input.recipientCoin.nullifier,
-      secret: input.recipientCoin.secret,
-      value: input.recipientCoin.value
-    }
-  });
-}
-
-// src/transact/onboarding/build-pending-claim-payload.ts
-import { Buffer as Buffer15 } from "buffer";
-var FIELD_HEX_LENGTH2 = 64;
-function hexToBuffer2(hex) {
-  const clean = hex.trim().replace(/^0x/u, "");
-  return Buffer15.from(clean.padStart(FIELD_HEX_LENGTH2, "0"), "hex");
-}
-function buildPendingClaimOnboardingPayload(input) {
-  const ownerAddress = input.claim.owner.trim();
-  const permanentPrivateAddress = input.permanentPrivateAddressStpl1.trim();
-  const decoded = decodePrivateAddress(permanentPrivateAddress);
-  const encryptedRecovery = input.claim.encryptedRecoveryBase64?.trim();
-  if (!encryptedRecovery) {
-    throw new Error("Pending claim is missing encrypted recovery data.");
-  }
-  return {
-    owner: ownerAddress,
-    temp_public_key_x: hexToBuffer2(input.claim.tempPublicKeyXHex ?? ""),
-    temp_public_key_y: hexToBuffer2(input.claim.tempPublicKeyYHex ?? ""),
-    encrypted_private_key: Buffer15.from(encryptedRecovery, "base64"),
-    notes: { notes: [] },
-    private_address_registration: {
-      tag: "Some",
-      values: [
-        {
-          owner: ownerAddress,
-          public_key_x: hexToBuffer2(decoded.x),
-          public_key_y: hexToBuffer2(decoded.y)
-        }
-      ]
-    }
-  };
-}
-
 // src/transact/engine/transfer-proof-at-execute.ts
 function readChangeRecipient(input, changeStroops) {
   if (changeStroops <= 0n || input.prepared.kind !== "transfer") {
     return void 0;
   }
   const from = input.prepared.intent.from;
-  if (isPendingClaimSource(from)) {
-    return void 0;
-  }
   return readTransferFromPrivateAddress(from);
 }
+function proofEscrowFields(input) {
+  return {
+    ...input.escrowSend ? { escrowSend: input.escrowSend } : {},
+    ...input.escrowClaimantLimbs ? { escrowClaimantLimbs: input.escrowClaimantLimbs } : {}
+  };
+}
 async function buildSingleTransferProofAtExecute(input) {
   const context = await buildSpendProofContextAtExecute(input);
-  const changeStroops = context.pendingClaim ? 0n : BigInt(context.coin.value) - input.prepared.intent.amount;
+  const changeStroops = BigInt(context.coin.value) - input.prepared.intent.amount;
   const proof = await prepareConfidentialTransferProof({
     coin: context.coin,
     state: { commitments: context.commitments },
-    senderGAddress: context.walletPublicKey,
     senderPrivKeyScalarHex: context.senderPrivKeyScalarHex,
     depositorEphemeralKey: serializeEphemeralKeyString({
       xHex: context.ephemeral.xHex,
@@ -6081,7 +5699,8 @@ async function buildSingleTransferProofAtExecute(input) {
     transferStroops: input.prepared.intent.amount,
     recipientPrivateAddressStpl1: context.recipientPrivateAddressStpl1,
     selfPrivateAddressStpl1ForChange: readChangeRecipient(input, changeStroops),
-    tokenAddress: context.tokenAddress
+    tokenAddress: context.tokenAddress,
+    ...proofEscrowFields(input)
   });
   return { context, proof };
 }
@@ -6103,7 +5722,6 @@ async function buildDualTransferProofAtExecute(input) {
     coinA: context.coin,
     coinB: secondary.coin,
     state: { commitments: context.commitments },
-    senderGAddress: context.walletPublicKey,
     senderPrivKeyScalarHex: context.senderPrivKeyScalarHex,
     ephemeralAKey: serializeEphemeralKeyString({
       xHex: context.ephemeral.xHex,
@@ -6116,7 +5734,8 @@ async function buildDualTransferProofAtExecute(input) {
     transferStroops: input.prepared.intent.amount,
     recipientPrivateAddressStpl1: context.recipientPrivateAddressStpl1,
     selfPrivateAddressStpl1ForChange: readChangeRecipient(input, changeStroops),
-    tokenAddress: context.tokenAddress
+    tokenAddress: context.tokenAddress,
+    ...proofEscrowFields(input)
   });
   return { context, proof };
 }
@@ -6132,6 +5751,41 @@ async function buildTransferProofAtExecute(input) {
 }
 
 // src/transact/engine/transfer-finalize.ts
+function stampEscrowOutputRecords(input) {
+  if (input.escrowSendPrivateAddress) {
+    const [recipientRecord, ...rest] = input.prepared.outputRecords;
+    if (recipientRecord) {
+      input.prepared.outputRecords = [
+        {
+          ...recipientRecord,
+          privateAddress: input.escrowSendPrivateAddress
+        },
+        ...rest
+      ];
+    }
+  }
+  seedEscrowSweepOutputsFromProof({
+    prepared: input.prepared,
+    proof: input.proof,
+    walletPublicKey: input.walletPublicKey
+  });
+  enrichTransferOutputRecords(input.prepared, input.proof);
+}
+function seedEscrowSweepOutputsFromProof(input) {
+  if (input.prepared.transactArtifacts?.spendSource !== "escrow" || input.prepared.outputRecords.length > 0) {
+    return;
+  }
+  input.prepared.outputRecords = [
+    {
+      id: input.proof.recipientCoin.commitment_hex,
+      owner: input.walletPublicKey,
+      privateAddress: input.prepared.intent.to,
+      asset: input.prepared.intent.asset,
+      amount: input.prepared.intent.amount,
+      consumed: false
+    }
+  ];
+}
 function enrichTransferOutputRecords(prepared, proof) {
   if (prepared.outputRecords.length === 0) {
     return;
@@ -6155,65 +5809,34 @@ function enrichTransferOutputRecords(prepared, proof) {
     };
   });
 }
-async function resolvePendingClaimOnboardingAtExecute(input) {
-  const claim = input.prepared.transactArtifacts?.pendingClaim;
-  if (!claim || input.prepared.kind !== "transfer") {
-    return;
-  }
-  const contractContext = requireContractContext(input.environment);
-  const lookup = await readRegistryLookupFromChain({
-    contractContext,
-    owner: input.walletPublicKey.trim(),
-    walletPublicKey: input.walletPublicKey.trim()
-  });
-  if (lookup.status === "registered") {
-    return;
-  }
-  return buildPendingClaimOnboardingPayload({
-    claim,
-    permanentPrivateAddressStpl1: input.prepared.intent.to.trim()
-  });
-}
-async function ensurePendingClaimReadyForExecute(input) {
-  const pendingClaim = input.prepared.transactArtifacts?.pendingClaim;
-  if (!pendingClaim) {
-    return;
+function escrowSpendArtifacts(input) {
+  if (input.escrowSend) {
+    return {
+      escrowSend: true,
+      spendSource: "escrow",
+      ...input.escrowRecipient ? { escrowRecipient: input.escrowRecipient } : {}
+    };
   }
-  await verifyPendingClaimBeforeExecute({
-    claim: pendingClaim,
-    environment: input.environment,
-    walletPublicKey: input.walletPublicKey
-  });
-}
-async function resolveTransferOnboardingBundle(input) {
-  const pendingClaim = input.prepared.transactArtifacts?.pendingClaim;
-  if (pendingClaim) {
-    const pendingOnboarding = await resolvePendingClaimOnboardingAtExecute({
-      prepared: input.prepared,
-      environment: input.environment,
-      walletPublicKey: input.walletPublicKey
-    });
-    if (pendingOnboarding) {
-      return pendingOnboarding;
-    }
+  if (input.preparedSpendSource === "escrow") {
+    return {
+      spendSource: "escrow",
+      ...input.escrowRecipient ? { escrowRecipient: input.escrowRecipient } : {},
+      ...input.escrowSpendScalarHex ? { escrowSpendScalarHex: input.escrowSpendScalarHex } : {},
+      ...input.escrowClaimantLimbs ? { escrowClaimantLimbs: input.escrowClaimantLimbs } : {}
+    };
   }
-  return resolveTransferOnboardingAtExecute({
-    prepared: input.prepared,
-    environment: input.environment,
-    recipient: input.recipient,
-    recipientCoin: input.recipientCoin,
-    tokenAddress: input.tokenAddress
-  });
+  return {};
 }
 function buildTransferFinalizeArtifacts(input) {
   return {
     proofHex: input.proof.proof_hex,
     publicHex: input.proof.public_hex,
+    ...ciphertextArtifactsFromProof(input.proof),
     applicationIdsPlaintext: input.proof.applicationIdsPlaintext,
     tokenAddress: input.context.tokenAddress,
     walletPublicKey: input.context.walletPublicKey,
-    onboarding: input.onboarding,
-    executeFinalizeRequired: false
+    executeFinalizeRequired: false,
+    ...escrowSpendArtifacts(input)
   };
 }
 async function runTransferFinalizeSteps(input) {
@@ -6222,26 +5845,50 @@ async function runTransferFinalizeSteps(input) {
     input.environment,
     input.walletPublicKey
   );
+  const spendScalarHex = nullifierCheckSpendScalarHex(input.prepared.transactArtifacts);
   await verifyPrivateRecordsNullifiersBeforeExecute({
     records: input.prepared.consumedRecords,
     environment: input.environment,
-    walletPublicKey: input.walletPublicKey
+    walletPublicKey: input.walletPublicKey,
+    ...spendScalarHex ? { spendScalarHex } : {}
   });
   const { context, proof } = await buildTransferProofAtExecute({
     prepared: input.prepared,
     environment: input.environment,
-    recipientPrivateAddressStpl1: recipient.recipientPrivateAddressStpl1
+    recipientPrivateAddressStpl1: recipient.recipientPrivateAddressStpl1,
+    ...recipient.escrowSend ? { escrowSend: recipient.escrowSend } : {},
+    ...input.prepared.transactArtifacts?.escrowClaimantLimbs ? {
+      escrowClaimantLimbs: input.prepared.transactArtifacts.escrowClaimantLimbs
+    } : {}
   });
-  const onboarding = await resolveTransferOnboardingBundle({
+  stampEscrowOutputRecords({
     prepared: input.prepared,
-    environment: input.environment,
+    proof,
     walletPublicKey: input.walletPublicKey,
-    recipient,
-    recipientCoin: proof.recipientCoin.coin,
-    tokenAddress: context.tokenAddress
+    ...recipient.escrowSend ? { escrowSendPrivateAddress: recipient.recipientPrivateAddressStpl1 } : {}
+  });
+  return buildTransferFinalizeArtifacts({
+    proof,
+    context,
+    ...sweepFinalizeStamp(input.prepared, recipient)
   });
-  enrichTransferOutputRecords(input.prepared, proof);
-  return buildTransferFinalizeArtifacts({ proof, context, onboarding });
+}
+function sweepArtifactStamp(artifacts) {
+  return {
+    ...artifacts?.escrowSpendScalarHex ? { escrowSpendScalarHex: artifacts.escrowSpendScalarHex } : {},
+    ...artifacts?.spendSource ? { preparedSpendSource: artifacts.spendSource } : {},
+    ...artifacts?.escrowClaimantLimbs ? { escrowClaimantLimbs: artifacts.escrowClaimantLimbs } : {}
+  };
+}
+function sweepFinalizeStamp(prepared, recipient) {
+  const artifacts = prepared.transactArtifacts;
+  const fromSend = recipient.escrowSend?.recipientStellarAddress?.trim();
+  const escrowRecipient = fromSend || artifacts?.escrowRecipient?.trim();
+  return {
+    ...recipient.escrowSend ? { escrowSend: true } : {},
+    ...escrowRecipient ? { escrowRecipient } : {},
+    ...sweepArtifactStamp(artifacts)
+  };
 }
 async function finalizeTransferAtExecute(prepared, environment) {
   const [primaryRecord] = prepared.consumedRecords;
@@ -6249,11 +5896,6 @@ async function finalizeTransferAtExecute(prepared, environment) {
     throw new Error("Transfer execution record owner is missing.");
   }
   const walletPublicKey = primaryRecord.owner.trim();
-  await ensurePendingClaimReadyForExecute({
-    prepared,
-    environment,
-    walletPublicKey
-  });
   return runTransferFinalizeSteps({ prepared, environment, walletPublicKey });
 }
 
@@ -6272,12 +5914,18 @@ function enrichWithdrawOutputRecords(prepared, proof) {
     precommitementHex: changeCoin.precommitementHex
   }));
 }
-async function finalizeWithdrawAtExecute(prepared, environment, poolService) {
-  if (prepared.kind !== "withdraw") {
-    throw new Error("Withdraw finalize requires a withdraw operation.");
-  }
-  const withdrawIntent = prepared.intent;
-  const withdrawFrom = withdrawIntent.from;
+function buildWithdrawFinalizeArtifacts(proof, context) {
+  return {
+    proofHex: proof.proof_hex,
+    publicHex: proof.public_hex,
+    ...ciphertextArtifactsFromProof(proof),
+    applicationIdsPlaintext: proof.applicationIdsPlaintext,
+    tokenAddress: context.tokenAddress,
+    walletPublicKey: context.walletPublicKey,
+    executeFinalizeRequired: false
+  };
+}
+async function finalizeSingleWithdrawAtExecute(prepared, environment, poolService, withdrawFrom) {
   const context = await buildSpendProofContextAtExecute({
     prepared,
     environment,
@@ -6298,14 +5946,71 @@ async function finalizeWithdrawAtExecute(prepared, environment, poolService) {
     tokenAddress: context.tokenAddress
   });
   enrichWithdrawOutputRecords(prepared, proof);
-  return {
-    proofHex: proof.proof_hex,
-    publicHex: proof.public_hex,
-    applicationIdsPlaintext: proof.applicationIdsPlaintext,
-    tokenAddress: context.tokenAddress,
+  return buildWithdrawFinalizeArtifacts(proof, context);
+}
+async function finalizeDualWithdrawAtExecute(prepared, environment, poolService, withdrawFrom) {
+  const [, secondaryRecord] = prepared.consumedRecords;
+  if (!secondaryRecord) {
+    throw new Error("Dual withdraw execution requires two private input records.");
+  }
+  const context = await buildSpendProofContextAtExecute({
+    prepared,
+    environment,
+    recipientPrivateAddressStpl1: withdrawFrom
+  });
+  const secondary = await readCoinEphemeralForRecord({
+    record: secondaryRecord,
+    environment,
     walletPublicKey: context.walletPublicKey,
-    executeFinalizeRequired: false
-  };
+    commitments: context.commitments
+  });
+  const totalNotes = BigInt(context.coin.value) + BigInt(secondary.coin.value);
+  const changeStroops = totalNotes - prepared.intent.amount;
+  const proof = await poolService.prepareWithdrawTransactProofDual({
+    coinA: context.coin,
+    coinB: secondary.coin,
+    state: { commitments: context.commitments },
+    destinationStellarAddress: prepared.intent.to,
+    privKeyScalarHex: context.senderPrivKeyScalarHex,
+    depositorEphemeralAKey: serializeEphemeralKeyString({
+      xHex: context.ephemeral.xHex,
+      yHex: context.ephemeral.yHex
+    }),
+    depositorEphemeralBKey: serializeEphemeralKeyString({
+      xHex: secondary.ephemeral.xHex,
+      yHex: secondary.ephemeral.yHex
+    }),
+    withdrawAmountStroops: prepared.intent.amount,
+    changePrivateAddressStpl1: changeStroops > 0n ? withdrawFrom : void 0,
+    tokenAddress: context.tokenAddress
+  });
+  enrichWithdrawOutputRecords(prepared, proof);
+  return buildWithdrawFinalizeArtifacts(proof, context);
+}
+async function finalizeWithdrawAtExecute(prepared, environment, poolService) {
+  if (prepared.kind !== "withdraw") {
+    throw new Error("Withdraw finalize requires a withdraw operation.");
+  }
+  const withdrawIntent = prepared.intent;
+  const withdrawFrom = withdrawIntent.from;
+  const recordCount = prepared.consumedRecords.length;
+  if (recordCount === 1) {
+    return finalizeSingleWithdrawAtExecute(
+      prepared,
+      environment,
+      poolService,
+      withdrawFrom
+    );
+  }
+  if (recordCount === 2) {
+    return finalizeDualWithdrawAtExecute(
+      prepared,
+      environment,
+      poolService,
+      withdrawFrom
+    );
+  }
+  throw new Error("Confidential withdraw execution supports at most two input notes.");
 }
 async function finalizeSpendOperationAtExecute(prepared, environment, poolService) {
   if (prepared.kind !== "transfer" && prepared.kind !== "withdraw") {
@@ -6324,6 +6029,12 @@ async function finalizeSpendOperationAtExecute(prepared, environment, poolServic
   };
 }
 
+// src/transact/kyt/passage/inspect.ts
+import {
+  layoutForKnownNonce,
+  zeroBindingTagsInPublicSignals
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
+
 // src/transact/kyt/inspect-error.ts
 var KytInspectError = class extends Error {
   reasonCode;
@@ -6406,16 +6117,16 @@ async function waitForKytRegistration(parameters) {
 }
 
 // src/transact/kyt/passage/submit.ts
-import { Buffer as Buffer16 } from "buffer";
+import { Buffer as Buffer14 } from "buffer";
 import { Operation, TransactionBuilder, rpc as rpc3, xdr as xdr2 } from "@stellar/stellar-sdk";
 var KYT_REGISTER_FEE_STROOPS = "1000000";
 var KYT_REGISTER_TIMEOUT_SECONDS = 300;
 function passageIdToScValue(passageId) {
-  return xdr2.ScVal.scvBytes(Buffer16.from(passageId.replace(/^0x/, ""), "hex"));
+  return xdr2.ScVal.scvBytes(Buffer14.from(passageId.replace(/^0x/, ""), "hex"));
 }
 function approvalSignatureToBytes(signature) {
   const clean = signature.trim();
-  return /^(0x)?[0-9a-fA-F]{128}$/.test(clean) ? Buffer16.from(clean.replace(/^0x/i, ""), "hex") : Buffer16.from(clean, "base64");
+  return /^(0x)?[0-9a-fA-F]{128}$/.test(clean) ? Buffer14.from(clean.replace(/^0x/i, ""), "hex") : Buffer14.from(clean, "base64");
 }
 function signatureToScValue(signature) {
   const bytes = approvalSignatureToBytes(signature);
@@ -6464,8 +6175,8 @@ async function registerKytPassage(parameters) {
 }
 
 // src/transact/kyt/passage/inspect.ts
-function buildApplicationIdHints(applicationId) {
-  return [applicationId, applicationId, applicationId, applicationId];
+function buildApplicationIdHints2(applicationId, nAuditSlots) {
+  return uniformApplicationIdHints(applicationId, nAuditSlots);
 }
 function buildNonce() {
   return globalThis.crypto?.randomUUID?.() ?? `${Date.now()}`;
@@ -6493,36 +6204,61 @@ function throwKytInspectRejected(body) {
     ...parsed.address ? { detailAddress: parsed.address } : {}
   });
 }
-async function requestKytPassageForPoolInteraction(input) {
-  const applicationId = resolvePoolApplicationId(
-    input.transactEnvironment.network.applicationId
-  );
-  const applicationIdsPlaintext = input.applicationIdsPlaintext ?? buildApplicationIdHints(applicationId);
-  const kytRegistry = input.transactEnvironment.kyt.kytPassageRegistryContract;
-  const currentLedger = await fetchCurrentLedger(input.sorobanRpcUrl);
+function inspectRequestHeaders(inspectAuthorization) {
+  const token = inspectAuthorization?.trim();
+  return {
+    "content-type": "application/json",
+    ...token ? { authorization: `Bearer ${token}` } : {}
+  };
+}
+async function postKytInspect(input, applicationIdsPlaintext, zkConfigNonce, currentLedger) {
   const response = await fetch(
     `${input.transactEnvironment.kyt.apiBaseUrl}/kyt/passages/inspect`,
     {
       method: "POST",
-      headers: { "content-type": "application/json" },
+      headers: inspectRequestHeaders(
+        input.transactEnvironment.kyt.inspectAuthorization
+      ),
       body: JSON.stringify(
         {
           owner: input.owner,
           poolContract: input.poolContract,
-          kytRegistry,
+          kytRegistry: input.transactEnvironment.kyt.kytPassageRegistryContract,
           proofBytes: input.proofHex,
-          publicSignalsBytes: input.publicHex,
+          publicSignalsBytes: zeroBindingTagsInPublicSignals(
+            input.publicHex,
+            zkConfigNonce
+          ).toString("hex"),
           applicationIdsPlaintext,
           decryptedAuditSlots: input.decryptedAuditSlots,
-          onboarding: input.onboarding,
           nonce: buildNonce(),
-          currentLedger
+          zkConfigNonce,
+          currentLedger,
+          ...input.ciphertextHex ? { ciphertextBytes: input.ciphertextHex } : {},
+          ...input.outputNoteEphemeralScalars ? { outputNoteEphemeralScalars: input.outputNoteEphemeralScalars } : {}
         },
         kytJsonReplacer
       )
     }
   );
-  const body = await parseInspectResponse(response);
+  return parseInspectResponse(response);
+}
+async function requestKytPassageForPoolInteraction(input) {
+  const applicationId = resolvePoolApplicationId(
+    input.transactEnvironment.network.applicationId
+  );
+  const zkConfigNonce = resolveZkConfigNonce(input.transactEnvironment);
+  const applicationIdsPlaintext = input.applicationIdsPlaintext ?? buildApplicationIdHints2(
+    applicationId,
+    layoutForKnownNonce(zkConfigNonce).nAuditSlots
+  );
+  const currentLedger = await fetchCurrentLedger(input.sorobanRpcUrl);
+  const body = await postKytInspect(
+    input,
+    applicationIdsPlaintext,
+    zkConfigNonce,
+    currentLedger
+  );
   if (body.status !== "approved") {
     throwKytInspectRejected(body);
   }
@@ -6538,14 +6274,129 @@ async function requestKytPassageForPoolInteraction(input) {
   return body;
 }
 
+// src/transact/submit/zk-config-ttl.ts
+import {
+  Address as Address2,
+  Operation as Operation2,
+  SorobanDataBuilder,
+  TransactionBuilder as TransactionBuilder2,
+  rpc as rpc4,
+  xdr as xdr3
+} from "@stellar/stellar-sdk";
+var ZK_CONFIG_TTL_THRESHOLD_LEDGERS = 1e5;
+var ZK_CONFIG_TTL_EXTEND_TO_LEDGERS = 5e5;
+var EXTEND_TTL_FEE_STROOPS = "1000000";
+var EXTEND_TTL_TIMEOUT_SECONDS = 300;
+var EXTEND_TTL_MAX_POLLS = 60;
+var EXTEND_TTL_POLL_INTERVAL_MS = 1e3;
+async function waitForExtendFootprintTtlConfirmation(parameters) {
+  for (let attempt = 0; attempt < EXTEND_TTL_MAX_POLLS; attempt += 1) {
+    const response = await parameters.server.getTransaction(parameters.hash);
+    if (response.status === "SUCCESS") {
+      return;
+    }
+    if (response.status === "FAILED") {
+      throw new Error("ZK config TTL extension failed on-chain");
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, EXTEND_TTL_POLL_INTERVAL_MS);
+    });
+  }
+  throw new Error("ZK config TTL extension was not confirmed in time");
+}
+function zkConfigLedgerKey(contractId, nonce) {
+  const configKeyScValue = xdr3.ScVal.scvVec([
+    xdr3.ScVal.scvSymbol("Config"),
+    xdr3.ScVal.scvU64(xdr3.Uint64.fromString(nonce.toString()))
+  ]);
+  return xdr3.LedgerKey.contractData(
+    new xdr3.LedgerKeyContractData({
+      contract: new Address2(contractId).toScAddress(),
+      key: configKeyScValue,
+      durability: xdr3.ContractDataDurability.persistent()
+    })
+  );
+}
+async function needsTtlExtension(parameters) {
+  const [entriesResponse, latestLedger] = await Promise.all([
+    parameters.server.getLedgerEntries(parameters.ledgerKey),
+    parameters.server.getLatestLedger()
+  ]);
+  const entry = entriesResponse.entries.at(0);
+  if (!entry || entry.liveUntilLedgerSeq === void 0) {
+    return false;
+  }
+  const remainingLedgers = entry.liveUntilLedgerSeq - latestLedger.sequence;
+  return remainingLedgers < ZK_CONFIG_TTL_THRESHOLD_LEDGERS;
+}
+async function submitExtendFootprintTtlTransaction(parameters) {
+  const sourceAccount = await parameters.server.getAccount(parameters.sourcePublicKey);
+  const transaction = new TransactionBuilder2(sourceAccount, {
+    fee: EXTEND_TTL_FEE_STROOPS,
+    networkPassphrase: parameters.networkPassphrase
+  }).addOperation(
+    Operation2.extendFootprintTtl({ extendTo: ZK_CONFIG_TTL_EXTEND_TO_LEDGERS })
+  ).setSorobanData(
+    new SorobanDataBuilder().setReadOnly([parameters.ledgerKey]).build()
+  ).setTimeout(EXTEND_TTL_TIMEOUT_SECONDS).build();
+  const preparedTransaction = await parameters.server.prepareTransaction(transaction);
+  const { signedTxXdr } = await parameters.signTransaction({
+    xdr: preparedTransaction.toXDR(),
+    networkPassphrase: parameters.networkPassphrase,
+    address: parameters.sourcePublicKey
+  });
+  const signedTransaction = TransactionBuilder2.fromXDR(
+    signedTxXdr,
+    parameters.networkPassphrase
+  );
+  const result = await parameters.server.sendTransaction(signedTransaction);
+  const status = String(result.status);
+  if (status !== "PENDING" && status !== "SUCCESS") {
+    throw new Error(`ZK config TTL extension submit failed: ${status}`);
+  }
+  await waitForExtendFootprintTtlConfirmation({
+    server: parameters.server,
+    hash: result.hash
+  });
+}
+async function extendZkConfigTtlIfNeeded(parameters) {
+  if (!parameters.signTransaction) {
+    return;
+  }
+  const server = new rpc4.Server(parameters.sorobanRpcUrl, { allowHttp: true });
+  const ledgerKey = zkConfigLedgerKey(parameters.contractId, parameters.nonce);
+  if (!await needsTtlExtension({ server, ledgerKey })) {
+    return;
+  }
+  await submitExtendFootprintTtlTransaction({
+    server,
+    ledgerKey,
+    networkPassphrase: parameters.networkPassphrase,
+    sourcePublicKey: parameters.sourcePublicKey,
+    signTransaction: parameters.signTransaction
+  });
+}
+
 // src/transact/submit/pool-transact.ts
-import { Buffer as Buffer17 } from "buffer";
+import { Buffer as Buffer15 } from "buffer";
 async function submitPoolTransact(parameters) {
+  await extendZkConfigTtlIfNeeded({
+    sorobanRpcUrl: parameters.sorobanRpcUrl,
+    networkPassphrase: parameters.networkPassphrase,
+    contractId: parameters.contractId,
+    nonce: parameters.nonce,
+    sourcePublicKey: parameters.from,
+    signTransaction: parameters.transactEnvironment.signTransaction
+  });
   const assembledTransaction = await parameters.contractClient.transact({
     from: parameters.from,
-    proof_bytes: Buffer17.from(parameters.proofHex.replace(/^0x/iu, ""), "hex"),
-    pub_signals_bytes: Buffer17.from(parameters.publicHex.replace(/^0x/iu, ""), "hex"),
-    onboarding: parameters.onboarding,
+    nonce: parameters.nonce,
+    proof_bytes: Buffer15.from(parameters.proofHex.replace(/^0x/iu, ""), "hex"),
+    pub_signals_bytes: Buffer15.from(parameters.publicHex.replace(/^0x/iu, ""), "hex"),
+    ciphertext_bytes: Buffer15.from(
+      (parameters.ciphertextHex ?? "").replace(/^0x/iu, ""),
+      "hex"
+    ),
     kyt_authorization: {
       expiration_ledger: parameters.approval.expiresAtLedger,
       signature: approvalSignatureToBytes(parameters.approval.signature)
@@ -6573,7 +6424,8 @@ async function submitSorobanConfidentialTransfer(input) {
     poolContract: input.contractId,
     proofHex: input.proofHex,
     publicHex: input.publicHex,
-    ...input.onboarding ? { onboarding: input.onboarding } : {},
+    ...input.ciphertextHex ? { ciphertextHex: input.ciphertextHex } : {},
+    ...input.outputNoteEphemeralScalars ? { outputNoteEphemeralScalars: input.outputNoteEphemeralScalars } : {},
     ...input.applicationIdsPlaintext ? { applicationIdsPlaintext: input.applicationIdsPlaintext } : {},
     networkPassphrase: input.networkPassphrase,
     sorobanRpcUrl: input.sorobanRpcUrl,
@@ -6581,15 +6433,27 @@ async function submitSorobanConfidentialTransfer(input) {
   });
   return submitPoolTransact({
     contractClient: poolClient,
+    contractId: input.contractId,
     from: input.walletPublicKey,
+    nonce: resolveZkConfigNonce(input.transactEnvironment),
     proofHex: input.proofHex,
     publicHex: input.publicHex,
-    ...input.onboarding ? { onboarding: input.onboarding } : {},
-    approval
+    ...input.ciphertextHex ? { ciphertextHex: input.ciphertextHex } : {},
+    approval,
+    networkPassphrase: input.networkPassphrase,
+    sorobanRpcUrl: input.sorobanRpcUrl,
+    transactEnvironment: input.transactEnvironment
   });
 }
 
 // src/transact/engine/submit.ts
+function optionalInspectCiphertext(artifacts) {
+  return {
+    ...artifacts.ciphertextHex ? { ciphertextHex: artifacts.ciphertextHex } : {},
+    ...artifacts.outputNoteEphemeralScalars ? { outputNoteEphemeralScalars: artifacts.outputNoteEphemeralScalars } : {},
+    ...artifacts.applicationIdsPlaintext ? { applicationIdsPlaintext: artifacts.applicationIdsPlaintext } : {}
+  };
+}
 async function submitPreparedDeposit(prepared, environment) {
   const artifacts = prepared.transactArtifacts;
   const outputRecord = prepared.outputRecords[0];
@@ -6607,17 +6471,23 @@ async function submitPreparedDeposit(prepared, environment) {
     poolContract: environment.network.poolContract,
     proofHex: artifacts.proofHex,
     publicHex: artifacts.publicHex,
-    ...artifacts.applicationIdsPlaintext ? { applicationIdsPlaintext: artifacts.applicationIdsPlaintext } : {},
+    ...optionalInspectCiphertext(artifacts),
     networkPassphrase: environment.network.networkPassphrase,
     sorobanRpcUrl: environment.network.rpcUrl,
     transactEnvironment: environment
   });
   return submitPoolTransact({
     contractClient: poolClient,
+    contractId: environment.network.poolContract,
     from: artifacts.walletPublicKey,
+    nonce: resolveZkConfigNonce(environment),
     proofHex: artifacts.proofHex,
     publicHex: artifacts.publicHex,
-    approval
+    ...artifacts.ciphertextHex ? { ciphertextHex: artifacts.ciphertextHex } : {},
+    approval,
+    networkPassphrase: environment.network.networkPassphrase,
+    sorobanRpcUrl: environment.network.rpcUrl,
+    transactEnvironment: environment
   });
 }
 async function submitPreparedPoolTransact(prepared, environment) {
@@ -6630,8 +6500,7 @@ async function submitPreparedPoolTransact(prepared, environment) {
     walletPublicKey: artifacts.walletPublicKey,
     proofHex: artifacts.proofHex,
     publicHex: artifacts.publicHex,
-    ...artifacts.onboarding ? { onboarding: artifacts.onboarding } : {},
-    ...artifacts.applicationIdsPlaintext ? { applicationIdsPlaintext: artifacts.applicationIdsPlaintext } : {},
+    ...optionalInspectCiphertext(artifacts),
     networkPassphrase: environment.network.networkPassphrase,
     sorobanRpcUrl: environment.network.rpcUrl,
     transactEnvironment: environment
@@ -6669,18 +6538,33 @@ function createBrowserStellarTransactEngine(input) {
 }
 
 // src/transact/engine/default-factory.ts
-async function createDefaultTransactEngine(assets, transactEnvironment) {
-  await PrivacyPoolSDK4.init({
+async function privacyPoolInitOptions(assets, transactEnvironment) {
+  if (!transactEnvironment) {
+    return { wasmBinary: assets.sdkWasm };
+  }
+  const zkConfigNonce = resolveZkConfigNonce(transactEnvironment);
+  const zkCircuits = await materializeSelectedZkCircuit(
+    transactEnvironment.zkCircuits,
+    zkConfigNonce
+  );
+  return {
     wasmBinary: assets.sdkWasm,
-    circuitWasm: assets.circuitWasm,
-    zkey: assets.provingKey
-  });
+    zkCircuits,
+    zkConfigNonce,
+    ...optionalZkArtifactBaseUrl(transactEnvironment.zkArtifactBaseUrl)
+  };
+}
+async function createDefaultTransactEngine(assets, transactEnvironment) {
+  await PrivacyPoolSDK3.init(await privacyPoolInitOptions(assets, transactEnvironment));
   if (transactEnvironment) {
     configurePrivacyPoolService(
       createPrivacyPoolService({
         assets,
         applicationId: transactEnvironment.network.applicationId,
-        ...transactEnvironment.auditPublicKey ? { auditPublicKey: transactEnvironment.auditPublicKey } : {}
+        ...transactEnvironment.auditPublicKey ? { auditPublicKey: transactEnvironment.auditPublicKey } : {},
+        ...transactEnvironment.zkCircuits ? { zkCircuits: transactEnvironment.zkCircuits } : {},
+        ...transactEnvironment.zkConfigNonce === void 0 ? {} : { zkConfigNonce: transactEnvironment.zkConfigNonce },
+        ...optionalZkArtifactBaseUrl(transactEnvironment.zkArtifactBaseUrl)
       })
     );
     return createBrowserStellarTransactEngine({
@@ -6723,7 +6607,7 @@ async function createStellarPrivacyClientFromNodeConfig(config) {
       return input.transactEngine;
     }
     const browserAssets = await loadNodeAssets(input.assets);
-    return createDefaultTransactEngine(browserAssets);
+    return createDefaultTransactEngine(browserAssets, input.transactEnvironment);
   });
   if (!resolved.ok) {
     return resolved.result;