@invisi-labs/sdk 1.1.5 → 1.1.7

package/dist/chunk-J2JH6HIG.cjs

@@ -0,0 +1,1877 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk7F7ZZW3Lcjs = require('./chunk-7F7ZZW3L.cjs');
+
+// src/errors.ts
+var _core = require('@invisi-labs/core');
+var InvisiError = class extends Error {
+  
+  
+  
+  
+  
+  
+  constructor(code, message, details = {}) {
+    super(message, { cause: details.cause });
+    this.name = "InvisiError";
+    this.code = code;
+    this.operation = details.operation;
+    this.address = details.address;
+    this.outputIndex = details.outputIndex;
+    this.field = details.field;
+    this.capability = details.capability;
+  }
+};
+async function prepareWithErrors(operation, prepare) {
+  try {
+    return await prepare();
+  } catch (cause) {
+    if (cause instanceof InvisiError) {
+      if (cause.operation) throw cause;
+      throw new InvisiError(cause.code, cause.message, {
+        operation,
+        ...cause.address === void 0 ? {} : { address: cause.address },
+        ...cause.outputIndex === void 0 ? {} : { outputIndex: cause.outputIndex },
+        ...cause.field === void 0 ? {} : { field: cause.field },
+        ...cause.capability === void 0 ? {} : { capability: cause.capability },
+        cause: cause.cause
+      });
+    }
+    throw new InvisiError(
+      cause instanceof _core.MissingCapabilityError ? "MISSING_CAPABILITY" : "PREPARATION_FAILED",
+      cause instanceof Error ? cause.message : "Transaction preparation failed",
+      {
+        operation,
+        cause,
+        ...cause instanceof _core.MissingCapabilityError ? { capability: cause.capability } : {}
+      }
+    );
+  }
+}
+
+// src/payment-note/codec.ts
+
+var _ethers = require('ethers');
+function uint(value, bytes) {
+  if (typeof value !== "bigint" || value < 0n || value >= 1n << BigInt(bytes * 8))
+    throw new RangeError(`Invalid uint${bytes * 8} payment note field`);
+  return _ethers.getBytes.call(void 0, `0x${value.toString(16).padStart(bytes * 2, "0")}`);
+}
+function validate(value) {
+  const keys = [
+    "chainId",
+    "protocolAddress",
+    "tokenAddress",
+    "amount",
+    "ownerAddress",
+    "nonce",
+    "commitment"
+  ];
+  if (!value || typeof value !== "object" || Object.keys(value).some((key) => !keys.includes(key)))
+    throw new TypeError("Invalid payment note fields");
+  uint(value.chainId, 8);
+  uint(value.amount, 16);
+  if (value.chainId === 0n || value.amount === 0n)
+    throw new RangeError("Positive chainId and amount required");
+  for (const key of ["protocolAddress", "ownerAddress", "tokenAddress"]) {
+    _ethers.getAddress.call(void 0, value[key]);
+    if (key !== "tokenAddress" && BigInt(value[key]) === 0n)
+      throw new RangeError(`Invalid ${key}`);
+  }
+  uint(value.nonce, 32);
+  if (value.nonce >= _core.FIELD_MODULUS) throw new RangeError("Invalid payment note nonce");
+  if (!/^0x[\da-f]{64}$/i.test(value.commitment) || BigInt(value.commitment) <= 0n || BigInt(value.commitment) >= _core.FIELD_MODULUS)
+    throw new RangeError("Invalid payment note commitment");
+}
+function encodePaymentNote(value) {
+  validate(value);
+  const bytes = _ethers.concat.call(void 0, [
+    new Uint8Array([1]),
+    uint(value.chainId, 8),
+    _ethers.getBytes.call(void 0, value.protocolAddress),
+    _ethers.getBytes.call(void 0, value.tokenAddress),
+    uint(value.amount, 16),
+    _ethers.getBytes.call(void 0, value.ownerAddress),
+    uint(value.nonce, 32),
+    _ethers.getBytes.call(void 0, value.commitment)
+  ]);
+  return `ipn:${_ethers.encodeBase64.call(void 0, bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")}`;
+}
+function decodePaymentNote(encoded) {
+  if (typeof encoded !== "string" || encoded.length !== 203 || !/^ipn:[A-Za-z0-9_-]+$/.test(encoded))
+    throw new TypeError("Invalid payment note encoding");
+  const bytes = _ethers.decodeBase64.call(void 0, encoded.slice(4).replace(/-/g, "+").replace(/_/g, "/") + "=");
+  if (bytes.length !== 149 || bytes[0] !== 1)
+    throw new Error("Unsupported payment note version or length");
+  let offset = 1;
+  const take = (size) => {
+    const value2 = _ethers.hexlify.call(void 0, bytes.slice(offset, offset += size));
+    return value2;
+  };
+  const value = {
+    chainId: BigInt(take(8)),
+    protocolAddress: _ethers.getAddress.call(void 0, take(20)),
+    tokenAddress: _ethers.getAddress.call(void 0, take(20)),
+    amount: BigInt(take(16)),
+    ownerAddress: _ethers.getAddress.call(void 0, take(20)).toLowerCase(),
+    nonce: BigInt(take(32)),
+    commitment: take(32)
+  };
+  if (encodePaymentNote(value) !== encoded) throw new Error("Noncanonical payment note encoding");
+  return value;
+}
+
+// src/transactions/signing/statement.ts
+
+
+
+
+
+
+
+
+var _protocol = require('@invisi-labs/protocol');
+function requiresAuthorization(plan) {
+  const ownerOnlyFullWithdrawal = !plan.credit && plan.inputs.length > 0 && plan.outputs.length === 0 && plan.params !== void 0 && plan.params.outputCommitments.length === 0 && (_nullishCoalesce(plan.params.feeAmount, () => ( 0n))) === 0n && BigInt(_nullishCoalesce(plan.params.feeRecipient, () => ( 0n))) === 0n && (_nullishCoalesce(plan.funding.amount, () => ( 0n))) === 0n && plan.fundingMode === "none" && BigInt(plan.params.withdrawalAddress) === BigInt(plan.scope.ownerAddress) && plan.params.withdrawalAmount === plan.inputs.reduce((sum, input) => sum + input.note.amount, 0n) && plan.inputs.every((input) => input.note.ownerAddress === plan.scope.ownerAddress);
+  if (ownerOnlyFullWithdrawal) return false;
+  return !!plan.credit || plan.inputs.length > 0;
+}
+function statement(plan) {
+  if (!plan.statement) throw new Error("operation has no proof statement");
+  const credit = plan.credit;
+  let words;
+  if (_optionalChain([credit, 'optionalAccess', _2 => _2.topUp])) {
+    words = _protocol.topUpCreditPublicInputs.call(void 0, 
+      plan.context,
+      credit.topUp,
+      credit.deliveries,
+      plan.funding
+    );
+  } else if (_optionalChain([credit, 'optionalAccess', _3 => _3.creation])) {
+    words = _protocol.createCreditPublicInputs.call(void 0, 
+      plan.context,
+      credit.creation,
+      credit.deliveries,
+      plan.funding
+    );
+  } else if (_optionalChain([credit, 'optionalAccess', _4 => _4.draw])) {
+    words = _protocol.creditDrawPublicInputs.call(void 0, plan.context, credit.draw, credit.deliveries);
+  } else if (_optionalChain([credit, 'optionalAccess', _5 => _5.cancel])) {
+    words = _protocol.cancelCreditPublicInputs.call(void 0, plan.context, credit.cancel);
+  } else {
+    words = _protocol.transactUserPublicInputs.call(void 0, 
+      plan.context,
+      plan.params,
+      plan.outputs.map((output) => output.delivery),
+      plan.funding
+    );
+  }
+  const result = _protocol.WitnessBuilder.statement(
+    plan.statement.circuitName,
+    words,
+    plan.statement.target
+  );
+  if (JSON.stringify(result) !== JSON.stringify(plan.statement)) {
+    throw new Error("frozen operation statement changed");
+  }
+  return result;
+}
+function authorizationRequest(plan) {
+  let operation = "transact";
+  if (plan.kind === "draw-credit") {
+    operation = "credit-draw";
+  } else if (plan.kind === "create-credit" || plan.kind === "top-up-credit" || plan.kind === "cancel-credit") {
+    operation = plan.kind;
+  }
+  return {
+    context: {
+      chainId: plan.context.chainId,
+      protocolAddress: BigInt(plan.context.protocolAddress)
+    },
+    operation,
+    capacity: plan.capacity,
+    words: statement(plan).expectedPublicInputs.slice(0, -2).map(BigInt)
+  };
+}
+function operationExpired(plan, now) {
+  if (now > plan.deadline) return true;
+  const credit = plan.credit;
+  if (_optionalChain([credit, 'optionalAccess', _6 => _6.topUp]) && now >= credit.topUp.previousExpiry) return true;
+  if (_optionalChain([credit, 'optionalAccess', _7 => _7.creation]) && now >= credit.creation.expiry) return true;
+  if (_optionalChain([credit, 'optionalAccess', _8 => _8.draw])) {
+    if (credit.draw.expiries.some((expiry) => now >= expiry)) return true;
+    const prepared = _core.creditPeriods.call(void 0, plan.preparedAt.timestamp), current = _core.creditPeriods.call(void 0, now);
+    if (prepared.currentDay !== current.currentDay || prepared.currentMonth !== current.currentMonth)
+      return true;
+  }
+  return false;
+}
+
+// src/broadcaster/intent.ts
+
+var _contracts = require('@invisi-labs/protocol/contracts');
+
+function exportBroadcasterIntent(plan) {
+  if (plan.kind === "draw-credit" || plan.statement && plan.statement.target !== "evm")
+    throw new Error("unsupported broadcaster operation");
+  if (plan.statement) statement(plan);
+  const feeDefaults = (params) => ({
+    ...params,
+    feeRecipient: _nullishCoalesce(params.feeRecipient, () => ( "0x0000000000000000000000000000000000000000")),
+    feeAmount: _nullishCoalesce(params.feeAmount, () => ( 0n))
+  });
+  const funding = { ..._protocol.normalizeFunding.call(void 0, plan.funding), signature: "0x" };
+  let method;
+  let args;
+  if (plan.params) {
+    method = "transact";
+    args = [
+      "0x",
+      {
+        params: feeDefaults(plan.params),
+        deliveries: plan.outputs.map((o) => o.delivery),
+        funding
+      }
+    ];
+  } else if (plan.shieldParams) {
+    method = "shield";
+    args = [
+      feeDefaults(plan.shieldParams),
+      plan.shieldOutputs,
+      plan.outputs.map((o) => o.delivery),
+      funding
+    ];
+  } else if (_optionalChain([plan, 'access', _9 => _9.credit, 'optionalAccess', _10 => _10.topUp])) {
+    method = "topUpCredit";
+    args = [
+      "0x",
+      { ...plan.credit.topUp, creation: feeDefaults(plan.credit.topUp.creation) },
+      plan.credit.deliveries,
+      funding
+    ];
+  } else if (_optionalChain([plan, 'access', _11 => _11.credit, 'optionalAccess', _12 => _12.creation])) {
+    method = "createCredit";
+    args = ["0x", feeDefaults(plan.credit.creation), plan.credit.deliveries, funding];
+  } else if (_optionalChain([plan, 'access', _13 => _13.credit, 'optionalAccess', _14 => _14.cancel])) {
+    method = "cancelCredit";
+    args = ["0x", feeDefaults(plan.credit.cancel)];
+  } else throw new Error("unsupported broadcaster operation");
+  const abi = _contracts.invisiProtocolAbi.filter(
+    (item) => item.type === "function" && item.name === method && (method !== "transact" || _optionalChain([item, 'access', _15 => _15.inputs, 'access', _16 => _16[1], 'optionalAccess', _17 => _17.type]) === "tuple")
+  );
+  return {
+    sendable: false,
+    data: new (0, _ethers.Interface)(abi).encodeFunctionData(method, args)
+  };
+}
+
+// src/payment-request/codec.ts
+
+
+
+// src/payment-request/binary.ts
+function uint2(value, size, name) {
+  if (typeof value !== "bigint" || value < 0n || value >= 1n << BigInt(size * 8))
+    throw new RangeError(`${name} must be uint${size * 8}`);
+  const result = new Uint8Array(size);
+  for (let i = size - 1; i >= 0; i--) {
+    result[i] = Number(value & 255n);
+    value >>= 8n;
+  }
+  return result;
+}
+function concat2(parts) {
+  const result = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    result.set(part, offset);
+    offset += part.length;
+  }
+  return result;
+}
+var Reader = class {
+  constructor(data) {
+    this.data = data;
+  }
+  #offset = 0;
+  take(size) {
+    if (this.#offset + size > this.data.length) throw new Error("Truncated payment request");
+    const result = this.data.slice(this.#offset, this.#offset + size);
+    this.#offset += size;
+    return result;
+  }
+  integer(size) {
+    return this.take(size).reduce((n, b) => n << 8n | BigInt(b), 0n);
+  }
+  done() {
+    if (this.#offset !== this.data.length) throw new Error("Trailing payment request bytes");
+  }
+};
+
+// src/payment-request/validation.ts
+
+
+var MAX_REQUEST_PAYLOAD_BYTES = _core.MAX_CIPHERTEXT_BYTES - 160;
+function fields(value, allowed, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError(`Invalid ${name}`);
+  for (const key of Object.keys(value))
+    if (!allowed.includes(key)) throw new TypeError(`Unsupported ${name} field ${key}`);
+}
+function nonce(value) {
+  uint2(value, 32, "nonce");
+  if (value >= _core.FIELD_MODULUS)
+    throw new RangeError("nonce must be a canonical BN254 field element");
+  return value;
+}
+function validatePaymentRequest(request) {
+  fields(
+    request,
+    ["chainId", "protocolAddress", "tokenAddress", "amount", "recipient", "payload"],
+    "payment request"
+  );
+  uint2(request.chainId, 8, "chainId");
+  if (request.chainId === 0n) throw new RangeError("chainId must be positive");
+  const protocol = _ethers.getAddress.call(void 0, request.protocolAddress);
+  _ethers.getAddress.call(void 0, request.tokenAddress);
+  if (BigInt(protocol) === 0n) throw new RangeError("protocol address must be nonzero");
+  uint2(request.amount, 16, "amount");
+  if (request.amount === 0n) throw new RangeError("amount must be positive");
+  const recipient = request.recipient;
+  fields(
+    recipient,
+    ["type", "address", "nonce", "identity", "envelope", "addressLookup"],
+    "recipient"
+  );
+  if (recipient.type === "identity") {
+    fields(recipient, ["type", "identity"], "identity recipient");
+    if (typeof recipient.identity !== "string" || !/^0x[\da-f]{64}$/i.test(recipient.identity) || BigInt(recipient.identity) <= 0n || BigInt(recipient.identity) >= _core.FIELD_MODULUS)
+      throw new RangeError("identity must be a nonzero canonical BN254 field element");
+    if (request.payload !== void 0)
+      throw new TypeError("payload requires an encrypted envelope");
+    return;
+  }
+  if (recipient.type !== "evm" && recipient.type !== "invisi")
+    throw new TypeError("Invalid recipient type");
+  fields(
+    recipient,
+    recipient.type === "evm" ? ["type", "address", "nonce", "envelope", "addressLookup"] : ["type", "address", "nonce"],
+    "recipient"
+  );
+  const parsed = _core.ReceivingAddress.parse(recipient.address);
+  if (recipient.type === "evm" !== (parsed.kind === "short"))
+    throw new TypeError("recipient address type mismatch");
+  if (BigInt(parsed.ownerAddress) === 0n) throw new RangeError("owner address must be nonzero");
+  if (recipient.nonce !== void 0) nonce(recipient.nonce);
+  if (recipient.type === "evm") {
+    if (recipient.envelope !== void 0 && typeof recipient.envelope !== "boolean")
+      throw new TypeError("evm envelope must be boolean");
+    if (recipient.addressLookup !== void 0 && !["chain", "protocol-rpc"].includes(recipient.addressLookup))
+      throw new TypeError("Invalid recipient addressLookup");
+    if (recipient.envelope === false && request.payload !== void 0)
+      throw new TypeError("payload requires an encrypted envelope");
+  }
+  if (request.payload !== void 0 && !(request.payload instanceof Uint8Array))
+    throw new TypeError("payload must be Uint8Array");
+  if ((_nullishCoalesce(_optionalChain([request, 'access', _18 => _18.payload, 'optionalAccess', _19 => _19.length]), () => ( 0))) > MAX_REQUEST_PAYLOAD_BYTES)
+    throw new RangeError("payload exceeds funds envelope limit");
+}
+
+// src/payment-request/codec.ts
+var PREFIX = "ipr:";
+var VERSION = 1;
+var MAX_BINARY_BYTES = 186 + MAX_REQUEST_PAYLOAD_BYTES;
+function base64url(data) {
+  return _ethers.encodeBase64.call(void 0, data).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function encodePaymentRequest(request) {
+  validatePaymentRequest(request);
+  const recipient = request.recipient;
+  const parts = [
+    new Uint8Array([
+      VERSION,
+      recipient.type === "evm" ? 1 : recipient.type === "invisi" ? 2 : 3
+    ]),
+    uint2(request.chainId, 8, "chainId"),
+    _ethers.getBytes.call(void 0, request.protocolAddress),
+    _ethers.getBytes.call(void 0, request.tokenAddress),
+    uint2(request.amount, 16, "amount")
+  ];
+  if (recipient.type === "identity") parts.push(_ethers.getBytes.call(void 0, recipient.identity));
+  else {
+    const parsed = _core.ReceivingAddress.parse(recipient.address);
+    parts.push(_ethers.getBytes.call(void 0, parsed.ownerAddress));
+    if (recipient.type === "invisi") {
+      const keys = parsed.getReceivingKeys();
+      parts.push(keys.viewingPublicKey, keys.clueKey);
+    } else parts.push(new Uint8Array([recipient.envelope === false ? 0 : 1]));
+    parts.push(new Uint8Array([recipient.nonce === void 0 ? 0 : 1]));
+    if (recipient.nonce !== void 0) parts.push(uint2(recipient.nonce, 32, "nonce"));
+    if (recipient.type === "invisi" || recipient.envelope !== false) {
+      const payload = _nullishCoalesce(request.payload, () => ( new Uint8Array()));
+      parts.push(uint2(BigInt(payload.length), 2, "payloadLength"), payload);
+    }
+  }
+  return PREFIX + base64url(concat2(parts));
+}
+function decodePaymentRequest(encoded) {
+  if (typeof encoded !== "string" || !encoded.startsWith(PREFIX) || encoded.length > 4 + Math.ceil(MAX_BINARY_BYTES * 8 / 6))
+    throw new Error("Invalid payment request encoding");
+  const text = encoded.slice(PREFIX.length);
+  if (!/^[A-Za-z0-9_-]+$/.test(text) || text.length % 4 === 1)
+    throw new Error("Invalid payment request Base64URL");
+  const data = _ethers.decodeBase64.call(void 0, 
+    text.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - text.length % 4) % 4)
+  );
+  if (base64url(data) !== text) throw new Error("Noncanonical payment request Base64URL");
+  const reader = new Reader(data);
+  if (reader.integer(1) !== BigInt(VERSION))
+    throw new Error("Unsupported payment request version");
+  const type = reader.integer(1);
+  if (type < 1n || type > 3n) throw new Error("Unsupported payment request recipient type");
+  const context = {
+    chainId: reader.integer(8),
+    protocolAddress: _ethers.hexlify.call(void 0, reader.take(20)),
+    tokenAddress: _ethers.hexlify.call(void 0, reader.take(20)),
+    amount: reader.integer(16)
+  };
+  let recipient;
+  let payload;
+  if (type === 3n)
+    recipient = { type: "identity", identity: _ethers.hexlify.call(void 0, reader.take(32)) };
+  else {
+    const ownerAddress = _ethers.hexlify.call(void 0, reader.take(20));
+    let address;
+    let envelope = true;
+    if (type === 2n)
+      address = _core.ReceivingAddress.from({
+        ownerAddress,
+        viewingPublicKey: reader.take(33),
+        clueKey: reader.take(32)
+      }).toString();
+    else {
+      address = _core.ReceivingAddress.fromIdentity(ownerAddress).toString();
+      const value = reader.integer(1);
+      if (value > 1n) throw new Error("Invalid envelope flag");
+      envelope = value === 1n;
+    }
+    const present = reader.integer(1);
+    if (present > 1n) throw new Error("Invalid nonce presence flag");
+    const nonce2 = present === 1n ? reader.integer(32) : void 0;
+    recipient = type === 2n ? { type: "invisi", address, ...nonce2 === void 0 ? {} : { nonce: nonce2 } } : { type: "evm", address, envelope, ...nonce2 === void 0 ? {} : { nonce: nonce2 } };
+    if (envelope) {
+      const length = Number(reader.integer(2));
+      if (length > MAX_REQUEST_PAYLOAD_BYTES)
+        throw new RangeError("payload exceeds funds envelope limit");
+      if (length !== 0) payload = reader.take(length);
+    }
+  }
+  reader.done();
+  const request = {
+    ...context,
+    recipient,
+    ...payload === void 0 ? {} : { payload }
+  };
+  validatePaymentRequest(request);
+  if (encodePaymentRequest(request) !== encoded) throw new Error("Noncanonical payment request");
+  return request;
+}
+
+// src/payment-note/export.ts
+function exportPaymentNote(output) {
+  const note = output.note;
+  if (output.recipient.type === "identity" || !note)
+    throw new Error("Identity outputs cannot export an IPN");
+  return encodePaymentNote({
+    chainId: note.chainId,
+    protocolAddress: output.context.protocolAddress,
+    tokenAddress: output.context.tokenAddress,
+    amount: note.amount,
+    ownerAddress: note.ownerAddress,
+    nonce: note.nonce,
+    commitment: output.commitment
+  });
+}
+
+// src/notes/NoteOutput.ts
+
+
+
+
+
+
+
+
+
+
+
+// src/notes/resolve-recipient.ts
+
+
+
+
+async function resolveRecipient(address, lookup, details = {}) {
+  const context = { ...details, address };
+  let recipient;
+  try {
+    recipient = _core.ReceivingAddress.parse(address);
+  } catch (cause) {
+    throw new InvisiError("INVALID_RECIPIENT", "Invalid recipient address", {
+      ...context,
+      cause
+    });
+  }
+  if (recipient.kind === "long") return recipient;
+  if (!lookup) {
+    throw new InvisiError("MISSING_CAPABILITY", "Missing registry lookup capability", {
+      ...context,
+      capability: "registry lookup"
+    });
+  }
+  let keys;
+  try {
+    keys = await lookup(recipient.ownerAddress);
+  } catch (cause) {
+    if (cause instanceof _core.MissingCapabilityError) {
+      throw new InvisiError("MISSING_CAPABILITY", cause.message, {
+        ...context,
+        cause,
+        capability: cause.capability
+      });
+    }
+    throw new InvisiError("RECIPIENT_LOOKUP_FAILED", "Recipient registry lookup failed", {
+      ...context,
+      cause
+    });
+  }
+  if (keys == null) {
+    throw new InvisiError(
+      "EVM_ADDRESS_NOT_REGISTERED",
+      "EVM address has no registered receiving keys",
+      context
+    );
+  }
+  try {
+    return _core.ReceivingAddress.from({
+      ownerAddress: recipient.ownerAddress,
+      viewingPublicKey: keys.viewingPublicKey,
+      clueKey: keys.clueKey
+    });
+  } catch (cause) {
+    throw new InvisiError(
+      "RECIPIENT_LOOKUP_FAILED",
+      "Registry returned invalid receiving keys",
+      { ...context, cause }
+    );
+  }
+}
+
+// src/payment-request/match-output.ts
+
+
+function assertRequestMatchesOutput(ipp, output) {
+  const request = decodePaymentRequest(ipp);
+  const expected = request.recipient;
+  const actual = output.recipient;
+  if (request.chainId !== output.context.chainId || BigInt(request.protocolAddress) !== BigInt(output.context.protocolAddress) || BigInt(request.tokenAddress) !== BigInt(output.context.tokenAddress) || request.amount !== output.amount || expected.type !== actual.type)
+    throw new Error("IPR does not match output context or recipient");
+  if (expected.type === "identity") {
+    if (actual.type !== "identity" || BigInt(expected.identity) !== BigInt(actual.identity))
+      throw new Error("IPR identity mismatch");
+    return;
+  }
+  if (actual.type === "identity") throw new Error("IPR recipient type mismatch");
+  const parsed = _core.ReceivingAddress.parse(expected.address);
+  const resolved = _core.ReceivingAddress.parse(actual.address);
+  if (parsed.ownerAddress !== resolved.ownerAddress || expected.nonce !== void 0 && expected.nonce !== _optionalChain([output, 'access', _20 => _20.note, 'optionalAccess', _21 => _21.nonce]) || _ethers.hexlify.call(void 0, _nullishCoalesce(request.payload, () => ( new Uint8Array()))) !== _ethers.hexlify.call(void 0, _nullishCoalesce(_optionalChain([output, 'access', _22 => _22.note, 'optionalAccess', _23 => _23.payload]), () => ( new Uint8Array()))))
+    throw new Error("IPR does not match output opening");
+  if (expected.type === "evm" && actual.type === "evm" && expected.envelope !== false !== (actual.envelope !== false))
+    throw new Error("IPR envelope mismatch");
+  if (expected.type === "invisi") {
+    const a = parsed.getReceivingKeys(), b = resolved.getReceivingKeys();
+    if (_ethers.hexlify.call(void 0, a.viewingPublicKey) !== _ethers.hexlify.call(void 0, b.viewingPublicKey) || _ethers.hexlify.call(void 0, a.clueKey) !== _ethers.hexlify.call(void 0, b.clueKey))
+      throw new Error("IPR receiving keys mismatch");
+  }
+}
+
+// src/payment-request/execution.ts
+function applyExecutionOptions(request, execution) {
+  fields(execution, ["nonce", "addressLookup"], "execution options");
+  const copy = structuredClone(request);
+  const recipient = copy.recipient;
+  if (execution.nonce !== void 0) {
+    if (recipient.type === "identity")
+      throw new TypeError("identity recipient cannot specify nonce");
+    nonce(execution.nonce);
+    if (recipient.nonce !== void 0 && recipient.nonce !== execution.nonce)
+      throw new Error("nonce conflicts with the fixed payment request");
+    recipient.nonce = execution.nonce;
+  }
+  if (execution.addressLookup !== void 0) {
+    if (recipient.type !== "evm" || recipient.envelope === false)
+      throw new TypeError("addressLookup requires an encrypted EVM recipient");
+    if (!["chain", "protocol-rpc"].includes(execution.addressLookup))
+      throw new TypeError("Invalid addressLookup");
+    recipient.addressLookup = execution.addressLookup;
+  }
+  return copy;
+}
+
+// src/notes/NoteOutput.ts
+function nonceValue(value) {
+  if (typeof value !== "bigint" || value < 0n || value >= _core.FIELD_MODULUS)
+    throw new RangeError("nonce must be a canonical BN254 field element");
+  return value;
+}
+function identityValue(value) {
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(value) || BigInt(value) <= 0n || BigInt(value) >= _core.FIELD_MODULUS)
+    throw new RangeError("identity must be a nonzero canonical BN254 field element");
+  return value.toLowerCase();
+}
+function payloadCopy(value) {
+  if (value === void 0) return new Uint8Array();
+  if (!(value instanceof Uint8Array)) throw new TypeError("payload must be Uint8Array");
+  return Uint8Array.from(value);
+}
+function fingerprint(delivery) {
+  return _ethers.keccak256.call(void 0, 
+    _ethers.AbiCoder.defaultAbiCoder().encode(["bytes", "bytes"], [delivery.ciphertext, delivery.clue])
+  );
+}
+function checkedContext(context) {
+  if (typeof context.chainId !== "bigint" || context.chainId <= 0n)
+    throw new RangeError("chainId must be positive");
+  const protocolAddress = _ethers.getAddress.call(void 0, context.protocolAddress);
+  const tokenAddress = _ethers.getAddress.call(void 0, context.tokenAddress);
+  if (BigInt(protocolAddress) === 0n) throw new RangeError("protocol address must be nonzero");
+  return { chainId: context.chainId, protocolAddress, tokenAddress };
+}
+function encrypted(recipient) {
+  return recipient.type === "invisi" || recipient.type === "evm" && recipient.envelope !== false;
+}
+function rejectLegacy(value) {
+  for (const key of [
+    "expectedCommitment",
+    "nonce",
+    "envelope",
+    "context",
+    "to",
+    "addressResolver",
+    "addressLookup"
+  ])
+    if (key in value) throw new TypeError(`${key} is not a NoteOutput create option`);
+}
+var outputCreation = /* @__PURE__ */ Symbol("NoteOutput.create");
+var NoteOutput = class _NoteOutput {
+  
+  
+  
+  
+  
+  
+  /** Encrypted EVM delivery is resolved by preparation; the original offline intent stays pending. */
+  
+  constructor(output, token, ipp) {
+    if (token !== outputCreation)
+      throw new TypeError("outputs must be created with NoteOutput.create");
+    const saved = structuredClone(output);
+    this.ipp = ipp;
+    this.to = saved.address;
+    this.amount = saved.amount;
+    this.identity = saved.identity;
+    this.commitment = saved.commitment;
+    this.deliveryFingerprint = fingerprint(saved.delivery);
+    this.deliveryPending = saved.deliveryPending === true;
+    Object.defineProperties(this, {
+      context: { enumerable: true, get: () => structuredClone(saved.context) },
+      recipient: { enumerable: true, get: () => structuredClone(saved.recipient) },
+      nonce: { enumerable: true, get: () => _optionalChain([saved, 'access', _24 => _24.note, 'optionalAccess', _25 => _25.nonce]) },
+      payload: { enumerable: true, get: () => payloadCopy(_optionalChain([saved, 'access', _26 => _26.note, 'optionalAccess', _27 => _27.payload])) },
+      preparedOutput: { enumerable: true, get: () => structuredClone(saved) }
+    });
+    Object.freeze(this);
+  }
+  /** Private offline delivery data; does not assert that the output has been mined. */
+  exportPaymentNote() {
+    return exportPaymentNote(this.preparedOutput);
+  }
+  static async create(input, execution = {}) {
+    if (typeof input !== "string") rejectLegacy(input);
+    const request = typeof input === "string" ? decodePaymentRequest(input) : structuredClone(input);
+    rejectLegacy(request);
+    const options = applyExecutionOptions(request, execution);
+    if (typeof options.amount !== "bigint" || options.amount <= 0n || options.amount >= 1n << 128n)
+      throw new RangeError("amount must be a positive uint128");
+    const context = checkedContext(options);
+    const recipient = structuredClone(options.recipient);
+    if (!recipient || !["evm", "invisi", "identity"].includes(recipient.type))
+      throw new TypeError("invalid recipient type");
+    if ("expectedCommitment" in recipient)
+      throw new TypeError("expectedCommitment is not supported");
+    const envelope = encrypted(recipient);
+    if (!envelope && options.payload !== void 0)
+      throw new TypeError("payload requires an encrypted envelope");
+    let identity;
+    let note;
+    let resolved;
+    let address;
+    if (recipient.type === "identity") {
+      if ("nonce" in recipient || "envelope" in recipient || "addressLookup" in recipient)
+        throw new TypeError("identity recipient cannot specify nonce or envelope");
+      identity = identityValue(recipient.identity);
+      address = identity;
+    } else {
+      if (recipient.type === "evm" && recipient.envelope !== void 0 && typeof recipient.envelope !== "boolean")
+        throw new TypeError("evm envelope must be boolean");
+      if (recipient.type === "invisi" && "envelope" in recipient)
+        throw new TypeError("invisi recipient is always encrypted");
+      let parsed;
+      try {
+        parsed = _core.ReceivingAddress.parse(recipient.address);
+      } catch (cause) {
+        throw new InvisiError("INVALID_RECIPIENT", "Invalid recipient address", {
+          address: recipient.address,
+          field: "to",
+          cause
+        });
+      }
+      if (recipient.type === "evm" !== (parsed.kind === "short"))
+        throw new TypeError("recipient address type mismatch");
+      resolved = parsed;
+      if (recipient.type === "evm") {
+        if (recipient.addressLookup !== void 0 && recipient.addressLookup !== "chain" && recipient.addressLookup !== "protocol-rpc")
+          throw new TypeError("invalid recipient addressLookup");
+        recipient.addressLookup ??= "protocol-rpc";
+      } else if ("addressLookup" in recipient)
+        throw new TypeError("addressLookup only applies to EVM recipients");
+      const nonce2 = nonceValue(
+        recipient.nonce === void 0 ? _core.generateNonce.call(void 0, ) : recipient.nonce
+      );
+      recipient.nonce = nonce2;
+      identity = await _core.computeNoteIdentity.call(void 0, BigInt(resolved.ownerAddress), nonce2);
+      address = recipient.address;
+      note = {
+        chainId: context.chainId,
+        protocolAddress: BigInt(context.protocolAddress),
+        tokenAddress: BigInt(context.tokenAddress),
+        ownerAddress: resolved.ownerAddress,
+        amount: options.amount,
+        nonce: nonce2,
+        payload: payloadCopy(options.payload)
+      };
+    }
+    const commitment = await _core.computeNoteCommitment.call(void 0, 
+      context.chainId,
+      identity,
+      BigInt(context.tokenAddress),
+      options.amount
+    );
+    let delivery = { ciphertext: "0x", clue: "0x" };
+    if (envelope && recipient.type === "invisi") {
+      const keys = resolved.getReceivingKeys();
+      delivery = {
+        ciphertext: _ethers.hexlify.call(void 0, 
+          await _core.encryptPrivateTransferNote.call(void 0, keys.viewingPublicKey, note, {
+            chainId: context.chainId,
+            protocolAddress: BigInt(context.protocolAddress),
+            outputCommitment: commitment
+          })
+        ),
+        clue: _ethers.hexlify.call(void 0, _core.createClue.call(void 0, keys.clueKey))
+      };
+    }
+    const ipp = typeof input === "string" ? input : encodePaymentRequest(request);
+    return new _NoteOutput(
+      {
+        context,
+        recipient,
+        amount: options.amount,
+        ...note ? { note } : {},
+        identity,
+        commitment,
+        delivery,
+        ...envelope && recipient.type === "evm" ? { deliveryPending: true } : {},
+        address,
+        change: false
+      },
+      outputCreation,
+      ipp
+    );
+  }
+  assertCommitment(expectedHex) {
+    if (typeof expectedHex !== "string" || expectedHex.toLowerCase() !== this.commitment.toLowerCase())
+      throw new Error("note output commitment mismatch");
+  }
+  get note() {
+    return this.preparedOutput.note;
+  }
+  get delivery() {
+    return this.preparedOutput.delivery;
+  }
+};
+async function materializeNoteOutput(payment, context, lookup) {
+  if ("expectedCommitment" in payment) throw new TypeError("expectedCommitment is not supported");
+  const cached = payment.preparedOutput;
+  if (cached === void 0) throw new TypeError("outputs must be created with NoteOutput.create");
+  const output = structuredClone(cached);
+  const expectedContext = checkedContext(context);
+  const copied = payment;
+  for (const actual of [output.context, copied.context]) {
+    if (!actual || actual.chainId !== expectedContext.chainId || BigInt(actual.protocolAddress) !== BigInt(expectedContext.protocolAddress) || BigInt(actual.tokenAddress) !== BigInt(expectedContext.tokenAddress))
+      throw new Error("note output chain, protocol or token mismatch");
+  }
+  if (output.amount !== payment.amount || output.address !== payment.to || output.identity !== copied.identity || output.commitment !== copied.commitment || JSON.stringify(output.recipient, (_, v) => typeof v === "bigint" ? v.toString() : v) !== JSON.stringify(copied.recipient, (_, v) => typeof v === "bigint" ? v.toString() : v))
+    throw new Error("note output material does not match payment intent");
+  if (fingerprint(output.delivery) !== copied.deliveryFingerprint)
+    throw new Error("note output delivery fingerprint mismatch");
+  const hasCiphertext = output.delivery.ciphertext !== "0x";
+  const hasClue = output.delivery.clue !== "0x";
+  const pending = output.deliveryPending === true;
+  if (copied.deliveryPending !== pending || "deliveryPending" in output && output.deliveryPending !== true)
+    throw new Error("note output pending delivery mismatch");
+  if (hasCiphertext !== hasClue || (pending ? hasCiphertext || output.recipient.type !== "evm" || !encrypted(output.recipient) : hasCiphertext !== encrypted(output.recipient)))
+    throw new Error("note output delivery mode mismatch");
+  const recipient = output.recipient;
+  if ("expectedCommitment" in recipient) throw new Error("expectedCommitment is not supported");
+  if (!encrypted(recipient) && payloadCopy(payment.payload).length !== 0)
+    throw new Error("payload requires an encrypted envelope");
+  if (recipient.type === "identity") {
+    if (!/^0x[0-9a-fA-F]{64}$/.test(output.identity) || output.address !== output.identity || output.note || "nonce" in recipient || "envelope" in recipient || "addressLookup" in recipient || recipient.identity.toLowerCase() !== output.identity.toLowerCase())
+      throw new Error("opaque identity output material mismatch");
+    identityValue(output.identity);
+  } else {
+    const note = output.note;
+    const parsed = _core.ReceivingAddress.parse(recipient.address);
+    if (recipient.type === "evm" && recipient.addressLookup !== void 0 && recipient.addressLookup !== "chain" && recipient.addressLookup !== "protocol-rpc")
+      throw new Error("invalid recipient addressLookup");
+    if (recipient.type === "invisi" && "addressLookup" in recipient)
+      throw new Error("addressLookup only applies to EVM recipients");
+    if (output.address !== recipient.address || recipient.type === "evm" && recipient.envelope !== void 0 && typeof recipient.envelope !== "boolean" || recipient.type === "invisi" && "envelope" in recipient)
+      throw new Error("recipient material mismatch");
+    if (!note || note.chainId !== context.chainId || note.protocolAddress !== BigInt(context.protocolAddress) || note.tokenAddress !== BigInt(context.tokenAddress) || note.ownerAddress !== parsed.ownerAddress || note.amount !== output.amount || note.nonce !== recipient.nonce || note.nonce !== payment.nonce || _ethers.hexlify.call(void 0, payloadCopy(note.payload)) !== _ethers.hexlify.call(void 0, payloadCopy(payment.payload)))
+      throw new Error("note output opening does not match payment intent");
+    if (recipient.type === "evm" !== (parsed.kind === "short"))
+      throw new Error("recipient type mismatch");
+    if (await _core.computeNoteIdentity.call(void 0, BigInt(note.ownerAddress), nonceValue(note.nonce)) !== output.identity)
+      throw new Error("note output identity mismatch");
+  }
+  if (typeof output.amount !== "bigint" || output.amount <= 0n || output.amount >= 1n << 128n || await _core.computeNoteCommitment.call(void 0, 
+    context.chainId,
+    output.identity,
+    BigInt(context.tokenAddress),
+    output.amount
+  ) !== output.commitment)
+    throw new Error("note output commitment mismatch");
+  assertRequestMatchesOutput(payment.ipp, output);
+  if (pending) {
+    if (recipient.type !== "evm") throw new Error("only EVM outputs may have pending delivery");
+    const resolved = await resolveRecipient(
+      recipient.address,
+      _optionalChain([lookup, 'optionalCall', _28 => _28(_nullishCoalesce(recipient.addressLookup, () => ( "protocol-rpc")))]),
+      { field: "to" }
+    );
+    const keys = resolved.getReceivingKeys();
+    output.delivery = {
+      ciphertext: _ethers.hexlify.call(void 0, 
+        await _core.encryptPrivateTransferNote.call(void 0, keys.viewingPublicKey, output.note, {
+          chainId: context.chainId,
+          protocolAddress: BigInt(context.protocolAddress),
+          outputCommitment: output.commitment
+        })
+      ),
+      clue: _ethers.hexlify.call(void 0, _core.createClue.call(void 0, keys.clueKey))
+    };
+    delete output.deliveryPending;
+  }
+  return output;
+}
+function resolvedOutputSnapshot(payment, output) {
+  const copy = structuredClone(payment);
+  Object.assign(copy, {
+    preparedOutput: structuredClone(output),
+    deliveryFingerprint: fingerprint(output.delivery),
+    deliveryPending: false
+  });
+  return copy;
+}
+
+// src/notes/recipient-infrastructure.ts
+
+
+
+
+var _rpc = require('@invisi-labs/rpc');
+var recipientInfrastructure = /* @__PURE__ */ Symbol("SDK recipient infrastructure");
+function configureRecipientInfrastructure(options) {
+  const { provider, protocolRpc, chainReader } = options;
+  const registry = options.protocol.deployment.registry;
+  const deployment = options.protocol.deployment;
+  const lookup = (source) => async (ownerAddress) => {
+    if (!registry) throw new (0, _core.MissingCapabilityError)("receiving-key registry deployment");
+    if (source === "chain") {
+      if (!provider)
+        throw new (0, _core.MissingCapabilityError)("ethers provider for registry lookup");
+      return new (0, _chunk7F7ZZW3Lcjs.EthersAddressResolver)(
+        provider,
+        {
+          chainId: deployment.chainId,
+          registryAddress: registry.address
+        },
+        registry.runtimeCodeHash
+      ).lookup(ownerAddress);
+    }
+    if (!(protocolRpc instanceof _rpc.ProtocolRpcClient))
+      throw new (0, _core.MissingCapabilityError)("Protocol RPC recipient discovery");
+    const rpc = chainReader ? protocolRpc.withReader(chainReader) : protocolRpc;
+    const discovered = await rpc.getDeployment(deployment.chainId);
+    if (discovered.protocol.address !== deployment.protocol.address || discovered.protocol.runtimeCodeHash !== deployment.protocol.runtimeCodeHash || discovered.protocol.fromBlock !== deployment.protocol.fromBlock || _optionalChain([discovered, 'access', _29 => _29.registry, 'optionalAccess', _30 => _30.address]) !== registry.address || discovered.registry.runtimeCodeHash !== registry.runtimeCodeHash || discovered.registry.fromBlock !== registry.fromBlock)
+      throw new Error("Recipient registry deployment pins mismatch");
+    const registration = await rpc.getReceivingAddress(ownerAddress);
+    return registration ? _core.ReceivingAddress.parse(registration.receivingAddress).getReceivingKeys() : null;
+  };
+  return { ...options, [recipientInfrastructure]: lookup };
+}
+function recipientLookup(options, source = "protocol-rpc") {
+  return async (ownerAddress) => {
+    const lookup = options[recipientInfrastructure];
+    if (!lookup) throw new (0, _core.MissingCapabilityError)("recipient infrastructure");
+    return lookup(source)(ownerAddress);
+  };
+}
+
+// src/discovery/membership.ts
+
+async function verifyMembership(reader, context, block, input, proof) {
+  if (proof.block.hash !== block.hash || proof.block.number !== block.number || proof.leaf !== input.commitment || proof.treeId !== input.treeId || proof.leafIndex !== input.leafIndex || proof.path.length !== 16 || !Number.isInteger(input.leafIndex) || input.leafIndex < 0 || input.leafIndex >= 65536 || !await reader.isKnownRoot(context, input.treeId, proof.root, block))
+    throw new Error("membership context/root mismatch");
+  let root = BigInt(input.commitment);
+  for (let i = 0; i < 16; i++) {
+    const sibling = proof.path[i];
+    if (typeof sibling !== "bigint" || sibling < 0n || sibling >= _core.FIELD_MODULUS)
+      throw new Error("noncanonical membership path");
+    root = BigInt(
+      await _core.poseidonHash.call(void 0, input.leafIndex >> i & 1 ? [sibling, root] : [root, sibling])
+    );
+  }
+  if (root !== BigInt(proof.root))
+    throw new Error("membership path does not produce canonical root");
+}
+
+// src/transactions/preparation/credit-values.ts
+
+
+
+
+async function creditLeaf(state) {
+  const n = state.note;
+  return _core.computeCreditCommitment.call(void 0, 
+    n.chainId,
+    n.spenderWalletIdentity,
+    n.ownerWalletIdentity,
+    n.spenderPayout,
+    n.ownerPayout,
+    n.tokenAddress,
+    n.amount,
+    n.nonce,
+    n.expiry,
+    await _core.computeCreditSharedKeyHash.call(void 0, n.creditSharedKey),
+    n
+  );
+}
+
+// src/transactions/preparation/transaction-preparation.ts
+
+
+
+
+
+
+
+
+// src/transactions/preparation/prepare-common.ts
+
+
+
+
+
+
+
+
+
+
+// src/transactions/preparation/selection.ts
+function selectNotes(notes, target, reserved) {
+  if (typeof target !== "bigint" || target < 0n)
+    throw new Error("selection target must be a nonnegative amount");
+  if (target === 0n) return [];
+  const eligible = notes.filter(
+    (note) => note.spent === "unspent" && !reserved.has(note.commitment)
+  );
+  for (const record of eligible)
+    if (typeof record.note.amount !== "bigint" || record.note.amount <= 0n || record.note.amount >= 1n << 128n)
+      throw new Error("invalid verified note amount");
+  eligible.sort(
+    (a, b) => a.note.amount > b.note.amount ? -1 : a.note.amount < b.note.amount ? 1 : a.treeId < b.treeId ? -1 : a.treeId > b.treeId ? 1 : a.leafIndex - b.leafIndex || a.commitment.localeCompare(b.commitment)
+  );
+  const selected = [];
+  let total = 0n;
+  for (const record of eligible) {
+    selected.push(structuredClone(record));
+    total += record.note.amount;
+    if (total >= target) return selected;
+  }
+  throw new Error("insufficient verified available funds");
+}
+
+// src/transactions/preparation/prepare-common.ts
+function positiveAmount(value, bits = 128) {
+  if (typeof value !== "bigint" || value <= 0n || value >= 1n << BigInt(bits)) {
+    throw new Error(`amount must be a positive uint${bits}`);
+  }
+  return value;
+}
+function copyApplicationPayload(value) {
+  if (value === void 0) return new Uint8Array();
+  if (!(value instanceof Uint8Array)) throw new TypeError("payload must be Uint8Array");
+  return Uint8Array.from(value);
+}
+function positiveOutputAmount(payment, outputIndex) {
+  try {
+    return positiveAmount(payment.amount);
+  } catch (cause) {
+    throw new InvisiError(
+      "PREPARATION_FAILED",
+      cause instanceof Error ? cause.message : "Invalid output amount",
+      {
+        address: payment.to,
+        field: "amount",
+        ...outputIndex === void 0 ? {} : { outputIndex },
+        cause
+      }
+    );
+  }
+}
+var Preparation = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  #roots = /* @__PURE__ */ new Map();
+  async frame(requested) {
+    const { reader, options } = this.runtime;
+    await options.protocol.validateDeployment(reader);
+    const block = await reader.getBlock(await reader.getLatestBlockNumber());
+    const deadline = _nullishCoalesce(requested, () => ( block.timestamp + (_nullishCoalesce(options.transactionTTL, () => ( 300n)))));
+    if (typeof deadline !== "bigint" || deadline < block.timestamp || deadline >= 1n << 64n) {
+      throw new Error("invalid transaction deadline");
+    }
+    const state = await this.runtime.readInventory();
+    if (state.invalidated) {
+      throw new Error("wallet requires canonical resync");
+    }
+    for (const point of [state.observedThrough]) {
+      if (point && (await reader.getBlock(point.number)).hash !== point.hash) {
+        throw new Error("canonical wallet checkpoint changed; resync required");
+      }
+    }
+    return {
+      context: {
+        ...options.protocol.context,
+        now: block.timestamp,
+        timestamp: block.timestamp
+      },
+      block,
+      deadline
+    };
+  }
+  async assertBlock(frame) {
+    if ((await this.runtime.reader.getBlock(frame.block.number)).hash !== frame.block.hash) {
+      throw new Error("canonical block changed while preparing");
+    }
+  }
+  async funding(source, frame) {
+    if (!source) {
+      return { funding: {}, fundingMode: "none" };
+    }
+    positiveAmount(source.amount);
+    const payer = _ethers.getAddress.call(void 0, source.payer);
+    const mode = _nullishCoalesce(source.authorization, () => ( "signature"));
+    if (BigInt(payer) === 0n) {
+      throw new Error("funding payer must be nonzero");
+    }
+    if (mode !== "signature" && mode !== "caller") {
+      throw new Error("invalid funding authorization mode");
+    }
+    if (mode === "caller" && (source.sigNonce || source.deadline)) {
+      throw new Error("caller funding uses zero nonce/deadline");
+    }
+    const funding = _protocol.normalizeFunding.call(void 0, {
+      payer,
+      amount: source.amount,
+      sigNonce: mode === "caller" ? 0n : await _asyncNullishCoalesce(source.sigNonce, async () => ( await this.runtime.reader.getFundingNonce(
+        frame.context,
+        payer,
+        frame.block
+      ))),
+      deadline: mode === "caller" ? 0n : _nullishCoalesce(source.deadline, () => ( frame.deadline)),
+      ...source.permit ? { permit: structuredClone(source.permit) } : {}
+    });
+    if (mode === "signature" && funding.deadline < frame.block.timestamp) {
+      throw new Error("funding authorization deadline has expired");
+    }
+    return { funding, fundingMode: mode };
+  }
+  async change(amount, context) {
+    const address = _nullishCoalesce(this.runtime.changeAddress, () => ( this.runtime.options.wallet.getReceivingAddress().toString()));
+    try {
+      const output = await NoteOutput.create({
+        chainId: context.chainId,
+        protocolAddress: context.protocolAddress,
+        tokenAddress: context.tokenAddress,
+        amount,
+        recipient: address.startsWith("0i") ? { type: "invisi", address } : { type: "evm", address }
+      });
+      return await this.output(output, context, true);
+    } catch (cause) {
+      if (cause instanceof InvisiError)
+        throw new InvisiError(cause.code, cause.message, {
+          address,
+          field: "changeAddress",
+          ...cause.capability ? { capability: cause.capability } : {},
+          cause: _nullishCoalesce(cause.cause, () => ( cause))
+        });
+      throw new InvisiError(
+        "PREPARATION_FAILED",
+        cause instanceof Error ? cause.message : "Change output preparation failed",
+        { address, field: "changeAddress", cause }
+      );
+    }
+  }
+  async output(payment, context, change = false, outputIndex) {
+    try {
+      positiveOutputAmount(payment, outputIndex);
+      const output = await materializeNoteOutput(
+        payment,
+        context,
+        (source) => recipientLookup(this.runtime.options, source)
+      );
+      return { ...output, change };
+    } catch (cause) {
+      if (cause instanceof InvisiError) {
+        throw new InvisiError(cause.code, cause.message, {
+          address: _nullishCoalesce(cause.address, () => ( payment.to)),
+          field: change ? "changeAddress" : _nullishCoalesce(cause.field, () => ( "to")),
+          ...outputIndex === void 0 ? {} : { outputIndex },
+          ...cause.capability ? { capability: cause.capability } : {},
+          cause: _nullishCoalesce(cause.cause, () => ( cause))
+        });
+      }
+      throw new InvisiError(
+        "PREPARATION_FAILED",
+        cause instanceof Error ? cause.message : "Output preparation failed",
+        {
+          address: payment.to,
+          field: change ? "changeAddress" : "to",
+          ...outputIndex === void 0 ? {} : { outputIndex },
+          cause
+        }
+      );
+    }
+  }
+  async membership(input, frame) {
+    const { options, reader } = this.runtime;
+    if (!options.protocolRpc)
+      throw new (0, _core.MissingCapabilityError)("Protocol RPC membership provider");
+    const root = this.#roots.get(input.treeId);
+    const proof = await options.protocolRpc.getMembership(
+      frame.context,
+      {
+        ...input,
+        ...root ? { root } : {}
+      },
+      frame.block
+    );
+    if (root && proof.root !== root)
+      throw new Error("membership provider changed the pinned source root");
+    await verifyMembership(reader, frame.context, frame.block, input, proof);
+    this.#roots.set(input.treeId, proof.root);
+    return { ...proof, path: [...proof.path] };
+  }
+  async selectFunds(target, frame, maxInputs = 168) {
+    const { scope, options, reader } = this.runtime;
+    const state = await this.runtime.readInventory();
+    if (state.invalidated) {
+      throw new Error("wallet requires canonical resync");
+    }
+    const need = target > 0n ? target : 0n;
+    const nullifier = options.wallet.exportNullifier();
+    const reserved = new Set(Object.keys(state.reservations));
+    const eligible = Object.values(state.notes).filter(
+      (note) => note.note.tokenAddress === BigInt(frame.context.tokenAddress) && note.spent === "unspent" && !reserved.has(note.commitment)
+    );
+    const byId = new Map(eligible.map((note) => [note.commitment, note]));
+    const choices = this.runtime.inputSelection ? [...this.runtime.inputSelection] : this.runtime.explicitInputs ? eligible.map((note) => note.commitment) : need > 0n && options.coinSelector ? await options.coinSelector.select(storedCandidates(eligible), need) : selectNotes(eligible, need, reserved).map((note) => note.commitment);
+    if (!Array.isArray(choices) || new Set(choices).size !== choices.length || choices.some((id) => !byId.has(id))) {
+      throw new Error("invalid or duplicate coin selection");
+    }
+    const selected = choices.map((id) => structuredClone(byId.get(id)));
+    const amount = selected.reduce((sum, input) => sum + input.note.amount, 0n);
+    if (amount < need) {
+      throw new Error("coin selection has insufficient verified funds");
+    }
+    if (selected.length > maxInputs || amount >= 1n << 135n) {
+      throw new Error("coin selection exceeds transaction capacity");
+    }
+    const inputs = [];
+    const sources = /* @__PURE__ */ new Map();
+    const nullifiers = [];
+    for (const input of selected) {
+      const note = input.note;
+      const c = frame.context;
+      if (note.ownerAddress !== scope.ownerAddress || note.chainId !== c.chainId || note.protocolAddress !== BigInt(c.protocolAddress) || note.tokenAddress !== BigInt(c.tokenAddress) || await _core.computeNoteCommitment.call(void 0, 
+        c.chainId,
+        await _core.computeNoteIdentity.call(void 0, BigInt(note.ownerAddress), note.nonce),
+        note.tokenAddress,
+        note.amount
+      ) !== input.commitment) {
+        throw new Error("selected input preimage/context mismatch");
+      }
+      const proof = await this.membership(input, frame);
+      const path = [...proof.path];
+      const root = proof.root;
+      if (sources.has(input.treeId) && sources.get(input.treeId) !== root) {
+        throw new Error("source roots do not share a canonical snapshot");
+      }
+      sources.set(input.treeId, root);
+      inputs.push({
+        note,
+        commitment: input.commitment,
+        treeId: input.treeId,
+        leafIndex: input.leafIndex,
+        path
+      });
+      nullifiers.push(
+        await nullifier.compute(c.chainId, input.commitment, input.note.nonce)
+      );
+    }
+    await this.assertUnspent(nullifiers, frame);
+    return {
+      inputs,
+      sources: [...sources].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([treeId, merkleRoot]) => ({ treeId, merkleRoot })),
+      nullifiers,
+      amount
+    };
+  }
+  async assertUnspent(nullifiers, frame) {
+    if (nullifiers.length) {
+      const spent = await this.runtime.reader.isSpent(frame.context, nullifiers, frame.block);
+      if (spent.length !== nullifiers.length || spent.some((value) => value !== false)) {
+        throw new Error("selected input spent or invalid spent-state response");
+      }
+    }
+  }
+};
+function storedCandidates(inputs) {
+  const records = inputs.filter(
+    (input) => "blockNumber" in input && typeof input.blockNumber === "bigint" && "blockHash" in input && typeof input.blockHash === "string"
+  );
+  if (records.length !== inputs.length)
+    throw new Error("custom coin selection requires stored receipt metadata");
+  return structuredClone(records);
+}
+
+// src/transactions/preparation/prepare-credit.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var EMPTY = { ciphertext: "0x", clue: "0x" };
+var CreditPreparation = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.#prepare = new Preparation(runtime);
+  }
+  #prepare;
+  expiry(value, frame) {
+    if (typeof value !== "bigint" || value <= frame.block.timestamp || value >= 1n << 64n) {
+      throw new Error("Credit expiry must be a future uint64 timestamp");
+    }
+    return value;
+  }
+  async seal(input, frame) {
+    const state = _core.normalizeCreditDeliveryState.call(void 0, input);
+    const commitment = await creditLeaf(state);
+    const context = {
+      chainId: frame.context.chainId,
+      protocolAddress: BigInt(frame.context.protocolAddress),
+      outputCommitment: commitment
+    };
+    const deliveries = await Promise.all(
+      ["owner", "spender"].map(async (role) => {
+        const keys = role === "owner" ? state.ownerReceivingKeys : state.spenderReceivingKeys;
+        return {
+          ciphertext: _ethers.hexlify.call(void 0, 
+            await _core.encryptCreditNote.call(void 0, keys.viewingPublicKey, state, { ...context, role })
+          ),
+          clue: _ethers.hexlify.call(void 0, _core.createClue.call(void 0, keys.clueKey))
+        };
+      })
+    );
+    return { state, commitment, deliveries };
+  }
+  async input(commitment, role, frame) {
+    const stored = (await this.runtime.readInventory()).credits[commitment + ":" + role];
+    if (!stored || stored.spent !== "unspent" || stored.role !== role) {
+      throw new Error(`confirmed unspent ${role} Credit is unavailable`);
+    }
+    const state = _core.normalizeCreditDeliveryState.call(void 0, stored.state);
+    const n = state.note;
+    if ((role === "owner" ? n.ownerWalletIdentity : n.spenderWalletIdentity) !== this.runtime.scope.ownerAddress || n.chainId !== frame.context.chainId || n.protocolAddress !== BigInt(frame.context.protocolAddress) || n.tokenAddress !== BigInt(frame.context.tokenAddress) || await creditLeaf(state) !== commitment) {
+      throw new Error("Credit role, commitment or deployment mismatch");
+    }
+    const proof = await this.#prepare.membership(stored, frame);
+    const path = [...proof.path];
+    const nullifier = await _core.computeCreditNullifier.call(void 0, n.chainId, n.creditSharedKey, commitment);
+    await this.#prepare.assertUnspent([nullifier], frame);
+    return {
+      input: {
+        state,
+        commitment,
+        role,
+        treeId: stored.treeId,
+        leafIndex: stored.leafIndex,
+        path
+      },
+      nullifier,
+      source: {
+        treeId: stored.treeId,
+        merkleRoot: proof.root
+      }
+    };
+  }
+  base(frame, kind) {
+    return {
+      version: 1,
+      id: crypto.randomUUID(),
+      kind,
+      context: frame.context,
+      scope: this.runtime.scope,
+      preparedAt: frame.block,
+      deadline: frame.deadline,
+      outputs: [],
+      inputs: [],
+      funding: {},
+      fundingMode: "none"
+    };
+  }
+  async create(options) {
+    positiveAmount(options.amount, 126);
+    const frame = await this.#prepare.frame(options.deadline);
+    const expiry = this.expiry(options.expiry, frame);
+    const spender = await resolveRecipient(
+      options.spender,
+      recipientLookup(this.runtime.options),
+      { field: "spender" }
+    );
+    const owner = await resolveRecipient(
+      this.runtime.options.wallet.getReceivingAddress().toString(),
+      recipientLookup(this.runtime.options),
+      { field: "wallet" }
+    );
+    const ownerPayout = _ethers.getAddress.call(void 0, owner.ownerAddress);
+    const spenderPayout = _ethers.getAddress.call(void 0, spender.ownerAddress);
+    if (BigInt(ownerPayout) === 0n || BigInt(spenderPayout) === 0n) {
+      throw new Error("Credit payouts must be nonzero");
+    }
+    const output = await this.seal(
+      {
+        note: {
+          chainId: frame.context.chainId,
+          protocolAddress: BigInt(frame.context.protocolAddress),
+          tokenAddress: BigInt(frame.context.tokenAddress),
+          ownerWalletIdentity: this.runtime.scope.ownerAddress,
+          spenderWalletIdentity: spender.ownerAddress,
+          ownerPayout: BigInt(ownerPayout),
+          spenderPayout: BigInt(spenderPayout),
+          ..._core.normalizeCreditPolicy.call(void 0, {
+            singleLimit: _nullishCoalesce(options.singleLimit, () => ( 0n)),
+            dailyLimit: _nullishCoalesce(options.dailyLimit, () => ( 0n)),
+            monthlyLimit: _nullishCoalesce(options.monthlyLimit, () => ( 0n))
+          }),
+          amount: options.amount,
+          payload: copyApplicationPayload(options.payload),
+          expiry,
+          nonce: _core.generateNonce.call(void 0, ),
+          creditSharedKey: _core.generateCreditSharedKey.call(void 0, )
+        },
+        ownerReceivingKeys: owner.getReceivingKeys(),
+        spenderReceivingKeys: spender.getReceivingKeys()
+      },
+      frame
+    );
+    return this.creation(
+      this.base(frame, "create-credit"),
+      output,
+      options.amount,
+      options.funding,
+      options.fee,
+      frame
+    );
+  }
+  async creation(plan, output, delta, fundingSource, fee, frame, previous) {
+    const funding = await this.#prepare.funding(fundingSource, frame);
+    const selected = await this.#prepare.selectFunds(
+      delta + (_nullishCoalesce(_optionalChain([fee, 'optionalAccess', _31 => _31.amount]), () => ( 0n))) - (_nullishCoalesce(funding.funding.amount, () => ( 0n))),
+      frame,
+      10
+    );
+    const change = selected.amount + (_nullishCoalesce(funding.funding.amount, () => ( 0n))) - delta - (_nullishCoalesce(_optionalChain([fee, 'optionalAccess', _32 => _32.amount]), () => ( 0n)));
+    plan.inputs = selected.inputs;
+    Object.assign(plan, funding);
+    if (change > 0n) {
+      plan.outputs.push(await this.#prepare.change(change, frame.context));
+    }
+    const creation = {
+      token: frame.context.tokenAddress,
+      feeRecipient: _nullishCoalesce(_optionalChain([fee, 'optionalAccess', _33 => _33.recipient]), () => ( "0x0000000000000000000000000000000000000000")),
+      feeAmount: _nullishCoalesce(_optionalChain([fee, 'optionalAccess', _34 => _34.amount]), () => ( 0n)),
+      sources: selected.sources,
+      nullifiers: selected.nullifiers,
+      creditCommitment: output.commitment,
+      changeCommitment: _nullishCoalesce(_optionalChain([plan, 'access', _35 => _35.outputs, 'access', _36 => _36[0], 'optionalAccess', _37 => _37.commitment]), () => ( _protocol.word.call(void 0, 0n))),
+      owner: _ethers.getAddress.call(void 0, _ethers.toBeHex.call(void 0, output.state.note.ownerPayout, 20)),
+      expiry: output.state.note.expiry,
+      deadline: frame.deadline
+    };
+    const deliveries = [...output.deliveries, _nullishCoalesce(_optionalChain([plan, 'access', _38 => _38.outputs, 'access', _39 => _39[0], 'optionalAccess', _40 => _40.delivery]), () => ( { ...EMPTY }))];
+    plan.capacity = 10;
+    plan.credit = {
+      inputs: previous ? [previous.input] : [],
+      outputs: [output],
+      deliveries,
+      creation
+    };
+    if (previous) {
+      plan.credit.topUp = {
+        creation,
+        creditSource: previous.source,
+        creditNullifier: previous.nullifier,
+        previousExpiry: previous.input.state.note.expiry
+      };
+      plan.statement = _protocol.WitnessBuilder.statement(
+        "credit_top_up",
+        _protocol.topUpCreditPublicInputs.call(void 0, frame.context, plan.credit.topUp, deliveries, plan.funding)
+      );
+    } else {
+      plan.statement = _protocol.WitnessBuilder.statement(
+        "create_credit",
+        _protocol.createCreditPublicInputs.call(void 0, frame.context, creation, deliveries, plan.funding)
+      );
+    }
+    await this.#prepare.assertBlock(frame);
+    return this.runtime.complete(plan);
+  }
+  async topUp(options) {
+    positiveAmount(options.additionalAmount, 126);
+    const frame = await this.#prepare.frame(options.deadline);
+    const previous = await this.input(options.credit, "owner", frame);
+    const old = previous.input.state;
+    if (old.note.expiry <= frame.block.timestamp) {
+      throw new Error("previous Credit has expired");
+    }
+    const expiry = this.expiry(_nullishCoalesce(options.expiry, () => ( old.note.expiry)), frame);
+    if (expiry < old.note.expiry) {
+      throw new Error("Credit expiry must not decrease");
+    }
+    const amount = positiveAmount(old.note.amount + options.additionalAmount, 126);
+    const output = await this.seal(
+      {
+        ...old,
+        note: {
+          ...old.note,
+          singleLimit: _nullishCoalesce(_nullishCoalesce(options.singleLimit, () => ( old.note.singleLimit)), () => ( 0n)),
+          dailyLimit: _nullishCoalesce(_nullishCoalesce(options.dailyLimit, () => ( old.note.dailyLimit)), () => ( 0n)),
+          monthlyLimit: _nullishCoalesce(_nullishCoalesce(options.monthlyLimit, () => ( old.note.monthlyLimit)), () => ( 0n)),
+          amount,
+          expiry,
+          nonce: _core.generateNonce.call(void 0, ),
+          payload: copyApplicationPayload(
+            options.payload === void 0 ? old.note.payload : options.payload
+          )
+        }
+      },
+      frame
+    );
+    return this.creation(
+      this.base(frame, "top-up-credit"),
+      output,
+      options.additionalAmount,
+      options.funding,
+      options.fee,
+      frame,
+      previous
+    );
+  }
+  async draw(options) {
+    const frame = await this.#prepare.frame(options.deadline);
+    const profile = _protocol.selectCreditDrawCircuit.call(void 0, options.credits.length);
+    if (new Set(options.credits.map((value) => value.credit)).size !== options.credits.length) {
+      throw new Error("duplicate Credit input");
+    }
+    const members = await Promise.all(
+      options.credits.map((value) => this.input(value.credit, "spender", frame))
+    );
+    const payout = members[0].input.state.note.spenderPayout;
+    const sources = /* @__PURE__ */ new Map();
+    const outputs = [];
+    const deliveries = [];
+    const recoveryAmounts = [];
+    const remainders = [];
+    const amounts = [];
+    for (const [i, member] of members.entries()) {
+      const state = member.input.state;
+      const n = state.note;
+      const amount = positiveAmount(options.credits[i].amount, 126);
+      if (n.spenderPayout !== payout) {
+        throw new Error(
+          "Credit draw requires separate groups for different public payouts; one call must be atomic"
+        );
+      }
+      this.expiry(n.expiry, frame);
+      if (amount > n.amount) {
+        throw new Error("Credit draw exceeds remaining amount");
+      }
+      if (sources.has(member.source.treeId) && sources.get(member.source.treeId) !== member.source.merkleRoot) {
+        throw new Error("Credit source root mismatch");
+      }
+      sources.set(member.source.treeId, member.source.merkleRoot);
+      amounts.push(amount);
+      const usage = _core.applyCreditDrawUsage.call(void 0, n, amount, frame.block.timestamp);
+      const remaining = n.amount - amount;
+      if (remaining === 0n) {
+        remainders.push(_protocol.word.call(void 0, 0n));
+        recoveryAmounts.push(_protocol.word.call(void 0, 0n));
+        deliveries.push({ ...EMPTY }, { ...EMPTY });
+        continue;
+      }
+      const args = [
+        n.chainId,
+        n.protocolAddress,
+        n.tokenAddress,
+        BigInt(member.nullifier),
+        n.creditSharedKey
+      ];
+      const output = await this.seal(
+        {
+          ...state,
+          note: {
+            ...n,
+            ...usage,
+            amount: remaining,
+            payload: copyApplicationPayload(
+              options.credits[i].payload === void 0 ? n.payload : options.credits[i].payload
+            ),
+            nonce: await _core.deriveRemainderNonce.call(void 0, ...args)
+          }
+        },
+        frame
+      );
+      outputs.push(output);
+      remainders.push(output.commitment);
+      recoveryAmounts.push(
+        _protocol.word.call(void 0, (remaining + await _core.computeCreditRecoveryPad.call(void 0, ...args)) % _core.FIELD_MODULUS)
+      );
+      deliveries.push(...output.deliveries);
+    }
+    const plan = this.base(frame, "draw-credit");
+    const params = {
+      token: frame.context.tokenAddress,
+      sources: [...sources].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([treeId, merkleRoot]) => ({ treeId, merkleRoot })),
+      nullifiers: members.map((member) => member.nullifier),
+      remainderCommitments: remainders,
+      expiries: members.map((member) => member.input.state.note.expiry),
+      recoveryAmounts,
+      spender: _ethers.getAddress.call(void 0, _ethers.toBeHex.call(void 0, payout, 20)),
+      totalAmount: amounts.reduce((sum, amount) => sum + amount, 0n),
+      deadline: frame.deadline
+    };
+    plan.capacity = profile.maxSize;
+    plan.credit = {
+      inputs: members.map((member) => member.input),
+      outputs,
+      deliveries,
+      draw: params,
+      amounts
+    };
+    plan.statement = _protocol.WitnessBuilder.statement(
+      profile.name,
+      _protocol.creditDrawPublicInputs.call(void 0, frame.context, params, deliveries)
+    );
+    await this.#prepare.assertBlock(frame);
+    return this.runtime.complete(plan);
+  }
+  async cancel(options) {
+    const frame = await this.#prepare.frame(options.deadline);
+    const previous = await this.input(options.credit, "owner", frame);
+    const n = previous.input.state.note;
+    const plan = this.base(frame, "cancel-credit");
+    if ((_nullishCoalesce(_optionalChain([options, 'access', _41 => _41.fee, 'optionalAccess', _42 => _42.amount]), () => ( 0n))) >= n.amount)
+      throw new Error("fee must be less than the cancellation refund");
+    const params = {
+      feeRecipient: _nullishCoalesce(_optionalChain([options, 'access', _43 => _43.fee, 'optionalAccess', _44 => _44.recipient]), () => ( "0x0000000000000000000000000000000000000000")),
+      feeAmount: _nullishCoalesce(_optionalChain([options, 'access', _45 => _45.fee, 'optionalAccess', _46 => _46.amount]), () => ( 0n)),
+      token: frame.context.tokenAddress,
+      source: previous.source,
+      nullifier: previous.nullifier,
+      owner: _ethers.getAddress.call(void 0, _ethers.toBeHex.call(void 0, n.ownerPayout, 20)),
+      amount: n.amount,
+      deadline: frame.deadline
+    };
+    plan.capacity = 1;
+    plan.credit = { inputs: [previous.input], outputs: [], deliveries: [], cancel: params };
+    plan.statement = _protocol.WitnessBuilder.statement(
+      "credit_cancel",
+      _protocol.cancelCreditPublicInputs.call(void 0, frame.context, params)
+    );
+    await this.#prepare.assertBlock(frame);
+    return this.runtime.complete(plan);
+  }
+};
+
+// src/transactions/preparation/transaction-preparation.ts
+var TransactionPreparation = class {
+  constructor(context) {
+    this.context = context;
+    const complete = context.complete;
+    this.context = {
+      ...context,
+      complete: (plan) => {
+        const intent = this.#intent ? structuredClone(this.#intent) : void 0;
+        if (intent && (intent.kind === "transfer" || intent.kind === "shield")) {
+          const businessOutputs = plan.outputs.filter((output) => !output.change);
+          intent.options.outputs = intent.options.outputs.map(
+            (payment, index) => resolvedOutputSnapshot(payment, businessOutputs[index])
+          );
+        }
+        return complete({ ...plan, ...intent ? { intent } : {} });
+      }
+    };
+  }
+  #intent;
+  runtime(tokenAddress) {
+    if (_ethers.getAddress.call(void 0, tokenAddress) !== _ethers.getAddress.call(void 0, this.context.options.protocol.context.tokenAddress))
+      throw new Error("preparation token mismatch");
+    return this.context;
+  }
+  get scope() {
+    return this.context.scope;
+  }
+  async prepareTransfer(options) {
+    this.#intent = { kind: "transfer", options: structuredClone(options) };
+    if (Object.hasOwn(options, "target") || Object.hasOwn(options, "execution")) {
+      throw new Error(
+        "prepareTransfer accepts no target or execution; choose execution in prove()"
+      );
+    }
+    const copied = structuredClone(options);
+    const runtime = this.runtime(copied.tokenAddress);
+    if (copied.commitments !== void 0 && copied.commitments.length === 0)
+      throw new Error("empty explicit input selection");
+    const preparation = new Preparation({
+      ...runtime,
+      ...copied.commitments !== void 0 ? { inputSelection: copied.commitments } : {}
+    });
+    const frame = await preparation.frame(copied.deadline);
+    if (copied.outputs.length > 168) throw new Error("transfer supports at most 168 outputs");
+    let withdrawalAddress = _protocol.ZERO_ADDRESS;
+    let withdrawalAmount = 0n;
+    if (copied.withdrawal !== void 0) {
+      withdrawalAddress = _ethers.getAddress.call(void 0, copied.withdrawal.to);
+      positiveAmount(copied.withdrawal.amount);
+      if (BigInt(withdrawalAddress) === 0n)
+        throw new Error("withdrawal destination must be nonzero");
+      withdrawalAmount = copied.withdrawal.amount;
+    }
+    if (copied.outputs.length === 0 && withdrawalAmount === 0n)
+      throw new Error("transfer requires a private output or public withdrawal");
+    const feeRecipient = copied.fee ? _ethers.getAddress.call(void 0, copied.fee.recipient) : _protocol.ZERO_ADDRESS;
+    const feeAmount = _nullishCoalesce(_optionalChain([copied, 'access', _47 => _47.fee, 'optionalAccess', _48 => _48.amount]), () => ( 0n));
+    if (copied.fee) {
+      positiveAmount(feeAmount);
+      if (BigInt(feeRecipient) === 0n) throw new Error("fee recipient must be nonzero");
+    }
+    const total = copied.outputs.reduce(
+      (sum, output, index) => sum + positiveOutputAmount(output, index),
+      withdrawalAmount + feeAmount
+    );
+    const funding = await preparation.funding(copied.funding, frame);
+    return this.funds(
+      copied.outputs,
+      total,
+      withdrawalAddress,
+      withdrawalAmount,
+      { recipient: feeRecipient, amount: feeAmount },
+      frame,
+      funding,
+      preparation
+    );
+  }
+  async funds(payments, total, withdrawalAddress, withdrawalAmount, fee, frame, funding, preparation) {
+    if (total >= 1n << 135n) {
+      throw new Error("transaction sum exceeds uint135");
+    }
+    const { context, block, deadline } = frame;
+    const selection = await preparation.selectFunds(
+      total - (_nullishCoalesce(funding.funding.amount, () => ( 0n))),
+      frame
+    );
+    const outputs = await Promise.all(
+      payments.map((payment, index) => preparation.output(payment, context, false, index))
+    );
+    const change = selection.amount + (_nullishCoalesce(funding.funding.amount, () => ( 0n))) - total;
+    if (change > 0n) {
+      outputs.push(await preparation.change(change, context));
+    }
+    const params = {
+      token: context.tokenAddress,
+      sources: selection.sources,
+      nullifiers: selection.nullifiers,
+      outputCommitments: outputs.map((output) => output.commitment),
+      withdrawalAddress,
+      withdrawalAmount,
+      deadline,
+      feeRecipient: fee.recipient,
+      feeAmount: fee.amount
+    };
+    const deliveries = outputs.map((output) => output.delivery);
+    const normalized = _protocol.normalizeTransactRequest.call(void 0, context, params, deliveries, funding.funding);
+    const statement2 = _protocol.WitnessBuilder.statement(
+      `transact_user_slots${normalized.capacity}`,
+      _protocol.transactUserPublicInputs.call(void 0, context, params, deliveries, funding.funding),
+      "evm"
+    );
+    await preparation.assertBlock(frame);
+    return preparation.runtime.complete({
+      version: 1,
+      id: crypto.randomUUID(),
+      kind: "transfer",
+      context,
+      scope: this.scope,
+      preparedAt: block,
+      deadline,
+      outputs,
+      inputs: selection.inputs,
+      ...funding,
+      params,
+      capacity: normalized.capacity,
+      statement: statement2
+    });
+  }
+  async prepareShield(options) {
+    this.#intent = { kind: "shield", options: structuredClone(options) };
+    const copied = structuredClone(options);
+    const preparation = new Preparation(this.runtime(copied.tokenAddress));
+    const frame = await preparation.frame(copied.deadline);
+    const funding = await preparation.funding(copied.funding, frame);
+    if (copied.outputs.length < 1 || copied.outputs.length > 10) {
+      throw new Error("shield requires 1..10 outputs");
+    }
+    const outputs = await Promise.all(
+      copied.outputs.map(
+        (output, index) => preparation.output(output, frame.context, false, index)
+      )
+    );
+    if (outputs.reduce((sum, output) => sum + output.amount, 0n) !== (_nullishCoalesce(funding.funding.amount, () => ( 0n))) - (_nullishCoalesce(_optionalChain([copied, 'access', _49 => _49.fee, 'optionalAccess', _50 => _50.amount]), () => ( 0n)))) {
+      throw new Error("shield funding must equal output total");
+    }
+    await preparation.assertBlock(frame);
+    return preparation.runtime.complete({
+      version: 1,
+      id: crypto.randomUUID(),
+      kind: "shield",
+      context: frame.context,
+      scope: this.scope,
+      preparedAt: frame.block,
+      deadline: frame.deadline,
+      outputs,
+      inputs: [],
+      ...funding,
+      shieldParams: {
+        token: frame.context.tokenAddress,
+        feeRecipient: _nullishCoalesce(_optionalChain([copied, 'access', _51 => _51.fee, 'optionalAccess', _52 => _52.recipient]), () => ( _protocol.ZERO_ADDRESS)),
+        feeAmount: _nullishCoalesce(_optionalChain([copied, 'access', _53 => _53.fee, 'optionalAccess', _54 => _54.amount]), () => ( 0n)),
+        outputCommitments: outputs.map((output) => output.commitment),
+        deadline: frame.deadline
+      },
+      shieldOutputs: outputs.map((output) => ({
+        identity: output.identity,
+        amount: output.amount
+      }))
+    });
+  }
+  prepareCreateCredit(options) {
+    this.#intent = { kind: "create-credit", options: structuredClone(options) };
+    return new CreditPreparation(this.runtime(options.tokenAddress)).create(
+      structuredClone(options)
+    );
+  }
+  prepareDrawCredit(options) {
+    this.#intent = void 0;
+    return new CreditPreparation(this.runtime(options.tokenAddress)).draw(
+      structuredClone(options)
+    );
+  }
+  prepareTopUpCredit(options) {
+    this.#intent = { kind: "top-up-credit", options: structuredClone(options) };
+    return new CreditPreparation(this.runtime(options.tokenAddress)).topUp(
+      structuredClone(options)
+    );
+  }
+  prepareCancelCredit(options) {
+    this.#intent = { kind: "cancel-credit", options: structuredClone(options) };
+    return new CreditPreparation(this.runtime(options.tokenAddress)).cancel(
+      structuredClone(options)
+    );
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.InvisiError = InvisiError; exports.prepareWithErrors = prepareWithErrors; exports.encodePaymentNote = encodePaymentNote; exports.decodePaymentNote = decodePaymentNote; exports.exportPaymentNote = exportPaymentNote; exports.requiresAuthorization = requiresAuthorization; exports.statement = statement; exports.authorizationRequest = authorizationRequest; exports.operationExpired = operationExpired; exports.exportBroadcasterIntent = exportBroadcasterIntent; exports.encodePaymentRequest = encodePaymentRequest; exports.decodePaymentRequest = decodePaymentRequest; exports.NoteOutput = NoteOutput; exports.configureRecipientInfrastructure = configureRecipientInfrastructure; exports.recipientLookup = recipientLookup; exports.verifyMembership = verifyMembership; exports.positiveAmount = positiveAmount; exports.creditLeaf = creditLeaf; exports.TransactionPreparation = TransactionPreparation;
+//# sourceMappingURL=chunk-J2JH6HIG.cjs.map