@perkos/service-x402 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,94 @@
+import { Address, X402VerifyRequest, VerifyResponse, PaymentPayload, PaymentRequirements } from '@perkos/types-x402';
+export { Address, DeferredPayload, ExactPayload, Hex, PaymentPayload, PaymentRequirements, SettleResponse, VerifyResponse, Voucher, X402SettleRequest, X402VerifyRequest } from '@perkos/types-x402';
+import { SupportedNetwork } from '@perkos/util-chains';
+export { SUPPORTED_NETWORKS, SupportedNetwork, getChainIdFromNetwork } from '@perkos/util-chains';
+import { ExactSchemeVerifier } from '@perkos/scheme-exact';
+export { ExactSchemeVerifier, createEIP712Domain as createExactEIP712Domain, generateNonce, parseSignature as parseExactSignature } from '@perkos/scheme-exact';
+import { DeferredSchemeVerifier } from '@perkos/scheme-deferred';
+export { DeferredSchemeVerifier, createEIP712Domain as createDeferredEIP712Domain, createVoucherMessage, createVoucherTuple, generateVoucherId, parseSignature as parseDeferredSignature } from '@perkos/scheme-deferred';
+
+/**
+ * @perkos/service-x402
+ * Unified x402 payment protocol verification and settlement service
+ */
+
+interface X402ServiceConfig {
+    /** Default network to use */
+    defaultNetwork?: SupportedNetwork;
+    /** RPC URL overrides by network */
+    rpcUrls?: Partial<Record<SupportedNetwork, string>>;
+    /** Enable deferred scheme */
+    deferredEnabled?: boolean;
+    /** Escrow addresses for deferred scheme by network */
+    escrowAddresses?: Partial<Record<SupportedNetwork, Address>>;
+    /** Token name overrides for exact scheme (by chainId) */
+    tokenNames?: Record<number, string>;
+    /** Token version overrides for exact scheme (by chainId) */
+    tokenVersions?: Record<number, string>;
+}
+interface SupportedResponse {
+    kinds: Array<{
+        scheme: "exact" | "deferred";
+        network: SupportedNetwork;
+    }>;
+}
+declare class X402Service {
+    private config;
+    private exactSchemes;
+    private deferredSchemes;
+    constructor(config?: X402ServiceConfig);
+    /**
+     * Convert CAIP-2 network format to legacy format
+     */
+    caip2ToLegacy(caip2: string): SupportedNetwork | null;
+    /**
+     * Convert legacy network format to CAIP-2 format
+     */
+    legacyToCaip2(network: SupportedNetwork): string | null;
+    /**
+     * Normalize network format (CAIP-2 or legacy) to legacy format
+     */
+    normalizeNetwork(network: string): SupportedNetwork | null;
+    /**
+     * Verify payment payload
+     */
+    verify(request: X402VerifyRequest): Promise<VerifyResponse>;
+    /**
+     * Verify payment without full request wrapper
+     */
+    verifyPayload(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Get supported schemes and networks
+     */
+    getSupported(): SupportedResponse;
+    /**
+     * Check if a network is supported
+     */
+    isNetworkSupported(network: string): boolean;
+    /**
+     * Check if deferred scheme is enabled for a network
+     */
+    isDeferredEnabled(network: string): boolean;
+    /**
+     * Get exact scheme verifier for network
+     */
+    getExactScheme(network: SupportedNetwork): ExactSchemeVerifier | undefined;
+    /**
+     * Get deferred scheme verifier for network
+     */
+    getDeferredScheme(network: SupportedNetwork): DeferredSchemeVerifier | undefined;
+    /**
+     * Get default network
+     */
+    getDefaultNetwork(): SupportedNetwork;
+}
+/**
+ * Create a new X402 service instance
+ */
+declare function createX402Service(config?: X402ServiceConfig): X402Service;
+/**
+ * Create a minimal X402 service for verification only (no deferred scheme)
+ */
+declare function createVerificationService(networks?: SupportedNetwork[], rpcUrls?: Partial<Record<SupportedNetwork, string>>): X402Service;
+
+export { type SupportedResponse, X402Service, type X402ServiceConfig, createVerificationService, createX402Service };

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import { Address, X402VerifyRequest, VerifyResponse, PaymentPayload, PaymentRequirements } from '@perkos/types-x402';
+export { Address, DeferredPayload, ExactPayload, Hex, PaymentPayload, PaymentRequirements, SettleResponse, VerifyResponse, Voucher, X402SettleRequest, X402VerifyRequest } from '@perkos/types-x402';
+import { SupportedNetwork } from '@perkos/util-chains';
+export { SUPPORTED_NETWORKS, SupportedNetwork, getChainIdFromNetwork } from '@perkos/util-chains';
+import { ExactSchemeVerifier } from '@perkos/scheme-exact';
+export { ExactSchemeVerifier, createEIP712Domain as createExactEIP712Domain, generateNonce, parseSignature as parseExactSignature } from '@perkos/scheme-exact';
+import { DeferredSchemeVerifier } from '@perkos/scheme-deferred';
+export { DeferredSchemeVerifier, createEIP712Domain as createDeferredEIP712Domain, createVoucherMessage, createVoucherTuple, generateVoucherId, parseSignature as parseDeferredSignature } from '@perkos/scheme-deferred';
+
+/**
+ * @perkos/service-x402
+ * Unified x402 payment protocol verification and settlement service
+ */
+
+interface X402ServiceConfig {
+    /** Default network to use */
+    defaultNetwork?: SupportedNetwork;
+    /** RPC URL overrides by network */
+    rpcUrls?: Partial<Record<SupportedNetwork, string>>;
+    /** Enable deferred scheme */
+    deferredEnabled?: boolean;
+    /** Escrow addresses for deferred scheme by network */
+    escrowAddresses?: Partial<Record<SupportedNetwork, Address>>;
+    /** Token name overrides for exact scheme (by chainId) */
+    tokenNames?: Record<number, string>;
+    /** Token version overrides for exact scheme (by chainId) */
+    tokenVersions?: Record<number, string>;
+}
+interface SupportedResponse {
+    kinds: Array<{
+        scheme: "exact" | "deferred";
+        network: SupportedNetwork;
+    }>;
+}
+declare class X402Service {
+    private config;
+    private exactSchemes;
+    private deferredSchemes;
+    constructor(config?: X402ServiceConfig);
+    /**
+     * Convert CAIP-2 network format to legacy format
+     */
+    caip2ToLegacy(caip2: string): SupportedNetwork | null;
+    /**
+     * Convert legacy network format to CAIP-2 format
+     */
+    legacyToCaip2(network: SupportedNetwork): string | null;
+    /**
+     * Normalize network format (CAIP-2 or legacy) to legacy format
+     */
+    normalizeNetwork(network: string): SupportedNetwork | null;
+    /**
+     * Verify payment payload
+     */
+    verify(request: X402VerifyRequest): Promise<VerifyResponse>;
+    /**
+     * Verify payment without full request wrapper
+     */
+    verifyPayload(payload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Get supported schemes and networks
+     */
+    getSupported(): SupportedResponse;
+    /**
+     * Check if a network is supported
+     */
+    isNetworkSupported(network: string): boolean;
+    /**
+     * Check if deferred scheme is enabled for a network
+     */
+    isDeferredEnabled(network: string): boolean;
+    /**
+     * Get exact scheme verifier for network
+     */
+    getExactScheme(network: SupportedNetwork): ExactSchemeVerifier | undefined;
+    /**
+     * Get deferred scheme verifier for network
+     */
+    getDeferredScheme(network: SupportedNetwork): DeferredSchemeVerifier | undefined;
+    /**
+     * Get default network
+     */
+    getDefaultNetwork(): SupportedNetwork;
+}
+/**
+ * Create a new X402 service instance
+ */
+declare function createX402Service(config?: X402ServiceConfig): X402Service;
+/**
+ * Create a minimal X402 service for verification only (no deferred scheme)
+ */
+declare function createVerificationService(networks?: SupportedNetwork[], rpcUrls?: Partial<Record<SupportedNetwork, string>>): X402Service;
+
+export { type SupportedResponse, X402Service, type X402ServiceConfig, createVerificationService, createX402Service };

package/dist/index.js

@@ -0,0 +1,301 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DeferredSchemeVerifier: () => import_scheme_deferred2.DeferredSchemeVerifier,
+  ExactSchemeVerifier: () => import_scheme_exact2.ExactSchemeVerifier,
+  SUPPORTED_NETWORKS: () => import_util_chains2.SUPPORTED_NETWORKS,
+  X402Service: () => X402Service,
+  createDeferredEIP712Domain: () => import_scheme_deferred2.createEIP712Domain,
+  createExactEIP712Domain: () => import_scheme_exact2.createEIP712Domain,
+  createVerificationService: () => createVerificationService,
+  createVoucherMessage: () => import_scheme_deferred2.createVoucherMessage,
+  createVoucherTuple: () => import_scheme_deferred2.createVoucherTuple,
+  createX402Service: () => createX402Service,
+  generateNonce: () => import_scheme_exact2.generateNonce,
+  generateVoucherId: () => import_scheme_deferred2.generateVoucherId,
+  getChainIdFromNetwork: () => import_util_chains2.getChainIdFromNetwork,
+  parseDeferredSignature: () => import_scheme_deferred2.parseSignature,
+  parseExactSignature: () => import_scheme_exact2.parseSignature
+});
+module.exports = __toCommonJS(index_exports);
+var import_util_chains = require("@perkos/util-chains");
+var import_scheme_exact = require("@perkos/scheme-exact");
+var import_scheme_deferred = require("@perkos/scheme-deferred");
+var import_util_chains2 = require("@perkos/util-chains");
+var import_scheme_exact2 = require("@perkos/scheme-exact");
+var import_scheme_deferred2 = require("@perkos/scheme-deferred");
+var CAIP2_TO_LEGACY = {
+  // Avalanche
+  "eip155:43114": "avalanche",
+  "eip155:43113": "avalanche-fuji",
+  // Celo
+  "eip155:42220": "celo",
+  "eip155:11142220": "celo-sepolia",
+  // Base
+  "eip155:8453": "base",
+  "eip155:84532": "base-sepolia",
+  // Ethereum
+  "eip155:1": "ethereum",
+  "eip155:11155111": "sepolia",
+  // Polygon
+  "eip155:137": "polygon",
+  "eip155:80002": "polygon-amoy",
+  // Monad
+  "eip155:10142": "monad",
+  "eip155:10143": "monad-testnet",
+  // Arbitrum
+  "eip155:42161": "arbitrum",
+  "eip155:421614": "arbitrum-sepolia",
+  // Optimism
+  "eip155:10": "optimism",
+  "eip155:11155420": "optimism-sepolia"
+};
+var LEGACY_TO_CAIP2 = Object.fromEntries(
+  Object.entries(CAIP2_TO_LEGACY).map(([k, v]) => [v, k])
+);
+var X402Service = class {
+  constructor(config = {}) {
+    this.exactSchemes = /* @__PURE__ */ new Map();
+    this.deferredSchemes = /* @__PURE__ */ new Map();
+    this.config = {
+      defaultNetwork: "base-sepolia",
+      deferredEnabled: false,
+      ...config
+    };
+    for (const network of import_util_chains.SUPPORTED_NETWORKS) {
+      const chainId = (0, import_util_chains.getChainIdFromNetwork)(network);
+      if (chainId) {
+        this.exactSchemes.set(
+          network,
+          new import_scheme_exact.ExactSchemeVerifier({
+            network,
+            rpcUrl: this.config.rpcUrls?.[network],
+            tokenName: chainId ? this.config.tokenNames?.[chainId] : void 0,
+            tokenVersion: chainId ? this.config.tokenVersions?.[chainId] : void 0
+          })
+        );
+      }
+    }
+    if (this.config.deferredEnabled && this.config.escrowAddresses) {
+      for (const [network, escrowAddress] of Object.entries(this.config.escrowAddresses)) {
+        if (escrowAddress && import_util_chains.SUPPORTED_NETWORKS.includes(network)) {
+          try {
+            this.deferredSchemes.set(
+              network,
+              new import_scheme_deferred.DeferredSchemeVerifier({
+                network,
+                escrowAddress,
+                rpcUrl: this.config.rpcUrls?.[network]
+              })
+            );
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Convert CAIP-2 network format to legacy format
+   */
+  caip2ToLegacy(caip2) {
+    return CAIP2_TO_LEGACY[caip2] || null;
+  }
+  /**
+   * Convert legacy network format to CAIP-2 format
+   */
+  legacyToCaip2(network) {
+    return LEGACY_TO_CAIP2[network] || null;
+  }
+  /**
+   * Normalize network format (CAIP-2 or legacy) to legacy format
+   */
+  normalizeNetwork(network) {
+    if (import_util_chains.SUPPORTED_NETWORKS.includes(network)) {
+      return network;
+    }
+    if (network.includes(":")) {
+      return this.caip2ToLegacy(network);
+    }
+    return null;
+  }
+  /**
+   * Verify payment payload
+   */
+  async verify(request) {
+    const { paymentPayload, paymentRequirements } = request;
+    const isV1 = request.x402Version === 1 && paymentPayload.x402Version === 1;
+    const isV2 = request.x402Version === 2 && paymentPayload.x402Version === 2;
+    if (!isV1 && !isV2) {
+      return {
+        isValid: false,
+        invalidReason: `Unsupported x402 version. Expected 1 or 2, got ${request.x402Version} (payload: ${paymentPayload.x402Version})`,
+        payer: null
+      };
+    }
+    const normalizedPayloadNetwork = this.normalizeNetwork(paymentPayload.network);
+    const normalizedRequirementsNetwork = this.normalizeNetwork(paymentRequirements.network);
+    if (!normalizedPayloadNetwork) {
+      return {
+        isValid: false,
+        invalidReason: `Unsupported network: ${paymentPayload.network}`,
+        payer: null
+      };
+    }
+    if (!normalizedRequirementsNetwork) {
+      return {
+        isValid: false,
+        invalidReason: `Unsupported network: ${paymentRequirements.network}`,
+        payer: null
+      };
+    }
+    if (normalizedPayloadNetwork !== normalizedRequirementsNetwork) {
+      return {
+        isValid: false,
+        invalidReason: `Network mismatch between payload (${paymentPayload.network}) and requirements (${paymentRequirements.network})`,
+        payer: null
+      };
+    }
+    if (paymentPayload.scheme !== paymentRequirements.scheme) {
+      return {
+        isValid: false,
+        invalidReason: "Scheme mismatch",
+        payer: null
+      };
+    }
+    const network = normalizedPayloadNetwork;
+    if (paymentPayload.scheme === "exact") {
+      const exactScheme = this.exactSchemes.get(network);
+      if (!exactScheme) {
+        return {
+          isValid: false,
+          invalidReason: `Exact scheme not initialized for network: ${network}`,
+          payer: null
+        };
+      }
+      return exactScheme.verify(
+        paymentPayload.payload,
+        paymentRequirements
+      );
+    } else if (paymentPayload.scheme === "deferred") {
+      const deferredScheme = this.deferredSchemes.get(network);
+      if (!deferredScheme) {
+        return {
+          isValid: false,
+          invalidReason: `Deferred scheme not enabled for network: ${network}`,
+          payer: null
+        };
+      }
+      return deferredScheme.verify(
+        paymentPayload.payload,
+        paymentRequirements
+      );
+    } else {
+      return {
+        isValid: false,
+        invalidReason: `Unsupported scheme: ${paymentPayload.scheme}`,
+        payer: null
+      };
+    }
+  }
+  /**
+   * Verify payment without full request wrapper
+   */
+  async verifyPayload(payload, requirements) {
+    return this.verify({
+      x402Version: payload.x402Version,
+      paymentPayload: payload,
+      paymentRequirements: requirements
+    });
+  }
+  /**
+   * Get supported schemes and networks
+   */
+  getSupported() {
+    const kinds = [];
+    for (const network of this.exactSchemes.keys()) {
+      kinds.push({ scheme: "exact", network });
+    }
+    for (const network of this.deferredSchemes.keys()) {
+      kinds.push({ scheme: "deferred", network });
+    }
+    return { kinds };
+  }
+  /**
+   * Check if a network is supported
+   */
+  isNetworkSupported(network) {
+    const normalized = this.normalizeNetwork(network);
+    return normalized !== null && this.exactSchemes.has(normalized);
+  }
+  /**
+   * Check if deferred scheme is enabled for a network
+   */
+  isDeferredEnabled(network) {
+    const normalized = this.normalizeNetwork(network);
+    return normalized !== null && this.deferredSchemes.has(normalized);
+  }
+  /**
+   * Get exact scheme verifier for network
+   */
+  getExactScheme(network) {
+    return this.exactSchemes.get(network);
+  }
+  /**
+   * Get deferred scheme verifier for network
+   */
+  getDeferredScheme(network) {
+    return this.deferredSchemes.get(network);
+  }
+  /**
+   * Get default network
+   */
+  getDefaultNetwork() {
+    return this.config.defaultNetwork || "base-sepolia";
+  }
+};
+function createX402Service(config) {
+  return new X402Service(config);
+}
+function createVerificationService(networks, rpcUrls) {
+  return new X402Service({
+    deferredEnabled: false,
+    rpcUrls
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeferredSchemeVerifier,
+  ExactSchemeVerifier,
+  SUPPORTED_NETWORKS,
+  X402Service,
+  createDeferredEIP712Domain,
+  createExactEIP712Domain,
+  createVerificationService,
+  createVoucherMessage,
+  createVoucherTuple,
+  createX402Service,
+  generateNonce,
+  generateVoucherId,
+  getChainIdFromNetwork,
+  parseDeferredSignature,
+  parseExactSignature
+});

package/dist/index.mjs

@@ -0,0 +1,280 @@
+// src/index.ts
+import {
+  SUPPORTED_NETWORKS,
+  getChainIdFromNetwork
+} from "@perkos/util-chains";
+import { ExactSchemeVerifier } from "@perkos/scheme-exact";
+import { DeferredSchemeVerifier } from "@perkos/scheme-deferred";
+import {
+  SUPPORTED_NETWORKS as SUPPORTED_NETWORKS2,
+  getChainIdFromNetwork as getChainIdFromNetwork2
+} from "@perkos/util-chains";
+import {
+  ExactSchemeVerifier as ExactSchemeVerifier2,
+  parseSignature,
+  createEIP712Domain,
+  generateNonce
+} from "@perkos/scheme-exact";
+import {
+  DeferredSchemeVerifier as DeferredSchemeVerifier2,
+  parseSignature as parseSignature2,
+  createEIP712Domain as createEIP712Domain2,
+  generateVoucherId,
+  createVoucherMessage,
+  createVoucherTuple
+} from "@perkos/scheme-deferred";
+var CAIP2_TO_LEGACY = {
+  // Avalanche
+  "eip155:43114": "avalanche",
+  "eip155:43113": "avalanche-fuji",
+  // Celo
+  "eip155:42220": "celo",
+  "eip155:11142220": "celo-sepolia",
+  // Base
+  "eip155:8453": "base",
+  "eip155:84532": "base-sepolia",
+  // Ethereum
+  "eip155:1": "ethereum",
+  "eip155:11155111": "sepolia",
+  // Polygon
+  "eip155:137": "polygon",
+  "eip155:80002": "polygon-amoy",
+  // Monad
+  "eip155:10142": "monad",
+  "eip155:10143": "monad-testnet",
+  // Arbitrum
+  "eip155:42161": "arbitrum",
+  "eip155:421614": "arbitrum-sepolia",
+  // Optimism
+  "eip155:10": "optimism",
+  "eip155:11155420": "optimism-sepolia"
+};
+var LEGACY_TO_CAIP2 = Object.fromEntries(
+  Object.entries(CAIP2_TO_LEGACY).map(([k, v]) => [v, k])
+);
+var X402Service = class {
+  constructor(config = {}) {
+    this.exactSchemes = /* @__PURE__ */ new Map();
+    this.deferredSchemes = /* @__PURE__ */ new Map();
+    this.config = {
+      defaultNetwork: "base-sepolia",
+      deferredEnabled: false,
+      ...config
+    };
+    for (const network of SUPPORTED_NETWORKS) {
+      const chainId = getChainIdFromNetwork(network);
+      if (chainId) {
+        this.exactSchemes.set(
+          network,
+          new ExactSchemeVerifier({
+            network,
+            rpcUrl: this.config.rpcUrls?.[network],
+            tokenName: chainId ? this.config.tokenNames?.[chainId] : void 0,
+            tokenVersion: chainId ? this.config.tokenVersions?.[chainId] : void 0
+          })
+        );
+      }
+    }
+    if (this.config.deferredEnabled && this.config.escrowAddresses) {
+      for (const [network, escrowAddress] of Object.entries(this.config.escrowAddresses)) {
+        if (escrowAddress && SUPPORTED_NETWORKS.includes(network)) {
+          try {
+            this.deferredSchemes.set(
+              network,
+              new DeferredSchemeVerifier({
+                network,
+                escrowAddress,
+                rpcUrl: this.config.rpcUrls?.[network]
+              })
+            );
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Convert CAIP-2 network format to legacy format
+   */
+  caip2ToLegacy(caip2) {
+    return CAIP2_TO_LEGACY[caip2] || null;
+  }
+  /**
+   * Convert legacy network format to CAIP-2 format
+   */
+  legacyToCaip2(network) {
+    return LEGACY_TO_CAIP2[network] || null;
+  }
+  /**
+   * Normalize network format (CAIP-2 or legacy) to legacy format
+   */
+  normalizeNetwork(network) {
+    if (SUPPORTED_NETWORKS.includes(network)) {
+      return network;
+    }
+    if (network.includes(":")) {
+      return this.caip2ToLegacy(network);
+    }
+    return null;
+  }
+  /**
+   * Verify payment payload
+   */
+  async verify(request) {
+    const { paymentPayload, paymentRequirements } = request;
+    const isV1 = request.x402Version === 1 && paymentPayload.x402Version === 1;
+    const isV2 = request.x402Version === 2 && paymentPayload.x402Version === 2;
+    if (!isV1 && !isV2) {
+      return {
+        isValid: false,
+        invalidReason: `Unsupported x402 version. Expected 1 or 2, got ${request.x402Version} (payload: ${paymentPayload.x402Version})`,
+        payer: null
+      };
+    }
+    const normalizedPayloadNetwork = this.normalizeNetwork(paymentPayload.network);
+    const normalizedRequirementsNetwork = this.normalizeNetwork(paymentRequirements.network);
+    if (!normalizedPayloadNetwork) {
+      return {
+        isValid: false,
+        invalidReason: `Unsupported network: ${paymentPayload.network}`,
+        payer: null
+      };
+    }
+    if (!normalizedRequirementsNetwork) {
+      return {
+        isValid: false,
+        invalidReason: `Unsupported network: ${paymentRequirements.network}`,
+        payer: null
+      };
+    }
+    if (normalizedPayloadNetwork !== normalizedRequirementsNetwork) {
+      return {
+        isValid: false,
+        invalidReason: `Network mismatch between payload (${paymentPayload.network}) and requirements (${paymentRequirements.network})`,
+        payer: null
+      };
+    }
+    if (paymentPayload.scheme !== paymentRequirements.scheme) {
+      return {
+        isValid: false,
+        invalidReason: "Scheme mismatch",
+        payer: null
+      };
+    }
+    const network = normalizedPayloadNetwork;
+    if (paymentPayload.scheme === "exact") {
+      const exactScheme = this.exactSchemes.get(network);
+      if (!exactScheme) {
+        return {
+          isValid: false,
+          invalidReason: `Exact scheme not initialized for network: ${network}`,
+          payer: null
+        };
+      }
+      return exactScheme.verify(
+        paymentPayload.payload,
+        paymentRequirements
+      );
+    } else if (paymentPayload.scheme === "deferred") {
+      const deferredScheme = this.deferredSchemes.get(network);
+      if (!deferredScheme) {
+        return {
+          isValid: false,
+          invalidReason: `Deferred scheme not enabled for network: ${network}`,
+          payer: null
+        };
+      }
+      return deferredScheme.verify(
+        paymentPayload.payload,
+        paymentRequirements
+      );
+    } else {
+      return {
+        isValid: false,
+        invalidReason: `Unsupported scheme: ${paymentPayload.scheme}`,
+        payer: null
+      };
+    }
+  }
+  /**
+   * Verify payment without full request wrapper
+   */
+  async verifyPayload(payload, requirements) {
+    return this.verify({
+      x402Version: payload.x402Version,
+      paymentPayload: payload,
+      paymentRequirements: requirements
+    });
+  }
+  /**
+   * Get supported schemes and networks
+   */
+  getSupported() {
+    const kinds = [];
+    for (const network of this.exactSchemes.keys()) {
+      kinds.push({ scheme: "exact", network });
+    }
+    for (const network of this.deferredSchemes.keys()) {
+      kinds.push({ scheme: "deferred", network });
+    }
+    return { kinds };
+  }
+  /**
+   * Check if a network is supported
+   */
+  isNetworkSupported(network) {
+    const normalized = this.normalizeNetwork(network);
+    return normalized !== null && this.exactSchemes.has(normalized);
+  }
+  /**
+   * Check if deferred scheme is enabled for a network
+   */
+  isDeferredEnabled(network) {
+    const normalized = this.normalizeNetwork(network);
+    return normalized !== null && this.deferredSchemes.has(normalized);
+  }
+  /**
+   * Get exact scheme verifier for network
+   */
+  getExactScheme(network) {
+    return this.exactSchemes.get(network);
+  }
+  /**
+   * Get deferred scheme verifier for network
+   */
+  getDeferredScheme(network) {
+    return this.deferredSchemes.get(network);
+  }
+  /**
+   * Get default network
+   */
+  getDefaultNetwork() {
+    return this.config.defaultNetwork || "base-sepolia";
+  }
+};
+function createX402Service(config) {
+  return new X402Service(config);
+}
+function createVerificationService(networks, rpcUrls) {
+  return new X402Service({
+    deferredEnabled: false,
+    rpcUrls
+  });
+}
+export {
+  DeferredSchemeVerifier2 as DeferredSchemeVerifier,
+  ExactSchemeVerifier2 as ExactSchemeVerifier,
+  SUPPORTED_NETWORKS2 as SUPPORTED_NETWORKS,
+  X402Service,
+  createEIP712Domain2 as createDeferredEIP712Domain,
+  createEIP712Domain as createExactEIP712Domain,
+  createVerificationService,
+  createVoucherMessage,
+  createVoucherTuple,
+  createX402Service,
+  generateNonce,
+  generateVoucherId,
+  getChainIdFromNetwork2 as getChainIdFromNetwork,
+  parseSignature2 as parseDeferredSignature,
+  parseSignature as parseExactSignature
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@perkos/service-x402",
+  "version": "1.0.0",
+  "description": "Unified x402 payment protocol verification and settlement service",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "x402",
+    "payment",
+    "protocol",
+    "verification",
+    "settlement",
+    "ethereum",
+    "web3",
+    "crypto"
+  ],
+  "author": "PerkOS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PerkOS-xyz/pkg-service-x402"
+  },
+  "dependencies": {
+    "@perkos/types-x402": "^1.0.0",
+    "@perkos/util-chains": "^1.0.0",
+    "@perkos/scheme-exact": "^1.0.0",
+    "@perkos/scheme-deferred": "^1.0.0",
+    "viem": "^2.28.2"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  }
+}