@okxweb3/app-x402-core 0.1.2 → 0.2.0

package/dist/cjs/subscription/index.d.ts

@@ -0,0 +1,3 @@
+export { A as AccessProof, z as AccessRouteRequirements, C as CancelAuth, x as CancelInitiator, w as ChargeResult, m as FacilitatorCancelData, o as FacilitatorCancelPendingData, l as FacilitatorChangeData, p as FacilitatorChargeData, B as FacilitatorChargeRow, j as FacilitatorEnvelope, q as FacilitatorFinalizeExpiredData, r as FacilitatorGetChargesData, t as FacilitatorGetSubscriptionData, s as FacilitatorPendingChangeRow, k as FacilitatorSubscribeData, O as OnBeforeAccessContext, D as OnBeforeAccessHook, E as OnBeforeAccessResult, n as PendingChangeCancelAuth, G as PendingPlanChange, I as PlanCatalog, J as PlanCatalogEntry, y as PlanInitialCharge, K as SettleCancelOk, L as SettleCancelPendingChangeOk, M as SettleCancelPendingChangeResult, Q as SettleCancelResult, R as SettleChangeOk, T as SettleChangeResult, U as SettleResultFail, W as SettleSubscribeOk, X as SettleSubscribeResult, u as Subscription, v as SubscriptionCapability, Y as SubscriptionFacilitatorClient, Z as SubscriptionState, _ as VerifyAccessOk, $ as VerifyAccessResult, a0 as VerifyChangeOk, a1 as VerifyChangeResult, a2 as VerifyOwnershipOk, a3 as VerifyOwnershipResult, a4 as VerifyResult, a5 as VerifyResultFail, a6 as VerifyResultOk, a7 as hasSubscriptionCapability, a8 as supportsSubscription } from '../mechanisms-LhI9qkRo.js';
+export { A as AccessProofMessageInput, B as BuildCancelAuthTypedDataInput, a as BuildPermit2TypedDataInput, b as BuildSubscriptionTermsTypedDataInput, C as CANCEL_AUTH_TYPES, c as ChangeFromExtra, d as ChargeError, e as ChargeErrorCode, E as EncodePaymentPayloadInput, f as ErrorCode, I as InMemoryStore, P as PENDING_CHANGE_CANCEL_AUTH_TYPES, g as PERMIT2_TYPES, h as PermitSingleData, S as SUBSCRIPTION_TERMS_TYPES, i as SubscriptionClient, j as SubscriptionClientConfig, k as SubscriptionContractAddresses, l as SubscriptionPaymentInner, m as SubscriptionPlanExtra, n as SubscriptionRequirementsExtra, o as SubscriptionStore, p as SubscriptionTerms, T as TypedDataEnvelope, Z as ZERO_BYTES32, q as addCalendarMonths, r as asSubscriptionPaymentInner, s as base64DecodeUtf8, t as base64EncodeUtf8, u as buildAccessProofMessage, v as buildCancelAuthTypedData, w as buildPendingChangeCancelAuthTypedData, x as buildPermit2TypedData, y as buildSubscriptionTermsTypedData, z as computeElapsedPeriods, D as computePermitSingleStructHash, F as decodeAccessProof, G as decodePaymentPayload, H as elapsedCalendarMonths, J as encodeAccessProof, K as encodePaymentPayload, L as parseChainIdFromNetwork, M as parsePaymentRequired, N as verifyTermsBindRequirements } from '../index-2gWfiUbK.js';
+import 'viem';

package/dist/cjs/subscription/index.js

