@perkos/service-pricing 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,317 @@
+import { Address } from '@perkos/types-x402';
+
+/**
+ * @perkos/service-pricing
+ * Dynamic pricing service with strategy patterns for x402 payment protocol
+ *
+ * Provides vendor-centric pricing with multiple strategy types:
+ * - Fixed: Static price per request
+ * - Tiered: Volume-based pricing tiers
+ * - Usage-based: Pay per unit (token, byte, time)
+ * - Time-bucket: Peak/off-peak pricing
+ * - Subscription: Recurring plans with credits
+ */
+
+type PricingStrategyType = "fixed" | "tiered" | "usage-based" | "time-bucket" | "auction" | "subscription" | "custom";
+type PricingUnit = "per-request" | "per-token" | "per-byte" | "per-second" | "per-minute" | "per-hour" | "per-day" | "per-month";
+type UserTier = "free" | "basic" | "premium" | "enterprise";
+interface PricingContext {
+    request: RequestContext;
+    user?: UserContext;
+    vendor: VendorContext;
+    endpoint: EndpointContext;
+    environment?: EnvironmentContext;
+    timestamp: number;
+}
+interface RequestContext {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    body?: unknown;
+    contentLength?: number;
+    clientIp?: string;
+}
+interface UserContext {
+    address: Address;
+    tier?: UserTier;
+    usage?: UsageHistory;
+    reputation?: number;
+    subscription?: SubscriptionStatus;
+}
+interface UsageHistory {
+    requestCount: number;
+    totalVolume: string;
+    periodStart: number;
+    periodEnd: number;
+}
+interface SubscriptionStatus {
+    active: boolean;
+    planId: string;
+    tierName: string;
+    remainingCredits?: number;
+    expiresAt?: number;
+}
+interface VendorContext {
+    id: string;
+    name: string;
+    walletAddress: Address;
+    network: string;
+    chainId: number | null;
+    asset: string;
+    basePriceUsd: string | null;
+    pricingConfig: VendorPricingConfig | null;
+}
+interface EndpointContext {
+    id: string;
+    path: string;
+    method: string;
+    priceUsd: string;
+    pricingConfig?: EndpointPricingConfig | null;
+}
+interface EnvironmentContext {
+    networkLoad?: number;
+    timeBucket?: "peak" | "off-peak" | "normal";
+    gasPrice?: string;
+    marketRate?: number;
+}
+interface PriceResult {
+    amount: string;
+    asset: Address;
+    network: string;
+    breakdown?: PriceBreakdown[];
+    validUntil?: number;
+    minAmount?: string;
+    display?: PriceDisplay;
+    cacheKey?: string;
+}
+interface PriceBreakdown {
+    component: string;
+    amount: string;
+    description?: string;
+    percentage?: number;
+}
+interface PriceDisplay {
+    formatted: string;
+    symbol: string;
+    decimals: number;
+}
+interface VendorPricingConfig {
+    id: string;
+    vendorId: string;
+    strategyType: PricingStrategyType;
+    name: string;
+    isDefault: boolean;
+    parameters: StrategyParameters;
+    cache?: CacheConfig;
+    routePatterns?: string[];
+    priority: number;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface EndpointPricingConfig {
+    strategyType?: PricingStrategyType;
+    parameters?: Partial<StrategyParameters>;
+    cache?: Partial<CacheConfig>;
+}
+interface CacheConfig {
+    enabled: boolean;
+    ttlSeconds: number;
+    customKeyTemplate?: string;
+}
+type StrategyParameters = FixedPricingParams | TieredPricingParams | UsageBasedPricingParams | TimeBucketPricingParams | AuctionPricingParams | SubscriptionPricingParams | CustomPricingParams;
+interface FixedPricingParams {
+    type: "fixed";
+    price: string;
+    asset: Address;
+    network: string;
+}
+interface TieredPricingParams {
+    type: "tiered";
+    tiers: PricingTier[];
+    asset: Address;
+    network: string;
+    resetPeriod: number;
+}
+interface PricingTier {
+    name: string;
+    upTo: number;
+    pricePerRequest: string;
+    discount?: number;
+}
+interface UsageBasedPricingParams {
+    type: "usage-based";
+    pricePerUnit: string;
+    unit: PricingUnit;
+    minimumCharge?: string;
+    maximumCharge?: string;
+    asset: Address;
+    network: string;
+    unitExtractor?: string;
+}
+interface TimeBucketPricingParams {
+    type: "time-bucket";
+    basePrice: string;
+    peakMultiplier: number;
+    offPeakMultiplier: number;
+    peakHours: Array<{
+        start: number;
+        end: number;
+    }>;
+    timezone: string;
+    asset: Address;
+    network: string;
+}
+interface AuctionPricingParams {
+    type: "auction";
+    floorPrice: string;
+    ceilingPrice: string;
+    adjustmentRate: number;
+    demandFactor?: number;
+    asset: Address;
+    network: string;
+}
+interface SubscriptionPricingParams {
+    type: "subscription";
+    plans: SubscriptionPlan[];
+    overagePrice?: string;
+    asset: Address;
+    network: string;
+}
+interface SubscriptionPlan {
+    id: string;
+    name: string;
+    monthlyPrice: string;
+    includedRequests: number;
+    features: string[];
+}
+interface CustomPricingParams {
+    type: "custom";
+    calculatorEndpoint?: string;
+    customParams: Record<string, unknown>;
+    asset: Address;
+    network: string;
+}
+interface PricingStrategy {
+    readonly name: string;
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+    generateCacheKey(context: PricingContext): string;
+    validate(): ValidationResult;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors?: string[];
+}
+interface PricingServiceConfig {
+    cache: CacheConfig;
+    enableLogging: boolean;
+    fallbackPrice?: string;
+    fallbackAsset?: Address;
+    fallbackNetwork?: string;
+    usdcDecimals: number;
+}
+declare const ASSET_SYMBOLS: Record<string, string>;
+/**
+ * Convert USD string to atomic units (USDC decimals = 6)
+ */
+declare function usdToAtomicUnits(usdAmount: string, decimals?: number): string;
+/**
+ * Convert atomic units to USD string
+ */
+declare function atomicUnitsToUsd(atomicUnits: string, decimals?: number): string;
+/**
+ * Format price for display
+ */
+declare function formatPrice(amount: bigint, asset: Address, decimals?: number): PriceDisplay;
+/**
+ * Apply percentage discount to amount
+ */
+declare function applyDiscount(amount: bigint, discountPercent: number): bigint;
+/**
+ * Apply multiplier to amount
+ */
+declare function applyMultiplier(amount: bigint, multiplier: number): bigint;
+/**
+ * Generate deterministic cache key
+ */
+declare function generateCacheKey(strategyType: string, configId: string, context: PricingContext): string;
+/**
+ * Sort object keys deterministically
+ */
+declare function sortObject(obj: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Get current time bucket based on timezone
+ */
+declare function getTimeBucket(timezone: string, peakHours: Array<{
+    start: number;
+    end: number;
+}>): "peak" | "off-peak" | "normal";
+/**
+ * Determine tier for request count
+ */
+declare function determineTier(requestCount: number, tiers: PricingTier[]): PricingTier | undefined;
+/**
+ * Calculate usage-based units from request
+ */
+declare function calculateUsageUnits(context: PricingContext, unit: PricingUnit): number;
+/**
+ * Build price result structure
+ */
+declare function buildPriceResult(amount: bigint, asset: Address, network: string, ttlSeconds?: number, breakdown?: PriceBreakdown[]): PriceResult;
+/**
+ * Abstract base class for pricing strategies
+ */
+declare abstract class BasePricingStrategy implements PricingStrategy {
+    abstract readonly name: string;
+    abstract readonly type: PricingStrategyType;
+    protected config: VendorPricingConfig;
+    protected decimals: number;
+    constructor(config: VendorPricingConfig, decimals?: number);
+    abstract calculatePrice(context: PricingContext): Promise<PriceResult>;
+    generateCacheKey(context: PricingContext): string;
+    validate(): ValidationResult;
+    protected getParams<T extends StrategyParameters>(): T;
+    protected getCacheTtl(): number;
+}
+/**
+ * Fixed pricing strategy - static price per request
+ */
+declare class FixedPricingStrategy extends BasePricingStrategy {
+    readonly name = "Fixed Pricing";
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+    validate(): ValidationResult;
+}
+/**
+ * Tiered pricing strategy - volume-based discounts
+ */
+declare class TieredPricingStrategy extends BasePricingStrategy {
+    readonly name = "Tiered Pricing";
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+    validate(): ValidationResult;
+}
+/**
+ * Usage-based pricing strategy - pay per unit
+ */
+declare class UsageBasedPricingStrategy extends BasePricingStrategy {
+    readonly name = "Usage-Based Pricing";
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+}
+/**
+ * Time-bucket pricing strategy - peak/off-peak pricing
+ */
+declare class TimeBucketPricingStrategy extends BasePricingStrategy {
+    readonly name = "Time-Bucket Pricing";
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+}
+/**
+ * Create a pricing strategy instance from configuration
+ */
+declare function createPricingStrategy(config: VendorPricingConfig, decimals?: number): PricingStrategy;
+
+export { ASSET_SYMBOLS, type AuctionPricingParams, BasePricingStrategy, type CacheConfig, type CustomPricingParams, type EndpointContext, type EndpointPricingConfig, type EnvironmentContext, type FixedPricingParams, FixedPricingStrategy, type PriceBreakdown, type PriceDisplay, type PriceResult, type PricingContext, type PricingServiceConfig, type PricingStrategy, type PricingStrategyType, type PricingTier, type PricingUnit, type RequestContext, type StrategyParameters, type SubscriptionPlan, type SubscriptionPricingParams, type SubscriptionStatus, type TieredPricingParams, TieredPricingStrategy, type TimeBucketPricingParams, TimeBucketPricingStrategy, type UsageBasedPricingParams, UsageBasedPricingStrategy, type UsageHistory, type UserContext, type UserTier, type ValidationResult, type VendorContext, type VendorPricingConfig, applyDiscount, applyMultiplier, atomicUnitsToUsd, buildPriceResult, calculateUsageUnits, createPricingStrategy, determineTier, formatPrice, generateCacheKey, getTimeBucket, sortObject, usdToAtomicUnits };

package/dist/index.d.ts

@@ -0,0 +1,317 @@
+import { Address } from '@perkos/types-x402';
+
+/**
+ * @perkos/service-pricing
+ * Dynamic pricing service with strategy patterns for x402 payment protocol
+ *
+ * Provides vendor-centric pricing with multiple strategy types:
+ * - Fixed: Static price per request
+ * - Tiered: Volume-based pricing tiers
+ * - Usage-based: Pay per unit (token, byte, time)
+ * - Time-bucket: Peak/off-peak pricing
+ * - Subscription: Recurring plans with credits
+ */
+
+type PricingStrategyType = "fixed" | "tiered" | "usage-based" | "time-bucket" | "auction" | "subscription" | "custom";
+type PricingUnit = "per-request" | "per-token" | "per-byte" | "per-second" | "per-minute" | "per-hour" | "per-day" | "per-month";
+type UserTier = "free" | "basic" | "premium" | "enterprise";
+interface PricingContext {
+    request: RequestContext;
+    user?: UserContext;
+    vendor: VendorContext;
+    endpoint: EndpointContext;
+    environment?: EnvironmentContext;
+    timestamp: number;
+}
+interface RequestContext {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    body?: unknown;
+    contentLength?: number;
+    clientIp?: string;
+}
+interface UserContext {
+    address: Address;
+    tier?: UserTier;
+    usage?: UsageHistory;
+    reputation?: number;
+    subscription?: SubscriptionStatus;
+}
+interface UsageHistory {
+    requestCount: number;
+    totalVolume: string;
+    periodStart: number;
+    periodEnd: number;
+}
+interface SubscriptionStatus {
+    active: boolean;
+    planId: string;
+    tierName: string;
+    remainingCredits?: number;
+    expiresAt?: number;
+}
+interface VendorContext {
+    id: string;
+    name: string;
+    walletAddress: Address;
+    network: string;
+    chainId: number | null;
+    asset: string;
+    basePriceUsd: string | null;
+    pricingConfig: VendorPricingConfig | null;
+}
+interface EndpointContext {
+    id: string;
+    path: string;
+    method: string;
+    priceUsd: string;
+    pricingConfig?: EndpointPricingConfig | null;
+}
+interface EnvironmentContext {
+    networkLoad?: number;
+    timeBucket?: "peak" | "off-peak" | "normal";
+    gasPrice?: string;
+    marketRate?: number;
+}
+interface PriceResult {
+    amount: string;
+    asset: Address;
+    network: string;
+    breakdown?: PriceBreakdown[];
+    validUntil?: number;
+    minAmount?: string;
+    display?: PriceDisplay;
+    cacheKey?: string;
+}
+interface PriceBreakdown {
+    component: string;
+    amount: string;
+    description?: string;
+    percentage?: number;
+}
+interface PriceDisplay {
+    formatted: string;
+    symbol: string;
+    decimals: number;
+}
+interface VendorPricingConfig {
+    id: string;
+    vendorId: string;
+    strategyType: PricingStrategyType;
+    name: string;
+    isDefault: boolean;
+    parameters: StrategyParameters;
+    cache?: CacheConfig;
+    routePatterns?: string[];
+    priority: number;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface EndpointPricingConfig {
+    strategyType?: PricingStrategyType;
+    parameters?: Partial<StrategyParameters>;
+    cache?: Partial<CacheConfig>;
+}
+interface CacheConfig {
+    enabled: boolean;
+    ttlSeconds: number;
+    customKeyTemplate?: string;
+}
+type StrategyParameters = FixedPricingParams | TieredPricingParams | UsageBasedPricingParams | TimeBucketPricingParams | AuctionPricingParams | SubscriptionPricingParams | CustomPricingParams;
+interface FixedPricingParams {
+    type: "fixed";
+    price: string;
+    asset: Address;
+    network: string;
+}
+interface TieredPricingParams {
+    type: "tiered";
+    tiers: PricingTier[];
+    asset: Address;
+    network: string;
+    resetPeriod: number;
+}
+interface PricingTier {
+    name: string;
+    upTo: number;
+    pricePerRequest: string;
+    discount?: number;
+}
+interface UsageBasedPricingParams {
+    type: "usage-based";
+    pricePerUnit: string;
+    unit: PricingUnit;
+    minimumCharge?: string;
+    maximumCharge?: string;
+    asset: Address;
+    network: string;
+    unitExtractor?: string;
+}
+interface TimeBucketPricingParams {
+    type: "time-bucket";
+    basePrice: string;
+    peakMultiplier: number;
+    offPeakMultiplier: number;
+    peakHours: Array<{
+        start: number;
+        end: number;
+    }>;
+    timezone: string;
+    asset: Address;
+    network: string;
+}
+interface AuctionPricingParams {
+    type: "auction";
+    floorPrice: string;
+    ceilingPrice: string;
+    adjustmentRate: number;
+    demandFactor?: number;
+    asset: Address;
+    network: string;
+}
+interface SubscriptionPricingParams {
+    type: "subscription";
+    plans: SubscriptionPlan[];
+    overagePrice?: string;
+    asset: Address;
+    network: string;
+}
+interface SubscriptionPlan {
+    id: string;
+    name: string;
+    monthlyPrice: string;
+    includedRequests: number;
+    features: string[];
+}
+interface CustomPricingParams {
+    type: "custom";
+    calculatorEndpoint?: string;
+    customParams: Record<string, unknown>;
+    asset: Address;
+    network: string;
+}
+interface PricingStrategy {
+    readonly name: string;
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+    generateCacheKey(context: PricingContext): string;
+    validate(): ValidationResult;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors?: string[];
+}
+interface PricingServiceConfig {
+    cache: CacheConfig;
+    enableLogging: boolean;
+    fallbackPrice?: string;
+    fallbackAsset?: Address;
+    fallbackNetwork?: string;
+    usdcDecimals: number;
+}
+declare const ASSET_SYMBOLS: Record<string, string>;
+/**
+ * Convert USD string to atomic units (USDC decimals = 6)
+ */
+declare function usdToAtomicUnits(usdAmount: string, decimals?: number): string;
+/**
+ * Convert atomic units to USD string
+ */
+declare function atomicUnitsToUsd(atomicUnits: string, decimals?: number): string;
+/**
+ * Format price for display
+ */
+declare function formatPrice(amount: bigint, asset: Address, decimals?: number): PriceDisplay;
+/**
+ * Apply percentage discount to amount
+ */
+declare function applyDiscount(amount: bigint, discountPercent: number): bigint;
+/**
+ * Apply multiplier to amount
+ */
+declare function applyMultiplier(amount: bigint, multiplier: number): bigint;
+/**
+ * Generate deterministic cache key
+ */
+declare function generateCacheKey(strategyType: string, configId: string, context: PricingContext): string;
+/**
+ * Sort object keys deterministically
+ */
+declare function sortObject(obj: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Get current time bucket based on timezone
+ */
+declare function getTimeBucket(timezone: string, peakHours: Array<{
+    start: number;
+    end: number;
+}>): "peak" | "off-peak" | "normal";
+/**
+ * Determine tier for request count
+ */
+declare function determineTier(requestCount: number, tiers: PricingTier[]): PricingTier | undefined;
+/**
+ * Calculate usage-based units from request
+ */
+declare function calculateUsageUnits(context: PricingContext, unit: PricingUnit): number;
+/**
+ * Build price result structure
+ */
+declare function buildPriceResult(amount: bigint, asset: Address, network: string, ttlSeconds?: number, breakdown?: PriceBreakdown[]): PriceResult;
+/**
+ * Abstract base class for pricing strategies
+ */
+declare abstract class BasePricingStrategy implements PricingStrategy {
+    abstract readonly name: string;
+    abstract readonly type: PricingStrategyType;
+    protected config: VendorPricingConfig;
+    protected decimals: number;
+    constructor(config: VendorPricingConfig, decimals?: number);
+    abstract calculatePrice(context: PricingContext): Promise<PriceResult>;
+    generateCacheKey(context: PricingContext): string;
+    validate(): ValidationResult;
+    protected getParams<T extends StrategyParameters>(): T;
+    protected getCacheTtl(): number;
+}
+/**
+ * Fixed pricing strategy - static price per request
+ */
+declare class FixedPricingStrategy extends BasePricingStrategy {
+    readonly name = "Fixed Pricing";
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+    validate(): ValidationResult;
+}
+/**
+ * Tiered pricing strategy - volume-based discounts
+ */
+declare class TieredPricingStrategy extends BasePricingStrategy {
+    readonly name = "Tiered Pricing";
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+    validate(): ValidationResult;
+}
+/**
+ * Usage-based pricing strategy - pay per unit
+ */
+declare class UsageBasedPricingStrategy extends BasePricingStrategy {
+    readonly name = "Usage-Based Pricing";
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+}
+/**
+ * Time-bucket pricing strategy - peak/off-peak pricing
+ */
+declare class TimeBucketPricingStrategy extends BasePricingStrategy {
+    readonly name = "Time-Bucket Pricing";
+    readonly type: PricingStrategyType;
+    calculatePrice(context: PricingContext): Promise<PriceResult>;
+}
+/**
+ * Create a pricing strategy instance from configuration
+ */
+declare function createPricingStrategy(config: VendorPricingConfig, decimals?: number): PricingStrategy;
+
+export { ASSET_SYMBOLS, type AuctionPricingParams, BasePricingStrategy, type CacheConfig, type CustomPricingParams, type EndpointContext, type EndpointPricingConfig, type EnvironmentContext, type FixedPricingParams, FixedPricingStrategy, type PriceBreakdown, type PriceDisplay, type PriceResult, type PricingContext, type PricingServiceConfig, type PricingStrategy, type PricingStrategyType, type PricingTier, type PricingUnit, type RequestContext, type StrategyParameters, type SubscriptionPlan, type SubscriptionPricingParams, type SubscriptionStatus, type TieredPricingParams, TieredPricingStrategy, type TimeBucketPricingParams, TimeBucketPricingStrategy, type UsageBasedPricingParams, UsageBasedPricingStrategy, type UsageHistory, type UserContext, type UserTier, type ValidationResult, type VendorContext, type VendorPricingConfig, applyDiscount, applyMultiplier, atomicUnitsToUsd, buildPriceResult, calculateUsageUnits, createPricingStrategy, determineTier, formatPrice, generateCacheKey, getTimeBucket, sortObject, usdToAtomicUnits };

package/dist/index.js

@@ -0,0 +1,387 @@
+"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, {
+  ASSET_SYMBOLS: () => ASSET_SYMBOLS,
+  BasePricingStrategy: () => BasePricingStrategy,
+  FixedPricingStrategy: () => FixedPricingStrategy,
+  TieredPricingStrategy: () => TieredPricingStrategy,
+  TimeBucketPricingStrategy: () => TimeBucketPricingStrategy,
+  UsageBasedPricingStrategy: () => UsageBasedPricingStrategy,
+  applyDiscount: () => applyDiscount,
+  applyMultiplier: () => applyMultiplier,
+  atomicUnitsToUsd: () => atomicUnitsToUsd,
+  buildPriceResult: () => buildPriceResult,
+  calculateUsageUnits: () => calculateUsageUnits,
+  createPricingStrategy: () => createPricingStrategy,
+  determineTier: () => determineTier,
+  formatPrice: () => formatPrice,
+  generateCacheKey: () => generateCacheKey,
+  getTimeBucket: () => getTimeBucket,
+  sortObject: () => sortObject,
+  usdToAtomicUnits: () => usdToAtomicUnits
+});
+module.exports = __toCommonJS(index_exports);
+var ASSET_SYMBOLS = {
+  // USDC addresses across networks
+  "0x036CbD53842c5426634e7929541eC2318f3dCF7e": "USDC",
+  // Base Sepolia
+  "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": "USDC",
+  // Base Mainnet
+  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "USDC",
+  // Ethereum Mainnet
+  "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359": "USDC",
+  // Polygon
+  "0xaf88d065e77c8cC2239327C5EDb3A432268e5831": "USDC",
+  // Arbitrum
+  "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85": "USDC",
+  // Optimism
+  "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E": "USDC"
+  // Avalanche
+};
+function usdToAtomicUnits(usdAmount, decimals = 6) {
+  const parts = usdAmount.split(".");
+  const integerPart = parts[0] || "0";
+  const fractionalPart = (parts[1] || "").padEnd(decimals, "0").slice(0, decimals);
+  const atomicUnits = BigInt(integerPart + fractionalPart);
+  return atomicUnits.toString();
+}
+function atomicUnitsToUsd(atomicUnits, decimals = 6) {
+  const amount = BigInt(atomicUnits);
+  const divisor = BigInt(10 ** decimals);
+  const integerPart = amount / divisor;
+  const fractionalPart = amount % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  return `${integerPart}.${fractionalStr}`;
+}
+function formatPrice(amount, asset, decimals = 6) {
+  const divisor = BigInt(10 ** decimals);
+  const integerPart = amount / divisor;
+  const fractionalPart = amount % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  const formatted = `${integerPart}.${fractionalStr}`;
+  const symbol = ASSET_SYMBOLS[asset] || ASSET_SYMBOLS[asset.toLowerCase()] || "USDC";
+  return {
+    formatted,
+    symbol,
+    decimals
+  };
+}
+function applyDiscount(amount, discountPercent) {
+  if (discountPercent <= 0 || discountPercent > 100) return amount;
+  const multiplier = BigInt(Math.floor((100 - discountPercent) * 100));
+  return amount * multiplier / 10000n;
+}
+function applyMultiplier(amount, multiplier) {
+  const multiplierInt = BigInt(Math.floor(multiplier * 1e4));
+  return amount * multiplierInt / 10000n;
+}
+function generateCacheKey(strategyType, configId, context) {
+  const keyComponents = {
+    strategy: strategyType,
+    configId,
+    method: context.request.method,
+    path: context.request.path,
+    query: sortObject(context.request.query),
+    bodyHash: context.request.body ? hashObject(context.request.body) : null,
+    vendorId: context.vendor.id,
+    endpointId: context.endpoint.id,
+    user: context.user?.address || "anonymous"
+  };
+  const keyString = JSON.stringify(keyComponents);
+  return simpleHash(keyString);
+}
+function sortObject(obj) {
+  if (!obj || typeof obj !== "object") return {};
+  return Object.keys(obj).sort().reduce((acc, key) => {
+    acc[key] = obj[key];
+    return acc;
+  }, {});
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+function hashObject(obj) {
+  return simpleHash(JSON.stringify(obj));
+}
+function getTimeBucket(timezone, peakHours) {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      hour: "numeric",
+      hour12: false,
+      timeZone: timezone
+    });
+    const hour = parseInt(formatter.format(now), 10);
+    for (const peak of peakHours) {
+      if (hour >= peak.start && hour < peak.end) {
+        return "peak";
+      }
+    }
+    if (hour >= 22 || hour < 6) {
+      return "off-peak";
+    }
+    return "normal";
+  } catch {
+    return "normal";
+  }
+}
+function determineTier(requestCount, tiers) {
+  const sortedTiers = [...tiers].sort((a, b) => a.upTo - b.upTo);
+  for (const tier of sortedTiers) {
+    if (tier.upTo === -1 || requestCount <= tier.upTo) {
+      return tier;
+    }
+  }
+  return sortedTiers[sortedTiers.length - 1];
+}
+function calculateUsageUnits(context, unit) {
+  switch (unit) {
+    case "per-request":
+      return 1;
+    case "per-byte":
+      return context.request.contentLength || 0;
+    case "per-token":
+      return Math.ceil((context.request.contentLength || 0) / 4);
+    default:
+      return 1;
+  }
+}
+function buildPriceResult(amount, asset, network, ttlSeconds = 300, breakdown) {
+  return {
+    amount: amount.toString(),
+    asset,
+    network,
+    breakdown,
+    validUntil: Math.floor(Date.now() / 1e3) + ttlSeconds,
+    display: formatPrice(amount, asset)
+  };
+}
+var BasePricingStrategy = class {
+  constructor(config, decimals = 6) {
+    this.config = config;
+    this.decimals = decimals;
+  }
+  generateCacheKey(context) {
+    return generateCacheKey(this.type, this.config.id, context);
+  }
+  validate() {
+    const errors = [];
+    if (!this.config.parameters) {
+      errors.push("Strategy parameters are required");
+    }
+    if (!this.config.vendorId) {
+      errors.push("Vendor ID is required");
+    }
+    return {
+      valid: errors.length === 0,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+  getParams() {
+    return this.config.parameters;
+  }
+  getCacheTtl() {
+    return this.config.cache?.ttlSeconds ?? 300;
+  }
+};
+var FixedPricingStrategy = class extends BasePricingStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "Fixed Pricing";
+    this.type = "fixed";
+  }
+  async calculatePrice(context) {
+    const params = this.getParams();
+    const amount = BigInt(params.price);
+    return buildPriceResult(
+      amount,
+      params.asset,
+      params.network,
+      this.getCacheTtl(),
+      [{ component: "Base Price", amount: params.price }]
+    );
+  }
+  validate() {
+    const base = super.validate();
+    if (!base.valid) return base;
+    const errors = [];
+    const params = this.getParams();
+    if (!params.price || BigInt(params.price) <= 0n) {
+      errors.push("Fixed price must be positive");
+    }
+    if (!params.asset) {
+      errors.push("Asset address is required");
+    }
+    return {
+      valid: errors.length === 0,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+};
+var TieredPricingStrategy = class extends BasePricingStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "Tiered Pricing";
+    this.type = "tiered";
+  }
+  async calculatePrice(context) {
+    const params = this.getParams();
+    const requestCount = context.user?.usage?.requestCount || 0;
+    const tier = determineTier(requestCount, params.tiers);
+    if (!tier) {
+      throw new Error("No applicable pricing tier found");
+    }
+    let amount = BigInt(tier.pricePerRequest);
+    if (tier.discount && tier.discount > 0) {
+      amount = applyDiscount(amount, tier.discount);
+    }
+    return buildPriceResult(
+      amount,
+      params.asset,
+      params.network,
+      this.getCacheTtl(),
+      [
+        { component: "Base Price", amount: tier.pricePerRequest },
+        ...tier.discount ? [{ component: "Tier Discount", amount: `-${tier.discount}%`, percentage: tier.discount }] : []
+      ]
+    );
+  }
+  validate() {
+    const base = super.validate();
+    if (!base.valid) return base;
+    const errors = [];
+    const params = this.getParams();
+    if (!params.tiers || params.tiers.length === 0) {
+      errors.push("At least one pricing tier is required");
+    }
+    return {
+      valid: errors.length === 0,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+};
+var UsageBasedPricingStrategy = class extends BasePricingStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "Usage-Based Pricing";
+    this.type = "usage-based";
+  }
+  async calculatePrice(context) {
+    const params = this.getParams();
+    const units = calculateUsageUnits(context, params.unit);
+    let amount = BigInt(params.pricePerUnit) * BigInt(units);
+    if (params.minimumCharge) {
+      const min = BigInt(params.minimumCharge);
+      if (amount < min) {
+        amount = min;
+      }
+    }
+    if (params.maximumCharge) {
+      const max = BigInt(params.maximumCharge);
+      if (amount > max) {
+        amount = max;
+      }
+    }
+    return buildPriceResult(
+      amount,
+      params.asset,
+      params.network,
+      this.getCacheTtl(),
+      [
+        { component: `${units} ${params.unit}`, amount: amount.toString() }
+      ]
+    );
+  }
+};
+var TimeBucketPricingStrategy = class extends BasePricingStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "Time-Bucket Pricing";
+    this.type = "time-bucket";
+  }
+  async calculatePrice(context) {
+    const params = this.getParams();
+    const bucket = getTimeBucket(params.timezone, params.peakHours);
+    let amount = BigInt(params.basePrice);
+    let multiplier = 1;
+    switch (bucket) {
+      case "peak":
+        multiplier = params.peakMultiplier;
+        break;
+      case "off-peak":
+        multiplier = params.offPeakMultiplier;
+        break;
+    }
+    amount = applyMultiplier(amount, multiplier);
+    return buildPriceResult(
+      amount,
+      params.asset,
+      params.network,
+      this.getCacheTtl(),
+      [
+        { component: "Base Price", amount: params.basePrice },
+        { component: `${bucket} multiplier`, amount: `x${multiplier}` }
+      ]
+    );
+  }
+};
+function createPricingStrategy(config, decimals = 6) {
+  switch (config.strategyType) {
+    case "fixed":
+      return new FixedPricingStrategy(config, decimals);
+    case "tiered":
+      return new TieredPricingStrategy(config, decimals);
+    case "usage-based":
+      return new UsageBasedPricingStrategy(config, decimals);
+    case "time-bucket":
+      return new TimeBucketPricingStrategy(config, decimals);
+    default:
+      throw new Error(`Unsupported strategy type: ${config.strategyType}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASSET_SYMBOLS,
+  BasePricingStrategy,
+  FixedPricingStrategy,
+  TieredPricingStrategy,
+  TimeBucketPricingStrategy,
+  UsageBasedPricingStrategy,
+  applyDiscount,
+  applyMultiplier,
+  atomicUnitsToUsd,
+  buildPriceResult,
+  calculateUsageUnits,
+  createPricingStrategy,
+  determineTier,
+  formatPrice,
+  generateCacheKey,
+  getTimeBucket,
+  sortObject,
+  usdToAtomicUnits
+});

package/dist/index.mjs

@@ -0,0 +1,345 @@
+// src/index.ts
+var ASSET_SYMBOLS = {
+  // USDC addresses across networks
+  "0x036CbD53842c5426634e7929541eC2318f3dCF7e": "USDC",
+  // Base Sepolia
+  "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": "USDC",
+  // Base Mainnet
+  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "USDC",
+  // Ethereum Mainnet
+  "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359": "USDC",
+  // Polygon
+  "0xaf88d065e77c8cC2239327C5EDb3A432268e5831": "USDC",
+  // Arbitrum
+  "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85": "USDC",
+  // Optimism
+  "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E": "USDC"
+  // Avalanche
+};
+function usdToAtomicUnits(usdAmount, decimals = 6) {
+  const parts = usdAmount.split(".");
+  const integerPart = parts[0] || "0";
+  const fractionalPart = (parts[1] || "").padEnd(decimals, "0").slice(0, decimals);
+  const atomicUnits = BigInt(integerPart + fractionalPart);
+  return atomicUnits.toString();
+}
+function atomicUnitsToUsd(atomicUnits, decimals = 6) {
+  const amount = BigInt(atomicUnits);
+  const divisor = BigInt(10 ** decimals);
+  const integerPart = amount / divisor;
+  const fractionalPart = amount % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  return `${integerPart}.${fractionalStr}`;
+}
+function formatPrice(amount, asset, decimals = 6) {
+  const divisor = BigInt(10 ** decimals);
+  const integerPart = amount / divisor;
+  const fractionalPart = amount % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  const formatted = `${integerPart}.${fractionalStr}`;
+  const symbol = ASSET_SYMBOLS[asset] || ASSET_SYMBOLS[asset.toLowerCase()] || "USDC";
+  return {
+    formatted,
+    symbol,
+    decimals
+  };
+}
+function applyDiscount(amount, discountPercent) {
+  if (discountPercent <= 0 || discountPercent > 100) return amount;
+  const multiplier = BigInt(Math.floor((100 - discountPercent) * 100));
+  return amount * multiplier / 10000n;
+}
+function applyMultiplier(amount, multiplier) {
+  const multiplierInt = BigInt(Math.floor(multiplier * 1e4));
+  return amount * multiplierInt / 10000n;
+}
+function generateCacheKey(strategyType, configId, context) {
+  const keyComponents = {
+    strategy: strategyType,
+    configId,
+    method: context.request.method,
+    path: context.request.path,
+    query: sortObject(context.request.query),
+    bodyHash: context.request.body ? hashObject(context.request.body) : null,
+    vendorId: context.vendor.id,
+    endpointId: context.endpoint.id,
+    user: context.user?.address || "anonymous"
+  };
+  const keyString = JSON.stringify(keyComponents);
+  return simpleHash(keyString);
+}
+function sortObject(obj) {
+  if (!obj || typeof obj !== "object") return {};
+  return Object.keys(obj).sort().reduce((acc, key) => {
+    acc[key] = obj[key];
+    return acc;
+  }, {});
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+function hashObject(obj) {
+  return simpleHash(JSON.stringify(obj));
+}
+function getTimeBucket(timezone, peakHours) {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      hour: "numeric",
+      hour12: false,
+      timeZone: timezone
+    });
+    const hour = parseInt(formatter.format(now), 10);
+    for (const peak of peakHours) {
+      if (hour >= peak.start && hour < peak.end) {
+        return "peak";
+      }
+    }
+    if (hour >= 22 || hour < 6) {
+      return "off-peak";
+    }
+    return "normal";
+  } catch {
+    return "normal";
+  }
+}
+function determineTier(requestCount, tiers) {
+  const sortedTiers = [...tiers].sort((a, b) => a.upTo - b.upTo);
+  for (const tier of sortedTiers) {
+    if (tier.upTo === -1 || requestCount <= tier.upTo) {
+      return tier;
+    }
+  }
+  return sortedTiers[sortedTiers.length - 1];
+}
+function calculateUsageUnits(context, unit) {
+  switch (unit) {
+    case "per-request":
+      return 1;
+    case "per-byte":
+      return context.request.contentLength || 0;
+    case "per-token":
+      return Math.ceil((context.request.contentLength || 0) / 4);
+    default:
+      return 1;
+  }
+}
+function buildPriceResult(amount, asset, network, ttlSeconds = 300, breakdown) {
+  return {
+    amount: amount.toString(),
+    asset,
+    network,
+    breakdown,
+    validUntil: Math.floor(Date.now() / 1e3) + ttlSeconds,
+    display: formatPrice(amount, asset)
+  };
+}
+var BasePricingStrategy = class {
+  constructor(config, decimals = 6) {
+    this.config = config;
+    this.decimals = decimals;
+  }
+  generateCacheKey(context) {
+    return generateCacheKey(this.type, this.config.id, context);
+  }
+  validate() {
+    const errors = [];
+    if (!this.config.parameters) {
+      errors.push("Strategy parameters are required");
+    }
+    if (!this.config.vendorId) {
+      errors.push("Vendor ID is required");
+    }
+    return {
+      valid: errors.length === 0,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+  getParams() {
+    return this.config.parameters;
+  }
+  getCacheTtl() {
+    return this.config.cache?.ttlSeconds ?? 300;
+  }
+};
+var FixedPricingStrategy = class extends BasePricingStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "Fixed Pricing";
+    this.type = "fixed";
+  }
+  async calculatePrice(context) {
+    const params = this.getParams();
+    const amount = BigInt(params.price);
+    return buildPriceResult(
+      amount,
+      params.asset,
+      params.network,
+      this.getCacheTtl(),
+      [{ component: "Base Price", amount: params.price }]
+    );
+  }
+  validate() {
+    const base = super.validate();
+    if (!base.valid) return base;
+    const errors = [];
+    const params = this.getParams();
+    if (!params.price || BigInt(params.price) <= 0n) {
+      errors.push("Fixed price must be positive");
+    }
+    if (!params.asset) {
+      errors.push("Asset address is required");
+    }
+    return {
+      valid: errors.length === 0,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+};
+var TieredPricingStrategy = class extends BasePricingStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "Tiered Pricing";
+    this.type = "tiered";
+  }
+  async calculatePrice(context) {
+    const params = this.getParams();
+    const requestCount = context.user?.usage?.requestCount || 0;
+    const tier = determineTier(requestCount, params.tiers);
+    if (!tier) {
+      throw new Error("No applicable pricing tier found");
+    }
+    let amount = BigInt(tier.pricePerRequest);
+    if (tier.discount && tier.discount > 0) {
+      amount = applyDiscount(amount, tier.discount);
+    }
+    return buildPriceResult(
+      amount,
+      params.asset,
+      params.network,
+      this.getCacheTtl(),
+      [
+        { component: "Base Price", amount: tier.pricePerRequest },
+        ...tier.discount ? [{ component: "Tier Discount", amount: `-${tier.discount}%`, percentage: tier.discount }] : []
+      ]
+    );
+  }
+  validate() {
+    const base = super.validate();
+    if (!base.valid) return base;
+    const errors = [];
+    const params = this.getParams();
+    if (!params.tiers || params.tiers.length === 0) {
+      errors.push("At least one pricing tier is required");
+    }
+    return {
+      valid: errors.length === 0,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+};
+var UsageBasedPricingStrategy = class extends BasePricingStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "Usage-Based Pricing";
+    this.type = "usage-based";
+  }
+  async calculatePrice(context) {
+    const params = this.getParams();
+    const units = calculateUsageUnits(context, params.unit);
+    let amount = BigInt(params.pricePerUnit) * BigInt(units);
+    if (params.minimumCharge) {
+      const min = BigInt(params.minimumCharge);
+      if (amount < min) {
+        amount = min;
+      }
+    }
+    if (params.maximumCharge) {
+      const max = BigInt(params.maximumCharge);
+      if (amount > max) {
+        amount = max;
+      }
+    }
+    return buildPriceResult(
+      amount,
+      params.asset,
+      params.network,
+      this.getCacheTtl(),
+      [
+        { component: `${units} ${params.unit}`, amount: amount.toString() }
+      ]
+    );
+  }
+};
+var TimeBucketPricingStrategy = class extends BasePricingStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "Time-Bucket Pricing";
+    this.type = "time-bucket";
+  }
+  async calculatePrice(context) {
+    const params = this.getParams();
+    const bucket = getTimeBucket(params.timezone, params.peakHours);
+    let amount = BigInt(params.basePrice);
+    let multiplier = 1;
+    switch (bucket) {
+      case "peak":
+        multiplier = params.peakMultiplier;
+        break;
+      case "off-peak":
+        multiplier = params.offPeakMultiplier;
+        break;
+    }
+    amount = applyMultiplier(amount, multiplier);
+    return buildPriceResult(
+      amount,
+      params.asset,
+      params.network,
+      this.getCacheTtl(),
+      [
+        { component: "Base Price", amount: params.basePrice },
+        { component: `${bucket} multiplier`, amount: `x${multiplier}` }
+      ]
+    );
+  }
+};
+function createPricingStrategy(config, decimals = 6) {
+  switch (config.strategyType) {
+    case "fixed":
+      return new FixedPricingStrategy(config, decimals);
+    case "tiered":
+      return new TieredPricingStrategy(config, decimals);
+    case "usage-based":
+      return new UsageBasedPricingStrategy(config, decimals);
+    case "time-bucket":
+      return new TimeBucketPricingStrategy(config, decimals);
+    default:
+      throw new Error(`Unsupported strategy type: ${config.strategyType}`);
+  }
+}
+export {
+  ASSET_SYMBOLS,
+  BasePricingStrategy,
+  FixedPricingStrategy,
+  TieredPricingStrategy,
+  TimeBucketPricingStrategy,
+  UsageBasedPricingStrategy,
+  applyDiscount,
+  applyMultiplier,
+  atomicUnitsToUsd,
+  buildPriceResult,
+  calculateUsageUnits,
+  createPricingStrategy,
+  determineTier,
+  formatPrice,
+  generateCacheKey,
+  getTimeBucket,
+  sortObject,
+  usdToAtomicUnits
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@perkos/service-pricing",
+  "version": "1.0.0",
+  "description": "Dynamic pricing service with strategy patterns for x402 payment protocol",
+  "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": [
+    "pricing",
+    "dynamic-pricing",
+    "x402",
+    "payment",
+    "strategy-pattern",
+    "tiered-pricing",
+    "usage-based-pricing"
+  ],
+  "author": "PerkOS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PerkOS-xyz/pkg-service-pricing"
+  },
+  "dependencies": {
+    "@perkos/types-x402": "^1.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  }
+}