@arcanetech/privacy-sdk-stellar 0.3.0 → 0.4.1

package/dist/transact/index.js

@@ -1,9 +1,10 @@
 // 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 Buffer2 } from "buffer";
@@ -26,11 +27,18 @@ import {
   decodeStealthAddress,
   encodeStealthAddress,
   recipientPublicKeysDecimalFromStealthAddress
-} from "@auditable/privacy-pool-zk-sdk";
-import { DEFAULT_STEALTH_SIGN_NONCE } from "@auditable/privacy-pool-zk-sdk";
-function buildPrivateAddressSignMessage(publicKey, nonce) {
+} 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 buildPrivateAddressSignMessage(publicKey, domain, nonce) {
   const buildMessage = buildStealthAddressSignMessage;
-  return buildMessage(publicKey, nonce);
+  if (nonce === void 0) {
+    return buildMessage(publicKey, domain);
+  }
+  return buildMessage(publicKey, domain, nonce);
 }
 function decodePrivateAddress(value) {
   const decodeAddress = decodeStealthAddress;
@@ -60,12 +68,12 @@ 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 Buffer4 } from "buffer";
@@ -105,6 +113,10 @@ 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) {
@@ -131,7 +143,25 @@ 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) {
@@ -142,91 +172,91 @@ function assetLegToTokenAddress(assetHi, assetLo) {
   const payload = Buffer4.concat([decimalToBytes16(assetHi), decimalToBytes16(assetLo)]);
   return StrKey2.encodeContract(payload);
 }
-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 Buffer5 } 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 };
 }
@@ -235,16 +265,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) {
@@ -252,15 +282,6 @@ function dualWithdrawLegsWithSharedRoot(parameters) {
   }
   return { legA, legB };
 }
-function senderWithdrawFrAndScalar(parameters) {
-  const pkRaw = StrKey3.decodeEd25519PublicKey(parameters.senderGAddress);
-  const pkHex = Buffer5.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() ?? "";
@@ -285,15 +306,15 @@ function changeStroopsAfterDualTransfer(transferStroops, totalNotes) {
 import {
   DEMO_AUDIT_PUBLIC_KEY,
   resolveTransactionAuditParams
-} from "@auditable/privacy-pool-zk-sdk";
-import { Buffer as Buffer6 } from "buffer";
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
+import { Buffer as Buffer5 } 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;
@@ -313,13 +334,13 @@ function parseAuditPublicKeyFromEnvHex(raw) {
       "Audit public key must be uncompressed 65-byte hex (04 + X + Y) or 64-byte X+Y hex"
     );
   }
-  const bytes = Buffer6.from(payload, "hex");
+  const bytes = Buffer5.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)
@@ -331,7 +352,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) {
@@ -345,24 +367,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 Buffer7 } from "buffer";
+import { StrKey as StrKey3 } from "@stellar/stellar-sdk";
+import { Buffer as Buffer6 } 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 Buffer7.from(raw).toString("hex");
+    const raw = StrKey3.decodeEd25519PublicKey(trimmed);
+    return Buffer6.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");
     }
@@ -387,26 +409,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 privKeyScalarDecimalFromRecipientScalarHex(hexInput) {
+  const hex = normalizeRecipientScalarHex(hexInput);
+  const value = BigInt(`0x${hex}`);
+  return canonicalBabyJubScalarFromInteger(value).toString(DECIMAL_RADIX2);
 }
 
 // src/transact/proofs/withdraw/helpers.ts
@@ -414,7 +439,7 @@ function destinationWithdrawFrAndScalar(parameters) {
   const pkHex = ed25519PublicKeyHexFromStellarAccount(
     parameters.destinationStellarAddress
   );
-  const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals2(pkHex);
+  const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals(pkHex);
   const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
     parameters.privKeyScalarHex
   );
@@ -428,8 +453,11 @@ function buildWithdrawPublicInput(parameters) {
   return withTokenAddressPublicInputs(
     {
       stateRoot: parameters.stateRoot,
-      withdrawAddressHi: hi,
-      withdrawAddressLo: lo,
+      ...publicWithdrawAddressLimbs({
+        publicWithdrawalAmount: parameters.publicWithdrawalAmount,
+        destinationHi: hi,
+        destinationLo: lo
+      }),
       privKeyScalar
     },
     parameters.tokenAddress
@@ -437,7 +465,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) {
@@ -451,7 +479,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,
@@ -476,14 +504,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({
@@ -491,8 +519,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({
@@ -505,17 +537,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 } : {}
   };
 }
@@ -533,35 +567,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,
@@ -572,18 +620,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) {
@@ -599,12 +648,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 } : {}
   };
 }
@@ -612,33 +660,146 @@ 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 STANDARD_ZK_CONFIG_NONCE = 0n;
+var COMMITMENT_V2_ZK_NONCE = 2n;
+var BINDING_ZK_NONCE = 3n;
+var SIX_BY_SIX_ZK_NONCE = 6n;
+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();
@@ -654,17 +815,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,
@@ -679,27 +835,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() {
@@ -715,10 +878,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;
@@ -736,22 +905,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
     });
@@ -774,6 +938,7 @@ var PrivacyPoolService = class {
     const applicationId = this.getApplicationId();
     const audit = buildPoolTransactionAuditParameters({
       applicationId,
+      nAuditSlots: sdk.getLayout().nAuditSlots,
       ...this.auditPublicKey ? { auditPublicKey: this.auditPublicKey } : {}
     });
     const deposit = {
@@ -787,38 +952,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 } : {},
@@ -826,12 +988,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 } : {},
@@ -854,7 +1013,10 @@ function createPrivacyPoolService(input) {
   return new PrivacyPoolService(
     input?.assets,
     input?.applicationId,
-    input?.auditPublicKey
+    input?.auditPublicKey,
+    input?.zkCircuits,
+    input?.zkConfigNonce,
+    input?.zkArtifactBaseUrl
   );
 }
 var configuredPrivacyPoolService;
@@ -870,143 +1032,473 @@ function getPrivacyPoolService() {
   return configuredPrivacyPoolService;
 }
 
-// src/transact/assets/load-browser.ts
-async function loadStellarBrowserAssets(input) {
-  const cacheKey = input.cacheBust ? `?v=${Date.now()}` : "";
-  const [sdkWasm, circuitWasm, provingKey] = await Promise.all([
-    fetch(`${input.sdkWasmUrl}${cacheKey}`).then((response) => response.arrayBuffer()),
-    fetch(input.circuitWasmUrl).then((response) => response.arrayBuffer()),
-    fetch(input.provingKeyUrl).then((response) => response.arrayBuffer())
-  ]);
-  return { sdkWasm, circuitWasm, provingKey };
-}
-async function loadDefaultStellarBrowserAssets(options) {
-  await import("@auditable/privacy-pool-zk-sdk");
-  const sdkWasmUrl = new URL("@auditable/privacy-pool-zk-sdk/sdk.wasm", import.meta.url).href;
-  const circuitWasmUrl = new URL(
-    "@auditable/privacy-pool-zk-sdk/witness.wasm",
-    import.meta.url
-  ).href;
-  const provingKeyUrl = new URL(
-    "@auditable/privacy-pool-zk-sdk/main.zkey",
-    import.meta.url
-  ).href;
-  return loadStellarBrowserAssets({
-    sdkWasmUrl,
-    circuitWasmUrl,
-    provingKeyUrl,
-    ...options?.cacheBust ? { cacheBust: true } : {}
-  });
+// src/transact/escrow/tag-challenge-message.ts
+function buildBlindedRecipientTagChallengeMessage(fields) {
+  return [
+    "Arcane privacy layer: issue your blinded recipient tags.",
+    "",
+    `Wallet: ${fields.stellarAddress}`,
+    `Network: ${fields.networkPassphrase}`,
+    `Issued: ${fields.issuedAt}`,
+    `Expires: ${fields.expiresAt}`,
+    `Nonce: ${fields.nonce}`,
+    "",
+    "This signature proves you control the wallet. It is the same kind of signed challenge used to derive your private-note spend key."
+  ].join("\n");
 }
 
-// src/transact/onboarding/build-payload.ts
-import { Buffer as Buffer9 } from "buffer";
-import { PrivacyPoolSDK as PrivacyPoolSDK4 } from "@auditable/privacy-pool-zk-sdk";
+// src/transact/escrow/derived-escrow-recipient.ts
+import { Buffer as Buffer8 } 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_LENGTH = 64;
+function stellarAccountToFieldLimbs(stellarAddress) {
+  const pkRaw = StrKey4.decodeEd25519PublicKey(stellarAddress.trim());
+  const pkHex = Buffer8.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_LENGTH, "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 {
+    nonceDecimal,
+    recipientHi,
+    recipientLo,
+    recipientStellarAddress,
+    privateAddressStpl1: encodePrivateAddressFromHexCoordinates(
+      padCoordinateHex(key.pointXHex),
+      padCoordinateHex(key.pointYHex)
+    ),
+    scalarHex: padCoordinateHex(key.scalarHex)
+  };
+}
 
