@invisi-labs/sdk 1.1.6 → 1.2.0

package/dist/chunk-FL4TIGWW.js

@@ -1,1781 +0,0 @@
-import {
-  EthersAddressResolver
-} from "./chunk-QC6TQR3R.js";
-
-// src/errors.ts
-import { MissingCapabilityError } from "@invisi-labs/core";
-var InvisiError = class extends Error {
-  code;
-  operation;
-  address;
-  outputIndex;
-  field;
-  capability;
-  constructor(code, message, details = {}) {
-    super(message, { cause: details.cause });
-    this.name = "InvisiError";
-    this.code = code;
-    this.operation = details.operation;
-    this.address = details.address;
-    this.outputIndex = details.outputIndex;
-    this.field = details.field;
-    this.capability = details.capability;
-  }
-};
-async function prepareWithErrors(operation, prepare) {
-  try {
-    return await prepare();
-  } catch (cause) {
-    if (cause instanceof InvisiError) {
-      if (cause.operation) throw cause;
-      throw new InvisiError(cause.code, cause.message, {
-        operation,
-        ...cause.address === void 0 ? {} : { address: cause.address },
-        ...cause.outputIndex === void 0 ? {} : { outputIndex: cause.outputIndex },
-        ...cause.field === void 0 ? {} : { field: cause.field },
-        ...cause.capability === void 0 ? {} : { capability: cause.capability },
-        cause: cause.cause
-      });
-    }
-    throw new InvisiError(
-      cause instanceof MissingCapabilityError ? "MISSING_CAPABILITY" : "PREPARATION_FAILED",
-      cause instanceof Error ? cause.message : "Transaction preparation failed",
-      {
-        operation,
-        cause,
-        ...cause instanceof MissingCapabilityError ? { capability: cause.capability } : {}
-      }
-    );
-  }
-}
-
-// src/NoteOutput.ts
-import {
-  FIELD_MODULUS,
-  ReceivingAddress as ReceivingAddress2,
-  computeNoteCommitment,
-  computeNoteIdentity,
-  createClue,
-  encryptPrivateTransferNote,
-  generateNonce
-} from "@invisi-labs/core";
-import { AbiCoder, getAddress, hexlify, keccak256 } from "ethers";
-
-// src/resolve-recipient.ts
-import {
-  MissingCapabilityError as MissingCapabilityError2,
-  ReceivingAddress
-} from "@invisi-labs/core";
-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/NoteOutput.ts
-function nonceValue(value) {
-  if (typeof value !== "bigint" || value < 0n || value >= 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) >= 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 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 = getAddress(context.protocolAddress);
-  const tokenAddress = getAddress(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;
-  amount;
-  identity;
-  commitment;
-  deliveryFingerprint;
-  /** Encrypted EVM delivery is resolved by preparation; the original offline intent stays pending. */
-  deliveryPending;
-  constructor(output, token) {
-    if (token !== outputCreation)
-      throw new TypeError("outputs must be created with NoteOutput.create");
-    const saved = structuredClone(output);
-    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);
-  }
-  static async create(options) {
-    rejectLegacy(options);
-    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 = ReceivingAddress2.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 nonce = nonceValue(
-        recipient.nonce === void 0 ? generateNonce() : recipient.nonce
-      );
-      recipient.nonce = nonce;
-      identity = await computeNoteIdentity(BigInt(resolved.ownerAddress), nonce);
-      address = recipient.address;
-      note = {
-        chainId: context.chainId,
-        protocolAddress: BigInt(context.protocolAddress),
-        tokenAddress: BigInt(context.tokenAddress),
-        ownerAddress: resolved.ownerAddress,
-        amount: options.amount,
-        nonce,
-        payload: payloadCopy(options.payload)
-      };
-    }
-    const commitment = await computeNoteCommitment(
-      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: hexlify(
-          await encryptPrivateTransferNote(keys.viewingPublicKey, note, {
-            chainId: context.chainId,
-            protocolAddress: BigInt(context.protocolAddress),
-            outputCommitment: commitment
-          })
-        ),
-        clue: hexlify(createClue(keys.clueKey))
-      };
-    }
-    return new _NoteOutput(
-      {
-        context,
-        recipient,
-        amount: options.amount,
-        ...note ? { note } : {},
-        identity,
-        commitment,
-        delivery,
-        ...envelope && recipient.type === "evm" ? { deliveryPending: true } : {},
-        address,
-        change: false
-      },
-      outputCreation
-    );
-  }
-  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 = ReceivingAddress2.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)))
-      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,
-    output.identity,
-    BigInt(context.tokenAddress),
-    output.amount
-  ) !== output.commitment)
-    throw new Error("note output commitment mismatch");
-  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: hexlify(
-        await encryptPrivateTransferNote(keys.viewingPublicKey, output.note, {
-          chainId: context.chainId,
-          protocolAddress: BigInt(context.protocolAddress),
-          outputCommitment: output.commitment
-        })
-      ),
-      clue: hexlify(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;
-}
-
-// 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
-import {
-  MissingCapabilityError as MissingCapabilityError3,
-  ReceivingAddress as ReceivingAddress3
-} from "@invisi-labs/core";
-import { ProtocolRpcClient } from "@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 MissingCapabilityError3("receiving-key registry deployment");
-    if (source === "chain") {
-      if (!provider)
-        throw new MissingCapabilityError3("ethers provider for registry lookup");
-      return new EthersAddressResolver(
-        provider,
-        {
-          chainId: deployment.chainId,
-          registryAddress: registry.address
-        },
-        registry.runtimeCodeHash
-      ).lookup(ownerAddress);
-    }
-    if (!(protocolRpc instanceof ProtocolRpcClient))
-      throw new MissingCapabilityError3("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 || 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 { ...options, [recipientInfrastructure]: lookup };
-}
-function recipientLookup(options, source = "protocol-rpc") {
-  return async (ownerAddress) => {
-    const lookup = options[recipientInfrastructure];
-    if (!lookup) throw new MissingCapabilityError3("recipient infrastructure");
-    return lookup(source)(ownerAddress);
-  };
-}
-
-// 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";
-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)
-      throw new Error("noncanonical membership path");
-    root = BigInt(
-      await poseidonHash(input.leafIndex >> i & 1 ? [sibling, root] : [root, sibling])
-    );
-  }
-  if (root !== BigInt(proof.root))
-    throw new Error("membership path does not produce canonical root");
-}
-
-// src/session/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/session/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 = requested ?? block.timestamp + (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 = getAddress2(source.payer);
-    const mode = 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 = normalizeFunding2({
-      payer,
-      amount: source.amount,
-      sigNonce: mode === "caller" ? 0n : source.sigNonce ?? await this.runtime.reader.getFundingNonce(
-        frame.context,
-        payer,
-        frame.block
-      ),
-      deadline: mode === "caller" ? 0n : 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 = this.runtime.changeAddress ?? this.runtime.options.wallet.getReceivingAddress().toString();
-    try {
-      const output = await NoteOutput.create({
-        ...context,
-        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: 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: cause.address ?? payment.to,
-          field: change ? "changeAddress" : cause.field ?? "to",
-          ...outputIndex === void 0 ? {} : { outputIndex },
-          ...cause.capability ? { capability: cause.capability } : {},
-          cause: 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 MissingCapabilityError4("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 computeNoteCommitment2(
-        c.chainId,
-        await computeNoteIdentity2(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/session/prepare-credit.ts
-import { getAddress as getAddress3, hexlify as hexlify2, toBeHex } from "ethers";
-import {
-  FIELD_MODULUS as FIELD_MODULUS3,
-  normalizeCreditPolicy,
-  applyCreditDrawUsage,
-  computeCreditNullifier,
-  computeCreditRecoveryPad,
-  createClue as createClue2,
-  deriveRemainderNonce,
-  encryptCreditNote,
-  generateCreditSharedKey,
-  generateNonce as generateNonce2,
-  normalizeCreditDeliveryState
-} from "@invisi-labs/core";
-import {
-  WitnessBuilder as WitnessBuilder2,
-  cancelCreditPublicInputs as cancelCreditPublicInputs2,
-  createCreditPublicInputs as createCreditPublicInputs2,
-  creditDrawPublicInputs as creditDrawPublicInputs2,
-  selectCreditDrawCircuit,
-  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) {
-    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 = normalizeCreditDeliveryState(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: hexlify2(
-            await encryptCreditNote(keys.viewingPublicKey, state, { ...context, role })
-          ),
-          clue: hexlify2(createClue2(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 = normalizeCreditDeliveryState(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 computeCreditNullifier(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 = getAddress3(owner.ownerAddress);
-    const spenderPayout = getAddress3(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),
-          ...normalizeCreditPolicy({
-            singleLimit: options.singleLimit ?? 0n,
-            dailyLimit: options.dailyLimit ?? 0n,
-            monthlyLimit: options.monthlyLimit ?? 0n
-          }),
-          amount: options.amount,
-          payload: copyApplicationPayload(options.payload),
-          expiry,
-          nonce: generateNonce2(),
-          creditSharedKey: generateCreditSharedKey()
-        },
-        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 + (fee?.amount ?? 0n) - (funding.funding.amount ?? 0n),
-      frame,
-      10
-    );
-    const change = selected.amount + (funding.funding.amount ?? 0n) - delta - (fee?.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: fee?.recipient ?? "0x0000000000000000000000000000000000000000",
-      feeAmount: fee?.amount ?? 0n,
-      sources: selected.sources,
-      nullifiers: selected.nullifiers,
-      creditCommitment: output.commitment,
-      changeCommitment: plan.outputs[0]?.commitment ?? word(0n),
-      owner: getAddress3(toBeHex(output.state.note.ownerPayout, 20)),
-      expiry: output.state.note.expiry,
-      deadline: frame.deadline
-    };
-    const deliveries = [...output.deliveries, plan.outputs[0]?.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 = WitnessBuilder2.statement(
-        "credit_top_up",
-        topUpCreditPublicInputs2(frame.context, plan.credit.topUp, deliveries, plan.funding)
-      );
-    } else {
-      plan.statement = WitnessBuilder2.statement(
-        "create_credit",
-        createCreditPublicInputs2(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(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: options.singleLimit ?? old.note.singleLimit ?? 0n,
-          dailyLimit: options.dailyLimit ?? old.note.dailyLimit ?? 0n,
-          monthlyLimit: options.monthlyLimit ?? old.note.monthlyLimit ?? 0n,
-          amount,
-          expiry,
-          nonce: generateNonce2(),
-          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 = selectCreditDrawCircuit(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 = applyCreditDrawUsage(n, amount, frame.block.timestamp);
-      const remaining = n.amount - amount;
-      if (remaining === 0n) {
-        remainders.push(word(0n));
-        recoveryAmounts.push(word(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 deriveRemainderNonce(...args)
-          }
-        },
-        frame
-      );
-      outputs.push(output);
-      remainders.push(output.commitment);
-      recoveryAmounts.push(
-        word((remaining + await computeCreditRecoveryPad(...args)) % FIELD_MODULUS3)
-      );
-      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: getAddress3(toBeHex(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 = WitnessBuilder2.statement(
-      profile.name,
-      creditDrawPublicInputs2(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 ((options.fee?.amount ?? 0n) >= n.amount)
-      throw new Error("fee must be less than the cancellation refund");
-    const params = {
-      feeRecipient: options.fee?.recipient ?? "0x0000000000000000000000000000000000000000",
-      feeAmount: options.fee?.amount ?? 0n,
-      token: frame.context.tokenAddress,
-      source: previous.source,
-      nullifier: previous.nullifier,
-      owner: getAddress3(toBeHex(n.ownerPayout, 20)),
-      amount: n.amount,
-      deadline: frame.deadline
-    };
-    plan.capacity = 1;
-    plan.credit = { inputs: [previous.input], outputs: [], deliveries: [], cancel: params };
-    plan.statement = WitnessBuilder2.statement(
-      "credit_cancel",
-      cancelCreditPublicInputs2(frame.context, params)
-    );
-    await this.#prepare.assertBlock(frame);
-    return this.runtime.complete(plan);
-  }
-};
-
-// src/session/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 (getAddress4(tokenAddress) !== getAddress4(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 = ZERO_ADDRESS;
-    let withdrawalAmount = 0n;
-    if (copied.withdrawal !== void 0) {
-      withdrawalAddress = getAddress4(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 ? getAddress4(copied.fee.recipient) : ZERO_ADDRESS;
-    const feeAmount = copied.fee?.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 - (funding.funding.amount ?? 0n),
-      frame
-    );
-    const outputs = await Promise.all(
-      payments.map((payment, index) => preparation.output(payment, context, false, index))
-    );
-    const change = selection.amount + (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 = normalizeTransactRequest2(context, params, deliveries, funding.funding);
-    const statement2 = WitnessBuilder3.statement(
-      `transact_user_slots${normalized.capacity}`,
-      transactUserPublicInputs2(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) !== (funding.funding.amount ?? 0n) - (copied.fee?.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: copied.fee?.recipient ?? ZERO_ADDRESS,
-        feeAmount: copied.fee?.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)
-    );
-  }
-};
-
-export {
-  InvisiError,
-  prepareWithErrors,
-  NoteOutput,
-  configureRecipientInfrastructure,
-  creditReservationKey,
-  walletBalance,
-  walletBalances,
-  requiresAuthorization,
-  inputFacts,
-  operationSources,
-  statement,
-  authorizationRequest,
-  witnessFor,
-  encodeOperation,
-  fundingTypedData,
-  publicProof,
-  operationExpired,
-  exportBroadcasterIntent,
-  verifyMembership,
-  positiveAmount,
-  creditLeaf,
-  TransactionPreparation
-};
-//# sourceMappingURL=chunk-FL4TIGWW.js.map