@invisi-labs/sdk 1.1.6 → 1.1.7

package/dist/{chunk-4SD3MW6N.js → chunk-EHP5TBC6.js}

@@ -2,28 +2,67 @@ import {
   TransactionPreparation,
   authorizationRequest,
   configureRecipientInfrastructure,
-  creditLeaf,
-  creditReservationKey,
-  encodeOperation,
   exportBroadcasterIntent,
-  fundingTypedData,
-  inputFacts,
-  operationExpired,
-  operationSources,
+  exportPaymentNote,
+  positiveAmount,
   prepareWithErrors,
-  publicProof,
   requiresAuthorization,
-  statement,
-  verifyMembership,
-  walletBalance,
-  walletBalances,
-  witnessFor
-} from "./chunk-FL4TIGWW.js";
+  statement
+} from "./chunk-ITTGBIG2.js";
 import {
-  EthersChainReader
-} from "./chunk-QC6TQR3R.js";
+  EthersChainReader,
+  EthersFundingVerifier
+} from "./chunk-XHKQ2BO2.js";
+
+// 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 ?? credit?.creation?.nullifiers ?? [];
+  let creditNullifiers = [];
+  if (credit?.draw) {
+    creditNullifiers = credit.draw.nullifiers;
+  } else if (credit?.topUp) {
+    creditNullifiers = [credit.topUp.creditNullifier];
+  } else if (credit?.cancel) {
+    creditNullifiers = [credit.cancel.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?.topUp) {
+    return [...credit.topUp.creation.sources, credit.topUp.creditSource];
+  }
+  if (credit?.creation) return credit.creation.sources;
+  if (credit?.draw) return credit.draw.sources;
+  if (credit?.cancel) return [credit.cancel.source];
+  return [];
+}
 
-// src/data/gas-benchmarks.json
+// src/gas/data/gas-benchmarks.json
 var gas_benchmarks_default = [
   {
     formatVersion: 1,
@@ -1724,7 +1763,7 @@ var gas_benchmarks_default = [
   }
 ];
 
-// src/gas-estimation.ts
+// src/gas/profiles.ts
 var word = /^0x[0-9a-fA-F]{64}$/;
 var address = /^0x[0-9a-fA-F]{40}$/;
 var decimal = /^(0|[1-9][0-9]*)$/;
@@ -1807,6 +1846,86 @@ function sameDeployment(a, b) {
 function sameCircuit(a, b) {
   return a === null ? b === null : b !== null && a.circuitName === b.circuitName && a.target === b.target && a.artifactSha256.toLowerCase() === b.artifactSha256.toLowerCase() && a.vkSha256.toLowerCase() === b.vkSha256.toLowerCase();
 }
+
+// src/gas/shape.ts
+function estimateShapeGas(request, profiles = defaultProfiles) {
+  if (request.shape.target === "noir-recursive") {
+    throw new Error(
+      "Estimate gas for the complete aggregate, not an individual recursive member"
+    );
+  }
+  const measurements = profiles.flatMap((profile) => profile.measurements);
+  const matching = measurements.filter(
+    (measurement) => measurement.shape.kind === request.shape.kind && measurement.shape.target === request.shape.target && sameCircuit(measurement.circuit, request.circuit)
+  );
+  const exact = matching.filter(
+    (measurement) => shapeKeys.every((key) => measurement.shape[key] === request.shape[key])
+  );
+  if (exact.length) {
+    const means = exact.map((m) => {
+      const count = BigInt(m.samples.length);
+      return (m.samples.reduce((sum, s) => sum + BigInt(s.gasUsed), 0n) + count - 1n) / count;
+    });
+    return { gasUnits: means.reduce((max, v) => v > max ? v : max) };
+  }
+  if (["create-credit", "draw-credit", "top-up-credit", "cancel-credit"].includes(
+    request.shape.kind
+  ) && !matching.length)
+    throw new Error("No current Credit gas reference for this artifact and verification key");
+  const candidates = matching.length ? matching : measurements.filter(
+    (measurement) => measurement.shape.kind === request.shape.kind && measurement.shape.target === request.shape.target
+  );
+  if (!candidates.length) throw new Error("No gas reference for this operation kind and target");
+  const dimensions = [
+    "noteInputs",
+    "noteOutputs",
+    "sourceTrees",
+    "creditInputs",
+    "creditOutputs",
+    "creditRemainders",
+    "deliveryBytes",
+    ...!matching.length ? ["capacity"] : []
+  ];
+  const groups = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = JSON.stringify([
+      shapeKeys.map((k) => candidate.shape[k]),
+      candidate.circuit?.circuitName,
+      candidate.circuit?.target,
+      candidate.circuit?.artifactSha256.toLowerCase(),
+      candidate.circuit?.vkSha256.toLowerCase()
+    ]);
+    const previous = groups.get(key);
+    groups.set(
+      key,
+      previous ? { ...candidate, samples: [...previous.samples, ...candidate.samples] } : candidate
+    );
+  }
+  const estimates = [...groups.values()].map((measurement) => {
+    let numerator = 1n;
+    let denominator = 1n;
+    for (const key of dimensions) {
+      const current = BigInt(request.shape[key]) + 1n;
+      const baseline = BigInt(measurement.shape[key]) + 1n;
+      if (current * denominator > numerator * baseline) {
+        numerator = current;
+        denominator = baseline;
+      }
+    }
+    let gas = measurement.samples.reduce(
+      (max, sample) => BigInt(sample.gasUsed) > max ? BigInt(sample.gasUsed) : max,
+      0n
+    );
+    gas = (gas * numerator + denominator - 1n) / denominator;
+    if (request.shape.funding === "signature" && measurement.shape.funding !== "signature")
+      gas *= 2n;
+    if (request.shape.permit && !measurement.shape.permit) gas *= 2n;
+    return gas;
+  });
+  return { gasUnits: estimates.reduce((min, gas) => gas < min ? gas : min) };
+}
+
+// src/gas/gas-estimation.ts
 function estimateBenchmarkGas(plan, protocol, profiles) {
   const credit = plan.credit;
   const deliveries = credit?.deliveries ?? plan.outputs.map((out) => out.delivery);
@@ -1882,680 +2001,278 @@ function estimateBenchmarkGas(plan, protocol, profiles) {
   }
   return { ...base, available: false, reason: "shape-not-covered" };
 }
-function estimateShapeGas(request, profiles = defaultProfiles) {
-  if (request.shape.target === "noir-recursive") {
-    throw new Error(
-      "Estimate gas for the complete aggregate, not an individual recursive member"
-    );
+function estimateGasReference(plan, protocol, profiles) {
+  const reference = estimateBenchmarkGas(plan, protocol, profiles);
+  if (reference.available) return { gasUnits: reference.gasUnits };
+  return estimateShapeGas(reference.request);
+}
+
+// src/protocol/AddressRegistry.ts
+import { AddressRegistry as Registry } from "@invisi-labs/protocol";
+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);
+    });
   }
