@invisi-labs/sdk 1.1.7 → 1.2.0

package/dist/chunk-GUD3LAUO.js

@@ -0,0 +1,765 @@
+// src/payment-note/codec.ts
+import { FIELD_MODULUS } from "@invisi-labs/primitives";
+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/errors.ts
+import { MissingCapabilityError } from "@invisi-labs/primitives";
+var InvisiError = class extends Error {
+  code;
+  operation;
+  address;
+  outputIndex;
+  field;
+  capability;
+  constructor(code, message, details = {}) {
+    super(message, { cause: details.cause });
+    this.name = "InvisiError";
+    this.code = code;
+    this.operation = details.operation;
+    this.address = details.address;
+    this.outputIndex = details.outputIndex;
+    this.field = details.field;
+    this.capability = details.capability;
+  }
+};
+async function prepareWithErrors(operation, prepare) {
+  try {
+    return await prepare();
+  } catch (cause) {
+    if (cause instanceof InvisiError) {
+      if (cause.operation) throw cause;
+      throw new InvisiError(cause.code, cause.message, {
+        operation,
+        ...cause.address === void 0 ? {} : { address: cause.address },
+        ...cause.outputIndex === void 0 ? {} : { outputIndex: cause.outputIndex },
+        ...cause.field === void 0 ? {} : { field: cause.field },
+        ...cause.capability === void 0 ? {} : { capability: cause.capability },
+        cause: cause.cause
+      });
+    }
+    throw new InvisiError(
+      cause instanceof MissingCapabilityError ? "MISSING_CAPABILITY" : "PREPARATION_FAILED",
+      cause instanceof Error ? cause.message : "Transaction preparation failed",
+      {
+        operation,
+        cause,
+        ...cause instanceof MissingCapabilityError ? { capability: cause.capability } : {}
+      }
+    );
+  }
+}
+
+// src/notes/resolve-recipient.ts
+import {
+  MissingCapabilityError as MissingCapabilityError2,
+  ReceivingAddress
+} from "@invisi-labs/primitives";
+async function resolveRecipient(address, lookup, details = {}) {
+  const context = { ...details, address };
+  let recipient;
+  try {
+    recipient = 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 MissingCapabilityError2) {
+      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 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/codec.ts
+import { ReceivingAddress as ReceivingAddress3 } from "@invisi-labs/primitives";
+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 as ReceivingAddress2 } from "@invisi-labs/primitives";
+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 = ReceivingAddress2.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 = ReceivingAddress3.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 = ReceivingAddress3.from({
+        ownerAddress,
+        viewingPublicKey: reader.take(33),
+        clueKey: reader.take(32)
+      }).toString();
+    else {
+      address = ReceivingAddress3.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/primitives";
+import { AbiCoder, getAddress as getAddress3, hexlify as hexlify4, keccak256 } from "ethers";
+
+// src/payment-request/match-output.ts
+import { ReceivingAddress as ReceivingAddress4 } from "@invisi-labs/primitives";
+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_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_MODULUS3)
+    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 keccak256(
+    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 = 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 };
+}
+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 {
+  to;
+  ipp;
+  amount;
+  identity;
+  commitment;
+  deliveryFingerprint;
+  /** Encrypted EVM delivery is resolved by preparation; the original offline intent stays pending. */
+  deliveryPending;
+  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: () => saved.note?.nonce },
+      payload: { enumerable: true, get: () => payloadCopy(saved.note?.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 = ReceivingAddress5.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 ? generateNonce() : recipient.nonce
+      );
+      recipient.nonce = nonce2;
+      identity = await computeNoteIdentity(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 computeNoteCommitment(
+      context.chainId,
+      BigInt(context.protocolAddress),
+      identity,
+      BigInt(context.tokenAddress),
+      options.amount
+    );
+    let delivery = { ciphertext: "0x", clue: "0x" };
+    if (envelope && recipient.type === "invisi") {
+      const keys = resolved.getReceivingKeys();
+      delivery = {
+        ciphertext: hexlify4(
+          await encryptPrivateTransferNote(keys.viewingPublicKey, note, {
+            chainId: context.chainId,
+            protocolAddress: BigInt(context.protocolAddress),
+            outputCommitment: commitment
+          })
+        ),
+        clue: hexlify4(createClue(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 = 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 || 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");
+    if (await computeNoteIdentity(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 computeNoteCommitment(
+    context.chainId,
+    BigInt(context.protocolAddress),
+    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,
+      lookup?.(recipient.addressLookup ?? "protocol-rpc"),
+      { field: "to" }
+    );
+    const keys = resolved.getReceivingKeys();
+    output.delivery = {
+      ciphertext: hexlify4(
+        await encryptPrivateTransferNote(keys.viewingPublicKey, output.note, {
+          chainId: context.chainId,
+          protocolAddress: BigInt(context.protocolAddress),
+          outputCommitment: output.commitment
+        })
+      ),
+      clue: hexlify4(createClue(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;
+}
+
+export {
+  encodePaymentNote,
+  decodePaymentNote,
+  exportPaymentNote,
+  InvisiError,
+  prepareWithErrors,
+  resolveRecipient,
+  encodePaymentRequest,
+  decodePaymentRequest,
+  NoteOutput,
+  materializeNoteOutput,
+  resolvedOutputSnapshot
+};
+//# sourceMappingURL=chunk-GUD3LAUO.js.map