@invisi-labs/sdk 1.1.2 → 1.1.4

package/dist/index.cjs

@@ -21,32 +21,89 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   AddressRegistry: () => AddressRegistry,
-  Detector: () => import_core15.Detector,
-  Disclosure: () => import_core15.Disclosure,
+  Detector: () => import_core20.Detector,
+  Disclosure: () => import_core20.Disclosure,
   DisclosureVerifier: () => DisclosureVerifier,
   EncryptedWalletCodec: () => EncryptedWalletCodec,
   Invisi: () => Invisi,
-  MAX_MEMO_BYTES: () => import_core15.MAX_MEMO_BYTES,
-  MissingCapabilityError: () => import_core15.MissingCapabilityError,
-  NullifierCapability: () => import_core15.NullifierCapability,
+  InvisiError: () => InvisiError,
+  MAX_MEMO_BYTES: () => import_core20.MAX_MEMO_BYTES,
+  MissingCapabilityError: () => import_core20.MissingCapabilityError,
+  NullifierCapability: () => import_core20.NullifierCapability,
   Operation: () => Operation,
   PreparedTransaction: () => PreparedTransaction,
-  Protocol: () => import_protocol10.Protocol,
+  Protocol: () => import_protocol11.Protocol,
   ProtocolRpcClient: () => ProtocolRpcClient2,
   ProtocolRpcError: () => import_rpc3.ProtocolRpcError,
-  RegistrationOperation: () => import_protocol10.RegistrationOperation,
-  ViewingCapability: () => import_core15.ViewingCapability,
-  Wallet: () => import_core15.Wallet,
-  WalletAuthorization: () => import_core15.WalletAuthorization,
+  PublicWallet: () => import_core20.PublicWallet,
+  RegistrationOperation: () => import_protocol11.RegistrationOperation,
+  ViewingCapability: () => import_core20.ViewingCapability,
+  Wallet: () => import_core20.Wallet,
+  WalletAuthorization: () => import_core20.WalletAuthorization,
   WalletSession: () => WalletSession,
-  decodeMemoText: () => import_core15.decodeMemoText,
+  computeCreditNullifier: () => import_core20.computeCreditNullifier,
+  creditPeriods: () => import_core20.creditPeriods,
+  creditV1: () => import_core20.creditV1,
+  decodeDeliveryHeader: () => import_core20.decodeDeliveryHeader,
+  decodeMemoText: () => import_core20.decodeMemoText,
+  decryptCandidates: () => decryptCandidates,
   defineGasBenchmarks: () => defineGasBenchmarks,
-  encodeMemo: () => import_core15.encodeMemo,
+  encodeMemo: () => import_core20.encodeMemo,
+  fundsV1: () => import_core20.fundsV1,
+  readProtocolLogs: () => readProtocolLogs,
   walletBalance: () => walletBalance
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/errors.ts
+var import_core = require("@invisi-labs/core");
+var InvisiError = class extends Error {
+  code;
+  operation;
+  address;
+  outputIndex;
+  field;
+  capability;
+  constructor(code, message, details = {}) {
+    super(message, { cause: details.cause });
+    this.name = "InvisiError";
+    this.code = code;
+    this.operation = details.operation;
+    this.address = details.address;
+    this.outputIndex = details.outputIndex;
+    this.field = details.field;
+    this.capability = details.capability;
+  }
+};
+async function prepareWithErrors(operation, prepare) {
+  try {
+    return await prepare();
+  } catch (cause) {
+    if (cause instanceof InvisiError) {
+      if (cause.operation) throw cause;
+      throw new InvisiError(cause.code, cause.message, {
+        operation,
+        ...cause.address === void 0 ? {} : { address: cause.address },
+        ...cause.outputIndex === void 0 ? {} : { outputIndex: cause.outputIndex },
+        ...cause.field === void 0 ? {} : { field: cause.field },
+        ...cause.capability === void 0 ? {} : { capability: cause.capability },
+        cause: cause.cause
+      });
+    }
+    throw new InvisiError(
+      cause instanceof import_core.MissingCapabilityError ? "MISSING_CAPABILITY" : "PREPARATION_FAILED",
+      cause instanceof Error ? cause.message : "Transaction preparation failed",
+      {
+        operation,
+        cause,
+        ...cause instanceof import_core.MissingCapabilityError ? { capability: cause.capability } : {}
+      }
+    );
+  }
+}
+
 // src/session/operation-protocol.ts
+var import_core2 = require("@invisi-labs/core");
 var import_protocol = require("@invisi-labs/protocol");
 
 // src/session/state.ts
