@invisi-labs/sdk 1.1.6 → 1.1.7

package/dist/{chunk-FL4TIGWW.js → chunk-ITTGBIG2.js}

@@ -1,6 +1,6 @@
 import {
   EthersAddressResolver
-} from "./chunk-QC6TQR3R.js";
+} from "./chunk-XHKQ2BO2.js";
 
 // src/errors.ts
 import { MissingCapabilityError } from "@invisi-labs/core";
@@ -49,28 +49,472 @@ async function prepareWithErrors(operation, prepare) {
   }
 }
 
-// src/NoteOutput.ts
+// src/payment-note/codec.ts
+import { FIELD_MODULUS } from "@invisi-labs/core";
+import { decodeBase64, encodeBase64, getAddress, getBytes, hexlify, concat } from "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 getBytes(`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"]) {
+    getAddress(value[key]);
+    if (key !== "tokenAddress" && BigInt(value[key]) === 0n)
+      throw new RangeError(`Invalid ${key}`);
+  }
+  uint(value.nonce, 32);
+  if (value.nonce >= 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) >= FIELD_MODULUS)
+    throw new RangeError("Invalid payment note commitment");
+}
+function encodePaymentNote(value) {
+  validate(value);
+  const bytes = concat([
+    new Uint8Array([1]),
+    uint(value.chainId, 8),
+    getBytes(value.protocolAddress),
+    getBytes(value.tokenAddress),
+    uint(value.amount, 16),
+    getBytes(value.ownerAddress),
+    uint(value.nonce, 32),
+    getBytes(value.commitment)
+  ]);
+  return `ipn:${encodeBase64(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 = decodeBase64(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 = hexlify(bytes.slice(offset, offset += size));
+    return value2;
+  };
+  const value = {
+    chainId: BigInt(take(8)),
+    protocolAddress: getAddress(take(20)),
+    tokenAddress: getAddress(take(20)),
+    amount: BigInt(take(16)),
+    ownerAddress: getAddress(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
+import { creditPeriods } from "@invisi-labs/core";
 import {
-  FIELD_MODULUS,
-  ReceivingAddress as ReceivingAddress2,
+  WitnessBuilder,
+  cancelCreditPublicInputs,
+  createCreditPublicInputs,
+  creditDrawPublicInputs,
+  topUpCreditPublicInputs,
+  transactUserPublicInputs
+} from "@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 && (plan.params.feeAmount ?? 0n) === 0n && BigInt(plan.params.feeRecipient ?? 0n) === 0n && (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 (credit?.topUp) {
+    words = topUpCreditPublicInputs(
+      plan.context,
+      credit.topUp,
+      credit.deliveries,
+      plan.funding
+    );
+  } else if (credit?.creation) {
+    words = createCreditPublicInputs(
+      plan.context,
+      credit.creation,
+      credit.deliveries,
+      plan.funding
+    );
+  } else if (credit?.draw) {
+    words = creditDrawPublicInputs(plan.context, credit.draw, credit.deliveries);
+  } else if (credit?.cancel) {
+    words = cancelCreditPublicInputs(plan.context, credit.cancel);
+  } else {
+    words = transactUserPublicInputs(
+      plan.context,
+      plan.params,
+      plan.outputs.map((output) => output.delivery),
+      plan.funding
+    );
+  }
+  const result = 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 (credit?.topUp && now >= credit.topUp.previousExpiry) return true;
+  if (credit?.creation && now >= credit.creation.expiry) return true;
+  if (credit?.draw) {
+    if (credit.draw.expiries.some((expiry) => now >= expiry)) return true;
+    const prepared = creditPeriods(plan.preparedAt.timestamp), current = creditPeriods(now);
+    if (prepared.currentDay !== current.currentDay || prepared.currentMonth !== current.currentMonth)
+      return true;
+  }
+  return false;
+}
+
+// src/broadcaster/intent.ts
+import { normalizeFunding } from "@invisi-labs/protocol";
+import { invisiProtocolAbi } from "@invisi-labs/protocol/contracts";
+import { Interface } from "ethers";
+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: params.feeRecipient ?? "0x0000000000000000000000000000000000000000",
+    feeAmount: params.feeAmount ?? 0n
+  });
+  const funding = { ...normalizeFunding(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 (plan.credit?.topUp) {
+    method = "topUpCredit";
+    args = [
+      "0x",
+      { ...plan.credit.topUp, creation: feeDefaults(plan.credit.topUp.creation) },
+      plan.credit.deliveries,
+      funding
+    ];
+  } else if (plan.credit?.creation) {
+    method = "createCredit";
+    args = ["0x", feeDefaults(plan.credit.creation), plan.credit.deliveries, funding];
+  } else if (plan.credit?.cancel) {
+    method = "cancelCredit";
+    args = ["0x", feeDefaults(plan.credit.cancel)];
+  } else throw new Error("unsupported broadcaster operation");
+  const abi = invisiProtocolAbi.filter(
+    (item) => item.type === "function" && item.name === method && (method !== "transact" || item.inputs[1]?.type === "tuple")
+  );
+  return {
+    sendable: false,
+    data: new Interface(abi).encodeFunctionData(method, args)
+  };
+}
+
+// src/payment-request/codec.ts
+import { ReceivingAddress as ReceivingAddress2 } from "@invisi-labs/core";
+import { decodeBase64 as decodeBase642, encodeBase64 as encodeBase642, getBytes as getBytes2, hexlify as hexlify2 } from "ethers";
+
+// 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
+import { FIELD_MODULUS as FIELD_MODULUS2, MAX_CIPHERTEXT_BYTES, ReceivingAddress } from "@invisi-labs/core";
+import { getAddress as getAddress2 } from "ethers";
+var MAX_REQUEST_PAYLOAD_BYTES = 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 >= FIELD_MODULUS2)
+    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 = getAddress2(request.protocolAddress);
+  getAddress2(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) >= FIELD_MODULUS2)
+      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 = 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 ((request.payload?.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 encodeBase642(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"),
+    getBytes2(request.protocolAddress),
+    getBytes2(request.tokenAddress),
+    uint2(request.amount, 16, "amount")
+  ];
+  if (recipient.type === "identity") parts.push(getBytes2(recipient.identity));
+  else {
+    const parsed = ReceivingAddress2.parse(recipient.address);
+    parts.push(getBytes2(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 = 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 = decodeBase642(
+    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: hexlify2(reader.take(20)),
+    tokenAddress: hexlify2(reader.take(20)),
+    amount: reader.integer(16)
+  };
+  let recipient;
+  let payload;
+  if (type === 3n)
+    recipient = { type: "identity", identity: hexlify2(reader.take(32)) };
+  else {
+    const ownerAddress = hexlify2(reader.take(20));
+    let address;
+    let envelope = true;
+    if (type === 2n)
+      address = ReceivingAddress2.from({
+        ownerAddress,
+        viewingPublicKey: reader.take(33),
+        clueKey: reader.take(32)
+      }).toString();
+    else {
+      address = ReceivingAddress2.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
+import {
+  FIELD_MODULUS as FIELD_MODULUS3,
+  ReceivingAddress as ReceivingAddress5,
   computeNoteCommitment,
   computeNoteIdentity,
   createClue,
   encryptPrivateTransferNote,
   generateNonce
 } from "@invisi-labs/core";
-import { AbiCoder, getAddress, hexlify, keccak256 } from "ethers";
+import { AbiCoder, getAddress as getAddress3, hexlify as hexlify4, keccak256 } from "ethers";
 
-// src/resolve-recipient.ts
+// src/notes/resolve-recipient.ts
 import {
   MissingCapabilityError as MissingCapabilityError2,
-  ReceivingAddress
+  ReceivingAddress as ReceivingAddress3
 } from "@invisi-labs/core";
 async function resolveRecipient(address, lookup, details = {}) {
   const context = { ...details, address };
   let recipient;
   try {
-    recipient = ReceivingAddress.parse(address);
+    recipient = ReceivingAddress3.parse(address);
   } catch (cause) {
     throw new InvisiError("INVALID_RECIPIENT", "Invalid recipient address", {
       ...context,
@@ -108,7 +552,7 @@ async function resolveRecipient(address, lookup, details = {}) {
     );
   }
   try {
-    return ReceivingAddress.from({
+    return ReceivingAddress3.from({
       ownerAddress: recipient.ownerAddress,
       viewingPublicKey: keys.viewingPublicKey,
       clueKey: keys.clueKey
@@ -122,14 +566,65 @@ async function resolveRecipient(address, lookup, details = {}) {
   }
 }
 
-// src/NoteOutput.ts
+// src/payment-request/match-output.ts
+import { ReceivingAddress as ReceivingAddress4 } from "@invisi-labs/core";
+import { hexlify as hexlify3 } from "ethers";
+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 = ReceivingAddress4.parse(expected.address);
+  const resolved = ReceivingAddress4.parse(actual.address);
+  if (parsed.ownerAddress !== resolved.ownerAddress || expected.nonce !== void 0 && expected.nonce !== output.note?.nonce || hexlify3(request.payload ?? new Uint8Array()) !== hexlify3(output.note?.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 (hexlify3(a.viewingPublicKey) !== hexlify3(b.viewingPublicKey) || hexlify3(a.clueKey) !== hexlify3(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 >= FIELD_MODULUS)
+  if (typeof value !== "bigint" || value < 0n || value >= FIELD_MODULUS3)
     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) >= FIELD_MODULUS)
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(value) || BigInt(value) <= 0n || BigInt(value) >= FIELD_MODULUS3)
     throw new RangeError("identity must be a nonzero canonical BN254 field element");
   return value.toLowerCase();
 }
@@ -146,8 +641,8 @@ function fingerprint(delivery) {
 function checkedContext(context) {
   if (typeof context.chainId !== "bigint" || context.chainId <= 0n)
     throw new RangeError("chainId must be positive");
-  const protocolAddress = getAddress(context.protocolAddress);
-  const tokenAddress = getAddress(context.tokenAddress);
+  const protocolAddress = getAddress3(context.protocolAddress);
+  const tokenAddress = getAddress3(context.tokenAddress);
   if (BigInt(protocolAddress) === 0n) throw new RangeError("protocol address must be nonzero");
   return { chainId: context.chainId, protocolAddress, tokenAddress };
 }
@@ -169,16 +664,18 @@ function rejectLegacy(value) {
 var outputCreation = /* @__PURE__ */ Symbol("NoteOutput.create");
 var NoteOutput = class _NoteOutput {
   to;
+  ipp;
   amount;
   identity;
   commitment;
   deliveryFingerprint;
   /** Encrypted EVM delivery is resolved by preparation; the original offline intent stays pending. */
   deliveryPending;
-  constructor(output, token) {
+  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;
@@ -194,8 +691,15 @@ var NoteOutput = class _NoteOutput {
     });
     Object.freeze(this);
   }
-  static async create(options) {
-    rejectLegacy(options);
+  /** 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);
@@ -223,7 +727,7 @@ var NoteOutput = class _NoteOutput {
         throw new TypeError("invisi recipient is always encrypted");
       let parsed;
       try {
-        parsed = ReceivingAddress2.parse(recipient.address);
+        parsed = ReceivingAddress5.parse(recipient.address);
       } catch (cause) {
         throw new InvisiError("INVALID_RECIPIENT", "Invalid recipient address", {
           address: recipient.address,
@@ -240,11 +744,11 @@ var NoteOutput = class _NoteOutput {
         recipient.addressLookup ??= "protocol-rpc";
       } else if ("addressLookup" in recipient)
         throw new TypeError("addressLookup only applies to EVM recipients");
-      const nonce = nonceValue(
+      const nonce2 = nonceValue(
         recipient.nonce === void 0 ? generateNonce() : recipient.nonce
       );
-      recipient.nonce = nonce;
-      identity = await computeNoteIdentity(BigInt(resolved.ownerAddress), nonce);
+      recipient.nonce = nonce2;
+      identity = await computeNoteIdentity(BigInt(resolved.ownerAddress), nonce2);
       address = recipient.address;
       note = {
         chainId: context.chainId,
@@ -252,7 +756,7 @@ var NoteOutput = class _NoteOutput {
         tokenAddress: BigInt(context.tokenAddress),
         ownerAddress: resolved.ownerAddress,
         amount: options.amount,
-        nonce,
+        nonce: nonce2,
         payload: payloadCopy(options.payload)
       };
     }
@@ -266,16 +770,17 @@ var NoteOutput = class _NoteOutput {
     if (envelope && recipient.type === "invisi") {
       const keys = resolved.getReceivingKeys();
       delivery = {
-        ciphertext: hexlify(
+        ciphertext: hexlify4(
           await encryptPrivateTransferNote(keys.viewingPublicKey, note, {
             chainId: context.chainId,
             protocolAddress: BigInt(context.protocolAddress),
             outputCommitment: commitment
           })
         ),
-        clue: hexlify(createClue(keys.clueKey))
+        clue: hexlify4(createClue(keys.clueKey))
       };
     }
+    const ipp = typeof input === "string" ? input : encodePaymentRequest(request);
     return new _NoteOutput(
       {
         context,
@@ -289,7 +794,8 @@ var NoteOutput = class _NoteOutput {
         address,
         change: false
       },
-      outputCreation
+      outputCreation,
+      ipp
     );
   }
   assertCommitment(expectedHex) {
@@ -335,14 +841,14 @@ async function materializeNoteOutput(payment, context, lookup) {
     identityValue(output.identity);
   } else {
     const note = output.note;
-    const parsed = ReceivingAddress2.parse(recipient.address);
+    const parsed = ReceivingAddress5.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 || hexlify(payloadCopy(note.payload)) !== hexlify(payloadCopy(payment.payload)))
+    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 || hexlify4(payloadCopy(note.payload)) !== hexlify4(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");
@@ -356,6 +862,7 @@ async function materializeNoteOutput(payment, context, lookup) {
     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(
@@ -365,14 +872,14 @@ async function materializeNoteOutput(payment, context, lookup) {
     );
     const keys = resolved.getReceivingKeys();
     output.delivery = {
-      ciphertext: hexlify(
+      ciphertext: hexlify4(
         await encryptPrivateTransferNote(keys.viewingPublicKey, output.note, {
           chainId: context.chainId,
           protocolAddress: BigInt(context.protocolAddress),
           outputCommitment: output.commitment
         })
       ),
-      clue: hexlify(createClue(keys.clueKey))
+      clue: hexlify4(createClue(keys.clueKey))
     };
     delete output.deliveryPending;
   }
@@ -388,427 +895,10 @@ function resolvedOutputSnapshot(payment, output) {
   return copy;
 }
 
-// src/session/state.ts
-function creditReservationKey(commitment) {
-  return "credit:" + commitment;
-}
-function walletBalance(state, tokenAddress) {
-  let confirmedKnown = 0n;
-  let reserved = 0n;
-  let unknown = !!state.invalidated;
-  const records = Object.values(state.notes).filter(
-    (r) => r.note.tokenAddress === BigInt(tokenAddress)
-  );
-  const points = records.map((record) => record.checkedThrough);
-  let checkedThrough = null;
-  if (records.length && points.every((point) => point !== void 0) && records.every((record) => record.spent !== "unknown")) {
-    checkedThrough = points.reduce(
-      (earliest, point) => point.number < earliest.number ? point : earliest
-    );
-  } else if (!records.length) {
-    checkedThrough = state.observedThrough ?? null;
-  }
-  if (!records.length && !checkedThrough) {
-    unknown = true;
-  }
-  for (const [id, record] of Object.entries(state.notes)) {
-    if (record.note.tokenAddress !== BigInt(tokenAddress)) continue;
-    if (record.spent !== "spent") {
-      confirmedKnown += record.note.amount;
-      if (record.spent === "unknown") {
-        unknown = true;
-      }
-      if (state.reservations[id]) {
-        reserved += record.note.amount;
-      }
-    }
-  }
-  return {
-    tokenAddress,
-    scope: { ...state.scope },
-    checkedThrough: state.invalidated ? null : checkedThrough ? { ...checkedThrough } : null,
-    confirmedKnown,
-    reserved,
-    availableKnown: unknown ? null : confirmedKnown - reserved,
-    invalidated: !!state.invalidated
-  };
-}
-function walletBalances(state) {
-  const tokens = new Set(
-    Object.values(state.notes).map(
-      (r) => `0x${r.note.tokenAddress.toString(16).padStart(40, "0")}`
-    )
-  );
-  return [...tokens].sort().map((token) => walletBalance(state, token));
-}
-
-// src/session/operation-protocol.ts
-import { Interface } from "ethers";
-import { invisiProtocolAbi } from "@invisi-labs/protocol/contracts";
-import { creditPeriods } from "@invisi-labs/core";
-import {
-  WitnessBuilder,
-  normalizeFunding,
-  buildCancelCreditCalldata,
-  buildCreateCreditCalldata,
-  buildCreditDrawCalldata,
-  buildShieldCalldata,
-  buildTopUpCreditCalldata,
-  buildTransactCalldata,
-  cancelCreditPublicInputs,
-  createCreditPublicInputs,
-  creditDrawPublicInputs,
-  encodeAggregateFundingTypedData,
-  encodeCreateCreditFundingTypedData,
-  encodeShieldFundingTypedData,
-  encodeTopUpCreditFundingTypedData,
-  encodeTransactFundingTypedData,
-  topUpCreditPublicInputs,
-  transactUserPublicInputs
-} from "@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 && (plan.params.feeAmount ?? 0n) === 0n && BigInt(plan.params.feeRecipient ?? 0n) === 0n && (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 inputFacts(plan) {
-  const credit = plan.credit;
-  const noteNullifiers = plan.params?.nullifiers ?? credit?.creation?.nullifiers ?? [];
-  let creditNullifiers = [];
-  if (credit?.draw) {
-    creditNullifiers = credit.draw.nullifiers;
-  } else if (credit?.topUp) {
-    creditNullifiers = [credit.topUp.creditNullifier];
-  } else if (credit?.cancel) {
-    creditNullifiers = [credit.cancel.nullifier];
-  }
-  if (noteNullifiers.length !== plan.inputs.length || creditNullifiers.length !== (credit?.inputs.length ?? 0)) {
-    throw new Error("operation input statement count mismatch");
-  }
-  return [
-    ...plan.inputs.map((input, index) => ({
-      key: input.commitment,
-      reservationKey: input.commitment,
-      nullifier: noteNullifiers[index],
-      kind: "notes"
-    })),
-    ...(credit?.inputs ?? []).map((input, index) => ({
-      key: input.commitment + ":" + input.role,
-      reservationKey: creditReservationKey(input.commitment),
-      nullifier: creditNullifiers[index],
-      kind: "credits"
-    }))
-  ];
-}
-function operationSources(plan) {
-  const noteSources = plan.params?.sources;
-  if (noteSources != null) return noteSources;
-  const credit = plan.credit;
-  if (credit?.topUp) {
-    return [...credit.topUp.creation.sources, credit.topUp.creditSource];
-  }
-  if (credit?.creation) return credit.creation.sources;
-  if (credit?.draw) return credit.draw.sources;
-  if (credit?.cancel) return [credit.cancel.source];
-  return [];
-}
-function statement(plan) {
-  if (!plan.statement) throw new Error("operation has no proof statement");
-  const credit = plan.credit;
-  let words;
-  if (credit?.topUp) {
-    words = topUpCreditPublicInputs(
-      plan.context,
-      credit.topUp,
-      credit.deliveries,
-      plan.funding
-    );
-  } else if (credit?.creation) {
-    words = createCreditPublicInputs(
-      plan.context,
-      credit.creation,
-      credit.deliveries,
-      plan.funding
-    );
-  } else if (credit?.draw) {
-    words = creditDrawPublicInputs(plan.context, credit.draw, credit.deliveries);
-  } else if (credit?.cancel) {
-    words = cancelCreditPublicInputs(plan.context, credit.cancel);
-  } else {
-    words = transactUserPublicInputs(
-      plan.context,
-      plan.params,
-      plan.outputs.map((output) => output.delivery),
-      plan.funding
-    );
-  }
-  const result = 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)
-  };
-}
-async function witnessFor(protocol, plan, authorization) {
-  const builder = new WitnessBuilder(protocol);
-  const credit = plan.credit;
-  if (credit) {
-    if (!authorization) throw new Error("private Credit wallet authorization required");
-    if (credit.topUp) {
-      return builder.topUpCredit({
-        params: credit.topUp,
-        deliveries: credit.deliveries,
-        funding: plan.funding,
-        inputs: plan.inputs,
-        state: credit.outputs[0].state,
-        ...plan.outputs[0] ? { change: plan.outputs[0].note } : {},
-        previous: credit.inputs[0],
-        authorization
-      });
-    }
-    if (credit.creation) {
-      return builder.createCredit({
-        params: credit.creation,
-        deliveries: credit.deliveries,
-        funding: plan.funding,
-        inputs: plan.inputs,
-        state: credit.outputs[0].state,
-        ...plan.outputs[0] ? { change: plan.outputs[0].note } : {},
-        authorization
-      });
-    }
-    if (credit.draw) {
-      return builder.drawCredit({
-        timestamp: plan.preparedAt.timestamp,
-        params: credit.draw,
-        deliveries: credit.deliveries,
-        inputs: credit.inputs,
-        amounts: credit.amounts,
-        authorization
-      });
-    }
-    if (credit.cancel) {
-      return builder.cancelCredit({
-        params: credit.cancel,
-        input: credit.inputs[0],
-        authorization
-      });
-    }
-    throw new Error("unsupported Credit operation");
-  }
-  return builder.transact({
-    params: plan.params,
-    deliveries: plan.outputs.map((output) => output.delivery),
-    funding: plan.funding,
-    inputs: plan.inputs,
-    outputs: plan.outputs.map((output) => ({
-      identity: output.identity,
-      amount: output.amount,
-      ...output.note ? { note: output.note } : {}
-    })),
-    ...authorization ? { authorization } : {},
-    target: plan.statement.target
-  });
-}
-async function encodeOperation(saved) {
-  const plan = saved.plan;
-  const credit = plan.credit;
-  const caller = plan.fundingMode === "caller" ? plan.funding.payer : void 0;
-  const common = { context: plan.context, proof: saved.proof?.proofHex ?? "0x" };
-  const funded = { ...common, funding: plan.funding, ...caller ? { caller } : {} };
-  let encoded;
-  if (credit?.topUp) {
-    encoded = buildTopUpCreditCalldata({
-      ...funded,
-      params: credit.topUp,
-      deliveries: credit.deliveries
-    });
-  } else if (credit?.creation) {
-    encoded = buildCreateCreditCalldata({
-      ...funded,
-      params: credit.creation,
-      deliveries: credit.deliveries
-    });
-  } else if (credit?.draw) {
-    encoded = buildCreditDrawCalldata({
-      ...common,
-      params: credit.draw,
-      deliveries: credit.deliveries
-    });
-  } else if (credit?.cancel) {
-    encoded = buildCancelCreditCalldata({ ...common, params: credit.cancel });
-  } else if (plan.kind === "shield") {
-    encoded = await buildShieldCalldata({
-      ...funded,
-      params: plan.shieldParams,
-      outputs: plan.shieldOutputs,
-      deliveries: plan.outputs.map((output) => output.delivery)
-    });
-  } else {
-    encoded = buildTransactCalldata({
-      ...funded,
-      params: plan.params,
-      deliveries: plan.outputs.map((output) => output.delivery)
-    });
-  }
-  return { to: plan.context.protocolAddress, data: encoded.data, value: 0n };
-}
-async function fundingTypedData(saved) {
-  const plan = saved.plan;
-  const credit = plan.credit;
-  if (credit?.topUp) {
-    return encodeTopUpCreditFundingTypedData(
-      plan.context,
-      credit.topUp,
-      credit.deliveries,
-      plan.funding
-    );
-  }
-  if (credit?.creation) {
-    return encodeCreateCreditFundingTypedData(
-      plan.context,
-      credit.creation,
-      credit.deliveries,
-      plan.funding
-    );
-  }
-  if (plan.kind === "shield") {
-    return encodeShieldFundingTypedData({
-      context: plan.context,
-      params: plan.shieldParams,
-      outputs: plan.shieldOutputs,
-      deliveries: plan.outputs.map((output) => output.delivery),
-      funding: plan.funding
-    });
-  }
-  if (plan.statement?.target === "noir-recursive") {
-    return encodeAggregateFundingTypedData(plan.context, {
-      params: plan.params,
-      deliveries: plan.outputs.map((output) => output.delivery),
-      funding: plan.funding
-    });
-  }
-  return encodeTransactFundingTypedData(
-    plan.context,
-    saved.proof.proofHex,
-    plan.params,
-    plan.outputs.map((output) => output.delivery),
-    plan.funding
-  );
-}
-function publicProof(bundle) {
-  return {
-    formatVersion: bundle.formatVersion,
-    circuitName: bundle.circuitName,
-    target: bundle.target,
-    bbVersion: bundle.bbVersion,
-    artifactSha256: bundle.artifactSha256,
-    vkSha256: bundle.vkSha256,
-    proofHex: bundle.proofHex,
-    proofSha256: bundle.proofSha256,
-    publicInputs: [...bundle.publicInputs]
-  };
-}
-function operationExpired(plan, now) {
-  if (now > plan.deadline) return true;
-  const credit = plan.credit;
-  if (credit?.topUp && now >= credit.topUp.previousExpiry) return true;
-  if (credit?.creation && now >= credit.creation.expiry) return true;
-  if (credit?.draw) {
-    if (credit.draw.expiries.some((expiry) => now >= expiry)) return true;
-    const prepared = creditPeriods(plan.preparedAt.timestamp), current = creditPeriods(now);
-    if (prepared.currentDay !== current.currentDay || prepared.currentMonth !== current.currentMonth)
-      return true;
-  }
-  return false;
-}
-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: params.feeRecipient ?? "0x0000000000000000000000000000000000000000",
-    feeAmount: params.feeAmount ?? 0n
-  });
-  const funding = { ...normalizeFunding(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 (plan.credit?.topUp) {
-    method = "topUpCredit";
-    args = [
-      "0x",
-      { ...plan.credit.topUp, creation: feeDefaults(plan.credit.topUp.creation) },
-      plan.credit.deliveries,
-      funding
-    ];
-  } else if (plan.credit?.creation) {
-    method = "createCredit";
-    args = ["0x", feeDefaults(plan.credit.creation), plan.credit.deliveries, funding];
-  } else if (plan.credit?.cancel) {
-    method = "cancelCredit";
-    args = ["0x", feeDefaults(plan.credit.cancel)];
-  } else throw new Error("unsupported broadcaster operation");
-  const abi = invisiProtocolAbi.filter(
-    (item) => item.type === "function" && item.name === method && (method !== "transact" || item.inputs[1]?.type === "tuple")
-  );
-  return {
-    sendable: false,
-    data: new Interface(abi).encodeFunctionData(method, args)
-  };
-}
-
-// src/session/transaction-preparation.ts
-import { getAddress as getAddress4 } from "ethers";
-import {
-  normalizeTransactRequest as normalizeTransactRequest2,
-  transactUserPublicInputs as transactUserPublicInputs2,
-  WitnessBuilder as WitnessBuilder3,
-  ZERO_ADDRESS
-} from "@invisi-labs/protocol";
-
-// src/recipient-infrastructure.ts
+// src/notes/recipient-infrastructure.ts
 import {
   MissingCapabilityError as MissingCapabilityError3,
-  ReceivingAddress as ReceivingAddress3
+  ReceivingAddress as ReceivingAddress6
 } from "@invisi-labs/core";
 import { ProtocolRpcClient } from "@invisi-labs/rpc";
 var recipientInfrastructure = /* @__PURE__ */ Symbol("SDK recipient infrastructure");
@@ -837,7 +927,7 @@ function configureRecipientInfrastructure(options) {
     if (discovered.protocol.address !== deployment.protocol.address || discovered.protocol.runtimeCodeHash !== deployment.protocol.runtimeCodeHash || discovered.protocol.fromBlock !== deployment.protocol.fromBlock || discovered.registry?.address !== registry.address || discovered.registry.runtimeCodeHash !== registry.runtimeCodeHash || discovered.registry.fromBlock !== registry.fromBlock)
       throw new Error("Recipient registry deployment pins mismatch");
     const registration = await rpc.getReceivingAddress(ownerAddress);
-    return registration ? ReceivingAddress3.parse(registration.receivingAddress).getReceivingKeys() : null;
+    return registration ? ReceivingAddress6.parse(registration.receivingAddress).getReceivingKeys() : null;
   };
   return { ...options, [recipientInfrastructure]: lookup };
 }
@@ -849,26 +939,15 @@ function recipientLookup(options, source = "protocol-rpc") {
   };
 }
 
-// src/session/prepare-common.ts
-import { getAddress as getAddress2 } from "ethers";
-import {
-  MissingCapabilityError as MissingCapabilityError4,
-  computeNoteCommitment as computeNoteCommitment2,
-  computeNoteIdentity as computeNoteIdentity2
-} from "@invisi-labs/core";
-import {
-  normalizeFunding as normalizeFunding2
-} from "@invisi-labs/protocol";
-
-// src/session/membership.ts
-import { FIELD_MODULUS as FIELD_MODULUS2, poseidonHash } from "@invisi-labs/core";
+// src/discovery/membership.ts
+import { FIELD_MODULUS as FIELD_MODULUS4, poseidonHash } from "@invisi-labs/core";
 async function verifyMembership(reader, context, block, input, proof) {
   if (proof.block.hash !== block.hash || proof.block.number !== block.number || proof.leaf !== input.commitment || proof.treeId !== input.treeId || proof.leafIndex !== input.leafIndex || proof.path.length !== 16 || !Number.isInteger(input.leafIndex) || input.leafIndex < 0 || input.leafIndex >= 65536 || !await reader.isKnownRoot(context, input.treeId, proof.root, block))
     throw new Error("membership context/root mismatch");
   let root = BigInt(input.commitment);
   for (let i = 0; i < 16; i++) {
     const sibling = proof.path[i];
-    if (typeof sibling !== "bigint" || sibling < 0n || sibling >= FIELD_MODULUS2)
+    if (typeof sibling !== "bigint" || sibling < 0n || sibling >= FIELD_MODULUS4)
       throw new Error("noncanonical membership path");
     root = BigInt(
       await poseidonHash(input.leafIndex >> i & 1 ? [sibling, root] : [root, sibling])
@@ -878,7 +957,49 @@ async function verifyMembership(reader, context, block, input, proof) {
     throw new Error("membership path does not produce canonical root");
 }
 
-// src/session/selection.ts
+// src/transactions/preparation/credit-values.ts
+import {
+  computeCreditCommitment,
+  computeCreditSharedKeyHash
+} from "@invisi-labs/core";
+async function creditLeaf(state) {
+  const n = state.note;
+  return computeCreditCommitment(
+    n.chainId,
+    n.spenderWalletIdentity,
+    n.ownerWalletIdentity,
+    n.spenderPayout,
+    n.ownerPayout,
+    n.tokenAddress,
+    n.amount,
+    n.nonce,
+    n.expiry,
+    await computeCreditSharedKeyHash(n.creditSharedKey),
+    n
+  );
+}
+
+// src/transactions/preparation/transaction-preparation.ts
+import {
+  normalizeTransactRequest,
+  transactUserPublicInputs as transactUserPublicInputs2,
+  WitnessBuilder as WitnessBuilder3,
+  ZERO_ADDRESS
+} from "@invisi-labs/protocol";
+import { getAddress as getAddress6 } from "ethers";
+
+// src/transactions/preparation/prepare-common.ts
+import { getAddress as getAddress4 } from "ethers";
+import {
+  MissingCapabilityError as MissingCapabilityError4,
+  computeNoteCommitment as computeNoteCommitment2,
+  computeNoteIdentity as computeNoteIdentity2
+} from "@invisi-labs/core";
+import {
+  normalizeFunding as normalizeFunding2
+} from "@invisi-labs/protocol";
+
+// 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");
@@ -902,7 +1023,7 @@ function selectNotes(notes, target, reserved) {
   throw new Error("insufficient verified available funds");
 }
 
-// src/session/prepare-common.ts
+// 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}`);
@@ -972,7 +1093,7 @@ var Preparation = class {
       return { funding: {}, fundingMode: "none" };
     }
     positiveAmount(source.amount);