-  const measurements = profiles.flatMap((profile) => profile.measurements);
-  const matching = measurements.filter(
-    (measurement) => measurement.shape.kind === request.shape.kind && measurement.shape.target === request.shape.target && sameCircuit(measurement.circuit, request.circuit)
+};
+
+// src/notes/TransactionOutput.ts
+var TransactionOutput = class {
+  #output;
+  constructor(output) {
+    this.#output = structuredClone(output);
+    Object.freeze(this);
+  }
+  get context() {
+    return structuredClone(this.#output.context);
+  }
+  get recipient() {
+    return structuredClone(this.#output.recipient);
+  }
+  get amount() {
+    return this.#output.amount;
+  }
+  get commitment() {
+    return this.#output.commitment;
+  }
+  get identity() {
+    return this.#output.identity;
+  }
+  get nonce() {
+    return this.#output.note?.nonce;
+  }
+  get change() {
+    return this.#output.change;
+  }
+  exportPaymentNote() {
+    return exportPaymentNote(this.#output);
+  }
+};
+
+// 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"
   );
-  const exact = matching.filter(
-    (measurement) => shapeKeys.every((key) => measurement.shape[key] === request.shape[key])
+  check(
+    proof.publicInputs.length === expected.expectedPublicInputs.length && proof.publicInputs.every((word2, i) => word2 === expected.expectedPublicInputs[i]),
+    "proof public statement mismatch"
   );
-  if (exact.length) {
-    const means = exact.map((m) => {
-      const count = BigInt(m.samples.length);
-      return (m.samples.reduce((sum, s) => sum + BigInt(s.gasUsed), 0n) + count - 1n) / count;
-    });
-    return { gasUnits: means.reduce((max, v) => v > max ? v : max) };
-  }
-  if (["create-credit", "draw-credit", "top-up-credit", "cancel-credit"].includes(
-    request.shape.kind
-  ) && !matching.length)
-    throw new Error("No current Credit gas reference for this artifact and verification key");
-  const candidates = matching.length ? matching : measurements.filter(
-    (measurement) => measurement.shape.kind === request.shape.kind && measurement.shape.target === request.shape.target
+  check(
+    /^0x(?:[a-fA-F0-9]{2})+$/.test(proof.proofHex) && bytesToHex(sha256(getBytes(proof.proofHex))) === proof.proofSha256,
+    "proof integrity mismatch"
   );
-  if (!candidates.length) throw new Error("No gas reference for this operation kind and target");
-  const dimensions = [
-    "noteInputs",
-    "noteOutputs",
-    "sourceTrees",
-    "creditInputs",
-    "creditOutputs",
-    "creditRemainders",
-    "deliveryBytes",
-    ...!matching.length ? ["capacity"] : []
-  ];
-  const groups = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
-    const key = JSON.stringify([
-      shapeKeys.map((k) => candidate.shape[k]),
-      candidate.circuit?.circuitName,
-      candidate.circuit?.target,
-      candidate.circuit?.artifactSha256.toLowerCase(),
-      candidate.circuit?.vkSha256.toLowerCase()
-    ]);
-    const previous = groups.get(key);
-    groups.set(
-      key,
-      previous ? { ...candidate, samples: [...previous.samples, ...candidate.samples] } : candidate
-    );
+}
+
+// src/transactions/execution/calldata.ts
+import {
+  buildCancelCreditCalldata,
+  buildCreateCreditCalldata,
+  buildCreditDrawCalldata,
+  buildShieldCalldata,
+  buildTopUpCreditCalldata,
+  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?.topUp) {
+    encoded = buildTopUpCreditCalldata({
+      ...funded,
+      params: credit.topUp,
+      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?.cancel) {
+    encoded = buildCancelCreditCalldata({ ...common, params: credit.cancel });
+  } 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)
+    });
   }
-  const estimates = [...groups.values()].map((measurement) => {
-    let numerator = 1n;
-    let denominator = 1n;
-    for (const key of dimensions) {
-      const current2 = BigInt(request.shape[key]) + 1n;
-      const baseline = BigInt(measurement.shape[key]) + 1n;
-      if (current2 * denominator > numerator * baseline) {
-        numerator = current2;
-        denominator = baseline;
-      }
+  return { to: plan.context.protocolAddress, data: encoded.data, value: 0n };
+}
+
+// src/transactions/proving/witness.ts
+import { WitnessBuilder } from "@invisi-labs/protocol";
+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.topUp) {
+      return builder.topUpCredit({
+        params: credit.topUp,
+        deliveries: credit.deliveries,
+        funding: plan.funding,
+        inputs: plan.inputs,
+        state: credit.outputs[0].state,
+        ...plan.outputs[0] ? { change: plan.outputs[0].note } : {},
+        previous: credit.inputs[0],
+        authorization
+      });
     }
-    let gas = measurement.samples.reduce(
-      (max, sample) => BigInt(sample.gasUsed) > max ? BigInt(sample.gasUsed) : max,
-      0n
-    );
-    gas = (gas * numerator + denominator - 1n) / denominator;
-    if (request.shape.funding === "signature" && measurement.shape.funding !== "signature")
-      gas *= 2n;
-    if (request.shape.permit && !measurement.shape.permit) gas *= 2n;
-    return gas;
+    if (credit.creation) {
+      return builder.createCredit({
+        params: credit.creation,
+        deliveries: credit.deliveries,
+        funding: plan.funding,
+        inputs: plan.inputs,
+        state: credit.outputs[0].state,
+        ...plan.outputs[0] ? { change: plan.outputs[0].note } : {},
+        authorization
+      });
+    }
+    if (credit.draw) {
+      return builder.drawCredit({
+        timestamp: plan.preparedAt.timestamp,
+        params: credit.draw,
+        deliveries: credit.deliveries,
+        inputs: credit.inputs,
+        amounts: credit.amounts,
+        authorization
+      });
+    }
+    if (credit.cancel) {
+      return builder.cancelCredit({
+        params: credit.cancel,
+        input: credit.inputs[0],
+        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
   });
-  return { gasUnits: estimates.reduce((min, gas) => gas < min ? gas : min) };
-}
-function estimateGasReference(plan, protocol, profiles) {
-  const reference2 = estimateBenchmarkGas(plan, protocol, profiles);
-  if (reference2.available) return { gasUnits: reference2.gasUnits };
-  return estimateShapeGas(reference2.request);
 }
 
-// src/session/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 args = decoded.args.toObject(true);
-  for (const key of [
-    "tokens",
-    "commitments",
-    "nullifiers",
-    "outputCommitments",
-    "leafIndices",
-    "remainderLeafIndices"
-  ]) {
-    const values = decoded.args.getValue(key);
-    if (values) args[key] = values.toArray(true);
+// src/transactions/signing/funding.ts
+import {
+  encodeAggregateFundingTypedData,
+  encodeCreateCreditFundingTypedData,
+  encodeShieldFundingTypedData,
+  encodeTopUpCreditFundingTypedData,
+  encodeTransactFundingTypedData
+} from "@invisi-labs/protocol";
+async function fundingTypedData(saved) {
+  const plan = saved.plan;
+  const credit = plan.credit;
+  if (credit?.topUp) {
+    return encodeTopUpCreditFundingTypedData(
+      plan.context,
+      credit.topUp,
+      credit.deliveries,
+      plan.funding
+    );
   }
-  for (const key of ["sources", "deliveries"]) {
-    const values = decoded.args.getValue(key);
-    if (values) args[key] = values.map((value) => value.toObject(true));
+  if (credit?.creation) {
+    return encodeCreateCreditFundingTypedData(
+      plan.context,
+      credit.creation,
+      credit.deliveries,
+      plan.funding
+    );
   }
-  const params = decoded.args.getValue("params");
-  if (params) {
-    const source = params.getValue("creation") ?? params;
-    const target = params.getValue("creation") ? args.params.creation : args.params;
-    for (const key of ["nullifiers", "remainderCommitments", "expiries", "recoveryAmounts"]) {
-      const values = source.getValue(key);
-      if (values) target[key] = values.toArray(true);
-    }
-    const sources = source.getValue("sources");
-    if (sources) target.sources = sources.map((value) => value.toObject(true));
-  }
-  return { eventName: decoded.name, args };
-}
-
-// src/session/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/session/discovery.ts
-import { MAX_CIPHERTEXT_BYTES } from "@invisi-labs/core";
-import { isAddress } from "ethers";
-import {
-  decodeAddress,
-  ReceivingAddress
-} from "@invisi-labs/core";
-import { normalizeOpaqueDelivery } from "@invisi-labs/protocol";
-var EVENTS = /* @__PURE__ */ new Set([
-  "CommitmentsInserted",
-  "BatchOutputs",
-  "Shield",
-  "Transact",
-  "CrossTreeTransact",
-  "CreditCreated",
-  "CreditDraw",
-  "CreditToppedUp",
-  "CreditCancelled"
-]);
-function check(ok, message) {
-  if (!ok) throw new Error(message);
-}
-function object(value) {
-  check(value && typeof value === "object" && !Array.isArray(value), "invalid event object");
-  return value;
-}
-function array(value) {
-  check(Array.isArray(value), "invalid event array");
-  check(
-    Array.from({ length: value.length }, (_, i) => i in value).every(Boolean),
-    "sparse event array"
-  );
-  return value;
-}
-function integer(value) {
-  check(
-    typeof value === "bigint" || typeof value === "number" && Number.isSafeInteger(value),
-    "invalid event integer"
-  );
-  const n = BigInt(value);
-  check(n >= 0n, "negative event integer");
-  return n;
-}
-function index(value) {
-  const n = integer(value);
-  check(n < 65536n, "invalid event leaf index");
-  return Number(n);
-}
-function hash(value) {
-  check(typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value), "invalid event hash");
-  return value.toLowerCase();
-}
-function contextCheck(context) {
-  check(context.chainId >= 0n && context.chainId < 1n << 64n, "invalid discovery chain");
-  check(
-    isAddress(context.protocolAddress) && BigInt(context.protocolAddress) !== 0n,
-    "invalid discovery instance/token"
-  );
-}
-var position = (tree, at) => `${tree}:${at}`;
-function extractDeliveryCandidates(logs, context, confirmedThrough) {
-  contextCheck(context);
-  check(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) => {
-    check(!log.removed, "discovery resync required after reorg");
-    check(
-      typeof log.blockNumber === "bigint" && log.blockNumber >= 0n && log.blockNumber <= confirmedThrough,
-      "event is not confirmed"
-    );
-    check(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(a.commitments);
-    check(tree > 0n && tree < 1n << 64n, "invalid insertion tree");
-    check(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);
-      check(!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) => {
-    check(tree > 0n && tree < 1n << 64n, "invalid output tree");
-    const inserted = insertions.get(insertionKey(log, tree, at));
-    check(inserted, "delivery has no matching canonical insertion");
-    if (commitment !== void 0)
-      check(hash(commitment) === inserted, "delivery commitment conflicts with insertion");
-    const delivery = normalizeOpaqueDelivery(wire, { allowEmpty: role === "funds" });
-    check(
-      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);
-    check(
-      !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), leaves = array(a.leafIndices), ds = array(a.deliveries);
-    const change = hash(fields.changeCommitment), hasChange = BigInt(change) !== 0n;
-    check(
-      ds.length === 3 && leaves.length === (hasChange ? 2 : 1),
-      "invalid Credit creation delivery slots"
-    );
-    add(log, tree, index(leaves[0]), fields.creditCommitment, "owner", ds[0]);
-    add(log, tree, index(leaves[0]), fields.creditCommitment, "spender", ds[1]);
-    if (hasChange) add(log, tree, index(leaves[1]), change, "funds", ds[2]);
-    else normalizeOpaqueDelivery(ds[2], { empty: true });
-  };
-  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);
-      check(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.outputCommitments), ds = array(a.deliveries), leaves = array(a.leafIndices), tree = integer(a.outputTreeId);
-      check(
-        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.commitments), tree = integer(a.treeId), start = index(a.startLeafIndex), packed = a.packedDeliveries;
-      check(
-        typeof packed === "string" && /^0x(?:[0-9a-fA-F]{2})*$/.test(packed),
-        "invalid packed deliveries"
-      );
-      check(tokens.length === cs.length, "batch token count mismatch");
-      check(start + cs.length <= 65536, "batch exceeds tree capacity");
-      let offset = 2;
-      cs.forEach((c, i) => {
-        check(offset + 4 <= packed.length, "truncated delivery length prefix");
-        const length = Number.parseInt(packed.slice(offset, offset + 4), 16);
-        offset += 4;
-        check(
-          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]);
-      });
-      check(offset === packed.length, "trailing packed delivery bytes");
-    } else if (log.eventName === "CreditCreated") creation(log, a, a);
-    else if (log.eventName === "CreditToppedUp")
-      creation(log, a, object(object(a.params).creation));
-    else if (log.eventName === "CreditDraw") {
-      const p = object(a.params), cs = array(p.remainderCommitments), ds = array(a.deliveries), leaves = array(a.remainderLeafIndices), tree = integer(a.outputTreeId);
-      check(
-        ds.length === 2 * cs.length && leaves.length === cs.length,
-        "invalid draw delivery slots"
-      );
-      cs.forEach((c, i) => {
-        if (BigInt(hash(c)) === 0n) {
-          check(integer(leaves[i]) === 0n, "absent remainder has nonzero position");
-          normalizeOpaqueDelivery(ds[2 * i], { empty: true });
-          normalizeOpaqueDelivery(ds[2 * i + 1], { empty: true });
-        } else {
-          add(log, tree, index(leaves[i]), c, "owner", ds[2 * i]);
-          add(log, tree, index(leaves[i]), c, "spender", ds[2 * i + 1]);
-        }
-      });
-    }
-  }
-  return [...results.values()];
-}
-async function decryptCandidates(logs, options) {
-  contextCheck(options.context);
-  decodeAddress(ReceivingAddress.fromIdentity(options.viewing.ownerAddress).toString());
-  check(
-    !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);
-    check(
-      !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);
-        notes.push({ ...positionData, note });
-      } else {
-        const state = await options.viewing.decryptCredit(delivery.ciphertext, {
-          ...context,
-          role
-        });
-        credits.push({ ...positionData, role, state });
-      }
-    } catch {
-    }
-  }
-  return { notes, credits };
-}
-
-// src/session/DisclosureVerifier.ts
-function check2(value, message) {
-  if (!value) throw new Error(message);
-}
-function reference(value) {
-  check2(/^0x[0-9a-fA-F]{64}$/.test(value.transactionHash), "invalid disclosure transaction hash");
-  check2(
-    typeof value.treeId === "bigint" && value.treeId > 0n && value.treeId < 1n << 64n,
-    "invalid disclosure tree ID"
-  );
-  check2(
-    Number.isSafeInteger(value.leafIndex) && value.leafIndex >= 0 && value.leafIndex < 65536,
-    "invalid disclosure leaf index"
-  );
-  check2(["funds", "owner", "spender"].includes(value.role), "invalid disclosure reference role");
-  return {
-    transactionHash: value.transactionHash.toLowerCase(),
-    treeId: value.treeId,
-    leafIndex: value.leafIndex,
-    role: value.role
-  };
-}
-var DisclosureVerifier = class {
-  #protocol;
-  #reader;
-  #confirmations;
-  constructor(options) {
-    const confirmations = options.confirmations ?? 1;
-    check2(
-      Number.isSafeInteger(confirmations) && confirmations >= 1,
-      "invalid disclosure confirmations"
-    );
-    this.#protocol = options.protocol;
-    this.#reader = "provider" in options ? new EthersChainReader(options.provider) : options.reader;
-    this.#confirmations = BigInt(confirmations);
-    Object.freeze(this);
-  }
-  async barrier(block) {
-    await this.#protocol.validateDeployment(this.#reader);
-    const canonical2 = await this.#reader.getBlock(block.number);
-    check2(
-      canonical2.number === block.number && canonical2.hash.toLowerCase() === block.hash.toLowerCase(),
-      "disclosure canonical block changed; reorg verification required"
-    );
-    const head = await this.#reader.getLatestBlockNumber();
-    check2(
-      head >= block.number && head - block.number + 1n >= this.#confirmations,
-      "insufficient disclosure confirmations"
-    );
-    check2(
-      await this.#reader.getChainId() === this.#protocol.context.chainId,
-      "disclosure chain changed during verification"
-    );
-    return head - block.number + 1n;
-  }
-  /** Resolve the exact inserted output and its delivery from a successful canonical receipt. */
-  async readOutput(value) {
-    const selected = reference(value);
-    await this.#protocol.validateDeployment(this.#reader);
-    const received = await this.#reader.getReceipt(selected.transactionHash);
-    check2(received, "disclosure transaction receipt is unavailable");
-    const receipt = structuredClone(received);
-    check2(receipt.status === "success", "disclosure requires a successful transaction receipt");
-    check2(
-      receipt.transactionHash.toLowerCase() === selected.transactionHash,
-      "disclosure receipt transaction mismatch"
-    );
-    check2(
-      typeof receipt.block.number === "bigint" && receipt.block.number >= 0n && /^0x[0-9a-fA-F]{64}$/.test(receipt.block.hash),
-      "invalid disclosure receipt block"
-    );
-    const { context } = this.#protocol;
-    const logs = readProtocolLogs(receipt, context.protocolAddress);
-    const candidates = extractDeliveryCandidates(logs, context, receipt.block.number).filter(
-      (candidate2) => candidate2.treeId === selected.treeId && candidate2.leafIndex === selected.leafIndex && candidate2.role === selected.role && candidate2.tokenAddress.toLowerCase() === context.tokenAddress.toLowerCase()
-    );
-    check2(
-      candidates.length === 1,
-      "disclosure output has no unique canonical insertion and delivery"
-    );
-    const candidate = candidates[0];
-    const confirmations = await this.barrier(receipt.block);
-    return Object.freeze({
-      reference: Object.freeze(selected),
-      block: Object.freeze({ ...receipt.block }),
-      confirmations,
-      output: Object.freeze({
-        chainId: context.chainId,
-        protocolAddress: BigInt(context.protocolAddress),
-        tokenAddress: BigInt(context.tokenAddress),
-        outputCommitment: candidate.commitment,
-        role: selected.role,
-        ciphertext: candidate.delivery.ciphertext
-      })
-    });
-  }
-  async verify(disclosure, value) {
-    const evidence = await this.readOutput(value);
-    const result = await disclosure.verify(evidence.output);
-    const confirmations = await this.barrier(evidence.block);
-    return Object.freeze({
-      result: Object.freeze(result),
-      block: evidence.block,
-      confirmations,
-      output: Object.freeze({
-        ...evidence.reference,
-        commitment: evidence.output.outputCommitment
-      })
-    });
-  }
-  toJSON() {
-    return { disclosureVerifier: true, confirmations: this.#confirmations.toString() };
-  }
-  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
-    return this.toJSON();
-  }
-};
-
-// src/session/store.ts
-import { FIELD_MODULUS, normalizeCreditDeliveryState } from "@invisi-labs/core";
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
-function scopeKey(scope) {
-  if (typeof scope.namespace !== "string" || !scope.namespace.length || scope.namespace.length > 256)
-    throw new Error("invalid wallet namespace");
-  if (typeof scope.chainId !== "bigint" || scope.chainId < 0n || scope.chainId >= 1n << 64n)
-    throw new Error("invalid scope chain");
-  for (const address2 of [scope.protocolAddress])
-    if (!/^0x[0-9a-fA-F]{40}$/.test(address2) || BigInt(address2) === 0n)
-      throw new Error("invalid scope deployment");
-  if (!/^0x[0-9a-fA-F]{40}$/.test(scope.ownerAddress) || BigInt(scope.ownerAddress) <= 0n || BigInt(scope.ownerAddress) >= 1n << 160n)
-    throw new Error("invalid scope wallet");
-  return bytesToHex(
-    sha256(
-      utf8ToBytes(
-        "Invisi.WalletScope.v1:" + JSON.stringify([
-          scope.namespace,
-          scope.chainId.toString(),
-          scope.protocolAddress.toLowerCase(),
-          scope.ownerAddress.toLowerCase()
-        ])
-      )
-    )
-  );
-}
-function initialState(scope) {
-  scopeKey(scope);
-  return {
-    schemaVersion: 1,
-    scope: { ...scope },
-    revision: 0,
-    notes: {},
-    credits: {},
-    reservations: {},
-    operations: {}
-  };
-}
-function validateState(state, scope, revision) {
-  if (!state || state.schemaVersion !== 1 || scopeKey(state.scope) !== scopeKey(scope) || state.revision !== revision)
-    throw new Error("wallet state scope/schema/revision mismatch");
-  if (!Number.isSafeInteger(revision) || revision < 0)
-    throw new Error("invalid wallet state revision");
-  for (const field of [state.notes, state.credits, state.reservations, state.operations])
-    if (!field || typeof field !== "object" || Array.isArray(field))
-      throw new Error("invalid wallet state records");
-  for (const record of Object.values(state.notes)) {
-    if (typeof record.note.tokenAddress !== "bigint" || record.note.tokenAddress <= 0n || record.note.tokenAddress >= 1n << 160n || record.note.chainId !== scope.chainId || record.note.protocolAddress !== BigInt(scope.protocolAddress) || record.note.ownerAddress.toLowerCase() !== scope.ownerAddress.toLowerCase() || typeof record.note.amount !== "bigint" || record.note.amount <= 0n || record.note.amount >= 1n << 128n)
-      throw new Error("invalid stored note context or amount");
-    if (!["unspent", "unknown", "spent"].includes(record.spent))
-      throw new Error("invalid spent state");
-  }
-  for (const record of Object.values(state.credits)) {
-    const note = normalizeCreditDeliveryState(record.state).note;
-    if (note.chainId !== scope.chainId || note.protocolAddress !== BigInt(scope.protocolAddress) || !["owner", "spender"].includes(record.role) || (record.role === "owner" ? note.ownerWalletIdentity : note.spenderWalletIdentity).toLowerCase() !== scope.ownerAddress.toLowerCase() || !["unspent", "unknown", "spent"].includes(record.spent))
-      throw new Error("invalid stored Credit context or role");
-  }
-  for (const record of [...Object.values(state.notes), ...Object.values(state.credits)]) {
-    if (!/^0x[0-9a-fA-F]{64}$/.test(record.commitment) || BigInt(record.commitment) <= 0n || BigInt(record.commitment) >= FIELD_MODULUS || typeof record.treeId !== "bigint" || record.treeId < 1n || record.treeId >= 1n << 64n || !Number.isInteger(record.leafIndex) || record.leafIndex < 0 || record.leafIndex >= 65536 || typeof record.blockNumber !== "bigint" || record.blockNumber < 0n || !/^0x[0-9a-fA-F]{64}$/.test(record.blockHash))
-      throw new Error("invalid stored receipt position");
-  }
-  for (const [id, operation] of Object.entries(state.reservations))
-    if (!state.operations[operation] || !state.notes[id] && !Object.values(state.credits).some(
-      (record) => creditReservationKey(record.commitment) === id
-    ) && !["submitted", "uncertain", "reorged"].includes(
-      state.operations[operation].status
-    ))
-      throw new Error("orphan input reservation");
-}
-var TransactionalWalletStore = class {
-  persistent;
-  #records;
-  #codec;
-  constructor(records, codec, options) {
-    this.#records = records;
-    this.#codec = codec;
-    this.persistent = options.persistent;
-  }
-  async readSnapshot(scope) {
-    const key = scopeKey(scope), record = await this.#records.read(key);
-    if (!record) return initialState(scope);
-    const state = await this.#codec.decode(record.data, { key, revision: record.revision });
-    validateState(state, scope, record.revision);
-    return state;
-  }
-  async transaction(scope, action) {
-    if (action.constructor.name === "AsyncFunction")
-      throw new Error("wallet transaction action must be synchronous");
-    const copied = { ...scope }, key = scopeKey(copied);
-    for (let attempt = 0; attempt < 100; attempt++) {
-      const draft = await this.readSnapshot(copied), previous = draft.revision;
-      const result = action(draft);
-      if (result && typeof result === "object" && "then" in result) {
-        Promise.resolve(result).catch(() => {
-        });
-        throw new Error("wallet transaction action must be synchronous");
-      }
-      validateState(draft, copied, previous);
-      if (!Number.isSafeInteger(previous + 1))
-        throw new Error("wallet state revision exhausted");
-      draft.revision = previous + 1;
-      const data = await this.#codec.encode(draft, { key, revision: draft.revision });
-      if (await this.#records.compareAndSwap(key, previous, {
-        revision: draft.revision,
-        data
-      }))
-        return result;
-    }
-    throw new Error("wallet transaction contention limit exceeded");
-  }
-  toJSON() {
-    return { walletStore: true, persistent: this.persistent };
-  }
-  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
-    return this.toJSON();
-  }
-};
-var MemoryAtomicRecords = class {
-  #values = /* @__PURE__ */ new Map();
-  async read(key) {
-    const value = this.#values.get(key);
-    return value ? { revision: value.revision, data: Uint8Array.from(value.data) } : void 0;
+  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
+    });
   }
