@invisi-labs/protocol 1.1.0

package/dist/index.js

@@ -0,0 +1,3613 @@
+import {
+  invisiAddressRegistryAbi,
+  invisiFactoryAbi,
+  invisiProtocolAbi
+} from "./chunk-XTOQXQES.js";
+
+// src/AddressRegistry.ts
+import { getAddress as getAddress6, keccak256 as keccak2566 } from "ethers";
+import {
+  MissingCapabilityError as MissingCapabilityError2,
+  ReceivingAddress as ReceivingAddress3
+} from "@invisi-labs/core";
+
+// src/RegistrationOperation.ts
+import { hexlify as hexlify2, Interface as Interface5 } from "ethers";
+import {
+  computeWalletAuthorizationDigest as computeWalletAuthorizationDigest5,
+  MissingCapabilityError,
+  ReceivingAddress as ReceivingAddress2
+} from "@invisi-labs/core";
+
+// src/registry.ts
+import {
+  Contract,
+  Interface,
+  concat,
+  getAddress,
+  getBytes,
+  hexlify,
+  isHexString,
+  keccak256,
+  toBeHex
+} from "ethers";
+import {
+  ReceivingAddress,
+  computeWalletAuthorizationDigest,
+  decodeAddress,
+  walletAuthorizationTypedData
+} from "@invisi-labs/core";
+var MAX_NONCE = (1n << 64n) - 1n;
+var MASK128 = (1n << 128n) - 1n;
+function uint64(value, name) {
+  if (typeof value !== "bigint" || value < 0n || value > MAX_NONCE)
+    throw new RangeError(`${name} must be uint64`);
+  return value;
+}
+function hexBytes(value, length) {
+  if (typeof value !== "string" || !isHexString(value) || value.length !== 2 + length * 2)
+    throw new Error(`Expected ${length} hexadecimal bytes`);
+  return getBytes(value);
+}
+function normalizeKeys(walletIdentity, keys) {
+  const decoded = decodeAddress(
+    ReceivingAddress.from({
+      walletIdentity,
+      viewingPublicKey: hexBytes(keys.viewingPublicKey, 33),
+      clueKey: hexBytes(keys.clueKey, 32)
+    }).toString()
+  );
+  if (decoded.kind !== "long") throw new Error("Expected full receiving address");
+  return {
+    viewingPublicKey: hexlify(decoded.viewingPublicKey),
+    clueKey: hexlify(decoded.clueKey)
+  };
+}
+function normalize(context, registration, options) {
+  uint64(context.chainId, "chainId");
+  const registryAddress = getAddress(context.registryAddress);
+  if (BigInt(registryAddress) === 0n) throw new Error("Registry address must be nonzero");
+  const walletIdentity = decodeAddress(
+    ReceivingAddress.fromIdentity(registration.walletIdentity).toString()
+  ).walletIdentity;
+  const keys = normalizeKeys(walletIdentity, registration.keys);
+  const nonce = uint64(registration.nonce, "nonce"), deadline = uint64(registration.deadline, "deadline");
+  if (nonce === MAX_NONCE) throw new Error("Registry nonce exhausted");
+  if (options.update !== void 0 && typeof options.update !== "boolean")
+    throw new TypeError("update must be boolean");
+  if (!options.update && nonce !== 0n)
+    throw new Error("Initial registration requires nonce zero");
+  if (options.expectedNonce !== void 0 && uint64(options.expectedNonce, "expectedNonce") !== nonce)
+    throw new Error("Registry nonce mismatch");
+  if (context.now !== void 0 && deadline < uint64(context.now, "now"))
+    throw new Error("Registration expired");
+  return { registryAddress, registration: { walletIdentity, keys, nonce, deadline } };
+}
+function registrationAuthorizationRequest(context, registration, options = {}) {
+  const normalized = normalize(context, registration, options), r = normalized.registration;
+  const keysHash = BigInt(
+    keccak256(concat([r.keys.viewingPublicKey, r.keys.clueKey]))
+  );
+  return {
+    context: { chainId: context.chainId, protocolAddress: BigInt(normalized.registryAddress) },
+    operation: options.update ? "update-address" : "register-address",
+    capacity: 0,
+    words: [
+      context.chainId,
+      BigInt(normalized.registryAddress),
+      BigInt(r.walletIdentity),
+      r.nonce,
+      r.deadline,
+      keysHash >> 128n,
+      keysHash & MASK128
+    ]
+  };
+}
+function registrationTypedData(context, registration, options = {}) {
+  return walletAuthorizationTypedData(
+    registrationAuthorizationRequest(context, registration, options)
+  );
+}
+function registrationPublicInputs(context, registration, options = {}) {
+  const request = registrationAuthorizationRequest(context, registration, options);
+  const digest = BigInt(computeWalletAuthorizationDigest(request));
+  return [
+    toBeHex(request.words[2], 32),
+    toBeHex(digest >> 128n, 32),
+    toBeHex(digest & MASK128, 32)
+  ];
+}
+function buildRegistrationCalldata(context, registration, proof, options = {}) {
+  const normalized = normalize(context, registration, options);
+  if (typeof proof !== "string" || !isHexString(proof) || proof.length <= 2 || proof.length % 2 !== 0)
+    throw new Error("Registration proof must be nonempty hexadecimal bytes");
+  return {
+    to: normalized.registryAddress,
+    value: 0n,
+    callData: new Interface(invisiAddressRegistryAbi).encodeFunctionData(
+      options.update ? "updateKeys" : "registerKeys",
+      [
+        {
+          ...normalized.registration,
+          walletIdentity: toBeHex(BigInt(normalized.registration.walletIdentity), 32)
+        },
+        proof
+      ]
+    ),
+    publicInputs: registrationPublicInputs(context, normalized.registration, options)
+  };
+}
+function createRegistryReceivingKeyLookup(client, registryAddress) {
+  const address = getAddress(registryAddress);
+  if (BigInt(address) === 0n) throw new Error("Registry address must be nonzero");
+  return async (walletIdentity) => {
+    const identity = decodeAddress(
+      ReceivingAddress.fromIdentity(walletIdentity).toString()
+    ).walletIdentity;
+    const [keys, nonce] = await new Contract(
+      address,
+      invisiAddressRegistryAbi,
+      client
+    ).getFunction("receivingKeysOf")(toBeHex(BigInt(identity), 32));
+    uint64(nonce, "registry nonce");
+    const normalized = normalizeKeys(identity, keys);
+    return {
+      viewingPublicKey: getBytes(normalized.viewingPublicKey),
+      clueKey: getBytes(normalized.clueKey)
+    };
+  };
+}
+
+// src/witness.ts
+import {
+  computeCreditCommitment,
+  computeCreditNullifier,
+  computeCreditSharedKeyHash,
+  computeNoteCommitment as computeNoteCommitment2,
+  computeNoteIdentity,
+  computeNoteNullifier,
+  computeWalletAuthorizationDigest as computeWalletAuthorizationDigest4,
+  normalizeCreditDeliveryState,
+  poseidonHash,
+  verifyWalletAuthorization
+} from "@invisi-labs/core";
+import {
+  LocalWitness
+} from "@invisi-labs/prover";
+
+// src/credit-create.ts
+import {
+  AbiCoder as AbiCoder2,
+  dataLength as dataLength2,
+  getAddress as getAddress3,
+  Interface as Interface2,
+  isHexString as isHexString3,
+  keccak256 as keccak2563,
+  ParamType as ParamType2
+} from "ethers";
+import { computeWalletAuthorizationDigest as computeWalletAuthorizationDigest2, walletAuthorizationTypedData as walletAuthorizationTypedData2 } from "@invisi-labs/core";
+
+// src/validation.ts
+import {
+  AbiCoder,
+  dataLength,
+  getAddress as getAddress2,
+  isHexString as isHexString2,
+  keccak256 as keccak2562,
+  ParamType,
+  toBeHex as toBeHex2
+} from "ethers";
+var FIELD_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ZERO_WORD = toBeHex2(0n, 32);
+var EMPTY_PERMIT = {
+  deadline: 0n,
+  v: 0,
+  r: ZERO_WORD,
+  s: ZERO_WORD
+};
+var EMPTY_FUNDING = {
+  payer: ZERO_ADDRESS,
+  amount: 0n,
+  sigNonce: 0n,
+  deadline: 0n,
+  signature: "0x",
+  permit: EMPTY_PERMIT
+};
+function uint(v, bits, name = "value") {
+  if (typeof v !== "bigint" && typeof v !== "number" && typeof v !== "string" || typeof v === "number" && !Number.isSafeInteger(v))
+    throw new Error(`${name} must be an integer`);
+  const n = BigInt(v);
+  if (n < 0n || n >= 1n << BigInt(bits)) throw new Error(`${name} exceeds u${bits}`);
+  return n;
+}
+function field(v, name = "field") {
+  const n = uint(v, 256, name);
+  if (n >= FIELD_MODULUS) throw new Error(`${name} is noncanonical field`);
+  return n;
+}
+var word = (v) => toBeHex2(typeof v === "bigint" ? v : BigInt(v), 32);
+function dense(v, name) {
+  if (!Array.isArray(v)) throw new Error(`${name} must be array`);
+  for (let i = 0; i < v.length; i++)
+    if (!Object.hasOwn(v, i) || v[i] === void 0 || v[i] === null)
+      throw new Error(`${name} has missing or sparse entries`);
+  return v;
+}
+function known(v, keys, name = "params") {
+  if (!v || typeof v !== "object" || Array.isArray(v) || Object.keys(v).some((k) => !keys.includes(k)))
+    throw new Error(`${name} has unsupported fields`);
+}
+function notes(v, name) {
+  const r = dense(v, name).map((v2) => word(field(v2, name)));
+  if (r.some((v2) => BigInt(v2) === 0n) || new Set(r).size !== r.length)
+    throw new Error(`duplicate or zero ${name}`);
+  return r;
+}
+function envelope(v, length, version) {
+  if (!isHexString2(v) || !/^0x(?:[a-fA-F0-9]{2})*$/.test(v) || dataLength(v) !== length)
+    throw new Error(`ciphertext must be ${length} bytes`);
+  if (version !== void 0 && Number.parseInt(v.slice(2, 4), 16) !== version)
+    throw new Error("unsupported ciphertext envelope version");
+  return v;
+}
+function normalizeContext(c) {
+  return {
+    ...c,
+    chainId: uint(c.chainId, 64, "chainId"),
+    protocolAddress: getAddress2(c.protocolAddress),
+    tokenAddress: getAddress2(c.tokenAddress)
+  };
+}
+function checkDeadline(c, value) {
+  const n = uint(value, 64, "deadline");
+  if (c.now !== void 0 && n < uint(c.now, 64, "now")) throw new Error("deadline has expired");
+  return n;
+}
+function normalizeSources(sources, inputCount, capacity) {
+  dense(sources, "sources");
+  if (inputCount < 0 || inputCount > capacity || sources.length > inputCount || (inputCount === 0 ? sources.length !== 0 : sources.length === 0))
+    throw new Error("source count must be 1..inputCount, or empty for zero inputs");
+  let previous = 0n;
+  return sources.map((s) => {
+    known(s, ["treeId", "merkleRoot"], "source");
+    const treeId = uint(s.treeId, 64, "treeId"), merkleRoot = word(field(s.merkleRoot, "merkleRoot"));
+    if (treeId === 0n || treeId <= previous || BigInt(merkleRoot) === 0n)
+      throw new Error("sources must have positive roots and strictly ascending tree IDs");
+    previous = treeId;
+    return { treeId, merkleRoot };
+  });
+}
+var pad = (v, n) => [
+  ...v,
+  ...Array(n - v.length).fill(0n)
+];
+function normalizeDelivery(value, options = {}) {
+  known(value, ["ciphertext", "clue"], "delivery");
+  if (options.empty) {
+    if (value.ciphertext !== "0x" || value.clue !== "0x")
+      throw new Error("absent output requires an empty delivery");
+    return { ciphertext: "0x", clue: "0x" };
+  }
+  const ciphertext = envelope(
+    value.ciphertext,
+    options.credit ? 400 : 158,
+    options.credit ? 3 : 1
+  );
+  const clue = envelope(value.clue, 68);
+  if (clue.slice(130, 132).toLowerCase() !== "18") throw new Error("clue precision must be 24");
+  return { ciphertext, clue };
+}
+var deliveriesHash = (v) => keccak2562(
+  AbiCoder.defaultAbiCoder().encode(
+    [
+      {
+        type: "tuple[]",
+        components: [
+          { name: "ciphertext", type: "bytes" },
+          { name: "clue", type: "bytes" }
+        ]
+      }
+    ].map((parameter) => ParamType.from(parameter)),
+    [dense(v, "deliveries")]
+  )
+);
+function normalizeFunding(input = {}) {
+  const f = { ...EMPTY_FUNDING, ...input };
+  getAddress2(f.payer);
+  uint(f.amount, 128, "depositAmount");
+  uint(f.sigNonce, 256, "sigNonce");
+  uint(f.deadline, 256, "funding deadline");
+  if (!isHexString2(f.signature) || !/^0x(?:[a-fA-F0-9]{2})*$/.test(f.signature))
+    throw new Error("invalid signature bytes");
+  const p = f.permit;
+  uint(p.deadline, 256);
+  uint(p.v, 8);
+  for (const v of [p.r, p.s])
+    if (!isHexString2(v) || dataLength(v) !== 32) throw new Error("permit r/s must be bytes32");
+  if (f.amount === 0n !== (BigInt(f.payer) === 0n))
+    throw new Error("deposit amount and payer must both be zero or positive");
+  if (f.amount === 0n && (f.sigNonce !== 0n || f.deadline !== 0n || f.signature !== "0x" || p.deadline !== 0n || p.v !== 0 || BigInt(p.r) !== 0n || BigInt(p.s) !== 0n))
+    throw new Error("zero funding must be entirely empty");
+  return { ...f, payer: getAddress2(f.payer) };
+}
+function validateFundingSubmission(f, caller, now) {
+  if (f.signature !== "0x" && now !== void 0 && uint(now, 64, "now") > f.deadline)
+    throw new Error("funding authorization has expired");
+  if (f.signature === "0x" && (f.sigNonce !== 0n || f.deadline !== 0n || caller !== void 0 && f.amount > 0n && getAddress2(caller) !== f.payer))
+    throw new Error("direct funding requires payer caller and zero nonce/deadline");
+}
+var getEIP712Domain = (c) => ({
+  name: "InvisibleProtocol",
+  version: "1",
+  chainId: uint(c.chainId, 64),
+  verifyingContract: getAddress2(c.protocolAddress)
+});
+var fundingFields = [
+  { name: "requestHash", type: "bytes32" },
+  { name: "payer", type: "address" },
+  { name: "amount", type: "uint256" },
+  { name: "sigNonce", type: "uint256" },
+  { name: "deadline", type: "uint256" }
+];
+
+// src/credit-create.ts
+var creationTuple = [
+  "(address token,(uint256 treeId,bytes32 merkleRoot)[] sources,bytes32[] nullifiers,bytes32 creditCommitment,bytes32 changeCommitment,address owner,uint256 expiry,uint256 deadline)"
+][0];
+var CREATE_CREDIT_FIELDS = [
+  "token",
+  "sources",
+  "nullifiers",
+  "creditCommitment",
+  "changeCommitment",
+  "owner",
+  "expiry",
+  "deadline"
+];
+function validateCreateCreditRequest(c, p, cs, funding = {}) {
+  known(p, CREATE_CREDIT_FIELDS);
+  if (getAddress3(p.token) !== getAddress3(c.tokenAddress))
+    throw new Error("request token mismatch");
+  const ctx = normalizeContext(c), ns = notes(p.nullifiers, "nullifiers"), sources = normalizeSources(p.sources, ns.length, 10), creditCommitment = word(field(p.creditCommitment)), changeCommitment = word(field(p.changeCommitment)), owner = getAddress3(p.owner), expiry = uint(p.expiry, 64, "expiry"), deadline = checkDeadline(c, p.deadline), f = normalizeFunding(funding);
+  if (BigInt(creditCommitment) === 0n || creditCommitment === changeCommitment)
+    throw new Error("zero or duplicate commitment");
+  if (BigInt(owner) === 0n || expiry === 0n || c.now !== void 0 && expiry <= c.now)
+    throw new Error("owner must be nonzero and expiry future");
+  if (dense(cs, "deliveries").length !== 3) throw new Error("deliveries count mismatch");
+  const deliveries = cs.map(
+    (v, i) => normalizeDelivery(v, { credit: i < 2, empty: i === 2 && BigInt(changeCommitment) === 0n })
+  );
+  if (ns.length === 0 && f.amount === 0n)
+    throw new Error("empty inputs require positive funding");
+  return {
+    ...ctx,
+    sources,
+    nullifiers: ns,
+    actualCount: ns.length,
+    sourceCount: sources.length,
+    creditCommitment,
+    changeCommitment,
+    owner,
+    expiry,
+    deadline,
+    deliveries,
+    funding: f
+  };
+}
+function createCreditBaseInputs(c, p, cs, f = {}) {
+  const r = validateCreateCreditRequest(c, p, cs, f), h = BigInt(deliveriesHash(cs));
+  return [
+    r.chainId,
+    BigInt(r.protocolAddress),
+    BigInt(r.tokenAddress),
+    BigInt(r.owner),
+    BigInt(r.actualCount),
+    BigInt(r.sourceCount),
+    ...pad(
+      r.sources.map((s) => s.treeId),
+      10
+    ),
+    ...pad(
+      r.sources.map((s) => BigInt(s.merkleRoot)),
+      10
+    ),
+    ...pad(r.nullifiers.map(BigInt), 10),
+    BigInt(r.creditCommitment),
+    BigInt(r.changeCommitment),
+    h >> 128n,
+    h & (1n << 128n) - 1n,
+    r.expiry,
+    r.deadline,
+    r.funding.amount,
+    BigInt(r.funding.payer)
+  ].map(word);
+}
+function createCreditPublicInputs(c, p, deliveries, funding = {}) {
+  const base = createCreditBaseInputs(c, p, deliveries, funding);
+  const digest = BigInt(
+    computeWalletAuthorizationDigest2({
+      context: { chainId: c.chainId, protocolAddress: BigInt(c.protocolAddress) },
+      operation: "create-credit",
+      capacity: 10,
+      words: base.map(BigInt)
+    })
+  );
+  return [...base, word(digest >> 128n), word(digest & (1n << 128n) - 1n)];
+}
+var hashContext = {
+  chainId: 0n,
+  protocolAddress: ZERO_ADDRESS,
+  tokenAddress: ZERO_ADDRESS
+};
+function createCreditRequestHash(p, cs, f = {}) {
+  const r = validateCreateCreditRequest({ ...hashContext, tokenAddress: p.token }, p, cs, f);
+  return keccak2563(
+    AbiCoder2.defaultAbiCoder().encode(
+      [
+        { type: "bytes32" },
+        creationTuple,
+        { type: "bytes32" },
+        { type: "address" },
+        { type: "uint256" }
+      ].map((parameter) => ParamType2.from(parameter)),
+      [
+        keccak2563(new TextEncoder().encode("InvisiCreateCredit")),
+        p,
+        deliveriesHash(cs),
+        r.funding.payer,
+        r.funding.amount
+      ]
+    )
+  );
+}
+function encodeCreateCreditTypedData(c, p, deliveries, funding = {}) {
+  return walletAuthorizationTypedData2({
+    context: { chainId: c.chainId, protocolAddress: BigInt(c.protocolAddress) },
+    operation: "create-credit",
+    capacity: 10,
+    words: createCreditBaseInputs(c, p, deliveries, funding).map(BigInt)
+  });
+}
+function encodeCreateCreditFundingTypedData(c, p, cs, f) {
+  const r = validateCreateCreditRequest(c, p, cs, f);
+  if (r.funding.amount === 0n) throw new Error("funding authorization requires positive deposit");
+  return {
+    domain: getEIP712Domain(c),
+    primaryType: "FundTransact",
+    types: { FundTransact: fundingFields },
+    message: {
+      requestHash: createCreditRequestHash(p, cs, f),
+      payer: r.funding.payer,
+      amount: r.funding.amount,
+      sigNonce: r.funding.sigNonce,
+      deadline: r.funding.deadline
+    }
+  };
+}
+function buildCreateCreditCalldata(p) {
+  const r = validateCreateCreditRequest(p.context, p.params, p.deliveries, p.funding);
+  validateFundingSubmission(r.funding, p.caller, p.context.now);
+  return {
+    data: new Interface2(invisiProtocolAbi).encodeFunctionData("createCredit", [
+      encodeCreditProof(p.proof),
+      p.params,
+      p.deliveries,
+      r.funding
+    ]),
+    approveAmount: r.funding.amount
+  };
+}
+function encodeCreditProof(proof) {
+  if (!isHexString3(proof) || !/^0x(?:[a-fA-F0-9]{2})*$/.test(proof) || dataLength2(proof) === 0)
+    throw new Error("empty or malformed Credit proof");
+  return AbiCoder2.defaultAbiCoder().encode(
+    ["uint8", "bytes"].map((parameter) => ParamType2.from(parameter)),
+    [0, proof]
+  );
+}
+
+// src/credit-lifecycle.ts
+import { AbiCoder as AbiCoder3, getAddress as getAddress4, Interface as Interface3, keccak256 as keccak2564, ParamType as ParamType3 } from "ethers";
+import {
+  computeWalletAuthorizationDigest as computeWalletAuthorizationDigest3,
+  walletAuthorizationTypedData as walletAuthorizationTypedData3
+} from "@invisi-labs/core";
+var CREDIT_DRAW_CAPACITIES = [1, 12, 50, 120];
+function selectCreditDrawCircuit(count) {
+  if (!Number.isInteger(count) || count < 1 || count > 120)
+    throw new Error("draw requires 1..120 credits");
+  const maxSize = CREDIT_DRAW_CAPACITIES.find((n) => count <= n);
+  return {
+    name: `credit_draw_slots${maxSize}`,
+    maxSize,
+    publicInputCount: 6 * maxSize + 12,
+    totalBits: 126 + Math.ceil(Math.log2(maxSize))
+  };
+}
+function validateCreditDrawRequest(c, p, cs) {
+  known(p, [
+    "token",
+    "sources",
+    "nullifiers",
+    "remainderCommitments",
+    "expiries",
+    "recoveryAmounts",
+    "spender",
+    "totalAmount",
+    "deadline"
+  ]);
+  if (getAddress4(p.token) !== getAddress4(c.tokenAddress))
+    throw new Error("request token mismatch");
+  const ctx = normalizeContext(c), ns = notes(p.nullifiers, "nullifiers"), profile = selectCreditDrawCircuit(ns.length), sources = normalizeSources(p.sources, ns.length, profile.maxSize);
+  for (const [key, v] of Object.entries({
+    remainderCommitments: p.remainderCommitments,
+    expiries: p.expiries,
+    recoveryAmounts: p.recoveryAmounts
+  }))
+    if (dense(v, key).length !== ns.length) throw new Error(`${key} count mismatch`);
+  const remainderCommitments = p.remainderCommitments.map((v) => word(field(v))), recoveryAmounts = p.recoveryAmounts.map((v) => word(field(v))), expiries = p.expiries.map((v) => uint(v, 64, "expiry")), positives = remainderCommitments.filter((v) => BigInt(v) !== 0n);
+  if (new Set(positives).size !== positives.length)
+    throw new Error("duplicate remainder commitment");
+  for (let i = 0; i < ns.length; i++) {
+    if (expiries[i] === 0n || c.now !== void 0 && expiries[i] <= c.now)
+      throw new Error("expiry must be future");
+    if (BigInt(remainderCommitments[i]) === 0n && BigInt(recoveryAmounts[i]) !== 0n)
+      throw new Error("full draw requires zero recovery amount");
+  }
+  const spender = getAddress4(p.spender), totalAmount = uint(p.totalAmount, profile.totalBits, "totalAmount");
+  if (BigInt(spender) === 0n || totalAmount === 0n)
+    throw new Error("spender and total amount must be positive");
+  if (dense(cs, "deliveries").length !== 2 * ns.length)
+    throw new Error("deliveries count mismatch");
+  const deliveries = cs.map(
+    (v, i) => BigInt(remainderCommitments[Math.floor(i / 2)]) === 0n ? normalizeDelivery(v, { empty: true }) : normalizeDelivery(v, { credit: true })
+  );
+  return {
+    ...ctx,
+    sources,
+    nullifiers: ns,
+    remainderCommitments,
+    recoveryAmounts,
+    expiries,
+    spender,
+    totalAmount,
+    deadline: checkDeadline(c, p.deadline),
+    deliveries,
+    profile
+  };
+}
+function creditDrawBaseInputs(c, p, cs) {
+  const r = validateCreditDrawRequest(c, p, cs), n = r.profile.maxSize, h = BigInt(deliveriesHash(cs));
+  return [
+    r.chainId,
+    BigInt(r.protocolAddress),
+    BigInt(r.tokenAddress),
+    BigInt(r.spender),
+    BigInt(r.nullifiers.length),
+    BigInt(r.sources.length),
+    ...pad(
+      r.sources.map((s) => s.treeId),
+      n
+    ),
+    ...pad(
+      r.sources.map((s) => BigInt(s.merkleRoot)),
+      n
+    ),
+    ...pad(r.nullifiers.map(BigInt), n),
+    ...pad(r.remainderCommitments.map(BigInt), n),
+    ...pad(r.expiries, n),
+    r.totalAmount,
+    r.deadline,
+    h >> 128n,
+    h & (1n << 128n) - 1n,
+    ...pad(r.recoveryAmounts.map(BigInt), n)
+  ].map(word);
+}
+function validateCancelCreditRequest(c, p) {
+  known(p, ["token", "source", "nullifier", "owner", "amount", "deadline"]);
+  if (getAddress4(p.token) !== getAddress4(c.tokenAddress))
+    throw new Error("request token mismatch");
+  const ctx = normalizeContext(c), source = normalizeSources([p.source], 1, 1)[0], nullifier = notes([p.nullifier], "nullifier")[0], owner = getAddress4(p.owner), amount = uint(p.amount, 126, "amount");
+  if (BigInt(owner) === 0n || amount === 0n) throw new Error("owner and amount must be positive");
+  return {
+    ...ctx,
+    source,
+    nullifier,
+    owner,
+    amount,
+    deadline: checkDeadline(c, p.deadline)
+  };
+}
+function cancelCreditBaseInputs(c, p) {
+  const r = validateCancelCreditRequest(c, p);
+  return [
+    r.chainId,
+    BigInt(r.protocolAddress),
+    BigInt(r.tokenAddress),
+    BigInt(r.owner),
+    r.source.treeId,
+    BigInt(r.source.merkleRoot),
+    BigInt(r.nullifier),
+    r.amount,
+    r.deadline
+  ].map(word);
+}
+function validateTopUpCreditRequest(c, p, cs, funding = {}) {
+  known(p, ["token", "creation", "creditSource", "creditNullifier", "previousExpiry"]);
+  const creation = validateCreateCreditRequest(c, p.creation, cs, funding), creditSource = normalizeSources([p.creditSource], 1, 1)[0], creditNullifier = notes([p.creditNullifier], "creditNullifier")[0], previousExpiry = uint(p.previousExpiry, 64, "previousExpiry");
+  if (previousExpiry === 0n || c.now !== void 0 && previousExpiry <= c.now)
+    throw new Error("previous Credit has expired");
+  if (creation.expiry < previousExpiry) throw new Error("expiry must not decrease");
+  if (creation.nullifiers.includes(creditNullifier))
+    throw new Error("duplicate credit and ordinary nullifier");
+  return { creation, creditSource, creditNullifier, previousExpiry };
+}
+function topUpCreditBaseInputs(c, p, cs, f = {}) {
+  const r = validateTopUpCreditRequest(c, p, cs, f);
+  return [
+    ...createCreditBaseInputs(c, p.creation, cs, f),
+    word(r.creditSource.treeId),
+    r.creditSource.merkleRoot,
+    r.creditNullifier,
+    word(r.previousExpiry)
+  ];
+}
+var cancelTuple = [
+  "(address token,(uint256 treeId,bytes32 merkleRoot) source,bytes32 nullifier,address owner,uint256 amount,uint256 deadline)"
+][0];
+var topTuple = [
+  "((address token,(uint256 treeId,bytes32 merkleRoot)[] sources,bytes32[] nullifiers,bytes32 creditCommitment,bytes32 changeCommitment,address owner,uint256 expiry,uint256 deadline) creation,(uint256 treeId,bytes32 merkleRoot) creditSource,bytes32 creditNullifier,uint256 previousExpiry)"
+][0];
+var hashContext2 = {
+  chainId: 0n,
+  protocolAddress: ZERO_ADDRESS,
+  tokenAddress: ZERO_ADDRESS
+};
+function cancelCreditRequestHash(p) {
+  validateCancelCreditRequest({ ...hashContext2, tokenAddress: p.token }, p);
+  return keccak2564(
+    AbiCoder3.defaultAbiCoder().encode(
+      [{ type: "bytes32" }, cancelTuple].map((parameter) => ParamType3.from(parameter)),
+      [keccak2564(new TextEncoder().encode("InvisiCancelCredit")), p]
+    )
+  );
+}
+function topUpCreditRequestHash(p, cs, f = {}) {
+  const r = validateTopUpCreditRequest(
+    { ...hashContext2, tokenAddress: p.creation.token },
+    p,
+    cs,
+    f
+  );
+  return keccak2564(
+    AbiCoder3.defaultAbiCoder().encode(
+      [
+        { type: "bytes32" },
+        topTuple,
+        { type: "bytes32" },
+        { type: "address" },
+        { type: "uint256" }
+      ].map((parameter) => ParamType3.from(parameter)),
+      [
+        keccak2564(new TextEncoder().encode("InvisiTopUpCredit")),
+        p,
+        deliveriesHash(cs),
+        r.creation.funding.payer,
+        r.creation.funding.amount
+      ]
+    )
+  );
+}
+function authorize(c, operation, capacity, words) {
+  return walletAuthorizationTypedData3({
+    context: { chainId: c.chainId, protocolAddress: BigInt(c.protocolAddress) },
+    operation,
+    capacity,
+    words: words.map(BigInt)
+  });
+}
+function appendDigest(c, operation, capacity, words) {
+  const digest = BigInt(
+    computeWalletAuthorizationDigest3({
+      context: { chainId: c.chainId, protocolAddress: BigInt(c.protocolAddress) },
+      operation,
+      capacity,
+      words: words.map(BigInt)
+    })
+  );
+  return [...words, word(digest >> 128n), word(digest & (1n << 128n) - 1n)];
+}
+function encodeCancelCreditTypedData(c, p) {
+  return authorize(c, "cancel-credit", 1, cancelCreditBaseInputs(c, p));
+}
+function encodeTopUpCreditTypedData(c, p, deliveries, funding = {}) {
+  return authorize(c, "top-up-credit", 10, topUpCreditBaseInputs(c, p, deliveries, funding));
+}
+function encodeCreditDrawTypedData(c, p, deliveries) {
+  return authorize(
+    c,
+    "credit-draw",
+    selectCreditDrawCircuit(p.nullifiers.length).maxSize,
+    creditDrawBaseInputs(c, p, deliveries)
+  );
+}
+function creditDrawPublicInputs(c, p, deliveries) {
+  return appendDigest(
+    c,
+    "credit-draw",
+    selectCreditDrawCircuit(p.nullifiers.length).maxSize,
+    creditDrawBaseInputs(c, p, deliveries)
+  );
+}
+function cancelCreditPublicInputs(c, p) {
+  return appendDigest(c, "cancel-credit", 1, cancelCreditBaseInputs(c, p));
+}
+function topUpCreditPublicInputs(c, p, deliveries, funding = {}) {
+  return appendDigest(c, "top-up-credit", 10, topUpCreditBaseInputs(c, p, deliveries, funding));
+}
+function encodeTopUpCreditFundingTypedData(c, p, cs, f) {
+  const r = validateTopUpCreditRequest(c, p, cs, f), funding = r.creation.funding;
+  if (funding.amount === 0n) throw new Error("funding authorization requires positive deposit");
+  return {
+    domain: getEIP712Domain(c),
+    primaryType: "FundTransact",
+    types: { FundTransact: fundingFields },
+    message: {
+      requestHash: topUpCreditRequestHash(p, cs, f),
+      payer: funding.payer,
+      amount: funding.amount,
+      sigNonce: funding.sigNonce,
+      deadline: funding.deadline
+    }
+  };
+}
+function buildCreditDrawCalldata(p) {
+  validateCreditDrawRequest(p.context, p.params, p.deliveries);
+  return {
+    data: new Interface3(invisiProtocolAbi).encodeFunctionData("creditDraw", [
+      encodeCreditProof(p.proof),
+      p.params,
+      p.deliveries
+    ]),
+    nullifiers: p.params.nullifiers,
+    totalAmount: p.params.totalAmount
+  };
+}
+function buildCancelCreditCalldata(p) {
+  validateCancelCreditRequest(p.context, p.params);
+  return {
+    data: new Interface3(invisiProtocolAbi).encodeFunctionData("cancelCredit", [
+      encodeCreditProof(p.proof),
+      p.params
+    ])
+  };
+}
+function buildTopUpCreditCalldata(p) {
+  const r = validateTopUpCreditRequest(p.context, p.params, p.deliveries, p.funding);
+  validateFundingSubmission(r.creation.funding, p.caller, p.context.now);
+  return {
+    data: new Interface3(invisiProtocolAbi).encodeFunctionData("topUpCredit", [
+      encodeCreditProof(p.proof),
+      p.params,
+      p.deliveries,
+      r.creation.funding
+    ]),
+    approveAmount: r.creation.funding.amount
+  };
+}
+
+// src/funds.ts
+import { AbiCoder as AbiCoder4, getAddress as getAddress5, Interface as Interface4, keccak256 as keccak2565, ParamType as ParamType4, TypedDataEncoder } from "ethers";
+import { computeNoteCommitment, walletAuthorizationTypedData as walletAuthorizationTypedData4 } from "@invisi-labs/core";
+var TRANSACT_CAPACITIES = [14, 56, 112, 168];
+function selectTransactCapacity(inputs, outputs) {
+  if (!Number.isInteger(inputs) || !Number.isInteger(outputs) || inputs < 0 || outputs < 0 || inputs + outputs < 1 || inputs === 0 && outputs < 2 || inputs + outputs > 168)
+    throw new Error("unsupported transact shape");
+  return TRANSACT_CAPACITIES.find((n) => inputs + outputs <= n);
+}
+function normalizeTransactRequest(c, p, cs, funding = {}) {
+  const ctx = normalizeContext(c);
+  if (getAddress5(p.token) !== ctx.tokenAddress)
+    throw new Error("request token mismatch");
+  known(p, [
+    "token",
+    "sources",
+    "nullifiers",
+    "outputCommitments",
+    "withdrawalAddress",
+    "withdrawalAmount",
+    "deadline"
+  ]);
+  const ns = notes(p.nullifiers, "nullifiers"), os = notes(p.outputCommitments, "outputCommitments"), capacity = selectTransactCapacity(ns.length, os.length);
+  const sources = normalizeSources(p.sources, ns.length, capacity), deliveries = dense(cs, "deliveries").map((v) => normalizeDelivery(v));
+  if (deliveries.length !== os.length) throw new Error("deliveries count mismatch");
+  const withdrawalAmount = uint(p.withdrawalAmount, 128, "withdrawalAmount"), withdrawalAddress = getAddress5(p.withdrawalAddress), f = normalizeFunding(funding);
+  if (withdrawalAmount === 0n !== (BigInt(withdrawalAddress) === 0n) || os.length === 0 && withdrawalAmount === 0n)
+    throw new Error("invalid withdrawal");
+  if (ns.length === 0 && (f.amount === 0n || withdrawalAmount !== 0n))
+    throw new Error("zero inputs require positive funding and zero withdrawal");
+  return {
+    ...ctx,
+    capacity,
+    sources,
+    nullifiers: ns,
+    outputCommitments: os,
+    inputCount: ns.length,
+    outputCount: os.length,
+    sourceCount: sources.length,
+    inputTreeIds: pad(
+      sources.map((s) => s.treeId),
+      capacity
+    ),
+    merkleRoots: pad(
+      sources.map((s) => BigInt(s.merkleRoot)),
+      capacity
+    ),
+    slotValues: pad([...ns, ...os].map(BigInt), capacity),
+    deliveries,
+    deliveriesHash: deliveriesHash(deliveries),
+    withdrawalAddress,
+    withdrawalAmount,
+    deadline: checkDeadline(c, p.deadline),
+    depositAmount: f.amount,
+    depositPayer: f.payer,
+    funding: f
+  };
+}
+function transactPublicInputs(c, p, cs, f = {}) {
+  const r = normalizeTransactRequest(c, p, cs, f), h = BigInt(r.deliveriesHash);
+  return [
+    r.chainId,
+    BigInt(r.protocolAddress),
+    BigInt(r.tokenAddress),
+    BigInt(r.inputCount),
+    BigInt(r.outputCount),
+    BigInt(r.sourceCount),
+    ...r.inputTreeIds,
+    ...r.merkleRoots,
+    ...r.slotValues,
+    h >> 128n,
+    h & (1n << 128n) - 1n,
+    BigInt(r.withdrawalAddress),
+    r.withdrawalAmount,
+    r.deadline,
+    r.depositAmount,
+    BigInt(r.depositPayer)
+  ].map(word);
+}
+function encodeTransactTypedData(c, p, deliveries, f = {}) {
+  const r = normalizeTransactRequest(c, p, deliveries, f);
+  return walletAuthorizationTypedData4({
+    context: { chainId: r.chainId, protocolAddress: BigInt(r.protocolAddress) },
+    operation: "transact",
+    capacity: r.capacity,
+    words: transactPublicInputs(c, p, deliveries, f).map(BigInt)
+  });
+}
+var singleTuple = [
+  "(address token,bytes32 merkleRoot,bytes32[] nullifiers,bytes32[] outputCommitments,uint256 inputTreeId,address withdrawalAddress,uint256 withdrawalAmount,uint256 deadline)"
+][0];
+var crossTuple = [
+  "(address token,(uint256 treeId,bytes32 merkleRoot)[] sources,bytes32[] nullifiers,bytes32[] outputCommitments,address withdrawalAddress,uint256 withdrawalAmount,uint256 deadline)"
+][0];
+function transactFundingRequestHash(proof, p, cs) {
+  const single = {
+    token: p.token,
+    merkleRoot: p.sources[0]?.merkleRoot ?? word(0n),
+    nullifiers: p.nullifiers,
+    outputCommitments: p.outputCommitments,
+    inputTreeId: p.sources[0]?.treeId ?? 0n,
+    withdrawalAddress: p.withdrawalAddress,
+    withdrawalAmount: p.withdrawalAmount,
+    deadline: p.deadline
+  };
+  return p.sources.length > 1 ? keccak2565(
+    AbiCoder4.defaultAbiCoder().encode(
+      [{ type: "bytes32" }, { type: "bytes32" }, crossTuple, { type: "bytes32" }].map(
+        (parameter) => ParamType4.from(parameter)
+      ),
+      [
+        keccak2565(new TextEncoder().encode("InvisiCrossTreeTransact")),
+        keccak2565(proof),
+        p,
+        deliveriesHash(cs)
+      ]
+    )
+  ) : keccak2565(
+    AbiCoder4.defaultAbiCoder().encode(
+      [{ type: "bytes32" }, singleTuple, { type: "bytes32" }].map(
+        (parameter) => ParamType4.from(parameter)
+      ),
+      [keccak2565(proof), single, deliveriesHash(cs)]
+    )
+  );
+}
+function encodeTransactFundingTypedData(c, proof, p, cs, funding) {
+  normalizeTransactRequest(c, p, cs, funding);
+  const f = normalizeFunding(funding);
+  if (f.amount === 0n) throw new Error("funding authorization requires positive deposit");
+  return {
+    domain: getEIP712Domain(c),
+    primaryType: "FundTransact",
+    types: { FundTransact: fundingFields },
+    message: {
+      requestHash: transactFundingRequestHash(proof, p, cs),
+      payer: f.payer,
+      amount: f.amount,
+      sigNonce: f.sigNonce,
+      deadline: f.deadline
+    }
+  };
+}
+function buildTransactCalldata(p) {
+  const r = normalizeTransactRequest(p.context, p.params, p.deliveries, p.funding);
+  validateFundingSubmission(r.funding, p.caller, p.context.now);
+  const request = {
+    params: {
+      token: r.tokenAddress,
+      sources: r.sources,
+      nullifiers: r.nullifiers,
+      outputCommitments: r.outputCommitments,
+      withdrawalAddress: r.withdrawalAddress,
+      withdrawalAmount: r.withdrawalAmount,
+      deadline: r.deadline
+    },
+    deliveries: p.deliveries,
+    funding: r.funding
+  };
+  const abi = invisiProtocolAbi.filter(
+    (item) => item.type === "function" && item.name === "transact" && item.inputs.length === 2 && item.inputs[1]?.type === "tuple"
+  );
+  const data = new Interface4(abi).encodeFunctionData("transact", [p.proof, request]);
+  return { data, capacity: r.capacity, approveAmount: r.depositAmount };
+}
+function buildTransactAggregateCalldata(p) {
+  if (![4, 8, 12].includes(dense(p.requests, "requests").length))
+    throw new Error("aggregate requires 4, 8 or 12 requests");
+  for (const request of p.requests) {
+    const r = normalizeTransactRequest(
+      { ...p.context, tokenAddress: request.params.token },
+      request.params,
+      request.deliveries,
+      request.funding
+    );
+    if (r.capacity !== 14) throw new Error("aggregate supports only capacity 14");
+    validateFundingSubmission(r.funding, p.caller, p.context.now);
+  }
+  return {
+    data: new Interface4(
+      invisiProtocolAbi.filter(
+        (item) => item.type === "function" && item.name === "transact" && item.inputs[1]?.type === "tuple[]"
+      )
+    ).encodeFunctionData("transact", [p.proof, p.requests]),
+    capacity: 14
+  };
+}
+async function validateShieldRequest(p) {
+  normalizeContext(p.context);
+  if (getAddress5(p.params.token) !== getAddress5(p.context.tokenAddress))
+    throw new Error("request token mismatch");
+  known(p.params, ["token", "outputCommitments", "deadline"]);
+  checkDeadline(p.context, p.params.deadline);
+  const outputs = dense(p.outputs, "outputs"), commitments = notes(p.params.outputCommitments, "outputCommitments"), cs = dense(p.deliveries, "deliveries"), f = normalizeFunding(p.funding);
+  if (outputs.length < 1 || outputs.length > 10 || commitments.length !== outputs.length || cs.length !== outputs.length)
+    throw new Error("shield requires 1..10 outputs and matching deliveries");
+  let total = 0n;
+  for (const [i, o] of outputs.entries()) {
+    known(o, ["identity", "amount"], "output");
+    uint(o.amount, 128, "amount");
+    if (o.amount === 0n) throw new Error("amount must be positive");
+    field(o.identity);
+    normalizeDelivery(cs[i]);
+    if (await computeNoteCommitment(
+      p.context.chainId,
+      o.identity,
+      BigInt(p.context.tokenAddress),
+      o.amount
+    ) !== commitments[i])
+      throw new Error("output commitment mismatch");
+    total += o.amount;
+  }
+  if (total !== f.amount) throw new Error("funding must equal output total");
+  return f;
+}
+function shieldFundingRequestHash(params, outputs, cs) {
+  const outputHash = keccak2565(
+    AbiCoder4.defaultAbiCoder().encode(
+      ["(bytes32 identity,uint256 amount)[]"].map((parameter) => ParamType4.from(parameter)),
+      [outputs]
+    )
+  );
+  return keccak2565(
+    AbiCoder4.defaultAbiCoder().encode(
+      [
+        "bytes32",
+        "(address token,bytes32[] outputCommitments,uint256 deadline)",
+        "bytes32",
+        "bytes32"
+      ].map((parameter) => ParamType4.from(parameter)),
+      [
+        keccak2565(new TextEncoder().encode("InvisiShield")),
+        params,
+        outputHash,
+        deliveriesHash(cs)
+      ]
+    )
+  );
+}
+async function encodeShieldFundingTypedData(p) {
+  const f = await validateShieldRequest(p);
+  return {
+    domain: getEIP712Domain(p.context),
+    primaryType: "FundShield",
+    types: { FundShield: fundingFields },
+    message: {
+      requestHash: shieldFundingRequestHash(p.params, p.outputs, p.deliveries),
+      payer: f.payer,
+      amount: f.amount,
+      sigNonce: f.sigNonce,
+      deadline: f.deadline
+    }
+  };
+}
+async function buildShieldCalldata(p) {
+  const f = await validateShieldRequest(p);
+  validateFundingSubmission(f, p.caller, p.context.now);
+  return {
+    data: new Interface4(invisiProtocolAbi).encodeFunctionData("shield", [
+      p.params,
+      p.outputs,
+      p.deliveries,
+      f
+    ]),
+    approveAmount: f.amount
+  };
+}
+function transactUserPublicInputs(c, p, cs, f = {}) {
+  const words = transactPublicInputs(c, p, cs, f), digest = BigInt(
+    ((typed) => TypedDataEncoder.hash(
+      typed.domain,
+      Object.fromEntries(
+        Object.entries(typed.types).map(([name, fields]) => [
+          name,
+          [...fields]
+        ])
+      ),
+      typed.message
+    ))(encodeTransactTypedData(c, p, cs, f))
+  );
+  return [...words, word(digest >> 128n), word(digest & (1n << 128n) - 1n)];
+}
+function aggregateMemberRequestHash(c, r) {
+  const capacity = selectTransactCapacity(
+    r.params.nullifiers.length,
+    r.params.outputCommitments.length
+  );
+  if (capacity !== 14) throw new Error("aggregate supports only capacity 14");
+  return keccak2565(
+    AbiCoder4.defaultAbiCoder().encode(
+      ["bytes32", "uint256", "bytes32[]"].map((parameter) => ParamType4.from(parameter)),
+      [
+        keccak2565(new TextEncoder().encode("InvisiAtomicBatchMemberV1")),
+        BigInt(capacity),
+        transactPublicInputs(c, r.params, r.deliveries, r.funding)
+      ]
+    )
+  );
+}
+function aggregatePublicInputs(c, requests) {
+  if (![4, 8, 12].includes(dense(requests, "requests").length))
+    throw new Error("aggregate requires 4, 8 or 12 requests");
+  return requests.flatMap((r) => {
+    const context = { ...c, tokenAddress: r.params.token };
+    aggregateMemberRequestHash(context, r);
+    return [word(14n), ...transactPublicInputs(context, r.params, r.deliveries, r.funding)];
+  });
+}
+function encodeAggregateFundingTypedData(c, r) {
+  const f = normalizeFunding(r.funding);
+  if (f.amount === 0n) throw new Error("funding authorization requires positive deposit");
+  return {
+    domain: getEIP712Domain(c),
+    primaryType: "FundTransact",
+    types: { FundTransact: fundingFields },
+    message: {
+      requestHash: aggregateMemberRequestHash(c, r),
+      payer: f.payer,
+      amount: f.amount,
+      sigNonce: f.sigNonce,
+      deadline: f.deadline
+    }
+  };
+}
+
+// src/witness-layouts.json
+var witness_layouts_default = {
+  transact_user_slots14: {
+    artifactSha256: "486a749ae3944ae83a7ff2d298e7469b18737d88553a7d99c4782f22f7332996",
+    keys: {
+      evm: "7b3e65d5201246e733a1816489d80acb219a98e8606e1b81e6d48ff0c1fd537a",
+      "noir-recursive": "148957e28e6339a8ce1121851fb7a232e31f4c5b741e415733b8d627f4b62649"
+    },
+    publicInputCount: 57,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "output_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_tree_ids",
+        count: 14,
+        array: true
+      },
+      {
+        name: "merkle_roots",
+        count: 14,
+        array: true
+      },
+      {
+        name: "slot_values",
+        count: 14,
+        array: true
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "withdrawal_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "withdrawal_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_payer",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "wallet_identity",
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "output_wallet_identities",
+      "amounts",
+      "nonces",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices"
+    ]
+  },
+  transact_user_slots56: {
+    artifactSha256: "169db2ff23c15adb14756edf9bb99bbd343df807b3e1c7f1f510070897e653cf",
+    keys: {
+      evm: "cbf54de94bff266bf846f9722c0f3ffa1fb7a0f9f478466f193de0e9123ce7f5"
+    },
+    publicInputCount: 183,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "output_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_tree_ids",
+        count: 56,
+        array: true
+      },
+      {
+        name: "merkle_roots",
+        count: 56,
+        array: true
+      },
+      {
+        name: "slot_values",
+        count: 56,
+        array: true
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "withdrawal_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "withdrawal_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_payer",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "wallet_identity",
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "output_wallet_identities",
+      "amounts",
+      "nonces",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices"
+    ]
+  },
+  transact_user_slots112: {
+    artifactSha256: "221bbbd6ff0c7d7dec74677e52484f082b3e176bb0fa47f3236064e396d73739",
+    keys: {
+      evm: "67b2d361b023f193ecdb5a9aefbe2840349ee5ce848ab4101416734f3a7e91e9"
+    },
+    publicInputCount: 351,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "output_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_tree_ids",
+        count: 112,
+        array: true
+      },
+      {
+        name: "merkle_roots",
+        count: 112,
+        array: true
+      },
+      {
+        name: "slot_values",
+        count: 112,
+        array: true
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "withdrawal_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "withdrawal_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_payer",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "wallet_identity",
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "output_wallet_identities",
+      "amounts",
+      "nonces",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices"
+    ]
+  },
+  transact_user_slots168: {
+    artifactSha256: "d479253eaaacc973806a84e142e2362d873bba0f150ce050d32b8d9b2947adc8",
+    keys: {
+      evm: "c50e72b0718c6393f82f5a67e248ba093d0db56ece42bbf092da93e9369c2624"
+    },
+    publicInputCount: 519,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "output_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_tree_ids",
+        count: 168,
+        array: true
+      },
+      {
+        name: "merkle_roots",
+        count: 168,
+        array: true
+      },
+      {
+        name: "slot_values",
+        count: 168,
+        array: true
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "withdrawal_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "withdrawal_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_payer",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "wallet_identity",
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "output_wallet_identities",
+      "amounts",
+      "nonces",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices"
+    ]
+  },
+  transact_aggregate_14_4: {
+    artifactSha256: "4fe7c63fb80cba35af4c4525fbabcfb75033286e681afbdcb3fb043c03456246",
+    keys: {
+      evm: "664d4ff0de6b8c876ce990ea368d7a59cee411463c24dd5621d64c8949554674"
+    },
+    publicInputCount: 229,
+    public: [
+      {
+        name: "statements",
+        count: 4,
+        array: true
+      },
+      {
+        name: "inner_vk_commitment",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "verification_key",
+      "key_hash",
+      "proofs"
+    ]
+  },
+  transact_aggregate_14_8: {
+    artifactSha256: "0a266ad4bb4c6dce42b1e851fcbb34b1becae1edd6bf6af82d7b9ed7184576df",
+    keys: {
+      evm: "042139122d0eee8beeaa9c18397276fa5a2872218495fa16ca438fbdd80fa3e1"
+    },
+    publicInputCount: 457,
+    public: [
+      {
+        name: "statements",
+        count: 8,
+        array: true
+      },
+      {
+        name: "inner_vk_commitment",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "verification_key",
+      "key_hash",
+      "proofs"
+    ]
+  },
+  transact_aggregate_14_12: {
+    artifactSha256: "738849e83eb4a78eb69cb6e20a86f6f27ba3784d04a83abd338f84de5c20d7d2",
+    keys: {
+      evm: "539928b264aea4d07a41e772d5d5a7b7666a6883decb985c27ca7422e7f8ea1f"
+    },
+    publicInputCount: 685,
+    public: [
+      {
+        name: "statements",
+        count: 12,
+        array: true
+      },
+      {
+        name: "inner_vk_commitment",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "verification_key",
+      "key_hash",
+      "proofs"
+    ]
+  },
+  create_credit: {
+    artifactSha256: "078c6d2da1ed2d6bd27fab28af9970261fe626a0b22ae56ad170e5d15b1b05ba",
+    keys: {
+      evm: "8285456447e92833a4fa9c330b9c667a3a1b9e48649578082041b9738f037c8f"
+    },
+    publicInputCount: 46,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "owner_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "actual_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_tree_ids",
+        count: 10,
+        array: true
+      },
+      {
+        name: "merkle_roots",
+        count: 10,
+        array: true
+      },
+      {
+        name: "nullifiers",
+        count: 10,
+        array: true
+      },
+      {
+        name: "credit_commitment",
+        count: 1,
+        array: false
+      },
+      {
+        name: "change_commitment",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "expiry",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_payer",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "input_amounts",
+      "input_nonces",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices",
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "spender_payout",
+      "spender_wallet_identity",
+      "owner_wallet_identity",
+      "credit_amount",
+      "credit_nonce",
+      "credit_shared_key",
+      "change_amount",
+      "change_nonce"
+    ]
+  },
+  credit_draw_slots1: {
+    artifactSha256: "2b9da9d3d1dbd411d9be1bbe2b34305ac5dce7c7d18e3857d8e2be7dd9bf7c21",
+    keys: {
+      evm: "613699a440f50a0937e4c57e5152b5fdea42c31b10157d6b93226fef313df553"
+    },
+    publicInputCount: 18,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "spender_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "actual_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "tree_ids",
+        count: 1,
+        array: true
+      },
+      {
+        name: "roots",
+        count: 1,
+        array: true
+      },
+      {
+        name: "nullifiers",
+        count: 1,
+        array: true
+      },
+      {
+        name: "remainder_commitments",
+        count: 1,
+        array: true
+      },
+      {
+        name: "expiries",
+        count: 1,
+        array: true
+      },
+      {
+        name: "total_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "recovery_amounts",
+        count: 1,
+        array: true
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "spender_wallet_identity",
+      "owner_payouts",
+      "owner_wallet_identities",
+      "input_amounts",
+      "input_nonces",
+      "credit_shared_keys",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices",
+      "draw_amounts"
+    ]
+  },
+  credit_draw_slots12: {
+    artifactSha256: "92b741e161a99c05b8810bc24cee6bafc1cebc85347ea47fe511ee6c8f7065be",
+    keys: {
+      evm: "a5ae214784fe6e523977ef4e283a6d217fc3f4ec0c5a40effb275693a74ee5ce"
+    },
+    publicInputCount: 84,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "spender_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "actual_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "tree_ids",
+        count: 12,
+        array: true
+      },
+      {
+        name: "roots",
+        count: 12,
+        array: true
+      },
+      {
+        name: "nullifiers",
+        count: 12,
+        array: true
+      },
+      {
+        name: "remainder_commitments",
+        count: 12,
+        array: true
+      },
+      {
+        name: "expiries",
+        count: 12,
+        array: true
+      },
+      {
+        name: "total_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "recovery_amounts",
+        count: 12,
+        array: true
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "spender_wallet_identity",
+      "owner_payouts",
+      "owner_wallet_identities",
+      "input_amounts",
+      "input_nonces",
+      "credit_shared_keys",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices",
+      "draw_amounts"
+    ]
+  },
+  credit_draw_slots50: {
+    artifactSha256: "9c6a23d5dbca3a1aeed461c908f228e89642550775cbc519d633bb1c984a3d04",
+    keys: {
+      evm: "f0b192e2cb312148c7a16fae3acaed9efb01b0c6a1b381ce03468f00b4ef0f2a"
+    },
+    publicInputCount: 312,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "spender_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "actual_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "tree_ids",
+        count: 50,
+        array: true
+      },
+      {
+        name: "roots",
+        count: 50,
+        array: true
+      },
+      {
+        name: "nullifiers",
+        count: 50,
+        array: true
+      },
+      {
+        name: "remainder_commitments",
+        count: 50,
+        array: true
+      },
+      {
+        name: "expiries",
+        count: 50,
+        array: true
+      },
+      {
+        name: "total_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "recovery_amounts",
+        count: 50,
+        array: true
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "spender_wallet_identity",
+      "owner_payouts",
+      "owner_wallet_identities",
+      "input_amounts",
+      "input_nonces",
+      "credit_shared_keys",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices",
+      "draw_amounts"
+    ]
+  },
+  credit_draw_slots120: {
+    artifactSha256: "69686a4f0a8a98d8cef06485b0de1804ca2e8f47ce0244287a03ceef4d67625a",
+    keys: {
+      evm: "6f32ca89775f332a9193af9b1e25641ef14fda9fbdd2685c33ee775d3c170b92"
+    },
+    publicInputCount: 732,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "spender_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "actual_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "tree_ids",
+        count: 120,
+        array: true
+      },
+      {
+        name: "roots",
+        count: 120,
+        array: true
+      },
+      {
+        name: "nullifiers",
+        count: 120,
+        array: true
+      },
+      {
+        name: "remainder_commitments",
+        count: 120,
+        array: true
+      },
+      {
+        name: "expiries",
+        count: 120,
+        array: true
+      },
+      {
+        name: "total_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "recovery_amounts",
+        count: 120,
+        array: true
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "spender_wallet_identity",
+      "owner_payouts",
+      "owner_wallet_identities",
+      "input_amounts",
+      "input_nonces",
+      "credit_shared_keys",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices",
+      "draw_amounts"
+    ]
+  },
+  credit_cancel: {
+    artifactSha256: "ff278a04f22d2886c9f27f7785a0b8fc317dd242fd4aa9d0d9398d18b7513daf",
+    keys: {
+      evm: "1f8a3c20cb081d6a90962556da3124919cc4e5675e59ad31562af39299da02fb"
+    },
+    publicInputCount: 11,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "owner_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "tree_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "merkle_root",
+        count: 1,
+        array: false
+      },
+      {
+        name: "nullifier",
+        count: 1,
+        array: false
+      },
+      {
+        name: "amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "spender_payout",
+      "spender_wallet_identity",
+      "owner_wallet_identity",
+      "input_nonce",
+      "expiry",
+      "credit_shared_key",
+      "leaf_index",
+      "merkle_path"
+    ]
+  },
+  credit_top_up: {
+    artifactSha256: "fbe662363d9814983f7940f74369117cd6c84783945fbf527b0ed48d011b58a4",
+    keys: {
+      evm: "44436f31414497a708355426da051ee48ba63fdebcb6cfd72347c37c34c98c50"
+    },
+    publicInputCount: 50,
+    public: [
+      {
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "protocol_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "token_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "owner_address",
+        count: 1,
+        array: false
+      },
+      {
+        name: "actual_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "source_count",
+        count: 1,
+        array: false
+      },
+      {
+        name: "input_tree_ids",
+        count: 10,
+        array: true
+      },
+      {
+        name: "merkle_roots",
+        count: 10,
+        array: true
+      },
+      {
+        name: "nullifiers",
+        count: 10,
+        array: true
+      },
+      {
+        name: "credit_commitment",
+        count: 1,
+        array: false
+      },
+      {
+        name: "change_commitment",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "delivery_hash_low",
+        count: 1,
+        array: false
+      },
+      {
+        name: "expiry",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deadline",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_amount",
+        count: 1,
+        array: false
+      },
+      {
+        name: "deposit_payer",
+        count: 1,
+        array: false
+      },
+      {
+        name: "credit_tree_id",
+        count: 1,
+        array: false
+      },
+      {
+        name: "credit_merkle_root",
+        count: 1,
+        array: false
+      },
+      {
+        name: "credit_nullifier",
+        count: 1,
+        array: false
+      },
+      {
+        name: "previous_expiry",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "input_amounts",
+      "input_nonces",
+      "leaf_indices",
+      "merkle_paths",
+      "input_source_indices",
+      "public_key_x",
+      "public_key_y",
+      "signature",
+      "spender_payout",
+      "spender_wallet_identity",
+      "owner_wallet_identity",
+      "credit_amount",
+      "credit_nonce",
+      "credit_shared_key",
+      "change_amount",
+      "change_nonce",
+      "previous_credit_amount",
+      "previous_credit_nonce",
+      "previous_credit_leaf_index",
+      "previous_credit_merkle_path"
+    ]
+  },
+  wallet_registration: {
+    artifactSha256: "65c3d429f6bc9735af3136f7c383214c2eb222cd32655791f37f7ae5dd428048",
+    keys: {
+      evm: "b8171bdb558489c75293ee71f64c1ac534f533ae3b3f71107378e46dbd93dd48"
+    },
+    publicInputCount: 3,
+    public: [
+      {
+        name: "wallet_identity",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_high",
+        count: 1,
+        array: false
+      },
+      {
+        name: "auth_digest_low",
+        count: 1,
+        array: false
+      }
+    ],
+    private: [
+      "public_key_x",
+      "public_key_y",
+      "signature"
+    ]
+  }
+};
+
+// src/witness.ts
+var pad2 = (values, count, zero) => {
+  if (values.length > count) throw new Error("witness capacity exceeded");
+  return [...values, ...Array.from({ length: count - values.length }, zero)];
+};
+var zeros = () => Array(16).fill(0n);
+var zeroAuthority = () => ({
+  public_key_x: Array(32).fill(0),
+  public_key_y: Array(32).fill(0),
+  signature: Array(64).fill(0)
+});
+function check(ok, message) {
+  if (!ok) throw new Error(message);
+}
+function provingRequest(circuitName, privateInputs, expectedPublicInputs, target = "evm") {
+  const schema = witness_layouts_default[circuitName], key = schema.keys[target];
+  check(typeof key === "string", "unpublished proof target");
+  check(
+    expectedPublicInputs.length === schema.publicInputCount,
+    "public input order/width mismatch"
+  );
+  check(
+    Object.keys(privateInputs).length === schema.private.length && schema.private.every((name) => Object.hasOwn(privateInputs, name)),
+    "private witness schema mismatch"
+  );
+  let offset = 0;
+  const publicInputs = {};
+  for (const entry of schema.public) {
+    const values = expectedPublicInputs.slice(offset, offset + entry.count).map((value) => {
+      const n = BigInt(value);
+      check(n >= 0n && n < FIELD_MODULUS, "noncanonical public input");
+      return n;
+    });
+    publicInputs[entry.name] = entry.array ? values : values[0];
+    offset += entry.count;
+  }
+  check(offset === expectedPublicInputs.length, "public input layout mismatch");
+  return {
+    circuitName,
+    target,
+    artifactSha256: schema.artifactSha256,
+    vkSha256: key,
+    expectedPublicInputs: [...expectedPublicInputs],
+    witness: new LocalWitness({ ...privateInputs, ...publicInputs })
+  };
+}
+var WitnessBuilder = class {
+  #protocol;
+  constructor(protocol) {
+    this.#protocol = protocol;
+  }
+  static statement(circuitName, expectedPublicInputs, target = "evm") {
+    const schema = witness_layouts_default[circuitName], key = schema.keys[target];
+    check(
+      typeof key === "string" && expectedPublicInputs.length === schema.publicInputCount,
+      "unpublished target or statement width mismatch"
+    );
+    return {
+      circuitName,
+      target,
+      artifactSha256: schema.artifactSha256,
+      vkSha256: key,
+      expectedPublicInputs: [...expectedPublicInputs]
+    };
+  }
+  context(note) {
+    const c = this.#protocol.context;
+    check(
+      note.chainId === c.chainId && note.protocolAddress === BigInt(c.protocolAddress) && note.tokenAddress === BigInt(c.tokenAddress),
+      "note context mismatch"
+    );
+  }
+  async authority(operation, capacity, words, signed, identity) {
+    check(!!signed, "private wallet authorization required");
+    const c = this.#protocol.context, request = {
+      context: { chainId: c.chainId, protocolAddress: BigInt(c.protocolAddress) },
+      operation,
+      capacity,
+      words: words.slice(0, -2).map(BigInt)
+    };
+    check(
+      signed.walletIdentity === identity && signed.digest === computeWalletAuthorizationDigest4(request),
+      "authorization statement mismatch"
+    );
+    const witness = signed.withWitness((value) => value);
+    check(
+      await verifyWalletAuthorization(
+        identity,
+        Uint8Array.from([4, ...witness.public_key_x, ...witness.public_key_y]),
+        Uint8Array.from(witness.signature),
+        request
+      ),
+      "invalid wallet authorization"
+    );
+    return witness;
+  }
+  async membership(leaf, input, sources) {
+    const source = sources.findIndex((value) => value.treeId === input.treeId);
+    check(
+      source >= 0 && Number.isInteger(input.leafIndex) && input.leafIndex >= 0 && input.leafIndex < 65536 && input.path.length === 16,
+      "invalid membership position"
+    );
+    let root = BigInt(leaf);
+    for (let level = 0; level < 16; level++)
+      root = BigInt(
+        await poseidonHash(
+          input.leafIndex >> level & 1 ? [input.path[level], root] : [root, input.path[level]]
+        )
+      );
+    check(root === BigInt(sources[source].merkleRoot), "membership root mismatch");
+    return source;
+  }
+  async noteLeaf(note) {
+    this.context(note);
+    return computeNoteCommitment2(
+      note.chainId,
+      await computeNoteIdentity(BigInt(note.walletIdentity), note.nonce),
+      note.tokenAddress,
+      note.amount
+    );
+  }
+  async creditLeaf(note) {
+    this.context(note);
+    return computeCreditCommitment(
+      note.chainId,
+      note.spenderWalletIdentity,
+      note.ownerWalletIdentity,
+      note.spenderPayout,
+      note.ownerPayout,
+      note.tokenAddress,
+      note.amount,
+      note.nonce,
+      note.expiry,
+      await computeCreditSharedKeyHash(note.creditSharedKey)
+    );
+  }
+  async noteInputs(inputs, sources, nullifiers, identity, authority) {
+    check(inputs.length === nullifiers.length, "input count mismatch");
+    return Promise.all(
+      inputs.map(async (input, i) => {
+        check(input.note.walletIdentity === identity, "input wallet mismatch");
+        const leaf = await this.noteLeaf(input.note);
+        check(
+          await computeNoteNullifier(input.note.chainId, input.note.nonce, leaf) === nullifiers[i],
+          "input nullifier mismatch"
+        );
+        return BigInt(await this.membership(leaf, input, sources));
+      })
+    );
+  }
+  async transact(p) {
+    const c = this.#protocol.context, n = normalizeTransactRequest(c, p.params, p.deliveries, p.funding), words = transactUserPublicInputs(c, p.params, p.deliveries, p.funding);
+    check(
+      p.inputs.length === n.inputCount && p.outputs.length === n.outputCount,
+      "note count mismatch"
+    );
+    const identity = p.inputs[0]?.note.walletIdentity;
+    const unsignedSweep = !!identity && !p.authorization && n.outputCount === 0 && n.depositAmount === 0n && BigInt(p.params.withdrawalAddress) === BigInt(identity);
+    const authority = identity && !unsignedSweep ? await this.authority("transact", n.capacity, words, p.authorization, identity) : zeroAuthority();
+    const sources = await this.noteInputs(
+      p.inputs,
+      p.params.sources,
+      p.params.nullifiers,
+      identity ?? "0x" + "00".repeat(32),
+      authority
+    );
+    for (const [i, note] of p.outputs.entries())
+      check(
+        await this.noteLeaf(note) === p.params.outputCommitments[i],
+        "output commitment mismatch"
+      );
+    const all = [...p.inputs.map((input) => input.note), ...p.outputs];
+    return provingRequest(
+      `transact_user_slots${n.capacity}`,
+      {
+        wallet_identity: identity ? BigInt(identity) : 0n,
+        ...authority,
+        output_wallet_identities: pad2(
+          [
+            ...p.inputs.map(() => 0n),
+            ...p.outputs.map((note) => BigInt(note.walletIdentity))
+          ],
+          n.capacity,
+          () => 0n
+        ),
+        amounts: pad2(
+          all.map((note) => note.amount),
+          n.capacity,
+          () => 0n
+        ),
+        nonces: pad2(
+          all.map((note) => note.nonce),
+          n.capacity,
+          () => 0n
+        ),
+        leaf_indices: pad2(
+          p.inputs.map((input) => BigInt(input.leafIndex)),
+          n.capacity,
+          () => 0n
+        ),
+        merkle_paths: pad2(
+          p.inputs.map((input) => [...input.path]),
+          n.capacity,
+          zeros
+        ),
+        input_source_indices: pad2(sources, n.capacity, () => 0n)
+      },
+      words,
+      p.target
+    );
+  }
+  async creation(p, operation, words) {
+    const state = normalizeCreditDeliveryState(p.state), note = state.note;
+    check(
+      await this.creditLeaf(note) === p.params.creditCommitment && note.ownerPayout === BigInt(p.params.owner) && note.expiry === p.params.expiry,
+      "Credit creation mismatch"
+    );
+    const authority = await this.authority(
+      operation,
+      10,
+      words,
+      p.authorization,
+      note.ownerWalletIdentity
+    );
+    const sources = await this.noteInputs(
+      p.inputs,
+      p.params.sources,
+      p.params.nullifiers,
+      note.ownerWalletIdentity,
+      authority
+    );
+    if (p.change)
+      check(
+        p.change.walletIdentity === note.ownerWalletIdentity && await this.noteLeaf(p.change) === p.params.changeCommitment,
+        "change commitment mismatch"
+      );
+    else check(BigInt(p.params.changeCommitment) === 0n, "missing change note");
+    return {
+      ...authority,
+      input_amounts: pad2(
+        p.inputs.map((input) => input.note.amount),
+        10,
+        () => 0n
+      ),
+      input_nonces: pad2(
+        p.inputs.map((input) => input.note.nonce),
+        10,
+        () => 0n
+      ),
+      leaf_indices: pad2(
+        p.inputs.map((input) => BigInt(input.leafIndex)),
+        10,
+        () => 0n
+      ),
+      merkle_paths: pad2(
+        p.inputs.map((input) => [...input.path]),
+        10,
+        zeros
+      ),
+      input_source_indices: pad2(sources, 10, () => 0n),
+      spender_payout: note.spenderPayout,
+      spender_wallet_identity: BigInt(note.spenderWalletIdentity),
+      owner_wallet_identity: BigInt(note.ownerWalletIdentity),
+      credit_amount: note.amount,
+      credit_nonce: note.nonce,
+      credit_shared_key: note.creditSharedKey,
+      change_amount: p.change?.amount ?? 0n,
+      change_nonce: p.change?.nonce ?? 0n
+    };
+  }
+  async createCredit(p) {
+    const words = createCreditPublicInputs(
+      this.#protocol.context,
+      p.params,
+      p.deliveries,
+      p.funding
+    );
+    return provingRequest(
+      "create_credit",
+      await this.creation(p, "create-credit", words),
+      words
+    );
+  }
+  async cancelCredit(p) {
+    const note = normalizeCreditDeliveryState(p.input.state).note, leaf = await this.creditLeaf(note), c = this.#protocol.context;
+    check(
+      await computeCreditNullifier(c.chainId, note.creditSharedKey, leaf) === p.params.nullifier && note.amount === p.params.amount && note.ownerPayout === BigInt(p.params.owner),
+      "Credit cancellation mismatch"
+    );
+    await this.membership(leaf, p.input, [p.params.source]);
+    const words = cancelCreditPublicInputs(c, p.params), authority = await this.authority(
+      "cancel-credit",
+      1,
+      words,
+      p.authorization,
+      note.ownerWalletIdentity
+    );
+    return provingRequest(
+      "credit_cancel",
+      {
+        ...authority,
+        spender_payout: note.spenderPayout,
+        spender_wallet_identity: BigInt(note.spenderWalletIdentity),
+        owner_wallet_identity: BigInt(note.ownerWalletIdentity),
+        input_nonce: note.nonce,
+        expiry: note.expiry,
+        credit_shared_key: note.creditSharedKey,
+        leaf_index: BigInt(p.input.leafIndex),
+        merkle_path: [...p.input.path]
+      },
+      words
+    );
+  }
+  async drawCredit(p) {
+    const c = this.#protocol.context, profile = selectCreditDrawCircuit(p.inputs.length), capacity = profile.maxSize;
+    check(
+      p.inputs.length === p.amounts.length && p.inputs.length === p.params.nullifiers.length,
+      "draw input count mismatch"
+    );
+    const notes2 = p.inputs.map((input) => normalizeCreditDeliveryState(input.state).note), identity = notes2[0].spenderWalletIdentity;
+    const words = creditDrawPublicInputs(c, p.params, p.deliveries), authority = await this.authority(
+      "credit-draw",
+      capacity,
+      words,
+      p.authorization,
+      identity
+    );
+    const sourceIndices = await Promise.all(
+      notes2.map(async (note, i) => {
+        const leaf = await this.creditLeaf(note);
+        check(
+          note.spenderWalletIdentity === identity && note.spenderPayout === BigInt(p.params.spender) && note.expiry === p.params.expiries[i] && p.amounts[i] > 0n && p.amounts[i] <= note.amount && await computeCreditNullifier(c.chainId, note.creditSharedKey, leaf) === p.params.nullifiers[i],
+          "Credit draw mismatch"
+        );
+        return BigInt(await this.membership(leaf, p.inputs[i], p.params.sources));
+      })
+    );
+    return provingRequest(
+      profile.name,
+      {
+        ...authority,
+        spender_wallet_identity: BigInt(identity),
+        owner_payouts: pad2(
+          notes2.map((note) => note.ownerPayout),
+          capacity,
+          () => 0n
+        ),
+        owner_wallet_identities: pad2(
+          notes2.map((note) => BigInt(note.ownerWalletIdentity)),
+          capacity,
+          () => 0n
+        ),
+        input_amounts: pad2(
+          notes2.map((note) => note.amount),
+          capacity,
+          () => 0n
+        ),
+        input_nonces: pad2(
+          notes2.map((note) => note.nonce),
+          capacity,
+          () => 0n
+        ),
+        credit_shared_keys: pad2(
+          notes2.map((note) => note.creditSharedKey),
+          capacity,
+          () => 0n
+        ),
+        leaf_indices: pad2(
+          p.inputs.map((input) => BigInt(input.leafIndex)),
+          capacity,
+          () => 0n
+        ),
+        merkle_paths: pad2(
+          p.inputs.map((input) => [...input.path]),
+          capacity,
+          zeros
+        ),
+        input_source_indices: pad2(sourceIndices, capacity, () => 0n),
+        draw_amounts: pad2(p.amounts, capacity, () => 0n)
+      },
+      words
+    );
+  }
+  async topUpCredit(p) {
+    const c = this.#protocol.context, previous = normalizeCreditDeliveryState(p.previous.state), next = normalizeCreditDeliveryState(p.state), old = previous.note, note = next.note, leaf = await this.creditLeaf(old);
+    for (const field2 of [
+      "spenderWalletIdentity",
+      "ownerWalletIdentity",
+      "spenderPayout",
+      "ownerPayout",
+      "creditSharedKey"
+    ])
+      check(old[field2] === note[field2], "Credit role or payout changed");
+    check(
+      JSON.stringify(previous.ownerReceivingKeys) === JSON.stringify(next.ownerReceivingKeys) && JSON.stringify(previous.spenderReceivingKeys) === JSON.stringify(next.spenderReceivingKeys),
+      "Credit receiving snapshots changed"
+    );
+    check(
+      old.amount < note.amount && old.expiry <= note.expiry && old.expiry === p.params.previousExpiry && (c.now === void 0 || old.expiry > c.now),
+      "invalid Credit top-up"
+    );
+    check(
+      await computeCreditNullifier(c.chainId, old.creditSharedKey, leaf) === p.params.creditNullifier,
+      "previous Credit nullifier mismatch"
+    );
+    await this.membership(leaf, p.previous, [p.params.creditSource]);
+    const words = topUpCreditPublicInputs(c, p.params, p.deliveries, p.funding), base = await this.creation({ ...p, params: p.params.creation }, "top-up-credit", words);
+    return provingRequest(
+      "credit_top_up",
+      {
+        ...base,
+        previous_credit_amount: old.amount,
+        previous_credit_nonce: old.nonce,
+        previous_credit_leaf_index: BigInt(p.previous.leafIndex),
+        previous_credit_merkle_path: [...p.previous.path]
+      },
+      words
+    );
+  }
+  static async registration(context, registration, authorization, options) {
+    const request = registrationAuthorizationRequest(context, registration, options), words = registrationPublicInputs(context, registration, options);
+    check(
+      authorization.walletIdentity === registration.walletIdentity && authorization.digest === computeWalletAuthorizationDigest4(request),
+      "registry authorization mismatch"
+    );
+    const witness = authorization.withWitness((value) => value);
+    check(
+      await verifyWalletAuthorization(
+        registration.walletIdentity,
+        Uint8Array.from([4, ...witness.public_key_x, ...witness.public_key_y]),
+        Uint8Array.from(witness.signature),
+        request
+      ),
+      "invalid registry authority"
+    );
+    return provingRequest("wallet_registration", { ...witness }, words);
+  }
+};
+
+// src/RegistrationOperation.ts
+function check2(ok, message) {
+  if (!ok) {
+    throw new Error(message);
+  }
+}
+function publicProof(bundle) {
+  return {
+    formatVersion: bundle.formatVersion,
+    bbVersion: bundle.bbVersion,
+    circuitName: bundle.circuitName,
+    target: bundle.target,
+    artifactSha256: bundle.artifactSha256,
+    vkSha256: bundle.vkSha256,
+    proofHex: bundle.proofHex,
+    proofSha256: bundle.proofSha256,
+    publicInputs: [...bundle.publicInputs]
+  };
+}
+var RegistrationOperation = class _RegistrationOperation {
+  #registry;
+  #runtime;
+  #plan;
+  #authorization;
+  #proof;
+  #hash;
+  #anchor;
+  status;
+  constructor(registry, runtime, plan, status, authorization, proof, hash, anchor) {
+    this.#registry = registry;
+    this.#runtime = { ...runtime };
+    this.#plan = structuredClone(plan);
+    this.status = status;
+    this.#authorization = authorization;
+    this.#proof = proof ? publicProof(proof) : void 0;
+    this.#hash = hash;
+    this.#anchor = anchor ? { ...anchor } : void 0;
+    Object.freeze(this);
+  }
+  static async prepare(registry, options) {
+    const runtime = { ...options };
+    const update = options.update ?? false;
+    check2(typeof update === "boolean", "update must be boolean");
+    await registry.validateDeployment(runtime.reader);
+    const block = await runtime.reader.getBlock(await runtime.reader.getLatestBlockNumber());
+    const context = { ...registry.context, now: block.timestamp };
+    const nonce = await runtime.reader.getRegistryNonce(
+      context,
+      runtime.wallet.walletIdentity,
+      block
+    );
+    check2(
+      typeof nonce === "bigint" && nonce >= 0n && nonce < (1n << 64n) - 1n,
+      "invalid or exhausted registry nonce"
+    );
+    check2(
+      update ? nonce > 0n : nonce === 0n,
+      update ? "wallet is not registered" : "wallet is already registered; prepare an update"
+    );
+    const address = ReceivingAddress2.parse(await registry.resolve(runtime.wallet.getAddress()));
+    const keys = address.getReceivingKeys();
+    const registration = {
+      walletIdentity: runtime.wallet.walletIdentity,
+      keys: {
+        viewingPublicKey: hexlify2(keys.viewingPublicKey),
+        clueKey: hexlify2(keys.clueKey)
+      },
+      nonce,
+      deadline: options.deadline ?? block.timestamp + 300n
+    };
+    const words = registrationPublicInputs(context, registration, {
+      update,
+      expectedNonce: nonce
+    });
+    const statement = WitnessBuilder.statement("wallet_registration", words);
+    check2(
+      (await runtime.reader.getBlock(block.number)).hash === block.hash,
+      "canonical registry block changed while preparing"
+    );
+    return new _RegistrationOperation(
+      registry,
+      runtime,
+      { id: crypto.randomUUID(), context, registration, update, statement },
+      "prepared"
+    );
+  }
+  get id() {
+    return this.#plan.id;
+  }
+  preview() {
+    return {
+      id: this.id,
+      status: this.status,
+      chainId: this.#plan.context.chainId,
+      registryAddress: this.#plan.context.registryAddress,
+      ...structuredClone(this.#plan.registration),
+      update: this.#plan.update
+    };
+  }
+  async authorize(options = {}) {
+    check2(
+      this.status === "prepared" || this.status === "authorized",
+      "registry operation is not awaiting authorization"
+    );
+    options.signal?.throwIfAborted();
+    const provider = this.#runtime.authorization ?? this.#runtime.wallet.exportAuthorization();
+    const p = this.#plan;
+    check2(
+      provider.walletIdentity === p.registration.walletIdentity,
+      "registry wallet authorization capability mismatch"
+    );
+    const request = registrationAuthorizationRequest(p.context, p.registration, {
+      update: p.update,
+      expectedNonce: p.registration.nonce
+    });
+    const authorization = await provider.authorize(request);
+    check2(
+      authorization.walletIdentity === provider.walletIdentity && authorization.digest === computeWalletAuthorizationDigest5(request),
+      "registry authorization statement mismatch"
+    );
+    options.signal?.throwIfAborted();
+    return new _RegistrationOperation(
+      this.#registry,
+      this.#runtime,
+      p,
+      "authorized",
+      authorization
+    );
+  }
+  async prove(options = {}) {
+    check2(
+      this.status === "authorized" && this.#authorization,
+      "private registry authorization required"
+    );
+    const prover = this.#runtime.prover;
+    if (!prover) {
+      throw new MissingCapabilityError("registry prover");
+    }
+    const p = this.#plan;
+    const request = await WitnessBuilder.registration(
+      p.context,
+      p.registration,
+      this.#authorization,
+      { update: p.update, expectedNonce: p.registration.nonce }
+    );
+    check2(
+      JSON.stringify({ ...request, witness: void 0 }) === JSON.stringify(p.statement),
+      "registry proof statement changed"
+    );
+    try {
+      const proof = publicProof(await prover.prove(request, options));
+      const expected = p.statement;
+      check2(
+        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.publicInputs.length === 3 && proof.publicInputs.every(
+          (word2, i) => word2 === expected.expectedPublicInputs[i]
+        ),
+        "registry proof release or public statement mismatch"
+      );
+      check2(/^0x(?:[a-fA-F0-9]{2})+$/.test(proof.proofHex), "malformed registry proof");
+      const bytes = Uint8Array.from(
+        proof.proofHex.slice(2).match(/../g),
+        (byte) => parseInt(byte, 16)
+      );
+      const hash = hexlify2(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))).slice(2);
+      check2(
+        hash === proof.proofSha256 && await prover.verify(publicProof(proof), structuredClone(expected), options),
+        "registry proof verification failed"
+      );
+      options.signal?.throwIfAborted();
+      return new _RegistrationOperation(
+        this.#registry,
+        this.#runtime,
+        p,
+        "ready",
+        void 0,
+        proof
+      );
+    } catch {
+      options.signal?.throwIfAborted();
+      throw new Error("registry proof generation or verification failed");
+    }
+  }
+  call() {
+    check2(this.#proof, "registry proof is missing");
+    const p = this.#plan;
+    const result = buildRegistrationCalldata(p.context, p.registration, this.#proof.proofHex, {
+      update: p.update,
+      expectedNonce: p.registration.nonce
+    });
+    return { to: result.to, data: result.callData, value: result.value };
+  }
+  async exportTransaction() {
+    check2(
+      this.#proof && this.status !== "prepared" && this.status !== "authorized",
+      "registry operation is not ready"
+    );
+    await this.#registry.validateDeployment(this.#runtime.reader);
+    const block = await this.#runtime.reader.getBlock(
+      await this.#runtime.reader.getLatestBlockNumber()
+    );
+    const p = this.#plan;
+    check2(block.timestamp <= p.registration.deadline, "registry operation has expired");
+    check2(
+      await this.#runtime.reader.getRegistryNonce(
+        p.context,
+        p.registration.walletIdentity,
+        block
+      ) === p.registration.nonce,
+      "registry nonce changed; prepare again"
+    );
+    return this.call();
+  }
+  /** Associate a signed/broadcast transaction; ethers owns sending and receipt waiting. */
+  trackTransaction(transactionHash) {
+    check2(/^0x[a-fA-F0-9]{64}$/.test(transactionHash), "invalid registry transaction hash");
+    check2(
+      this.#proof && ["ready", "uncertain"].includes(this.status),
+      "registry operation is not ready"
+    );
+    return new _RegistrationOperation(
+      this.#registry,
+      this.#runtime,
+      this.#plan,
+      "uncertain",
+      void 0,
+      this.#proof,
+      transactionHash
+    );
+  }
+  async reconcile(options = {}) {
+    options.signal?.throwIfAborted();
+    const { reader } = this.#runtime;
+    const p = this.#plan;
+    await this.#registry.validateDeployment(reader);
+    if (this.#anchor && (await reader.getBlock(this.#anchor.number)).hash !== this.#anchor.hash) {
+      return new _RegistrationOperation(
+        this.#registry,
+        this.#runtime,
+        p,
+        "reorged",
+        void 0,
+        this.#proof,
+        this.#hash
+      );
+    }
+    const hash = options.transactionHash ?? this.#hash;
+    const receipt = hash ? await reader.getReceipt(hash) : null;
+    if (receipt) {
+      check2(
+        receipt.transactionHash === hash && (await reader.getBlock(receipt.block.number)).hash === receipt.block.hash,
+        "registry receipt is not canonical"
+      );
+      const transaction = await reader.getTransaction(hash);
+      const call = this.call();
+      check2(
+        transaction && transaction.transactionHash === hash && transaction.to.toLowerCase() === call.to.toLowerCase() && transaction.data.toLowerCase() === call.data.toLowerCase() && transaction.value === 0n,
+        "registry transaction differs from frozen request"
+      );
+      check2(
+        receipt.status === "success" || receipt.status === "reverted",
+        "registry execution status is missing"
+      );
+      if (receipt.status === "success") {
+        const found = receipt.logs.some((log) => {
+          if (log.address.toLowerCase() !== p.context.registryAddress.toLowerCase() || log.transactionHash !== hash) {
+            return false;
+          }
+          try {
+            const event = ((decoded) => ({
+              eventName: decoded.name,
+              args: decoded.args.toObject()
+            }))(
+              new Interface5(invisiAddressRegistryAbi).parseLog({
+                data: log.data,
+                topics: log.topics
+              })
+            );
+            return event.eventName === "ReceivingKeysSet" && BigInt(event.args.walletIdentity) === BigInt(p.registration.walletIdentity) && event.args.viewingPublicKey.toLowerCase() === p.registration.keys.viewingPublicKey.toLowerCase() && event.args.clueKey.toLowerCase() === p.registration.keys.clueKey.toLowerCase() && event.args.nextNonce === p.registration.nonce + 1n;
+          } catch {
+            return false;
+          }
+        });
+        check2(found, "registry receipt has no matching key update event");
+        check2(
+          (await reader.getBlock(receipt.block.number)).hash === receipt.block.hash,
+          "registry block changed during confirmation"
+        );
+        options.signal?.throwIfAborted();
+        return new _RegistrationOperation(
+          this.#registry,
+          this.#runtime,
+          p,
+          "confirmed",
+          void 0,
+          this.#proof,
+          hash,
+          receipt.block
+        );
+      }
+    }
+    const head = await reader.getBlock(await reader.getLatestBlockNumber());
+    const nonce = await reader.getRegistryNonce(p.context, p.registration.walletIdentity, head);
+    check2(
+      (await reader.getBlock(head.number)).hash === head.hash,
+      "canonical registry block changed during reconciliation"
+    );
+    return new _RegistrationOperation(
+      this.#registry,
+      this.#runtime,
+      p,
+      head.timestamp > p.registration.deadline ? "expired" : nonce !== p.registration.nonce ? "failed" : "uncertain",
+      void 0,
+      this.#proof,
+      hash
+    );
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      kind: this.#plan.update ? "update-address" : "register-address",
+      status: this.status
+    };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+};
+
+// src/AddressRegistry.ts
+var AddressRegistry = class {
+  context;
+  #lookup;
+  expectedRuntimeCodeHash;
+  constructor(context, options = {}) {
+    if (typeof context.chainId !== "bigint" || context.chainId < 0n || context.chainId >= 1n << 64n || BigInt(getAddress6(context.registryAddress)) === 0n) {
+      throw new Error("invalid registry context");
+    }
+    this.context = Object.freeze({
+      ...context,
+      registryAddress: getAddress6(context.registryAddress)
+    });
+    this.#lookup = options.lookup;
+    this.expectedRuntimeCodeHash = options.expectedRuntimeCodeHash?.toLowerCase();
+    if (this.expectedRuntimeCodeHash && !/^0x[0-9a-f]{64}$/.test(this.expectedRuntimeCodeHash)) {
+      throw new Error("invalid registry runtime profile");
+    }
+    Object.freeze(this);
+  }
+  async validateDeployment(reader) {
+    if (!this.expectedRuntimeCodeHash) {
+      throw new MissingCapabilityError2("trusted registry deployment profile");
+    }
+    if (await reader.getChainId() !== this.context.chainId) {
+      throw new Error("registry chain mismatch");
+    }
+    const code = await reader.getCode(this.context.registryAddress);
+    if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(code) || keccak2566(code) !== this.expectedRuntimeCodeHash) {
+      throw new Error("registry runtime profile mismatch");
+    }
+  }
+  prepareRegistration(options) {
+    return RegistrationOperation.prepare(this, options);
+  }
+  async resolve(address) {
+    const receiving = ReceivingAddress3.parse(address);
+    if (receiving.kind === "short" && !this.#lookup) {
+      throw new MissingCapabilityError2("registry reader");
+    }
+    return (await receiving.resolve(this.#lookup)).toString();
+  }
+  authorization(registration, options) {
+    return registrationAuthorizationRequest(this.context, registration, options);
+  }
+  publicInputs(registration, options) {
+    return registrationPublicInputs(this.context, registration, options);
+  }
+  buildCall(registration, proof, options) {
+    return buildRegistrationCalldata(this.context, registration, proof, options);
+  }
+};
+
+// src/Protocol.ts
+import { Contract as Contract2, getAddress as getAddress7, keccak256 as keccak2568 } from "ethers";
+import {
+  defineDeployment
+} from "@invisi-labs/rpc";
+
+// src/TokenProtocol.ts
+import { keccak256 as keccak2567 } from "ethers";
+import { MissingCapabilityError as MissingCapabilityError3 } from "@invisi-labs/core";
+var TokenProtocol = class {
+  context;
+  expectedRuntimeCodeHash;
+  constructor(context, options = {}) {
+    const normalized = normalizeContext(context);
+    if (BigInt(normalized.protocolAddress) === 0n || BigInt(normalized.tokenAddress) === 0n) {
+      throw new Error("deployment addresses must be nonzero");
+    }
+    if (options.expectedRuntimeCodeHash && !/^0x[0-9a-fA-F]{64}$/.test(options.expectedRuntimeCodeHash)) {
+      throw new Error("invalid runtime code hash");
+    }
+    this.expectedRuntimeCodeHash = options.expectedRuntimeCodeHash?.toLowerCase();
+    this.context = Object.freeze(normalized);
+    Object.freeze(this);
+  }
+  async validateDeployment(reader, options = {}) {
+    if ((options.requireRuntimeProfile ?? true) && !this.expectedRuntimeCodeHash) {
+      throw new MissingCapabilityError3("trusted deployment profile");
+    }
+    if (await reader.getChainId() !== this.context.chainId) {
+      throw new Error("deployment chain mismatch");
+    }
+    const code = await reader.getCode(this.context.protocolAddress);
+    if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(code) || this.expectedRuntimeCodeHash && keccak2567(code) !== this.expectedRuntimeCodeHash) {
+      throw new Error("deployment runtime code profile mismatch");
+    }
+    const tokenCode = await reader.getCode(this.context.tokenAddress);
+    if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(tokenCode)) {
+      throw new Error("token address must have contract code");
+    }
+  }
+  transact(request) {
+    return {
+      to: this.context.protocolAddress,
+      value: 0n,
+      ...buildTransactCalldata({ ...request, context: this.context })
+    };
+  }
+  aggregate(request) {
+    return {
+      to: this.context.protocolAddress,
+      value: 0n,
+      ...buildTransactAggregateCalldata({ ...request, context: this.context })
+    };
+  }
+  async shield(request) {
+    return {
+      to: this.context.protocolAddress,
+      value: 0n,
+      ...await buildShieldCalldata({ ...request, context: this.context })
+    };
+  }
+  createCredit(request) {
+    return {
+      to: this.context.protocolAddress,
+      value: 0n,
+      ...buildCreateCreditCalldata({ ...request, context: this.context })
+    };
+  }
+  drawCredit(request) {
+    return {
+      to: this.context.protocolAddress,
+      value: 0n,
+      ...buildCreditDrawCalldata({ ...request, context: this.context })
+    };
+  }
+  cancelCredit(request) {
+    return {
+      to: this.context.protocolAddress,
+      value: 0n,
+      ...buildCancelCreditCalldata({ ...request, context: this.context })
+    };
+  }
+  topUpCredit(request) {
+    return {
+      to: this.context.protocolAddress,
+      value: 0n,
+      ...buildTopUpCreditCalldata({ ...request, context: this.context })
+    };
+  }
+};
+
+// src/Protocol.ts
+var Protocol = class _Protocol {
+  deployment;
+  context;
+  constructor(options) {
+    known(options, ["deployment"], "protocol options");
+    this.deployment = defineDeployment(options.deployment);
+    this.context = Object.freeze({
+      chainId: this.deployment.chainId,
+      protocolAddress: this.deployment.protocol.address
+    });
+    Object.freeze(this);
+  }
+  /** Load the selected deployment and verify its contract against Chain RPC before returning. */
+  static async fromRpc(rpc, provider, options = {}) {
+    const chainId = (await provider.getNetwork()).chainId;
+    if (typeof chainId !== "bigint" || chainId <= 0n || chainId >= 1n << 64n)
+      throw new Error("invalid protocol chainId");
+    const deployment = await rpc.getDeployment(
+      chainId,
+      options.signal ? { signal: options.signal } : {}
+    );
+    const protocol = new _Protocol({ deployment });
+    if (protocol.context.chainId !== chainId) throw new Error("RPC deployment chain mismatch");
+    await protocol.validateDeployment(provider);
+    return protocol;
+  }
+  async validateDeployment(connection) {
+    const reader = "getNetwork" in connection ? {
+      getChainId: async () => (await connection.getNetwork()).chainId,
+      getCode: async (address) => await connection.getCode(address),
+      getProtocolVersion: async (address) => BigInt(
+        await new Contract2(
+          address,
+          ["function VERSION() view returns (uint256)"],
+          connection
+        ).getFunction("VERSION")()
+      )
+    } : connection;
+    if (await reader.getChainId() !== this.context.chainId)
+      throw new Error("deployment chain mismatch");
+    const code = await reader.getCode(this.context.protocolAddress);
+    if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(code) || keccak2568(code) !== this.deployment.protocol.runtimeCodeHash)
+      throw new Error("protocol runtime code profile mismatch");
+    if (reader.getProtocolVersion && await reader.getProtocolVersion(this.context.protocolAddress) !== 1n)
+      throw new Error("unsupported onchain protocol version");
+  }
+  aggregate(request) {
+    return {
+      to: this.context.protocolAddress,
+      value: 0n,
+      ...buildTransactAggregateCalldata({ ...request, context: this.context })
+    };
+  }
+  /** Build an operation context for one asset within this same deployment. */
+  forToken(tokenAddress) {
+    return new TokenProtocol(
+      { ...this.context, tokenAddress: getAddress7(tokenAddress) },
+      { expectedRuntimeCodeHash: this.deployment.protocol.runtimeCodeHash }
+    );
+  }
+};
+
+// src/verify.ts
+import {
+  computeCreditCommitment as computeCreditCommitment2,
+  computeCreditSharedKeyHash as computeCreditSharedKeyHash2,
+  computeNoteCommitment as computeNoteCommitment3,
+  computeNoteIdentity as computeNoteIdentity2,
+  FIELD_MODULUS as FIELD_MODULUS2
+} from "@invisi-labs/core";
+async function verifyNoteCommitment(params) {
+  const expected = await computeNoteCommitment3(
+    params.chainId,
+    await computeNoteIdentity2(BigInt(params.walletIdentity), BigInt(params.nonce)),
+    BigInt(params.tokenAddress),
+    params.amount
+  );
+  return BigInt(expected) === BigInt(params.noteCommitment);
+}
+async function verifyCreditCommitment(params) {
+  if (params.creditSharedKey <= 0n || params.creditSharedKey >= FIELD_MODULUS2)
+    throw new RangeError("creditSharedKey must be a nonzero canonical Field");
+  const expected = await computeCreditCommitment2(
+    params.chainId,
+    params.spenderWalletIdentity,
+    params.ownerWalletIdentity,
+    BigInt(params.spenderPayout),
+    BigInt(params.ownerPayout),
+    BigInt(params.tokenAddress),
+    params.amount,
+    params.nonce,
+    params.expiry,
+    await computeCreditSharedKeyHash2(params.creditSharedKey)
+  );
+  return BigInt(expected) === BigInt(params.creditCommitment);
+}
+
+// src/withdrawal.ts
+import {
+  computeNoteCommitment as computeNoteCommitment4,
+  computeNoteIdentity as computeNoteIdentity3,
+  computeNoteNullifier as computeNoteNullifier2
+} from "@invisi-labs/core";
+async function buildWithdrawalCalldata(p) {
+  const r = normalizeTransactRequest(p.context, p.params, [], p.funding);
+  if (r.outputCount !== 0 || r.depositAmount !== 0n || p.sourceNotes.length === 0 || p.sourceNotes.length !== r.inputCount) {
+    throw new Error("full withdrawal requires inputs, no private outputs and no funding");
+  }
+  const walletIdentity = BigInt(p.sourceNotes[0].walletIdentity);
+  let total = 0n;
+  for (const [index, note] of p.sourceNotes.entries()) {
+    if (note.chainId !== p.context.chainId || note.protocolAddress !== BigInt(p.context.protocolAddress))
+      throw new Error("source note context mismatch");
+    if (BigInt(note.walletIdentity) !== walletIdentity || note.tokenAddress !== BigInt(p.context.tokenAddress) || note.amount <= 0n)
+      throw new Error("source note wallet/token/amount mismatch");
+    const commitment = await computeNoteCommitment4(
+      note.chainId,
+      await computeNoteIdentity3(walletIdentity, note.nonce),
+      note.tokenAddress,
+      note.amount
+    );
+    const nullifier = await computeNoteNullifier2(note.chainId, note.nonce, commitment);
+    if (nullifier.toLowerCase() !== r.nullifiers[index].toLowerCase())
+      throw new Error("source note nullifier mismatch");
+    total += note.amount;
+  }
+  if (r.withdrawalAmount !== total)
+    throw new Error("withdrawal must equal the full input balance");
+  return buildTransactCalldata({ ...p, deliveries: [] });
+}
+
+// src/factory.ts
+import { Contract as Contract3, getAddress as getAddress8 } from "ethers";
+async function resolveInstanceAddress(client, factoryAddress, salt) {
+  const instance = await new Contract3(
+    getAddress8(factoryAddress),
+    invisiFactoryAbi,
+    client
+  ).getFunction("getInstanceAddress")(salt);
+  return getAddress8(instance);
+}
+export {
+  AddressRegistry,
+  CREATE_CREDIT_FIELDS,
+  CREDIT_DRAW_CAPACITIES,
+  EMPTY_FUNDING,
+  EMPTY_PERMIT,
+  FIELD_MODULUS,
+  Protocol,
+  RegistrationOperation,
+  TRANSACT_CAPACITIES,
+  TokenProtocol,
+  WitnessBuilder,
+  ZERO_ADDRESS,
+  ZERO_WORD,
+  aggregateMemberRequestHash,
+  aggregatePublicInputs,
+  buildCancelCreditCalldata,
+  buildCreateCreditCalldata,
+  buildCreditDrawCalldata,
+  buildRegistrationCalldata,
+  buildShieldCalldata,
+  buildTopUpCreditCalldata,
+  buildTransactAggregateCalldata,
+  buildTransactCalldata,
+  buildWithdrawalCalldata,
+  cancelCreditBaseInputs,
+  cancelCreditPublicInputs,
+  cancelCreditRequestHash,
+  checkDeadline,
+  createCreditBaseInputs,
+  createCreditPublicInputs,
+  createCreditRequestHash,
+  createRegistryReceivingKeyLookup,
+  creditDrawBaseInputs,
+  creditDrawPublicInputs,
+  deliveriesHash,
+  dense,
+  encodeAggregateFundingTypedData,
+  encodeCancelCreditTypedData,
+  encodeCreateCreditFundingTypedData,
+  encodeCreateCreditTypedData,
+  encodeCreditDrawTypedData,
+  encodeCreditProof,
+  encodeShieldFundingTypedData,
+  encodeTopUpCreditFundingTypedData,
+  encodeTopUpCreditTypedData,
+  encodeTransactFundingTypedData,
+  encodeTransactTypedData,
+  envelope,
+  field,
+  fundingFields,
+  getEIP712Domain,
+  known,
+  normalizeContext,
+  normalizeDelivery,
+  normalizeFunding,
+  normalizeSources,
+  normalizeTransactRequest,
+  notes,
+  pad,
+  registrationAuthorizationRequest,
+  registrationPublicInputs,
+  registrationTypedData,
+  resolveInstanceAddress,
+  selectCreditDrawCircuit,
+  selectTransactCapacity,
+  shieldFundingRequestHash,
+  topUpCreditBaseInputs,
+  topUpCreditPublicInputs,
+  topUpCreditRequestHash,
+  transactFundingRequestHash,
+  transactPublicInputs,
+  transactUserPublicInputs,
+  uint,
+  validateCancelCreditRequest,
+  validateCreateCreditRequest,
+  validateCreditDrawRequest,
+  validateFundingSubmission,
+  validateShieldRequest,
+  validateTopUpCreditRequest,
+  verifyCreditCommitment,
+  verifyNoteCommitment,
+  word
+};
+//# sourceMappingURL=index.js.map