@arcanetech/privacy-sdk-stellar 0.2.0

package/dist/transact/index.js

@@ -0,0 +1,4163 @@
+// src/transact/pool/service.ts
+import {
+  decodeDecodedEphemeralKey,
+  randomFrDecimal253,
+  scalarHexToFrDecimal as scalarHexToFrDecimal2
+} from "@auditable/privacy-pool-zk-sdk";
+
+// src/transact/merkle/field-decimal.ts
+import { Buffer as Buffer2 } 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 = Buffer2.from(root).toString("hex");
+  return (BigInt(`0x${hex}`) % BN254).toString(DECIMAL_STRING_RADIX);
+}
+
+// src/transact/private-address/codec.ts
+import {
+  buildStealthAddressSignMessage,
+  decodeStealthAddress,
+  encodeStealthAddress,
+  recipientPublicKeysDecimalFromStealthAddress
+} from "@auditable/privacy-pool-zk-sdk";
+import { DEFAULT_STEALTH_SIGN_NONCE } from "@auditable/privacy-pool-zk-sdk";
+function buildPrivateAddressSignMessage(publicKey, nonce) {
+  const buildMessage = buildStealthAddressSignMessage;
+  return buildMessage(publicKey, nonce);
+}
+function decodePrivateAddress(value) {
+  const decodeAddress = decodeStealthAddress;
+  return decodeAddress(value);
+}
+function encodePrivateAddress(decoded) {
+  const encodeAddress = encodeStealthAddress;
+  return encodeAddress(decoded);
+}
+function encodePrivateAddressFromHexCoordinates(publicKeyXHex, publicKeyYHex) {
+  return encodePrivateAddress(
+    Object.fromEntries([
+      ["x", publicKeyXHex],
+      ["y", publicKeyYHex]
+    ])
+  );
+}
+function recipientPublicKeysDecimalFromPrivateAddress(value) {
+  const readPublicKeys = recipientPublicKeysDecimalFromStealthAddress;
+  return readPublicKeys(value);
+}
+function privateAddressSdk(sdk) {
+  const generator = sdk.generateStealthAddressFromStellarSignature;
+  if (typeof generator !== "function") {
+    throw new TypeError(
+      "Missing privacy pool SDK method: generateStealthAddressFromStellarSignature"
+    );
+  }
+  return {
+    generatePrivateAddressFromStellarSignature: (signature) => generator.call(sdk, signature)
+  };
+}
+
+// src/transact/proofs/withdraw/transact-proof.ts
+import { withdrawObjectFromMerkleWitness as withdrawObjectFromMerkleWitness2 } from "@auditable/privacy-pool-zk-sdk";
+
+// src/transact/proofs/transaction-input.ts
+import { Buffer as Buffer4 } from "buffer";
+import { StrKey as StrKey2 } from "@stellar/stellar-sdk";
+
+// src/transact/stellar/token-contract.ts
+import { Buffer as Buffer3 } 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(Buffer3.from(hexPayload, "hex"));
+}
+function normalizeSorobanContractId(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Contract ID is empty");
+  }
+  if (StrKey.isValidContract(trimmed)) {
+    return trimmed;
+  }
+  const hexMatch = CONTRACT_ID_HEX.exec(trimmed);
+  const hexPayload = hexMatch?.[1];
+  if (hexPayload !== void 0 && hexPayload.length === CONTRACT_ID_HEX_CHAR_LENGTH) {
+    return encodeContractFromHex(hexPayload);
+  }
+  throw new Error(`Invalid Soroban contract address: ${trimmed}`);
+}
+function resolveTokenContractId(tokenContractRaw) {
+  const raw = tokenContractRaw?.trim();
+  if (!raw) {
+    throw new Error("Selected asset has no client contract");
+  }
+  return normalizeSorobanContractId(raw);
+}
+
+// src/transact/proofs/transaction-input.ts
+var CONTRACT_ADDRESS_HALF_BYTES = 16;
+var CONTRACT_ADDRESS_BYTES = 32;
+function bytes16ToDecimal(bytes) {
+  return BigInt(`0x${Buffer4.from(bytes).toString("hex")}`).toString();
+}
+function decimalToBytes16(value) {
+  const hex = BigInt(value).toString(16).padStart(CONTRACT_ADDRESS_HALF_BYTES * 2, "0");
+  if (hex.length > CONTRACT_ADDRESS_HALF_BYTES * 2) {
+    throw new Error("Asset leg does not fit into 16 bytes.");
+  }
+  return Buffer4.from(hex, "hex");
+}
+function tokenAddressFrParts(tokenAddress) {
+  const normalized = resolveTokenContractId(tokenAddress);
+  const payload = StrKey2.decodeContract(normalized);
+  const hi = bytes16ToDecimal(payload.subarray(0, CONTRACT_ADDRESS_HALF_BYTES));
+  const lo = bytes16ToDecimal(
+    payload.subarray(CONTRACT_ADDRESS_HALF_BYTES, CONTRACT_ADDRESS_BYTES)
+  );
+  return { hi, lo };
+}
+function withTokenAddressPublicInputs(base, tokenAddress) {
+  const { hi, lo } = tokenAddressFrParts(tokenAddress);
+  return {
+    ...base,
+    tokenAddressHi: hi,
+    tokenAddressLo: lo
+  };
+}
+function tokenAddressToAssetLeg(tokenAddress) {
+  const { hi, lo } = tokenAddressFrParts(tokenAddress);
+  return [hi, lo];
+}
+function assetLegToTokenAddress(assetHi, assetLo) {
+  const payload = Buffer4.concat([decimalToBytes16(assetHi), decimalToBytes16(assetLo)]);
+  return StrKey2.encodeContract(payload);
+}
+function buildZeroPublicLegs() {
+  return {
+    publicWithdrawnAssets: [["0", "0"]],
+    publicDepositedAssets: [["0", "0"]],
+    publicDeposits: ["0"],
+    publicWithdrawals: ["0"]
+  };
+}
+function buildPublicDepositLegs(tokenAddress, amount) {
+  const legs = buildZeroPublicLegs();
+  return {
+    ...legs,
+    publicDepositedAssets: [tokenAddressToAssetLeg(tokenAddress)],
+    publicDeposits: [amount]
+  };
+}
+function buildPublicWithdrawLegs(tokenAddress, amount) {
+  const legs = buildZeroPublicLegs();
+  return {
+    ...legs,
+    publicWithdrawnAssets: [tokenAddressToAssetLeg(tokenAddress)],
+    publicWithdrawals: [amount]
+  };
+}
+
+// src/transact/proofs/confidential/helpers.ts
+import {
+  ed25519PubkeyPayloadHexToWithdrawFrDecimals,
+  withdrawObjectFromMerkleWitness
+} from "@auditable/privacy-pool-zk-sdk";
+import { StrKey as StrKey3 } from "@stellar/stellar-sdk";
+import { Buffer as Buffer5 } from "buffer";
+
+// src/transact/encoding/priv-key-scalar-from-recipient-hex.ts
+import { BN254_BABYJUB_SCALAR_MAX_EXCLUSIVE } from "@auditable/privacy-pool-zk-sdk";
+var SCALAR_HEX_CHAR_LENGTH = 64;
+var DECIMAL_RADIX = 10;
+var BIGINT_ONE = 1n;
+function normalizeRecipientScalarHex(hexInput) {
+  const trimmed = hexInput.trim().replace(/^0x/iu, "");
+  if (!/^[0-9a-f]*$/iu.test(trimmed)) {
+    throw new Error("recipient scalar hex must be hexadecimal");
+  }
+  const withLeadingNibble = trimmed.length % 2 === 0 ? trimmed : `0${trimmed}`;
+  const lower = withLeadingNibble.toLowerCase();
+  const padded = lower.padStart(SCALAR_HEX_CHAR_LENGTH, "0").slice(-SCALAR_HEX_CHAR_LENGTH);
+  if (padded.length !== SCALAR_HEX_CHAR_LENGTH) {
+    throw new Error(
+      `recipient scalar hex must fit 32 bytes (${SCALAR_HEX_CHAR_LENGTH} hex chars)`
+    );
+  }
+  return padded;
+}
+function privKeyScalarDecimalFromRecipientScalarHex(hexInput) {
+  const hex = normalizeRecipientScalarHex(hexInput);
+  const value = BigInt(`0x${hex}`);
+  const mask = BN254_BABYJUB_SCALAR_MAX_EXCLUSIVE - BIGINT_ONE;
+  return (value & mask).toString(DECIMAL_RADIX);
+}
+
+// src/transact/proofs/confidential/helpers.ts
+var MIN_CONFIDENTIAL_TRANSFER_STROOPS = 1n;
+var ZERO_STROOPS = 0n;
+function leafEphemeralCoords(xHex, yHex) {
+  const coords = {};
+  Object.defineProperty(coords, "x", {
+    value: xHex,
+    enumerable: true,
+    writable: true
+  });
+  Object.defineProperty(coords, "y", {
+    value: yHex,
+    enumerable: true,
+    writable: true
+  });
+  return coords;
+}
+function withdrawWitnessForCoin(parameters) {
+  const { sdk, coin, state, xHex, yHex } = parameters;
+  const witness = sdk.buildWithdrawMerkleWitness(coin, state);
+  const withdrawApplicationId = coin.application_id ?? parameters.applicationId;
+  const withdrawObject = withdrawObjectFromMerkleWitness(
+    witness,
+    leafEphemeralCoords(xHex, yHex),
+    withdrawApplicationId
+  );
+  return { witness, withdrawObject };
+}
+function dualWithdrawLegsWithSharedRoot(parameters) {
+  const legA = withdrawWitnessForCoin({
+    sdk: parameters.sdk,
+    coin: parameters.coinA,
+    state: parameters.state,
+    xHex: parameters.ephemeralA.xHex,
+    yHex: parameters.ephemeralA.yHex,
+    applicationId: parameters.applicationId
+  });
+  const legB = withdrawWitnessForCoin({
+    sdk: parameters.sdk,
+    coin: parameters.coinB,
+    state: parameters.state,
+    xHex: parameters.ephemeralB.xHex,
+    yHex: parameters.ephemeralB.yHex,
+    applicationId: parameters.applicationId
+  });
+  if (legA.witness.stateRoot !== legB.witness.stateRoot) {
+    throw new Error("Merkle state root mismatch between input coins");
+  }
+  return { legA, legB };
+}
+function senderWithdrawFrAndScalar(parameters) {
+  const pkRaw = StrKey3.decodeEd25519PublicKey(parameters.senderGAddress);
+  const pkHex = Buffer5.from(pkRaw).toString("hex");
+  const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals(pkHex);
+  const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
+    parameters.senderPrivKeyScalarHex
+  );
+  return { hi, lo, privKeyScalar };
+}
+function requireChangeRecipientWhenPartial(changeStroops, selfPrivateAddressStpl1ForChange) {
+  if (changeStroops > ZERO_STROOPS) {
+    const stpl1 = selfPrivateAddressStpl1ForChange?.trim() ?? "";
+    if (!stpl1) {
+      throw new Error(
+        "Private address is required to receive the remaining balance after a partial transfer"
+      );
+    }
+  }
+}
+function changeStroopsAfterDualTransfer(transferStroops, totalNotes) {
+  if (transferStroops < MIN_CONFIDENTIAL_TRANSFER_STROOPS) {
+    throw new Error("Transfer amount must be positive");
+  }
+  if (transferStroops > totalNotes) {
+    throw new Error("Transfer amount exceeds combined note value");
+  }
+  return totalNotes - transferStroops;
+}
+
+// src/transact/audit/parameters.ts
+import {
+  DEMO_AUDIT_PUBLIC_KEY,
+  resolveTransactionAuditParams
+} from "@auditable/privacy-pool-zk-sdk";
+import { Buffer as Buffer6 } from "buffer";
+var UNCOMPRESSED_PREFIX = "04";
+var UNCOMPRESSED_HEX_LENGTH = 130;
+var XY_HEX_LENGTH = 128;
+var X_OFFSET_END = 32;
+var Y_OFFSET_START = 32;
+var Y_OFFSET_END = 64;
+var DECIMAL_RADIX2 = 10;
+var BN254_FR_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+var BABYJUBJUB_A = 168700n;
+var BABYJUBJUB_D = 168696n;
+var BABYJUB_CURVE_ONE = 1n;
+function passesBabyJubCurveCheck(coordinateX, coordinateY) {
+  const xSquared = coordinateX * coordinateX % BN254_FR_MODULUS;
+  const ySquared = coordinateY * coordinateY % BN254_FR_MODULUS;
+  const lhs = (BABYJUBJUB_A * xSquared + ySquared) % BN254_FR_MODULUS;
+  const rhs = (BABYJUB_CURVE_ONE + BABYJUBJUB_D * xSquared * ySquared) % BN254_FR_MODULUS;
+  return lhs === rhs;
+}
+function parseAuditPublicKeyFromEnvHex(raw) {
+  const normalized = raw.replace(/^0x/i, "");
+  const payload = normalized.length === UNCOMPRESSED_HEX_LENGTH && normalized.startsWith(UNCOMPRESSED_PREFIX) ? normalized.slice(UNCOMPRESSED_PREFIX.length) : normalized;
+  if (payload.length !== XY_HEX_LENGTH || !/^[\da-fA-F]+$/.test(payload)) {
+    throw new Error(
+      "Audit public key must be uncompressed 65-byte hex (04 + X + Y) or 64-byte X+Y hex"
+    );
+  }
+  const bytes = Buffer6.from(payload, "hex");
+  const auditPublicKeyXDecimal = BigInt(
+    `0x${bytes.subarray(0, X_OFFSET_END).toString("hex")}`
+  ).toString(DECIMAL_RADIX2);
+  const auditPublicKeyYDecimal = BigInt(
+    `0x${bytes.subarray(Y_OFFSET_START, Y_OFFSET_END).toString("hex")}`
+  ).toString(DECIMAL_RADIX2);
+  if (!passesBabyJubCurveCheck(
+    BigInt(auditPublicKeyXDecimal),
+    BigInt(auditPublicKeyYDecimal)
+  )) {
+    throw new Error("Audit public key is not a valid BabyJubJub point.");
+  }
+  return [auditPublicKeyXDecimal, auditPublicKeyYDecimal];
+}
+function buildPoolTransactionAuditParameters(input) {
+  return resolveTransactionAuditParams(
+    input.applicationId,
+    input.auditPublicKey ?? DEMO_AUDIT_PUBLIC_KEY
+  );
+}
+function resolvePoolApplicationId(applicationId) {
+  const trimmed = applicationId?.trim();
+  if (!trimmed) {
+    throw new Error(
+      "Privacy pool applicationId is required. Pass it in client factory config."
+    );
+  }
+  return trimmed;
+}
+
+// src/transact/proofs/withdraw/helpers.ts
+import { ed25519PubkeyPayloadHexToWithdrawFrDecimals as ed25519PubkeyPayloadHexToWithdrawFrDecimals2 } from "@auditable/privacy-pool-zk-sdk";
+
+// src/transact/stellar/account.ts
+import { StrKey as StrKey4 } from "@stellar/stellar-sdk";
+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 = StrKey4.decodeEd25519PublicKey(trimmed);
+    return Buffer7.from(raw).toString("hex");
+  } catch {
+    return void 0;
+  }
+}
+function ed25519HexFromMuxedAddress(trimmed) {
+  try {
+    const raw = StrKey4.decodeMed25519PublicKey(trimmed);
+    if (raw.length === MUXED_ACCOUNT_ID_BYTE_LENGTH + ED25519_PUBLIC_KEY_BYTE_LENGTH) {
+      return raw.subarray(MUXED_ACCOUNT_ID_BYTE_LENGTH).toString("hex");
+    }
+    if (raw.length === ED25519_PUBLIC_KEY_BYTE_LENGTH) {
+      return raw.toString("hex");
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function ed25519PublicKeyHexFromStellarAccount(address) {
+  const trimmed = address.trim();
+  const fromG = ed25519HexFromGAddress(trimmed);
+  if (fromG !== void 0) {
+    return fromG;
+  }
+  const fromMuxed = ed25519HexFromMuxedAddress(trimmed);
+  if (fromMuxed !== void 0) {
+    return fromMuxed;
+  }
+  throw new Error("Invalid destination Stellar address");
+}
+
+// src/transact/encoding/ephemeral-key.ts
+var HEX_64_RE = /^[\da-f]{64}$/iu;
+function normalizeCoordinate(value) {
+  const hex = value.trim().replace(/^0x/iu, "").toLowerCase();
+  if (!HEX_64_RE.test(hex)) {
+    throw new Error("Ephemeral key coordinate must be a 32-byte hex string.");
+  }
+  return hex;
+}
+function parseEphemeralKeyString(input) {
+  const [xRaw, yRaw, extra] = input.split(":");
+  if (!xRaw || !yRaw || extra !== void 0) {
+    throw new Error(
+      'Ephemeral key must be a string in "xHex:yHex" format (32-byte hex each).'
+    );
+  }
+  return {
+    xHex: normalizeCoordinate(xRaw),
+    yHex: normalizeCoordinate(yRaw)
+  };
+}
+
+// src/transact/proofs/withdraw/helpers.ts
+function destinationWithdrawFrAndScalar(parameters) {
+  const pkHex = ed25519PublicKeyHexFromStellarAccount(
+    parameters.destinationStellarAddress
+  );
+  const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals2(pkHex);
+  const privKeyScalar = privKeyScalarDecimalFromRecipientScalarHex(
+    parameters.privKeyScalarHex
+  );
+  return { hi, lo, privKeyScalar };
+}
+function buildWithdrawPublicInput(parameters) {
+  const { hi, lo, privKeyScalar } = destinationWithdrawFrAndScalar({
+    destinationStellarAddress: parameters.destinationStellarAddress,
+    privKeyScalarHex: parameters.privKeyScalarHex
+  });
+  return withTokenAddressPublicInputs(
+    {
+      stateRoot: parameters.stateRoot,
+      withdrawAddressHi: hi,
+      withdrawAddressLo: lo,
+      privKeyScalar
+    },
+    parameters.tokenAddress
+  );
+}
+async function resolveWithdrawChangeDeposits(parameters) {
+  if (parameters.changeStroops <= ZERO_STROOPS) {
+    return { deposits: ["dummy", "dummy"] };
+  }
+  const stpl1 = parameters.changePrivateAddressStpl1?.trim() ?? "";
+  if (!stpl1) {
+    throw new Error(
+      "Private address is required to return the unused balance to the pool (partial withdraw)"
+    );
+  }
+  const slot = await parameters.buildAlignedDepositSlot({
+    privateAddressStpl1: stpl1,
+    amountStroops: parameters.changeStroops,
+    tokenAddress: parameters.tokenAddress
+  });
+  return {
+    deposits: [slot.deposit, "dummy"],
+    changeCoin: {
+      commitment_hex: slot.commitment_hex,
+      coin: slot.coin,
+      depositScalarHex: slot.depositScalarHex,
+      precommitementHex: slot.precommitementHex
+    }
+  };
+}
+function validateDualWithdrawAmounts(withdrawAmountStroops, totalNotes, changePrivateAddressStpl1) {
+  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;
+  requireChangeRecipientWhenPartial(changeStroops, changePrivateAddressStpl1);
+  return changeStroops;
+}
+function buildDualWithdrawPublicInput(parameters) {
+  return buildWithdrawPublicInput({
+    stateRoot: parameters.stateRoot,
+    destinationStellarAddress: parameters.destinationStellarAddress,
+    privKeyScalarHex: parameters.privKeyScalarHex,
+    tokenAddress: parameters.tokenAddress
+  });
+}
+async function prepareDualWithdrawProofInputs(parameters) {
+  const totalNotes = BigInt(parameters.coinA.value) + BigInt(parameters.coinB.value);
+  const changeStroops = validateDualWithdrawAmounts(
+    parameters.withdrawAmountStroops,
+    totalNotes,
+    parameters.changePrivateAddressStpl1
+  );
+  const { legA, legB } = dualWithdrawLegsWithSharedRoot({
+    sdk: parameters.sdk,
+    coinA: parameters.coinA,
+    coinB: parameters.coinB,
+    state: parameters.state,
+    ephemeralA: parseEphemeralKeyString(parameters.ephemeralAKey),
+    ephemeralB: parseEphemeralKeyString(parameters.ephemeralBKey),
+    applicationId: parameters.applicationId
+  });
+  const { deposits, changeCoin } = await resolveWithdrawChangeDeposits({
+    changeStroops,
+    changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
+    buildAlignedDepositSlot: parameters.buildAlignedDepositSlot,
+    tokenAddress: parameters.tokenAddress
+  });
+  const publicInput = buildDualWithdrawPublicInput({
+    destinationStellarAddress: parameters.destinationStellarAddress,
+    privKeyScalarHex: parameters.privKeyScalarHex,
+    tokenAddress: parameters.tokenAddress,
+    stateRoot: legA.witness.stateRoot
+  });
+  const audit = buildPoolTransactionAuditParameters({
+    applicationId: parameters.applicationId,
+    ...parameters.auditPublicKey ? { auditPublicKey: parameters.auditPublicKey } : {}
+  });
+  return {
+    publicInput,
+    audit,
+    withdrawLegs: [legA.withdrawObject, legB.withdrawObject],
+    deposits,
+    ...changeCoin ? { changeCoin } : {}
+  };
+}
+
+// src/transact/proofs/withdraw/transact-proof.ts
+function validateSingleWithdrawAmounts(withdrawAmountStroops, noteStroops) {
+  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;
+}
+async function proveSingleWithdrawTransaction(parameters) {
+  return parameters.sdk.proveTransaction(
+    parameters.publicInput,
+    buildPublicWithdrawLegs(
+      parameters.tokenAddress,
+      parameters.withdrawAmountStroops.toString()
+    ),
+    [parameters.primaryWithdraw, "dummy"],
+    parameters.deposits,
+    parameters.audit
+  );
+}
+function buildPrimaryWithdrawForCoin(parameters) {
+  const ephemeralPoint = parseEphemeralKeyString(parameters.depositorEphemeralKey);
+  const witness = parameters.sdk.buildWithdrawMerkleWitness(
+    parameters.coin,
+    parameters.state
+  );
+  const primaryWithdraw = withdrawObjectFromMerkleWitness2(
+    witness,
+    leafEphemeralCoords(ephemeralPoint.xHex, ephemeralPoint.yHex),
+    parameters.applicationId
+  );
+  return { witness, primaryWithdraw };
+}
+async function prepareSingleWithdrawProofInputs(parameters) {
+  const noteStroops = BigInt(parameters.coin.value);
+  const changeStroops = validateSingleWithdrawAmounts(
+    parameters.withdrawAmountStroops,
+    noteStroops
+  );
+  const { witness, primaryWithdraw } = buildPrimaryWithdrawForCoin(parameters);
+  const { deposits, changeCoin } = await resolveWithdrawChangeDeposits({
+    changeStroops,
+    changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
+    buildAlignedDepositSlot: parameters.buildAlignedDepositSlot,
+    tokenAddress: parameters.tokenAddress
+  });
+  const publicInput = buildWithdrawPublicInput({
+    stateRoot: witness.stateRoot,
+    destinationStellarAddress: parameters.destinationStellarAddress,
+    privKeyScalarHex: parameters.privKeyScalarHex,
+    tokenAddress: parameters.tokenAddress
+  });
+  const audit = buildPoolTransactionAuditParameters({
+    applicationId: parameters.applicationId,
+    ...parameters.auditPublicKey ? { auditPublicKey: parameters.auditPublicKey } : {}
+  });
+  return {
+    primaryWithdraw,
+    deposits,
+    changeCoin,
+    publicInput,
+    audit
+  };
+}
+async function proveWithdrawTransact(parameters) {
+  const { primaryWithdraw, deposits, changeCoin, publicInput, audit } = await prepareSingleWithdrawProofInputs(parameters);
+  const proof = await proveSingleWithdrawTransaction({
+    sdk: parameters.sdk,
+    publicInput,
+    audit,
+    primaryWithdraw,
+    deposits,
+    tokenAddress: parameters.tokenAddress,
+    withdrawAmountStroops: parameters.withdrawAmountStroops
+  });
+  return {
+    ...proof,
+    applicationIdsPlaintext: [
+      parameters.applicationId,
+      "0",
+      changeCoin ? parameters.applicationId : "0",
+      "0"
+    ],
+    ...changeCoin ? { changeCoin } : {}
+  };
+}
+async function proveWithdrawTransactDual(parameters) {
+  const { publicInput, audit, withdrawLegs, deposits, changeCoin } = await prepareDualWithdrawProofInputs(parameters);
+  const proof = await parameters.sdk.proveTransaction(
+    publicInput,
+    buildPublicWithdrawLegs(
+      parameters.tokenAddress,
+      parameters.withdrawAmountStroops.toString()
+    ),
+    withdrawLegs,
+    deposits,
+    audit
+  );
+  return {
+    ...proof,
+    applicationIdsPlaintext: [
+      audit.applicationId,
+      audit.applicationId,
+      changeCoin ? audit.applicationId : "0",
+      "0"
+    ],
+    ...changeCoin ? { changeCoin } : {}
+  };
+}
+
+// src/transact/pool/service.ts
+import "buffer";
+import { PrivacyPoolSDK as PrivacyPoolSdkClass } from "@auditable/privacy-pool-zk-sdk";
+
+// src/transact/pool/aligned-deposit.ts
+import { PrivacyPoolSDK, scalarHexToFrDecimal } from "@auditable/privacy-pool-zk-sdk";
+var SAMPLE_SCALAR_ATTEMPTS = 10;
+function sampleValidDepositScalarHex() {
+  for (let index = 0; index < SAMPLE_SCALAR_ATTEMPTS; index++) {
+    const candidate = PrivacyPoolSDK.generateRandomScalarHex32();
+    try {
+      scalarHexToFrDecimal(candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("could not sample valid depositor ephemeral scalar");
+}
+async function buildAlignedDepositSlotForSdk(sdk, applicationId, parameters) {
+  const privateAddressPoint = decodePrivateAddress(parameters.privateAddressStpl1);
+  const scalarHex = sampleValidDepositScalarHex();
+  const shared = sdk.ecdhSharedKey(
+    scalarHex,
+    privateAddressPoint.x,
+    privateAddressPoint.y
+  );
+  const [assetHi, assetLo] = tokenAddressToAssetLeg(parameters.tokenAddress);
+  const resolvedApplicationId = resolvePoolApplicationId(applicationId);
+  const generated = sdk.generateCoinForDepositWithSharedHex(
+    scalarHex,
+    shared.x,
+    shared.y,
+    parameters.amountStroops,
+    assetHi,
+    assetLo,
+    resolvedApplicationId
+  );
+  const recipientPublicKeys = recipientPublicKeysDecimalFromPrivateAddress(
+    parameters.privateAddressStpl1
+  );
+  const deposit = {
+    value: generated.coin.value,
+    nullifier: generated.coin.nullifier,
+    ephemeralKeyScalar: scalarHexToFrDecimal(scalarHex),
+    asset: [generated.coin.asset_hi, generated.coin.asset_lo],
+    applicationId: resolvedApplicationId,
+    recipientPublicKeys
+  };
+  return {
+    deposit,
+    commitment_hex: generated.commitment_hex,
+    coin: generated.coin,
+    depositScalarHex: scalarHex,
+    precommitementHex: generated.precommitement_hex
+  };
+}
+
+// src/transact/pool/service.ts
+var PrivacyPoolService = class {
+  constructor(assets, applicationId, auditPublicKey) {
+    this.assets = assets;
+    this.applicationId = applicationId;
+    this.auditPublicKey = auditPublicKey;
+  }
+  assets;
+  applicationId;
+  auditPublicKey;
+  sdk = void 0;
+  initPromise = void 0;
+  async ensureInit() {
+    if (this.sdk) {
+      return;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = (async () => {
+      if (!this.assets) {
+        throw new Error(
+          "PrivacyPoolService requires browser ZK assets before initialization."
+        );
+      }
+      this.sdk = await PrivacyPoolSdkClass.init({
+        wasmBinary: this.assets.sdkWasm,
+        circuitWasm: this.assets.circuitWasm,
+        zkey: this.assets.provingKey
+      });
+    })();
+    return this.initPromise;
+  }
+  async getInitializedSdk() {
+    await this.ensureInit();
+    if (!this.sdk) {
+      throw new Error("SDK not initialized");
+    }
+    return this.sdk;
+  }
+  getAuditPublicKey() {
+    return this.auditPublicKey;
+  }
+  getApplicationId() {
+    return resolvePoolApplicationId(this.applicationId);
+  }
+  async generatePrivateAddressFromStellarSignature(signature) {
+    await this.ensureInit();
+    if (!this.sdk) {
+      throw new Error("SDK not initialized");
+    }
+    return privateAddressSdk(this.sdk).generatePrivateAddressFromStellarSignature(
+      signature
+    );
+  }
+  async sharedSecretX(recipientScalarHex, ephemeralKeyEncoded) {
+    await this.ensureInit();
+    if (!this.sdk) {
+      throw new Error("SDK not initialized");
+    }
+    const ephemeralKey = decodeDecodedEphemeralKey(ephemeralKeyEncoded);
+    const shared = this.sdk.sharedSecretFromRecipientPreimage({
+      recipientScalar: recipientScalarHex,
+      ephemeralKey
+    });
+    return shared.x;
+  }
+  async buildAlignedDepositSlot(parameters) {
+    const sdk = await this.getInitializedSdk();
+    return buildAlignedDepositSlotForSdk(sdk, this.getApplicationId(), parameters);
+  }
+  async createAlignedShieldCoinData(parameters) {
+    const { commitment_hex, coin, depositScalarHex, precommitementHex } = await this.buildAlignedDepositSlot(parameters);
+    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,
+      ...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,
+        withdrawAddressHi: "0",
+        withdrawAddressLo: "0",
+        privKeyScalar: randomFrDecimal253()
+      },
+      parameters.tokenAddress
+    );
+    const proof = await sdk.proveTransaction(
+      publicInput,
+      buildPublicDepositLegs(parameters.tokenAddress, parameters.coin.value),
+      ["dummy", "dummy"],
+      [deposit, "dummy"],
+      audit
+    );
+    const applicationIdsPlaintext = [
+      "0",
+      "0",
+      applicationId,
+      "0"
+    ];
+    return { ...proof, applicationIdsPlaintext };
+  }
+  async calculateNullifierHash(nullifier) {
+    const sdk = await this.getInitializedSdk();
+    return sdk.calculateNullifierHash(nullifier);
+  }
+  async prepareWithdrawTransactProof(parameters) {
+    await this.ensureInit();
+    if (!this.sdk) {
+      throw new Error("SDK not initialized");
+    }
+    return proveWithdrawTransact({
+      sdk: this.sdk,
+      applicationId: this.getApplicationId(),
+      buildAlignedDepositSlot: (input) => this.buildAlignedDepositSlot(input),
+      ...this.auditPublicKey ? { auditPublicKey: this.auditPublicKey } : {},
+      ...parameters
+    });
+  }
+  async prepareWithdrawTransactProofDual(parameters) {
+    await this.ensureInit();
+    if (!this.sdk) {
+      throw new Error("SDK not initialized");
+    }
+    return proveWithdrawTransactDual({
+      sdk: this.sdk,
+      applicationId: this.getApplicationId(),
+      buildAlignedDepositSlot: (input) => this.buildAlignedDepositSlot(input),
+      ...this.auditPublicKey ? { auditPublicKey: this.auditPublicKey } : {},
+      coinA: parameters.coinA,
+      coinB: parameters.coinB,
+      state: parameters.state,
+      destinationStellarAddress: parameters.destinationStellarAddress,
+      privKeyScalarHex: parameters.privKeyScalarHex,
+      ephemeralAKey: parameters.depositorEphemeralAKey,
+      ephemeralBKey: parameters.depositorEphemeralBKey,
+      withdrawAmountStroops: parameters.withdrawAmountStroops,
+      changePrivateAddressStpl1: parameters.changePrivateAddressStpl1,
+      tokenAddress: parameters.tokenAddress
+    });
+  }
+};
+
+// src/transact/pool/singleton.ts
+function createPrivacyPoolService(input) {
+  return new PrivacyPoolService(
+    input?.assets,
+    input?.applicationId,
+    input?.auditPublicKey
+  );
+}
+var configuredPrivacyPoolService;
+function configurePrivacyPoolService(service) {
+  configuredPrivacyPoolService = service;
+}
+function getPrivacyPoolService() {
+  if (!configuredPrivacyPoolService) {
+    throw new Error(
+      "PrivacyPoolService is not configured. Call configurePrivacyPoolService first."
+    );
+  }
+  return configuredPrivacyPoolService;
+}
+
+// src/transact/assets/load-browser.ts
+async function loadStellarBrowserAssets(input) {
+  const cacheKey = input.cacheBust ? `?v=${Date.now()}` : "";
+  const [sdkWasm, circuitWasm, provingKey] = await Promise.all([
+    fetch(`${input.sdkWasmUrl}${cacheKey}`).then((response) => response.arrayBuffer()),
+    fetch(input.circuitWasmUrl).then((response) => response.arrayBuffer()),
+    fetch(input.provingKeyUrl).then((response) => response.arrayBuffer())
+  ]);
+  return { sdkWasm, circuitWasm, provingKey };
+}
+async function loadDefaultStellarBrowserAssets(options) {
+  await import("@auditable/privacy-pool-zk-sdk");
+  const sdkWasmUrl = new URL("@auditable/privacy-pool-zk-sdk/sdk.wasm", import.meta.url).href;
+  const circuitWasmUrl = new URL(
+    "@auditable/privacy-pool-zk-sdk/witness.wasm",
+    import.meta.url
+  ).href;
+  const provingKeyUrl = new URL(
+    "@auditable/privacy-pool-zk-sdk/main.zkey",
+    import.meta.url
+  ).href;
+  return loadStellarBrowserAssets({
+    sdkWasmUrl,
+    circuitWasmUrl,
+    provingKeyUrl,
+    ...options?.cacheBust ? { cacheBust: true } : {}
+  });
+}
+
+// src/transact/onboarding/build-payload.ts
+import { Buffer as Buffer9 } from "buffer";
+import { PrivacyPoolSDK as PrivacyPoolSDK4 } from "@auditable/privacy-pool-zk-sdk";
+
+// src/transact/encoding/fr-decimal-to-bytes.ts
+var BN254_SCALAR_MOD = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+var FIELD_BYTE_LENGTH = 32;
+var BYTE_MASK = 0xffn;
+var BITS_PER_BYTE = 8n;
+function frDecimalToPaddedBytes32(decimal) {
+  let value = BigInt(decimal.trim());
+  value = (value % BN254_SCALAR_MOD + BN254_SCALAR_MOD) % BN254_SCALAR_MOD;
+  const bytes = Buffer.alloc(FIELD_BYTE_LENGTH);
+  for (let index = FIELD_BYTE_LENGTH - 1; index >= 0; index -= 1) {
+    bytes[index] = Number(value & BYTE_MASK);
+    value >>= BITS_PER_BYTE;
+  }
+  return bytes;
+}
+
+// src/transact/onboarding/recipient.ts
+import { PrivacyPoolSDK as PrivacyPoolSDK3 } from "@auditable/privacy-pool-zk-sdk";
+var COORDINATE_HEX_LENGTH = 64;
+async function generateTemporaryRecipientPrivateAddress() {
+  await getPrivacyPoolService().getInitializedSdk();
+  const temporaryScalarHex = PrivacyPoolSDK3.generateRandomScalarHex32();
+  const sdk = await getPrivacyPoolService().getInitializedSdk();
+  const point = sdk.ecdhEphemeralPublicKeyFromScalarHex(temporaryScalarHex);
+  const publicKeyXHex = point.x.padStart(COORDINATE_HEX_LENGTH, "0");
+  const publicKeyYHex = point.y.padStart(COORDINATE_HEX_LENGTH, "0");
+  return {
+    temporaryScalarHex,
+    temporaryPrivateAddressStpl1: encodePrivateAddressFromHexCoordinates(
+      publicKeyXHex,
+      publicKeyYHex
+    )
+  };
+}
+
+// src/transact/onboarding/build-payload.ts
+var COORDINATE_HEX_LENGTH2 = 64;
+function noneOptionalRegistration() {
+  return { tag: "None", values: void 0 };
+}
+function coinToPlaintextNote(coin) {
+  const [assetHi, assetLo] = tokenAddressToAssetLeg(coin.tokenAddress);
+  return {
+    asset_hi: frDecimalToPaddedBytes32(assetHi),
+    asset_lo: frDecimalToPaddedBytes32(assetLo),
+    deposited_ephemeral_scalar: void 0,
+    nullifier: frDecimalToPaddedBytes32(coin.nullifier),
+    secret: frDecimalToPaddedBytes32(coin.secret),
+    value: BigInt(coin.value)
+  };
+}
+async function generateRandomDepositScalarHex() {
+  await getPrivacyPoolService().getInitializedSdk();
+  return PrivacyPoolSDK4.generateRandomScalarHex32();
+}
+function buildOnboardingPayload(parameters) {
+  const notes = parameters.recipientNotes.map((coin) => coinToPlaintextNote(coin));
+  const temporaryDecoded = decodePrivateAddress(
+    parameters.temporaryKey.temporaryPrivateAddressStpl1.trim()
+  );
+  let privateAddressRegistration = noneOptionalRegistration();
+  if (parameters.permanentPrivateAddressStpl1?.trim()) {
+    const decoded = decodePrivateAddress(
+      parameters.permanentPrivateAddressStpl1.trim()
+    );
+    const registration = {
+      owner: parameters.ownerStellarAddress.trim(),
+      public_key_x: Buffer9.from(decoded.x.padStart(COORDINATE_HEX_LENGTH2, "0"), "hex"),
+      public_key_y: Buffer9.from(decoded.y.padStart(COORDINATE_HEX_LENGTH2, "0"), "hex")
+    };
+    privateAddressRegistration = { tag: "Some", values: [registration] };
+  }
+  return {
+    owner: parameters.ownerStellarAddress.trim(),
+    temp_public_key_x: Buffer9.from(
+      temporaryDecoded.x.padStart(COORDINATE_HEX_LENGTH2, "0"),
+      "hex"
+    ),
+    temp_public_key_y: Buffer9.from(
+      temporaryDecoded.y.padStart(COORDINATE_HEX_LENGTH2, "0"),
+      "hex"
+    ),
+    encrypted_private_key: Buffer9.from(
+      parameters.temporaryKey.temporaryScalarHex,
+      "utf8"
+    ),
+    notes: { notes },
+    private_address_registration: privateAddressRegistration
+  };
+}
+async function buildTransferOnboardingAtExecute(input) {
+  return buildOnboardingPayload({
+    ownerStellarAddress: input.ownerStellarAddress,
+    temporaryKey: {
+      temporaryScalarHex: input.temporaryRecipientKey.temporaryScalarHex,
+      temporaryPrivateAddressStpl1: input.temporaryRecipientKey.temporaryPrivateAddressStpl1
+    },
+    recipientNotes: [input.recipientNote]
+  });
+}
+
+// src/transact/kyt/inspect-error.ts
+var KytInspectError = class extends Error {
+  reasonCode;
+  decisionId;
+  detailAddress;
+  constructor(parameters) {
+    super(parameters.message);
+    this.name = "KytInspectError";
+    this.reasonCode = parameters.reasonCode;
+    if (parameters.decisionId !== void 0) {
+      this.decisionId = parameters.decisionId;
+    }
+    if (parameters.detailAddress !== void 0) {
+      this.detailAddress = parameters.detailAddress;
+    }
+  }
+};
+function parseKytReasonCode(reasonCode) {
+  const separatorIndex = reasonCode.indexOf(":");
+  if (separatorIndex === -1) {
+    return { code: reasonCode };
+  }
+  return {
+    code: reasonCode.slice(0, separatorIndex),
+    address: reasonCode.slice(separatorIndex + 1)
+  };
+}
+
+// src/contracts/contract-context.ts
+function requireContractContext(environment) {
+  if (!environment || !("contractContext" in environment)) {
+    throw new Error("Contract context is not configured on the transact environment.");
+  }
+  const resolved = environment;
+  return resolved.contractContext;
+}
+function readPoolClientFactory(environment) {
+  return requireContractContext(environment).createPoolClient;
+}
+
+// src/transact/kyt/passage/poll.ts
+import "@stellar/stellar-sdk";
+var KYT_REGISTER_MAX_POLLS = 60;
+var KYT_REGISTER_POLL_INTERVAL_MS = 1e3;
+function parseLedgerSequence(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isSafeInteger(parsed) && parsed >= 0) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+async function fetchCurrentLedger(sorobanRpcUrl) {
+  const response = await fetch(sorobanRpcUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "getLatestLedger"
+    })
+  });
+  const body = await response.json();
+  if (!response.ok || body.error) {
+    const details = body.error?.message ?? response.statusText;
+    throw new Error(`Failed to fetch current ledger from Soroban RPC: ${details}`);
+  }
+  const sequence = parseLedgerSequence(body.result?.sequence) ?? parseLedgerSequence(body.result?.latestLedger);
+  if (sequence === void 0) {
+    throw new Error("Failed to fetch current ledger from Soroban RPC: invalid payload");
+  }
+  return sequence;
+}
+async function waitForKytRegistration(parameters) {
+  for (let attempt = 0; attempt < KYT_REGISTER_MAX_POLLS; attempt += 1) {
+    const response = await parameters.server.getTransaction(parameters.hash);
+    if (response.status === "SUCCESS") {
+      return;
+    }
+    if (response.status === "FAILED") {
+      throw new Error("KYT passage registration failed on-chain");
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, KYT_REGISTER_POLL_INTERVAL_MS);
+    });
+  }
+  throw new Error("KYT passage registration was not confirmed in time");
+}
+
+// src/transact/kyt/passage/submit.ts
+import { Buffer as Buffer10 } from "buffer";
+import { Operation, TransactionBuilder, rpc as rpc2, xdr } from "@stellar/stellar-sdk";
+var KYT_REGISTER_FEE_STROOPS = "1000000";
+var KYT_REGISTER_TIMEOUT_SECONDS = 300;
+function passageIdToScValue(passageId) {
+  return xdr.ScVal.scvBytes(Buffer10.from(passageId.replace(/^0x/, ""), "hex"));
+}
+function approvalSignatureToBytes(signature) {
+  const clean = signature.trim();
+  return /^(0x)?[0-9a-fA-F]{128}$/.test(clean) ? Buffer10.from(clean.replace(/^0x/i, ""), "hex") : Buffer10.from(clean, "base64");
+}
+function signatureToScValue(signature) {
+  const bytes = approvalSignatureToBytes(signature);
+  return xdr.ScVal.scvBytes(bytes);
+}
+async function registerKytPassage(parameters) {
+  const signTransaction = parameters.transactEnvironment.signTransaction;
+  if (!signTransaction) {
+    throw new Error(
+      "KYT passage registration requires a wallet signTransaction adapter."
+    );
+  }
+  const kytRegistry = parameters.transactEnvironment.kyt.kytPassageRegistryContract;
+  const server = new rpc2.Server(parameters.sorobanRpcUrl, { allowHttp: true });
+  const sourceAccount = await server.getAccount(parameters.owner);
+  const transaction = new TransactionBuilder(sourceAccount, {
+    fee: KYT_REGISTER_FEE_STROOPS,
+    networkPassphrase: parameters.networkPassphrase
+  }).addOperation(
+    Operation.invokeContractFunction({
+      contract: kytRegistry,
+      function: "register_passage",
+      args: [
+        passageIdToScValue(parameters.approval.passageId),
+        xdr.ScVal.scvU32(parameters.approval.expiresAtLedger),
+        signatureToScValue(parameters.approval.signature)
+      ]
+    })
+  ).setTimeout(KYT_REGISTER_TIMEOUT_SECONDS).build();
+  const preparedTransaction = await server.prepareTransaction(transaction);
+  const { signedTxXdr } = await signTransaction({
+    xdr: preparedTransaction.toXDR(),
+    networkPassphrase: parameters.networkPassphrase,
+    address: parameters.owner
+  });
+  const signedTransaction = TransactionBuilder.fromXDR(
+    signedTxXdr,
+    parameters.networkPassphrase
+  );
+  const result = await server.sendTransaction(signedTransaction);
+  const status = String(result.status);
+  if (status !== "PENDING" && status !== "SUCCESS") {
+    throw new Error(`KYT passage registration submit failed: ${status}`);
+  }
+  await waitForKytRegistration({ server, hash: result.hash });
+}
+
+// src/transact/kyt/passage/inspect.ts
+function buildApplicationIdHints(applicationId) {
+  return [applicationId, applicationId, applicationId, applicationId];
+}
+function buildNonce() {
+  return globalThis.crypto?.randomUUID?.() ?? `${Date.now()}`;
+}
+function kytJsonReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return value;
+}
+async function parseInspectResponse(response) {
+  const body = await response.json();
+  if (!response.ok) {
+    throw new Error(`KYT inspect failed: ${JSON.stringify(body)}`);
+  }
+  return body;
+}
+function throwKytInspectRejected(body) {
+  const reasonCode = body.reasonCode ?? body.status;
+  const parsed = parseKytReasonCode(reasonCode);
+  throw new KytInspectError({
+    message: reasonCode,
+    reasonCode,
+    ...body.decisionId ? { decisionId: body.decisionId } : {},
+    ...parsed.address ? { detailAddress: parsed.address } : {}
+  });
+}
+async function requestKytPassageForPoolInteraction(input) {
+  const applicationId = resolvePoolApplicationId(
+    input.transactEnvironment.network.applicationId
+  );
+  const applicationIdsPlaintext = input.applicationIdsPlaintext ?? buildApplicationIdHints(applicationId);
+  const kytRegistry = input.transactEnvironment.kyt.kytPassageRegistryContract;
+  const currentLedger = await fetchCurrentLedger(input.sorobanRpcUrl);
+  const response = await fetch(
+    `${input.transactEnvironment.kyt.apiBaseUrl}/kyt/passages/inspect`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(
+        {
+          owner: input.owner,
+          poolContract: input.poolContract,
+          kytRegistry,
+          proofBytes: input.proofHex,
+          publicSignalsBytes: input.publicHex,
+          applicationIdsPlaintext,
+          decryptedAuditSlots: input.decryptedAuditSlots,
+          onboarding: input.onboarding,
+          nonce: buildNonce(),
+          currentLedger
+        },
+        kytJsonReplacer
+      )
+    }
+  );
+  const body = await parseInspectResponse(response);
+  if (body.status !== "approved") {
+    throwKytInspectRejected(body);
+  }
+  if (input.transactEnvironment.kyt.registerPassageOnChain) {
+    await registerKytPassage({
+      approval: body,
+      owner: input.owner,
+      networkPassphrase: input.networkPassphrase,
+      sorobanRpcUrl: input.sorobanRpcUrl,
+      transactEnvironment: input.transactEnvironment
+    });
+  }
+  return body;
+}
+
+// src/transact/submit/ttl-preflight.ts
+function getNested(source, path) {
+  let cursor = source;
+  for (const key of path) {
+    if (typeof cursor !== "object" || cursor === null) {
+      return void 0;
+    }
+    cursor = cursor[key];
+  }
+  return cursor;
+}
+function needsRestore(simulation) {
+  const restorePreamble = getNested(simulation, ["restorePreamble"]) ?? getNested(simulation, ["result", "restorePreamble"]) ?? getNested(simulation, ["simulation", "restorePreamble"]);
+  if (restorePreamble && typeof restorePreamble === "object") {
+    return true;
+  }
+  const isSimulationError = getNested(simulation, ["error"]);
+  if (typeof isSimulationError === "string") {
+    return isSimulationError.toLowerCase().includes("restore");
+  }
+  return false;
+}
+async function maybeCallFunction(target, methodName) {
+  if (typeof target !== "object" || target === null) {
+    return void 0;
+  }
+  const method = target[methodName];
+  if (typeof method !== "function") {
+    return void 0;
+  }
+  return method();
+}
+async function runTtlPreflight(assembledTransaction) {
+  const simulation = await maybeCallFunction(assembledTransaction, "simulate");
+  if (!simulation || !needsRestore(simulation)) {
+    return;
+  }
+  const restoreResult = await maybeCallFunction(assembledTransaction, "restoreFootprint") ?? await maybeCallFunction(assembledTransaction, "restore");
+  if (!restoreResult) {
+    return;
+  }
+  await maybeCallFunction(assembledTransaction, "simulate");
+}
+
+// src/transact/submit/pool-transact.ts
+import { Buffer as Buffer11 } from "buffer";
+async function submitPoolTransact(parameters) {
+  const assembledTransaction = await parameters.contractClient.transact({
+    from: parameters.from,
+    proof_bytes: Buffer11.from(parameters.proofHex.replace(/^0x/iu, ""), "hex"),
+    pub_signals_bytes: Buffer11.from(parameters.publicHex.replace(/^0x/iu, ""), "hex"),
+    onboarding: parameters.onboarding,
+    kyt_authorization: {
+      expiration_ledger: parameters.approval.expiresAtLedger,
+      signature: approvalSignatureToBytes(parameters.approval.signature)
+    }
+  });
+  await runTtlPreflight(assembledTransaction);
+  const sentTransaction = await assembledTransaction.signAndSend();
+  const transactionHash = sentTransaction.sendTransactionResponse?.hash ?? "";
+  if (!transactionHash) {
+    throw new Error("Transaction failed");
+  }
+  return transactionHash;
+}
+
+// src/transact/submit/soroban-deposit.ts
+async function submitSorobanDeposit(input) {
+  const poolClient = readPoolClientFactory(input.transactEnvironment)({
+    contractId: input.contractId,
+    walletPublicKey: input.walletPublicKey,
+    networkPassphrase: input.networkPassphrase,
+    sorobanRpcUrl: input.sorobanRpcUrl
+  });
+  const merkleTx = await poolClient.get_merkle_root();
+  const merkleRootBuffer = merkleTx.result;
+  const { applicationIdsPlaintext, proof_hex, public_hex } = await input.privacyPoolService.prepareDepositTransactProof({
+    privateAddressStpl1: input.privateAddressStpl1,
+    coin: input.coin,
+    depositScalarHex: input.depositScalarHex,
+    merkleRootBytes: merkleRootBuffer,
+    tokenAddress: input.tokenAddress
+  });
+  const approval = await requestKytPassageForPoolInteraction({
+    owner: input.walletPublicKey,
+    poolContract: input.contractId,
+    proofHex: proof_hex,
+    publicHex: public_hex,
+    applicationIdsPlaintext,
+    networkPassphrase: input.networkPassphrase,
+    sorobanRpcUrl: input.sorobanRpcUrl,
+    transactEnvironment: input.transactEnvironment
+  });
+  return submitPoolTransact({
+    contractClient: poolClient,
+    from: input.walletPublicKey,
+    proofHex: proof_hex,
+    publicHex: public_hex,
+    approval
+  });
+}
+
+// src/transact/submit/soroban-confidential-transfer.ts
+async function submitSorobanConfidentialTransfer(input) {
+  const poolClient = readPoolClientFactory(input.transactEnvironment)({
+    contractId: input.contractId,
+    walletPublicKey: input.walletPublicKey,
+    networkPassphrase: input.networkPassphrase,
+    sorobanRpcUrl: input.sorobanRpcUrl
+  });
+  const approval = await requestKytPassageForPoolInteraction({
+    owner: input.walletPublicKey,
+    poolContract: input.contractId,
+    proofHex: input.proofHex,
+    publicHex: input.publicHex,
+    ...input.onboarding ? { onboarding: input.onboarding } : {},
+    ...input.applicationIdsPlaintext ? { applicationIdsPlaintext: input.applicationIdsPlaintext } : {},
+    networkPassphrase: input.networkPassphrase,
+    sorobanRpcUrl: input.sorobanRpcUrl,
+    transactEnvironment: input.transactEnvironment
+  });
+  return submitPoolTransact({
+    contractClient: poolClient,
+    from: input.walletPublicKey,
+    proofHex: input.proofHex,
+    publicHex: input.publicHex,
+    ...input.onboarding ? { onboarding: input.onboarding } : {},
+    approval
+  });
+}
+
+// src/transact/onboarding/recipient-change-deposits.ts
+async function buildPaddingDepositPair(recipientPrivateAddressStpl1, tokenAddress, recipientDeposit) {
+  const paddingSlot = await getPrivacyPoolService().buildAlignedDepositSlot({
+    privateAddressStpl1: recipientPrivateAddressStpl1,
+    amountStroops: ZERO_STROOPS,
+    tokenAddress
+  });
+  return [recipientDeposit, paddingSlot.deposit];
+}
+async function buildChangeDepositPair(parameters) {
+  const changeSlot = await getPrivacyPoolService().buildAlignedDepositSlot({
+    privateAddressStpl1: parameters.selfPrivateAddressStpl1ForChange.trim(),
+    amountStroops: parameters.changeStroops,
+    tokenAddress: parameters.tokenAddress
+  });
+  return {
+    deposits: [parameters.recipientDeposit, changeSlot.deposit],
+    changeCoin: {
+      commitment_hex: changeSlot.commitment_hex,
+      coin: changeSlot.coin,
+      depositScalarHex: changeSlot.depositScalarHex,
+      precommitementHex: changeSlot.precommitementHex
+    }
+  };
+}
+async function buildRecipientAndOptionalChangeDeposits(parameters) {
+  const recipientPrivateAddress = parameters.recipientPrivateAddressStpl1.trim();
+  const recipientSlot = await getPrivacyPoolService().buildAlignedDepositSlot({
+    privateAddressStpl1: recipientPrivateAddress,
+    amountStroops: parameters.transferStroops,
+    tokenAddress: parameters.tokenAddress
+  });
+  if (parameters.changeStroops <= ZERO_STROOPS) {
+    return {
+      recipientSlot,
+      deposits: await buildPaddingDepositPair(
+        recipientPrivateAddress,
+        parameters.tokenAddress,
+        recipientSlot.deposit
+      )
+    };
+  }
+  const changeResult = await buildChangeDepositPair({
+    recipientPrivateAddressStpl1: recipientPrivateAddress,
+    selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
+    changeStroops: parameters.changeStroops,
+    tokenAddress: parameters.tokenAddress,
+    recipientDeposit: recipientSlot.deposit
+  });
+  return {
+    recipientSlot,
+    deposits: changeResult.deposits,
+    changeCoin: changeResult.changeCoin
+  };
+}
+
+// src/transact/proofs/confidential/shared.ts
+function generatedOutputCoinFromSlot(slot) {
+  return {
+    commitment_hex: slot.commitment_hex,
+    coin: slot.coin,
+    depositScalarHex: slot.depositScalarHex,
+    precommitementHex: slot.precommitementHex
+  };
+}
+async function buildTransferDepositsAndPublicInput(parameters) {
+  const { recipientSlot, deposits, changeCoin } = await buildRecipientAndOptionalChangeDeposits({
+    recipientPrivateAddressStpl1: parameters.recipientPrivateAddressStpl1,
+    transferStroops: parameters.transferStroops,
+    changeStroops: parameters.changeStroops,
+    selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
+    tokenAddress: parameters.tokenAddress
+  });
+  const publicInput = withTokenAddressPublicInputs(
+    {
+      stateRoot: parameters.stateRoot,
+      withdrawAddressHi: parameters.withdrawAddressHi,
+      withdrawAddressLo: parameters.withdrawAddressLo,
+      privKeyScalar: parameters.privKeyScalar
+    },
+    parameters.tokenAddress
+  );
+  return {
+    recipientSlot,
+    deposits,
+    ...changeCoin ? { changeCoin } : {},
+    publicInput
+  };
+}
+async function buildSenderTransferDepositsAndPublicInput(parameters) {
+  const { hi, lo, privKeyScalar } = senderWithdrawFrAndScalar({
+    senderGAddress: parameters.senderGAddress,
+    senderPrivKeyScalarHex: parameters.senderPrivKeyScalarHex
+  });
+  return buildTransferDepositsAndPublicInput({
+    recipientPrivateAddressStpl1: parameters.recipientPrivateAddressStpl1,
+    transferStroops: parameters.transferStroops,
+    changeStroops: parameters.changeStroops,
+    selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
+    tokenAddress: parameters.tokenAddress,
+    stateRoot: parameters.stateRoot,
+    withdrawAddressHi: hi,
+    withdrawAddressLo: lo,
+    privKeyScalar
+  });
+}
+
+// src/transact/proofs/confidential/dual.ts
+function buildDualTransferApplicationIds(applicationId, changeCoin) {
+  return [
+    applicationId,
+    applicationId,
+    applicationId,
+    changeCoin ? applicationId : "0"
+  ];
+}
+async function proveDualConfidentialTransfer(parameters) {
+  const audit = buildPoolTransactionAuditParameters({
+    applicationId: parameters.applicationId,
+    ...parameters.auditPublicKey ? { auditPublicKey: parameters.auditPublicKey } : {}
+  });
+  return parameters.sdk.proveTransaction(
+    parameters.publicInput,
+    buildZeroPublicLegs(),
+    [parameters.legA.withdrawObject, parameters.legB.withdrawObject],
+    parameters.deposits,
+    audit
+  );
+}
+async function buildDualTransferProofContext(parameters, applicationId, sdk) {
+  const totalNotes = BigInt(parameters.coinA.value) + BigInt(parameters.coinB.value);
+  const changeStroops = changeStroopsAfterDualTransfer(
+    parameters.transferStroops,
+    totalNotes
+  );
+  requireChangeRecipientWhenPartial(
+    changeStroops,
+    parameters.selfPrivateAddressStpl1ForChange
+  );
+  const { legA, legB } = dualWithdrawLegsWithSharedRoot({
+    sdk,
+    coinA: parameters.coinA,
+    coinB: parameters.coinB,
+    state: parameters.state,
+    ephemeralA: parseEphemeralKeyString(parameters.ephemeralAKey),
+    ephemeralB: parseEphemeralKeyString(parameters.ephemeralBKey),
+    applicationId
+  });
+  const transferInputs = await buildSenderTransferDepositsAndPublicInput({
+    senderGAddress: parameters.senderGAddress,
+    senderPrivKeyScalarHex: parameters.senderPrivKeyScalarHex,
+    recipientPrivateAddressStpl1: parameters.recipientPrivateAddressStpl1,
+    transferStroops: parameters.transferStroops,
+    changeStroops,
+    selfPrivateAddressStpl1ForChange: parameters.selfPrivateAddressStpl1ForChange,
+    tokenAddress: parameters.tokenAddress,
+    stateRoot: legA.witness.stateRoot
+  });
+  return { legA, legB, applicationId, ...transferInputs };
+}
+async function prepareConfidentialTransferProofDual(parameters) {
+  const poolService = getPrivacyPoolService();
+  const sdk = await poolService.getInitializedSdk();
+  const applicationId = poolService.getApplicationId();
+  const { legA, legB, recipientSlot, deposits, changeCoin, publicInput } = await buildDualTransferProofContext(parameters, applicationId, sdk);
+  const auditPublicKey = poolService.getAuditPublicKey();
+  const proof = await (auditPublicKey ? proveDualConfidentialTransfer({
+    sdk,
+    publicInput,
+    legA,
+    legB,
+    deposits,
+    applicationId,
+    auditPublicKey
+  }) : proveDualConfidentialTransfer({
+    sdk,
+    publicInput,
+    legA,
+    legB,
+    deposits,
+    applicationId
+  }));
+  return {
+    ...proof,
+    applicationIdsPlaintext: buildDualTransferApplicationIds(applicationId, changeCoin),
+    recipientCoin: generatedOutputCoinFromSlot(recipientSlot),
+    ...changeCoin ? { changeCoin } : {}
+  };
+}
+
+// src/transact/proofs/confidential/single.ts
+function validateSingleCoinTransferAmounts(transferStroops, noteStroops, selfPrivateAddressStpl1ForChange) {
+  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;
+  requireChangeRecipientWhenPartial(changeStroops, selfPrivateAddressStpl1ForChange);
+  return changeStroops;
+}
+function buildSingleTransferApplicationIds(applicationId, changeCoin) {
+  return [applicationId, "0", applicationId, changeCoin ? applicationId : "0"];
+}
+function buildTransferAuditParameters(parameters) {
+  const auditPublicKey = parameters.poolService.getAuditPublicKey();
+  return buildPoolTransactionAuditParameters({
+    applicationId: parameters.applicationId,
+    ...auditPublicKey ? { auditPublicKey } : {}
+  });
+}
+async function proveTransaction(parameters) {
+  return parameters.sdk.proveTransaction(
+    parameters.publicInput,
+    buildZeroPublicLegs(),
+    [parameters.withdrawObject, "dummy"],
+    parameters.deposits,
+    parameters.audit
+  );
+}
+async function buildTransferProofInputs(parameters) {
+  const changeStroops = validateSingleCoinTransferAmounts(
+    parameters.input.transferStroops,
+    parameters.noteStroops,
+    parameters.input.selfPrivateAddressStpl1ForChange
+  );
+  const { witness, withdrawObject } = withdrawWitnessForCoin({
+    sdk: parameters.sdk,
+    coin: parameters.input.coin,
+    state: parameters.input.state,
+    ...parseEphemeralKeyString(parameters.input.depositorEphemeralKey),
+    applicationId: parameters.applicationId
+  });
+  const { recipientSlot, deposits, changeCoin, publicInput } = await buildSenderTransferDepositsAndPublicInput({
+    senderGAddress: parameters.input.senderGAddress,
+    senderPrivKeyScalarHex: parameters.input.senderPrivKeyScalarHex,
+    recipientPrivateAddressStpl1: parameters.input.recipientPrivateAddressStpl1,
+    transferStroops: parameters.input.transferStroops,
+    changeStroops,
+    selfPrivateAddressStpl1ForChange: parameters.input.selfPrivateAddressStpl1ForChange,
+    tokenAddress: parameters.input.tokenAddress,
+    stateRoot: witness.stateRoot
+  });
+  return {
+    witness,
+    withdrawObject,
+    recipientSlot,
+    deposits,
+    changeCoin,
+    publicInput
+  };
+}
+async function prepareConfidentialTransferProof(parameters) {
+  const poolService = getPrivacyPoolService();
+  const sdk = await poolService.getInitializedSdk();
+  const applicationId = poolService.getApplicationId();
+  const noteStroops = BigInt(parameters.coin.value);
+  const { withdrawObject, recipientSlot, deposits, changeCoin, publicInput } = await buildTransferProofInputs({
+    sdk,
+    applicationId,
+    input: parameters,
+    noteStroops
+  });
+  const audit = buildTransferAuditParameters({ poolService, applicationId });
+  const proof = await proveTransaction({
+    sdk,
+    publicInput,
+    withdrawObject,
+    deposits,
+    audit
+  });
+  return {
+    ...proof,
+    applicationIdsPlaintext: buildSingleTransferApplicationIds(
+      applicationId,
+      changeCoin
+    ),
+    recipientCoin: generatedOutputCoinFromSlot(recipientSlot),
+    ...changeCoin ? { changeCoin } : {}
+  };
+}
+
+// src/transact/merkle/fetch-contract.ts
+import { Buffer as Buffer13 } from "buffer";
+
+// src/transact/merkle/encoding.ts
+import "buffer";
+var FR_ORDER = 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n;
+function bufferToDecimal(buf) {
+  const hex = buf.toString("hex");
+  const bigintFromHex = BigInt(`0x${hex}`);
+  const reduced = bigintFromHex % FR_ORDER;
+  return reduced.toString();
+}
+function commitmentsBuffersToDecimal(buffers) {
+  return buffers.map((bufferRow) => bufferToDecimal(bufferRow));
+}
+
+// src/transact/merkle/state-port.ts
+function poolMerkleStateToCachedView(state) {
+  return {
+    commitments: state.commitments,
+    updatedAt: state.updatedAt,
+    merkleRootHex: state.merkleRootHex
+  };
+}
+
+// src/transact/merkle/fetch-contract.ts
+function normalizeCommitmentBuffers(rawBuffers) {
+  return rawBuffers.map(
+    (bufferRow) => Buffer13.isBuffer(bufferRow) ? bufferRow : Buffer13.from(bufferRow)
+  );
+}
+function mergeContractMerkleWithCache(parameters) {
+  const cachedCount = parameters.cachedState?.commitments.length ?? 0;
+  const shouldPreferContract = parameters.contractCount > cachedCount || !parameters.cachedState || cachedCount === 0;
+  if (shouldPreferContract) {
+    const updatedAt = Date.now();
+    void parameters.poolMerkleState?.set({
+      poolContract: parameters.poolContractId,
+      commitments: parameters.contractCommitments,
+      commitmentCount: parameters.contractCount,
+      merkleRootHex: parameters.merkleRootHex,
+      updatedAt
+    });
+    return {
+      commitments: parameters.contractCommitments,
+      updatedAt,
+      merkleRootHex: parameters.merkleRootHex,
+      commitmentCount: parameters.contractCount
+    };
+  }
+  return {
+    commitments: parameters.cachedState.commitments,
+    updatedAt: parameters.cachedState.updatedAt,
+    merkleRootHex: parameters.cachedState.merkleRootHex ?? parameters.merkleRootHex,
+    commitmentCount: parameters.cachedState.commitments.length
+  };
+}
+async function readCachedPoolMerkleView(poolMerkleState, poolContractId) {
+  if (!poolMerkleState) {
+    return void 0;
+  }
+  const cached = await poolMerkleState.get(poolContractId);
+  return cached ? poolMerkleStateToCachedView(cached) : void 0;
+}
+async function fetchAndMergeMerkleState(parameters) {
+  const client = readPoolClientFactory(parameters.transactEnvironment)({
+    contractId: parameters.poolContractId,
+    walletPublicKey: parameters.walletPublicKey,
+    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
+    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
+  });
+  const commitmentsRead = await client.get_commitments();
+  const rawBuffers = commitmentsRead.result;
+  const buffers = normalizeCommitmentBuffers(rawBuffers);
+  const contractCommitments = commitmentsBuffersToDecimal(buffers);
+  const contractCount = contractCommitments.length;
+  const rootRead = await client.get_merkle_root();
+  const merkleRootBuffer = rootRead.result;
+  const merkleRootHex = Buffer13.from(merkleRootBuffer).toString("hex");
+  const cachedState = await readCachedPoolMerkleView(
+    parameters.poolMerkleState,
+    parameters.poolContractId
+  );
+  return mergeContractMerkleWithCache({
+    poolContractId: parameters.poolContractId,
+    contractCommitments,
+    contractCount,
+    merkleRootHex,
+    cachedState,
+    ...parameters.poolMerkleState ? { poolMerkleState: parameters.poolMerkleState } : {}
+  });
+}
+async function readLeafEphemeralHex(parameters) {
+  const cached = await parameters.leafEphemeral?.get({
+    poolContract: parameters.poolContractId,
+    leafIndex: parameters.leafIndex
+  });
+  if (cached?.xHex && cached.yHex) {
+    return { xHex: cached.xHex, yHex: cached.yHex };
+  }
+  const client = readPoolClientFactory(parameters.transactEnvironment)({
+    contractId: parameters.poolContractId,
+    walletPublicKey: parameters.walletPublicKey,
+    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
+    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
+  });
+  const read = await client.get_leaf_ephemeral({ leaf_index: parameters.leafIndex });
+  const coords = read.result;
+  if (!coords?.x || !coords?.y) {
+    throw new Error("Missing leaf ephemeral key on contract");
+  }
+  const xHex = Buffer13.from(coords.x).toString("hex");
+  const yHex = Buffer13.from(coords.y).toString("hex");
+  await parameters.leafEphemeral?.set({
+    poolContract: parameters.poolContractId,
+    leafIndex: parameters.leafIndex,
+    xHex,
+    yHex,
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { xHex, yHex };
+}
+
+// src/state/foundation/paths.ts
+var STELLAR_STATE_PATHS = {
+  privateRecords: "$.privateRecords",
+  pendingClaimsItems: "$.pendingClaims.items",
+  pendingClaimsPagination: "$.pendingClaims.pagination",
+  pendingClaimsCountByOwner: "$.pendingClaims.countByOwner",
+  registryPrivateAddresses: "$.registry.privateAddresses",
+  registryRegisteredAddresses: "$.registry.registeredAddresses",
+  registryLookups: "$.registry.lookups",
+  assets: "$.assets",
+  assetsById: "$.assets.byId",
+  assetsListOrder: "$.assets.listOrder",
+  publicBalances: "$.balances.publicByOwnerAsset",
+  poolsByContract: "$.pools.byContract",
+  poolsLeafEphemeral: "$.pools.leafEphemeralByContractAndIndex",
+  deliveriesIncomingById: "$.deliveries.incomingById",
+  deliveriesSync: "$.deliveries.syncByPrivateAddressAsset",
+  transactionsByHash: "$.transactions.byHash",
+  walletPrivateAddressScalars: "$.wallet.privateAddressScalars",
+  walletPrivateAddressRecords: "$.wallet.privateAddressRecords",
+  walletDefaultPrivateAddressNonce: "$.wallet.defaultPrivateAddressNonce"
+};
+
+// src/state/schemas/shared.ts
+import { z } from "zod";
+var pendingClaimSchema = z.object({
+  id: z.string().min(1),
+  owner: z.string().min(1),
+  asset: z.string().min(1),
+  amount: z.coerce.bigint(),
+  createdAt: z.string().min(1),
+  poolTxId: z.string().optional(),
+  commitmentHex: z.string().optional(),
+  nullifierHex: z.string().optional(),
+  futureNullifierHashHex: z.string().optional(),
+  assetHiHex: z.string().optional(),
+  assetLoHex: z.string().optional(),
+  nullifierFieldHex: z.string().optional(),
+  secretHex: z.string().optional(),
+  tempPublicKeyXHex: z.string().optional(),
+  tempPublicKeyYHex: z.string().optional(),
+  encryptedRecoveryBase64: z.string().optional(),
+  createdAtLedger: z.number().int().optional()
+});
+var paginationSchema = z.object({
+  total: z.number().int().nonnegative(),
+  page: z.number().int().positive(),
+  pageSize: z.number().int().positive(),
+  hasMore: z.boolean()
+});
+var stellarPrivateCoinNoteSchema = z.object({
+  value: z.string(),
+  nullifier: z.string(),
+  secret: z.string(),
+  commitment: z.string(),
+  asset_hi: z.string(),
+  asset_lo: z.string(),
+  application_id: z.string().optional()
+});
+var privateRecordSchema = z.object({
+  id: z.string().min(1),
+  owner: z.string().min(1),
+  asset: z.string().min(1),
+  amount: z.coerce.bigint(),
+  consumed: z.boolean(),
+  status: z.enum(["pending", "finalized", "spent"]).optional(),
+  poolContract: z.string().optional(),
+  commitmentHex: z.string().optional(),
+  nullifierHex: z.string().optional(),
+  amountDisplay: z.number().optional(),
+  deliveryId: z.number().int().optional(),
+  privateAddress: z.string().optional(),
+  txHash: z.string().optional(),
+  coinNote: stellarPrivateCoinNoteSchema.optional(),
+  depositScalarHex: z.string().optional(),
+  precommitementHex: z.string().optional()
+});
+var assetSchema = z.object({
+  id: z.number().int(),
+  assetId: z.string().min(1),
+  name: z.string().min(1),
+  logoUrl: z.string().nullable(),
+  issuerAddress: z.string().nullable(),
+  clientContract: z.string().nullable(),
+  poolContracts: z.array(z.string()),
+  poolContract: z.string().min(1),
+  mintable: z.boolean(),
+  mintAmount: z.string().nullable(),
+  decimals: z.number().int().nullable().optional()
+});
+var publicBalanceSchema = z.object({
+  owner: z.string().min(1),
+  asset: z.string().min(1),
+  balance: z.string(),
+  trustlineStatus: z.enum(["active", "inactive", "none"])
+});
+var registryLookupSchema = z.object({
+  owner: z.string().min(1),
+  status: z.enum(["registered", "unregistered"]),
+  privateAddressStpl1: z.string().optional(),
+  publicKeyXHex: z.string().optional(),
+  publicKeyYHex: z.string().optional(),
+  updatedAtLedger: z.number().int().optional(),
+  cachedAt: z.string().optional()
+});
+var walletPrivateAddressScalarSchema = z.object({
+  owner: z.string().min(1),
+  nonce: z.string().min(1),
+  scalarHex: z.string().min(1),
+  updatedAt: z.string().optional()
+});
+var walletPrivateAddressRecordSchema = z.object({
+  owner: z.string().min(1),
+  nonce: z.string().min(1),
+  privateAddress: z.string().min(1),
+  createdAt: z.number()
+});
+var poolMerkleStateSchema = z.object({
+  poolContract: z.string().min(1),
+  commitments: z.array(z.string()),
+  commitmentCount: z.number().int().nonnegative(),
+  merkleRootHex: z.string().min(1),
+  updatedAt: z.number(),
+  syncedLedger: z.number().int().optional()
+});
+var leafEphemeralSchema = z.object({
+  poolContract: z.string().min(1),
+  leafIndex: z.number().int().nonnegative(),
+  xHex: z.string().min(1),
+  yHex: z.string().min(1),
+  cachedAt: z.string().optional()
+});
+var incomingDeliverySchema = z.object({
+  id: z.number().int(),
+  privateAddress: z.string().min(1),
+  asset: z.string().min(1),
+  ciphertextBase64: z.string().min(1),
+  ephemeralKey: z.string().min(1),
+  tagBase64: z.string().min(1),
+  createdAt: z.string().min(1),
+  processed: z.boolean().optional()
+});
+var deliverySyncStateSchema = z.object({
+  privateAddress: z.string().min(1),
+  asset: z.string().min(1),
+  bloomM: z.number().int().positive(),
+  bloomK: z.number().int().positive(),
+  bloomBitsBase64: z.string().optional(),
+  lastPage: z.number().int().positive().optional(),
+  lastPolledAt: z.string().optional()
+});
+var transactionStatusSchema = z.object({
+  txHash: z.string().min(1),
+  status: z.enum(["pending", "success", "failed"]),
+  ledger: z.number().int().optional(),
+  createdAt: z.string().optional()
+});
+
+// src/state/foundation/coerce.ts
+function withoutUndefinedFields(value) {
+  const next = {};
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (fieldValue !== void 0) {
+      Reflect.set(next, key, fieldValue);
+    }
+  }
+  return next;
+}
+
+// src/state/read/normalize/assets.ts
+function normalizeAssetsCatalog(value) {
+  if (typeof value !== "object" || value === null) {
+    return { byId: {}, listOrder: [] };
+  }
+  const record = value;
+  const byIdRaw = record.byId;
+  const listOrderRaw = record.listOrder;
+  const byId = {};
+  if (typeof byIdRaw === "object" && byIdRaw !== null) {
+    for (const [key, entry] of Object.entries(byIdRaw)) {
+      const parsed = assetSchema.safeParse(entry);
+      if (parsed.success) {
+        byId[key] = withoutUndefinedFields(parsed.data);
+      }
+    }
+  }
+  const listOrder = Array.isArray(listOrderRaw) ? listOrderRaw.filter((item) => typeof item === "string") : [];
+  return { byId, listOrder };
+}
+function normalizeAsset(value) {
+  const parsed = assetSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizePublicBalance(value) {
+  const parsed = publicBalanceSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function normalizePublicBalancesFromEntries(value, owner) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => {
+    if (!Array.isArray(entry) || entry.length < 2) {
+      return;
+    }
+    const [key, balanceValue] = entry;
+    if (typeof key !== "string" || !key.startsWith(`${owner}:`)) {
+      return;
+    }
+    return normalizePublicBalance(balanceValue);
+  }).filter((balance) => balance !== void 0);
+}
+
+// src/state/read/normalize/claims.ts
+function normalizePendingClaimsState(value) {
+  if (typeof value !== "object" || value === null) {
+    return { items: [] };
+  }
+  const record = value;
+  const items = Array.isArray(record.items) ? record.items.flatMap((item) => {
+    const parsed = pendingClaimSchema.safeParse(item);
+    return parsed.success ? [withoutUndefinedFields(parsed.data)] : [];
+  }) : [];
+  const paginationResult = paginationSchema.safeParse(record.pagination);
+  if (paginationResult.success) {
+    return { items, pagination: paginationResult.data };
+  }
+  return { items };
+}
+function normalizePendingClaimsCount(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+
+// src/state/read/normalize/deliveries.ts
+function normalizeIncomingDeliveries(value) {
+  const entries = typeof value === "object" && value !== null && !Array.isArray(value) ? Object.values(value) : value;
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    const parsed = incomingDeliverySchema.safeParse(entry);
+    return parsed.success ? [withoutUndefinedFields(parsed.data)] : [];
+  });
+}
+function normalizeDeliverySyncState(value) {
+  const parsed = deliverySyncStateSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+
+// src/state/read/normalize/pool.ts
+function normalizePoolMerkleState(value) {
+  const parsed = poolMerkleStateSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizeLeafEphemeral(value) {
+  const parsed = leafEphemeralSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+
+// src/state/read/normalize/registry.ts
+function normalizeCachedPrivateAddress(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function normalizeRegistryLookup(value) {
+  const parsed = registryLookupSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizeRegistryLookupFromLegacy(input) {
+  const lookup = normalizeRegistryLookup(
+    typeof input.registered === "object" && input.registered !== null ? input.registered : void 0
+  );
+  if (lookup) {
+    return lookup;
+  }
+  if (input.registered === void 0 && input.privateAddress === void 0) {
+    return void 0;
+  }
+  const registered2 = Boolean(input.registered);
+  const privateAddressStpl1 = normalizeCachedPrivateAddress(input.privateAddress);
+  if (!registered2 && privateAddressStpl1 === void 0) {
+    return { owner: input.address, status: "unregistered" };
+  }
+  return withoutUndefinedFields({
+    owner: input.address,
+    status: registered2 ? "registered" : "unregistered",
+    ...privateAddressStpl1 === void 0 ? {} : { privateAddressStpl1 }
+  });
+}
+
+// src/state/read/normalize/records.ts
+import "zod";
+function normalizePrivateRecords(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const records = value.flatMap((item) => {
+    const parsed = privateRecordSchema.safeParse(item);
+    return parsed.success ? [normalizePrivateRecordFields(parsed.data)] : [];
+  });
+  return deduplicatePrivateRecords(records);
+}
+function normalizeTransactionStatus(value) {
+  const parsed = transactionStatusSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function privateRecordCommitmentKey(record) {
+  return (record.commitmentHex?.trim() || record.coinNote?.commitment.trim() || record.id.trim()).replace(/^0x/iu, "").toLowerCase();
+}
+function normalizePrivateRecordFields(record) {
+  const normalized = withoutUndefinedFields(record);
+  if (!normalized.privateAddress && normalized.owner.trim().startsWith("stpl")) {
+    return { ...normalized, privateAddress: normalized.owner.trim() };
+  }
+  return normalized;
+}
+function preferPrivateRecord(current, incoming, key) {
+  if (privateRecordIdKey(incoming) === key) {
+    return incoming;
+  }
+  if (privateRecordIdKey(current) === key) {
+    return current;
+  }
+  return incoming;
+}
+function privateRecordIdKey(record) {
+  return record.id.trim().replace(/^0x/iu, "").toLowerCase();
+}
+function deduplicatePrivateRecords(records) {
+  const byCommitment = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const key = privateRecordCommitmentKey(record);
+    const current = byCommitment.get(key);
+    byCommitment.set(key, current ? preferPrivateRecord(current, record, key) : record);
+  }
+  return [...byCommitment.values()];
+}
+
+// src/state/read/normalize/wallet.ts
+function normalizeWalletPrivateAddressScalar(value) {
+  const parsed = walletPrivateAddressScalarSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizeWalletPrivateAddressRecord(value) {
+  const parsed = walletPrivateAddressRecordSchema.safeParse(value);
+  return parsed.success ? withoutUndefinedFields(parsed.data) : void 0;
+}
+function normalizeWalletDefaultPrivateAddressNonce(value) {
+  return typeof value === "string" ? value.trim() || void 0 : void 0;
+}
+
+// src/state/filters/register-schemas.ts
+import { registerArrayFilterItemSchema } from "@arcanetech/privacy-sdk-core/state";
+
+// src/state/filters/ops.ts
+var stellarArrayFilterSchemaKeys = {
+  privateRecord: "privateRecord",
+  pendingClaim: "pendingClaim"
+};
+function rejectPrivateRecordsByIds(ids) {
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.privateRecords,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.privateRecord,
+    rejectWhen: {
+      op: "fieldIn",
+      field: "id",
+      values: ids
+    }
+  };
+}
+function rejectConsumedPrivateRecords() {
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.privateRecords,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.privateRecord,
+    rejectWhen: {
+      op: "fieldEquals",
+      field: "consumed",
+      value: true
+    }
+  };
+}
+function rejectPendingClaimsByOwner(owner) {
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.pendingClaim,
+    rejectWhen: {
+      op: "fieldEquals",
+      field: "owner",
+      value: owner
+    }
+  };
+}
+function rejectPendingClaimsByIds(ids) {
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.pendingClaim,
+    rejectWhen: {
+      op: "fieldIn",
+      field: "id",
+      values: ids
+    }
+  };
+}
+function rejectPendingClaimsByOwnerAndAsset(input) {
+  const matches = [];
+  if (input.owner !== void 0) {
+    matches.push({
+      op: "fieldEquals",
+      field: "owner",
+      value: input.owner
+    });
+  }
+  if (input.asset !== void 0) {
+    matches.push({
+      op: "fieldEquals",
+      field: "asset",
+      value: input.asset
+    });
+  }
+  return {
+    opType: "arrayFilter",
+    jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+    itemSchemaKey: stellarArrayFilterSchemaKeys.pendingClaim,
+    rejectWhen: {
+      op: "and",
+      matches
+    }
+  };
+}
+
+// src/state/filters/register-schemas.ts
+var registered = false;
+function registerStellarArrayFilterSchemas() {
+  if (registered) {
+    return;
+  }
+  registerArrayFilterItemSchema(
+    stellarArrayFilterSchemaKeys.privateRecord,
+    privateRecordSchema
+  );
+  registerArrayFilterItemSchema(
+    stellarArrayFilterSchemaKeys.pendingClaim,
+    pendingClaimSchema
+  );
+  registered = true;
+}
+
+// src/state/bridge/call-types.ts
+import "@arcanetech/privacy-sdk-core/state";
+var stellarStateCallTypes = {
+  pendingClaims: "pendingClaims",
+  clearPendingClaims: "clearPendingClaims",
+  readPendingClaims: "readPendingClaims",
+  replacePendingClaimsPage: "replacePendingClaimsPage",
+  upsertPendingClaims: "upsertPendingClaims",
+  removePendingClaims: "removePendingClaims",
+  setPendingClaimsCount: "setPendingClaimsCount",
+  readPendingClaimsCount: "readPendingClaimsCount",
+  readStellarAddressRegistered: "readStellarAddressRegistered",
+  readCachedPrivateAddress: "readCachedPrivateAddress",
+  readRegistryLookup: "readRegistryLookup",
+  saveRegisteredPrivateAddress: "saveRegisteredPrivateAddress",
+  saveRegistryLookup: "saveRegistryLookup",
+  invalidateRegisteredAddress: "invalidateRegisteredAddress",
+  invalidateRegistryLookup: "invalidateRegistryLookup",
+  readAssetsCatalog: "readAssetsCatalog",
+  readAsset: "readAsset",
+  replaceAssets: "replaceAssets",
+  upsertAssets: "upsertAssets",
+  readPublicBalance: "readPublicBalance",
+  readPublicBalances: "readPublicBalances",
+  setPublicBalance: "setPublicBalance",
+  setPublicBalances: "setPublicBalances",
+  readPoolMerkleState: "readPoolMerkleState",
+  setPoolMerkleState: "setPoolMerkleState",
+  readLeafEphemeral: "readLeafEphemeral",
+  setLeafEphemeral: "setLeafEphemeral",
+  listPrivateRecords: "listPrivateRecords",
+  savePrivateRecords: "savePrivateRecords",
+  replacePrivateRecords: "replacePrivateRecords",
+  upsertPrivateRecords: "upsertPrivateRecords",
+  pruneConsumedPrivateRecords: "pruneConsumedPrivateRecords",
+  readIncomingDeliveries: "readIncomingDeliveries",
+  upsertIncomingDeliveries: "upsertIncomingDeliveries",
+  readDeliverySyncState: "readDeliverySyncState",
+  setDeliverySyncState: "setDeliverySyncState",
+  readTransactionStatus: "readTransactionStatus",
+  setTransactionStatus: "setTransactionStatus",
+  clearTransactionStatus: "clearTransactionStatus",
+  saveWalletPrivateAddressScalar: "saveWalletPrivateAddressScalar",
+  readWalletPrivateAddressScalar: "readWalletPrivateAddressScalar",
+  saveWalletPrivateAddressRecord: "saveWalletPrivateAddressRecord",
+  readWalletPrivateAddressRecord: "readWalletPrivateAddressRecord",
+  setWalletDefaultPrivateAddressNonce: "setWalletDefaultPrivateAddressNonce",
+  readWalletDefaultPrivateAddressNonce: "readWalletDefaultPrivateAddressNonce",
+  deleteWalletPrivateAddressScalar: "deleteWalletPrivateAddressScalar"
+};
+
+// src/state/schemas/assets/catalog.ts
+import { z as z3 } from "zod";
+var readAssetsCatalogSchema = z3.object({
+  type: z3.literal(stellarStateCallTypes.readAssetsCatalog)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "primitiveGet",
+      jsonPath: STELLAR_STATE_PATHS.assets
+    }
+  ]
+}));
+var readAssetSchema = z3.object({
+  type: z3.literal(stellarStateCallTypes.readAsset),
+  assetId: z3.string().min(1)
+}).transform(({ type, assetId }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.assetsById,
+      key: assetId
+    }
+  ]
+}));
+var replaceAssetsSchema = z3.object({
+  type: z3.literal(stellarStateCallTypes.replaceAssets),
+  assets: z3.array(assetSchema)
+}).transform(({ type, assets }) => {
+  const byId = {};
+  const listOrder = [];
+  for (const asset of assets) {
+    Reflect.set(byId, asset.assetId, withoutUndefinedFields(asset));
+    listOrder.push(asset.assetId);
+  }
+  return {
+    type,
+    operations: [
+      {
+        opType: "primitiveSet",
+        jsonPath: STELLAR_STATE_PATHS.assets,
+        value: { byId, listOrder }
+      }
+    ]
+  };
+});
+var upsertAssetsSchema = z3.object({
+  type: z3.literal(stellarStateCallTypes.upsertAssets),
+  assets: z3.array(assetSchema)
+}).transform(({ type, assets }) => ({
+  type,
+  operations: assets.map((asset) => ({
+    opType: "recordSet",
+    jsonPath: STELLAR_STATE_PATHS.assetsById,
+    key: asset.assetId,
+    value: asset
+  }))
+}));
+
+// src/state/definitions/assets.ts
+var stellarAssetsStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readAssetsCatalog,
+    mode: "read",
+    schema: readAssetsCatalogSchema
+  },
+  {
+    type: stellarStateCallTypes.readAsset,
+    mode: "read",
+    schema: readAssetSchema
+  },
+  {
+    type: stellarStateCallTypes.replaceAssets,
+    mode: "write",
+    schema: replaceAssetsSchema
+  },
+  {
+    type: stellarStateCallTypes.upsertAssets,
+    mode: "write",
+    schema: upsertAssetsSchema
+  }
+];
+
+// src/state/schemas/assets/balances.ts
+import { z as z4 } from "zod";
+
+// src/state/foundation/keys.ts
+function ownerAssetKey(owner, asset) {
+  return `${owner}:${asset}`;
+}
+function readRecordValue(record, key) {
+  if (!Object.hasOwn(record, key)) {
+    return void 0;
+  }
+  return Reflect.get(record, key);
+}
+function poolLeafKey(poolContract, leafIndex) {
+  return `${poolContract}:${leafIndex}`;
+}
+function privateAddressAssetKey(privateAddress, asset) {
+  return `${privateAddress}:${asset}`;
+}
+function walletOwnerNonceKey(owner, nonce) {
+  return `${owner}:${nonce}`;
+}
+
+// src/state/schemas/assets/balances.ts
+var readPublicBalanceSchema = z4.object({
+  type: z4.literal(stellarStateCallTypes.readPublicBalance),
+  owner: z4.string().min(1),
+  asset: z4.string().min(1)
+}).transform(({ type, owner, asset }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.publicBalances,
+      key: ownerAssetKey(owner, asset)
+    }
+  ]
+}));
+var readPublicBalancesSchema = z4.object({
+  type: z4.literal(stellarStateCallTypes.readPublicBalances),
+  owner: z4.string().min(1)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordEntries",
+      jsonPath: STELLAR_STATE_PATHS.publicBalances
+    }
+  ]
+}));
+var setPublicBalanceSchema = z4.object({
+  type: z4.literal(stellarStateCallTypes.setPublicBalance),
+  balance: publicBalanceSchema
+}).transform(({ type, balance }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.publicBalances,
+      key: ownerAssetKey(balance.owner, balance.asset),
+      value: balance
+    }
+  ]
+}));
+var setPublicBalancesSchema = z4.object({
+  type: z4.literal(stellarStateCallTypes.setPublicBalances),
+  owner: z4.string().min(1),
+  balances: z4.array(publicBalanceSchema)
+}).transform(({ type, owner, balances }) => ({
+  type,
+  operations: balances.map((balance) => ({
+    opType: "recordSet",
+    jsonPath: STELLAR_STATE_PATHS.publicBalances,
+    key: ownerAssetKey(owner, balance.asset),
+    value: { ...balance, owner }
+  }))
+}));
+
+// src/state/definitions/balances.ts
+var stellarBalancesStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readPublicBalance,
+    mode: "read",
+    schema: readPublicBalanceSchema
+  },
+  {
+    type: stellarStateCallTypes.readPublicBalances,
+    mode: "read",
+    schema: readPublicBalancesSchema
+  },
+  {
+    type: stellarStateCallTypes.setPublicBalance,
+    mode: "write",
+    schema: setPublicBalanceSchema
+  },
+  {
+    type: stellarStateCallTypes.setPublicBalances,
+    mode: "write",
+    schema: setPublicBalancesSchema
+  }
+];
+
+// src/state/schemas/claims/write.ts
+import { z as z5 } from "zod";
+var pendingClaimsWriteSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.pendingClaims),
+  claims: z5.array(pendingClaimSchema),
+  paginationInfo: paginationSchema
+}).transform(({ type, claims, paginationInfo }) => ({
+  type,
+  operations: [
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+      items: claims
+    },
+    {
+      opType: "primitiveSet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsPagination,
+      value: paginationInfo
+    }
+  ]
+}));
+var clearPendingClaimsSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.clearPendingClaims),
+  owner: z5.string().optional(),
+  asset: z5.string().optional()
+}).transform(({ type, owner, asset }) => {
+  if (owner === void 0 && asset === void 0) {
+    return {
+      type,
+      operations: [
+        {
+          opType: "arrayClean",
+          jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems
+        }
+      ]
+    };
+  }
+  return {
+    type,
+    operations: [rejectPendingClaimsByOwnerAndAsset({ owner, asset })]
+  };
+});
+var readPendingClaimsSchema = z5.object({
+  type: z5.literal(stellarStateCallTypes.readPendingClaims)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "primitiveGet",
+      jsonPath: "$.pendingClaims"
+    }
+  ]
+}));
+
+// src/state/schemas/claims/page.ts
+import { z as z6 } from "zod";
+var pendingClaimBridgeItemSchema = pendingClaimSchema;
+var replacePendingClaimsPageSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.replacePendingClaimsPage),
+  owner: z6.string().min(1),
+  claims: z6.array(pendingClaimBridgeItemSchema),
+  paginationInfo: z6.object({
+    total: z6.number().int().nonnegative(),
+    page: z6.number().int().positive(),
+    pageSize: z6.number().int().positive(),
+    hasMore: z6.boolean()
+  }),
+  count: z6.number().int().nonnegative().optional()
+}).transform(({ type, owner, claims, paginationInfo, count }) => ({
+  type,
+  operations: [
+    rejectPendingClaimsByOwner(owner),
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+      items: claims
+    },
+    {
+      opType: "primitiveSet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsPagination,
+      value: paginationInfo
+    },
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
+      key: owner,
+      value: count ?? paginationInfo.total
+    }
+  ]
+}));
+var upsertPendingClaimsSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.upsertPendingClaims),
+  claims: z6.array(pendingClaimBridgeItemSchema)
+}).transform(({ type, claims }) => ({
+  type,
+  operations: [
+    rejectPendingClaimsByIds(claims.map((claim) => claim.id)),
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsItems,
+      items: claims
+    }
+  ]
+}));
+var removePendingClaimsSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.removePendingClaims),
+  ids: z6.array(z6.string().min(1))
+}).transform(({ type, ids }) => ({
+  type,
+  operations: [rejectPendingClaimsByIds(ids)]
+}));
+var readPendingClaimsCountSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.readPendingClaimsCount),
+  owner: z6.string().min(1)
+}).transform(({ type, owner }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
+      key: owner
+    }
+  ]
+}));
+var setPendingClaimsCountSchema = z6.object({
+  type: z6.literal(stellarStateCallTypes.setPendingClaimsCount),
+  owner: z6.string().min(1),
+  count: z6.number().int().nonnegative()
+}).transform(({ type, owner, count }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.pendingClaimsCountByOwner,
+      key: owner,
+      value: count
+    }
+  ]
+}));
+
+// src/state/definitions/claims.ts
+var stellarClaimsStateDefinitions = [
+  {
+    type: stellarStateCallTypes.pendingClaims,
+    mode: "write",
+    schema: pendingClaimsWriteSchema
+  },
+  {
+    type: stellarStateCallTypes.clearPendingClaims,
+    mode: "write",
+    schema: clearPendingClaimsSchema
+  },
+  {
+    type: stellarStateCallTypes.readPendingClaims,
+    mode: "read",
+    schema: readPendingClaimsSchema
+  },
+  {
+    type: stellarStateCallTypes.replacePendingClaimsPage,
+    mode: "write",
+    schema: replacePendingClaimsPageSchema
+  },
+  {
+    type: stellarStateCallTypes.upsertPendingClaims,
+    mode: "write",
+    schema: upsertPendingClaimsSchema
+  },
+  {
+    type: stellarStateCallTypes.removePendingClaims,
+    mode: "write",
+    schema: removePendingClaimsSchema
+  },
+  {
+    type: stellarStateCallTypes.readPendingClaimsCount,
+    mode: "read",
+    schema: readPendingClaimsCountSchema
+  },
+  {
+    type: stellarStateCallTypes.setPendingClaimsCount,
+    mode: "write",
+    schema: setPendingClaimsCountSchema
+  }
+];
+
+// src/state/schemas/claims/deliveries.ts
+import { z as z7 } from "zod";
+var readIncomingDeliveriesSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.readIncomingDeliveries)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "primitiveGet",
+      jsonPath: STELLAR_STATE_PATHS.deliveriesIncomingById
+    }
+  ]
+}));
+var upsertIncomingDeliveriesSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.upsertIncomingDeliveries),
+  deliveries: z7.array(incomingDeliverySchema)
+}).transform(({ type, deliveries }) => ({
+  type,
+  operations: deliveries.map((delivery) => ({
+    opType: "recordSet",
+    jsonPath: STELLAR_STATE_PATHS.deliveriesIncomingById,
+    key: String(delivery.id),
+    value: delivery
+  }))
+}));
+var readDeliverySyncStateSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.readDeliverySyncState),
+  privateAddress: z7.string().min(1),
+  asset: z7.string().min(1)
+}).transform(({ type, privateAddress, asset }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.deliveriesSync,
+      key: privateAddressAssetKey(privateAddress, asset)
+    }
+  ]
+}));
+var setDeliverySyncStateSchema = z7.object({
+  type: z7.literal(stellarStateCallTypes.setDeliverySyncState),
+  syncState: deliverySyncStateSchema
+}).transform(({ type, syncState }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.deliveriesSync,
+      key: privateAddressAssetKey(syncState.privateAddress, syncState.asset),
+      value: syncState
+    }
+  ]
+}));
+
+// src/state/definitions/deliveries.ts
+var stellarDeliveriesStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readIncomingDeliveries,
+    mode: "read",
+    schema: readIncomingDeliveriesSchema
+  },
+  {
+    type: stellarStateCallTypes.upsertIncomingDeliveries,
+    mode: "write",
+    schema: upsertIncomingDeliveriesSchema
+  },
+  {
+    type: stellarStateCallTypes.readDeliverySyncState,
+    mode: "read",
+    schema: readDeliverySyncStateSchema
+  },
+  {
+    type: stellarStateCallTypes.setDeliverySyncState,
+    mode: "write",
+    schema: setDeliverySyncStateSchema
+  }
+];
+
+// src/state/schemas/pool/merkle.ts
+import { z as z8 } from "zod";
+var readPoolMerkleStateSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.readPoolMerkleState),
+  poolContract: z8.string().min(1)
+}).transform(({ type, poolContract }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.poolsByContract,
+      key: poolContract
+    }
+  ]
+}));
+var setPoolMerkleStateSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.setPoolMerkleState),
+  state: poolMerkleStateSchema
+}).transform(({ type, state }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.poolsByContract,
+      key: state.poolContract,
+      value: state
+    }
+  ]
+}));
+var readLeafEphemeralSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.readLeafEphemeral),
+  poolContract: z8.string().min(1),
+  leafIndex: z8.number().int().nonnegative()
+}).transform(({ type, poolContract, leafIndex }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.poolsLeafEphemeral,
+      key: poolLeafKey(poolContract, leafIndex)
+    }
+  ]
+}));
+var setLeafEphemeralSchema = z8.object({
+  type: z8.literal(stellarStateCallTypes.setLeafEphemeral),
+  ephemeral: leafEphemeralSchema
+}).transform(({ type, ephemeral }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.poolsLeafEphemeral,
+      key: poolLeafKey(ephemeral.poolContract, ephemeral.leafIndex),
+      value: ephemeral
+    }
+  ]
+}));
+
+// src/state/definitions/pool.ts
+var stellarPoolStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readPoolMerkleState,
+    mode: "read",
+    schema: readPoolMerkleStateSchema
+  },
+  {
+    type: stellarStateCallTypes.setPoolMerkleState,
+    mode: "write",
+    schema: setPoolMerkleStateSchema
+  },
+  {
+    type: stellarStateCallTypes.readLeafEphemeral,
+    mode: "read",
+    schema: readLeafEphemeralSchema
+  },
+  {
+    type: stellarStateCallTypes.setLeafEphemeral,
+    mode: "write",
+    schema: setLeafEphemeralSchema
+  }
+];
+
+// src/state/schemas/records/private.ts
+import { z as z9 } from "zod";
+var listPrivateRecordsSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.listPrivateRecords)
+}).transform(({ type }) => ({
+  type,
+  operations: [
+    {
+      opType: "primitiveGet",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords
+    }
+  ]
+}));
+var savePrivateRecordsSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.savePrivateRecords),
+  records: z9.array(privateRecordSchema)
+}).transform(({ type, records }) => ({
+  type,
+  operations: [
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords,
+      items: records
+    }
+  ]
+}));
+var replacePrivateRecordsSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.replacePrivateRecords),
+  records: z9.array(privateRecordSchema)
+}).transform(({ type, records }) => ({
+  type,
+  operations: [
+    {
+      opType: "arrayClean",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords
+    },
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords,
+      items: records
+    }
+  ]
+}));
+var pruneConsumedPrivateRecordsSchema = z9.object({
+  type: z9.literal(stellarStateCallTypes.pruneConsumedPrivateRecords)
+}).transform(({ type }) => ({
+  type,
+  operations: [rejectConsumedPrivateRecords()]
+}));
+
+// src/state/schemas/records/transactions.ts
+import { z as z10 } from "zod";
+var upsertPrivateRecordsSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.upsertPrivateRecords),
+  records: z10.array(privateRecordSchema)
+}).transform(({ type, records }) => ({
+  type,
+  operations: [
+    rejectPrivateRecordsByIds(records.map((record) => record.id)),
+    {
+      opType: "arrayPush",
+      jsonPath: STELLAR_STATE_PATHS.privateRecords,
+      items: records
+    }
+  ]
+}));
+var readTransactionStatusSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.readTransactionStatus),
+  txHash: z10.string().min(1)
+}).transform(({ type, txHash }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.transactionsByHash,
+      key: txHash
+    }
+  ]
+}));
+var setTransactionStatusSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.setTransactionStatus),
+  status: transactionStatusSchema
+}).transform(({ type, status }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.transactionsByHash,
+      key: status.txHash,
+      value: status
+    }
+  ]
+}));
+var clearTransactionStatusSchema = z10.object({
+  type: z10.literal(stellarStateCallTypes.clearTransactionStatus),
+  txHash: z10.string().min(1)
+}).transform(({ type, txHash }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.transactionsByHash,
+      key: txHash
+    }
+  ]
+}));
+
+// src/state/definitions/records.ts
+var stellarRecordsStateDefinitions = [
+  {
+    type: stellarStateCallTypes.listPrivateRecords,
+    mode: "read",
+    schema: listPrivateRecordsSchema
+  },
+  {
+    type: stellarStateCallTypes.savePrivateRecords,
+    mode: "write",
+    schema: savePrivateRecordsSchema
+  },
+  {
+    type: stellarStateCallTypes.replacePrivateRecords,
+    mode: "write",
+    schema: replacePrivateRecordsSchema
+  },
+  {
+    type: stellarStateCallTypes.upsertPrivateRecords,
+    mode: "write",
+    schema: upsertPrivateRecordsSchema
+  },
+  {
+    type: stellarStateCallTypes.pruneConsumedPrivateRecords,
+    mode: "write",
+    schema: pruneConsumedPrivateRecordsSchema
+  }
+];
+
+// src/state/schemas/registry/lookup.ts
+import { z as z11 } from "zod";
+var readStellarAddressRegisteredSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.readStellarAddressRegistered),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+      key: address
+    }
+  ]
+}));
+var readCachedPrivateAddressSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.readCachedPrivateAddress),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+      key: address
+    }
+  ]
+}));
+var saveRegisteredPrivateAddressSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.saveRegisteredPrivateAddress),
+  address: z11.string().min(1),
+  privateAddress: z11.string().min(1),
+  registered: z11.boolean()
+}).transform(({ type, address, privateAddress, registered: registered2 }) => {
+  const lookup = registryLookupSchema.parse({
+    owner: address,
+    status: registered2 ? "registered" : "unregistered",
+    privateAddressStpl1: registered2 ? privateAddress : void 0,
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    type,
+    operations: [
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+        key: address,
+        value: privateAddress
+      },
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+        key: address,
+        value: registered2
+      },
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryLookups,
+        key: address,
+        value: lookup
+      }
+    ]
+  };
+});
+var invalidateRegisteredAddressSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.invalidateRegisteredAddress),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+      key: address
+    },
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+      key: address
+    },
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryLookups,
+      key: address
+    }
+  ]
+}));
+var readRegistryLookupSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.readRegistryLookup),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.registryLookups,
+      key: address
+    }
+  ]
+}));
+var saveRegistryLookupSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.saveRegistryLookup),
+  lookup: registryLookupSchema
+}).transform(({ type, lookup }) => {
+  const operations = [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.registryLookups,
+      key: lookup.owner,
+      value: lookup
+    }
+  ];
+  if (lookup.status === "registered" && lookup.privateAddressStpl1) {
+    operations.push(
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+        key: lookup.owner,
+        value: lookup.privateAddressStpl1
+      },
+      {
+        opType: "recordSet",
+        jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+        key: lookup.owner,
+        value: true
+      }
+    );
+  } else {
+    operations.push({
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+      key: lookup.owner,
+      value: false
+    });
+  }
+  return { type, operations };
+});
+var invalidateRegistryLookupSchema = z11.object({
+  type: z11.literal(stellarStateCallTypes.invalidateRegistryLookup),
+  address: z11.string().min(1)
+}).transform(({ type, address }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryLookups,
+      key: address
+    },
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryPrivateAddresses,
+      key: address
+    },
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.registryRegisteredAddresses,
+      key: address
+    }
+  ]
+}));
+
+// src/state/definitions/registry.ts
+var stellarRegistryStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readStellarAddressRegistered,
+    mode: "read",
+    schema: readStellarAddressRegisteredSchema
+  },
+  {
+    type: stellarStateCallTypes.readCachedPrivateAddress,
+    mode: "read",
+    schema: readCachedPrivateAddressSchema
+  },
+  {
+    type: stellarStateCallTypes.readRegistryLookup,
+    mode: "read",
+    schema: readRegistryLookupSchema
+  },
+  {
+    type: stellarStateCallTypes.saveRegisteredPrivateAddress,
+    mode: "write",
+    schema: saveRegisteredPrivateAddressSchema
+  },
+  {
+    type: stellarStateCallTypes.saveRegistryLookup,
+    mode: "write",
+    schema: saveRegistryLookupSchema
+  },
+  {
+    type: stellarStateCallTypes.invalidateRegisteredAddress,
+    mode: "write",
+    schema: invalidateRegisteredAddressSchema
+  },
+  {
+    type: stellarStateCallTypes.invalidateRegistryLookup,
+    mode: "write",
+    schema: invalidateRegistryLookupSchema
+  }
+];
+
+// src/state/definitions/transactions.ts
+var stellarTransactionStateDefinitions = [
+  {
+    type: stellarStateCallTypes.readTransactionStatus,
+    mode: "read",
+    schema: readTransactionStatusSchema
+  },
+  {
+    type: stellarStateCallTypes.setTransactionStatus,
+    mode: "write",
+    schema: setTransactionStatusSchema
+  },
+  {
+    type: stellarStateCallTypes.clearTransactionStatus,
+    mode: "write",
+    schema: clearTransactionStatusSchema
+  }
+];
+
+// src/state/schemas/wallet/scalar.ts
+import { z as z12 } from "zod";
+var saveWalletPrivateAddressScalarSchema = z12.object({
+  type: z12.literal(stellarStateCallTypes.saveWalletPrivateAddressScalar),
+  scalar: walletPrivateAddressScalarSchema
+}).transform(({ type, scalar }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressScalars,
+      key: walletOwnerNonceKey(scalar.owner, scalar.nonce),
+      value: scalar
+    }
+  ]
+}));
+var readWalletPrivateAddressScalarSchema = z12.object({
+  type: z12.literal(stellarStateCallTypes.readWalletPrivateAddressScalar),
+  owner: z12.string().min(1),
+  nonce: z12.string().min(1)
+}).transform(({ type, owner, nonce }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressScalars,
+      key: walletOwnerNonceKey(owner, nonce)
+    }
+  ]
+}));
+
+// src/state/schemas/wallet/private-address.ts
+import { z as z13 } from "zod";
+var saveWalletPrivateAddressRecordSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.saveWalletPrivateAddressRecord),
+  record: walletPrivateAddressRecordSchema
+}).transform(({ type, record }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressRecords,
+      key: walletOwnerNonceKey(record.owner, record.nonce),
+      value: record
+    }
+  ]
+}));
+var readWalletPrivateAddressRecordSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.readWalletPrivateAddressRecord),
+  owner: z13.string().min(1),
+  nonce: z13.string().min(1)
+}).transform(({ type, owner, nonce }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressRecords,
+      key: walletOwnerNonceKey(owner, nonce)
+    }
+  ]
+}));
+var setWalletDefaultPrivateAddressNonceSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.setWalletDefaultPrivateAddressNonce),
+  owner: z13.string().min(1),
+  nonce: z13.string().min(1)
+}).transform(({ type, owner, nonce }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordSet",
+      jsonPath: STELLAR_STATE_PATHS.walletDefaultPrivateAddressNonce,
+      key: owner,
+      value: nonce
+    }
+  ]
+}));
+var readWalletDefaultPrivateAddressNonceSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.readWalletDefaultPrivateAddressNonce),
+  owner: z13.string().min(1)
+}).transform(({ type, owner }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordGet",
+      jsonPath: STELLAR_STATE_PATHS.walletDefaultPrivateAddressNonce,
+      key: owner
+    }
+  ]
+}));
+var deleteWalletPrivateAddressScalarSchema = z13.object({
+  type: z13.literal(stellarStateCallTypes.deleteWalletPrivateAddressScalar),
+  owner: z13.string().min(1),
+  nonce: z13.string().min(1)
+}).transform(({ type, owner, nonce }) => ({
+  type,
+  operations: [
+    {
+      opType: "recordDelete",
+      jsonPath: STELLAR_STATE_PATHS.walletPrivateAddressScalars,
+      key: walletOwnerNonceKey(owner, nonce)
+    }
+  ]
+}));
+
+// src/state/definitions/wallet.ts
+var stellarWalletStateDefinitions = [
+  {
+    type: stellarStateCallTypes.saveWalletPrivateAddressScalar,
+    mode: "write",
+    schema: saveWalletPrivateAddressScalarSchema
+  },
+  {
+    type: stellarStateCallTypes.readWalletPrivateAddressScalar,
+    mode: "read",
+    schema: readWalletPrivateAddressScalarSchema
+  },
+  {
+    type: stellarStateCallTypes.saveWalletPrivateAddressRecord,
+    mode: "write",
+    schema: saveWalletPrivateAddressRecordSchema
+  },
+  {
+    type: stellarStateCallTypes.readWalletPrivateAddressRecord,
+    mode: "read",
+    schema: readWalletPrivateAddressRecordSchema
+  },
+  {
+    type: stellarStateCallTypes.setWalletDefaultPrivateAddressNonce,
+    mode: "write",
+    schema: setWalletDefaultPrivateAddressNonceSchema
+  },
+  {
+    type: stellarStateCallTypes.readWalletDefaultPrivateAddressNonce,
+    mode: "read",
+    schema: readWalletDefaultPrivateAddressNonceSchema
+  },
+  {
+    type: stellarStateCallTypes.deleteWalletPrivateAddressScalar,
+    mode: "write",
+    schema: deleteWalletPrivateAddressScalarSchema
+  }
+];
+
+// src/state/definitions/index.ts
+registerStellarArrayFilterSchemas();
+var stellarStateDefinitions = [
+  ...stellarClaimsStateDefinitions,
+  ...stellarRegistryStateDefinitions,
+  ...stellarAssetsStateDefinitions,
+  ...stellarBalancesStateDefinitions,
+  ...stellarPoolStateDefinitions,
+  ...stellarRecordsStateDefinitions,
+  ...stellarDeliveriesStateDefinitions,
+  ...stellarWalletStateDefinitions,
+  ...stellarTransactionStateDefinitions
+];
+
+// src/state/service/base.ts
+import {
+  createStateBridge
+} from "@arcanetech/privacy-sdk-core/state";
+var StellarStateServiceBase = class {
+  bridge;
+  constructor(adapter) {
+    this.bridge = createStateBridge(adapter);
+    this.bridge.init(stellarStateDefinitions);
+  }
+};
+
+// src/state/service/assets/balance-methods.ts
+function createPublicBalanceMethods(context) {
+  const { bridge } = context;
+  return {
+    async getPublicBalance(input) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readPublicBalance,
+        owner: input.owner,
+        asset: input.asset
+      });
+      return normalizePublicBalance(value);
+    },
+    async getPublicBalances(owner) {
+      const entries = await bridge.read({
+        type: stellarStateCallTypes.readPublicBalances,
+        owner
+      });
+      return normalizePublicBalancesFromEntries(entries, owner);
+    },
+    setPublicBalance(balance) {
+      return bridge.write({
+        type: stellarStateCallTypes.setPublicBalance,
+        balance
+      });
+    },
+    setPublicBalances(input) {
+      return bridge.write({
+        type: stellarStateCallTypes.setPublicBalances,
+        owner: input.owner,
+        balances: input.balances
+      });
+    }
+  };
+}
+
+// src/state/service/assets/upsert-methods.ts
+function createAssetsUpsertMethods(_context, deps) {
+  return {
+    async upsertAssets(assets) {
+      if (assets.length === 0) {
+        return;
+      }
+      const catalog = await deps.getAssetsCatalog();
+      const byId = { ...catalog.byId };
+      const listOrder = [...catalog.listOrder];
+      for (const asset of assets) {
+        byId[asset.assetId] = asset;
+        if (!listOrder.includes(asset.assetId)) {
+          listOrder.push(asset.assetId);
+        }
+      }
+      const merged = listOrder.map((assetId) => readRecordValue(byId, assetId)).filter((asset) => asset !== void 0);
+      await deps.replaceAssets(merged);
+    }
+  };
+}
+
+// src/state/service/assets/catalog-methods.ts
+function createAssetsCatalogMethods(context) {
+  const { bridge } = context;
+  async function getAssetsCatalog() {
+    const value = await bridge.read({
+      type: stellarStateCallTypes.readAssetsCatalog
+    });
+    return normalizeAssetsCatalog(value);
+  }
+  function replaceAssets(assets) {
+    return bridge.write({
+      type: stellarStateCallTypes.replaceAssets,
+      assets
+    });
+  }
+  const coreMethods = {
+    getAssetsCatalog,
+    async getAsset(assetId) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readAsset,
+        assetId
+      });
+      return normalizeAsset(value);
+    },
+    async getAssets() {
+      const catalog = await getAssetsCatalog();
+      return catalog.listOrder.map((assetId) => readRecordValue(catalog.byId, assetId)).filter((asset) => asset !== void 0);
+    },
+    async getAssetsForPool(poolContract) {
+      const assets = await coreMethods.getAssets();
+      return assets.filter((asset) => asset.poolContracts.includes(poolContract));
+    },
+    replaceAssets
+  };
+  return {
+    ...coreMethods,
+    ...createAssetsUpsertMethods(context, {
+      getAssetsCatalog,
+      replaceAssets
+    })
+  };
+}
+
+// src/state/service/assets/index.ts
+function createAssetsService(context) {
+  return {
+    ...createAssetsCatalogMethods(context),
+    ...createPublicBalanceMethods(context)
+  };
+}
+
+// src/state/service/claims/read-methods.ts
+function createClaimsReadMethods(context) {
+  const { bridge } = context;
+  async function getPendingClaims(filter = {}) {
+    const value = await bridge.read({
+      type: stellarStateCallTypes.readPendingClaims
+    });
+    const state = normalizePendingClaimsState(value);
+    const items = state.items.filter((claim) => {
+      if (filter.owner !== void 0 && claim.owner !== filter.owner) {
+        return false;
+      }
+      if (filter.asset !== void 0 && claim.asset !== filter.asset) {
+        return false;
+      }
+      return true;
+    });
+    if (state.pagination !== void 0) {
+      return { items, pagination: state.pagination };
+    }
+    return { items };
+  }
+  return {
+    getPendingClaims,
+    async getPendingClaimsCount(owner) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readPendingClaimsCount,
+        owner
+      });
+      const count = normalizePendingClaimsCount(value);
+      if (count !== void 0) {
+        return count;
+      }
+      const claims = await getPendingClaims({ owner });
+      return claims.items.length;
+    }
+  };
+}
+
+// src/state/service/claims/write-methods.ts
+function appendPendingClaims(bridge, claims, paginationInfo) {
+  return bridge.write({
+    type: stellarStateCallTypes.pendingClaims,
+    claims,
+    paginationInfo
+  });
+}
+function replacePendingClaimsPage(bridge, input) {
+  return bridge.write({
+    type: stellarStateCallTypes.replacePendingClaimsPage,
+    owner: input.owner,
+    claims: input.claims,
+    paginationInfo: input.paginationInfo,
+    ...input.count === void 0 ? {} : { count: input.count }
+  });
+}
+function upsertPendingClaims(bridge, claims) {
+  return bridge.write({
+    type: stellarStateCallTypes.upsertPendingClaims,
+    claims
+  });
+}
+function removePendingClaims(bridge, ids) {
+  return bridge.write({
+    type: stellarStateCallTypes.removePendingClaims,
+    ids
+  });
+}
+function clearPendingClaims(bridge, input = {}) {
+  return bridge.write({
+    type: stellarStateCallTypes.clearPendingClaims,
+    ...input.owner === void 0 ? {} : { owner: input.owner },
+    ...input.asset === void 0 ? {} : { asset: input.asset }
+  });
+}
+function setPendingClaimsCount(bridge, owner, count) {
+  return bridge.write({
+    type: stellarStateCallTypes.setPendingClaimsCount,
+    owner,
+    count
+  });
+}
+function createClaimsWriteMethods(context) {
+  const { bridge } = context;
+  return {
+    appendPendingClaims: (claims, paginationInfo) => appendPendingClaims(bridge, claims, paginationInfo),
+    replacePendingClaimsPage: (input) => replacePendingClaimsPage(bridge, input),
+    upsertPendingClaims: (claims) => upsertPendingClaims(bridge, claims),
+    removePendingClaims: (ids) => removePendingClaims(bridge, ids),
+    clearPendingClaims: (input = {}) => clearPendingClaims(bridge, input),
+    setPendingClaimsCount: (owner, count) => setPendingClaimsCount(bridge, owner, count)
+  };
+}
+
+// src/state/service/claims/index.ts
+function createClaimsService(context) {
+  return {
+    ...createClaimsWriteMethods(context),
+    ...createClaimsReadMethods(context)
+  };
+}
+
+// src/state/service/deliveries/incoming-methods.ts
+function createIncomingDeliveryMethods(context) {
+  const { bridge } = context;
+  async function getIncomingDeliveries(filter) {
+    const values = await bridge.read({
+      type: stellarStateCallTypes.readIncomingDeliveries
+    });
+    const deliveries = normalizeIncomingDeliveries(values);
+    return deliveries.filter((delivery) => {
+      if (delivery.privateAddress !== filter.privateAddress) {
+        return false;
+      }
+      if (filter.asset !== void 0 && delivery.asset !== filter.asset) {
+        return false;
+      }
+      if (!filter.includeProcessed && delivery.processed) {
+        return false;
+      }
+      return true;
+    });
+  }
+  function upsertIncomingDeliveries(deliveries) {
+    return bridge.write({
+      type: stellarStateCallTypes.upsertIncomingDeliveries,
+      deliveries
+    });
+  }
+  return {
+    getIncomingDeliveries,
+    upsertIncomingDeliveries,
+    async markDeliveryProcessed(id) {
+      const deliveries = await bridge.read({
+        type: stellarStateCallTypes.readIncomingDeliveries
+      });
+      const match = normalizeIncomingDeliveries(deliveries).find(
+        (delivery) => delivery.id === id
+      );
+      if (!match) {
+        return;
+      }
+      await upsertIncomingDeliveries([{ ...match, processed: true }]);
+    }
+  };
+}
+
+// src/state/service/deliveries/sync-methods.ts
+function createDeliverySyncMethods(context) {
+  const { bridge } = context;
+  return {
+    async getDeliverySyncState(input) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readDeliverySyncState,
+        privateAddress: input.privateAddress,
+        asset: input.asset
+      });
+      return normalizeDeliverySyncState(value);
+    },
+    setDeliverySyncState(syncState) {
+      return bridge.write({
+        type: stellarStateCallTypes.setDeliverySyncState,
+        syncState
+      });
+    }
+  };
+}
+
+// src/state/service/deliveries/index.ts
+function createDeliveriesService(context) {
+  return {
+    ...createIncomingDeliveryMethods(context),
+    ...createDeliverySyncMethods(context)
+  };
+}
+
+// src/state/service/pool/ephemeral.ts
+function isMissingStatePathError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes("Record path not found:") || error.message.includes("JSONPath segment not found:");
+}
+function createPoolEphemeralService(context) {
+  const { bridge } = context;
+  return {
+    async getLeafEphemeral(input) {
+      try {
+        const value = await bridge.read({
+          type: stellarStateCallTypes.readLeafEphemeral,
+          poolContract: input.poolContract,
+          leafIndex: input.leafIndex
+        });
+        return normalizeLeafEphemeral(value);
+      } catch (error) {
+        if (isMissingStatePathError(error)) {
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    setLeafEphemeral(ephemeral) {
+      return bridge.write({
+        type: stellarStateCallTypes.setLeafEphemeral,
+        ephemeral
+      });
+    }
+  };
+}
+
+// src/state/service/pool/merkle.ts
+function isMissingStatePathError2(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes("Record path not found:") || error.message.includes("JSONPath segment not found:");
+}
+function createPoolMerkleService(context) {
+  const { bridge } = context;
+  return {
+    async getPoolMerkleState(poolContract) {
+      try {
+        const value = await bridge.read({
+          type: stellarStateCallTypes.readPoolMerkleState,
+          poolContract
+        });
+        return normalizePoolMerkleState(value);
+      } catch (error) {
+        if (isMissingStatePathError2(error)) {
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    setPoolMerkleState(state) {
+      return bridge.write({
+        type: stellarStateCallTypes.setPoolMerkleState,
+        state
+      });
+    },
+    async appendPoolCommitments(input) {
+      const current = await this.getPoolMerkleState(input.poolContract);
+      const mergedCommitments = [...current?.commitments ?? [], ...input.commitments];
+      await this.setPoolMerkleState(
+        withoutUndefinedFields({
+          poolContract: input.poolContract,
+          commitments: mergedCommitments,
+          commitmentCount: mergedCommitments.length,
+          merkleRootHex: input.merkleRootHex,
+          updatedAt: Date.now(),
+          syncedLedger: input.syncedLedger ?? current?.syncedLedger
+        })
+      );
+    }
+  };
+}
+
+// src/state/service/records/private-record-upsert.ts
+function privateCoinNotesEqual(left, right) {
+  if (left === void 0 || right === void 0) {
+    return left === right;
+  }
+  return left.value === right.value && left.nullifier === right.nullifier && left.secret === right.secret && left.commitment === right.commitment && left.asset_hi === right.asset_hi && left.asset_lo === right.asset_lo && left.application_id === right.application_id;
+}
+function privateRecordCoreFieldsEqual(left, right) {
+  return left.id === right.id && left.owner === right.owner && left.asset === right.asset && left.amount === right.amount && left.consumed === right.consumed && left.status === right.status && left.poolContract === right.poolContract && left.amountDisplay === right.amountDisplay;
+}
+function privateRecordChainFieldsEqual(left, right) {
+  return left.commitmentHex === right.commitmentHex && left.nullifierHex === right.nullifierHex && left.deliveryId === right.deliveryId && left.privateAddress === right.privateAddress && left.txHash === right.txHash;
+}
+function privateRecordSecretFieldsEqual(left, right) {
+  return left.depositScalarHex === right.depositScalarHex && left.precommitementHex === right.precommitementHex && privateCoinNotesEqual(left.coinNote, right.coinNote);
+}
+function privateRecordsEqual(left, right) {
+  return privateRecordCoreFieldsEqual(left, right) && privateRecordChainFieldsEqual(left, right) && privateRecordSecretFieldsEqual(left, right);
+}
+function privateRecordArraysEqual(left, right) {
+  return left.length === right.length && left.every((record, index) => {
+    const rightRecord = right.at(index);
+    return rightRecord !== void 0 && privateRecordsEqual(record, rightRecord);
+  });
+}
+function mergePrivateRecords(current, records) {
+  const ids = new Set(records.map((record) => record.id));
+  return [...current.filter((record) => !ids.has(record.id)), ...records];
+}
+
+// src/state/service/records/private-methods.ts
+async function readPrivateRecords(bridge) {
+  const value = await bridge.read({
+    type: stellarStateCallTypes.listPrivateRecords
+  });
+  return normalizePrivateRecords(value);
+}
+function writeReplacePrivateRecords(bridge, records) {
+  return bridge.write({
+    type: stellarStateCallTypes.replacePrivateRecords,
+    records
+  });
+}
+async function readAvailablePrivateRecords(bridge, filter) {
+  const records = await readPrivateRecords(bridge);
+  return records.filter((record) => matchesPrivateRecordFilter(record, filter, false));
+}
+async function applyPrivateRecordsStatus(bridge, records, status) {
+  const current = await readPrivateRecords(bridge);
+  const ids = new Set(records.map((record) => record.id));
+  const next = current.map(
+    (record) => ids.has(record.id) ? {
+      ...record,
+      status,
+      consumed: status === "spent" ? true : record.consumed
+    } : record
+  );
+  await writeReplacePrivateRecords(bridge, next);
+}
+function aggregatePrivateAssetRows(records, owner) {
+  const available = records.filter(
+    (record) => record.owner === owner && !record.consumed && record.status !== "spent"
+  );
+  const byAsset = /* @__PURE__ */ new Map();
+  for (const record of available) {
+    const existing = byAsset.get(record.asset);
+    const amountDisplay = record.amountDisplay ?? Number(record.amount);
+    if (existing) {
+      existing.totalAmount += record.amount;
+      existing.totalAmountDisplay += amountDisplay;
+    } else {
+      byAsset.set(record.asset, {
+        assetId: record.asset,
+        poolContract: record.poolContract ?? "",
+        totalAmount: record.amount,
+        totalAmountDisplay: amountDisplay
+      });
+    }
+  }
+  return [...byAsset.values()].toSorted(
+    (left, right) => left.assetId.localeCompare(right.assetId)
+  );
+}
+function pruneConsumedPrivateRecords(bridge) {
+  return bridge.write({
+    type: stellarStateCallTypes.pruneConsumedPrivateRecords
+  });
+}
+function savePrivateRecords(bridge, records) {
+  return bridge.write({
+    type: stellarStateCallTypes.savePrivateRecords,
+    records
+  });
+}
+async function upsertPrivateRecords(bridge, records) {
+  if (records.length === 0) {
+    return;
+  }
+  const current = await readPrivateRecords(bridge);
+  const next = mergePrivateRecords(current, records);
+  if (privateRecordArraysEqual(current, next)) {
+    return;
+  }
+  return bridge.write({
+    type: stellarStateCallTypes.upsertPrivateRecords,
+    records
+  });
+}
+async function readPrivateBalance(bridge, input) {
+  const records = await readAvailablePrivateRecords(bridge, {
+    owner: input.owner,
+    asset: input.asset
+  });
+  return records.reduce((total, record) => total + record.amount, 0n);
+}
+async function readPrivateAssetRows(bridge, owner) {
+  const records = await readPrivateRecords(bridge);
+  return aggregatePrivateAssetRows(records, owner);
+}
+function createPrivateRecordMethods(context) {
+  const { bridge } = context;
+  return {
+    pruneConsumedPrivateRecords: () => pruneConsumedPrivateRecords(bridge),
+    getPrivateRecords: () => readPrivateRecords(bridge),
+    getAvailablePrivateRecords: (filter) => readAvailablePrivateRecords(bridge, filter),
+    listPrivateRecords: (filter) => readAvailablePrivateRecords(bridge, filter),
+    savePrivateRecords: (records) => savePrivateRecords(bridge, records),
+    upsertPrivateRecords: (records) => upsertPrivateRecords(bridge, records),
+    markPrivateRecordsUsed: (records) => applyPrivateRecordsStatus(bridge, records, "spent"),
+    markPrivateRecordsStatus: (records, status) => applyPrivateRecordsStatus(bridge, records, status),
+    getPrivateBalance: (input) => readPrivateBalance(bridge, input),
+    getPrivateAssetRows: (owner) => readPrivateAssetRows(bridge, owner)
+  };
+}
+function matchesPrivateRecordFilter(record, filter, includeConsumed) {
+  if (filter.owner !== void 0 && record.owner !== filter.owner) {
+    return false;
+  }
+  if (filter.privateAddress !== void 0 && record.privateAddress !== filter.privateAddress) {
+    return false;
+  }
+  if (filter.owner === void 0 && filter.privateAddress === void 0) {
+    return false;
+  }
+  if (filter.asset !== void 0 && record.asset !== filter.asset) {
+    return false;
+  }
+  if (!includeConsumed && (record.consumed || record.status === "spent")) {
+    return false;
+  }
+  return true;
+}
+
+// src/state/service/records/transaction-methods.ts
+function createTransactionRecordMethods(context) {
+  const { bridge } = context;
+  return {
+    async getTransactionStatus(txHash) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readTransactionStatus,
+        txHash
+      });
+      return normalizeTransactionStatus(value);
+    },
+    setTransactionStatus(status) {
+      return bridge.write({
+        type: stellarStateCallTypes.setTransactionStatus,
+        status
+      });
+    },
+    clearTransactionStatus(txHash) {
+      return bridge.write({
+        type: stellarStateCallTypes.clearTransactionStatus,
+        txHash
+      });
+    }
+  };
+}
+
+// src/state/service/records/index.ts
+function createRecordsService(context) {
+  return {
+    ...createPrivateRecordMethods(context),
+    ...createTransactionRecordMethods(context)
+  };
+}
+
+// src/state/service/registry/lookup-read.ts
+async function readRegistryLookup(bridge, address) {
+  try {
+    const value = await bridge.read({
+      type: stellarStateCallTypes.readRegistryLookup,
+      address
+    });
+    const lookup = normalizeRegistryLookup(value);
+    if (lookup) {
+      return lookup;
+    }
+  } catch {
+  }
+  let registered2;
+  let privateAddress;
+  try {
+    registered2 = await bridge.read({
+      type: stellarStateCallTypes.readStellarAddressRegistered,
+      address
+    });
+  } catch {
+    registered2 = void 0;
+  }
+  try {
+    privateAddress = await bridge.read({
+      type: stellarStateCallTypes.readCachedPrivateAddress,
+      address
+    });
+  } catch {
+    privateAddress = void 0;
+  }
+  return normalizeRegistryLookupFromLegacy({
+    address,
+    registered: registered2,
+    privateAddress
+  });
+}
+async function readCachedPrivateAddress(bridge, address) {
+  const lookup = await readRegistryLookup(bridge, address);
+  if (lookup?.privateAddressStpl1) {
+    return lookup.privateAddressStpl1;
+  }
+  const value = await bridge.read({
+    type: stellarStateCallTypes.readCachedPrivateAddress,
+    address
+  });
+  return normalizeCachedPrivateAddress(value);
+}
+function createRegistryLookupReadMethods(context) {
+  const { bridge } = context;
+  return {
+    getRegistryLookup: (address) => readRegistryLookup(bridge, address),
+    async isStellarAddressRegistered(address) {
+      const lookup = await readRegistryLookup(bridge, address);
+      if (lookup === void 0) {
+        return void 0;
+      }
+      return lookup.status === "registered";
+    },
+    getCachedPrivateAddress: (address) => readCachedPrivateAddress(bridge, address)
+  };
+}
+
+// src/state/service/registry/lookup-write.ts
+function createRegistryLookupWriteMethods(context) {
+  const { bridge } = context;
+  async function invalidateRegistryLookup(address) {
+    return bridge.write({
+      type: stellarStateCallTypes.invalidateRegistryLookup,
+      address
+    });
+  }
+  return {
+    saveRegistryLookup(lookup) {
+      return bridge.write({
+        type: stellarStateCallTypes.saveRegistryLookup,
+        lookup
+      });
+    },
+    saveRegisteredPrivateAddress(input) {
+      return bridge.write({
+        type: stellarStateCallTypes.saveRegisteredPrivateAddress,
+        address: input.address,
+        privateAddress: input.privateAddress,
+        registered: input.registered
+      });
+    },
+    invalidateRegistryLookup,
+    invalidateRegisteredAddress(address) {
+      return invalidateRegistryLookup(address);
+    }
+  };
+}
+
+// src/state/service/registry/lookup.ts
+function createRegistryLookupService(context) {
+  return {
+    ...createRegistryLookupReadMethods(context),
+    ...createRegistryLookupWriteMethods(context)
+  };
+}
+
+// src/state/service/registry/wallet-record-methods.ts
+function createWalletRecordMethods(context) {
+  const { bridge } = context;
+  return {
+    async getWalletPrivateAddressRecord(input) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readWalletPrivateAddressRecord,
+        owner: input.owner,
+        nonce: input.nonce
+      });
+      return normalizeWalletPrivateAddressRecord(value);
+    },
+    saveWalletPrivateAddressRecord(record) {
+      return bridge.write({
+        type: stellarStateCallTypes.saveWalletPrivateAddressRecord,
+        record
+      });
+    },
+    async getWalletDefaultPrivateAddressNonce(owner) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readWalletDefaultPrivateAddressNonce,
+        owner
+      });
+      return normalizeWalletDefaultPrivateAddressNonce(value);
+    },
+    setWalletDefaultPrivateAddressNonce(input) {
+      return bridge.write({
+        type: stellarStateCallTypes.setWalletDefaultPrivateAddressNonce,
+        owner: input.owner,
+        nonce: input.nonce
+      });
+    }
+  };
+}
+
+// src/state/service/registry/wallet-scalar-methods.ts
+function createWalletScalarMethods(context) {
+  const { bridge } = context;
+  return {
+    async getWalletPrivateAddressScalar(input) {
+      const value = await bridge.read({
+        type: stellarStateCallTypes.readWalletPrivateAddressScalar,
+        owner: input.owner,
+        nonce: input.nonce
+      });
+      return normalizeWalletPrivateAddressScalar(value);
+    },
+    saveWalletPrivateAddressScalar(scalar) {
+      return bridge.write({
+        type: stellarStateCallTypes.saveWalletPrivateAddressScalar,
+        scalar
+      });
+    },
+    deleteWalletPrivateAddressScalar(input) {
+      return bridge.write({
+        type: stellarStateCallTypes.deleteWalletPrivateAddressScalar,
+        owner: input.owner,
+        nonce: input.nonce
+      });
+    }
+  };
+}
+
+// src/state/service/registry/wallet-address.ts
+function createWalletAddressService(context) {
+  return {
+    ...createWalletScalarMethods(context),
+    ...createWalletRecordMethods(context)
+  };
+}
+
+// src/state/service/compose.ts
+function composeStellarStateService(adapter) {
+  const base = new StellarStateServiceBase(adapter);
+  return {
+    bridge: base.bridge,
+    ...createAssetsService(base),
+    ...createRegistryLookupService(base),
+    ...createWalletAddressService(base),
+    ...createPoolMerkleService(base),
+    ...createPoolEphemeralService(base),
+    ...createClaimsService(base),
+    ...createDeliveriesService(base),
+    ...createRecordsService(base)
+  };
+}
+
+// src/state/service/index.ts
+function createStellarStateService(adapter) {
+  return composeStellarStateService(adapter);
+}
+
+// src/transact/merkle/attach-state-ports.ts
+function createPoolMerkleStatePort(state) {
+  const stateService = createStellarStateService(state);
+  return {
+    get: (poolContract) => stateService.getPoolMerkleState(poolContract),
+    set: (merkleState) => stateService.setPoolMerkleState(merkleState)
+  };
+}
+function createLeafEphemeralStatePort(state) {
+  const stateService = createStellarStateService(state);
+  return {
+    get: (input) => stateService.getLeafEphemeral(input),
+    set: (ephemeral) => stateService.setLeafEphemeral(ephemeral)
+  };
+}
+function createSenderScalarStateResolver(state) {
+  const stateService = createStellarStateService(state);
+  return async (input) => {
+    const owner = input.owner.trim();
+    if (!owner) {
+      return;
+    }
+    const defaultNonce = await stateService.getWalletDefaultPrivateAddressNonce(owner);
+    if (!defaultNonce) {
+      return;
+    }
+    const requestedAddress = input.privateAddressStpl1.trim();
+    const record = await stateService.getWalletPrivateAddressRecord({
+      owner,
+      nonce: defaultNonce
+    });
+    const recordAddress = record?.privateAddress?.trim();
+    if (recordAddress !== requestedAddress) {
+      return;
+    }
+    const scalar = await stateService.getWalletPrivateAddressScalar({
+      owner,
+      nonce: defaultNonce
+    });
+    const normalized = scalar?.scalarHex?.trim() ?? "";
+    return normalized.length > 0 ? normalized : void 0;
+  };
+}
+function attachPoolStatePorts(transactEnvironment, state) {
+  if (!transactEnvironment) {
+    return void 0;
+  }
+  return {
+    ...transactEnvironment,
+    poolMerkleState: createPoolMerkleStatePort(state),
+    leafEphemeral: createLeafEphemeralStatePort(state),
+    resolveSenderPrivKeyScalarFromState: createSenderScalarStateResolver(state)
+  };
+}
+export {
+  DEFAULT_STEALTH_SIGN_NONCE as DEFAULT_PRIVATE_ADDRESS_SIGN_NONCE,
+  KytInspectError,
+  MIN_CONFIDENTIAL_TRANSFER_STROOPS,
+  PrivacyPoolService,
+  ZERO_STROOPS,
+  assetLegToTokenAddress,
+  attachPoolStatePorts,
+  buildOnboardingPayload,
+  buildPoolTransactionAuditParameters,
+  buildPrivateAddressSignMessage,
+  buildTransferOnboardingAtExecute,
+  configurePrivacyPoolService,
+  createPrivacyPoolService,
+  decodePrivateAddress,
+  encodePrivateAddress,
+  encodePrivateAddressFromHexCoordinates,
+  fetchAndMergeMerkleState,
+  frDecimalToPaddedBytes32,
+  generateRandomDepositScalarHex,
+  generateTemporaryRecipientPrivateAddress,
+  getPrivacyPoolService,
+  loadDefaultStellarBrowserAssets,
+  loadStellarBrowserAssets,
+  parseAuditPublicKeyFromEnvHex,
+  parseKytReasonCode,
+  prepareConfidentialTransferProof,
+  prepareConfidentialTransferProofDual,
+  privateAddressSdk,
+  readLeafEphemeralHex,
+  recipientPublicKeysDecimalFromPrivateAddress,
+  requestKytPassageForPoolInteraction,
+  resolvePoolApplicationId,
+  runTtlPreflight,
+  submitSorobanConfidentialTransfer,
+  submitSorobanDeposit,
+  tokenAddressToAssetLeg
+};
+//# sourceMappingURL=index.js.map