-    const payer = getAddress2(source.payer);
+    const payer = getAddress4(source.payer);
     const mode = source.authorization ?? "signature";
     if (BigInt(payer) === 0n) {
       throw new Error("funding payer must be nonzero");
@@ -1003,7 +1124,9 @@ var Preparation = class {
     const address = this.runtime.changeAddress ?? this.runtime.options.wallet.getReceivingAddress().toString();
     try {
       const output = await NoteOutput.create({
-        ...context,
+        chainId: context.chainId,
+        protocolAddress: context.protocolAddress,
+        tokenAddress: context.tokenAddress,
         amount,
         recipient: address.startsWith("0i") ? { type: "invisi", address } : { type: "evm", address }
       });
@@ -1156,11 +1279,10 @@ function storedCandidates(inputs) {
   return structuredClone(records);
 }
 
-// src/session/prepare-credit.ts
-import { getAddress as getAddress3, hexlify as hexlify2, toBeHex } from "ethers";
+// src/transactions/preparation/prepare-credit.ts
+import { getAddress as getAddress5, hexlify as hexlify5, toBeHex } from "ethers";
 import {
-  FIELD_MODULUS as FIELD_MODULUS3,
-  normalizeCreditPolicy,
+  FIELD_MODULUS as FIELD_MODULUS5,
   applyCreditDrawUsage,
   computeCreditNullifier,
   computeCreditRecoveryPad,
@@ -1169,7 +1291,8 @@ import {
   encryptCreditNote,
   generateCreditSharedKey,
   generateNonce as generateNonce2,
-  normalizeCreditDeliveryState
+  normalizeCreditDeliveryState,
+  normalizeCreditPolicy
 } from "@invisi-labs/core";
 import {
   WitnessBuilder as WitnessBuilder2,
@@ -1180,30 +1303,6 @@ import {
   topUpCreditPublicInputs as topUpCreditPublicInputs2,
   word
 } from "@invisi-labs/protocol";
-
-// src/session/credit-values.ts
-import {
-  computeCreditCommitment,
-  computeCreditSharedKeyHash
-} from "@invisi-labs/core";
-async function creditLeaf(state) {
-  const n = state.note;
-  return computeCreditCommitment(
-    n.chainId,
-    n.spenderWalletIdentity,
-    n.ownerWalletIdentity,
-    n.spenderPayout,
-    n.ownerPayout,
-    n.tokenAddress,
-    n.amount,
-    n.nonce,
-    n.expiry,
-    await computeCreditSharedKeyHash(n.creditSharedKey),
-    n
-  );
-}
-
-// src/session/prepare-credit.ts
 var EMPTY = { ciphertext: "0x", clue: "0x" };
 var CreditPreparation = class {
   constructor(runtime) {
@@ -1229,10 +1328,10 @@ var CreditPreparation = class {
       ["owner", "spender"].map(async (role) => {
         const keys = role === "owner" ? state.ownerReceivingKeys : state.spenderReceivingKeys;
         return {
-          ciphertext: hexlify2(
+          ciphertext: hexlify5(
             await encryptCreditNote(keys.viewingPublicKey, state, { ...context, role })
           ),
-          clue: hexlify2(createClue2(keys.clueKey))
+          clue: hexlify5(createClue2(keys.clueKey))
         };
       })
     );
@@ -1297,8 +1396,8 @@ var CreditPreparation = class {
       recipientLookup(this.runtime.options),
       { field: "wallet" }
     );
-    const ownerPayout = getAddress3(owner.ownerAddress);
-    const spenderPayout = getAddress3(spender.ownerAddress);
+    const ownerPayout = getAddress5(owner.ownerAddress);
+    const spenderPayout = getAddress5(spender.ownerAddress);
     if (BigInt(ownerPayout) === 0n || BigInt(spenderPayout) === 0n) {
       throw new Error("Credit payouts must be nonzero");
     }
@@ -1358,7 +1457,7 @@ var CreditPreparation = class {
       nullifiers: selected.nullifiers,
       creditCommitment: output.commitment,
       changeCommitment: plan.outputs[0]?.commitment ?? word(0n),
-      owner: getAddress3(toBeHex(output.state.note.ownerPayout, 20)),
+      owner: getAddress5(toBeHex(output.state.note.ownerPayout, 20)),
       expiry: output.state.note.expiry,
       deadline: frame.deadline
     };
@@ -1498,7 +1597,7 @@ var CreditPreparation = class {
       outputs.push(output);
       remainders.push(output.commitment);
       recoveryAmounts.push(
-        word((remaining + await computeCreditRecoveryPad(...args)) % FIELD_MODULUS3)
+        word((remaining + await computeCreditRecoveryPad(...args)) % FIELD_MODULUS5)
       );
       deliveries.push(...output.deliveries);
     }
@@ -1510,7 +1609,7 @@ var CreditPreparation = class {
       remainderCommitments: remainders,
       expiries: members.map((member) => member.input.state.note.expiry),
       recoveryAmounts,
-      spender: getAddress3(toBeHex(payout, 20)),
+      spender: getAddress5(toBeHex(payout, 20)),
       totalAmount: amounts.reduce((sum, amount) => sum + amount, 0n),
       deadline: frame.deadline
     };
@@ -1542,7 +1641,7 @@ var CreditPreparation = class {
       token: frame.context.tokenAddress,
       source: previous.source,
       nullifier: previous.nullifier,
-      owner: getAddress3(toBeHex(n.ownerPayout, 20)),
+      owner: getAddress5(toBeHex(n.ownerPayout, 20)),
       amount: n.amount,
       deadline: frame.deadline
     };
@@ -1557,7 +1656,7 @@ var CreditPreparation = class {
   }
 };
 
-// src/session/transaction-preparation.ts
+// src/transactions/preparation/transaction-preparation.ts
 var TransactionPreparation = class {
   constructor(context) {
     this.context = context;
@@ -1578,7 +1677,7 @@ var TransactionPreparation = class {
   }
   #intent;
   runtime(tokenAddress) {
-    if (getAddress4(tokenAddress) !== getAddress4(this.context.options.protocol.context.tokenAddress))
+    if (getAddress6(tokenAddress) !== getAddress6(this.context.options.protocol.context.tokenAddress))
       throw new Error("preparation token mismatch");
     return this.context;
   }
@@ -1605,7 +1704,7 @@ var TransactionPreparation = class {
     let withdrawalAddress = ZERO_ADDRESS;
     let withdrawalAmount = 0n;
     if (copied.withdrawal !== void 0) {
-      withdrawalAddress = getAddress4(copied.withdrawal.to);
+      withdrawalAddress = getAddress6(copied.withdrawal.to);
       positiveAmount(copied.withdrawal.amount);
       if (BigInt(withdrawalAddress) === 0n)
         throw new Error("withdrawal destination must be nonzero");
@@ -1613,7 +1712,7 @@ var TransactionPreparation = class {
     }
     if (copied.outputs.length === 0 && withdrawalAmount === 0n)
       throw new Error("transfer requires a private output or public withdrawal");
-    const feeRecipient = copied.fee ? getAddress4(copied.fee.recipient) : ZERO_ADDRESS;
+    const feeRecipient = copied.fee ? getAddress6(copied.fee.recipient) : ZERO_ADDRESS;
     const feeAmount = copied.fee?.amount ?? 0n;
     if (copied.fee) {
       positiveAmount(feeAmount);
@@ -1663,7 +1762,7 @@ var TransactionPreparation = class {
       feeAmount: fee.amount
     };
     const deliveries = outputs.map((output) => output.delivery);
-    const normalized = normalizeTransactRequest2(context, params, deliveries, funding.funding);
+    const normalized = normalizeTransactRequest(context, params, deliveries, funding.funding);
     const statement2 = WitnessBuilder3.statement(
       `transact_user_slots${normalized.capacity}`,
       transactUserPublicInputs2(context, params, deliveries, funding.funding),
@@ -1757,25 +1856,22 @@ var TransactionPreparation = class {
 export {
   InvisiError,
   prepareWithErrors,
-  NoteOutput,
-  configureRecipientInfrastructure,
-  creditReservationKey,
-  walletBalance,
-  walletBalances,
+  encodePaymentNote,
+  decodePaymentNote,
+  exportPaymentNote,
   requiresAuthorization,
-  inputFacts,
-  operationSources,
   statement,
   authorizationRequest,
-  witnessFor,
-  encodeOperation,
-  fundingTypedData,
-  publicProof,
   operationExpired,
   exportBroadcasterIntent,
+  encodePaymentRequest,
+  decodePaymentRequest,
+  NoteOutput,
+  configureRecipientInfrastructure,
+  recipientLookup,
   verifyMembership,
   positiveAmount,
   creditLeaf,
   TransactionPreparation
 };
-//# sourceMappingURL=chunk-FL4TIGWW.js.map
+//# sourceMappingURL=chunk-ITTGBIG2.js.map