@@ -0,0 +1,600 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/subscription/index.ts
+var subscription_exports = {};
+__export(subscription_exports, {
+  CANCEL_AUTH_TYPES: () => CANCEL_AUTH_TYPES,
+  ChargeError: () => ChargeError,
+  ChargeErrorCode: () => ChargeErrorCode,
+  ErrorCode: () => ErrorCode,
+  InMemoryStore: () => InMemoryStore,
+  PENDING_CHANGE_CANCEL_AUTH_TYPES: () => PENDING_CHANGE_CANCEL_AUTH_TYPES,
+  PERMIT2_TYPES: () => PERMIT2_TYPES,
+  SUBSCRIPTION_TERMS_TYPES: () => SUBSCRIPTION_TERMS_TYPES,
+  SubscriptionClient: () => SubscriptionClient,
+  ZERO_BYTES32: () => ZERO_BYTES32,
+  addCalendarMonths: () => addCalendarMonths,
+  asSubscriptionPaymentInner: () => asSubscriptionPaymentInner,
+  base64DecodeUtf8: () => base64DecodeUtf8,
+  base64EncodeUtf8: () => base64EncodeUtf8,
+  buildAccessProofMessage: () => buildAccessProofMessage,
+  buildCancelAuthTypedData: () => buildCancelAuthTypedData,
+  buildPendingChangeCancelAuthTypedData: () => buildPendingChangeCancelAuthTypedData,
+  buildPermit2TypedData: () => buildPermit2TypedData,
+  buildSubscriptionTermsTypedData: () => buildSubscriptionTermsTypedData,
+  computeElapsedPeriods: () => computeElapsedPeriods,
+  computePermitSingleStructHash: () => computePermitSingleStructHash,
+  decodeAccessProof: () => decodeAccessProof,
+  decodePaymentPayload: () => decodePaymentPayload,
+  elapsedCalendarMonths: () => elapsedCalendarMonths,
+  encodeAccessProof: () => encodeAccessProof,
+  encodePaymentPayload: () => encodePaymentPayload,
+  hasSubscriptionCapability: () => hasSubscriptionCapability,
+  parseChainIdFromNetwork: () => parseChainIdFromNetwork,
+  parsePaymentRequired: () => parsePaymentRequired,
+  supportsSubscription: () => supportsSubscription,
+  verifyTermsBindRequirements: () => verifyTermsBindRequirements
+});
+module.exports = __toCommonJS(subscription_exports);
+
+// src/subscription/types.ts
+function hasSubscriptionCapability(scheme) {
+  return typeof scheme === "object" && scheme !== null && "verifyAccess" in scheme && "settlementMode" in scheme && scheme.settlementMode === "pre";
+}
+
+// src/subscription/errors.ts
+var ErrorCode = {
+  // subscribe / change
+  TermsBindingInvalid: "terms_binding_invalid",
+  AllowanceInsufficient: "allowance_insufficient",
+  AllowanceExpired: "allowance_expired",
+  // charge
+  PeriodNotDue: "period_not_due",
+  InsufficientBalance: "insufficient_balance",
+  // charge / cancel / access
+  SubscriptionNotActive: "subscription_not_active",
+  /**
+   * SDK-local code. Surfaced by `verifyAccess` when local period math
+   * yields `currentCalculatePeriod === 0` — subscription exists but
+   * `nowSec < startAt`, i.e. has not yet entered its first chargeable
+   * period.
+   */
+  SubscriptionNotYetActive: "subscription_not_yet_active",
+  UnauthorizedCaller: "unauthorized_caller",
+  // cancel
+  CancelSignatureInvalid: "cancel_signature_invalid",
+  CancelNonceUsed: "cancel_nonce_used",
+  // change
+  TierSame: "tier_same",
+  ChangeEffectiveAtMismatch: "change_effective_at_mismatch",
+  MerchantMismatch: "merchant_mismatch",
+  PayerMismatch: "payer_mismatch",
+  PendingChangeExists: "pending_change_exists",
+  SubNotActiveForChange: "sub_not_active_for_change",
+  // cancel-pending-change
+  NoPendingChange: "no_pending_change",
+  // all writes
+  ConfirmationTimeout: "confirmation_timeout"
+};
+var ChargeErrorCode = {
+  PeriodNotDue: ErrorCode.PeriodNotDue,
+  SubscriptionNotActive: ErrorCode.SubscriptionNotActive,
+  InsufficientBalance: ErrorCode.InsufficientBalance,
+  AllowanceExpired: ErrorCode.AllowanceExpired,
+  UnauthorizedCaller: ErrorCode.UnauthorizedCaller,
+  ConfirmationTimeout: ErrorCode.ConfirmationTimeout
+};
+var ChargeError = class extends Error {
+  constructor(code, subId, txHash) {
+    super(`charge failed: ${code} (sub=${subId})`);
+    this.name = "ChargeError";
+    this.code = code;
+    this.subId = subId;
+    this.txHash = txHash;
+  }
+};
+
+// src/subscription/store.ts
+var InMemoryStore = class {
+  constructor() {
+    this.data = /* @__PURE__ */ new Map();
+  }
+  async get(subId) {
+    const sub = this.data.get(subId);
+    return sub ? { ...sub } : null;
+  }
+  async put(sub) {
+    this.data.set(sub.subId, { ...sub });
+  }
+  async delete(subId) {
+    this.data.delete(subId);
+  }
+  /**
+   * Return all subscriptions, ordered by `startAt` ascending. Not part of
+   * the SubscriptionStore interface — admin/debug helper, not used by the
+   * scheme. Production backends should expose paginated equivalents.
+   */
+  async list() {
+    return Array.from(this.data.values()).map((s) => ({ ...s })).sort((a, b) => a.startAt - b.startAt);
+  }
+};
+
+// src/subscription/client.ts
+var SubscriptionClient = class {
+  constructor(config) {
+    this.scheme = config.scheme;
+    this.store = config.store;
+  }
+  /**
+   * Run one charge period for a subscription. Throws `ChargeError` (one of 6
+   * codes) on facilitator-side failure. Internally `scheme.charge` already
+   * updates the store on success (and on `planChangeTriggered`); the client is
+   * a pass-through.
+   */
+  async charge(subId) {
+    return this.scheme.charge(subId);
+  }
+  /**
+   * Seller-initiated cancel (e.g. ToS violation, fraud, business reason).
+   *
+   * The SDK does NOT hold the Seller's merchant private key; the Seller must
+   * construct + sign a `CancelAuth` with `by=1 (MERCHANT)` outside and pass
+   * it in. SDK runs verifyCancel (sanity check on the auth) then settleCancel
+   * (facilitator + store mark canceled).
+   *
+   * Throws on either verify or settle failure.
+   */
+  async cancelBySeller(subId, auth, _reason) {
+    const v = await this.scheme.verifyCancel(auth, subId);
+    if (!v.ok) {
+      throw new Error(`cancelBySeller.verify failed: ${v.error}`);
+    }
+    const r = await this.scheme.settleCancel(auth, subId);
+    if (!r.success) {
+      throw new Error(`cancelBySeller.settle failed: ${r.error}`);
+    }
+  }
+  /**
+   * Re-sync a subscription from chain and repair the store. Use when:
+   *   - `charge` threw `SubscriptionNotActive` (buyer may have cancelled
+   *     directly via the facilitator or contract)
+   *   - `charge` threw `ConfirmationTimeout` (network-level failure; chain
+   *     may or may not have written)
+   *   - periodic reconciliation
+   *
+   * If the synced sub is in `"changed"` state, the downstream `changedToSubId`
+   * is also fetched and persisted, so the Seller's `dueIndex` can switch over
+   * to the new sub without manual intervention.
+   */
+  async syncFromChain(subId) {
+    const latest = await this.scheme.getSubscription(subId);
+    if (!latest) return null;
+    await this.store.put(latest);
+    if (latest.state === "changed" && latest.changedToSubId) {
+      const newSub = await this.scheme.getSubscription(latest.changedToSubId);
+      if (newSub) await this.store.put(newSub);
+    }
+    return latest;
+  }
+  /**
+   * Direct store read. Cheap; does NOT touch the chain. Use this for hot-path
+   * lookups (e.g. resolving subId to plan/tier for business logic). For chain
+   * state of record, use `syncFromChain`.
+   */
+  async getSubscription(subId) {
+    return this.store.get(subId);
+  }
+};
+
+// src/subscription/codec/typed-data.ts
+var import_viem = require("viem");
+var ZERO_BYTES32 = `0x${"0".repeat(64)}`;
+var PERMIT2_TYPES = {
+  PermitSingle: [
+    { name: "details", type: "PermitDetails" },
+    { name: "spender", type: "address" },
+    { name: "sigDeadline", type: "uint256" }
+  ],
+  PermitDetails: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint160" },
+    { name: "expiration", type: "uint48" },
+    { name: "nonce", type: "uint48" }
+  ]
+};
+var SUBSCRIPTION_TERMS_TYPES = {
+  SubscriptionTerms: [
+    { name: "payer", type: "address" },
+    { name: "merchant", type: "address" },
+    { name: "facilitator", type: "address" },
+    { name: "token", type: "address" },
+    { name: "amountPerPeriod", type: "uint160" },
+    { name: "periodSec", type: "uint64" },
+    { name: "maxPeriods", type: "uint32" },
+    { name: "startAt", type: "uint64" },
+    { name: "initialChargePeriods", type: "uint32" },
+    { name: "initialChargeAmount", type: "uint160" },
+    { name: "termsDeadline", type: "uint64" },
+    { name: "permitHash", type: "bytes32" },
+    { name: "salt", type: "bytes32" },
+    { name: "planTier", type: "uint8" },
+    { name: "changeFromSubId", type: "bytes32" },
+    { name: "changeEffectiveAt", type: "uint8" },
+    { name: "periodMode", type: "uint8" }
+  ]
+};
+var CANCEL_AUTH_TYPES = {
+  CancelAuth: [
+    { name: "action", type: "uint8" },
+    { name: "subId", type: "bytes32" },
+    { name: "initiator", type: "uint8" },
+    { name: "nonce", type: "bytes32" },
+    { name: "deadline", type: "uint64" }
+  ]
+};
+var PENDING_CHANGE_CANCEL_AUTH_TYPES = {
+  PendingChangeCancelAuth: [
+    { name: "subId", type: "bytes32" },
+    { name: "newSubId", type: "bytes32" },
+    { name: "nonce", type: "bytes32" },
+    { name: "deadline", type: "uint64" }
+  ]
+};
+var CANCEL_INITIATOR_TO_ENUM = {
+  payer: 0,
+  merchant: 1
+};
+function getSubscriptionExtra(req) {
+  const extra = req.extra;
+  if (!extra || !extra.contracts || !extra.plan || !extra.domain) {
+    throw new Error(
+      "subscription codec: PaymentRequirements.extra is missing contracts/plan/domain"
+    );
+  }
+  return extra;
+}
+function defaultPermitAmount(extra) {
+  const initialChargePeriods = BigInt(extra.initialCharge?.periodCount ?? 0);
+  const initialChargeAmount = BigInt(extra.initialCharge?.totalAmount ?? "0");
+  const remainingPeriods = BigInt(extra.maxPeriods) - initialChargePeriods;
+  const remainingAmount = remainingPeriods > 0n ? remainingPeriods * BigInt(extra.amountPerPeriod) : 0n;
+  return (initialChargeAmount + remainingAmount).toString();
+}
+function buildPermit2TypedData(input) {
+  const extra = getSubscriptionExtra(input.selected);
+  const amount = input.amount ?? defaultPermitAmount(extra);
+  const chainId = parseChainIdFromNetwork(input.selected.network);
+  return {
+    domain: {
+      name: "Permit2",
+      chainId,
+      verifyingContract: extra.contracts.permit2
+    },
+    types: PERMIT2_TYPES,
+    primaryType: "PermitSingle",
+    message: {
+      details: {
+        token: input.selected.asset,
+        amount,
+        expiration: input.expiration,
+        nonce: input.nonce
+      },
+      spender: extra.contracts.subscription,
+      sigDeadline: input.sigDeadline
+    }
+  };
+}
+function computePermitSingleStructHash(permit) {
+  const PERMIT_DETAILS_TYPEHASH = (0, import_viem.keccak256)(
+    new TextEncoder().encode(
+      "PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)"
+    )
+  );
+  const detailsHash = (0, import_viem.keccak256)(
+    (0, import_viem.encodeAbiParameters)(
+      [
+        { type: "bytes32" },
+        { type: "address" },
+        { type: "uint160" },
+        { type: "uint48" },
+        { type: "uint48" }
+      ],
+      [
+        PERMIT_DETAILS_TYPEHASH,
+        permit.details.token,
+        BigInt(permit.details.amount),
+        Number(permit.details.expiration),
+        Number(permit.details.nonce)
+      ]
+    )
+  );
+  const PERMIT_SINGLE_TYPEHASH = (0, import_viem.keccak256)(
+    new TextEncoder().encode(
+      "PermitSingle(PermitDetails details,address spender,uint256 sigDeadline)PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)"
+    )
+  );
+  return (0, import_viem.keccak256)(
+    (0, import_viem.encodeAbiParameters)(
+      [{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "uint256" }],
+      [PERMIT_SINGLE_TYPEHASH, detailsHash, permit.spender, BigInt(permit.sigDeadline)]
+    )
+  );
+}
+function buildSubscriptionTermsTypedData(input) {
+  const extra = getSubscriptionExtra(input.selected);
+  const domain = input.domain ?? extra.domain;
+  let changeEffectiveAt = 0;
+  if (input.changeFrom?.effectiveAt === "immediate") changeEffectiveAt = 1;
+  else if (input.changeFrom?.effectiveAt === "period_end") changeEffectiveAt = 2;
+  const message = {
+    payer: input.payer,
+    merchant: input.selected.payTo,
+    facilitator: extra.facilitator,
+    token: input.selected.asset,
+    amountPerPeriod: extra.amountPerPeriod,
+    periodSec: extra.periodSec,
+    maxPeriods: extra.maxPeriods,
+    startAt: input.startAt,
+    initialChargePeriods: extra.initialCharge?.periodCount ?? 0,
+    initialChargeAmount: extra.initialCharge?.totalAmount ?? "0",
+    termsDeadline: input.termsDeadline,
+    permitHash: input.permitHash,
+    salt: input.salt,
+    planTier: extra.plan.tier,
+    changeFromSubId: input.changeFrom?.fromSubId ?? ZERO_BYTES32,
+    changeEffectiveAt,
+    periodMode: extra.periodMode ?? 0
+  };
+  return {
+    domain,
+    types: SUBSCRIPTION_TERMS_TYPES,
+    primaryType: "SubscriptionTerms",
+    message
+  };
+}
+function buildCancelAuthTypedData(input) {
+  return {
+    domain: input.domain,
+    types: CANCEL_AUTH_TYPES,
+    primaryType: "CancelAuth",
+    message: {
+      action: 0,
+      subId: input.subId,
+      initiator: CANCEL_INITIATOR_TO_ENUM[input.initiator],
+      nonce: input.nonce,
+      deadline: input.deadline
+    }
+  };
+}
+function buildPendingChangeCancelAuthTypedData(input) {
+  return {
+    domain: input.domain,
+    types: PENDING_CHANGE_CANCEL_AUTH_TYPES,
+    primaryType: "PendingChangeCancelAuth",
+    message: {
+      subId: input.subId,
+      newSubId: input.newSubId,
+      nonce: input.nonce,
+      deadline: input.deadline
+    }
+  };
+}
+function parseChainIdFromNetwork(network) {
+  const parts = network.split(":");
+  if (parts.length !== 2 || parts[0] !== "eip155") {
+    throw new Error(`parseChainIdFromNetwork: expected "eip155:<chainId>", got "${network}"`);
+  }
+  const id = Number(parts[1]);
+  if (!Number.isInteger(id) || id <= 0) {
+    throw new Error(`parseChainIdFromNetwork: invalid chainId "${parts[1]}"`);
+  }
+  return id;
+}
+
+// src/subscription/codec/verify-terms.ts
+function addrEq(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function hexEq(a, b) {
+  return !!a && a.toLowerCase() === b.toLowerCase();
+}
+function verifyTermsBindRequirements(terms, requirements) {
+  const extra = requirements.extra ?? {};
+  if (!extra.plan || extra.amountPerPeriod === void 0 || extra.facilitator === void 0) {
+    return ErrorCode.TermsBindingInvalid;
+  }
+  if (!addrEq(terms.merchant, requirements.payTo)) return ErrorCode.MerchantMismatch;
+  if (!addrEq(terms.token, requirements.asset)) return ErrorCode.TermsBindingInvalid;
+  if (!addrEq(terms.facilitator, extra.facilitator)) return ErrorCode.TermsBindingInvalid;
+  if (terms.amountPerPeriod !== extra.amountPerPeriod) return ErrorCode.TermsBindingInvalid;
+  if (terms.periodSec !== extra.periodSec) return ErrorCode.TermsBindingInvalid;
+  if (terms.maxPeriods !== extra.maxPeriods) return ErrorCode.TermsBindingInvalid;
+  if (terms.periodMode !== (extra.periodMode ?? 0)) return ErrorCode.TermsBindingInvalid;
+  if (terms.planTier !== extra.plan.tier) return ErrorCode.TermsBindingInvalid;
+  if (extra.startAt !== void 0 && terms.startAt !== extra.startAt) {
+    return ErrorCode.TermsBindingInvalid;
+  }
+  const expectedInitPeriods = extra.initialCharge?.periodCount ?? 0;
+  const expectedInitAmount = extra.initialCharge?.totalAmount ?? "0";
+  if (terms.initialChargePeriods !== expectedInitPeriods) return ErrorCode.TermsBindingInvalid;
+  if (terms.initialChargeAmount !== expectedInitAmount) return ErrorCode.TermsBindingInvalid;
+  if (extra.changeFrom) {
+    if (!hexEq(terms.changeFromSubId, extra.changeFrom.fromSubId)) {
+      return ErrorCode.TermsBindingInvalid;
+    }
+    const expectedEff = extra.changeFrom.effectiveAt === "immediate" ? 1 : extra.changeFrom.effectiveAt === "period_end" ? 2 : 0;
+    if (terms.changeEffectiveAt !== expectedEff) return ErrorCode.TermsBindingInvalid;
+  } else {
+    if (terms.changeFromSubId !== ZERO_BYTES32) return ErrorCode.TermsBindingInvalid;
+    if (terms.changeEffectiveAt !== 0) return ErrorCode.TermsBindingInvalid;
+  }
+  return null;
+}
+
+// src/subscription/codec/period-math.ts
+var PERIOD_MODE_CALENDAR_MONTH = 1;
+function computeElapsedPeriods(periodMode, startAt, billingAnchorAt, periodSec, nowSec) {
+  if (nowSec < startAt) return 0;
+  if (periodMode === PERIOD_MODE_CALENDAR_MONTH) {
+    const anchor = billingAnchorAt > 0 ? billingAnchorAt : startAt;
+    const startOffset = elapsedCalendarMonths(anchor, startAt);
+    return elapsedCalendarMonths(anchor, nowSec) - startOffset + 1;
+  }
+  if (periodSec <= 0) return 0;
+  return Math.floor((nowSec - startAt) / periodSec) + 1;
+}
+function elapsedCalendarMonths(anchorSec, tsSec) {
+  if (tsSec <= anchorSec) return 0;
+  const anchor = new Date(anchorSec * 1e3);
+  const ts = new Date(tsSec * 1e3);
+  let diff = (ts.getUTCFullYear() - anchor.getUTCFullYear()) * 12 + (ts.getUTCMonth() - anchor.getUTCMonth());
+  if (diff < 0) return 0;
+  if (addCalendarMonths(anchorSec, diff) > tsSec) diff--;
+  return Math.max(diff, 0);
+}
+function addCalendarMonths(anchorSec, n) {
+  const anchor = new Date(anchorSec * 1e3);
+  const targetYear = anchor.getUTCFullYear() + Math.floor((anchor.getUTCMonth() + n) / 12);
+  const targetMonth = ((anchor.getUTCMonth() + n) % 12 + 12) % 12;
+  const daysInTargetMonth = new Date(Date.UTC(targetYear, targetMonth + 1, 0)).getUTCDate();
+  const day = Math.min(anchor.getUTCDate(), daysInTargetMonth);
+  const ts = Date.UTC(
+    targetYear,
+    targetMonth,
+    day,
+    anchor.getUTCHours(),
+    anchor.getUTCMinutes(),
+    anchor.getUTCSeconds(),
+    anchor.getUTCMilliseconds()
+  );
+  return Math.floor(ts / 1e3);
+}
+
+// src/subscription/codec/base64.ts
+var hasBuffer = typeof Buffer !== "undefined";
+function base64EncodeUtf8(value) {
+  if (hasBuffer) return Buffer.from(value, "utf8").toString("base64");
+  const binary = unescape(encodeURIComponent(value));
+  return globalThis.btoa(binary);
+}
+function base64DecodeUtf8(value) {
+  if (hasBuffer) return Buffer.from(value, "base64").toString("utf8");
+  const binary = globalThis.atob(value);
+  return decodeURIComponent(escape(binary));
+}
+
+// src/subscription/codec/payload.ts
+function parsePaymentRequired(headerValue) {
+  const json = base64DecodeUtf8(headerValue);
+  const parsed = JSON.parse(json);
+  if (!parsed || !Array.isArray(parsed.accepts)) {
+    throw new Error("parsePaymentRequired: missing or invalid `accepts` array");
+  }
+  return parsed.accepts;
+}
+function encodePaymentPayload(input) {
+  const payload = {
+    x402Version: 2,
+    accepted: input.selected,
+    payload: {
+      permitSingle: input.permitSingle,
+      permitSingleSignature: input.permitSingleSignature,
+      terms: input.terms,
+      termsSignature: input.termsSignature
+    }
+  };
+  return base64EncodeUtf8(JSON.stringify(payload));
+}
+function decodePaymentPayload(headerValue) {
+  const json = base64DecodeUtf8(headerValue);
+  return JSON.parse(json);
+}
+function asSubscriptionPaymentInner(payload) {
+  const inner = payload.payload;
+  if (!inner || !inner.permitSingle || !inner.terms || !inner.permitSingleSignature || !inner.termsSignature) {
+    throw new Error(
+      "asSubscriptionPaymentInner: payload.payload is missing required permitSingle/terms fields"
+    );
+  }
+  return inner;
+}
+
+// src/subscription/codec/access-proof.ts
+var import_viem2 = require("viem");
+function buildAccessProofMessage(input) {
+  return (0, import_viem2.keccak256)(
+    (0, import_viem2.encodePacked)(
+      ["bytes32", "address", "uint256"],
+      [input.subId, input.payer, BigInt(input.timestamp)]
+    )
+  );
+}
+function encodeAccessProof(proof) {
+  return base64EncodeUtf8(JSON.stringify(proof));
+}
+function decodeAccessProof(headerValue) {
+  const json = base64DecodeUtf8(headerValue);
+  const parsed = JSON.parse(json);
+  if (!parsed || parsed.kind !== "subscription-id") {
+    throw new Error(`decodeAccessProof: expected kind="subscription-id", got "${parsed?.kind}"`);
+  }
+  return parsed;
+}
+
+// src/subscription/facilitator-client.ts
+function supportsSubscription(client) {
+  const c = client;
+  return typeof c.subscribe === "function" && typeof c.changeSubscription === "function" && typeof c.cancelSubscription === "function" && typeof c.cancelPendingChange === "function" && typeof c.chargeSubscription === "function" && typeof c.finalizeExpired === "function" && typeof c.getCharges === "function" && typeof c.getPendingChange === "function" && typeof c.getSubscription === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CANCEL_AUTH_TYPES,
+  ChargeError,
+  ChargeErrorCode,
+  ErrorCode,
+  InMemoryStore,
+  PENDING_CHANGE_CANCEL_AUTH_TYPES,
+  PERMIT2_TYPES,
+  SUBSCRIPTION_TERMS_TYPES,
+  SubscriptionClient,
+  ZERO_BYTES32,
+  addCalendarMonths,
+  asSubscriptionPaymentInner,
+  base64DecodeUtf8,
+  base64EncodeUtf8,
+  buildAccessProofMessage,
+  buildCancelAuthTypedData,
+  buildPendingChangeCancelAuthTypedData,
+  buildPermit2TypedData,
+  buildSubscriptionTermsTypedData,
+  computeElapsedPeriods,
+  computePermitSingleStructHash,
+  decodeAccessProof,
+  decodePaymentPayload,
+  elapsedCalendarMonths,
+  encodeAccessProof,
+  encodePaymentPayload,
+  hasSubscriptionCapability,
+  parseChainIdFromNetwork,
+  parsePaymentRequired,
+  supportsSubscription,
+  verifyTermsBindRequirements
+});
+//# sourceMappingURL=index.js.map