@@ -105,11 +162,8 @@ function walletBalances(state) {
 
 // src/session/operation-protocol.ts
 function requiresAuthorization(plan) {
-  if (plan.kind === "sweep") {
-    if (plan.credit || !plan.inputs.length || plan.outputs.length || !plan.params || plan.params.outputCommitments.length || (plan.funding.amount ?? 0n) !== 0n || BigInt(plan.params.withdrawalAddress) !== BigInt(plan.scope.walletIdentity) || plan.params.withdrawalAmount !== plan.inputs.reduce((sum, input) => sum + input.note.amount, 0n) || plan.inputs.some((input) => input.note.walletIdentity !== plan.scope.walletIdentity))
-      throw new Error("invalid owner-only sweep plan");
-    return false;
-  }
+  const ownerOnlyFullWithdrawal = !plan.credit && plan.inputs.length > 0 && plan.outputs.length === 0 && plan.params !== void 0 && plan.params.outputCommitments.length === 0 && (plan.funding.amount ?? 0n) === 0n && plan.fundingMode === "none" && BigInt(plan.params.withdrawalAddress) === BigInt(plan.scope.walletIdentity) && plan.params.withdrawalAmount === plan.inputs.reduce((sum, input) => sum + input.note.amount, 0n) && plan.inputs.every((input) => input.note.walletIdentity === plan.scope.walletIdentity);
+  if (ownerOnlyFullWithdrawal) return false;
   return !!plan.credit || plan.inputs.length > 0;
 }
 function inputFacts(plan) {
@@ -240,6 +294,7 @@ async function witnessFor(protocol, plan, authorization) {
     }
     if (credit.draw) {
       return builder.drawCredit({
+        timestamp: plan.preparedAt.timestamp,
         params: credit.draw,
         deliveries: credit.deliveries,
         inputs: credit.inputs,
@@ -370,7 +425,12 @@ function operationExpired(plan, now) {
   const credit = plan.credit;
   if (credit?.topUp && now >= credit.topUp.previousExpiry) return true;
   if (credit?.creation && now >= credit.creation.expiry) return true;
-  if (credit?.draw && credit.draw.expiries.some((expiry) => now >= expiry)) return true;
+  if (credit?.draw) {
+    if (credit.draw.expiries.some((expiry) => now >= expiry)) return true;
+    const prepared = (0, import_core2.creditPeriods)(plan.preparedAt.timestamp), current2 = (0, import_core2.creditPeriods)(now);
+    if (prepared.currentDay !== current2.currentDay || prepared.currentMonth !== current2.currentMonth)
+      return true;
+  }
   return false;
 }
 
@@ -378,352 +438,987 @@ function operationExpired(plan, now) {
 var gas_benchmarks_default = [
   {
     formatVersion: 1,
-    id: "protocol-92ef274-osaka-real",
+    id: "protocol-42f2546-621cbef5f84a-prague-credit-real",
     deployment: {
       chainId: "31337",
-      protocolAddress: "0x8870C63A18a9480C7de9B860b849fD293832856D",
-      runtimeCodeHash: "0x604572c0da90ea139b774cd0d2962a2972fac46e0556c7cec6f6f9aac5deef14",
-      tokenAddress: "0x4826533B4897376654Bb4d4AD88B7faFD0C98528"
+      protocolAddress: "0xEeD9be753bccbCB21463C49f0c56cC0E48bEcf3c",
+      runtimeCodeHash: "0x80228a2080d224b4481fc5df24fe8ce080d4536c663b13ec7829ecf0ef46abbd",
+      tokenAddress: "0x99bbA657f2BbC93c02D617f8bA121cB8Fc104Acf"
     },
     source: {
-      protocolCommit: "92ef274c6b36d783507699a33ee20e52192c83c7",
-      measuredAt: "2026-10-27T08:42:15.991Z",
+      protocolCommit: "42f2546b62312e4c11e21b8e6b2ff6f72187d6a6",
+      measuredAt: "2026-10-29T10:56:24.758Z",
       chain: "Anvil 31337",
-      hardfork: "osaka",
+      hardfork: "prague",
       token: "MockERC20",
       verifier: "real",
+      fingerprints: {
+        protocolSourceSha256: "621cbef5f84a133ca96674a2dba39b21b5f9fbc022977d4d2ab296d9d6e685e0",
+        dirtyDiffSha256: "eb2c41cca3802a47196181648397ec6f47fb2ba0efa8aa3800508d8d255fae3f",
+        compiledArtifactsSha256: "c0e658d74fe49caeebf5ef9deadc1751d9e48add690f7e9ab478de7a00dab7e4",
+        creditManifestSha256: "da819378af60471905cc902a43e464b58159e0c75bd46fb804ea9d34d8aa7ef6",
+        userManifestSha256: "067b6c50e4bc4d9c19dd29f25352db88d189a5f49aed0ed603daa70760e699df",
+        sdkSourceSha256: "37e1f82a447db741f46e1490b866ddf85718eab42c33d369cf5f5d2ec3a25c78"
+      },
+      toolchain: {
+        solidity: "0.8.38",
+        barretenberg: "6.0.0",
+        noir: "1.0.0-rc.6",
+        evmVersion: "prague",
+        optimizerRuns: 200,
+        anvil: "anvil Version: 1.8.6"
+      },
+      blockGasLimit: "500000000",
+      runtimeContracts: {
+        transact_user_slots14_direct_Verifier: {
+          address: "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+          runtimeCodeHash: "0xedab185b2b9fc7d98660db2cdc99fe30b9d1341dfe568172a1626e322d208f7e"
+        },
+        "transact_user_slots14-adapter": {
+          address: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+          runtimeCodeHash: "0xe222cd9c142bc2b13e083e6fe66ea76c0e1e9a194715bfa57082b625c55d867f"
+        },
+        transact_user_slots56_direct_Verifier: {
+          address: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
+          runtimeCodeHash: "0x8913eb7060f38234aca199c4a1007892f68e703de48b588c436b24faaeb23a53"
+        },
+        "transact_user_slots56-adapter": {
+          address: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9",
+          runtimeCodeHash: "0x97c416d190da0b9b8111a5ee17367e8a702ba7884019bf724155ae629a783477"
+        },
+        transact_user_slots112_direct_Verifier: {
+          address: "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9",
+          runtimeCodeHash: "0x501a4791ff0c0a96465ab5e0d42d0ce763bbbb7fd8aebe21929de4d460e1b42c"
+        },
+        "transact_user_slots112-adapter": {
+          address: "0x5FC8d32690cc91D4c39d9d3abcBD16989F875707",
+          runtimeCodeHash: "0xf22ed8ea34a4011650a41c1b9f664b5259ea5a8d66a82d706dab9611a38c109f"
+        },
+        transact_user_slots168_direct_Verifier: {
+          address: "0x0165878A594ca255338adfa4d48449f69242Eb8F",
+          runtimeCodeHash: "0xc22acdfa6f3e278ae46d194a1c50b905e4815fd7b61e39edb52334570670fdce"
+        },
+        "transact_user_slots168-adapter": {
+          address: "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853",
+          runtimeCodeHash: "0x05a318f54d93440a501b6fc6be88e4e76e89d72f1be8333553cb4a61f4f9a0d7"
+        },
+        transact_aggregate_14_4_Verifier: {
+          address: "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6",
+          runtimeCodeHash: "0x7a6f2bafe4c61a72a99a195e188f2f4a32900c0cc63cc132e33881d8199fd446"
+        },
+        "transact_aggregate_14_4-adapter": {
+          address: "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318",
+          runtimeCodeHash: "0x15877da9940d5b8dd4868ffa92ded3b93d6092c3963ba9e18b50f1ea15d89898"
+        },
+        transact_aggregate_14_8_Verifier: {
+          address: "0x610178dA211FEF7D417bC0e6FeD39F05609AD788",
+          runtimeCodeHash: "0x5667d16b39973813a499375f6885a3082d7bfcd6e3c0f3548d7de3131cd285f3"
+        },
+        "transact_aggregate_14_8-adapter": {
+          address: "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e",
+          runtimeCodeHash: "0x9d1a93c78edf7e81b4b6da10ab209b3fb009ed8355594f670559a67842d88cfc"
+        },
+        transact_aggregate_14_12_Verifier: {
+          address: "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0",
+          runtimeCodeHash: "0xa4e67840a47182d4011d577981c2477bb4ab2bc36845bb136375f19f12c0800b"
+        },
+        "transact_aggregate_14_12-adapter": {
+          address: "0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82",
+          runtimeCodeHash: "0x96a6e170aafc0af9d46232ba00206d950bba85e65962d43501bafb6d7f9fe61d"
+        },
+        create_credit_direct_Verifier: {
+          address: "0x9A676e781A523b5d0C0e43731313A708CB607508",
+          runtimeCodeHash: "0xbdc6450bf9ba01001082f345b8bd21006a4f75274f32d026cf6e14270e6d56e6"
+        },
+        "create_credit-adapter": {
+          address: "0x0B306BF915C4d645ff596e518fAf3F9669b97016",
+          runtimeCodeHash: "0x3a95a22b32aef18ce053a7110056bbfbf13bb0b07932a49765ebb136528a4707"
+        },
+        credit_draw_slots1_direct_Verifier: {
+          address: "0x959922bE3CAee4b8Cd9a407cc3ac1C251C2007B1",
+          runtimeCodeHash: "0x47be80e72c3a22ea044638f6004de8c3a0264d5a0d17189c01153cdabfd7bab6"
+        },
+        "credit_draw_slots1-adapter": {
+          address: "0x9A9f2CCfdE556A7E9Ff0848998Aa4a0CFD8863AE",
+          runtimeCodeHash: "0x28f25aeb97659fb9253ae67f2ff284789710bc59e1ed077ffc7a07b800cbfcc1"
+        },
+        credit_draw_slots12_direct_Verifier: {
+          address: "0x68B1D87F95878fE05B998F19b66F4baba5De1aed",
+          runtimeCodeHash: "0x244d9ba22f5c736c2a5c42c466701e2a8ba7ae8108665133541026ea45d56e04"
+        },
+        "credit_draw_slots12-adapter": {
+          address: "0x3Aa5ebB10DC797CAC828524e59A333d0A371443c",
+          runtimeCodeHash: "0x60d48a35279d318a0621e5f59b293f44074463b8002ce180b7e6a31b995ac195"
+        },
+        credit_draw_slots50_direct_Verifier: {
+          address: "0xc6e7DF5E7b4f2A278906862b61205850344D4e7d",
+          runtimeCodeHash: "0x2ad5eb64bcfae34ef04111dd8f9c1ffc5fc8aa6c1ad3a65d8da78233f3390660"
+        },
+        "credit_draw_slots50-adapter": {
+          address: "0x59b670e9fA9D0A427751Af201D676719a970857b",
+          runtimeCodeHash: "0x468966de20e5c71cf7b6f3cda7fa7a76b5d80dc5ddf82119f441ea6a7c6c1e70"
+        },
+        credit_draw_slots120_direct_Verifier: {
+          address: "0x4ed7c70F96B99c776995fB64377f0d4aB3B0e1C1",
+          runtimeCodeHash: "0x523b6d211618bbd33d708f8198b9f3daafc10e2fa7a6a857db5795ed748a24e4"
+        },
+        "credit_draw_slots120-adapter": {
+          address: "0x322813Fd9A801c5507c9de605d63CEA4f2CE6c44",
+          runtimeCodeHash: "0xa91d585ce6037e703efb914205bf193881fde4f470d2fc63b615699b56175239"
+        },
+        credit_cancel_direct_Verifier: {
+          address: "0xa85233C63b9Ee964Add6F2cffe00Fd84eb32338f",
+          runtimeCodeHash: "0x182e86861a73f712071e40a6b8497b80c58c383eaa799182e7a50e39196399fd"
+        },
+        "credit_cancel-adapter": {
+          address: "0x4A679253410272dd5232B3Ff7cF5dbB88f295319",
+          runtimeCodeHash: "0xea1f0f22445eed5a92c8d6990219059b7e241ad66c55a6d9ddef22a94a0f015f"
+        },
+        credit_top_up_direct_Verifier: {
+          address: "0x7a2088a1bFc9d81c55368AE168C2C02570cB814F",
+          runtimeCodeHash: "0xeeb42a2b6377ab305b713d1caf4ca96edb302c6d1e1007239e5c70091819c266"
+        },
+        "credit_top_up-adapter": {
+          address: "0x09635F643e140090A9A8Dcd712eD6285858ceBef",
+          runtimeCodeHash: "0xbcf35a1d0e6c16dd01b09f944889aa5917d358d986fe399a0343d06bbdedaa61"
+        },
+        PrivateTransferVerifierRegistry: {
+          address: "0xc5a5C42992dECbae36851359345FE25997F5C42d",
+          runtimeCodeHash: "0x678684af147cb42c872184b6e22c8439748139ae0c5885032941ab8832fcb142"
+        },
+        CrossTreeVerifierRegistry: {
+          address: "0x67d269191c92Caf3cD7723F116c85e6E9bf55933",
+          runtimeCodeHash: "0xa5ee16fc7ed9f982450e42a48365a93bfca784fa884adcb8695b557e921cb93b"
+        },
+        DualVerifierRouter: {
+          address: "0xE6E340D132b5f46d1e472DebcD681B2aBc16e57E",
+          runtimeCodeHash: "0xcc094ed6f1bcc9270c597f62b817e4fc0a54770f373320133c2836e5b07ef2cc"
+        },
+        AtomicBatchOutputLib: {
+          address: "0xc3e53F4d16Ae77Db1c982e75a937B9f60FE63690",
+          runtimeCodeHash: "0x7c138c13e40b3ad0fee3b319d6c1580a21855cb5ecdda92571d530509d9b7316"
+        },
+        FundingLib: {
+          address: "0x84eA74d481Ee0A5332c457a4d796187F6Ba67fEB",
+          runtimeCodeHash: "0x898d13d6ec4123df85f21ee0f98678dcd9f9b9a60134f88e35c1ef1aaa0a45f9"
+        },
+        PrivateTransferLib: {
+          address: "0x9E545E3C0baAB3E08CdfD552C960A1050f373042",
+          runtimeCodeHash: "0xfb18f2dd0a39af1b99ae35c25e2746cb5bc85c205e041db5f440671d84c82e5e"
+        },
+        CrossTreeTransferLib: {
+          address: "0xa82fF9aFd8f496c3d6ac40E2a0F282E47488CFc9",
+          runtimeCodeHash: "0x7b33a08f2feb9da462b951c95482cb2909796a85c0fde7cc9a6b65ff8b7ff253"
+        },
+        AggregateTransferLib: {
+          address: "0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8",
+          runtimeCodeHash: "0xb3b4bd3a428f5c35712a57180f07b2249774d399ca87d4494929148ea26c5b99"
+        },
+        CreateCreditLib: {
+          address: "0x851356ae760d987E095750cCeb3bC6014560891C",
+          runtimeCodeHash: "0xe37a4b7c129c4fba5615d25ed8b7e898e64a306c68f7e599ade911db98fe881c"
+        },
+        CreditLifecycleLib: {
+          address: "0xf5059a5D33d5853360D16C683c16e67980206f36",
+          runtimeCodeHash: "0xf87a2227680efa7070071516587793e2e847c172b83261b8983c826f8a8c79bb"
+        },
+        ShieldLib: {
+          address: "0x95401dc811bb5740090279Ba06cfA8fcF6113778",
+          runtimeCodeHash: "0x371e57d8d324e44445a4ec30303b89a8bc98bbdbd03aeaa80faf0f821a65451d"
+        },
+        InvisiFactory: {
+          address: "0x998abeb3E57409262aE5b751f60747921B33613E",
+          runtimeCodeHash: "0xc56e5a0b71f4a1f63576a6663efb62b17c0d7520b6885a8d3483a356e12edf9b"
+        },
+        InvisiAddressRegistry: {
+          address: "0x70e0bA845a1A0F2DA3359C97E0285013525FFC49",
+          runtimeCodeHash: "0x007da3f4e888366ba0eed52cd511c4a369359291387ad19ca37e89eb395fce30"
+        },
+        InvisiProtocol: {
+          address: "0xEeD9be753bccbCB21463C49f0c56cC0E48bEcf3c",
+          runtimeCodeHash: "0x80228a2080d224b4481fc5df24fe8ce080d4536c663b13ec7829ecf0ef46abbd"
+        },
+        MockERC20: {
+          address: "0x99bbA657f2BbC93c02D617f8bA121cB8Fc104Acf",
+          runtimeCodeHash: "0xf7f676b5c54f6e94f82f0de65a0117468a0d915e8a79d150e74f76bd6d7f708b"
+        }
+      },
       assumptions: [
-        "normal CREATE/Factory deployment; no code or storage injection",
-        "Solidity 0.8.27 optimizer 200; real BB 5.2.1 verifiers",
-        "one source tree; two existing leaves; no rollover or screener",
-        "funding/approval setup excluded; complete transaction receipt gas included",
-        "exact allowance for caller funding; configured benchmark payout balances",
-        "observed local samples, not a confidence interval or gas limit"
+        "normal CREATE/Factory deployment and fresh registry; EIP170/EIP3860 unchanged; no code/storage injection",
+        "Solidity0.8.38 optimizer200 Prague; pinned BB6.0.0 real verifiers; every native proof independently verified",
+        "one physical source tree and 123 existing leaves shared by every sample; top-up has two authenticated source groups; no rollover or screener",
+        "funding/approvals/121 genuine Credit seeds/usage-seed draw/payout reset excluded from business gas",
+        "each round restores identical token balances, exact caller allowance100, note cursor, nullifiers and baseline; spender payout starts zero",
+        "complete receipt.gasUsed is measured, including verifier/calldata/logging/output insertion; memo0",
+        "Prague local block gas limit500000000; measured transactions may be unmineable under lower network transaction/block limits",
+        "observed three-sample ranges are neither a confidence interval nor a recommended transaction gas limit"
       ]
     },
     measurements: [
       {
-        id: "shield-1",
+        id: "create-credit-caller-0x0",
         shape: {
-          kind: "shield",
+          kind: "create-credit",
           target: "evm",
-          capacity: 0,
+          capacity: 10,
           noteInputs: 0,
-          noteOutputs: 1,
+          noteOutputs: 0,
           sourceTrees: 0,
           creditInputs: 0,
-          creditOutputs: 0,
+          creditOutputs: 1,
           creditRemainders: 0,
           funding: "caller",
           permit: false,
-          deliveryBytes: 226
+          deliveryBytes: 1132
+        },
+        circuit: {
+          circuitName: "create_credit",
+          target: "evm",
+          artifactSha256: "3ed6cfdee4f5fd840f023580f76c208768777fea79737f2511377e5c55be0230",
+          vkSha256: "56f663c6053be0d158a271022d200c732597efd3a2e0be48fe94549d0b1795e0"
         },
-        circuit: null,
         samples: [
           {
-            gasUsed: "649286",
-            transactionHash: "0xcc299d1780ada9a69b1d9f0f3d06a165db15fccbd2b7ff407834f02f5d563a18",
-            blockNumber: "50",
-            blockHash: "0xbcb868e781a20588d2fa099a4d7f87c1600044a2e5ec1e369e384d7a5f22f00a",
-            calldataBytes: 1156
+            gasUsed: "1574696",
+            transactionHash: "0x76112c532a1b5f24ad84fb83f91789ba4acd15ed9473ec9a0267cd5fe605448d",
+            blockNumber: "172",
+            blockHash: "0x0d91421e94947132a19f38ffdd76932c2d85add201de3d9189325ed3568125a7",
+            calldataBytes: 11780
           },
           {
-            gasUsed: "649322",
-            transactionHash: "0x95139dff109725989f0769e3e6fb9bd3e7e1bf581fd475f14e822875eb90fda4",
-            blockNumber: "50",
-            blockHash: "0x7ace353fea4fc8c856c0fd45521d200b02619921977709ff4f910e0ff41c06fe",
-            calldataBytes: 1156
+            gasUsed: "1574576",
+            transactionHash: "0x545f72d9d207329bfc69ef0d1e96470c614924d5e463d974cc001712bf619fd8",
+            blockNumber: "172",
+            blockHash: "0x2053f97a2b2f3cf66e14da0ab9c1d7bd462d2d4f3ef2b13021aefcddedb71cf8",
+            calldataBytes: 11780
           },
           {
-            gasUsed: "649322",
-            transactionHash: "0xef578bb38dc8ff8bfd47d2e76e3ab4273019ea9a385f5d2fd99add32ceaecb58",
-            blockNumber: "50",
-            blockHash: "0xded817f8ef89637e2443e3b626c0837f184ca134fe753be913d5570554c649a6",
-            calldataBytes: 1156
+            gasUsed: "1574612",
+            transactionHash: "0x880ec0c666068d0756fba39947dc5b211aeebb31f41bd1e1e54856b090f65d34",
+            blockNumber: "172",
+            blockHash: "0xbb86ed21379a917e9688a3c90364ae8fbe1ba633ac068360e0a82bf4d3113b6d",
+            calldataBytes: 11780
           }
         ]
       },
       {
-        id: "shield-2",
+        id: "create-credit-1x1",
         shape: {
-          kind: "shield",
+          kind: "create-credit",
           target: "evm",
-          capacity: 0,
-          noteInputs: 0,
-          noteOutputs: 2,
-          sourceTrees: 0,
+          capacity: 10,
+          noteInputs: 1,
+          noteOutputs: 1,
+          sourceTrees: 1,
           creditInputs: 0,
-          creditOutputs: 0,
+          creditOutputs: 1,
           creditRemainders: 0,
-          funding: "caller",
+          funding: "none",
           permit: false,
-          deliveryBytes: 452
+          deliveryBytes: 1360
+        },
+        circuit: {
+          circuitName: "create_credit",
+          target: "evm",
+          artifactSha256: "3ed6cfdee4f5fd840f023580f76c208768777fea79737f2511377e5c55be0230",
+          vkSha256: "56f663c6053be0d158a271022d200c732597efd3a2e0be48fe94549d0b1795e0"
         },
-        circuit: null,
         samples: [
           {
-            gasUsed: "757063",
-            transactionHash: "0x024e2dfbd6f50c368e2a4aa347e3029de668f4ebd36b80227aa003bb7ac21c74",
-            blockNumber: "50",
-            blockHash: "0x8ed63973c158d706ac54bb646626e4f0db5777b4bd56d179b94503af6c417c50",
-            calldataBytes: 1668
+            gasUsed: "1671641",
+            transactionHash: "0x24ca3f03681aeb188b48989d5eaf7dd264a8c32e828acd34ff1b44be74f17ea6",
+            blockNumber: "172",
+            blockHash: "0xcdac07aa5d3ec187874dc1fc9be65503235289c7036ebe455feaf5161db42bb5",
+            calldataBytes: 12132
           },
           {
-            gasUsed: "757063",
-            transactionHash: "0x898d852ab28f68adac4d30b160a3dbfee33fa7ca875f70df9eb7763b6b1cd1f0",
-            blockNumber: "50",
-            blockHash: "0x9bb6810de38193933a9f26fa03d3d9bad1ca0151ff5e04544c56520e09da3043",
-            calldataBytes: 1668
+            gasUsed: "1671509",
+            transactionHash: "0x31a7f69ab02effa5fdd2e02bd02fb7e715a54786813261113fd7c07a0d3ef549",
+            blockNumber: "172",
+            blockHash: "0xc78ca874aa22cc6b8ea19e12a2806ba448a0f844345450d3fedc9841ea71c3a8",
+            calldataBytes: 12132
           },
           {
-            gasUsed: "757039",
-            transactionHash: "0x8ff9720e3197aab2d741fbd8d0fa2969203ea8cd051d9649d1e5eb890bcc2be3",
-            blockNumber: "50",
-            blockHash: "0x8604c75eb6363aaae774276e638f5b749aae1f8f815eb99ab1183137eef5730e",
-            calldataBytes: 1668
+            gasUsed: "1671485",
+            transactionHash: "0xc5a30116885dcac8b3631c15847544cfeb91c46bde44c3765ac0ce42e3259157",
+            blockNumber: "172",
+            blockHash: "0x4a2c90ff972da4d37408567062779762efbb5790d4784d03842ee2c926c8c894",
+            calldataBytes: 12132
           }
         ]
       },
       {
-        id: "shield-10",
+        id: "draw-credit-1-partial",
         shape: {
-          kind: "shield",
+          kind: "draw-credit",
           target: "evm",
-          capacity: 0,
+          capacity: 1,
           noteInputs: 0,
-          noteOutputs: 10,
-          sourceTrees: 0,
-          creditInputs: 0,
-          creditOutputs: 0,
-          creditRemainders: 0,
-          funding: "caller",
+          noteOutputs: 0,
+          sourceTrees: 1,
+          creditInputs: 1,
+          creditOutputs: 1,
+          creditRemainders: 1,
+          funding: "none",
           permit: false,
-          deliveryBytes: 2260
+          deliveryBytes: 1132
+        },
+        circuit: {
+          circuitName: "credit_draw_slots1",
+          target: "evm",
+          artifactSha256: "4542b227e0552b45c302f1dace21cadeba4962c96244e021472f1f7531cff8d1",
+          vkSha256: "43c051a2bedf9454c12e70b10156361e414944823ba23e80662c16c7ced0a2ce"
         },
-        circuit: null,
         samples: [
           {
-            gasUsed: "1692143",
-            transactionHash: "0x6c13db8bd8a8599daf5034e56712abefbf406982fafe7647b6d22291ba4199ed",
-            blockNumber: "50",
-            blockHash: "0x1ab2ae514f408a79e0c40ca10cee74b2e23d7c8a5f24641b8eea3e1cf58ce700",
-            calldataBytes: 5764
+            gasUsed: "1588303",
+            transactionHash: "0x85c5180692470aa952aa13eb29ca0404d4f5b5192cb31475f90d03d78864895e",
+            blockNumber: "172",
+            blockHash: "0xfe4876c0a2ebf05385a46562bca693b6df80da731fd9651117593916015dc38c",
+            calldataBytes: 11588
           },
           {
-            gasUsed: "1692083",
-            transactionHash: "0x5e476c9d3838b782a51332af9bf5c372d29fc411c2168a7af619c52bd5309c7b",
-            blockNumber: "50",
-            blockHash: "0x9c62bc72fc90f990c6711b48865ff922a1856ae05c4fef61dad5f4da7d948401",
-            calldataBytes: 5764
+            gasUsed: "1588303",
+            transactionHash: "0x61684313840623187ca1205b4b07b43a08038448524ee1a028c7e14050032682",
+            blockNumber: "172",
+            blockHash: "0x9726d31c10e6516e38e3f63c84fc4b9a8a161486d35e0d8d07e6829261a88fe7",
+            calldataBytes: 11588
           },
           {
-            gasUsed: "1692203",
-            transactionHash: "0x0092e2d9160fad95279cde586fc6c79c713244f55db8a2060a5abab9d98c176a",
-            blockNumber: "50",
-            blockHash: "0xac1bf780b4cc05b4dcc7ee5d741c049ba99ab4af9bdcd25104add730c2a14152",
-            calldataBytes: 5764
+            gasUsed: "1588255",
+            transactionHash: "0x0aa052fb8e356cc81dd73bcdae72f760937cd2e56bd4a3e8eb5878208b4f7596",
+            blockNumber: "172",
+            blockHash: "0x2c958cfba0627e18cd5cb47001b278628c305071929596e3335d770b92c1dc16",
+            calldataBytes: 11588
           }
         ]
       },
       {
-        id: "transfer-1x2",
+        id: "draw-credit-1-full",
         shape: {
-          kind: "transfer",
+          kind: "draw-credit",
           target: "evm",
-          capacity: 14,
-          noteInputs: 1,
-          noteOutputs: 2,
+          capacity: 1,
+          noteInputs: 0,
+          noteOutputs: 0,
           sourceTrees: 1,
-          creditInputs: 0,
+          creditInputs: 1,
           creditOutputs: 0,
           creditRemainders: 0,
           funding: "none",
           permit: false,
-          deliveryBytes: 452
+          deliveryBytes: 0
         },
         circuit: {
-          circuitName: "transact_user_slots14",
+          circuitName: "credit_draw_slots1",
           target: "evm",
-          artifactSha256: "2a6a20839e90b88b1ecd629f59a01821bad3ee11dbe04db1fd9cdce7a3de0e84",
-          vkSha256: "ffe0e1a4e690792ecb4eb1fc1acc9ff60f13d3b5af03cfc6ae6d6bf26e99bdea"
+          artifactSha256: "4542b227e0552b45c302f1dace21cadeba4962c96244e021472f1f7531cff8d1",
+          vkSha256: "43c051a2bedf9454c12e70b10156361e414944823ba23e80662c16c7ced0a2ce"
         },
         samples: [
           {
-            gasUsed: "1617516",
-            transactionHash: "0xf49ea3d31cc1346472172e2dee84f9360f60a3fe948a3ef6e87f727af6d42f0d",
-            blockNumber: "49",
-            blockHash: "0xf59c57e63ec2f03abc36d28f273b0af5290184dc97197df740b23d79a851a887",
-            calldataBytes: 11012
+            gasUsed: "1042812",
+            transactionHash: "0xb5d55729d975abdc92ca44c0b72e44a0d5841da8b23dc11b5bd31f46d88a341a",
+            blockNumber: "172",
+            blockHash: "0x8a6ddbe2f1630e1956485cac7984fb9cdc4fbb26b10522e158b38e2970ee4f3b",
+            calldataBytes: 10372
           },
           {
-            gasUsed: "1617516",
-            transactionHash: "0xf8d11286f1f2a4db006ff6b06900c47d0fbf685984499e1e5d4aea49478ba8e5",
-            blockNumber: "49",
-            blockHash: "0xeb5a800190be3534c9e2675c97ac56d0e0be8adef55f60bd32d375776a7d150c",
-            calldataBytes: 11012
+            gasUsed: "1042824",
+            transactionHash: "0xf64f3186fbf94fcbd9fb12426c714b4a8425599e1a7e5677866fae3d6873b7ae",
+            blockNumber: "172",
+            blockHash: "0xd630c44d8ce96234ec836dd2178caac2a6d0bc2df5cf37df1534eb8896be48d3",
+            calldataBytes: 10372
           },
           {
-            gasUsed: "1617504",
-            transactionHash: "0x8939fcea97079a3c5118b9e94325455e2ad1cdb47310ae499a277272654b3eb6",
-            blockNumber: "49",
-            blockHash: "0xecffefb593e2fec5d5827cfd39d0cc4d0efb67dbff6f8dbbd0d2db2439a80cf9",
-            calldataBytes: 11012
+            gasUsed: "1042884",
+            transactionHash: "0xdf634e809b87603a62292ef046fa5e84715561fa76ef121c768303dd779568f1",
+            blockNumber: "172",
+            blockHash: "0x09cad4a799360bdf825c3ad70fe374b7fe2df802f8ee37ccb7f26ffc49aa2a3a",
+            calldataBytes: 10372
           }
         ]
       },
       {
-        id: "transfer-1x14",
+        id: "draw-credit-12-partial",
         shape: {
-          kind: "transfer",
+          kind: "draw-credit",
           target: "evm",
-          capacity: 56,
-          noteInputs: 1,
-          noteOutputs: 14,
+          capacity: 12,
+          noteInputs: 0,
+          noteOutputs: 0,
           sourceTrees: 1,
-          creditInputs: 0,
-          creditOutputs: 0,
-          creditRemainders: 0,
+          creditInputs: 12,
+          creditOutputs: 12,
+          creditRemainders: 12,
           funding: "none",
           permit: false,
-          deliveryBytes: 3164
+          deliveryBytes: 13584
         },
         circuit: {
-          circuitName: "transact_user_slots56",
+          circuitName: "credit_draw_slots12",
           target: "evm",
-          artifactSha256: "ba83ec2f177d16fa88ea04bc54f2e99920f1ac195cdb05b88b9b3bbc245fd953",
-          vkSha256: "6ad5d3aff0c72a632fb19895658af093a6a92478a9994985e838a71e61237720"
+          artifactSha256: "dd72b0867fc3be7cd90de263bd2d0892075cb18eb4f6dd671b13111710f10369",
+          vkSha256: "5e31d771e6294993736078596d9c69f21fe7595eda50e3cce6d7406b65cf1443"
         },
         samples: [
           {
-            gasUsed: "2489010",
-            transactionHash: "0x053557acea930a869d6469c91e9bc015d0893607a6ab18d2af684986f7074676",
-            blockNumber: "49",
-            blockHash: "0x734873097eb5e4cb66bfc2cdb61fac6753b53a4b9450fb22895281100af3aaf3",
-            calldataBytes: 17156
+            gasUsed: "3102895",
+            transactionHash: "0x699ba81f296f4af397a8dfaf96adf14d00d0f7dd69c0b09608641fc9b99fc28f",
+            blockNumber: "172",
+            blockHash: "0x8d318f563f5563fa5c213617481089f75aab3a6e9d14818db107ac20a8c20ffb",
+            calldataBytes: 30276
           },
           {
-            gasUsed: "2489106",
-            transactionHash: "0xb3990edb994011775e275bc1eb38c527b7206a2bfadf510e8aa53e260f3594b8",
-            blockNumber: "49",
-            blockHash: "0xf8cb019ebb0ecd0ec5d6634198292883c63fe93a7c65c34f9f3120c6cc54f1cf",
-            calldataBytes: 17156
+            gasUsed: "3102871",
+            transactionHash: "0xddfc1c6c505f6c54f4d9aabc96a02eb6b606182e8ad708a578eacd274d885dee",
+            blockNumber: "172",
+            blockHash: "0xcc7738fe329a608241615dc43b7d16e075eb62be202ea8aaf4ae27a5278bf438",
+            calldataBytes: 30276
           },
           {
-            gasUsed: "2489094",
-            transactionHash: "0xc97079019567ff8a79d285421351ee4bc48d14092a0e12ff634151719e991088",
-            blockNumber: "49",
-            blockHash: "0x5a6947839165c8961eeeb9190331415c40366a78b4a6a5771e7b8954dbb8b3c7",
-            calldataBytes: 17156
+            gasUsed: "3103171",
+            transactionHash: "0x6efab6408d927e1877f1f6c33ecd285a128382f7d1dfe6e123927b035781c8aa",
+            blockNumber: "172",
+            blockHash: "0xcb4588df9ecdca0d353ccbd226e1d5d07f21e6dc93875e41cdd5f64568859f4d",
+            calldataBytes: 30276
           }
         ]
       },
       {
-        id: "transfer-1x56",
+        id: "draw-credit-12-full",
         shape: {
-          kind: "transfer",
+          kind: "draw-credit",
           target: "evm",
-          capacity: 112,
-          noteInputs: 1,
-          noteOutputs: 56,
+          capacity: 12,
+          noteInputs: 0,
+          noteOutputs: 0,
           sourceTrees: 1,
-          creditInputs: 0,
+          creditInputs: 12,
           creditOutputs: 0,
           creditRemainders: 0,
           funding: "none",
           permit: false,
-          deliveryBytes: 12656
+          deliveryBytes: 0
         },
         circuit: {
-          circuitName: "transact_user_slots112",
+          circuitName: "credit_draw_slots12",
           target: "evm",
-          artifactSha256: "713b78469b6e97711122210f8497942120c1c9d66d3604bc184566c4eba59cc3",
-          vkSha256: "d6a46e297949c28b9a62fd9aef1f202870fdca97b8bfb15beefd27b9e9f3d86e"
+          artifactSha256: "dd72b0867fc3be7cd90de263bd2d0892075cb18eb4f6dd671b13111710f10369",
+          vkSha256: "5e31d771e6294993736078596d9c69f21fe7595eda50e3cce6d7406b65cf1443"
         },
         samples: [
           {
-            gasUsed: "5389227",
-            transactionHash: "0xb820d3c358724c1d64422017f232d074e4ff1ffaf1b1ce5ee719409427cf2208",
-            blockNumber: "49",
-            blockHash: "0x474bd1e52457801d1a596a9f23aeb6d365a17be028ee0c8cf8fd4758eaa1106b",
-            calldataBytes: 36356
+            gasUsed: "1536675",
+            transactionHash: "0xc0d3eef8e6b0e90984d776a5e41bcdce1e0ca0bc6dc3a71616e4768e80c01546",
+            blockNumber: "172",
+            blockHash: "0x22dfac3d8e9913a6a1f2ff84faaece4ed59bfe1cb74e06a60131ff28cc6c2f9d",
+            calldataBytes: 15684
           },
           {
-            gasUsed: "5389095",
-            transactionHash: "0x16514d8cf1136d7a7f40591859e2ea2d256af66520498e1fc81eb28837db600d",
-            blockNumber: "49",
-            blockHash: "0x42314a0d6eb9e765869e1b66b279444c78f919d2c28aed544d9fa7ac3bd2acb4",
-            calldataBytes: 36356
+            gasUsed: "1536675",
+            transactionHash: "0x9879d86a1eaa550a6a6afaeeb0f5f07745d5dcd9caa07b660d7fb512911dc67e",
+            blockNumber: "172",
+            blockHash: "0xf88ba9f1b7a0c627338a61bbabe1c650bdfcd7fa1c56433d6853f492135b753d",
+            calldataBytes: 15684
           },
           {
-            gasUsed: "5389203",
-            transactionHash: "0xee69d565a7eafb60ad7a47afe80a49d4fa40b50660669d9141e7dc6f4c3dbe0d",
-            blockNumber: "49",
-            blockHash: "0x0dcdada663ee04dd63e06fcdb79dacc5623201d29b687f63deede2b4762a994e",
-            calldataBytes: 36356
+            gasUsed: "1536711",
+            transactionHash: "0xbd8f75a021a8ce8dc1900bd2d84d723acc6a64018844050a5aa2f8712cf7fd6b",
+            blockNumber: "172",
+            blockHash: "0xa55b539c2ea4e10ce9a9ee8e6de9cf1daa97263b51f32cfef8342c100b663b0f",
+            calldataBytes: 15684
           }
         ]
       },
       {
-        id: "transfer-1x112",
+        id: "draw-credit-50-partial",
         shape: {
-          kind: "transfer",
+          kind: "draw-credit",
           target: "evm",
-          capacity: 168,
+          capacity: 50,
+          noteInputs: 0,
+          noteOutputs: 0,
+          sourceTrees: 1,
+          creditInputs: 50,
+          creditOutputs: 50,
+          creditRemainders: 50,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 56600
+        },
+        circuit: {
+          circuitName: "credit_draw_slots50",
+          target: "evm",
+          artifactSha256: "09c7469866748b4c0c4bbf2b040844771948a170999f6dc7a38fe5c0ecda4054",
+          vkSha256: "7b613225b6f32a077011d4196c356e836d22dcd116efe687fde53144fbd8db9f"
+        },
+        samples: [
+          {
+            gasUsed: "8015473",
+            transactionHash: "0x5dcc0fa08abaf5212424ac6f3e2f3bb8a0bd333f90ef6e421f8d3fe370ca1acf",
+            blockNumber: "172",
+            blockHash: "0x3197c523dece3492226c5021f974e7c02db2e686265943d03a5550c6cb96a12e",
+            calldataBytes: 94276
+          },
+          {
+            gasUsed: "8015449",
+            transactionHash: "0x6a55f88551a45b3e118cde0607cfff1ef0b6ab15ad9472e838412d9ce714b42a",
+            blockNumber: "172",
+            blockHash: "0xea82c8962d45db8361bd67ed326806f21c511bd51550adc453d0c3e5cab3a7ae",
+            calldataBytes: 94276
+          },
+          {
+            gasUsed: "8015149",
+            transactionHash: "0x2cc8d474a92abe91f8025109a70cf1f9f081dbec43aa4a475ab9f33222cfc76b",
+            blockNumber: "172",
+            blockHash: "0x4398f419da699ccca33867852d4975b5c461a40bb01cd5241a0e6dcacaeb78b3",
+            calldataBytes: 94276
+          }
+        ]
+      },
+      {
+        id: "draw-credit-50-full",
+        shape: {
+          kind: "draw-credit",
+          target: "evm",
+          capacity: 50,
+          noteInputs: 0,
+          noteOutputs: 0,
+          sourceTrees: 1,
+          creditInputs: 50,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 0
+        },
+        circuit: {
+          circuitName: "credit_draw_slots50",
+          target: "evm",
+          artifactSha256: "09c7469866748b4c0c4bbf2b040844771948a170999f6dc7a38fe5c0ecda4054",
+          vkSha256: "7b613225b6f32a077011d4196c356e836d22dcd116efe687fde53144fbd8db9f"
+        },
+        samples: [
+          {
+            gasUsed: "3216708",
+            transactionHash: "0x16933368d26ea1d7fbe69027c700671df832ad308944eeff42e7c2da40297b06",
+            blockNumber: "172",
+            blockHash: "0x0739a6f4188b8bdeae7bd5460960086d04adfea993d07d65b2b3630ad01b8cab",
+            calldataBytes: 33476
+          },
+          {
+            gasUsed: "3216840",
+            transactionHash: "0x45dc15a62b1661f54e167cf13b9693770370c926a8a7af959da7354e9bb4aa6e",
+            blockNumber: "172",
+            blockHash: "0xf2e294db9af3b11814fed1dec358b8370ea28a99189211f883c9b0012349d677",
+            calldataBytes: 33476
+          },
+          {
+            gasUsed: "3216744",
+            transactionHash: "0x2c827753026ea421497534a01bcc2adaca866a7612f570dad3fcf18c660f8590",
+            blockNumber: "172",
+            blockHash: "0x3ccd465528ff22e6d1955670220df3565899a16dd683f71c83c9810f2df420b4",
+            calldataBytes: 33476
+          }
+        ]
+      },
+      {
+        id: "draw-credit-120-partial",
+        shape: {
+          kind: "draw-credit",
+          target: "evm",
+          capacity: 120,
+          noteInputs: 0,
+          noteOutputs: 0,
+          sourceTrees: 1,
+          creditInputs: 120,
+          creditOutputs: 120,
+          creditRemainders: 120,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 135840
+        },
+        circuit: {
+          circuitName: "credit_draw_slots120",
+          target: "evm",
+          artifactSha256: "6ccd0366a669c50fd5da875c3eae194fe8aa4c36d35a5f9ebfd64636ea599b48",
+          vkSha256: "d715848afc5c1ecdfcef5ed5026865abef5040a3bc232fd65330a5ffee8475fb"
+        },
+        samples: [
+          {
+            gasUsed: "17458512",
+            transactionHash: "0x84dd6bda5f3172a53e899051fd226dc5869edb796bd513a33e7f224bed13f4ae",
+            blockNumber: "172",
+            blockHash: "0xfca82de1e112b92319185d8c3f0115e0aa339d0247ea65970eb0d37ba958b08e",
+            calldataBytes: 211140
+          },
+          {
+            gasUsed: "17458224",
+            transactionHash: "0xae26838942cf8b5499d43cb5e74681ae87aec77890a8eabddd692ff83830e013",
+            blockNumber: "172",
+            blockHash: "0x3e513447e0cfdbb682a95b7a719b0d300ec46b0ee22b518eaae7fb082f6436e7",
+            calldataBytes: 211140
+          },
+          {
+            gasUsed: "17458524",
+            transactionHash: "0xeaa07e77fe958f4317e71b07ddb876482ae9c5172fd6d6cefaacc551dbbda7d5",
+            blockNumber: "172",
+            blockHash: "0x12b34c1fd2e15480276052842157c2a6355acdd43d7bd01ae7511c3f39e0ecfc",
+            calldataBytes: 211140
+          }
+        ]
+      },
+      {
+        id: "draw-credit-120-full",
+        shape: {
+          kind: "draw-credit",
+          target: "evm",
+          capacity: 120,
+          noteInputs: 0,
+          noteOutputs: 0,
+          sourceTrees: 1,
+          creditInputs: 120,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 0
+        },
+        circuit: {
+          circuitName: "credit_draw_slots120",
+          target: "evm",
+          artifactSha256: "6ccd0366a669c50fd5da875c3eae194fe8aa4c36d35a5f9ebfd64636ea599b48",
+          vkSha256: "d715848afc5c1ecdfcef5ed5026865abef5040a3bc232fd65330a5ffee8475fb"
+        },
+        samples: [
+          {
+            gasUsed: "6289576",
+            transactionHash: "0xbf11743f7edc5ed5ff334efc5e35634f45e48e4940d33ddd9c87d8fe444dafc5",
+            blockNumber: "172",
+            blockHash: "0x774de17971107b73cab2cd20f26b60665f55a37b0cc1147166babf16743e34d5",
+            calldataBytes: 65220
+          },
+          {
+            gasUsed: "6289768",
+            transactionHash: "0x651bb13e0645ee8a08657db627f1072f5e964ddaff44f70f829440ed68488dea",
+            blockNumber: "172",
+            blockHash: "0xa9795828565fb0ce65bda295073106b8bbdc110bb8317d269839d3db3e312d5b",
+            calldataBytes: 65220
+          },
+          {
+            gasUsed: "6289720",
+            transactionHash: "0x2a859d381cb4b50830971b1ffc9789b11569fc96147e130dae6fecd141f5ceb0",
+            blockNumber: "172",
+            blockHash: "0x7d990830157bfeff8e5cbe580e9effe97faa7676c9957ce32891b76c83961430",
+            calldataBytes: 65220
+          }
+        ]
+      },
+      {
+        id: "top-up-credit-1x1-unchanged-limits",
+        shape: {
+          kind: "top-up-credit",
+          target: "evm",
+          capacity: 10,
           noteInputs: 1,
-          noteOutputs: 112,
+          noteOutputs: 1,
+          sourceTrees: 2,
+          creditInputs: 1,
+          creditOutputs: 1,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 1360
+        },
+        circuit: {
+          circuitName: "credit_top_up",
+          target: "evm",
+          artifactSha256: "2ffebd5753ec1b0c050204d4f97498765fe61ea01a793a9b2466c2f97536345c",
+          vkSha256: "40b02a9d2e7eb7b49daaac4b7760328537b7982fd5a225cc065bb74cd5ef44b3"
+        },
+        samples: [
+          {
+            gasUsed: "1711282",
+            transactionHash: "0x74d45084bb07bacabbced09ee6ef69d8632a22a4493be783c326c47e929ba0ed",
+            blockNumber: "172",
+            blockHash: "0x3503643f7081b52ae20d4754a0e9b11f52034ae48059f5b5298546c2570fa091",
+            calldataBytes: 12292
+          },
+          {
+            gasUsed: "1711282",
+            transactionHash: "0x4b5e2432d5571f6b56507b3ab995a8120560ba608959ff100f03b87873e72be6",
+            blockNumber: "172",
+            blockHash: "0xca15dc309371a5aa9c7bc5bf1d65c5b325c71528ce7856ba68a118114124fccc",
+            calldataBytes: 12292
+          },
+          {
+            gasUsed: "1711390",
+            transactionHash: "0x304f3740b64c80dcc5c894fb30af59080d96a11e08371096ae695cbc46ef2c8b",
+            blockNumber: "172",
+            blockHash: "0x9671ed76d6b8e49a36ba229d3609289fcf70756f31277ac5fc0e3f08cd52304f",
+            calldataBytes: 12292
+          }
+        ]
+      },
+      {
+        id: "top-up-credit-1x1-changed-limits",
+        shape: {
+          kind: "top-up-credit",
+          target: "evm",
+          capacity: 10,
+          noteInputs: 1,
+          noteOutputs: 1,
+          sourceTrees: 2,
+          creditInputs: 1,
+          creditOutputs: 1,
+          creditRemainders: 0,
+          funding: "none",
+          permit: false,
+          deliveryBytes: 1360
+        },
+        circuit: {
+          circuitName: "credit_top_up",
+          target: "evm",
+          artifactSha256: "2ffebd5753ec1b0c050204d4f97498765fe61ea01a793a9b2466c2f97536345c",
+          vkSha256: "40b02a9d2e7eb7b49daaac4b7760328537b7982fd5a225cc065bb74cd5ef44b3"
+        },
+        samples: [
+          {
+            gasUsed: "1711318",
+            transactionHash: "0x65284df534b42631f8a592fb2a6efc16361a4cc122f1a8dd41418e7b950f48f1",
+            blockNumber: "172",
+            blockHash: "0xf198242a1edf5b133961568c9165648c829729e7bfbbf57a1e148551c971b87c",
+            calldataBytes: 12292
+          },
+          {
+            gasUsed: "1711438",
+            transactionHash: "0xcee89a81e598974798365c4ebada806fb51196ee602334b0fffdbb25da0afe25",
+            blockNumber: "172",
+            blockHash: "0xb506a6fb54cc2f91b803211ed955aac0203fba93e2428f8f52ec0d413c90af09",
+            calldataBytes: 12292
+          },
+          {
+            gasUsed: "1711342",
+            transactionHash: "0x957de5c79f365c9b0510b9e125a662317494aad50cb446edceef6f678d561cc7",
+            blockNumber: "172",
+            blockHash: "0xb1d5cffd6d6db58ade9d5e16d48b060b9ab2152415966dc809e7e70785472ab8",
+            calldataBytes: 12292
+          }
+        ]
+      },
+      {
+        id: "cancel-credit-1",
+        shape: {
+          kind: "cancel-credit",
+          target: "evm",
+          capacity: 1,
+          noteInputs: 0,
+          noteOutputs: 0,
           sourceTrees: 1,
-          creditInputs: 0,
+          creditInputs: 1,
           creditOutputs: 0,
           creditRemainders: 0,
           funding: "none",
           permit: false,
-          deliveryBytes: 25312
+          deliveryBytes: 0
         },
         circuit: {
-          circuitName: "transact_user_slots168",
+          circuitName: "credit_cancel",
           target: "evm",
-          artifactSha256: "f7b3b1384e961367702f544299ca3521d8205fac31b7691c45ff84325d5a31c3",
-          vkSha256: "e00181533d7e35d2307570528f9e7f8f88e2909b6ae338d93373b608dea96881"
+          artifactSha256: "b4459c2cf756d096e37291cf4d7cd129866b6d420b6d03c928f383b057112ccb",
+          vkSha256: "fc8ad196ef15f3328afcc8f01d867a3ebefd15451c2813948442fab1923b73b2"
         },
         samples: [
           {
-            gasUsed: "9139842",
-            transactionHash: "0x09951c4e00b868b6660429d187a482004646e4c84ef341d3b98352c249db6a06",
-            blockNumber: "49",
-            blockHash: "0xba9da3c08189335acff1eb33554f5f12475e4a6510324cf6ec9eadf340ce15d2",
-            calldataBytes: 61444
+            gasUsed: "985543",
+            transactionHash: "0x29ca63fbefcc5e92dbc86f67d6280993e567a5dd02ff3defd7f3251ce711865e",
+            blockNumber: "172",
+            blockHash: "0xecd7808fe9f7467af917069bd7a82ab0324e3cbab8dcad622b089d6e3eee9a58",
+            calldataBytes: 9540
           },
           {
-            gasUsed: "9139650",
-            transactionHash: "0xb06f69d1c6e5406758918d5d296ab889bab4c3814f616cc581ad312cc7ebb2f3",
-            blockNumber: "49",
-            blockHash: "0x5516a76b4b366f2e539a67bb848b7d232c3e6f328d34ca5bd3dba43a14c316bf",
-            calldataBytes: 61444
+            gasUsed: "985795",
+            transactionHash: "0xaf8bca0769330f89b647363f99b752dbbe6fdbb8b1aae912224f6a3a59f40faa",
+            blockNumber: "172",
+            blockHash: "0x58e1358e02f189d57628fa7c504b87fb000fe60eb9f0a0c3c0e58dae876e64da",
+            calldataBytes: 9540
           },
           {
-            gasUsed: "9139530",
-            transactionHash: "0x116c4875b7712b7cb51cdb0fcb6e66a95733dca272aa272bc0b1fd265edbe26c",
-            blockNumber: "49",
-            blockHash: "0xd36340fddd1eace21b73f785c6589bf73b07bef782f2e78a5e3d3d828b0b607c",
-            calldataBytes: 61444
+            gasUsed: "985711",
+            transactionHash: "0x2c911fd5a422f6f72f2a00b16872b7e46e182d39b8f5bfa9e3b2bf99d3155da7",
+            blockNumber: "172",
+            blockHash: "0x9da571cbe63f52232261ee1527d5ed97a9e90e374b4fcda97d04feb25114d18e",
+            calldataBytes: 9540
+          }
+        ]
+      }
+    ]
+  },
+  {
+    formatVersion: 1,
+    id: "protocol-92ef274-osaka-real",
+    deployment: {
+      chainId: "31337",
+      protocolAddress: "0x8870C63A18a9480C7de9B860b849fD293832856D",
+      runtimeCodeHash: "0x604572c0da90ea139b774cd0d2962a2972fac46e0556c7cec6f6f9aac5deef14",
+      tokenAddress: "0x4826533B4897376654Bb4d4AD88B7faFD0C98528"
+    },
+    source: {
+      protocolCommit: "92ef274c6b36d783507699a33ee20e52192c83c7",
+      measuredAt: "2026-10-27T08:42:15.991Z",
+      chain: "Anvil 31337",
+      hardfork: "osaka",
+      token: "MockERC20",
+      verifier: "real",
+      assumptions: [
+        "normal CREATE/Factory deployment; no code or storage injection",
+        "Solidity 0.8.27 optimizer 200; real BB 5.2.1 verifiers",
+        "one source tree; two existing leaves; no rollover or screener",
+        "funding/approval setup excluded; complete transaction receipt gas included",
+        "exact allowance for caller funding; configured benchmark payout balances",
+        "observed local samples, not a confidence interval or gas limit"
+      ]
+    },
+    measurements: [
+      {
+        id: "shield-1",
+        shape: {
+          kind: "shield",
+          target: "evm",
+          capacity: 0,
+          noteInputs: 0,
+          noteOutputs: 1,
+          sourceTrees: 0,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "caller",
+          permit: false,
+          deliveryBytes: 226
+        },
+        circuit: null,
+        samples: [
+          {
+            gasUsed: "649286",
+            transactionHash: "0xcc299d1780ada9a69b1d9f0f3d06a165db15fccbd2b7ff407834f02f5d563a18",
+            blockNumber: "50",
+            blockHash: "0xbcb868e781a20588d2fa099a4d7f87c1600044a2e5ec1e369e384d7a5f22f00a",
+            calldataBytes: 1156
+          },
+          {
+            gasUsed: "649322",
+            transactionHash: "0x95139dff109725989f0769e3e6fb9bd3e7e1bf581fd475f14e822875eb90fda4",
+            blockNumber: "50",
+            blockHash: "0x7ace353fea4fc8c856c0fd45521d200b02619921977709ff4f910e0ff41c06fe",
+            calldataBytes: 1156
+          },
+          {
+            gasUsed: "649322",
+            transactionHash: "0xef578bb38dc8ff8bfd47d2e76e3ab4273019ea9a385f5d2fd99add32ceaecb58",
+            blockNumber: "50",
+            blockHash: "0xded817f8ef89637e2443e3b626c0837f184ca134fe753be913d5570554c649a6",
+            calldataBytes: 1156
           }
         ]
       },
       {
-        id: "withdraw-1x1",
+        id: "shield-2",
         shape: {
-          kind: "withdraw",
+          kind: "shield",
+          target: "evm",
+          capacity: 0,
+          noteInputs: 0,
+          noteOutputs: 2,
+          sourceTrees: 0,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "caller",
+          permit: false,
+          deliveryBytes: 452
+        },
+        circuit: null,
+        samples: [
+          {
+            gasUsed: "757063",
+            transactionHash: "0x024e2dfbd6f50c368e2a4aa347e3029de668f4ebd36b80227aa003bb7ac21c74",
+            blockNumber: "50",
+            blockHash: "0x8ed63973c158d706ac54bb646626e4f0db5777b4bd56d179b94503af6c417c50",
+            calldataBytes: 1668
+          },
+          {
+            gasUsed: "757063",
+            transactionHash: "0x898d852ab28f68adac4d30b160a3dbfee33fa7ca875f70df9eb7763b6b1cd1f0",
+            blockNumber: "50",
+            blockHash: "0x9bb6810de38193933a9f26fa03d3d9bad1ca0151ff5e04544c56520e09da3043",
+            calldataBytes: 1668
+          },
+          {
+            gasUsed: "757039",
+            transactionHash: "0x8ff9720e3197aab2d741fbd8d0fa2969203ea8cd051d9649d1e5eb890bcc2be3",
+            blockNumber: "50",
+            blockHash: "0x8604c75eb6363aaae774276e638f5b749aae1f8f815eb99ab1183137eef5730e",
+            calldataBytes: 1668
+          }
+        ]
+      },
+      {
+        id: "shield-10",
+        shape: {
+          kind: "shield",
+          target: "evm",
+          capacity: 0,
+          noteInputs: 0,
+          noteOutputs: 10,
+          sourceTrees: 0,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
+          funding: "caller",
+          permit: false,
+          deliveryBytes: 2260
+        },
+        circuit: null,
+        samples: [
+          {
+            gasUsed: "1692143",
+            transactionHash: "0x6c13db8bd8a8599daf5034e56712abefbf406982fafe7647b6d22291ba4199ed",
+            blockNumber: "50",
+            blockHash: "0x1ab2ae514f408a79e0c40ca10cee74b2e23d7c8a5f24641b8eea3e1cf58ce700",
+            calldataBytes: 5764
+          },
+          {
+            gasUsed: "1692083",
+            transactionHash: "0x5e476c9d3838b782a51332af9bf5c372d29fc411c2168a7af619c52bd5309c7b",
+            blockNumber: "50",
+            blockHash: "0x9c62bc72fc90f990c6711b48865ff922a1856ae05c4fef61dad5f4da7d948401",
+            calldataBytes: 5764
+          },
+          {
+            gasUsed: "1692203",
+            transactionHash: "0x0092e2d9160fad95279cde586fc6c79c713244f55db8a2060a5abab9d98c176a",
+            blockNumber: "50",
+            blockHash: "0xac1bf780b4cc05b4dcc7ee5d741c049ba99ab4af9bdcd25104add730c2a14152",
+            calldataBytes: 5764
+          }
+        ]
+      },
+      {
+        id: "transfer-1x2",
+        shape: {
+          kind: "transfer",
           target: "evm",
           capacity: 14,
           noteInputs: 1,
-          noteOutputs: 1,
+          noteOutputs: 2,
           sourceTrees: 1,
           creditInputs: 0,
           creditOutputs: 0,
           creditRemainders: 0,
           funding: "none",
           permit: false,
-          deliveryBytes: 226
+          deliveryBytes: 452
         },
         circuit: {
           circuitName: "transact_user_slots14",
@@ -733,222 +1428,222 @@ var gas_benchmarks_default = [
         },
         samples: [
           {
-            gasUsed: "1597571",
-            transactionHash: "0x326892d32146e0bc36b396fd3973151a629312df68ed25a4ffbb6a3da23ba274",
+            gasUsed: "1617516",
+            transactionHash: "0xf49ea3d31cc1346472172e2dee84f9360f60a3fe948a3ef6e87f727af6d42f0d",
             blockNumber: "49",
-            blockHash: "0x3e0f326cba3dd019b86431b4c22145758a7f10c121a696a81a094746b04495b5",
-            calldataBytes: 10564
+            blockHash: "0xf59c57e63ec2f03abc36d28f273b0af5290184dc97197df740b23d79a851a887",
+            calldataBytes: 11012
           },
           {
-            gasUsed: "1597715",
-            transactionHash: "0x2e3a15157ac9c07e4717bbd4641481ce3bc0068d26157752815b6ec6b30acdd0",
+            gasUsed: "1617516",
+            transactionHash: "0xf8d11286f1f2a4db006ff6b06900c47d0fbf685984499e1e5d4aea49478ba8e5",
             blockNumber: "49",
-            blockHash: "0xab7fceac97d55e8702d1202b98d3a05c4b1e0f71e51b6d88d7e80e91cc338596",
-            calldataBytes: 10564
+            blockHash: "0xeb5a800190be3534c9e2675c97ac56d0e0be8adef55f60bd32d375776a7d150c",
+            calldataBytes: 11012
           },
           {
-            gasUsed: "1597595",
-            transactionHash: "0x5052e94a67520c43416cdcb60a1365a126560861173d0eef46bcbf0a566fe947",
+            gasUsed: "1617504",
+            transactionHash: "0x8939fcea97079a3c5118b9e94325455e2ad1cdb47310ae499a277272654b3eb6",
             blockNumber: "49",
-            blockHash: "0x9a64cf76b646b5a07b72fcc61266e87f17365fec891701c331982a93e5ba9b89",
-            calldataBytes: 10564
+            blockHash: "0xecffefb593e2fec5d5827cfd39d0cc4d0efb67dbff6f8dbbd0d2db2439a80cf9",
+            calldataBytes: 11012
           }
         ]
       },
       {
-        id: "sweep-1x0",
+        id: "transfer-1x14",
         shape: {
-          kind: "sweep",
+          kind: "transfer",
           target: "evm",
-          capacity: 14,
+          capacity: 56,
           noteInputs: 1,
-          noteOutputs: 0,
+          noteOutputs: 14,
           sourceTrees: 1,
           creditInputs: 0,
           creditOutputs: 0,
           creditRemainders: 0,
           funding: "none",
           permit: false,
-          deliveryBytes: 0
+          deliveryBytes: 3164
         },
         circuit: {
-          circuitName: "transact_user_slots14",
+          circuitName: "transact_user_slots56",
           target: "evm",
-          artifactSha256: "2a6a20839e90b88b1ecd629f59a01821bad3ee11dbe04db1fd9cdce7a3de0e84",
-          vkSha256: "ffe0e1a4e690792ecb4eb1fc1acc9ff60f13d3b5af03cfc6ae6d6bf26e99bdea"
+          artifactSha256: "ba83ec2f177d16fa88ea04bc54f2e99920f1ac195cdb05b88b9b3bbc245fd953",
+          vkSha256: "6ad5d3aff0c72a632fb19895658af093a6a92478a9994985e838a71e61237720"
         },
         samples: [
           {
-            gasUsed: "1069308",
-            transactionHash: "0xb1ab469d05ca5f49659f54a332cc172892dcce37e475342fbf52fa9cfb4d3927",
+            gasUsed: "2489010",
+            transactionHash: "0x053557acea930a869d6469c91e9bc015d0893607a6ab18d2af684986f7074676",
             blockNumber: "49",
-            blockHash: "0xe5b04579149987198801f1ca19ab771d5262de2aaf9861a6c962d50d1c6baef0",
-            calldataBytes: 10116
+            blockHash: "0x734873097eb5e4cb66bfc2cdb61fac6753b53a4b9450fb22895281100af3aaf3",
+            calldataBytes: 17156
           },
           {
-            gasUsed: "1069284",
-            transactionHash: "0xd6adee997f7e1e19e3918f913f6ee48d94df69c09ed74e333325023089e7f6df",
+            gasUsed: "2489106",
+            transactionHash: "0xb3990edb994011775e275bc1eb38c527b7206a2bfadf510e8aa53e260f3594b8",
             blockNumber: "49",
-            blockHash: "0xcb225566f8f1ea6ae8da30158b8f1aef03d50fa4ea352a00aa42b7f41a05d63c",
-            calldataBytes: 10116
+            blockHash: "0xf8cb019ebb0ecd0ec5d6634198292883c63fe93a7c65c34f9f3120c6cc54f1cf",
+            calldataBytes: 17156
           },
           {
-            gasUsed: "1069308",
-            transactionHash: "0xe06dd7f3a2718bc9a9412c2d6f505960ce225b2e5fe6c1c66bb5b0e8f427006f",
+            gasUsed: "2489094",
+            transactionHash: "0xc97079019567ff8a79d285421351ee4bc48d14092a0e12ff634151719e991088",
             blockNumber: "49",
-            blockHash: "0x37a08c5918892e1c19df017c746ab0ede03c1bb195c3be593d70c1f9de91897e",
-            calldataBytes: 10116
+            blockHash: "0x5a6947839165c8961eeeb9190331415c40366a78b4a6a5771e7b8954dbb8b3c7",
+            calldataBytes: 17156
           }
         ]
       },
       {
-        id: "create-credit-1x1",
+        id: "transfer-1x56",
         shape: {
-          kind: "create-credit",
+          kind: "transfer",
           target: "evm",
-          capacity: 10,
+          capacity: 112,
           noteInputs: 1,
-          noteOutputs: 1,
+          noteOutputs: 56,
           sourceTrees: 1,
           creditInputs: 0,
-          creditOutputs: 1,
+          creditOutputs: 0,
           creditRemainders: 0,
           funding: "none",
           permit: false,
-          deliveryBytes: 1162
+          deliveryBytes: 12656
         },
         circuit: {
-          circuitName: "create_credit",
+          circuitName: "transact_user_slots112",
           target: "evm",
-          artifactSha256: "ab97cd5a036851a9748a5cfd8e6f9834e23090c8e95db4531aabfc37d3abb353",
-          vkSha256: "fac0e65b768a28750323cca851990598af936611125b6cfa3f5c16b04c7d084f"
+          artifactSha256: "713b78469b6e97711122210f8497942120c1c9d66d3604bc184566c4eba59cc3",
+          vkSha256: "d6a46e297949c28b9a62fd9aef1f202870fdca97b8bfb15beefd27b9e9f3d86e"
         },
         samples: [
           {
-            gasUsed: "1627325",
-            transactionHash: "0x7763d93a5b1e8797b5f4af2e1e5b1bb029a8b0f9f7b90bcc04f581947d826803",
+            gasUsed: "5389227",
+            transactionHash: "0xb820d3c358724c1d64422017f232d074e4ff1ffaf1b1ce5ee719409427cf2208",
             blockNumber: "49",
-            blockHash: "0x93e51ae5e99c68dc642693d478e444330d8e26255ff5bb9aafc4a3f4e70d3a45",
-            calldataBytes: 11940
+            blockHash: "0x474bd1e52457801d1a596a9f23aeb6d365a17be028ee0c8cf8fd4758eaa1106b",
+            calldataBytes: 36356
           },
           {
-            gasUsed: "1627385",
-            transactionHash: "0xe246d59cafa2a26dddf21c8385dd843be4d4596388ebe23e936df84e7f906635",
+            gasUsed: "5389095",
+            transactionHash: "0x16514d8cf1136d7a7f40591859e2ea2d256af66520498e1fc81eb28837db600d",
             blockNumber: "49",
-            blockHash: "0x3c24b2d6ed2a998562d34b49e0517515742a9b39d59aec38a9ac6b22be1b694b",
-            calldataBytes: 11940
+            blockHash: "0x42314a0d6eb9e765869e1b66b279444c78f919d2c28aed544d9fa7ac3bd2acb4",
+            calldataBytes: 36356
           },
           {
-            gasUsed: "1627157",
-            transactionHash: "0x2f7ed0b75435cc6a820d0cd90fd82d362f74787057413722b6eb3c6e37db87d3",
+            gasUsed: "5389203",
+            transactionHash: "0xee69d565a7eafb60ad7a47afe80a49d4fa40b50660669d9141e7dc6f4c3dbe0d",
             blockNumber: "49",
-            blockHash: "0x0a0301670b46017da772800c68bb941245ac1941c79fde9c85717632154e15ee",
-            calldataBytes: 11940
+            blockHash: "0x0dcdada663ee04dd63e06fcdb79dacc5623201d29b687f63deede2b4762a994e",
+            calldataBytes: 36356
           }
         ]
       },
       {
-        id: "draw-credit-1-partial",
+        id: "transfer-1x112",
         shape: {
-          kind: "draw-credit",
+          kind: "transfer",
           target: "evm",
-          capacity: 1,
-          noteInputs: 0,
-          noteOutputs: 0,
+          capacity: 168,
+          noteInputs: 1,
+          noteOutputs: 112,
           sourceTrees: 1,
-          creditInputs: 1,
-          creditOutputs: 1,
-          creditRemainders: 1,
+          creditInputs: 0,
+          creditOutputs: 0,
+          creditRemainders: 0,
           funding: "none",
           permit: false,
-          deliveryBytes: 936
+          deliveryBytes: 25312
         },
         circuit: {
-          circuitName: "credit_draw_slots1",
+          circuitName: "transact_user_slots168",
           target: "evm",
-          artifactSha256: "f5e458790948f37a61a833fad52cf2cc3b26a59515d271de32e0caaa4e229eb5",
-          vkSha256: "613699a440f50a0937e4c57e5152b5fdea42c31b10157d6b93226fef313df553"
+          artifactSha256: "f7b3b1384e961367702f544299ca3521d8205fac31b7691c45ff84325d5a31c3",
+          vkSha256: "e00181533d7e35d2307570528f9e7f8f88e2909b6ae338d93373b608dea96881"
         },
         samples: [
           {
-            gasUsed: "1581294",
-            transactionHash: "0xd438e22b0fa07a657279f182537e4996f1936f0881d5b7d637845f8ca2808aab",
+            gasUsed: "9139842",
+            transactionHash: "0x09951c4e00b868b6660429d187a482004646e4c84ef341d3b98352c249db6a06",
             blockNumber: "49",
-            blockHash: "0x9e384a3054530b1ff237a639bca1a559afb2b73b30e21c262aac85ebf480fc9b",
-            calldataBytes: 11396
+            blockHash: "0xba9da3c08189335acff1eb33554f5f12475e4a6510324cf6ec9eadf340ce15d2",
+            calldataBytes: 61444
           },
           {
-            gasUsed: "1581402",
-            transactionHash: "0xa70ac3e7284b6e98f8591a6ba88e4ddfb23ecbd05343641d0532f34920e10b56",
+            gasUsed: "9139650",
+            transactionHash: "0xb06f69d1c6e5406758918d5d296ab889bab4c3814f616cc581ad312cc7ebb2f3",
             blockNumber: "49",
-            blockHash: "0x37c5eb34ce96a841e96c36103a7ab65c1a3e08603dc9843efb0c0752c069f1d4",
-            calldataBytes: 11396
+            blockHash: "0x5516a76b4b366f2e539a67bb848b7d232c3e6f328d34ca5bd3dba43a14c316bf",
+            calldataBytes: 61444
           },
           {
-            gasUsed: "1581174",
-            transactionHash: "0xd062494979d0bc0e284ccb070f87b48f3e8e5befb6001f15a006dd2a4a72ca24",
+            gasUsed: "9139530",
+            transactionHash: "0x116c4875b7712b7cb51cdb0fcb6e66a95733dca272aa272bc0b1fd265edbe26c",
             blockNumber: "49",
-            blockHash: "0x12840d920f14163b2d29491f28cee616e1bb9fd9514a4debe10ae35256345fc1",
-            calldataBytes: 11396
+            blockHash: "0xd36340fddd1eace21b73f785c6589bf73b07bef782f2e78a5e3d3d828b0b607c",
+            calldataBytes: 61444
           }
         ]
       },
       {
-        id: "top-up-credit-1x1",
+        id: "withdraw-1x1",
         shape: {
-          kind: "top-up-credit",
+          kind: "withdraw",
           target: "evm",
-          capacity: 10,
+          capacity: 14,
           noteInputs: 1,
           noteOutputs: 1,
-          sourceTrees: 2,
-          creditInputs: 1,
-          creditOutputs: 1,
+          sourceTrees: 1,
+          creditInputs: 0,
+          creditOutputs: 0,
           creditRemainders: 0,
           funding: "none",
           permit: false,
-          deliveryBytes: 1162
+          deliveryBytes: 226
         },
         circuit: {
-          circuitName: "credit_top_up",
+          circuitName: "transact_user_slots14",
           target: "evm",
-          artifactSha256: "ee9dbcf8be6f6c09478190996e90b1d39d4a10a00245950f69fc1d2c329c6e9b",
-          vkSha256: "0c369fec0469b60baebb3be650bad42f3ccae6f0ff139cce6ad9a3f451ed7513"
+          artifactSha256: "2a6a20839e90b88b1ecd629f59a01821bad3ee11dbe04db1fd9cdce7a3de0e84",
+          vkSha256: "ffe0e1a4e690792ecb4eb1fc1acc9ff60f13d3b5af03cfc6ae6d6bf26e99bdea"
         },
         samples: [
           {
-            gasUsed: "1666948",
-            transactionHash: "0x1403da01167962a4349d2655ea217bfcfc1a2390138bea0279792c44b4381dd2",
+            gasUsed: "1597571",
+            transactionHash: "0x326892d32146e0bc36b396fd3973151a629312df68ed25a4ffbb6a3da23ba274",
             blockNumber: "49",
-            blockHash: "0xcb554ffcdb4afe5f6458e5d23ffbdd1fdbef9c23f982343065772c0b3e3dd633",
-            calldataBytes: 12100
+            blockHash: "0x3e0f326cba3dd019b86431b4c22145758a7f10c121a696a81a094746b04495b5",
+            calldataBytes: 10564
           },
           {
-            gasUsed: "1666900",
-            transactionHash: "0x3b5e54f29e3f888a443526cf23ab9255b3f0c7adf1d0d127c16b85f4c6a324d9",
+            gasUsed: "1597715",
+            transactionHash: "0x2e3a15157ac9c07e4717bbd4641481ce3bc0068d26157752815b6ec6b30acdd0",
             blockNumber: "49",
-            blockHash: "0xeb304df6bdd24b249cac3197b543b0eaa6381ed75ad812dff248f914864105ed",
-            calldataBytes: 12100
+            blockHash: "0xab7fceac97d55e8702d1202b98d3a05c4b1e0f71e51b6d88d7e80e91cc338596",
+            calldataBytes: 10564
           },
           {
-            gasUsed: "1666780",
-            transactionHash: "0x81c5ef25268a719275cb3b80618c2af291e1f7b3f91d7e82cc26bc894a8c332a",
+            gasUsed: "1597595",
+            transactionHash: "0x5052e94a67520c43416cdcb60a1365a126560861173d0eef46bcbf0a566fe947",
             blockNumber: "49",
-            blockHash: "0xfa42070d6349fc8d559b8bd4ad0ee6b79089107540c4472b9e492b8f5a6bd3e4",
-            calldataBytes: 12100
+            blockHash: "0x9a64cf76b646b5a07b72fcc61266e87f17365fec891701c331982a93e5ba9b89",
+            calldataBytes: 10564
           }
         ]
       },
       {
-        id: "cancel-credit-1",
+        id: "sweep-1x0",
         shape: {
-          kind: "cancel-credit",
+          kind: "sweep",
           target: "evm",
-          capacity: 1,
-          noteInputs: 0,
+          capacity: 14,
+          noteInputs: 1,
           noteOutputs: 0,
           sourceTrees: 1,
-          creditInputs: 1,
+          creditInputs: 0,
           creditOutputs: 0,
           creditRemainders: 0,
           funding: "none",
@@ -956,32 +1651,32 @@ var gas_benchmarks_default = [
           deliveryBytes: 0
         },
         circuit: {
-          circuitName: "credit_cancel",
+          circuitName: "transact_user_slots14",
           target: "evm",
-          artifactSha256: "d332453a2b8c2c544747ac8d5f01912c9757f48d986226fd6a9b0e24d8321474",
-          vkSha256: "1f8a3c20cb081d6a90962556da3124919cc4e5675e59ad31562af39299da02fb"
+          artifactSha256: "2a6a20839e90b88b1ecd629f59a01821bad3ee11dbe04db1fd9cdce7a3de0e84",
+          vkSha256: "ffe0e1a4e690792ecb4eb1fc1acc9ff60f13d3b5af03cfc6ae6d6bf26e99bdea"
         },
         samples: [
           {
-            gasUsed: "998146",
-            transactionHash: "0x97bc72692d241e2c344b912804f9939061db5ef59cf4bb23922d93812e382160",
+            gasUsed: "1069308",
+            transactionHash: "0xb1ab469d05ca5f49659f54a332cc172892dcce37e475342fbf52fa9cfb4d3927",
             blockNumber: "49",
-            blockHash: "0x2e09df4df84a1c25961386febe8404531bb5da274836d50cc15a26c91b433a98",
-            calldataBytes: 9540
+            blockHash: "0xe5b04579149987198801f1ca19ab771d5262de2aaf9861a6c962d50d1c6baef0",
+            calldataBytes: 10116
           },
           {
-            gasUsed: "998134",
-            transactionHash: "0x26c5067b12c2bc4b694070784e6b19d4855efa6e77c2422f0c6b1567f061570a",
+            gasUsed: "1069284",
+            transactionHash: "0xd6adee997f7e1e19e3918f913f6ee48d94df69c09ed74e333325023089e7f6df",
             blockNumber: "49",
-            blockHash: "0xdd3f20520c09e001374cab58387e52c82446db053539e30dad28b0de679a333c",
-            calldataBytes: 9540
+            blockHash: "0xcb225566f8f1ea6ae8da30158b8f1aef03d50fa4ea352a00aa42b7f41a05d63c",
+            calldataBytes: 10116
           },
           {
-            gasUsed: "998230",
-            transactionHash: "0x5dc09445a405150da1445c22f50d6dd10d8d428a6a3f41ee90db7d3574657e31",
+            gasUsed: "1069308",
+            transactionHash: "0xe06dd7f3a2718bc9a9412c2d6f505960ce225b2e5fe6c1c66bb5b0e8f427006f",
             blockNumber: "49",
-            blockHash: "0x5c8f8223a50d2c8d48188a2db28ffa33c1b150a2fb465e99db4430949db3664b",
-            calldataBytes: 9540
+            blockHash: "0x37a08c5918892e1c19df017c746ab0ede03c1bb195c3be593d70c1f9de91897e",
+            calldataBytes: 10116
           }
         ]
       }
@@ -1012,6 +1707,29 @@ function copyGasBenchmarks(profiles) {
   for (const p of copy) {
     if (p.formatVersion !== 1 || !p.id || !decimal.test(p.deployment.chainId) || !address.test(p.deployment.protocolAddress) || !address.test(p.deployment.tokenAddress) || !p.deployment.runtimeCodeHash || !word.test(p.deployment.runtimeCodeHash) || p.source.verifier !== "real" || !/^[0-9a-f]{40}$/i.test(p.source.protocolCommit) || !p.source.measuredAt || !Array.isArray(p.source.assumptions) || !p.source.assumptions.every((assumption) => typeof assumption === "string") || !p.measurements.length)
       throw new Error("invalid gas benchmark profile");
+    if (p.source.fingerprints && ![
+      "protocolSourceSha256",
+      "dirtyDiffSha256",
+      "compiledArtifactsSha256",
+      "creditManifestSha256",
+      "userManifestSha256",
+      "sdkSourceSha256"
+    ].every((key) => {
+      const v = p.source.fingerprints[key];
+      return typeof v === "string" && /^[a-f0-9]{64}$/i.test(v);
+    }))
+      throw new Error("invalid benchmark source fingerprint");
+    if (p.source.blockGasLimit !== void 0 && (!decimal.test(p.source.blockGasLimit) || BigInt(p.source.blockGasLimit) <= 0n))
+      throw new Error("invalid benchmark block gas limit");
+    if (p.source.runtimeContracts && !Object.values(p.source.runtimeContracts).every(
+      (v) => address.test(v.address) && word.test(v.runtimeCodeHash)
+    ))
+      throw new Error("invalid benchmark runtime identity");
+    if (p.source.toolchain && (!["solidity", "barretenberg", "noir", "evmVersion", "anvil"].every((key) => {
+      const v = p.source.toolchain[key];
+      return typeof v === "string" && v.length > 0;
+    }) || !Number.isSafeInteger(p.source.toolchain.optimizerRuns) || p.source.toolchain.optimizerRuns < 0))
+      throw new Error("invalid benchmark toolchain");
     for (const m of p.measurements) {
       if (!m.id || !m.samples.length || !["none", "caller", "signature"].includes(m.shape.funding) || typeof m.shape.permit !== "boolean")
         throw new Error("invalid gas benchmark measurement");
@@ -1091,11 +1809,20 @@ function estimateBenchmarkGas(plan, protocol, profiles) {
   );
   if (!request.deployment.runtimeCodeHash || !candidates.length)
     return { ...base, available: false, reason: "deployment-not-covered" };
-  for (const profile of candidates) {
-    const measurement = profile.measurements.find(
+  const exact = candidates.flatMap(
+    (profile) => profile.measurements.filter(
       (m) => shapeKeys.every((key) => m.shape[key] === request.shape[key]) && sameCircuit(m.circuit, request.circuit)
-    );
-    if (!measurement) continue;
+    ).map((measurement) => ({ profile, measurement }))
+  );
+  const mean = (measurement) => {
+    const count = BigInt(measurement.samples.length);
+    return (measurement.samples.reduce((sum, s) => sum + BigInt(s.gasUsed), 0n) + count - 1n) / count;
+  };
+  exact.sort(
+    (a, b) => mean(a.measurement) > mean(b.measurement) ? -1 : mean(a.measurement) < mean(b.measurement) ? 1 : a.measurement.id.localeCompare(b.measurement.id)
+  );
+  if (exact.length) {
+    const { profile, measurement } = exact[0];
     const gas = measurement.samples.map((sample) => BigInt(sample.gasUsed));
     const count = BigInt(gas.length);
     return {
@@ -1125,14 +1852,20 @@ function estimateShapeGas(request, profiles = defaultProfiles) {
   const matching = measurements.filter(
     (measurement) => measurement.shape.kind === request.shape.kind && measurement.shape.target === request.shape.target && sameCircuit(measurement.circuit, request.circuit)
   );
-  const exact = matching.find(
+  const exact = matching.filter(
     (measurement) => shapeKeys.every((key) => measurement.shape[key] === request.shape[key])
   );
-  if (exact) {
-    const gas = exact.samples.map((sample) => BigInt(sample.gasUsed));
-    const count = BigInt(gas.length);
-    return { gasUnits: (gas.reduce((sum, value) => sum + value, 0n) + count - 1n) / count };
+  if (exact.length) {
+    const means = exact.map((m) => {
+      const count = BigInt(m.samples.length);
+      return (m.samples.reduce((sum, s) => sum + BigInt(s.gasUsed), 0n) + count - 1n) / count;
+    });
+    return { gasUnits: means.reduce((max, v) => v > max ? v : max) };
   }
+  if (["create-credit", "draw-credit", "top-up-credit", "cancel-credit"].includes(
+    request.shape.kind
+  ) && !matching.length)
+    throw new Error("No current Credit gas reference for this artifact and verification key");
   const candidates = matching.length ? matching : measurements.filter(
     (measurement) => measurement.shape.kind === request.shape.kind && measurement.shape.target === request.shape.target
   );
@@ -1147,7 +1880,22 @@ function estimateShapeGas(request, profiles = defaultProfiles) {
     "deliveryBytes",
     ...!matching.length ? ["capacity"] : []
   ];
-  const estimates = candidates.map((measurement) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = JSON.stringify([
+      shapeKeys.map((k) => candidate.shape[k]),
+      candidate.circuit?.circuitName,
+      candidate.circuit?.target,
+      candidate.circuit?.artifactSha256.toLowerCase(),
+      candidate.circuit?.vkSha256.toLowerCase()
+    ]);
+    const previous = groups.get(key);
+    groups.set(
+      key,
+      previous ? { ...candidate, samples: [...previous.samples, ...candidate.samples] } : candidate
+    );
+  }
+  const estimates = [...groups.values()].map((measurement) => {
     let numerator = 1n;
     let denominator = 1n;
     for (const key of dimensions) {
@@ -1181,7 +1929,8 @@ var import_ethers6 = require("ethers");
 
 // src/session/operation-execution.ts
 var import_ethers2 = require("ethers");
-var import_core = require("@invisi-labs/core");
+var import_core3 = require("@invisi-labs/core");
+var import_protocol2 = require("@invisi-labs/protocol");
 
 // src/session/proof-integrity.ts
 var import_ethers = require("ethers");
@@ -1210,23 +1959,41 @@ async function authorizeOperation(plan, provider) {
   if (provider.walletIdentity !== plan.scope.walletIdentity)
     throw new Error("wallet authorization capability mismatch");
   const request = authorizationRequest(plan);
-  const digest = (0, import_core.computeWalletAuthorizationDigest)(request);
+  const digest = (0, import_core3.computeWalletAuthorizationDigest)(request);
   const signed = await provider.authorize(structuredClone(request));
   if (signed.walletIdentity !== plan.scope.walletIdentity || signed.digest !== digest)
     throw new Error("wallet authorization statement mismatch");
   return signed;
 }
 async function proveOperation(protocol, plan, authorization, prover, options) {
+  if (Object.hasOwn(options, "target")) {
+    throw new Error("prove accepts execution, not a backend target");
+  }
+  const { execution = "single", ...proverOptions } = options;
+  if (execution !== "single" && execution !== "aggregate") {
+    throw new Error("execution must be single or aggregate");
+  }
+  const frozen = statement(plan);
+  if (execution === "aggregate" && (plan.kind !== "transfer" || plan.capacity !== 14)) {
+    throw new Error("aggregate execution requires a 14-slot transfer");
+  }
+  if (plan.kind === "transfer") {
+    plan.statement = import_protocol2.WitnessBuilder.statement(
+      frozen.circuitName,
+      frozen.expectedPublicInputs,
+      execution === "aggregate" ? "noir-recursive" : "evm"
+    );
+  }
   const request = await witnessFor(protocol, plan, authorization);
   if (JSON.stringify({ ...request, witness: void 0 }) !== JSON.stringify(plan.statement))
     throw new Error("prepared proof statement changed");
   try {
-    const proof = publicProof(await prover.prove(request, options));
+    const proof = publicProof(await prover.prove(request, proverOptions));
     sameStatement(proof, plan.statement);
     if (await prover.verify(
       structuredClone(proof),
       structuredClone(plan.statement),
-      options
+      proverOptions
     ) !== true)
       throw new Error("proof verification failed");
     return proof;
@@ -1241,25 +2008,94 @@ async function signOperationFunding(saved, signer, verifier) {
     throw new Error("funding signer is not the payer");
   const typed = await fundingTypedData(saved);
   const signature = await signer.signTypedData(structuredClone(typed));
+  return verifyFundingSignature(typed, payer, signature, verifier);
+}
+function walletSigningRequest(plan) {
+  return (0, import_core3.createSigningRequest)((0, import_core3.walletAuthorizationTypedData)(authorizationRequest(plan)));
+}
+async function acceptWalletSignature(plan, signature) {
+  const request = authorizationRequest(plan);
+  const digest = (0, import_core3.computeWalletAuthorizationDigest)(request);
+  try {
+    const signed = import_ethers2.Signature.from(signature);
+    const publicKey = (0, import_ethers2.getBytes)(import_ethers2.SigningKey.recoverPublicKey(digest, signed));
+    const owner = await (0, import_core3.computeWalletIdentity)(publicKey);
+    if (owner.toLowerCase() !== plan.scope.walletIdentity.toLowerCase()) {
+      throw new Error("wallet signature identity mismatch");
+    }
+    return new import_core3.AuthorizedStatement(plan.scope.walletIdentity, digest, {
+      public_key_x: Array.from(publicKey.slice(1, 33)),
+      public_key_y: Array.from(publicKey.slice(33)),
+      signature: Array.from((0, import_ethers2.getBytes)((0, import_ethers2.concat)([signed.r, signed.s])))
+    });
+  } catch {
+    throw new Error("invalid wallet authorization signature");
+  }
+}
+async function fundingSigningRequest(saved, runtime) {
+  const plan = saved.plan;
+  if (plan.fundingMode !== "signature") {
+    throw new Error("operation does not require a funding signature");
+  }
+  if (plan.kind !== "shield" && !saved.proof) {
+    throw new Error("proof must precede funding authorization");
+  }
+  await runtime.options.protocol.validateDeployment(runtime.reader);
+  const block = await runtime.reader.getBlock(await runtime.reader.getLatestBlockNumber());
+  if (block.timestamp > plan.deadline || block.timestamp > (plan.funding.deadline ?? 0n)) {
+    throw new Error("funding authorization expired");
+  }
+  if (await runtime.reader.getFundingNonce(plan.context, plan.funding.payer, block) !== plan.funding.sigNonce) {
+    throw new Error("funding nonce changed; prepare again");
+  }
+  const request = (0, import_core3.createSigningRequest)(await fundingTypedData(saved));
+  if ((await runtime.reader.getBlock(block.number)).hash !== block.hash) {
+    throw new Error("canonical funding block changed");
+  }
+  return request;
+}
+async function acceptFundingSignature(saved, signature, runtime) {
+  if (!/^0x(?:[a-fA-F0-9]{2})+$/.test(signature)) {
+    throw new Error("invalid EVM funding signature");
+  }
+  const request = await fundingSigningRequest(saved, runtime);
+  return verifyFundingSignature(
+    request,
+    saved.plan.funding.payer,
+    signature,
+    runtime.options.fundingVerifier
+  );
+}
+async function verifyFundingSignature(request, payer, signature, verifier) {
+  if (!/^0x(?:[a-fA-F0-9]{2})+$/.test(signature)) {
+    throw new Error("invalid EVM funding signature");
+  }
+  const types = Object.fromEntries(
+    Object.entries(request.types).map(([name, fields]) => [name, [...fields]])
+  );
+  let validEOA = false;
+  try {
+    validEOA = (0, import_ethers2.verifyTypedData)(request.domain, types, request.message, signature).toLowerCase() === payer.toLowerCase();
+    if (validEOA) {
+      signature = import_ethers2.Signature.from(signature).serialized;
+    }
+  } catch {
+    validEOA = false;
+  }
   const valid = verifier ? await verifier.verifyTypedData({
-    ...structuredClone(typed),
+    ...structuredClone(request),
     address: payer,
     signature
-  }) : (0, import_ethers2.verifyTypedData)(
-    typed.domain,
-    Object.fromEntries(
-      Object.entries(typed.types).map(([name, fields]) => [name, [...fields]])
-    ),
-    typed.message,
-    signature
-  ).toLowerCase() === payer.toLowerCase();
-  if (valid !== true) throw new Error("invalid EVM funding signature");
+  }) : validEOA;
+  if (valid !== true) {
+    throw new Error("invalid EVM funding signature");
+  }
   return signature;
 }
 
 // src/PreparedTransaction.ts
-var import_core2 = require("@invisi-labs/core");
-var import_protocol2 = require("@invisi-labs/protocol");
+var import_core4 = require("@invisi-labs/core");
+var import_protocol3 = require("@invisi-labs/protocol");
 
 // src/session/operation-preview.ts
 function operationPreview(plan, status) {
@@ -1367,30 +2203,77 @@ var PreparedTransaction = class _PreparedTransaction {
       this.#lifecycle.busy = false;
     }
   }
-  async authorize(providerOrOptions = {}, suppliedOptions = {}) {
-    const options = "authorize" in providerOrOptions ? suppliedOptions : providerOrOptions;
-    const provider = "authorize" in providerOrOptions ? providerOrOptions : this.#runtime.authorization();
+  /** Public EIP-712 request; signing transport and key custody belong to the caller. */
+  async exportWalletAuthorization(options = {}) {
+    options.signal?.throwIfAborted();
+    this.current();
     check2(
       requiresAuthorization(this.#saved.plan),
       "operation does not require wallet authorization"
     );
-    const selectedProvider = provider;
     check2(
-      provider.walletIdentity === this.#runtime.scope.walletIdentity,
-      "wallet authorization capability mismatch"
+      ["prepared", "authorized"].includes(this.status),
+      "operation is not awaiting wallet authorization"
+    );
+    return walletSigningRequest(this.#saved.plan);
+  }
+  /** Attach an external EOA signature, retaining its witness only at the private proving boundary. */
+  async withWalletSignature(signature, options = {}) {
+    options.signal?.throwIfAborted();
+    this.current();
+    check2(
+      requiresAuthorization(this.#saved.plan),
+      "operation does not require wallet authorization"
+    );
+    check2(
+      ["prepared", "authorized"].includes(this.status),
+      "operation is not awaiting wallet authorization"
     );
+    const authorization = await acceptWalletSignature(this.#saved.plan, signature);
     return this.stage(
       "wallet authorization",
       ["prepared", "authorized"],
+      async () => ({ status: "authorized", authorization }),
+      options.signal
+    );
+  }
+  /** Export only after proving when the funding authorization binds an actual proof hash. */
+  async exportFundingAuthorization(options = {}) {
+    options.signal?.throwIfAborted();
+    this.current();
+    check2(
+      this.status === (this.kind === "shield" ? "prepared" : "proved"),
+      "operation is not awaiting funding authorization or proof"
+    );
+    const request = await fundingSigningRequest(this.#saved, this.#runtime);
+    options.signal?.throwIfAborted();
+    this.current();
+    return request;
+  }
+  /** Verify an external signature against this handle's own frozen operation. */
+  async withFundingSignature(signature, options = {}) {
+    options.signal?.throwIfAborted();
+    this.current();
+    check2(
+      this.status === (this.kind === "shield" ? "prepared" : "proved"),
+      "operation is not awaiting funding authorization or proof"
+    );
+    const verified = await acceptFundingSignature(this.#saved, signature, this.#runtime);
+    return this.stage(
+      "funding authorization",
+      this.kind === "shield" ? ["prepared"] : ["proved"],
       async (saved) => {
-        const authorization = await authorizeOperation(saved.plan, selectedProvider);
-        return { status: "authorized", authorization };
+        saved.plan.funding.signature = verified;
+        if (saved.plan.statement?.target !== "noir-recursive") {
+          saved.call = await this.encode(saved);
+        }
+        return { status: "ready" };
       },
       options.signal
     );
   }
   async prove(backendOrOptions = {}, suppliedOptions = {}) {
-    const options = "prove" in backendOrOptions ? suppliedOptions : backendOrOptions;
+    const options = { ..."prove" in backendOrOptions ? suppliedOptions : backendOrOptions };
     const plan = this.#saved.plan;
     check2(plan.kind !== "shield", "shield requires no proof");
     if (requiresAuthorization(plan)) {
@@ -1401,7 +2284,7 @@ var PreparedTransaction = class _PreparedTransaction {
     }
     const prover = "prove" in backendOrOptions ? backendOrOptions : this.#runtime.options.prover;
     if (!prover) {
-      throw new import_core2.MissingCapabilityError("prover");
+      throw new import_core4.MissingCapabilityError("prover");
     }
     return this.stage(
       "proof",
@@ -1429,37 +2312,6 @@ var PreparedTransaction = class _PreparedTransaction {
   encode(saved) {
     return encodeOperation(saved);
   }
-  async authorizeFunding(signerOrOptions = {}, suppliedOptions = {}) {
-    const options = "signTypedData" in signerOrOptions ? suppliedOptions : signerOrOptions;
-    const suppliedSigner = "signTypedData" in signerOrOptions ? signerOrOptions : void 0;
-    const p = this.#saved.plan;
-    check2(p.fundingMode === "signature", "operation does not require a funding signature");
-    check2(p.kind === "shield" || this.#saved.proof, "proof must precede funding authorization");
-    const signer = suppliedSigner ?? this.#runtime.options.fundingSigner;
-    if (!signer) {
-      throw new import_core2.MissingCapabilityError("EVM funding signer");
-    }
-    check2(
-      signer.address.toLowerCase() === p.funding.payer.toLowerCase(),
-      "funding signer is not the payer"
-    );
-    return this.stage(
-      "funding authorization",
-      p.kind === "shield" ? ["prepared"] : ["proved"],
-      async (saved) => {
-        saved.plan.funding.signature = await signOperationFunding(
-          saved,
-          signer,
-          this.#runtime.options.fundingVerifier
-        );
-        if (saved.plan.statement?.target !== "noir-recursive") {
-          saved.call = await this.encode(saved);
-        }
-        return { status: "ready" };
-      },
-      options.signal
-    );
-  }
   /** Shield caller funding needs no wallet signing or proof; this step only encodes its frozen request. */
   async ready() {
     check2(
@@ -1504,7 +2356,7 @@ var PreparedTransaction = class _PreparedTransaction {
       request: {
         params: structuredClone(plan.params),
         deliveries: plan.outputs.map((output) => structuredClone(output.delivery)),
-        funding: (0, import_protocol2.normalizeFunding)(plan.funding)
+        funding: (0, import_protocol3.normalizeFunding)(plan.funding)
       }
     };
   }
@@ -1516,23 +2368,81 @@ var PreparedTransaction = class _PreparedTransaction {
   }
 };
 
+// src/resolve-recipient.ts
+var import_core5 = require("@invisi-labs/core");
+async function resolveRecipient(address2, lookup, details = {}) {
+  const context = { ...details, address: address2 };
+  let recipient;
+  try {
+    recipient = import_core5.ReceivingAddress.parse(address2);
+  } catch (cause) {
+    throw new InvisiError("INVALID_RECIPIENT", "Invalid recipient address", {
+      ...context,
+      cause
+    });
+  }
+  if (recipient.kind === "long") return recipient;
+  if (!lookup) {
+    throw new InvisiError("MISSING_CAPABILITY", "Missing registry lookup capability", {
+      ...context,
+      capability: "registry lookup"
+    });
+  }
+  let keys;
+  try {
+    keys = await lookup(recipient.walletIdentity);
+  } catch (cause) {
+    if (cause instanceof import_core5.MissingCapabilityError) {
+      throw new InvisiError("MISSING_CAPABILITY", cause.message, {
+        ...context,
+        cause,
+        capability: cause.capability
+      });
+    }
+    throw new InvisiError("RECIPIENT_LOOKUP_FAILED", "Recipient registry lookup failed", {
+      ...context,
+      cause
+    });
+  }
+  if (keys == null) {
+    throw new InvisiError(
+      "EVM_ADDRESS_NOT_REGISTERED",
+      "EVM address has no registered receiving keys",
+      context
+    );
+  }
+  try {
+    return import_core5.ReceivingAddress.from({
+      walletIdentity: recipient.walletIdentity,
+      viewingPublicKey: keys.viewingPublicKey,
+      clueKey: keys.clueKey
+    });
+  } catch (cause) {
+    throw new InvisiError(
+      "RECIPIENT_LOOKUP_FAILED",
+      "Registry returned invalid receiving keys",
+      { ...context, cause }
+    );
+  }
+}
+
 // src/session/prepare-common.ts
 var import_ethers3 = require("ethers");
-var import_core4 = require("@invisi-labs/core");
-var import_protocol3 = require("@invisi-labs/protocol");
+var import_core7 = require("@invisi-labs/core");
+var import_protocol4 = require("@invisi-labs/protocol");
 
 // src/session/membership.ts
-var import_core3 = require("@invisi-labs/core");
+var import_core6 = require("@invisi-labs/core");
 async function verifyMembership(reader, context, block, input, proof) {
   if (proof.block.hash !== block.hash || proof.block.number !== block.number || proof.leaf !== input.commitment || proof.treeId !== input.treeId || proof.leafIndex !== input.leafIndex || proof.path.length !== 16 || !Number.isInteger(input.leafIndex) || input.leafIndex < 0 || input.leafIndex >= 65536 || !await reader.isKnownRoot(context, input.treeId, proof.root, block))
     throw new Error("membership context/root mismatch");
   let root = BigInt(input.commitment);
   for (let i = 0; i < 16; i++) {
     const sibling = proof.path[i];
-    if (typeof sibling !== "bigint" || sibling < 0n || sibling >= import_core3.FIELD_MODULUS)
+    if (typeof sibling !== "bigint" || sibling < 0n || sibling >= import_core6.FIELD_MODULUS)
       throw new Error("noncanonical membership path");
     root = BigInt(
-      await (0, import_core3.poseidonHash)(input.leafIndex >> i & 1 ? [sibling, root] : [root, sibling])
+      await (0, import_core6.poseidonHash)(input.leafIndex >> i & 1 ? [sibling, root] : [root, sibling])
     );
   }
   if (root !== BigInt(proof.root))
@@ -1568,7 +2478,28 @@ function positiveAmount(value, bits = 128) {
   if (typeof value !== "bigint" || value <= 0n || value >= 1n << BigInt(bits)) {
     throw new Error(`amount must be a positive uint${bits}`);
   }
-  return value;
+  return value;
+}
+function copyApplicationPayload(value) {
+  if (value === void 0) return new Uint8Array();
+  if (!(value instanceof Uint8Array)) throw new TypeError("payload must be Uint8Array");
+  return Uint8Array.from(value);
+}
+function positiveOutputAmount(payment, outputIndex) {
+  try {
+    return positiveAmount(payment.amount);
+  } catch (cause) {
+    throw new InvisiError(
+      "PREPARATION_FAILED",
+      cause instanceof Error ? cause.message : "Invalid output amount",
+      {
+        address: payment.to,
+        field: "amount",
+        ...outputIndex === void 0 ? {} : { outputIndex },
+        cause
+      }
+    );
+  }
 }
 var Preparation = class {
   constructor(runtime) {
@@ -1592,7 +2523,15 @@ var Preparation = class {
         throw new Error("canonical wallet checkpoint changed; resync required");
       }
     }
-    return { context: { ...options.protocol.context, now: block.timestamp }, block, deadline };
+    return {
+      context: {
+        ...options.protocol.context,
+        now: block.timestamp,
+        timestamp: block.timestamp
+      },
+      block,
+      deadline
+    };
   }
   async assertBlock(frame) {
     if ((await this.runtime.reader.getBlock(frame.block.number)).hash !== frame.block.hash) {
@@ -1615,7 +2554,7 @@ var Preparation = class {
     if (mode === "caller" && (source.sigNonce || source.deadline)) {
       throw new Error("caller funding uses zero nonce/deadline");
     }
-    const funding = (0, import_protocol3.normalizeFunding)({
+    const funding = (0, import_protocol4.normalizeFunding)({
       payer,
       amount: source.amount,
       sigNonce: mode === "caller" ? 0n : source.sigNonce ?? await this.runtime.reader.getFundingNonce(
@@ -1631,52 +2570,70 @@ var Preparation = class {
     }
     return { funding, fundingMode: mode };
   }
-  async output(payment, context, change = false) {
-    positiveAmount(payment.amount);
-    const recipient = await import_core4.ReceivingAddress.parse(payment.to).resolve(
-      this.runtime.options.addressResolver
-    );
-    const memo = (0, import_core4.encodeMemo)(payment.memo);
-    const nonce = (0, import_core4.generateNonce)();
-    const identity = await (0, import_core4.computeNoteIdentity)(BigInt(recipient.walletIdentity), nonce);
-    const keys = recipient.getReceivingKeys();
-    const note = {
-      chainId: context.chainId,
-      protocolAddress: BigInt(context.protocolAddress),
-      tokenAddress: BigInt(context.tokenAddress),
-      walletIdentity: recipient.walletIdentity,
-      amount: payment.amount,
-      ...memo.length === 0 ? {} : { memo },
-      nonce
-    };
-    const commitment = await (0, import_core4.computeNoteCommitment)(
-      context.chainId,
-      identity,
-      note.tokenAddress,
-      note.amount
-    );
-    return {
-      note,
-      commitment,
-      identity,
-      address: payment.to,
-      change,
-      delivery: {
-        ciphertext: (0, import_ethers3.hexlify)(
-          await (0, import_core4.encryptPrivateTransferNote)(keys.viewingPublicKey, note, {
-            chainId: context.chainId,
-            protocolAddress: note.protocolAddress,
-            outputCommitment: commitment
-          })
-        ),
-        clue: (0, import_ethers3.hexlify)((0, import_core4.createClue)(keys.clueKey))
-      }
-    };
+  async output(payment, context, change = false, outputIndex) {
+    try {
+      positiveOutputAmount(payment, outputIndex);
+      const recipient = await resolveRecipient(
+        payment.to,
+        this.runtime.options.addressResolver,
+        {
+          field: change ? "changeAddress" : "to",
+          ...outputIndex === void 0 ? {} : { outputIndex }
+        }
+      );
+      const nonce = (0, import_core7.generateNonce)();
+      const identity = await (0, import_core7.computeNoteIdentity)(BigInt(recipient.walletIdentity), nonce);
+      const keys = recipient.getReceivingKeys();
+      const note = {
+        chainId: context.chainId,
+        protocolAddress: BigInt(context.protocolAddress),
+        tokenAddress: BigInt(context.tokenAddress),
+        walletIdentity: recipient.walletIdentity,
+        amount: payment.amount,
+        payload: copyApplicationPayload(payment.payload),
+        nonce
+      };
+      const commitment = await (0, import_core7.computeNoteCommitment)(
+        context.chainId,
+        identity,
+        note.tokenAddress,
+        note.amount
+      );
+      return {
+        note,
+        commitment,
+        identity,
+        address: payment.to,
+        change,
+        delivery: {
+          ciphertext: (0, import_ethers3.hexlify)(
+            await (0, import_core7.encryptPrivateTransferNote)(keys.viewingPublicKey, note, {
+              chainId: context.chainId,
+              protocolAddress: note.protocolAddress,
+              outputCommitment: commitment
+            })
+          ),
+          clue: (0, import_ethers3.hexlify)((0, import_core7.createClue)(keys.clueKey))
+        }
+      };
+    } catch (cause) {
+      if (cause instanceof InvisiError) throw cause;
+      throw new InvisiError(
+        "PREPARATION_FAILED",
+        cause instanceof Error ? cause.message : "Output preparation failed",
+        {
+          address: payment.to,
+          field: change ? "changeAddress" : "to",
+          ...outputIndex === void 0 ? {} : { outputIndex },
+          cause
+        }
+      );
+    }
   }
   async membership(input, frame) {
     const { options, reader } = this.runtime;
     if (!options.protocolRpc)
-      throw new import_core4.MissingCapabilityError("Protocol RPC membership provider");
+      throw new import_core7.MissingCapabilityError("Protocol RPC membership provider");
     const root = this.#roots.get(input.treeId);
     const proof = await options.protocolRpc.getMembership(
       frame.context,
@@ -1723,9 +2680,9 @@ var Preparation = class {
     for (const input of selected) {
       const note = input.note;
       const c = frame.context;
-      if (note.walletIdentity !== scope.walletIdentity || note.chainId !== c.chainId || note.protocolAddress !== BigInt(c.protocolAddress) || note.tokenAddress !== BigInt(c.tokenAddress) || await (0, import_core4.computeNoteCommitment)(
+      if (note.walletIdentity !== scope.walletIdentity || note.chainId !== c.chainId || note.protocolAddress !== BigInt(c.protocolAddress) || note.tokenAddress !== BigInt(c.tokenAddress) || await (0, import_core7.computeNoteCommitment)(
         c.chainId,
-        await (0, import_core4.computeNoteIdentity)(BigInt(note.walletIdentity), note.nonce),
+        await (0, import_core7.computeNoteIdentity)(BigInt(note.walletIdentity), note.nonce),
         note.tokenAddress,
         note.amount
       ) !== input.commitment) {
@@ -1777,18 +2734,18 @@ function storedCandidates(inputs) {
 
 // src/session/transaction-preparation.ts
 var import_ethers5 = require("ethers");
-var import_protocol5 = require("@invisi-labs/protocol");
+var import_protocol6 = require("@invisi-labs/protocol");
 
 // src/session/prepare-credit.ts
 var import_ethers4 = require("ethers");
-var import_core6 = require("@invisi-labs/core");
-var import_protocol4 = require("@invisi-labs/protocol");
+var import_core9 = require("@invisi-labs/core");
+var import_protocol5 = require("@invisi-labs/protocol");
 
 // src/session/credit-values.ts
-var import_core5 = require("@invisi-labs/core");
+var import_core8 = require("@invisi-labs/core");
 async function creditLeaf(state) {
   const n = state.note;
-  return (0, import_core5.computeCreditCommitment)(
+  return (0, import_core8.computeCreditCommitment)(
     n.chainId,
     n.spenderWalletIdentity,
     n.ownerWalletIdentity,
@@ -1798,7 +2755,8 @@ async function creditLeaf(state) {
     n.amount,
     n.nonce,
     n.expiry,
-    await (0, import_core5.computeCreditSharedKeyHash)(n.creditSharedKey)
+    await (0, import_core8.computeCreditSharedKeyHash)(n.creditSharedKey),
+    n
   );
 }
 
@@ -1817,7 +2775,7 @@ var CreditPreparation = class {
     return value;
   }
   async seal(input, frame) {
-    const state = (0, import_core6.normalizeCreditDeliveryState)(input);
+    const state = (0, import_core9.normalizeCreditDeliveryState)(input);
     const commitment = await creditLeaf(state);
     const context = {
       chainId: frame.context.chainId,
@@ -1829,9 +2787,9 @@ var CreditPreparation = class {
         const keys = role === "owner" ? state.ownerReceivingKeys : state.spenderReceivingKeys;
         return {
           ciphertext: (0, import_ethers4.hexlify)(
-            await (0, import_core6.encryptCreditNote)(keys.viewingPublicKey, state, { ...context, role })
+            await (0, import_core9.encryptCreditNote)(keys.viewingPublicKey, state, { ...context, role })
           ),
-          clue: (0, import_ethers4.hexlify)((0, import_core6.createClue)(keys.clueKey))
+          clue: (0, import_ethers4.hexlify)((0, import_core9.createClue)(keys.clueKey))
         };
       })
     );
@@ -1842,14 +2800,14 @@ var CreditPreparation = class {
     if (!stored || stored.spent !== "unspent" || stored.role !== role) {
       throw new Error(`confirmed unspent ${role} Credit is unavailable`);
     }
-    const state = (0, import_core6.normalizeCreditDeliveryState)(stored.state);
+    const state = (0, import_core9.normalizeCreditDeliveryState)(stored.state);
     const n = state.note;
     if ((role === "owner" ? n.ownerWalletIdentity : n.spenderWalletIdentity) !== this.runtime.scope.walletIdentity || n.chainId !== frame.context.chainId || n.protocolAddress !== BigInt(frame.context.protocolAddress) || n.tokenAddress !== BigInt(frame.context.tokenAddress) || await creditLeaf(state) !== commitment) {
       throw new Error("Credit role, commitment or deployment mismatch");
     }
     const proof = await this.#prepare.membership(stored, frame);
     const path = [...proof.path];
-    const nullifier = await (0, import_core6.computeCreditNullifier)(n.chainId, n.creditSharedKey, commitment);
+    const nullifier = await (0, import_core9.computeCreditNullifier)(n.chainId, n.creditSharedKey, commitment);
     await this.#prepare.assertUnspent([nullifier], frame);
     return {
       input: {
@@ -1886,10 +2844,16 @@ var CreditPreparation = class {
     positiveAmount(options.amount, 126);
     const frame = await this.#prepare.frame(options.deadline);
     const expiry = this.expiry(options.expiry, frame);
-    const spender = await import_core6.ReceivingAddress.parse(options.spender).resolve(
-      this.runtime.options.addressResolver
+    const spender = await resolveRecipient(
+      options.spender,
+      this.runtime.options.addressResolver,
+      { field: "spender" }
+    );
+    const owner = await resolveRecipient(
+      this.runtime.options.wallet.getReceivingAddress().toString(),
+      this.runtime.options.addressResolver,
+      { field: "wallet" }
     );
-    const owner = await this.runtime.options.wallet.getReceivingAddress().resolve(this.runtime.options.addressResolver);
     const ownerPayout = (0, import_ethers4.getAddress)(owner.walletIdentity);
     const spenderPayout = (0, import_ethers4.getAddress)(spender.walletIdentity);
     if (BigInt(ownerPayout) === 0n || BigInt(spenderPayout) === 0n) {
@@ -1905,11 +2869,16 @@ var CreditPreparation = class {
           spenderWalletIdentity: spender.walletIdentity,
           ownerPayout: BigInt(ownerPayout),
           spenderPayout: BigInt(spenderPayout),
+          ...(0, import_core9.normalizeCreditPolicy)({
+            singleLimit: options.singleLimit ?? 0n,
+            dailyLimit: options.dailyLimit ?? 0n,
+            monthlyLimit: options.monthlyLimit ?? 0n
+          }),
           amount: options.amount,
-          ...options.memo === void 0 ? {} : { memo: options.memo },
+          payload: copyApplicationPayload(options.payload),
           expiry,
-          nonce: (0, import_core6.generateNonce)(),
-          creditSharedKey: (0, import_core6.generateCreditSharedKey)()
+          nonce: (0, import_core9.generateNonce)(),
+          creditSharedKey: (0, import_core9.generateCreditSharedKey)()
         },
         ownerReceivingKeys: owner.getReceivingKeys(),
         spenderReceivingKeys: spender.getReceivingKeys()
@@ -1951,7 +2920,7 @@ var CreditPreparation = class {
       sources: selected.sources,
       nullifiers: selected.nullifiers,
       creditCommitment: output.commitment,
-      changeCommitment: plan.outputs[0]?.commitment ?? (0, import_protocol4.word)(0n),
+      changeCommitment: plan.outputs[0]?.commitment ?? (0, import_protocol5.word)(0n),
       owner: (0, import_ethers4.getAddress)((0, import_ethers4.toBeHex)(output.state.note.ownerPayout, 20)),
       expiry: output.state.note.expiry,
       deadline: frame.deadline
@@ -1971,14 +2940,14 @@ var CreditPreparation = class {
         creditNullifier: previous.nullifier,
         previousExpiry: previous.input.state.note.expiry
       };
-      plan.statement = import_protocol4.WitnessBuilder.statement(
+      plan.statement = import_protocol5.WitnessBuilder.statement(
         "credit_top_up",
-        (0, import_protocol4.topUpCreditPublicInputs)(frame.context, plan.credit.topUp, deliveries, plan.funding)
+        (0, import_protocol5.topUpCreditPublicInputs)(frame.context, plan.credit.topUp, deliveries, plan.funding)
       );
     } else {
-      plan.statement = import_protocol4.WitnessBuilder.statement(
+      plan.statement = import_protocol5.WitnessBuilder.statement(
         "create_credit",
-        (0, import_protocol4.createCreditPublicInputs)(frame.context, creation, deliveries, plan.funding)
+        (0, import_protocol5.createCreditPublicInputs)(frame.context, creation, deliveries, plan.funding)
       );
     }
     await this.#prepare.assertBlock(frame);
@@ -2002,10 +2971,15 @@ var CreditPreparation = class {
         ...old,
         note: {
           ...old.note,
+          singleLimit: options.singleLimit ?? old.note.singleLimit ?? 0n,
+          dailyLimit: options.dailyLimit ?? old.note.dailyLimit ?? 0n,
+          monthlyLimit: options.monthlyLimit ?? old.note.monthlyLimit ?? 0n,
           amount,
           expiry,
-          nonce: (0, import_core6.generateNonce)(),
-          ...options.memo === void 0 ? {} : { memo: options.memo }
+          nonce: (0, import_core9.generateNonce)(),
+          payload: copyApplicationPayload(
+            options.payload === void 0 ? old.note.payload : options.payload
+          )
         }
       },
       frame
@@ -2021,7 +2995,7 @@ var CreditPreparation = class {
   }
   async draw(options) {
     const frame = await this.#prepare.frame(options.deadline);
-    const profile = (0, import_protocol4.selectCreditDrawCircuit)(options.credits.length);
+    const profile = (0, import_protocol5.selectCreditDrawCircuit)(options.credits.length);
     if (new Set(options.credits.map((value) => value.credit)).size !== options.credits.length) {
       throw new Error("duplicate Credit input");
     }
@@ -2053,10 +3027,11 @@ var CreditPreparation = class {
       }
       sources.set(member.source.treeId, member.source.merkleRoot);
       amounts.push(amount);
+      const usage = (0, import_core9.applyCreditDrawUsage)(n, amount, frame.block.timestamp);
       const remaining = n.amount - amount;
       if (remaining === 0n) {
-        remainders.push((0, import_protocol4.word)(0n));
-        recoveryAmounts.push((0, import_protocol4.word)(0n));
+        remainders.push((0, import_protocol5.word)(0n));
+        recoveryAmounts.push((0, import_protocol5.word)(0n));
         deliveries.push({ ...EMPTY }, { ...EMPTY });
         continue;
       }
@@ -2072,9 +3047,12 @@ var CreditPreparation = class {
           ...state,
           note: {
             ...n,
+            ...usage,
             amount: remaining,
-            ...options.credits[i].memo === void 0 ? {} : { memo: options.credits[i].memo },
-            nonce: await (0, import_core6.deriveRemainderNonce)(...args)
+            payload: copyApplicationPayload(
+              options.credits[i].payload === void 0 ? n.payload : options.credits[i].payload
+            ),
+            nonce: await (0, import_core9.deriveRemainderNonce)(...args)
           }
         },
         frame
@@ -2082,7 +3060,7 @@ var CreditPreparation = class {
       outputs.push(output);
       remainders.push(output.commitment);
       recoveryAmounts.push(
-        (0, import_protocol4.word)((remaining + await (0, import_core6.computeCreditRecoveryPad)(...args)) % import_core6.FIELD_MODULUS)
+        (0, import_protocol5.word)((remaining + await (0, import_core9.computeCreditRecoveryPad)(...args)) % import_core9.FIELD_MODULUS)
       );
       deliveries.push(...output.deliveries);
     }
@@ -2106,9 +3084,9 @@ var CreditPreparation = class {
       draw: params,
       amounts
     };
-    plan.statement = import_protocol4.WitnessBuilder.statement(
+    plan.statement = import_protocol5.WitnessBuilder.statement(
       profile.name,
-      (0, import_protocol4.creditDrawPublicInputs)(frame.context, params, deliveries)
+      (0, import_protocol5.creditDrawPublicInputs)(frame.context, params, deliveries)
     );
     await this.#prepare.assertBlock(frame);
     return this.runtime.complete(plan);
@@ -2128,9 +3106,9 @@ var CreditPreparation = class {
     };
     plan.capacity = 1;
     plan.credit = { inputs: [previous.input], outputs: [], deliveries: [], cancel: params };
-    plan.statement = import_protocol4.WitnessBuilder.statement(
+    plan.statement = import_protocol5.WitnessBuilder.statement(
       "credit_cancel",
-      (0, import_protocol4.cancelCreditPublicInputs)(frame.context, params)
+      (0, import_protocol5.cancelCreditPublicInputs)(frame.context, params)
     );
     await this.#prepare.assertBlock(frame);
     return this.runtime.complete(plan);
@@ -2151,87 +3129,48 @@ var TransactionPreparation = class {
     return this.context.scope;
   }
   async prepareTransfer(options) {
+    if (Object.hasOwn(options, "target") || Object.hasOwn(options, "execution")) {
+      throw new Error(
+        "prepareTransfer accepts no target or execution; choose execution in prove()"
+      );
+    }
     const copied = structuredClone(options);
-    const preparation = new Preparation(this.runtime(copied.tokenAddress));
+    const runtime = this.runtime(copied.tokenAddress);
+    if (copied.commitments !== void 0 && copied.commitments.length === 0)
+      throw new Error("empty explicit input selection");
+    const preparation = new Preparation({
+      ...runtime,
+      ...copied.commitments !== void 0 ? { inputSelection: copied.commitments } : {}
+    });
     const frame = await preparation.frame(copied.deadline);
-    if (copied.outputs.length < 1 || copied.outputs.length > 168) {
-      throw new Error("transfer requires 1..168 outputs");
+    if (copied.outputs.length > 168) throw new Error("transfer supports at most 168 outputs");
+    let withdrawalAddress = import_protocol6.ZERO_ADDRESS;
+    let withdrawalAmount = 0n;
+    if (copied.withdrawal !== void 0) {
+      withdrawalAddress = (0, import_ethers5.getAddress)(copied.withdrawal.to);
+      positiveAmount(copied.withdrawal.amount);
+      if (BigInt(withdrawalAddress) === 0n)
+        throw new Error("withdrawal destination must be nonzero");
+      withdrawalAmount = copied.withdrawal.amount;
     }
+    if (copied.outputs.length === 0 && withdrawalAmount === 0n)
+      throw new Error("transfer requires a private output or public withdrawal");
     const total = copied.outputs.reduce(
-      (sum, output) => sum + positiveAmount(output.amount),
-      0n
+      (sum, output, index2) => sum + positiveOutputAmount(output, index2),
+      withdrawalAmount
     );
     const funding = await preparation.funding(copied.funding, frame);
     return this.funds(
-      "transfer",
       copied.outputs,
       total,
-      import_protocol5.ZERO_ADDRESS,
-      0n,
+      withdrawalAddress,
+      withdrawalAmount,
       frame,
       funding,
-      copied.target,
-      preparation
-    );
-  }
-  async prepareWithdraw(options) {
-    const copied = structuredClone(options);
-    const preparation = new Preparation(this.runtime(copied.tokenAddress));
-    const frame = await preparation.frame(copied.deadline);
-    const to = (0, import_ethers5.getAddress)(copied.to);
-    positiveAmount(copied.amount);
-    if (BigInt(to) === 0n) {
-      throw new Error("withdrawal destination must be nonzero");
-    }
-    return this.funds(
-      "withdraw",
-      [],
-      copied.amount,
-      to,
-      copied.amount,
-      frame,
-      { funding: {}, fundingMode: "none" },
-      copied.target,
       preparation
     );
   }
-  /** Full payout to the note owner; no arbitrary destination, change or spending signature. */
-  async prepareSweep(options) {
-    const copied = structuredClone(options);
-    const runtime = this.runtime(copied.tokenAddress);
-    const state = await runtime.readInventory();
-    const available = Object.values(state.notes).filter(
-      (record) => record.note.tokenAddress === BigInt(copied.tokenAddress) && record.spent === "unspent" && !state.reservations[record.commitment]
-    );
-    const selected = copied.commitments ?? available.map((record) => record.commitment);
-    if (selected.length === 0) throw new Error("empty sweep input selection");
-    if (new Set(selected).size !== selected.length) throw new Error("duplicate sweep inputs");
-    const byId = new Map(available.map((record) => [record.commitment, record]));
-    let amount = 0n;
-    for (const id of selected) {
-      const record = byId.get(id);
-      if (!record) throw new Error("sweep input unavailable");
-      amount += record.note.amount;
-    }
-    positiveAmount(amount);
-    const preparation = new Preparation({
-      ...runtime,
-      inputSelection: selected
-    });
-    const frame = await preparation.frame(copied.deadline);
-    return this.funds(
-      "sweep",
-      [],
-      amount,
-      this.scope.walletIdentity,
-      amount,
-      frame,
-      { funding: {}, fundingMode: "none" },
-      copied.target,
-      preparation
-    );
-  }
-  async funds(kind, payments, total, withdrawalAddress, withdrawalAmount, frame, funding, target, preparation) {
+  async funds(payments, total, withdrawalAddress, withdrawalAmount, frame, funding, preparation) {
     if (total >= 1n << 135n) {
       throw new Error("transaction sum exceeds uint135");
     }
@@ -2241,7 +3180,7 @@ var TransactionPreparation = class {
       frame
     );
     const outputs = await Promise.all(
-      payments.map((payment) => preparation.output(payment, context))
+      payments.map((payment, index2) => preparation.output(payment, context, false, index2))
     );
     const change = selection.amount + (funding.funding.amount ?? 0n) - total;
     if (change > 0n) {
@@ -2266,17 +3205,17 @@ var TransactionPreparation = class {
       deadline
     };
     const deliveries = outputs.map((output) => output.delivery);
-    const normalized = (0, import_protocol5.normalizeTransactRequest)(context, params, deliveries, funding.funding);
-    const statement2 = import_protocol5.WitnessBuilder.statement(
+    const normalized = (0, import_protocol6.normalizeTransactRequest)(context, params, deliveries, funding.funding);
+    const statement2 = import_protocol6.WitnessBuilder.statement(
       `transact_user_slots${normalized.capacity}`,
-      (0, import_protocol5.transactUserPublicInputs)(context, params, deliveries, funding.funding),
-      target ?? "evm"
+      (0, import_protocol6.transactUserPublicInputs)(context, params, deliveries, funding.funding),
+      "evm"
     );
     await preparation.assertBlock(frame);
     return preparation.runtime.complete({
       version: 1,
       id: crypto.randomUUID(),
-      kind,
+      kind: "transfer",
       context,
       scope: this.scope,
       preparedAt: block,
@@ -2298,7 +3237,9 @@ var TransactionPreparation = class {
       throw new Error("shield requires 1..10 outputs");
     }
     const outputs = await Promise.all(
-      copied.outputs.map((output) => preparation.output(output, frame.context))
+      copied.outputs.map(
+        (output, index2) => preparation.output(output, frame.context, false, index2)
+      )
     );
     if (outputs.reduce((sum, output) => sum + output.note.amount, 0n) !== (funding.funding.amount ?? 0n)) {
       throw new Error("shield funding must equal output total");
@@ -2380,14 +3321,21 @@ function explicitPreparation(options, data, tokenAddress) {
     namespace: "explicit",
     walletIdentity: options.wallet.walletIdentity
   };
-  const { store: _store, coinSelector: _selector, ...capabilities } = options;
+  const {
+    store: _store,
+    coinSelector: _selector,
+    authorization: _authorization,
+    viewing: _viewing,
+    signer: _signer,
+    fundingSigner: _fundingSigner,
+    ...capabilities
+  } = options;
   if (inputs.some((input) => input.note.tokenAddress !== BigInt((0, import_ethers6.getAddress)(tokenAddress))))
     throw new Error("explicit note token mismatch");
   const runtime = {
     options: { ...capabilities, protocol: options.protocol.forToken(tokenAddress) },
     reader: options.chainReader,
-    scope,
-    authorization: () => options.authorization ?? options.wallet.exportAuthorization()
+    scope
   };
   return new TransactionPreparation({
     ...runtime,
@@ -2685,34 +3633,6 @@ var EthersAddressResolver = class {
     }).getReceivingKeys();
   };
 };
-var EthersFundingSigner = class _EthersFundingSigner {
-  constructor(signer, chainId, address2) {
-    this.signer = signer;
-    this.chainId = chainId;
-    this.address = getAddress5(address2);
-  }
-  address;
-  static async create(signer, chainId) {
-    return new _EthersFundingSigner(signer, chainId, getAddress5(await signer.getAddress()));
-  }
-  async signTypedData(data) {
-    const copied = structuredClone(data);
-    check3(
-      BigInt(copied.domain.chainId) === this.chainId,
-      "funding typed-data chain mismatch"
-    );
-    check3(
-      getAddress5(await this.signer.getAddress()) === this.address,
-      "funding signer address mismatch"
-    );
-    if (this.signer.provider) await chain(this.signer.provider, this.chainId);
-    return await this.signer.signTypedData(
-      copied.domain,
-      fundingTypes(copied),
-      copied.message
-    );
-  }
-};
 var EthersFundingVerifier = class {
   constructor(client, chainId) {
     this.client = client;
@@ -2755,7 +3675,24 @@ var EthersFundingVerifier = class {
 };
 
 // src/Invisi.ts
-var import_core14 = require("@invisi-labs/core");
+var import_core19 = require("@invisi-labs/core");
+
+// src/AddressRegistry.ts
+var import_protocol7 = require("@invisi-labs/protocol");
+var AddressRegistry = class extends import_protocol7.AddressRegistry {
+  prepareRegistration(options) {
+    return prepareWithErrors("prepareRegistration", async () => {
+      if ("provider" in options) {
+        const { provider, ...preparation } = options;
+        return super.prepareRegistration({
+          ...preparation,
+          reader: new EthersChainReader(provider)
+        });
+      }
+      return super.prepareRegistration(options);
+    });
+  }
+};
 
 // src/session/codec.ts
 function encode(value) {
@@ -2801,8 +3738,8 @@ function deserializeState(data) {
 
 // src/session/protocol-events.ts
 var import_contracts2 = require("@invisi-labs/protocol/contracts");
-var import_ethers8 = require("ethers");
-var protocolInterface = new import_ethers8.Interface(import_contracts2.invisiProtocolAbi);
+var import_ethers9 = require("ethers");
+var protocolInterface = new import_ethers9.Interface(import_contracts2.invisiProtocolAbi);
 function decodeProtocolEvent(log) {
   const decoded = protocolInterface.parseLog(log);
   if (!decoded) throw new Error("Unknown protocol receipt event");
@@ -2865,9 +3802,10 @@ function readProtocolLogs(receipt, protocolAddress) {
 }
 
 // src/session/discovery.ts
-var import_ethers9 = require("ethers");
-var import_core7 = require("@invisi-labs/core");
-var import_protocol6 = require("@invisi-labs/protocol");
+var import_core10 = require("@invisi-labs/core");
+var import_ethers10 = require("ethers");
+var import_core11 = require("@invisi-labs/core");
+var import_protocol8 = require("@invisi-labs/protocol");
 var EVENTS = /* @__PURE__ */ new Set([
   "CommitmentsInserted",
   "BatchOutputs",
@@ -2915,7 +3853,7 @@ function hash(value) {
 function contextCheck(context) {
   check4(context.chainId >= 0n && context.chainId < 1n << 64n, "invalid discovery chain");
   check4(
-    (0, import_ethers9.isAddress)(context.protocolAddress) && BigInt(context.protocolAddress) !== 0n,
+    (0, import_ethers10.isAddress)(context.protocolAddress) && BigInt(context.protocolAddress) !== 0n,
     "invalid discovery instance/token"
   );
 }
@@ -2960,9 +3898,9 @@ function extractDeliveryCandidates(logs, context, confirmedThrough) {
     check4(inserted, "delivery has no matching canonical insertion");
     if (commitment !== void 0)
       check4(hash(commitment) === inserted, "delivery commitment conflicts with insertion");
-    const delivery = (0, import_protocol6.normalizeDelivery)(wire, { credit: role !== "funds" });
+    const delivery = (0, import_protocol8.normalizeOpaqueDelivery)(wire);
     check4(
-      typeof token === "string" && (0, import_ethers9.isAddress)(token) && BigInt(token) !== 0n,
+      typeof token === "string" && (0, import_ethers10.isAddress)(token) && BigInt(token) !== 0n,
       "invalid event token"
     );
     const value = {
@@ -2991,7 +3929,7 @@ function extractDeliveryCandidates(logs, context, confirmedThrough) {
     add(log, tree, index(leaves[0]), fields.creditCommitment, "owner", ds[0]);
     add(log, tree, index(leaves[0]), fields.creditCommitment, "spender", ds[1]);
     if (hasChange) add(log, tree, index(leaves[1]), change, "funds", ds[2]);
-    else (0, import_protocol6.normalizeDelivery)(ds[2], { empty: true });
+    else (0, import_protocol8.normalizeOpaqueDelivery)(ds[2], { empty: true });
   };
   for (const log of relevant) {
     const a = object(log.args);
@@ -3021,7 +3959,7 @@ function extractDeliveryCandidates(logs, context, confirmedThrough) {
         const length = Number.parseInt(packed.slice(offset, offset + 4), 16);
         offset += 4;
         check4(
-          length >= 160 && length <= 416 && offset + length * 2 + 136 <= packed.length,
+          length >= 1 && length <= import_core10.MAX_CIPHERTEXT_BYTES && offset + length * 2 + 136 <= packed.length,
           "invalid packed delivery length"
         );
         const ciphertext = `0x${packed.slice(offset, offset + length * 2)}`;
@@ -3043,8 +3981,8 @@ function extractDeliveryCandidates(logs, context, confirmedThrough) {
       cs.forEach((c, i) => {
         if (BigInt(hash(c)) === 0n) {
           check4(integer(leaves[i]) === 0n, "absent remainder has nonzero position");
-          (0, import_protocol6.normalizeDelivery)(ds[2 * i], { empty: true });
-          (0, import_protocol6.normalizeDelivery)(ds[2 * i + 1], { empty: true });
+          (0, import_protocol8.normalizeOpaqueDelivery)(ds[2 * i], { empty: true });
+          (0, import_protocol8.normalizeOpaqueDelivery)(ds[2 * i + 1], { empty: true });
         } else {
           add(log, tree, index(leaves[i]), c, "owner", ds[2 * i]);
           add(log, tree, index(leaves[i]), c, "spender", ds[2 * i + 1]);
@@ -3056,7 +3994,7 @@ function extractDeliveryCandidates(logs, context, confirmedThrough) {
 }
 async function decryptCandidates(logs, options) {
   contextCheck(options.context);
-  (0, import_core7.decodeAddress)(import_core7.ReceivingAddress.fromIdentity(options.viewing.walletIdentity).toString());
+  (0, import_core11.decodeAddress)(import_core11.ReceivingAddress.fromIdentity(options.viewing.walletIdentity).toString());
   check4(
     !logs.some(
       (log) => log.address.toLowerCase() === options.context.protocolAddress.toLowerCase() && log.removed
@@ -3344,7 +4282,7 @@ function mergeReceiptRecords(state, batch) {
 }
 
 // src/session/store.ts
-var import_core8 = require("@invisi-labs/core");
+var import_core12 = require("@invisi-labs/core");
 var import_sha2562 = require("@noble/hashes/sha256");
 var import_utils2 = require("@noble/hashes/utils");
 function scopeKey(scope) {
@@ -3360,7 +4298,7 @@ function scopeKey(scope) {
   return (0, import_utils2.bytesToHex)(
     (0, import_sha2562.sha256)(
       (0, import_utils2.utf8ToBytes)(
-        "Invisi.WalletScope.v2:" + JSON.stringify([
+        "Invisi.WalletScope.v1:" + JSON.stringify([
           scope.namespace,
           scope.chainId.toString(),
           scope.protocolAddress.toLowerCase(),
@@ -3397,12 +4335,12 @@ function validateState(state, scope, revision) {
       throw new Error("invalid spent state");
   }
   for (const record of Object.values(state.credits)) {
-    const note = (0, import_core8.normalizeCreditDeliveryState)(record.state).note;
+    const note = (0, import_core12.normalizeCreditDeliveryState)(record.state).note;
     if (note.chainId !== scope.chainId || note.protocolAddress !== BigInt(scope.protocolAddress) || !["owner", "spender"].includes(record.role) || (record.role === "owner" ? note.ownerWalletIdentity : note.spenderWalletIdentity).toLowerCase() !== scope.walletIdentity.toLowerCase() || !["unspent", "unknown", "spent"].includes(record.spent))
       throw new Error("invalid stored Credit context or role");
   }
   for (const record of [...Object.values(state.notes), ...Object.values(state.credits)]) {
-    if (!/^0x[0-9a-fA-F]{64}$/.test(record.commitment) || BigInt(record.commitment) <= 0n || BigInt(record.commitment) >= import_core8.FIELD_MODULUS || typeof record.treeId !== "bigint" || record.treeId < 1n || record.treeId >= 1n << 64n || !Number.isInteger(record.leafIndex) || record.leafIndex < 0 || record.leafIndex >= 65536 || typeof record.blockNumber !== "bigint" || record.blockNumber < 0n || !/^0x[0-9a-fA-F]{64}$/.test(record.blockHash))
+    if (!/^0x[0-9a-fA-F]{64}$/.test(record.commitment) || BigInt(record.commitment) <= 0n || BigInt(record.commitment) >= import_core12.FIELD_MODULUS || typeof record.treeId !== "bigint" || record.treeId < 1n || record.treeId >= 1n << 64n || !Number.isInteger(record.leafIndex) || record.leafIndex < 0 || record.leafIndex >= 65536 || typeof record.blockNumber !== "bigint" || record.blockNumber < 0n || !/^0x[0-9a-fA-F]{64}$/.test(record.blockHash))
       throw new Error("invalid stored receipt position");
   }
   for (const [id, operation] of Object.entries(state.reservations))
@@ -3463,16 +4401,16 @@ var TransactionalWalletStore = class {
 };
 
 // src/session/Operation.ts
-var import_core10 = require("@invisi-labs/core");
-var import_protocol8 = require("@invisi-labs/protocol");
+var import_core14 = require("@invisi-labs/core");
+var import_protocol10 = require("@invisi-labs/protocol");
 
 // src/session/operation-confirmation.ts
-var import_core9 = require("@invisi-labs/core");
+var import_core13 = require("@invisi-labs/core");
 
 // src/session/aggregate-receipt.ts
-var import_ethers11 = require("ethers");
+var import_ethers12 = require("ethers");
 var import_contracts3 = require("@invisi-labs/protocol/contracts");
-var import_protocol7 = require("@invisi-labs/protocol");
+var import_protocol9 = require("@invisi-labs/protocol");
 var aggregateAbi = import_contracts3.invisiProtocolAbi.filter(
   (item) => item.type === "function" && item.name === "transact" && item.inputs.length === 2 && item.inputs[1]?.type === "tuple[]"
 );
@@ -3481,7 +4419,7 @@ function matchesAggregateTransaction(saved, transaction) {
   if (plan.statement?.target !== "noir-recursive" || !plan.params || !saved.externalized || transaction.to.toLowerCase() !== plan.context.protocolAddress.toLowerCase() || transaction.value !== 0n)
     return false;
   try {
-    const decoded = new import_ethers11.Interface(aggregateAbi).parseTransaction({ data: transaction.data }), requests = decoded.args[1].map((request) => {
+    const decoded = new import_ethers12.Interface(aggregateAbi).parseTransaction({ data: transaction.data }), requests = decoded.args[1].map((request) => {
       const member = request.toObject(true);
       member.params.sources = request.params.sources.map(
         (source) => source.toObject(true)
@@ -3500,7 +4438,7 @@ function matchesAggregateTransaction(saved, transaction) {
     });
     if (decoded.name !== "transact" || !Array.isArray(requests) || ![4, 8, 12].includes(requests.length))
       return false;
-    const canonical2 = (request) => (0, import_protocol7.buildTransactCalldata)({
+    const canonical2 = (request) => (0, import_protocol9.buildTransactCalldata)({
       context: { ...plan.context, tokenAddress: request.params.token },
       proof: "0x00",
       params: request.params,
@@ -3508,7 +4446,7 @@ function matchesAggregateTransaction(saved, transaction) {
       funding: request.funding,
       caller: transaction.from
     }).data.toLowerCase();
-    const expected = (0, import_protocol7.buildTransactCalldata)({
+    const expected = (0, import_protocol9.buildTransactCalldata)({
       context: plan.context,
       proof: "0x00",
       params: plan.params,
@@ -3687,7 +4625,7 @@ async function confirmOperation(runtime, id, generation, hash2, signal) {
   if (credits.length) {
     const nullifiers = await Promise.all(
       credits.map(
-        async (record) => (0, import_core9.computeCreditNullifier)(
+        async (record) => (0, import_core13.computeCreditNullifier)(
           plan.context.chainId,
           record.state.note.creditSharedKey,
           await creditLeaf(record.state)
@@ -3988,6 +4926,81 @@ var Operation = class _Operation {
       throw error;
     }
   }
+  async signingCurrent() {
+    await this.#runtime.store.transaction(this.#runtime.scope, (state) => {
+      check7(!state.invalidated, "wallet state requires canonical resync");
+      this.current(state.operations[this.id]);
+    });
+  }
+  /** Public EIP-712 request; signing transport and key custody belong to the caller. */
+  async exportWalletAuthorization(options = {}) {
+    options.signal?.throwIfAborted();
+    await this.signingCurrent();
+    check7(
+      requiresAuthorization(this.#saved.plan),
+      "operation does not require wallet authorization"
+    );
+    check7(
+      ["prepared", "authorized"].includes(this.status),
+      "operation is not awaiting wallet authorization"
+    );
+    return walletSigningRequest(this.#saved.plan);
+  }
+  /** Attach an external EOA signature, retaining its witness only at the private proving boundary. */
+  async withWalletSignature(signature, options = {}) {
+    options.signal?.throwIfAborted();
+    await this.signingCurrent();
+    check7(
+      requiresAuthorization(this.#saved.plan),
+      "operation does not require wallet authorization"
+    );
+    check7(
+      ["prepared", "authorized"].includes(this.status),
+      "operation is not awaiting wallet authorization"
+    );
+    const authorization = await acceptWalletSignature(this.#saved.plan, signature);
+    return this.stage(
+      "wallet authorization",
+      ["prepared", "authorized"],
+      async () => ({ status: "authorized", authorization }),
+      options.signal
+    );
+  }
+  /** Export only after proving when the funding authorization binds an actual proof hash. */
+  async exportFundingAuthorization(options = {}) {
+    options.signal?.throwIfAborted();
+    await this.signingCurrent();
+    check7(
+      this.status === (this.kind === "shield" ? "prepared" : "proved"),
+      "operation is not awaiting funding authorization or proof"
+    );
+    const request = await fundingSigningRequest(this.#saved, this.#runtime);
+    options.signal?.throwIfAborted();
+    await this.signingCurrent();
+    return request;
+  }
+  /** Verify an external signature against this handle's own frozen operation. */
+  async withFundingSignature(signature, options = {}) {
+    options.signal?.throwIfAborted();
+    await this.signingCurrent();
+    check7(
+      this.status === (this.kind === "shield" ? "prepared" : "proved"),
+      "operation is not awaiting funding authorization or proof"
+    );
+    const verified = await acceptFundingSignature(this.#saved, signature, this.#runtime);
+    return this.stage(
+      "funding authorization",
+      this.kind === "shield" ? ["prepared"] : ["proved"],
+      async (saved) => {
+        saved.plan.funding.signature = verified;
+        if (saved.plan.statement?.target !== "noir-recursive") {
+          saved.call = await this.encode(saved);
+        }
+        return { status: "ready" };
+      },
+      options.signal
+    );
+  }
   async authorize(options = {}) {
     check7(
       requiresAuthorization(this.#saved.plan),
@@ -4008,7 +5021,8 @@ var Operation = class _Operation {
       options.signal
     );
   }
-  async prove(options = {}) {
+  async prove(suppliedOptions = {}) {
+    const options = { ...suppliedOptions };
     const plan = this.#saved.plan;
     check7(plan.kind !== "shield", "shield requires no proof");
     if (requiresAuthorization(plan)) {
@@ -4019,7 +5033,7 @@ var Operation = class _Operation {
     }
     const prover = this.#runtime.options.prover;
     if (!prover) {
-      throw new import_core10.MissingCapabilityError("prover");
+      throw new import_core14.MissingCapabilityError("prover");
     }
     return this.stage(
       "proof",
@@ -4053,7 +5067,7 @@ var Operation = class _Operation {
     check7(p.kind === "shield" || this.#saved.proof, "proof must precede funding authorization");
     const signer = this.#runtime.options.fundingSigner;
     if (!signer) {
-      throw new import_core10.MissingCapabilityError("EVM funding signer");
+      throw new import_core14.MissingCapabilityError("EVM funding signer");
     }
     check7(
       signer.address.toLowerCase() === p.funding.payer.toLowerCase(),
@@ -4155,7 +5169,7 @@ var Operation = class _Operation {
         request: {
           params: structuredClone(plan.params),
           deliveries: plan.outputs.map((output) => structuredClone(output.delivery)),
-          funding: (0, import_protocol8.normalizeFunding)(plan.funding)
+          funding: (0, import_protocol10.normalizeFunding)(plan.funding)
         }
       };
     });
@@ -4243,8 +5257,66 @@ var Operation = class _Operation {
 };
 
 // src/session/WalletSession.ts
-var import_ethers12 = require("ethers");
-var import_core13 = require("@invisi-labs/core");
+var import_core17 = require("@invisi-labs/core");
+
+// src/session/history.ts
+function walletHistory(state, options = {}) {
+  const token = options.tokenAddress?.toLowerCase();
+  const outgoing = [];
+  for (const record of Object.values(state.operations)) {
+    const saved = record.payload;
+    if (!saved?.plan || token && saved.plan.context.tokenAddress.toLowerCase() !== token) {
+      continue;
+    }
+    const plan = saved.plan;
+    outgoing.push({
+      ...operationPreview(plan, record.status),
+      preparedAt: { ...plan.preparedAt },
+      ...record.transactionHash ? { transactionHash: record.transactionHash } : {},
+      outputs: plan.outputs.map((output) => ({
+        to: output.address,
+        amount: output.note.amount,
+        change: output.change,
+        commitment: output.commitment,
+        payload: Uint8Array.from(output.note.payload ?? [])
+      }))
+    });
+  }
+  outgoing.sort(
+    (a, b) => a.preparedAt.number === b.preparedAt.number ? a.id.localeCompare(b.id) : a.preparedAt.number > b.preparedAt.number ? -1 : 1
+  );
+  const incoming = [];
+  for (const record of Object.values(state.notes)) {
+    const tokenAddress = `0x${record.note.tokenAddress.toString(16).padStart(40, "0")}`;
+    if (token && tokenAddress !== token) continue;
+    incoming.push({
+      commitment: record.commitment,
+      treeId: record.treeId,
+      leafIndex: record.leafIndex,
+      blockNumber: record.blockNumber,
+      blockHash: record.blockHash,
+      ...record.transactionHash ? { transactionHash: record.transactionHash } : {},
+      tokenAddress,
+      amount: record.note.amount,
+      payload: Uint8Array.from(record.note.payload ?? []),
+      spent: record.spent
+    });
+  }
+  incoming.sort(
+    (a, b) => a.blockNumber === b.blockNumber ? a.commitment.localeCompare(b.commitment) : a.blockNumber > b.blockNumber ? -1 : 1
+  );
+  return structuredClone({
+    revision: state.revision,
+    checkedThrough: state.discoveryThrough ?? null,
+    invalidated: !!state.invalidated,
+    outgoing,
+    incoming
+  });
+}
+
+// src/session/WalletSession.ts
+var import_ethers13 = require("ethers");
+var import_core18 = require("@invisi-labs/core");
 
 // src/session/refresh.ts
 async function refreshWallet(runtime, options) {
@@ -4301,10 +5373,10 @@ async function refreshWallet(runtime, options) {
 }
 
 // src/session/WalletUpdater.ts
-var import_core12 = require("@invisi-labs/core");
+var import_core16 = require("@invisi-labs/core");
 
 // src/session/inventory.ts
-var import_core11 = require("@invisi-labs/core");
+var import_core15 = require("@invisi-labs/core");
 var CanonicalConflict = class extends Error {
 };
 var CreditMetadataMismatch = class extends Error {
@@ -4356,10 +5428,10 @@ var InventoryProcessor = class {
   }
   async creditNullifier(state) {
     const n = state.note;
-    return (0, import_core11.computeCreditNullifier)(
+    return (0, import_core15.computeCreditNullifier)(
       n.chainId,
       n.creditSharedKey,
-      await (0, import_core11.computeCreditCommitment)(
+      await (0, import_core15.computeCreditCommitment)(
         n.chainId,
         n.spenderWalletIdentity,
         n.ownerWalletIdentity,
@@ -4369,7 +5441,8 @@ var InventoryProcessor = class {
         n.amount,
         n.nonce,
         n.expiry,
-        await (0, import_core11.computeCreditSharedKeyHash)(n.creditSharedKey)
+        await (0, import_core15.computeCreditSharedKeyHash)(n.creditSharedKey),
+        n
       )
     );
   }
@@ -4416,6 +5489,9 @@ var InventoryProcessor = class {
     };
     for (const event of logs) {
       if (event.eventName === "CreditDraw") {
+        const block = await this.#options.reader.getBlock(event.blockNumber);
+        if (block.hash !== event.blockHash)
+          throw new CanonicalConflict("draw block changed during Credit recovery");
         const args = event.args;
         const params = args.params;
         const indices = args.remainderLeafIndices;
@@ -4429,10 +5505,11 @@ var InventoryProcessor = class {
               previous.state.note.expiry === params.expiries[index2],
               "draw recovery expiry mismatch"
             );
-            const remainder = await (0, import_core11.recoverCreditRemainder)(
+            const remainder = await (0, import_core15.recoverCreditRemainder)(
               context,
               previous.state.note,
               {
+                timestamp: block.timestamp,
                 creditNullifier: nullifier,
                 remainderCommitment: params.remainderCommitments[index2],
                 recoveryAmount: BigInt(params.recoveryAmounts[index2])
@@ -4444,7 +5521,7 @@ var InventoryProcessor = class {
             const child = foundByKey.get(
               params.remainderCommitments[index2] + ":" + previous.role
             );
-            const memo = child?.state.note.memo;
+            const payload = child?.state.note.payload;
             const record = {
               commitment: params.remainderCommitments[index2],
               treeId: BigInt(args.outputTreeId),
@@ -4457,7 +5534,7 @@ var InventoryProcessor = class {
                 ...clone(previous.state),
                 note: {
                   ...remainder,
-                  ...memo === void 0 ? {} : { memo: (0, import_core11.encodeMemo)(memo) }
+                  ...payload === void 0 ? {} : { payload: clone(payload) }
                 }
               },
               receivingKeySource: { kind: "draw", commitment: previous.commitment },
@@ -4536,7 +5613,7 @@ var WalletUpdater = class extends InventoryProcessor {
   }
   async run(batch, options) {
     const { reader, protocol, scope, store, viewing } = this.#options;
-    const nullifier = import_core12.NullifierCapability.fromIdentity(scope.walletIdentity);
+    const nullifier = import_core16.NullifierCapability.fromIdentity(scope.walletIdentity);
     const { signal, reset } = options;
     signal?.throwIfAborted();
     const context = protocol.context;
@@ -4705,6 +5782,7 @@ var WalletUpdater = class extends InventoryProcessor {
           draft.notes = {};
           draft.credits = {};
           delete draft.observedThrough;
+          delete draft.discoveryThrough;
           delete draft.invalidated;
         }
         mergeReceiptRecords(draft, { notes, credits, checkpoint: block });
@@ -4736,13 +5814,38 @@ var WalletUpdater = class extends InventoryProcessor {
 var WalletSession = class {
   #options;
   #updater;
+  #listeners = /* @__PURE__ */ new Set();
   #sending = /* @__PURE__ */ new Set();
   #refreshQueue = Promise.resolve();
   scope;
   protocol;
   constructor(options) {
+    if ("ciphertextCodecs" in options || "envelopeVersion" in options) {
+      throw new Error(
+        "SDK envelope versions are fixed; encode application payload bytes externally"
+      );
+    }
+    const store = options.store;
     this.#options = {
       ...options,
+      ...store ? {
+        store: {
+          persistent: store.persistent,
+          readSnapshot: (scope) => store.readSnapshot(scope),
+          transaction: async (scope, action) => {
+            const result = await store.transaction(scope, action);
+            if (scopeKey(scope) === scopeKey(this.scope)) {
+              for (const listener of [...this.#listeners]) {
+                try {
+                  listener();
+                } catch {
+                }
+              }
+            }
+            return result;
+          }
+        }
+      } : {},
       ...options.gasBenchmarks ? { gasBenchmarks: copyGasBenchmarks(options.gasBenchmarks) } : {}
     };
     this.protocol = options.protocol;
@@ -4757,7 +5860,7 @@ var WalletSession = class {
   /** Delegate sending to ethers; managed operations additionally retain the resulting hash. */
   async sendTransaction(input, options = {}) {
     const signer = this.#options.signer;
-    if (!signer) throw new import_core13.MissingCapabilityError("ethers signer");
+    if (!signer) throw new import_core18.MissingCapabilityError("ethers signer");
     const operation = input instanceof Operation ? input : void 0;
     if (operation && this.#sending.has(operation.id))
       throw new Error("operation is already being sent by this session");
@@ -4765,12 +5868,12 @@ var WalletSession = class {
     const overrides = { ...options };
     const plain = operation ? void 0 : { ...input };
     try {
-      if (!signer.provider) throw new import_core13.MissingCapabilityError("connected ethers signer");
+      if (!signer.provider) throw new import_core18.MissingCapabilityError("connected ethers signer");
       if ((await signer.provider.getNetwork()).chainId !== this.protocol.context.chainId) {
         throw new Error("signer-provider session chain mismatch");
       }
       if (operation) {
-        if (!this.#options.store) throw new import_core13.MissingCapabilityError("wallet store");
+        if (!this.#options.store) throw new import_core18.MissingCapabilityError("wallet store");
         const state = await this.#options.store.readSnapshot(this.scope);
         if (!state.operations[operation.id])
           throw new Error("operation does not belong to this wallet session");
@@ -4801,25 +5904,30 @@ var WalletSession = class {
   runtime(tokenAddress) {
     const options = this.#options;
     if (!options.store) {
-      throw new import_core13.MissingCapabilityError("wallet store");
+      throw new import_core18.MissingCapabilityError("wallet store");
     }
     if (!options.chainReader) {
-      throw new import_core13.MissingCapabilityError("chain reader");
+      throw new import_core18.MissingCapabilityError("chain reader");
     }
     return {
       options: { ...options, protocol: options.protocol.forToken(tokenAddress) },
       scope: this.scope,
       store: options.store,
       reader: options.chainReader,
-      authorization: () => options.authorization ?? options.wallet.exportAuthorization()
+      authorization: () => {
+        if (options.authorization) return options.authorization;
+        if (options.wallet instanceof import_core17.Wallet) return options.wallet.exportAuthorization();
+        throw new import_core18.MissingCapabilityError("wallet authorization");
+      }
     };
   }
   updater() {
     if (this.#updater) return this.#updater;
     const options = this.#options;
     if (!options.store || !options.chainReader || !options.protocolRpc)
-      throw new import_core13.MissingCapabilityError("wallet store, chain reader and Protocol RPC");
-    const viewing = options.viewing ?? options.wallet.getViewer();
+      throw new import_core18.MissingCapabilityError("wallet store, chain reader and Protocol RPC");
+    const viewing = options.viewing ?? (options.wallet instanceof import_core17.Wallet ? options.wallet.getViewer() : void 0);
+    if (!viewing) throw new import_core18.MissingCapabilityError("viewing");
     const receivingAddress = options.wallet.getReceivingAddress();
     const receivingKeys = receivingAddress.kind === "long" ? receivingAddress.getReceivingKeys() : void 0;
     this.#updater = new WalletUpdater({
@@ -4833,26 +5941,43 @@ var WalletSession = class {
     });
     return this.#updater;
   }
+  /** Local session commits only. Host applications own cross-tab/store subscriptions. */
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  /** Detached history for wallet UI; construction records do not imply chain success. */
+  async getHistory(options = {}) {
+    const tokenAddress = options.tokenAddress ? (0, import_ethers13.getAddress)(options.tokenAddress) : void 0;
+    const store = this.#options.store;
+    if (!store) throw new import_core18.MissingCapabilityError("wallet store");
+    return walletHistory(
+      await store.readSnapshot(this.scope),
+      tokenAddress ? { tokenAddress } : {}
+    );
+  }
   async balance(tokenAddress) {
     const store = this.#options.store;
     if (!store) {
-      throw new import_core13.MissingCapabilityError("wallet store");
+      throw new import_core18.MissingCapabilityError("wallet store");
     }
-    return walletBalance(await store.readSnapshot(this.scope), (0, import_ethers12.getAddress)(tokenAddress));
+    return walletBalance(await store.readSnapshot(this.scope), (0, import_ethers13.getAddress)(tokenAddress));
   }
   /** Pull explicitly selected indexed pages; no chain scanning or public tree reconstruction. */
   async refresh(options) {
     const provider = this.#options.protocolRpc;
     const reader = this.#options.chainReader;
-    if (!reader) throw new import_core13.MissingCapabilityError("chain reader");
-    if (!provider) throw new import_core13.MissingCapabilityError("Protocol RPC");
+    if (!reader) throw new import_core18.MissingCapabilityError("chain reader");
+    if (!provider) throw new import_core18.MissingCapabilityError("Protocol RPC");
     const updater = this.updater();
     const request = {
       ...options,
       ...options.detectionKey ? { detectionKey: options.detectionKey.slice() } : {}
     };
-    const task = this.#refreshQueue.then(
-      () => refreshWallet(
+    const task = this.#refreshQueue.then(async () => {
+      const result = await refreshWallet(
         {
           provider,
           reader,
@@ -4861,8 +5986,21 @@ var WalletSession = class {
           apply: (batch, settings) => updater.applyUpdates(batch, settings)
         },
         request
-      )
-    );
+      );
+      await this.#options.store.transaction(this.scope, (state) => {
+        request.signal?.throwIfAborted();
+        if (state.invalidated) throw new Error("wallet requires canonical resync");
+        const previous = state.discoveryThrough;
+        const start = previous ? previous.number + 1n : this.protocol.deployment.protocol.fromBlock;
+        if (request.fromBlock <= start && (!previous || result.block.number >= previous.number)) {
+          state.discoveryThrough = {
+            number: result.block.number,
+            hash: result.block.hash
+          };
+        }
+      });
+      return result;
+    });
     this.#refreshQueue = task.catch(() => {
     });
     return task;
@@ -4873,38 +6011,43 @@ var WalletSession = class {
       options: runtime.options,
       scope: runtime.scope,
       reader: runtime.reader,
-      authorization: runtime.authorization,
       readInventory: () => runtime.store.readSnapshot(runtime.scope),
       complete: (plan) => Operation.prepare(runtime, plan)
     });
   }
   async prepareTransfer(options) {
-    return this.preparation(options.tokenAddress).prepareTransfer(options);
-  }
-  async prepareWithdraw(options) {
-    return this.preparation(options.tokenAddress).prepareWithdraw(options);
-  }
-  async prepareSweep(options) {
-    return this.preparation(options.tokenAddress).prepareSweep(options);
+    return prepareWithErrors("prepareTransfer", async () => {
+      return this.preparation(options.tokenAddress).prepareTransfer(options);
+    });
   }
   async prepareShield(options) {
-    return this.preparation(options.tokenAddress).prepareShield(options);
+    return prepareWithErrors("prepareShield", async () => {
+      return this.preparation(options.tokenAddress).prepareShield(options);
+    });
   }
   async prepareCreateCredit(options) {
-    return this.preparation(options.tokenAddress).prepareCreateCredit(options);
+    return prepareWithErrors("prepareCreateCredit", async () => {
+      return this.preparation(options.tokenAddress).prepareCreateCredit(options);
+    });
   }
   async prepareDrawCredit(options) {
-    return this.preparation(options.tokenAddress).prepareDrawCredit(options);
+    return prepareWithErrors("prepareDrawCredit", async () => {
+      return this.preparation(options.tokenAddress).prepareDrawCredit(options);
+    });
   }
   async prepareTopUpCredit(options) {
-    return this.preparation(options.tokenAddress).prepareTopUpCredit(options);
+    return prepareWithErrors("prepareTopUpCredit", async () => {
+      return this.preparation(options.tokenAddress).prepareTopUpCredit(options);
+    });
   }
   async prepareCancelCredit(options) {
-    return this.preparation(options.tokenAddress).prepareCancelCredit(options);
+    return prepareWithErrors("prepareCancelCredit", async () => {
+      return this.preparation(options.tokenAddress).prepareCancelCredit(options);
+    });
   }
   async resume(operationId) {
     const store = this.#options.store;
-    if (!store) throw new import_core13.MissingCapabilityError("wallet store");
+    if (!store) throw new import_core18.MissingCapabilityError("wallet store");
     const state = await store.readSnapshot(this.scope);
     const saved = state.operations[operationId]?.payload;
     if (!saved?.plan) throw new Error("operation not found");
@@ -4922,6 +6065,16 @@ var WalletSession = class {
 var Invisi = class {
   #options;
   constructor(options = {}) {
+    if ("ciphertextCodecs" in options || "envelopeVersion" in options) {
+      throw new Error(
+        "SDK envelope versions are fixed; encode application payload bytes externally"
+      );
+    }
+    if ("signer" in options || "fundingSigner" in options) {
+      throw new Error(
+        "Invisi does not accept signer defaults; export a signing request and attach the external signature"
+      );
+    }
     this.#options = {
       ...options,
       ...options.gasBenchmarks ? { gasBenchmarks: copyGasBenchmarks(options.gasBenchmarks) } : {}
@@ -4932,7 +6085,15 @@ var Invisi = class {
     return new WalletSession(await this.resolve(options));
   }
   async resolve(options) {
-    const allowed = ["wallet", "protocol", "namespace", "viewing", "authorization"];
+    const allowed = [
+      "wallet",
+      "protocol",
+      "namespace",
+      "viewing",
+      "authorization",
+      "signer",
+      "fundingSigner"
+    ];
     for (const key of Object.keys(options)) {
       if (!allowed.includes(key))
         throw new Error(
@@ -4941,97 +6102,150 @@ var Invisi = class {
     }
     const selected = { ...options };
     const combined = { ...this.#options, ...selected };
-    const { provider, signer, ...runtime } = combined;
+    const { provider, addressLookup = "protocol-rpc", ...runtime } = combined;
+    if (addressLookup !== void 0 && addressLookup !== "chain" && addressLookup !== "protocol-rpc") {
+      throw new Error("Invalid recipient address lookup source");
+    }
     const reader = combined.chainReader ?? (provider ? new EthersChainReader(provider) : void 0);
-    if (!reader) throw new import_core14.MissingCapabilityError("chain reader");
+    if (!reader) throw new import_core19.MissingCapabilityError("chain reader");
     if (provider && (await provider.getNetwork()).chainId !== selected.protocol.context.chainId)
       throw new Error("provider deployment chain mismatch");
     await selected.protocol.validateDeployment(reader);
     if (runtime.protocolRpc instanceof import_rpc.ProtocolRpcClient) {
       runtime.protocolRpc = runtime.protocolRpc.withReader(reader);
     }
-    if (signer) {
-      if (!provider) throw new import_core14.MissingCapabilityError("provider for signer");
-      if (!signer.provider) throw new Error("signer must be connected to a provider");
-      if ((await signer.provider.getNetwork()).chainId !== selected.protocol.context.chainId)
-        throw new Error("signer-provider deployment chain mismatch");
-    }
     const registry = selected.protocol.deployment.registry;
-    const fundingSigner = combined.fundingSigner ?? (signer ? await EthersFundingSigner.create(signer, selected.protocol.context.chainId) : void 0);
     const fundingVerifier = combined.fundingVerifier ?? (provider ? new EthersFundingVerifier(provider, selected.protocol.context.chainId) : void 0);
-    const addressResolver = combined.addressResolver ?? (provider && registry ? new EthersAddressResolver(
-      provider,
-      {
-        chainId: selected.protocol.context.chainId,
-        registryAddress: registry.address
-      },
-      registry.runtimeCodeHash
-    ).lookup : void 0);
+    let addressResolver = combined.addressResolver;
+    if (!addressResolver && registry) {
+      if (addressLookup === "protocol-rpc") {
+        const rpc = runtime.protocolRpc;
+        addressResolver = async (identity) => {
+          if (!(rpc instanceof import_rpc.ProtocolRpcClient)) {
+            throw new import_core19.MissingCapabilityError("Protocol RPC recipient discovery");
+          }
+          const discovered = await rpc.getDeployment(selected.protocol.context.chainId);
+          const expected = selected.protocol.deployment;
+          if (discovered.protocol.address !== expected.protocol.address || discovered.protocol.runtimeCodeHash !== expected.protocol.runtimeCodeHash || discovered.protocol.fromBlock !== expected.protocol.fromBlock || discovered.registry?.address !== registry.address || discovered.registry.runtimeCodeHash !== registry.runtimeCodeHash || discovered.registry.fromBlock !== registry.fromBlock)
+            throw new Error("Recipient registry deployment pins mismatch");
+          const registration = await rpc.getReceivingAddress(identity);
+          return registration ? import_core19.ReceivingAddress.parse(registration.receivingAddress).getReceivingKeys() : null;
+        };
+      } else if (provider) {
+        addressResolver = new EthersAddressResolver(
+          provider,
+          {
+            chainId: selected.protocol.context.chainId,
+            registryAddress: registry.address
+          },
+          registry.runtimeCodeHash
+        ).lookup;
+      }
+    }
     return {
       ...runtime,
       chainReader: reader,
-      ...signer ? { signer } : {},
-      ...fundingSigner ? { fundingSigner } : {},
       ...fundingVerifier ? { fundingVerifier } : {},
       ...addressResolver ? { addressResolver } : {},
       protocol: selected.protocol
     };
   }
+  /** Discover the selected chain's registry and prepare an independent signing request. */
+  async prepareRegistration(options) {
+    return prepareWithErrors("prepareRegistration", async () => {
+      for (const key of Object.keys(options)) {
+        if (!["wallet", "update", "deadline"].includes(key)) {
+          throw new Error(`Unknown registration option: ${key}`);
+        }
+      }
+      this.assertPublicIdentity(options);
+      const selected = { ...options };
+      const { provider, protocolRpc } = this.#options;
+      if (!provider) throw new import_core19.MissingCapabilityError("ethers provider");
+      if (!(protocolRpc instanceof import_rpc.ProtocolRpcClient)) {
+        throw new import_core19.MissingCapabilityError("Protocol RPC deployment discovery");
+      }
+      const chainId = (await provider.getNetwork()).chainId;
+      const deployment = await protocolRpc.getDeployment(chainId);
+      if (!deployment.registry) {
+        throw new import_core19.MissingCapabilityError("receiving-key registry deployment");
+      }
+      const registry = new AddressRegistry(
+        { chainId, registryAddress: deployment.registry.address },
+        { expectedRuntimeCodeHash: deployment.registry.runtimeCodeHash }
+      );
+      return registry.prepareRegistration({ ...selected, provider });
+    });
+  }
+  assertPublicIdentity(options) {
+    const { wallet } = options;
+    if (!(wallet instanceof import_core19.PublicWallet) || ["getViewer", "getDetector", "exportAuthorization"].some((key) => key in wallet)) {
+      throw new Error(
+        "Independent preparation requires a PublicWallet without private capabilities"
+      );
+    }
+    for (const key of ["authorization", "signer", "fundingSigner", "viewing"]) {
+      if (key in options)
+        throw new Error(`Independent preparation does not accept capability: ${key}`);
+    }
+  }
+  resolveExplicit(options) {
+    this.assertPublicIdentity(options);
+    return this.resolve({ wallet: options.wallet, protocol: options.protocol });
+  }
   async prepareTransfer(options) {
-    const { wallet, protocol, ...input } = options;
-    const request = structuredClone(input);
-    const runtime = await this.resolve({ wallet, protocol });
-    const preparation = explicitPreparation(runtime, request, request.tokenAddress);
-    return preparation.prepareTransfer(request);
-  }
-  async prepareWithdraw(options) {
-    const { wallet, protocol, ...input } = options;
-    const request = structuredClone(input);
-    const runtime = await this.resolve({ wallet, protocol });
-    const preparation = explicitPreparation(runtime, request, request.tokenAddress);
-    return preparation.prepareWithdraw(request);
-  }
-  async prepareSweep(options) {
-    const { wallet, protocol, ...input } = options;
-    const request = structuredClone(input);
-    const runtime = await this.resolve({ wallet, protocol });
-    const preparation = explicitPreparation(runtime, request, request.tokenAddress);
-    return preparation.prepareSweep(request);
+    return prepareWithErrors("prepareTransfer", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, request, request.tokenAddress);
+      return preparation.prepareTransfer(request);
+    });
   }
   async prepareShield(options) {
-    const { wallet, protocol, ...input } = options;
-    const request = structuredClone(input);
-    const runtime = await this.resolve({ wallet, protocol });
-    const preparation = explicitPreparation(runtime, {}, request.tokenAddress);
-    return preparation.prepareShield(request);
+    return prepareWithErrors("prepareShield", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, {}, request.tokenAddress);
+      return preparation.prepareShield(request);
+    });
   }
   async prepareCreateCredit(options) {
-    const { wallet, protocol, ...input } = options;
-    const request = structuredClone(input);
-    const runtime = await this.resolve({ wallet, protocol });
-    const preparation = explicitPreparation(runtime, request, request.tokenAddress);
-    return preparation.prepareCreateCredit(request);
+    return prepareWithErrors("prepareCreateCredit", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, request, request.tokenAddress);
+      return preparation.prepareCreateCredit(request);
+    });
   }
   async prepareDrawCredit(options) {
-    const { wallet, protocol, ...input } = options;
-    const request = structuredClone(input);
-    const runtime = await this.resolve({ wallet, protocol });
-    const preparation = explicitPreparation(runtime, request, request.tokenAddress);
-    return preparation.prepareDrawCredit(request);
+    return prepareWithErrors("prepareDrawCredit", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, request, request.tokenAddress);
+      return preparation.prepareDrawCredit(request);
+    });
   }
   async prepareTopUpCredit(options) {
-    const { wallet, protocol, ...input } = options;
-    const request = structuredClone(input);
-    const runtime = await this.resolve({ wallet, protocol });
-    const preparation = explicitPreparation(runtime, request, request.tokenAddress);
-    return preparation.prepareTopUpCredit(request);
+    return prepareWithErrors("prepareTopUpCredit", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, request, request.tokenAddress);
+      return preparation.prepareTopUpCredit(request);
+    });
   }
   async prepareCancelCredit(options) {
-    const { wallet, protocol, ...input } = options;
-    const request = structuredClone(input);
-    const runtime = await this.resolve({ wallet, protocol });
-    const preparation = explicitPreparation(runtime, request, request.tokenAddress);
-    return preparation.prepareCancelCredit(request);
+    return prepareWithErrors("prepareCancelCredit", async () => {
+      const { wallet, protocol, ...input } = options;
+      const request = structuredClone(input);
+      const runtime = await this.resolveExplicit(options);
+      const preparation = explicitPreparation(runtime, request, request.tokenAddress);
+      return preparation.prepareCancelCredit(request);
+    });
   }
   toJSON() {
     return { invisi: true };
@@ -5042,8 +6256,8 @@ var Invisi = class {
 };
 
 // src/index.ts
-var import_core15 = require("@invisi-labs/core");
-var import_protocol10 = require("@invisi-labs/protocol");
+var import_core20 = require("@invisi-labs/core");
+var import_protocol11 = require("@invisi-labs/protocol");
 var import_rpc3 = require("@invisi-labs/rpc");
 
 // src/ProtocolRpcClient.ts
@@ -5054,21 +6268,6 @@ var ProtocolRpcClient2 = class extends import_rpc2.ProtocolRpcClient {
   }
 };
 
-// src/AddressRegistry.ts
-var import_protocol9 = require("@invisi-labs/protocol");
-var AddressRegistry = class extends import_protocol9.AddressRegistry {
-  prepareRegistration(options) {
-    if ("provider" in options) {
-      const { provider, ...preparation } = options;
-      return super.prepareRegistration({
-        ...preparation,
-        reader: new EthersChainReader(provider)
-      });
-    }
-    return super.prepareRegistration(options);
-  }
-};
-
 // src/integrations/encrypted-codec.ts
 var EncryptedWalletCodec = class _EncryptedWalletCodec {
   #key;
@@ -5160,6 +6359,7 @@ var EncryptedWalletCodec = class _EncryptedWalletCodec {
   DisclosureVerifier,
   EncryptedWalletCodec,
   Invisi,
+  InvisiError,
   MAX_MEMO_BYTES,
   MissingCapabilityError,
   NullifierCapability,
@@ -5168,14 +6368,22 @@ var EncryptedWalletCodec = class _EncryptedWalletCodec {
   Protocol,
   ProtocolRpcClient,
   ProtocolRpcError,
+  PublicWallet,
   RegistrationOperation,
   ViewingCapability,
   Wallet,
   WalletAuthorization,
   WalletSession,
+  computeCreditNullifier,
+  creditPeriods,
+  creditV1,
+  decodeDeliveryHeader,
   decodeMemoText,
+  decryptCandidates,
   defineGasBenchmarks,
   encodeMemo,
+  fundsV1,
+  readProtocolLogs,
   walletBalance
 });
 //# sourceMappingURL=index.cjs.map