@invisi-labs/sdk 1.1.7 → 1.2.0

package/dist/chunk-4H4FARQK.js

@@ -0,0 +1,1582 @@
+import {
+  TransactionPreparation,
+  exportBroadcasterIntent
+} from "./chunk-HLH5JZD4.js";
+import {
+  authorizationRequest,
+  requiresAuthorization,
+  statement
+} from "./chunk-THMD5QO2.js";
+import {
+  TransactionOutput
+} from "./chunk-DGMVGFKM.js";
+import {
+  bindBroadcasterOperation
+} from "./chunk-R5YAOJKB.js";
+import {
+  assertCreditUpdatePlan,
+  configureRecipientInfrastructure,
+  positiveAmount
+} from "./chunk-RY4M2CIQ.js";
+import {
+  prepareWithErrors
+} from "./chunk-GUD3LAUO.js";
+import {
+  EthersChainReader,
+  EthersFundingVerifier
+} from "./chunk-4VI6LYGH.js";
+
+// src/protocol/AddressRegistry.ts
+import { AddressRegistry as Registry } from "@invisi-labs/rpc";
+var AddressRegistry = class extends Registry {
+  prepareRegistration(options) {
+    return prepareWithErrors("prepareRegistration", async () => {
+      if ("provider" in options) {
+        const { provider, ...preparation } = options;
+        return super.prepareRegistration({
+          ...preparation,
+          reader: new EthersChainReader(provider)
+        });
+      }
+      return super.prepareRegistration(options);
+    });
+  }
+};
+
+// src/transactions/signing/revocation.ts
+import { createSigningRequest } from "@invisi-labs/primitives";
+import { encodeRevokeCreditTypedData } from "@invisi-labs/protocol";
+import { getAddress, verifyTypedData } from "ethers";
+async function revocationSigningRequest(plan, runtime) {
+  const params = plan.credit?.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 = createSigningRequest(
+    encodeRevokeCreditTypedData({ ...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 = getAddress(
+      verifyTypedData(request.domain, request.types, request.message, signature)
+    ) === getAddress(owner);
+  } catch {
+  }
+  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 = plan.params?.nullifiers ?? [];
+  let creditNullifiers = [];
+  if (credit?.draw) {
+    creditNullifiers = credit.draw.nullifiers;
+  } else if (credit?.update) {
+    creditNullifiers = [credit.update.nullifier];
+  }
+  if (noteNullifiers.length !== plan.inputs.length || creditNullifiers.length !== (credit?.inputs.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"
+    })),
+    ...(credit?.inputs ?? []).map((input, index2) => ({
+      key: input.commitment + ":" + input.role,
+      reservationKey: creditReservationKey(input.commitment),
+      nullifier: creditNullifiers[index2],
+      kind: "credits"
+    }))
+  ];
+}
+function operationSources(plan) {
+  const noteSources = plan.params?.sources;
+  if (noteSources != null) return noteSources;
+  const credit = plan.credit;
+  if (credit?.draw) return credit.draw.sources;
+  if (credit?.update) return [credit.update.source];
+  return [];
+}
+
+// src/gas/gas-estimation.ts
+import { getDocumentedGasReference } from "@invisi-labs/protocol";
+import { getDocumentedGasReference as getDocumentedGasReference2 } from "@invisi-labs/protocol";
+function getOperationGasReference(plan, _protocol) {
+  let query = { kind: plan.kind };
+  const credit = plan.credit;
+  if (plan.statement?.target === "noir-recursive")
+    return getDocumentedGasReference({ kind: "aggregate" });
+  if (credit?.creation)
+    query = { kind: "create-credit", scenario: "first-allocation-empty-tree" };
+  else if (credit?.update)
+    query = { kind: "update-credit", scenario: "after-draw-preserve-usage" };
+  else if (credit?.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" : !(plan.funding.amount ?? 0n) && !(plan.params?.withdrawalAmount ?? 0n) && !(plan.params?.feeAmount ?? 0n) ? "private" : "mixed"
+    };
+  if (credit) {
+    const feeAmount = credit.creation?.feeAmount ?? credit.update?.feeAmount ?? credit.draw?.feeAmount ?? credit.revocation?.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) || credit?.outputs.some((o) => o.deliveries.some((d) => (d.ciphertext.length - 2) / 2 !== 485)))
+    return getDocumentedGasReference({ kind: "unmeasured-delivery-size" });
+  return getDocumentedGasReference(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
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex } from "@noble/hashes/utils";
+import { getBytes } from "ethers";
+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) && bytesToHex(sha256(getBytes(proof.proofHex))) === proof.proofSha256,
+    "proof integrity mismatch"
+  );
+}
+
+// src/transactions/execution/calldata.ts
+import {
+  buildRevokeCreditCalldata,
+  buildCreateCreditCalldata,
+  buildCreditDrawCalldata,
+  buildShieldCalldata,
+  buildUpdateCreditCalldata,
+  buildTransactCalldata
+} from "@invisi-labs/protocol";
+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: saved.proof?.proofHex ?? "0x" };
+  const funded = { ...common, funding: plan.funding, ...caller ? { caller } : {} };
+  let encoded;
+  if (credit?.update) {
+    encoded = buildUpdateCreditCalldata({
+      ...funded,
+      params: credit.update,
+      deliveries: credit.deliveries
+    });
+  } else if (credit?.creation) {
+    encoded = buildCreateCreditCalldata({
+      ...funded,
+      params: credit.creation,
+      deliveries: credit.deliveries
+    });
+  } else if (credit?.draw) {
+    encoded = buildCreditDrawCalldata({
+      ...common,
+      params: credit.draw,
+      deliveries: credit.deliveries
+    });
+  } else if (credit?.revocation) {
+    encoded = buildRevokeCreditCalldata({
+      context: plan.context,
+      params: credit.revocation,
+      signature: credit.revocationSignature ?? "0x",
+      ...credit.revocationCaller ? { caller: credit.revocationCaller } : {}
+    });
+  } else if (plan.kind === "shield") {
+    encoded = await buildShieldCalldata({
+      ...funded,
+      params: plan.shieldParams,
+      outputs: plan.shieldOutputs,
+      deliveries: plan.outputs.map((output) => output.delivery)
+    });
+  } else {
+    encoded = buildTransactCalldata({
+      ...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
+import { WitnessBuilder } from "@invisi-labs/prover";
+async function witnessFor(protocol, plan, authorization) {
+  const builder = new WitnessBuilder(protocol);
+  const credit = plan.credit;
+  if (credit) {
+    if (!authorization) throw new Error("private Credit wallet authorization required");
+    if (credit.update) {
+      await assertCreditUpdatePlan(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
+import {
+  encodeAggregateFundingTypedData,
+  encodeShieldFundingTypedData,
+  encodeTransactFundingTypedData
+} from "@invisi-labs/protocol";
+async function fundingTypedData(saved) {
+  const plan = saved.plan;
+  if (plan.credit) throw Error("Credit operations have no funding authorization");
+  if (plan.kind === "shield") {
+    return encodeShieldFundingTypedData({
+      context: plan.context,
+      params: plan.shieldParams,
+      outputs: plan.shieldOutputs,
+      deliveries: plan.outputs.map((output) => output.delivery),
+      funding: plan.funding
+    });
+  }
+  if (plan.statement?.target === "noir-recursive") {
+    return encodeAggregateFundingTypedData(plan.context, {
+      params: plan.params,
+      deliveries: plan.outputs.map((output) => output.delivery),
+      funding: plan.funding
+    });
+  }
+  return encodeTransactFundingTypedData(
+    plan.context,
+    saved.proof.proofHex,
+    plan.params,
+    plan.outputs.map((output) => output.delivery),
+    plan.funding
+  );
+}
+
+// src/transactions/execution/operation-execution.ts
+import {
+  AuthorizedStatement,
+  computeOwnerAddress,
+  computeWalletAuthorizationDigest,
+  createSigningRequest as createSigningRequest2,
+  walletAuthorizationTypedData
+} from "@invisi-labs/primitives";
+import { WitnessBuilder as WitnessBuilder2 } from "@invisi-labs/prover";
+import { Signature, SigningKey, concat, getBytes as getBytes2, verifyTypedData as verifyTypedData2 } from "ethers";
+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 = statement(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 = WitnessBuilder2.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 {
+    options.signal?.throwIfAborted();
+    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 createSigningRequest2(walletAuthorizationTypedData(authorizationRequest(plan)));
+}
+async function acceptWalletSignature(plan, signature) {
+  const request = authorizationRequest(plan);
+  const digest = computeWalletAuthorizationDigest(request);
+  try {
+    const signed = Signature.from(signature);
+    const publicKey = getBytes2(SigningKey.recoverPublicKey(digest, signed));
+    const owner = await computeOwnerAddress(publicKey);
+    if (owner.toLowerCase() !== plan.scope.ownerAddress.toLowerCase()) {
+      throw new Error("wallet signature identity mismatch");
+    }
+    return new 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(getBytes2(concat([signed.r, signed.s])))
+    });
+  } catch {
+    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 > (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 = createSigningRequest2(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 = verifyTypedData2(request.domain, types, request.message, signature).toLowerCase() === payer.toLowerCase();
+    if (validEOA) {
+      signature = Signature.from(signature).serialized;
+    }
+  } catch {
+    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
+import { normalizeCreditPolicy, normalizeCreditUsage } from "@invisi-labs/primitives";
+import { normalizeFunding } from "@invisi-labs/protocol";
+function operationPreview(plan, status) {
+  const p = plan;
+  const fee = p.params ?? p.shieldParams ?? p.credit?.creation ?? p.credit?.update ?? p.credit?.draw ?? p.credit?.revocation;
+  const funding = normalizeFunding(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
+      })),
+      ...(p.credit?.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: p.credit?.outputs.map((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,
+      ...normalizeCreditPolicy(output.state.note),
+      availableCredit: output.state.note.availableCredit,
+      unlimited: output.state.note.unlimited,
+      ...normalizeCreditUsage(output.state.note)
+    })),
+    creditUpdate: p.credit?.updateChanges ? structuredClone(p.credit.updateChanges) : void 0,
+    creditDraw: p.credit?.draw ? {
+      grossAmount: p.credit.draw.totalAmount,
+      feeAmount: p.credit.draw.feeAmount ?? 0n,
+      netAmount: p.credit.draw.totalAmount - (p.credit.draw.feeAmount ?? 0n),
+      payers: p.credit.draw.payers.map((payer) => ({ ...payer }))
+    } : void 0,
+    creditFeePayer: p.credit?.creation?.owner ?? p.credit?.update?.owner ?? p.credit?.revocation?.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: fee?.feeRecipient,
+    feeAmount: fee?.feeAmount ?? 0n,
+    fundingAmount: p.funding.amount ?? 0n,
+    fundingPayer: p.funding.payer,
+    withdrawalAmount: p.params?.withdrawalAmount ?? 0n,
+    withdrawalAddress: p.params?.withdrawalAddress,
+    permissions: {
+      walletAuthorization: requiresAuthorization(p),
+      proof: p.kind !== "shield" && p.kind !== "revoke-credit",
+      fundingAuthorization: p.fundingMode === "signature"
+    }
+  };
+}
+
+// src/transactions/execution/PreparedTransaction.ts
+import {
+  Wallet,
+  prepareWalletRequest,
+  acceptWalletResponse
+} from "@invisi-labs/primitives";
+import { MissingCapabilityError } from "@invisi-labs/primitives";
+import { normalizeFunding as normalizeFunding2 } from "@invisi-labs/protocol";
+function check2(ok, message) {
+  if (!ok) throw new Error(message);
+}
+var PreparedTransaction = class _PreparedTransaction {
+  #runtime;
+  #saved;
+  #authorization;
+  #walletRequests = /* @__PURE__ */ new Map();
+  #lifecycle;
+  status;
+  constructor(runtime, saved, status, lifecycle, authorization) {
+    this.#runtime = runtime;
+    this.#saved = structuredClone(saved);
+    this.#lifecycle = lifecycle;
+    this.#authorization = authorization;
+    this.status = status;
+    bindBroadcasterOperation(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 import("./broadcaster-preparation-ZQAPZAUG.js");
+    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 import("./provenance-preparation-HEZE4L5H.js");
+    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 import("./provenance-preparation-HEZE4L5H.js");
+    validateBroadcastEnvelope(this.#saved, client);
+    if (this.#saved.broadcasterSubmissionId) {
+      try {
+        return await client.status(this.#saved.broadcasterSubmissionId);
+      } catch (error) {
+        const { BroadcasterRpcError } = await import("./broadcaster-7ZKKSTZQ.js");
+        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(this.#saved.provenance?.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 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 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 exportBroadcasterIntent(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) {
+    signal?.throwIfAborted();
+    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);
+      signal?.throwIfAborted();
+      saved.generation++;
+      this.#lifecycle.generation = saved.generation;
+      return new _PreparedTransaction(
+        this.#runtime,
+        saved,
+        next.status,
+        this.#lifecycle,
+        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 = {}) {
+    options.signal?.throwIfAborted();
+    this.current();
+    check2(
+      requiresAuthorization(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 = authorizationRequest(this.#saved.plan);
+    const prepared = prepareWalletRequest(
+      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 = {}) {
+    options.signal?.throwIfAborted();
+    this.current();
+    check2(
+      requiresAuthorization(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 acceptWalletResponse(
+      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 = {}) {
+    options.signal?.throwIfAborted();
+    this.current();
+    check2(
+      requiresAuthorization(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 = {}) {
+    options.signal?.throwIfAborted();
+    this.current();
+    check2(
+      requiresAuthorization(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 = {}) {
+    options.signal?.throwIfAborted();
+    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);
+    options.signal?.throwIfAborted();
+    this.current();
+    return request;
+  }
+  /** Verify an external signature against this handle's own frozen operation. */
+  async withFundingSignature(signature, options = {}) {
+    options.signal?.throwIfAborted();
+    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 (saved.plan.statement?.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 (requiresAuthorization(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 MissingCapabilityError("prover");
+    }
+    return this.stage(
+      "proof",
+      requiresAuthorization(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 (p.statement?.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(
+      this.#saved.plan.statement?.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 && plan.statement?.target === "noir-recursive" && plan.statement.circuitName.startsWith("transact_user_slots") && (plan.capacity ?? 0) <= 10,
+      "ready recursive C1..C10 transaction required"
+    );
+    sameStatement(saved.proof, statement(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: normalizeFunding2(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
+import { MissingCapabilityError as MissingCapabilityError2 } from "@invisi-labs/primitives";
+import { ProtocolRpcClient } from "@invisi-labs/rpc";
+function configureTransactionInfrastructure(options) {
+  const { provider } = options;
+  const reader = options.chainReader ?? (provider ? new EthersChainReader(provider) : void 0);
+  const protocolRpc = options.protocolRpc instanceof ProtocolRpcClient && reader ? options.protocolRpc.withReader(reader) : options.protocolRpc;
+  const fundingVerifier = options.fundingVerifier ?? (provider ? new EthersFundingVerifier(provider, options.protocol.context.chainId) : void 0);
+  return configureRecipientInfrastructure({
+    ...options,
+    ...reader ? { chainReader: reader } : {},
+    ...protocolRpc ? { protocolRpc } : {},
+    ...fundingVerifier ? { fundingVerifier } : {}
+  });
+}
+async function validateTransactionInfrastructure(options) {
+  if (!options.chainReader) throw new MissingCapabilityError2("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
+import { MissingCapabilityError as MissingCapabilityError3, Wallet as Wallet2 } from "@invisi-labs/primitives";
+import { ProtocolRpcClient as ProtocolRpcClient2 } from "@invisi-labs/rpc";
+
+// src/transactions/preparation/explicit-preparation.ts
+import { getAddress as getAddress2 } from "ethers";
+function explicitPreparation(options, data, tokenAddress) {
+  if (!options.chainReader) throw new Error("chain reader required");
+  const inputs = structuredClone(data.inputs ?? []);
+  const credits = structuredClone(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);
+    positiveAmount(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(getAddress2(tokenAddress))))
+    throw new Error("explicit note token mismatch");
+  const runtime = {
+    options: { ...capabilities, protocol: options.protocol.forToken(tokenAddress) },
+    reader: options.chainReader,
+    scope
+  };
+  const reprepare = (intent) => import("./broadcaster-preparation-ZQAPZAUG.js").then(
+    ({ prepareIntent }) => prepareIntent(
+      {
+        ...runtime,
+        explicitInputs: true,
+        ...data.changeAddress ? { changeAddress: data.changeAddress } : {},
+        readInventory: async () => structuredClone(inventory),
+        complete: async (plan) => plan
+      },
+      intent
+    )
+  );
+  return new 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 prepareWithErrors("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 MissingCapabilityError3("ethers provider");
+      if (!(protocolRpc instanceof ProtocolRpcClient2)) {
+        throw new MissingCapabilityError3("Protocol RPC deployment discovery");
+      }
+      const chainId = (await provider.getNetwork()).chainId;
+      const deployment = await protocolRpc.getDeployment(chainId);
+      if (!deployment.registry) {
+        throw new MissingCapabilityError3("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 Wallet2) || ["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 prepareWithErrors("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 prepareWithErrors("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 prepareWithErrors("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 prepareWithErrors("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 prepareWithErrors("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 prepareWithErrors("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
+import { invisiProtocolAbi } from "@invisi-labs/protocol/contracts";
+import { Interface } from "ethers";
+var protocolInterface = new Interface(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
+import { DeliveryDecryptionError } from "@invisi-labs/primitives";
+import { MAX_CIPHERTEXT_BYTES } from "@invisi-labs/primitives";
+import { isAddress } from "ethers";
+import {
+  decodeAddress,
+  ReceivingAddress
+} from "@invisi-labs/primitives";
+import { normalizeOpaqueDelivery } from "@invisi-labs/protocol";
+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(
+    isAddress(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 = log.args?.token ?? log.args?.params?.token ?? log.args?.params?.creation?.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 = normalizeOpaqueDelivery(wire, { allowEmpty: role === "funds" });
+    check3(
+      typeof token === "string" && isAddress(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 <= 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);
+  decodeAddress(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 DeliveryDecryptionError) throw error;
+    }
+  }
+  return { notes, credits };
+}
+
+export {
+  AddressRegistry,
+  revocationSigningRequest,
+  acceptRevocationSignature,
+  creditReservationKey,
+  inputFacts,
+  operationSources,
+  getOperationGasReference,
+  getDocumentedGasReference2 as getDocumentedGasReference,
+  publicProof,
+  sameStatement,
+  encodeOperation,
+  witnessFor,
+  fundingTypedData,
+  proveOperation,
+  signOperationFunding,
+  walletSigningRequest,
+  acceptWalletSignature,
+  fundingSigningRequest,
+  acceptFundingSignature,
+  operationPreview,
+  PreparedTransaction,
+  configureTransactionInfrastructure,
+  validateTransactionInfrastructure,
+  Invisi,
+  decodeProtocolEvent,
+  readProtocolLogs,
+  extractDeliveryCandidates,
+  decryptCandidates
+};
+//# sourceMappingURL=chunk-4H4FARQK.js.map