npm - @arcanetech/privacy-sdk-stellar - Versions diffs - 0.5.1 → 0.5.4 - Mend

@arcanetech/privacy-sdk-stellar 0.5.1 → 0.5.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/README.md +1 -0
package/dist/index.d.ts +40 -10
package/dist/index.js +971 -335
package/dist/index.js.map +1 -1
package/dist/node.d.ts +7 -5
package/dist/node.js +947 -319
package/dist/node.js.map +1 -1
package/dist/testing/index.d.ts +1 -0
package/dist/transact/index.d.ts +40 -10
package/dist/transact/index.js +905 -291
package/dist/transact/index.js.map +1 -1
package/package.json +6 -6

package/dist/node.js CHANGED Viewed

@@ -468,27 +468,9 @@ function buildPrivateRecordFromDeposit(input) {
 // src/transact/pool/service.ts
 import {
-  PrivacyPoolSDK as PrivacyPoolSDK2,
-  decodeDecodedEphemeralKey,
-  randomFrDecimal253,
-  scalarHexToFrDecimal as scalarHexToFrDecimal2
+  decodeDecodedEphemeralKey
 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
-// src/transact/merkle/field-decimal.ts
-import { Buffer as Buffer4 } from "buffer";
-var BN254 = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
-var MERKLE_ROOT_BYTE_LENGTH = 32;
-var DECIMAL_STRING_RADIX = 10;
-function merkleRootBufferToFrDecimal(root) {
-  if (root.length !== MERKLE_ROOT_BYTE_LENGTH) {
-    throw new Error(
-      `expected ${MERKLE_ROOT_BYTE_LENGTH}-byte merkle root, got ${root.length}`
-    );
-  }
-  const hex = Buffer4.from(root).toString("hex");
-  return (BigInt(`0x${hex}`) % BN254).toString(DECIMAL_STRING_RADIX);
-}
 // src/transact/private-address/codec.ts
 import {
   buildStealthAddressSignMessage,
@@ -537,18 +519,18 @@ function privateAddressSdk(sdk) {
 import { withdrawObjectFromMerkleWitness as withdrawObjectFromMerkleWitness2 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
 // src/transact/proofs/transaction-input.ts
-import { Buffer as Buffer6 } from "buffer";
+import { Buffer as Buffer5 } from "buffer";
 import { StrKey as StrKey2 } from "@stellar/stellar-sdk";
 // src/transact/stellar/token-contract.ts
-import { Buffer as Buffer5 } from "buffer";
+import { Buffer as Buffer4 } from "buffer";
 import { StrKey } from "@stellar/stellar-sdk";
 var CONTRACT_ID_BYTE_LENGTH = 32;
 var HEX_CHARS_PER_BYTE = 2;
 var CONTRACT_ID_HEX_CHAR_LENGTH = CONTRACT_ID_BYTE_LENGTH * HEX_CHARS_PER_BYTE;
 var CONTRACT_ID_HEX = /^(?:0x)?([0-9a-f]{64})$/i;
 function encodeContractFromHex(hexPayload) {
-  return StrKey.encodeContract(Buffer5.from(hexPayload, "hex"));
+  return StrKey.encodeContract(Buffer4.from(hexPayload, "hex"));
 }
 function normalizeSorobanContractId(raw) {
   const trimmed = raw.trim();
@@ -581,7 +563,7 @@ var ZERO_PUBLIC_WITHDRAW_ADDRESS = {
 var CONTRACT_ADDRESS_HALF_BYTES = 16;
 var CONTRACT_ADDRESS_BYTES = 32;
 function bytes16ToDecimal(bytes) {
-  return BigInt(`0x${Buffer6.from(bytes).toString("hex")}`).toString();
+  return BigInt(`0x${Buffer5.from(bytes).toString("hex")}`).toString();
 }
 function tokenAddressFrParts(tokenAddress) {
   const normalized = resolveTokenContractId(tokenAddress);
@@ -742,14 +724,144 @@ function requireChangeRecipientWhenPartial(changeStroops, selfPrivateAddressStpl
     }
   }
 }
-function changeStroopsAfterDualTransfer(transferStroops, totalNotes) {
-  if (transferStroops < MIN_CONFIDENTIAL_TRANSFER_STROOPS) {
-    throw new Error("Transfer amount must be positive");
+// src/transact/fees/quote-request-body.ts
+function presentInstructedAmount(amount) {
+  const trimmed = amount?.trim() ?? "";
+  if (!trimmed || trimmed === "0") {
+    return void 0;
+  }
+  return trimmed;
+}
+function feeQuoteRequestBody(request) {
+  const publicDepositAmount = presentInstructedAmount(request.publicDepositAmount);
+  const transferInstructedAmount = presentInstructedAmount(
+    request.transferInstructedAmount
+  );
+  const publicWithdrawalAmount = presentInstructedAmount(
+    request.publicWithdrawalAmount
+  );
+  return {
+    feeAsset: request.feeAsset,
+    spendsNotes: request.spendsNotes,
+    ...publicDepositAmount === void 0 ? {} : { publicDepositAmount },
+    ...transferInstructedAmount === void 0 ? {} : { transferInstructedAmount },
+    ...publicWithdrawalAmount === void 0 ? {} : { publicWithdrawalAmount }
+  };
+}
+// src/transact/fees/quote-required-fee.ts
+function quoteHeaders(inspectAuthorization) {
+  const token = inspectAuthorization?.trim();
+  return {
+    "content-type": "application/json",
+    ...token ? { authorization: `Bearer ${token}` } : {}
+  };
+}
+function parseRequiredFee(raw) {
+  const text = `${raw ?? ""}`.trim();
+  if (!/^\d+$/u.test(text)) {
+    throw new Error("Fee Quote Required Fee must be an integer minor-unit string.");
+  }
+  return BigInt(text);
+}
+function requireQuoteString(raw, field) {
+  const text = `${raw ?? ""}`.trim();
+  if (!text) {
+    throw new Error(`Fee Quote is missing ${field}.`);
+  }
+  return text;
+}
+function parseQuotePayload(payload) {
+  return {
+    requiredFee: parseRequiredFee(payload.requiredFee),
+    feeAsset: requireQuoteString(payload.feeAsset, "Fee Asset"),
+    feeCollectorPrivateAddress: requireQuoteString(
+      payload.feeCollectorPrivateAddress,
+      "Fee Collector Private Address"
+    ),
+    feeRate: requireQuoteString(payload.feeRate, "Fee Rate")
+  };
+}
+async function quoteRequiredFee(input) {
+  const response = await fetch(
+    `${input.transactEnvironment.kyt.apiBaseUrl}/kyt/fees/quote`,
+    {
+      method: "POST",
+      headers: quoteHeaders(input.transactEnvironment.kyt.inspectAuthorization),
+      body: JSON.stringify(feeQuoteRequestBody(input.request))
+    }
+  );
+  const payload = await response.json();
+  if (!response.ok) {
+    throw new Error(`Fee Quote failed: ${JSON.stringify(payload)}`);
+  }
+  return parseQuotePayload(payload);
+}
+// src/transact/fees/should-attach-fee-output.ts
+function shouldAttachFeeOutput(input) {
+  if (input.spendSource === "escrow" && input.escrowSend !== true) {
+    return false;
+  }
+  return input.kind === "deposit" || input.kind === "transfer" || input.kind === "withdraw";
+}
+function feeOutputKindFromPrepared(prepared) {
+  return {
+    kind: prepared.kind,
+    ...prepared.transactArtifacts?.spendSource ? { spendSource: prepared.transactArtifacts.spendSource } : {},
+    ...prepared.transactArtifacts?.escrowSend ? { escrowSend: true } : {}
+  };
+}
+// src/transact/fees/quote-fee-output-for-prepared.ts
+function instructedMinorUnits(prepared) {
+  return prepared.intent.amount.toString();
+}
+function quoteRequestForPrepared(input) {
+  const amount = instructedMinorUnits(input.prepared);
+  if (input.prepared.kind === "deposit") {
+    return {
+      feeAsset: input.tokenAddress,
+      publicDepositAmount: amount,
+      spendsNotes: false
+    };
+  }
+  if (input.prepared.kind === "withdraw") {
+    return {
+      feeAsset: input.tokenAddress,
+      publicWithdrawalAmount: amount,
+      spendsNotes: true
+    };
+  }
+  return {
+    feeAsset: input.tokenAddress,
+    transferInstructedAmount: amount,
+    spendsNotes: true
+  };
+}
+async function quoteFeeOutputForPrepared(input) {
+  if (!shouldAttachFeeOutput(feeOutputKindFromPrepared(input.prepared))) {
+    return void 0;
+  }
+  const quote = await quoteRequiredFee({
+    transactEnvironment: input.environment,
+    request: quoteRequestForPrepared(input)
+  });
+  if (quote.requiredFee <= 0n) {
+    return void 0;
   }
-  if (transferStroops > totalNotes) {
-    throw new Error("Transfer amount exceeds combined note value");
+  return {
+    requiredFee: quote.requiredFee,
+    feeCollectorPrivateAddress: quote.feeCollectorPrivateAddress
+  };
+}
+function remainingAfterRequiredFee(input) {
+  const remaining = input.available - input.instructed - input.requiredFee;
+  if (remaining < 0n) {
+    throw new Error("Instructed amount and Required Fee exceed available note value");
   }
-  return totalNotes - transferStroops;
+  return remaining;
 }
 // src/transact/audit/parameters.ts
@@ -757,7 +869,7 @@ import {
   DEMO_AUDIT_PUBLIC_KEY,
   resolveTransactionAuditParams
 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
-import { Buffer as Buffer7 } from "buffer";
+import { Buffer as Buffer6 } from "buffer";
 var UNCOMPRESSED_PREFIX = "04";
 var UNCOMPRESSED_HEX_LENGTH = 130;
 var XY_HEX_LENGTH = 128;
@@ -784,7 +896,7 @@ function parseAuditPublicKeyFromEnvHex(raw) {
       "Audit public key must be uncompressed 65-byte hex (04 + X + Y) or 64-byte X+Y hex"
     );
   }
-  const bytes = Buffer7.from(payload, "hex");
+  const bytes = Buffer6.from(payload, "hex");
   const auditPublicKeyXDecimal = BigInt(
     `0x${bytes.subarray(0, X_OFFSET_END).toString("hex")}`
   ).toString(DECIMAL_RADIX);
@@ -806,6 +918,7 @@ function buildPoolTransactionAuditParameters(input) {
     input.nAuditSlots
   );
 }
+var DECIMAL_APPLICATION_ID = /^\d+$/u;
 function resolvePoolApplicationId(applicationId) {
   const trimmed = applicationId?.trim();
   if (!trimmed) {
@@ -813,6 +926,11 @@ function resolvePoolApplicationId(applicationId) {
       "Privacy pool applicationId is required. Pass it in client factory config."
     );
   }
+  if (!DECIMAL_APPLICATION_ID.test(trimmed)) {
+    throw new Error(
+      "Privacy pool applicationId must be association.audit_id (decimal Fr), not a UUID or foreignId."
+    );
+  }
   return trimmed;
 }
@@ -821,13 +939,13 @@ import { ed25519PubkeyPayloadHexToWithdrawFrDecimals } from "@arcanetech/stellar
 // src/transact/stellar/account.ts
 import { StrKey as StrKey3 } from "@stellar/stellar-sdk";
-import { Buffer as Buffer8 } from "buffer";
+import { Buffer as Buffer7 } from "buffer";
 var MUXED_ACCOUNT_ID_BYTE_LENGTH = 8;
 var ED25519_PUBLIC_KEY_BYTE_LENGTH = 32;
 function ed25519HexFromGAddress(trimmed) {
   try {
     const raw = StrKey3.decodeEd25519PublicKey(trimmed);
-    return Buffer8.from(raw).toString("hex");
+    return Buffer7.from(raw).toString("hex");
   } catch {
     return void 0;
   }
@@ -884,6 +1002,32 @@ function privKeyScalarDecimalFromRecipientScalarHex(hexInput) {
   return canonicalBabyJubScalarFromInteger(value).toString(DECIMAL_RADIX2);
 }
+// src/transact/fees/append-fee-output.ts
+function feeCoinFromSlot(slot) {
+  return {
+    commitment_hex: slot.commitment_hex,
+    coin: slot.coin,
+    depositScalarHex: slot.depositScalarHex,
+    precommitementHex: slot.precommitementHex
+  };
+}
+async function appendFeeOutputSlot(input) {
+  const requiredFee = input.feeOutput?.requiredFee ?? ZERO_STROOPS;
+  const collector = input.feeOutput?.feeCollectorPrivateAddress.trim() ?? "";
+  if (requiredFee <= ZERO_STROOPS || !collector) {
+    return { deposits: input.deposits };
+  }
+  const slot = await input.buildAlignedDepositSlot({
+    privateAddressStpl1: collector,
+    amountStroops: requiredFee,
+    tokenAddress: input.tokenAddress
+  });
+  return {
+    deposits: [...input.deposits, slot.deposit],
+    feeCoin: feeCoinFromSlot(slot)
+  };
+}
 // src/transact/proofs/withdraw/helpers.ts
 function destinationWithdrawFrAndScalar(parameters) {
   const pkHex = ed25519PublicKeyHexFromStellarAccount(
@@ -938,14 +1082,15 @@ async function resolveWithdrawChangeDeposits(parameters) {
     }
   };
 }
-function validateDualWithdrawAmounts(withdrawAmountStroops, totalNotes, changePrivateAddressStpl1) {
+function validateDualWithdrawAmounts(withdrawAmountStroops, totalNotes, changePrivateAddressStpl1, requiredFee) {
   if (withdrawAmountStroops < MIN_CONFIDENTIAL_TRANSFER_STROOPS) {
     throw new Error("Withdraw amount must be positive");
   }
-  if (withdrawAmountStroops > totalNotes) {
-    throw new Error("Withdraw amount exceeds combined note value");
-  }
-  const changeStroops = totalNotes - withdrawAmountStroops;
+  const changeStroops = remainingAfterRequiredFee({
+    available: totalNotes,
+    instructed: withdrawAmountStroops,
+    requiredFee
+  });
   requireChangeRecipientWhenPartial(changeStroops, changePrivateAddressStpl1);
   return changeStroops;
 }
@@ -958,11 +1103,31 @@ function buildDualWithdrawPublicInput(parameters) {
     publicWithdrawalAmount: parameters.publicWithdrawalAmount
   });
 }
+async function withdrawOutputsWithOptionalFee(parameters) {
+  const { deposits: changeDeposits, changeCoin } = await resolveWithdrawChangeDeposits({
+    changeStroops: parameters.changeStroops,
+    changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
+    buildAlignedDepositSlot: parameters.buildAlignedDepositSlot,
+    tokenAddress: parameters.tokenAddress
+  });
+  const withFee = await appendFeeOutputSlot({
+    deposits: changeDeposits,
+    tokenAddress: parameters.tokenAddress,
+    buildAlignedDepositSlot: parameters.buildAlignedDepositSlot,
+    ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
+  });
+  return {
+    deposits: withFee.deposits,
+    ...changeCoin ? { changeCoin } : {},
+    ...withFee.feeCoin ? { feeCoin: withFee.feeCoin } : {}
+  };
+}
 async function prepareDualWithdrawProofInputs(parameters) {
   const changeStroops = validateDualWithdrawAmounts(
     parameters.withdrawAmountStroops,
     BigInt(parameters.coinA.value) + BigInt(parameters.coinB.value),
-    parameters.changePrivateAddressStpl1
+    parameters.changePrivateAddressStpl1,
+    parameters.feeOutput?.requiredFee ?? 0n
   );
   const { legA, legB } = dualWithdrawLegsWithSharedRoot({
     sdk: parameters.sdk,
@@ -977,11 +1142,12 @@ async function prepareDualWithdrawProofInputs(parameters) {
     ),
     applicationId: parameters.applicationId
   });
-  const { deposits, changeCoin } = await resolveWithdrawChangeDeposits({
+  const { deposits, changeCoin, feeCoin } = await withdrawOutputsWithOptionalFee({
     changeStroops,
     changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
     buildAlignedDepositSlot: parameters.buildAlignedDepositSlot,
-    tokenAddress: parameters.tokenAddress
+    tokenAddress: parameters.tokenAddress,
+    ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
   });
   const publicInput = buildDualWithdrawPublicInput({
     destinationStellarAddress: parameters.destinationStellarAddress,
@@ -1000,19 +1166,55 @@ async function prepareDualWithdrawProofInputs(parameters) {
     audit,
     deposits,
     withdrawLegs: [legA.withdrawObject, legB.withdrawObject],
-    ...changeCoin ? { changeCoin } : {}
+    ...changeCoin ? { changeCoin } : {},
+    ...feeCoin ? { feeCoin } : {}
   };
 }
+// src/transact/proofs/withdraw/fee-deposits.ts
+async function withdrawDepositsWithFee(parameters) {
+  const { deposits, changeCoin } = await resolveWithdrawChangeDeposits({
+    changeStroops: parameters.changeStroops,
+    changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
+    buildAlignedDepositSlot: parameters.buildAlignedDepositSlot,
+    tokenAddress: parameters.tokenAddress
+  });
+  const withFee = await appendFeeOutputSlot({
+    deposits,
+    tokenAddress: parameters.tokenAddress,
+    buildAlignedDepositSlot: parameters.buildAlignedDepositSlot,
+    ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
+  });
+  return {
+    deposits: withFee.deposits,
+    ...changeCoin ? { changeCoin } : {},
+    ...withFee.feeCoin ? { feeCoin: withFee.feeCoin } : {}
+  };
+}
+function withdrawOutputApplicationIds(input) {
+  const outputIds = [];
+  if (input.hasChange) {
+    outputIds.push(input.applicationId);
+  }
+  if (input.hasFeeOutput) {
+    outputIds.push(input.applicationId);
+  }
+  if (outputIds.length === 0) {
+    outputIds.push("0");
+  }
+  return outputIds;
+}
 // src/transact/proofs/withdraw/transact-proof.ts
-function validateSingleWithdrawAmounts(withdrawAmountStroops, noteStroops) {
+function validateSingleWithdrawAmounts(withdrawAmountStroops, noteStroops, requiredFee) {
   if (withdrawAmountStroops < MIN_CONFIDENTIAL_TRANSFER_STROOPS) {
     throw new Error("Withdraw amount must be positive");
   }
-  if (withdrawAmountStroops > noteStroops) {
-    throw new Error("Withdraw amount exceeds note value");
-  }
-  return noteStroops - withdrawAmountStroops;
+  return remainingAfterRequiredFee({
+    available: noteStroops,
+    instructed: withdrawAmountStroops,
+    requiredFee
+  });
 }
 async function proveSingleWithdrawTransaction(parameters) {
   return parameters.sdk.proveTransaction(
@@ -1051,7 +1253,8 @@ function buildPrimaryWithdrawForCoin(parameters) {
 async function prepareSingleWithdrawProofInputs(parameters) {
   const changeStroops = validateSingleWithdrawAmounts(
     parameters.withdrawAmountStroops,
-    BigInt(parameters.coin.value)
+    BigInt(parameters.coin.value),
+    parameters.feeOutput?.requiredFee ?? 0n
   );
   const { witness, primaryWithdraw } = buildPrimaryWithdrawForCoin({
     sdk: parameters.sdk,
@@ -1060,11 +1263,12 @@ async function prepareSingleWithdrawProofInputs(parameters) {
     state: parameters.state,
     privKeyScalarHex: parameters.privKeyScalarHex
   });
-  const { deposits, changeCoin } = await resolveWithdrawChangeDeposits({
+  const { deposits, changeCoin, feeCoin } = await withdrawDepositsWithFee({
     changeStroops,
     changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
     buildAlignedDepositSlot: parameters.buildAlignedDepositSlot,
-    tokenAddress: parameters.tokenAddress
+    tokenAddress: parameters.tokenAddress,
+    ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
   });
   const publicInput = buildWithdrawPublicInput({
     stateRoot: witness.stateRoot,
@@ -1077,6 +1281,7 @@ async function prepareSingleWithdrawProofInputs(parameters) {
     primaryWithdraw,
     deposits,
     changeCoin,
+    feeCoin,
     publicInput,
     audit: buildPoolTransactionAuditParameters({
       applicationId: parameters.applicationId,
@@ -1086,7 +1291,7 @@ async function prepareSingleWithdrawProofInputs(parameters) {
   };
 }
 async function proveWithdrawTransact(parameters) {
-  const { primaryWithdraw, deposits, changeCoin, publicInput, audit } = await prepareSingleWithdrawProofInputs(parameters);
+  const { primaryWithdraw, deposits, changeCoin, feeCoin, publicInput, audit } = await prepareSingleWithdrawProofInputs(parameters);
   const proof = await proveSingleWithdrawTransaction({
     sdk: parameters.sdk,
     publicInput,
@@ -1101,13 +1306,17 @@ async function proveWithdrawTransact(parameters) {
     applicationIdsPlaintext: buildApplicationIdHints({
       sdk: parameters.sdk,
       inputIds: [parameters.applicationId],
-      outputIds: [changeCoin ? parameters.applicationId : "0"]
+      outputIds: withdrawOutputApplicationIds({
+        applicationId: parameters.applicationId,
+        hasChange: Boolean(changeCoin),
+        hasFeeOutput: Boolean(feeCoin)
+      })
     }),
     ...changeCoin ? { changeCoin } : {}
   };
 }
 async function proveWithdrawTransactDual(parameters) {
-  const { publicInput, audit, withdrawLegs, deposits, changeCoin } = await prepareDualWithdrawProofInputs(parameters);
+  const { publicInput, audit, withdrawLegs, deposits, changeCoin, feeCoin } = await prepareDualWithdrawProofInputs(parameters);
   const proof = await parameters.sdk.proveTransaction(
     publicInput,
     padPublicLegsToLayout(
@@ -1126,7 +1335,11 @@ async function proveWithdrawTransactDual(parameters) {
     applicationIdsPlaintext: buildApplicationIdHints({
       sdk: parameters.sdk,
       inputIds: [audit.applicationId, audit.applicationId],
-      outputIds: [changeCoin ? audit.applicationId : "0"]
+      outputIds: withdrawOutputApplicationIds({
+        applicationId: audit.applicationId,
+        hasChange: Boolean(changeCoin),
+        hasFeeOutput: Boolean(feeCoin)
+      })
     }),
     ...changeCoin ? { changeCoin } : {}
   };
@@ -1147,6 +1360,9 @@ var DEFAULT_ZK_CONFIG_NONCE = BINDING_ZK_NONCE;
 function resolveZkConfigNonce(transactEnvironment) {
   return transactEnvironment.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
 }
+function transactNonceFromArtifacts(artifacts, transactEnvironment) {
+  return artifacts?.zkConfigNonce ?? resolveZkConfigNonce(transactEnvironment);
+}
 // src/transact/zk/browser-artifact-cache.ts
 import { ZK_ARTIFACT_VERSION } from "@arcanetech/stellar-privacy-pool-zk-sdk";
@@ -1399,6 +1615,122 @@ async function buildAlignedDepositSlotForSdk(sdk, applicationId, parameters) {
   };
 }
+// src/transact/pool/initialize-sdk.ts
+import { PrivacyPoolSDK as PrivacyPoolSDK2 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
+async function initializePrivacyPoolSdk(input, nonce) {
+  const zkConfigNonce = nonce ?? input.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
+  const zkCircuits = await materializeSelectedZkCircuit(
+    input.zkCircuits,
+    zkConfigNonce,
+    input.zkArtifactBaseUrl
+  );
+  return PrivacyPoolSDK2.init({
+    wasmBinary: input.assets.sdkWasm,
+    zkCircuits,
+    zkConfigNonce,
+    ...optionalZkArtifactBaseUrl(input.zkArtifactBaseUrl)
+  });
+}
+// src/transact/fees/zk-config-nonce-for-kind.ts
+function configuredNonceSpread(zkConfigNonce) {
+  if (zkConfigNonce === void 0) {
+    return {};
+  }
+  return { configuredNonce: zkConfigNonce };
+}
+function zkConfigNonceForFeeBearingKind(input) {
+  if (input.configuredNonce === SIX_BY_SIX_BINDING_ZK_NONCE) {
+    return SIX_BY_SIX_BINDING_ZK_NONCE;
+  }
+  if (input.kind === "transfer" && shouldAttachFeeOutput(input)) {
+    return SIX_BY_SIX_BINDING_ZK_NONCE;
+  }
+  return input.configuredNonce ?? BINDING_ZK_NONCE;
+}
+// src/transact/pool/prepare-deposit-proof.ts
+import {
+  randomFrDecimal253,
+  scalarHexToFrDecimal as scalarHexToFrDecimal2
+} from "@arcanetech/stellar-privacy-pool-zk-sdk";
+// src/transact/merkle/field-decimal.ts
+import { Buffer as Buffer8 } from "buffer";
+var BN254 = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+var MERKLE_ROOT_BYTE_LENGTH = 32;
+var DECIMAL_STRING_RADIX = 10;
+function merkleRootBufferToFrDecimal(root) {
+  if (root.length !== MERKLE_ROOT_BYTE_LENGTH) {
+    throw new Error(
+      `expected ${MERKLE_ROOT_BYTE_LENGTH}-byte merkle root, got ${root.length}`
+    );
+  }
+  const hex = Buffer8.from(root).toString("hex");
+  return (BigInt(`0x${hex}`) % BN254).toString(DECIMAL_STRING_RADIX);
+}
+// src/transact/pool/prepare-deposit-proof.ts
+function userDepositSlot(input) {
+  return {
+    value: input.coin.value,
+    nullifier: input.coin.nullifier,
+    ephemeralKeyScalar: scalarHexToFrDecimal2(input.depositScalarHex),
+    asset: [input.coin.asset_hi, input.coin.asset_lo],
+    applicationId: input.applicationId,
+    recipientPublicKeys: recipientPublicKeysDecimalFromPrivateAddress(
+      input.privateAddressStpl1
+    )
+  };
+}
+function outputApplicationIds(input) {
+  if (input.hasFeeOutput) {
+    return [input.applicationId, input.applicationId];
+  }
+  return [input.applicationId];
+}
+async function proveDepositTransact(input) {
+  const publicDeposit = (input.publicDepositStroops ?? BigInt(input.coin.value)).toString();
+  const withFee = await appendFeeOutputSlot({
+    deposits: [userDepositSlot(input)],
+    tokenAddress: input.tokenAddress,
+    buildAlignedDepositSlot: input.buildAlignedDepositSlot,
+    ...input.feeOutput ? { feeOutput: input.feeOutput } : {}
+  });
+  const audit = buildPoolTransactionAuditParameters({
+    applicationId: input.applicationId,
+    nAuditSlots: input.sdk.getLayout().nAuditSlots,
+    ...input.auditPublicKey ? { auditPublicKey: input.auditPublicKey } : {}
+  });
+  const proof = await input.sdk.proveTransaction(
+    withTokenAddressPublicInputs(
+      {
+        stateRoot: merkleRootBufferToFrDecimal(input.merkleRootBytes),
+        privKeyScalar: randomFrDecimal253()
+      },
+      input.tokenAddress
+    ),
+    padPublicLegsToLayout(
+      input.sdk,
+      buildPublicDepositLegs(input.tokenAddress, publicDeposit)
+    ),
+    padWithdrawSlotsToLayout(input.sdk, []),
+    padDepositSlotsToLayout(input.sdk, withFee.deposits),
+    audit
+  );
+  return {
+    ...proof,
+    applicationIdsPlaintext: buildApplicationIdHints({
+      sdk: input.sdk,
+      inputIds: [],
+      outputIds: outputApplicationIds({
+        applicationId: input.applicationId,
+        hasFeeOutput: Boolean(withFee.feeCoin)
+      })
+    })
+  };
+}
 // src/transact/pool/service.ts
 var PrivacyPoolService = class {
   constructor(assets, applicationId, auditPublicKey, zkCircuits, zkConfigNonce, zkArtifactBaseUrl) {
@@ -1415,42 +1747,50 @@ var PrivacyPoolService = class {
   zkCircuits;
   zkConfigNonce;
   zkArtifactBaseUrl;
-  sdk = void 0;
-  initPromise = void 0;
-  async ensureInit() {
-    if (this.sdk) {
-      return;
+  sdks = /* @__PURE__ */ new Map();
+  initPromises = /* @__PURE__ */ new Map();
+  async getInitializedSdk(nonce) {
+    const zkConfigNonce = nonce ?? this.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
+    const key = zkConfigNonce.toString();
+    const existing = this.sdks.get(key);
+    if (existing) {
+      return existing;
     }
-    if (this.initPromise) {
-      return this.initPromise;
+    const pending = this.initPromises.get(key);
+    if (pending) {
+      return pending;
     }
-    this.initPromise = (async () => {
-      if (!this.assets) {
-        throw new Error(
-          "PrivacyPoolService requires browser ZK assets before initialization."
-        );
-      }
-      const zkConfigNonce = this.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
-      const zkCircuits = await materializeSelectedZkCircuit(
-        this.zkCircuits,
-        zkConfigNonce,
-        this.zkArtifactBaseUrl
-      );
-      this.sdk = await PrivacyPoolSDK2.init({
-        wasmBinary: this.assets.sdkWasm,
-        zkCircuits,
-        zkConfigNonce,
-        ...optionalZkArtifactBaseUrl(this.zkArtifactBaseUrl)
-      });
-    })();
-    return this.initPromise;
+    const started = this.initializeSdk(zkConfigNonce);
+    this.initPromises.set(key, started);
+    try {
+      const sdk = await started;
+      this.sdks.set(key, sdk);
+      return sdk;
+    } finally {
+      this.initPromises.delete(key);
+    }
+  }
+  feeBearingZkConfigNonce(input) {
+    return zkConfigNonceForFeeBearingKind({
+      ...input,
+      ...configuredNonceSpread(this.zkConfigNonce)
+    });
   }
-  async getInitializedSdk() {
-    await this.ensureInit();
-    if (!this.sdk) {
-      throw new Error("SDK not initialized");
+  async initializeSdk(nonce) {
+    if (!this.assets) {
+      throw new Error(
+        "PrivacyPoolService requires browser ZK assets before initialization."
+      );
     }
-    return this.sdk;
+    return initializePrivacyPoolSdk(
+      {
+        assets: this.assets,
+        ...this.zkCircuits ? { zkCircuits: this.zkCircuits } : {},
+        ...this.zkConfigNonce === void 0 ? {} : { zkConfigNonce: this.zkConfigNonce },
+        ...optionalZkArtifactBaseUrl(this.zkArtifactBaseUrl)
+      },
+      nonce
+    );
   }
   getAuditPublicKey() {
     return this.auditPublicKey;
@@ -1483,65 +1823,51 @@ var PrivacyPoolService = class {
     return { commitment_hex, coin, depositScalarHex, precommitementHex };
   }
   async prepareDepositTransactProof(parameters) {
-    const sdk = await this.getInitializedSdk();
-    const stateRoot = merkleRootBufferToFrDecimal(parameters.merkleRootBytes);
-    const recipientPublicKeys = recipientPublicKeysDecimalFromPrivateAddress(
-      parameters.privateAddressStpl1
-    );
-    const applicationId = this.getApplicationId();
-    const audit = buildPoolTransactionAuditParameters({
-      applicationId,
-      nAuditSlots: sdk.getLayout().nAuditSlots,
-      ...this.auditPublicKey ? { auditPublicKey: this.auditPublicKey } : {}
-    });
-    const deposit = {
-      value: parameters.coin.value,
-      nullifier: parameters.coin.nullifier,
-      ephemeralKeyScalar: scalarHexToFrDecimal2(parameters.depositScalarHex),
-      asset: [parameters.coin.asset_hi, parameters.coin.asset_lo],
-      applicationId,
-      recipientPublicKeys
-    };
-    const publicInput = withTokenAddressPublicInputs(
-      {
-        stateRoot,
-        privKeyScalar: randomFrDecimal253()
-      },
-      parameters.tokenAddress
+    const sdk = await this.getInitializedSdk(
+      this.feeBearingZkConfigNonce({ kind: "deposit" })
     );
-    const proof = await sdk.proveTransaction(
-      publicInput,
-      padPublicLegsToLayout(
-        sdk,
-        buildPublicDepositLegs(parameters.tokenAddress, parameters.coin.value)
-      ),
-      padWithdrawSlotsToLayout(sdk, []),
-      padDepositSlotsToLayout(sdk, [deposit]),
-      audit
-    );
-    const applicationIdsPlaintext = buildApplicationIdHints({
+    return proveDepositTransact({
       sdk,
-      inputIds: [],
-      outputIds: [applicationId]
+      applicationId: this.getApplicationId(),
+      privateAddressStpl1: parameters.privateAddressStpl1,
+      coin: parameters.coin,
+      depositScalarHex: parameters.depositScalarHex,
+      merkleRootBytes: parameters.merkleRootBytes,
+      tokenAddress: parameters.tokenAddress,
+      buildAlignedDepositSlot: (input) => this.buildAlignedDepositSlot(input),
+      ...this.auditPublicKey ? { auditPublicKey: this.auditPublicKey } : {},
+      ...parameters.publicDepositStroops === void 0 ? {} : { publicDepositStroops: parameters.publicDepositStroops },
+      ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
     });
-    return { ...proof, applicationIdsPlaintext };
   }
   async calculateNullifierHash(nullifier, privKeyScalar) {
     const sdk = await this.getInitializedSdk();
     return sdk.calculateNullifierHash(nullifier, privKeyScalar);
   }
   async prepareWithdrawTransactProof(parameters) {
-    const sdk = await this.getInitializedSdk();
+    const sdk = await this.getInitializedSdk(
+      this.feeBearingZkConfigNonce({ kind: "withdraw" })
+    );
     return proveWithdrawTransact({
       sdk,
       applicationId: this.getApplicationId(),
       buildAlignedDepositSlot: (input) => this.buildAlignedDepositSlot(input),
       ...this.auditPublicKey ? { auditPublicKey: this.auditPublicKey } : {},
-      ...parameters
+      coin: parameters.coin,
+      state: parameters.state,
+      destinationStellarAddress: parameters.destinationStellarAddress,
+      privKeyScalarHex: parameters.privKeyScalarHex,
+      depositorEphemeralKey: parameters.depositorEphemeralKey,
+      withdrawAmountStroops: parameters.withdrawAmountStroops,
+      changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
+      tokenAddress: parameters.tokenAddress,
+      ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
     });
   }
   async prepareWithdrawTransactProofDual(parameters) {
-    const sdk = await this.getInitializedSdk();
+    const sdk = await this.getInitializedSdk(
+      this.feeBearingZkConfigNonce({ kind: "withdraw" })
+    );
     return proveWithdrawTransactDual({
       sdk,
       applicationId: this.getApplicationId(),
@@ -1556,7 +1882,8 @@ var PrivacyPoolService = class {
       ephemeralBKey: parameters.depositorEphemeralBKey,
       withdrawAmountStroops: parameters.withdrawAmountStroops,
       changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
-      tokenAddress: parameters.tokenAddress
+      tokenAddress: parameters.tokenAddress,
+      ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
     });
   }
 };
@@ -1586,92 +1913,167 @@ function getPrivacyPoolService() {
 }
 // src/transact/merkle/fetch-contract.ts
+import { Buffer as Buffer12 } from "buffer";
+// src/transact/merkle/state-port.ts
+function poolMerkleStateToCachedView(state) {
+  return {
+    commitments: state.commitments,
+    updatedAt: state.updatedAt,
+    merkleRootHex: state.merkleRootHex
+  };
+}
+// src/transact/merkle/read-tree-leaves.ts
+import { Address, xdr } from "@stellar/stellar-sdk";
 import { Buffer as Buffer11 } from "buffer";
 // src/transact/merkle/encoding.ts
 import "buffer";
 var FR_ORDER = 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n;
-function bufferToDecimal(buf) {
+function commitmentBufferToDecimal(buf) {
   const hex = buf.toString("hex");
   const bigintFromHex = BigInt(`0x${hex}`);
   const reduced = bigintFromHex % FR_ORDER;
   return reduced.toString();
 }
-function commitmentsBuffersToDecimal(buffers) {
-  return buffers.map((bufferRow) => bufferToDecimal(bufferRow));
-}
-// src/transact/merkle/state-port.ts
-function poolMerkleStateToCachedView(state) {
-  return {
-    commitments: state.commitments,
-    updatedAt: state.updatedAt,
-    merkleRootHex: state.merkleRootHex
-  };
-}
-// src/transact/merkle/fetch-contract.ts
-function normalizeCommitmentBuffers(rawBuffers) {
-  return rawBuffers.map(
-    (bufferRow) => Buffer11.isBuffer(bufferRow) ? bufferRow : Buffer11.from(bufferRow)
+// src/transact/merkle/read-tree-leaves.ts
+var TREE_LEAF_LEDGER_BATCH_SIZE = 100;
+function treeLeafLedgerKey(contractId, leafIndex) {
+  return xdr.LedgerKey.contractData(
+    new xdr.LedgerKeyContractData({
+      contract: new Address(contractId).toScAddress(),
+      key: treeLeafKeyScValue(leafIndex),
+      durability: xdr.ContractDataDurability.persistent()
+    })
   );
 }
-function mergeContractMerkleWithCache(parameters) {
-  const cachedCount = parameters.cachedState?.commitments.length ?? 0;
-  const shouldPreferContract = parameters.contractCount > cachedCount || !parameters.cachedState || cachedCount === 0;
-  if (shouldPreferContract) {
-    const updatedAt = Date.now();
-    void parameters.poolMerkleState?.set({
-      poolContract: parameters.poolContractId,
-      commitments: parameters.contractCommitments,
-      commitmentCount: parameters.contractCount,
-      merkleRootHex: parameters.merkleRootHex,
-      updatedAt
-    });
-    return {
-      commitments: parameters.contractCommitments,
-      updatedAt,
-      merkleRootHex: parameters.merkleRootHex,
-      commitmentCount: parameters.contractCount
-    };
+function treeLeafKeyScValue(leafIndex) {
+  return xdr.ScVal.scvVec([xdr.ScVal.scvSymbol("Leaf"), xdr.ScVal.scvU32(leafIndex)]);
+}
+function leafIndexFromContractDataKey(key) {
+  if (key.switch() !== xdr.ScValType.scvVec()) {
+    return void 0;
   }
-  return {
-    commitments: parameters.cachedState.commitments,
-    updatedAt: parameters.cachedState.updatedAt,
-    merkleRootHex: parameters.cachedState.merkleRootHex ?? parameters.merkleRootHex,
-    commitmentCount: parameters.cachedState.commitments.length
-  };
+  const fields = key.vec();
+  if (!fields || fields.length !== 2) {
+    return void 0;
+  }
+  const [tag, indexValue] = fields;
+  if (!tag || tag.switch() !== xdr.ScValType.scvSymbol()) {
+    return void 0;
+  }
+  if (tag.sym().toString() !== "Leaf") {
+    return void 0;
+  }
+  if (!indexValue || indexValue.switch() !== xdr.ScValType.scvU32()) {
+    return void 0;
+  }
+  return indexValue.u32();
 }
-async function readCachedPoolMerkleView(poolMerkleState, poolContractId) {
-  if (!poolMerkleState) {
+function commitmentBytesFromContractDataValue(value) {
+  if (value.switch() !== xdr.ScValType.scvBytes()) {
     return void 0;
   }
-  const cached = await poolMerkleState.get(poolContractId);
-  return cached ? poolMerkleStateToCachedView(cached) : void 0;
+  return Buffer11.from(value.bytes());
+}
+async function readTreeLeafCommitments(input) {
+  if (input.startIndex >= input.endIndex) {
+    return [];
+  }
+  const byIndex = await readLeafBuffersByIndex(input);
+  return decimalCommitmentsInRange(byIndex, input.startIndex, input.endIndex);
+}
+async function readLeafBuffersByIndex(input) {
+  const keys = ledgerKeysForRange(input.contractId, input.startIndex, input.endIndex);
+  const byIndex = /* @__PURE__ */ new Map();
+  for (const batch of chunkLedgerKeys(keys, TREE_LEAF_LEDGER_BATCH_SIZE)) {
+    const response = await input.reader.getLedgerEntries(...batch);
+    collectLeafBuffers(response.entries, byIndex);
+  }
+  return byIndex;
+}
+function ledgerKeysForRange(contractId, startIndex, endIndex) {
+  const keys = [];
+  for (let leafIndex = startIndex; leafIndex < endIndex; leafIndex += 1) {
+    keys.push(treeLeafLedgerKey(contractId, leafIndex));
+  }
+  return keys;
+}
+function chunkLedgerKeys(keys, batchSize) {
+  const batches = [];
+  for (let offset = 0; offset < keys.length; offset += batchSize) {
+    batches.push(keys.slice(offset, offset + batchSize));
+  }
+  return batches;
+}
+function collectLeafBuffers(entries, byIndex) {
+  for (const entry of entries) {
+    const contractData = entry.val.contractData();
+    const leafIndex = leafIndexFromContractDataKey(contractData.key());
+    const bytes = commitmentBytesFromContractDataValue(contractData.val());
+    if (leafIndex === void 0 || !bytes) {
+      continue;
+    }
+    byIndex.set(leafIndex, bytes);
+  }
+}
+function decimalCommitmentsInRange(byIndex, startIndex, endIndex) {
+  const commitments = [];
+  for (let leafIndex = startIndex; leafIndex < endIndex; leafIndex += 1) {
+    const bytes = byIndex.get(leafIndex);
+    if (!bytes) {
+      throw new Error(`Missing Merkle leaf ${String(leafIndex)} in pool storage.`);
+    }
+    commitments.push(commitmentBufferToDecimal(bytes));
+  }
+  return commitments;
+}
+// src/transact/merkle/reuse-cached-commitments.ts
+function completeCacheRootMatches(cachedState, merkleRootHex) {
+  const cachedRoot = cachedState?.merkleRootHex;
+  if (cachedRoot === void 0 || cachedRoot === "") {
+    return true;
+  }
+  return cachedRoot === merkleRootHex;
+}
+function reuseCachedCommitments(input) {
+  const cachedCommitments = input.cachedState?.commitments ?? [];
+  if (cachedCommitments.length === 0) {
+    return [];
+  }
+  if (cachedCommitments.length > input.onChainCount) {
+    return [];
+  }
+  if (cachedCommitments.length === input.onChainCount) {
+    return completeCacheRootMatches(input.cachedState, input.merkleRootHex) ? cachedCommitments : [];
+  }
+  return cachedCommitments;
 }
+// src/transact/merkle/fetch-contract.ts
 async function fetchAndMergeMerkleState(parameters) {
-  const client = readPoolClientFactory(parameters.transactEnvironment)({
-    contractId: parameters.poolContractId,
-    walletPublicKey: parameters.walletPublicKey,
-    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
-    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
-  });
-  const commitmentsRead = await client.get_commitments();
-  const rawBuffers = commitmentsRead.result;
-  const buffers = normalizeCommitmentBuffers(rawBuffers);
-  const contractCommitments = commitmentsBuffersToDecimal(buffers);
-  const contractCount = contractCommitments.length;
+  const client = createPoolClient(parameters);
+  const countRead = await client.get_commitment_count();
+  const onChainCount = requireCommitmentCount(countRead.result);
   const rootRead = await client.get_merkle_root();
-  const merkleRootBuffer = rootRead.result;
-  const merkleRootHex = Buffer11.from(merkleRootBuffer).toString("hex");
+  const merkleRootHex = merkleRootToHex(rootRead.result);
   const cachedState = await readCachedPoolMerkleView(
     parameters.poolMerkleState,
     parameters.poolContractId
   );
-  return mergeContractMerkleWithCache({
+  const commitments = await loadCommitments({
+    cachedState,
+    onChainCount,
+    merkleRootHex,
+    rpcUrl: parameters.transactEnvironment.network.rpcUrl,
+    contractId: parameters.poolContractId
+  });
+  return persistFetchedMerkleState({
     poolContractId: parameters.poolContractId,
-    contractCommitments,
-    contractCount,
+    commitments,
     merkleRootHex,
     cachedState,
     ...parameters.poolMerkleState ? { poolMerkleState: parameters.poolMerkleState } : {}
@@ -1685,19 +2087,14 @@ async function readLeafEphemeralHex(parameters) {
   if (cached?.xHex && cached.yHex) {
     return { xHex: cached.xHex, yHex: cached.yHex };
   }
-  const client = readPoolClientFactory(parameters.transactEnvironment)({
-    contractId: parameters.poolContractId,
-    walletPublicKey: parameters.walletPublicKey,
-    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
-    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
-  });
+  const client = createPoolClient(parameters);
   const read = await client.get_leaf_ephemeral({ leaf_index: parameters.leafIndex });
   const coords = read.result;
   if (!coords?.x || !coords?.y) {
     throw new Error("Missing leaf ephemeral key on contract");
   }
-  const xHex = Buffer11.from(coords.x).toString("hex");
-  const yHex = Buffer11.from(coords.y).toString("hex");
+  const xHex = Buffer12.from(coords.x).toString("hex");
+  const yHex = Buffer12.from(coords.y).toString("hex");
   await parameters.leafEphemeral?.set({
     poolContract: parameters.poolContractId,
     leafIndex: parameters.leafIndex,
@@ -1707,6 +2104,84 @@ async function readLeafEphemeralHex(parameters) {
   });
   return { xHex, yHex };
 }
+function createPoolClient(parameters) {
+  return readPoolClientFactory(parameters.transactEnvironment)({
+    contractId: parameters.poolContractId,
+    walletPublicKey: parameters.walletPublicKey,
+    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
+    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
+  });
+}
+function requireCommitmentCount(result) {
+  if (typeof result === "number" && Number.isInteger(result) && result >= 0) {
+    return result;
+  }
+  throw new Error("Pool commitment count is not a non-negative integer.");
+}
+function merkleRootToHex(root) {
+  return Buffer12.from(root).toString("hex");
+}
+async function readCachedPoolMerkleView(poolMerkleState, poolContractId) {
+  if (!poolMerkleState) {
+    return void 0;
+  }
+  const cached = await poolMerkleState.get(poolContractId);
+  return cached ? poolMerkleStateToCachedView(cached) : void 0;
+}
+async function loadCommitments(input) {
+  const reused = reuseCachedCommitments({
+    cachedState: input.cachedState,
+    onChainCount: input.onChainCount,
+    merkleRootHex: input.merkleRootHex
+  });
+  if (reused.length === input.onChainCount) {
+    return reused;
+  }
+  const fetched = await readTreeLeafCommitments({
+    reader: createStellarRpcServer(input.rpcUrl),
+    contractId: input.contractId,
+    startIndex: reused.length,
+    endIndex: input.onChainCount
+  });
+  return [...reused, ...fetched];
+}
+async function persistFetchedMerkleState(input) {
+  const cachedState = input.cachedState;
+  if (cachedState && cachedMerkleUnchanged(cachedState, input.commitments, input.merkleRootHex)) {
+    return viewFromCachedMerkle(cachedState, input.merkleRootHex);
+  }
+  const updatedAt = Date.now();
+  await input.poolMerkleState?.set({
+    poolContract: input.poolContractId,
+    commitments: input.commitments,
+    commitmentCount: input.commitments.length,
+    merkleRootHex: input.merkleRootHex,
+    updatedAt
+  });
+  return {
+    commitments: input.commitments,
+    updatedAt,
+    merkleRootHex: input.merkleRootHex,
+    commitmentCount: input.commitments.length
+  };
+}
+function viewFromCachedMerkle(cachedState, merkleRootHex) {
+  return {
+    commitments: cachedState.commitments,
+    updatedAt: cachedState.updatedAt,
+    merkleRootHex: cachedState.merkleRootHex ?? merkleRootHex,
+    commitmentCount: cachedState.commitments.length
+  };
+}
+function cachedMerkleUnchanged(cachedState, commitments, merkleRootHex) {
+  if (!cachedState) {
+    return false;
+  }
+  if ((cachedState.merkleRootHex ?? merkleRootHex) !== merkleRootHex) {
+    return false;
+  }
+  return cachedState.commitments.join(",") === commitments.join(",");
+}
 // src/transact/engine/prepare/shared.ts
 async function resolveTokenContractId2(environment, assetId) {
@@ -1996,6 +2471,13 @@ async function filterUnspentPrivateRecords(input) {
   }
   return unspent;
 }
+function spendAmountCoveringProtocolFee(amount) {
+  if (amount <= 0n) {
+    return amount;
+  }
+  const hundredths = (amount + 99n) / 100n;
+  return amount + (hundredths === 0n ? 1n : hundredths);
+}
 function pickRecordsForSpendAmount(input) {
   let selectedTotal = 0n;
   const selected = [];
@@ -2049,7 +2531,7 @@ async function selectPrivateRecords(input) {
   return pickRecordsForSpendAmount({
     available,
     kind: input.kind,
-    amount: input.intent.amount
+    amount: spendAmountCoveringProtocolFee(input.intent.amount)
   });
 }
 function sumRecordAmounts(records) {
@@ -4104,7 +4586,7 @@ function createStellarStorageAdapterFromState(state) {
 }
 // src/contracts/registry/registry-domain-service.ts
-import { Buffer as Buffer12 } from "buffer";
+import { Buffer as Buffer13 } from "buffer";
 // src/transact/submit/ttl-preflight.ts
 function getNested(source, path) {
@@ -4153,11 +4635,11 @@ async function runTtlPreflight(assembledTransaction) {
 // src/contracts/registry/registry-domain-service.ts
 var COORDINATE_HEX_LENGTH = 64;
 function readCoordinateBytes(value) {
-  if (value instanceof Buffer12) {
+  if (value instanceof Buffer13) {
     return value;
   }
   if (value instanceof Uint8Array) {
-    return Buffer12.from(value);
+    return Buffer13.from(value);
   }
   return void 0;
 }
@@ -4196,8 +4678,8 @@ function parseRegistryLookupRecord(result) {
   return parseOptionSomeRecord(result);
 }
 function recordToLookupResult(record) {
-  const publicKeyXHex = Buffer12.from(record.public_key_x).toString("hex");
-  const publicKeyYHex = Buffer12.from(record.public_key_y).toString("hex");
+  const publicKeyXHex = Buffer13.from(record.public_key_x).toString("hex");
+  const publicKeyYHex = Buffer13.from(record.public_key_y).toString("hex");
   return {
     owner: record.owner,
     status: "registered",
@@ -4240,8 +4722,8 @@ async function registerPrivateAddressOnChain(input) {
   });
   const assembled = await client.register_private_address({
     owner: input.owner.trim(),
-    public_key_x: Buffer12.from(decoded.x.padStart(COORDINATE_HEX_LENGTH, "0"), "hex"),
-    public_key_y: Buffer12.from(decoded.y.padStart(COORDINATE_HEX_LENGTH, "0"), "hex")
+    public_key_x: Buffer13.from(decoded.x.padStart(COORDINATE_HEX_LENGTH, "0"), "hex"),
+    public_key_y: Buffer13.from(decoded.y.padStart(COORDINATE_HEX_LENGTH, "0"), "hex")
   });
   await runTtlPreflight(assembled);
   const sent = await assembled.signAndSend();
@@ -4256,7 +4738,7 @@ async function registerPrivateAddressOnChain(input) {
 import { StrKey as StrKey5 } from "@stellar/stellar-sdk";
 // src/transact/escrow/derived-escrow-recipient.ts
-import { Buffer as Buffer13 } from "buffer";
+import { Buffer as Buffer14 } from "buffer";
 import { StrKey as StrKey4 } from "@stellar/stellar-sdk";
 import {
   derivedEscrowKey,
@@ -4266,7 +4748,7 @@ import {
 var COORDINATE_HEX_LENGTH2 = 64;
 function stellarAccountToFieldLimbs(stellarAddress) {
   const pkRaw = StrKey4.decodeEd25519PublicKey(stellarAddress.trim());
-  const pkHex = Buffer13.from(pkRaw).toString("hex");
+  const pkHex = Buffer14.from(pkRaw).toString("hex");
   const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals2(pkHex);
   return { recipientHi: hi, recipientLo: lo };
 }
@@ -4351,7 +4833,7 @@ async function resolveTransferRecipientFromChain(input) {
 import { Api } from "@stellar/stellar-sdk/rpc";
 // src/rpc/soroban-transaction-meta.ts
-import { Address, StrKey as StrKey6 } from "@stellar/stellar-sdk";
+import { Address as Address2, StrKey as StrKey6 } from "@stellar/stellar-sdk";
 var BIGINT_SHIFT_64 = 64n;
 var TRANSACTION_META_SWITCH_SOROBAN_V3 = 3;
 var TRANSACTION_META_SWITCH_SOROBAN_V4 = 4;
@@ -4451,8 +4933,8 @@ function transferPartyAddressesFromTopics(topics) {
       return void 0;
     }
     return {
-      from: Address.fromScVal(fromTopic).toString(),
-      to: Address.fromScVal(toTopic).toString()
+      from: Address2.fromScVal(fromTopic).toString(),
+      to: Address2.fromScVal(toTopic).toString()
     };
   } catch {
     return void 0;
@@ -5158,7 +5640,7 @@ function createStellarPrivacyClientFromResolvedConfig(config) {
 }
 // src/transact/engine/default-factory.ts
-import { PrivacyPoolSDK as PrivacyPoolSDK3 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
+import { PrivacyPoolSDK as PrivacyPoolSDK4 } from "@arcanetech/stellar-privacy-pool-zk-sdk";
 // src/transact/pool/proof-types.ts
 function ciphertextArtifactsFromProof(proof) {
@@ -5173,9 +5655,15 @@ function ciphertextArtifactsFromProof(proof) {
 // src/transact/engine/prepare/deposit.ts
 var STROOPS_PER_UNIT = 10000000n;
 async function createAlignedDepositWithProof(parameters) {
+  const feeOutput = await quoteFeeOutputForPrepared(parameters);
+  const instructed = parameters.prepared.intent.amount;
+  const userAmount = instructed - (feeOutput?.requiredFee ?? 0n);
+  if (userAmount <= 0n) {
+    throw new Error("Required Fee leaves no spendable deposit note");
+  }
   const aligned = await parameters.poolService.createAlignedShieldCoinData({
     privateAddressStpl1: parameters.prepared.intent.to,
-    amountStroops: parameters.prepared.intent.amount,
+    amountStroops: userAmount,
     tokenAddress: parameters.tokenAddress
   });
   const poolClient = readPoolClientFactory(parameters.environment)({
@@ -5190,7 +5678,9 @@ async function createAlignedDepositWithProof(parameters) {
     coin: aligned.coin,
     depositScalarHex: aligned.depositScalarHex,
     merkleRootBytes: merkleTx.result,
-    tokenAddress: parameters.tokenAddress
+    tokenAddress: parameters.tokenAddress,
+    publicDepositStroops: instructed,
+    ...feeOutput ? { feeOutput } : {}
   });
   return { ...aligned, proof };
 }
@@ -5209,8 +5699,8 @@ async function prepareDepositOperation(prepared, environment, poolService) {
     privateAddress: prepared.intent.to,
     assetId: prepared.intent.asset,
     poolContract: environment.network.poolContract,
-    amount: prepared.intent.amount,
-    amountDisplay: Number(prepared.intent.amount) / Number(STROOPS_PER_UNIT),
+    amount: BigInt(depositProof.coin.value),
+    amountDisplay: Number(depositProof.coin.value) / Number(STROOPS_PER_UNIT),
     commitmentHex: depositProof.commitment_hex,
     coin: depositProof.coin,
     depositScalarHex: depositProof.depositScalarHex,
@@ -5226,7 +5716,11 @@ async function prepareDepositOperation(prepared, environment, poolService) {
     depositScalarHex: depositProof.depositScalarHex,
     precommitementHex: depositProof.precommitementHex,
     commitmentHex: depositProof.commitment_hex,
-    walletPublicKey
+    walletPublicKey,
+    zkConfigNonce: zkConfigNonceForFeeBearingKind({
+      kind: "deposit",
+      ...configuredNonceSpread(environment.zkConfigNonce)
+    })
   });
 }
@@ -5400,9 +5894,6 @@ function escrowOutputFields(input) {
     recipientLo: input.escrowSend.recipientLo
   };
 }
-function paddingDepositPair(recipientDeposit) {
-  return [recipientDeposit, "dummy"];
-}
 async function buildChangeDepositPair(parameters) {
   const changeSlot = await getPrivacyPoolService().buildAlignedDepositSlot({
     privateAddressStpl1: parameters.selfPrivateAddressStpl1ForChange.trim(),
@@ -5419,34 +5910,54 @@ async function buildChangeDepositPair(parameters) {
     }
   };
 }
+function recipientOnlyDeposits(recipientDeposit, hasFeeOutput) {
+  if (hasFeeOutput) {
+    return [recipientDeposit];
+  }
+  return [recipientDeposit, "dummy"];
+}
+async function depositsWithoutFee(input) {
+  if (input.changeStroops <= ZERO_STROOPS) {
+    return {
+      deposits: recipientOnlyDeposits(input.recipientDeposit, input.hasFeeOutput)
+    };
+  }
+  return buildChangeDepositPair({
+    selfPrivateAddressStpl1ForChange: input.selfPrivateAddressStpl1ForChange,
+    changeStroops: input.changeStroops,
+    tokenAddress: input.tokenAddress,
+    recipientDeposit: input.recipientDeposit
+  });
+}
 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,
+    privateAddressStpl1: parameters.recipientPrivateAddressStpl1.trim(),
     amountStroops: parameters.transferStroops,
     tokenAddress: parameters.tokenAddress,
     ...escrowOutputFields(escrow)
   });
-  if (parameters.changeStroops <= ZERO_STROOPS) {
-    return {
-      recipientSlot,
-      deposits: paddingDepositPair(recipientSlot.deposit)
-    };
-  }
-  const changeResult = await buildChangeDepositPair({
-    selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
+  const withoutFee = await depositsWithoutFee({
+    recipientDeposit: recipientSlot.deposit,
     changeStroops: parameters.changeStroops,
+    selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
+    tokenAddress: parameters.tokenAddress,
+    hasFeeOutput: (parameters.feeOutput?.requiredFee ?? ZERO_STROOPS) > ZERO_STROOPS
+  });
+  const withFee = await appendFeeOutputSlot({
+    deposits: withoutFee.deposits,
     tokenAddress: parameters.tokenAddress,
-    recipientDeposit: recipientSlot.deposit
+    buildAlignedDepositSlot: (aligned) => getPrivacyPoolService().buildAlignedDepositSlot(aligned),
+    ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
   });
   return {
     recipientSlot,
-    deposits: changeResult.deposits,
-    changeCoin: changeResult.changeCoin
+    deposits: withFee.deposits,
+    ..."changeCoin" in withoutFee ? { changeCoin: withoutFee.changeCoin } : {},
+    ...withFee.feeCoin ? { feeCoin: withFee.feeCoin } : {}
   };
 }
@@ -5499,14 +6010,15 @@ function sweepOutputOwnerFields(parameters) {
   return { sweepOutputOwnerPubX, sweepOutputOwnerPubY };
 }
 async function buildTransferDepositsAndPublicInput(parameters) {
-  const { recipientSlot, deposits, changeCoin } = await buildRecipientAndOptionalChangeDeposits({
+  const { recipientSlot, deposits, changeCoin, feeCoin } = await buildRecipientAndOptionalChangeDeposits({
     recipientPrivateAddressStpl1: parameters.recipientPrivateAddressStpl1,
     transferStroops: parameters.transferStroops,
     changeStroops: parameters.changeStroops,
     selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
     tokenAddress: parameters.tokenAddress,
     ...parameters.escrowSend ? { escrowSend: parameters.escrowSend } : {},
-    ...parameters.escrowClaimantLimbs ? { escrowClaimantLimbs: parameters.escrowClaimantLimbs } : {}
+    ...parameters.escrowClaimantLimbs ? { escrowClaimantLimbs: parameters.escrowClaimantLimbs } : {},
+    ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
   });
   const publicInput = withTokenAddressPublicInputs(
     {
@@ -5521,6 +6033,7 @@ async function buildTransferDepositsAndPublicInput(parameters) {
     recipientSlot,
     deposits,
     ...changeCoin ? { changeCoin } : {},
+    ...feeCoin ? { feeCoin } : {},
     publicInput
   };
 }
@@ -5536,7 +6049,8 @@ async function buildSenderTransferDepositsAndPublicInput(parameters) {
       parameters.senderPrivKeyScalarHex
     ),
     ...parameters.escrowSend ? { escrowSend: parameters.escrowSend } : {},
-    ...parameters.escrowClaimantLimbs ? { escrowClaimantLimbs: parameters.escrowClaimantLimbs } : {}
+    ...parameters.escrowClaimantLimbs ? { escrowClaimantLimbs: parameters.escrowClaimantLimbs } : {},
+    ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
   });
 }
@@ -5560,11 +6074,20 @@ function stampDualWithdrawLegs(legs, parameters) {
     }
   };
 }
-function buildDualTransferApplicationIds(sdk, applicationId, changeCoin) {
+function buildDualTransferApplicationIds(sdk, applicationId, changeCoin, feeCoin) {
+  const outputIds = [applicationId];
+  if (changeCoin) {
+    outputIds.push(applicationId);
+  } else if (!feeCoin) {
+    outputIds.push("0");
+  }
+  if (feeCoin) {
+    outputIds.push(applicationId);
+  }
   return buildApplicationIdHints({
     sdk,
     inputIds: [applicationId, applicationId],
-    outputIds: [applicationId, changeCoin ? applicationId : "0"]
+    outputIds
   });
 }
 async function proveDualConfidentialTransfer(parameters) {
@@ -5584,16 +6107,24 @@ async function proveDualConfidentialTransfer(parameters) {
     audit
   );
 }
-async function buildDualTransferProofContext(parameters, applicationId, sdk) {
+function dualTransferChangeStroops(parameters) {
   const totalNotes = BigInt(parameters.coinA.value) + BigInt(parameters.coinB.value);
-  const changeStroops = changeStroopsAfterDualTransfer(
-    parameters.transferStroops,
-    totalNotes
-  );
+  if (parameters.transferStroops < MIN_CONFIDENTIAL_TRANSFER_STROOPS) {
+    throw new Error("Transfer amount must be positive");
+  }
+  const changeStroops = remainingAfterRequiredFee({
+    available: totalNotes,
+    instructed: parameters.transferStroops,
+    requiredFee: parameters.feeOutput?.requiredFee ?? 0n
+  });
   requireChangeRecipientWhenPartial(
     changeStroops,
     parameters.selfPrivateAddressStpl1ForChange
   );
+  return changeStroops;
+}
+async function buildDualTransferProofContext(parameters, applicationId, sdk) {
+  const changeStroops = dualTransferChangeStroops(parameters);
   const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
     parameters.senderPrivKeyScalarHex
   );
@@ -5620,15 +6151,21 @@ async function buildDualTransferProofContext(parameters, applicationId, sdk) {
     selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
     tokenAddress: parameters.tokenAddress,
     stateRoot: legA.witness.stateRoot,
-    ...confidentialEscrowFields(parameters)
+    ...confidentialEscrowFields(parameters),
+    ...parameters.feeOutput ? { feeOutput: parameters.feeOutput } : {}
   });
   return { legA, legB, applicationId, ...transferInputs };
 }
 async function prepareConfidentialTransferProofDual(parameters) {
   const poolService = getPrivacyPoolService();
-  const sdk = await poolService.getInitializedSdk();
+  const sdk = await poolService.getInitializedSdk(
+    poolService.feeBearingZkConfigNonce({
+      kind: "transfer",
+      ...parameters.escrowClaimantLimbs ? { spendSource: "escrow" } : {}
+    })
+  );
   const applicationId = poolService.getApplicationId();
-  const { legA, legB, recipientSlot, deposits, changeCoin, publicInput } = await buildDualTransferProofContext(parameters, applicationId, sdk);
+  const { legA, legB, recipientSlot, deposits, changeCoin, feeCoin, publicInput } = await buildDualTransferProofContext(parameters, applicationId, sdk);
   const auditPublicKey = poolService.getAuditPublicKey();
   const proof = await (auditPublicKey ? proveDualConfidentialTransfer({
     sdk,
@@ -5651,7 +6188,8 @@ async function prepareConfidentialTransferProofDual(parameters) {
     applicationIdsPlaintext: buildDualTransferApplicationIds(
       sdk,
       applicationId,
-      changeCoin
+      changeCoin,
+      feeCoin
     ),
     recipientCoin: generatedOutputCoinFromSlot(recipientSlot),
     ...changeCoin ? { changeCoin } : {}
@@ -5659,22 +6197,32 @@ async function prepareConfidentialTransferProofDual(parameters) {
 }
 // src/transact/proofs/confidential/single.ts
-function validateSingleCoinTransferAmounts(transferStroops, noteStroops, selfPrivateAddressStpl1ForChange) {
+function validateSingleCoinTransferAmounts(transferStroops, noteStroops, selfPrivateAddressStpl1ForChange, requiredFee) {
   if (transferStroops < MIN_CONFIDENTIAL_TRANSFER_STROOPS) {
     throw new Error("Transfer amount must be positive");
   }
-  if (transferStroops > noteStroops) {
-    throw new Error("Transfer amount exceeds note value");
-  }
-  const changeStroops = noteStroops - transferStroops;
+  const changeStroops = remainingAfterRequiredFee({
+    available: noteStroops,
+    instructed: transferStroops,
+    requiredFee
+  });
   requireChangeRecipientWhenPartial(changeStroops, selfPrivateAddressStpl1ForChange);
   return changeStroops;
 }
-function buildSingleTransferApplicationIds(sdk, applicationId, changeCoin) {
+function buildSingleTransferApplicationIds(sdk, applicationId, changeCoin, feeCoin) {
+  const outputIds = [applicationId];
+  if (changeCoin) {
+    outputIds.push(applicationId);
+  } else if (!feeCoin) {
+    outputIds.push("0");
+  }
+  if (feeCoin) {
+    outputIds.push(applicationId);
+  }
   return buildApplicationIdHints({
     sdk,
     inputIds: [applicationId],
-    outputIds: [applicationId, changeCoin ? applicationId : "0"]
+    outputIds
   });
 }
 function buildTransferAuditParameters(parameters) {
@@ -5700,11 +6248,25 @@ function confidentialEscrowFields2(input) {
     ...input.escrowClaimantLimbs ? { escrowClaimantLimbs: input.escrowClaimantLimbs } : {}
   };
 }
+function transferDepositInputFromProof(input, changeStroops, stateRoot) {
+  return {
+    senderPrivKeyScalarHex: input.senderPrivKeyScalarHex,
+    recipientPrivateAddressStpl1: input.recipientPrivateAddressStpl1,
+    transferStroops: input.transferStroops,
+    changeStroops,
+    selfPrivateAddressStpl1ForChange: input.selfPrivateAddressStpl1ForChange,
+    tokenAddress: input.tokenAddress,
+    stateRoot,
+    ...confidentialEscrowFields2(input),
+    ...input.feeOutput ? { feeOutput: input.feeOutput } : {}
+  };
+}
 async function buildTransferProofInputs(parameters) {
   const changeStroops = validateSingleCoinTransferAmounts(
     parameters.input.transferStroops,
     parameters.noteStroops,
-    parameters.input.selfPrivateAddressStpl1ForChange
+    parameters.input.selfPrivateAddressStpl1ForChange,
+    parameters.input.feeOutput?.requiredFee ?? 0n
   );
   const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
     parameters.input.senderPrivKeyScalarHex
@@ -5723,31 +6285,30 @@ async function buildTransferProofInputs(parameters) {
     withdrawObject,
     sweepWithdrawStamp(confidentialEscrowFields2(parameters.input))
   );
-  const { recipientSlot, deposits, changeCoin, publicInput } = await buildSenderTransferDepositsAndPublicInput({
-    senderPrivKeyScalarHex: parameters.input.senderPrivKeyScalarHex,
-    recipientPrivateAddressStpl1: parameters.input.recipientPrivateAddressStpl1,
-    transferStroops: parameters.input.transferStroops,
-    changeStroops,
-    selfPrivateAddressStpl1ForChange: parameters.input.selfPrivateAddressStpl1ForChange,
-    tokenAddress: parameters.input.tokenAddress,
-    stateRoot: witness.stateRoot,
-    ...confidentialEscrowFields2(parameters.input)
-  });
+  const { recipientSlot, deposits, changeCoin, feeCoin, publicInput } = await buildSenderTransferDepositsAndPublicInput(
+    transferDepositInputFromProof(parameters.input, changeStroops, witness.stateRoot)
+  );
   return {
     witness,
     withdrawObject: stampedWithdraw,
     recipientSlot,
     deposits,
     changeCoin,
+    feeCoin,
     publicInput
   };
 }
 async function prepareConfidentialTransferProof(parameters) {
   const poolService = getPrivacyPoolService();
-  const sdk = await poolService.getInitializedSdk();
+  const sdk = await poolService.getInitializedSdk(
+    poolService.feeBearingZkConfigNonce({
+      kind: "transfer",
+      ...parameters.escrowClaimantLimbs ? { spendSource: "escrow" } : {}
+    })
+  );
   const applicationId = poolService.getApplicationId();
   const noteStroops = BigInt(parameters.coin.value);
-  const { withdrawObject, recipientSlot, deposits, changeCoin, publicInput } = await buildTransferProofInputs({
+  const { withdrawObject, recipientSlot, deposits, changeCoin, feeCoin, publicInput } = await buildTransferProofInputs({
     sdk,
     applicationId,
     input: parameters,
@@ -5770,7 +6331,8 @@ async function prepareConfidentialTransferProof(parameters) {
     applicationIdsPlaintext: buildSingleTransferApplicationIds(
       sdk,
       applicationId,
-      changeCoin
+      changeCoin,
+      feeCoin
     ),
     recipientCoin: generatedOutputCoinFromSlot(recipientSlot),
     ...changeCoin ? { changeCoin } : {}
@@ -5793,7 +6355,12 @@ function proofEscrowFields(input) {
 }
 async function buildSingleTransferProofAtExecute(input) {
   const context = await buildSpendProofContextAtExecute(input);
-  const changeStroops = BigInt(context.coin.value) - input.prepared.intent.amount;
+  const feeOutput = await quoteFeeOutputForPrepared({
+    prepared: input.prepared,
+    environment: input.environment,
+    tokenAddress: context.tokenAddress
+  });
+  const changeStroops = BigInt(context.coin.value) - input.prepared.intent.amount - (feeOutput?.requiredFee ?? 0n);
   const proof = await prepareConfidentialTransferProof({
     coin: context.coin,
     state: { commitments: context.commitments },
@@ -5806,7 +6373,8 @@ async function buildSingleTransferProofAtExecute(input) {
     recipientPrivateAddressStpl1: context.recipientPrivateAddressStpl1,
     selfPrivateAddressStpl1ForChange: readChangeRecipient(input, changeStroops),
     tokenAddress: context.tokenAddress,
-    ...proofEscrowFields(input)
+    ...proofEscrowFields(input),
+    ...feeOutput ? { feeOutput } : {}
   });
   return { context, proof };
 }
@@ -5823,7 +6391,12 @@ async function buildDualTransferProofAtExecute(input) {
     commitments: context.commitments
   });
   const totalNotes = BigInt(context.coin.value) + BigInt(secondary.coin.value);
-  const changeStroops = totalNotes - input.prepared.intent.amount;
+  const feeOutput = await quoteFeeOutputForPrepared({
+    prepared: input.prepared,
+    environment: input.environment,
+    tokenAddress: context.tokenAddress
+  });
+  const changeStroops = totalNotes - input.prepared.intent.amount - (feeOutput?.requiredFee ?? 0n);
   const proof = await prepareConfidentialTransferProofDual({
     coinA: context.coin,
     coinB: secondary.coin,
@@ -5841,7 +6414,8 @@ async function buildDualTransferProofAtExecute(input) {
     recipientPrivateAddressStpl1: context.recipientPrivateAddressStpl1,
     selfPrivateAddressStpl1ForChange: readChangeRecipient(input, changeStroops),
     tokenAddress: context.tokenAddress,
-    ...proofEscrowFields(input)
+    ...proofEscrowFields(input),
+    ...feeOutput ? { feeOutput } : {}
   });
   return { context, proof };
 }
@@ -5973,11 +6547,17 @@ async function runTransferFinalizeSteps(input) {
     walletPublicKey: input.walletPublicKey,
     ...recipient.escrowSend ? { escrowSendPrivateAddress: recipient.recipientPrivateAddressStpl1 } : {}
   });
-  return buildTransferFinalizeArtifacts({
-    proof,
-    context,
-    ...sweepFinalizeStamp(input.prepared, recipient)
-  });
+  return {
+    ...buildTransferFinalizeArtifacts({
+      proof,
+      context,
+      ...sweepFinalizeStamp(input.prepared, recipient)
+    }),
+    zkConfigNonce: zkConfigNonceForFeeBearingKind({
+      ...feeOutputKindFromPrepared(input.prepared),
+      ...configuredNonceSpread(input.environment.zkConfigNonce)
+    })
+  };
 }
 function sweepArtifactStamp(artifacts) {
   return {
@@ -6005,6 +6585,24 @@ async function finalizeTransferAtExecute(prepared, environment) {
   return runTransferFinalizeSteps({ prepared, environment, walletPublicKey });
 }
+// src/transact/engine/withdraw-fee.ts
+async function withdrawFeeProofFields(input) {
+  const feeOutput = await quoteFeeOutputForPrepared({
+    prepared: input.prepared,
+    environment: input.environment,
+    tokenAddress: input.tokenAddress
+  });
+  const changeStroops = remainingAfterRequiredFee({
+    available: input.available,
+    instructed: input.prepared.intent.amount,
+    requiredFee: feeOutput?.requiredFee ?? 0n
+  });
+  return {
+    ...feeOutput ? { feeOutput } : {},
+    ...changeStroops > 0n ? { changePrivateAddressStpl1: input.withdrawFrom } : {}
+  };
+}
 // src/transact/engine/execute.ts
 function enrichWithdrawOutputRecords(prepared, proof) {
   if (!proof.changeCoin || prepared.outputRecords.length === 0) {
@@ -6020,7 +6618,7 @@ function enrichWithdrawOutputRecords(prepared, proof) {
     precommitementHex: changeCoin.precommitementHex
   }));
 }
-function buildWithdrawFinalizeArtifacts(proof, context) {
+function buildWithdrawFinalizeArtifacts(proof, context, environment) {
   return {
     proofHex: proof.proof_hex,
     publicHex: proof.public_hex,
@@ -6028,7 +6626,11 @@ function buildWithdrawFinalizeArtifacts(proof, context) {
     applicationIdsPlaintext: proof.applicationIdsPlaintext,
     tokenAddress: context.tokenAddress,
     walletPublicKey: context.walletPublicKey,
-    executeFinalizeRequired: false
+    executeFinalizeRequired: false,
+    zkConfigNonce: zkConfigNonceForFeeBearingKind({
+      kind: "withdraw",
+      ...configuredNonceSpread(environment.zkConfigNonce)
+    })
   };
 }
 async function finalizeSingleWithdrawAtExecute(prepared, environment, poolService, withdrawFrom) {
@@ -6037,7 +6639,13 @@ async function finalizeSingleWithdrawAtExecute(prepared, environment, poolServic
     environment,
     recipientPrivateAddressStpl1: withdrawFrom
   });
-  const changeStroops = BigInt(context.coin.value) - prepared.intent.amount;
+  const feeFields = await withdrawFeeProofFields({
+    prepared,
+    environment,
+    tokenAddress: context.tokenAddress,
+    available: BigInt(context.coin.value),
+    withdrawFrom
+  });
   const proof = await poolService.prepareWithdrawTransactProof({
     coin: context.coin,
     state: { commitments: context.commitments },
@@ -6048,11 +6656,24 @@ async function finalizeSingleWithdrawAtExecute(prepared, environment, poolServic
       yHex: context.ephemeral.yHex
     }),
     withdrawAmountStroops: prepared.intent.amount,
-    changePrivateAddressStpl1: changeStroops > 0n ? withdrawFrom : void 0,
-    tokenAddress: context.tokenAddress
+    changePrivateAddressStpl1: feeFields.changePrivateAddressStpl1,
+    tokenAddress: context.tokenAddress,
+    ...feeFields.feeOutput ? { feeOutput: feeFields.feeOutput } : {}
   });
   enrichWithdrawOutputRecords(prepared, proof);
-  return buildWithdrawFinalizeArtifacts(proof, context);
+  return buildWithdrawFinalizeArtifacts(proof, context, environment);
+}
+function dualWithdrawEphemeralKeys(input) {
+  return {
+    depositorEphemeralAKey: serializeEphemeralKeyString({
+      xHex: input.context.ephemeral.xHex,
+      yHex: input.context.ephemeral.yHex
+    }),
+    depositorEphemeralBKey: serializeEphemeralKeyString({
+      xHex: input.secondary.ephemeral.xHex,
+      yHex: input.secondary.ephemeral.yHex
+    })
+  };
 }
 async function finalizeDualWithdrawAtExecute(prepared, environment, poolService, withdrawFrom) {
   const [, secondaryRecord] = prepared.consumedRecords;
@@ -6070,28 +6691,27 @@ async function finalizeDualWithdrawAtExecute(prepared, environment, poolService,
     walletPublicKey: context.walletPublicKey,
     commitments: context.commitments
   });
-  const totalNotes = BigInt(context.coin.value) + BigInt(secondary.coin.value);
-  const changeStroops = totalNotes - prepared.intent.amount;
+  const feeFields = await withdrawFeeProofFields({
+    prepared,
+    environment,
+    tokenAddress: context.tokenAddress,
+    available: BigInt(context.coin.value) + BigInt(secondary.coin.value),
+    withdrawFrom
+  });
   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
-    }),
+    ...dualWithdrawEphemeralKeys({ context, secondary }),
     withdrawAmountStroops: prepared.intent.amount,
-    changePrivateAddressStpl1: changeStroops > 0n ? withdrawFrom : void 0,
-    tokenAddress: context.tokenAddress
+    changePrivateAddressStpl1: feeFields.changePrivateAddressStpl1,
+    tokenAddress: context.tokenAddress,
+    ...feeFields.feeOutput ? { feeOutput: feeFields.feeOutput } : {}
   });
   enrichWithdrawOutputRecords(prepared, proof);
-  return buildWithdrawFinalizeArtifacts(proof, context);
+  return buildWithdrawFinalizeArtifacts(proof, context, environment);
 }
 async function finalizeWithdrawAtExecute(prepared, environment, poolService) {
   if (prepared.kind !== "withdraw") {
@@ -6223,20 +6843,20 @@ async function waitForKytRegistration(parameters) {
 }
 // src/transact/kyt/passage/submit.ts
-import { Buffer as Buffer14 } from "buffer";
-import { Operation, TransactionBuilder, rpc as rpc3, xdr as xdr2 } from "@stellar/stellar-sdk";
+import { Buffer as Buffer15 } 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 xdr2.ScVal.scvBytes(Buffer14.from(passageId.replace(/^0x/, ""), "hex"));
+  return xdr3.ScVal.scvBytes(Buffer15.from(passageId.replace(/^0x/, ""), "hex"));
 }
 function approvalSignatureToBytes(signature) {
   const clean = signature.trim();
-  return /^(0x)?[0-9a-fA-F]{128}$/.test(clean) ? Buffer14.from(clean.replace(/^0x/i, ""), "hex") : Buffer14.from(clean, "base64");
+  return /^(0x)?[0-9a-fA-F]{128}$/.test(clean) ? Buffer15.from(clean.replace(/^0x/i, ""), "hex") : Buffer15.from(clean, "base64");
 }
 function signatureToScValue(signature) {
   const bytes = approvalSignatureToBytes(signature);
-  return xdr2.ScVal.scvBytes(bytes);
+  return xdr3.ScVal.scvBytes(bytes);
 }
 async function registerKytPassage(parameters) {
   const signTransaction = parameters.transactEnvironment.signTransaction;
@@ -6257,7 +6877,7 @@ async function registerKytPassage(parameters) {
       function: "register_passage",
       args: [
         passageIdToScValue(parameters.approval.passageId),
-        xdr2.ScVal.scvU32(parameters.approval.expiresAtLedger),
+        xdr3.ScVal.scvU32(parameters.approval.expiresAtLedger),
         signatureToScValue(parameters.approval.signature)
       ]
     })
@@ -6353,7 +6973,7 @@ async function requestKytPassageForPoolInteraction(input) {
   const applicationId = resolvePoolApplicationId(
     input.transactEnvironment.network.applicationId
   );
-  const zkConfigNonce = resolveZkConfigNonce(input.transactEnvironment);
+  const zkConfigNonce = input.zkConfigNonce ?? resolveZkConfigNonce(input.transactEnvironment);
   const applicationIdsPlaintext = input.applicationIdsPlaintext ?? buildApplicationIdHints2(
     applicationId,
     layoutForKnownNonce(zkConfigNonce).nAuditSlots
@@ -6382,12 +7002,12 @@ async function requestKytPassageForPoolInteraction(input) {
 // src/transact/submit/zk-config-ttl.ts
 import {
-  Address as Address2,
+  Address as Address3,
   Operation as Operation2,
   SorobanDataBuilder,
   TransactionBuilder as TransactionBuilder2,
   rpc as rpc4,
-  xdr as xdr3
+  xdr as xdr4
 } from "@stellar/stellar-sdk";
 var ZK_CONFIG_TTL_THRESHOLD_LEDGERS = 1e5;
 var ZK_CONFIG_TTL_EXTEND_TO_LEDGERS = 5e5;
@@ -6411,15 +7031,15 @@ async function waitForExtendFootprintTtlConfirmation(parameters) {
   throw new Error("ZK config TTL extension was not confirmed in time");
 }
 function zkConfigLedgerKey(contractId, nonce) {
-  const configKeyScValue = xdr3.ScVal.scvVec([
-    xdr3.ScVal.scvSymbol("Config"),
-    xdr3.ScVal.scvU64(xdr3.Uint64.fromString(nonce.toString()))
+  const configKeyScValue = xdr4.ScVal.scvVec([
+    xdr4.ScVal.scvSymbol("Config"),
+    xdr4.ScVal.scvU64(xdr4.Uint64.fromString(nonce.toString()))
   ]);
-  return xdr3.LedgerKey.contractData(
-    new xdr3.LedgerKeyContractData({
-      contract: new Address2(contractId).toScAddress(),
+  return xdr4.LedgerKey.contractData(
+    new xdr4.LedgerKeyContractData({
+      contract: new Address3(contractId).toScAddress(),
       key: configKeyScValue,
-      durability: xdr3.ContractDataDurability.persistent()
+      durability: xdr4.ContractDataDurability.persistent()
     })
   );
 }
@@ -6484,7 +7104,7 @@ async function extendZkConfigTtlIfNeeded(parameters) {
 }
 // src/transact/submit/pool-transact.ts
-import { Buffer as Buffer15 } from "buffer";
+import { Buffer as Buffer16 } from "buffer";
 async function submitPoolTransact(parameters) {
   await extendZkConfigTtlIfNeeded({
     sorobanRpcUrl: parameters.sorobanRpcUrl,
@@ -6497,9 +7117,9 @@ async function submitPoolTransact(parameters) {
   const assembledTransaction = await parameters.contractClient.transact({
     from: parameters.from,
     nonce: parameters.nonce,
-    proof_bytes: Buffer15.from(parameters.proofHex.replace(/^0x/iu, ""), "hex"),
-    pub_signals_bytes: Buffer15.from(parameters.publicHex.replace(/^0x/iu, ""), "hex"),
-    ciphertext_bytes: Buffer15.from(
+    proof_bytes: Buffer16.from(parameters.proofHex.replace(/^0x/iu, ""), "hex"),
+    pub_signals_bytes: Buffer16.from(parameters.publicHex.replace(/^0x/iu, ""), "hex"),
+    ciphertext_bytes: Buffer16.from(
       (parameters.ciphertextHex ?? "").replace(/^0x/iu, ""),
       "hex"
     ),
@@ -6525,6 +7145,10 @@ async function submitSorobanConfidentialTransfer(input) {
     networkPassphrase: input.networkPassphrase,
     sorobanRpcUrl: input.sorobanRpcUrl
   });
+  const nonce = transactNonceFromArtifacts(
+    input.zkConfigNonce === void 0 ? void 0 : { zkConfigNonce: input.zkConfigNonce },
+    input.transactEnvironment
+  );
   const approval = await requestKytPassageForPoolInteraction({
     owner: input.walletPublicKey,
     poolContract: input.contractId,
@@ -6533,6 +7157,7 @@ async function submitSorobanConfidentialTransfer(input) {
     ...input.ciphertextHex ? { ciphertextHex: input.ciphertextHex } : {},
     ...input.outputNoteEphemeralScalars ? { outputNoteEphemeralScalars: input.outputNoteEphemeralScalars } : {},
     ...input.applicationIdsPlaintext ? { applicationIdsPlaintext: input.applicationIdsPlaintext } : {},
+    ...input.zkConfigNonce === void 0 ? {} : { zkConfigNonce: input.zkConfigNonce },
     networkPassphrase: input.networkPassphrase,
     sorobanRpcUrl: input.sorobanRpcUrl,
     transactEnvironment: input.transactEnvironment
@@ -6541,7 +7166,7 @@ async function submitSorobanConfidentialTransfer(input) {
     contractClient: poolClient,
     contractId: input.contractId,
     from: input.walletPublicKey,
-    nonce: resolveZkConfigNonce(input.transactEnvironment),
+    nonce,
     proofHex: input.proofHex,
     publicHex: input.publicHex,
     ...input.ciphertextHex ? { ciphertextHex: input.ciphertextHex } : {},
@@ -6572,12 +7197,14 @@ async function submitPreparedDeposit(prepared, environment) {
     networkPassphrase: environment.network.networkPassphrase,
     sorobanRpcUrl: environment.network.rpcUrl
   });
+  const nonce = transactNonceFromArtifacts(artifacts, environment);
   const approval = await requestKytPassageForPoolInteraction({
     owner: artifacts.walletPublicKey,
     poolContract: environment.network.poolContract,
     proofHex: artifacts.proofHex,
     publicHex: artifacts.publicHex,
     ...optionalInspectCiphertext(artifacts),
+    ...artifacts.zkConfigNonce === void 0 ? {} : { zkConfigNonce: artifacts.zkConfigNonce },
     networkPassphrase: environment.network.networkPassphrase,
     sorobanRpcUrl: environment.network.rpcUrl,
     transactEnvironment: environment
@@ -6586,7 +7213,7 @@ async function submitPreparedDeposit(prepared, environment) {
     contractClient: poolClient,
     contractId: environment.network.poolContract,
     from: artifacts.walletPublicKey,
-    nonce: resolveZkConfigNonce(environment),
+    nonce,
     proofHex: artifacts.proofHex,
     publicHex: artifacts.publicHex,
     ...artifacts.ciphertextHex ? { ciphertextHex: artifacts.ciphertextHex } : {},
@@ -6607,6 +7234,7 @@ async function submitPreparedPoolTransact(prepared, environment) {
     proofHex: artifacts.proofHex,
     publicHex: artifacts.publicHex,
     ...optionalInspectCiphertext(artifacts),
+    ...artifacts.zkConfigNonce === void 0 ? {} : { zkConfigNonce: artifacts.zkConfigNonce },
     networkPassphrase: environment.network.networkPassphrase,
     sorobanRpcUrl: environment.network.rpcUrl,
     transactEnvironment: environment
@@ -6662,7 +7290,7 @@ async function privacyPoolInitOptions(assets, transactEnvironment) {
   };
 }
 async function createDefaultTransactEngine(assets, transactEnvironment) {
-  await PrivacyPoolSDK3.init(await privacyPoolInitOptions(assets, transactEnvironment));
+  await PrivacyPoolSDK4.init(await privacyPoolInitOptions(assets, transactEnvironment));
   if (transactEnvironment) {
     configurePrivacyPoolService(
       createPrivacyPoolService({