-// src/transact/encoding/fr-decimal-to-bytes.ts
-var BN254_SCALAR_MOD = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
-var FIELD_BYTE_LENGTH = 32;
-var BYTE_MASK = 0xffn;
-var BITS_PER_BYTE = 8n;
-function frDecimalToPaddedBytes32(decimal) {
-  let value = BigInt(decimal.trim());
-  value = (value % BN254_SCALAR_MOD + BN254_SCALAR_MOD) % BN254_SCALAR_MOD;
-  const bytes = Buffer.alloc(FIELD_BYTE_LENGTH);
-  for (let index = FIELD_BYTE_LENGTH - 1; index >= 0; index -= 1) {
-    bytes[index] = Number(value & BYTE_MASK);
-    value >>= BITS_PER_BYTE;
+// src/transact/escrow/assert-escrow-sweep-claimant.ts
+import { insufficientStateError } from "@arcanetech/privacy-sdk-core";
+function assertEscrowSweepClaimant(input) {
+  const walletPublicKey = input.walletPublicKey.trim();
+  const claimantAddress = input.claimantAddress.trim();
+  if (!walletPublicKey || walletPublicKey !== claimantAddress) {
+    const error = insufficientStateError(
+      "escrow_sweep_claimant_mismatch",
+      "Escrow sweep requires the connected account that owns the note.",
+      { walletPublicKey, claimantAddress }
+    );
+    throw new Error(error.message, { cause: error });
   }
-  return bytes;
 }
 
-// src/transact/onboarding/recipient.ts
-import { PrivacyPoolSDK as PrivacyPoolSDK3 } from "@auditable/privacy-pool-zk-sdk";
-var COORDINATE_HEX_LENGTH = 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_LENGTH, "0");
-  const publicKeyYHex = point.y.padStart(COORDINATE_HEX_LENGTH, "0");
+// src/transact/escrow/reconstruct-escrow-note.ts
+var FIELD_HEX_LENGTH = 64;
+function hexToDecimal(hex) {
+  const clean = hex.trim().replace(/^0x/u, "");
+  return BigInt(`0x${clean || "0"}`).toString();
+}
+function padFieldHex(value) {
+  return value.replace(/^0x/iu, "").padStart(FIELD_HEX_LENGTH, "0");
+}
+async function defaultDecryptOutputNote(input) {
+  const module = await import("@arcanetech/stellar-privacy-pool-zk-sdk");
+  if (typeof module.decryptOutputNoteEvent !== "function") {
+    throw new TypeError("Output note decryption is not available.");
+  }
+  return module.decryptOutputNoteEvent(input);
+}
+async function reconstructEscrowNote(input) {
+  const derived = await deriveEscrowRecipientFromStellarAddress({
+    recipientStellarAddress: input.claimantAddress,
+    nonceDecimal: input.nonceDecimal,
+    ...input.deriveKey ? { deriveKey: input.deriveKey } : {}
+  });
+  const event = input.events.find((entry) => entry.outputIndex === input.seq);
+  if (!event) {
+    throw new Error("Escrow output note event was not found for this sequence.");
+  }
+  const decrypt = input.decrypt ?? defaultDecryptOutputNote;
+  const decrypted = await decrypt({
+    recipientScalarHex: derived.scalarHex,
+    commitmentHashHex: event.commitmentHashHex,
+    createdEphemeralKey: event.createdEphemeralKey,
+    ciphertext: event.ciphertext,
+    tag: event.tag,
+    ownerMode: 1n
+  });
   return {
-    temporaryScalarHex,
-    temporaryPrivateAddressStpl1: encodePrivateAddressFromHexCoordinates(
-      publicKeyXHex,
-      publicKeyYHex
-    )
+    coin: {
+      value: decrypted.value,
+      nullifier: decrypted.nullifier,
+      secret: decrypted.secret,
+      commitment: hexToDecimal(decrypted.commitmentHex),
+      asset_hi: decrypted.assetHi,
+      asset_lo: decrypted.assetLo,
+      application_id: decrypted.applicationId
+    },
+    scalarHex: derived.scalarHex,
+    privateAddressStpl1: derived.privateAddressStpl1,
+    recipientHi: derived.recipientHi,
+    recipientLo: derived.recipientLo,
+    nonceDecimal: derived.nonceDecimal,
+    tokenAddress: assetLegToTokenAddress(decrypted.assetHi, decrypted.assetLo),
+    commitmentHex: padFieldHex(decrypted.commitmentHex)
   };
 }
 
-// src/transact/onboarding/build-payload.ts
-var COORDINATE_HEX_LENGTH2 = 64;
-function noneOptionalRegistration() {
-  return { tag: "None", values: void 0 };
+// src/transact/escrow/prepare-escrow-sweep.ts
+import { StrKey as StrKey5 } from "@stellar/stellar-sdk";
+var PRIVATE_DISCLOSURE = {
+  senderAddress: "private",
+  recipientAddress: "private",
+  assetAddress: "private",
+  amount: "private"
+};
+function requireRegisteredPrivateAddress(value) {
+  const trimmed = value.trim();
+  if (!trimmed || StrKey5.isValidEd25519PublicKey(trimmed)) {
+    throw new Error("Escrow sweep recipient must be a registered private address.");
+  }
+  return trimmed;
 }
-function coinToPlaintextNote(coin) {
-  const [assetHi, assetLo] = tokenAddressToAssetLeg(coin.tokenAddress);
+function consumedEscrowRecord(input) {
   return {
-    asset_hi: frDecimalToPaddedBytes32(assetHi),
-    asset_lo: frDecimalToPaddedBytes32(assetLo),
-    deposited_ephemeral_scalar: void 0,
-    nullifier: frDecimalToPaddedBytes32(coin.nullifier),
-    secret: frDecimalToPaddedBytes32(coin.secret),
-    value: BigInt(coin.value)
+    id: input.reconstructed.commitmentHex,
+    owner: input.walletPublicKey,
+    asset: input.asset,
+    amount: BigInt(input.reconstructed.coin.value),
+    consumed: false,
+    status: "finalized",
+    poolContract: input.poolContract,
+    coinNote: input.reconstructed.coin,
+    privateAddress: input.reconstructed.privateAddressStpl1,
+    commitmentHex: input.reconstructed.commitmentHex
   };
 }
-async function generateRandomDepositScalarHex() {
-  await getPrivacyPoolService().getInitializedSdk();
-  return PrivacyPoolSDK4.generateRandomScalarHex32();
-}
-function buildOnboardingPayload(parameters) {
-  const notes = parameters.recipientNotes.map((coin) => coinToPlaintextNote(coin));
-  const temporaryDecoded = decodePrivateAddress(
-    parameters.temporaryKey.temporaryPrivateAddressStpl1.trim()
-  );
-  let privateAddressRegistration = noneOptionalRegistration();
-  if (parameters.permanentPrivateAddressStpl1?.trim()) {
-    const decoded = decodePrivateAddress(
-      parameters.permanentPrivateAddressStpl1.trim()
-    );
-    const registration = {
-      owner: parameters.ownerStellarAddress.trim(),
-      public_key_x: Buffer9.from(decoded.x.padStart(COORDINATE_HEX_LENGTH2, "0"), "hex"),
-      public_key_y: Buffer9.from(decoded.y.padStart(COORDINATE_HEX_LENGTH2, "0"), "hex")
-    };
-    privateAddressRegistration = { tag: "Some", values: [registration] };
+function attachEscrowAuthorization(prepared, escrowAuthorization) {
+  const credential = escrowAuthorization.trim();
+  if (!credential) {
+    throw new Error("Escrow sweep requires a signed authorization entry.");
   }
   return {
-    owner: parameters.ownerStellarAddress.trim(),
-    temp_public_key_x: Buffer9.from(
-      temporaryDecoded.x.padStart(COORDINATE_HEX_LENGTH2, "0"),
-      "hex"
-    ),
-    temp_public_key_y: Buffer9.from(
-      temporaryDecoded.y.padStart(COORDINATE_HEX_LENGTH2, "0"),
-      "hex"
-    ),
-    encrypted_private_key: Buffer9.from(
-      parameters.temporaryKey.temporaryScalarHex,
-      "utf8"
-    ),
-    notes: { notes },
-    private_address_registration: privateAddressRegistration
+    ...prepared,
+    transactArtifacts: {
+      ...prepared.transactArtifacts,
+      escrowAuthorization: credential
+    }
   };
 }
-async function buildTransferOnboardingAtExecute(input) {
-  return buildOnboardingPayload({
-    ownerStellarAddress: input.ownerStellarAddress,
-    temporaryKey: {
-      temporaryScalarHex: input.temporaryRecipientKey.temporaryScalarHex,
-      temporaryPrivateAddressStpl1: input.temporaryRecipientKey.temporaryPrivateAddressStpl1
+function sweepTransactArtifacts(input) {
+  return {
+    spendSource: "escrow",
+    escrowRecipient: input.claimantAddress.trim(),
+    escrowSpendScalarHex: input.reconstructed.scalarHex,
+    escrowClaimantLimbs: {
+      recipientHi: input.reconstructed.recipientHi,
+      recipientLo: input.reconstructed.recipientLo,
+      nonceDecimal: input.reconstructed.nonceDecimal
     },
-    recipientNotes: [input.recipientNote]
-  });
+    executeFinalizeRequired: true,
+    walletPublicKey: input.walletPublicKey
+  };
 }
-
-// src/transact/kyt/inspect-error.ts
-var KytInspectError = class extends Error {
-  reasonCode;
+function prepareEscrowSweepOperation(input) {
+  assertEscrowSweepClaimant({
+    walletPublicKey: input.walletPublicKey,
+    claimantAddress: input.claimantAddress
+  });
+  const walletPublicKey = input.walletPublicKey.trim();
+  const registeredPrivateAddress = requireRegisteredPrivateAddress(
+    input.registeredPrivateAddress
+  );
+  const amount = BigInt(input.reconstructed.coin.value);
+  return {
+    kind: "transfer",
+    intent: {
+      from: input.reconstructed.privateAddressStpl1,
+      to: registeredPrivateAddress,
+      asset: input.asset,
+      amount,
+      disclosure: PRIVATE_DISCLOSURE
+    },
+    consumedRecords: [
+      consumedEscrowRecord({
+        reconstructed: input.reconstructed,
+        walletPublicKey,
+        poolContract: input.poolContract,
+        asset: input.asset
+      })
+    ],
+    outputRecords: [],
+    submissionPayload: { operationId: crypto.randomUUID(), signed: false },
+    transactArtifacts: sweepTransactArtifacts({
+      claimantAddress: input.claimantAddress,
+      reconstructed: input.reconstructed,
+      walletPublicKey
+    })
+  };
+}
+
+// src/transact/escrow/fetch-output-note-events.ts
+import { Api } from "@stellar/stellar-sdk/rpc";
+
+// src/rpc/soroban-transaction-meta.ts
+import { Address, StrKey as StrKey6 } from "@stellar/stellar-sdk";
+var TRANSACTION_META_SWITCH_SOROBAN_V3 = 3;
+var TRANSACTION_META_SWITCH_SOROBAN_V4 = 4;
+function pushSorobanV3ContractEvents(out, meta) {
+  const soroban = meta.v3().sorobanMeta();
+  if (!soroban) {
+    return;
+  }
+  for (const event of soroban.events()) {
+    out.push(event);
+  }
+}
+function pushSorobanV4ContractEvents(out, meta) {
+  const v4 = meta.v4();
+  for (const txEvent of v4.events()) {
+    out.push(txEvent.event());
+  }
+  for (const op of v4.operations()) {
+    for (const event of op.events()) {
+      out.push(event);
+    }
+  }
+}
+function collectContractEventsFromMeta(meta) {
+  const out = [];
+  const code = meta.switch();
+  if (code === TRANSACTION_META_SWITCH_SOROBAN_V3) {
+    pushSorobanV3ContractEvents(out, meta);
+  }
+  if (code === TRANSACTION_META_SWITCH_SOROBAN_V4) {
+    pushSorobanV4ContractEvents(out, meta);
+  }
+  return out;
+}
+
+// src/rpc/server.ts
+import { rpc } from "@stellar/stellar-sdk";
+function createStellarRpcServer(rpcUrl) {
+  return new rpc.Server(rpcUrl.trim(), { allowHttp: true });
+}
+
+// src/transact/escrow/parse-output-note-events.ts
+import { StrKey as StrKey7 } from "@stellar/stellar-sdk";
+var FIELD_BYTE_LENGTH = 32;
+var FIELD_HEX_LENGTH2 = 64;
+var CONTRACT_EVENT_BODY_V0 = 0;
+var OUTPUT_NOTE_TOPIC_COUNT = 3;
+function extractSymbol(value) {
+  try {
+    if (value.switch().name === "scvSymbol") {
+      return value.sym().toString();
+    }
+    if (value.switch().name === "scvString") {
+      return value.str().toString();
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function readBytes(value) {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    if (value.switch().name !== "scvBytes") {
+      return void 0;
+    }
+    return Buffer.from(value.bytes());
+  } catch {
+    return void 0;
+  }
+}
+function readU32(value) {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    if (value.switch().name !== "scvU32") {
+      return void 0;
+    }
+    return value.u32();
+  } catch {
+    return void 0;
+  }
+}
+function fieldHex(bytes) {
+  return bytes.toString("hex").padStart(FIELD_HEX_LENGTH2, "0");
+}
+function ciphertextLimbs(bytes) {
+  if (bytes.length === 0 || bytes.length % FIELD_BYTE_LENGTH !== 0) {
+    return [];
+  }
+  const limbs = [];
+  for (let offset = 0; offset < bytes.length; offset += FIELD_BYTE_LENGTH) {
+    limbs.push(fieldHex(bytes.subarray(offset, offset + FIELD_BYTE_LENGTH)));
+  }
+  return limbs;
+}
+function payloadMap(data) {
+  const entries = /* @__PURE__ */ new Map();
+  try {
+    if (data.switch().name !== "scvMap") {
+      return entries;
+    }
+    const mapped = data.map();
+    if (!mapped) {
+      return entries;
+    }
+    for (const entry of mapped) {
+      const key = extractSymbol(entry.key());
+      if (key) {
+        entries.set(key, entry.val());
+      }
+    }
+  } catch {
+    return entries;
+  }
+  return entries;
+}
+function hashToBuffer(value) {
+  return Buffer.isBuffer(value) ? value : void 0;
+}
+function eventContractId(event) {
+  try {
+    const contractId = hashToBuffer(event.contractId());
+    if (!contractId) {
+      return void 0;
+    }
+    return StrKey7.encodeContract(contractId);
+  } catch {
+    return void 0;
+  }
+}
+function eventMatchesPool(event, poolAddress) {
+  const contractId = eventContractId(event);
+  return contractId === void 0 || contractId === poolAddress.trim();
+}
+function outputNoteEventBody(event) {
+  if (event.type().name !== "contract") {
+    return void 0;
+  }
+  const body = event.body();
+  if (body.switch() !== CONTRACT_EVENT_BODY_V0) {
+    return void 0;
+  }
+  return body.v0();
+}
+function outputNoteFromPayload(topics, payload) {
+  const commitment = readBytes(topics[2]);
+  const outputIndex = readU32(payload.get("output_index"));
+  const ephemeralX = readBytes(payload.get("ephemeral_x"));
+  const ephemeralY = readBytes(payload.get("ephemeral_y"));
+  const ciphertextBytes = readBytes(payload.get("ciphertext"));
+  const tag = readBytes(payload.get("tag"));
+  const ciphertext = ciphertextBytes ? ciphertextLimbs(ciphertextBytes) : [];
+  if (!commitment || outputIndex === void 0 || !ephemeralX || !ephemeralY || ciphertext.length === 0 || !tag) {
+    return void 0;
+  }
+  return {
+    outputIndex,
+    commitmentHashHex: fieldHex(commitment),
+    createdEphemeralKey: [fieldHex(ephemeralX), fieldHex(ephemeralY)],
+    ciphertext,
+    tag: fieldHex(tag)
+  };
+}
+function parseEscrowOutputNoteEvent(event, poolAddress) {
+  if (!eventMatchesPool(event, poolAddress)) {
+    return void 0;
+  }
+  const v0 = outputNoteEventBody(event);
+  const topics = v0?.topics();
+  if (!v0 || !Array.isArray(topics) || topics.length < OUTPUT_NOTE_TOPIC_COUNT) {
+    return void 0;
+  }
+  if (extractSymbol(topics[0]) !== "audit" || extractSymbol(topics[1]) !== "output_note") {
+    return void 0;
+  }
+  return outputNoteFromPayload(topics, payloadMap(v0.data()));
+}
+
+// src/transact/escrow/fetch-output-note-events.ts
+async function fetchEscrowOutputNoteEvents(input) {
+  const txId = input.txId.trim();
+  if (!txId) {
+    throw new Error("Escrow output-note transaction id is missing.");
+  }
+  const response = await createStellarRpcServer(
+    input.transactEnvironment.network.rpcUrl
+  ).getTransaction(txId);
+  if (response.status !== Api.GetTransactionStatus.SUCCESS) {
+    throw new Error("Escrow output-note transaction was not found.");
+  }
+  const meta = response.resultMetaXdr;
+  if (!meta) {
+    return [];
+  }
+  const events = [];
+  for (const event of collectContractEventsFromMeta(meta)) {
+    const parsed = parseEscrowOutputNoteEvent(event, input.poolAddress);
+    if (parsed) {
+      events.push(parsed);
+    }
+  }
+  return events;
+}
+
+// src/transact/escrow/simulate-escrow-authorization.ts
+import {
+  Account,
+  Address as Address3,
+  Contract,
+  nativeToScVal as nativeToScVal2,
+  TransactionBuilder as TransactionBuilder2,
+  rpc as rpc4
+} from "@stellar/stellar-sdk";
+import { Buffer as Buffer10 } from "buffer";
+
+// 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;
   decisionId;
   detailAddress;
   constructor(parameters) {
@@ -1032,18 +1524,6 @@ function parseKytReasonCode(reasonCode) {
   };
 }
 
-// src/contracts/contract-context.ts
-function requireContractContext(environment) {
-  if (!environment || !("contractContext" in environment)) {
-    throw new Error("Contract context is not configured on the transact environment.");
-  }
-  const resolved = environment;
-  return resolved.contractContext;
-}
-function readPoolClientFactory(environment) {
-  return requireContractContext(environment).createPoolClient;
-}
-
 // src/transact/kyt/passage/poll.ts
 import "@stellar/stellar-sdk";
 var KYT_REGISTER_MAX_POLLS = 60;
@@ -1098,20 +1578,20 @@ async function waitForKytRegistration(parameters) {
 }
 
 // src/transact/kyt/passage/submit.ts
-import { Buffer as Buffer10 } from "buffer";
-import { Operation, TransactionBuilder, rpc as rpc2, xdr } from "@stellar/stellar-sdk";
+import { Buffer as Buffer9 } from "buffer";
+import { Operation, TransactionBuilder, rpc as rpc3, xdr as xdr3 } from "@stellar/stellar-sdk";
 var KYT_REGISTER_FEE_STROOPS = "1000000";
 var KYT_REGISTER_TIMEOUT_SECONDS = 300;
 function passageIdToScValue(passageId) {
-  return xdr.ScVal.scvBytes(Buffer10.from(passageId.replace(/^0x/, ""), "hex"));
+  return xdr3.ScVal.scvBytes(Buffer9.from(passageId.replace(/^0x/, ""), "hex"));
 }
 function approvalSignatureToBytes(signature) {
   const clean = signature.trim();
-  return /^(0x)?[0-9a-fA-F]{128}$/.test(clean) ? Buffer10.from(clean.replace(/^0x/i, ""), "hex") : Buffer10.from(clean, "base64");
+  return /^(0x)?[0-9a-fA-F]{128}$/.test(clean) ? Buffer9.from(clean.replace(/^0x/i, ""), "hex") : Buffer9.from(clean, "base64");
 }
 function signatureToScValue(signature) {
   const bytes = approvalSignatureToBytes(signature);
-  return xdr.ScVal.scvBytes(bytes);
+  return xdr3.ScVal.scvBytes(bytes);
 }
 async function registerKytPassage(parameters) {
   const signTransaction = parameters.transactEnvironment.signTransaction;
@@ -1121,7 +1601,7 @@ async function registerKytPassage(parameters) {
     );
   }
   const kytRegistry = parameters.transactEnvironment.kyt.kytPassageRegistryContract;
-  const server = new rpc2.Server(parameters.sorobanRpcUrl, { allowHttp: true });
+  const server = new rpc3.Server(parameters.sorobanRpcUrl, { allowHttp: true });
   const sourceAccount = await server.getAccount(parameters.owner);
   const transaction = new TransactionBuilder(sourceAccount, {
     fee: KYT_REGISTER_FEE_STROOPS,
@@ -1132,7 +1612,7 @@ async function registerKytPassage(parameters) {
       function: "register_passage",
       args: [
         passageIdToScValue(parameters.approval.passageId),
-        xdr.ScVal.scvU32(parameters.approval.expiresAtLedger),
+        xdr3.ScVal.scvU32(parameters.approval.expiresAtLedger),
         signatureToScValue(parameters.approval.signature)
       ]
     })
@@ -1155,15 +1635,9 @@ async function registerKytPassage(parameters) {
   await waitForKytRegistration({ server, hash: result.hash });
 }
 
-// src/transact/environment/zk-config-nonce.ts
-var DEFAULT_ZK_CONFIG_NONCE = 0n;
-function resolveZkConfigNonce(transactEnvironment) {
-  return transactEnvironment.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
-}
-
 // 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()}`;
@@ -1191,37 +1665,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(),
-          zkConfigNonce: resolveZkConfigNonce(input.transactEnvironment),
-          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);
   }
@@ -1237,6 +1735,216 @@ async function requestKytPassageForPoolInteraction(input) {
   return body;
 }
 
+// src/transact/escrow/kyt-authorization-sc-value.ts
+import { nativeToScVal } from "@stellar/stellar-sdk";
+function kytAuthorizationScValue(parameters) {
+  return nativeToScVal(
+    {
+      expiration_ledger: parameters.expirationLedger,
+      signature: parameters.signature
+    },
+    {
+      type: {
+        expiration_ledger: ["symbol", "u32"],
+        signature: ["symbol", "bytes"]
+      }
+    }
+  );
+}
+
+// src/transact/escrow/pick-escrow-authorization.ts
+import { Address as Address2 } from "@stellar/stellar-sdk";
+function credentialAddress(entry) {
+  try {
+    const credentials = entry.credentials();
+    if (credentials.switch().name !== "sorobanCredentialsAddress") {
+      return void 0;
+    }
+    return Address2.fromScAddress(credentials.address().address()).toString();
+  } catch {
+    return void 0;
+  }
+}
+function pickUnsignedEscrowAuthorization(input) {
+  const claimant = input.claimantAddress.trim();
+  const match = input.auth.find((entry) => credentialAddress(entry) === claimant);
+  if (!match) {
+    throw new Error("Simulation did not return a claimant authorization entry.");
+  }
+  return match.toXDR("base64");
+}
+
+// src/transact/escrow/simulate-escrow-authorization.ts
+var SIMULATE_FEE = "100";
+var SIMULATE_TIMEOUT_SECONDS = 30;
+var RECORD_NONROOT_AUTH = "record_allow_nonroot";
+function hexToBytes(hex) {
+  return Buffer10.from(hex.replace(/^0x/iu, ""), "hex");
+}
+function optionalSweepCiphertext(artifacts) {
+  return {
+    ...artifacts?.ciphertextHex ? { ciphertextHex: artifacts.ciphertextHex } : {},
+    ...artifacts?.outputNoteEphemeralScalars ? { outputNoteEphemeralScalars: artifacts.outputNoteEphemeralScalars } : {}
+  };
+}
+function requireSweepArtifacts(prepared) {
+  const artifacts = prepared.transactArtifacts;
+  const proofHex = artifacts?.proofHex?.trim();
+  const publicHex = artifacts?.publicHex?.trim();
+  const escrowRecipient = artifacts?.escrowRecipient?.trim();
+  if (!proofHex || !publicHex || !escrowRecipient) {
+    throw new Error("Prepared sweep is missing proof, public signals, or claimant.");
+  }
+  return {
+    proofHex,
+    publicHex,
+    escrowRecipient,
+    ...optionalSweepCiphertext(artifacts)
+  };
+}
+function requireRelayerPublicKey(value) {
+  const relayerPublicKey = value.trim();
+  if (!relayerPublicKey) {
+    throw new Error("Escrow sweep simulation requires the relayer public key.");
+  }
+  return relayerPublicKey;
+}
+async function inspectRelayerSweepKyt(input) {
+  const environment = input.transactEnvironment;
+  return requestKytPassageForPoolInteraction({
+    owner: input.relayerPublicKey,
+    poolContract: environment.network.poolContract,
+    proofHex: input.artifacts.proofHex,
+    publicHex: input.artifacts.publicHex,
+    ...input.artifacts.ciphertextHex ? { ciphertextHex: input.artifacts.ciphertextHex } : {},
+    ...input.artifacts.outputNoteEphemeralScalars ? { outputNoteEphemeralScalars: input.artifacts.outputNoteEphemeralScalars } : {},
+    ...input.prepared.transactArtifacts?.applicationIdsPlaintext ? {
+      applicationIdsPlaintext: input.prepared.transactArtifacts.applicationIdsPlaintext
+    } : {},
+    networkPassphrase: environment.network.networkPassphrase,
+    sorobanRpcUrl: environment.network.rpcUrl,
+    transactEnvironment: environment
+  });
+}
+async function simulateSweepAuthEntries(input) {
+  const environment = input.transactEnvironment;
+  const server = createStellarRpcServer(environment.network.rpcUrl);
+  const account = await server.getAccount(input.relayerPublicKey);
+  const operation = new Contract(environment.network.poolContract).call(
+    "transact",
+    new Address3(input.relayerPublicKey).toScVal(),
+    nativeToScVal2(resolveZkConfigNonce(environment), { type: "u64" }),
+    nativeToScVal2(hexToBytes(input.artifacts.proofHex), { type: "bytes" }),
+    nativeToScVal2(hexToBytes(input.artifacts.publicHex), { type: "bytes" }),
+    nativeToScVal2(hexToBytes(input.artifacts.ciphertextHex ?? ""), { type: "bytes" }),
+    kytAuthorizationScValue({
+      expirationLedger: input.approval.expiresAtLedger,
+      signature: approvalSignatureToBytes(input.approval.signature)
+    })
+  );
+  const built = new TransactionBuilder2(
+    new Account(account.accountId(), account.sequenceNumber()),
+    {
+      fee: SIMULATE_FEE,
+      networkPassphrase: environment.network.networkPassphrase
+    }
+  ).addOperation(operation).setTimeout(SIMULATE_TIMEOUT_SECONDS).build();
+  const simulated = await server.simulateTransaction(
+    built,
+    { cpuInstructions: 0 },
+    RECORD_NONROOT_AUTH
+  );
+  if (rpc4.Api.isSimulationError(simulated)) {
+    throw new Error(`Escrow sweep authorization simulation failed: ${simulated.error}`);
+  }
+  return simulated.result?.auth ?? [];
+}
+async function unsignedEscrowAuthorizationForSweep(input) {
+  const relayerPublicKey = requireRelayerPublicKey(input.relayerPublicKey);
+  const artifacts = requireSweepArtifacts(input.prepared);
+  const approval = await inspectRelayerSweepKyt({
+    artifacts,
+    prepared: input.prepared,
+    transactEnvironment: input.transactEnvironment,
+    relayerPublicKey
+  });
+  const auth = await simulateSweepAuthEntries({
+    artifacts,
+    transactEnvironment: input.transactEnvironment,
+    relayerPublicKey,
+    approval
+  });
+  return pickUnsignedEscrowAuthorization({
+    auth,
+    claimantAddress: artifacts.escrowRecipient
+  });
+}
+
+// src/transact/assets/load-browser.ts
+async function loadStellarBrowserAssets(input) {
+  const cacheKey = input.cacheBust ? `?v=${Date.now()}` : "";
+  const sdkWasm = await fetch(`${input.sdkWasmUrl}${cacheKey}`).then(
+    (response) => response.arrayBuffer()
+  );
+  return { sdkWasm };
+}
+async function loadDefaultStellarBrowserAssets(options) {
+  await import("@arcanetech/stellar-privacy-pool-zk-sdk");
+  const sdkWasmUrl = new URL(
+    "@arcanetech/stellar-privacy-pool-zk-sdk/sdk.wasm",
+    import.meta.url
+  ).href;
+  return loadStellarBrowserAssets({
+    sdkWasmUrl,
+    ...options?.cacheBust ? { cacheBust: true } : {}
+  });
+}
+
+// src/transact/private-address/temporary-recipient.ts
+import { PrivacyPoolSDK as PrivacyPoolSDK3 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
+var COORDINATE_HEX_LENGTH2 = 64;
+async function generateRandomDepositScalarHex() {
+  await getPrivacyPoolService().getInitializedSdk();
+  return PrivacyPoolSDK3.generateRandomScalarHex32();
+}
+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");
+  return {
+    temporaryScalarHex,
+    temporaryPrivateAddressStpl1: encodePrivateAddressFromHexCoordinates(
+      publicKeyXHex,
+      publicKeyYHex
+    )
+  };
+}
+
+// src/contracts/contract-context.ts
+function requireContractContext(environment) {
+  if (!environment || !("contractContext" in environment)) {
+    throw new Error("Contract context is not configured on the transact environment.");
+  }
+  const resolved = environment;
+  return resolved.contractContext;
+}
+function readPoolClientFactory(environment) {
+  return requireContractContext(environment).createPoolClient;
+}
+
+// src/transact/pool/proof-types.ts
+function ciphertextArtifactsFromProof(proof) {
+  return {
+    ...proof.ciphertext_hex === void 0 ? {} : { ciphertextHex: proof.ciphertext_hex },
+    ...proof.output_note_ephemeral_scalars === void 0 ? {} : {
+      outputNoteEphemeralScalars: [...proof.output_note_ephemeral_scalars]
+    }
+  };
+}
+
 // src/transact/submit/ttl-preflight.ts
 function getNested(source, path) {
   let cursor = source;
@@ -1283,12 +1991,12 @@ async function runTtlPreflight(assembledTransaction) {
 
 // src/transact/submit/zk-config-ttl.ts
 import {
-  Address,
+  Address as Address4,
   Operation as Operation2,
   SorobanDataBuilder,
-  TransactionBuilder as TransactionBuilder2,
-  rpc as rpc3,
-  xdr as xdr2
+  TransactionBuilder as TransactionBuilder3,
+  rpc as rpc5,
+  xdr as xdr5
 } from "@stellar/stellar-sdk";
 var ZK_CONFIG_TTL_THRESHOLD_LEDGERS = 1e5;
 var ZK_CONFIG_TTL_EXTEND_TO_LEDGERS = 5e5;
@@ -1312,15 +2020,15 @@ async function waitForExtendFootprintTtlConfirmation(parameters) {
   throw new Error("ZK config TTL extension was not confirmed in time");
 }
 function zkConfigLedgerKey(contractId, nonce) {
-  const configKeyScValue = xdr2.ScVal.scvVec([
-    xdr2.ScVal.scvSymbol("Config"),
-    xdr2.ScVal.scvU64(xdr2.Uint64.fromString(nonce.toString()))
+  const configKeyScValue = xdr5.ScVal.scvVec([
+    xdr5.ScVal.scvSymbol("Config"),
+    xdr5.ScVal.scvU64(xdr5.Uint64.fromString(nonce.toString()))
   ]);
-  return xdr2.LedgerKey.contractData(
-    new xdr2.LedgerKeyContractData({
-      contract: new Address(contractId).toScAddress(),
+  return xdr5.LedgerKey.contractData(
+    new xdr5.LedgerKeyContractData({
+      contract: new Address4(contractId).toScAddress(),
       key: configKeyScValue,
-      durability: xdr2.ContractDataDurability.persistent()
+      durability: xdr5.ContractDataDurability.persistent()
     })
   );
 }
@@ -1338,7 +2046,7 @@ async function needsTtlExtension(parameters) {
 }
 async function submitExtendFootprintTtlTransaction(parameters) {
   const sourceAccount = await parameters.server.getAccount(parameters.sourcePublicKey);
-  const transaction = new TransactionBuilder2(sourceAccount, {
+  const transaction = new TransactionBuilder3(sourceAccount, {
     fee: EXTEND_TTL_FEE_STROOPS,
     networkPassphrase: parameters.networkPassphrase
   }).addOperation(
@@ -1352,7 +2060,7 @@ async function submitExtendFootprintTtlTransaction(parameters) {
     networkPassphrase: parameters.networkPassphrase,
     address: parameters.sourcePublicKey
   });
-  const signedTransaction = TransactionBuilder2.fromXDR(
+  const signedTransaction = TransactionBuilder3.fromXDR(
     signedTxXdr,
     parameters.networkPassphrase
   );
@@ -1370,7 +2078,7 @@ async function extendZkConfigTtlIfNeeded(parameters) {
   if (!parameters.signTransaction) {
     return;
   }
-  const server = new rpc3.Server(parameters.sorobanRpcUrl, { allowHttp: true });
+  const server = new rpc5.Server(parameters.sorobanRpcUrl, { allowHttp: true });
   const ledgerKey = zkConfigLedgerKey(parameters.contractId, parameters.nonce);
   if (!await needsTtlExtension({ server, ledgerKey })) {
     return;
@@ -1400,7 +2108,10 @@ async function submitPoolTransact(parameters) {
     nonce: parameters.nonce,
     proof_bytes: Buffer11.from(parameters.proofHex.replace(/^0x/iu, ""), "hex"),
     pub_signals_bytes: Buffer11.from(parameters.publicHex.replace(/^0x/iu, ""), "hex"),
-    onboarding: parameters.onboarding,
+    ciphertext_bytes: Buffer11.from(
+      (parameters.ciphertextHex ?? "").replace(/^0x/iu, ""),
+      "hex"
+    ),
     kyt_authorization: {
       expiration_ledger: parameters.approval.expiresAtLedger,
       signature: approvalSignatureToBytes(parameters.approval.signature)
@@ -1425,19 +2136,21 @@ async function submitSorobanDeposit(input) {
   });
   const merkleTx = await poolClient.get_merkle_root();
   const merkleRootBuffer = merkleTx.result;
-  const { applicationIdsPlaintext, proof_hex, public_hex } = await input.privacyPoolService.prepareDepositTransactProof({
+  const proof = await input.privacyPoolService.prepareDepositTransactProof({
     privateAddressStpl1: input.privateAddressStpl1,
     coin: input.coin,
     depositScalarHex: input.depositScalarHex,
     merkleRootBytes: merkleRootBuffer,
     tokenAddress: input.tokenAddress
   });
+  const ciphertext = ciphertextArtifactsFromProof(proof);
   const approval = await requestKytPassageForPoolInteraction({
     owner: input.walletPublicKey,
     poolContract: input.contractId,
-    proofHex: proof_hex,
-    publicHex: public_hex,
-    applicationIdsPlaintext,
+    proofHex: proof.proof_hex,
+    publicHex: proof.public_hex,
+    applicationIdsPlaintext: proof.applicationIdsPlaintext,
+    ...ciphertext,
     networkPassphrase: input.networkPassphrase,
     sorobanRpcUrl: input.sorobanRpcUrl,
     transactEnvironment: input.transactEnvironment
@@ -1447,8 +2160,9 @@ async function submitSorobanDeposit(input) {
     contractId: input.contractId,
     from: input.walletPublicKey,
     nonce: resolveZkConfigNonce(input.transactEnvironment),
-    proofHex: proof_hex,
-    publicHex: public_hex,
+    proofHex: proof.proof_hex,
+    publicHex: proof.public_hex,
+    ...ciphertext,
     approval,
     networkPassphrase: input.networkPassphrase,
     sorobanRpcUrl: input.sorobanRpcUrl,
@@ -1469,7 +2183,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,
@@ -1482,7 +2197,7 @@ async function submitSorobanConfidentialTransfer(input) {
     nonce: resolveZkConfigNonce(input.transactEnvironment),
     proofHex: input.proofHex,
     publicHex: input.publicHex,
-    ...input.onboarding ? { onboarding: input.onboarding } : {},
+    ...input.ciphertextHex ? { ciphertextHex: input.ciphertextHex } : {},
     approval,
     networkPassphrase: input.networkPassphrase,
     sorobanRpcUrl: input.sorobanRpcUrl,
@@ -1490,14 +2205,19 @@ async function submitSorobanConfidentialTransfer(input) {
   });
 }
 
-// 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({
@@ -1516,24 +2236,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,
@@ -1555,20 +2275,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
   );
@@ -1580,10 +2341,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,
@@ -1591,31 +2348,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
   );
 }
@@ -1629,24 +2410,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 };
 }
@@ -1674,7 +2464,11 @@ async function prepareConfidentialTransferProofDual(parameters) {
   }));
   return {
     ...proof,
-    applicationIdsPlaintext: buildDualTransferApplicationIds(applicationId, changeCoin),
+    applicationIdsPlaintext: buildDualTransferApplicationIds(
+      sdk,
+      applicationId,
+      changeCoin
+    ),
     recipientCoin: generatedOutputCoinFromSlot(recipientSlot),
     ...changeCoin ? { changeCoin } : {}
   };
@@ -1692,51 +2486,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,
@@ -1754,7 +2569,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,
@@ -1765,6 +2584,7 @@ async function prepareConfidentialTransferProof(parameters) {
   return {
     ...proof,
     applicationIdsPlaintext: buildSingleTransferApplicationIds(
+      sdk,
       applicationId,
       changeCoin
     ),
@@ -1896,12 +2716,25 @@ async function readLeafEphemeralHex(parameters) {
   return { xHex, yHex };
 }
 
+// src/transact/encoding/fr-decimal-to-bytes.ts
+var BN254_SCALAR_MOD = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+var FIELD_BYTE_LENGTH2 = 32;
+var BYTE_MASK = 0xffn;
+var BITS_PER_BYTE = 8n;
+function frDecimalToPaddedBytes32(decimal) {
+  let value = BigInt(decimal.trim());
+  value = (value % BN254_SCALAR_MOD + BN254_SCALAR_MOD) % BN254_SCALAR_MOD;
+  const bytes = Buffer.alloc(FIELD_BYTE_LENGTH2);
+  for (let index = FIELD_BYTE_LENGTH2 - 1; index >= 0; index -= 1) {
+    bytes[index] = Number(value & BYTE_MASK);
+    value >>= BITS_PER_BYTE;
+  }
+  return bytes;
+}
+
 // 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",
@@ -1921,25 +2754,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(),
@@ -2109,26 +2923,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;
@@ -2251,8 +3045,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 {
@@ -2278,56 +3071,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;
@@ -2339,24 +3082,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,194 +3314,10 @@ var stellarBalancesStateDefinitions = [
   }
 ];
 
-// 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 }) => ({
-  type,
-  operations: [
-    {
-      opType: "recordSet",
-      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
-      key: owner,
-      value: count
-    }
-  ]
-}));
-
-// src/state/definitions/claims.ts
-var stellarClaimsStateDefinitions = [
-  {
-    type: stellarStateCallTypes.pendingClaims,
-    mode: "write",
-    schema: pendingClaimsWriteSchema
-  },
-  {
-    type: stellarStateCallTypes.clearPendingClaims,
-    mode: "write",
-    schema: clearPendingClaimsSchema
-  },
-  {
-    type: stellarStateCallTypes.readPendingClaims,
-    mode: "read",
-    schema: readPendingClaimsSchema
-  },
-  {
-    type: stellarStateCallTypes.replacePendingClaimsPage,
-    mode: "write",
-    schema: replacePendingClaimsPageSchema
-  },
-  {
-    type: stellarStateCallTypes.upsertPendingClaims,
-    mode: "write",
-    schema: upsertPendingClaimsSchema
-  },
-  {
-    type: stellarStateCallTypes.removePendingClaims,
-    mode: "write",
-    schema: removePendingClaimsSchema
-  },
-  {
-    type: stellarStateCallTypes.readPendingClaimsCount,
-    mode: "read",
-    schema: readPendingClaimsCountSchema
-  },
-  {
-    type: stellarStateCallTypes.setPendingClaimsCount,
-    mode: "write",
-    schema: setPendingClaimsCountSchema
-  }
-];
-
 // 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: [
@@ -2780,9 +3327,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) => ({
@@ -2792,10 +3339,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: [
@@ -2806,8 +3353,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,
@@ -2846,10 +3393,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: [
@@ -2860,8 +3407,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,
@@ -2874,10 +3421,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: [
@@ -2888,8 +3435,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,
@@ -2928,9 +3475,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: [
@@ -2940,9 +3487,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: [
@@ -2953,9 +3500,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: [
@@ -2970,18 +3517,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: [
@@ -2993,9 +3540,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: [
@@ -3006,8 +3553,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,
@@ -3020,9 +3567,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: [
@@ -3064,10 +3611,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: [
@@ -3078,9 +3625,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: [
@@ -3091,11 +3638,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,
@@ -3127,9 +3674,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: [
@@ -3150,9 +3697,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: [
@@ -3163,8 +3710,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 = [
@@ -3200,9 +3747,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: [
@@ -3283,9 +3830,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,
@@ -3298,10 +3845,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: [
@@ -3314,9 +3861,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,
@@ -3329,10 +3876,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: [
@@ -3343,10 +3890,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: [
@@ -3358,9 +3905,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: [
@@ -3371,10 +3918,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: [
@@ -3428,7 +3975,6 @@ var stellarWalletStateDefinitions = [
 // src/state/definitions/index.ts
 registerStellarArrayFilterSchemas();
 var stellarStateDefinitions = [
-  ...stellarClaimsStateDefinitions,
   ...stellarRegistryStateDefinitions,
   ...stellarAssetsStateDefinitions,
   ...stellarBalancesStateDefinitions,
@@ -3552,112 +4098,10 @@ function createAssetsCatalogMethods(context) {
 }
 
 // src/state/service/assets/index.ts
-function createAssetsService(context) {
-  return {
-    ...createAssetsCatalogMethods(context),
-    ...createPublicBalanceMethods(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) {
+function createAssetsService(context) {
   return {
-    ...createClaimsWriteMethods(context),
-    ...createClaimsReadMethods(context)
+    ...createAssetsCatalogMethods(context),
+    ...createPublicBalanceMethods(context)
   };
 }
 
@@ -4186,7 +4630,6 @@ function composeStellarStateService(adapter) {
     ...createWalletAddressService(base),
     ...createPoolMerkleService(base),
     ...createPoolEphemeralService(base),
-    ...createClaimsService(base),
     ...createDeliveriesService(base),
     ...createRecordsService(base)
   };
@@ -4251,42 +4694,1030 @@ function attachPoolStatePorts(transactEnvironment, state) {
     resolveSenderPrivKeyScalarFromState: createSenderScalarStateResolver(state)
   };
 }
+
+// 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/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);
+}
+
+// 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 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 };
+}
+
+// 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/transfer-source/resolve.ts
+function readTransferFromPrivateAddress(from) {
+  return from.trim();
+}
+
+// src/transact/transfer-source/verify-private-records.ts
+import { executionError, insufficientStateError as insufficientStateError2 } from "@arcanetech/privacy-sdk-core";
+
+// src/contracts/pool/pool-domain-service.ts
+import { Buffer as Buffer14 } from "buffer";
+function hexToBuffer(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  return Buffer14.from(clean, "hex");
+}
+async function readNullifierConsumedOnChain(input) {
+  const client = input.contractContext.createPoolClient({
+    contractId: input.poolContractId,
+    walletPublicKey: input.walletPublicKey,
+    networkPassphrase: input.contractContext.network.networkPassphrase,
+    sorobanRpcUrl: input.contractContext.network.rpcUrl
+  });
+  const read = await client.is_nulifier_hash_consumed({
+    hash: hexToBuffer(input.nullifierHashHex)
+  });
+  return read.result;
+}
+
+// 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 executionError(
+      "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,
+    privKeyScalarDecimalFromRecipientScalarHex(scalarHex)
+  );
+  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 { spent, nullifierHashHex };
+}
+async function verifyPrivateRecordsNullifiersBeforeExecute(input) {
+  for (const record of input.records) {
+    const status = await readPrivateRecordNullifierSpendStatus({
+      record,
+      environment: input.environment,
+      walletPublicKey: input.walletPublicKey,
+      ...input.poolContractId ? { poolContractId: input.poolContractId } : {},
+      ...input.spendScalarHex ? { spendScalarHex: input.spendScalarHex } : {}
+    });
+    if (status.spent) {
+      throw executionError(
+        "Private input note nullifier was already spent on-chain.",
+        "validation",
+        {
+          reason: "private_record_nullifier_spent",
+          recordId: record.id,
+          nullifierHashHex: status.nullifierHashHex
+        }
+      );
+    }
+  }
+}
+
+// src/transact/engine/spend-proof-context.ts
+async function resolveSenderPrivKeyScalarHex2(input) {
+  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.");
+  }
+  return ensureSenderPrivKeyScalarHex(
+    input.environment,
+    readTransferFromPrivateAddress(input.prepared.intent.from),
+    input.walletPublicKey
+  );
+}
+async function buildSpendProofContextAtExecute(input) {
+  const [primaryRecord] = input.prepared.consumedRecords;
+  if (!primaryRecord) {
+    throw new Error("Spend execution requires at least one private record.");
+  }
+  const walletPublicKey = primaryRecord.owner.trim();
+  if (!walletPublicKey) {
+    throw new Error("Spend execution record owner is missing.");
+  }
+  const senderPrivKeyScalarHex = await resolveSenderPrivKeyScalarHex2({
+    prepared: input.prepared,
+    environment: input.environment,
+    walletPublicKey
+  });
+  const tokenAddress = await resolveTokenContractId2(
+    input.environment,
+    input.prepared.intent.asset
+  );
+  const coin = requireCoinNoteFromRecord(primaryRecord);
+  const { commitments } = await loadMerkleState(input.environment, walletPublicKey);
+  const leafIndex = findCommitmentLeafIndex(commitments, coin.commitment);
+  if (leafIndex < 0) {
+    throw new Error("Coin commitment not found in on-chain Merkle state.");
+  }
+  const ephemeral = await readLeafEphemeralHex({
+    poolContractId: input.environment.network.poolContract,
+    walletPublicKey,
+    leafIndex,
+    transactEnvironment: input.environment,
+    ...input.environment.leafEphemeral ? { leafEphemeral: input.environment.leafEphemeral } : {}
+  });
+  return {
+    walletPublicKey,
+    tokenAddress,
+    coin,
+    commitments,
+    ephemeral,
+    senderPrivKeyScalarHex,
+    recipientPrivateAddressStpl1: input.recipientPrivateAddressStpl1
+  };
+}
+async function readCoinEphemeralForRecord(input) {
+  const coin = requireCoinNoteFromRecord(input.record);
+  const leafIndex = findCommitmentLeafIndex(input.commitments, coin.commitment);
+  if (leafIndex < 0) {
+    throw new Error("Coin commitment not found in on-chain Merkle state.");
+  }
+  const ephemeral = await readLeafEphemeralHex({
+    poolContractId: input.environment.network.poolContract,
+    walletPublicKey: input.walletPublicKey,
+    leafIndex,
+    transactEnvironment: input.environment,
+    ...input.environment.leafEphemeral ? { leafEphemeral: input.environment.leafEphemeral } : {}
+  });
+  return { coin, ephemeral };
+}
+
+// src/transact/engine/prepare/transfer-helpers.ts
+import { StrKey as StrKey8 } from "@stellar/stellar-sdk";
+function isStellarAccountRecipient(prepared) {
+  return prepared.kind === "transfer" && StrKey8.isValidEd25519PublicKey(prepared.intent.to.trim());
+}
+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/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;
+  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 = BigInt(context.coin.value) - input.prepared.intent.amount;
+  const proof = await prepareConfidentialTransferProof({
+    coin: context.coin,
+    state: { commitments: context.commitments },
+    senderPrivKeyScalarHex: context.senderPrivKeyScalarHex,
+    depositorEphemeralKey: serializeEphemeralKeyString({
+      xHex: context.ephemeral.xHex,
+      yHex: context.ephemeral.yHex
+    }),
+    transferStroops: input.prepared.intent.amount,
+    recipientPrivateAddressStpl1: context.recipientPrivateAddressStpl1,
+    selfPrivateAddressStpl1ForChange: readChangeRecipient(input, changeStroops),
+    tokenAddress: context.tokenAddress,
+    ...proofEscrowFields(input)
+  });
+  return { context, proof };
+}
+async function buildDualTransferProofAtExecute(input) {
+  const [primaryRecord, secondaryRecord] = input.prepared.consumedRecords;
+  if (!primaryRecord || !secondaryRecord) {
+    throw new Error("Dual transfer execution requires two private input records.");
+  }
+  const context = await buildSpendProofContextAtExecute(input);
+  const secondary = await readCoinEphemeralForRecord({
+    record: secondaryRecord,
+    environment: input.environment,
+    walletPublicKey: context.walletPublicKey,
+    commitments: context.commitments
+  });
+  const totalNotes = BigInt(context.coin.value) + BigInt(secondary.coin.value);
+  const changeStroops = totalNotes - input.prepared.intent.amount;
+  const proof = await prepareConfidentialTransferProofDual({
+    coinA: context.coin,
+    coinB: secondary.coin,
+    state: { commitments: context.commitments },
+    senderPrivKeyScalarHex: context.senderPrivKeyScalarHex,
+    ephemeralAKey: serializeEphemeralKeyString({
+      xHex: context.ephemeral.xHex,
+      yHex: context.ephemeral.yHex
+    }),
+    ephemeralBKey: serializeEphemeralKeyString({
+      xHex: secondary.ephemeral.xHex,
+      yHex: secondary.ephemeral.yHex
+    }),
+    transferStroops: input.prepared.intent.amount,
+    recipientPrivateAddressStpl1: context.recipientPrivateAddressStpl1,
+    selfPrivateAddressStpl1ForChange: readChangeRecipient(input, changeStroops),
+    tokenAddress: context.tokenAddress,
+    ...proofEscrowFields(input)
+  });
+  return { context, proof };
+}
+async function buildTransferProofAtExecute(input) {
+  const recordCount = input.prepared.consumedRecords.length;
+  if (recordCount === 1) {
+    return buildSingleTransferProofAtExecute(input);
+  }
+  if (recordCount === 2) {
+    return buildDualTransferProofAtExecute(input);
+  }
+  throw new Error("Confidential transfer execution supports at most two input notes.");
+}
+
+// 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;
+  }
+  const generatedOutputCoins = [
+    proof.recipientCoin,
+    ...proof.changeCoin ? [proof.changeCoin] : []
+  ];
+  prepared.outputRecords = prepared.outputRecords.map((record, index) => {
+    const generatedCoin = generatedOutputCoins.at(index);
+    if (!generatedCoin) {
+      return record;
+    }
+    return {
+      ...record,
+      id: generatedCoin.commitment_hex,
+      commitmentHex: generatedCoin.commitment_hex,
+      coinNote: generatedCoin.coin,
+      depositScalarHex: generatedCoin.depositScalarHex,
+      precommitementHex: generatedCoin.precommitementHex
+    };
+  });
+}
+function escrowSpendArtifacts(input) {
+  if (input.escrowSend) {
+    return {
+      escrowSend: true,
+      spendSource: "escrow",
+      ...input.escrowRecipient ? { escrowRecipient: input.escrowRecipient } : {}
+    };
+  }
+  if (input.preparedSpendSource === "escrow") {
+    return {
+      spendSource: "escrow",
+      ...input.escrowRecipient ? { escrowRecipient: input.escrowRecipient } : {},
+      ...input.escrowSpendScalarHex ? { escrowSpendScalarHex: input.escrowSpendScalarHex } : {},
+      ...input.escrowClaimantLimbs ? { escrowClaimantLimbs: input.escrowClaimantLimbs } : {}
+    };
+  }
+  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,
+    executeFinalizeRequired: false,
+    ...escrowSpendArtifacts(input)
+  };
+}
+async function runTransferFinalizeSteps(input) {
+  const recipient = await resolveTransferRecipientForExecute(
+    input.prepared,
+    input.environment,
+    input.walletPublicKey
+  );
+  const spendScalarHex = nullifierCheckSpendScalarHex(input.prepared.transactArtifacts);
+  await verifyPrivateRecordsNullifiersBeforeExecute({
+    records: input.prepared.consumedRecords,
+    environment: input.environment,
+    walletPublicKey: input.walletPublicKey,
+    ...spendScalarHex ? { spendScalarHex } : {}
+  });
+  const { context, proof } = await buildTransferProofAtExecute({
+    prepared: input.prepared,
+    environment: input.environment,
+    recipientPrivateAddressStpl1: recipient.recipientPrivateAddressStpl1,
+    ...recipient.escrowSend ? { escrowSend: recipient.escrowSend } : {},
+    ...input.prepared.transactArtifacts?.escrowClaimantLimbs ? {
+      escrowClaimantLimbs: input.prepared.transactArtifacts.escrowClaimantLimbs
+    } : {}
+  });
+  stampEscrowOutputRecords({
+    prepared: input.prepared,
+    proof,
+    walletPublicKey: input.walletPublicKey,
+    ...recipient.escrowSend ? { escrowSendPrivateAddress: recipient.recipientPrivateAddressStpl1 } : {}
+  });
+  return buildTransferFinalizeArtifacts({
+    proof,
+    context,
+    ...sweepFinalizeStamp(input.prepared, recipient)
+  });
+}
+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;
+  if (!primaryRecord?.owner.trim()) {
+    throw new Error("Transfer execution record owner is missing.");
+  }
+  const walletPublicKey = primaryRecord.owner.trim();
+  return runTransferFinalizeSteps({ prepared, environment, walletPublicKey });
+}
+
+// src/transact/engine/execute.ts
+function enrichWithdrawOutputRecords(prepared, proof) {
+  if (!proof.changeCoin || prepared.outputRecords.length === 0) {
+    return;
+  }
+  const changeCoin = proof.changeCoin;
+  prepared.outputRecords = prepared.outputRecords.map((record) => ({
+    ...record,
+    id: changeCoin.commitment_hex,
+    commitmentHex: changeCoin.commitment_hex,
+    coinNote: changeCoin.coin,
+    depositScalarHex: changeCoin.depositScalarHex,
+    precommitementHex: changeCoin.precommitementHex
+  }));
+}
+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,
+    recipientPrivateAddressStpl1: withdrawFrom
+  });
+  const changeStroops = BigInt(context.coin.value) - prepared.intent.amount;
+  const proof = await poolService.prepareWithdrawTransactProof({
+    coin: context.coin,
+    state: { commitments: context.commitments },
+    destinationStellarAddress: prepared.intent.to,
+    privKeyScalarHex: context.senderPrivKeyScalarHex,
+    depositorEphemeralKey: serializeEphemeralKeyString({
+      xHex: context.ephemeral.xHex,
+      yHex: context.ephemeral.yHex
+    }),
+    withdrawAmountStroops: prepared.intent.amount,
+    changePrivateAddressStpl1: changeStroops > 0n ? withdrawFrom : void 0,
+    tokenAddress: context.tokenAddress
+  });
+  enrichWithdrawOutputRecords(prepared, proof);
+  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,
+    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") {
+    return prepared;
+  }
+  if (prepared.transactArtifacts?.proofHex) {
+    return prepared;
+  }
+  const artifacts = prepared.kind === "transfer" ? await finalizeTransferAtExecute(prepared, environment) : await finalizeWithdrawAtExecute(prepared, environment, poolService);
+  return {
+    ...prepared,
+    transactArtifacts: {
+      ...prepared.transactArtifacts,
+      ...artifacts
+    }
+  };
+}
+
+// src/transact/relay/constants.ts
+var RELAY_TRANSACT_PACKAGE_VERSION_V1 = 1;
+var RELAY_TRANSACT_SUPPORTED_SIGNAL_COUNT = 93;
+var RELAY_TRANSACT_FIELD_BYTES = 32;
+var RELAY_TRANSACT_SIGNAL_PREFIX_BYTES = 4;
+var RELAY_SIGNAL_INDEX_NULLIFIER_0 = 0;
+var RELAY_SIGNAL_INDEX_NULLIFIER_1 = 1;
+var RELAY_SIGNAL_INDEX_STATE_ROOT = 82;
+var RELAY_SIGNAL_INDEX_WITHDRAW_ADDRESS_HI = 83;
+var RELAY_SIGNAL_INDEX_WITHDRAW_ADDRESS_LO = 84;
+var RELAY_SIGNAL_INDEX_ESCROW_RECIPIENT_HI = 85;
+var RELAY_SIGNAL_INDEX_ESCROW_RECIPIENT_LO = 86;
+var RELAY_SIGNAL_INDEX_PUBLIC_WITHDRAWAL_ASSET_HI = 87;
+var RELAY_SIGNAL_INDEX_PUBLIC_WITHDRAWAL_ASSET_LO = 88;
+var RELAY_SIGNAL_INDEX_PUBLIC_DEPOSIT_ASSET_HI = 89;
+var RELAY_SIGNAL_INDEX_PUBLIC_DEPOSIT_ASSET_LO = 90;
+var RELAY_SIGNAL_INDEX_PUBLIC_DEPOSIT = 91;
+var RELAY_SIGNAL_INDEX_PUBLIC_WITHDRAWAL = 92;
+
+// src/transact/relay/signals.ts
+import { Buffer as Buffer15 } from "buffer";
+
+// src/transact/relay/layout-profile.ts
+var FIELD_BYTES = 32;
+var PREFIX_BYTES = 4;
+var LEGACY_PUBLIC_INPUT_PREFIX_LEN = 5;
+var V2_PUBLIC_INPUT_PREFIX_LEN = 7;
+var EPHEMERAL_COORDINATE_COUNT = 2;
+var STANDARD_SHAPE = {
+  nIns: 2,
+  nOuts: 2,
+  publicNInputs: 1,
+  publicNOutputs: 1,
+  nAuditSlots: 4,
+  noteAuditLen: 12,
+  noteOutputLen: 6
+};
+var SIX_BY_SIX_SHAPE = {
+  nIns: 6,
+  nOuts: 6,
+  publicNInputs: 1,
+  publicNOutputs: 1,
+  nAuditSlots: 12,
+  noteAuditLen: 12,
+  noteOutputLen: 6
+};
+function profileFromShape(nonce, shape, publicInputPrefixLength, ciphertextsInPublicSignals) {
+  const auditOffset = shape.nIns + shape.nOuts + shape.nOuts * EPHEMERAL_COORDINATE_COUNT;
+  const outputNoteOffset = ciphertextsInPublicSignals ? auditOffset + shape.nAuditSlots * EPHEMERAL_COORDINATE_COUNT + shape.nAuditSlots * shape.noteAuditLen + shape.nAuditSlots : auditOffset + EPHEMERAL_COORDINATE_COUNT + shape.nAuditSlots;
+  const publicOutputsLength = ciphertextsInPublicSignals ? outputNoteOffset + shape.nOuts * shape.noteOutputLen + shape.nOuts : outputNoteOffset + shape.nOuts;
+  const signalCount = publicOutputsLength + publicInputPrefixLength + EPHEMERAL_COORDINATE_COUNT * shape.publicNInputs + EPHEMERAL_COORDINATE_COUNT * shape.publicNOutputs + shape.publicNInputs + shape.publicNOutputs;
+  const stateRoot = publicOutputsLength;
+  return {
+    nonce,
+    signalCount,
+    fieldBytes: FIELD_BYTES,
+    prefixBytes: PREFIX_BYTES,
+    indices: {
+      nullifier0: 0,
+      nullifier1: 1,
+      stateRoot,
+      withdrawAddressHi: stateRoot + 1,
+      withdrawAddressLo: stateRoot + 2,
+      escrowRecipientHi: stateRoot + 3,
+      escrowRecipientLo: stateRoot + 4,
+      publicWithdrawalAssetHi: stateRoot + publicInputPrefixLength,
+      publicWithdrawalAssetLo: stateRoot + publicInputPrefixLength + 1,
+      publicDepositAssetHi: stateRoot + publicInputPrefixLength + 2,
+      publicDepositAssetLo: stateRoot + publicInputPrefixLength + 3,
+      publicDeposit: stateRoot + publicInputPrefixLength + 4,
+      publicWithdrawal: stateRoot + publicInputPrefixLength + 5
+    }
+  };
+}
+function relayLayoutProfileForNonce(nonce) {
+  if (nonce === STANDARD_ZK_CONFIG_NONCE) {
+    return profileFromShape(
+      nonce,
+      STANDARD_SHAPE,
+      LEGACY_PUBLIC_INPUT_PREFIX_LEN,
+      true
+    );
+  }
+  if (nonce === COMMITMENT_V2_ZK_NONCE) {
+    return profileFromShape(nonce, STANDARD_SHAPE, V2_PUBLIC_INPUT_PREFIX_LEN, true);
+  }
+  if (nonce === BINDING_ZK_NONCE) {
+    return profileFromShape(nonce, STANDARD_SHAPE, V2_PUBLIC_INPUT_PREFIX_LEN, false);
+  }
+  if (nonce === SIX_BY_SIX_ZK_NONCE) {
+    return profileFromShape(nonce, SIX_BY_SIX_SHAPE, V2_PUBLIC_INPUT_PREFIX_LEN, true);
+  }
+  if (nonce === SIX_BY_SIX_BINDING_ZK_NONCE) {
+    return profileFromShape(nonce, SIX_BY_SIX_SHAPE, V2_PUBLIC_INPUT_PREFIX_LEN, false);
+  }
+  throw new Error(`Unknown ZK config nonce ${nonce.toString()}`);
+}
+
+// src/transact/relay/signals.ts
+function decodePublicSignalBytes(publicSignals) {
+  return Buffer15.from(publicSignals.replace(/^0x/iu, ""), "hex");
+}
+function hasSupportedLengthPrefix(bytes, signalCount) {
+  const expected = RELAY_TRANSACT_SIGNAL_PREFIX_BYTES + signalCount * RELAY_TRANSACT_FIELD_BYTES;
+  if (bytes.length !== expected) {
+    return false;
+  }
+  return bytes.readUInt32BE(0) === signalCount;
+}
+function assertSupportedPublicSignals(publicSignals, zkConfigNonce = DEFAULT_ZK_CONFIG_NONCE) {
+  const profile = relayLayoutProfileForNonce(zkConfigNonce);
+  const bytes = decodePublicSignalBytes(publicSignals);
+  const supportedBytes = profile.signalCount * RELAY_TRANSACT_FIELD_BYTES;
+  if (bytes.length === supportedBytes || hasSupportedLengthPrefix(bytes, profile.signalCount)) {
+    return;
+  }
+  throw new Error(
+    `Relay Transact Package V1 requires exactly ${String(profile.signalCount)} packed public signals.`
+  );
+}
+function sliceSupportedPublicSignalFields(publicSignals, zkConfigNonce = DEFAULT_ZK_CONFIG_NONCE) {
+  assertSupportedPublicSignals(publicSignals, zkConfigNonce);
+  const profile = relayLayoutProfileForNonce(zkConfigNonce);
+  const bytes = decodePublicSignalBytes(publicSignals);
+  const body = hasSupportedLengthPrefix(bytes, profile.signalCount) ? bytes.subarray(RELAY_TRANSACT_SIGNAL_PREFIX_BYTES) : bytes;
+  return Array.from(
+    { length: profile.signalCount },
+    (_unused, index) => Buffer15.from(
+      body.subarray(
+        index * RELAY_TRANSACT_FIELD_BYTES,
+        (index + 1) * RELAY_TRANSACT_FIELD_BYTES
+      )
+    )
+  );
+}
+
+// src/transact/relay/prepare.ts
+function normalizeHex(value) {
+  return value.replace(/^0x/iu, "").toLowerCase();
+}
+function prepareRelayTransactPackage(input) {
+  const zkConfigNonce = input.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
+  assertSupportedPublicSignals(input.publicSignals, zkConfigNonce);
+  const prepared = {
+    version: RELAY_TRANSACT_PACKAGE_VERSION_V1,
+    poolSelector: input.poolSelector,
+    zkConfigNonce,
+    proofBytes: normalizeHex(input.proofBytes),
+    publicSignals: normalizeHex(input.publicSignals),
+    applicationIdHints: input.applicationIdHints
+  };
+  if (input.ciphertextBytes) {
+    prepared.ciphertextBytes = normalizeHex(input.ciphertextBytes);
+  }
+  if (input.outputNoteEphemeralScalars) {
+    prepared.outputNoteEphemeralScalars = [...input.outputNoteEphemeralScalars];
+  }
+  if (input.escrowAuthorization) {
+    prepared.escrowAuthorization = input.escrowAuthorization;
+  }
+  if (input.keyVersionHints) {
+    prepared.keyVersionHints = input.keyVersionHints;
+  }
+  return prepared;
+}
+
+// src/transact/relay/from-prepared.ts
+function requirePreparedArtifacts(prepared) {
+  const artifacts = prepared.transactArtifacts;
+  if (!artifacts?.proofHex || !artifacts.publicHex || !artifacts.applicationIdsPlaintext) {
+    throw new Error("Prepared operation is missing transact artifacts.");
+  }
+  return {
+    proofBytes: artifacts.proofHex,
+    publicSignals: artifacts.publicHex,
+    applicationIdHints: artifacts.applicationIdsPlaintext,
+    ...artifacts.ciphertextHex ? { ciphertextBytes: artifacts.ciphertextHex } : {},
+    ...artifacts.outputNoteEphemeralScalars ? { outputNoteEphemeralScalars: artifacts.outputNoteEphemeralScalars } : {},
+    ...artifacts.escrowAuthorization ? { escrowAuthorization: artifacts.escrowAuthorization } : {}
+  };
+}
+function prepareRelayTransactPackageFromPrepared(input) {
+  return prepareRelayTransactPackage({
+    poolSelector: input.poolSelector,
+    ...requirePreparedArtifacts(input.prepared),
+    ...input.zkConfigNonce === void 0 ? {} : { zkConfigNonce: input.zkConfigNonce },
+    ...input.keyVersionHints ? { keyVersionHints: input.keyVersionHints } : {}
+  });
+}
+
+// src/transact/relay/profile.ts
+function fieldAt(fields, index) {
+  const field = fields.find((_unused, offset) => offset === index);
+  if (!field) {
+    throw new Error(`Missing packed public signal at index ${String(index)}.`);
+  }
+  return field;
+}
+function fieldHex2(fields, index) {
+  return fieldAt(fields, index).toString("hex");
+}
+function fieldAmount(fields, index) {
+  return BigInt(`0x${fieldAt(fields, index).toString("hex")}`).toString();
+}
+function readRelayTransactSupportedProfile(prepared) {
+  const layout = relayLayoutProfileForNonce(prepared.zkConfigNonce);
+  const fields = sliceSupportedPublicSignalFields(
+    prepared.publicSignals,
+    prepared.zkConfigNonce
+  );
+  const { indices } = layout;
+  return {
+    orderedNullifiers: [
+      fieldHex2(fields, indices.nullifier0),
+      fieldHex2(fields, indices.nullifier1)
+    ],
+    publicLegContext: {
+      stateRoot: fieldHex2(fields, indices.stateRoot),
+      withdrawAddressHi: fieldHex2(fields, indices.withdrawAddressHi),
+      withdrawAddressLo: fieldHex2(fields, indices.withdrawAddressLo),
+      escrowRecipientHi: fieldHex2(fields, indices.escrowRecipientHi),
+      escrowRecipientLo: fieldHex2(fields, indices.escrowRecipientLo),
+      publicWithdrawalAssetHi: fieldHex2(fields, indices.publicWithdrawalAssetHi),
+      publicWithdrawalAssetLo: fieldHex2(fields, indices.publicWithdrawalAssetLo),
+      publicDepositAssetHi: fieldHex2(fields, indices.publicDepositAssetHi),
+      publicDepositAssetLo: fieldHex2(fields, indices.publicDepositAssetLo),
+      publicDepositAmount: fieldAmount(fields, indices.publicDeposit),
+      publicWithdrawalAmount: fieldAmount(fields, indices.publicWithdrawal)
+    }
+  };
+}
+
+// src/transact/relay/required-submission-method.ts
+var ZERO_PUBLIC_DEPOSIT = 0n;
+var SUBMISSION_METHOD = {
+  direct: "direct",
+  relay: "relay"
+};
+var ESCROW_SUBMISSION_REFUSAL = {
+  positivePublicDeposit: "escrow_positive_public_deposit"
+};
+var EscrowSubmissionRefusedError = class extends Error {
+  reason;
+  constructor(reason) {
+    super(reason);
+    this.name = "EscrowSubmissionRefusedError";
+    this.reason = reason;
+  }
+};
+function isEscrowPreparedOperation(prepared) {
+  return prepared.transactArtifacts?.escrowSend === true || prepared.transactArtifacts?.spendSource === "escrow";
+}
+function publicDepositAmountFromPrepared(prepared, zkConfigNonce) {
+  const publicHex = prepared.transactArtifacts?.publicHex;
+  if (!publicHex) {
+    return void 0;
+  }
+  const layout = relayLayoutProfileForNonce(zkConfigNonce);
+  const fields = sliceSupportedPublicSignalFields(publicHex, zkConfigNonce);
+  const field = fields.find(
+    (_unused, offset) => offset === layout.indices.publicDeposit
+  );
+  if (!field) {
+    throw new Error(
+      `Missing packed public signal at index ${String(layout.indices.publicDeposit)}.`
+    );
+  }
+  return BigInt(`0x${field.toString("hex")}`);
+}
+function evaluateRequiredSubmissionMethod(prepared, zkConfigNonce = DEFAULT_ZK_CONFIG_NONCE) {
+  const publicDepositAmount = publicDepositAmountFromPrepared(prepared, zkConfigNonce);
+  if (isEscrowPreparedOperation(prepared)) {
+    if (publicDepositAmount !== void 0 && publicDepositAmount > ZERO_PUBLIC_DEPOSIT) {
+      return { refused: ESCROW_SUBMISSION_REFUSAL.positivePublicDeposit };
+    }
+    if (prepared.transactArtifacts?.escrowSend === true) {
+      return { method: SUBMISSION_METHOD.relay };
+    }
+    return { method: SUBMISSION_METHOD.direct };
+  }
+  if (publicDepositAmount === void 0) {
+    throw new Error("Prepared operation is missing transact artifacts.");
+  }
+  return {
+    method: publicDepositAmount > ZERO_PUBLIC_DEPOSIT ? SUBMISSION_METHOD.direct : SUBMISSION_METHOD.relay
+  };
+}
+function requiredSubmissionMethod(prepared, zkConfigNonce = DEFAULT_ZK_CONFIG_NONCE) {
+  const result = evaluateRequiredSubmissionMethod(prepared, zkConfigNonce);
+  if ("refused" in result) {
+    throw new EscrowSubmissionRefusedError(result.refused);
+  }
+  return result.method;
+}
 export {
+  BundledZkCircuit2 as BundledZkCircuit,
+  COMMITMENT_V2_ZK_NONCE,
   DEFAULT_STEALTH_SIGN_NONCE as DEFAULT_PRIVATE_ADDRESS_SIGN_NONCE,
+  DEFAULT_STELLAR_ZK_CIRCUITS,
+  DEFAULT_ZK_CONFIG_NONCE,
+  ESCROW_SUBMISSION_REFUSAL,
+  EscrowSubmissionRefusedError,
   KytInspectError,
   MIN_CONFIDENTIAL_TRANSFER_STROOPS,
+  OWNER_BOUND_NOTE_SCHEMA_VERSION,
   PrivacyPoolService,
+  RELAY_SIGNAL_INDEX_ESCROW_RECIPIENT_HI,
+  RELAY_SIGNAL_INDEX_ESCROW_RECIPIENT_LO,
+  RELAY_SIGNAL_INDEX_NULLIFIER_0,
+  RELAY_SIGNAL_INDEX_NULLIFIER_1,
+  RELAY_SIGNAL_INDEX_PUBLIC_DEPOSIT,
+  RELAY_SIGNAL_INDEX_PUBLIC_DEPOSIT_ASSET_HI,
+  RELAY_SIGNAL_INDEX_PUBLIC_DEPOSIT_ASSET_LO,
+  RELAY_SIGNAL_INDEX_PUBLIC_WITHDRAWAL,
+  RELAY_SIGNAL_INDEX_PUBLIC_WITHDRAWAL_ASSET_HI,
+  RELAY_SIGNAL_INDEX_PUBLIC_WITHDRAWAL_ASSET_LO,
+  RELAY_SIGNAL_INDEX_STATE_ROOT,
+  RELAY_SIGNAL_INDEX_WITHDRAW_ADDRESS_HI,
+  RELAY_SIGNAL_INDEX_WITHDRAW_ADDRESS_LO,
+  RELAY_TRANSACT_FIELD_BYTES,
+  RELAY_TRANSACT_PACKAGE_VERSION_V1,
+  RELAY_TRANSACT_SIGNAL_PREFIX_BYTES,
+  RELAY_TRANSACT_SUPPORTED_SIGNAL_COUNT,
+  SIX_BY_SIX_ZK_NONCE,
+  STANDARD_ZK_CONFIG_NONCE,
+  SUBMISSION_METHOD,
   ZERO_STROOPS,
+  assertEscrowSweepClaimant,
   assetLegToTokenAddress,
+  attachEscrowAuthorization,
   attachPoolStatePorts,
-  buildOnboardingPayload,
+  buildBlindedRecipientTagChallengeMessage,
   buildPoolTransactionAuditParameters,
   buildPrivateAddressSignMessage,
-  buildTransferOnboardingAtExecute,
   configurePrivacyPoolService,
   createPrivacyPoolService,
   decodePrivateAddress,
+  deriveEscrowRecipientFromStellarAddress,
   encodePrivateAddress,
   encodePrivateAddressFromHexCoordinates,
+  evaluateRequiredSubmissionMethod,
   fetchAndMergeMerkleState,
+  fetchEscrowOutputNoteEvents,
+  finalizeSpendOperationAtExecute,
   frDecimalToPaddedBytes32,
   generateRandomDepositScalarHex,
   generateTemporaryRecipientPrivateAddress,
   getPrivacyPoolService,
+  isEscrowPreparedOperation,
   loadDefaultStellarBrowserAssets,
   loadStellarBrowserAssets,
+  optionalZkArtifactBaseUrl,
   parseAuditPublicKeyFromEnvHex,
   parseKytReasonCode,
   prepareConfidentialTransferProof,
   prepareConfidentialTransferProofDual,
+  prepareEscrowSweepOperation,
+  prepareRelayTransactPackage,
+  prepareRelayTransactPackageFromPrepared,
   privateAddressSdk,
   readLeafEphemeralHex,
+  readRelayTransactSupportedProfile,
   recipientPublicKeysDecimalFromPrivateAddress,
+  reconstructEscrowNote,
   requestKytPassageForPoolInteraction,
+  requiredSubmissionMethod,
   resolvePoolApplicationId,
+  resolveZkConfigNonce,
   runTtlPreflight,
+  spendScalarHexFromStellarSignature,
   submitSorobanConfidentialTransfer,
   submitSorobanDeposit,
-  tokenAddressToAssetLeg
+  tokenAddressToAssetLeg,
+  unsignedEscrowAuthorizationForSweep
 };
 //# sourceMappingURL=index.js.map