@arcanetech/privacy-sdk-stellar 0.5.1 → 0.5.2

package/dist/node.d.ts

@@ -198,14 +198,15 @@ interface StellarTransactEnvironment {
     network: StellarNetworkConfig;
     /**
      * Nonce (persistent storage key) of the pool's `ZkConfig` entry this
-     * environment's proofs/circuit shape target. Defaults to `2n` (Commitment
-     * V2, 95 public signals) when omitted. Nonce `0` is the retired 93-signal
-     * layout and must be passed explicitly.
+     * environment's proofs/circuit shape target. Defaults to `3n` (bundled 2×2
+     * binding layout) when omitted. Also bundled: `7n` (6×6). The value must
+     * match the on-chain pool config or bootstrap/execute fails with
+     * `no zk circuit configured for nonce …`.
      */
     zkConfigNonce?: bigint;
     /**
-     * Optional nonce-keyed circuit map. Defaults to the SDK bundled 2×2 (nonce 2)
-     * and 6×6 (nonce 6) schemes. URL fields are only for a custom/dev circuit.
+     * Optional nonce-keyed circuit map. Defaults to the SDK bundled 2×2 (nonce 3)
+     * and 6×6 (nonce 7) schemes. URL fields are only for a custom/dev circuit.
      */
     zkCircuits?: Record<string, StellarZkCircuitDefinition>;
     /**

package/dist/node.js

@@ -806,6 +806,7 @@ function buildPoolTransactionAuditParameters(input) {
     input.nAuditSlots
   );
 }
+var DECIMAL_APPLICATION_ID = /^\d+$/u;
 function resolvePoolApplicationId(applicationId) {
   const trimmed = applicationId?.trim();
   if (!trimmed) {
@@ -813,6 +814,11 @@ function resolvePoolApplicationId(applicationId) {
       "Privacy pool applicationId is required. Pass it in client factory config."
     );
   }
+  if (!DECIMAL_APPLICATION_ID.test(trimmed)) {
+    throw new Error(
+      "Privacy pool applicationId must be association.audit_id (decimal Fr), not a UUID or foreignId."
+    );
+  }
   return trimmed;
 }
 
@@ -1586,92 +1592,167 @@ function getPrivacyPoolService() {
 }
 
 // src/transact/merkle/fetch-contract.ts
+import { Buffer as Buffer12 } from "buffer";
+
+// src/transact/merkle/state-port.ts
+function poolMerkleStateToCachedView(state) {
+  return {
+    commitments: state.commitments,
+    updatedAt: state.updatedAt,
+    merkleRootHex: state.merkleRootHex
+  };
+}
+
+// src/transact/merkle/read-tree-leaves.ts
+import { Address, xdr } from "@stellar/stellar-sdk";
 import { Buffer as Buffer11 } from "buffer";
 
 // src/transact/merkle/encoding.ts
 import "buffer";
 var FR_ORDER = 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n;
-function bufferToDecimal(buf) {
+function commitmentBufferToDecimal(buf) {
   const hex = buf.toString("hex");
   const bigintFromHex = BigInt(`0x${hex}`);
   const reduced = bigintFromHex % FR_ORDER;
   return reduced.toString();
 }
-function commitmentsBuffersToDecimal(buffers) {
-  return buffers.map((bufferRow) => bufferToDecimal(bufferRow));
-}
-
-// src/transact/merkle/state-port.ts
-function poolMerkleStateToCachedView(state) {
-  return {
-    commitments: state.commitments,
-    updatedAt: state.updatedAt,
-    merkleRootHex: state.merkleRootHex
-  };
-}
 
-// src/transact/merkle/fetch-contract.ts
-function normalizeCommitmentBuffers(rawBuffers) {
-  return rawBuffers.map(
-    (bufferRow) => Buffer11.isBuffer(bufferRow) ? bufferRow : Buffer11.from(bufferRow)
+// src/transact/merkle/read-tree-leaves.ts
+var TREE_LEAF_LEDGER_BATCH_SIZE = 100;
+function treeLeafLedgerKey(contractId, leafIndex) {
+  return xdr.LedgerKey.contractData(
+    new xdr.LedgerKeyContractData({
+      contract: new Address(contractId).toScAddress(),
+      key: treeLeafKeyScValue(leafIndex),
+      durability: xdr.ContractDataDurability.persistent()
+    })
   );
 }
-function mergeContractMerkleWithCache(parameters) {
-  const cachedCount = parameters.cachedState?.commitments.length ?? 0;
-  const shouldPreferContract = parameters.contractCount > cachedCount || !parameters.cachedState || cachedCount === 0;
-  if (shouldPreferContract) {
-    const updatedAt = Date.now();
-    void parameters.poolMerkleState?.set({
-      poolContract: parameters.poolContractId,
-      commitments: parameters.contractCommitments,
-      commitmentCount: parameters.contractCount,
-      merkleRootHex: parameters.merkleRootHex,
-      updatedAt
-    });
-    return {
-      commitments: parameters.contractCommitments,
-      updatedAt,
-      merkleRootHex: parameters.merkleRootHex,
-      commitmentCount: parameters.contractCount
-    };
+function treeLeafKeyScValue(leafIndex) {
+  return xdr.ScVal.scvVec([xdr.ScVal.scvSymbol("Leaf"), xdr.ScVal.scvU32(leafIndex)]);
+}
+function leafIndexFromContractDataKey(key) {
+  if (key.switch() !== xdr.ScValType.scvVec()) {
+    return void 0;
   }
-  return {
-    commitments: parameters.cachedState.commitments,
-    updatedAt: parameters.cachedState.updatedAt,
-    merkleRootHex: parameters.cachedState.merkleRootHex ?? parameters.merkleRootHex,
-    commitmentCount: parameters.cachedState.commitments.length
-  };
+  const fields = key.vec();
+  if (!fields || fields.length !== 2) {
+    return void 0;
+  }
+  const [tag, indexValue] = fields;
+  if (!tag || tag.switch() !== xdr.ScValType.scvSymbol()) {
+    return void 0;
+  }
+  if (tag.sym().toString() !== "Leaf") {
+    return void 0;
+  }
+  if (!indexValue || indexValue.switch() !== xdr.ScValType.scvU32()) {
+    return void 0;
+  }
+  return indexValue.u32();
 }
-async function readCachedPoolMerkleView(poolMerkleState, poolContractId) {
-  if (!poolMerkleState) {
+function commitmentBytesFromContractDataValue(value) {
+  if (value.switch() !== xdr.ScValType.scvBytes()) {
     return void 0;
   }
-  const cached = await poolMerkleState.get(poolContractId);
-  return cached ? poolMerkleStateToCachedView(cached) : void 0;
+  return Buffer11.from(value.bytes());
+}
+async function readTreeLeafCommitments(input) {
+  if (input.startIndex >= input.endIndex) {
+    return [];
+  }
+  const byIndex = await readLeafBuffersByIndex(input);
+  return decimalCommitmentsInRange(byIndex, input.startIndex, input.endIndex);
+}
+async function readLeafBuffersByIndex(input) {
+  const keys = ledgerKeysForRange(input.contractId, input.startIndex, input.endIndex);
+  const byIndex = /* @__PURE__ */ new Map();
+  for (const batch of chunkLedgerKeys(keys, TREE_LEAF_LEDGER_BATCH_SIZE)) {
+    const response = await input.reader.getLedgerEntries(...batch);
+    collectLeafBuffers(response.entries, byIndex);
+  }
+  return byIndex;
+}
+function ledgerKeysForRange(contractId, startIndex, endIndex) {
+  const keys = [];
+  for (let leafIndex = startIndex; leafIndex < endIndex; leafIndex += 1) {
+    keys.push(treeLeafLedgerKey(contractId, leafIndex));
+  }
+  return keys;
+}
+function chunkLedgerKeys(keys, batchSize) {
+  const batches = [];
+  for (let offset = 0; offset < keys.length; offset += batchSize) {
+    batches.push(keys.slice(offset, offset + batchSize));
+  }
+  return batches;
+}
+function collectLeafBuffers(entries, byIndex) {
+  for (const entry of entries) {
+    const contractData = entry.val.contractData();
+    const leafIndex = leafIndexFromContractDataKey(contractData.key());
+    const bytes = commitmentBytesFromContractDataValue(contractData.val());
+    if (leafIndex === void 0 || !bytes) {
+      continue;
+    }
+    byIndex.set(leafIndex, bytes);
+  }
+}
+function decimalCommitmentsInRange(byIndex, startIndex, endIndex) {
+  const commitments = [];
+  for (let leafIndex = startIndex; leafIndex < endIndex; leafIndex += 1) {
+    const bytes = byIndex.get(leafIndex);
+    if (!bytes) {
+      throw new Error(`Missing Merkle leaf ${String(leafIndex)} in pool storage.`);
+    }
+    commitments.push(commitmentBufferToDecimal(bytes));
+  }
+  return commitments;
+}
+
+// src/transact/merkle/reuse-cached-commitments.ts
+function completeCacheRootMatches(cachedState, merkleRootHex) {
+  const cachedRoot = cachedState?.merkleRootHex;
+  if (cachedRoot === void 0 || cachedRoot === "") {
+    return true;
+  }
+  return cachedRoot === merkleRootHex;
+}
+function reuseCachedCommitments(input) {
+  const cachedCommitments = input.cachedState?.commitments ?? [];
+  if (cachedCommitments.length === 0) {
+    return [];
+  }
+  if (cachedCommitments.length > input.onChainCount) {
+    return [];
+  }
+  if (cachedCommitments.length === input.onChainCount) {
+    return completeCacheRootMatches(input.cachedState, input.merkleRootHex) ? cachedCommitments : [];
+  }
+  return cachedCommitments;
 }
