@invisi-labs/protocol 1.1.0 → 1.1.1

package/dist/index.cjs

@@ -79,8 +79,7 @@ __export(src_exports, {
   normalizeTransactRequest: () => normalizeTransactRequest,
   notes: () => notes,
   pad: () => pad,
-  registrationAuthorizationRequest: () => registrationAuthorizationRequest,
-  registrationPublicInputs: () => registrationPublicInputs,
+  registrationDigest: () => registrationDigest,
   registrationTypedData: () => registrationTypedData,
   resolveInstanceAddress: () => resolveInstanceAddress,
   selectCreditDrawCircuit: () => selectCreditDrawCircuit,
@@ -106,11 +105,11 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/AddressRegistry.ts
-var import_ethers7 = require("ethers");
-var import_core7 = require("@invisi-labs/core");
+var import_ethers3 = require("ethers");
+var import_core3 = require("@invisi-labs/core");
 
 // src/RegistrationOperation.ts
-var import_ethers6 = require("ethers");
+var import_ethers2 = require("ethers");
 
 // src/contracts/abis/InvisiProtocol.ts
 var invisiProtocolAbi = [
@@ -153,6 +152,11 @@ var invisiProtocolAbi = [
         "name": "_screener",
         "type": "address",
         "internalType": "address"
+      },
+      {
+        "name": "_addressRegistry",
+        "type": "address",
+        "internalType": "address"
       }
     ],
     "stateMutability": "nonpayable"
@@ -229,6 +233,19 @@ var invisiProtocolAbi = [
     ],
     "stateMutability": "view"
   },
+  {
+    "type": "function",
+    "name": "addressRegistry",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "contract IAddressRegistry"
+      }
+    ],
+    "stateMutability": "view"
+  },
   {
     "type": "function",
     "name": "cancelCredit",
@@ -422,7 +439,7 @@ var invisiProtocolAbi = [
           {
             "name": "permit",
             "type": "tuple",
-            "internalType": "struct IInvisiMetaTx.TokenPermit",
+            "internalType": "struct IMetaTx.TokenPermit",
             "components": [
               {
                 "name": "deadline",
@@ -965,7 +982,7 @@ var invisiProtocolAbi = [
           {
             "name": "permit",
             "type": "tuple",
-            "internalType": "struct IInvisiMetaTx.TokenPermit",
+            "internalType": "struct IMetaTx.TokenPermit",
             "components": [
               {
                 "name": "deadline",
@@ -1147,7 +1164,7 @@ var invisiProtocolAbi = [
           {
             "name": "permit",
             "type": "tuple",
-            "internalType": "struct IInvisiMetaTx.TokenPermit",
+            "internalType": "struct IMetaTx.TokenPermit",
             "components": [
               {
                 "name": "deadline",
@@ -1295,7 +1312,7 @@ var invisiProtocolAbi = [
               {
                 "name": "permit",
                 "type": "tuple",
-                "internalType": "struct IInvisiMetaTx.TokenPermit",
+                "internalType": "struct IMetaTx.TokenPermit",
                 "components": [
                   {
                     "name": "deadline",
@@ -1445,7 +1462,7 @@ var invisiProtocolAbi = [
               {
                 "name": "permit",
                 "type": "tuple",
-                "internalType": "struct IInvisiMetaTx.TokenPermit",
+                "internalType": "struct IMetaTx.TokenPermit",
                 "components": [
                   {
                     "name": "deadline",
@@ -2532,6 +2549,11 @@ var invisiProtocolAbi = [
       }
     ]
   },
+  {
+    "type": "error",
+    "name": "InvalidAddressRegistry",
+    "inputs": []
+  },
   {
     "type": "error",
     "name": "InvalidAggregateBatch",
@@ -2908,6 +2930,11 @@ var invisiFactoryAbi = [
         "name": "screener_",
         "type": "address",
         "internalType": "address"
+      },
+      {
+        "name": "addressRegistry_",
+        "type": "address",
+        "internalType": "address"
       }
     ],
     "outputs": [
@@ -2960,6 +2987,11 @@ var invisiFactoryAbi = [
         "name": "screener_",
         "type": "address",
         "internalType": "address"
+      },
+      {
+        "name": "addressRegistry_",
+        "type": "address",
+        "internalType": "address"
       }
     ],
     "outputs": [
@@ -3343,13 +3375,7 @@ var invisiFactoryAbi = [
 var invisiAddressRegistryAbi = [
   {
     "type": "constructor",
-    "inputs": [
-      {
-        "name": "verifier",
-        "type": "address",
-        "internalType": "contract IVerifier"
-      }
-    ],
+    "inputs": [],
     "stateMutability": "nonpayable"
   },
   {
@@ -3365,6 +3391,49 @@ var invisiAddressRegistryAbi = [
     ],
     "stateMutability": "view"
   },
+  {
+    "type": "function",
+    "name": "eip712Domain",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "fields",
+        "type": "bytes1",
+        "internalType": "bytes1"
+      },
+      {
+        "name": "name",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "version",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "chainId",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "verifyingContract",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "salt",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      },
+      {
+        "name": "extensions",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      }
+    ],
+    "stateMutability": "view"
+  },
   {
     "type": "function",
     "name": "isRegistered",
@@ -3417,7 +3486,7 @@ var invisiAddressRegistryAbi = [
       {
         "name": "keys",
         "type": "tuple",
-        "internalType": "struct IInvisiAddressRegistry.ReceivingKeys",
+        "internalType": "struct IAddressRegistry.ReceivingKeys",
         "components": [
           {
             "name": "viewingPublicKey",
@@ -3446,7 +3515,7 @@ var invisiAddressRegistryAbi = [
       {
         "name": "registration",
         "type": "tuple",
-        "internalType": "struct IInvisiAddressRegistry.Registration",
+        "internalType": "struct IAddressRegistry.Registration",
         "components": [
           {
             "name": "walletIdentity",
@@ -3456,7 +3525,7 @@ var invisiAddressRegistryAbi = [
           {
             "name": "keys",
             "type": "tuple",
-            "internalType": "struct IInvisiAddressRegistry.ReceivingKeys",
+            "internalType": "struct IAddressRegistry.ReceivingKeys",
             "components": [
               {
                 "name": "viewingPublicKey",
@@ -3483,7 +3552,7 @@ var invisiAddressRegistryAbi = [
         ]
       },
       {
-        "name": "proof",
+        "name": "signature",
         "type": "bytes",
         "internalType": "bytes"
       }
@@ -3491,19 +3560,6 @@ var invisiAddressRegistryAbi = [
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "registrationVerifier",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "address",
-        "internalType": "contract IVerifier"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "supportsInterface",
@@ -3530,7 +3586,7 @@ var invisiAddressRegistryAbi = [
       {
         "name": "registration",
         "type": "tuple",
-        "internalType": "struct IInvisiAddressRegistry.Registration",
+        "internalType": "struct IAddressRegistry.Registration",
         "components": [
           {
             "name": "walletIdentity",
@@ -3540,7 +3596,7 @@ var invisiAddressRegistryAbi = [
           {
             "name": "keys",
             "type": "tuple",
-            "internalType": "struct IInvisiAddressRegistry.ReceivingKeys",
+            "internalType": "struct IAddressRegistry.ReceivingKeys",
             "components": [
               {
                 "name": "viewingPublicKey",
@@ -3567,7 +3623,7 @@ var invisiAddressRegistryAbi = [
         ]
       },
       {
-        "name": "proof",
+        "name": "signature",
         "type": "bytes",
         "internalType": "bytes"
       }
@@ -3575,6 +3631,12 @@ var invisiAddressRegistryAbi = [
     "outputs": [],
     "stateMutability": "nonpayable"
   },
+  {
+    "type": "event",
+    "name": "EIP712DomainChanged",
+    "inputs": [],
+    "anonymous": false
+  },
   {
     "type": "event",
     "name": "ReceivingKeysSet",
@@ -3628,12 +3690,12 @@ var invisiAddressRegistryAbi = [
   },
   {
     "type": "error",
-    "name": "InvalidRegistrationProof",
+    "name": "InvalidRegistrationSignature",
     "inputs": []
   },
   {
     "type": "error",
-    "name": "InvalidVerifier",
+    "name": "InvalidShortString",
     "inputs": []
   },
   {
@@ -3641,11 +3703,6 @@ var invisiAddressRegistryAbi = [
     "name": "InvalidWalletIdentity",
     "inputs": []
   },
-  {
-    "type": "error",
-    "name": "InvalidWalletStatement",
-    "inputs": []
-  },
   {
     "type": "error",
     "name": "NonceExhausted",
@@ -3665,17 +3722,27 @@ var invisiAddressRegistryAbi = [
     "type": "error",
     "name": "RegistrationExpired",
     "inputs": []
+  },
+  {
+    "type": "error",
+    "name": "StringTooLong",
+    "inputs": [
+      {
+        "name": "str",
+        "type": "string",
+        "internalType": "string"
+      }
+    ]
   }
 ];
 
 // src/RegistrationOperation.ts
-var import_core6 = require("@invisi-labs/core");
+var import_core2 = require("@invisi-labs/core");
 
 // src/registry.ts
 var import_ethers = require("ethers");
 var import_core = require("@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`);
@@ -3704,8 +3771,12 @@ function normalize(context, registration, options) {
   uint64(context.chainId, "chainId");
   const registryAddress = (0, import_ethers.getAddress)(context.registryAddress);
   if (BigInt(registryAddress) === 0n) throw new Error("Registry address must be nonzero");
+  if (!/^0x(?:[0-9a-fA-F]{40}|[0-9a-fA-F]{64})$/.test(registration.walletIdentity))
+    throw new Error("Wallet identity must be an EVM owner or padded bytes32");
   const walletIdentity = (0, import_core.decodeAddress)(
-    import_core.ReceivingAddress.fromIdentity(registration.walletIdentity).toString()
+    import_core.ReceivingAddress.fromIdentity(
+      (0, import_ethers.toBeHex)(BigInt(registration.walletIdentity), 20)
+    ).toString()
   ).walletIdentity;
   const keys = normalizeKeys(walletIdentity, registration.keys);
   const nonce = uint64(registration.nonce, "nonce"), deadline = uint64(registration.deadline, "deadline");
@@ -3720,44 +3791,42 @@ function normalize(context, registration, options) {
     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(
-    (0, import_ethers.keccak256)((0, import_ethers.concat)([r.keys.viewingPublicKey, r.keys.clueKey]))
-  );
+function registrationTypedData(context, registration, options = {}) {
+  const { registryAddress, registration: r } = normalize(context, registration, options);
+  const primaryType = options.update ? "UpdateReceivingKeys" : "RegisterReceivingKeys";
   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
-    ]
+    domain: {
+      name: "InvisiAddressRegistry",
+      version: "1",
+      chainId: context.chainId,
+      verifyingContract: registryAddress
+    },
+    primaryType,
+    types: {
+      [primaryType]: [
+        { name: "walletIdentity", type: "bytes32" },
+        { name: "viewingPublicKey", type: "bytes" },
+        { name: "clueKey", type: "bytes32" },
+        { name: "nonce", type: "uint64" },
+        { name: "deadline", type: "uint64" }
+      ]
+    },
+    message: {
+      walletIdentity: (0, import_ethers.toBeHex)(BigInt(r.walletIdentity), 32),
+      ...r.keys,
+      nonce: r.nonce,
+      deadline: r.deadline
+    }
   };
 }
-function registrationTypedData(context, registration, options = {}) {
-  return (0, import_core.walletAuthorizationTypedData)(
-    registrationAuthorizationRequest(context, registration, options)
-  );
-}
-function registrationPublicInputs(context, registration, options = {}) {
-  const request = registrationAuthorizationRequest(context, registration, options);
-  const digest = BigInt((0, import_core.computeWalletAuthorizationDigest)(request));
-  return [
-    (0, import_ethers.toBeHex)(request.words[2], 32),
-    (0, import_ethers.toBeHex)(digest >> 128n, 32),
-    (0, import_ethers.toBeHex)(digest & MASK128, 32)
-  ];
+function registrationDigest(context, registration, options = {}) {
+  const typed = registrationTypedData(context, registration, options);
+  return import_ethers.TypedDataEncoder.hash(typed.domain, typed.types, typed.message);
 }
-function buildRegistrationCalldata(context, registration, proof, options = {}) {
+function buildRegistrationCalldata(context, registration, signature, options = {}) {
   const normalized = normalize(context, registration, options);
-  if (typeof proof !== "string" || !(0, import_ethers.isHexString)(proof) || proof.length <= 2 || proof.length % 2 !== 0)
-    throw new Error("Registration proof must be nonempty hexadecimal bytes");
+  if (typeof signature !== "string" || !(0, import_ethers.isHexString)(signature) || signature.length % 2 !== 0)
+    throw new Error("Registration signature must be hexadecimal bytes");
   return {
     to: normalized.registryAddress,
     value: 0n,
@@ -3768,10 +3837,9 @@ function buildRegistrationCalldata(context, registration, proof, options = {}) {
           ...normalized.registration,
           walletIdentity: (0, import_ethers.toBeHex)(BigInt(normalized.registration.walletIdentity), 32)
         },
-        proof
+        signature
       ]
-    ),
-    publicInputs: registrationPublicInputs(context, normalized.registration, options)
+    )
   };
 }
 function createRegistryReceivingKeyLookup(client, registryAddress) {
@@ -3795,161 +3863,512 @@ function createRegistryReceivingKeyLookup(client, registryAddress) {
   };
 }
 
-// src/witness.ts
-var import_core5 = require("@invisi-labs/core");
-var import_prover = require("@invisi-labs/prover");
-
-// src/credit-create.ts
-var import_ethers3 = require("ethers");
-var import_core2 = require("@invisi-labs/core");
-
-// src/validation.ts
-var import_ethers2 = require("ethers");
-var FIELD_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var ZERO_WORD = (0, import_ethers2.toBeHex)(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) => (0, import_ethers2.toBeHex)(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 (!(0, import_ethers2.isHexString)(v) || !/^0x(?:[a-fA-F0-9]{2})*$/.test(v) || (0, import_ethers2.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: (0, import_ethers2.getAddress)(c.protocolAddress),
-    tokenAddress: (0, import_ethers2.getAddress)(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" };
+// src/RegistrationOperation.ts
+function check(ok, message) {
+  if (!ok) {
+    throw new Error(message);
   }
-  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) => (0, import_ethers2.keccak256)(
-  import_ethers2.AbiCoder.defaultAbiCoder().encode(
-    [
-      {
-        type: "tuple[]",
-        components: [
-          { name: "ciphertext", type: "bytes" },
-          { name: "clue", type: "bytes" }
-        ]
-      }
-    ].map((parameter) => import_ethers2.ParamType.from(parameter)),
-    [dense(v, "deliveries")]
-  )
-);
-function normalizeFunding(input = {}) {
-  const f = { ...EMPTY_FUNDING, ...input };
-  (0, import_ethers2.getAddress)(f.payer);
-  uint(f.amount, 128, "depositAmount");
-  uint(f.sigNonce, 256, "sigNonce");
+var RegistrationOperation = class _RegistrationOperation {
+  #registry;
+  #runtime;
+  #plan;
+  #signature;
+  #hash;
+  #anchor;
+  status;
+  constructor(registry, runtime, plan, status, signature, hash, anchor) {
+    this.#registry = registry;
+    this.#runtime = { ...runtime };
+    this.#plan = structuredClone(plan);
+    this.status = status;
+    this.#signature = signature;
+    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;
+    check(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
+    );
+    check(
+      typeof nonce === "bigint" && nonce >= 0n && nonce < (1n << 64n) - 1n,
+      "invalid or exhausted registry nonce"
+    );
+    check(
+      update ? nonce > 0n : nonce === 0n,
+      update ? "wallet is not registered" : "wallet is already registered; prepare an update"
+    );
+    const address = import_core2.ReceivingAddress.parse(await registry.resolve(runtime.wallet.getAddress()));
+    const keys = address.getReceivingKeys();
+    const registration = {
+      walletIdentity: runtime.wallet.walletIdentity,
+      keys: {
+        viewingPublicKey: (0, import_ethers2.hexlify)(keys.viewingPublicKey),
+        clueKey: (0, import_ethers2.hexlify)(keys.clueKey)
+      },
+      nonce,
+      deadline: options.deadline ?? block.timestamp + 300n
+    };
+    registrationTypedData(context, registration, { update, expectedNonce: nonce });
+    check(
+      (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 },
+      "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
+    };
+  }
+  /** Sign with ethers, or attach externally obtained ERC-1271 signature bytes. */
+  async authorize(options = {}) {
+    check(this.status === "prepared", "registry operation is not awaiting authorization");
+    options.signal?.throwIfAborted();
+    await this.validateFreshness();
+    options.signal?.throwIfAborted();
+    let signature = options.signature;
+    if (signature === void 0) {
+      const signer = this.#runtime.signer;
+      check(signer, "registry signer capability is missing");
+      check(
+        BigInt(await signer.getAddress()) === BigInt(this.#plan.registration.walletIdentity),
+        "registry signer does not match wallet owner"
+      );
+      const typed = this.typedData();
+      signature = await signer.signTypedData(
+        typed.domain,
+        typed.types,
+        typed.message
+      );
+    }
+    check(
+      /^0x(?:[a-fA-F0-9]{2})+$/.test(signature),
+      "registry signature must be nonempty hexadecimal bytes"
+    );
+    const p = this.#plan;
+    const owner = p.registration.walletIdentity;
+    let valid = false;
+    try {
+      const bytes = (0, import_ethers2.getBytes)(signature);
+      const typed = this.typedData();
+      valid = bytes.length === 65 && (bytes[64] === 27 || bytes[64] === 28) && BigInt((0, import_ethers2.verifyTypedData)(typed.domain, typed.types, typed.message, signature)) === BigInt(owner);
+    } catch {
+      valid = false;
+    }
+    if (!valid) {
+      const code = await this.#runtime.reader.getCode(owner);
+      check(/^0x(?:[a-fA-F0-9]{2})*$/.test(code), "invalid owner contract code");
+      check(code !== "0x", "invalid EOA registry signature");
+      const verify = this.#runtime.reader.isValidRegistrationSignature;
+      check(verify, "ERC-1271 registry signature verification capability is missing");
+      check(
+        await verify.call(
+          this.#runtime.reader,
+          owner,
+          registrationDigest(p.context, p.registration, { update: p.update }),
+          signature
+        ),
+        "invalid ERC-1271 registry signature"
+      );
+    }
+    options.signal?.throwIfAborted();
+    return new _RegistrationOperation(
+      this.#registry,
+      this.#runtime,
+      this.#plan,
+      "ready",
+      signature
+    );
+  }
+  /** Empty signatures require the transaction sender to be the wallet owner. */
+  async authorizeDirect() {
+    check(this.status === "prepared", "registry operation is not awaiting authorization");
+    await this.validateFreshness();
+    return new _RegistrationOperation(this.#registry, this.#runtime, this.#plan, "ready", "0x");
+  }
+  typedData() {
+    const p = this.#plan;
+    return registrationTypedData(p.context, p.registration, {
+      update: p.update,
+      expectedNonce: p.registration.nonce
+    });
+  }
+  call() {
+    check(this.#signature !== void 0, "registry signature is missing");
+    const p = this.#plan;
+    const result = buildRegistrationCalldata(p.context, p.registration, this.#signature, {
+      update: p.update,
+      expectedNonce: p.registration.nonce
+    });
+    return { to: result.to, data: result.callData, value: result.value };
+  }
+  async exportTransaction() {
+    check(
+      this.#signature !== void 0 && this.status !== "prepared",
+      "registry operation is not ready"
+    );
+    await this.validateFreshness();
+    return this.call();
+  }
+  async validateFreshness() {
+    await this.#registry.validateDeployment(this.#runtime.reader);
+    const block = await this.#runtime.reader.getBlock(
+      await this.#runtime.reader.getLatestBlockNumber()
+    );
+    const p = this.#plan;
+    check(block.timestamp <= p.registration.deadline, "registry operation has expired");
+    check(
+      await this.#runtime.reader.getRegistryNonce(
+        p.context,
+        p.registration.walletIdentity,
+        block
+      ) === p.registration.nonce,
+      "registry nonce changed; prepare again"
+    );
+    check(
+      (await this.#runtime.reader.getBlock(block.number)).hash === block.hash,
+      "canonical registry block changed during authorization"
+    );
+  }
+  /** Associate a signed/broadcast transaction; ethers owns sending and receipt waiting. */
+  trackTransaction(transactionHash) {
+    check(/^0x[a-fA-F0-9]{64}$/.test(transactionHash), "invalid registry transaction hash");
+    check(
+      this.#signature !== void 0 && ["ready", "uncertain"].includes(this.status),
+      "registry operation is not ready"
+    );
+    return new _RegistrationOperation(
+      this.#registry,
+      this.#runtime,
+      this.#plan,
+      "uncertain",
+      this.#signature,
+      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",
+        this.#signature,
+        this.#hash
+      );
+    }
+    const hash = options.transactionHash ?? this.#hash;
+    const receipt = hash ? await reader.getReceipt(hash) : null;
+    if (receipt) {
+      check(
+        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();
+      check(
+        transaction && transaction.transactionHash === hash && transaction.to.toLowerCase() === call.to.toLowerCase() && transaction.data.toLowerCase() === call.data.toLowerCase() && transaction.value === 0n && (this.#signature !== "0x" || BigInt(transaction.from) === BigInt(p.registration.walletIdentity)),
+        "registry transaction differs from frozen request"
+      );
+      check(
+        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 import_ethers2.Interface(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;
+          }
+        });
+        check(found, "registry receipt has no matching key update event");
+        check(
+          (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",
+          this.#signature,
+          hash,
+          receipt.block
+        );
+      }
+    }
+    const head = await reader.getBlock(await reader.getLatestBlockNumber());
+    const nonce = await reader.getRegistryNonce(p.context, p.registration.walletIdentity, head);
+    check(
+      (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",
+      this.#signature,
+      hash
+    );
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      kind: this.#plan.update ? "update-receiving-keys" : "register-receiving-keys",
+      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((0, import_ethers3.getAddress)(context.registryAddress)) === 0n) {
+      throw new Error("invalid registry context");
+    }
+    this.context = Object.freeze({
+      ...context,
+      registryAddress: (0, import_ethers3.getAddress)(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 import_core3.MissingCapabilityError("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) || (0, import_ethers3.keccak256)(code) !== this.expectedRuntimeCodeHash) {
+      throw new Error("registry runtime profile mismatch");
+    }
+  }
+  prepareRegistration(options) {
+    return RegistrationOperation.prepare(this, options);
+  }
+  async resolve(address) {
+    const receiving = import_core3.ReceivingAddress.parse(address);
+    if (receiving.kind === "short" && !this.#lookup) {
+      throw new import_core3.MissingCapabilityError("registry reader");
+    }
+    return (await receiving.resolve(this.#lookup)).toString();
+  }
+  typedData(registration, options) {
+    return registrationTypedData(this.context, registration, options);
+  }
+  digest(registration, options) {
+    return registrationDigest(this.context, registration, options);
+  }
+  buildCall(registration, signature, options) {
+    return buildRegistrationCalldata(this.context, registration, signature, options);
+  }
+};
+
+// src/credit-create.ts
+var import_ethers5 = require("ethers");
+var import_core4 = require("@invisi-labs/core");
+
+// src/validation.ts
+var import_ethers4 = require("ethers");
+var FIELD_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ZERO_WORD = (0, import_ethers4.toBeHex)(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) => (0, import_ethers4.toBeHex)(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 (!(0, import_ethers4.isHexString)(v) || !/^0x(?:[a-fA-F0-9]{2})*$/.test(v) || (0, import_ethers4.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: (0, import_ethers4.getAddress)(c.protocolAddress),
+    tokenAddress: (0, import_ethers4.getAddress)(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) => (0, import_ethers4.keccak256)(
+  import_ethers4.AbiCoder.defaultAbiCoder().encode(
+    [
+      {
+        type: "tuple[]",
+        components: [
+          { name: "ciphertext", type: "bytes" },
+          { name: "clue", type: "bytes" }
+        ]
+      }
+    ].map((parameter) => import_ethers4.ParamType.from(parameter)),
+    [dense(v, "deliveries")]
+  )
+);
+function normalizeFunding(input = {}) {
+  const f = { ...EMPTY_FUNDING, ...input };
+  (0, import_ethers4.getAddress)(f.payer);
+  uint(f.amount, 128, "depositAmount");
+  uint(f.sigNonce, 256, "sigNonce");
   uint(f.deadline, 256, "funding deadline");
-  if (!(0, import_ethers2.isHexString)(f.signature) || !/^0x(?:[a-fA-F0-9]{2})*$/.test(f.signature))
+  if (!(0, import_ethers4.isHexString)(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 (!(0, import_ethers2.isHexString)(v) || (0, import_ethers2.dataLength)(v) !== 32) throw new Error("permit r/s must be bytes32");
+    if (!(0, import_ethers4.isHexString)(v) || (0, import_ethers4.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: (0, import_ethers2.getAddress)(f.payer) };
+  return { ...f, payer: (0, import_ethers4.getAddress)(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 && (0, import_ethers2.getAddress)(caller) !== f.payer))
+  if (f.signature === "0x" && (f.sigNonce !== 0n || f.deadline !== 0n || caller !== void 0 && f.amount > 0n && (0, import_ethers4.getAddress)(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: (0, import_ethers2.getAddress)(c.protocolAddress)
+  verifyingContract: (0, import_ethers4.getAddress)(c.protocolAddress)
 });
 var fundingFields = [
   { name: "requestHash", type: "bytes32" },
@@ -3975,9 +4394,9 @@ var CREATE_CREDIT_FIELDS = [
 ];
 function validateCreateCreditRequest(c, p, cs, funding = {}) {
   known(p, CREATE_CREDIT_FIELDS);
-  if ((0, import_ethers3.getAddress)(p.token) !== (0, import_ethers3.getAddress)(c.tokenAddress))
+  if ((0, import_ethers5.getAddress)(p.token) !== (0, import_ethers5.getAddress)(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 = (0, import_ethers3.getAddress)(p.owner), expiry = uint(p.expiry, 64, "expiry"), deadline = checkDeadline(c, p.deadline), f = normalizeFunding(funding);
+  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 = (0, import_ethers5.getAddress)(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)
@@ -4034,7 +4453,7 @@ function createCreditBaseInputs(c, p, cs, f = {}) {
 function createCreditPublicInputs(c, p, deliveries, funding = {}) {
   const base = createCreditBaseInputs(c, p, deliveries, funding);
   const digest = BigInt(
-    (0, import_core2.computeWalletAuthorizationDigest)({
+    (0, import_core4.computeWalletAuthorizationDigest)({
       context: { chainId: c.chainId, protocolAddress: BigInt(c.protocolAddress) },
       operation: "create-credit",
       capacity: 10,
@@ -4050,17 +4469,17 @@ var hashContext = {
 };
 function createCreditRequestHash(p, cs, f = {}) {
   const r = validateCreateCreditRequest({ ...hashContext, tokenAddress: p.token }, p, cs, f);
-  return (0, import_ethers3.keccak256)(
-    import_ethers3.AbiCoder.defaultAbiCoder().encode(
+  return (0, import_ethers5.keccak256)(
+    import_ethers5.AbiCoder.defaultAbiCoder().encode(
       [
         { type: "bytes32" },
         creationTuple,
         { type: "bytes32" },
         { type: "address" },
         { type: "uint256" }
-      ].map((parameter) => import_ethers3.ParamType.from(parameter)),
+      ].map((parameter) => import_ethers5.ParamType.from(parameter)),
       [
-        (0, import_ethers3.keccak256)(new TextEncoder().encode("InvisiCreateCredit")),
+        (0, import_ethers5.keccak256)(new TextEncoder().encode("InvisiCreateCredit")),
         p,
         deliveriesHash(cs),
         r.funding.payer,
@@ -4070,7 +4489,7 @@ function createCreditRequestHash(p, cs, f = {}) {
   );
 }
 function encodeCreateCreditTypedData(c, p, deliveries, funding = {}) {
-  return (0, import_core2.walletAuthorizationTypedData)({
+  return (0, import_core4.walletAuthorizationTypedData)({
     context: { chainId: c.chainId, protocolAddress: BigInt(c.protocolAddress) },
     operation: "create-credit",
     capacity: 10,
@@ -4097,7 +4516,7 @@ 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 import_ethers3.Interface(invisiProtocolAbi).encodeFunctionData("createCredit", [
+    data: new import_ethers5.Interface(invisiProtocolAbi).encodeFunctionData("createCredit", [
       encodeCreditProof(p.proof),
       p.params,
       p.deliveries,
@@ -4107,17 +4526,17 @@ function buildCreateCreditCalldata(p) {
   };
 }
 function encodeCreditProof(proof) {
-  if (!(0, import_ethers3.isHexString)(proof) || !/^0x(?:[a-fA-F0-9]{2})*$/.test(proof) || (0, import_ethers3.dataLength)(proof) === 0)
+  if (!(0, import_ethers5.isHexString)(proof) || !/^0x(?:[a-fA-F0-9]{2})*$/.test(proof) || (0, import_ethers5.dataLength)(proof) === 0)
     throw new Error("empty or malformed Credit proof");
-  return import_ethers3.AbiCoder.defaultAbiCoder().encode(
-    ["uint8", "bytes"].map((parameter) => import_ethers3.ParamType.from(parameter)),
+  return import_ethers5.AbiCoder.defaultAbiCoder().encode(
+    ["uint8", "bytes"].map((parameter) => import_ethers5.ParamType.from(parameter)),
     [0, proof]
   );
 }
 
 // src/credit-lifecycle.ts
-var import_ethers4 = require("ethers");
-var import_core3 = require("@invisi-labs/core");
+var import_ethers6 = require("ethers");
+var import_core5 = require("@invisi-labs/core");
 var CREDIT_DRAW_CAPACITIES = [1, 12, 50, 120];
 function selectCreditDrawCircuit(count) {
   if (!Number.isInteger(count) || count < 1 || count > 120)
@@ -4142,7 +4561,7 @@ function validateCreditDrawRequest(c, p, cs) {
     "totalAmount",
     "deadline"
   ]);
-  if ((0, import_ethers4.getAddress)(p.token) !== (0, import_ethers4.getAddress)(c.tokenAddress))
+  if ((0, import_ethers6.getAddress)(p.token) !== (0, import_ethers6.getAddress)(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({
@@ -4160,7 +4579,7 @@ function validateCreditDrawRequest(c, p, cs) {
     if (BigInt(remainderCommitments[i]) === 0n && BigInt(recoveryAmounts[i]) !== 0n)
       throw new Error("full draw requires zero recovery amount");
   }
-  const spender = (0, import_ethers4.getAddress)(p.spender), totalAmount = uint(p.totalAmount, profile.totalBits, "totalAmount");
+  const spender = (0, import_ethers6.getAddress)(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)
@@ -4211,9 +4630,9 @@ function creditDrawBaseInputs(c, p, cs) {
 }
 function validateCancelCreditRequest(c, p) {
   known(p, ["token", "source", "nullifier", "owner", "amount", "deadline"]);
-  if ((0, import_ethers4.getAddress)(p.token) !== (0, import_ethers4.getAddress)(c.tokenAddress))
+  if ((0, import_ethers6.getAddress)(p.token) !== (0, import_ethers6.getAddress)(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 = (0, import_ethers4.getAddress)(p.owner), amount = uint(p.amount, 126, "amount");
+  const ctx = normalizeContext(c), source = normalizeSources([p.source], 1, 1)[0], nullifier = notes([p.nullifier], "nullifier")[0], owner = (0, import_ethers6.getAddress)(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,
@@ -4271,10 +4690,10 @@ var hashContext2 = {
 };
 function cancelCreditRequestHash(p) {
   validateCancelCreditRequest({ ...hashContext2, tokenAddress: p.token }, p);
-  return (0, import_ethers4.keccak256)(
-    import_ethers4.AbiCoder.defaultAbiCoder().encode(
-      [{ type: "bytes32" }, cancelTuple].map((parameter) => import_ethers4.ParamType.from(parameter)),
-      [(0, import_ethers4.keccak256)(new TextEncoder().encode("InvisiCancelCredit")), p]
+  return (0, import_ethers6.keccak256)(
+    import_ethers6.AbiCoder.defaultAbiCoder().encode(
+      [{ type: "bytes32" }, cancelTuple].map((parameter) => import_ethers6.ParamType.from(parameter)),
+      [(0, import_ethers6.keccak256)(new TextEncoder().encode("InvisiCancelCredit")), p]
     )
   );
 }
@@ -4285,17 +4704,17 @@ function topUpCreditRequestHash(p, cs, f = {}) {
     cs,
     f
   );
-  return (0, import_ethers4.keccak256)(
-    import_ethers4.AbiCoder.defaultAbiCoder().encode(
+  return (0, import_ethers6.keccak256)(
+    import_ethers6.AbiCoder.defaultAbiCoder().encode(
       [
         { type: "bytes32" },
         topTuple,
         { type: "bytes32" },
         { type: "address" },
         { type: "uint256" }
-      ].map((parameter) => import_ethers4.ParamType.from(parameter)),
+      ].map((parameter) => import_ethers6.ParamType.from(parameter)),
       [
-        (0, import_ethers4.keccak256)(new TextEncoder().encode("InvisiTopUpCredit")),
+        (0, import_ethers6.keccak256)(new TextEncoder().encode("InvisiTopUpCredit")),
         p,
         deliveriesHash(cs),
         r.creation.funding.payer,
@@ -4305,7 +4724,7 @@ function topUpCreditRequestHash(p, cs, f = {}) {
   );
 }
 function authorize(c, operation, capacity, words) {
-  return (0, import_core3.walletAuthorizationTypedData)({
+  return (0, import_core5.walletAuthorizationTypedData)({
     context: { chainId: c.chainId, protocolAddress: BigInt(c.protocolAddress) },
     operation,
     capacity,
@@ -4314,7 +4733,7 @@ function authorize(c, operation, capacity, words) {
 }
 function appendDigest(c, operation, capacity, words) {
   const digest = BigInt(
-    (0, import_core3.computeWalletAuthorizationDigest)({
+    (0, import_core5.computeWalletAuthorizationDigest)({
       context: { chainId: c.chainId, protocolAddress: BigInt(c.protocolAddress) },
       operation,
       capacity,
@@ -4370,7 +4789,7 @@ function encodeTopUpCreditFundingTypedData(c, p, cs, f) {
 function buildCreditDrawCalldata(p) {
   validateCreditDrawRequest(p.context, p.params, p.deliveries);
   return {
-    data: new import_ethers4.Interface(invisiProtocolAbi).encodeFunctionData("creditDraw", [
+    data: new import_ethers6.Interface(invisiProtocolAbi).encodeFunctionData("creditDraw", [
       encodeCreditProof(p.proof),
       p.params,
       p.deliveries
@@ -4382,7 +4801,7 @@ function buildCreditDrawCalldata(p) {
 function buildCancelCreditCalldata(p) {
   validateCancelCreditRequest(p.context, p.params);
   return {
-    data: new import_ethers4.Interface(invisiProtocolAbi).encodeFunctionData("cancelCredit", [
+    data: new import_ethers6.Interface(invisiProtocolAbi).encodeFunctionData("cancelCredit", [
       encodeCreditProof(p.proof),
       p.params
     ])
@@ -4392,7 +4811,7 @@ 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 import_ethers4.Interface(invisiProtocolAbi).encodeFunctionData("topUpCredit", [
+    data: new import_ethers6.Interface(invisiProtocolAbi).encodeFunctionData("topUpCredit", [
       encodeCreditProof(p.proof),
       p.params,
       p.deliveries,
@@ -4403,8 +4822,8 @@ function buildTopUpCreditCalldata(p) {
 }
 
 // src/funds.ts
-var import_ethers5 = require("ethers");
-var import_core4 = require("@invisi-labs/core");
+var import_ethers7 = require("ethers");
+var import_core6 = require("@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)
@@ -4413,7 +4832,7 @@ function selectTransactCapacity(inputs, outputs) {
 }
 function normalizeTransactRequest(c, p, cs, funding = {}) {
   const ctx = normalizeContext(c);
-  if ((0, import_ethers5.getAddress)(p.token) !== ctx.tokenAddress)
+  if ((0, import_ethers7.getAddress)(p.token) !== ctx.tokenAddress)
     throw new Error("request token mismatch");
   known(p, [
     "token",
@@ -4427,7 +4846,7 @@ function normalizeTransactRequest(c, p, cs, funding = {}) {
   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 = (0, import_ethers5.getAddress)(p.withdrawalAddress), f = normalizeFunding(funding);
+  const withdrawalAmount = uint(p.withdrawalAmount, 128, "withdrawalAmount"), withdrawalAddress = (0, import_ethers7.getAddress)(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))
@@ -4483,7 +4902,7 @@ function transactPublicInputs(c, p, cs, f = {}) {
 }
 function encodeTransactTypedData(c, p, deliveries, f = {}) {
   const r = normalizeTransactRequest(c, p, deliveries, f);
-  return (0, import_core4.walletAuthorizationTypedData)({
+  return (0, import_core6.walletAuthorizationTypedData)({
     context: { chainId: r.chainId, protocolAddress: BigInt(r.protocolAddress) },
     operation: "transact",
     capacity: r.capacity,
@@ -4507,24 +4926,24 @@ function transactFundingRequestHash(proof, p, cs) {
     withdrawalAmount: p.withdrawalAmount,
     deadline: p.deadline
   };
-  return p.sources.length > 1 ? (0, import_ethers5.keccak256)(
-    import_ethers5.AbiCoder.defaultAbiCoder().encode(
+  return p.sources.length > 1 ? (0, import_ethers7.keccak256)(
+    import_ethers7.AbiCoder.defaultAbiCoder().encode(
       [{ type: "bytes32" }, { type: "bytes32" }, crossTuple, { type: "bytes32" }].map(
-        (parameter) => import_ethers5.ParamType.from(parameter)
+        (parameter) => import_ethers7.ParamType.from(parameter)
       ),
       [
-        (0, import_ethers5.keccak256)(new TextEncoder().encode("InvisiCrossTreeTransact")),
-        (0, import_ethers5.keccak256)(proof),
+        (0, import_ethers7.keccak256)(new TextEncoder().encode("InvisiCrossTreeTransact")),
+        (0, import_ethers7.keccak256)(proof),
         p,
         deliveriesHash(cs)
       ]
     )
-  ) : (0, import_ethers5.keccak256)(
-    import_ethers5.AbiCoder.defaultAbiCoder().encode(
+  ) : (0, import_ethers7.keccak256)(
+    import_ethers7.AbiCoder.defaultAbiCoder().encode(
       [{ type: "bytes32" }, singleTuple, { type: "bytes32" }].map(
-        (parameter) => import_ethers5.ParamType.from(parameter)
+        (parameter) => import_ethers7.ParamType.from(parameter)
       ),
-      [(0, import_ethers5.keccak256)(proof), single, deliveriesHash(cs)]
+      [(0, import_ethers7.keccak256)(proof), single, deliveriesHash(cs)]
     )
   );
 }
@@ -4564,7 +4983,7 @@ function buildTransactCalldata(p) {
   const abi = invisiProtocolAbi.filter(
     (item) => item.type === "function" && item.name === "transact" && item.inputs.length === 2 && item.inputs[1]?.type === "tuple"
   );
-  const data = new import_ethers5.Interface(abi).encodeFunctionData("transact", [p.proof, request]);
+  const data = new import_ethers7.Interface(abi).encodeFunctionData("transact", [p.proof, request]);
   return { data, capacity: r.capacity, approveAmount: r.depositAmount };
 }
 function buildTransactAggregateCalldata(p) {
@@ -4581,7 +5000,7 @@ function buildTransactAggregateCalldata(p) {
     validateFundingSubmission(r.funding, p.caller, p.context.now);
   }
   return {
-    data: new import_ethers5.Interface(
+    data: new import_ethers7.Interface(
       invisiProtocolAbi.filter(
         (item) => item.type === "function" && item.name === "transact" && item.inputs[1]?.type === "tuple[]"
       )
@@ -4591,7 +5010,7 @@ function buildTransactAggregateCalldata(p) {
 }
 async function validateShieldRequest(p) {
   normalizeContext(p.context);
-  if ((0, import_ethers5.getAddress)(p.params.token) !== (0, import_ethers5.getAddress)(p.context.tokenAddress))
+  if ((0, import_ethers7.getAddress)(p.params.token) !== (0, import_ethers7.getAddress)(p.context.tokenAddress))
     throw new Error("request token mismatch");
   known(p.params, ["token", "outputCommitments", "deadline"]);
   checkDeadline(p.context, p.params.deadline);
@@ -4605,7 +5024,7 @@ async function validateShieldRequest(p) {
     if (o.amount === 0n) throw new Error("amount must be positive");
     field(o.identity);
     normalizeDelivery(cs[i]);
-    if (await (0, import_core4.computeNoteCommitment)(
+    if (await (0, import_core6.computeNoteCommitment)(
       p.context.chainId,
       o.identity,
       BigInt(p.context.tokenAddress),
@@ -4618,22 +5037,22 @@ async function validateShieldRequest(p) {
   return f;
 }
 function shieldFundingRequestHash(params, outputs, cs) {
-  const outputHash = (0, import_ethers5.keccak256)(
-    import_ethers5.AbiCoder.defaultAbiCoder().encode(
-      ["(bytes32 identity,uint256 amount)[]"].map((parameter) => import_ethers5.ParamType.from(parameter)),
+  const outputHash = (0, import_ethers7.keccak256)(
+    import_ethers7.AbiCoder.defaultAbiCoder().encode(
+      ["(bytes32 identity,uint256 amount)[]"].map((parameter) => import_ethers7.ParamType.from(parameter)),
       [outputs]
     )
   );
-  return (0, import_ethers5.keccak256)(
-    import_ethers5.AbiCoder.defaultAbiCoder().encode(
+  return (0, import_ethers7.keccak256)(
+    import_ethers7.AbiCoder.defaultAbiCoder().encode(
       [
         "bytes32",
         "(address token,bytes32[] outputCommitments,uint256 deadline)",
         "bytes32",
         "bytes32"
-      ].map((parameter) => import_ethers5.ParamType.from(parameter)),
+      ].map((parameter) => import_ethers7.ParamType.from(parameter)),
       [
-        (0, import_ethers5.keccak256)(new TextEncoder().encode("InvisiShield")),
+        (0, import_ethers7.keccak256)(new TextEncoder().encode("InvisiShield")),
         params,
         outputHash,
         deliveriesHash(cs)
@@ -4660,7 +5079,7 @@ async function buildShieldCalldata(p) {
   const f = await validateShieldRequest(p);
   validateFundingSubmission(f, p.caller, p.context.now);
   return {
-    data: new import_ethers5.Interface(invisiProtocolAbi).encodeFunctionData("shield", [
+    data: new import_ethers7.Interface(invisiProtocolAbi).encodeFunctionData("shield", [
       p.params,
       p.outputs,
       p.deliveries,
@@ -4671,7 +5090,7 @@ async function buildShieldCalldata(p) {
 }
 function transactUserPublicInputs(c, p, cs, f = {}) {
   const words = transactPublicInputs(c, p, cs, f), digest = BigInt(
-    ((typed) => import_ethers5.TypedDataEncoder.hash(
+    ((typed) => import_ethers7.TypedDataEncoder.hash(
       typed.domain,
       Object.fromEntries(
         Object.entries(typed.types).map(([name, fields]) => [
@@ -4690,11 +5109,11 @@ function aggregateMemberRequestHash(c, r) {
     r.params.outputCommitments.length
   );
   if (capacity !== 14) throw new Error("aggregate supports only capacity 14");
-  return (0, import_ethers5.keccak256)(
-    import_ethers5.AbiCoder.defaultAbiCoder().encode(
-      ["bytes32", "uint256", "bytes32[]"].map((parameter) => import_ethers5.ParamType.from(parameter)),
+  return (0, import_ethers7.keccak256)(
+    import_ethers7.AbiCoder.defaultAbiCoder().encode(
+      ["bytes32", "uint256", "bytes32[]"].map((parameter) => import_ethers7.ParamType.from(parameter)),
       [
-        (0, import_ethers5.keccak256)(new TextEncoder().encode("InvisiAtomicBatchMemberV1")),
+        (0, import_ethers7.keccak256)(new TextEncoder().encode("InvisiAtomicBatchMemberV1")),
         BigInt(capacity),
         transactPublicInputs(c, r.params, r.deliveries, r.funding)
       ]
@@ -4727,6 +5146,240 @@ function encodeAggregateFundingTypedData(c, r) {
   };
 }
 
+// src/Protocol.ts
+var import_ethers9 = require("ethers");
+var import_rpc = require("@invisi-labs/rpc");
+
+// src/TokenProtocol.ts
+var import_ethers8 = require("ethers");
+var import_core7 = require("@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 import_core7.MissingCapabilityError("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 && (0, import_ethers8.keccak256)(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 = (0, import_rpc.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),
+      getProtocolAddressRegistry: async (address) => (0, import_ethers9.getAddress)(
+        await new import_ethers9.Contract(
+          address,
+          ["function addressRegistry() view returns (address)"],
+          connection
+        ).getFunction("addressRegistry")()
+      ),
+      getProtocolVersion: async (address) => BigInt(
+        await new import_ethers9.Contract(
+          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) || (0, import_ethers9.keccak256)(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");
+    const registry = this.deployment.registry;
+    if (registry) {
+      if (!reader.getProtocolAddressRegistry)
+        throw new Error("registry binding reader capability is missing");
+      if ((0, import_ethers9.getAddress)(
+        await reader.getProtocolAddressRegistry(this.context.protocolAddress)
+      ) !== (0, import_ethers9.getAddress)(registry.address))
+        throw new Error("protocol registry binding mismatch");
+      const registryCode = await reader.getCode(registry.address);
+      if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(registryCode) || (0, import_ethers9.keccak256)(registryCode) !== registry.runtimeCodeHash)
+        throw new Error("registry runtime code profile mismatch");
+    }
+  }
+  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: (0, import_ethers9.getAddress)(tokenAddress) },
+      { expectedRuntimeCodeHash: this.deployment.protocol.runtimeCodeHash }
+    );
+  }
+};
+
+// src/verify.ts
+var import_core8 = require("@invisi-labs/core");
+async function verifyNoteCommitment(params) {
+  const expected = await (0, import_core8.computeNoteCommitment)(
+    params.chainId,
+    await (0, import_core8.computeNoteIdentity)(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 >= import_core8.FIELD_MODULUS)
+    throw new RangeError("creditSharedKey must be a nonzero canonical Field");
+  const expected = await (0, import_core8.computeCreditCommitment)(
+    params.chainId,
+    params.spenderWalletIdentity,
+    params.ownerWalletIdentity,
+    BigInt(params.spenderPayout),
+    BigInt(params.ownerPayout),
+    BigInt(params.tokenAddress),
+    params.amount,
+    params.nonce,
+    params.expiry,
+    await (0, import_core8.computeCreditSharedKeyHash)(params.creditSharedKey)
+  );
+  return BigInt(expected) === BigInt(params.creditCommitment);
+}
+
+// src/withdrawal.ts
+var import_core9 = require("@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 (0, import_core9.computeNoteCommitment)(
+      note.chainId,
+      await (0, import_core9.computeNoteIdentity)(walletIdentity, note.nonce),
+      note.tokenAddress,
+      note.amount
+    );
+    const nullifier = await (0, import_core9.computeNoteNullifier)(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/witness.ts
+var import_core10 = require("@invisi-labs/core");
+var import_prover = require("@invisi-labs/prover");
+
 // src/witness-layouts.json
 var witness_layouts_default = {
   transact_user_slots14: {
@@ -5718,301 +6371,85 @@ var witness_layouts_default = {
     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",
+        name: "chain_id",
         count: 1,
         array: false
       },
       {
-        name: "change_commitment",
+        name: "protocol_address",
         count: 1,
         array: false
       },
       {
-        name: "delivery_hash_high",
+        name: "token_address",
         count: 1,
         array: false
       },
       {
-        name: "delivery_hash_low",
+        name: "spender_address",
         count: 1,
         array: false
       },
       {
-        name: "expiry",
+        name: "actual_count",
         count: 1,
         array: false
       },
       {
-        name: "deadline",
+        name: "source_count",
         count: 1,
         array: false
       },
       {
-        name: "deposit_amount",
-        count: 1,
-        array: false
+        name: "tree_ids",
+        count: 120,
+        array: true
       },
       {
-        name: "deposit_payer",
-        count: 1,
-        array: false
+        name: "roots",
+        count: 120,
+        array: true
       },
       {
-        name: "credit_tree_id",
+        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: "credit_merkle_root",
+        name: "deadline",
         count: 1,
         array: false
       },
       {
-        name: "credit_nullifier",
+        name: "delivery_hash_high",
         count: 1,
         array: false
       },
       {
-        name: "previous_expiry",
+        name: "delivery_hash_low",
         count: 1,
         array: false
       },
+      {
+        name: "recovery_amounts",
+        count: 120,
+        array: true
+      },
       {
         name: "auth_digest_high",
         count: 1,
@@ -6025,1089 +6462,666 @@ var witness_layouts_default = {
       }
     ],
     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",
-      "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"
+      "draw_amounts"
     ]
   },
-  wallet_registration: {
-    artifactSha256: "65c3d429f6bc9735af3136f7c383214c2eb222cd32655791f37f7ae5dd428048",
+  credit_cancel: {
+    artifactSha256: "ff278a04f22d2886c9f27f7785a0b8fc317dd242fd4aa9d0d9398d18b7513daf",
     keys: {
-      evm: "b8171bdb558489c75293ee71f64c1ac534f533ae3b3f71107378e46dbd93dd48"
+      evm: "1f8a3c20cb081d6a90962556da3124919cc4e5675e59ad31562af39299da02fb"
     },
-    publicInputCount: 3,
+    publicInputCount: 11,
     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 import_prover.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 === (0, import_core5.computeWalletAuthorizationDigest)(request),
-      "authorization statement mismatch"
-    );
-    const witness = signed.withWitness((value) => value);
-    check(
-      await (0, import_core5.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 (0, import_core5.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 (0, import_core5.computeNoteCommitment)(
-      note.chainId,
-      await (0, import_core5.computeNoteIdentity)(BigInt(note.walletIdentity), note.nonce),
-      note.tokenAddress,
-      note.amount
-    );
-  }
-  async creditLeaf(note) {
-    this.context(note);
-    return (0, import_core5.computeCreditCommitment)(
-      note.chainId,
-      note.spenderWalletIdentity,
-      note.ownerWalletIdentity,
-      note.spenderPayout,
-      note.ownerPayout,
-      note.tokenAddress,
-      note.amount,
-      note.nonce,
-      note.expiry,
-      await (0, import_core5.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 (0, import_core5.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}`,
+        name: "chain_id",
+        count: 1,
+        array: false
+      },
       {
-        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)
+        name: "protocol_address",
+        count: 1,
+        array: false
       },
-      words,
-      p.target
-    );
-  }
-  async creation(p, operation, words) {
-    const state = (0, import_core5.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 = (0, import_core5.normalizeCreditDeliveryState)(p.input.state).note, leaf = await this.creditLeaf(note), c = this.#protocol.context;
-    check(
-      await (0, import_core5.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]
+        name: "token_address",
+        count: 1,
+        array: false
       },
-      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) => (0, import_core5.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 (0, import_core5.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)
+        name: "owner_address",
+        count: 1,
+        array: false
       },
-      words
-    );
-  }
-  async topUpCredit(p) {
-    const c = this.#protocol.context, previous = (0, import_core5.normalizeCreditDeliveryState)(p.previous.state), next = (0, import_core5.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 (0, import_core5.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]
+        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
       },
-      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 === (0, import_core5.computeWalletAuthorizationDigest)(request),
-      "registry authorization mismatch"
-    );
-    const witness = authorization.withWitness((value) => value);
-    check(
-      await (0, import_core5.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 = import_core6.ReceivingAddress.parse(await registry.resolve(runtime.wallet.getAddress()));
-    const keys = address.getReceivingKeys();
-    const registration = {
-      walletIdentity: runtime.wallet.walletIdentity,
-      keys: {
-        viewingPublicKey: (0, import_ethers6.hexlify)(keys.viewingPublicKey),
-        clueKey: (0, import_ethers6.hexlify)(keys.clueKey)
+      {
+        name: "deadline",
+        count: 1,
+        array: false
       },
-      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 === (0, import_core6.computeWalletAuthorizationDigest)(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 import_core6.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 = (0, import_ethers6.hexlify)(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 import_ethers6.Interface(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
-        );
+      {
+        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
       }
-    }
-    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((0, import_ethers7.getAddress)(context.registryAddress)) === 0n) {
-      throw new Error("invalid registry context");
-    }
-    this.context = Object.freeze({
-      ...context,
-      registryAddress: (0, import_ethers7.getAddress)(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 import_core7.MissingCapabilityError("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) || (0, import_ethers7.keccak256)(code) !== this.expectedRuntimeCodeHash) {
-      throw new Error("registry runtime profile mismatch");
-    }
-  }
-  prepareRegistration(options) {
-    return RegistrationOperation.prepare(this, options);
-  }
-  async resolve(address) {
-    const receiving = import_core7.ReceivingAddress.parse(address);
-    if (receiving.kind === "short" && !this.#lookup) {
-      throw new import_core7.MissingCapabilityError("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
-var import_ethers9 = require("ethers");
-var import_rpc = require("@invisi-labs/rpc");
-
-// src/TokenProtocol.ts
-var import_ethers8 = require("ethers");
-var import_core8 = require("@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 import_core8.MissingCapabilityError("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 && (0, import_ethers8.keccak256)(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 })
-    };
+    ],
+    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"
+    ]
   }
-  aggregate(request) {
-    return {
-      to: this.context.protocolAddress,
-      value: 0n,
-      ...buildTransactAggregateCalldata({ ...request, context: this.context })
-    };
+};
+
+// 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 check2(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];
+  check2(typeof key === "string", "unpublished proof target");
+  check2(
+    expectedPublicInputs.length === schema.publicInputCount,
+    "public input order/width mismatch"
+  );
+  check2(
+    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);
+      check2(n >= 0n && n < FIELD_MODULUS, "noncanonical public input");
+      return n;
+    });
+    publicInputs[entry.name] = entry.array ? values : values[0];
+    offset += entry.count;
   }
-  async shield(request) {
-    return {
-      to: this.context.protocolAddress,
-      value: 0n,
-      ...await buildShieldCalldata({ ...request, context: this.context })
-    };
+  check2(offset === expectedPublicInputs.length, "public input layout mismatch");
+  return {
+    circuitName,
+    target,
+    artifactSha256: schema.artifactSha256,
+    vkSha256: key,
+    expectedPublicInputs: [...expectedPublicInputs],
+    witness: new import_prover.LocalWitness({ ...privateInputs, ...publicInputs })
+  };
+}
+var WitnessBuilder = class {
+  #protocol;
+  constructor(protocol) {
+    this.#protocol = protocol;
   }
-  createCredit(request) {
+  static statement(circuitName, expectedPublicInputs, target = "evm") {
+    const schema = witness_layouts_default[circuitName], key = schema.keys[target];
+    check2(
+      typeof key === "string" && expectedPublicInputs.length === schema.publicInputCount,
+      "unpublished target or statement width mismatch"
+    );
     return {
-      to: this.context.protocolAddress,
-      value: 0n,
-      ...buildCreateCreditCalldata({ ...request, context: this.context })
+      circuitName,
+      target,
+      artifactSha256: schema.artifactSha256,
+      vkSha256: key,
+      expectedPublicInputs: [...expectedPublicInputs]
     };
   }
-  drawCredit(request) {
-    return {
-      to: this.context.protocolAddress,
-      value: 0n,
-      ...buildCreditDrawCalldata({ ...request, context: this.context })
-    };
+  context(note) {
+    const c = this.#protocol.context;
+    check2(
+      note.chainId === c.chainId && note.protocolAddress === BigInt(c.protocolAddress) && note.tokenAddress === BigInt(c.tokenAddress),
+      "note context mismatch"
+    );
   }
-  cancelCredit(request) {
-    return {
-      to: this.context.protocolAddress,
-      value: 0n,
-      ...buildCancelCreditCalldata({ ...request, context: this.context })
+  async authority(operation, capacity, words, signed, identity) {
+    check2(!!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)
     };
+    check2(
+      signed.walletIdentity === identity && signed.digest === (0, import_core10.computeWalletAuthorizationDigest)(request),
+      "authorization statement mismatch"
+    );
+    const witness = signed.withWitness((value) => value);
+    check2(
+      await (0, import_core10.verifyWalletAuthorization)(
+        identity,
+        Uint8Array.from([4, ...witness.public_key_x, ...witness.public_key_y]),
+        Uint8Array.from(witness.signature),
+        request
+      ),
+      "invalid wallet authorization"
+    );
+    return witness;
   }
-  topUpCredit(request) {
-    return {
-      to: this.context.protocolAddress,
-      value: 0n,
-      ...buildTopUpCreditCalldata({ ...request, context: this.context })
-    };
+  async membership(leaf, input, sources) {
+    const source = sources.findIndex((value) => value.treeId === input.treeId);
+    check2(
+      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 (0, import_core10.poseidonHash)(
+          input.leafIndex >> level & 1 ? [input.path[level], root] : [root, input.path[level]]
+        )
+      );
+    check2(root === BigInt(sources[source].merkleRoot), "membership root mismatch");
+    return source;
   }
-};
-
-// src/Protocol.ts
-var Protocol = class _Protocol {
-  deployment;
-  context;
-  constructor(options) {
-    known(options, ["deployment"], "protocol options");
-    this.deployment = (0, import_rpc.defineDeployment)(options.deployment);
-    this.context = Object.freeze({
-      chainId: this.deployment.chainId,
-      protocolAddress: this.deployment.protocol.address
-    });
-    Object.freeze(this);
+  async noteLeaf(note) {
+    this.context(note);
+    return (0, import_core10.computeNoteCommitment)(
+      note.chainId,
+      await (0, import_core10.computeNoteIdentity)(BigInt(note.walletIdentity), note.nonce),
+      note.tokenAddress,
+      note.amount
+    );
   }
-  /** 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 } : {}
+  async creditLeaf(note) {
+    this.context(note);
+    return (0, import_core10.computeCreditCommitment)(
+      note.chainId,
+      note.spenderWalletIdentity,
+      note.ownerWalletIdentity,
+      note.spenderPayout,
+      note.ownerPayout,
+      note.tokenAddress,
+      note.amount,
+      note.nonce,
+      note.expiry,
+      await (0, import_core10.computeCreditSharedKeyHash)(note.creditSharedKey)
     );
-    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 import_ethers9.Contract(
-          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) || (0, import_ethers9.keccak256)(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");
+  async noteInputs(inputs, sources, nullifiers, identity, authority) {
+    check2(inputs.length === nullifiers.length, "input count mismatch");
+    return Promise.all(
+      inputs.map(async (input, i) => {
+        check2(input.note.walletIdentity === identity, "input wallet mismatch");
+        const leaf = await this.noteLeaf(input.note);
+        check2(
+          await (0, import_core10.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);
+    check2(
+      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())
+      check2(
+        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
+    );
   }
-  aggregate(request) {
+  async creation(p, operation, words) {
+    const state = (0, import_core10.normalizeCreditDeliveryState)(p.state), note = state.note;
+    check2(
+      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)
+      check2(
+        p.change.walletIdentity === note.ownerWalletIdentity && await this.noteLeaf(p.change) === p.params.changeCommitment,
+        "change commitment mismatch"
+      );
+    else check2(BigInt(p.params.changeCommitment) === 0n, "missing change note");
     return {
-      to: this.context.protocolAddress,
-      value: 0n,
-      ...buildTransactAggregateCalldata({ ...request, context: this.context })
+      ...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
     };
   }
-  /** Build an operation context for one asset within this same deployment. */
-  forToken(tokenAddress) {
-    return new TokenProtocol(
-      { ...this.context, tokenAddress: (0, import_ethers9.getAddress)(tokenAddress) },
-      { expectedRuntimeCodeHash: this.deployment.protocol.runtimeCodeHash }
+  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
     );
   }
-};
-
-// src/verify.ts
-var import_core9 = require("@invisi-labs/core");
-async function verifyNoteCommitment(params) {
-  const expected = await (0, import_core9.computeNoteCommitment)(
-    params.chainId,
-    await (0, import_core9.computeNoteIdentity)(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 >= import_core9.FIELD_MODULUS)
-    throw new RangeError("creditSharedKey must be a nonzero canonical Field");
-  const expected = await (0, import_core9.computeCreditCommitment)(
-    params.chainId,
-    params.spenderWalletIdentity,
-    params.ownerWalletIdentity,
-    BigInt(params.spenderPayout),
-    BigInt(params.ownerPayout),
-    BigInt(params.tokenAddress),
-    params.amount,
-    params.nonce,
-    params.expiry,
-    await (0, import_core9.computeCreditSharedKeyHash)(params.creditSharedKey)
-  );
-  return BigInt(expected) === BigInt(params.creditCommitment);
-}
-
-// src/withdrawal.ts
-var import_core10 = require("@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");
+  async cancelCredit(p) {
+    const note = (0, import_core10.normalizeCreditDeliveryState)(p.input.state).note, leaf = await this.creditLeaf(note), c = this.#protocol.context;
+    check2(
+      await (0, import_core10.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
+    );
   }
-  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 (0, import_core10.computeNoteCommitment)(
-      note.chainId,
-      await (0, import_core10.computeNoteIdentity)(walletIdentity, note.nonce),
-      note.tokenAddress,
-      note.amount
+  async drawCredit(p) {
+    const c = this.#protocol.context, profile = selectCreditDrawCircuit(p.inputs.length), capacity = profile.maxSize;
+    check2(
+      p.inputs.length === p.amounts.length && p.inputs.length === p.params.nullifiers.length,
+      "draw input count mismatch"
+    );
+    const notes2 = p.inputs.map((input) => (0, import_core10.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);
+        check2(
+          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 (0, import_core10.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
     );
-    const nullifier = await (0, import_core10.computeNoteNullifier)(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: [] });
-}
+  async topUpCredit(p) {
+    const c = this.#protocol.context, previous = (0, import_core10.normalizeCreditDeliveryState)(p.previous.state), next = (0, import_core10.normalizeCreditDeliveryState)(p.state), old = previous.note, note = next.note, leaf = await this.creditLeaf(old);
+    for (const field2 of [
+      "spenderWalletIdentity",
+      "ownerWalletIdentity",
+      "spenderPayout",
+      "ownerPayout",
+      "creditSharedKey"
+    ])
+      check2(old[field2] === note[field2], "Credit role or payout changed");
+    check2(
+      JSON.stringify(previous.ownerReceivingKeys) === JSON.stringify(next.ownerReceivingKeys) && JSON.stringify(previous.spenderReceivingKeys) === JSON.stringify(next.spenderReceivingKeys),
+      "Credit receiving snapshots changed"
+    );
+    check2(
+      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"
+    );
+    check2(
+      await (0, import_core10.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
+    );
+  }
+};
 
 // src/factory.ts
 var import_ethers10 = require("ethers");
@@ -7180,8 +7194,7 @@ async function resolveInstanceAddress(client, factoryAddress, salt) {
   normalizeTransactRequest,
   notes,
   pad,
-  registrationAuthorizationRequest,
-  registrationPublicInputs,
+  registrationDigest,
   registrationTypedData,
   resolveInstanceAddress,
   selectCreditDrawCircuit,