-  async compareAndSwap(key, previousRevision, next) {
-    if ((this.#values.get(key)?.revision ?? 0) !== previousRevision) return false;
-    this.#values.set(key, { revision: next.revision, data: Uint8Array.from(next.data) });
-    return true;
+  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/session/operation-execution.ts
-import { Signature, SigningKey, getBytes as getBytes2, concat, verifyTypedData } from "ethers";
+// src/transactions/execution/operation-execution.ts
 import {
-  computeWalletAuthorizationDigest,
   AuthorizedStatement,
   computeOwnerAddress,
+  computeWalletAuthorizationDigest,
   createSigningRequest,
   walletAuthorizationTypedData
 } from "@invisi-labs/core";
-import { WitnessBuilder } from "@invisi-labs/protocol";
-
-// src/session/proof-integrity.ts
-import { getBytes } from "ethers";
-import { sha256 as sha2562 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils";
-function check3(ok, message) {
-  if (!ok) throw new Error(message);
-}
-function sameStatement(proof, expected) {
-  check3(
-    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"
-  );
-  check3(
-    proof.publicInputs.length === expected.expectedPublicInputs.length && proof.publicInputs.every((word2, i) => word2 === expected.expectedPublicInputs[i]),
-    "proof public statement mismatch"
-  );
-  check3(
-    /^0x(?:[a-fA-F0-9]{2})+$/.test(proof.proofHex) && bytesToHex2(sha2562(getBytes(proof.proofHex))) === proof.proofSha256,
-    "proof integrity mismatch"
-  );
-}
-
-// src/session/operation-execution.ts
+import { WitnessBuilder as WitnessBuilder2 } from "@invisi-labs/protocol";
+import { Signature, SigningKey, concat, getBytes as getBytes2, verifyTypedData } from "ethers";
 async function authorizeOperation(plan, provider) {
   if (provider.ownerAddress !== plan.scope.ownerAddress)
     throw new Error("wallet authorization capability mismatch");
@@ -2579,7 +2296,7 @@ async function proveOperation(protocol, plan, authorization, prover, options) {
     throw new Error("aggregate execution requires a 14-slot transfer");
   }
   if (plan.kind === "transfer") {
-    plan.statement = WitnessBuilder.statement(
+    plan.statement = WitnessBuilder2.statement(
       frozen.circuitName,
       frozen.expectedPublicInputs,
       execution === "aggregate" ? "noir-recursive" : "evm"
@@ -2658,753 +2375,164 @@ async function fundingSigningRequest(saved, runtime) {
 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 = verifyTypedData(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/session/operation-preview.ts
-import { normalizeFunding } from "@invisi-labs/protocol";
-function operationPreview(plan, status) {
-  const p = plan;
-  const fee = p.params ?? p.shieldParams ?? p.credit?.creation ?? p.credit?.cancel;
-  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,
-        amount: input.state.note.amount,
-        owner: input.state.note.ownerWalletIdentity,
-        spender: input.state.note.spenderWalletIdentity,
-        expiry: input.state.note.expiry,
-        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,
-      amount: output.state.note.amount,
-      expiry: output.state.note.expiry,
-      owner: output.state.note.ownerWalletIdentity,
-      spender: output.state.note.spenderWalletIdentity,
-      ownerPayout: output.state.note.ownerPayout,
-      spenderPayout: output.state.note.spenderPayout
-    })),
-    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 ?? p.credit?.draw?.totalAmount ?? (p.credit?.cancel ? p.credit.cancel.amount - (p.credit.cancel.feeAmount ?? 0n) : void 0) ?? 0n,
-    withdrawalAddress: p.params?.withdrawalAddress ?? p.credit?.draw?.spender ?? p.credit?.cancel?.owner,
-    permissions: {
-      walletAuthorization: requiresAuthorization(p),
-      proof: p.kind !== "shield",
-      fundingAuthorization: p.fundingMode === "signature"
-    }
-  };
-}
-
-// src/session/Operation.ts
-import { MissingCapabilityError } from "@invisi-labs/core";
-import { normalizeFunding as normalizeFunding2 } from "@invisi-labs/protocol";
-
-// src/session/operation-confirmation.ts
-import { computeCreditNullifier } from "@invisi-labs/core";
-
-// src/session/aggregate-receipt.ts
-import { Interface as Interface2 } from "ethers";
-import { invisiProtocolAbi as invisiProtocolAbi2 } from "@invisi-labs/protocol/contracts";
-import { buildTransactCalldata } from "@invisi-labs/protocol";
-var aggregateAbi = invisiProtocolAbi2.filter(
-  (item) => item.type === "function" && item.name === "transact" && item.inputs.length === 2 && item.inputs[1]?.type === "tuple[]"
-);
-function matchesAggregateTransaction(saved, transaction) {
-  const plan = saved.plan;
-  if (plan.statement?.target !== "noir-recursive" || !plan.params || !saved.externalized || transaction.to.toLowerCase() !== plan.context.protocolAddress.toLowerCase() || transaction.value !== 0n)
-    return false;
-  try {
-    const decoded = new Interface2(aggregateAbi).parseTransaction({ data: transaction.data }), requests = decoded.args[1].map((request) => {
-      const member = request.toObject(true);
-      member.params.sources = request.params.sources.map(
-        (source) => source.toObject(true)
-      );
-      member.params.nullifiers = request.params.nullifiers.toArray(true);
-      member.params.outputCommitments = request.params.outputCommitments.toArray(true);
-      member.deliveries = request.deliveries.map(
-        (delivery) => delivery.toObject(true)
-      );
-      member.funding.permit.v = Number(member.funding.permit.v);
-      return {
-        params: member.params,
-        deliveries: member.deliveries,
-        funding: member.funding
-      };
-    });
-    if (decoded.name !== "transact" || !Array.isArray(requests) || ![4, 8, 12].includes(requests.length))
-      return false;
-    const canonical2 = (request) => buildTransactCalldata({
-      context: { ...plan.context, tokenAddress: request.params.token },
-      proof: "0x00",
-      params: request.params,
-      deliveries: request.deliveries,
-      funding: request.funding,
-      caller: transaction.from
-    }).data.toLowerCase();
-    const expected = buildTransactCalldata({
-      context: plan.context,
-      proof: "0x00",
-      params: plan.params,
-      deliveries: plan.outputs.map((output) => output.delivery),
-      funding: plan.funding,
-      caller: transaction.from
-    }).data.toLowerCase();
-    return requests.filter((request) => canonical2(request) === expected).length === 1;
-  } catch {
-    return false;
-  }
-}
-
-// src/session/receipts.ts
-function canonical(value) {
-  return JSON.stringify(value, (_, item) => {
-    if (typeof item === "bigint") {
-      return ["bigint", item.toString()];
-    }
-    if (item instanceof Uint8Array) {
-      return Array.from(item);
-    }
-    if (item && typeof item === "object" && !Array.isArray(item)) {
-      return Object.fromEntries(
-        Object.keys(item).sort().map((key) => [key, item[key]])
-      );
-    }
-    return item;
-  });
-}
-function validateInheritance(state, record) {
-  const source = record.receivingKeySource;
-  if (!source) return false;
-  const parent = state.credits[source.commitment + ":" + record.role];
-  if (!parent) {
-    throw new Error("Credit receiving inheritance has no authenticated parent");
-  }
-  const previous = parent.state;
-  const successor = record.state;
-  const immutableFields = [
-    "chainId",
-    "protocolAddress",
-    "tokenAddress",
-    "spenderWalletIdentity",
-    "ownerWalletIdentity",
-    "spenderPayout",
-    "ownerPayout",
-    "creditSharedKey"
-  ];
-  if (immutableFields.some((field) => previous.note[field] !== successor.note[field]) || canonical(previous.ownerReceivingKeys) !== canonical(successor.ownerReceivingKeys) || canonical(previous.spenderReceivingKeys) !== canonical(successor.spenderReceivingKeys)) {
-    throw new Error("Credit receiving inheritance changed immutable fields");
-  }
-  if (source.kind === "draw") {
-    if (successor.note.amount >= previous.note.amount || successor.note.expiry !== previous.note.expiry) {
-      throw new Error("invalid Credit receiving inheritance");
-    }
-  } else if (source.kind !== "top-up" || successor.note.amount <= previous.note.amount || successor.note.expiry < previous.note.expiry) {
-    throw new Error("invalid Credit receiving inheritance");
-  }
-  return true;
-}
-function mergeSpentObservation(previous, incoming) {
-  const next = incoming.checkedThrough;
-  const old = previous.checkedThrough;
-  if (!next || incoming.spent === "unknown") {
-    return;
-  }
-  if (old && next.number < old.number) {
-    return;
-  }
-  if (old && next.number === old.number && next.hash !== old.hash) {
-    throw new Error("canonical spent checkpoint conflict requires resync");
-  }
-  if (previous.spent === "spent" && incoming.spent !== "spent") {
-    throw new Error("canonical spent observation conflict requires resync");
-  }
-  previous.spent = incoming.spent;
-  previous.checkedThrough = { ...next };
-}
-function mergeReceiptRecords(state, batch) {
-  if (state.invalidated) {
-    throw new Error("wallet inventory is invalidated");
-  }
-  const checkpoint = { ...batch.checkpoint };
-  for (const record of [...batch.notes, ...batch.credits]) {
-    if (record.blockNumber > checkpoint.number) {
-      throw new Error("receipt exceeds confirmed checkpoint");
-    }
-    const atPosition = [...Object.values(state.notes), ...Object.values(state.credits)].filter(
-      (existing) => existing.treeId === record.treeId && existing.leafIndex === record.leafIndex
-    );
-    if (atPosition.some(
-      (existing) => existing.commitment !== record.commitment || existing.blockHash !== record.blockHash
-    )) {
-      throw new Error("canonical position conflict requires resync");
-    }
-    if ("note" in record) {
-      const previous = state.notes[record.commitment];
-      if (previous) {
-        if (canonical(previous.note) !== canonical(record.note)) {
-          throw new Error("canonical note preimage conflict");
-        }
-        mergeSpentObservation(previous, record);
-        continue;
-      }
-      state.notes[record.commitment] = record;
-    } else {
-      const key = record.commitment + ":" + record.role;
-      const previous = state.credits[key];
-      const inherited = validateInheritance(state, record);
-      if (previous) {
-        if (canonical(previous.state.note) !== canonical(record.state.note)) {
-          throw new Error("canonical Credit preimage conflict");
-        }
-        if (canonical(previous.state) !== canonical(record.state)) {
-          if (!inherited) {
-            if (previous.receivingKeySource) {
-              mergeSpentObservation(previous, record);
-              continue;
-            }
-            throw new Error("Credit receiving metadata conflict");
-          }
-          previous.state = record.state;
-          previous.receivingKeySource = record.receivingKeySource;
-        } else if (inherited) {
-          previous.receivingKeySource = record.receivingKeySource;
-        }
-        mergeSpentObservation(previous, record);
-        continue;
-      }
-      state.credits[key] = record;
-    }
-  }
-}
-
-// src/session/operation-confirmation.ts
-function check4(ok, message) {
-  if (!ok) {
-    throw new Error(message);
-  }
-}
-async function barrier(runtime, state, block) {
-  const checkpoints = [
-    state.observedThrough,
-    ...block ? [{ number: block.number, hash: block.hash }] : []
-  ];
-  for (const point of checkpoints) {
-    if (point && (await runtime.reader.getBlock(point.number)).hash !== point.hash) {
-      await runtime.store.transaction(runtime.scope, (draft) => {
-        draft.invalidated = "Canonical operation checkpoint changed; full resync required";
-        for (const record of [
-          ...Object.values(draft.notes),
-          ...Object.values(draft.credits)
-        ]) {
-          record.spent = "unknown";
-        }
-        for (const operation of Object.values(draft.operations)) {
-          if (["failed", "expired"].includes(operation.status) && !operation.payload?.externalized) {
-            continue;
-          }
-          operation.status = "reorged";
-          for (const id of operation.inputs) {
-            if (!draft.reservations[id]) {
-              draft.reservations[id] = operation.id;
-            }
-          }
-        }
-      });
-      throw new Error("canonical operation checkpoint changed; full resync required");
-    }
-  }
-}
-function current(state, id, generation) {
-  check4(!state.invalidated, "wallet requires canonical resync");
-  const record = state.operations[id];
-  const saved = record?.payload;
-  check4(record && saved.generation === generation && !saved.claim, "stale operation recovery");
-  return { record, saved };
-}
-function observe(state, block) {
-  if (state.observedThrough?.number === block.number) {
-    check4(state.observedThrough.hash === block.hash, "operation checkpoint conflict");
-  }
-  if (!state.observedThrough || state.observedThrough.number < block.number) {
-    state.observedThrough = { number: block.number, hash: block.hash };
-  }
-}
-async function confirmOperation(runtime, id, generation, hash2, signal) {
-  const { reader, store, scope, options } = runtime;
-  const state = await store.readSnapshot(scope);
-  const { saved } = current(state, id, generation);
-  const plan = saved.plan;
-  await options.protocol.validateDeployment(reader);
-  await barrier(runtime, state);
-  const receipt = await reader.getReceipt(hash2);
-  if (!receipt) {
-    return void 0;
-  }
-  check4(receipt.transactionHash === hash2, "receipt transaction identity mismatch");
-  await barrier(runtime, state, receipt.block);
-  const transaction = await reader.getTransaction(hash2);
-  check4(
-    transaction && transaction.transactionHash === hash2,
-    "confirmed transaction differs from the frozen operation"
-  );
-  let matchesRequest;
-  if (plan.statement?.target === "noir-recursive") {
-    matchesRequest = matchesAggregateTransaction(saved, transaction);
-  } else {
-    matchesRequest = !!saved.call && transaction.to.toLowerCase() === saved.call.to.toLowerCase() && transaction.value === saved.call.value && transaction.data.toLowerCase() === saved.call.data.toLowerCase();
-  }
-  check4(matchesRequest, "confirmed transaction differs from the frozen operation");
-  check4(
-    receipt.status === "success" || receipt.status === "reverted",
-    "receipt execution status is missing"
-  );
-  if (receipt.status === "reverted") {
-    return void 0;
-  }
-  const candidates = extractDeliveryCandidates(
-    readProtocolLogs(receipt, plan.context.protocolAddress),
-    plan.context,
-    receipt.block.number
-  );
-  const latest = await reader.getLatestBlockNumber();
-  const height = [latest, receipt.block.number, state.observedThrough?.number ?? 0n].reduce(
-    (a, b) => a > b ? a : b
-  );
-  const spentBlock = await reader.getBlock(height);
-  check4(spentBlock.number === height, "spent-state canonical block mismatch");
-  const notes = [];
-  for (const output of plan.outputs) {
-    const candidate = candidates.find(
-      (value) => value.role === "funds" && value.commitment === output.commitment
-    );
-    check4(candidate, "confirmed output is missing from canonical receipt");
-    if (!output.note || output.note.ownerAddress !== scope.ownerAddress) {
-      continue;
-    }
-    const input = {
-      treeId: candidate.treeId,
-      leafIndex: candidate.leafIndex,
-      commitment: candidate.commitment
-    };
-    check4(options.protocolRpc, "membership provider required for confirmed owned output");
-    const proof = await options.protocolRpc.getMembership(plan.context, input, receipt.block);
-    await verifyMembership(reader, plan.context, receipt.block, input, proof);
-    notes.push({
-      ...input,
-      note: structuredClone(output.note),
-      blockNumber: receipt.block.number,
-      blockHash: receipt.block.hash,
-      transactionHash: hash2,
-      spent: "unknown"
-    });
-  }
-  const credits = [];
-  for (const output of plan.credit?.outputs ?? []) {
-    const n = output.state.note;
-    for (const role of ["owner", "spender"]) {
-      if ((role === "owner" ? n.ownerWalletIdentity : n.spenderWalletIdentity) !== scope.ownerAddress) {
-        continue;
-      }
-      const candidate = candidates.find(
-        (value) => value.role === role && value.commitment === output.commitment
-      );
-      check4(candidate, "confirmed Credit output is missing from canonical receipt");
-      const input = {
-        treeId: candidate.treeId,
-        leafIndex: candidate.leafIndex,
-        commitment: candidate.commitment
-      };
-      check4(options.protocolRpc, "membership provider required for confirmed Credit");
-      const proof = await options.protocolRpc.getMembership(
-        plan.context,
-        input,
-        receipt.block
-      );
-      await verifyMembership(reader, plan.context, receipt.block, input, proof);
-      const index2 = plan.credit?.draw?.remainderCommitments.indexOf(output.commitment);
-      const parent = plan.credit?.topUp ? plan.credit.inputs[0] : index2 !== void 0 && index2 >= 0 ? plan.credit?.inputs[index2] : void 0;
-      const receivingKeySource = parent && state.credits[parent.commitment + ":" + role] ? {
-        kind: plan.credit?.topUp ? "top-up" : "draw",
-        commitment: parent.commitment
-      } : void 0;
-      credits.push({
-        ...input,
-        state: structuredClone(output.state),
-        role,
-        blockNumber: receipt.block.number,
-        blockHash: receipt.block.hash,
-        transactionHash: hash2,
-        spent: "unknown",
-        ...receivingKeySource ? { receivingKeySource } : {}
-      });
-    }
-  }
-  if (credits.length) {
-    const nullifiers = await Promise.all(
-      credits.map(
-        async (record) => computeCreditNullifier(
-          plan.context.chainId,
-          record.state.note.creditSharedKey,
-          await creditLeaf(record.state)
-        )
-      )
-    );
-    const values = await reader.isSpent(plan.context, nullifiers, spentBlock);
-    check4(
-      values.length === credits.length && values.every((value) => typeof value === "boolean"),
-      "invalid Credit spent-state response"
-    );
-    credits.forEach((record, i) => {
-      record.spent = values[i] ? "spent" : "unspent";
-      record.checkedThrough = { number: spentBlock.number, hash: spentBlock.hash };
-    });
-  }
-  const facts = inputFacts(plan);
-  const nfs = facts.map((input) => input.nullifier);
-  const spent = nfs.length ? await reader.isSpent(plan.context, nfs, spentBlock) : [];
-  check4(
-    spent.length === nfs.length && spent.every((value) => value === true),
-    "successful operation inputs are not consumed"
-  );
-  const nullifier = options.wallet.exportNullifier();
-  if (notes.length) {
-    const values = await reader.isSpent(
-      plan.context,
-      await Promise.all(
-        notes.map(
-          (note) => nullifier.compute(plan.context.chainId, note.commitment, note.note.nonce)
-        )
-      ),
-      spentBlock
-    );
-    check4(
-      values.length === notes.length && values.every((value) => typeof value === "boolean"),
-      "invalid output spent-state response"
-    );
-    notes.forEach((note, i) => {
-      note.spent = values[i] ? "spent" : "unspent";
-      note.checkedThrough = { number: spentBlock.number, hash: spentBlock.hash };
-    });
-  }
-  signal?.throwIfAborted();
-  await barrier(runtime, state, receipt.block);
-  await barrier(runtime, state, spentBlock);
-  return store.transaction(scope, (draft) => {
-    signal?.throwIfAborted();
-    const { record, saved: active } = current(draft, id, generation);
-    for (const point of [draft.observedThrough]) {
-      check4(
-        !point || point.number < spentBlock.number || point.number === spentBlock.number && point.hash === spentBlock.hash,
-        "wallet advanced or changed during confirmation; retry"
-      );
-    }
-    mergeReceiptRecords(draft, {
-      notes,
-      credits,
-      checkpoint: { number: receipt.block.number, hash: receipt.block.hash }
-    });
-    for (const fact of facts) {
-      const input = draft[fact.kind][fact.key];
-      if (input) {
-        mergeSpentObservation(input, {
-          spent: "spent",
-          checkedThrough: { number: spentBlock.number, hash: spentBlock.hash }
-        });
-      }
-      if (fact.kind === "credits" && input) {
-        for (const other of Object.values(draft.credits)) {
-          if (other.commitment === input.commitment) {
-            mergeSpentObservation(other, {
-              spent: "spent",
-              checkedThrough: { number: spentBlock.number, hash: spentBlock.hash }
-            });
-          }
-        }
-      }
-      if (draft.reservations[fact.reservationKey] === id) {
-        delete draft.reservations[fact.reservationKey];
-      }
-    }
-    observe(draft, spentBlock);
-    record.status = "confirmed";
-    record.transactionHash = hash2;
-    active.generation++;
-    return { status: record.status, saved: structuredClone(active) };
-  });
+  }
+  const request = await fundingSigningRequest(saved, runtime);
+  return verifyFundingSignature(
+    request,
+    saved.plan.funding.payer,
+    signature,
+    runtime.options.fundingVerifier
+  );
 }
-async function reconcileOperation(runtime, id, generation, signal) {
-  const { reader, store, scope, options } = runtime;
-  const state = await store.readSnapshot(scope);
-  const { record, saved } = current(state, id, generation);
-  const plan = saved.plan;
-  await options.protocol.validateDeployment(reader);
-  await barrier(runtime, state);
-  const block = await reader.getBlock(await reader.getLatestBlockNumber());
-  const facts = inputFacts(plan);
-  const nfs = facts.map((input) => input.nullifier);
-  const spent = nfs.length ? await reader.isSpent(plan.context, nfs, block) : [];
-  check4(
-    spent.length === nfs.length && spent.every((value) => typeof value === "boolean"),
-    "invalid reconciliation spent-state response"
+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]])
   );
-  const expired = operationExpired(plan, block.timestamp);
-  const impossible = spent.some((value) => value);
-  signal?.throwIfAborted();
-  await barrier(runtime, state, block);
-  return store.transaction(scope, (draft) => {
-    signal?.throwIfAborted();
-    const { record: active, saved: next } = current(draft, id, generation);
-    for (const point of [
-      draft.observedThrough,
-      ...facts.map((fact) => draft[fact.kind][fact.key]?.checkedThrough)
-    ]) {
-      check4(
-        !point || point.number < block.number || point.number === block.number && point.hash === block.hash,
-        "wallet advanced or changed during reconciliation; retry"
-      );
+  let validEOA = false;
+  try {
+    validEOA = verifyTypedData(request.domain, types, request.message, signature).toLowerCase() === payer.toLowerCase();
+    if (validEOA) {
+      signature = Signature.from(signature).serialized;
     }
-    if (expired || impossible) {
-      active.status = expired ? "expired" : "failed";
-      facts.forEach((fact, i) => {
-        const input = draft[fact.kind][fact.key];
-        if (input) {
-          mergeSpentObservation(input, {
-            spent: spent[i] ? "spent" : "unspent",
-            checkedThrough: { number: block.number, hash: block.hash }
-          });
-          if (fact.kind === "credits") {
-            for (const other of Object.values(draft.credits)) {
-              if (other.commitment === input.commitment) {
-                mergeSpentObservation(other, {
-                  spent: spent[i] ? "spent" : "unspent",
-                  checkedThrough: { number: block.number, hash: block.hash }
-                });
-              }
-            }
-          }
-        }
-        if (draft.reservations[fact.reservationKey] === id) {
-          delete draft.reservations[fact.reservationKey];
-        }
-      });
-      observe(draft, block);
-    } else if (next.externalized || active.status === "reorged") {
-      active.status = "uncertain";
+  } 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 { normalizeFunding } from "@invisi-labs/protocol";
+function operationPreview(plan, status) {
+  const p = plan;
+  const fee = p.params ?? p.shieldParams ?? p.credit?.creation ?? p.credit?.cancel;
+  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,
+        amount: input.state.note.amount,
+        owner: input.state.note.ownerWalletIdentity,
+        spender: input.state.note.spenderWalletIdentity,
+        expiry: input.state.note.expiry,
+        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,
+      amount: output.state.note.amount,
+      expiry: output.state.note.expiry,
+      owner: output.state.note.ownerWalletIdentity,
+      spender: output.state.note.spenderWalletIdentity,
+      ownerPayout: output.state.note.ownerPayout,
+      spenderPayout: output.state.note.spenderPayout
+    })),
+    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 ?? p.credit?.draw?.totalAmount ?? (p.credit?.cancel ? p.credit.cancel.amount - (p.credit.cancel.feeAmount ?? 0n) : void 0) ?? 0n,
+    withdrawalAddress: p.params?.withdrawalAddress ?? p.credit?.draw?.spender ?? p.credit?.cancel?.owner,
+    permissions: {
+      walletAuthorization: requiresAuthorization(p),
+      proof: p.kind !== "shield",
+      fundingAuthorization: p.fundingMode === "signature"
     }
-    next.generation++;
-    return { status: active.status, saved: structuredClone(next) };
-  });
+  };
 }
 
-// src/session/Operation.ts
-function check5(ok, message) {
-  if (!ok) {
-    throw new Error(message);
-  }
+// src/transactions/execution/PreparedTransaction.ts
+import { MissingCapabilityError } from "@invisi-labs/core";
+import { normalizeFunding as normalizeFunding2 } from "@invisi-labs/protocol";
+function check2(ok, message) {
+  if (!ok) throw new Error(message);
 }
-var Operation = class _Operation {
+var PreparedTransaction = class _PreparedTransaction {
   #runtime;
   #saved;
   #authorization;
+  #lifecycle;
   status;
-  constructor(runtime, saved, status, authorization) {
+  constructor(runtime, saved, status, lifecycle, authorization) {
     this.#runtime = runtime;
     this.#saved = structuredClone(saved);
-    this.status = status;
+    this.#lifecycle = lifecycle;
     this.#authorization = authorization;
+    this.status = status;
     Object.freeze(this);
   }
-  static async prepare(runtime, plan) {
-    const saved = { plan: structuredClone(plan), generation: 0 };
-    await runtime.store.transaction(runtime.scope, (state) => {
-      check5(!state.invalidated, "wallet state requires canonical resync");
-      check5(!state.operations[plan.id], "operation already exists");
-      const facts = inputFacts(plan);
-      for (const input of facts) {
-        const record = state[input.kind][input.key];
-        check5(
-          record && record.spent === "unspent" && !state.reservations[input.reservationKey],
-          "input unavailable or already reserved"
-        );
-      }
-      state.operations[plan.id] = {
-        id: plan.id,
-        status: "prepared",
-        inputs: facts.map((input) => input.reservationKey),
-        deadline: plan.deadline,
-        payload: saved
-      };
-      for (const input of facts) {
-        state.reservations[input.reservationKey] = plan.id;
-      }
-    });
-    return new _Operation(runtime, saved, "prepared");
-  }
-  static async resume(runtime, id) {
-    const result = await runtime.store.transaction(runtime.scope, (state) => {
-      const record = state.operations[id];
-      check5(record, "unknown operation");
-      const saved = record.payload;
-      check5(
-        saved?.plan?.version === 1 && saved.plan.id === id && Number.isSafeInteger(saved.generation) && saved.generation >= 0 && saved.generation < Number.MAX_SAFE_INTEGER,
-        "invalid operation payload"
-      );
-      const context = runtime.options.protocol.context;
-      const actual = saved.plan.context;
-      check5(
-        scopeKey(saved.plan.scope) === scopeKey(runtime.scope) && actual.chainId === context.chainId && actual.protocolAddress.toLowerCase() === context.protocolAddress.toLowerCase() && actual.tokenAddress.toLowerCase() === context.tokenAddress.toLowerCase(),
-        "recovered operation scope/deployment context mismatch"
-      );
-      if (saved.plan.kind !== "shield") {
-        statement(saved.plan);
-      }
-      if (saved.proof) {
-        sameStatement(saved.proof, saved.plan.statement);
-      }
-      saved.generation++;
-      delete saved.claim;
-      return new _Operation(runtime, saved, record.status);
-    });
-    if (result.#saved.call) {
-      const expected = await result.encode(result.#saved);
-      check5(
-        expected.to === result.#saved.call.to && expected.value === result.#saved.call.value && expected.data === result.#saved.call.data,
-        "recovered transaction differs from frozen operation"
-      );
-    }
-    return result;
-  }
-  /** Public non-sendable intent for a firm quote before wallet authorization. */
-  async exportBroadcasterIntent() {
-    check5(
-      ["prepared", "authorized"].includes(this.status),
-      "quote intent requires a prepared operation"
+  static prepare(runtime, plan) {
+    return new _PreparedTransaction(
+      runtime,
+      { plan: structuredClone(plan), generation: 0 },
+      "prepared",
+      { generation: 0, busy: false }
     );
-    return exportBroadcasterIntent(this.#saved.plan);
   }
   broadcasterQuote() {
     return this.#saved.broadcasterQuote ? structuredClone(this.#saved.broadcasterQuote) : void 0;
   }
   async withBroadcaster(client, options) {
-    check5(this.status === "prepared", "broadcaster must attach before signing");
-    const { prepareIntent, prepareBroadcasterPlan } = await import("./broadcaster-preparation-QVL62KM6.js");
-    const runtime = this.#runtime;
-    const reprepare = (intent) => prepareIntent(
-      {
-        options: runtime.options,
-        scope: runtime.scope,
-        reader: runtime.reader,
-        readInventory: async () => {
-          const state = await runtime.store.readSnapshot(runtime.scope);
-          for (const [key, owner] of Object.entries(state.reservations))
-            if (owner === this.id) delete state.reservations[key];
-          return state;
-        },
-        complete: async (plan) => plan
-      },
-      intent
+    this.current();
+    check2(
+      this.status === "prepared" && this.#runtime.reprepare,
+      "broadcaster must attach to an unsigned prepared transaction"
+    );
+    const { prepareBroadcasterPlan } = await import("./broadcaster-preparation-RMWQFYNL.js");
+    const selected = await prepareBroadcasterPlan(
+      this.#saved.plan,
+      this.#runtime.reprepare,
+      client,
+      options
+    );
+    return new _PreparedTransaction(
+      this.#runtime,
+      { plan: selected.plan, broadcasterQuote: selected.quote, generation: 0 },
+      "prepared",
+      { generation: 0, busy: false }
     );
-    const selected = await prepareBroadcasterPlan(this.#saved.plan, reprepare, client, options);
-    const saved = await runtime.store.transaction(runtime.scope, (state) => {
-      const record = state.operations[this.id];
-      const old = record?.payload;
-      check5(
-        record?.status === "prepared" && old?.generation === this.#saved.generation && !old.claim && !old.externalized,
-        "stale operation or active worker"
-      );
-      check5(!state.invalidated, "wallet state requires canonical resync");
-      const nextPlan = { ...selected.plan, id: this.id };
-      const facts = inputFacts(nextPlan);
-      for (const fact of facts)
-        check5(
-          state[fact.kind][fact.key]?.spent === "unspent" && (!state.reservations[fact.reservationKey] || state.reservations[fact.reservationKey] === this.id),
-          "input unavailable or already reserved"
-        );
-      for (const [key, owner] of Object.entries(state.reservations))
-        if (owner === this.id) delete state.reservations[key];
-      for (const fact of facts) state.reservations[fact.reservationKey] = this.id;
-      const next = {
-        plan: nextPlan,
-        broadcasterQuote: selected.quote,
-        generation: old.generation + 1
-      };
-      record.payload = next;
-      record.inputs = facts.map((fact) => fact.reservationKey);
-      record.deadline = nextPlan.deadline;
-      return structuredClone(next);
-    });
-    return new _Operation(runtime, saved, "prepared");
   }
   get id() {
     return this.#saved.plan.id;
@@ -3419,77 +2547,61 @@ var Operation = class _Operation {
       this.#runtime.options.gasBenchmarks
     );
   }
+  /** 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);
   }
-  current(record) {
-    check5(record, "unknown operation");
-    const saved = record.payload;
-    check5(
-      saved.generation === this.#saved.generation && !saved.claim,
-      "stale operation handle or active worker; recover the operation"
+  /** 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"
     );
-    return saved;
   }
   async stage(stage, allowed, work, signal) {
     signal?.throwIfAborted();
-    const { store, scope } = this.#runtime;
-    const token = crypto.randomUUID();
-    const saved = await store.transaction(scope, (state) => {
-      check5(!state.invalidated, "wallet requires canonical resync");
-      const record = state.operations[this.id];
-      const current2 = this.current(record);
-      check5(allowed.includes(record.status), `invalid operation stage for ${stage}`);
-      current2.generation++;
-      current2.claim = { stage, token };
-      return structuredClone(current2);
-    });
+    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();
-      await store.transaction(scope, (state) => {
-        check5(!state.invalidated, "wallet invalidated during operation");
-        const record = state.operations[this.id];
-        const current2 = record?.payload;
-        check5(
-          record && current2?.generation === saved.generation && current2.claim?.token === token && allowed.includes(record.status),
-          "stale operation worker after recovery"
-        );
-        delete saved.claim;
-        record.status = next.status;
-        record.payload = structuredClone(saved);
-      });
-      return new _Operation(
+      saved.generation++;
+      this.#lifecycle.generation = saved.generation;
+      return new _PreparedTransaction(
         this.#runtime,
         saved,
         next.status,
+        this.#lifecycle,
         next.authorization ?? this.#authorization
       );
-    } catch (error) {
-      await store.transaction(scope, (state) => {
-        const current2 = state.operations[this.id]?.payload;
-        if (current2?.claim?.token === token) {
-          delete current2.claim;
-        }
-      });
-      throw error;
+    } finally {
+      this.#lifecycle.busy = false;
     }
   }
-  async signingCurrent() {
-    await this.#runtime.store.transaction(this.#runtime.scope, (state) => {
-      check5(!state.invalidated, "wallet state requires canonical resync");
-      this.current(state.operations[this.id]);
-    });
-  }
   /** Public EIP-712 request; signing transport and key custody belong to the caller. */
   async exportWalletAuthorization(options = {}) {
     options.signal?.throwIfAborted();
-    await this.signingCurrent();
-    check5(
+    this.current();
+    check2(
       requiresAuthorization(this.#saved.plan),
       "operation does not require wallet authorization"
     );
-    check5(
+    check2(
       ["prepared", "authorized"].includes(this.status),
       "operation is not awaiting wallet authorization"
     );
@@ -3498,12 +2610,12 @@ var Operation = class _Operation {
   /** Attach an external EOA signature, retaining its witness only at the private proving boundary. */
   async withWalletSignature(signature, options = {}) {
     options.signal?.throwIfAborted();
-    await this.signingCurrent();
-    check5(
+    this.current();
+    check2(
       requiresAuthorization(this.#saved.plan),
       "operation does not require wallet authorization"
     );
-    check5(
+    check2(
       ["prepared", "authorized"].includes(this.status),
       "operation is not awaiting wallet authorization"
     );
@@ -3518,21 +2630,21 @@ var Operation = class _Operation {
   /** Export only after proving when the funding authorization binds an actual proof hash. */
   async exportFundingAuthorization(options = {}) {
     options.signal?.throwIfAborted();
-    await this.signingCurrent();
-    check5(
+    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();
-    await this.signingCurrent();
+    this.current();
     return request;
   }
   /** Verify an external signature against this handle's own frozen operation. */
   async withFundingSignature(signature, options = {}) {
     options.signal?.throwIfAborted();
-    await this.signingCurrent();
-    check5(
+    this.current();
+    check2(
       this.status === (this.kind === "shield" ? "prepared" : "proved"),
       "operation is not awaiting funding authorization or proof"
     );
@@ -3550,41 +2662,21 @@ var Operation = class _Operation {
       options.signal
     );
   }
-  async authorize(options = {}) {
-    check5(
-      requiresAuthorization(this.#saved.plan),
-      "operation does not require wallet authorization"
-    );
-    const provider = this.#runtime.authorization();
-    check5(
-      provider.ownerAddress === this.#runtime.scope.ownerAddress,
-      "wallet authorization capability mismatch"
-    );
-    return this.stage(
-      "wallet authorization",
-      ["prepared", "authorized"],
-      async (saved) => {
-        const authorization = await authorizeOperation(saved.plan, provider);
-        return { status: "authorized", authorization };
-      },
-      options.signal
-    );
-  }
-  async prove(suppliedOptions = {}) {
-    const options = { ...suppliedOptions };
-    check5(
+  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;
-    check5(plan.kind !== "shield", "shield requires no proof");
+    check2(plan.kind !== "shield", "shield requires no proof");
     if (requiresAuthorization(plan)) {
-      check5(
+      check2(
         this.#authorization,
         "local wallet authorization required; authorize again after recovery"
       );
     }
-    const prover = this.#runtime.options.prover;
+    const prover = "prove" in backendOrOptions ? backendOrOptions : this.#runtime.options.prover;
     if (!prover) {
       throw new MissingCapabilityError("prover");
     }
@@ -3611,1101 +2703,863 @@ var Operation = class _Operation {
       options.signal
     );
   }
-  encode(saved) {
-    return encodeOperation(saved);
+  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",
+      "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 === "transact_user_slots14",
+      "ready recursive slots14 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/core";
+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, PublicWallet } from "@invisi-labs/core";
+import { ProtocolRpcClient as ProtocolRpcClient2 } from "@invisi-labs/rpc";
+
+// src/transactions/preparation/explicit-preparation.ts
+import { getAddress } 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(getAddress(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-RMWQFYNL.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,
+      ...options.gasBenchmarks ? { gasBenchmarks: copyGasBenchmarks(options.gasBenchmarks) } : {}
+    };
+    Object.freeze(this);
+  }
+  /** A detached snapshot of shared infrastructure; wallet permissions and persistence stay external. */
+  getInfrastructure() {
+    return Object.freeze({
+      ...this.#options,
+      ...this.#options.gasBenchmarks ? { gasBenchmarks: copyGasBenchmarks(this.#options.gasBenchmarks) } : {}
+    });
   }
-  async authorizeFunding(options = {}) {
-    const p = this.#saved.plan;
-    check5(p.fundingMode === "signature", "operation does not require a funding signature");
-    check5(p.kind === "shield" || this.#saved.proof, "proof must precede funding authorization");
-    const signer = this.#runtime.options.fundingSigner;
-    if (!signer) {
-      throw new MissingCapabilityError("EVM funding signer");
-    }
-    check5(
-      signer.address.toLowerCase() === p.funding.payer.toLowerCase(),
-      "funding signer is not the payer"
-    );
-    return this.stage(
-      "funding authorization",
-      p.kind === "shield" ? ["prepared"] : ["proved"],
-      async (saved) => {
-        saved.plan.funding.signature = await signOperationFunding(
-          saved,
-          signer,
-          this.#runtime.options.fundingVerifier
-        );
-        if (saved.plan.statement?.target !== "noir-recursive") {
-          saved.call = await this.encode(saved);
+  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}`);
         }
-        return { status: "ready" };
-      },
-      options.signal
-    );
-  }
-  /** Shield caller funding needs no wallet signing or proof; this step only encodes its frozen request. */
-  async ready() {
-    check5(
-      this.kind === "shield" && this.#saved.plan.fundingMode === "caller",
-      "operation needs authorization or proof first"
-    );
-    return this.stage("encoding", ["prepared"], async (saved) => {
-      saved.call = await this.encode(saved);
-      return { status: "ready" };
+      }
+      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 });
     });
   }
-  async validateExport(signal) {
-    signal?.throwIfAborted();
-    const { reader, options: runtimeOptions } = this.#runtime;
-    await runtimeOptions.protocol.validateDeployment(reader);
-    const head = await reader.getBlock(await reader.getLatestBlockNumber());
-    const plan = this.#saved.plan;
-    check5(!operationExpired(plan, head.timestamp), "operation has expired");
-    if (plan.fundingMode === "signature") {
-      check5(head.timestamp <= (plan.funding.deadline ?? 0n), "funding authorization expired");
-      check5(
-        await reader.getFundingNonce(plan.context, plan.funding.payer, head) === plan.funding.sigNonce,
-        "funding nonce changed; prepare again"
-      );
-    }
-    for (const source of operationSources(plan)) {
-      check5(
-        await reader.isKnownRoot(plan.context, source.treeId, source.merkleRoot, head),
-        "source root is no longer accepted; prepare again"
+  assertPublicIdentity(options) {
+    const { wallet } = options;
+    if (!(wallet instanceof PublicWallet) || ["getViewer", "getDetector", "exportAuthorization"].some((key) => key in wallet)) {
+      throw new Error(
+        "Independent preparation requires a PublicWallet without private capabilities"
       );
     }
-    const nullifiers = inputFacts(plan).map((input) => input.nullifier);
-    if (nullifiers.length) {
-      const spent = await reader.isSpent(plan.context, nullifiers, head);
-      check5(
-        spent.length === nullifiers.length && spent.every((value) => value === false),
-        "input spent or invalid spent response"
-      );
+    for (const key of ["authorization", "signer", "fundingSigner", "viewing"]) {
+      if (key in options)
+        throw new Error(`Independent preparation does not accept capability: ${key}`);
     }
-    signal?.throwIfAborted();
   }
-  async exportTransaction(options = {}) {
-    check5(
-      this.#saved.plan.statement?.target !== "noir-recursive",
-      "recursive operations must be exported as aggregate members"
-    );
-    await this.validateExport(options.signal);
-    const result = await this.#runtime.store.transaction(this.#runtime.scope, (state) => {
-      options.signal?.throwIfAborted();
-      const record = state.operations[this.id];
-      const saved = this.current(record);
-      check5(record.status === "ready" && saved.call, "operation is not ready");
-      saved.externalized = true;
-      return structuredClone(saved.call);
+  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);
     });
-    return result;
   }
-  async exportAggregateMember() {
-    return this.#runtime.store.transaction(this.#runtime.scope, (state) => {
-      const record = state.operations[this.id];
-      const saved = this.current(record);
-      const plan = saved.plan;
-      check5(
-        ["ready", "uncertain"].includes(record.status) && plan.params && saved.proof && plan.statement?.target === "noir-recursive" && plan.statement.circuitName === "transact_user_slots14",
-        "operation is not a ready recursive slots14 aggregate member"
-      );
-      sameStatement(saved.proof, statement(plan));
-      check5(
-        saved.proof.proofHex.length === 2 + 458 * 64,
-        "recursive member proof must have 458 fields"
-      );
-      saved.externalized = true;
-      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)
-        }
-      };
+  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 abandon() {
-    const saved = await this.#runtime.store.transaction(this.#runtime.scope, (state) => {
-      const record = state.operations[this.id];
-      const current2 = this.current(record);
-      check5(
-        !current2.externalized,
-        "externalized or broadcast operation requires chain reconciliation"
-      );
-      check5(
-        !["confirmed", "reorged"].includes(record.status),
-        "operation requires chain reconciliation"
-      );
-      for (const id of record.inputs) {
-        if (state.reservations[id] === this.id) {
-          delete state.reservations[id];
-        }
-      }
-      record.status = "failed";
-      current2.generation++;
-      return structuredClone(current2);
+  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, request.tokenAddress);
+      return preparation.prepareCreateCredit(request);
     });
-    return new _Operation(this.#runtime, saved, "failed");
   }
-  /** Record an application-owned signed/broadcast transaction. This never sends or waits. */
-  async trackTransaction(transactionHash) {
-    check5(/^0x[a-fA-F0-9]{64}$/.test(transactionHash), "invalid transaction hash");
-    const saved = await this.#runtime.store.transaction(this.#runtime.scope, (state) => {
-      check5(!state.invalidated, "wallet requires canonical resync");
-      const record = state.operations[this.id];
-      const current2 = this.current(record);
-      check5(
-        ["ready", "uncertain", "submitted"].includes(record.status),
-        "operation is not ready"
-      );
-      check5(
-        current2.externalized,
-        "export the transaction or aggregate member before tracking"
-      );
-      for (const input of record.inputs) {
-        check5(state.reservations[input] === this.id, "operation input reservation lost");
-      }
-      current2.generation++;
-      current2.externalized = true;
-      record.transactionHash = transactionHash;
-      record.status = "uncertain";
-      return structuredClone(current2);
+  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);
     });
-    return new _Operation(this.#runtime, saved, "uncertain");
   }
-  async reconcile(options = {}) {
-    options.signal?.throwIfAborted();
-    const state = await this.#runtime.store.readSnapshot(this.#runtime.scope);
-    const record = state.operations[this.id];
-    this.current(record);
-    check5(!state.invalidated, "wallet requires canonical resync");
-    const hash2 = options.transactionHash ?? record.transactionHash;
-    let outcome;
-    if (hash2) {
-      outcome = await confirmOperation(
-        this.#runtime,
-        this.id,
-        this.#saved.generation,
-        hash2,
-        options.signal
-      );
-    }
-    outcome ??= await reconcileOperation(
-      this.#runtime,
-      this.id,
-      this.#saved.generation,
-      options.signal
-    );
-    return new _Operation(this.#runtime, outcome.saved, outcome.status);
+  async prepareTopUpCredit(options) {
+    return prepareWithErrors("prepareTopUpCredit", 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.prepareTopUpCredit(request);
+    });
+  }
+  async prepareCancelCredit(options) {
+    return prepareWithErrors("prepareCancelCredit", 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.prepareCancelCredit(request);
+    });
   }
   toJSON() {
-    return { id: this.id, kind: this.kind, status: this.status };
+    return { invisi: true };
   }
   [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
     return this.toJSON();
   }
 };
 
-// src/session/WalletSession.ts
-import { Wallet } from "@invisi-labs/core";
-
-// src/session/history.ts
-function walletHistory(state, options = {}) {
-  const token = options.tokenAddress?.toLowerCase();
-  const outgoing = [];
-  for (const record of Object.values(state.operations)) {
-    const saved = record.payload;
-    if (!saved?.plan || token && saved.plan.context.tokenAddress.toLowerCase() !== token) {
-      continue;
-    }
-    const plan = saved.plan;
-    outgoing.push({
-      ...operationPreview(plan, record.status),
-      preparedAt: { ...plan.preparedAt },
-      ...record.transactionHash ? { transactionHash: record.transactionHash } : {},
-      outputs: plan.outputs.map((output) => ({
-        to: output.address,
-        amount: output.amount,
-        change: output.change,
-        commitment: output.commitment,
-        payload: Uint8Array.from(output.note?.payload ?? [])
-      }))
-    });
+// 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 args = decoded.args.toObject(true);
+  for (const key of [
+    "tokens",
+    "commitments",
+    "nullifiers",
+    "outputCommitments",
+    "leafIndices",
+    "remainderLeafIndices"
+  ]) {
+    const values = decoded.args.getValue(key);
+    if (values) args[key] = values.toArray(true);
   }
-  outgoing.sort(
-    (a, b) => a.preparedAt.number === b.preparedAt.number ? a.id.localeCompare(b.id) : a.preparedAt.number > b.preparedAt.number ? -1 : 1
-  );
-  const incoming = [];
-  for (const record of Object.values(state.notes)) {
-    const tokenAddress = `0x${record.note.tokenAddress.toString(16).padStart(40, "0")}`;
-    if (token && tokenAddress !== token) continue;
-    incoming.push({
-      commitment: record.commitment,
-      treeId: record.treeId,
-      leafIndex: record.leafIndex,
-      blockNumber: record.blockNumber,
-      blockHash: record.blockHash,
-      ...record.transactionHash ? { transactionHash: record.transactionHash } : {},
-      tokenAddress,
-      amount: record.note.amount,
-      payload: Uint8Array.from(record.note.payload ?? []),
-      spent: record.spent
-    });
+  for (const key of ["sources", "deliveries"]) {
+    const values = decoded.args.getValue(key);
+    if (values) args[key] = values.map((value) => value.toObject(true));
   }
-  incoming.sort(
-    (a, b) => a.blockNumber === b.blockNumber ? a.commitment.localeCompare(b.commitment) : a.blockNumber > b.blockNumber ? -1 : 1
-  );
-  return structuredClone({
-    revision: state.revision,
-    checkedThrough: state.discoveryThrough ?? null,
-    invalidated: !!state.invalidated,
-    outgoing,
-    incoming
-  });
-}
-
-// src/session/WalletSession.ts
-import { getAddress } from "ethers";
-import { MissingCapabilityError as MissingCapabilityError2 } from "@invisi-labs/core";
-
-// src/session/refresh.ts
-import { MAX_UPDATE_BLOCKS } from "@invisi-labs/rpc";
-async function refreshWallet(runtime, options) {
-  const { signal } = options;
-  try {
-    signal?.throwIfAborted();
-    if (typeof options.fromBlock !== "bigint" || options.fromBlock < runtime.fromBlock)
-      throw new Error("refresh range precedes deployment");
-    const pageSize = options.pageSize ?? MAX_UPDATE_BLOCKS;
-    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > MAX_UPDATE_BLOCKS)
-      throw new Error(`refresh page size must be 1..${MAX_UPDATE_BLOCKS}`);
-    const status = await runtime.provider.getStatus(runtime.context, {
-      ...signal ? { signal } : {}
-    });
-    if (!status.indexedHead) throw new Error("Protocol RPC has not indexed any blocks");
-    const toBlock = options.toBlock ?? status.indexedHead.number;
-    if (typeof toBlock !== "bigint" || toBlock < options.fromBlock || toBlock > status.indexedHead.number)
-      throw new Error("refresh range is outside indexed history");
-    const target = await runtime.reader.getBlock(toBlock);
-    if (target.number !== toBlock)
-      throw new Error("Chain RPC returned the wrong refresh anchor");
-    let result;
-    let notes = 0;
-    let credits = 0;
-    for (let from = options.fromBlock; from <= toBlock; from += BigInt(pageSize)) {
-      signal?.throwIfAborted();
-      const end = from + BigInt(pageSize) - 1n;
-      const page = await runtime.provider.getUpdates(runtime.context, {
-        fromBlock: from,
-        toBlock: end < toBlock ? end : toBlock,
-        ...options.detectionKey ? { detectionKey: options.detectionKey } : {},
-        ...signal ? { signal } : {}
-      });
-      if (page.block.number !== (end < toBlock ? end : toBlock))
-        throw new Error("Protocol RPC returned the wrong page anchor");
-      signal?.throwIfAborted();
-      if (page.transactionHashes.length === 0 && (result || from + BigInt(pageSize) <= toBlock))
-        continue;
-      const firstApplication = result === void 0;
-      result = await runtime.apply(
-        {
-          context: runtime.context,
-          transactionHashes: page.transactionHashes,
-          block: target
-        },
-        {
-          ...signal ? { signal } : {},
-          ...firstApplication && options.reset ? { reset: true } : {}
-        }
-      );
-      notes += result.notes;
-      credits += result.credits;
+  const params = decoded.args.getValue("params");
+  if (params) {
+    const source = params.getValue("creation") ?? params;
+    const target = params.getValue("creation") ? args.params.creation : args.params;
+    for (const key of ["nullifiers", "remainderCommitments", "expiries", "recoveryAmounts"]) {
+      const values = source.getValue(key);
+      if (values) target[key] = values.toArray(true);
     }
-    return { ...result, notes, credits };
-  } finally {
-    options.detectionKey?.fill(0);
+    const sources = source.getValue("sources");
+    if (sources) target.sources = sources.map((value) => value.toObject(true));
   }
+  return { eventName: decoded.name, args };
 }
 
-// src/session/WalletUpdater.ts
-import { NullifierCapability } from "@invisi-labs/core";
+// 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/session/inventory.ts
+// src/discovery/discovery.ts
+import { MAX_CIPHERTEXT_BYTES } from "@invisi-labs/core";
+import { isAddress } from "ethers";
 import {
-  computeCreditCommitment,
-  computeCreditNullifier as computeCreditNullifier2,
-  computeCreditSharedKeyHash,
-  recoverCreditRemainder
+  decodeAddress,
+  ReceivingAddress
 } from "@invisi-labs/core";
-var CanonicalConflict = class extends Error {
-};
-var CreditMetadataMismatch = class extends Error {
-};
-function check6(value, message) {
-  if (!value) {
-    throw new Error(message);
-  }
+import { normalizeOpaqueDelivery } from "@invisi-labs/protocol";
+var EVENTS = /* @__PURE__ */ new Set([
+  "CommitmentsInserted",
+  "BatchOutputs",
+  "Shield",
+  "Transact",
+  "CrossTreeTransact",
+  "CreditCreated",
+  "CreditDraw",
+  "CreditToppedUp",
+  "CreditCancelled"
+]);
+function check3(ok, message) {
+  if (!ok) throw new Error(message);
 }
-var clone = (value) => structuredClone(value);
-var InventoryProcessor = class {
-  #options;
-  constructor(options) {
-    this.#options = { ...options, scope: Object.freeze({ ...options.scope }) };
-  }
-  reorgOperations(state) {
-    for (const operation of Object.values(state.operations)) {
-      if (["failed", "expired"].includes(operation.status) && !operation.payload?.externalized) {
-        continue;
-      }
-      operation.status = "reorged";
-      for (const id of operation.inputs) {
-        if (!state.reservations[id]) {
-          state.reservations[id] = operation.id;
-        }
-      }
-    }
-  }
-  async invalidate() {
-    const { store, scope } = this.#options;
-    await store.transaction(scope, (state) => {
-      state.invalidated = "Canonical history changed; rebuild inventory from canonical data";
-      for (const record of [...Object.values(state.notes), ...Object.values(state.credits)]) {
-        record.spent = "unknown";
-      }
-      this.reorgOperations(state);
-    });
-  }
-  checkSnapshotKeys(record) {
-    const expected = this.#options.receivingKeys;
-    const keys = record.role === "owner" ? record.state.ownerReceivingKeys : record.state.spenderReceivingKeys;
-    if (expected && !keys.viewingPublicKey.every((byte, i) => byte === expected.viewingPublicKey[i])) {
-      throw new CreditMetadataMismatch("Credit receiving key snapshot mismatch");
-    }
-    const clue = expected?.clueKey;
-    if (clue && !keys.clueKey.every((byte, i) => byte === clue[i])) {
-      throw new CreditMetadataMismatch("Credit clue key snapshot mismatch");
-    }
-  }
-  async creditNullifier(state) {
-    const n = state.note;
-    return computeCreditNullifier2(
-      n.chainId,
-      n.creditSharedKey,
-      await computeCreditCommitment(
-        n.chainId,
-        n.spenderWalletIdentity,
-        n.ownerWalletIdentity,
-        n.spenderPayout,
-        n.ownerPayout,
-        n.tokenAddress,
-        n.amount,
-        n.nonce,
-        n.expiry,
-        await computeCreditSharedKeyHash(n.creditSharedKey),
-        n
-      )
-    );
-  }
-  async recoverCredits(base, found, logs, snapshot) {
-    const known = /* @__PURE__ */ new Map();
-    const byNullifier = /* @__PURE__ */ new Map();
-    const cachedNullifiers = /* @__PURE__ */ new Map();
-    const recovered = [];
-    const foundByKey = new Map(
-      found.map((record) => [record.commitment + ":" + record.role, record])
+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"
     );
-    const remember = async (record) => {
-      const key = record.commitment + ":" + record.role;
-      let nullifier = cachedNullifiers.get(record.commitment);
-      if (!nullifier) {
-        nullifier = await this.creditNullifier(record.state);
-        cachedNullifiers.set(record.commitment, nullifier);
-      }
-      known.set(key, record);
-      let members = byNullifier.get(nullifier);
-      if (!members) {
-        members = /* @__PURE__ */ new Set();
-        byNullifier.set(nullifier, members);
-      }
-      members.add(key);
-    };
-    const matching = (nullifier) => [...byNullifier.get(nullifier) ?? []].map((key) => known.get(key));
-    for (const record of Object.values(base.credits)) {
-      await remember(record);
-    }
-    for (const record of found) {
-      try {
-        this.checkSnapshotKeys(record);
-        await remember({ ...record, spent: "unknown" });
-      } catch (error) {
-        if (!(error instanceof CreditMetadataMismatch)) {
-          throw error;
-        }
-      }
-    }
-    const context = {
-      chainId: this.#options.scope.chainId,
-      protocolAddress: BigInt(this.#options.scope.protocolAddress)
+    check3(Number.isSafeInteger(log.logIndex) && log.logIndex >= 0, "invalid log position");
+    return {
+      blockNumber: log.blockNumber,
+      blockHash: hash(log.blockHash),
+      transactionHash: hash(log.transactionHash)
     };
-    for (const event of logs) {
-      if (event.eventName === "CreditDraw") {
-        const block = await this.#options.reader.getBlock(event.blockNumber);
-        if (block.hash !== event.blockHash)
-          throw new CanonicalConflict("draw block changed during Credit recovery");
-        const args = event.args;
-        const params = args.params;
-        const indices = args.remainderLeafIndices;
-        check6(
-          Array.isArray(params.nullifiers) && params.nullifiers.length === params.remainderCommitments.length && params.nullifiers.length === params.recoveryAmounts.length && params.nullifiers.length === params.expiries.length && params.nullifiers.length === indices.length,
-          "invalid draw recovery slots"
-        );
-        for (const [index2, nullifier] of params.nullifiers.entries()) {
-          for (const previous of matching(nullifier)) {
-            check6(
-              previous.state.note.expiry === params.expiries[index2],
-              "draw recovery expiry mismatch"
-            );
-            const remainder = await recoverCreditRemainder(
-              context,
-              previous.state.note,
-              {
-                timestamp: block.timestamp,
-                creditNullifier: nullifier,
-                remainderCommitment: params.remainderCommitments[index2],
-                recoveryAmount: BigInt(params.recoveryAmounts[index2])
-              }
-            );
-            if (!remainder) {
-              continue;
-            }
-            const child = foundByKey.get(
-              params.remainderCommitments[index2] + ":" + previous.role
-            );
-            const payload = child?.state.note.payload;
-            const record = {
-              commitment: params.remainderCommitments[index2],
-              treeId: BigInt(args.outputTreeId),
-              leafIndex: Number(indices[index2]),
-              blockNumber: event.blockNumber,
-              blockHash: event.blockHash,
-              transactionHash: event.transactionHash,
-              role: previous.role,
-              state: {
-                ...clone(previous.state),
-                note: {
-                  ...remainder,
-                  ...payload === void 0 ? {} : { payload: clone(payload) }
-                }
-              },
-              receivingKeySource: { kind: "draw", commitment: previous.commitment },
-              spent: "unknown"
-            };
-            check6(
-              await snapshot.getLeaf(record.treeId, record.leafIndex) === BigInt(record.commitment),
-              "draw recovery canonical leaf mismatch"
-            );
-            this.checkSnapshotKeys(record);
-            await remember(record);
-            recovered.push(record);
-          }
-        }
-      } else if (event.eventName === "CreditToppedUp") {
-        const params = event.args.params;
-        for (const previous of matching(params.creditNullifier)) {
-          const child = foundByKey.get(
-            params.creation.creditCommitment + ":" + previous.role
-          );
-          if (!child) {
-            continue;
-          }
-          const old = previous.state.note;
-          const next = child.state.note;
-          if ([
-            "chainId",
-            "protocolAddress",
-            "tokenAddress",
-            "spenderWalletIdentity",
-            "ownerWalletIdentity",
-            "spenderPayout",
-            "ownerPayout",
-            "creditSharedKey"
-          ].some(
-            (field) => old[field] !== next[field]
-          ) || next.amount <= old.amount || next.expiry < old.expiry) {
-            continue;
-          }
-          const repaired = {
-            ...clone(child),
-            state: {
-              note: clone(next),
-              ownerReceivingKeys: clone(previous.state.ownerReceivingKeys),
-              spenderReceivingKeys: clone(previous.state.spenderReceivingKeys)
-            },
-            receivingKeySource: { kind: "top-up", commitment: previous.commitment }
-          };
-          this.checkSnapshotKeys(repaired);
-          await remember(repaired);
-          recovered.push(repaired);
-        }
-      }
+  };
+  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(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);
     }
-    return recovered;
   }
-};
-
-// src/session/WalletUpdater.ts
-var check7 = (value, message) => {
-  if (!value) throw new Error(message);
-};
-var position2 = (treeId, leafIndex) => `${treeId}:${leafIndex}`;
-var WalletUpdater = class extends InventoryProcessor {
-  #options;
-  constructor(options) {
-    super(options);
-    this.#options = { ...options };
-    check7(
-      options.viewing.ownerAddress === options.scope.ownerAddress,
-      "viewing capability wallet mismatch"
+  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"
     );
-  }
-  applyUpdates(batch, options = {}) {
-    return this.run(structuredClone(batch), { ...options });
-  }
-  async run(batch, options) {
-    const { reader, protocol, scope, store, viewing } = this.#options;
-    const nullifier = NullifierCapability.fromIdentity(scope.ownerAddress);
-    const { signal, reset } = options;
-    signal?.throwIfAborted();
-    const context = protocol.context;
-    check7(
-      batch.context.chainId === context.chainId && batch.context.protocolAddress.toLowerCase() === context.protocolAddress.toLowerCase(),
-      "update deployment context mismatch"
+    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"
     );
-    check7(
-      batch.block.number >= protocol.deployment.protocol.fromBlock,
-      "update precedes deployment"
+    results.set(key, value);
+  };
+  const creation = (log, a, fields) => {
+    const tree = integer(a.outputTreeId), leaves = array(a.leafIndices), ds = array(a.deliveries);
+    const change = hash(fields.changeCommitment), hasChange = BigInt(change) !== 0n;
+    check3(
+      ds.length === 3 && leaves.length === (hasChange ? 2 : 1),
+      "invalid Credit creation delivery slots"
     );
-    await protocol.validateDeployment(reader);
-    const base = await store.readSnapshot(scope);
-    check7(reset || !base.invalidated, "wallet state is invalidated; rebuild required");
-    try {
-      if (!reset) {
-        for (const cursor of [base.observedThrough]) {
-          if (!cursor) continue;
-          if ((await reader.getBlock(cursor.number)).hash !== cursor.hash)
-            throw new CanonicalConflict("Canonical history changed after a reorg");
-          check7(
-            cursor.number <= batch.block.number,
-            "update target precedes wallet checkpoint"
-          );
-        }
-      } else {
-        base.notes = {};
-        base.credits = {};
-      }
-      const block = await reader.getBlock(batch.block.number);
-      check7(
-        block.hash === batch.block.hash && block.number === batch.block.number,
-        "update target block is not canonical"
-      );
-      const receipts = [];
-      for (const hash2 of new Set(batch.transactionHashes)) {
-        signal?.throwIfAborted();
-        check7(/^0x[0-9a-fA-F]{64}$/.test(hash2), "invalid candidate transaction hash");
-        const receipt = await reader.getReceipt(hash2);
-        check7(
-          receipt && receipt.status === "success" && receipt.transactionHash.toLowerCase() === hash2.toLowerCase(),
-          "invalid or unsuccessful candidate receipt"
-        );
-        check7(
-          receipt.block.number >= protocol.deployment.protocol.fromBlock && receipt.block.number <= block.number,
-          "candidate receipt outside update range"
-        );
-        if ((await reader.getBlock(receipt.block.number)).hash !== receipt.block.hash)
-          throw new CanonicalConflict("Candidate receipt disagrees with canonical chain");
-        receipts.push(receipt);
-      }
-      const logs = receipts.flatMap(
-        (receipt) => readProtocolLogs(receipt, context.protocolAddress)
-      );
-      logs.sort(
-        (a, b) => a.blockNumber < b.blockNumber ? -1 : a.blockNumber > b.blockNumber ? 1 : a.logIndex - b.logIndex
-      );
-      const leaves = /* @__PURE__ */ new Map();
-      for (const event of logs) {
-        if (event.eventName !== "CommitmentsInserted" && event.eventName !== "BatchOutputs")
-          continue;
-        const { treeId, startLeafIndex, commitments } = event.args;
-        for (const [i, commitment] of commitments.entries()) {
-          const key = position2(treeId, Number(startLeafIndex) + i);
-          check7(
-            !leaves.has(key) || leaves.get(key) === BigInt(commitment),
-            "conflicting canonical insertion"
-          );
-          leaves.set(key, BigInt(commitment));
-        }
-      }
-      const getLeaf = (tree, index2) => {
-        const leaf = leaves.get(position2(tree, index2));
-        check7(leaf !== void 0, "missing canonical insertion");
-        return leaf;
-      };
-      const decrypted = await decryptCandidates(logs, {
-        context,
-        viewing,
-        confirmedThrough: block.number
-      });
-      const notes = decrypted.notes.map((record) => ({
-        ...record,
-        spent: "unknown"
-      }));
-      const incoming = decrypted.credits.map((record) => ({
-        ...record,
-        spent: "unknown"
-      }));
-      const recovered = await this.recoverCredits(base, incoming, logs, { getLeaf });
-      const creditsByKey = new Map(
-        incoming.map((record) => [record.commitment + ":" + record.role, record])
+    add(log, tree, index(leaves[0]), fields.creditCommitment, "owner", ds[0]);
+    add(log, tree, index(leaves[0]), fields.creditCommitment, "spender", ds[1]);
+    if (hasChange) add(log, tree, index(leaves[1]), change, "funds", ds[2]);
+    else normalizeOpaqueDelivery(ds[2], { empty: true });
+  };
+  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.outputCommitments), 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"
       );
-      for (const record of recovered)
-        creditsByKey.set(record.commitment + ":" + record.role, record);
-      const credits = [...creditsByKey.values()].filter((record) => {
-        try {
-          this.checkSnapshotKeys(record);
-          return true;
-        } catch (error) {
-          if (error instanceof CreditMetadataMismatch) return false;
-          throw error;
-        }
-      }).sort(
-        (a, b) => a.blockNumber < b.blockNumber ? -1 : a.blockNumber > b.blockNumber ? 1 : a.treeId < b.treeId ? -1 : a.treeId > b.treeId ? 1 : a.leafIndex - b.leafIndex
+      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.commitments), 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"
       );
-      for (const record of [...notes, ...credits]) {
-        signal?.throwIfAborted();
-        const proof = await this.#options.protocolRpc.getMembership(context, record, block);
-        const tokenAddress = "note" in record ? record.note.tokenAddress : record.state.note.tokenAddress;
-        await verifyMembership(
-          reader,
-          {
-            ...context,
-            tokenAddress: `0x${tokenAddress.toString(16).padStart(40, "0")}`
-          },
-          block,
-          record,
-          proof
+      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 allNotes = {
-        ...base.notes,
-        ...Object.fromEntries(notes.map((record) => [record.commitment, record]))
-      };
-      const allCredits = {
-        ...base.credits,
-        ...Object.fromEntries(
-          credits.map((record) => [record.commitment + ":" + record.role, record])
-        )
-      };
-      const observations = [];
-      for (const [id, record] of Object.entries(allNotes))
-        observations.push({
-          kind: "notes",
-          id,
-          nullifier: await nullifier.compute(
-            scope.chainId,
-            record.commitment,
-            record.note.nonce
-          )
-        });
-      for (const [id, record] of Object.entries(allCredits))
-        observations.push({
-          kind: "credits",
-          id,
-          nullifier: await this.creditNullifier(record.state)
-        });
-      const spent = observations.length ? await reader.isSpent(
-        context,
-        observations.map((item) => item.nullifier),
-        block
-      ) : [];
-      check7(
-        spent.length === observations.length && spent.every((value) => typeof value === "boolean"),
-        "invalid spent-state response"
+        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 === "CreditToppedUp")
+      creation(log, a, object(object(a.params).creation));
+    else if (log.eventName === "CreditDraw") {
+      const p = object(a.params), cs = array(p.remainderCommitments), ds = array(a.deliveries), leaves = array(a.remainderLeafIndices), tree = integer(a.outputTreeId);
+      check3(
+        ds.length === 2 * cs.length && leaves.length === cs.length,
+        "invalid draw delivery slots"
       );
-      signal?.throwIfAborted();
-      if ((await reader.getBlock(block.number)).hash !== block.hash)
-        throw new CanonicalConflict("Canonical block changed during update");
-      await store.transaction(scope, (draft) => {
-        signal?.throwIfAborted();
-        check7(draft.revision === base.revision, "wallet changed during update; retry");
-        if (reset) {
-          this.reorgOperations(draft);
-          draft.notes = {};
-          draft.credits = {};
-          delete draft.observedThrough;
-          delete draft.discoveryThrough;
-          delete draft.invalidated;
+      cs.forEach((c, i) => {
+        if (BigInt(hash(c)) === 0n) {
+          check3(integer(leaves[i]) === 0n, "absent remainder has nonzero position");
+          normalizeOpaqueDelivery(ds[2 * i], { empty: true });
+          normalizeOpaqueDelivery(ds[2 * i + 1], { empty: true });
+        } else {
+          add(log, tree, index(leaves[i]), c, "owner", ds[2 * i]);
+          add(log, tree, index(leaves[i]), c, "spender", ds[2 * i + 1]);
         }
-        mergeReceiptRecords(draft, { notes, credits, checkpoint: block });
-        observations.forEach((item, index2) => {
-          const record = draft[item.kind][item.id];
-          if (record) {
-            mergeSpentObservation(record, {
-              spent: spent[index2] ? "spent" : "unspent",
-              checkedThrough: { number: block.number, hash: block.hash }
-            });
-          }
-        });
-        draft.observedThrough = { number: block.number, hash: block.hash };
       });
-      return {
-        block,
-        notes: notes.length,
-        credits: credits.length,
-        balances: walletBalances(await store.readSnapshot(scope))
-      };
-    } catch (error) {
-      if (error instanceof CanonicalConflict) await this.invalidate();
-      throw error;
     }
   }
-};
-
-// src/session/WalletSession.ts
-var WalletSession = class {
-  #options;
-  #updater;
-  #listeners = /* @__PURE__ */ new Set();
-  #sending = /* @__PURE__ */ new Set();
-  #refreshQueue = Promise.resolve();
-  scope;
-  protocol;
-  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"
-      );
-    options = configureRecipientInfrastructure(options);
-    if ("ciphertextCodecs" in options || "envelopeVersion" in options) {
-      throw new Error(
-        "SDK envelope versions are fixed; encode application payload bytes externally"
-      );
-    }
-    const store = options.store;
-    this.#options = {
-      ...options,
-      ...store ? {
-        store: {
-          persistent: store.persistent,
-          readSnapshot: (scope) => store.readSnapshot(scope),
-          transaction: async (scope, action) => {
-            const result = await store.transaction(scope, action);
-            if (scopeKey(scope) === scopeKey(this.scope)) {
-              for (const listener of [...this.#listeners]) {
-                try {
-                  listener();
-                } catch {
-                }
-              }
-            }
-            return result;
-          }
-        }
-      } : {},
-      ...options.gasBenchmarks ? { gasBenchmarks: copyGasBenchmarks(options.gasBenchmarks) } : {}
-    };
-    this.protocol = options.protocol;
-    this.scope = Object.freeze({
-      namespace: options.namespace ?? "default",
-      ...options.protocol.context,
-      ownerAddress: options.wallet.ownerAddress
-    });
-    scopeKey(this.scope);
-    Object.freeze(this);
+  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);
   }
-  /** Delegate sending to ethers; managed operations additionally retain the resulting hash. */
-  async sendTransaction(input, options = {}) {
-    const signer = this.#options.signer;
-    if (!signer) throw new MissingCapabilityError2("ethers signer");
-    const operation = input instanceof Operation ? input : void 0;
-    if (operation && this.#sending.has(operation.id))
-      throw new Error("operation is already being sent by this session");
-    if (operation) this.#sending.add(operation.id);
-    const overrides = { ...options };
-    const plain = operation ? void 0 : { ...input };
+  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 (!signer.provider) throw new MissingCapabilityError2("connected ethers signer");
-      if ((await signer.provider.getNetwork()).chainId !== this.protocol.context.chainId) {
-        throw new Error("signer-provider session chain mismatch");
-      }
-      if (operation) {
-        if (!this.#options.store) throw new MissingCapabilityError2("wallet store");
-        const state = await this.#options.store.readSnapshot(this.scope);
-        if (!state.operations[operation.id])
-          throw new Error("operation does not belong to this wallet session");
-      }
-      const call = operation ? await operation.exportTransaction() : plain;
-      const transaction = await signer.sendTransaction({
-        ...overrides,
-        to: call.to,
-        data: call.data,
-        value: call.value,
-        chainId: this.protocol.context.chainId
-      });
-      if (operation) {
-        try {
-          await operation.trackTransaction(transaction.hash);
-        } catch (cause) {
-          throw new Error(
-            `Transaction ${transaction.hash} was sent but its operation association could not be saved; resume and reconcile this hash`,
-            { cause }
-          );
-        }
+      if (role === "funds") {
+        if (delivery.ciphertext === "0x") continue;
+        const note = await options.viewing.decryptNote(delivery.ciphertext, context);
+        notes.push({ ...positionData, note });
+      } else {
+        const state = await options.viewing.decryptCredit(delivery.ciphertext, {
+          ...context,
+          role
+        });
+        credits.push({ ...positionData, role, state });
       }
-      return transaction;
-    } finally {
-      if (operation) this.#sending.delete(operation.id);
-    }
-  }
-  runtime(tokenAddress) {
-    const options = this.#options;
-    if (!options.store) {
-      throw new MissingCapabilityError2("wallet store");
-    }
-    if (!options.chainReader) {
-      throw new MissingCapabilityError2("chain reader");
+    } catch {
     }
-    return {
-      options: { ...options, protocol: options.protocol.forToken(tokenAddress) },
-      scope: this.scope,
-      store: options.store,
-      reader: options.chainReader,
-      authorization: () => {
-        if (options.authorization) return options.authorization;
-        if (options.wallet instanceof Wallet) return options.wallet.exportAuthorization();
-        throw new MissingCapabilityError2("wallet authorization");
-      }
-    };
   }
-  updater() {
-    if (this.#updater) return this.#updater;
-    const options = this.#options;
-    if (!options.store || !options.chainReader || !options.protocolRpc)
-      throw new MissingCapabilityError2("wallet store, chain reader and Protocol RPC");
-    const viewing = options.viewing ?? (options.wallet instanceof Wallet ? options.wallet.getViewer() : void 0);
-    if (!viewing) throw new MissingCapabilityError2("viewing");
-    const receivingAddress = options.wallet.getReceivingAddress();
-    const receivingKeys = receivingAddress.kind === "long" ? receivingAddress.getReceivingKeys() : void 0;
-    this.#updater = new WalletUpdater({
-      protocol: options.protocol,
-      scope: this.scope,
-      store: options.store,
-      reader: options.chainReader,
-      viewing,
-      protocolRpc: options.protocolRpc,
-      ...receivingKeys ? { receivingKeys } : {}
+  return { notes, credits };
+}
+
+// src/broadcaster/index.ts
+import { invisiProtocolAbi as invisiProtocolAbi2 } from "@invisi-labs/protocol/contracts";
+import { AbiCoder, getAddress as getAddress2, Interface as Interface2, keccak256, verifyTypedData as verifyTypedData2 } from "ethers";
+var broadcasterQuoteTypes = {
+  Quote: [
+    { name: "token", type: "address" },
+    { name: "feeRecipient", type: "address" },
+    { name: "feeAmount", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "maxGas", type: "uint256" },
+    { name: "requestHash", type: "bytes32" }
+  ]
+};
+function broadcasterQuoteDomain(trust) {
+  return {
+    name: "InvisiBroadcaster",
+    version: "1",
+    chainId: trust.chainId,
+    verifyingContract: getAddress2(trust.protocol)
+  };
+}
+var supportedMethods = ["transact", "shield", "createCredit", "topUpCredit", "cancelCredit"];
+var intentAbi = invisiProtocolAbi2.filter(
+  (item) => item.type === "function" && supportedMethods.includes(item.name) && (item.name !== "transact" || item.inputs[1]?.type === "tuple")
+);
+var broadcasterTransactInterface = new Interface2(intentAbi);
+function decodeBroadcasterIntent(data) {
+  const parsed = broadcasterTransactInterface.parseTransaction({ data });
+  if (!parsed || !supportedMethods.includes(parsed.name))
+    throw new Error("unsupported broadcaster method");
+  const fragment = parsed.fragment;
+  const decoded = parsed.args;
+  if (broadcasterTransactInterface.encodeFunctionData(fragment, decoded).toLowerCase() !== data.toLowerCase())
+    throw new Error("noncanonical broadcaster calldata");
+  const method = parsed.name;
+  const raw = method === "transact" ? decoded[1] : void 0;
+  const params = raw?.params ?? (method === "shield" ? decoded[0] : method === "topUpCredit" ? decoded[1].creation : decoded[1]);
+  const funding = raw?.funding ?? (method === "shield" ? decoded[3] : ["createCredit", "topUpCredit"].includes(method) ? decoded[3] : void 0);
+  const deliveries = raw?.deliveries ?? (method === "shield" ? decoded[2] : ["createCredit", "topUpCredit"].includes(method) ? decoded[2] : []);
+  return {
+    fragment,
+    method,
+    args: decoded,
+    proof: method === "shield" ? "0x" : decoded[0],
+    request: { params, funding, deliveries }
+  };
+}
+function broadcasterRequestHash(data) {
+  const { fragment, method, args } = decodeBroadcasterIntent(data);
+  const copy = (value) => Array.isArray(value) ? value.map(copy) : value;
+  const canonical = copy(args);
+  if (method !== "shield") canonical[0] = "0x";
+  if (method === "transact") canonical[1][2][4] = "0x";
+  else if (method !== "cancelCredit") canonical[3][4] = "0x";
+  const calldata = broadcasterTransactInterface.encodeFunctionData(fragment, canonical);
+  return keccak256(
+    AbiCoder.defaultAbiCoder().encode(
+      ["string", "string", "bytes"],
+      ["InvisiBroadcasterIntentV1", method, calldata]
+    )
+  );
+}
+function verifyBroadcasterQuote(signed, trust, data, now = BigInt(Math.floor(Date.now() / 1e3))) {
+  const { quote } = signed;
+  const { request } = decodeBroadcasterIntent(data);
+  const p = request.params;
+  if (quote.requestHash !== broadcasterRequestHash(data) || getAddress2(quote.token) !== getAddress2(p.token) || getAddress2(quote.feeRecipient) !== getAddress2(p.feeRecipient) || BigInt(quote.feeAmount) !== p.feeAmount || BigInt(quote.deadline) > p.deadline || BigInt(quote.deadline) < now || BigInt(quote.maxGas) <= 0n || BigInt(quote.feeAmount) <= 0n || BigInt(quote.feeAmount) >= 1n << 128n)
+    throw new Error("quote does not match final intent or bounds");
+  if (getAddress2(
+    verifyTypedData2(
+      broadcasterQuoteDomain(trust),
+      broadcasterQuoteTypes,
+      quote,
+      signed.signature
+    )
+  ) !== getAddress2(trust.signer))
+    throw new Error("untrusted quote signature");
+  return quote;
+}
+function checkedStatus(value, id) {
+  const status = value;
+  if (!status || status.id !== id || !["pending", "submitted", "confirmed", "reverted", "uncertain"].includes(status.state) || status.transactionHash !== void 0 && !/^0x[0-9a-fA-F]{64}$/.test(status.transactionHash))
+    throw new Error("invalid broadcaster status");
+  return status;
+}
+var BroadcasterClient = class {
+  configuration;
+  url;
+  transport;
+  requestId = 0;
+  constructor(configuration, transport) {
+    this.configuration = Object.freeze({
+      endpoint: configuration.endpoint,
+      quoteSigner: getAddress2(configuration.quoteSigner),
+      feeRecipient: getAddress2(configuration.feeRecipient)
     });
-    return this.#updater;
-  }
-  /** Local session commits only. Host applications own cross-tab/store subscriptions. */
-  subscribe(listener) {
-    this.#listeners.add(listener);
-    return () => {
-      this.#listeners.delete(listener);
-    };
-  }
-  /** Detached history for wallet UI; construction records do not imply chain success. */
-  async getHistory(options = {}) {
-    const tokenAddress = options.tokenAddress ? getAddress(options.tokenAddress) : void 0;
-    const store = this.#options.store;
-    if (!store) throw new MissingCapabilityError2("wallet store");
-    return walletHistory(
-      await store.readSnapshot(this.scope),
-      tokenAddress ? { tokenAddress } : {}
-    );
-  }
-  async balance(tokenAddress) {
-    const store = this.#options.store;
-    if (!store) {
-      throw new MissingCapabilityError2("wallet store");
-    }
-    return walletBalance(await store.readSnapshot(this.scope), getAddress(tokenAddress));
-  }
-  /** Pull explicitly selected indexed pages; no chain scanning or public tree reconstruction. */
-  async refresh(options) {
-    const provider = this.#options.protocolRpc;
-    const reader = this.#options.chainReader;
-    if (!reader) throw new MissingCapabilityError2("chain reader");
-    if (!provider) throw new MissingCapabilityError2("Protocol RPC");
-    const updater = this.updater();
-    const request = {
-      ...options,
-      ...options.detectionKey ? { detectionKey: options.detectionKey.slice() } : {}
-    };
-    const task = this.#refreshQueue.then(async () => {
-      const result = await refreshWallet(
-        {
-          provider,
-          reader,
-          context: this.protocol.context,
-          fromBlock: this.protocol.deployment.protocol.fromBlock,
-          apply: (batch, settings) => updater.applyUpdates(batch, settings)
-        },
-        request
-      );
-      await this.#options.store.transaction(this.scope, (state) => {
-        request.signal?.throwIfAborted();
-        if (state.invalidated) throw new Error("wallet requires canonical resync");
-        const previous = state.discoveryThrough;
-        const start = previous ? previous.number + 1n : this.protocol.deployment.protocol.fromBlock;
-        if (request.fromBlock <= start && (!previous || result.block.number >= previous.number)) {
-          state.discoveryThrough = {
-            number: result.block.number,
-            hash: result.block.hash
-          };
-        }
+    if (BigInt(this.configuration.quoteSigner) === 0n || BigInt(this.configuration.feeRecipient) === 0n)
+      throw new Error("invalid broadcaster configuration");
+    this.url = configuration.endpoint;
+    const base = new URL(this.url);
+    if (base.protocol !== "https:" || base.username || base.password)
+      throw new Error("broadcaster requires HTTPS");
+    this.transport = transport ?? (async (request) => {
+      const response = await fetch(base, {
+        redirect: "error",
+        method: "POST",
+        body: JSON.stringify(request),
+        headers: { "content-type": "application/json" },
+        signal: AbortSignal.timeout(3e4)
       });
-      return result;
-    });
-    this.#refreshQueue = task.catch(() => {
-    });
-    return task;
-  }
-  preparation(tokenAddress) {
-    const runtime = this.runtime(tokenAddress);
-    return new TransactionPreparation({
-      options: runtime.options,
-      scope: runtime.scope,
-      reader: runtime.reader,
-      readInventory: () => runtime.store.readSnapshot(runtime.scope),
-      complete: (plan) => Operation.prepare(runtime, plan)
-    });
-  }
-  async prepareTransfer(options) {
-    return prepareWithErrors("prepareTransfer", async () => {
-      return this.preparation(options.tokenAddress).prepareTransfer(options);
-    });
-  }
-  async prepareShield(options) {
-    return prepareWithErrors("prepareShield", async () => {
-      return this.preparation(options.tokenAddress).prepareShield(options);
-    });
-  }
-  async prepareCreateCredit(options) {
-    return prepareWithErrors("prepareCreateCredit", async () => {
-      return this.preparation(options.tokenAddress).prepareCreateCredit(options);
+      if (!response.ok) throw new Error(`Broadcaster HTTP ${response.status}`);
+      if (!response.body) throw new Error("empty broadcaster response");
+      const reader = response.body.getReader();
+      const chunks = [];
+      let size = 0;
+      try {
+        while (true) {
+          const result = await reader.read();
+          if (result.done) break;
+          size += result.value.length;
+          if (size > 65536) throw new Error("broadcaster response too large");
+          chunks.push(result.value);
+        }
+      } finally {
+        await reader.cancel();
+      }
+      const bytes = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return JSON.parse(new TextDecoder().decode(bytes));
     });
   }
-  async prepareDrawCredit(options) {
-    return prepareWithErrors("prepareDrawCredit", async () => {
-      return this.preparation(options.tokenAddress).prepareDrawCredit(options);
+  async call(method, params) {
+    const id = ++this.requestId;
+    const response = await this.transport({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params: [params]
     });
+    if (!response || response.jsonrpc !== "2.0" || response.id !== id || Object.hasOwn(response, "result") === Object.hasOwn(response, "error"))
+      throw new Error("invalid broadcaster JSON-RPC response");
+    if (response.error) {
+      if (!Number.isInteger(response.error.code) || typeof response.error.message !== "string")
+        throw new Error("invalid broadcaster JSON-RPC error");
+      throw new BroadcasterRpcError(response.error.code, response.error.message);
+    }
+    return response.result;
   }
-  async prepareTopUpCredit(options) {
-    return prepareWithErrors("prepareTopUpCredit", async () => {
-      return this.preparation(options.tokenAddress).prepareTopUpCredit(options);
+  async fee(token, data) {
+    const fee = await this.call("broadcaster_getFee", {
+      token: getAddress2(token),
+      ...data ? { data } : {}
     });
+    if (!fee || getAddress2(fee.feeRecipient) !== this.configuration.feeRecipient || !/^\d+$/.test(fee.feeAmount) || BigInt(fee.feeAmount) <= 0n || BigInt(fee.feeAmount) >= 1n << 128n || !/^\d+$/.test(fee.maxGas) || BigInt(fee.maxGas) <= 0n)
+      throw new Error("invalid broadcaster fee");
+    return fee;
   }
-  async prepareCancelCredit(options) {
-    return prepareWithErrors("prepareCancelCredit", async () => {
-      return this.preparation(options.tokenAddress).prepareCancelCredit(options);
+  async quote(data, context) {
+    const signed = await this.call("broadcaster_getQuote", {
+      data
     });
-  }
-  async resume(operationId) {
-    const store = this.#options.store;
-    if (!store) throw new MissingCapabilityError2("wallet store");
-    const state = await store.readSnapshot(this.scope);
-    const saved = state.operations[operationId]?.payload;
-    if (!saved?.plan) throw new Error("operation not found");
-    return Operation.resume(this.runtime(saved.plan.context.tokenAddress), operationId);
-  }
-  toJSON() {
-    return { walletSession: true, ownerAddress: this.scope.ownerAddress };
-  }
-  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
-    return this.toJSON();
-  }
-};
-
-// src/session/codec.ts
-function encode(value) {
-  if (typeof value === "bigint") return ["bigint", value.toString()];
-  if (value instanceof Uint8Array) return ["bytes", Array.from(value)];
-  if (Array.isArray(value)) return ["array", value.map(encode)];
-  if (value && typeof value === "object")
-    return ["object", Object.entries(value).map(([key, item]) => [key, encode(item)])];
-  if (value === void 0) return ["undefined"];
-  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
-    return ["value", value];
-  throw new Error("unsupported wallet record value");
-}
-function decode(node) {
-  if (!Array.isArray(node)) throw new Error("invalid wallet record encoding");
-  const [type, value] = node;
-  if (type === "bigint" && typeof value === "string" && /^-?(0|[1-9][0-9]*)$/.test(value))
-    return BigInt(value);
-  if (type === "bytes" && Array.isArray(value) && value.every((n) => Number.isInteger(n) && n >= 0 && n < 256))
-    return Uint8Array.from(value);
-  if (type === "array" && Array.isArray(value)) return value.map(decode);
-  if (type === "object" && Array.isArray(value))
-    return Object.fromEntries(
-      value.map((pair) => {
-        if (!Array.isArray(pair) || pair.length !== 2 || typeof pair[0] !== "string")
-          throw new Error("invalid object record");
-        return [pair[0], decode(pair[1])];
-      })
+    verifyBroadcasterQuote(
+      signed,
+      { ...context, signer: this.configuration.quoteSigner },
+      data
+    );
+    if (getAddress2(signed.quote.feeRecipient) !== this.configuration.feeRecipient)
+      throw new Error("unregistered fee recipient");
+    return { quote: signed.quote, signature: signed.signature, context: { ...context } };
+  }
+  async submit(data, signed, idempotencyKey) {
+    if (!signed.context) throw new Error("missing verified quote context");
+    verifyBroadcasterQuote(
+      signed,
+      { ...signed.context, signer: this.configuration.quoteSigner },
+      data,
+      0n
+    );
+    if (getAddress2(signed.quote.feeRecipient) !== this.configuration.feeRecipient)
+      throw new Error("unregistered fee recipient");
+    return checkedStatus(
+      await this.call("broadcaster_submitTransaction", {
+        data,
+        quote: signed.quote,
+        signature: signed.signature,
+        idempotencyKey
+      }),
+      idempotencyKey
     );
-  if (type === "undefined" && node.length === 1) return void 0;
-  if (type === "value" && (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)))
-    return value;
-  throw new Error("invalid wallet record node");
-}
-function serializeState(state) {
-  return new TextEncoder().encode(JSON.stringify(encode(state)));
-}
-function deserializeState(data) {
-  return decode(
-    JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(data))
-  );
-}
-var MemoryRecordCodec = class {
-  async encode(state) {
-    return serializeState(state);
   }
-  async decode(data) {
-    return deserializeState(data);
+  async status(id) {
+    return checkedStatus(await this.call("broadcaster_getTransactionStatus", { id }), id);
   }
 };
-
-// src/session/index.ts
-var MemoryWalletStore = class extends TransactionalWalletStore {
-  constructor() {
-    super(new MemoryAtomicRecords(), new MemoryRecordCodec(), { persistent: false });
+var BroadcasterRpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BroadcasterRpcError";
   }
 };
 
 export {
+  creditReservationKey,
+  inputFacts,
+  operationSources,
   copyGasBenchmarks,
   defineGasBenchmarks,
+  estimateShapeGas,
+  estimateBenchmarkGas,
   estimateGasReference,
+  AddressRegistry,
+  TransactionOutput,
+  publicProof,
   sameStatement,
+  encodeOperation,
+  witnessFor,
+  fundingTypedData,
+  authorizeOperation,
   proveOperation,
+  signOperationFunding,
   walletSigningRequest,
   acceptWalletSignature,
   fundingSigningRequest,
   acceptFundingSignature,
   operationPreview,
-  serializeState,
-  deserializeState,
+  PreparedTransaction,
+  configureTransactionInfrastructure,
+  validateTransactionInfrastructure,
+  Invisi,
+  decodeProtocolEvent,
   readProtocolLogs,
+  extractDeliveryCandidates,
   decryptCandidates,
-  DisclosureVerifier,
-  TransactionalWalletStore,
-  MemoryAtomicRecords,
-  Operation,
-  WalletSession,
-  MemoryWalletStore
+  broadcasterQuoteTypes,
+  broadcasterQuoteDomain,
+  broadcasterTransactInterface,
+  decodeBroadcasterIntent,
+  broadcasterRequestHash,
+  verifyBroadcasterQuote,
+  BroadcasterClient,
+  BroadcasterRpcError
 };
-//# sourceMappingURL=chunk-4SD3MW6N.js.map
+//# sourceMappingURL=chunk-EHP5TBC6.js.map