@invisi-labs/primitives 0.0.0-stage → 1.2.1

package/dist/index.cjs

@@ -0,0 +1,2796 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod3) => __copyProps(__defProp({}, "__esModule", { value: true }), mod3);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AuthorizedStatement: () => AuthorizedStatement,
+  CREDIT_POLICY_FIELDS: () => CREDIT_POLICY_FIELDS,
+  CREDIT_USAGE_FIELDS: () => CREDIT_USAGE_FIELDS,
+  D_CNULL: () => D_CNULL,
+  D_CREDIT: () => D_CREDIT,
+  D_CREDIT_KEY_HASH: () => D_CREDIT_KEY_HASH,
+  D_CREDIT_RECOVERY: () => D_CREDIT_RECOVERY,
+  D_CREDIT_STATE_NONCE: () => D_CREDIT_STATE_NONCE,
+  D_IDENT: () => D_IDENT,
+  D_NOTE: () => D_NOTE,
+  D_NULL: () => D_NULL,
+  DeliveryAuthenticationError: () => DeliveryAuthenticationError,
+  DeliveryDecryptionError: () => DeliveryDecryptionError,
+  Detector: () => Detector,
+  Disclosure: () => Disclosure,
+  FIELD_MODULUS: () => FIELD_MODULUS,
+  MAX_CIPHERTEXT_BYTES: () => MAX_CIPHERTEXT_BYTES,
+  MAX_MEMO_BYTES: () => MAX_MEMO_BYTES,
+  MAX_WALLET_BATCH_BYTES: () => MAX_WALLET_BATCH_BYTES,
+  MissingCapabilityError: () => MissingCapabilityError,
+  NativeWalletError: () => NativeWalletError,
+  NullifierCapability: () => NullifierCapability,
+  ReceivingAddress: () => ReceivingAddress,
+  TREE_DEPTH: () => TREE_DEPTH,
+  ViewingCapability: () => ViewingCapability,
+  WALLET_AUTHORIZATION_TYPES: () => WALLET_AUTHORIZATION_TYPES,
+  Wallet: () => Wallet,
+  acceptWalletResponse: () => acceptWalletResponse,
+  acceptWalletResponses: () => acceptWalletResponses,
+  applyCreditDrawUsage: () => applyCreditDrawUsage,
+  authenticatedDecryptor: () => authenticatedDecryptor,
+  computeCreditCommitment: () => computeCreditCommitment,
+  computeCreditNullifier: () => computeCreditNullifier,
+  computeCreditRecoveryPad: () => computeCreditRecoveryPad,
+  computeCreditSharedKeyHash: () => computeCreditSharedKeyHash,
+  computeNoteCommitment: () => computeNoteCommitment,
+  computeNoteIdentity: () => computeNoteIdentity,
+  computeNoteNullifier: () => computeNoteNullifier,
+  computeOwnerAddress: () => computeOwnerAddress,
+  computeWalletAuthorizationDigest: () => computeWalletAuthorizationDigest,
+  createClue: () => createClue,
+  createClueFromSeed: () => createClueFromSeed,
+  createSigningRequest: () => createSigningRequest,
+  creditPeriods: () => creditPeriods,
+  creditV1: () => creditV1,
+  decodeAddress: () => decodeAddress,
+  decodeDeliveryHeader: () => decodeDeliveryHeader,
+  decodeMemoText: () => decodeMemoText,
+  decryptCreditState: () => decryptCreditState,
+  decryptPrivateTransferNote: () => decryptPrivateTransferNote,
+  deliveryCodec: () => deliveryCodec,
+  deliveryHeader: () => deliveryHeader,
+  deriveClueKey: () => deriveClueKey,
+  deriveCreditState: () => deriveCreditState,
+  deriveCreditStateNonce: () => deriveCreditStateNonce,
+  deriveCreditUpdate: () => deriveCreditUpdate,
+  encodeMemo: () => encodeMemo,
+  encryptCreditState: () => encryptCreditState,
+  encryptPrivateTransferNote: () => encryptPrivateTransferNote,
+  fundsV1: () => fundsV1,
+  generateCreditSharedKey: () => generateCreditSharedKey,
+  generateNonce: () => generateNonce,
+  normalizeCreditDeliveryState: () => normalizeCreditDeliveryState,
+  normalizeCreditPolicy: () => normalizeCreditPolicy,
+  normalizeCreditState: () => normalizeCreditState,
+  normalizeCreditUsage: () => normalizeCreditUsage,
+  poseidonHash: () => poseidonHash,
+  prepareWalletRequest: () => prepareWalletRequest,
+  provenanceIntentHash: () => provenanceIntentHash,
+  recoverCreditState: () => recoverCreditState,
+  validateClueKey: () => validateClueKey,
+  validateDeliveryCiphertext: () => validateDeliveryCiphertext,
+  validateWalletBatch: () => validateWalletBatch,
+  validateWalletResponses: () => validateWalletResponses,
+  verifyWalletAuthorization: () => verifyWalletAuthorization,
+  viewingPublicKey: () => viewingPublicKey,
+  walletAuthorizationTypedData: () => walletAuthorizationTypedData
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/address/address.ts
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_sha3 = require("@noble/hashes/sha3");
+var import_utils2 = require("@noble/hashes/utils");
+var import_ethers = require("ethers");
+
+// src/fmd/fmd.ts
+var import_blake2b2 = require("@noble/hashes/blake2b");
+var import_utils = require("@noble/hashes/utils");
+
+// src/fmd/decaf377.ts
+var import_edwards = require("@noble/curves/abstract/edwards");
+var import_modular = require("@noble/curves/abstract/modular");
+var import_blake2b = require("@noble/hashes/blake2b");
+var FQ = 8444461749428370424248824938781546531375899335154063827935233455917409239041n;
+var FR = 2111115437357092606062206234695386632838870926408408195193685246394721360383n;
+var field = (0, import_modular.Field)(FQ, 253, true);
+var f = (n) => (0, import_modular.mod)(n, FQ);
+var abs = (n) => (n & 1n) === 0n ? n : f(-n);
+function secureRandomBytes(length) {
+  const webCrypto = globalThis.crypto;
+  if (!webCrypto?.getRandomValues) throw new Error("WebCrypto secure randomness is unavailable");
+  return webCrypto.getRandomValues(new Uint8Array(length));
+}
+var curve = (0, import_edwards.twistedEdwards)({
+  a: FQ - 1n,
+  d: 3021n,
+  Fp: field,
+  n: FR,
+  h: 4n,
+  Gx: 4959445789346820725352484487855828915252512307947624787834978378872129235627n,
+  Gy: 6060471950081851567114691557659790004756535011754163002297540472747064943288n,
+  hash: import_blake2b.blake2b,
+  randomBytes: (length = 32) => secureRandomBytes(length)
+});
+var generator = curve.ExtendedPoint.BASE;
+function readLE(bytes3) {
+  let n = 0n;
+  for (let i = bytes3.length - 1; i >= 0; i--) n = n << 8n | BigInt(bytes3[i]);
+  return n;
+}
+function writeLE(n) {
+  const bytes3 = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    bytes3[i] = Number(n & 255n);
+    n >>= 8n;
+  }
+  return bytes3;
+}
+function multiply(point, scalar) {
+  return scalar === 0n ? curve.ExtendedPoint.ZERO : point.multiply(scalar);
+}
+function inverseScalar(scalar) {
+  return (0, import_modular.Field)(FR).inv(scalar);
+}
+function decodePoint(bytes3) {
+  if (!(bytes3 instanceof Uint8Array) || bytes3.length !== 32)
+    throw new Error("Invalid Decaf377 encoding length");
+  const s = readLE(bytes3);
+  if (s >= FQ || (s & 1n) !== 0n || bytes3[31] >> 5 !== 0)
+    throw new Error("Invalid Decaf377 encoding");
+  const ss = f(s * s);
+  const u1 = f(1n - ss);
+  const u2 = f(u1 * u1 - 4n * 3021n * ss);
+  const denominator = f(u2 * u1 * u1);
+  if (denominator === 0n) throw new Error("Invalid Decaf377 encoding");
+  let v;
+  try {
+    v = field.sqrt(field.inv(denominator));
+  } catch {
+    throw new Error("Invalid Decaf377 encoding");
+  }
+  const twoSU1 = f(2n * s * u1);
+  if ((f(twoSU1 * v) & 1n) !== 0n) v = f(-v);
+  const x = f(twoSU1 * v * v * u2);
+  const y = f((1n + ss) * v * u1);
+  return curve.ExtendedPoint.fromAffine({ x, y });
+}
+function encodePoint(point) {
+  const { ex: x, ez: z, et: t } = point;
+  if (x === 0n) return new Uint8Array(32);
+  const aMinusD = -3022n;
+  const u1 = f((x + t) * (x - t));
+  const denominator = f(u1 * aMinusD * x * x);
+  const v = field.sqrt(field.inv(denominator));
+  const u2 = abs(f(v * u1));
+  const u3 = f(u2 * z - t);
+  return writeLE(abs(f(aMinusD * v * u3 * x)));
+}
+function isIdentity(point) {
+  return point.ex === 0n;
+}
+
+// src/fmd/fmd.ts
+var PRECISION = 24;
+function requireBytes(value, length, name) {
+  if (!(value instanceof Uint8Array) || value.length !== length)
+    throw new TypeError(`${name} must be a ${length}-byte Uint8Array`);
+}
+function detectionScalar(key) {
+  requireBytes(key, 32, "Detection key");
+  const scalar = readLE(key);
+  if (scalar === 0n || scalar >= FR)
+    throw new Error("Detection key must be a canonical nonzero Decaf377 scalar");
+  return scalar;
+}
+function hash(domain, ...parts) {
+  const personalization = new Uint8Array(16);
+  personalization.set((0, import_utils.utf8ToBytes)(`decaf377-fmd.${domain}`));
+  return (0, import_blake2b2.blake2b)((0, import_utils.concatBytes)(...parts), { dkLen: 64, personalization });
+}
+var hashScalar = (domain, ...parts) => readLE(hash(domain, ...parts)) % FR;
+var childOffset = (clueKey, index) => hashScalar("hkd", clueKey, Uint8Array.of(index));
+var hashBit = (p, shared, q) => hash("bit", p, shared, q)[0] & 1;
+function deriveClueKey(detectionKey) {
+  return encodePoint(multiply(generator, detectionScalar(detectionKey)));
+}
+function validateClueKey(clueKey) {
+  requireBytes(clueKey, 32, "Clue key");
+  if (isIdentity(decodePoint(clueKey))) throw new Error("Clue key must not be the identity");
+}
+function createClue(clueKey) {
+  validateClueKey(clueKey);
+  return createClueFromSeed(clueKey, secureRandomBytes(32));
+}
+function createClueFromSeed(clueKey, seed32) {
+  validateClueKey(clueKey);
+  requireBytes(seed32, 32, "Clue seed");
+  const root = decodePoint(clueKey);
+  const r = hashScalar("rdv", clueKey, seed32);
+  const z = hashScalar("zdv", clueKey, seed32);
+  if (r === 0n) throw new Error("Degenerate clue seed");
+  const p = encodePoint(multiply(generator, r));
+  const q = encodePoint(multiply(generator, z));
+  const ciphertext = new Uint8Array(3);
+  for (let i = 0; i < PRECISION; i++) {
+    const child = root.add(multiply(generator, childOffset(clueKey, i)));
+    const shared = encodePoint(multiply(child, r));
+    ciphertext[i >> 3] = ciphertext[i >> 3] | (hashBit(p, shared, q) ^ 1) << (i & 7);
+  }
+  const m = hashScalar("sca", p, Uint8Array.of(PRECISION), ciphertext);
+  const y = (z - m + FR) * inverseScalar(r) % FR;
+  if (y === 0n) throw new Error("Degenerate clue seed");
+  return (0, import_utils.concatBytes)(p, writeLE(y), Uint8Array.of(PRECISION), ciphertext);
+}
+
+// src/address/address.ts
+var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+function identityBytes(value) {
+  if (typeof value !== "bigint" && (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value)))
+    throw new Error("invalid owner address encoding");
+  const n = BigInt(value);
+  if (n <= 0n || n >= 1n << 160n)
+    throw new RangeError("owner address must be a nonzero EVM owner address");
+  return (0, import_utils2.hexToBytes)(n.toString(16).padStart(40, "0"));
+}
+function receivingKeys(keys) {
+  const publicKey2 = keys.viewingPublicKey;
+  if (!(publicKey2 instanceof Uint8Array) || publicKey2.length !== 33 || publicKey2[0] !== 2 && publicKey2[0] !== 3)
+    throw new Error("invalid compressed viewing public key");
+  import_secp256k1.secp256k1.ProjectivePoint.fromHex(publicKey2).assertValidity();
+  validateClueKey(keys.clueKey);
+  return { viewingPublicKey: Uint8Array.from(publicKey2), clueKey: Uint8Array.from(keys.clueKey) };
+}
+function checkedText(prefix, data) {
+  const digest = (0, import_sha3.keccak_256)((0, import_utils2.utf8ToBytes)("Invisi.AddressCaseChecksum.v1:" + prefix + data));
+  return prefix + Array.from(
+    data,
+    (character, i) => digest[i >> 3] >> 7 - (i & 7) & 1 ? character.toUpperCase() : character
+  ).join("");
+}
+function encode(prefix, payload) {
+  let buffer2 = 0, bits = 0, data = "";
+  for (const byte of payload) {
+    buffer2 = buffer2 << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      data += ALPHABET[buffer2 >>> bits & 31];
+    }
+    buffer2 &= (1 << bits) - 1;
+  }
+  if (bits) data += ALPHABET[buffer2 << 5 - bits & 31];
+  return checkedText(prefix, data);
+}
+function encodeLongAddress(recipient) {
+  const identity2 = identityBytes(recipient.ownerAddress), keys = receivingKeys(recipient);
+  return encode("0i", (0, import_utils2.concatBytes)(identity2, keys.viewingPublicKey, keys.clueKey));
+}
+function encodeShortAddress(ownerAddress) {
+  const identity2 = identityBytes(ownerAddress);
+  return (0, import_ethers.getAddress)(
+    typeof ownerAddress === "string" ? ownerAddress : `0x${(0, import_utils2.bytesToHex)(identity2)}`
+  );
+}
+function decodeAddress(address) {
+  if (typeof address !== "string") throw new TypeError("address must be text");
+  if (address.startsWith("0x")) {
+    const owner2 = (0, import_ethers.getAddress)(address);
+    return { kind: "short", ownerAddress: `0x${(0, import_utils2.bytesToHex)(identityBytes(owner2))}` };
+  }
+  if (!address.startsWith("0i")) throw new Error("invalid Invisi address prefix");
+  const prefix = "0i";
+  if (address.length !== 138) throw new Error("invalid address length");
+  const data = address.slice(prefix.length).toLowerCase();
+  if (Array.from(data).some((character) => !ALPHABET.includes(character)))
+    throw new Error("invalid address alphabet");
+  if (checkedText(prefix, data) !== address) throw new Error("invalid address case checksum");
+  let buffer2 = 0, bits = 0;
+  const payload = [];
+  for (const character of data) {
+    buffer2 = buffer2 << 5 | ALPHABET.indexOf(character);
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      payload.push(buffer2 >>> bits & 255);
+    }
+    buffer2 &= (1 << bits) - 1;
+  }
+  if (bits !== 0 || buffer2 !== 0) throw new Error("noncanonical address padding");
+  const raw = Uint8Array.from(payload);
+  const ownerAddress = `0x${(0, import_utils2.bytesToHex)(identityBytes(`0x${(0, import_utils2.bytesToHex)(raw.subarray(0, 20))}`))}`;
+  return {
+    kind: "long",
+    ownerAddress,
+    ...receivingKeys({ viewingPublicKey: raw.slice(20, 53), clueKey: raw.slice(53) })
+  };
+}
+
+// src/errors.ts
+var MissingCapabilityError = class extends Error {
+  constructor(capability) {
+    super(`Missing ${capability} capability`);
+    this.capability = capability;
+    this.name = "MissingCapabilityError";
+  }
+  code = "MISSING_CAPABILITY";
+};
+
+// src/address/receiving-address.ts
+var ReceivingAddress = class _ReceivingAddress {
+  #text;
+  constructor(text) {
+    const decoded = decodeAddress(text);
+    this.#text = decoded.kind === "short" ? encodeShortAddress(decoded.ownerAddress) : text;
+    Object.freeze(this);
+  }
+  static parse(text) {
+    return new _ReceivingAddress(text);
+  }
+  static from(recipient) {
+    return new _ReceivingAddress(encodeLongAddress(recipient));
+  }
+  static fromIdentity(identity2) {
+    return new _ReceivingAddress(encodeShortAddress(identity2));
+  }
+  get ownerAddress() {
+    return decodeAddress(this.#text).ownerAddress;
+  }
+  get kind() {
+    return decodeAddress(this.#text).kind;
+  }
+  getReceivingKeys() {
+    const decoded = decodeAddress(this.#text);
+    if (decoded.kind === "short") {
+      throw new MissingCapabilityError("resolved receiving keys");
+    }
+    return { viewingPublicKey: decoded.viewingPublicKey, clueKey: decoded.clueKey };
+  }
+  async resolve(lookup) {
+    if (this.kind === "long") {
+      return this;
+    }
+    if (!lookup) {
+      throw new MissingCapabilityError("explicit registry lookup");
+    }
+    const keys = await lookup(this.ownerAddress);
+    if (!keys) {
+      throw new Error("owner address is not registered");
+    }
+    return _ReceivingAddress.from({
+      ownerAddress: this.ownerAddress,
+      viewingPublicKey: keys.viewingPublicKey,
+      clueKey: keys.clueKey
+    });
+  }
+  get viewingPublicKey() {
+    return this.getReceivingKeys().viewingPublicKey;
+  }
+  get clueKey() {
+    return this.getReceivingKeys().clueKey;
+  }
+  toString() {
+    return this.#text;
+  }
+  toJSON() {
+    return this.#text;
+  }
+};
+
+// src/crypto/domains.ts
+var D_IDENT = 2n;
+var D_NOTE = 3n;
+var D_NULL = 4n;
+var D_CREDIT = 5n;
+var D_CNULL = 6n;
+var D_CREDIT_KEY_HASH = 7n;
+var D_CREDIT_RECOVERY = 9n;
+var D_CREDIT_STATE_NONCE = 10n;
+var TREE_DEPTH = 16;
+
+// src/crypto/random.ts
+var FIELD_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+function sampleField(nonzero) {
+  const bytes3 = new Uint8Array(32);
+  for (; ; ) {
+    crypto.getRandomValues(bytes3);
+    const candidate = BigInt(
+      "0x" + Array.from(bytes3, (b) => b.toString(16).padStart(2, "0")).join("")
+    );
+    if (candidate < FIELD_MODULUS && (!nonzero || candidate !== 0n)) return candidate;
+  }
+}
+function generateNonce() {
+  return sampleField(false);
+}
+function generateCreditSharedKey() {
+  return sampleField(true);
+}
+
+// src/crypto/poseidon-constants.ts
+var INTERNAL_DIAGONAL = [
+  0x10dc6e9c006ea38b04b1e03b4bd9490c0d03f98929ca1d7fb56821fd19d3b6e7n,
+  0x0c28145b6a44df3e0149b3d0a30b3bb599df9756d4dd9b84a86b38cfb45a740bn,
+  0x00544b8338791518b2c7645a50392798b21f75bb60e3596170067d00141cac15n,
+  0x222c01175718386f2e2e82eb122789e352e105a3b8fa852613bc534433ee428bn
+];
+var ROUND_CONSTANTS = [
+  [
+    0x19b849f69450b06848da1d39bd5e4a4302bb86744edc26238b0878e269ed23e5n,
+    0x265ddfe127dd51bd7239347b758f0a1320eb2cc7450acc1dad47f80c8dcf34d6n,
+    0x199750ec472f1809e0f66a545e1e51624108ac845015c2aa3dfc36bab497d8aan,
+    0x157ff3fe65ac7208110f06a5f74302b14d743ea25067f0ffd032f787c7f1cdf8n
+  ],
+  [
+    0x2e49c43c4569dd9c5fd35ac45fca33f10b15c590692f8beefe18f4896ac94902n,
+    0x0e35fb89981890520d4aef2b6d6506c3cb2f0b6973c24fa82731345ffa2d1f1en,
+    0x251ad47cb15c4f1105f109ae5e944f1ba9d9e7806d667ffec6fe723002e0b996n,
+    0x13da07dc64d428369873e97160234641f8beb56fdd05e5f3563fa39d9c22df4en
+  ],
+  [
+    0x0c009b84e650e6d23dc00c7dccef7483a553939689d350cd46e7b89055fd4738n,
+    0x011f16b1c63a854f01992e3956f42d8b04eb650c6d535eb0203dec74befdca06n,
+    0x0ed69e5e383a688f209d9a561daa79612f3f78d0467ad45485df07093f367549n,
+    0x04dba94a7b0ce9e221acad41472b6bbe3aec507f5eb3d33f463672264c9f789bn
+  ],
+  [
+    0x0a3f2637d840f3a16eb094271c9d237b6036757d4bb50bf7ce732ff1d4fa28e8n,
+    0x259a666f129eea198f8a1c502fdb38fa39b1f075569564b6e54a485d1182323fn,
+    0x28bf7459c9b2f4c6d8e7d06a4ee3a47f7745d4271038e5157a32fdf7ede0d6a1n,
+    0x0a1ca941f057037526ea200f489be8d4c37c85bbcce6a2aeec91bd6941432447n
+  ],
+  [0x0c6f8f958be0e93053d7fd4fc54512855535ed1539f051dcb43a26fd926361cfn, 0x0n, 0x0n, 0x0n],
+  [0x123106a93cd17578d426e8128ac9d90aa9e8a00708e296e084dd57e69caaf811n, 0x0n, 0x0n, 0x0n],
+  [0x26e1ba52ad9285d97dd3ab52f8e840085e8fa83ff1e8f1877b074867cd2dee75n, 0x0n, 0x0n, 0x0n],
+  [0x1cb55cad7bd133de18a64c5c47b9c97cbe4d8b7bf9e095864471537e6a4ae2c5n, 0x0n, 0x0n, 0x0n],
+  [0x1dcd73e46acd8f8e0e2c7ce04bde7f6d2a53043d5060a41c7143f08e6e9055d0n, 0x0n, 0x0n, 0x0n],
+  [0x011003e32f6d9c66f5852f05474a4def0cda294a0eb4e9b9b12b9bb4512e5574n, 0x0n, 0x0n, 0x0n],
+  [0x2b1e809ac1d10ab29ad5f20d03a57dfebadfe5903f58bafed7c508dd2287ae8cn, 0x0n, 0x0n, 0x0n],
+  [0x2539de1785b735999fb4dac35ee17ed0ef995d05ab2fc5faeaa69ae87bcec0a5n, 0x0n, 0x0n, 0x0n],
+  [0x0c246c5a2ef8ee0126497f222b3e0a0ef4e1c3d41c86d46e43982cb11d77951dn, 0x0n, 0x0n, 0x0n],
+  [0x192089c4974f68e95408148f7c0632edbb09e6a6ad1a1c2f3f0305f5d03b527bn, 0x0n, 0x0n, 0x0n],
+  [0x1eae0ad8ab68b2f06a0ee36eeb0d0c058529097d91096b756d8fdc2fb5a60d85n, 0x0n, 0x0n, 0x0n],
+  [0x179190e5d0e22179e46f8282872abc88db6e2fdc0dee99e69768bd98c5d06bfbn, 0x0n, 0x0n, 0x0n],
+  [0x29bb9e2c9076732576e9a81c7ac4b83214528f7db00f31bf6cafe794a9b3cd1cn, 0x0n, 0x0n, 0x0n],
+  [0x225d394e42207599403efd0c2464a90d52652645882aac35b10e590e6e691e08n, 0x0n, 0x0n, 0x0n],
+  [0x064760623c25c8cf753d238055b444532be13557451c087de09efd454b23fd59n, 0x0n, 0x0n, 0x0n],
+  [0x10ba3a0e01df92e87f301c4b716d8a394d67f4bf42a75c10922910a78f6b5b87n, 0x0n, 0x0n, 0x0n],
+  [0x0e070bf53f8451b24f9c6e96b0c2a801cb511bc0c242eb9d361b77693f21471cn, 0x0n, 0x0n, 0x0n],
+  [0x1b94cd61b051b04dd39755ff93821a73ccd6cb11d2491d8aa7f921014de252fbn, 0x0n, 0x0n, 0x0n],
+  [0x1d7cb39bafb8c744e148787a2e70230f9d4e917d5713bb050487b5aa7d74070bn, 0x0n, 0x0n, 0x0n],
+  [0x2ec93189bd1ab4f69117d0fe980c80ff8785c2961829f701bb74ac1f303b17dbn, 0x0n, 0x0n, 0x0n],
+  [0x2db366bfdd36d277a692bb825b86275beac404a19ae07a9082ea46bd83517926n, 0x0n, 0x0n, 0x0n],
+  [0x062100eb485db06269655cf186a68532985275428450359adc99cec6960711b8n, 0x0n, 0x0n, 0x0n],
+  [0x0761d33c66614aaa570e7f1e8244ca1120243f92fa59e4f900c567bf41f5a59bn, 0x0n, 0x0n, 0x0n],
+  [0x20fc411a114d13992c2705aa034e3f315d78608a0f7de4ccf7a72e494855ad0dn, 0x0n, 0x0n, 0x0n],
+  [0x25b5c004a4bdfcb5add9ec4e9ab219ba102c67e8b3effb5fc3a30f317250bc5an, 0x0n, 0x0n, 0x0n],
+  [0x23b1822d278ed632a494e58f6df6f5ed038b186d8474155ad87e7dff62b37f4bn, 0x0n, 0x0n, 0x0n],
+  [0x22734b4c5c3f9493606c4ba9012499bf0f14d13bfcfcccaa16102a29cc2f69e0n, 0x0n, 0x0n, 0x0n],
+  [0x26c0c8fe09eb30b7e27a74dc33492347e5bdff409aa3610254413d3fad795ce5n, 0x0n, 0x0n, 0x0n],
+  [0x070dd0ccb6bd7bbae88eac03fa1fbb26196be3083a809829bbd626df348ccad9n, 0x0n, 0x0n, 0x0n],
+  [0x12b6595bdb329b6fb043ba78bb28c3bec2c0a6de46d8c5ad6067c4ebfd4250dan, 0x0n, 0x0n, 0x0n],
+  [0x248d97d7f76283d63bec30e7a5876c11c06fca9b275c671c5e33d95bb7e8d729n, 0x0n, 0x0n, 0x0n],
+  [0x1a306d439d463b0816fc6fd64cc939318b45eb759ddde4aa106d15d9bd9baaaan, 0x0n, 0x0n, 0x0n],
+  [0x28a8f8372e3c38daced7c00421cb4621f4f1b54ddc27821b0d62d3d6ec7c56cfn, 0x0n, 0x0n, 0x0n],
+  [0x0094975717f9a8a8bb35152f24d43294071ce320c829f388bc852183e1e2ce7en, 0x0n, 0x0n, 0x0n],
+  [0x04d5ee4c3aa78f7d80fde60d716480d3593f74d4f653ae83f4103246db2e8d65n, 0x0n, 0x0n, 0x0n],
+  [0x2a6cf5e9aa03d4336349ad6fb8ed2269c7bef54b8822cc76d08495c12efde187n, 0x0n, 0x0n, 0x0n],
+  [0x2304d31eaab960ba9274da43e19ddeb7f792180808fd6e43baae48d7efcba3f3n, 0x0n, 0x0n, 0x0n],
+  [0x03fd9ac865a4b2a6d5e7009785817249bff08a7e0726fcb4e1c11d39d199f0b0n, 0x0n, 0x0n, 0x0n],
+  [0x00b7258ded52bbda2248404d55ee5044798afc3a209193073f7954d4d63b0b64n, 0x0n, 0x0n, 0x0n],
+  [0x159f81ada0771799ec38fca2d4bf65ebb13d3a74f3298db36272c5ca65e92d9an, 0x0n, 0x0n, 0x0n],
+  [0x1ef90e67437fbc8550237a75bc28e3bb9000130ea25f0c5471e144cf4264431fn, 0x0n, 0x0n, 0x0n],
+  [0x1e65f838515e5ff0196b49aa41a2d2568df739bc176b08ec95a79ed82932e30dn, 0x0n, 0x0n, 0x0n],
+  [0x2b1b045def3a166cec6ce768d079ba74b18c844e570e1f826575c1068c94c33fn, 0x0n, 0x0n, 0x0n],
+  [0x0832e5753ceb0ff6402543b1109229c165dc2d73bef715e3f1c6e07c168bb173n, 0x0n, 0x0n, 0x0n],
+  [0x02f614e9cedfb3dc6b762ae0a37d41bab1b841c2e8b6451bc5a8e3c390b6ad16n, 0x0n, 0x0n, 0x0n],
+  [0x0e2427d38bd46a60dd640b8e362cad967370ebb777bedff40f6a0be27e7ed705n, 0x0n, 0x0n, 0x0n],
+  [0x0493630b7c670b6deb7c84d414e7ce79049f0ec098c3c7c50768bbe29214a53an, 0x0n, 0x0n, 0x0n],
+  [0x22ead100e8e482674decdab17066c5a26bb1515355d5461a3dc06cc85327cea9n, 0x0n, 0x0n, 0x0n],
+  [0x25b3e56e655b42cdaae2626ed2554d48583f1ae35626d04de5084e0b6d2a6f16n, 0x0n, 0x0n, 0x0n],
+  [0x1e32752ada8836ef5837a6cde8ff13dbb599c336349e4c584b4fdc0a0cf6f9d0n, 0x0n, 0x0n, 0x0n],
+  [0x2fa2a871c15a387cc50f68f6f3c3455b23c00995f05078f672a9864074d412e5n, 0x0n, 0x0n, 0x0n],
+  [0x2f569b8a9a4424c9278e1db7311e889f54ccbf10661bab7fcd18e7c7a7d83505n, 0x0n, 0x0n, 0x0n],
+  [0x044cb455110a8fdd531ade530234c518a7df93f7332ffd2144165374b246b43dn, 0x0n, 0x0n, 0x0n],
+  [0x227808de93906d5d420246157f2e42b191fe8c90adfe118178ddc723a5319025n, 0x0n, 0x0n, 0x0n],
+  [0x02fcca2934e046bc623adead873579865d03781ae090ad4a8579d2e7a6800355n, 0x0n, 0x0n, 0x0n],
+  [0x0ef915f0ac120b876abccceb344a1d36bad3f3c5ab91a8ddcbec2e060d8befacn, 0x0n, 0x0n, 0x0n],
+  [
+    0x1797130f4b7a3e1777eb757bc6f287f6ab0fb85f6be63b09f3b16ef2b1405d38n,
+    0x0a76225dc04170ae3306c85abab59e608c7f497c20156d4d36c668555decc6e5n,
+    0x1fffb9ec1992d66ba1e77a7b93209af6f8fa76d48acb664796174b5326a31a5cn,
+    0x25721c4fc15a3f2853b57c338fa538d85f8fbba6c6b9c6090611889b797b9c5fn
+  ],
+  [
+    0x0c817fd42d5f7a41215e3d07ba197216adb4c3790705da95eb63b982bfcaf75an,
+    0x13abe3f5239915d39f7e13c2c24970b6df8cf86ce00a22002bc15866e52b5a96n,
+    0x2106feea546224ea12ef7f39987a46c85c1bc3dc29bdbd7a92cd60acb4d391cen,
+    0x21ca859468a746b6aaa79474a37dab49f1ca5a28c748bc7157e1b3345bb0f959n
+  ],
+  [
+    0x05ccd6255c1e6f0c5cf1f0df934194c62911d14d0321662a8f1a48999e34185bn,
+    0x0f0e34a64b70a626e464d846674c4c8816c4fb267fe44fe6ea28678cb09490a4n,
+    0x0558531a4e25470c6157794ca36d0e9647dbfcfe350d64838f5b1a8a2de0d4bfn,
+    0x09d3dca9173ed2faceea125157683d18924cadad3f655a60b72f5864961f1455n
+  ],
+  [
+    0x0328cbd54e8c0913493f866ed03d218bf23f92d68aaec48617d4c722e5bd4335n,
+    0x2bf07216e2aff0a223a487b1a7094e07e79e7bcc9798c648ee3347dd5329d34bn,
+    0x1daf345a58006b736499c583cb76c316d6f78ed6a6dffc82111e11a63fe412dfn,
+    0x176563472456aaa746b694c60e1823611ef39039b2edc7ff391e6f2293d2c404n
+  ]
+];
+
+// src/crypto/poseidon.ts
+var mod2 = (n) => n % FIELD_MODULUS;
+var fifth = (n) => {
+  const x = mod2(n), x2 = mod2(x * x);
+  return mod2(x * x2 * x2);
+};
+function external(s) {
+  const t0 = s[0] + s[1], t1 = s[2] + s[3], t2 = 2n * s[1] + t1, t3 = 2n * s[3] + t0;
+  const t4 = 4n * t1 + t3, t5 = 4n * t0 + t2;
+  s[0] = mod2(t3 + t5);
+  s[1] = mod2(t5);
+  s[2] = mod2(t2 + t4);
+  s[3] = mod2(t4);
+}
+function permute(s) {
+  external(s);
+  for (let r = 0; r < 64; r++) {
+    const full = r < 4 || r >= 60, rc = ROUND_CONSTANTS[r];
+    if (full) {
+      for (let i = 0; i < 4; i++) s[i] = fifth(s[i] + rc[i]);
+      external(s);
+    } else {
+      s[0] = fifth(s[0] + rc[0]);
+      const sum = s.reduce((a, b) => a + b, 0n);
+      for (let i = 0; i < 4; i++) s[i] = mod2(s[i] * INTERNAL_DIAGONAL[i] + sum);
+    }
+  }
+}
+async function poseidonHash(inputs) {
+  for (let i = 0; i < inputs.length; i++)
+    if (inputs[i] < 0n || inputs[i] >= FIELD_MODULUS)
+      throw new RangeError(
+        `poseidonHash: input[${i}] out of BN254 field range [0, FIELD_MODULUS): ${inputs[i]}`
+      );
+  const state = [0n, 0n, 0n, BigInt(inputs.length) << 64n];
+  let used = 0;
+  for (const input of inputs) {
+    if (used === 3) {
+      permute(state);
+      used = 0;
+    }
+    state[used] = mod2(state[used] + input);
+    used++;
+  }
+  permute(state);
+  return `0x${state[0].toString(16).padStart(64, "0")}`;
+}
+
+// src/delivery/delivery-codec.ts
+var import_ethers2 = require("ethers");
+
+// src/delivery/note-payload.ts
+var import_secp256k12 = require("@noble/curves/secp256k1");
+
+// src/notes/noteContext.ts
+function assertNoteContext(note, context2) {
+  if (note.chainId !== context2.chainId || note.protocolAddress !== context2.protocolAddress) {
+    throw new Error("note context mismatch");
+  }
+}
+
+// src/credit/state.ts
+var CREDIT_POLICY_FIELDS = ["singleLimit", "dailyLimit", "monthlyLimit"];
+var CREDIT_USAGE_FIELDS = [
+  "lastDay",
+  "dailySpent",
+  "lastMonth",
+  "monthlySpent",
+  "totalSpent"
+];
+function normalizeCreditPolicy(value = {}) {
+  return Object.fromEntries(
+    CREDIT_POLICY_FIELDS.map((key) => {
+      const n = value[key] ?? 0n;
+      uint(n, 126, key);
+      return [key, n];
+    })
+  );
+}
+function normalizeCreditUsage(value = {}) {
+  const usage = Object.fromEntries(
+    CREDIT_USAGE_FIELDS.map((key) => {
+      const n = value[key] ?? 0n;
+      uint(n, key === "lastDay" || key === "lastMonth" ? 64 : 128, key);
+      return [key, n];
+    })
+  );
+  for (const [period, spent] of [
+    ["lastDay", "dailySpent"],
+    ["lastMonth", "monthlySpent"]
+  ])
+    if (usage[period] === 0n && usage[spent] !== 0n) throw Error("noncanonical Credit usage");
+  return usage;
+}
+function balance(value) {
+  uint(value.availableCredit, 128, "availableCredit");
+  if (typeof value.unlimited !== "boolean") throw TypeError("unlimited must be boolean");
+  if (value.unlimited && value.availableCredit !== 0n)
+    throw Error("unlimited Credit must have zero available credit");
+  return { availableCredit: value.availableCredit, unlimited: value.unlimited };
+}
+function creditPeriods(timestamp) {
+  if (typeof timestamp !== "bigint") throw new TypeError("Credit timestamp required");
+  uint(timestamp, 64, "timestamp");
+  const days = timestamp / 86400n, z = days + 719468n, era = z / 146097n, doe = z - era * 146097n;
+  const yoe = (doe - doe / 1460n + doe / 36524n - doe / 146096n) / 365n;
+  let year = yoe + era * 400n;
+  const doy = doe - (365n * yoe + yoe / 4n - yoe / 100n), mp = (5n * doy + 2n) / 153n;
+  const month = mp + (mp < 10n ? 3n : -9n);
+  if (month <= 2n) year++;
+  return { currentDay: days + 1n, currentMonth: (year - 1970n) * 12n + month };
+}
+function applyCreditDrawUsage(note, amount, timestamp) {
+  const policy = {
+    ...normalizeCreditPolicy(note),
+    ...normalizeCreditUsage(note),
+    ...balance(note)
+  }, periods = creditPeriods(timestamp);
+  uint(amount, 126, "draw amount");
+  if (amount === 0n) throw new Error("draw amount must be positive");
+  if (policy.singleLimit !== 0n && amount > policy.singleLimit)
+    throw new Error("single limit exceeded");
+  for (const [limit, last, spent, current] of [
+    ["dailyLimit", "lastDay", "dailySpent", "currentDay"],
+    ["monthlyLimit", "lastMonth", "monthlySpent", "currentMonth"]
+  ]) {
+    const period = periods[current];
+    if (period < policy[last]) throw new Error("Credit period rollback");
+    policy[spent] = (period === policy[last] ? policy[spent] : 0n) + amount;
+    uint(policy[spent], 128, spent);
+    policy[last] = period;
+    if (policy[limit] !== 0n && policy[spent] > policy[limit])
+      throw new Error(`${limit} exceeded`);
+  }
+  policy.totalSpent += amount;
+  uint(policy.totalSpent, 128, "totalSpent");
+  if (!policy.unlimited) {
+    if (amount > policy.availableCredit) throw Error("available credit exceeded");
+    policy.availableCredit -= amount;
+  }
+  return policy;
+}
+async function computeCreditSharedKeyHash(creditSharedKey) {
+  if (creditSharedKey <= 0n || creditSharedKey >= FIELD_MODULUS)
+    throw new RangeError("invalid Credit shared key");
+  return poseidonHash([D_CREDIT_KEY_HASH, creditSharedKey]);
+}
+function normalizeCreditState(state) {
+  const allowed = [
+    "chainId",
+    "protocolAddress",
+    "tokenAddress",
+    "spenderWalletIdentity",
+    "ownerWalletIdentity",
+    "revocationShard",
+    "revocationSlot",
+    "nonce",
+    "expiry",
+    "creditSharedKey",
+    ...CREDIT_POLICY_FIELDS,
+    ...CREDIT_USAGE_FIELDS,
+    "availableCredit",
+    "unlimited",
+    "payload"
+  ];
+  if (!state || typeof state !== "object" || Object.keys(state).some((k) => !allowed.includes(k)))
+    throw Error("Unsupported Credit fields");
+  for (const [name, bits] of [
+    ["chainId", 64],
+    ["protocolAddress", 160],
+    ["tokenAddress", 160],
+    ["revocationShard", 64],
+    ["revocationSlot", 16],
+    ["expiry", 64]
+  ])
+    uint(state[name], bits, name);
+  for (const id of [state.spenderWalletIdentity, state.ownerWalletIdentity])
+    if (!/^0x[0-9a-fA-F]{40}$/.test(id) || BigInt(id) === 0n)
+      throw Error("invalid Credit identity");
+  if (!state.protocolAddress || !state.tokenAddress || !state.revocationShard || !state.expiry)
+    throw Error("Credit deployment, token, shard and expiry must be positive");
+  field2(state.nonce, "nonce");
+  field2(state.creditSharedKey, "creditSharedKey");
+  if (!state.creditSharedKey) throw Error("Credit shared key must be positive");
+  if (state.payload !== void 0 && !(state.payload instanceof Uint8Array))
+    throw TypeError("payload must be Uint8Array");
+  return {
+    ...state,
+    ...normalizeCreditPolicy(state),
+    ...normalizeCreditUsage(state),
+    ...balance(state),
+    ...state.payload !== void 0 ? { payload: Uint8Array.from(state.payload) } : {}
+  };
+}
+async function computeCreditCommitment(state, keyHash) {
+  if (keyHash === void 0) state = normalizeCreditState(state);
+  for (const [name, bits] of [
+    ["chainId", 64],
+    ["protocolAddress", 160],
+    ["tokenAddress", 160],
+    ["revocationShard", 64],
+    ["revocationSlot", 16],
+    ["expiry", 64]
+  ])
+    uint(state[name], bits, name);
+  for (const identity2 of [state.spenderWalletIdentity, state.ownerWalletIdentity])
+    if (!/^0x[0-9a-fA-F]{40}$/.test(identity2) || BigInt(identity2) === 0n)
+      throw new Error("invalid Credit identity");
+  if (state.revocationShard === 0n || state.expiry === 0n)
+    throw new Error("Credit shard and expiry must be positive");
+  field2(state.nonce, "nonce");
+  const hash3 = keyHash ?? await computeCreditSharedKeyHash(state.creditSharedKey);
+  field2(BigInt(hash3), "Credit shared key hash");
+  return poseidonHash([
+    D_CREDIT,
+    state.chainId,
+    state.protocolAddress,
+    BigInt(state.spenderWalletIdentity),
+    BigInt(state.ownerWalletIdentity),
+    state.tokenAddress,
+    state.revocationShard,
+    state.revocationSlot,
+    state.nonce,
+    state.expiry,
+    BigInt(hash3),
+    ...CREDIT_POLICY_FIELDS.map((k) => normalizeCreditPolicy(state)[k]),
+    balance(state).availableCredit,
+    state.unlimited ? 1n : 0n,
+    ...CREDIT_USAGE_FIELDS.map((k) => normalizeCreditUsage(state)[k])
+  ]);
+}
+async function computeCreditNullifier(chainId, creditSharedKey, creditCommitment2) {
+  uint(chainId, 64, "chainId");
+  if (creditSharedKey <= 0n || creditSharedKey >= FIELD_MODULUS)
+    throw new RangeError("invalid Credit shared key");
+  if (!/^0x[0-9a-fA-F]{64}$/.test(creditCommitment2))
+    throw new Error("invalid Credit commitment encoding");
+  return poseidonHash([D_CNULL, chainId, creditSharedKey, BigInt(creditCommitment2)]);
+}
+async function deriveCreditStateNonce(chainId, protocolAddress, tokenAddress, creditNullifier, creditSharedKey) {
+  return BigInt(
+    await poseidonHash([
+      D_CREDIT_STATE_NONCE,
+      chainId,
+      protocolAddress,
+      tokenAddress,
+      creditNullifier,
+      creditSharedKey
+    ])
+  );
+}
+async function computeCreditRecoveryPad(chainId, protocolAddress, tokenAddress, creditNullifier, creditSharedKey) {
+  return BigInt(
+    await poseidonHash([
+      D_CREDIT_RECOVERY,
+      chainId,
+      protocolAddress,
+      tokenAddress,
+      creditNullifier,
+      creditSharedKey
+    ])
+  );
+}
+function uint(value, bits, name) {
+  if (typeof value !== "bigint" || value < 0n || value >= 1n << BigInt(bits))
+    throw new RangeError(`${name} out of uint${bits} range`);
+}
+function field2(value, name) {
+  if (typeof value !== "bigint" || value < 0n || value >= FIELD_MODULUS)
+    throw new RangeError(`${name} out of BN254 field range`);
+}
+async function recoverCreditState(context2, previous, recovery) {
+  assertNoteContext(previous, context2);
+  const nullifier = await computeCreditNullifier(
+    context2.chainId,
+    previous.creditSharedKey,
+    await computeCreditCommitment(previous)
+  );
+  if (nullifier.toLowerCase() !== recovery.creditNullifier.toLowerCase())
+    throw new Error("previous Credit nullifier mismatch");
+  field2(recovery.recoveryAmount, "recoveryAmount");
+  const args = [
+    context2.chainId,
+    context2.protocolAddress,
+    previous.tokenAddress,
+    BigInt(nullifier),
+    previous.creditSharedKey
+  ];
+  const nonce2 = await deriveCreditStateNonce(...args), mask = await computeCreditRecoveryPad(...args);
+  const debit = (recovery.recoveryAmount - mask + FIELD_MODULUS) % FIELD_MODULUS;
+  uint(debit, 126, "recovered debit");
+  if (!debit) throw new Error("invalid recovered debit");
+  if (nonce2 === previous.nonce) throw new Error("state nonce must change");
+  const { payload, ...financial } = previous;
+  const state = {
+    ...financial,
+    ...applyCreditDrawUsage(previous, debit, recovery.timestamp),
+    nonce: nonce2
+  };
+  if (await computeCreditCommitment(state) !== recovery.stateCommitment)
+    throw new Error("recovered Credit commitment mismatch");
+  return state;
+}
+async function deriveCreditState(previous, debit, timestamp) {
+  const nullifier = await computeCreditNullifier(
+    previous.chainId,
+    previous.creditSharedKey,
+    await computeCreditCommitment(previous)
+  );
+  const args = [
+    previous.chainId,
+    previous.protocolAddress,
+    previous.tokenAddress,
+    BigInt(nullifier),
+    previous.creditSharedKey
+  ];
+  const nonce2 = await deriveCreditStateNonce(...args), mask = await computeCreditRecoveryPad(...args);
+  if (nonce2 === previous.nonce) throw Error("state nonce must change");
+  const state = { ...previous, ...applyCreditDrawUsage(previous, debit, timestamp), nonce: nonce2 };
+  return {
+    state,
+    stateCommitment: await computeCreditCommitment(state),
+    nullifier,
+    recoveryAmount: (debit + mask) % FIELD_MODULUS
+  };
+}
+async function deriveCreditUpdate(previous, changes, deadline) {
+  for (const key of Object.keys(changes))
+    if (![
+      ...CREDIT_POLICY_FIELDS,
+      "expiry",
+      "unlimited",
+      "increaseAvailableCredit",
+      "decreaseAvailableCredit"
+    ].includes(key))
+      throw Error("unsupported Credit update field");
+  const old = normalizeCreditState(previous), increase = changes.increaseAvailableCredit === void 0 ? 0n : changes.increaseAvailableCredit, decrease = changes.decreaseAvailableCredit === void 0 ? 0n : changes.decreaseAvailableCredit;
+  uint(increase, 128, "increaseAvailableCredit");
+  uint(decrease, 128, "decreaseAvailableCredit");
+  if (increase !== 0n && decrease !== 0n)
+    throw Error("Credit increase and decrease are mutually exclusive");
+  const unlimited = changes.unlimited === void 0 ? old.unlimited : changes.unlimited;
+  if (typeof unlimited !== "boolean") throw TypeError("unlimited must be boolean");
+  let availableCredit = 0n;
+  if (unlimited) {
+    if (increase !== 0n || decrease !== 0n)
+      throw Error("unlimited update cannot adjust available credit");
+  } else {
+    if (decrease > old.availableCredit)
+      throw Error("available credit decrease exceeds balance");
+    availableCredit = old.availableCredit + increase - decrease;
+    uint(availableCredit, 128, "availableCredit");
+  }
+  uint(deadline, 64, "deadline");
+  const next = {
+    ...old,
+    ...normalizeCreditPolicy({ ...old, ...changes }),
+    expiry: changes.expiry ?? old.expiry,
+    availableCredit,
+    unlimited
+  };
+  if (previous.expiry < deadline || next.expiry < deadline)
+    throw Error("expiry before request deadline");
+  const nullifier = await computeCreditNullifier(
+    previous.chainId,
+    previous.creditSharedKey,
+    await computeCreditCommitment(previous)
+  );
+  const nonce2 = await deriveCreditStateNonce(
+    previous.chainId,
+    previous.protocolAddress,
+    previous.tokenAddress,
+    BigInt(nullifier),
+    previous.creditSharedKey
+  );
+  if (nonce2 === previous.nonce) throw Error("state nonce must change");
+  const state = { ...next, nonce: nonce2 };
+  return { state, nullifier, stateCommitment: await computeCreditCommitment(state) };
+}
+
+// src/delivery/note-payload.ts
+function concat(...parts) {
+  const out = new Uint8Array(parts.reduce((length, part) => length + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function uint2(value, bits, name) {
+  if (value < 0n || value >= 1n << BigInt(bits))
+    throw new RangeError(`${name} out of uint${bits} range`);
+}
+function encode2(value, length = 32) {
+  uint2(value, length * 8, "encoded value");
+  const out = new Uint8Array(length);
+  for (let i = length - 1; i >= 0; i--) {
+    out[i] = Number(value & 255n);
+    value >>= 8n;
+  }
+  return out;
+}
+function decode(value) {
+  return value.reduce((result, byte) => result << 8n | BigInt(byte), 0n);
+}
+function hexField(value) {
+  uint2(value, 160, "owner address");
+  return `0x${value.toString(16).padStart(40, "0")}`;
+}
+function receivingKeys2(keys) {
+  if (!keys || !(keys.viewingPublicKey instanceof Uint8Array) || !(keys.clueKey instanceof Uint8Array))
+    throw new Error("receiving keys required");
+  const viewingPublicKey2 = Uint8Array.from(keys.viewingPublicKey), clueKey = Uint8Array.from(keys.clueKey);
+  if (viewingPublicKey2.length !== 33 || viewingPublicKey2[0] !== 2 && viewingPublicKey2[0] !== 3)
+    throw new Error("invalid compressed viewing public key");
+  import_secp256k12.secp256k1.ProjectivePoint.fromHex(viewingPublicKey2).assertValidity();
+  if (clueKey.length !== 32) throw new Error("invalid clue key length");
+  validateClueKey(clueKey);
+  return { viewingPublicKey: viewingPublicKey2, clueKey };
+}
+function normalizeCreditDeliveryState(state) {
+  if (!state || typeof state !== "object" || !state.note || typeof state.note !== "object")
+    throw new TypeError("complete Credit delivery state required");
+  const allowed = [
+    "chainId",
+    "protocolAddress",
+    "tokenAddress",
+    "spenderWalletIdentity",
+    "ownerWalletIdentity",
+    "revocationShard",
+    "revocationSlot",
+    "nonce",
+    "expiry",
+    "creditSharedKey",
+    "singleLimit",
+    "dailyLimit",
+    "monthlyLimit",
+    "availableCredit",
+    "unlimited",
+    "lastDay",
+    "dailySpent",
+    "lastMonth",
+    "monthlySpent",
+    "totalSpent",
+    "payload"
+  ];
+  if (Object.keys(state.note).some((k) => !allowed.includes(k)))
+    throw Error("Unsupported Credit fields");
+  const note = normalizeCreditState(structuredClone(state.note));
+  return {
+    note: {
+      ...note,
+      ...normalizeCreditPolicy(note)
+    },
+    ownerReceivingKeys: receivingKeys2(state.ownerReceivingKeys),
+    spenderReceivingKeys: receivingKeys2(state.spenderReceivingKeys)
+  };
+}
+function encodePayload(value) {
+  if (value !== void 0 && !(value instanceof Uint8Array))
+    throw new TypeError("payload must be Uint8Array");
+  const payload = value ?? new Uint8Array();
+  if (payload.length > 65535) throw new RangeError("payload length exceeds uint16");
+  return concat(encode2(BigInt(payload.length), 2), payload);
+}
+function readPayload(plain, offset) {
+  if (plain.length < offset + 2) throw new Error("missing payload length");
+  const length = Number(decode(plain.slice(offset, offset + 2)));
+  if (plain.length !== offset + 2 + length) throw new Error("invalid payload length");
+  return Uint8Array.from(plain.subarray(offset + 2));
+}
+var fundsEnvelopeV1 = {
+  kind: "funds",
+  version: 1,
+  minimum: 160,
+  maximum: 4096,
+  encode(note) {
+    return concat(
+      encode2(BigInt(note.ownerAddress)),
+      encode2(note.amount, 16),
+      encode2(note.nonce),
+      encodePayload(note.payload)
+    );
+  },
+  decode(plain, context2) {
+    return {
+      chainId: context2.chainId,
+      protocolAddress: context2.protocolAddress,
+      tokenAddress: context2.tokenAddress,
+      ownerAddress: hexField(decode(plain.slice(0, 32))),
+      amount: decode(plain.slice(32, 48)),
+      nonce: decode(plain.slice(48, 80)),
+      payload: readPayload(plain, 80)
+    };
+  }
+};
+var creditWireFields = [
+  ["spenderWalletIdentity", 32],
+  ["ownerWalletIdentity", 32],
+  ["revocationShard", 8],
+  ["revocationSlot", 2],
+  ["nonce", 32],
+  ["expiry", 8],
+  ["creditSharedKey", 32],
+  ["singleLimit", 16],
+  ["dailyLimit", 16],
+  ["monthlyLimit", 16],
+  ["availableCredit", 16],
+  ["unlimited", 1],
+  ["lastDay", 8],
+  ["dailySpent", 16],
+  ["lastMonth", 8],
+  ["monthlySpent", 16],
+  ["totalSpent", 16]
+];
+var creditEnvelopeV2 = {
+  kind: "credit",
+  version: 2,
+  minimum: 485,
+  maximum: 4096,
+  encode(input) {
+    const state = normalizeCreditDeliveryState(input);
+    return concat(
+      ...creditWireFields.map(([k, size]) => encode2(BigInt(state.note[k]), size)),
+      state.ownerReceivingKeys.viewingPublicKey,
+      state.ownerReceivingKeys.clueKey,
+      state.spenderReceivingKeys.viewingPublicKey,
+      state.spenderReceivingKeys.clueKey,
+      encodePayload(state.note.payload)
+    );
+  },
+  decode(plain, context2) {
+    let offset = 0;
+    const note = {
+      chainId: context2.chainId,
+      protocolAddress: context2.protocolAddress,
+      tokenAddress: context2.tokenAddress
+    };
+    for (const [k, size] of creditWireFields) {
+      const n = decode(plain.slice(offset, offset + size));
+      if (k === "unlimited" && n !== 0n && n !== 1n)
+        throw Error("invalid Credit unlimited byte");
+      note[k] = k === "unlimited" ? n === 1n : k.endsWith("Identity") ? hexField(n) : n;
+      offset += size;
+    }
+    const keys = () => {
+      const k = {
+        viewingPublicKey: plain.slice(offset, offset + 33),
+        clueKey: plain.slice(offset + 33, offset + 65)
+      };
+      offset += 65;
+      return k;
+    };
+    const ownerReceivingKeys = keys(), spenderReceivingKeys = keys();
+    note.payload = readPayload(plain, offset);
+    return normalizeCreditDeliveryState({
+      note,
+      ownerReceivingKeys,
+      spenderReceivingKeys
+    });
+  }
+};
+
+// src/delivery/delivery-codec.ts
+var MAX_CIPHERTEXT_BYTES = 4096;
+function deliveryHeader(kind) {
+  if (kind !== "funds" && kind !== "credit") throw new Error("unsupported delivery kind");
+  return kind === "credit" ? 130 : 1;
+}
+function decodeDeliveryHeader(header) {
+  if (!Number.isInteger(header) || header < 0 || header > 255)
+    throw new Error("delivery header must be one byte");
+  const kind = header >>> 7 ? "credit" : "funds";
+  const version = header & 127;
+  if (version === 0) throw new Error("invalid envelope version");
+  return { kind, version };
+}
+function deliveryCodec(header) {
+  const { kind, version } = decodeDeliveryHeader(header);
+  if (version !== (kind === "credit" ? 2 : 1))
+    throw new Error(`unsupported envelope version ${version}`);
+  const codec = kind === "funds" ? fundsEnvelopeV1 : creditEnvelopeV2;
+  return {
+    ...codec,
+    domain: `Invisi.${kind === "funds" ? "Note" : "Credit"}Delivery.v${kind === "credit" ? 2 : 1}`
+  };
+}
+function validateDeliveryCiphertext(value, kind) {
+  const data = Uint8Array.from((0, import_ethers2.getBytes)(value));
+  if (data.length === 0 || data.length > MAX_CIPHERTEXT_BYTES)
+    throw new Error("invalid envelope length");
+  const codec = deliveryCodec(data[0]);
+  if (kind !== void 0 && codec.kind !== kind) throw new Error("unexpected envelope kind");
+  if (data.length < codec.minimum || data.length > codec.maximum)
+    throw new Error("invalid envelope length");
+  return data;
+}
+
+// src/delivery/errors.ts
+var DeliveryAuthenticationError = class extends Error {
+  constructor(cause) {
+    super("delivery authentication failed", { cause });
+    this.name = "DeliveryAuthenticationError";
+  }
+};
+
+// src/delivery/envelope.ts
+var import_secp256k13 = require("@noble/curves/secp256k1");
+
+// src/delivery/binary.ts
+var ascii = (value) => Uint8Array.from(value, (character) => character.charCodeAt(0));
+function concat2(...parts) {
+  const out = new Uint8Array(parts.reduce((size, p) => size + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function bytes(value, length) {
+  let out;
+  if (typeof value === "string") {
+    if (!/^0x(?:[0-9a-fA-F]{2})*$/.test(value)) throw new Error("invalid hexadecimal bytes");
+    out = Uint8Array.from(value.slice(2).match(/../g) ?? [], (b) => parseInt(b, 16));
+  } else if (value instanceof Uint8Array) out = Uint8Array.from(value);
+  else throw new Error("expected hexadecimal bytes or Uint8Array");
+  if (out.length !== length) throw new Error(`expected ${length} bytes`);
+  return out;
+}
+function uint3(value, bits, name) {
+  if (value < 0n || value >= 1n << BigInt(bits))
+    throw new RangeError(`${name} out of uint${bits} range`);
+}
+function field3(value, name) {
+  if (value < 0n || value >= FIELD_MODULUS)
+    throw new RangeError(`${name} out of BN254 field range`);
+}
+function encode3(value, length = 32) {
+  uint3(value, length * 8, "encoded value");
+  const out = new Uint8Array(length);
+  for (let i = length - 1; i >= 0; i--) {
+    out[i] = Number(value & 255n);
+    value >>= 8n;
+  }
+  return out;
+}
+
+// src/notes/commitment.ts
+async function computeNoteIdentity(ownerAddress, nonce2) {
+  if (ownerAddress <= 0n || ownerAddress >= 1n << 160n)
+    throw new RangeError("invalid owner address");
+  return poseidonHash([D_IDENT, ownerAddress, nonce2]);
+}
+async function computeNoteCommitment(chainId, protocolAddress, identity2, tokenAddress, amount) {
+  if (chainId < 0n || chainId >= 1n << 64n) throw new RangeError("invalid chainId");
+  if (protocolAddress <= 0n || protocolAddress >= 1n << 160n)
+    throw new RangeError("invalid protocol address");
+  if (tokenAddress < 0n || tokenAddress >= 1n << 160n)
+    throw new RangeError("invalid token address");
+  if (amount <= 0n || amount >= 1n << 128n) throw new RangeError("invalid note amount");
+  if (!/^0x[0-9a-fA-F]{64}$/.test(identity2)) throw new Error("invalid note identity encoding");
+  return poseidonHash([D_NOTE, chainId, protocolAddress, BigInt(identity2), tokenAddress, amount]);
+}
+
+// src/delivery/validation.ts
+function validateContext(context2, tokenAddress) {
+  uint3(context2.chainId, 64, "chainId");
+  uint3(context2.protocolAddress, 160, "protocolAddress");
+  uint3(tokenAddress, 160, "tokenAddress");
+  field3(BigInt(context2.outputCommitment), "outputCommitment");
+}
+function validateNote(note) {
+  uint3(note.amount, 128, "amount");
+  if (note.amount === 0n) throw new Error("amount must be positive");
+  field3(note.nonce, "nonce");
+  uint3(BigInt(note.ownerAddress), 160, "ownerAddress");
+  if (BigInt(note.ownerAddress) === 0n) throw new Error("owner address must be positive");
+  uint3(note.tokenAddress, 160, "tokenAddress");
+}
+async function noteCommitment(context2, note) {
+  validateContext(context2, note.tokenAddress);
+  assertNoteContext(note, context2);
+  validateNote(note);
+  const commitment2 = await computeNoteCommitment(
+    context2.chainId,
+    BigInt(context2.protocolAddress),
+    await computeNoteIdentity(BigInt(note.ownerAddress), note.nonce),
+    note.tokenAddress,
+    note.amount
+  );
+  if (BigInt(commitment2) !== BigInt(context2.outputCommitment))
+    throw new Error("output commitment mismatch");
+}
+async function creditCommitment(context2, note) {
+  validateContext(context2, note.tokenAddress);
+  assertNoteContext(note, context2);
+  const commitment2 = await computeCreditCommitment(note);
+  if (BigInt(commitment2) !== BigInt(context2.outputCommitment))
+    throw new Error("credit commitment mismatch");
+}
+
+// src/delivery/envelope.ts
+function aad(domain, context2, tokenAddress, header, role) {
+  validateContext(context2, tokenAddress);
+  return concat2(
+    domain,
+    header,
+    new Uint8Array([role]),
+    encode3(context2.chainId, 8),
+    encode3(context2.protocolAddress, 20),
+    encode3(tokenAddress, 20),
+    encode3(BigInt(context2.outputCommitment))
+  );
+}
+function privateKey(value) {
+  const key = bytes(value, 32);
+  if (!import_secp256k13.secp256k1.utils.isValidPrivateKey(key)) throw new Error("invalid viewing private key");
+  return key;
+}
+function publicKey(value) {
+  const key = bytes(value, 33);
+  if (key[0] !== 2 && key[0] !== 3) throw new Error("expected compressed secp256k1 public key");
+  import_secp256k13.secp256k1.ProjectivePoint.fromHex(key);
+  return key;
+}
+function viewingPublicKey(key) {
+  return import_secp256k13.secp256k1.getPublicKey(privateKey(key), true);
+}
+function random(length) {
+  return crypto.getRandomValues(new Uint8Array(length));
+}
+function ephemeralKey() {
+  for (; ; ) {
+    const key = random(32);
+    if (import_secp256k13.secp256k1.utils.isValidPrivateKey(key)) return key;
+  }
+}
+var buffer = (value) => Uint8Array.from(value).buffer;
+async function derivedKey(key, peer, header, recipient, domain, extractable = false) {
+  const secret = import_secp256k13.secp256k1.getSharedSecret(key, peer, true).slice(1);
+  const material = await crypto.subtle.importKey("raw", buffer(secret), "HKDF", false, [
+    "deriveKey"
+  ]);
+  try {
+    return await crypto.subtle.deriveKey(
+      {
+        name: "HKDF",
+        hash: "SHA-256",
+        salt: buffer(header.slice(34, 50)),
+        info: buffer(concat2(domain, header.slice(1, 34), recipient))
+      },
+      material,
+      { name: "AES-GCM", length: 256 },
+      extractable,
+      ["encrypt", "decrypt"]
+    );
+  } finally {
+    secret.fill(0);
+  }
+}
+async function seal(viewingKey, plaintext, context2, tokenAddress, headerByte, role) {
+  const peer = publicKey(viewingKey), key = ephemeralKey();
+  const salt = random(16), iv = random(12), domain = deliveryDomain(headerByte);
+  const header = concat2(
+    new Uint8Array([headerByte]),
+    import_secp256k13.secp256k1.getPublicKey(key, true),
+    salt,
+    iv
+  );
+  const additionalData = aad(domain, context2, tokenAddress, header, role);
+  try {
+    const encrypted = await crypto.subtle.encrypt(
+      {
+        name: "AES-GCM",
+        iv: buffer(iv),
+        additionalData: buffer(additionalData),
+        tagLength: 128
+      },
+      await derivedKey(key, peer, header, peer, domain),
+      buffer(plaintext)
+    );
+    return concat2(header, new Uint8Array(encrypted));
+  } finally {
+    key.fill(0);
+    plaintext.fill(0);
+  }
+}
+async function open(key, envelope, context2, headerByte, role, payloadKey = false) {
+  const data = envelopeBytes(envelope, deliveryCodec(headerByte).kind === "credit");
+  if (data[0] !== headerByte) throw new Error("unsupported envelope version");
+  const domain = deliveryDomain(headerByte);
+  const additionalData = aad(domain, context2, context2.tokenAddress, data.slice(0, 62), role);
+  const localKey = payloadKey ? bytes(key, 32) : privateKey(key);
+  try {
+    const aes = payloadKey ? await crypto.subtle.importKey("raw", buffer(bytes(key, 32)), "AES-GCM", false, [
+      "decrypt"
+    ]) : await derivedKey(
+      localKey,
+      publicKey(data.slice(1, 34)),
+      data.slice(0, 62),
+      import_secp256k13.secp256k1.getPublicKey(localKey, true),
+      domain
+    );
+    const decrypted = await crypto.subtle.decrypt(
+      {
+        name: "AES-GCM",
+        iv: buffer(data.slice(50, 62)),
+        additionalData: buffer(additionalData),
+        tagLength: 128
+      },
+      aes,
+      buffer(data.slice(62))
+    ).catch((error) => {
+      if (error instanceof Error && error.name === "OperationError")
+        throw new DeliveryAuthenticationError(error);
+      throw error;
+    });
+    return new Uint8Array(decrypted);
+  } finally {
+    localKey.fill(0);
+  }
+}
+function deliveryDomain(headerByte) {
+  return ascii(deliveryCodec(headerByte).domain);
+}
+async function exportPayloadKey(key, envelope, credit) {
+  const data = envelopeBytes(envelope, credit);
+  const localKey = privateKey(key);
+  try {
+    const aes = await derivedKey(
+      localKey,
+      publicKey(data.slice(1, 34)),
+      data.slice(0, 62),
+      viewingPublicKey(localKey),
+      deliveryDomain(data[0]),
+      true
+    );
+    return new Uint8Array(await crypto.subtle.exportKey("raw", aes));
+  } finally {
+    localKey.fill(0);
+  }
+}
+function envelopeBytes(value, credit) {
+  return validateDeliveryCiphertext(value, credit ? "credit" : "funds");
+}
+
+// src/delivery/encryption.ts
+function copyPayload(value, codec) {
+  if (!(value instanceof Uint8Array)) throw new Error("codec encode must return Uint8Array");
+  if (value.length + 78 < codec.minimum || value.length + 78 > codec.maximum)
+    throw new Error("invalid codec payload length");
+  return Uint8Array.from(value);
+}
+async function encryptPrivateTransferNote(viewingKey, note, context2) {
+  const scopedNote = structuredClone(note), scopedContext = { ...context2 };
+  const codec = deliveryCodec(deliveryHeader("funds"));
+  if (codec.kind !== "funds") throw new Error("unexpected envelope kind");
+  await noteCommitment(scopedContext, scopedNote);
+  const plaintext = copyPayload(codec.encode(structuredClone(scopedNote)), codec);
+  return seal(
+    viewingKey,
+    plaintext,
+    scopedContext,
+    scopedNote.tokenAddress,
+    deliveryHeader("funds"),
+    0
+  );
+}
+async function readNote(key, envelope, context2, payloadKey = false) {
+  const authenticatedContext = { ...context2 };
+  const data = envelopeBytes(envelope, false);
+  const headerByte = data[0];
+  const plain = await open(key, data, authenticatedContext, headerByte, 0, payloadKey);
+  try {
+    const codec = deliveryCodec(headerByte);
+    if (codec.kind !== "funds") throw new Error("unexpected envelope kind");
+    const note = structuredClone(
+      codec.decode(plain, Object.freeze({ ...authenticatedContext }))
+    );
+    if (BigInt(note.ownerAddress) !== BigInt(authenticatedContext.ownerAddress))
+      throw new Error("recipient owner address mismatch");
+    if (note.tokenAddress !== authenticatedContext.tokenAddress)
+      throw new Error("note token context mismatch");
+    await noteCommitment(authenticatedContext, note);
+    return note;
+  } finally {
+    plain.fill(0);
+  }
+}
+function creditRole(role) {
+  if (role !== "owner" && role !== "spender")
+    throw new Error("Credit role must be owner or spender");
+  return role === "owner" ? 1 : 2;
+}
+function matchCreditRecipient(state, role, recipient) {
+  const keys = role === "owner" ? state.ownerReceivingKeys : state.spenderReceivingKeys;
+  if (!keys.viewingPublicKey.every((value, index) => value === recipient[index]))
+    throw new Error("recipient receiving key mismatch");
+}
+async function encryptCreditState(viewingKey, state, context2) {
+  const scopedState = normalizeCreditDeliveryState(state), scopedNote = scopedState.note;
+  const scopedContext = { ...context2 };
+  const codec = deliveryCodec(deliveryHeader("credit"));
+  if (codec.kind !== "credit") throw new Error("unexpected envelope kind");
+  creditRole(scopedContext.role);
+  matchCreditRecipient(scopedState, scopedContext.role, publicKey(viewingKey));
+  await creditCommitment(scopedContext, scopedNote);
+  const plaintext = copyPayload(codec.encode(structuredClone(scopedState)), codec);
+  return seal(
+    viewingKey,
+    plaintext,
+    scopedContext,
+    scopedNote.tokenAddress,
+    deliveryHeader("credit"),
+    creditRole(scopedContext.role)
+  );
+}
+async function readCredit(key, envelope, context2, payloadKey = false) {
+  const authenticatedContext = { ...context2 };
+  const data = envelopeBytes(envelope, true);
+  const plain = await open(
+    key,
+    data,
+    authenticatedContext,
+    data[0],
+    creditRole(authenticatedContext.role),
+    payloadKey
+  );
+  try {
+    const codec = deliveryCodec(data[0]);
+    if (codec.kind !== "credit") throw new Error("unexpected envelope kind");
+    const state = normalizeCreditDeliveryState(
+      structuredClone(codec.decode(plain, Object.freeze({ ...authenticatedContext })))
+    );
+    const note = state.note;
+    if (BigInt(
+      authenticatedContext.role === "owner" ? note.ownerWalletIdentity : note.spenderWalletIdentity
+    ) !== BigInt(authenticatedContext.ownerAddress))
+      throw new Error("recipient owner address mismatch");
+    if (!payloadKey)
+      matchCreditRecipient(state, authenticatedContext.role, viewingPublicKey(key));
+    if (note.tokenAddress !== authenticatedContext.tokenAddress)
+      throw new Error("Credit token context mismatch");
+    await creditCommitment(authenticatedContext, note);
+    return {
+      ...state,
+      note: { ...state.note, payload: Uint8Array.from(state.note.payload ?? []) }
+    };
+  } finally {
+    plain.fill(0);
+  }
+}
+function decryptPrivateTransferNote(key, envelope, context2) {
+  return readNote(key, envelope, context2);
+}
+function decryptCreditState(key, envelope, context2) {
+  return readCredit(key, envelope, context2);
+}
+function decryptNotePayload(key, envelope, context2) {
+  return readNote(key, envelope, context2, true);
+}
+function decryptCreditPayload(key, envelope, context2) {
+  return readCredit(key, envelope, context2, true);
+}
+
+// src/disclosure/disclosure.ts
+var import_utils3 = require("@noble/hashes/utils");
+var NOTE_FIELDS = ["ownerAddress", "amount", "nonce"];
+var CREDIT_FIELDS = [
+  "spenderWalletIdentity",
+  "ownerWalletIdentity",
+  "revocationShard",
+  "revocationSlot",
+  "nonce",
+  "expiry",
+  "creditSharedKeyHash",
+  "singleLimit",
+  "dailyLimit",
+  "monthlyLimit",
+  "availableCredit",
+  "unlimited",
+  "lastDay",
+  "dailySpent",
+  "lastMonth",
+  "monthlySpent",
+  "totalSpent"
+];
+function record(value, fields) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("invalid disclosure object");
+  const keys = Object.keys(value);
+  if (keys.length !== fields.length || keys.some((key) => !fields.includes(key)))
+    throw new Error("unexpected disclosure fields");
+  return value;
+}
+function number(value, bits, label) {
+  if (typeof value !== "bigint" || value < 0n || value >= 1n << BigInt(bits))
+    throw new Error(`invalid disclosure ${label}`);
+  return value;
+}
+function decimal(value, bits, label) {
+  if (typeof value !== "string" || !/^(0|[1-9][0-9]*)$/.test(value) || value.length > 78)
+    throw new Error(`invalid disclosure ${label}`);
+  return number(BigInt(value), bits, label);
+}
+function hash2(value, label, field4 = true) {
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(value))
+    throw new Error(`invalid disclosure ${label}`);
+  if (field4 && BigInt(value) >= FIELD_MODULUS) throw new Error(`invalid disclosure ${label}`);
+  return value.toLowerCase();
+}
+function owner(value, label) {
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value) || BigInt(value) === 0n)
+    throw new Error(`invalid disclosure ${label}`);
+  return value.toLowerCase();
+}
+function nonce(value) {
+  if (value < 0n || value >= FIELD_MODULUS) throw new Error("invalid disclosure nonce");
+  return value;
+}
+function context(value) {
+  const result = {
+    chainId: number(value.chainId, 64, "chainId"),
+    protocolAddress: number(value.protocolAddress, 160, "protocolAddress"),
+    tokenAddress: number(value.tokenAddress, 160, "tokenAddress")
+  };
+  if (result.protocolAddress === 0n || result.tokenAddress === 0n)
+    throw new Error("disclosure addresses must be nonzero");
+  return result;
+}
+function encode4(values) {
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => [key, value.toString()])
+  );
+}
+async function creditOpening(note) {
+  const copied = { ...note };
+  return {
+    ...context(copied),
+    ...normalizeCreditPolicy(copied),
+    ...normalizeCreditUsage(copied),
+    availableCredit: number(copied.availableCredit, 128, "availableCredit"),
+    unlimited: copied.unlimited,
+    spenderWalletIdentity: owner(copied.spenderWalletIdentity, "spender identity"),
+    ownerWalletIdentity: owner(copied.ownerWalletIdentity, "owner identity"),
+    revocationShard: number(copied.revocationShard, 64, "revocation shard"),
+    revocationSlot: number(copied.revocationSlot, 16, "revocation slot"),
+    nonce: nonce(copied.nonce),
+    expiry: number(copied.expiry, 64, "expiry"),
+    creditSharedKeyHash: await computeCreditSharedKeyHash(copied.creditSharedKey)
+  };
+}
+async function commitment(note) {
+  if ("creditSharedKeyHash" in note) {
+    return computeCreditCommitment({ ...note, creditSharedKey: 0n }, note.creditSharedKeyHash);
+  }
+  return computeNoteCommitment(
+    note.chainId,
+    BigInt(note.protocolAddress),
+    await computeNoteIdentity(BigInt(note.ownerAddress), note.nonce),
+    note.tokenAddress,
+    note.amount
+  );
+}
+var Disclosure = class _Disclosure {
+  #material;
+  constructor(material) {
+    this.#material = {
+      ...material,
+      context: Object.freeze({ ...material.context }),
+      data: Object.freeze({ ...material.data })
+    };
+    Object.freeze(this.#material);
+    Object.freeze(this);
+  }
+  static async fromNote(value) {
+    const copied = { ...value };
+    const note = {
+      ...context(copied),
+      ownerAddress: owner(copied.ownerAddress, "owner address"),
+      amount: number(copied.amount, 128, "amount"),
+      nonce: nonce(copied.nonce)
+    };
+    return new _Disclosure({
+      version: 1,
+      kind: "note",
+      method: "opening",
+      context: {
+        ...encode4(context(note)),
+        outputCommitment: await commitment(note)
+      },
+      data: encode4({
+        ownerAddress: note.ownerAddress,
+        amount: note.amount,
+        nonce: note.nonce
+      })
+    });
+  }
+  static async fromCredit(value) {
+    const note = await creditOpening(value);
+    const data = Object.fromEntries(
+      CREDIT_FIELDS.map((key) => [
+        key,
+        key === "unlimited" ? note.unlimited ? "1" : "0" : note[key].toString()
+      ])
+    );
+    return new _Disclosure({
+      version: 1,
+      kind: "credit",
+      method: "opening",
+      context: {
+        ...encode4(context(note)),
+        outputCommitment: await commitment(note)
+      },
+      data
+    });
+  }
+  /** Low-level factory; normally use wallet.getViewer().discloseNote(). */
+  static async fromEncryptedNote(key, envelope, value) {
+    const scoped = { ...value };
+    const copied = typeof envelope === "string" ? envelope : Uint8Array.from(envelope);
+    const localKey = typeof key === "string" ? key : Uint8Array.from(key);
+    try {
+      await decryptPrivateTransferNote(localKey, copied, scoped);
+      return await _Disclosure.fromEnvelope(localKey, copied, scoped, "funds");
+    } finally {
+      if (localKey instanceof Uint8Array) localKey.fill(0);
+    }
+  }
+  /** Exposes the full selected Credit envelope, including its shared key and receiving snapshots. */
+  static async fromEncryptedCredit(key, envelope, value) {
+    const scoped = { ...value };
+    const copied = typeof envelope === "string" ? envelope : Uint8Array.from(envelope);
+    const localKey = typeof key === "string" ? key : Uint8Array.from(key);
+    try {
+      await decryptCreditState(localKey, copied, scoped);
+      return await _Disclosure.fromEnvelope(localKey, copied, scoped, scoped.role);
+    } finally {
+      if (localKey instanceof Uint8Array) localKey.fill(0);
+    }
+  }
+  static async fromEnvelope(key, envelope, scoped, role) {
+    const payloadKey = await exportPayloadKey(key, envelope, role !== "funds");
+    try {
+      return new _Disclosure({
+        version: 1,
+        kind: role === "funds" ? "note" : "credit",
+        method: "payload-key",
+        context: {
+          ...encode4(context(scoped)),
+          outputCommitment: hash2(scoped.outputCommitment, "commitment")
+        },
+        data: {
+          payloadKey: `0x${(0, import_utils3.bytesToHex)(payloadKey)}`,
+          ownerAddress: owner(scoped.ownerAddress, "owner address"),
+          role
+        }
+      });
+    } finally {
+      payloadKey.fill(0);
+    }
+  }
+  /** Parse untrusted JSON material; verification against an independent output is still required. */
+  static async fromExport(value) {
+    const root = record(value, ["version", "kind", "method", "context", "data"]);
+    if (root.version !== 1 || root.kind !== "note" && root.kind !== "credit" || root.method !== "opening" && root.method !== "payload-key")
+      throw new Error("unsupported disclosure format");
+    const rawContext = record(root.context, [
+      "chainId",
+      "protocolAddress",
+      "tokenAddress",
+      "outputCommitment"
+    ]);
+    const scoped = context({
+      chainId: decimal(rawContext.chainId, 64, "chainId"),
+      protocolAddress: decimal(rawContext.protocolAddress, 160, "protocolAddress"),
+      tokenAddress: decimal(rawContext.tokenAddress, 160, "tokenAddress")
+    });
+    const outputCommitment = hash2(rawContext.outputCommitment, "commitment");
+    const fields = root.method === "payload-key" ? ["payloadKey", "ownerAddress", "role"] : root.kind === "note" ? NOTE_FIELDS : CREDIT_FIELDS;
+    const raw = record(root.data, fields);
+    const data = {};
+    for (const key of fields) {
+      if (key === "role") {
+        if (root.kind === "note" ? raw[key] !== "funds" : raw[key] !== "owner" && raw[key] !== "spender")
+          throw new Error("invalid disclosure role");
+        data[key] = raw[key];
+      } else if (key === "payloadKey" || key.endsWith("Identity") || key === "ownerAddress" || key === "creditSharedKeyHash") {
+        data[key] = key.endsWith("Identity") || key === "ownerAddress" ? owner(raw[key], key) : hash2(raw[key], key, key !== "payloadKey");
+      } else if (key === "unlimited") {
+        if (raw[key] !== "0" && raw[key] !== "1")
+          throw Error("invalid disclosure unlimited");
+        data[key] = raw[key];
+      } else {
+        const bits = key === "availableCredit" ? 128 : key.endsWith("Payout") ? 160 : key === "expiry" ? 64 : key === "amount" ? root.kind === "note" ? 128 : 126 : 254;
+        const parsed = decimal(raw[key], bits, key);
+        if (key === "nonce") nonce(parsed);
+        data[key] = parsed.toString();
+      }
+    }
+    const material = {
+      version: 1,
+      kind: root.kind,
+      method: root.method,
+      context: { ...encode4(scoped), outputCommitment },
+      data
+    };
+    const result = new _Disclosure(material);
+    if (material.method === "opening")
+      await result.verify({
+        ...scoped,
+        outputCommitment,
+        role: material.kind === "note" ? "funds" : "owner"
+      });
+    return result;
+  }
+  getScope() {
+    const { version, kind, method } = this.#material;
+    return {
+      version,
+      kind,
+      method,
+      permitsOwnerSweep: kind === "note",
+      revealsNoteConsumption: kind === "note",
+      revealsCreditSharedKey: kind === "credit" && method === "payload-key",
+      revealsReceivingKeys: kind === "credit" && method === "payload-key",
+      revealsMemo: method === "payload-key",
+      revealsPayload: method === "payload-key"
+    };
+  }
+  /** Explicitly export sensitive, JSON-compatible material for a chosen recipient. */
+  export() {
+    return {
+      ...this.#material,
+      context: { ...this.#material.context },
+      data: { ...this.#material.data }
+    };
+  }
+  async verify(value) {
+    const output = {
+      ...value,
+      ciphertext: value.ciphertext instanceof Uint8Array ? Uint8Array.from(value.ciphertext) : value.ciphertext
+    };
+    const scoped = context(output);
+    const material = this.#material;
+    for (const field4 of ["chainId", "protocolAddress", "tokenAddress"]) {
+      if (scoped[field4].toString() !== material.context[field4])
+        throw new Error("disclosure deployment context mismatch");
+    }
+    if (hash2(output.outputCommitment, "commitment") !== material.context.outputCommitment)
+      throw new Error("disclosure output commitment mismatch");
+    if (material.kind === "note" ? output.role !== "funds" : output.role !== "owner" && output.role !== "spender")
+      throw new Error("disclosure output role mismatch");
+    const data = material.data;
+    if (material.method === "payload-key") {
+      if (output.role !== data.role || output.ciphertext === void 0)
+        throw new Error("disclosure requires the selected role envelope");
+      const decryption = {
+        ...scoped,
+        outputCommitment: output.outputCommitment,
+        ownerAddress: data.ownerAddress
+      };
+      if (material.kind === "note")
+        return {
+          kind: "note",
+          note: Object.freeze(
+            await decryptNotePayload(
+              data.payloadKey,
+              output.ciphertext,
+              decryption
+            )
+          )
+        };
+      const state = await decryptCreditPayload(
+        data.payloadKey,
+        output.ciphertext,
+        { ...decryption, role: output.role }
+      );
+      return {
+        kind: "credit",
+        note: Object.freeze({
+          ...await creditOpening(state.note),
+          ...state.note.payload === void 0 ? {} : { payload: structuredClone(state.note.payload) }
+        })
+      };
+    }
+    if (material.kind === "note") {
+      const note2 = {
+        ...scoped,
+        ownerAddress: data.ownerAddress,
+        amount: BigInt(data.amount),
+        nonce: BigInt(data.nonce)
+      };
+      if (await commitment(note2) !== material.context.outputCommitment)
+        throw new Error("disclosure opening commitment mismatch");
+      return { kind: "note", note: Object.freeze(note2) };
+    }
+    const note = {
+      ...scoped,
+      spenderWalletIdentity: data.spenderWalletIdentity,
+      ownerWalletIdentity: data.ownerWalletIdentity,
+      revocationShard: BigInt(data.revocationShard),
+      revocationSlot: BigInt(data.revocationSlot),
+      nonce: BigInt(data.nonce),
+      expiry: BigInt(data.expiry),
+      ...normalizeCreditPolicy(
+        Object.fromEntries(
+          ["singleLimit", "dailyLimit", "monthlyLimit"].map((k) => [k, BigInt(data[k])])
+        )
+      ),
+      ...normalizeCreditUsage(
+        Object.fromEntries(
+          ["lastDay", "dailySpent", "lastMonth", "monthlySpent", "totalSpent"].map(
+            (k) => [k, BigInt(data[k])]
+          )
+        )
+      ),
+      availableCredit: BigInt(data.availableCredit),
+      unlimited: data.unlimited === "1",
+      creditSharedKeyHash: data.creditSharedKeyHash
+    };
+    if (await commitment(note) !== material.context.outputCommitment)
+      throw new Error("disclosure opening commitment mismatch");
+    return { kind: "credit", note: Object.freeze(note) };
+  }
+  toJSON() {
+    return { capability: "disclosure", ...this.getScope() };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+};
+
+// src/notes/nullifier.ts
+async function computeNoteNullifier(chainId, protocolAddress, nonce2, commitment2) {
+  if (chainId < 0n || chainId >= 1n << 64n) throw new RangeError("invalid chainId");
+  if (protocolAddress <= 0n || protocolAddress >= 1n << 160n)
+    throw new RangeError("invalid protocol address");
+  if (nonce2 < 0n || nonce2 >= FIELD_MODULUS) throw new RangeError("invalid note nonce");
+  if (!/^0x[0-9a-fA-F]{64}$/.test(commitment2))
+    throw new Error("invalid note commitment encoding");
+  return poseidonHash([D_NULL, chainId, protocolAddress, nonce2, BigInt(commitment2)]);
+}
+
+// src/wallet/capabilities.ts
+var import_secp256k15 = require("@noble/curves/secp256k1");
+var import_utils5 = require("@noble/hashes/utils");
+
+// src/wallet/wallet.ts
+var import_secp256k14 = require("@noble/curves/secp256k1");
+var import_hkdf = require("@noble/hashes/hkdf");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_sha32 = require("@noble/hashes/sha3");
+var import_utils4 = require("@noble/hashes/utils");
+var OPERATIONS = {
+  transact: "Transact",
+  "create-credit": "CreateCredit",
+  "credit-draw": "CreditDraw",
+  "update-credit": "UpdateCredit"
+};
+var WALLET_AUTHORIZATION_TYPES = {
+  WalletAuthorization: [
+    { name: "operation", type: "bytes32" },
+    { name: "statementHash", type: "bytes32" }
+  ]
+};
+var hex = (value) => `0x${(0, import_utils4.bytesToHex)(value)}`;
+function bytes2(value, length) {
+  if (typeof value === "string" && !/^0x(?:[0-9a-fA-F]{2})*$/.test(value))
+    throw new Error("invalid hexadecimal bytes");
+  if (typeof value !== "string" && !(value instanceof Uint8Array))
+    throw new TypeError("expected bytes");
+  const result = typeof value === "string" ? (0, import_utils4.hexToBytes)(value.slice(2)) : Uint8Array.from(value);
+  if (length !== void 0 && result.length !== length)
+    throw new Error(`expected ${length} bytes`);
+  return result;
+}
+function word(value) {
+  if (value < 0n || value >= 1n << 256n) throw new RangeError("value exceeds uint256");
+  return (0, import_utils4.hexToBytes)(value.toString(16).padStart(64, "0"));
+}
+async function computeOwnerAddress(publicKey2) {
+  const point = import_secp256k14.secp256k1.ProjectivePoint.fromHex(bytes2(publicKey2));
+  point.assertValidity();
+  return hex((0, import_sha32.keccak_256)(point.toRawBytes(false).slice(1)).slice(12));
+}
+function walletAuthorizationTypedData(request) {
+  const { context: context2, operation, capacity, words } = request;
+  if (!Object.hasOwn(OPERATIONS, operation)) throw new Error("unsupported wallet operation");
+  const allowed = operation === "transact" ? [
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    20,
+    30,
+    40,
+    50,
+    60,
+    70,
+    80,
+    90,
+    100,
+    110,
+    120,
+    130,
+    140,
+    150,
+    160,
+    170,
+    180,
+    190
+  ] : operation === "credit-draw" ? [1, 2, 3, 4, 5, 10, 20, 30, 40, 50, 60, 70, 80] : [1];
+  if (!allowed.includes(capacity)) throw new Error("invalid operation capacity");
+  if (!Array.isArray(words) || words.length < 2) throw new Error("public words required");
+  for (const value of words)
+    if (typeof value !== "bigint" || value < 0n || value >= FIELD_MODULUS)
+      throw new RangeError("noncanonical public field");
+  const { chainId, protocolAddress } = context2;
+  if (typeof chainId !== "bigint" || chainId < 0n || chainId >= 1n << 64n)
+    throw new RangeError("invalid chain id");
+  if (typeof protocolAddress !== "bigint" || protocolAddress <= 0n || protocolAddress >= 1n << 160n)
+    throw new RangeError("invalid protocol address");
+  if (words[0] !== chainId) throw new Error("statement chain mismatch");
+  if (words[1] !== protocolAddress) throw new Error("statement instance mismatch");
+  const statement = (0, import_utils4.concatBytes)(
+    word(BigInt(capacity)),
+    word(64n),
+    word(BigInt(words.length)),
+    ...words.map(word)
+  );
+  return {
+    domain: {
+      name: "InvisibleProtocol",
+      version: "1",
+      chainId,
+      verifyingContract: `0x${protocolAddress.toString(16).padStart(40, "0")}`
+    },
+    types: WALLET_AUTHORIZATION_TYPES,
+    primaryType: "WalletAuthorization",
+    message: {
+      operation: hex(
+        (0, import_sha32.keccak_256)(
+          (0, import_utils4.utf8ToBytes)(
+            `Invisi.${OPERATIONS[operation]}.${operation === "transact" ? "v1" : "v4"}`
+          )
+        )
+      ),
+      statementHash: hex((0, import_sha32.keccak_256)(statement))
+    }
+  };
+}
+function computeWalletAuthorizationDigest(request) {
+  const data = walletAuthorizationTypedData(request), hashText = (text) => (0, import_sha32.keccak_256)((0, import_utils4.utf8ToBytes)(text));
+  const domain = (0, import_sha32.keccak_256)(
+    (0, import_utils4.concatBytes)(
+      hashText(
+        "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
+      ),
+      hashText(data.domain.name),
+      hashText(data.domain.version),
+      word(data.domain.chainId),
+      word(BigInt(data.domain.verifyingContract))
+    )
+  );
+  const structure = (0, import_sha32.keccak_256)(
+    (0, import_utils4.concatBytes)(
+      hashText("WalletAuthorization(bytes32 operation,bytes32 statementHash)"),
+      bytes2(data.message.operation),
+      bytes2(data.message.statementHash)
+    )
+  );
+  return hex((0, import_sha32.keccak_256)((0, import_utils4.concatBytes)(new Uint8Array([25, 1]), domain, structure)));
+}
+function signWalletAuthorization(privateKey2, request) {
+  return hex(
+    import_secp256k14.secp256k1.sign(bytes2(computeWalletAuthorizationDigest(request)), bytes2(privateKey2, 32), {
+      lowS: true
+    }).toCompactRawBytes()
+  );
+}
+async function verifyWalletAuthorization(expectedIdentity, publicKey2, signature, request) {
+  const raw = bytes2(signature, 64), digest = bytes2(computeWalletAuthorizationDigest(request));
+  if (await computeOwnerAddress(publicKey2) !== expectedIdentity) return false;
+  return import_secp256k14.secp256k1.verify(raw, digest, bytes2(publicKey2), { lowS: true });
+}
+async function buildWalletAuthorizationWitness(wallet, request) {
+  const publicKey2 = import_secp256k14.secp256k1.ProjectivePoint.fromHex(bytes2(wallet.spendingPublicKey)).toRawBytes(
+    false
+  );
+  const privateKey2 = bytes2(wallet.spendingPrivateKey, 32), identity2 = wallet.ownerAddress;
+  const statement = { ...request, context: { ...request.context }, words: [...request.words] };
+  try {
+    const derived = import_secp256k14.secp256k1.getPublicKey(privateKey2, false);
+    if (!derived.every((value, i) => value === publicKey2[i]))
+      throw new Error("spending key pair mismatch");
+    if (BigInt(await computeOwnerAddress(publicKey2)) !== BigInt(identity2))
+      throw new Error("owner address mismatch");
+    return {
+      public_key_x: Array.from(publicKey2.slice(1, 33)),
+      public_key_y: Array.from(publicKey2.slice(33)),
+      signature: Array.from(bytes2(signWalletAuthorization(privateKey2, statement), 64))
+    };
+  } finally {
+    privateKey2.fill(0);
+  }
+}
+
+// src/wallet/capabilities.ts
+var copyWitness = (witness) => ({
+  public_key_x: [...witness.public_key_x],
+  public_key_y: [...witness.public_key_y],
+  signature: [...witness.signature]
+});
+var inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+function copyBytes(value) {
+  if (typeof value === "string" && !/^0x(?:[0-9a-fA-F]{2})+$/.test(value)) {
+    throw new Error("invalid hexadecimal bytes");
+  }
+  return typeof value === "string" ? (0, import_utils5.hexToBytes)(value.slice(2)) : Uint8Array.from(value);
+}
+function identity(value) {
+  return ReceivingAddress.fromIdentity(value).ownerAddress;
+}
+var ViewingCapability = class {
+  #key;
+  ownerAddress;
+  constructor(ownerAddress, privateKey2, expectedPublicKey) {
+    this.ownerAddress = identity(ownerAddress);
+    this.#key = copyBytes(privateKey2);
+    const publicKey2 = viewingPublicKey(this.#key);
+    if (expectedPublicKey && (0, import_utils5.bytesToHex)(publicKey2) !== (0, import_utils5.bytesToHex)(expectedPublicKey)) {
+      throw new Error("viewing key pair mismatch");
+    }
+    Object.freeze(this);
+  }
+  decryptNote(envelope, context2) {
+    return decryptPrivateTransferNote(this.#key, envelope, {
+      ...context2,
+      ownerAddress: this.ownerAddress
+    });
+  }
+  decryptCredit(envelope, context2) {
+    return decryptCreditState(this.#key, envelope, {
+      ...context2,
+      ownerAddress: this.ownerAddress
+    });
+  }
+  getPublicKey() {
+    return viewingPublicKey(this.#key);
+  }
+  /** Disclose this authenticated output's payload key, without exporting the wallet viewing key. */
+  discloseNote(envelope, context2) {
+    return Disclosure.fromEncryptedNote(this.#key, envelope, {
+      ...context2,
+      ownerAddress: this.ownerAddress
+    });
+  }
+  /** Exposes the entire Credit envelope; prefer Disclosure.fromCredit() for hash-only opening. */
+  discloseCredit(envelope, context2) {
+    return Disclosure.fromEncryptedCredit(this.#key, envelope, {
+      ...context2,
+      ownerAddress: this.ownerAddress
+    });
+  }
+  /** Explicit sensitive export for delegating viewing. It grants note recovery and owner-only sweep permission. */
+  exportKey() {
+    return Uint8Array.from(this.#key);
+  }
+  toJSON() {
+    return { capability: "viewing", ownerAddress: this.ownerAddress };
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+};
+var Detector = class {
+  #key;
+  #clueKey;
+  constructor(key) {
+    this.#key = Uint8Array.from(key);
+    this.#clueKey = deriveClueKey(this.#key);
+    Object.freeze(this);
+  }
+  getClueKey() {
+    return Uint8Array.from(this.#clueKey);
+  }
+  /** Full detection delegation; the receiver chooses the checked prefix length. */
+  exportKey() {
+    return Uint8Array.from(this.#key);
+  }
+  toJSON() {
+    return { capability: "detection" };
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+};
+var NullifierCapability = class _NullifierCapability {
+  ownerAddress;
+  constructor(ownerAddress) {
+    this.ownerAddress = identity(ownerAddress);
+    Object.freeze(this);
+  }
+  static fromIdentity(ownerAddress) {
+    return new _NullifierCapability(ownerAddress);
+  }
+  compute(chainId, protocolAddress, commitment2, nonce2) {
+    return computeNoteNullifier(chainId, protocolAddress, nonce2, commitment2);
+  }
+  toJSON() {
+    return { capability: "nullifier", ownerAddress: this.ownerAddress };
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+};
+var AuthorizedStatement = class {
+  #witness;
+  digest;
+  ownerAddress;
+  constructor(ownerAddress, digest, witness) {
+    this.ownerAddress = ownerAddress;
+    this.digest = digest;
+    this.#witness = copyWitness(witness);
+    Object.freeze(this);
+  }
+  withWitness(assemble) {
+    return assemble(copyWitness(this.#witness));
+  }
+  toJSON() {
+    return { ownerAddress: this.ownerAddress, digest: this.digest };
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+};
+var WalletAuthorization = class _WalletAuthorization {
+  #privateKey;
+  #publicKey;
+  ownerAddress;
+  constructor(ownerAddress, privateKey2, publicKey2) {
+    this.ownerAddress = ownerAddress;
+    this.#privateKey = privateKey2;
+    this.#publicKey = publicKey2;
+    Object.freeze(this);
+  }
+  static async fromMaterial(ownerAddress, privateKey2) {
+    const privateBytes = copyBytes(privateKey2);
+    const publicBytes = import_secp256k15.secp256k1.getPublicKey(privateBytes, false);
+    if (await computeOwnerAddress(publicBytes) !== identity(ownerAddress)) {
+      throw new Error("owner address mismatch");
+    }
+    return new _WalletAuthorization(identity(ownerAddress), privateBytes, publicBytes);
+  }
+  getPublicKey() {
+    return Uint8Array.from(this.#publicKey);
+  }
+  async authorize(request) {
+    const frozen = { ...request, context: { ...request.context }, words: [...request.words] };
+    const digest = computeWalletAuthorizationDigest(frozen);
+    const witness = await buildWalletAuthorizationWitness(
+      {
+        ownerAddress: this.ownerAddress,
+        spendingPrivateKey: this.#privateKey,
+        spendingPublicKey: this.#publicKey
+      },
+      frozen
+    );
+    return new AuthorizedStatement(this.ownerAddress, digest, witness);
+  }
+  toJSON() {
+    return { capability: "wallet-authorization", ownerAddress: this.ownerAddress };
+  }
+  [inspect]() {
+    return this.toJSON();
+  }
+};
+
+// src/wallet/wallet-object.ts
+var WalletAddress = class {
+  #address;
+  constructor(address) {
+    this.#address = address;
+  }
+  get ownerAddress() {
+    return this.#address.ownerAddress;
+  }
+  get viewingPublicKey() {
+    return this.#address.viewingPublicKey;
+  }
+  get clueKey() {
+    return this.#address.clueKey;
+  }
+  /** Complete 0i receiving address. Owner-only wallets must first resolve their receiving keys. */
+  getAddress() {
+    if (this.#address.kind !== "long") {
+      throw new MissingCapabilityError("resolved receiving keys");
+    }
+    return this.#address.toString();
+  }
+  getReceivingAddress() {
+    return this.#address;
+  }
+  /** Nullifiers derive from public identity and do not grant spending authority. */
+  exportNullifier() {
+    return NullifierCapability.fromIdentity(this.ownerAddress);
+  }
+  toJSON() {
+    return { ownerAddress: this.ownerAddress, address: this.#address.toString() };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+};
+var Wallet = class _Wallet extends WalletAddress {
+  constructor(address) {
+    super(address);
+    Object.freeze(this);
+  }
+  /** Parse a complete 0i address or an EVM owner address without network access. */
+  static fromAddress(address) {
+    if (typeof address !== "string" && !(address instanceof ReceivingAddress)) {
+      throw new TypeError("expected a validated receiving address");
+    }
+    return new _Wallet(typeof address === "string" ? ReceivingAddress.parse(address) : address);
+  }
+};
+
+// src/delivery/memo.ts
+var MAX_MEMO_BYTES = 256;
+function encodeMemo(memo) {
+  if (memo === void 0) return new Uint8Array();
+  let encoded;
+  if (typeof memo === "string") {
+    for (let i = 0; i < memo.length; i++) {
+      const unit = memo.charCodeAt(i);
+      if (unit >= 55296 && unit <= 56319) {
+        const next = memo.charCodeAt(++i);
+        if (!(next >= 56320 && next <= 57343))
+          throw new Error("memo contains an invalid surrogate");
+      } else if (unit >= 56320 && unit <= 57343)
+        throw new Error("memo contains an invalid surrogate");
+    }
+    encoded = new TextEncoder().encode(memo);
+  } else if (memo instanceof Uint8Array) encoded = Uint8Array.from(memo);
+  else throw new TypeError("memo must be text or Uint8Array");
+  if (encoded.length > MAX_MEMO_BYTES) throw new RangeError("memo exceeds 256 bytes");
+  return encoded;
+}
+function decodeMemoText(memo) {
+  return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(memo);
+}
+
+// src/wallet/signing-request.ts
+var import_ethers3 = require("ethers");
+function createSigningRequest(data) {
+  const types = Object.fromEntries(
+    Object.entries(data.types).map(([name, fields]) => [name, [...fields]])
+  );
+  const payload = import_ethers3.TypedDataEncoder.getPayload(data.domain, types, data.message);
+  if (payload.primaryType !== data.primaryType) {
+    throw new Error("signing request primary type mismatch");
+  }
+  delete payload.types.EIP712Domain;
+  return structuredClone(payload);
+}
+
+// src/delivery/payload.ts
+function encodeData(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new TypeError("v1 payload data must be an object");
+  }
+  for (const key of Object.keys(data)) {
+    if (key !== "memo") throw new Error(`unsupported v1 payload field ${key}`);
+  }
+  const memo = encodeMemo(data.memo);
+  return new Uint8Array([1, ...memo]);
+}
+function readData(value) {
+  if (!(value instanceof Uint8Array) || value.length < 1) {
+    throw new Error("payload version required");
+  }
+  if (value[0] !== 1) throw new Error("unsupported payload version");
+  const memo = Uint8Array.from(value.subarray(1));
+  if (memo.length > 256) throw new Error("invalid memo length");
+  return memo.length === 0 ? {} : { memo };
+}
+var fundsV1 = Object.freeze({
+  encode(data = {}) {
+    return encodeData(data);
+  },
+  decode(value) {
+    return readData(value);
+  }
+});
+var creditV1 = Object.freeze({
+  encode(data = {}) {
+    return encodeData(data);
+  },
+  decode(value) {
+    return readData(value);
+  }
+});
+
+// src/delivery/decryptor.ts
+var import_utils6 = require("@noble/hashes/utils");
+var DeliveryDecryptionError = class extends Error {
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : "delivery decryption failed", { cause });
+    this.name = "DeliveryDecryptionError";
+  }
+};
+function checkedPlaintext(plaintext, codec) {
+  if (!(plaintext instanceof Uint8Array)) throw new Error("invalid decrypted plaintext");
+  if (plaintext.length + 78 < codec.minimum || plaintext.length + 78 > codec.maximum)
+    throw new Error("invalid plaintext length");
+  return plaintext.slice();
+}
+function authenticatedDecryptor(wallet, decryptor) {
+  const ownerAddress = wallet.ownerAddress;
+  return {
+    ownerAddress,
+    async detectCandidates(candidates) {
+      if (!decryptor.detect) return candidates.map(() => "candidate");
+      const result = await decryptor.detect(structuredClone(candidates));
+      if (!result || BigInt(result.ownerAddress) !== BigInt(ownerAddress) || !Array.isArray(result.results) || result.results.length !== candidates.length || result.results.some(
+        (value) => !["candidate", "not-recipient", "unresolved"].includes(value)
+      ))
+        throw new DeliveryDecryptionError(
+          new Error("invalid detection batch or wrong account")
+        );
+      return [...result.results];
+    },
+    async decryptNote(envelope, context2) {
+      context2 = { ...context2 };
+      try {
+        const bytes3 = validateDeliveryCiphertext(envelope, "funds");
+        const full = { ...context2, ownerAddress };
+        const plaintext = await decryptor.decryptNote(bytes3.slice(), { ...full });
+        if (plaintext === null) return null;
+        if (!(plaintext instanceof Uint8Array)) {
+          if (plaintext?.status === "authentication-failed")
+            throw new DeliveryAuthenticationError();
+          throw new Error("invalid decryption result");
+        }
+        const codec = deliveryCodec(bytes3[0]);
+        if (codec.kind !== "funds") throw new Error("unexpected envelope kind");
+        const note = codec.decode(checkedPlaintext(plaintext, codec), full);
+        if (BigInt(note.ownerAddress) !== BigInt(ownerAddress) || note.tokenAddress !== context2.tokenAddress)
+          throw new Error("decrypted note context mismatch");
+        await noteCommitment(full, note);
+        return note;
+      } catch (cause) {
+        if (cause instanceof DeliveryAuthenticationError) throw cause;
+        throw new DeliveryDecryptionError(cause);
+      }
+    },
+    async decryptCredit(envelope, context2) {
+      context2 = { ...context2 };
+      try {
+        const bytes3 = validateDeliveryCiphertext(envelope, "credit");
+        const full = { ...context2, ownerAddress };
+        const plaintext = await decryptor.decryptCredit(bytes3.slice(), { ...full });
+        if (plaintext === null) return null;
+        if (!(plaintext instanceof Uint8Array)) {
+          if (plaintext?.status === "authentication-failed")
+            throw new DeliveryAuthenticationError();
+          throw new Error("invalid decryption result");
+        }
+        const codec = deliveryCodec(bytes3[0]);
+        if (codec.kind !== "credit") throw new Error("unexpected envelope kind");
+        const state = codec.decode(checkedPlaintext(plaintext, codec), full);
+        const identity2 = context2.role === "owner" ? state.note.ownerWalletIdentity : state.note.spenderWalletIdentity;
+        if (BigInt(identity2) !== BigInt(ownerAddress) || state.note.tokenAddress !== context2.tokenAddress)
+          throw new Error("decrypted credit context mismatch");
+        if (wallet.getReceivingAddress().kind === "long") {
+          const keys = context2.role === "owner" ? state.ownerReceivingKeys : state.spenderReceivingKeys;
+          if ((0, import_utils6.bytesToHex)(keys.viewingPublicKey) !== (0, import_utils6.bytesToHex)(wallet.viewingPublicKey))
+            throw new Error("decrypted credit receiving key mismatch");
+        }
+        await creditCommitment(full, state.note);
+        return state;
+      } catch (cause) {
+        if (cause instanceof DeliveryAuthenticationError) throw cause;
+        throw new DeliveryDecryptionError(cause);
+      }
+    }
+  };
+}
+
+// src/wallet/wallet-wire.ts
+var import_utils7 = require("@noble/hashes/utils");
+var walletHex = (bytes3) => `0x${(0, import_utils7.bytesToHex)(bytes3)}`;
+function walletBytes(value, length) {
+  if (typeof value !== "string" || !/^0x(?:[0-9a-f]{2})*$/.test(value))
+    throw new Error("invalid canonical hex bytes");
+  const bytes3 = (0, import_utils7.hexToBytes)(value.slice(2));
+  if (length !== void 0 && bytes3.length !== length) throw new Error("invalid byte length");
+  return bytes3;
+}
+function walletInteger(value) {
+  if (typeof value !== "string" || !/^(0|[1-9][0-9]*)$/.test(value) || value.length > 78)
+    throw new Error("invalid canonical integer");
+  return BigInt(value);
+}
+function walletAuthorizationParams(params) {
+  return {
+    ...params,
+    words: params.words.map(walletInteger),
+    context: {
+      chainId: walletInteger(params.context.chainId),
+      protocolAddress: walletInteger(params.context.protocolAddress)
+    }
+  };
+}
+function walletDecryptionContext(request) {
+  const context2 = request.params.context;
+  return {
+    chainId: walletInteger(context2.chainId),
+    protocolAddress: walletInteger(context2.protocolAddress),
+    tokenAddress: walletInteger(context2.tokenAddress),
+    outputCommitment: context2.outputCommitment,
+    ownerAddress: request.ownerAddress,
+    ...context2.role ? { role: context2.role } : {}
+  };
+}
+function freeze(value) {
+  if (value && typeof value === "object") {
+    Object.values(value).forEach(freeze);
+    Object.freeze(value);
+  }
+  return value;
+}
+function exactKeys(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => !keys.includes(key)) || keys.some((key) => !Object.hasOwn(value, key)))
+    throw new Error("unexpected wallet fields");
+}
+function validateWalletRequest(request) {
+  exactKeys(request, ["version", "id", "ownerAddress", "method", "params"]);
+  if (request.version !== 1 || typeof request.id !== "string" || !/^[\x21-\x7e]{1,128}$/.test(request.id))
+    throw new Error("invalid wallet request envelope");
+  walletBytes(request.ownerAddress, 20);
+  ReceivingAddress.fromIdentity(request.ownerAddress);
+  switch (request.method) {
+    case "wallet.public":
+      exactKeys(request.params, []);
+      break;
+    case "wallet.detect": {
+      exactKeys(request.params, ["clues"]);
+      const { clues } = request.params;
+      if (!Array.isArray(clues) || clues.length > 1024) throw new Error("invalid clues");
+      clues.forEach((clue) => walletBytes(clue, 68));
+      break;
+    }
+    case "wallet.authorize": {
+      exactKeys(request.params, ["operation", "capacity", "words", "context"]);
+      const params = request.params;
+      exactKeys(params.context, ["chainId", "protocolAddress"]);
+      if (!Array.isArray(params.words) || params.words.length > 8192)
+        throw new Error("invalid authorization words");
+      computeWalletAuthorizationDigest(walletAuthorizationParams(params));
+      break;
+    }
+    case "wallet.decryptNote":
+    case "wallet.decryptCredit": {
+      const typed = request;
+      exactKeys(typed.params, ["envelope", "context"]);
+      exactKeys(typed.params.context, [
+        "chainId",
+        "protocolAddress",
+        "tokenAddress",
+        "outputCommitment",
+        ...request.method === "wallet.decryptCredit" ? ["role"] : []
+      ]);
+      const context2 = walletDecryptionContext(typed);
+      walletBytes(context2.outputCommitment, 32);
+      validateContext(context2, context2.tokenAddress);
+      if (request.method === "wallet.decryptCredit" && context2.role !== "owner" && context2.role !== "spender")
+        throw new Error("invalid credit role");
+      if (request.method === "wallet.decryptNote" && context2.role !== void 0)
+        throw new Error("unexpected note role");
+      walletBytes(typed.params.envelope);
+      validateDeliveryCiphertext(
+        typed.params.envelope,
+        request.method === "wallet.decryptCredit" ? "credit" : "funds"
+      );
+      break;
+    }
+    default:
+      throw new Error("unsupported wallet method");
+  }
+}
+var retainedWallets = /* @__PURE__ */ new WeakMap();
+function prepareWalletRequest(wallet, id, method, params) {
+  if (!(wallet instanceof Wallet)) throw new TypeError("public Wallet required");
+  const request = structuredClone({
+    version: 1,
+    id,
+    ownerAddress: wallet.ownerAddress.toLowerCase(),
+    method,
+    params
+  });
+  validateWalletRequest(request);
+  const prepared = freeze({ request });
+  retainedWallets.set(prepared, wallet);
+  return prepared;
+}
+async function acceptWalletResponse(prepared, response) {
+  return acceptResponse(prepared, response);
+}
+async function acceptResponse(prepared, response) {
+  const wallet = retainedWallets.get(prepared);
+  if (!wallet) throw new Error("wallet request was not prepared by this SDK instance");
+  const request = prepared.request;
+  validateWalletRequest(request);
+  const safe = structuredClone(response);
+  if (safe.version !== request.version || safe.id !== request.id || safe.ownerAddress !== request.ownerAddress || safe.method !== request.method)
+    throw new Error("wallet response envelope mismatch");
+  validateWalletResponses([request], [safe]);
+  if ("error" in safe) throw new NativeWalletError(safe.error.code);
+  const result = safe.result;
+  exactKeys(
+    result,
+    request.method === "wallet.public" ? ["viewingPublicKey", "spendingPublicKey", "clueKey"] : request.method === "wallet.authorize" ? ["spendingPublicKey", "signature", "digest"] : request.method === "wallet.detect" ? ["matches"] : ["plaintext"]
+  );
+  if (request.method === "wallet.public") {
+    walletBytes(result.spendingPublicKey, 65);
+    walletBytes(result.viewingPublicKey, 33);
+    walletBytes(result.clueKey, 32);
+    if (await computeOwnerAddress(result.spendingPublicKey) !== request.ownerAddress)
+      throw new Error("wallet public identity mismatch");
+    if (wallet.getReceivingAddress().kind === "long" && (walletHex(wallet.viewingPublicKey) !== result.viewingPublicKey || walletHex(wallet.clueKey) !== result.clueKey))
+      throw new Error("wallet receiving key mismatch");
+    ReceivingAddress.from({
+      ownerAddress: request.ownerAddress,
+      viewingPublicKey: walletBytes(result.viewingPublicKey),
+      clueKey: walletBytes(result.clueKey)
+    });
+  } else if (request.method === "wallet.authorize") {
+    const auth = walletAuthorizationParams(request.params);
+    if (result.digest !== computeWalletAuthorizationDigest(auth) || !await verifyWalletAuthorization(
+      request.ownerAddress,
+      result.spendingPublicKey,
+      result.signature,
+      auth
+    ))
+      throw new Error("invalid wallet authorization response");
+    const publicKey2 = walletBytes(result.spendingPublicKey, 65);
+    return new AuthorizedStatement(request.ownerAddress, result.digest, {
+      public_key_x: Array.from(publicKey2.slice(1, 33)),
+      public_key_y: Array.from(publicKey2.slice(33)),
+      signature: Array.from(walletBytes(result.signature, 64))
+    });
+  } else if (request.method === "wallet.detect") {
+    if (!Array.isArray(result.matches) || result.matches.length !== request.params.clues.length || result.matches.some((v) => typeof v !== "boolean"))
+      throw new Error("invalid detection response");
+  } else {
+    const typed = request;
+    const context2 = walletDecryptionContext(typed);
+    const plaintext = walletBytes(result.plaintext);
+    const viewing = authenticatedDecryptor(wallet, {
+      decryptNote: async () => plaintext,
+      decryptCredit: async () => plaintext
+    });
+    return typed.method === "wallet.decryptNote" ? viewing.decryptNote(typed.params.envelope, context2) : viewing.decryptCredit(typed.params.envelope, context2);
+  }
+  return result;
+}
+var NativeWalletError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "NativeWalletError";
+  }
+};
+var MAX_WALLET_BATCH_BYTES = 16 * 1024 * 1024;
+function boundedJson(value) {
+  const json = JSON.stringify(value);
+  if (typeof json !== "string" || new TextEncoder().encode(json).length > MAX_WALLET_BATCH_BYTES)
+    throw new Error("wallet batch exceeds encoded size limit");
+}
+function validateWalletBatch(requests) {
+  if (!Array.isArray(requests) || requests.length > 1024) throw new Error("invalid wallet batch");
+  boundedJson(requests);
+  const ids = /* @__PURE__ */ new Set();
+  for (const request of requests) {
+    validateWalletRequest(request);
+    if (ids.has(request.id)) throw new Error("duplicate wallet request id");
+    if (request.ownerAddress !== requests[0].ownerAddress)
+      throw new Error("mixed wallet batch owners");
+    ids.add(request.id);
+  }
+}
+function validateWalletResponses(requests, responses) {
+  validateWalletBatch(requests);
+  if (!Array.isArray(responses) || responses.length !== requests.length)
+    throw new Error("wallet response batch length mismatch");
+  boundedJson(responses);
+  const expected = new Map(requests.map((request) => [request.id, request]));
+  const found = /* @__PURE__ */ new Map();
+  for (const response of responses) {
+    if (!response || typeof response !== "object") throw new Error("invalid wallet response");
+    const request = expected.get(response.id);
+    if (!request || found.has(response.id) || response.version !== 1 || response.method !== request.method || response.ownerAddress !== request.ownerAddress)
+      throw new Error("wallet response envelope mismatch");
+    if (Object.hasOwn(response, "error")) {
+      exactKeys(response, ["version", "id", "ownerAddress", "method", "error"]);
+      exactKeys(response.error, ["code"]);
+      if (typeof response.error?.code !== "string" || !/^[A-Z][A-Z0-9_]{0,127}$/.test(response.error.code))
+        throw new Error("invalid native wallet error");
+    } else {
+      exactKeys(response, ["version", "id", "ownerAddress", "method", "result"]);
+      if (!response.result || typeof response.result !== "object" || Array.isArray(response.result))
+        throw new Error("invalid wallet result");
+      const result = response.result;
+      exactKeys(
+        result,
+        request.method === "wallet.public" ? ["viewingPublicKey", "spendingPublicKey", "clueKey"] : request.method === "wallet.authorize" ? ["spendingPublicKey", "signature", "digest"] : request.method === "wallet.detect" ? ["matches"] : ["plaintext"]
+      );
+      if (request.method === "wallet.public") {
+        walletBytes(result.viewingPublicKey, 33);
+        walletBytes(result.spendingPublicKey, 65);
+        walletBytes(result.clueKey, 32);
+      } else if (request.method === "wallet.authorize") {
+        walletBytes(result.spendingPublicKey, 65);
+        walletBytes(result.signature, 64);
+        walletBytes(result.digest, 32);
+      } else if (request.method === "wallet.detect") {
+        if (!Array.isArray(result.matches) || result.matches.length !== request.params.clues.length || result.matches.some((value) => typeof value !== "boolean"))
+          throw new Error("invalid detection response");
+      } else {
+        walletBytes(result.plaintext);
+      }
+    }
+    found.set(response.id, response);
+  }
+  return requests.map((request) => found.get(request.id));
+}
+async function acceptWalletResponses(prepared, responses) {
+  for (const item of prepared) {
+    if (!retainedWallets.has(item))
+      throw new Error("wallet request was not prepared by this SDK instance");
+  }
+  const ordered = validateWalletResponses(
+    prepared.map((item) => item.request),
+    structuredClone(responses)
+  );
+  return Promise.all(prepared.map((item, index) => acceptWalletResponse(item, ordered[index])));
+}
+
+// src/provenance/intent-hash.ts
+var import_ethers4 = require("ethers");
+function provenanceIntentHash(originalRequestHash) {
+  return (0, import_ethers4.keccak256)(
+    import_ethers4.AbiCoder.defaultAbiCoder().encode(
+      ["string", "bytes32"],
+      ["InvisiBroadcasterProvenanceIntentV1", (0, import_ethers4.toBeHex)(BigInt(originalRequestHash), 32)]
+    )
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthorizedStatement,
+  CREDIT_POLICY_FIELDS,
+  CREDIT_USAGE_FIELDS,
+  D_CNULL,
+  D_CREDIT,
+  D_CREDIT_KEY_HASH,
+  D_CREDIT_RECOVERY,
+  D_CREDIT_STATE_NONCE,
+  D_IDENT,
+  D_NOTE,
+  D_NULL,
+  DeliveryAuthenticationError,
+  DeliveryDecryptionError,
+  Detector,
+  Disclosure,
+  FIELD_MODULUS,
+  MAX_CIPHERTEXT_BYTES,
+  MAX_MEMO_BYTES,
+  MAX_WALLET_BATCH_BYTES,
+  MissingCapabilityError,
+  NativeWalletError,
+  NullifierCapability,
+  ReceivingAddress,
+  TREE_DEPTH,
+  ViewingCapability,
+  WALLET_AUTHORIZATION_TYPES,
+  Wallet,
+  acceptWalletResponse,
+  acceptWalletResponses,
+  applyCreditDrawUsage,
+  authenticatedDecryptor,
+  computeCreditCommitment,
+  computeCreditNullifier,
+  computeCreditRecoveryPad,
+  computeCreditSharedKeyHash,
+  computeNoteCommitment,
+  computeNoteIdentity,
+  computeNoteNullifier,
+  computeOwnerAddress,
+  computeWalletAuthorizationDigest,
+  createClue,
+  createClueFromSeed,
+  createSigningRequest,
+  creditPeriods,
+  creditV1,
+  decodeAddress,
+  decodeDeliveryHeader,
+  decodeMemoText,
+  decryptCreditState,
+  decryptPrivateTransferNote,
+  deliveryCodec,
+  deliveryHeader,
+  deriveClueKey,
+  deriveCreditState,
+  deriveCreditStateNonce,
+  deriveCreditUpdate,
+  encodeMemo,
+  encryptCreditState,
+  encryptPrivateTransferNote,
+  fundsV1,
+  generateCreditSharedKey,
+  generateNonce,
+  normalizeCreditDeliveryState,
+  normalizeCreditPolicy,
+  normalizeCreditState,
+  normalizeCreditUsage,
+  poseidonHash,
+  prepareWalletRequest,
+  provenanceIntentHash,
+  recoverCreditState,
+  validateClueKey,
+  validateDeliveryCiphertext,
+  validateWalletBatch,
+  validateWalletResponses,
+  verifyWalletAuthorization,
+  viewingPublicKey,
+  walletAuthorizationTypedData
+});
+//# sourceMappingURL=index.cjs.map