@invisi-labs/sdk 1.1.0

package/dist/indexeddb.cjs

@@ -0,0 +1,4464 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/integrations/indexeddb.ts
+var indexeddb_exports = {};
+__export(indexeddb_exports, {
+  IndexedDBAtomicRecords: () => IndexedDBAtomicRecords,
+  IndexedDBWalletStore: () => IndexedDBWalletStore
+});
+module.exports = __toCommonJS(indexeddb_exports);
+
+// src/integrations/ethers.ts
+var import_ethers = require("ethers");
+var import_contracts = require("@invisi-labs/protocol/contracts");
+var import_address = require("@invisi-labs/core/address");
+var getAddress = (value) => (0, import_ethers.getAddress)(value);
+function check(value, message) {
+  if (!value) {
+    throw new Error(message);
+  }
+}
+async function chain(client, expected) {
+  check((await client.getNetwork()).chainId === expected, "EVM client chain mismatch");
+}
+function number(value) {
+  check(typeof value === "bigint" && value >= 0n, "invalid chain integer");
+  return value;
+}
+function boolean(value) {
+  check(typeof value === "boolean", "invalid chain boolean");
+  return value;
+}
+function word(value) {
+  check(typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value), "invalid chain word");
+  return value.toLowerCase();
+}
+function ownerWord(value) {
+  const identity = import_address.ReceivingAddress.fromIdentity(value).walletIdentity;
+  return (0, import_ethers.zeroPadValue)(identity, 32);
+}
+var EthersChainReader = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getChainId() {
+    return (await this.client.getNetwork()).chainId;
+  }
+  async getProtocolVersion(address2) {
+    return BigInt(
+      await new import_ethers.Contract(getAddress(address2), import_contracts.invisiProtocolAbi, this.client).getFunction(
+        "VERSION"
+      )()
+    );
+  }
+  async getCode(address2) {
+    return await this.client.getCode(getAddress(address2));
+  }
+  async getFactoryInstanceAddress(factory, salt) {
+    return getAddress(
+      await new import_ethers.Contract(factory, import_contracts.invisiFactoryAbi, this.client).getFunction(
+        "getInstanceAddress"
+      )(salt)
+    );
+  }
+  async isFactoryInstance(factory, instance) {
+    return boolean(
+      await new import_ethers.Contract(factory, import_contracts.invisiFactoryAbi, this.client).getFunction("isInstance")(
+        instance
+      )
+    );
+  }
+  async getInstanceFactory(instance) {
+    return getAddress(
+      await new import_ethers.Contract(instance, import_contracts.invisiProtocolAbi, this.client).getFunction("factory")()
+    );
+  }
+  async getLatestBlockNumber() {
+    return BigInt(await this.client.getBlockNumber());
+  }
+  async getBlock(blockNumber) {
+    const block = await this.client.getBlock(blockNumber);
+    check(
+      block && BigInt(block.number) === blockNumber && block.hash && block.parentHash,
+      "invalid canonical block"
+    );
+    return {
+      number: BigInt(block.number),
+      hash: word(block.hash),
+      parentHash: word(block.parentHash),
+      timestamp: number(BigInt(block.timestamp))
+    };
+  }
+  async read(context, address2, abi, functionName, args, block) {
+    await chain(this.client, context.chainId);
+    if (block) {
+      check(
+        (await this.getBlock(block.number)).hash === block.hash,
+        "canonical read block mismatch"
+      );
+    }
+    return new import_ethers.Contract(getAddress(address2), abi, this.client).getFunction(functionName)(
+      ...args,
+      ...block ? [{ blockTag: block.number }] : []
+    );
+  }
+  async getFundingNonce(context, payer, block) {
+    return number(
+      await this.read(
+        context,
+        context.protocolAddress,
+        import_contracts.invisiProtocolAbi,
+        "nonces",
+        [getAddress(payer)],
+        block
+      )
+    );
+  }
+  async getRegistryNonce(context, walletIdentity, block) {
+    return number(
+      await this.read(
+        context,
+        context.registryAddress,
+        import_contracts.invisiAddressRegistryAbi,
+        "nonceOf",
+        [ownerWord(walletIdentity)],
+        block
+      )
+    );
+  }
+  async isKnownRoot(context, treeId, root, block) {
+    return boolean(
+      await this.read(
+        context,
+        context.protocolAddress,
+        import_contracts.invisiProtocolAbi,
+        "rootHistory",
+        [number(treeId), word(root)],
+        block
+      )
+    );
+  }
+  async isSpent(context, nullifiers, block) {
+    const copied = nullifiers.map(word);
+    const result = [];
+    for (let offset = 0; offset < copied.length; offset += 32) {
+      result.push(
+        ...await Promise.all(
+          copied.slice(offset, offset + 32).map(
+            (nf) => this.read(
+              context,
+              context.protocolAddress,
+              import_contracts.invisiProtocolAbi,
+              "isNullifierSpent",
+              [nf],
+              block
+            ).then(boolean)
+          )
+        )
+      );
+    }
+    return result;
+  }
+  async getTransaction(hash2) {
+    try {
+      const tx = await this.client.getTransaction(word(hash2));
+      if (!tx?.to) {
+        return null;
+      }
+      return {
+        transactionHash: word(tx.hash),
+        to: getAddress(tx.to),
+        from: getAddress(tx.from),
+        nonce: number(BigInt(tx.nonce)),
+        data: tx.data,
+        value: number(tx.value)
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === "TransactionNotFoundError") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getReceipt(hash2) {
+    try {
+      const receipt = await this.client.getTransactionReceipt(word(hash2));
+      if (!receipt) return null;
+      const block = await this.getBlock(BigInt(receipt.blockNumber));
+      check(block.hash === receipt.blockHash, "receipt block is no longer canonical");
+      return {
+        block,
+        transactionHash: word(receipt.hash),
+        status: receipt.status === 1 ? "success" : "reverted",
+        logs: receipt.logs.map((log) => {
+          check(
+            !log.removed && log.transactionHash === receipt.hash && log.index !== null,
+            "invalid receipt log"
+          );
+          return {
+            address: getAddress(log.address),
+            data: log.data,
+            topics: [...log.topics],
+            transactionHash: word(log.transactionHash),
+            logIndex: log.index
+          };
+        })
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === "TransactionReceiptNotFoundError") {
+        return null;
+      }
+      throw error;
+    }
+  }
+};
+
+// src/session/protocol-events.ts
+var import_contracts2 = require("@invisi-labs/protocol/contracts");
+var import_ethers2 = require("ethers");
+var protocolInterface = new import_ethers2.Interface(import_contracts2.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);
+  }
+  for (const key of ["sources", "deliveries"]) {
+    const values = decoded.args.getValue(key);
+    if (values) args[key] = values.map((value) => value.toObject(true));
+  }
+  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
+var import_ethers3 = require("ethers");
+var import_core = require("@invisi-labs/core");
+var import_protocol = require("@invisi-labs/protocol");
+var EVENTS = /* @__PURE__ */ new Set([
+  "CommitmentsInserted",
+  "BatchOutputs",
+  "Shield",
+  "Transact",
+  "CrossTreeTransact",
+  "CreditCreated",
+  "CreditDraw",
+  "CreditToppedUp",
+  "CreditCancelled"
+]);
+function check2(ok, message) {
+  if (!ok) throw new Error(message);
+}
+function object(value) {
+  check2(value && typeof value === "object" && !Array.isArray(value), "invalid event object");
+  return value;
+}
+function array(value) {
+  check2(Array.isArray(value), "invalid event array");
+  check2(
+    Array.from({ length: value.length }, (_, i) => i in value).every(Boolean),
+    "sparse event array"
+  );
+  return value;
+}
+function integer(value) {
+  check2(
+    typeof value === "bigint" || typeof value === "number" && Number.isSafeInteger(value),
+    "invalid event integer"
+  );
+  const n = BigInt(value);
+  check2(n >= 0n, "negative event integer");
+  return n;
+}
+function index(value) {
+  const n = integer(value);
+  check2(n < 65536n, "invalid event leaf index");
+  return Number(n);
+}
+function hash(value) {
+  check2(typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value), "invalid event hash");
+  return value.toLowerCase();
+}
+function contextCheck(context) {
+  check2(context.chainId >= 0n && context.chainId < 1n << 64n, "invalid discovery chain");
+  check2(
+    (0, import_ethers3.isAddress)(context.protocolAddress) && BigInt(context.protocolAddress) !== 0n,
+    "invalid discovery instance/token"
+  );
+}
+var position = (tree, at) => `${tree}:${at}`;
+function extractDeliveryCandidates(logs, context, confirmedThrough) {
+  contextCheck(context);
+  check2(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) => {
+    check2(!log.removed, "discovery resync required after reorg");
+    check2(
+      typeof log.blockNumber === "bigint" && log.blockNumber >= 0n && log.blockNumber <= confirmedThrough,
+      "event is not confirmed"
+    );
+    check2(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);
+    check2(tree > 0n && tree < 1n << 64n, "invalid insertion tree");
+    check2(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);
+      check2(!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) => {
+    check2(tree > 0n && tree < 1n << 64n, "invalid output tree");
+    const inserted = insertions.get(insertionKey(log, tree, at));
+    check2(inserted, "delivery has no matching canonical insertion");
+    if (commitment !== void 0)
+      check2(hash(commitment) === inserted, "delivery commitment conflicts with insertion");
+    const delivery = (0, import_protocol.normalizeDelivery)(wire, { credit: role !== "funds" });
+    check2(
+      typeof token === "string" && (0, import_ethers3.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);
+    check2(
+      !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;
+    check2(
+      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 (0, import_protocol.normalizeDelivery)(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);
+      check2(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);
+      check2(
+        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;
+      check2(
+        typeof packed === "string" && /^0x(?:[0-9a-fA-F]{2})*$/.test(packed) && packed.length === 2 + 452 * cs.length,
+        "invalid packed deliveries"
+      );
+      check2(tokens.length === cs.length, "batch token count mismatch");
+      cs.forEach((c, i) => {
+        const segment = packed.slice(2 + 452 * i, 2 + 452 * (i + 1));
+        add(
+          log,
+          tree,
+          start + i,
+          c,
+          "funds",
+          {
+            ciphertext: `0x${segment.slice(0, 316)}`,
+            clue: `0x${segment.slice(316)}`
+          },
+          tokens[i]
+        );
+      });
+    } 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);
+      check2(
+        ds.length === 2 * cs.length && leaves.length === cs.length,
+        "invalid draw delivery slots"
+      );
+      cs.forEach((c, i) => {
+        if (BigInt(hash(c)) === 0n) {
+          check2(integer(leaves[i]) === 0n, "absent remainder has nonzero position");
+          (0, import_protocol.normalizeDelivery)(ds[2 * i], { empty: true });
+          (0, import_protocol.normalizeDelivery)(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);
+  (0, import_core.decodeAddress)(import_core.ReceivingAddress.fromIdentity(options.viewing.walletIdentity).toString());
+  check2(
+    !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);
+    check2(
+      !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") {
+        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 check3(value, message) {
+  if (!value) throw new Error(message);
+}
+function reference(value) {
+  check3(/^0x[0-9a-fA-F]{64}$/.test(value.transactionHash), "invalid disclosure transaction hash");
+  check3(
+    typeof value.treeId === "bigint" && value.treeId > 0n && value.treeId < 1n << 64n,
+    "invalid disclosure tree ID"
+  );
+  check3(
+    Number.isSafeInteger(value.leafIndex) && value.leafIndex >= 0 && value.leafIndex < 65536,
+    "invalid disclosure leaf index"
+  );
+  check3(["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;
+    check3(
+      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);
+    check3(
+      canonical2.number === block.number && canonical2.hash.toLowerCase() === block.hash.toLowerCase(),
+      "disclosure canonical block changed; reorg verification required"
+    );
+    const head = await this.#reader.getLatestBlockNumber();
+    check3(
+      head >= block.number && head - block.number + 1n >= this.#confirmations,
+      "insufficient disclosure confirmations"
+    );
+    check3(
+      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);
+    check3(received, "disclosure transaction receipt is unavailable");
+    const receipt = structuredClone(received);
+    check3(receipt.status === "success", "disclosure requires a successful transaction receipt");
+    check3(
+      receipt.transactionHash.toLowerCase() === selected.transactionHash,
+      "disclosure receipt transaction mismatch"
+    );
+    check3(
+      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()
+    );
+    check3(
+      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/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/state.ts
+function creditReservationKey(commitment) {
+  return "credit:" + commitment;
+}
+function walletBalance(state, tokenAddress) {
+  let confirmedKnown = 0n;
+  let reserved = 0n;
+  let unknown = !!state.invalidated;
+  const records = Object.values(state.notes).filter(
+    (r) => r.note.tokenAddress === BigInt(tokenAddress)
+  );
+  const points = records.map((record) => record.checkedThrough);
+  let checkedThrough = null;
+  if (records.length && points.every((point) => point !== void 0) && records.every((record) => record.spent !== "unknown")) {
+    checkedThrough = points.reduce(
+      (earliest, point) => point.number < earliest.number ? point : earliest
+    );
+  } else if (!records.length) {
+    checkedThrough = state.observedThrough ?? null;
+  }
+  if (!records.length && !checkedThrough) {
+    unknown = true;
+  }
+  for (const [id, record] of Object.entries(state.notes)) {
+    if (record.note.tokenAddress !== BigInt(tokenAddress)) continue;
+    if (record.spent !== "spent") {
+      confirmedKnown += record.note.amount;
+      if (record.spent === "unknown") {
+        unknown = true;
+      }
+      if (state.reservations[id]) {
+        reserved += record.note.amount;
+      }
+    }
+  }
+  return {
+    tokenAddress,
+    scope: { ...state.scope },
+    checkedThrough: state.invalidated ? null : checkedThrough ? { ...checkedThrough } : null,
+    confirmedKnown,
+    reserved,
+    availableKnown: unknown ? null : confirmedKnown - reserved,
+    invalidated: !!state.invalidated
+  };
+}
+function walletBalances(state) {
+  const tokens = new Set(
+    Object.values(state.notes).map(
+      (r) => `0x${r.note.tokenAddress.toString(16).padStart(40, "0")}`
+    )
+  );
+  return [...tokens].sort().map((token) => walletBalance(state, token));
+}
+
+// src/session/store.ts
+var import_core2 = require("@invisi-labs/core");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_utils = require("@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.walletIdentity) || BigInt(scope.walletIdentity) <= 0n || BigInt(scope.walletIdentity) >= 1n << 160n)
+    throw new Error("invalid scope wallet");
+  return (0, import_utils.bytesToHex)(
+    (0, import_sha256.sha256)(
+      (0, import_utils.utf8ToBytes)(
+        "Invisi.WalletScope.v2:" + JSON.stringify([
+          scope.namespace,
+          scope.chainId.toString(),
+          scope.protocolAddress.toLowerCase(),
+          scope.walletIdentity.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.walletIdentity.toLowerCase() !== scope.walletIdentity.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 = (0, import_core2.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.walletIdentity.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) >= import_core2.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();
+  }
+};
+
+// src/session/operation-protocol.ts
+var import_protocol2 = require("@invisi-labs/protocol");
+function requiresAuthorization(plan) {
+  if (plan.kind === "sweep") {
+    if (plan.credit || !plan.inputs.length || plan.outputs.length || !plan.params || plan.params.outputCommitments.length || (plan.funding.amount ?? 0n) !== 0n || BigInt(plan.params.withdrawalAddress) !== BigInt(plan.scope.walletIdentity) || plan.params.withdrawalAmount !== plan.inputs.reduce((sum, input) => sum + input.note.amount, 0n) || plan.inputs.some((input) => input.note.walletIdentity !== plan.scope.walletIdentity))
+      throw new Error("invalid owner-only sweep plan");
+    return false;
+  }
+  return !!plan.credit || plan.inputs.length > 0;
+}
+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 [];
+}
+function statement(plan) {
+  if (!plan.statement) throw new Error("operation has no proof statement");
+  const credit = plan.credit;
+  let words;
+  if (credit?.topUp) {
+    words = (0, import_protocol2.topUpCreditPublicInputs)(
+      plan.context,
+      credit.topUp,
+      credit.deliveries,
+      plan.funding
+    );
+  } else if (credit?.creation) {
+    words = (0, import_protocol2.createCreditPublicInputs)(
+      plan.context,
+      credit.creation,
+      credit.deliveries,
+      plan.funding
+    );
+  } else if (credit?.draw) {
+    words = (0, import_protocol2.creditDrawPublicInputs)(plan.context, credit.draw, credit.deliveries);
+  } else if (credit?.cancel) {
+    words = (0, import_protocol2.cancelCreditPublicInputs)(plan.context, credit.cancel);
+  } else {
+    words = (0, import_protocol2.transactUserPublicInputs)(
+      plan.context,
+      plan.params,
+      plan.outputs.map((output) => output.delivery),
+      plan.funding
+    );
+  }
+  const result = import_protocol2.WitnessBuilder.statement(
+    plan.statement.circuitName,
+    words,
+    plan.statement.target
+  );
+  if (JSON.stringify(result) !== JSON.stringify(plan.statement)) {
+    throw new Error("frozen operation statement changed");
+  }
+  return result;
+}
+function authorizationRequest(plan) {
+  let operation = "transact";
+  if (plan.kind === "draw-credit") {
+    operation = "credit-draw";
+  } else if (plan.kind === "create-credit" || plan.kind === "top-up-credit" || plan.kind === "cancel-credit") {
+    operation = plan.kind;
+  }
+  return {
+    context: {
+      chainId: plan.context.chainId,
+      protocolAddress: BigInt(plan.context.protocolAddress)
+    },
+    operation,
+    capacity: plan.capacity,
+    words: statement(plan).expectedPublicInputs.slice(0, -2).map(BigInt)
+  };
+}
+async function witnessFor(protocol, plan, authorization) {
+  const builder = new import_protocol2.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
+      });
+    }
+    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({
+        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) => output.note),
+    ...authorization ? { authorization } : {},
+    target: plan.statement.target
+  });
+}
+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 = (0, import_protocol2.buildTopUpCreditCalldata)({
+      ...funded,
+      params: credit.topUp,
+      deliveries: credit.deliveries
+    });
+  } else if (credit?.creation) {
+    encoded = (0, import_protocol2.buildCreateCreditCalldata)({
+      ...funded,
+      params: credit.creation,
+      deliveries: credit.deliveries
+    });
+  } else if (credit?.draw) {
+    encoded = (0, import_protocol2.buildCreditDrawCalldata)({
+      ...common,
+      params: credit.draw,
+      deliveries: credit.deliveries
+    });
+  } else if (credit?.cancel) {
+    encoded = (0, import_protocol2.buildCancelCreditCalldata)({ ...common, params: credit.cancel });
+  } else if (plan.kind === "shield") {
+    encoded = await (0, import_protocol2.buildShieldCalldata)({
+      ...funded,
+      params: plan.shieldParams,
+      outputs: plan.shieldOutputs,
+      deliveries: plan.outputs.map((output) => output.delivery)
+    });
+  } else {
+    encoded = (0, import_protocol2.buildTransactCalldata)({
+      ...funded,
+      params: plan.params,
+      deliveries: plan.outputs.map((output) => output.delivery)
+    });
+  }
+  return { to: plan.context.protocolAddress, data: encoded.data, value: 0n };
+}
+async function fundingTypedData(saved) {
+  const plan = saved.plan;
+  const credit = plan.credit;
+  if (credit?.topUp) {
+    return (0, import_protocol2.encodeTopUpCreditFundingTypedData)(
+      plan.context,
+      credit.topUp,
+      credit.deliveries,
+      plan.funding
+    );
+  }
+  if (credit?.creation) {
+    return (0, import_protocol2.encodeCreateCreditFundingTypedData)(
+      plan.context,
+      credit.creation,
+      credit.deliveries,
+      plan.funding
+    );
+  }
+  if (plan.kind === "shield") {
+    return (0, import_protocol2.encodeShieldFundingTypedData)({
+      context: plan.context,
+      params: plan.shieldParams,
+      outputs: plan.shieldOutputs,
+      deliveries: plan.outputs.map((output) => output.delivery),
+      funding: plan.funding
+    });
+  }
+  if (plan.statement?.target === "noir-recursive") {
+    return (0, import_protocol2.encodeAggregateFundingTypedData)(plan.context, {
+      params: plan.params,
+      deliveries: plan.outputs.map((output) => output.delivery),
+      funding: plan.funding
+    });
+  }
+  return (0, import_protocol2.encodeTransactFundingTypedData)(
+    plan.context,
+    saved.proof.proofHex,
+    plan.params,
+    plan.outputs.map((output) => output.delivery),
+    plan.funding
+  );
+}
+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]
+  };
+}
+function operationExpired(plan, now) {
+  if (now > plan.deadline) return true;
+  const credit = plan.credit;
+  if (credit?.topUp && now >= credit.topUp.previousExpiry) return true;
+  if (credit?.creation && now >= credit.creation.expiry) return true;
+  if (credit?.draw && credit.draw.expiries.some((expiry) => now >= expiry)) return true;
+  return false;
+}
+
+// src/data/gas-benchmarks.json
+var gas_benchmarks_default = [
+  {
+    formatVersion: 1,
+    id: "protocol-92ef274-osaka-real",
+    deployment: {
+      chainId: "31337",
+      protocolAddress: "0x8870C63A18a9480C7de9B860b849fD293832856D",
+      runtimeCodeHash: "0x604572c0da90ea139b774cd0d2962a2972fac46e0556c7cec6f6f9aac5deef14",
+      tokenAddress: "0x4826533B4897376654Bb4d4AD88B7faFD0C98528"
+    },
+    source: {
+      protocolCommit: "92ef274c6b36d783507699a33ee20e52192c83c7",
+      measuredAt: "2026-10-27T08:42:15.991Z",
+      chain: "Anvil 31337",
+      hardfork: "osaka",
+      token: "MockERC20",
+      verifier: "real",
+      assumptions: [
+        "normal CREATE/Factory deployment; no code or storage injection",
+        "Solidity 0.8.27 optimizer 200; real BB 5.2.1 verifiers",
+        "one source tree; two existing leaves; no rollover or screener",
+        "funding/approval setup excluded; complete transaction receipt gas included",
+        "exact allowance for caller funding; configured benchmark payout balances",
+        "observed local samples, not a confidence interval or gas limit"
+      ]
+    },
+    measurements: [
+      {
+        id: "shield-1",
+        shape: {
+          kind: "shield",
+          target: "evm",
+          capacity: 0,
+          noteInputs: 0,
+          noteOutputs: 1,
+          sourceTrees: 0,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "caller",
+          permit: false,
+          deliveryBytes: 226
+        },
+        circuit: null,
+        samples: [
+          {
+            gasUsed: "649286",
+            transactionHash: "0xcc299d1780ada9a69b1d9f0f3d06a165db15fccbd2b7ff407834f02f5d563a18",
+            blockNumber: "50",
+            blockHash: "0xbcb868e781a20588d2fa099a4d7f87c1600044a2e5ec1e369e384d7a5f22f00a",
+            calldataBytes: 1156
+          },
+          {
+            gasUsed: "649322",
+            transactionHash: "0x95139dff109725989f0769e3e6fb9bd3e7e1bf581fd475f14e822875eb90fda4",
+            blockNumber: "50",
+            blockHash: "0x7ace353fea4fc8c856c0fd45521d200b02619921977709ff4f910e0ff41c06fe",
+            calldataBytes: 1156
+          },
+          {
+            gasUsed: "649322",
+            transactionHash: "0xef578bb38dc8ff8bfd47d2e76e3ab4273019ea9a385f5d2fd99add32ceaecb58",
+            blockNumber: "50",
+            blockHash: "0xded817f8ef89637e2443e3b626c0837f184ca134fe753be913d5570554c649a6",
+            calldataBytes: 1156
+          }
+        ]
+      },
+      {
+        id: "shield-2",
+        shape: {
+          kind: "shield",
+          target: "evm",
+          capacity: 0,
+          noteInputs: 0,
+          noteOutputs: 2,
+          sourceTrees: 0,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "caller",
+          permit: false,
+          deliveryBytes: 452
+        },
+        circuit: null,
+        samples: [
+          {
+            gasUsed: "757063",
+            transactionHash: "0x024e2dfbd6f50c368e2a4aa347e3029de668f4ebd36b80227aa003bb7ac21c74",
+            blockNumber: "50",
+            blockHash: "0x8ed63973c158d706ac54bb646626e4f0db5777b4bd56d179b94503af6c417c50",
+            calldataBytes: 1668
+          },
+          {
+            gasUsed: "757063",
+            transactionHash: "0x898d852ab28f68adac4d30b160a3dbfee33fa7ca875f70df9eb7763b6b1cd1f0",
+            blockNumber: "50",
+            blockHash: "0x9bb6810de38193933a9f26fa03d3d9bad1ca0151ff5e04544c56520e09da3043",
+            calldataBytes: 1668
+          },
+          {
+            gasUsed: "757039",
+            transactionHash: "0x8ff9720e3197aab2d741fbd8d0fa2969203ea8cd051d9649d1e5eb890bcc2be3",
+            blockNumber: "50",
+            blockHash: "0x8604c75eb6363aaae774276e638f5b749aae1f8f815eb99ab1183137eef5730e",
+            calldataBytes: 1668
+          }
+        ]
+      },
+      {
+        id: "shield-10",
+        shape: {
+          kind: "shield",
+          target: "evm",
+          capacity: 0,
+          noteInputs: 0,
+          noteOutputs: 10,
+          sourceTrees: 0,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "caller",
+          permit: false,
+          deliveryBytes: 2260
+        },
+        circuit: null,
+        samples: [
+          {
+            gasUsed: "1692143",
+            transactionHash: "0x6c13db8bd8a8599daf5034e56712abefbf406982fafe7647b6d22291ba4199ed",
+            blockNumber: "50",
+            blockHash: "0x1ab2ae514f408a79e0c40ca10cee74b2e23d7c8a5f24641b8eea3e1cf58ce700",
+            calldataBytes: 5764
+          },
+          {
+            gasUsed: "1692083",
+            transactionHash: "0x5e476c9d3838b782a51332af9bf5c372d29fc411c2168a7af619c52bd5309c7b",
+            blockNumber: "50",
+            blockHash: "0x9c62bc72fc90f990c6711b48865ff922a1856ae05c4fef61dad5f4da7d948401",
+            calldataBytes: 5764
+          },
+          {
+            gasUsed: "1692203",
+            transactionHash: "0x0092e2d9160fad95279cde586fc6c79c713244f55db8a2060a5abab9d98c176a",
+            blockNumber: "50",
+            blockHash: "0xac1bf780b4cc05b4dcc7ee5d741c049ba99ab4af9bdcd25104add730c2a14152",
+            calldataBytes: 5764
+          }
+        ]
+      },
+      {
+        id: "transfer-1x2",
+        shape: {
+          kind: "transfer",
+          target: "evm",
+          capacity: 14,
+          noteInputs: 1,
+          noteOutputs: 2,
+          sourceTrees: 1,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 452
+        },
+        circuit: {
+          circuitName: "transact_user_slots14",
+          target: "evm",
+          artifactSha256: "2a6a20839e90b88b1ecd629f59a01821bad3ee11dbe04db1fd9cdce7a3de0e84",
+          vkSha256: "ffe0e1a4e690792ecb4eb1fc1acc9ff60f13d3b5af03cfc6ae6d6bf26e99bdea"
+        },
+        samples: [
+          {
+            gasUsed: "1617516",
+            transactionHash: "0xf49ea3d31cc1346472172e2dee84f9360f60a3fe948a3ef6e87f727af6d42f0d",
+            blockNumber: "49",
+            blockHash: "0xf59c57e63ec2f03abc36d28f273b0af5290184dc97197df740b23d79a851a887",
+            calldataBytes: 11012
+          },
+          {
+            gasUsed: "1617516",
+            transactionHash: "0xf8d11286f1f2a4db006ff6b06900c47d0fbf685984499e1e5d4aea49478ba8e5",
+            blockNumber: "49",
+            blockHash: "0xeb5a800190be3534c9e2675c97ac56d0e0be8adef55f60bd32d375776a7d150c",
+            calldataBytes: 11012
+          },
+          {
+            gasUsed: "1617504",
+            transactionHash: "0x8939fcea97079a3c5118b9e94325455e2ad1cdb47310ae499a277272654b3eb6",
+            blockNumber: "49",
+            blockHash: "0xecffefb593e2fec5d5827cfd39d0cc4d0efb67dbff6f8dbbd0d2db2439a80cf9",
+            calldataBytes: 11012
+          }
+        ]
+      },
+      {
+        id: "transfer-1x14",
+        shape: {
+          kind: "transfer",
+          target: "evm",
+          capacity: 56,
+          noteInputs: 1,
+          noteOutputs: 14,
+          sourceTrees: 1,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 3164
+        },
+        circuit: {
+          circuitName: "transact_user_slots56",
+          target: "evm",
+          artifactSha256: "ba83ec2f177d16fa88ea04bc54f2e99920f1ac195cdb05b88b9b3bbc245fd953",
+          vkSha256: "6ad5d3aff0c72a632fb19895658af093a6a92478a9994985e838a71e61237720"
+        },
+        samples: [
+          {
+            gasUsed: "2489010",
+            transactionHash: "0x053557acea930a869d6469c91e9bc015d0893607a6ab18d2af684986f7074676",
+            blockNumber: "49",
+            blockHash: "0x734873097eb5e4cb66bfc2cdb61fac6753b53a4b9450fb22895281100af3aaf3",
+            calldataBytes: 17156
+          },
+          {
+            gasUsed: "2489106",
+            transactionHash: "0xb3990edb994011775e275bc1eb38c527b7206a2bfadf510e8aa53e260f3594b8",
+            blockNumber: "49",
+            blockHash: "0xf8cb019ebb0ecd0ec5d6634198292883c63fe93a7c65c34f9f3120c6cc54f1cf",
+            calldataBytes: 17156
+          },
+          {
+            gasUsed: "2489094",
+            transactionHash: "0xc97079019567ff8a79d285421351ee4bc48d14092a0e12ff634151719e991088",
+            blockNumber: "49",
+            blockHash: "0x5a6947839165c8961eeeb9190331415c40366a78b4a6a5771e7b8954dbb8b3c7",
+            calldataBytes: 17156
+          }
+        ]
+      },
+      {
+        id: "transfer-1x56",
+        shape: {
+          kind: "transfer",
+          target: "evm",
+          capacity: 112,
+          noteInputs: 1,
+          noteOutputs: 56,
+          sourceTrees: 1,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 12656
+        },
+        circuit: {
+          circuitName: "transact_user_slots112",
+          target: "evm",
+          artifactSha256: "713b78469b6e97711122210f8497942120c1c9d66d3604bc184566c4eba59cc3",
+          vkSha256: "d6a46e297949c28b9a62fd9aef1f202870fdca97b8bfb15beefd27b9e9f3d86e"
+        },
+        samples: [
+          {
+            gasUsed: "5389227",
+            transactionHash: "0xb820d3c358724c1d64422017f232d074e4ff1ffaf1b1ce5ee719409427cf2208",
+            blockNumber: "49",
+            blockHash: "0x474bd1e52457801d1a596a9f23aeb6d365a17be028ee0c8cf8fd4758eaa1106b",
+            calldataBytes: 36356
+          },
+          {
+            gasUsed: "5389095",
+            transactionHash: "0x16514d8cf1136d7a7f40591859e2ea2d256af66520498e1fc81eb28837db600d",
+            blockNumber: "49",
+            blockHash: "0x42314a0d6eb9e765869e1b66b279444c78f919d2c28aed544d9fa7ac3bd2acb4",
+            calldataBytes: 36356
+          },
+          {
+            gasUsed: "5389203",
+            transactionHash: "0xee69d565a7eafb60ad7a47afe80a49d4fa40b50660669d9141e7dc6f4c3dbe0d",
+            blockNumber: "49",
+            blockHash: "0x0dcdada663ee04dd63e06fcdb79dacc5623201d29b687f63deede2b4762a994e",
+            calldataBytes: 36356
+          }
+        ]
+      },
+      {
+        id: "transfer-1x112",
+        shape: {
+          kind: "transfer",
+          target: "evm",
+          capacity: 168,
+          noteInputs: 1,
+          noteOutputs: 112,
+          sourceTrees: 1,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 25312
+        },
+        circuit: {
+          circuitName: "transact_user_slots168",
+          target: "evm",
+          artifactSha256: "f7b3b1384e961367702f544299ca3521d8205fac31b7691c45ff84325d5a31c3",
+          vkSha256: "e00181533d7e35d2307570528f9e7f8f88e2909b6ae338d93373b608dea96881"
+        },
+        samples: [
+          {
+            gasUsed: "9139842",
+            transactionHash: "0x09951c4e00b868b6660429d187a482004646e4c84ef341d3b98352c249db6a06",
+            blockNumber: "49",
+            blockHash: "0xba9da3c08189335acff1eb33554f5f12475e4a6510324cf6ec9eadf340ce15d2",
+            calldataBytes: 61444
+          },
+          {
+            gasUsed: "9139650",
+            transactionHash: "0xb06f69d1c6e5406758918d5d296ab889bab4c3814f616cc581ad312cc7ebb2f3",
+            blockNumber: "49",
+            blockHash: "0x5516a76b4b366f2e539a67bb848b7d232c3e6f328d34ca5bd3dba43a14c316bf",
+            calldataBytes: 61444
+          },
+          {
+            gasUsed: "9139530",
+            transactionHash: "0x116c4875b7712b7cb51cdb0fcb6e66a95733dca272aa272bc0b1fd265edbe26c",
+            blockNumber: "49",
+            blockHash: "0xd36340fddd1eace21b73f785c6589bf73b07bef782f2e78a5e3d3d828b0b607c",
+            calldataBytes: 61444
+          }
+        ]
+      },
+      {
+        id: "withdraw-1x1",
+        shape: {
+          kind: "withdraw",
+          target: "evm",
+          capacity: 14,
+          noteInputs: 1,
+          noteOutputs: 1,
+          sourceTrees: 1,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 226
+        },
+        circuit: {
+          circuitName: "transact_user_slots14",
+          target: "evm",
+          artifactSha256: "2a6a20839e90b88b1ecd629f59a01821bad3ee11dbe04db1fd9cdce7a3de0e84",
+          vkSha256: "ffe0e1a4e690792ecb4eb1fc1acc9ff60f13d3b5af03cfc6ae6d6bf26e99bdea"
+        },
+        samples: [
+          {
+            gasUsed: "1597571",
+            transactionHash: "0x326892d32146e0bc36b396fd3973151a629312df68ed25a4ffbb6a3da23ba274",
+            blockNumber: "49",
+            blockHash: "0x3e0f326cba3dd019b86431b4c22145758a7f10c121a696a81a094746b04495b5",
+            calldataBytes: 10564
+          },
+          {
+            gasUsed: "1597715",
+            transactionHash: "0x2e3a15157ac9c07e4717bbd4641481ce3bc0068d26157752815b6ec6b30acdd0",
+            blockNumber: "49",
+            blockHash: "0xab7fceac97d55e8702d1202b98d3a05c4b1e0f71e51b6d88d7e80e91cc338596",
+            calldataBytes: 10564
+          },
+          {
+            gasUsed: "1597595",
+            transactionHash: "0x5052e94a67520c43416cdcb60a1365a126560861173d0eef46bcbf0a566fe947",
+            blockNumber: "49",
+            blockHash: "0x9a64cf76b646b5a07b72fcc61266e87f17365fec891701c331982a93e5ba9b89",
+            calldataBytes: 10564
+          }
+        ]
+      },
+      {
+        id: "sweep-1x0",
+        shape: {
+          kind: "sweep",
+          target: "evm",
+          capacity: 14,
+          noteInputs: 1,
+          noteOutputs: 0,
+          sourceTrees: 1,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 0
+        },
+        circuit: {
+          circuitName: "transact_user_slots14",
+          target: "evm",
+          artifactSha256: "2a6a20839e90b88b1ecd629f59a01821bad3ee11dbe04db1fd9cdce7a3de0e84",
+          vkSha256: "ffe0e1a4e690792ecb4eb1fc1acc9ff60f13d3b5af03cfc6ae6d6bf26e99bdea"
+        },
+        samples: [
+          {
+            gasUsed: "1069308",
+            transactionHash: "0xb1ab469d05ca5f49659f54a332cc172892dcce37e475342fbf52fa9cfb4d3927",
+            blockNumber: "49",
+            blockHash: "0xe5b04579149987198801f1ca19ab771d5262de2aaf9861a6c962d50d1c6baef0",
+            calldataBytes: 10116
+          },
+          {
+            gasUsed: "1069284",
+            transactionHash: "0xd6adee997f7e1e19e3918f913f6ee48d94df69c09ed74e333325023089e7f6df",
+            blockNumber: "49",
+            blockHash: "0xcb225566f8f1ea6ae8da30158b8f1aef03d50fa4ea352a00aa42b7f41a05d63c",
+            calldataBytes: 10116
+          },
+          {
+            gasUsed: "1069308",
+            transactionHash: "0xe06dd7f3a2718bc9a9412c2d6f505960ce225b2e5fe6c1c66bb5b0e8f427006f",
+            blockNumber: "49",
+            blockHash: "0x37a08c5918892e1c19df017c746ab0ede03c1bb195c3be593d70c1f9de91897e",
+            calldataBytes: 10116
+          }
+        ]
+      },
+      {
+        id: "create-credit-1x1",
+        shape: {
+          kind: "create-credit",
+          target: "evm",
+          capacity: 10,
+          noteInputs: 1,
+          noteOutputs: 1,
+          sourceTrees: 1,
+          creditInputs: 0,
+          creditOutputs: 1,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 1162
+        },
+        circuit: {
+          circuitName: "create_credit",
+          target: "evm",
+          artifactSha256: "ab97cd5a036851a9748a5cfd8e6f9834e23090c8e95db4531aabfc37d3abb353",
+          vkSha256: "fac0e65b768a28750323cca851990598af936611125b6cfa3f5c16b04c7d084f"
+        },
+        samples: [
+          {
+            gasUsed: "1627325",
+            transactionHash: "0x7763d93a5b1e8797b5f4af2e1e5b1bb029a8b0f9f7b90bcc04f581947d826803",
+            blockNumber: "49",
+            blockHash: "0x93e51ae5e99c68dc642693d478e444330d8e26255ff5bb9aafc4a3f4e70d3a45",
+            calldataBytes: 11940
+          },
+          {
+            gasUsed: "1627385",
+            transactionHash: "0xe246d59cafa2a26dddf21c8385dd843be4d4596388ebe23e936df84e7f906635",
+            blockNumber: "49",
+            blockHash: "0x3c24b2d6ed2a998562d34b49e0517515742a9b39d59aec38a9ac6b22be1b694b",
+            calldataBytes: 11940
+          },
+          {
+            gasUsed: "1627157",
+            transactionHash: "0x2f7ed0b75435cc6a820d0cd90fd82d362f74787057413722b6eb3c6e37db87d3",
+            blockNumber: "49",
+            blockHash: "0x0a0301670b46017da772800c68bb941245ac1941c79fde9c85717632154e15ee",
+            calldataBytes: 11940
+          }
+        ]
+      },
+      {
+        id: "draw-credit-1-partial",
+        shape: {
+          kind: "draw-credit",
+          target: "evm",
+          capacity: 1,
+          noteInputs: 0,
+          noteOutputs: 0,
+          sourceTrees: 1,
+          creditInputs: 1,
+          creditOutputs: 1,
+          creditRemainders: 1,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 936
+        },
+        circuit: {
+          circuitName: "credit_draw_slots1",
+          target: "evm",
+          artifactSha256: "f5e458790948f37a61a833fad52cf2cc3b26a59515d271de32e0caaa4e229eb5",
+          vkSha256: "613699a440f50a0937e4c57e5152b5fdea42c31b10157d6b93226fef313df553"
+        },
+        samples: [
+          {
+            gasUsed: "1581294",
+            transactionHash: "0xd438e22b0fa07a657279f182537e4996f1936f0881d5b7d637845f8ca2808aab",
+            blockNumber: "49",
+            blockHash: "0x9e384a3054530b1ff237a639bca1a559afb2b73b30e21c262aac85ebf480fc9b",
+            calldataBytes: 11396
+          },
+          {
+            gasUsed: "1581402",
+            transactionHash: "0xa70ac3e7284b6e98f8591a6ba88e4ddfb23ecbd05343641d0532f34920e10b56",
+            blockNumber: "49",
+            blockHash: "0x37c5eb34ce96a841e96c36103a7ab65c1a3e08603dc9843efb0c0752c069f1d4",
+            calldataBytes: 11396
+          },
+          {
+            gasUsed: "1581174",
+            transactionHash: "0xd062494979d0bc0e284ccb070f87b48f3e8e5befb6001f15a006dd2a4a72ca24",
+            blockNumber: "49",
+            blockHash: "0x12840d920f14163b2d29491f28cee616e1bb9fd9514a4debe10ae35256345fc1",
+            calldataBytes: 11396
+          }
+        ]
+      },
+      {
+        id: "top-up-credit-1x1",
+        shape: {
+          kind: "top-up-credit",
+          target: "evm",
+          capacity: 10,
+          noteInputs: 1,
+          noteOutputs: 1,
+          sourceTrees: 2,
+          creditInputs: 1,
+          creditOutputs: 1,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 1162
+        },
+        circuit: {
+          circuitName: "credit_top_up",
+          target: "evm",
+          artifactSha256: "ee9dbcf8be6f6c09478190996e90b1d39d4a10a00245950f69fc1d2c329c6e9b",
+          vkSha256: "0c369fec0469b60baebb3be650bad42f3ccae6f0ff139cce6ad9a3f451ed7513"
+        },
+        samples: [
+          {
+            gasUsed: "1666948",
+            transactionHash: "0x1403da01167962a4349d2655ea217bfcfc1a2390138bea0279792c44b4381dd2",
+            blockNumber: "49",
+            blockHash: "0xcb554ffcdb4afe5f6458e5d23ffbdd1fdbef9c23f982343065772c0b3e3dd633",
+            calldataBytes: 12100
+          },
+          {
+            gasUsed: "1666900",
+            transactionHash: "0x3b5e54f29e3f888a443526cf23ab9255b3f0c7adf1d0d127c16b85f4c6a324d9",
+            blockNumber: "49",
+            blockHash: "0xeb304df6bdd24b249cac3197b543b0eaa6381ed75ad812dff248f914864105ed",
+            calldataBytes: 12100
+          },
+          {
+            gasUsed: "1666780",
+            transactionHash: "0x81c5ef25268a719275cb3b80618c2af291e1f7b3f91d7e82cc26bc894a8c332a",
+            blockNumber: "49",
+            blockHash: "0xfa42070d6349fc8d559b8bd4ad0ee6b79089107540c4472b9e492b8f5a6bd3e4",
+            calldataBytes: 12100
+          }
+        ]
+      },
+      {
+        id: "cancel-credit-1",
+        shape: {
+          kind: "cancel-credit",
+          target: "evm",
+          capacity: 1,
+          noteInputs: 0,
+          noteOutputs: 0,
+          sourceTrees: 1,
+          creditInputs: 1,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 0
+        },
+        circuit: {
+          circuitName: "credit_cancel",
+          target: "evm",
+          artifactSha256: "d332453a2b8c2c544747ac8d5f01912c9757f48d986226fd6a9b0e24d8321474",
+          vkSha256: "1f8a3c20cb081d6a90962556da3124919cc4e5675e59ad31562af39299da02fb"
+        },
+        samples: [
+          {
+            gasUsed: "998146",
+            transactionHash: "0x97bc72692d241e2c344b912804f9939061db5ef59cf4bb23922d93812e382160",
+            blockNumber: "49",
+            blockHash: "0x2e09df4df84a1c25961386febe8404531bb5da274836d50cc15a26c91b433a98",
+            calldataBytes: 9540
+          },
+          {
+            gasUsed: "998134",
+            transactionHash: "0x26c5067b12c2bc4b694070784e6b19d4855efa6e77c2422f0c6b1567f061570a",
+            blockNumber: "49",
+            blockHash: "0xdd3f20520c09e001374cab58387e52c82446db053539e30dad28b0de679a333c",
+            calldataBytes: 9540
+          },
+          {
+            gasUsed: "998230",
+            transactionHash: "0x5dc09445a405150da1445c22f50d6dd10d8d428a6a3f41ee90db7d3574657e31",
+            blockNumber: "49",
+            blockHash: "0x5c8f8223a50d2c8d48188a2db28ffa33c1b150a2fb465e99db4430949db3664b",
+            calldataBytes: 9540
+          }
+        ]
+      }
+    ]
+  }
+];
+
+// src/gas-estimation.ts
+var word2 = /^0x[0-9a-fA-F]{64}$/;
+var address = /^0x[0-9a-fA-F]{40}$/;
+var decimal = /^(0|[1-9][0-9]*)$/;
+var shapeKeys = [
+  "kind",
+  "target",
+  "capacity",
+  "noteInputs",
+  "noteOutputs",
+  "sourceTrees",
+  "creditInputs",
+  "creditOutputs",
+  "creditRemainders",
+  "funding",
+  "permit",
+  "deliveryBytes"
+];
+function copyGasBenchmarks(profiles) {
+  const copy = structuredClone([...profiles]);
+  for (const p of copy) {
+    if (p.formatVersion !== 1 || !p.id || !decimal.test(p.deployment.chainId) || !address.test(p.deployment.protocolAddress) || !address.test(p.deployment.tokenAddress) || !p.deployment.runtimeCodeHash || !word2.test(p.deployment.runtimeCodeHash) || p.source.verifier !== "real" || !/^[0-9a-f]{40}$/i.test(p.source.protocolCommit) || !p.source.measuredAt || !Array.isArray(p.source.assumptions) || !p.source.assumptions.every((assumption) => typeof assumption === "string") || !p.measurements.length)
+      throw new Error("invalid gas benchmark profile");
+    for (const m of p.measurements) {
+      if (!m.id || !m.samples.length || !["none", "caller", "signature"].includes(m.shape.funding) || typeof m.shape.permit !== "boolean")
+        throw new Error("invalid gas benchmark measurement");
+      for (const key of shapeKeys) {
+        const value = m.shape[key];
+        if (!["kind", "target", "funding", "permit"].includes(key) && (!Number.isSafeInteger(value) || Number(value) < 0))
+          throw new Error("invalid gas benchmark shape");
+      }
+      if (m.circuit && (![m.circuit.artifactSha256, m.circuit.vkSha256].every(
+        (hash2) => /^[a-f0-9]{64}$/i.test(hash2)
+      ) || !m.circuit.circuitName || !m.circuit.target))
+        throw new Error("invalid gas benchmark circuit identity");
+      const hashes = /* @__PURE__ */ new Set();
+      for (const sample of m.samples) {
+        if (typeof sample.gasUsed !== "string" || !decimal.test(sample.gasUsed) || BigInt(sample.gasUsed) <= 0n || !word2.test(sample.transactionHash) || !word2.test(sample.blockHash) || !decimal.test(sample.blockNumber) || !Number.isSafeInteger(sample.calldataBytes) || sample.calldataBytes < 0 || hashes.has(sample.transactionHash.toLowerCase()))
+          throw new Error("invalid gas benchmark receipt");
+        hashes.add(sample.transactionHash.toLowerCase());
+      }
+    }
+  }
+  return copy;
+}
+function defineGasBenchmarks(input) {
+  if (!Array.isArray(input)) throw new Error("invalid gas benchmark catalog");
+  try {
+    return copyGasBenchmarks(input);
+  } catch {
+    throw new Error("invalid gas benchmark catalog");
+  }
+}
+var defaultProfiles = defineGasBenchmarks(gas_benchmarks_default);
+function sameDeployment(a, b) {
+  return a.chainId === b.chainId && a.protocolAddress.toLowerCase() === b.protocolAddress.toLowerCase() && a.tokenAddress.toLowerCase() === b.tokenAddress.toLowerCase() && a.runtimeCodeHash?.toLowerCase() === b.runtimeCodeHash?.toLowerCase();
+}
+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();
+}
+function estimateBenchmarkGas(plan, protocol, profiles) {
+  const credit = plan.credit;
+  const deliveries = credit?.deliveries ?? plan.outputs.map((out) => out.delivery);
+  const request = {
+    deployment: {
+      chainId: plan.context.chainId.toString(),
+      protocolAddress: plan.context.protocolAddress,
+      runtimeCodeHash: protocol.expectedRuntimeCodeHash ?? null,
+      tokenAddress: plan.context.tokenAddress
+    },
+    shape: {
+      kind: plan.kind,
+      target: plan.statement?.target ?? "evm",
+      capacity: plan.capacity ?? 0,
+      noteInputs: plan.inputs.length,
+      noteOutputs: plan.outputs.length,
+      sourceTrees: operationSources(plan).length,
+      creditInputs: credit?.inputs.length ?? 0,
+      creditOutputs: credit?.outputs.length ?? 0,
+      creditRemainders: credit?.draw?.remainderCommitments.filter((hash2) => BigInt(hash2) !== 0n).length ?? 0,
+      funding: plan.fundingMode,
+      permit: (plan.funding.permit?.deadline ?? 0n) !== 0n,
+      deliveryBytes: deliveries.reduce(
+        (sum, d) => sum + (d.ciphertext.length - 2) / 2 + (d.clue.length - 2) / 2,
+        0
+      )
+    },
+    circuit: plan.statement ? {
+      circuitName: plan.statement.circuitName,
+      target: plan.statement.target,
+      artifactSha256: plan.statement.artifactSha256,
+      vkSha256: plan.statement.vkSha256
+    } : null
+  };
+  const base = { source: "benchmark", request };
+  if (request.shape.target === "noir-recursive")
+    return { ...base, available: false, reason: "recursive-member-only" };
+  const candidates = (profiles ?? defaultProfiles).filter(
+    (p) => sameDeployment(p.deployment, request.deployment)
+  );
+  if (!request.deployment.runtimeCodeHash || !candidates.length)
+    return { ...base, available: false, reason: "deployment-not-covered" };
+  for (const profile of candidates) {
+    const measurement = profile.measurements.find(
+      (m) => shapeKeys.every((key) => m.shape[key] === request.shape[key]) && sameCircuit(m.circuit, request.circuit)
+    );
+    if (!measurement) continue;
+    const gas = measurement.samples.map((sample) => BigInt(sample.gasUsed));
+    const count = BigInt(gas.length);
+    return {
+      ...base,
+      available: true,
+      gasUnits: (gas.reduce((sum, value) => sum + value, 0n) + count - 1n) / count,
+      range: {
+        min: gas.reduce((a, b) => a < b ? a : b),
+        max: gas.reduce((a, b) => a > b ? a : b),
+        kind: "observed"
+      },
+      samples: gas.length,
+      profileId: profile.id,
+      measurementId: measurement.id,
+      evidence: structuredClone(profile.source)
+    };
+  }
+  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"
+    );
+  }
+  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.find(
+    (measurement) => shapeKeys.every((key) => measurement.shape[key] === request.shape[key])
+  );
+  if (exact) {
+    const gas = exact.samples.map((sample) => BigInt(sample.gasUsed));
+    const count = BigInt(gas.length);
+    return { gasUnits: (gas.reduce((sum, value) => sum + value, 0n) + count - 1n) / count };
+  }
+  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 estimates = candidates.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;
+      }
+    }
+    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) };
+}
+function estimateGasReference(plan, protocol, profiles) {
+  const reference2 = estimateBenchmarkGas(plan, protocol, profiles);
+  if (reference2.available) return { gasUnits: reference2.gasUnits };
+  return estimateShapeGas(reference2.request);
+}
+
+// src/session/operation-execution.ts
+var import_ethers6 = require("ethers");
+var import_core3 = require("@invisi-labs/core");
+
+// src/session/proof-integrity.ts
+var import_ethers5 = require("ethers");
+var import_sha2562 = require("@noble/hashes/sha256");
+var import_utils2 = require("@noble/hashes/utils");
+function check4(ok, message) {
+  if (!ok) throw new Error(message);
+}
+function sameStatement(proof, expected) {
+  check4(
+    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"
+  );
+  check4(
+    proof.publicInputs.length === expected.expectedPublicInputs.length && proof.publicInputs.every((word4, i) => word4 === expected.expectedPublicInputs[i]),
+    "proof public statement mismatch"
+  );
+  check4(
+    /^0x(?:[a-fA-F0-9]{2})+$/.test(proof.proofHex) && (0, import_utils2.bytesToHex)((0, import_sha2562.sha256)((0, import_ethers5.getBytes)(proof.proofHex))) === proof.proofSha256,
+    "proof integrity mismatch"
+  );
+}
+
+// src/session/operation-execution.ts
+async function authorizeOperation(plan, provider) {
+  if (provider.walletIdentity !== plan.scope.walletIdentity)
+    throw new Error("wallet authorization capability mismatch");
+  const request = authorizationRequest(plan);
+  const digest = (0, import_core3.computeWalletAuthorizationDigest)(request);
+  const signed = await provider.authorize(structuredClone(request));
+  if (signed.walletIdentity !== plan.scope.walletIdentity || signed.digest !== digest)
+    throw new Error("wallet authorization statement mismatch");
+  return signed;
+}
+async function proveOperation(protocol, plan, authorization, prover, options) {
+  const request = await witnessFor(protocol, plan, authorization);
+  if (JSON.stringify({ ...request, witness: void 0 }) !== JSON.stringify(plan.statement))
+    throw new Error("prepared proof statement changed");
+  try {
+    const proof = publicProof(await prover.prove(request, options));
+    sameStatement(proof, plan.statement);
+    if (await prover.verify(
+      structuredClone(proof),
+      structuredClone(plan.statement),
+      options
+    ) !== true)
+      throw new Error("proof verification failed");
+    return proof;
+  } catch {
+    options.signal?.throwIfAborted();
+    throw new Error("operation proof generation or verification failed");
+  }
+}
+async function signOperationFunding(saved, signer, verifier) {
+  const payer = saved.plan.funding.payer;
+  if (signer.address.toLowerCase() !== payer.toLowerCase())
+    throw new Error("funding signer is not the payer");
+  const typed = await fundingTypedData(saved);
+  const signature = await signer.signTypedData(structuredClone(typed));
+  const valid = verifier ? await verifier.verifyTypedData({
+    ...structuredClone(typed),
+    address: payer,
+    signature
+  }) : (0, import_ethers6.verifyTypedData)(
+    typed.domain,
+    Object.fromEntries(
+      Object.entries(typed.types).map(([name, fields]) => [name, [...fields]])
+    ),
+    typed.message,
+    signature
+  ).toLowerCase() === payer.toLowerCase();
+  if (valid !== true) throw new Error("invalid EVM funding signature");
+  return signature;
+}
+
+// src/session/operation-preview.ts
+function operationPreview(plan, status) {
+  const p = plan;
+  return {
+    id: p.id,
+    kind: p.kind,
+    status,
+    context: { ...p.context },
+    inputs: inputFacts(p).length,
+    creditOutputs: p.credit?.outputs.map((output) => ({
+      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) => ({
+      to: output.address,
+      amount: output.note.amount,
+      change: output.change
+    })),
+    capacity: p.capacity,
+    deadline: p.deadline,
+    fundingAmount: p.funding.amount ?? 0n,
+    fundingPayer: p.funding.payer,
+    withdrawalAmount: p.params?.withdrawalAmount ?? p.credit?.draw?.totalAmount ?? p.credit?.cancel?.amount ?? 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
+var import_core7 = require("@invisi-labs/core");
+var import_protocol4 = require("@invisi-labs/protocol");
+
+// src/session/operation-confirmation.ts
+var import_core6 = require("@invisi-labs/core");
+
+// src/session/aggregate-receipt.ts
+var import_ethers7 = require("ethers");
+var import_contracts3 = require("@invisi-labs/protocol/contracts");
+var import_protocol3 = require("@invisi-labs/protocol");
+var aggregateAbi = import_contracts3.invisiProtocolAbi.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 import_ethers7.Interface(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) => (0, import_protocol3.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 = (0, import_protocol3.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/credit-values.ts
+var import_core4 = require("@invisi-labs/core");
+async function creditLeaf(state) {
+  const n = state.note;
+  return (0, import_core4.computeCreditCommitment)(
+    n.chainId,
+    n.spenderWalletIdentity,
+    n.ownerWalletIdentity,
+    n.spenderPayout,
+    n.ownerPayout,
+    n.tokenAddress,
+    n.amount,
+    n.nonce,
+    n.expiry,
+    await (0, import_core4.computeCreditSharedKeyHash)(n.creditSharedKey)
+  );
+}
+
+// src/session/membership.ts
+var import_core5 = require("@invisi-labs/core");
+async function verifyMembership(reader, context, block, input, proof) {
+  if (proof.block.hash !== block.hash || proof.block.number !== block.number || proof.leaf !== input.commitment || proof.treeId !== input.treeId || proof.leafIndex !== input.leafIndex || proof.path.length !== 16 || !Number.isInteger(input.leafIndex) || input.leafIndex < 0 || input.leafIndex >= 65536 || !await reader.isKnownRoot(context, input.treeId, proof.root, block))
+    throw new Error("membership context/root mismatch");
+  let root = BigInt(input.commitment);
+  for (let i = 0; i < 16; i++) {
+    const sibling = proof.path[i];
+    if (typeof sibling !== "bigint" || sibling < 0n || sibling >= import_core5.FIELD_MODULUS)
+      throw new Error("noncanonical membership path");
+    root = BigInt(
+      await (0, import_core5.poseidonHash)(input.leafIndex >> i & 1 ? [sibling, root] : [root, sibling])
+    );
+  }
+  if (root !== BigInt(proof.root))
+    throw new Error("membership path does not produce canonical root");
+}
+
+// src/session/operation-confirmation.ts
+function check5(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) {
+  check5(!state.invalidated, "wallet requires canonical resync");
+  const record = state.operations[id];
+  const saved = record?.payload;
+  check5(record && saved.generation === generation && !saved.claim, "stale operation recovery");
+  return { record, saved };
+}
+function observe(state, block) {
+  if (state.observedThrough?.number === block.number) {
+    check5(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;
+  }
+  check5(receipt.transactionHash === hash2, "receipt transaction identity mismatch");
+  await barrier(runtime, state, receipt.block);
+  const transaction = await reader.getTransaction(hash2);
+  check5(
+    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();
+  }
+  check5(matchesRequest, "confirmed transaction differs from the frozen operation");
+  check5(
+    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);
+  check5(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
+    );
+    check5(candidate, "confirmed output is missing from canonical receipt");
+    if (output.note.walletIdentity !== scope.walletIdentity) {
+      continue;
+    }
+    const input = {
+      treeId: candidate.treeId,
+      leafIndex: candidate.leafIndex,
+      commitment: candidate.commitment
+    };
+    check5(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.walletIdentity) {
+        continue;
+      }
+      const candidate = candidates.find(
+        (value) => value.role === role && value.commitment === output.commitment
+      );
+      check5(candidate, "confirmed Credit output is missing from canonical receipt");
+      const input = {
+        treeId: candidate.treeId,
+        leafIndex: candidate.leafIndex,
+        commitment: candidate.commitment
+      };
+      check5(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) => (0, import_core6.computeCreditNullifier)(
+          plan.context.chainId,
+          record.state.note.creditSharedKey,
+          await creditLeaf(record.state)
+        )
+      )
+    );
+    const values = await reader.isSpent(plan.context, nullifiers, spentBlock);
+    check5(
+      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) : [];
+  check5(
+    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
+    );
+    check5(
+      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]) {
+      check5(
+        !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) };
+  });
+}
+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) : [];
+  check5(
+    spent.length === nfs.length && spent.every((value) => typeof value === "boolean"),
+    "invalid reconciliation spent-state response"
+  );
+  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)
+    ]) {
+      check5(
+        !point || point.number < block.number || point.number === block.number && point.hash === block.hash,
+        "wallet advanced or changed during reconciliation; retry"
+      );
+    }
+    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";
+    }
+    next.generation++;
+    return { status: active.status, saved: structuredClone(next) };
+  });
+}
+
+// src/session/Operation.ts
+function check6(ok, message) {
+  if (!ok) {
+    throw new Error(message);
+  }
+}
+var Operation = class _Operation {
+  #runtime;
+  #saved;
+  #authorization;
+  status;
+  constructor(runtime, saved, status, authorization) {
+    this.#runtime = runtime;
+    this.#saved = structuredClone(saved);
+    this.status = status;
+    this.#authorization = authorization;
+    Object.freeze(this);
+  }
+  static async prepare(runtime, plan) {
+    const saved = { plan: structuredClone(plan), generation: 0 };
+    await runtime.store.transaction(runtime.scope, (state) => {
+      check6(!state.invalidated, "wallet state requires canonical resync");
+      check6(!state.operations[plan.id], "operation already exists");
+      const facts = inputFacts(plan);
+      for (const input of facts) {
+        const record = state[input.kind][input.key];
+        check6(
+          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];
+      check6(record, "unknown operation");
+      const saved = record.payload;
+      check6(
+        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;
+      check6(
+        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);
+      check6(
+        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;
+  }
+  get id() {
+    return this.#saved.plan.id;
+  }
+  get kind() {
+    return this.#saved.plan.kind;
+  }
+  estimateGas() {
+    return estimateGasReference(
+      this.#saved.plan,
+      this.#runtime.options.protocol,
+      this.#runtime.options.gasBenchmarks
+    );
+  }
+  preview() {
+    return operationPreview(this.#saved.plan, this.status);
+  }
+  current(record) {
+    check6(record, "unknown operation");
+    const saved = record.payload;
+    check6(
+      saved.generation === this.#saved.generation && !saved.claim,
+      "stale operation handle or active worker; recover the operation"
+    );
+    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) => {
+      check6(!state.invalidated, "wallet requires canonical resync");
+      const record = state.operations[this.id];
+      const current2 = this.current(record);
+      check6(allowed.includes(record.status), `invalid operation stage for ${stage}`);
+      current2.generation++;
+      current2.claim = { stage, token };
+      return structuredClone(current2);
+    });
+    try {
+      const next = await work(saved);
+      signal?.throwIfAborted();
+      await store.transaction(scope, (state) => {
+        check6(!state.invalidated, "wallet invalidated during operation");
+        const record = state.operations[this.id];
+        const current2 = record?.payload;
+        check6(
+          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(
+        this.#runtime,
+        saved,
+        next.status,
+        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;
+    }
+  }
+  async authorize(options = {}) {
+    check6(
+      requiresAuthorization(this.#saved.plan),
+      "operation does not require wallet authorization"
+    );
+    const provider = this.#runtime.authorization();
+    check6(
+      provider.walletIdentity === this.#runtime.scope.walletIdentity,
+      "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(options = {}) {
+    const plan = this.#saved.plan;
+    check6(plan.kind !== "shield", "shield requires no proof");
+    if (requiresAuthorization(plan)) {
+      check6(
+        this.#authorization,
+        "local wallet authorization required; authorize again after recovery"
+      );
+    }
+    const prover = this.#runtime.options.prover;
+    if (!prover) {
+      throw new import_core7.MissingCapabilityError("prover");
+    }
+    return this.stage(
+      "proof",
+      requiresAuthorization(plan) ? ["authorized"] : ["prepared"],
+      async (saved) => {
+        const p = saved.plan;
+        saved.proof = await proveOperation(
+          this.#runtime.options.protocol,
+          p,
+          this.#authorization,
+          prover,
+          options
+        );
+        if (p.fundingMode === "signature") {
+          return { status: "proved" };
+        }
+        if (p.statement?.target !== "noir-recursive") {
+          saved.call = await this.encode(saved);
+        }
+        return { status: "ready" };
+      },
+      options.signal
+    );
+  }
+  encode(saved) {
+    return encodeOperation(saved);
+  }
+  async authorizeFunding(options = {}) {
+    const p = this.#saved.plan;
+    check6(p.fundingMode === "signature", "operation does not require a funding signature");
+    check6(p.kind === "shield" || this.#saved.proof, "proof must precede funding authorization");
+    const signer = this.#runtime.options.fundingSigner;
+    if (!signer) {
+      throw new import_core7.MissingCapabilityError("EVM funding signer");
+    }
+    check6(
+      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);
+        }
+        return { status: "ready" };
+      },
+      options.signal
+    );
+  }
+  /** Shield caller funding needs no wallet signing or proof; this step only encodes its frozen request. */
+  async ready() {
+    check6(
+      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 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;
+    check6(!operationExpired(plan, head.timestamp), "operation has expired");
+    if (plan.fundingMode === "signature") {
+      check6(head.timestamp <= (plan.funding.deadline ?? 0n), "funding authorization expired");
+      check6(
+        await reader.getFundingNonce(plan.context, plan.funding.payer, head) === plan.funding.sigNonce,
+        "funding nonce changed; prepare again"
+      );
+    }
+    for (const source of operationSources(plan)) {
+      check6(
+        await reader.isKnownRoot(plan.context, source.treeId, source.merkleRoot, head),
+        "source root is no longer accepted; prepare again"
+      );
+    }
+    const nullifiers = inputFacts(plan).map((input) => input.nullifier);
+    if (nullifiers.length) {
+      const spent = await reader.isSpent(plan.context, nullifiers, head);
+      check6(
+        spent.length === nullifiers.length && spent.every((value) => value === false),
+        "input spent or invalid spent response"
+      );
+    }
+    signal?.throwIfAborted();
+  }
+  async exportTransaction(options = {}) {
+    check6(
+      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);
+      check6(record.status === "ready" && saved.call, "operation is not ready");
+      saved.externalized = true;
+      return structuredClone(saved.call);
+    });
+    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;
+      check6(
+        ["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));
+      check6(
+        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: (0, import_protocol4.normalizeFunding)(plan.funding)
+        }
+      };
+    });
+  }
+  async abandon() {
+    const saved = await this.#runtime.store.transaction(this.#runtime.scope, (state) => {
+      const record = state.operations[this.id];
+      const current2 = this.current(record);
+      check6(
+        !current2.externalized,
+        "externalized or broadcast operation requires chain reconciliation"
+      );
+      check6(
+        !["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);
+    });
+    return new _Operation(this.#runtime, saved, "failed");
+  }
+  /** Record an application-owned signed/broadcast transaction. This never sends or waits. */
+  async trackTransaction(transactionHash) {
+    check6(/^0x[a-fA-F0-9]{64}$/.test(transactionHash), "invalid transaction hash");
+    const saved = await this.#runtime.store.transaction(this.#runtime.scope, (state) => {
+      check6(!state.invalidated, "wallet requires canonical resync");
+      const record = state.operations[this.id];
+      const current2 = this.current(record);
+      check6(
+        ["ready", "uncertain", "submitted"].includes(record.status),
+        "operation is not ready"
+      );
+      check6(
+        current2.externalized,
+        "export the transaction or aggregate member before tracking"
+      );
+      for (const input of record.inputs) {
+        check6(state.reservations[input] === this.id, "operation input reservation lost");
+      }
+      current2.generation++;
+      current2.externalized = true;
+      record.transactionHash = transactionHash;
+      record.status = "uncertain";
+      return structuredClone(current2);
+    });
+    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);
+    check6(!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);
+  }
+  toJSON() {
+    return { id: this.id, kind: this.kind, status: this.status };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+};
+
+// src/session/WalletSession.ts
+var import_ethers11 = require("ethers");
+var import_core12 = require("@invisi-labs/core");
+
+// src/session/transaction-preparation.ts
+var import_ethers10 = require("ethers");
+var import_protocol7 = require("@invisi-labs/protocol");
+
+// src/session/prepare-common.ts
+var import_ethers8 = require("ethers");
+var import_core8 = require("@invisi-labs/core");
+var import_protocol5 = require("@invisi-labs/protocol");
+
+// src/session/selection.ts
+function selectNotes(notes, target, reserved) {
+  if (typeof target !== "bigint" || target < 0n)
+    throw new Error("selection target must be a nonnegative amount");
+  if (target === 0n) return [];
+  const eligible = notes.filter(
+    (note) => note.spent === "unspent" && !reserved.has(note.commitment)
+  );
+  for (const record of eligible)
+    if (typeof record.note.amount !== "bigint" || record.note.amount <= 0n || record.note.amount >= 1n << 128n)
+      throw new Error("invalid verified note amount");
+  eligible.sort(
+    (a, b) => a.note.amount > b.note.amount ? -1 : a.note.amount < b.note.amount ? 1 : a.treeId < b.treeId ? -1 : a.treeId > b.treeId ? 1 : a.leafIndex - b.leafIndex || a.commitment.localeCompare(b.commitment)
+  );
+  const selected = [];
+  let total = 0n;
+  for (const record of eligible) {
+    selected.push(structuredClone(record));
+    total += record.note.amount;
+    if (total >= target) return selected;
+  }
+  throw new Error("insufficient verified available funds");
+}
+
+// src/session/prepare-common.ts
+function positiveAmount(value, bits = 128) {
+  if (typeof value !== "bigint" || value <= 0n || value >= 1n << BigInt(bits)) {
+    throw new Error(`amount must be a positive uint${bits}`);
+  }
+  return value;
+}
+var Preparation = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  #roots = /* @__PURE__ */ new Map();
+  async frame(requested) {
+    const { reader, options } = this.runtime;
+    await options.protocol.validateDeployment(reader);
+    const block = await reader.getBlock(await reader.getLatestBlockNumber());
+    const deadline = requested ?? block.timestamp + (options.transactionTTL ?? 300n);
+    if (typeof deadline !== "bigint" || deadline < block.timestamp || deadline >= 1n << 64n) {
+      throw new Error("invalid transaction deadline");
+    }
+    const state = await this.runtime.readInventory();
+    if (state.invalidated) {
+      throw new Error("wallet requires canonical resync");
+    }
+    for (const point of [state.observedThrough]) {
+      if (point && (await reader.getBlock(point.number)).hash !== point.hash) {
+        throw new Error("canonical wallet checkpoint changed; resync required");
+      }
+    }
+    return { context: { ...options.protocol.context, now: block.timestamp }, block, deadline };
+  }
+  async assertBlock(frame) {
+    if ((await this.runtime.reader.getBlock(frame.block.number)).hash !== frame.block.hash) {
+      throw new Error("canonical block changed while preparing");
+    }
+  }
+  async funding(source, frame) {
+    if (!source) {
+      return { funding: {}, fundingMode: "none" };
+    }
+    positiveAmount(source.amount);
+    const payer = (0, import_ethers8.getAddress)(source.payer);
+    const mode = source.authorization ?? "signature";
+    if (BigInt(payer) === 0n) {
+      throw new Error("funding payer must be nonzero");
+    }
+    if (mode !== "signature" && mode !== "caller") {
+      throw new Error("invalid funding authorization mode");
+    }
+    if (mode === "caller" && (source.sigNonce || source.deadline)) {
+      throw new Error("caller funding uses zero nonce/deadline");
+    }
+    const funding = (0, import_protocol5.normalizeFunding)({
+      payer,
+      amount: source.amount,
+      sigNonce: mode === "caller" ? 0n : source.sigNonce ?? await this.runtime.reader.getFundingNonce(
+        frame.context,
+        payer,
+        frame.block
+      ),
+      deadline: mode === "caller" ? 0n : source.deadline ?? frame.deadline,
+      ...source.permit ? { permit: structuredClone(source.permit) } : {}
+    });
+    if (mode === "signature" && funding.deadline < frame.block.timestamp) {
+      throw new Error("funding authorization deadline has expired");
+    }
+    return { funding, fundingMode: mode };
+  }
+  async output(payment, context, change = false) {
+    positiveAmount(payment.amount);
+    const recipient = await import_core8.ReceivingAddress.parse(payment.to).resolve(
+      this.runtime.options.addressResolver
+    );
+    const nonce = (0, import_core8.generateNonce)();
+    const identity = await (0, import_core8.computeNoteIdentity)(BigInt(recipient.walletIdentity), nonce);
+    const keys = recipient.getReceivingKeys();
+    const note = {
+      chainId: context.chainId,
+      protocolAddress: BigInt(context.protocolAddress),
+      tokenAddress: BigInt(context.tokenAddress),
+      walletIdentity: recipient.walletIdentity,
+      amount: payment.amount,
+      nonce
+    };
+    const commitment = await (0, import_core8.computeNoteCommitment)(
+      context.chainId,
+      identity,
+      note.tokenAddress,
+      note.amount
+    );
+    return {
+      note,
+      commitment,
+      identity,
+      address: payment.to,
+      change,
+      delivery: {
+        ciphertext: (0, import_ethers8.hexlify)(
+          await (0, import_core8.encryptPrivateTransferNote)(keys.viewingPublicKey, note, {
+            chainId: context.chainId,
+            protocolAddress: note.protocolAddress,
+            outputCommitment: commitment
+          })
+        ),
+        clue: (0, import_ethers8.hexlify)((0, import_core8.createClue)(keys.clueKey))
+      }
+    };
+  }
+  async membership(input, frame) {
+    const { options, reader } = this.runtime;
+    if (!options.protocolRpc)
+      throw new import_core8.MissingCapabilityError("Protocol RPC membership provider");
+    const root = this.#roots.get(input.treeId);
+    const proof = await options.protocolRpc.getMembership(
+      frame.context,
+      {
+        ...input,
+        ...root ? { root } : {}
+      },
+      frame.block
+    );
+    if (root && proof.root !== root)
+      throw new Error("membership provider changed the pinned source root");
+    await verifyMembership(reader, frame.context, frame.block, input, proof);
+    this.#roots.set(input.treeId, proof.root);
+    return { ...proof, path: [...proof.path] };
+  }
+  async selectFunds(target, frame, maxInputs = 168) {
+    const { scope, options, reader } = this.runtime;
+    const state = await this.runtime.readInventory();
+    if (state.invalidated) {
+      throw new Error("wallet requires canonical resync");
+    }
+    const need = target > 0n ? target : 0n;
+    const nullifier = options.wallet.exportNullifier();
+    const reserved = new Set(Object.keys(state.reservations));
+    const eligible = Object.values(state.notes).filter(
+      (note) => note.note.tokenAddress === BigInt(frame.context.tokenAddress) && note.spent === "unspent" && !reserved.has(note.commitment)
+    );
+    const byId = new Map(eligible.map((note) => [note.commitment, note]));
+    const choices = this.runtime.inputSelection ? [...this.runtime.inputSelection] : this.runtime.explicitInputs ? eligible.map((note) => note.commitment) : need > 0n && options.coinSelector ? await options.coinSelector.select(storedCandidates(eligible), need) : selectNotes(eligible, need, reserved).map((note) => note.commitment);
+    if (!Array.isArray(choices) || new Set(choices).size !== choices.length || choices.some((id) => !byId.has(id))) {
+      throw new Error("invalid or duplicate coin selection");
+    }
+    const selected = choices.map((id) => structuredClone(byId.get(id)));
+    const amount = selected.reduce((sum, input) => sum + input.note.amount, 0n);
+    if (amount < need) {
+      throw new Error("coin selection has insufficient verified funds");
+    }
+    if (selected.length > maxInputs || amount >= 1n << 135n) {
+      throw new Error("coin selection exceeds transaction capacity");
+    }
+    const inputs = [];
+    const sources = /* @__PURE__ */ new Map();
+    const nullifiers = [];
+    for (const input of selected) {
+      const note = input.note;
+      const c = frame.context;
+      if (note.walletIdentity !== scope.walletIdentity || note.chainId !== c.chainId || note.protocolAddress !== BigInt(c.protocolAddress) || note.tokenAddress !== BigInt(c.tokenAddress) || await (0, import_core8.computeNoteCommitment)(
+        c.chainId,
+        await (0, import_core8.computeNoteIdentity)(BigInt(note.walletIdentity), note.nonce),
+        note.tokenAddress,
+        note.amount
+      ) !== input.commitment) {
+        throw new Error("selected input preimage/context mismatch");
+      }
+      const proof = await this.membership(input, frame);
+      const path = [...proof.path];
+      const root = proof.root;
+      if (sources.has(input.treeId) && sources.get(input.treeId) !== root) {
+        throw new Error("source roots do not share a canonical snapshot");
+      }
+      sources.set(input.treeId, root);
+      inputs.push({
+        note,
+        commitment: input.commitment,
+        treeId: input.treeId,
+        leafIndex: input.leafIndex,
+        path
+      });
+      nullifiers.push(
+        await nullifier.compute(c.chainId, input.commitment, input.note.nonce)
+      );
+    }
+    await this.assertUnspent(nullifiers, frame);
+    return {
+      inputs,
+      sources: [...sources].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([treeId, merkleRoot]) => ({ treeId, merkleRoot })),
+      nullifiers,
+      amount
+    };
+  }
+  async assertUnspent(nullifiers, frame) {
+    if (nullifiers.length) {
+      const spent = await this.runtime.reader.isSpent(frame.context, nullifiers, frame.block);
+      if (spent.length !== nullifiers.length || spent.some((value) => value !== false)) {
+        throw new Error("selected input spent or invalid spent-state response");
+      }
+    }
+  }
+};
+function storedCandidates(inputs) {
+  const records = inputs.filter(
+    (input) => "blockNumber" in input && typeof input.blockNumber === "bigint" && "blockHash" in input && typeof input.blockHash === "string"
+  );
+  if (records.length !== inputs.length)
+    throw new Error("custom coin selection requires stored receipt metadata");
+  return structuredClone(records);
+}
+
+// src/session/prepare-credit.ts
+var import_ethers9 = require("ethers");
+var import_core9 = require("@invisi-labs/core");
+var import_protocol6 = require("@invisi-labs/protocol");
+var EMPTY = { ciphertext: "0x", clue: "0x" };
+var CreditPreparation = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.#prepare = new Preparation(runtime);
+  }
+  #prepare;
+  expiry(value, frame) {
+    if (typeof value !== "bigint" || value <= frame.block.timestamp || value >= 1n << 64n) {
+      throw new Error("Credit expiry must be a future uint64 timestamp");
+    }
+    return value;
+  }
+  async seal(input, frame) {
+    const state = (0, import_core9.normalizeCreditDeliveryState)(input);
+    const commitment = await creditLeaf(state);
+    const context = {
+      chainId: frame.context.chainId,
+      protocolAddress: BigInt(frame.context.protocolAddress),
+      outputCommitment: commitment
+    };
+    const deliveries = await Promise.all(
+      ["owner", "spender"].map(async (role) => {
+        const keys = role === "owner" ? state.ownerReceivingKeys : state.spenderReceivingKeys;
+        return {
+          ciphertext: (0, import_ethers9.hexlify)(
+            await (0, import_core9.encryptCreditNote)(keys.viewingPublicKey, state, { ...context, role })
+          ),
+          clue: (0, import_ethers9.hexlify)((0, import_core9.createClue)(keys.clueKey))
+        };
+      })
+    );
+    return { state, commitment, deliveries };
+  }
+  async input(commitment, role, frame) {
+    const stored = (await this.runtime.readInventory()).credits[commitment + ":" + role];
+    if (!stored || stored.spent !== "unspent" || stored.role !== role) {
+      throw new Error(`confirmed unspent ${role} Credit is unavailable`);
+    }
+    const state = (0, import_core9.normalizeCreditDeliveryState)(stored.state);
+    const n = state.note;
+    if ((role === "owner" ? n.ownerWalletIdentity : n.spenderWalletIdentity) !== this.runtime.scope.walletIdentity || n.chainId !== frame.context.chainId || n.protocolAddress !== BigInt(frame.context.protocolAddress) || n.tokenAddress !== BigInt(frame.context.tokenAddress) || await creditLeaf(state) !== commitment) {
+      throw new Error("Credit role, commitment or deployment mismatch");
+    }
+    const proof = await this.#prepare.membership(stored, frame);
+    const path = [...proof.path];
+    const nullifier = await (0, import_core9.computeCreditNullifier)(n.chainId, n.creditSharedKey, commitment);
+    await this.#prepare.assertUnspent([nullifier], frame);
+    return {
+      input: {
+        state,
+        commitment,
+        role,
+        treeId: stored.treeId,
+        leafIndex: stored.leafIndex,
+        path
+      },
+      nullifier,
+      source: {
+        treeId: stored.treeId,
+        merkleRoot: proof.root
+      }
+    };
+  }
+  base(frame, kind) {
+    return {
+      version: 1,
+      id: crypto.randomUUID(),
+      kind,
+      context: frame.context,
+      scope: this.runtime.scope,
+      preparedAt: frame.block,
+      deadline: frame.deadline,
+      outputs: [],
+      inputs: [],
+      funding: {},
+      fundingMode: "none"
+    };
+  }
+  async create(options) {
+    positiveAmount(options.amount, 126);
+    const frame = await this.#prepare.frame(options.deadline);
+    const expiry = this.expiry(options.expiry, frame);
+    const spender = await import_core9.ReceivingAddress.parse(options.spender).resolve(
+      this.runtime.options.addressResolver
+    );
+    const owner = await this.runtime.options.wallet.getReceivingAddress().resolve(this.runtime.options.addressResolver);
+    const ownerPayout = (0, import_ethers9.getAddress)(owner.walletIdentity);
+    const spenderPayout = (0, import_ethers9.getAddress)(spender.walletIdentity);
+    if (BigInt(ownerPayout) === 0n || BigInt(spenderPayout) === 0n) {
+      throw new Error("Credit payouts must be nonzero");
+    }
+    const output = await this.seal(
+      {
+        note: {
+          chainId: frame.context.chainId,
+          protocolAddress: BigInt(frame.context.protocolAddress),
+          tokenAddress: BigInt(frame.context.tokenAddress),
+          ownerWalletIdentity: this.runtime.scope.walletIdentity,
+          spenderWalletIdentity: spender.walletIdentity,
+          ownerPayout: BigInt(ownerPayout),
+          spenderPayout: BigInt(spenderPayout),
+          amount: options.amount,
+          expiry,
+          nonce: (0, import_core9.generateNonce)(),
+          creditSharedKey: (0, import_core9.generateCreditSharedKey)()
+        },
+        ownerReceivingKeys: owner.getReceivingKeys(),
+        spenderReceivingKeys: spender.getReceivingKeys()
+      },
+      frame
+    );
+    return this.creation(
+      this.base(frame, "create-credit"),
+      output,
+      options.amount,
+      options.funding,
+      frame
+    );
+  }
+  async creation(plan, output, delta, fundingSource, frame, previous) {
+    const funding = await this.#prepare.funding(fundingSource, frame);
+    const selected = await this.#prepare.selectFunds(
+      delta - (funding.funding.amount ?? 0n),
+      frame,
+      10
+    );
+    const change = selected.amount + (funding.funding.amount ?? 0n) - delta;
+    plan.inputs = selected.inputs;
+    Object.assign(plan, funding);
+    if (change > 0n) {
+      plan.outputs.push(
+        await this.#prepare.output(
+          {
+            to: this.runtime.changeAddress ?? this.runtime.options.wallet.getReceivingAddress().toString(),
+            amount: change
+          },
+          frame.context,
+          true
+        )
+      );
+    }
+    const creation = {
+      token: frame.context.tokenAddress,
+      sources: selected.sources,
+      nullifiers: selected.nullifiers,
+      creditCommitment: output.commitment,
+      changeCommitment: plan.outputs[0]?.commitment ?? (0, import_protocol6.word)(0n),
+      owner: (0, import_ethers9.getAddress)((0, import_ethers9.toBeHex)(output.state.note.ownerPayout, 20)),
+      expiry: output.state.note.expiry,
+      deadline: frame.deadline
+    };
+    const deliveries = [...output.deliveries, plan.outputs[0]?.delivery ?? { ...EMPTY }];
+    plan.capacity = 10;
+    plan.credit = {
+      inputs: previous ? [previous.input] : [],
+      outputs: [output],
+      deliveries,
+      creation
+    };
+    if (previous) {
+      plan.credit.topUp = {
+        creation,
+        creditSource: previous.source,
+        creditNullifier: previous.nullifier,
+        previousExpiry: previous.input.state.note.expiry
+      };
+      plan.statement = import_protocol6.WitnessBuilder.statement(
+        "credit_top_up",
+        (0, import_protocol6.topUpCreditPublicInputs)(frame.context, plan.credit.topUp, deliveries, plan.funding)
+      );
+    } else {
+      plan.statement = import_protocol6.WitnessBuilder.statement(
+        "create_credit",
+        (0, import_protocol6.createCreditPublicInputs)(frame.context, creation, deliveries, plan.funding)
+      );
+    }
+    await this.#prepare.assertBlock(frame);
+    return this.runtime.complete(plan);
+  }
+  async topUp(options) {
+    positiveAmount(options.additionalAmount, 126);
+    const frame = await this.#prepare.frame(options.deadline);
+    const previous = await this.input(options.credit, "owner", frame);
+    const old = previous.input.state;
+    if (old.note.expiry <= frame.block.timestamp) {
+      throw new Error("previous Credit has expired");
+    }
+    const expiry = this.expiry(options.expiry ?? old.note.expiry, frame);
+    if (expiry < old.note.expiry) {
+      throw new Error("Credit expiry must not decrease");
+    }
+    const amount = positiveAmount(old.note.amount + options.additionalAmount, 126);
+    const output = await this.seal(
+      { ...old, note: { ...old.note, amount, expiry, nonce: (0, import_core9.generateNonce)() } },
+      frame
+    );
+    return this.creation(
+      this.base(frame, "top-up-credit"),
+      output,
+      options.additionalAmount,
+      options.funding,
+      frame,
+      previous
+    );
+  }
+  async draw(options) {
+    const frame = await this.#prepare.frame(options.deadline);
+    const profile = (0, import_protocol6.selectCreditDrawCircuit)(options.credits.length);
+    if (new Set(options.credits.map((value) => value.credit)).size !== options.credits.length) {
+      throw new Error("duplicate Credit input");
+    }
+    const members = await Promise.all(
+      options.credits.map((value) => this.input(value.credit, "spender", frame))
+    );
+    const payout = members[0].input.state.note.spenderPayout;
+    const sources = /* @__PURE__ */ new Map();
+    const outputs = [];
+    const deliveries = [];
+    const recoveryAmounts = [];
+    const remainders = [];
+    const amounts = [];
+    for (const [i, member] of members.entries()) {
+      const state = member.input.state;
+      const n = state.note;
+      const amount = positiveAmount(options.credits[i].amount, 126);
+      if (n.spenderPayout !== payout) {
+        throw new Error(
+          "Credit draw requires separate groups for different public payouts; one call must be atomic"
+        );
+      }
+      this.expiry(n.expiry, frame);
+      if (amount > n.amount) {
+        throw new Error("Credit draw exceeds remaining amount");
+      }
+      if (sources.has(member.source.treeId) && sources.get(member.source.treeId) !== member.source.merkleRoot) {
+        throw new Error("Credit source root mismatch");
+      }
+      sources.set(member.source.treeId, member.source.merkleRoot);
+      amounts.push(amount);
+      const remaining = n.amount - amount;
+      if (remaining === 0n) {
+        remainders.push((0, import_protocol6.word)(0n));
+        recoveryAmounts.push((0, import_protocol6.word)(0n));
+        deliveries.push({ ...EMPTY }, { ...EMPTY });
+        continue;
+      }
+      const args = [
+        n.chainId,
+        n.protocolAddress,
+        n.tokenAddress,
+        BigInt(member.nullifier),
+        n.creditSharedKey
+      ];
+      const output = await this.seal(
+        {
+          ...state,
+          note: {
+            ...n,
+            amount: remaining,
+            nonce: await (0, import_core9.deriveRemainderNonce)(...args)
+          }
+        },
+        frame
+      );
+      outputs.push(output);
+      remainders.push(output.commitment);
+      recoveryAmounts.push(
+        (0, import_protocol6.word)((remaining + await (0, import_core9.computeCreditRecoveryPad)(...args)) % import_core9.FIELD_MODULUS)
+      );
+      deliveries.push(...output.deliveries);
+    }
+    const plan = this.base(frame, "draw-credit");
+    const params = {
+      token: frame.context.tokenAddress,
+      sources: [...sources].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([treeId, merkleRoot]) => ({ treeId, merkleRoot })),
+      nullifiers: members.map((member) => member.nullifier),
+      remainderCommitments: remainders,
+      expiries: members.map((member) => member.input.state.note.expiry),
+      recoveryAmounts,
+      spender: (0, import_ethers9.getAddress)((0, import_ethers9.toBeHex)(payout, 20)),
+      totalAmount: amounts.reduce((sum, amount) => sum + amount, 0n),
+      deadline: frame.deadline
+    };
+    plan.capacity = profile.maxSize;
+    plan.credit = {
+      inputs: members.map((member) => member.input),
+      outputs,
+      deliveries,
+      draw: params,
+      amounts
+    };
+    plan.statement = import_protocol6.WitnessBuilder.statement(
+      profile.name,
+      (0, import_protocol6.creditDrawPublicInputs)(frame.context, params, deliveries)
+    );
+    await this.#prepare.assertBlock(frame);
+    return this.runtime.complete(plan);
+  }
+  async cancel(options) {
+    const frame = await this.#prepare.frame(options.deadline);
+    const previous = await this.input(options.credit, "owner", frame);
+    const n = previous.input.state.note;
+    const plan = this.base(frame, "cancel-credit");
+    const params = {
+      token: frame.context.tokenAddress,
+      source: previous.source,
+      nullifier: previous.nullifier,
+      owner: (0, import_ethers9.getAddress)((0, import_ethers9.toBeHex)(n.ownerPayout, 20)),
+      amount: n.amount,
+      deadline: frame.deadline
+    };
+    plan.capacity = 1;
+    plan.credit = { inputs: [previous.input], outputs: [], deliveries: [], cancel: params };
+    plan.statement = import_protocol6.WitnessBuilder.statement(
+      "credit_cancel",
+      (0, import_protocol6.cancelCreditPublicInputs)(frame.context, params)
+    );
+    await this.#prepare.assertBlock(frame);
+    return this.runtime.complete(plan);
+  }
+};
+
+// src/session/transaction-preparation.ts
+var TransactionPreparation = class {
+  constructor(context) {
+    this.context = context;
+  }
+  runtime(tokenAddress) {
+    if ((0, import_ethers10.getAddress)(tokenAddress) !== (0, import_ethers10.getAddress)(this.context.options.protocol.context.tokenAddress))
+      throw new Error("preparation token mismatch");
+    return this.context;
+  }
+  get scope() {
+    return this.context.scope;
+  }
+  async prepareTransfer(options) {
+    const copied = structuredClone(options);
+    const preparation = new Preparation(this.runtime(copied.tokenAddress));
+    const frame = await preparation.frame(copied.deadline);
+    if (copied.outputs.length < 1 || copied.outputs.length > 168) {
+      throw new Error("transfer requires 1..168 outputs");
+    }
+    const total = copied.outputs.reduce(
+      (sum, output) => sum + positiveAmount(output.amount),
+      0n
+    );
+    const funding = await preparation.funding(copied.funding, frame);
+    return this.funds(
+      "transfer",
+      copied.outputs,
+      total,
+      import_protocol7.ZERO_ADDRESS,
+      0n,
+      frame,
+      funding,
+      copied.target,
+      preparation
+    );
+  }
+  async prepareWithdraw(options) {
+    const copied = structuredClone(options);
+    const preparation = new Preparation(this.runtime(copied.tokenAddress));
+    const frame = await preparation.frame(copied.deadline);
+    const to = (0, import_ethers10.getAddress)(copied.to);
+    positiveAmount(copied.amount);
+    if (BigInt(to) === 0n) {
+      throw new Error("withdrawal destination must be nonzero");
+    }
+    return this.funds(
+      "withdraw",
+      [],
+      copied.amount,
+      to,
+      copied.amount,
+      frame,
+      { funding: {}, fundingMode: "none" },
+      copied.target,
+      preparation
+    );
+  }
+  /** Full payout to the note owner; no arbitrary destination, change or spending signature. */
+  async prepareSweep(options) {
+    const copied = structuredClone(options);
+    const runtime = this.runtime(copied.tokenAddress);
+    const state = await runtime.readInventory();
+    const available = Object.values(state.notes).filter(
+      (record) => record.note.tokenAddress === BigInt(copied.tokenAddress) && record.spent === "unspent" && !state.reservations[record.commitment]
+    );
+    const selected = copied.commitments ?? available.map((record) => record.commitment);
+    if (selected.length === 0) throw new Error("empty sweep input selection");
+    if (new Set(selected).size !== selected.length) throw new Error("duplicate sweep inputs");
+    const byId = new Map(available.map((record) => [record.commitment, record]));
+    let amount = 0n;
+    for (const id of selected) {
+      const record = byId.get(id);
+      if (!record) throw new Error("sweep input unavailable");
+      amount += record.note.amount;
+    }
+    positiveAmount(amount);
+    const preparation = new Preparation({
+      ...runtime,
+      inputSelection: selected
+    });
+    const frame = await preparation.frame(copied.deadline);
+    return this.funds(
+      "sweep",
+      [],
+      amount,
+      this.scope.walletIdentity,
+      amount,
+      frame,
+      { funding: {}, fundingMode: "none" },
+      copied.target,
+      preparation
+    );
+  }
+  async funds(kind, payments, total, withdrawalAddress, withdrawalAmount, frame, funding, target, preparation) {
+    if (total >= 1n << 135n) {
+      throw new Error("transaction sum exceeds uint135");
+    }
+    const { context, block, deadline } = frame;
+    const selection = await preparation.selectFunds(
+      total - (funding.funding.amount ?? 0n),
+      frame
+    );
+    const outputs = await Promise.all(
+      payments.map((payment) => preparation.output(payment, context))
+    );
+    const change = selection.amount + (funding.funding.amount ?? 0n) - total;
+    if (change > 0n) {
+      outputs.push(
+        await preparation.output(
+          {
+            to: this.context.changeAddress ?? this.context.options.wallet.getReceivingAddress().toString(),
+            amount: change
+          },
+          context,
+          true
+        )
+      );
+    }
+    const params = {
+      token: context.tokenAddress,
+      sources: selection.sources,
+      nullifiers: selection.nullifiers,
+      outputCommitments: outputs.map((output) => output.commitment),
+      withdrawalAddress,
+      withdrawalAmount,
+      deadline
+    };
+    const deliveries = outputs.map((output) => output.delivery);
+    const normalized = (0, import_protocol7.normalizeTransactRequest)(context, params, deliveries, funding.funding);
+    const statement2 = import_protocol7.WitnessBuilder.statement(
+      `transact_user_slots${normalized.capacity}`,
+      (0, import_protocol7.transactUserPublicInputs)(context, params, deliveries, funding.funding),
+      target ?? "evm"
+    );
+    await preparation.assertBlock(frame);
+    return preparation.runtime.complete({
+      version: 1,
+      id: crypto.randomUUID(),
+      kind,
+      context,
+      scope: this.scope,
+      preparedAt: block,
+      deadline,
+      outputs,
+      inputs: selection.inputs,
+      ...funding,
+      params,
+      capacity: normalized.capacity,
+      statement: statement2
+    });
+  }
+  async prepareShield(options) {
+    const copied = structuredClone(options);
+    const preparation = new Preparation(this.runtime(copied.tokenAddress));
+    const frame = await preparation.frame(copied.deadline);
+    const funding = await preparation.funding(copied.funding, frame);
+    if (copied.outputs.length < 1 || copied.outputs.length > 10) {
+      throw new Error("shield requires 1..10 outputs");
+    }
+    const outputs = await Promise.all(
+      copied.outputs.map((output) => preparation.output(output, frame.context))
+    );
+    if (outputs.reduce((sum, output) => sum + output.note.amount, 0n) !== (funding.funding.amount ?? 0n)) {
+      throw new Error("shield funding must equal output total");
+    }
+    await preparation.assertBlock(frame);
+    return preparation.runtime.complete({
+      version: 1,
+      id: crypto.randomUUID(),
+      kind: "shield",
+      context: frame.context,
+      scope: this.scope,
+      preparedAt: frame.block,
+      deadline: frame.deadline,
+      outputs,
+      inputs: [],
+      ...funding,
+      shieldParams: {
+        token: frame.context.tokenAddress,
+        outputCommitments: outputs.map((output) => output.commitment),
+        deadline: frame.deadline
+      },
+      shieldOutputs: outputs.map((output) => ({
+        identity: output.identity,
+        amount: output.note.amount
+      }))
+    });
+  }
+  prepareCreateCredit(options) {
+    return new CreditPreparation(this.runtime(options.tokenAddress)).create(
+      structuredClone(options)
+    );
+  }
+  prepareDrawCredit(options) {
+    return new CreditPreparation(this.runtime(options.tokenAddress)).draw(
+      structuredClone(options)
+    );
+  }
+  prepareTopUpCredit(options) {
+    return new CreditPreparation(this.runtime(options.tokenAddress)).topUp(
+      structuredClone(options)
+    );
+  }
+  prepareCancelCredit(options) {
+    return new CreditPreparation(this.runtime(options.tokenAddress)).cancel(
+      structuredClone(options)
+    );
+  }
+};
+
+// src/session/refresh.ts
+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 ?? 100;
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100)
+      throw new Error("refresh page size must be 1..100");
+    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");
+      result = await runtime.apply(
+        {
+          context: runtime.context,
+          transactionHashes: page.transactionHashes,
+          block: target
+        },
+        {
+          ...signal ? { signal } : {},
+          ...from === options.fromBlock && options.reset ? { reset: true } : {}
+        }
+      );
+      notes += result.notes;
+      credits += result.credits;
+    }
+    return { ...result, notes, credits };
+  } finally {
+    options.detectionKey?.fill(0);
+  }
+}
+
+// src/session/WalletUpdater.ts
+var import_core11 = require("@invisi-labs/core");
+
+// src/session/inventory.ts
+var import_core10 = require("@invisi-labs/core");
+var CanonicalConflict = class extends Error {
+};
+var CreditMetadataMismatch = class extends Error {
+};
+function check7(value, message) {
+  if (!value) {
+    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 (0, import_core10.computeCreditNullifier)(
+      n.chainId,
+      n.creditSharedKey,
+      await (0, import_core10.computeCreditCommitment)(
+        n.chainId,
+        n.spenderWalletIdentity,
+        n.ownerWalletIdentity,
+        n.spenderPayout,
+        n.ownerPayout,
+        n.tokenAddress,
+        n.amount,
+        n.nonce,
+        n.expiry,
+        await (0, import_core10.computeCreditSharedKeyHash)(n.creditSharedKey)
+      )
+    );
+  }
+  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])
+    );
+    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)
+    };
+    for (const event of logs) {
+      if (event.eventName === "CreditDraw") {
+        const args = event.args;
+        const params = args.params;
+        const indices = args.remainderLeafIndices;
+        check7(
+          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)) {
+            check7(
+              previous.state.note.expiry === params.expiries[index2],
+              "draw recovery expiry mismatch"
+            );
+            const remainder = await (0, import_core10.recoverCreditRemainder)(
+              context,
+              previous.state.note,
+              {
+                creditNullifier: nullifier,
+                remainderCommitment: params.remainderCommitments[index2],
+                recoveryAmount: BigInt(params.recoveryAmounts[index2])
+              }
+            );
+            if (!remainder) {
+              continue;
+            }
+            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 },
+              receivingKeySource: { kind: "draw", commitment: previous.commitment },
+              spent: "unknown"
+            };
+            check7(
+              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);
+        }
+      }
+    }
+    return recovered;
+  }
+};
+
+// src/session/WalletUpdater.ts
+var check8 = (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 };
+    check8(
+      options.viewing.walletIdentity === options.scope.walletIdentity,
+      "viewing capability wallet mismatch"
+    );
+  }
+  applyUpdates(batch, options = {}) {
+    return this.run(structuredClone(batch), { ...options });
+  }
+  async run(batch, options) {
+    const { reader, protocol, scope, store, viewing } = this.#options;
+    const nullifier = import_core11.NullifierCapability.fromIdentity(scope.walletIdentity);
+    const { signal, reset } = options;
+    signal?.throwIfAborted();
+    const context = protocol.context;
+    check8(
+      batch.context.chainId === context.chainId && batch.context.protocolAddress.toLowerCase() === context.protocolAddress.toLowerCase(),
+      "update deployment context mismatch"
+    );
+    check8(
+      batch.block.number >= protocol.deployment.protocol.fromBlock,
+      "update precedes deployment"
+    );
+    await protocol.validateDeployment(reader);
+    const base = await store.readSnapshot(scope);
+    check8(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");
+          check8(
+            cursor.number <= batch.block.number,
+            "update target precedes wallet checkpoint"
+          );
+        }
+      } else {
+        base.notes = {};
+        base.credits = {};
+      }
+      const block = await reader.getBlock(batch.block.number);
+      check8(
+        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();
+        check8(/^0x[0-9a-fA-F]{64}$/.test(hash2), "invalid candidate transaction hash");
+        const receipt = await reader.getReceipt(hash2);
+        check8(
+          receipt && receipt.status === "success" && receipt.transactionHash.toLowerCase() === hash2.toLowerCase(),
+          "invalid or unsuccessful candidate receipt"
+        );
+        check8(
+          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);
+          check8(
+            !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));
+        check8(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])
+      );
+      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
+      );
+      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
+        );
+      }
+      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
+      ) : [];
+      check8(
+        spent.length === observations.length && spent.every((value) => typeof value === "boolean"),
+        "invalid spent-state response"
+      );
+      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();
+        check8(draft.revision === base.revision, "wallet changed during update; retry");
+        if (reset) {
+          this.reorgOperations(draft);
+          draft.notes = {};
+          draft.credits = {};
+          delete draft.observedThrough;
+          delete draft.invalidated;
+        }
+        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;
+  #sending = /* @__PURE__ */ new Set();
+  #refreshQueue = Promise.resolve();
+  scope;
+  protocol;
+  constructor(options) {
+    this.#options = {
+      ...options,
+      ...options.gasBenchmarks ? { gasBenchmarks: copyGasBenchmarks(options.gasBenchmarks) } : {}
+    };
+    this.protocol = options.protocol;
+    this.scope = Object.freeze({
+      namespace: options.namespace ?? "default",
+      ...options.protocol.context,
+      walletIdentity: options.wallet.walletIdentity
+    });
+    scopeKey(this.scope);
+    Object.freeze(this);
+  }
+  /** Delegate sending to ethers; managed operations additionally retain the resulting hash. */
+  async sendTransaction(input, options = {}) {
+    const signer = this.#options.signer;
+    if (!signer) throw new import_core12.MissingCapabilityError("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 };
+    try {
+      if (!signer.provider) throw new import_core12.MissingCapabilityError("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 import_core12.MissingCapabilityError("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 }
+          );
+        }
+      }
+      return transaction;
+    } finally {
+      if (operation) this.#sending.delete(operation.id);
+    }
+  }
+  runtime(tokenAddress) {
+    const options = this.#options;
+    if (!options.store) {
+      throw new import_core12.MissingCapabilityError("wallet store");
+    }
+    if (!options.chainReader) {
+      throw new import_core12.MissingCapabilityError("chain reader");
+    }
+    return {
+      options: { ...options, protocol: options.protocol.forToken(tokenAddress) },
+      scope: this.scope,
+      store: options.store,
+      reader: options.chainReader,
+      authorization: () => options.authorization ?? options.wallet.exportAuthorization()
+    };
+  }
+  updater() {
+    if (this.#updater) return this.#updater;
+    const options = this.#options;
+    if (!options.store || !options.chainReader || !options.protocolRpc)
+      throw new import_core12.MissingCapabilityError("wallet store, chain reader and Protocol RPC");
+    const viewing = options.viewing ?? options.wallet.getViewer();
+    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 this.#updater;
+  }
+  async balance(tokenAddress) {
+    const store = this.#options.store;
+    if (!store) {
+      throw new import_core12.MissingCapabilityError("wallet store");
+    }
+    return walletBalance(await store.readSnapshot(this.scope), (0, import_ethers11.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 import_core12.MissingCapabilityError("chain reader");
+    if (!provider) throw new import_core12.MissingCapabilityError("Protocol RPC");
+    const updater = this.updater();
+    const request = {
+      ...options,
+      ...options.detectionKey ? { detectionKey: options.detectionKey.slice() } : {}
+    };
+    const task = this.#refreshQueue.then(
+      () => refreshWallet(
+        {
+          provider,
+          reader,
+          context: this.protocol.context,
+          fromBlock: this.protocol.deployment.protocol.fromBlock,
+          apply: (batch, settings) => updater.applyUpdates(batch, settings)
+        },
+        request
+      )
+    );
+    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,
+      authorization: runtime.authorization,
+      readInventory: () => runtime.store.readSnapshot(runtime.scope),
+      complete: (plan) => Operation.prepare(runtime, plan)
+    });
+  }
+  async prepareTransfer(options) {
+    return this.preparation(options.tokenAddress).prepareTransfer(options);
+  }
+  async prepareWithdraw(options) {
+    return this.preparation(options.tokenAddress).prepareWithdraw(options);
+  }
+  async prepareSweep(options) {
+    return this.preparation(options.tokenAddress).prepareSweep(options);
+  }
+  async prepareShield(options) {
+    return this.preparation(options.tokenAddress).prepareShield(options);
+  }
+  async prepareCreateCredit(options) {
+    return this.preparation(options.tokenAddress).prepareCreateCredit(options);
+  }
+  async prepareDrawCredit(options) {
+    return this.preparation(options.tokenAddress).prepareDrawCredit(options);
+  }
+  async prepareTopUpCredit(options) {
+    return this.preparation(options.tokenAddress).prepareTopUpCredit(options);
+  }
+  async prepareCancelCredit(options) {
+    return this.preparation(options.tokenAddress).prepareCancelCredit(options);
+  }
+  async resume(operationId) {
+    const store = this.#options.store;
+    if (!store) throw new import_core12.MissingCapabilityError("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, walletIdentity: this.scope.walletIdentity };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+};
+
+// src/integrations/indexeddb.ts
+var IndexedDBAtomicRecords = class {
+  #database;
+  constructor(name, factory = indexedDB) {
+    if (!name) throw new Error("IndexedDB database name is required");
+    this.#database = new Promise((resolve, reject) => {
+      const request = factory.open(name, 1);
+      request.onupgradeneeded = () => {
+        request.result.createObjectStore("walletRecords");
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(new Error("could not open wallet IndexedDB"));
+      request.onblocked = () => reject(new Error("wallet IndexedDB upgrade is blocked"));
+    });
+  }
+  async read(key) {
+    const db = await this.#database;
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction("walletRecords", "readonly"), request = tx.objectStore("walletRecords").get(key);
+      let result;
+      request.onsuccess = () => {
+        const value = request.result;
+        if (value) result = { revision: value.revision, data: Uint8Array.from(value.data) };
+      };
+      tx.oncomplete = () => resolve(result);
+      tx.onerror = () => reject(new Error("wallet IndexedDB read failed"));
+      tx.onabort = () => reject(new Error("wallet IndexedDB read aborted"));
+    });
+  }
+  async compareAndSwap(key, previousRevision, next) {
+    const db = await this.#database;
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction("walletRecords", "readwrite"), store = tx.objectStore("walletRecords"), request = store.get(key);
+      let swapped = false;
+      request.onsuccess = () => {
+        if ((request.result?.revision ?? 0) === previousRevision) {
+          store.put({ revision: next.revision, data: Uint8Array.from(next.data) }, key);
+          swapped = true;
+        }
+      };
+      tx.oncomplete = () => resolve(swapped);
+      tx.onerror = () => reject(new Error("wallet IndexedDB transaction failed"));
+      tx.onabort = () => reject(new Error("wallet IndexedDB transaction aborted"));
+    });
+  }
+  async close() {
+    (await this.#database).close();
+  }
+};
+var IndexedDBWalletStore = class extends TransactionalWalletStore {
+  #records;
+  constructor(name, codec, factory) {
+    const records = new IndexedDBAtomicRecords(name, factory);
+    super(records, codec, { persistent: true });
+    this.#records = records;
+  }
+  close() {
+    return this.#records.close();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IndexedDBAtomicRecords,
+  IndexedDBWalletStore
+});
+//# sourceMappingURL=indexeddb.cjs.map