paybridge 0.1.2 → 0.2.1

package/README.md

@@ -5,6 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/paybridge.svg)](https://www.npmjs.com/package/paybridge)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue)](https://www.typescriptlang.org/)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Chat-5865F2?logo=discord&logoColor=white)](https://discord.gg/Y2jCXNGgE)
 
 Unified payment SDK for Node.js that works with multiple payment providers through a single, consistent API. Focus on South African providers first, with support for international gateways.
 
@@ -178,17 +179,32 @@ app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
 
 ## Supported Providers
 
+### Fiat providers
+
 | Provider | One-time | Subscriptions | Refunds | Webhooks | Status |
 |----------|----------|---------------|---------|----------|--------|
 | **SoftyComp** | ✅ | ✅ | ✅ | ✅ | **Production** |
-| **Yoco** | 🚧 | 🚧 | 🚧 | 🚧 | Coming soon |
-| **Ozow** | 🚧 | 🚧 | 🚧 | 🚧 | Coming soon |
-| **PayFast** | 📋 | 📋 | 📋 | 📋 | Planned |
-| **PayStack** | 📋 | 📋 | 📋 | 📋 | Planned |
-| **Stripe** | 📋 | 📋 | 📋 | 📋 | Planned |
-| **Peach Payments** | 📋 | 📋 | 📋 | 📋 | Planned |
+| **Yoco** | ✅ | ⛔ | ✅ | ✅ | **Production** |
+| **Ozow** | ✅ | ⛔ | ⛔ | ✅ | **Production** |
+| **PayFast** | ✅ | ✅ | ✅ | ✅ | **Production** |
+| **PayStack** | ✅ | ✅ | ✅ | ✅ | **Production** |
+| **Stripe** | ✅ | ✅ | ✅ | ✅ | **Production** |
+| **Peach Payments** | ✅ | ⛔ | ✅ | ✅ | **Production** |
+| **Flutterwave** | ✅ | ✅ | ✅ | ✅ | **Production** |
+
+### Crypto on/off-ramp providers
+
+| Provider | On-ramp | Off-ramp | Quote | Webhooks | Status |
+|----------|---------|----------|-------|----------|--------|
+| **MoonPay** | ✅ | ✅ | ✅ | ✅ | **Production** |
+| **Yellow Card** | ⚠️ | ⚠️ | ⚠️ | ⚠️ | **Experimental** |
 
-**Legend:** ✅ Production ready | 🚧 In development | 📋 Planned
+**Legend:** ✅ Supported | ⛔ Not supported by upstream API | ⚠️ Experimental (spec unverified)
+
+**Notes:**
+- `⛔` marks features the underlying provider's API doesn't support — those methods throw a clear error explaining the limitation. Use a different provider for that capability or use `PayBridgeRouter` to route accordingly.
+- **Yellow Card** is gated behind `@experimental` until partner API documentation is verified — it logs a warning on instantiation. Do not use in production without partner-confirmed spec.
+- **Sandbox testing.** PayFast / PayStack / Stripe / Peach / Flutterwave are wired and unit-tested, but have not yet been validated against live sandbox credentials. Run a sandbox transaction before going live.
 
 ## Provider Configuration
 
@@ -326,6 +342,64 @@ new PayBridge(config: PayBridgeConfig)
 
 See [src/types.ts](src/types.ts) for full type definitions.
 
+## Multi-Provider Routing
+
+PayBridge supports multi-provider routing with automatic failover and circuit breakers. Use `PayBridgeRouter` to route requests across multiple providers based on cost, priority, or round-robin.
+
+```typescript
+import { PayBridge, PayBridgeRouter } from 'paybridge';
+
+const softycomp = new PayBridge({ provider: 'softycomp', credentials: {...}, sandbox: true });
+const yoco = new PayBridge({ provider: 'yoco', credentials: {...}, sandbox: true });
+
+const router = new PayBridgeRouter({
+  providers: [
+    { provider: softycomp, weight: 1 },
+    { provider: yoco, weight: 2 }
+  ],
+  strategy: 'cheapest',
+  fallback: {
+    enabled: true,
+    maxAttempts: 3,
+    retryDelayMs: 250
+  }
+});
+
+const payment = await router.createPayment({
+  amount: 299.00,
+  currency: 'ZAR',
+  reference: 'INV-001',
+  customer: { name: 'John Doe', email: 'john@example.com' },
+  urls: {
+    success: 'https://myapp.com/success',
+    cancel: 'https://myapp.com/cancel',
+    webhook: 'https://myapp.com/webhook'
+  }
+});
+
+console.log(payment.routingMeta.chosenProvider);
+console.log(payment.routingMeta.attempts);
+```
+
+### Multi-instance deployments (Redis circuit-breaker)
+
+By default, each Node process has its own in-memory circuit breaker. To share circuit breaker state across multiple instances (e.g., behind a load balancer), use a Redis-backed store:
+
+```typescript
+import Redis from 'ioredis';
+import { PayBridgeRouter, createRedisCircuitBreakerStore } from 'paybridge';
+
+const redis = new Redis(process.env.REDIS_URL!);
+const store = createRedisCircuitBreakerStore(redis, { prefix: 'app:cb:' });
+
+const router = new PayBridgeRouter({
+  providers: [...],
+  circuitBreakerStore: store,
+});
+```
+
+The Redis adapter works with both `ioredis` and `redis` (node-redis v4+) clients. State is eventually consistent across instances — race conditions during state transitions may cause a few extra failures, but correctness is preserved.
+
 ## Currency Handling
 
 PayBridge **always uses major currency units** (rands, dollars) in the API:
@@ -394,6 +468,12 @@ We welcome contributions! To add a new payment provider:
 
 See [src/providers/softycomp.ts](src/providers/softycomp.ts) for reference implementation.
 
+## Community
+
+Join our Discord for support, feature discussions, and updates:
+
+- **Discord:** [https://discord.gg/Y2jCXNGgE](https://discord.gg/Y2jCXNGgE)
+
 ## License
 
 MIT © [Kobie Wentzel](https://github.com/kobie3717)

package/dist/circuit-breaker-store.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Circuit breaker storage abstraction
+ */
+export interface CircuitBreakerSnapshot {
+    state: 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+    failureCount: number;
+    nextAttemptTime: number;
+}
+/**
+ * Storage interface for circuit breaker state.
+ * TTL is advisory — in-memory stores may ignore it, Redis-backed stores use it for expiry.
+ */
+export interface CircuitBreakerStore {
+    get(key: string): Promise<CircuitBreakerSnapshot | null>;
+    set(key: string, snapshot: CircuitBreakerSnapshot, ttlMs?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/**
+ * In-memory circuit breaker store.
+ * Each process instance has its own isolated state.
+ */
+export declare class MemoryStore implements CircuitBreakerStore {
+    private map;
+    get(key: string): Promise<CircuitBreakerSnapshot | null>;
+    set(key: string, snapshot: CircuitBreakerSnapshot): Promise<void>;
+    delete(key: string): Promise<void>;
+}

package/dist/circuit-breaker-store.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Circuit breaker storage abstraction
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStore = void 0;
+/**
+ * In-memory circuit breaker store.
+ * Each process instance has its own isolated state.
+ */
+class MemoryStore {
+    constructor() {
+        this.map = new Map();
+    }
+    async get(key) {
+        return this.map.get(key) ?? null;
+    }
+    async set(key, snapshot) {
+        this.map.set(key, snapshot);
+    }
+    async delete(key) {
+        this.map.delete(key);
+    }
+}
+exports.MemoryStore = MemoryStore;

package/dist/circuit-breaker.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Circuit breaker for provider failure management.
+ * Supports pluggable storage for multi-instance deployments.
+ * Not atomic across processes — eventual consistency accepted.
+ */
+import { CircuitBreakerStore } from './circuit-breaker-store';
+export declare enum CircuitState {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN"
+}
+export interface CircuitBreakerConfig {
+    failureThreshold?: number;
+    resetTimeoutMs?: number;
+    store?: CircuitBreakerStore;
+}
+export declare class CircuitBreaker {
+    private readonly key;
+    private readonly failureThreshold;
+    private readonly resetTimeoutMs;
+    private readonly store;
+    constructor(key?: string, config?: CircuitBreakerConfig);
+    isOpen(): Promise<boolean>;
+    recordSuccess(): Promise<void>;
+    recordFailure(): Promise<void>;
+    getState(): Promise<CircuitState>;
+    reset(): Promise<void>;
+    private getSnapshot;
+    private saveSnapshot;
+}

package/dist/circuit-breaker.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Circuit breaker for provider failure management.
+ * Supports pluggable storage for multi-instance deployments.
+ * Not atomic across processes — eventual consistency accepted.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = exports.CircuitState = void 0;
+const circuit_breaker_store_1 = require("./circuit-breaker-store");
+var CircuitState;
+(function (CircuitState) {
+    CircuitState["CLOSED"] = "CLOSED";
+    CircuitState["OPEN"] = "OPEN";
+    CircuitState["HALF_OPEN"] = "HALF_OPEN";
+})(CircuitState || (exports.CircuitState = CircuitState = {}));
+class CircuitBreaker {
+    constructor(key = 'default', config = {}) {
+        this.key = key;
+        this.failureThreshold = config.failureThreshold ?? 5;
+        this.resetTimeoutMs = config.resetTimeoutMs ?? 30000;
+        this.store = config.store ?? new circuit_breaker_store_1.MemoryStore();
+    }
+    async isOpen() {
+        const snapshot = await this.getSnapshot();
+        if (snapshot.state === CircuitState.OPEN) {
+            if (Date.now() >= snapshot.nextAttemptTime) {
+                snapshot.state = CircuitState.HALF_OPEN;
+                await this.saveSnapshot(snapshot);
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    async recordSuccess() {
+        const snapshot = {
+            state: CircuitState.CLOSED,
+            failureCount: 0,
+            nextAttemptTime: 0,
+        };
+        await this.saveSnapshot(snapshot);
+    }
+    async recordFailure() {
+        const snapshot = await this.getSnapshot();
+        snapshot.failureCount++;
+        if (snapshot.state === CircuitState.HALF_OPEN) {
+            snapshot.state = CircuitState.OPEN;
+            snapshot.nextAttemptTime = Date.now() + this.resetTimeoutMs;
+            await this.saveSnapshot(snapshot, this.resetTimeoutMs + 5000);
+        }
+        else if (snapshot.failureCount >= this.failureThreshold) {
+            snapshot.state = CircuitState.OPEN;
+            snapshot.nextAttemptTime = Date.now() + this.resetTimeoutMs;
+            await this.saveSnapshot(snapshot, this.resetTimeoutMs + 5000);
+        }
+        else {
+            await this.saveSnapshot(snapshot);
+        }
+    }
+    async getState() {
+        const snapshot = await this.getSnapshot();
+        return snapshot.state;
+    }
+    async reset() {
+        const snapshot = {
+            state: CircuitState.CLOSED,
+            failureCount: 0,
+            nextAttemptTime: 0,
+        };
+        await this.saveSnapshot(snapshot);
+    }
+    async getSnapshot() {
+        const snapshot = await this.store.get(this.key);
+        if (snapshot)
+            return snapshot;
+        return {
+            state: CircuitState.CLOSED,
+            failureCount: 0,
+            nextAttemptTime: 0,
+        };
+    }
+    async saveSnapshot(snapshot, ttlMs) {
+        await this.store.set(this.key, snapshot, ttlMs);
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;

package/dist/crypto/base.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Base crypto ramp provider abstract class
+ */
+import { OnRampParams, OffRampParams, RampQuote, RampResult, CryptoRampCapabilities, CryptoNetwork } from './types';
+export declare function validateWalletAddress(address: string, network: CryptoNetwork): void;
+export declare abstract class CryptoRampProvider {
+    abstract readonly name: string;
+    abstract getQuote(direction: 'on' | 'off', fiatAmount: number, fiatCurrency: string, cryptoAsset: string, network: string): Promise<RampQuote>;
+    abstract createOnRamp(params: OnRampParams): Promise<RampResult>;
+    abstract createOffRamp(params: OffRampParams): Promise<RampResult>;
+    abstract getRamp(id: string): Promise<RampResult>;
+    abstract parseWebhook(body: any, headers?: any): any;
+    abstract verifyWebhook(body: any, headers?: any): boolean;
+    abstract getCapabilities(): CryptoRampCapabilities;
+}

package/dist/crypto/base.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Base crypto ramp provider abstract class
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoRampProvider = void 0;
+exports.validateWalletAddress = validateWalletAddress;
+function validateWalletAddress(address, network) {
+    const patterns = {
+        BTC: /^([13][a-km-zA-HJ-NP-Z1-9]{25,34}|bc1[a-z0-9]{39,59})$/,
+        ETH: /^0x[a-fA-F0-9]{40}$/,
+        POLYGON: /^0x[a-fA-F0-9]{40}$/,
+        BSC: /^0x[a-fA-F0-9]{40}$/,
+        TRON: /^T[A-Za-z1-9]{33}$/,
+    };
+    const re = patterns[network];
+    if (!re)
+        throw new Error(`Unsupported network: ${network}`);
+    if (!re.test(address))
+        throw new Error(`Invalid ${network} wallet address`);
+}
+class CryptoRampProvider {
+}
+exports.CryptoRampProvider = CryptoRampProvider;

package/dist/crypto/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * CryptoRamp — Unified crypto on/off-ramp SDK
+ */
+import { OnRampParams, OffRampParams, RampQuote, RampResult, CryptoRampCapabilities } from './types';
+export * from './types';
+export * from './base';
+export * from './moonpay';
+export * from './yellowcard';
+export * from './mock';
+export * from './router';
+export type CryptoProvider = 'moonpay' | 'yellowcard' | 'mock';
+export interface CryptoRampConfig {
+    provider: CryptoProvider;
+    credentials: {
+        apiKey?: string;
+        secretKey?: string;
+        [key: string]: any;
+    };
+    sandbox?: boolean;
+    webhookSecret?: string;
+}
+export declare class CryptoRamp {
+    private provider;
+    constructor(config: CryptoRampConfig);
+    private createProvider;
+    getQuote(direction: 'on' | 'off', fiatAmount: number, fiatCurrency: string, cryptoAsset: string, network: string): Promise<RampQuote>;
+    createOnRamp(params: OnRampParams): Promise<RampResult>;
+    createOffRamp(params: OffRampParams): Promise<RampResult>;
+    getRamp(id: string): Promise<RampResult>;
+    parseWebhook(body: any, headers?: any): any;
+    verifyWebhook(body: any, headers?: any): boolean;
+    getCapabilities(): CryptoRampCapabilities;
+    getProviderName(): string;
+}
+export default CryptoRamp;

package/dist/crypto/index.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * CryptoRamp — Unified crypto on/off-ramp SDK
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoRamp = void 0;
+const moonpay_1 = require("./moonpay");
+const yellowcard_1 = require("./yellowcard");
+const mock_1 = require("./mock");
+__exportStar(require("./types"), exports);
+__exportStar(require("./base"), exports);
+__exportStar(require("./moonpay"), exports);
+__exportStar(require("./yellowcard"), exports);
+__exportStar(require("./mock"), exports);
+__exportStar(require("./router"), exports);
+class CryptoRamp {
+    constructor(config) {
+        this.provider = this.createProvider(config);
+    }
+    createProvider(config) {
+        const { provider, credentials, sandbox = true, webhookSecret } = config;
+        switch (provider) {
+            case 'moonpay':
+                if (!credentials.apiKey || !credentials.secretKey) {
+                    throw new Error('MoonPay requires apiKey and secretKey');
+                }
+                return new moonpay_1.MoonPayProvider({
+                    apiKey: credentials.apiKey,
+                    secretKey: credentials.secretKey,
+                    sandbox,
+                    webhookSecret,
+                });
+            case 'yellowcard':
+                if (!credentials.apiKey || !credentials.secretKey) {
+                    throw new Error('Yellow Card requires apiKey and secretKey');
+                }
+                return new yellowcard_1.YellowCardProvider({
+                    apiKey: credentials.apiKey,
+                    secretKey: credentials.secretKey,
+                    sandbox,
+                    webhookSecret,
+                });
+            case 'mock':
+                return new mock_1.MockCryptoRampProvider();
+            default:
+                throw new Error(`Unknown crypto provider: ${provider}`);
+        }
+    }
+    async getQuote(direction, fiatAmount, fiatCurrency, cryptoAsset, network) {
+        return this.provider.getQuote(direction, fiatAmount, fiatCurrency, cryptoAsset, network);
+    }
+    async createOnRamp(params) {
+        if (!Number.isFinite(params.fiatAmount) || params.fiatAmount <= 0) {
+            throw new Error('Invalid amount: must be a positive finite number');
+        }
+        return this.provider.createOnRamp(params);
+    }
+    async createOffRamp(params) {
+        if (!Number.isFinite(params.cryptoAmount) || params.cryptoAmount <= 0) {
+            throw new Error('Invalid amount: must be a positive finite number');
+        }
+        return this.provider.createOffRamp(params);
+    }
+    async getRamp(id) {
+        return this.provider.getRamp(id);
+    }
+    parseWebhook(body, headers) {
+        return this.provider.parseWebhook(body, headers);
+    }
+    verifyWebhook(body, headers) {
+        return this.provider.verifyWebhook(body, headers);
+    }
+    getCapabilities() {
+        return this.provider.getCapabilities();
+    }
+    getProviderName() {
+        return this.provider.name;
+    }
+}
+exports.CryptoRamp = CryptoRamp;
+exports.default = CryptoRamp;

package/dist/crypto/mock.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Mock crypto ramp provider for testing
+ */
+import { CryptoRampProvider } from './base';
+import { OnRampParams, OffRampParams, RampQuote, RampResult, CryptoRampCapabilities } from './types';
+export declare class MockCryptoRampProvider extends CryptoRampProvider {
+    readonly name = "mock";
+    getQuote(direction: 'on' | 'off', fiatAmount: number, fiatCurrency: string, cryptoAsset: string, _network: string): Promise<RampQuote>;
+    createOnRamp(params: OnRampParams): Promise<RampResult>;
+    createOffRamp(params: OffRampParams): Promise<RampResult>;
+    getRamp(id: string): Promise<RampResult>;
+    parseWebhook(body: any, _headers?: any): any;
+    verifyWebhook(_body: any, _headers?: any): boolean;
+    getCapabilities(): CryptoRampCapabilities;
+}

package/dist/crypto/mock.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Mock crypto ramp provider for testing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockCryptoRampProvider = void 0;
+const base_1 = require("./base");
+class MockCryptoRampProvider extends base_1.CryptoRampProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'mock';
+    }
+    async getQuote(direction, fiatAmount, fiatCurrency, cryptoAsset, _network) {
+        const mockRate = cryptoAsset === 'BTC' ? 50000 : cryptoAsset === 'ETH' ? 3000 : 1;
+        const cryptoAmount = fiatAmount / mockRate;
+        const feePercent = direction === 'on' ? 3.5 : 2.0;
+        const feeTotal = fiatAmount * (feePercent / 100);
+        return {
+            fiatAmount,
+            cryptoAmount,
+            rate: mockRate,
+            feeFixed: 0,
+            feePercent,
+            feeTotal,
+            expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+        };
+    }
+    async createOnRamp(params) {
+        (0, base_1.validateWalletAddress)(params.destinationWallet, params.network);
+        const quote = await this.getQuote('on', params.fiatAmount, params.fiatCurrency, params.asset, params.network);
+        return {
+            id: `mock_on_${Date.now()}`,
+            direction: 'on',
+            status: 'pending',
+            quote,
+            checkoutUrl: `https://mock-ramp.example.com/checkout/${params.reference}`,
+            createdAt: new Date().toISOString(),
+            expiresAt: quote.expiresAt,
+        };
+    }
+    async createOffRamp(params) {
+        if (params.sourceWallet) {
+            (0, base_1.validateWalletAddress)(params.sourceWallet, params.network);
+        }
+        const mockRate = params.asset === 'BTC' ? 50000 : params.asset === 'ETH' ? 3000 : 1;
+        const fiatAmount = params.cryptoAmount * mockRate;
+        const quote = await this.getQuote('off', fiatAmount, params.fiatCurrency, params.asset, params.network);
+        return {
+            id: `mock_off_${Date.now()}`,
+            direction: 'off',
+            status: 'pending',
+            quote,
+            depositAddress: '0xMOCK1234567890ABCDEF',
+            depositTag: 'MOCK123',
+            createdAt: new Date().toISOString(),
+            expiresAt: quote.expiresAt,
+        };
+    }
+    async getRamp(id) {
+        const direction = id.includes('_on_') ? 'on' : 'off';
+        const quote = {
+            fiatAmount: 1000,
+            cryptoAmount: 0.02,
+            rate: 50000,
+            feeFixed: 0,
+            feePercent: 3.5,
+            feeTotal: 35,
+            expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+        };
+        return {
+            id,
+            direction,
+            status: 'completed',
+            quote,
+            txHash: '0xMOCKTXHASH123456',
+            createdAt: new Date(Date.now() - 10 * 60 * 1000).toISOString(),
+        };
+    }
+    parseWebhook(body, _headers) {
+        const event = typeof body === 'string' ? JSON.parse(body) : body;
+        return {
+            type: 'transaction.completed',
+            data: event,
+            raw: event,
+        };
+    }
+    verifyWebhook(_body, _headers) {
+        return true;
+    }
+    getCapabilities() {
+        return {
+            supportedAssets: ['BTC', 'ETH', 'USDT', 'USDC'],
+            supportedNetworks: ['BTC', 'ETH', 'TRON', 'POLYGON', 'BSC'],
+            supportedFiat: ['ZAR', 'USD', 'EUR', 'GBP'],
+            country: 'GLOBAL',
+            kycRequired: false,
+            onRampLimits: {
+                min: 10,
+                max: 100000,
+            },
+            offRampLimits: {
+                min: 10,
+                max: 100000,
+            },
+            fees: {
+                onRampPercent: 3.5,
+                offRampPercent: 2.0,
+            },
+        };
+    }
+}
+exports.MockCryptoRampProvider = MockCryptoRampProvider;

package/dist/crypto/moonpay.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MoonPay crypto on/off-ramp provider
+ * @see https://dev.moonpay.com
+ */
+import { CryptoRampProvider } from './base';
+import { OnRampParams, OffRampParams, RampQuote, RampResult, CryptoRampCapabilities } from './types';
+interface MoonPayConfig {
+    apiKey: string;
+    secretKey: string;
+    sandbox: boolean;
+    webhookSecret?: string;
+}
+export declare class MoonPayProvider extends CryptoRampProvider {
+    readonly name = "moonpay";
+    private apiKey;
+    private secretKey;
+    private sandbox;
+    private baseUrl;
+    private widgetUrl;
+    private webhookSecret?;
+    constructor(config: MoonPayConfig);
+    getQuote(direction: 'on' | 'off', fiatAmount: number, fiatCurrency: string, cryptoAsset: string, _network: string): Promise<RampQuote>;
+    createOnRamp(params: OnRampParams): Promise<RampResult>;
+    createOffRamp(params: OffRampParams): Promise<RampResult>;
+    getRamp(id: string): Promise<RampResult>;
+    parseWebhook(body: any, _headers?: any): any;
+    verifyWebhook(body: string | Buffer, headers?: any): boolean;
+    private verifyWebhookV2;
+    getCapabilities(): CryptoRampCapabilities;
+    private signWidgetUrl;
+    private mapMoonPayStatus;
+}
+export {};