@arcanetech/privacy-sdk-stellar 0.5.2 → 0.5.4

package/dist/node.js

@@ -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 (transferStroops > totalNotes) {
-    throw new Error("Transfer amount exceeds combined note value");
+  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;
   }
-  return totalNotes - transferStroops;
+  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 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);
@@ -827,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;
   }
@@ -890,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(
@@ -944,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;
 }
@@ -964,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,
@@ -983,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,
@@ -1006,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(
@@ -1057,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,
@@ -1066,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,
@@ -1083,6 +1281,7 @@ async function prepareSingleWithdrawProofInputs(parameters) {
     primaryWithdraw,
     deposits,
     changeCoin,
+    feeCoin,
     publicInput,
     audit: buildPoolTransactionAuditParameters({
       applicationId: parameters.applicationId,
@@ -1092,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,
@@ -1107,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(
@@ -1132,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 } : {}
   };
@@ -1153,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";
@@ -1405,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) {
@@ -1421,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;
+    }
+    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);
     }
-    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;
   }
-  async getInitializedSdk() {
-    await this.ensureInit();
-    if (!this.sdk) {
-      throw new Error("SDK not initialized");
+  feeBearingZkConfigNonce(input) {
+    return zkConfigNonceForFeeBearingKind({
+      ...input,
+      ...configuredNonceSpread(this.zkConfigNonce)
+    });
+  }
+  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;
@@ -1489,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 proof = await sdk.proveTransaction(
-      publicInput,
-      padPublicLegsToLayout(
-        sdk,
-        buildPublicDepositLegs(parameters.tokenAddress, parameters.coin.value)
-      ),
-      padWithdrawSlotsToLayout(sdk, []),
-      padDepositSlotsToLayout(sdk, [deposit]),
-      audit
+    const sdk = await this.getInitializedSdk(
+      this.feeBearingZkConfigNonce({ kind: "deposit" })
     );
-    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(),
@@ -1562,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 } : {}
     });
   }
 };
@@ -2150,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 = [];
@@ -2203,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) {
@@ -5312,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) {
@@ -5327,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)({
@@ -5344,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 };
 }
@@ -5363,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,
@@ -5380,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)
+    })
   });
 }
 
@@ -5554,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(),
@@ -5573,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 } : {}
   };
 }
 
@@ -5653,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(
     {
@@ -5675,6 +6033,7 @@ async function buildTransferDepositsAndPublicInput(parameters) {
     recipientSlot,
     deposits,
     ...changeCoin ? { changeCoin } : {},
+    ...feeCoin ? { feeCoin } : {},
     publicInput
   };
 }
@@ -5690,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 } : {}
   });
 }
 
@@ -5714,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) {
@@ -5738,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
   );
@@ -5774,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,
@@ -5805,7 +6188,8 @@ async function prepareConfidentialTransferProofDual(parameters) {
     applicationIdsPlaintext: buildDualTransferApplicationIds(
       sdk,
       applicationId,
-      changeCoin
+      changeCoin,
+      feeCoin
     ),
     recipientCoin: generatedOutputCoinFromSlot(recipientSlot),
     ...changeCoin ? { changeCoin } : {}
@@ -5813,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) {
@@ -5854,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
@@ -5877,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,
@@ -5924,7 +6331,8 @@ async function prepareConfidentialTransferProof(parameters) {
     applicationIdsPlaintext: buildSingleTransferApplicationIds(
       sdk,
       applicationId,
-      changeCoin
+      changeCoin,
+      feeCoin
     ),
     recipientCoin: generatedOutputCoinFromSlot(recipientSlot),
     ...changeCoin ? { changeCoin } : {}
@@ -5947,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 },
@@ -5960,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 };
 }
@@ -5977,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,
@@ -5995,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 };
 }
@@ -6127,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 {
@@ -6159,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) {
@@ -6174,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,
@@ -6182,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) {
@@ -6191,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 },
@@ -6202,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;
@@ -6224,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") {
@@ -6507,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
@@ -6679,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,
@@ -6687,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
@@ -6695,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 } : {},
@@ -6726,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
@@ -6740,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 } : {},
@@ -6761,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
@@ -6816,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({