@arcanetech/privacy-sdk-stellar 0.2.3 → 0.3.0

package/dist/transact/index.d.ts

@@ -90,6 +90,12 @@ interface StellarKytEnvironment {
 }
 interface StellarTransactEnvironment {
     network: StellarNetworkConfig;
+    /**
+     * Nonce (persistent storage key) of the pool's `ZkConfig` entry this
+     * environment's proofs/circuit shape target. Defaults to `0n` (the
+     * standard circuit) when omitted.
+     */
+    zkConfigNonce?: bigint;
     auditPublicKey?: AuditPublicKey;
     kyt: StellarKytEnvironment;
     signTransaction?: StellarSignTransaction;

package/dist/transact/index.js

@@ -1155,6 +1155,12 @@ async function registerKytPassage(parameters) {
   await waitForKytRegistration({ server, hash: result.hash });
 }
 
+// src/transact/environment/zk-config-nonce.ts
+var DEFAULT_ZK_CONFIG_NONCE = 0n;
+function resolveZkConfigNonce(transactEnvironment) {
+  return transactEnvironment.zkConfigNonce ?? DEFAULT_ZK_CONFIG_NONCE;
+}
+
 // src/transact/kyt/passage/inspect.ts
 function buildApplicationIdHints(applicationId) {
   return [applicationId, applicationId, applicationId, applicationId];
@@ -1208,6 +1214,7 @@ async function requestKytPassageForPoolInteraction(input) {
           decryptedAuditSlots: input.decryptedAuditSlots,
           onboarding: input.onboarding,
           nonce: buildNonce(),
+          zkConfigNonce: resolveZkConfigNonce(input.transactEnvironment),
           currentLedger
         },
         kytJsonReplacer
@@ -1274,11 +1281,123 @@ async function runTtlPreflight(assembledTransaction) {
   await maybeCallFunction(assembledTransaction, "simulate");
 }
 
+// src/transact/submit/zk-config-ttl.ts
+import {
+  Address,
+  Operation as Operation2,
+  SorobanDataBuilder,
+  TransactionBuilder as TransactionBuilder2,
+  rpc as rpc3,
+  xdr as xdr2
+} from "@stellar/stellar-sdk";
+var ZK_CONFIG_TTL_THRESHOLD_LEDGERS = 1e5;
+var ZK_CONFIG_TTL_EXTEND_TO_LEDGERS = 5e5;
+var EXTEND_TTL_FEE_STROOPS = "1000000";
+var EXTEND_TTL_TIMEOUT_SECONDS = 300;
+var EXTEND_TTL_MAX_POLLS = 60;
+var EXTEND_TTL_POLL_INTERVAL_MS = 1e3;
+async function waitForExtendFootprintTtlConfirmation(parameters) {
+  for (let attempt = 0; attempt < EXTEND_TTL_MAX_POLLS; attempt += 1) {
+    const response = await parameters.server.getTransaction(parameters.hash);
+    if (response.status === "SUCCESS") {
+      return;
+    }
+    if (response.status === "FAILED") {
+      throw new Error("ZK config TTL extension failed on-chain");
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, EXTEND_TTL_POLL_INTERVAL_MS);
+    });
+  }
+  throw new Error("ZK config TTL extension was not confirmed in time");
+}
+function zkConfigLedgerKey(contractId, nonce) {
+  const configKeyScValue = xdr2.ScVal.scvVec([
+    xdr2.ScVal.scvSymbol("Config"),
+    xdr2.ScVal.scvU64(xdr2.Uint64.fromString(nonce.toString()))
+  ]);
+  return xdr2.LedgerKey.contractData(
+    new xdr2.LedgerKeyContractData({
+      contract: new Address(contractId).toScAddress(),
+      key: configKeyScValue,
+      durability: xdr2.ContractDataDurability.persistent()
+    })
+  );
+}
+async function needsTtlExtension(parameters) {
+  const [entriesResponse, latestLedger] = await Promise.all([
+    parameters.server.getLedgerEntries(parameters.ledgerKey),
+    parameters.server.getLatestLedger()
+  ]);
+  const entry = entriesResponse.entries.at(0);
+  if (!entry || entry.liveUntilLedgerSeq === void 0) {
+    return false;
+  }
+  const remainingLedgers = entry.liveUntilLedgerSeq - latestLedger.sequence;
+  return remainingLedgers < ZK_CONFIG_TTL_THRESHOLD_LEDGERS;
+}
+async function submitExtendFootprintTtlTransaction(parameters) {
+  const sourceAccount = await parameters.server.getAccount(parameters.sourcePublicKey);
+  const transaction = new TransactionBuilder2(sourceAccount, {
+    fee: EXTEND_TTL_FEE_STROOPS,
+    networkPassphrase: parameters.networkPassphrase
+  }).addOperation(
+    Operation2.extendFootprintTtl({ extendTo: ZK_CONFIG_TTL_EXTEND_TO_LEDGERS })
+  ).setSorobanData(
+    new SorobanDataBuilder().setReadOnly([parameters.ledgerKey]).build()
+  ).setTimeout(EXTEND_TTL_TIMEOUT_SECONDS).build();
+  const preparedTransaction = await parameters.server.prepareTransaction(transaction);
+  const { signedTxXdr } = await parameters.signTransaction({
+    xdr: preparedTransaction.toXDR(),
+    networkPassphrase: parameters.networkPassphrase,
+    address: parameters.sourcePublicKey
+  });
+  const signedTransaction = TransactionBuilder2.fromXDR(
+    signedTxXdr,
+    parameters.networkPassphrase
+  );
+  const result = await parameters.server.sendTransaction(signedTransaction);
+  const status = String(result.status);
+  if (status !== "PENDING" && status !== "SUCCESS") {
+    throw new Error(`ZK config TTL extension submit failed: ${status}`);
+  }
+  await waitForExtendFootprintTtlConfirmation({
+    server: parameters.server,
+    hash: result.hash
+  });
+}
+async function extendZkConfigTtlIfNeeded(parameters) {
+  if (!parameters.signTransaction) {
+    return;
+  }
+  const server = new rpc3.Server(parameters.sorobanRpcUrl, { allowHttp: true });
+  const ledgerKey = zkConfigLedgerKey(parameters.contractId, parameters.nonce);
+  if (!await needsTtlExtension({ server, ledgerKey })) {
+    return;
+  }
+  await submitExtendFootprintTtlTransaction({
+    server,
+    ledgerKey,
+    networkPassphrase: parameters.networkPassphrase,
+    sourcePublicKey: parameters.sourcePublicKey,
+    signTransaction: parameters.signTransaction
+  });
+}
+
 // src/transact/submit/pool-transact.ts
 import { Buffer as Buffer11 } from "buffer";
 async function submitPoolTransact(parameters) {
+  await extendZkConfigTtlIfNeeded({
+    sorobanRpcUrl: parameters.sorobanRpcUrl,
+    networkPassphrase: parameters.networkPassphrase,
+    contractId: parameters.contractId,
+    nonce: parameters.nonce,
+    sourcePublicKey: parameters.from,
+    signTransaction: parameters.transactEnvironment.signTransaction
+  });
   const assembledTransaction = await parameters.contractClient.transact({
     from: parameters.from,
+    nonce: parameters.nonce,
     proof_bytes: Buffer11.from(parameters.proofHex.replace(/^0x/iu, ""), "hex"),
     pub_signals_bytes: Buffer11.from(parameters.publicHex.replace(/^0x/iu, ""), "hex"),
     onboarding: parameters.onboarding,
@@ -1325,10 +1444,15 @@ async function submitSorobanDeposit(input) {
   });
   return submitPoolTransact({
     contractClient: poolClient,
+    contractId: input.contractId,
     from: input.walletPublicKey,
+    nonce: resolveZkConfigNonce(input.transactEnvironment),
     proofHex: proof_hex,
     publicHex: public_hex,
-    approval
+    approval,
+    networkPassphrase: input.networkPassphrase,
+    sorobanRpcUrl: input.sorobanRpcUrl,
+    transactEnvironment: input.transactEnvironment
   });
 }
 
@@ -1353,11 +1477,16 @@ async function submitSorobanConfidentialTransfer(input) {
   });
   return submitPoolTransact({
     contractClient: poolClient,
+    contractId: input.contractId,
     from: input.walletPublicKey,
+    nonce: resolveZkConfigNonce(input.transactEnvironment),
     proofHex: input.proofHex,
     publicHex: input.publicHex,
     ...input.onboarding ? { onboarding: input.onboarding } : {},
-    approval
+    approval,
+    networkPassphrase: input.networkPassphrase,
+    sorobanRpcUrl: input.sorobanRpcUrl,
+    transactEnvironment: input.transactEnvironment
   });
 }