@puga-labs/x402-mantle-sdk 0.2.0 → 0.3.1

package/dist/server.cjs

@@ -0,0 +1,292 @@
+"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/server.ts
+var server_exports = {};
+__export(server_exports, {
+  MANTLE_DEFAULTS: () => MANTLE_DEFAULTS,
+  createPaymentMiddleware: () => createPaymentMiddleware,
+  mantlePaywall: () => mantlePaywall
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/shared/constants.ts
+var MANTLE_MAINNET_NETWORK_ID = "mantle-mainnet";
+var MANTLE_MAINNET_USDC = {
+  symbol: "USDC",
+  address: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9",
+  decimals: 6
+};
+var MANTLE_DEFAULTS = {
+  NETWORK: "mantle-mainnet",
+  CHAIN_ID: 5e3,
+  USDC_ADDRESS: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9",
+  USDC_DECIMALS: 6,
+  CURRENCY: "USD",
+  SCHEME: "exact",
+  FACILITATOR_URL: (typeof process !== "undefined" ? process.env?.NEXT_PUBLIC_FACILITATOR_URL : void 0) || "http://localhost:8080"
+};
+function getDefaultAssetForNetwork(network) {
+  switch (network) {
+    case MANTLE_MAINNET_NETWORK_ID:
+    default:
+      return MANTLE_MAINNET_USDC;
+  }
+}
+function usdCentsToAtomic(cents, decimals) {
+  if (cents < 0) {
+    throw new Error("priceUsdCents must be non-negative");
+  }
+  if (decimals < 2) {
+    throw new Error("token decimals must be >= 2 for USD cent conversion");
+  }
+  const base = BigInt(10) ** BigInt(decimals - 2);
+  return BigInt(cents) * base;
+}
+
+// src/server/constants.ts
+var DEFAULT_TELEMETRY_ENDPOINT = void 0;
+
+// src/server/telemetry.ts
+function createTelemetryEvent(entry, config) {
+  const assetConfig = getDefaultAssetForNetwork(entry.network);
+  return {
+    event: "payment_verified",
+    ts: entry.timestamp,
+    projectKey: config.projectKey,
+    network: entry.network,
+    buyer: entry.from,
+    payTo: entry.to,
+    amountAtomic: entry.valueAtomic,
+    asset: entry.asset,
+    decimals: assetConfig.decimals,
+    nonce: entry.id,
+    route: entry.route ?? "unknown",
+    // Facilitator metadata
+    facilitatorType: "hosted",
+    // SDK always uses hosted mode
+    facilitatorUrl: entry.facilitatorUrl,
+    // From PaymentLogEntry
+    // facilitatorAddress is undefined for SDK (not available)
+    // Optional metadata
+    txHash: entry.txHash,
+    priceUsd: entry.paymentRequirements?.price
+  };
+}
+async function sendTelemetry(event, endpoint) {
+  const targetEndpoint = endpoint ?? DEFAULT_TELEMETRY_ENDPOINT;
+  if (!targetEndpoint) {
+    return;
+  }
+  try {
+    const response = await fetch(targetEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${event.projectKey}`
+      },
+      body: JSON.stringify(event)
+    });
+    if (!response.ok) {
+      console.warn(
+        `[x402-telemetry] Failed to send event: HTTP ${response.status}`
+      );
+    }
+  } catch (err) {
+    console.error("[x402-telemetry] Error sending telemetry:", err);
+  }
+}
+
+// src/server/paymentMiddleware.ts
+function getRouteKey(req) {
+  const method = (req.method || "GET").toUpperCase();
+  const path = req.path || "/";
+  return `${method} ${path}`;
+}
+function decodePaymentHeader(paymentHeaderBase64) {
+  try {
+    if (typeof Buffer !== "undefined") {
+      const json = Buffer.from(paymentHeaderBase64, "base64").toString("utf8");
+      return JSON.parse(json);
+    }
+    if (typeof atob === "function") {
+      const json = atob(paymentHeaderBase64);
+      return JSON.parse(json);
+    }
+    throw new Error("No base64 decoding available in this environment");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    throw new Error(`Failed to decode paymentHeader: ${msg}`);
+  }
+}
+function createPaymentMiddleware(config) {
+  const { facilitatorUrl, receiverAddress, routes, onPaymentSettled, telemetry } = config;
+  if (!facilitatorUrl) {
+    throw new Error("facilitatorUrl is required");
+  }
+  if (!receiverAddress) {
+    throw new Error("receiverAddress is required");
+  }
+  if (!routes || Object.keys(routes).length === 0) {
+    throw new Error("routes config must not be empty");
+  }
+  return async function paymentMiddleware(req, res, next) {
+    const routeKey = getRouteKey(req);
+    const routeConfig = routes[routeKey];
+    if (!routeConfig) {
+      next();
+      return;
+    }
+    const { priceUsdCents, network } = routeConfig;
+    const assetConfig = getDefaultAssetForNetwork(network);
+    const maxAmountRequiredBigInt = usdCentsToAtomic(
+      priceUsdCents,
+      assetConfig.decimals
+    );
+    const paymentRequirements = {
+      scheme: "exact",
+      network,
+      asset: assetConfig.address,
+      maxAmountRequired: maxAmountRequiredBigInt.toString(),
+      payTo: receiverAddress,
+      price: `$${(priceUsdCents / 100).toFixed(2)}`,
+      currency: "USD"
+    };
+    const paymentHeader = req.header("X-PAYMENT") ?? req.header("x-payment");
+    if (!paymentHeader) {
+      res.status(402).json({
+        error: "Payment Required",
+        paymentRequirements,
+        paymentHeader: null
+      });
+      return;
+    }
+    try {
+      const verifyUrl = `${facilitatorUrl.replace(/\/+$/, "")}/verify`;
+      const verifyRes = await fetch(verifyUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          x402Version: 1,
+          paymentHeader,
+          paymentRequirements
+        })
+      });
+      if (!verifyRes.ok) {
+        const text = await verifyRes.text().catch(() => "");
+        console.error(
+          "[x402-mantle-sdk] Facilitator /verify returned non-OK:",
+          verifyRes.status,
+          text
+        );
+        res.status(500).json({
+          error: "Payment verification error",
+          details: `Facilitator responded with HTTP ${verifyRes.status}`
+        });
+        return;
+      }
+      const verifyJson = await verifyRes.json();
+      if (!verifyJson.isValid) {
+        res.status(402).json({
+          error: "Payment verification failed",
+          invalidReason: verifyJson.invalidReason ?? null,
+          paymentRequirements,
+          paymentHeader: null
+        });
+        return;
+      }
+      if (onPaymentSettled) {
+        try {
+          const headerObj = decodePaymentHeader(paymentHeader);
+          const { authorization } = headerObj.payload;
+          const logEntry = {
+            id: authorization.nonce,
+            from: authorization.from,
+            to: authorization.to,
+            valueAtomic: authorization.value,
+            network,
+            asset: assetConfig.address,
+            route: routeKey,
+            timestamp: Date.now(),
+            facilitatorUrl,
+            // Pass from config closure
+            paymentRequirements
+          };
+          onPaymentSettled(logEntry);
+          if (telemetry) {
+            const event = createTelemetryEvent(logEntry, telemetry);
+            sendTelemetry(event, telemetry.endpoint).catch(
+              (err) => console.error("[x402-telemetry] Async send failed:", err)
+            );
+          }
+        } catch (err) {
+          console.error(
+            "[x402-mantle-sdk] Error calling onPaymentSettled hook:",
+            err
+          );
+        }
+      }
+      next();
+      return;
+    } catch (err) {
+      console.error(
+        "[x402-mantle-sdk] Error while calling facilitator /verify:",
+        err
+      );
+      const message = err instanceof Error ? err.message : "Unknown verification error";
+      res.status(500).json({
+        error: "Payment verification error",
+        details: message
+      });
+      return;
+    }
+  };
+}
+
+// src/server/mantlePaywall.ts
+function mantlePaywall(opts) {
+  const { priceUsd, payTo, facilitatorUrl, telemetry, onPaymentSettled } = opts;
+  const priceUsdCents = Math.round(priceUsd * 100);
+  return async (req, res, next) => {
+    const method = (req.method || "GET").toUpperCase();
+    const path = req.path || "/";
+    const routeKey = `${method} ${path}`;
+    const middleware = createPaymentMiddleware({
+      facilitatorUrl: facilitatorUrl || MANTLE_DEFAULTS.FACILITATOR_URL,
+      receiverAddress: payTo,
+      routes: {
+        [routeKey]: {
+          priceUsdCents,
+          network: MANTLE_DEFAULTS.NETWORK
+        }
+      },
+      telemetry,
+      onPaymentSettled
+    });
+    return middleware(req, res, next);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MANTLE_DEFAULTS,
+  createPaymentMiddleware,
+  mantlePaywall
+});

package/dist/server.d.cts

@@ -0,0 +1,116 @@
+import { Request, Response, NextFunction } from 'express';
+import { N as NetworkId, P as PaymentRequirements } from './types-2zqbJvcz.cjs';
+export { A as AssetConfig, a as Authorization, E as EIP1193Provider, d as PaymentHeaderBase64, c as PaymentHeaderObject, b as PaymentHeaderPayload } from './types-2zqbJvcz.cjs';
+export { M as MANTLE_DEFAULTS } from './constants-DzCGK0Q3.cjs';
+
+/** Unique key for a protected route, e.g. "GET /api/protected". */
+type RouteKey = string;
+/** Pricing config for a single route. */
+interface RoutePricingConfig {
+    /** Price in USD cents, e.g. 1 => $0.01. */
+    priceUsdCents: number;
+    /** Network identifier (e.g. "mantle-mainnet"). */
+    network: NetworkId;
+}
+/** Map of route keys to pricing config. */
+type RoutesConfig = Record<RouteKey, RoutePricingConfig>;
+/** Log entry for a successfully settled payment. */
+interface PaymentLogEntry {
+    id: string;
+    from: string;
+    to: string;
+    valueAtomic: string;
+    network: NetworkId;
+    asset: string;
+    route?: RouteKey;
+    txHash?: string;
+    timestamp: number;
+    facilitatorUrl?: string;
+    paymentRequirements?: PaymentRequirements;
+}
+/** Config for optional telemetry (billing/analytics). */
+interface TelemetryConfig {
+    /** Project key from nosubs.ai dashboard. */
+    projectKey: string;
+    /**
+     * Telemetry endpoint URL.
+     * If not specified, uses DEFAULT_TELEMETRY_ENDPOINT (see server/constants.ts).
+     * If both are undefined, telemetry is not sent.
+     */
+    endpoint?: string;
+}
+/** Telemetry event payload for payment_verified. */
+interface TelemetryEvent {
+    event: "payment_verified";
+    ts: number;
+    projectKey: string;
+    network: string;
+    buyer: string;
+    payTo: string;
+    amountAtomic: string;
+    asset: string;
+    decimals: number;
+    nonce: string;
+    route: string;
+    facilitatorType: "hosted" | "self-hosted";
+    facilitatorUrl?: string;
+    facilitatorAddress?: string;
+    txHash?: string;
+    priceUsd?: string;
+}
+/** Config for createPaymentMiddleware. */
+interface PaymentMiddlewareConfig {
+    /** Base URL of facilitator, e.g. https://facilitator.nosubs.ai */
+    facilitatorUrl: string;
+    /** Recipient address (developer). */
+    receiverAddress: `0x${string}`;
+    /** Map of protected routes and their pricing. */
+    routes: RoutesConfig;
+    /**
+     * Optional hook called whenever a payment is successfully settled.
+     * You can use this to push logs into your DB / analytics pipeline.
+     */
+    onPaymentSettled?: (entry: PaymentLogEntry) => void;
+    /** Optional: Send usage telemetry for billing/analytics. */
+    telemetry?: TelemetryConfig;
+}
+/**
+ * Minimal config for mantlePaywall() - simplified API for single-route protection.
+ * This is the "sweet path" for Mantle mainnet + USDC with sensible defaults.
+ */
+interface MinimalPaywallOptions {
+    /** Price in USD (e.g. 0.01 for 1 cent). */
+    priceUsd: number;
+    /** Recipient address (developer wallet). */
+    payTo: `0x${string}`;
+    /** Optional facilitator URL (defaults to localhost:8080 or NEXT_PUBLIC_FACILITATOR_URL). */
+    facilitatorUrl?: string;
+    /** Optional telemetry config. */
+    telemetry?: TelemetryConfig;
+    /** Optional payment settled hook. */
+    onPaymentSettled?: (entry: PaymentLogEntry) => void;
+}
+/**
+ * Express middleware function type for Mantle paywall.
+ * Async function that returns Promise<void>.
+ */
+type MantleMiddleware = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+
+declare function createPaymentMiddleware(config: PaymentMiddlewareConfig): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+
+/**
+ * Simplified wrapper for protecting a single route with x402 payments.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * Usage:
+ * ```typescript
+ * const pay = mantlePaywall({ priceUsd: 0.01, payTo: "0x..." });
+ * export const POST = pay(async (req) => { ... });
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Express middleware function for single-route protection.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): MantleMiddleware;
+
+export { type MantleMiddleware, type MinimalPaywallOptions, NetworkId, type PaymentLogEntry, type PaymentMiddlewareConfig, PaymentRequirements, type RouteKey, type RoutePricingConfig, type RoutesConfig, type TelemetryConfig, type TelemetryEvent, createPaymentMiddleware, mantlePaywall };

package/dist/server.d.ts

@@ -0,0 +1,116 @@
+import { Request, Response, NextFunction } from 'express';
+import { N as NetworkId, P as PaymentRequirements } from './types-2zqbJvcz.js';
+export { A as AssetConfig, a as Authorization, E as EIP1193Provider, d as PaymentHeaderBase64, c as PaymentHeaderObject, b as PaymentHeaderPayload } from './types-2zqbJvcz.js';
+export { M as MANTLE_DEFAULTS } from './constants-CVFF0ray.js';
+
+/** Unique key for a protected route, e.g. "GET /api/protected". */
+type RouteKey = string;
+/** Pricing config for a single route. */
+interface RoutePricingConfig {
+    /** Price in USD cents, e.g. 1 => $0.01. */
+    priceUsdCents: number;
+    /** Network identifier (e.g. "mantle-mainnet"). */
+    network: NetworkId;
+}
+/** Map of route keys to pricing config. */
+type RoutesConfig = Record<RouteKey, RoutePricingConfig>;
+/** Log entry for a successfully settled payment. */
+interface PaymentLogEntry {
+    id: string;
+    from: string;
+    to: string;
+    valueAtomic: string;
+    network: NetworkId;
+    asset: string;
+    route?: RouteKey;
+    txHash?: string;
+    timestamp: number;
+    facilitatorUrl?: string;
+    paymentRequirements?: PaymentRequirements;
+}
+/** Config for optional telemetry (billing/analytics). */
+interface TelemetryConfig {
+    /** Project key from nosubs.ai dashboard. */
+    projectKey: string;
+    /**
+     * Telemetry endpoint URL.
+     * If not specified, uses DEFAULT_TELEMETRY_ENDPOINT (see server/constants.ts).
+     * If both are undefined, telemetry is not sent.
+     */
+    endpoint?: string;
+}
+/** Telemetry event payload for payment_verified. */
+interface TelemetryEvent {
+    event: "payment_verified";
+    ts: number;
+    projectKey: string;
+    network: string;
+    buyer: string;
+    payTo: string;
+    amountAtomic: string;
+    asset: string;
+    decimals: number;
+    nonce: string;
+    route: string;
+    facilitatorType: "hosted" | "self-hosted";
+    facilitatorUrl?: string;
+    facilitatorAddress?: string;
+    txHash?: string;
+    priceUsd?: string;
+}
+/** Config for createPaymentMiddleware. */
+interface PaymentMiddlewareConfig {
+    /** Base URL of facilitator, e.g. https://facilitator.nosubs.ai */
+    facilitatorUrl: string;
+    /** Recipient address (developer). */
+    receiverAddress: `0x${string}`;
+    /** Map of protected routes and their pricing. */
+    routes: RoutesConfig;
+    /**
+     * Optional hook called whenever a payment is successfully settled.
+     * You can use this to push logs into your DB / analytics pipeline.
+     */
+    onPaymentSettled?: (entry: PaymentLogEntry) => void;
+    /** Optional: Send usage telemetry for billing/analytics. */
+    telemetry?: TelemetryConfig;
+}
+/**
+ * Minimal config for mantlePaywall() - simplified API for single-route protection.
+ * This is the "sweet path" for Mantle mainnet + USDC with sensible defaults.
+ */
+interface MinimalPaywallOptions {
+    /** Price in USD (e.g. 0.01 for 1 cent). */
+    priceUsd: number;
+    /** Recipient address (developer wallet). */
+    payTo: `0x${string}`;
+    /** Optional facilitator URL (defaults to localhost:8080 or NEXT_PUBLIC_FACILITATOR_URL). */
+    facilitatorUrl?: string;
+    /** Optional telemetry config. */
+    telemetry?: TelemetryConfig;
+    /** Optional payment settled hook. */
+    onPaymentSettled?: (entry: PaymentLogEntry) => void;
+}
+/**
+ * Express middleware function type for Mantle paywall.
+ * Async function that returns Promise<void>.
+ */
+type MantleMiddleware = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+
+declare function createPaymentMiddleware(config: PaymentMiddlewareConfig): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+
+/**
+ * Simplified wrapper for protecting a single route with x402 payments.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * Usage:
+ * ```typescript
+ * const pay = mantlePaywall({ priceUsd: 0.01, payTo: "0x..." });
+ * export const POST = pay(async (req) => { ... });
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Express middleware function for single-route protection.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): MantleMiddleware;
+
+export { type MantleMiddleware, type MinimalPaywallOptions, NetworkId, type PaymentLogEntry, type PaymentMiddlewareConfig, PaymentRequirements, type RouteKey, type RoutePricingConfig, type RoutesConfig, type TelemetryConfig, type TelemetryEvent, createPaymentMiddleware, mantlePaywall };

package/dist/server.js

@@ -0,0 +1,12 @@
+import {
+  createPaymentMiddleware,
+  mantlePaywall
+} from "./chunk-Q6SPMEIW.js";
+import {
+  MANTLE_DEFAULTS
+} from "./chunk-XAQGMFSR.js";
+export {
+  MANTLE_DEFAULTS,
+  createPaymentMiddleware,
+  mantlePaywall
+};

package/dist/types-2zqbJvcz.d.cts

@@ -0,0 +1,63 @@
+/** Network identifier used in x402 paymentRequirements / paymentHeader. */
+type NetworkId = "mantle-mainnet" | (string & {});
+/** Basic ERC-20 asset config (e.g. USDC on Mantle). */
+interface AssetConfig {
+    symbol: string;
+    address: string;
+    decimals: number;
+}
+/** x402-style payment requirements (returned in 402 response). */
+interface PaymentRequirements {
+    scheme: "exact";
+    network: NetworkId;
+    asset: string;
+    maxAmountRequired: string;
+    payTo: `0x${string}`;
+    price?: string;
+    currency?: string;
+}
+/** EIP-3009 TransferWithAuthorization payload. */
+interface Authorization {
+    from: string;
+    to: string;
+    value: string;
+    validAfter: string;
+    validBefore: string;
+    nonce: string;
+}
+/** Inner payload of x402-style payment header. */
+interface PaymentHeaderPayload {
+    signature: string;
+    authorization: Authorization;
+}
+/** Structured x402-style payment header (before base64 encoding). */
+interface PaymentHeaderObject {
+    x402Version: number;
+    scheme: "exact";
+    network: NetworkId;
+    payload: PaymentHeaderPayload;
+}
+/** Base64-encoded payment header, sent in X-PAYMENT. */
+type PaymentHeaderBase64 = string;
+/**
+ * EIP-1193 provider interface (window.ethereum, MetaMask, etc.)
+ * Standard interface for Ethereum wallet providers.
+ */
+interface EIP1193Provider {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on?(event: string, listener: (...args: unknown[]) => void): void;
+    removeListener?(event: string, listener: (...args: unknown[]) => void): void;
+}
+/**
+ * Window ethereum extension for TypeScript
+ */
+declare global {
+    interface Window {
+        ethereum?: EIP1193Provider;
+    }
+}
+
+export type { AssetConfig as A, EIP1193Provider as E, NetworkId as N, PaymentRequirements as P, Authorization as a, PaymentHeaderPayload as b, PaymentHeaderObject as c, PaymentHeaderBase64 as d };

package/dist/types-2zqbJvcz.d.ts

@@ -0,0 +1,63 @@
+/** Network identifier used in x402 paymentRequirements / paymentHeader. */
+type NetworkId = "mantle-mainnet" | (string & {});
+/** Basic ERC-20 asset config (e.g. USDC on Mantle). */
+interface AssetConfig {
+    symbol: string;
+    address: string;
+    decimals: number;
+}
+/** x402-style payment requirements (returned in 402 response). */
+interface PaymentRequirements {
+    scheme: "exact";
+    network: NetworkId;
+    asset: string;
+    maxAmountRequired: string;
+    payTo: `0x${string}`;
+    price?: string;
+    currency?: string;
+}
+/** EIP-3009 TransferWithAuthorization payload. */
+interface Authorization {
+    from: string;
+    to: string;
+    value: string;
+    validAfter: string;
+    validBefore: string;
+    nonce: string;
+}
+/** Inner payload of x402-style payment header. */
+interface PaymentHeaderPayload {
+    signature: string;
+    authorization: Authorization;
+}
+/** Structured x402-style payment header (before base64 encoding). */
+interface PaymentHeaderObject {
+    x402Version: number;
+    scheme: "exact";
+    network: NetworkId;
+    payload: PaymentHeaderPayload;
+}
+/** Base64-encoded payment header, sent in X-PAYMENT. */
+type PaymentHeaderBase64 = string;
+/**
+ * EIP-1193 provider interface (window.ethereum, MetaMask, etc.)
+ * Standard interface for Ethereum wallet providers.
+ */
+interface EIP1193Provider {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on?(event: string, listener: (...args: unknown[]) => void): void;
+    removeListener?(event: string, listener: (...args: unknown[]) => void): void;
+}
+/**
+ * Window ethereum extension for TypeScript
+ */
+declare global {
+    interface Window {
+        ethereum?: EIP1193Provider;
+    }
+}
+
+export type { AssetConfig as A, EIP1193Provider as E, NetworkId as N, PaymentRequirements as P, Authorization as a, PaymentHeaderPayload as b, PaymentHeaderObject as c, PaymentHeaderBase64 as d };