+
+// src/transact/merkle/fetch-contract.ts
 async function fetchAndMergeMerkleState(parameters) {
-  const client = readPoolClientFactory(parameters.transactEnvironment)({
-    contractId: parameters.poolContractId,
-    walletPublicKey: parameters.walletPublicKey,
-    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
-    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
-  });
-  const commitmentsRead = await client.get_commitments();
-  const rawBuffers = commitmentsRead.result;
-  const buffers = normalizeCommitmentBuffers(rawBuffers);
-  const contractCommitments = commitmentsBuffersToDecimal(buffers);
-  const contractCount = contractCommitments.length;
+  const client = createPoolClient(parameters);
+  const countRead = await client.get_commitment_count();
+  const onChainCount = requireCommitmentCount(countRead.result);
   const rootRead = await client.get_merkle_root();
-  const merkleRootBuffer = rootRead.result;
-  const merkleRootHex = Buffer11.from(merkleRootBuffer).toString("hex");
+  const merkleRootHex = merkleRootToHex(rootRead.result);
   const cachedState = await readCachedPoolMerkleView(
     parameters.poolMerkleState,
     parameters.poolContractId
   );
-  return mergeContractMerkleWithCache({
+  const commitments = await loadCommitments({
+    cachedState,
+    onChainCount,
+    merkleRootHex,
+    rpcUrl: parameters.transactEnvironment.network.rpcUrl,
+    contractId: parameters.poolContractId
+  });
+  return persistFetchedMerkleState({
     poolContractId: parameters.poolContractId,
-    contractCommitments,
-    contractCount,
+    commitments,
     merkleRootHex,
     cachedState,
     ...parameters.poolMerkleState ? { poolMerkleState: parameters.poolMerkleState } : {}
@@ -1685,19 +1766,14 @@ async function readLeafEphemeralHex(parameters) {
   if (cached?.xHex && cached.yHex) {
     return { xHex: cached.xHex, yHex: cached.yHex };
   }
-  const client = readPoolClientFactory(parameters.transactEnvironment)({
-    contractId: parameters.poolContractId,
-    walletPublicKey: parameters.walletPublicKey,
-    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
-    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
-  });
+  const client = createPoolClient(parameters);
   const read = await client.get_leaf_ephemeral({ leaf_index: parameters.leafIndex });
   const coords = read.result;
   if (!coords?.x || !coords?.y) {
     throw new Error("Missing leaf ephemeral key on contract");
   }
-  const xHex = Buffer11.from(coords.x).toString("hex");
-  const yHex = Buffer11.from(coords.y).toString("hex");
+  const xHex = Buffer12.from(coords.x).toString("hex");
+  const yHex = Buffer12.from(coords.y).toString("hex");
   await parameters.leafEphemeral?.set({
     poolContract: parameters.poolContractId,
     leafIndex: parameters.leafIndex,
@@ -1707,6 +1783,84 @@ async function readLeafEphemeralHex(parameters) {
   });
   return { xHex, yHex };
 }
+function createPoolClient(parameters) {
+  return readPoolClientFactory(parameters.transactEnvironment)({
+    contractId: parameters.poolContractId,
+    walletPublicKey: parameters.walletPublicKey,
+    networkPassphrase: parameters.transactEnvironment.network.networkPassphrase,
+    sorobanRpcUrl: parameters.transactEnvironment.network.rpcUrl
+  });
+}
+function requireCommitmentCount(result) {
+  if (typeof result === "number" && Number.isInteger(result) && result >= 0) {
+    return result;
+  }
+  throw new Error("Pool commitment count is not a non-negative integer.");
+}
+function merkleRootToHex(root) {
+  return Buffer12.from(root).toString("hex");
+}
+async function readCachedPoolMerkleView(poolMerkleState, poolContractId) {
+  if (!poolMerkleState) {
+    return void 0;
+  }
+  const cached = await poolMerkleState.get(poolContractId);
+  return cached ? poolMerkleStateToCachedView(cached) : void 0;
+}
+async function loadCommitments(input) {
+  const reused = reuseCachedCommitments({
+    cachedState: input.cachedState,
+    onChainCount: input.onChainCount,
+    merkleRootHex: input.merkleRootHex
+  });
+  if (reused.length === input.onChainCount) {
+    return reused;
+  }
+  const fetched = await readTreeLeafCommitments({
+    reader: createStellarRpcServer(input.rpcUrl),
+    contractId: input.contractId,
+    startIndex: reused.length,
+    endIndex: input.onChainCount
+  });
+  return [...reused, ...fetched];
+}
+async function persistFetchedMerkleState(input) {
+  const cachedState = input.cachedState;
+  if (cachedState && cachedMerkleUnchanged(cachedState, input.commitments, input.merkleRootHex)) {
+    return viewFromCachedMerkle(cachedState, input.merkleRootHex);
+  }
+  const updatedAt = Date.now();
+  await input.poolMerkleState?.set({
+    poolContract: input.poolContractId,
+    commitments: input.commitments,
+    commitmentCount: input.commitments.length,
+    merkleRootHex: input.merkleRootHex,
+    updatedAt
+  });
+  return {
+    commitments: input.commitments,
+    updatedAt,
+    merkleRootHex: input.merkleRootHex,
+    commitmentCount: input.commitments.length
+  };
+}
+function viewFromCachedMerkle(cachedState, merkleRootHex) {
+  return {
+    commitments: cachedState.commitments,
+    updatedAt: cachedState.updatedAt,
+    merkleRootHex: cachedState.merkleRootHex ?? merkleRootHex,
+    commitmentCount: cachedState.commitments.length
+  };
+}
+function cachedMerkleUnchanged(cachedState, commitments, merkleRootHex) {
+  if (!cachedState) {
+    return false;
+  }
+  if ((cachedState.merkleRootHex ?? merkleRootHex) !== merkleRootHex) {
+    return false;
+  }
+  return cachedState.commitments.join(",") === commitments.join(",");
+}
 
 // src/transact/engine/prepare/shared.ts
 async function resolveTokenContractId2(environment, assetId) {
@@ -4104,7 +4258,7 @@ function createStellarStorageAdapterFromState(state) {
 }
 
 // src/contracts/registry/registry-domain-service.ts
-import { Buffer as Buffer12 } from "buffer";
+import { Buffer as Buffer13 } from "buffer";
 
 // src/transact/submit/ttl-preflight.ts
 function getNested(source, path) {
@@ -4153,11 +4307,11 @@ async function runTtlPreflight(assembledTransaction) {
 // src/contracts/registry/registry-domain-service.ts
 var COORDINATE_HEX_LENGTH = 64;
 function readCoordinateBytes(value) {
-  if (value instanceof Buffer12) {
+  if (value instanceof Buffer13) {
     return value;
   }
   if (value instanceof Uint8Array) {
-    return Buffer12.from(value);
+    return Buffer13.from(value);
   }
   return void 0;
 }
@@ -4196,8 +4350,8 @@ function parseRegistryLookupRecord(result) {
   return parseOptionSomeRecord(result);
 }
 function recordToLookupResult(record) {
-  const publicKeyXHex = Buffer12.from(record.public_key_x).toString("hex");
-  const publicKeyYHex = Buffer12.from(record.public_key_y).toString("hex");
+  const publicKeyXHex = Buffer13.from(record.public_key_x).toString("hex");
+  const publicKeyYHex = Buffer13.from(record.public_key_y).toString("hex");
   return {
     owner: record.owner,
     status: "registered",
@@ -4240,8 +4394,8 @@ async function registerPrivateAddressOnChain(input) {
   });
   const assembled = await client.register_private_address({
     owner: input.owner.trim(),
-    public_key_x: Buffer12.from(decoded.x.padStart(COORDINATE_HEX_LENGTH, "0"), "hex"),
-    public_key_y: Buffer12.from(decoded.y.padStart(COORDINATE_HEX_LENGTH, "0"), "hex")
+    public_key_x: Buffer13.from(decoded.x.padStart(COORDINATE_HEX_LENGTH, "0"), "hex"),
+    public_key_y: Buffer13.from(decoded.y.padStart(COORDINATE_HEX_LENGTH, "0"), "hex")
   });
   await runTtlPreflight(assembled);
   const sent = await assembled.signAndSend();
@@ -4256,7 +4410,7 @@ async function registerPrivateAddressOnChain(input) {
 import { StrKey as StrKey5 } from "@stellar/stellar-sdk";
 
 // src/transact/escrow/derived-escrow-recipient.ts
-import { Buffer as Buffer13 } from "buffer";
+import { Buffer as Buffer14 } from "buffer";
 import { StrKey as StrKey4 } from "@stellar/stellar-sdk";
 import {
   derivedEscrowKey,
@@ -4266,7 +4420,7 @@ import {
 var COORDINATE_HEX_LENGTH2 = 64;
 function stellarAccountToFieldLimbs(stellarAddress) {
   const pkRaw = StrKey4.decodeEd25519PublicKey(stellarAddress.trim());
-  const pkHex = Buffer13.from(pkRaw).toString("hex");
+  const pkHex = Buffer14.from(pkRaw).toString("hex");
   const { hi, lo } = ed25519PubkeyPayloadHexToWithdrawFrDecimals2(pkHex);
   return { recipientHi: hi, recipientLo: lo };
 }
@@ -4351,7 +4505,7 @@ async function resolveTransferRecipientFromChain(input) {
 import { Api } from "@stellar/stellar-sdk/rpc";
 
 // src/rpc/soroban-transaction-meta.ts
-import { Address, StrKey as StrKey6 } from "@stellar/stellar-sdk";
+import { Address as Address2, StrKey as StrKey6 } from "@stellar/stellar-sdk";
 var BIGINT_SHIFT_64 = 64n;
 var TRANSACTION_META_SWITCH_SOROBAN_V3 = 3;
 var TRANSACTION_META_SWITCH_SOROBAN_V4 = 4;
@@ -4451,8 +4605,8 @@ function transferPartyAddressesFromTopics(topics) {
       return void 0;
     }
     return {
-      from: Address.fromScVal(fromTopic).toString(),
-      to: Address.fromScVal(toTopic).toString()
+      from: Address2.fromScVal(fromTopic).toString(),
+      to: Address2.fromScVal(toTopic).toString()
     };
   } catch {
     return void 0;
@@ -6223,20 +6377,20 @@ async function waitForKytRegistration(parameters) {
 }
 
 // src/transact/kyt/passage/submit.ts
-import { Buffer as Buffer14 } from "buffer";
-import { Operation, TransactionBuilder, rpc as rpc3, xdr as xdr2 } from "@stellar/stellar-sdk";
+import { Buffer as Buffer15 } from "buffer";
+import { Operation, TransactionBuilder, rpc as rpc3, xdr as xdr3 } from "@stellar/stellar-sdk";
 var KYT_REGISTER_FEE_STROOPS = "1000000";
 var KYT_REGISTER_TIMEOUT_SECONDS = 300;
 function passageIdToScValue(passageId) {
-  return xdr2.ScVal.scvBytes(Buffer14.from(passageId.replace(/^0x/, ""), "hex"));
+  return xdr3.ScVal.scvBytes(Buffer15.from(passageId.replace(/^0x/, ""), "hex"));
 }
 function approvalSignatureToBytes(signature) {
   const clean = signature.trim();
-  return /^(0x)?[0-9a-fA-F]{128}$/.test(clean) ? Buffer14.from(clean.replace(/^0x/i, ""), "hex") : Buffer14.from(clean, "base64");
+  return /^(0x)?[0-9a-fA-F]{128}$/.test(clean) ? Buffer15.from(clean.replace(/^0x/i, ""), "hex") : Buffer15.from(clean, "base64");
 }
 function signatureToScValue(signature) {
   const bytes = approvalSignatureToBytes(signature);
-  return xdr2.ScVal.scvBytes(bytes);
+  return xdr3.ScVal.scvBytes(bytes);
 }
 async function registerKytPassage(parameters) {
   const signTransaction = parameters.transactEnvironment.signTransaction;
@@ -6257,7 +6411,7 @@ async function registerKytPassage(parameters) {
       function: "register_passage",
       args: [
         passageIdToScValue(parameters.approval.passageId),
-        xdr2.ScVal.scvU32(parameters.approval.expiresAtLedger),
+        xdr3.ScVal.scvU32(parameters.approval.expiresAtLedger),
         signatureToScValue(parameters.approval.signature)
       ]
     })
@@ -6382,12 +6536,12 @@ async function requestKytPassageForPoolInteraction(input) {
 
 // src/transact/submit/zk-config-ttl.ts
 import {
-  Address as Address2,
+  Address as Address3,
   Operation as Operation2,
   SorobanDataBuilder,
   TransactionBuilder as TransactionBuilder2,
   rpc as rpc4,
-  xdr as xdr3
+  xdr as xdr4
 } from "@stellar/stellar-sdk";
 var ZK_CONFIG_TTL_THRESHOLD_LEDGERS = 1e5;
 var ZK_CONFIG_TTL_EXTEND_TO_LEDGERS = 5e5;
@@ -6411,15 +6565,15 @@ async function waitForExtendFootprintTtlConfirmation(parameters) {
   throw new Error("ZK config TTL extension was not confirmed in time");
 }
 function zkConfigLedgerKey(contractId, nonce) {
-  const configKeyScValue = xdr3.ScVal.scvVec([
-    xdr3.ScVal.scvSymbol("Config"),
-    xdr3.ScVal.scvU64(xdr3.Uint64.fromString(nonce.toString()))
+  const configKeyScValue = xdr4.ScVal.scvVec([
+    xdr4.ScVal.scvSymbol("Config"),
+    xdr4.ScVal.scvU64(xdr4.Uint64.fromString(nonce.toString()))
   ]);
-  return xdr3.LedgerKey.contractData(
-    new xdr3.LedgerKeyContractData({
-      contract: new Address2(contractId).toScAddress(),
+  return xdr4.LedgerKey.contractData(
+    new xdr4.LedgerKeyContractData({
+      contract: new Address3(contractId).toScAddress(),
       key: configKeyScValue,
-      durability: xdr3.ContractDataDurability.persistent()
+      durability: xdr4.ContractDataDurability.persistent()
     })
   );
 }
@@ -6484,7 +6638,7 @@ async function extendZkConfigTtlIfNeeded(parameters) {
 }
 
 // src/transact/submit/pool-transact.ts
-import { Buffer as Buffer15 } from "buffer";
+import { Buffer as Buffer16 } from "buffer";
 async function submitPoolTransact(parameters) {
   await extendZkConfigTtlIfNeeded({
     sorobanRpcUrl: parameters.sorobanRpcUrl,
@@ -6497,9 +6651,9 @@ async function submitPoolTransact(parameters) {
   const assembledTransaction = await parameters.contractClient.transact({
     from: parameters.from,
     nonce: parameters.nonce,
-    proof_bytes: Buffer15.from(parameters.proofHex.replace(/^0x/iu, ""), "hex"),
-    pub_signals_bytes: Buffer15.from(parameters.publicHex.replace(/^0x/iu, ""), "hex"),
-    ciphertext_bytes: Buffer15.from(
+    proof_bytes: Buffer16.from(parameters.proofHex.replace(/^0x/iu, ""), "hex"),
+    pub_signals_bytes: Buffer16.from(parameters.publicHex.replace(/^0x/iu, ""), "hex"),
+    ciphertext_bytes: Buffer16.from(
       (parameters.ciphertextHex ?? "").replace(/^0x/iu, ""),
       "hex"
     ),