@invisi-labs/sdk 1.1.6 → 1.2.0

package/dist/chunk-NKYHYIRP.cjs

@@ -0,0 +1,1582 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkBBSRP4MHcjs = require('./chunk-BBSRP4MH.cjs');
+
+
+
+
+var _chunkHCB7RQ3Scjs = require('./chunk-HCB7RQ3S.cjs');
+
+
+var _chunkOCZLJKIAcjs = require('./chunk-OCZLJKIA.cjs');
+
+
+var _chunk3KTQQZOWcjs = require('./chunk-3KTQQZOW.cjs');
+
+
+
+
+var _chunkMA2QZEF5cjs = require('./chunk-MA2QZEF5.cjs');
+
+
+var _chunk4SDP53YQcjs = require('./chunk-4SDP53YQ.cjs');
+
+
+
+var _chunkLOR6PYH5cjs = require('./chunk-LOR6PYH5.cjs');
+
+// src/protocol/AddressRegistry.ts
+var _rpc = require('@invisi-labs/rpc');
+var AddressRegistry = class extends _rpc.AddressRegistry {
+  prepareRegistration(options) {
+    return _chunk4SDP53YQcjs.prepareWithErrors.call(void 0, "prepareRegistration", async () => {
+      if ("provider" in options) {
+        const { provider, ...preparation } = options;
+        return super.prepareRegistration({
+          ...preparation,
+          reader: new (0, _chunkLOR6PYH5cjs.EthersChainReader)(provider)
+        });
+      }
+      return super.prepareRegistration(options);
+    });
+  }
+};
+
+// src/transactions/signing/revocation.ts
+var _primitives = require('@invisi-labs/primitives');
+var _protocol2 = require('@invisi-labs/protocol');
+var _ethers = require('ethers');
+async function revocationSigningRequest(plan, runtime) {
+  const params = _optionalChain([plan, 'access', _2 => _2.credit, 'optionalAccess', _3 => _3.revocation]);
+  if (!params) throw Error("operation is not a public Credit revocation");
+  await runtime.options.protocol.validateDeployment(runtime.reader);
+  const block = await runtime.reader.getBlock(await runtime.reader.getLatestBlockNumber());
+  if (block.timestamp > params.deadline) throw Error("revocation authorization expired");
+  const request = _primitives.createSigningRequest.call(void 0, 
+    _protocol2.encodeRevokeCreditTypedData.call(void 0, { ...plan.context, now: block.timestamp }, params)
+  );
+  if ((await runtime.reader.getBlock(block.number)).hash !== block.hash)
+    throw Error("canonical revocation block changed");
+  return request;
+}
+async function acceptRevocationSignature(plan, signature, runtime) {
+  if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(signature)) throw Error("invalid revocation signature");
+  const request = await revocationSigningRequest(plan, runtime), owner = plan.credit.revocation.owner;
+  let valid = false;
+  try {
+    valid = _ethers.getAddress.call(void 0, 
+      _ethers.verifyTypedData.call(void 0, request.domain, request.types, request.message, signature)
+    ) === _ethers.getAddress.call(void 0, owner);
+  } catch (e) {
+  }
+  if (!valid && runtime.options.fundingVerifier)
+    valid = await runtime.options.fundingVerifier.verifyTypedData({
+      ...request,
+      address: owner,
+      signature
+    });
+  if (!valid) throw Error("invalid owner revocation signature");
+  return signature;
+}
+
+// src/transactions/records.ts
+function creditReservationKey(commitment) {
+  return "credit:" + commitment;
+}
+
+// src/transactions/preparation/inputs.ts
+function inputFacts(plan) {
+  const credit = plan.credit;
+  const noteNullifiers = _nullishCoalesce(_optionalChain([plan, 'access', _4 => _4.params, 'optionalAccess', _5 => _5.nullifiers]), () => ( []));
+  let creditNullifiers = [];
+  if (_optionalChain([credit, 'optionalAccess', _6 => _6.draw])) {
+    creditNullifiers = credit.draw.nullifiers;
+  } else if (_optionalChain([credit, 'optionalAccess', _7 => _7.update])) {
+    creditNullifiers = [credit.update.nullifier];
+  }
+  if (noteNullifiers.length !== plan.inputs.length || creditNullifiers.length !== (_nullishCoalesce(_optionalChain([credit, 'optionalAccess', _8 => _8.inputs, 'access', _9 => _9.length]), () => ( 0)))) {
+    throw new Error("operation input statement count mismatch");
+  }
+  return [
+    ...plan.inputs.map((input, index2) => ({
+      key: input.commitment,
+      reservationKey: input.commitment,
+      nullifier: noteNullifiers[index2],
+      kind: "notes"
+    })),
+    ...(_nullishCoalesce(_optionalChain([credit, 'optionalAccess', _10 => _10.inputs]), () => ( []))).map((input, index2) => ({
+      key: input.commitment + ":" + input.role,
+      reservationKey: creditReservationKey(input.commitment),
+      nullifier: creditNullifiers[index2],
+      kind: "credits"
+    }))
+  ];
+}
+function operationSources(plan) {
+  const noteSources = _optionalChain([plan, 'access', _11 => _11.params, 'optionalAccess', _12 => _12.sources]);
+  if (noteSources != null) return noteSources;
+  const credit = plan.credit;
+  if (_optionalChain([credit, 'optionalAccess', _13 => _13.draw])) return credit.draw.sources;
+  if (_optionalChain([credit, 'optionalAccess', _14 => _14.update])) return [credit.update.source];
+  return [];
+}
+
+// src/gas/gas-estimation.ts
+
+
+function getOperationGasReference(plan, _protocol) {
+  let query = { kind: plan.kind };
+  const credit = plan.credit;
+  if (_optionalChain([plan, 'access', _15 => _15.statement, 'optionalAccess', _16 => _16.target]) === "noir-recursive")
+    return _protocol2.getDocumentedGasReference.call(void 0, { kind: "aggregate" });
+  if (_optionalChain([credit, 'optionalAccess', _17 => _17.creation]))
+    query = { kind: "create-credit", scenario: "first-allocation-empty-tree" };
+  else if (_optionalChain([credit, 'optionalAccess', _18 => _18.update]))
+    query = { kind: "update-credit", scenario: "after-draw-preserve-usage" };
+  else if (_optionalChain([credit, 'optionalAccess', _19 => _19.draw]))
+    query = {
+      kind: "draw-credit",
+      capacity: plan.capacity,
+      creditInputs: credit.inputs.length,
+      distinctPayers: credit.draw.payers.length,
+      sourceTrees: operationSources(plan).length,
+      noteOutputs: 1,
+      creditOutputs: credit.outputs.length,
+      creditCiphertextBytes: 485,
+      noteCiphertextBytes: 160,
+      clueBytes: 68,
+      scenario: "distinct-payers"
+    };
+  else if (plan.kind === "transfer")
+    query = {
+      kind: "transact",
+      capacity: plan.capacity,
+      noteInputs: plan.inputs.length,
+      noteOutputs: plan.outputs.length,
+      sourceTrees: operationSources(plan).length,
+      noteCiphertextBytes: 160,
+      clueBytes: 68,
+      scenario: !plan.inputs.length ? "public-funding" : !plan.outputs.length ? "withdrawal" : !(_nullishCoalesce(plan.funding.amount, () => ( 0n))) && !(_nullishCoalesce(_optionalChain([plan, 'access', _20 => _20.params, 'optionalAccess', _21 => _21.withdrawalAmount]), () => ( 0n))) && !(_nullishCoalesce(_optionalChain([plan, 'access', _22 => _22.params, 'optionalAccess', _23 => _23.feeAmount]), () => ( 0n))) ? "private" : "mixed"
+    };
+  if (credit) {
+    const feeAmount = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([credit, 'access', _24 => _24.creation, 'optionalAccess', _25 => _25.feeAmount]), () => ( _optionalChain([credit, 'access', _26 => _26.update, 'optionalAccess', _27 => _27.feeAmount]))), () => ( _optionalChain([credit, 'access', _28 => _28.draw, 'optionalAccess', _29 => _29.feeAmount]))), () => ( _optionalChain([credit, 'access', _30 => _30.revocation, 'optionalAccess', _31 => _31.feeAmount]))), () => ( 0n));
+    query = {
+      ...query,
+      feeEnabled: feeAmount > 0n,
+      feeMechanism: feeAmount > 0n ? credit.draw ? "draw-deduction" : "owner-pull" : "none"
+    };
+  }
+  if (plan.outputs.some((o) => (o.delivery.ciphertext.length - 2) / 2 !== 160) || _optionalChain([credit, 'optionalAccess', _32 => _32.outputs, 'access', _33 => _33.some, 'call', _34 => _34((o) => o.deliveries.some((d) => (d.ciphertext.length - 2) / 2 !== 485))]))
+    return _protocol2.getDocumentedGasReference.call(void 0, { kind: "unmeasured-delivery-size" });
+  return _protocol2.getDocumentedGasReference.call(void 0, query);
+}
+
+// src/transactions/proving/proof.ts
+function publicProof(bundle) {
+  return {
+    formatVersion: bundle.formatVersion,
+    circuitName: bundle.circuitName,
+    target: bundle.target,
+    bbVersion: bundle.bbVersion,
+    artifactSha256: bundle.artifactSha256,
+    vkSha256: bundle.vkSha256,
+    proofHex: bundle.proofHex,
+    proofSha256: bundle.proofSha256,
+    publicInputs: [...bundle.publicInputs]
+  };
+}
+
+// src/transactions/proving/proof-integrity.ts
+var _sha256 = require('@noble/hashes/sha256');
+var _utils = require('@noble/hashes/utils');
+
+function check(ok, message) {
+  if (!ok) throw new Error(message);
+}
+function sameStatement(proof, expected) {
+  check(
+    proof.formatVersion === 1 && proof.bbVersion === "6.0.0" && proof.circuitName === expected.circuitName && proof.target === expected.target && proof.artifactSha256 === expected.artifactSha256 && proof.vkSha256 === expected.vkSha256,
+    "proof release/target mismatch"
+  );
+  check(
+    proof.publicInputs.length === expected.expectedPublicInputs.length && proof.publicInputs.every((word, i) => word === expected.expectedPublicInputs[i]),
+    "proof public statement mismatch"
+  );
+  check(
+    /^0x(?:[a-fA-F0-9]{2})+$/.test(proof.proofHex) && _utils.bytesToHex.call(void 0, _sha256.sha256.call(void 0, _ethers.getBytes.call(void 0, proof.proofHex))) === proof.proofSha256,
+    "proof integrity mismatch"
+  );
+}
+
+// src/transactions/execution/calldata.ts
+
+
+
+
+
+
+
+
+async function encodeOperation(saved) {
+  const plan = saved.plan;
+  const credit = plan.credit;
+  const caller = plan.fundingMode === "caller" ? plan.funding.payer : void 0;
+  const common = { context: plan.context, proof: _nullishCoalesce(_optionalChain([saved, 'access', _35 => _35.proof, 'optionalAccess', _36 => _36.proofHex]), () => ( "0x")) };
+  const funded = { ...common, funding: plan.funding, ...caller ? { caller } : {} };
+  let encoded;
+  if (_optionalChain([credit, 'optionalAccess', _37 => _37.update])) {
+    encoded = _protocol2.buildUpdateCreditCalldata.call(void 0, {
+      ...funded,
+      params: credit.update,
+      deliveries: credit.deliveries
+    });
+  } else if (_optionalChain([credit, 'optionalAccess', _38 => _38.creation])) {
+    encoded = _protocol2.buildCreateCreditCalldata.call(void 0, {
+      ...funded,
+      params: credit.creation,
+      deliveries: credit.deliveries
+    });
+  } else if (_optionalChain([credit, 'optionalAccess', _39 => _39.draw])) {
+    encoded = _protocol2.buildCreditDrawCalldata.call(void 0, {
+      ...common,
+      params: credit.draw,
+      deliveries: credit.deliveries
+    });
+  } else if (_optionalChain([credit, 'optionalAccess', _40 => _40.revocation])) {
+    encoded = _protocol2.buildRevokeCreditCalldata.call(void 0, {
+      context: plan.context,
+      params: credit.revocation,
+      signature: _nullishCoalesce(credit.revocationSignature, () => ( "0x")),
+      ...credit.revocationCaller ? { caller: credit.revocationCaller } : {}
+    });
+  } else if (plan.kind === "shield") {
+    encoded = await _protocol2.buildShieldCalldata.call(void 0, {
+      ...funded,
+      params: plan.shieldParams,
+      outputs: plan.shieldOutputs,
+      deliveries: plan.outputs.map((output) => output.delivery)
+    });
+  } else {
+    encoded = _protocol2.buildTransactCalldata.call(void 0, {
+      ...funded,
+      params: plan.params,
+      deliveries: plan.outputs.map((output) => output.delivery)
+    });
+  }
+  return { to: plan.context.protocolAddress, data: encoded.data, value: 0n };
+}
+
+// src/transactions/proving/witness.ts
+var _prover = require('@invisi-labs/prover');
+async function witnessFor(protocol, plan, authorization) {
+  const builder = new (0, _prover.WitnessBuilder)(protocol);
+  const credit = plan.credit;
+  if (credit) {
+    if (!authorization) throw new Error("private Credit wallet authorization required");
+    if (credit.update) {
+      await _chunkMA2QZEF5cjs.assertCreditUpdatePlan.call(void 0, plan);
+      if (!credit.updateChanges) throw Error("Credit update adjustment required");
+      return builder.updateCredit({
+        params: credit.update,
+        deliveries: credit.deliveries,
+        input: credit.inputs[0],
+        state: credit.outputs[0].state,
+        changes: credit.updateChanges,
+        authorization
+      });
+    }
+    if (credit.creation)
+      return builder.createCredit({
+        params: credit.creation,
+        deliveries: credit.deliveries,
+        state: credit.outputs[0].state,
+        authorization
+      });
+    if (credit.draw) {
+      return builder.drawCredit({
+        timestamp: plan.preparedAt.timestamp,
+        params: credit.draw,
+        deliveries: credit.deliveries,
+        inputs: credit.inputs,
+        amounts: credit.amounts,
+        output: plan.outputs[0].note,
+        authorization
+      });
+    }
+    throw new Error("unsupported Credit operation");
+  }
+  return builder.transact({
+    params: plan.params,
+    deliveries: plan.outputs.map((output) => output.delivery),
+    funding: plan.funding,
+    inputs: plan.inputs,
+    outputs: plan.outputs.map((output) => ({
+      identity: output.identity,
+      amount: output.amount,
+      ...output.note ? { note: output.note } : {}
+    })),
+    ...authorization ? { authorization } : {},
+    target: plan.statement.target
+  });
+}
+
+// src/transactions/signing/funding.ts
+
+
+
+
+
+async function fundingTypedData(saved) {
+  const plan = saved.plan;
+  if (plan.credit) throw Error("Credit operations have no funding authorization");
+  if (plan.kind === "shield") {
+    return _protocol2.encodeShieldFundingTypedData.call(void 0, {
+      context: plan.context,
+      params: plan.shieldParams,
+      outputs: plan.shieldOutputs,
+      deliveries: plan.outputs.map((output) => output.delivery),
+      funding: plan.funding
+    });
+  }
+  if (_optionalChain([plan, 'access', _41 => _41.statement, 'optionalAccess', _42 => _42.target]) === "noir-recursive") {
+    return _protocol2.encodeAggregateFundingTypedData.call(void 0, plan.context, {
+      params: plan.params,
+      deliveries: plan.outputs.map((output) => output.delivery),
+      funding: plan.funding
+    });
+  }
+  return _protocol2.encodeTransactFundingTypedData.call(void 0, 
+    plan.context,
+    saved.proof.proofHex,
+    plan.params,
+    plan.outputs.map((output) => output.delivery),
+    plan.funding
+  );
+}
+
+// src/transactions/execution/operation-execution.ts
+
+
+
+
+
+
+
+
+
+async function proveOperation(protocol, plan, authorization, prover, options) {
+  if (Object.hasOwn(options, "target")) {
+    throw new Error("prove accepts execution, not a backend target");
+  }
+  const { execution = "single", ...proverOptions } = options;
+  if (execution !== "single" && execution !== "aggregate") {
+    throw new Error("execution must be single or aggregate");
+  }
+  const frozen = _chunkHCB7RQ3Scjs.statement.call(void 0, plan);
+  if (execution === "aggregate" && (plan.kind !== "transfer" || !plan.capacity || plan.capacity > 10)) {
+    throw new Error("aggregate execution requires a C1..C10 transfer");
+  }
+  if (plan.kind === "transfer") {
+    plan.statement = _prover.WitnessBuilder.statement(
+      frozen.circuitName,
+      frozen.expectedPublicInputs,
+      execution === "aggregate" ? "noir-recursive" : "evm"
+    );
+  }
+  const request = await witnessFor(protocol, plan, authorization);
+  if (JSON.stringify({ ...request, witness: void 0 }) !== JSON.stringify(plan.statement))
+    throw new Error("prepared proof statement changed");
+  try {
+    const proof = publicProof(await prover.prove(request, proverOptions));
+    sameStatement(proof, plan.statement);
+    if (await prover.verify(
+      structuredClone(proof),
+      structuredClone(plan.statement),
+      proverOptions
+    ) !== true)
+      throw new Error("proof verification failed");
+    return proof;
+  } catch (e2) {
+    _optionalChain([options, 'access', _43 => _43.signal, 'optionalAccess', _44 => _44.throwIfAborted, 'call', _45 => _45()]);
+    throw new Error("operation proof generation or verification failed");
+  }
+}
+async function signOperationFunding(saved, signer, verifier) {
+  const payer = saved.plan.funding.payer;
+  if (signer.address.toLowerCase() !== payer.toLowerCase())
+    throw new Error("funding signer is not the payer");
+  const typed = await fundingTypedData(saved);
+  const signature = await signer.signTypedData(structuredClone(typed));
+  return verifyFundingSignature(typed, payer, signature, verifier);
+}
+function walletSigningRequest(plan) {
+  return _primitives.createSigningRequest.call(void 0, _primitives.walletAuthorizationTypedData.call(void 0, _chunkHCB7RQ3Scjs.authorizationRequest.call(void 0, plan)));
+}
+async function acceptWalletSignature(plan, signature) {
+  const request = _chunkHCB7RQ3Scjs.authorizationRequest.call(void 0, plan);
+  const digest = _primitives.computeWalletAuthorizationDigest.call(void 0, request);
+  try {
+    const signed = _ethers.Signature.from(signature);
+    const publicKey = _ethers.getBytes.call(void 0, _ethers.SigningKey.recoverPublicKey(digest, signed));
+    const owner = await _primitives.computeOwnerAddress.call(void 0, publicKey);
+    if (owner.toLowerCase() !== plan.scope.ownerAddress.toLowerCase()) {
+      throw new Error("wallet signature identity mismatch");
+    }
+    return new (0, _primitives.AuthorizedStatement)(plan.scope.ownerAddress, digest, {
+      public_key_x: Array.from(publicKey.slice(1, 33)),
+      public_key_y: Array.from(publicKey.slice(33)),
+      signature: Array.from(_ethers.getBytes.call(void 0, _ethers.concat.call(void 0, [signed.r, signed.s])))
+    });
+  } catch (e3) {
+    throw new Error("invalid wallet authorization signature");
+  }
+}
+async function fundingSigningRequest(saved, runtime) {
+  const plan = saved.plan;
+  if (plan.fundingMode !== "signature") {
+    throw new Error("operation does not require a funding signature");
+  }
+  if (plan.kind !== "shield" && !saved.proof) {
+    throw new Error("proof must precede funding authorization");
+  }
+  await runtime.options.protocol.validateDeployment(runtime.reader);
+  const block = await runtime.reader.getBlock(await runtime.reader.getLatestBlockNumber());
+  if (block.timestamp > plan.deadline || block.timestamp > (_nullishCoalesce(plan.funding.deadline, () => ( 0n)))) {
+    throw new Error("funding authorization expired");
+  }
+  if (await runtime.reader.getFundingNonce(plan.context, plan.funding.payer, block) !== plan.funding.sigNonce) {
+    throw new Error("funding nonce changed; prepare again");
+  }
+  const request = _primitives.createSigningRequest.call(void 0, await fundingTypedData(saved));
+  if ((await runtime.reader.getBlock(block.number)).hash !== block.hash) {
+    throw new Error("canonical funding block changed");
+  }
+  return request;
+}
+async function acceptFundingSignature(saved, signature, runtime) {
+  if (!/^0x(?:[a-fA-F0-9]{2})+$/.test(signature)) {
+    throw new Error("invalid EVM funding signature");
+  }
+  const request = await fundingSigningRequest(saved, runtime);
+  return verifyFundingSignature(
+    request,
+    saved.plan.funding.payer,
+    signature,
+    runtime.options.fundingVerifier
+  );
+}
+async function verifyFundingSignature(request, payer, signature, verifier) {
+  if (!/^0x(?:[a-fA-F0-9]{2})+$/.test(signature)) {
+    throw new Error("invalid EVM funding signature");
+  }
+  const types = Object.fromEntries(
+    Object.entries(request.types).map(([name, fields]) => [name, [...fields]])
+  );
+  let validEOA = false;
+  try {
+    validEOA = _ethers.verifyTypedData.call(void 0, request.domain, types, request.message, signature).toLowerCase() === payer.toLowerCase();
+    if (validEOA) {
+      signature = _ethers.Signature.from(signature).serialized;
+    }
+  } catch (e4) {
+    validEOA = false;
+  }
+  const valid = verifier ? await verifier.verifyTypedData({
+    ...structuredClone(request),
+    address: payer,
+    signature
+  }) : validEOA;
+  if (valid !== true) {
+    throw new Error("invalid EVM funding signature");
+  }
+  return signature;
+}
+
+// src/transactions/execution/operation-preview.ts
+
+
+function operationPreview(plan, status) {
+  const p = plan;
+  const fee = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(p.params, () => ( p.shieldParams)), () => ( _optionalChain([p, 'access', _46 => _46.credit, 'optionalAccess', _47 => _47.creation]))), () => ( _optionalChain([p, 'access', _48 => _48.credit, 'optionalAccess', _49 => _49.update]))), () => ( _optionalChain([p, 'access', _50 => _50.credit, 'optionalAccess', _51 => _51.draw]))), () => ( _optionalChain([p, 'access', _52 => _52.credit, 'optionalAccess', _53 => _53.revocation])));
+  const funding = _protocol2.normalizeFunding.call(void 0, p.funding);
+  return {
+    id: p.id,
+    kind: p.kind,
+    status,
+    context: { ...p.context },
+    inputs: inputFacts(p).length,
+    inputDetails: [
+      ...p.inputs.map((input) => ({
+        kind: "notes",
+        commitment: input.commitment,
+        amount: input.note.amount,
+        owner: input.note.ownerAddress,
+        treeId: input.treeId,
+        leafIndex: input.leafIndex
+      })),
+      ...(_nullishCoalesce(_optionalChain([p, 'access', _54 => _54.credit, 'optionalAccess', _55 => _55.inputs]), () => ( []))).map((input) => ({
+        kind: "credits",
+        commitment: input.commitment,
+        revocationShard: input.state.note.revocationShard,
+        revocationSlot: input.state.note.revocationSlot,
+        owner: input.state.note.ownerWalletIdentity,
+        spender: input.state.note.spenderWalletIdentity,
+        expiry: input.state.note.expiry,
+        availableCredit: input.state.note.availableCredit,
+        unlimited: input.state.note.unlimited,
+        role: input.role,
+        treeId: input.treeId,
+        leafIndex: input.leafIndex
+      }))
+    ],
+    funding: {
+      payer: funding.payer,
+      amount: funding.amount,
+      authorization: p.fundingMode,
+      sigNonce: funding.sigNonce,
+      deadline: funding.deadline,
+      permit: { deadline: funding.permit.deadline }
+    },
+    creditOutputs: _optionalChain([p, 'access', _56 => _56.credit, 'optionalAccess', _57 => _57.outputs, 'access', _58 => _58.map, 'call', _59 => _59((output) => ({
+      commitment: output.commitment,
+      revocationShard: output.state.note.revocationShard,
+      revocationSlot: output.state.note.revocationSlot,
+      expiry: output.state.note.expiry,
+      owner: output.state.note.ownerWalletIdentity,
+      spender: output.state.note.spenderWalletIdentity,
+      ..._primitives.normalizeCreditPolicy.call(void 0, output.state.note),
+      availableCredit: output.state.note.availableCredit,
+      unlimited: output.state.note.unlimited,
+      ..._primitives.normalizeCreditUsage.call(void 0, output.state.note)
+    }))]),
+    creditUpdate: _optionalChain([p, 'access', _60 => _60.credit, 'optionalAccess', _61 => _61.updateChanges]) ? structuredClone(p.credit.updateChanges) : void 0,
+    creditDraw: _optionalChain([p, 'access', _62 => _62.credit, 'optionalAccess', _63 => _63.draw]) ? {
+      grossAmount: p.credit.draw.totalAmount,
+      feeAmount: _nullishCoalesce(p.credit.draw.feeAmount, () => ( 0n)),
+      netAmount: p.credit.draw.totalAmount - (_nullishCoalesce(p.credit.draw.feeAmount, () => ( 0n))),
+      payers: p.credit.draw.payers.map((payer) => ({ ...payer }))
+    } : void 0,
+    creditFeePayer: _nullishCoalesce(_nullishCoalesce(_optionalChain([p, 'access', _64 => _64.credit, 'optionalAccess', _65 => _65.creation, 'optionalAccess', _66 => _66.owner]), () => ( _optionalChain([p, 'access', _67 => _67.credit, 'optionalAccess', _68 => _68.update, 'optionalAccess', _69 => _69.owner]))), () => ( _optionalChain([p, 'access', _70 => _70.credit, 'optionalAccess', _71 => _71.revocation, 'optionalAccess', _72 => _72.owner]))),
+    outputs: p.outputs.map((output) => ({
+      commitment: output.commitment,
+      to: output.address,
+      amount: output.amount,
+      change: output.change
+    })),
+    capacity: p.capacity,
+    deadline: p.deadline,
+    feeRecipient: _optionalChain([fee, 'optionalAccess', _73 => _73.feeRecipient]),
+    feeAmount: _nullishCoalesce(_optionalChain([fee, 'optionalAccess', _74 => _74.feeAmount]), () => ( 0n)),
+    fundingAmount: _nullishCoalesce(p.funding.amount, () => ( 0n)),
+    fundingPayer: p.funding.payer,
+    withdrawalAmount: _nullishCoalesce(_optionalChain([p, 'access', _75 => _75.params, 'optionalAccess', _76 => _76.withdrawalAmount]), () => ( 0n)),
+    withdrawalAddress: _optionalChain([p, 'access', _77 => _77.params, 'optionalAccess', _78 => _78.withdrawalAddress]),
+    permissions: {
+      walletAuthorization: _chunkHCB7RQ3Scjs.requiresAuthorization.call(void 0, p),
+      proof: p.kind !== "shield" && p.kind !== "revoke-credit",
+      fundingAuthorization: p.fundingMode === "signature"
+    }
+  };
+}
+
+// src/transactions/execution/PreparedTransaction.ts
+
+
+
+
+
+
+
+function check2(ok, message) {
+  if (!ok) throw new Error(message);
+}
+var PreparedTransaction = class _PreparedTransaction {
+  #runtime;
+  #saved;
+  #authorization;
+  #walletRequests = /* @__PURE__ */ new Map();
+  #lifecycle;
+  
+  constructor(runtime, saved, status, lifecycle, authorization) {
+    this.#runtime = runtime;
+    this.#saved = structuredClone(saved);
+    this.#lifecycle = lifecycle;
+    this.#authorization = authorization;
+    this.status = status;
+    _chunk3KTQQZOWcjs.bindBroadcasterOperation.call(void 0, this, {
+      quote: (client, options) => this.#quoteForBroadcaster(client, options),
+      submit: (client) => this.#submitViaBroadcaster(client),
+      provenanceContext: async () => {
+        this.current();
+        return {
+          chainId: this.#saved.plan.context.chainId,
+          protocolAddress: this.#saved.plan.context.protocolAddress
+        };
+      },
+      readProvenance: async () => {
+        this.current();
+        return structuredClone(this.#saved.provenance);
+      },
+      proveProvenance: (capability, reprove) => this.#proveProvenance(capability, reprove)
+    });
+    Object.freeze(this);
+  }
+  static prepare(runtime, plan) {
+    return new _PreparedTransaction(
+      runtime,
+      { plan: structuredClone(plan), generation: 0 },
+      "prepared",
+      { generation: 0, busy: false }
+    );
+  }
+  broadcasterQuote() {
+    return this.#saved.broadcasterQuote ? structuredClone(this.#saved.broadcasterQuote) : void 0;
+  }
+  async #quoteForBroadcaster(client, options) {
+    this.current();
+    check2(
+      this.status === "prepared" && this.#runtime.reprepare,
+      "broadcaster must attach to an unsigned prepared transaction"
+    );
+    const { prepareBroadcasterPlan } = await Promise.resolve().then(() => _interopRequireWildcard(require("./broadcaster-preparation-PJ263WBL.cjs")));
+    const selected = await prepareBroadcasterPlan(
+      this.#saved.plan,
+      this.#runtime.reprepare,
+      client,
+      options
+    );
+    return new _PreparedTransaction(
+      this.#runtime,
+      {
+        plan: selected.plan,
+        broadcasterQuote: selected.quote,
+        broadcasterBinding: selected.broadcasterBinding,
+        generation: 0
+      },
+      "prepared",
+      { generation: 0, busy: false }
+    );
+  }
+  async #proveProvenance(capability, reprove = false) {
+    this.current();
+    check2(this.status === "ready", "Ready transaction required for Provenance");
+    const { provePreparedProvenance } = await Promise.resolve().then(() => _interopRequireWildcard(require("./provenance-preparation-43DN2WK7.cjs")));
+    this.#lifecycle.busy = true;
+    try {
+      const packet = await provePreparedProvenance(
+        this.#saved,
+        this.#runtime,
+        capability,
+        reprove
+      );
+      if (!this.#saved.broadcasterAttempted) this.#saved.provenance = structuredClone(packet);
+      return packet;
+    } finally {
+      this.#lifecycle.busy = false;
+    }
+  }
+  async #submitViaBroadcaster(client) {
+    this.current();
+    check2(this.status === "ready", "transaction is not ready");
+    const { validateBroadcastEnvelope, validatePreparedBroadcast } = await Promise.resolve().then(() => _interopRequireWildcard(require("./provenance-preparation-43DN2WK7.cjs")));
+    validateBroadcastEnvelope(this.#saved, client);
+    if (this.#saved.broadcasterSubmissionId) {
+      try {
+        return await client.status(this.#saved.broadcasterSubmissionId);
+      } catch (error) {
+        const { BroadcasterRpcError } = await Promise.resolve().then(() => _interopRequireWildcard(require("./broadcaster-3KTB4JO2.cjs")));
+        if (!(error instanceof BroadcasterRpcError) || error.code !== -32001) throw error;
+      }
+    }
+    if (!this.#saved.broadcasterAttempted) {
+      const requirements = await client.submissionRequirements(this.#saved.broadcasterQuote);
+      if (requirements.provenanceRequired && this.#saved.plan.inputs.length && !this.#saved.provenance)
+        await this.#proveProvenance();
+      await validatePreparedBroadcast(this.#saved, client, this.#runtime);
+    }
+    this.#saved.externalized = true;
+    this.#saved.broadcasterAttempted = true;
+    const result = await client.submitTransaction(
+      this.#saved.call.data,
+      this.#saved.broadcasterQuote,
+      structuredClone(_nullishCoalesce(_optionalChain([this, 'access', _79 => _79.#saved, 'access', _80 => _80.provenance, 'optionalAccess', _81 => _81.sidecars]), () => ( [])))
+    );
+    check2(
+      !this.#saved.broadcasterSubmissionId || this.#saved.broadcasterSubmissionId === result.id,
+      "broadcaster changed submission ID"
+    );
+    this.#saved.broadcasterSubmissionId = result.id;
+    return result;
+  }
+  get id() {
+    return this.#saved.plan.id;
+  }
+  get kind() {
+    return this.#saved.plan.kind;
+  }
+  async estimateGas(options = {}) {
+    const provider = this.#runtime.options.provider;
+    if (!provider)
+      throw new (0, _primitives.MissingCapabilityError)("ethers provider for final eth_estimateGas");
+    const call = await this.exportTransaction();
+    return {
+      source: "rpc",
+      gasUnits: await provider.estimateGas({ ...call, ...options })
+    };
+  }
+  getGasReference() {
+    return getOperationGasReference(this.#saved.plan, this.#runtime.options.protocol);
+  }
+  /** Final Note outputs, including change; Credit outputs are not exported as IPN. */
+  getOutputs() {
+    return Object.freeze(
+      this.#saved.plan.outputs.map((output) => new (0, _chunkOCZLJKIAcjs.TransactionOutput)(output))
+    );
+  }
+  preview() {
+    return operationPreview(this.#saved.plan, this.status);
+  }
+  /** Obtain a firm quote before signing. This intent contains no private inputs or witness. */
+  async exportBroadcasterIntent() {
+    this.current();
+    check2(
+      ["prepared", "authorized"].includes(this.status),
+      "quote intent requires a prepared transaction"
+    );
+    return _chunkBBSRP4MHcjs.exportBroadcasterIntent.call(void 0, this.#saved.plan);
+  }
+  current() {
+    check2(
+      !this.#lifecycle.busy && this.#lifecycle.generation === this.#saved.generation,
+      "stale transaction handle or active worker"
+    );
+  }
+  async stage(stage, allowed, work, signal) {
+    _optionalChain([signal, 'optionalAccess', _82 => _82.throwIfAborted, 'call', _83 => _83()]);
+    this.current();
+    check2(allowed.includes(this.status), `invalid transaction stage for ${stage}`);
+    this.#lifecycle.busy = true;
+    const saved = structuredClone(this.#saved);
+    try {
+      const next = await work(saved);
+      _optionalChain([signal, 'optionalAccess', _84 => _84.throwIfAborted, 'call', _85 => _85()]);
+      saved.generation++;
+      this.#lifecycle.generation = saved.generation;
+      return new _PreparedTransaction(
+        this.#runtime,
+        saved,
+        next.status,
+        this.#lifecycle,
+        _nullishCoalesce(next.authorization, () => ( this.#authorization))
+      );
+    } finally {
+      this.#lifecycle.busy = false;
+    }
+  }
+  async exportRevocationAuthorization() {
+    this.current();
+    check2(this.status === "prepared", "revocation is not awaiting authorization");
+    return revocationSigningRequest(this.#saved.plan, this.#runtime);
+  }
+  async withRevocationSignature(signature) {
+    this.current();
+    const verified = await acceptRevocationSignature(
+      this.#saved.plan,
+      signature,
+      this.#runtime
+    );
+    return this.stage("revocation authorization", ["prepared"], async (saved) => {
+      saved.plan.credit.revocationSignature = verified;
+      saved.call = await this.encode(saved);
+      return { status: "ready" };
+    });
+  }
+  /** Export the same portable request used by managed native wallet transports. */
+  async exportWalletRequest(id, options = {}) {
+    _optionalChain([options, 'access', _86 => _86.signal, 'optionalAccess', _87 => _87.throwIfAborted, 'call', _88 => _88()]);
+    this.current();
+    check2(
+      _chunkHCB7RQ3Scjs.requiresAuthorization.call(void 0, this.#saved.plan),
+      "operation does not require wallet authorization"
+    );
+    check2(
+      ["prepared", "authorized"].includes(this.status),
+      "operation is not awaiting wallet authorization"
+    );
+    check2(!this.#walletRequests.has(id), "wallet request id already exported");
+    const request = _chunkHCB7RQ3Scjs.authorizationRequest.call(void 0, this.#saved.plan);
+    const prepared = _primitives.prepareWalletRequest.call(void 0, 
+      _primitives.Wallet.fromAddress(this.#saved.plan.scope.ownerAddress),
+      id,
+      "wallet.authorize",
+      {
+        ...request,
+        words: request.words.map(String),
+        context: {
+          chainId: request.context.chainId.toString(),
+          protocolAddress: request.context.protocolAddress.toString()
+        }
+      }
+    );
+    this.#walletRequests.set(id, prepared);
+    return structuredClone(prepared.request);
+  }
+  /** Independently validate host authorization against the retained request and frozen plan. */
+  async withWalletResponse(response, options = {}) {
+    _optionalChain([options, 'access', _89 => _89.signal, 'optionalAccess', _90 => _90.throwIfAborted, 'call', _91 => _91()]);
+    this.current();
+    check2(
+      _chunkHCB7RQ3Scjs.requiresAuthorization.call(void 0, this.#saved.plan),
+      "operation does not require wallet authorization"
+    );
+    const prepared = this.#walletRequests.get(response.id);
+    check2(prepared, "unknown wallet request response");
+    const authorization = await _primitives.acceptWalletResponse.call(void 0, 
+      prepared,
+      response
+    );
+    return this.stage(
+      "wallet authorization",
+      ["prepared", "authorized"],
+      async () => ({ status: "authorized", authorization }),
+      options.signal
+    );
+  }
+  /** Public EIP-712 request; signing transport and key custody belong to the caller. */
+  async exportWalletAuthorization(options = {}) {
+    _optionalChain([options, 'access', _92 => _92.signal, 'optionalAccess', _93 => _93.throwIfAborted, 'call', _94 => _94()]);
+    this.current();
+    check2(
+      _chunkHCB7RQ3Scjs.requiresAuthorization.call(void 0, this.#saved.plan),
+      "operation does not require wallet authorization"
+    );
+    check2(
+      ["prepared", "authorized"].includes(this.status),
+      "operation is not awaiting wallet authorization"
+    );
+    return walletSigningRequest(this.#saved.plan);
+  }
+  /** Attach an external EOA signature, retaining its witness only at the private proving boundary. */
+  async withWalletSignature(signature, options = {}) {
+    _optionalChain([options, 'access', _95 => _95.signal, 'optionalAccess', _96 => _96.throwIfAborted, 'call', _97 => _97()]);
+    this.current();
+    check2(
+      _chunkHCB7RQ3Scjs.requiresAuthorization.call(void 0, this.#saved.plan),
+      "operation does not require wallet authorization"
+    );
+    check2(
+      ["prepared", "authorized"].includes(this.status),
+      "operation is not awaiting wallet authorization"
+    );
+    const authorization = await acceptWalletSignature(this.#saved.plan, signature);
+    return this.stage(
+      "wallet authorization",
+      ["prepared", "authorized"],
+      async () => ({ status: "authorized", authorization }),
+      options.signal
+    );
+  }
+  /** Export only after proving when the funding authorization binds an actual proof hash. */
+  async exportFundingAuthorization(options = {}) {
+    _optionalChain([options, 'access', _98 => _98.signal, 'optionalAccess', _99 => _99.throwIfAborted, 'call', _100 => _100()]);
+    this.current();
+    check2(
+      this.status === (this.kind === "shield" ? "prepared" : "proved"),
+      "operation is not awaiting funding authorization or proof"
+    );
+    const request = await fundingSigningRequest(this.#saved, this.#runtime);
+    _optionalChain([options, 'access', _101 => _101.signal, 'optionalAccess', _102 => _102.throwIfAborted, 'call', _103 => _103()]);
+    this.current();
+    return request;
+  }
+  /** Verify an external signature against this handle's own frozen operation. */
+  async withFundingSignature(signature, options = {}) {
+    _optionalChain([options, 'access', _104 => _104.signal, 'optionalAccess', _105 => _105.throwIfAborted, 'call', _106 => _106()]);
+    this.current();
+    check2(
+      this.status === (this.kind === "shield" ? "prepared" : "proved"),
+      "operation is not awaiting funding authorization or proof"
+    );
+    const verified = await acceptFundingSignature(this.#saved, signature, this.#runtime);
+    return this.stage(
+      "funding authorization",
+      this.kind === "shield" ? ["prepared"] : ["proved"],
+      async (saved) => {
+        saved.plan.funding.signature = verified;
+        if (_optionalChain([saved, 'access', _107 => _107.plan, 'access', _108 => _108.statement, 'optionalAccess', _109 => _109.target]) !== "noir-recursive") {
+          saved.call = await this.encode(saved);
+        }
+        return { status: "ready" };
+      },
+      options.signal
+    );
+  }
+  async prove(backendOrOptions = {}, suppliedOptions = {}) {
+    const options = { ..."prove" in backendOrOptions ? suppliedOptions : backendOrOptions };
+    check2(
+      !this.#saved.broadcasterQuote || options.execution !== "aggregate",
+      "a broadcaster quote requires direct execution"
+    );
+    const plan = this.#saved.plan;
+    check2(
+      plan.kind !== "shield" && plan.kind !== "revoke-credit",
+      "operation requires no proof"
+    );
+    if (_chunkHCB7RQ3Scjs.requiresAuthorization.call(void 0, plan)) {
+      check2(
+        this.#authorization,
+        "local wallet authorization required; authorize again after recovery"
+      );
+    }
+    const prover = "prove" in backendOrOptions ? backendOrOptions : this.#runtime.options.prover;
+    if (!prover) {
+      throw new (0, _primitives.MissingCapabilityError)("prover");
+    }
+    return this.stage(
+      "proof",
+      _chunkHCB7RQ3Scjs.requiresAuthorization.call(void 0, plan) ? ["authorized"] : ["prepared"],
+      async (saved) => {
+        const p = saved.plan;
+        saved.proof = await proveOperation(
+          this.#runtime.options.protocol,
+          p,
+          this.#authorization,
+          prover,
+          options
+        );
+        if (p.fundingMode === "signature") {
+          return { status: "proved" };
+        }
+        if (_optionalChain([p, 'access', _110 => _110.statement, 'optionalAccess', _111 => _111.target]) !== "noir-recursive") {
+          saved.call = await this.encode(saved);
+        }
+        return { status: "ready" };
+      },
+      options.signal
+    );
+  }
+  encode(saved) {
+    return encodeOperation(saved);
+  }
+  /** Shield caller funding needs no wallet signing or proof; this step only encodes its frozen request. */
+  async ready() {
+    check2(
+      this.kind === "shield" && this.#saved.plan.fundingMode === "caller" || this.kind === "revoke-credit",
+      "operation needs authorization or proof first"
+    );
+    return this.stage("encoding", ["prepared"], async (saved) => {
+      saved.call = await this.encode(saved);
+      return { status: "ready" };
+    });
+  }
+  async exportTransaction() {
+    this.current();
+    check2(
+      _optionalChain([this, 'access', _112 => _112.#saved, 'access', _113 => _113.plan, 'access', _114 => _114.statement, 'optionalAccess', _115 => _115.target]) !== "noir-recursive",
+      "recursive operations must be exported as aggregate members"
+    );
+    check2(this.status === "ready" && this.#saved.call, "transaction is not ready");
+    return structuredClone(this.#saved.call);
+  }
+  exportProof() {
+    this.current();
+    check2(this.#saved.proof, "transaction has no proof");
+    return publicProof(this.#saved.proof);
+  }
+  exportAggregateMember() {
+    this.current();
+    const saved = this.#saved, plan = saved.plan;
+    check2(
+      this.status === "ready" && plan.params && saved.proof && _optionalChain([plan, 'access', _116 => _116.statement, 'optionalAccess', _117 => _117.target]) === "noir-recursive" && plan.statement.circuitName.startsWith("transact_user_slots") && (_nullishCoalesce(plan.capacity, () => ( 0))) <= 10,
+      "ready recursive C1..C10 transaction required"
+    );
+    sameStatement(saved.proof, _chunkHCB7RQ3Scjs.statement.call(void 0, plan));
+    check2(
+      saved.proof.proofHex.length === 2 + 458 * 64,
+      "recursive member proof must have 458 fields"
+    );
+    return {
+      bundle: publicProof(saved.proof),
+      statement: structuredClone(plan.statement),
+      context: { ...plan.context },
+      request: {
+        params: structuredClone(plan.params),
+        deliveries: plan.outputs.map((output) => structuredClone(output.delivery)),
+        funding: _protocol2.normalizeFunding.call(void 0, plan.funding)
+      }
+    };
+  }
+  toJSON() {
+    return { transaction: true, id: this.id, kind: this.kind, status: this.status };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+};
+
+// src/client/infrastructure.ts
+
+
+function configureTransactionInfrastructure(options) {
+  const { provider } = options;
+  const reader = _nullishCoalesce(options.chainReader, () => ( (provider ? new (0, _chunkLOR6PYH5cjs.EthersChainReader)(provider) : void 0)));
+  const protocolRpc = options.protocolRpc instanceof _rpc.ProtocolRpcClient && reader ? options.protocolRpc.withReader(reader) : options.protocolRpc;
+  const fundingVerifier = _nullishCoalesce(options.fundingVerifier, () => ( (provider ? new (0, _chunkLOR6PYH5cjs.EthersFundingVerifier)(provider, options.protocol.context.chainId) : void 0)));
+  return _chunkMA2QZEF5cjs.configureRecipientInfrastructure.call(void 0, {
+    ...options,
+    ...reader ? { chainReader: reader } : {},
+    ...protocolRpc ? { protocolRpc } : {},
+    ...fundingVerifier ? { fundingVerifier } : {}
+  });
+}
+async function validateTransactionInfrastructure(options) {
+  if (!options.chainReader) throw new (0, _primitives.MissingCapabilityError)("chain reader");
+  if (options.provider && (await options.provider.getNetwork()).chainId !== options.protocol.context.chainId)
+    throw new Error("provider deployment chain mismatch");
+  await options.protocol.validateDeployment(options.chainReader);
+}
+
+// src/client/Invisi.ts
+
+
+
+// src/transactions/preparation/explicit-preparation.ts
+
+function explicitPreparation(options, data, tokenAddress) {
+  if (!options.chainReader) throw new Error("chain reader required");
+  const inputs = structuredClone(_nullishCoalesce(data.inputs, () => ( [])));
+  const credits = structuredClone(_nullishCoalesce(data.creditInputs, () => ( [])));
+  const inventory = { notes: {}, credits: {}, reservations: {} };
+  const context = options.protocol.context;
+  function position2(input) {
+    if (typeof input.treeId !== "bigint" || input.treeId < 0n || input.treeId >= 1n << 256n || !Number.isInteger(input.leafIndex) || input.leafIndex < 0 || input.leafIndex >= 65536)
+      throw new Error("invalid explicit input position");
+  }
+  for (const input of inputs) {
+    position2(input);
+    _chunkMA2QZEF5cjs.positiveAmount.call(void 0, input.note.amount);
+    if (inventory.notes[input.commitment]) throw new Error("duplicate explicit note input");
+    if (input.note.chainId !== context.chainId || input.note.protocolAddress !== BigInt(context.protocolAddress) || input.note.ownerAddress !== options.wallet.ownerAddress)
+      throw new Error("explicit note identity or deployment mismatch");
+    inventory.notes[input.commitment] = { ...input, spent: "unspent" };
+  }
+  for (const input of credits) {
+    position2(input);
+    if (input.role !== "owner" && input.role !== "spender")
+      throw new Error("invalid explicit Credit role");
+    const key = input.commitment + ":" + input.role;
+    if (inventory.credits[key]) throw new Error("duplicate explicit Credit input");
+    inventory.credits[key] = { ...input, spent: "unspent" };
+  }
+  const scope = {
+    ...context,
+    namespace: "explicit",
+    ownerAddress: options.wallet.ownerAddress
+  };
+  const capabilities = options;
+  if (inputs.some((input) => input.note.tokenAddress !== BigInt(_ethers.getAddress.call(void 0, tokenAddress))))
+    throw new Error("explicit note token mismatch");
+  const runtime = {
+    options: { ...capabilities, protocol: options.protocol.forToken(tokenAddress) },
+    reader: options.chainReader,
+    scope
+  };
+  const reprepare = (intent) => Promise.resolve().then(() => _interopRequireWildcard(require("./broadcaster-preparation-PJ263WBL.cjs"))).then(
+    ({ prepareIntent }) => prepareIntent(
+      {
+        ...runtime,
+        explicitInputs: true,
+        ...data.changeAddress ? { changeAddress: data.changeAddress } : {},
+        readInventory: async () => structuredClone(inventory),
+        complete: async (plan) => plan
+      },
+      intent
+    )
+  );
+  return new (0, _chunkBBSRP4MHcjs.TransactionPreparation)({
+    ...runtime,
+    explicitInputs: true,
+    ...data.changeAddress ? { changeAddress: data.changeAddress } : {},
+    readInventory: async () => structuredClone(inventory),
+    complete: async (plan) => PreparedTransaction.prepare({ ...runtime, reprepare }, plan)
+  });
+}
+
+// src/client/Invisi.ts
+var Invisi = class {
+  #options;
+  constructor(options = {}) {
+    if ("addressLookup" in options || "addressResolver" in options)
+      throw new TypeError(
+        "Recipient lookup belongs to each EVM output; caller resolver injection is not supported"
+      );
+    if ("ciphertextCodecs" in options || "envelopeVersion" in options) {
+      throw new Error(
+        "SDK envelope versions are fixed; encode application payload bytes externally"
+      );
+    }
+    if ("signer" in options || "fundingSigner" in options) {
+      throw new Error(
+        "Invisi does not accept signer defaults; export a signing request and attach the external signature"
+      );
+    }
+    for (const key of [
+      "store",
+      "viewing",
+      "authorization",
+      "namespace",
+      "coinSelector",
+      "wallet",
+      "protocol"
+    ]) {
+      if (key in options)
+        throw new TypeError(`Wallet state and permissions belong to WalletSession: ${key}`);
+    }
+    this.#options = {
+      ...options
+    };
+    Object.freeze(this);
+  }
+  /** A detached snapshot of shared infrastructure; wallet permissions and persistence stay external. */
+  getInfrastructure() {
+    return Object.freeze({
+      ...this.#options
+    });
+  }
+  async resolve(options) {
+    const runtime = configureTransactionInfrastructure({
+      ...this.getInfrastructure(),
+      ...options
+    });
+    await validateTransactionInfrastructure(runtime);
+    return runtime;
+  }
+  /** Discover the selected chain's registry and prepare an independent signing request. */
+  async prepareRegistration(options) {
+    return _chunk4SDP53YQcjs.prepareWithErrors.call(void 0, "prepareRegistration", async () => {
+      for (const key of Object.keys(options)) {
+        if (!["wallet", "update", "deadline"].includes(key)) {
+          throw new Error(`Unknown registration option: ${key}`);
+        }
+      }
+      this.assertPublicIdentity(options);
+      const selected = { ...options };
+      const { provider, protocolRpc } = this.#options;
+      if (!provider) throw new (0, _primitives.MissingCapabilityError)("ethers provider");
+      if (!(protocolRpc instanceof _rpc.ProtocolRpcClient)) {
+        throw new (0, _primitives.MissingCapabilityError)("Protocol RPC deployment discovery");
+      }
+      const chainId = (await provider.getNetwork()).chainId;
+      const deployment = await protocolRpc.getDeployment(chainId);
+      if (!deployment.registry) {
+        throw new (0, _primitives.MissingCapabilityError)("receiving-key registry deployment");
+      }
+      const registry = new AddressRegistry(
+        { chainId, registryAddress: deployment.registry.address },
+        { expectedRuntimeCodeHash: deployment.registry.runtimeCodeHash }
+      );
+      return registry.prepareRegistration({ ...selected, provider });
+    });
+  }
+  assertPublicIdentity(options) {
+    const { wallet } = options;
+    if (!(wallet instanceof _primitives.Wallet) || ["getViewer", "getDetector", "exportAuthorization"].some((key) => key in wallet)) {
+      throw new Error(
+        "Independent preparation requires a Wallet without private capabilities"
+      );
+    }
+    for (const key of ["authorization", "signer", "fundingSigner", "viewing"]) {
+      if (key in options)
+        throw new Error(`Independent preparation does not accept capability: ${key}`);
+    }
+  }
+  resolveExplicit(options) {
+    this.assertPublicIdentity(options);
+    return this.resolve({ wallet: options.wallet, protocol: options.protocol });
+  }
+  async prepareTransfer(options) {
+    return _chunk4SDP53YQcjs.prepareWithErrors.call(void 0, "prepareTransfer", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, request, request.tokenAddress);
+      return preparation.prepareTransfer(request);
+    });
+  }
+  async prepareShield(options) {
+    return _chunk4SDP53YQcjs.prepareWithErrors.call(void 0, "prepareShield", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, {}, request.tokenAddress);
+      return preparation.prepareShield(request);
+    });
+  }
+  async prepareCreateCredit(options) {
+    return _chunk4SDP53YQcjs.prepareWithErrors.call(void 0, "prepareCreateCredit", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, {}, request.tokenAddress);
+      return preparation.prepareCreateCredit(request);
+    });
+  }
+  async prepareDrawCredit(options) {
+    return _chunk4SDP53YQcjs.prepareWithErrors.call(void 0, "prepareDrawCredit", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, request, request.tokenAddress);
+      return preparation.prepareDrawCredit(request);
+    });
+  }
+  async prepareUpdateCredit(options) {
+    return _chunk4SDP53YQcjs.prepareWithErrors.call(void 0, "prepareUpdateCredit", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, request, request.tokenAddress);
+      return preparation.prepareUpdateCredit(request);
+    });
+  }
+  async prepareRevokeCredit(options) {
+    return _chunk4SDP53YQcjs.prepareWithErrors.call(void 0, "prepareRevokeCredit", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, {}, request.tokenAddress);
+      return preparation.prepareRevokeCredit(request);
+    });
+  }
+  toJSON() {
+    return { invisi: true };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+};
+
+// src/discovery/protocol-events.ts
+var _contracts = require('@invisi-labs/protocol/contracts');
+
+var protocolInterface = new (0, _ethers.Interface)(_contracts.invisiProtocolAbi);
+function decodeProtocolEvent(log) {
+  const decoded = protocolInterface.parseLog(log);
+  if (!decoded) throw new Error("Unknown protocol receipt event");
+  const encoded = protocolInterface.encodeEventLog(decoded.fragment, decoded.args);
+  if (encoded.data.toLowerCase() !== log.data.toLowerCase() || encoded.topics.length !== log.topics.length || encoded.topics.some(
+    (topic, index2) => topic.toLowerCase() !== log.topics[index2].toLowerCase()
+  ))
+    throw new Error("Noncanonical protocol receipt event");
+  const value = (type, item) => {
+    if (type.baseType === "array")
+      return Array.from(item, (v) => value(type.arrayChildren, v));
+    if (type.baseType === "tuple")
+      return Object.fromEntries(
+        type.components.map((t, i) => [t.name, value(t, item[i])])
+      );
+    return item;
+  };
+  const args = Object.fromEntries(
+    decoded.fragment.inputs.map((type, i) => [type.name, value(type, decoded.args[i])])
+  );
+  return { eventName: decoded.name, args };
+}
+
+// src/discovery/receipt-logs.ts
+function readProtocolLogs(receipt, protocolAddress) {
+  if (receipt.status !== "success" || !/^0x[0-9a-fA-F]{64}$/.test(receipt.transactionHash) || typeof receipt.block.number !== "bigint" || receipt.block.number < 0n || !/^0x[0-9a-fA-F]{64}$/.test(receipt.block.hash))
+    throw new Error("Invalid canonical protocol receipt");
+  const seen = /* @__PURE__ */ new Set();
+  return receipt.logs.filter((log) => log.address.toLowerCase() === protocolAddress.toLowerCase()).map((log) => {
+    if (log.transactionHash.toLowerCase() !== receipt.transactionHash.toLowerCase() || !Number.isSafeInteger(log.logIndex) || log.logIndex < 0 || seen.has(log.logIndex))
+      throw new Error("Invalid canonical receipt log identity");
+    seen.add(log.logIndex);
+    const decoded = decodeProtocolEvent(log);
+    return {
+      address: log.address,
+      eventName: decoded.eventName,
+      args: decoded.args,
+      blockNumber: receipt.block.number,
+      blockHash: receipt.block.hash,
+      transactionHash: receipt.transactionHash.toLowerCase(),
+      logIndex: log.logIndex,
+      removed: false
+    };
+  }).sort((a, b) => a.logIndex - b.logIndex);
+}
+
+// src/discovery/discovery.ts
+
+
+
+
+
+
+
+
+var EVENTS = /* @__PURE__ */ new Set([
+  "CommitmentsInserted",
+  "BatchOutputs",
+  "Shield",
+  "Transact",
+  "CrossTreeTransact",
+  "CreditCreated",
+  "CreditDraw",
+  "CreditUpdated",
+  "CreditRevoked"
+]);
+function check3(ok, message) {
+  if (!ok) throw new Error(message);
+}
+function object(value) {
+  check3(value && typeof value === "object" && !Array.isArray(value), "invalid event object");
+  return value;
+}
+function array(value) {
+  check3(Array.isArray(value), "invalid event array");
+  check3(
+    Array.from({ length: value.length }, (_, i) => i in value).every(Boolean),
+    "sparse event array"
+  );
+  return value;
+}
+function integer(value) {
+  check3(
+    typeof value === "bigint" || typeof value === "number" && Number.isSafeInteger(value),
+    "invalid event integer"
+  );
+  const n = BigInt(value);
+  check3(n >= 0n, "negative event integer");
+  return n;
+}
+function index(value) {
+  const n = integer(value);
+  check3(n < 65536n, "invalid event leaf index");
+  return Number(n);
+}
+function hash(value) {
+  check3(typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value), "invalid event hash");
+  return value.toLowerCase();
+}
+function contextCheck(context) {
+  check3(context.chainId >= 0n && context.chainId < 1n << 64n, "invalid discovery chain");
+  check3(
+    _ethers.isAddress.call(void 0, context.protocolAddress) && BigInt(context.protocolAddress) !== 0n,
+    "invalid discovery instance/token"
+  );
+}
+var position = (tree, at) => `${tree}:${at}`;
+function extractDeliveryCandidates(logs, context, confirmedThrough) {
+  contextCheck(context);
+  check3(confirmedThrough >= 0n, "invalid confirmed height");
+  const relevant = logs.filter(
+    (log) => log.address.toLowerCase() === context.protocolAddress.toLowerCase() && EVENTS.has(log.eventName)
+  );
+  const insertions = /* @__PURE__ */ new Map();
+  const metadata = (log) => {
+    check3(!log.removed, "discovery resync required after reorg");
+    check3(
+      typeof log.blockNumber === "bigint" && log.blockNumber >= 0n && log.blockNumber <= confirmedThrough,
+      "event is not confirmed"
+    );
+    check3(Number.isSafeInteger(log.logIndex) && log.logIndex >= 0, "invalid log position");
+    return {
+      blockNumber: log.blockNumber,
+      blockHash: hash(log.blockHash),
+      transactionHash: hash(log.transactionHash)
+    };
+  };
+  const insertionKey = (log, tree, at) => `${hash(log.transactionHash)}:${position(tree, at)}`;
+  for (const log of relevant) {
+    metadata(log);
+    if (log.eventName !== "CommitmentsInserted" && log.eventName !== "BatchOutputs") continue;
+    const a = object(log.args), tree = integer(a.treeId), start = index(a.startLeafIndex), leaves = array(log.eventName === "BatchOutputs" ? a.noteCommitments : a.commitments);
+    check3(tree > 0n && tree < 1n << 64n, "invalid insertion tree");
+    check3(start + leaves.length <= 65536, "insertion exceeds tree capacity");
+    for (const [i, leaf] of leaves.entries()) {
+      const key = insertionKey(log, tree, start + i), value = hash(leaf), previous = insertions.get(key);
+      check3(!previous || previous === value, "conflicting insertion events");
+      insertions.set(key, value);
+    }
+  }
+  const results = /* @__PURE__ */ new Map();
+  const add = (log, tree, at, commitment, role, wire, token = _nullishCoalesce(_nullishCoalesce(_optionalChain([log, 'access', _118 => _118.args, 'optionalAccess', _119 => _119.token]), () => ( _optionalChain([log, 'access', _120 => _120.args, 'optionalAccess', _121 => _121.params, 'optionalAccess', _122 => _122.token]))), () => ( _optionalChain([log, 'access', _123 => _123.args, 'optionalAccess', _124 => _124.params, 'optionalAccess', _125 => _125.creation, 'optionalAccess', _126 => _126.token])))) => {
+    check3(tree > 0n && tree < 1n << 64n, "invalid output tree");
+    const inserted = insertions.get(insertionKey(log, tree, at));
+    check3(inserted, "delivery has no matching canonical insertion");
+    if (commitment !== void 0)
+      check3(hash(commitment) === inserted, "delivery commitment conflicts with insertion");
+    const delivery = _protocol2.normalizeOpaqueDelivery.call(void 0, wire, { allowEmpty: role === "funds" });
+    check3(
+      typeof token === "string" && _ethers.isAddress.call(void 0, token) && BigInt(token) !== 0n,
+      "invalid event token"
+    );
+    const value = {
+      tokenAddress: token,
+      treeId: tree,
+      leafIndex: at,
+      commitment: inserted,
+      role,
+      delivery,
+      ...metadata(log)
+    };
+    const key = `${insertionKey(log, tree, at)}:${role}`, previous = results.get(key);
+    check3(
+      !previous || previous.tokenAddress.toLowerCase() === token.toLowerCase() && previous.delivery.ciphertext === delivery.ciphertext && previous.delivery.clue === delivery.clue && previous.blockHash === value.blockHash,
+      "conflicting delivery events"
+    );
+    results.set(key, value);
+  };
+  const creation = (log, a, fields) => {
+    const tree = integer(a.outputTreeId), leaf = index(a.leafIndex), ds = array(a.deliveries);
+    check3(ds.length === 2, "invalid Credit delivery slots");
+    add(log, tree, leaf, fields.creditCommitment, "owner", ds[0]);
+    add(log, tree, leaf, fields.creditCommitment, "spender", ds[1]);
+  };
+  for (const log of relevant) {
+    const a = object(log.args);
+    if (log.eventName === "Shield") {
+      const ds = array(a.deliveries), tree = integer(a.treeId), start = index(a.startLeafIndex);
+      check3(start + ds.length <= 65536, "shield exceeds tree capacity");
+      ds.forEach((d, i) => add(log, tree, start + i, void 0, "funds", d));
+    } else if (log.eventName === "Transact" || log.eventName === "CrossTreeTransact") {
+      const cs = array(a.noteCommitments), ds = array(a.deliveries), leaves = array(a.leafIndices), tree = integer(a.outputTreeId);
+      check3(
+        cs.length === ds.length && cs.length === leaves.length,
+        "invalid transact delivery slots"
+      );
+      cs.forEach((c, i) => add(log, tree, index(leaves[i]), c, "funds", ds[i]));
+    } else if (log.eventName === "BatchOutputs") {
+      const tokens = array(a.tokens);
+      const cs = array(a.noteCommitments), tree = integer(a.treeId), start = index(a.startLeafIndex), packed = a.packedDeliveries;
+      check3(
+        typeof packed === "string" && /^0x(?:[0-9a-fA-F]{2})*$/.test(packed),
+        "invalid packed deliveries"
+      );
+      check3(tokens.length === cs.length, "batch token count mismatch");
+      check3(start + cs.length <= 65536, "batch exceeds tree capacity");
+      let offset = 2;
+      cs.forEach((c, i) => {
+        check3(offset + 4 <= packed.length, "truncated delivery length prefix");
+        const length = Number.parseInt(packed.slice(offset, offset + 4), 16);
+        offset += 4;
+        check3(
+          length <= _primitives.MAX_CIPHERTEXT_BYTES && offset + length * 2 + (length === 0 ? 0 : 136) <= packed.length,
+          "invalid packed delivery length"
+        );
+        const ciphertext = `0x${packed.slice(offset, offset + length * 2)}`;
+        offset += length * 2;
+        const clue = length === 0 ? "0x" : `0x${packed.slice(offset, offset + 136)}`;
+        if (length !== 0) offset += 136;
+        add(log, tree, start + i, c, "funds", { ciphertext, clue }, tokens[i]);
+      });
+      check3(offset === packed.length, "trailing packed delivery bytes");
+    } else if (log.eventName === "CreditCreated") creation(log, a, a);
+    else if (log.eventName === "CreditUpdated") creation(log, a, object(a.params));
+    else if (log.eventName === "CreditDraw") {
+      const p = object(a.params), cs = array(p.creditCommitments), ds = array(a.deliveries), leaves = array(a.leafIndices), tree = integer(a.outputTreeId);
+      check3(
+        ds.length === 2 * cs.length + 1 && leaves.length === cs.length + 1,
+        "invalid draw delivery slots"
+      );
+      cs.forEach((c, i) => {
+        add(log, tree, index(leaves[i]), c, "owner", ds[2 * i]);
+        add(log, tree, index(leaves[i]), c, "spender", ds[2 * i + 1]);
+      });
+      add(
+        log,
+        tree,
+        index(leaves[cs.length]),
+        p.noteCommitment,
+        "funds",
+        ds[2 * cs.length],
+        p.token
+      );
+    }
+  }
+  return [...results.values()];
+}
+async function decryptCandidates(logs, options) {
+  contextCheck(options.context);
+  _primitives.decodeAddress.call(void 0, _primitives.ReceivingAddress.fromIdentity(options.viewing.ownerAddress).toString());
+  check3(
+    !logs.some(
+      (log) => log.address.toLowerCase() === options.context.protocolAddress.toLowerCase() && log.removed
+    ),
+    "discovery resync required after reorg"
+  );
+  const candidates = extractDeliveryCandidates(logs, options.context, options.confirmedThrough);
+  const positions = /* @__PURE__ */ new Map();
+  const unique = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = position(candidate.treeId, candidate.leafIndex);
+    const previous = positions.get(key);
+    check3(
+      !previous || previous.commitment === candidate.commitment && previous.blockHash === candidate.blockHash && previous.transactionHash === candidate.transactionHash && previous.tokenAddress.toLowerCase() === candidate.tokenAddress.toLowerCase(),
+      "conflicting canonical position"
+    );
+    positions.set(key, candidate);
+    unique.set(`${key}:${candidate.role}`, candidate);
+  }
+  const notes = [];
+  const credits = [];
+  for (const candidate of unique.values()) {
+    const { delivery, role, ...positionData } = candidate;
+    const context = {
+      chainId: options.context.chainId,
+      protocolAddress: BigInt(options.context.protocolAddress),
+      tokenAddress: BigInt(candidate.tokenAddress),
+      outputCommitment: candidate.commitment
+    };
+    try {
+      if (role === "funds") {
+        if (delivery.ciphertext === "0x") continue;
+        const note = await options.viewing.decryptNote(delivery.ciphertext, context);
+        if (note !== null) notes.push({ ...positionData, note });
+      } else {
+        const state = await options.viewing.decryptCredit(delivery.ciphertext, {
+          ...context,
+          role
+        });
+        if (state !== null) credits.push({ ...positionData, role, state });
+      }
+    } catch (error) {
+      if (error instanceof _primitives.DeliveryDecryptionError) throw error;
+    }
+  }
+  return { notes, credits };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AddressRegistry = AddressRegistry; exports.revocationSigningRequest = revocationSigningRequest; exports.acceptRevocationSignature = acceptRevocationSignature; exports.creditReservationKey = creditReservationKey; exports.inputFacts = inputFacts; exports.operationSources = operationSources; exports.getOperationGasReference = getOperationGasReference; exports.getDocumentedGasReference = _protocol2.getDocumentedGasReference; exports.publicProof = publicProof; exports.sameStatement = sameStatement; exports.encodeOperation = encodeOperation; exports.witnessFor = witnessFor; exports.fundingTypedData = fundingTypedData; exports.proveOperation = proveOperation; exports.signOperationFunding = signOperationFunding; exports.walletSigningRequest = walletSigningRequest; exports.acceptWalletSignature = acceptWalletSignature; exports.fundingSigningRequest = fundingSigningRequest; exports.acceptFundingSignature = acceptFundingSignature; exports.operationPreview = operationPreview; exports.PreparedTransaction = PreparedTransaction; exports.configureTransactionInfrastructure = configureTransactionInfrastructure; exports.validateTransactionInfrastructure = validateTransactionInfrastructure; exports.Invisi = Invisi; exports.decodeProtocolEvent = decodeProtocolEvent; exports.readProtocolLogs = readProtocolLogs; exports.extractDeliveryCandidates = extractDeliveryCandidates; exports.decryptCandidates = decryptCandidates;
+//# sourceMappingURL=chunk-NKYHYIRP.cjs.map