paybridge 0.1.2 → 0.2.1

package/dist/crypto/moonpay.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * MoonPay crypto on/off-ramp provider
+ * @see https://dev.moonpay.com
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoonPayProvider = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const base_1 = require("./base");
+class MoonPayProvider extends base_1.CryptoRampProvider {
+    constructor(config) {
+        super();
+        this.name = 'moonpay';
+        this.apiKey = config.apiKey;
+        this.secretKey = config.secretKey;
+        this.sandbox = config.sandbox;
+        this.webhookSecret = config.webhookSecret;
+        // Sandbox vs live is determined by API key prefix (pk_test_* vs pk_live_*)
+        this.baseUrl = 'https://api.moonpay.com';
+        this.widgetUrl = this.sandbox
+            ? 'https://buy-sandbox.moonpay.com'
+            : 'https://buy.moonpay.com';
+    }
+    async getQuote(direction, fiatAmount, fiatCurrency, cryptoAsset, _network) {
+        const params = new URLSearchParams({
+            apiKey: this.apiKey,
+            baseCurrencyCode: fiatCurrency.toLowerCase(),
+            quoteCurrencyCode: cryptoAsset.toLowerCase(),
+            baseCurrencyAmount: fiatAmount.toString(),
+        });
+        const url = `${this.baseUrl}/v3/currencies/${cryptoAsset.toLowerCase()}/quote?${params}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`MoonPay quote failed: ${response.status}`);
+        }
+        const data = await response.json();
+        const feeTotal = data.feeAmount || 0;
+        const rate = data.quoteCurrencyPrice || 0;
+        const cryptoAmount = data.quoteCurrencyAmount || 0;
+        return {
+            fiatAmount,
+            cryptoAmount,
+            rate,
+            feeFixed: 0,
+            feePercent: (feeTotal / fiatAmount) * 100,
+            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);
+        const widgetParams = new URLSearchParams({
+            apiKey: this.apiKey,
+            currencyCode: params.asset.toLowerCase(),
+            baseCurrencyCode: params.fiatCurrency.toLowerCase(),
+            baseCurrencyAmount: params.fiatAmount.toString(),
+            walletAddress: params.destinationWallet,
+            email: params.customer.email,
+            externalTransactionId: params.reference,
+            redirectURL: params.urls.success,
+        });
+        const signature = this.signWidgetUrl(`?${widgetParams.toString()}`);
+        widgetParams.append('signature', signature);
+        const checkoutUrl = `${this.widgetUrl}?${widgetParams}`;
+        return {
+            id: `moonpay_on_${params.reference}`,
+            direction: 'on',
+            status: 'pending',
+            quote,
+            checkoutUrl,
+            createdAt: new Date().toISOString(),
+            expiresAt: quote.expiresAt,
+        };
+    }
+    async createOffRamp(params) {
+        if (params.sourceWallet) {
+            (0, base_1.validateWalletAddress)(params.sourceWallet, params.network);
+        }
+        // TODO: verify endpoint - use /v3/currencies/{code}/sell_quote?baseCurrencyAmount=...
+        // For now, use getQuote with 'off' direction
+        const quote = await this.getQuote('off', 0, // Will be calculated from crypto amount
+        params.fiatCurrency, params.asset, params.network);
+        const sellWidgetUrl = this.sandbox
+            ? 'https://sell-sandbox.moonpay.com'
+            : 'https://sell.moonpay.com';
+        const widgetParams = new URLSearchParams({
+            apiKey: this.apiKey,
+            baseCurrencyCode: params.asset.toLowerCase(),
+            quoteCurrencyCode: params.fiatCurrency.toLowerCase(),
+            baseCurrencyAmount: params.cryptoAmount.toString(),
+            externalTransactionId: params.reference,
+            refundWalletAddress: params.sourceWallet || '',
+            redirectURL: params.urls?.success || '',
+        });
+        const signature = this.signWidgetUrl(`?${widgetParams.toString()}`);
+        widgetParams.append('signature', signature);
+        const checkoutUrl = `${sellWidgetUrl}?${widgetParams}`;
+        return {
+            id: `moonpay_off_${params.reference}`,
+            direction: 'off',
+            status: 'pending',
+            quote,
+            checkoutUrl,
+            createdAt: new Date().toISOString(),
+            expiresAt: quote.expiresAt,
+        };
+    }
+    async getRamp(id) {
+        const response = await fetch(`${this.baseUrl}/v3/transactions/${id}`, {
+            headers: {
+                Authorization: `Bearer ${this.secretKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`MoonPay getRamp failed: ${response.status}`);
+        }
+        const data = await response.json();
+        const direction = data.type === 'buy' ? 'on' : 'off';
+        const status = this.mapMoonPayStatus(data.status);
+        const quote = {
+            fiatAmount: data.baseCurrencyAmount || 0,
+            cryptoAmount: data.quoteCurrencyAmount || 0,
+            rate: data.quoteCurrencyPrice || 0,
+            feeFixed: 0,
+            feePercent: 0,
+            feeTotal: data.feeAmount || 0,
+            expiresAt: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+        };
+        const sanitizedRaw = { ...data };
+        if (sanitizedRaw.bankAccount)
+            delete sanitizedRaw.bankAccount;
+        if (sanitizedRaw.bank_account)
+            delete sanitizedRaw.bank_account;
+        return {
+            id: data.id,
+            direction,
+            status,
+            quote,
+            txHash: data.cryptoTransactionId,
+            createdAt: data.createdAt,
+            raw: sanitizedRaw,
+        };
+    }
+    parseWebhook(body, _headers) {
+        const event = typeof body === 'string' ? JSON.parse(body) : body;
+        return {
+            type: event.type,
+            data: event.data,
+            raw: event,
+        };
+    }
+    verifyWebhook(body, headers) {
+        if (!this.webhookSecret)
+            return false;
+        // Try V2 signature first (recommended)
+        const signatureV2 = headers?.['moonpay-signature-v2'];
+        if (signatureV2) {
+            return this.verifyWebhookV2(body, signatureV2);
+        }
+        // Fall back to legacy signature
+        const signature = headers?.['moonpay-signature'] || headers?.signature;
+        if (!signature)
+            return false;
+        const expectedSignature = crypto_1.default
+            .createHmac('sha256', this.webhookSecret)
+            .update(body)
+            .digest('hex');
+        const sigBuf = Buffer.from(signature);
+        const expBuf = Buffer.from(expectedSignature);
+        if (sigBuf.length !== expBuf.length)
+            return false;
+        return crypto_1.default.timingSafeEqual(sigBuf, expBuf);
+    }
+    verifyWebhookV2(body, signatureHeader) {
+        if (!this.webhookSecret)
+            return false;
+        // Parse V2 format: t=<timestamp>,s=<signature>
+        const parts = signatureHeader.split(',');
+        let timestamp;
+        let signature;
+        for (const part of parts) {
+            const [key, value] = part.split('=');
+            if (key === 't')
+                timestamp = value;
+            if (key === 's')
+                signature = value;
+        }
+        if (!timestamp || !signature)
+            return false;
+        // Replay protection: timestamp must be within 5 minutes
+        const now = Math.floor(Date.now() / 1000);
+        const ts = parseInt(timestamp, 10);
+        if (isNaN(ts) || Math.abs(now - ts) > 300)
+            return false;
+        // Verify signature: HMAC-SHA256 of ${timestamp}.${body}
+        const bodyStr = Buffer.isBuffer(body) ? body.toString('utf8') : body;
+        const payload = `${timestamp}.${bodyStr}`;
+        const expectedSignature = crypto_1.default
+            .createHmac('sha256', this.webhookSecret)
+            .update(payload)
+            .digest('hex');
+        const sigBuf = Buffer.from(signature);
+        const expBuf = Buffer.from(expectedSignature);
+        if (sigBuf.length !== expBuf.length)
+            return false;
+        return crypto_1.default.timingSafeEqual(sigBuf, expBuf);
+    }
+    getCapabilities() {
+        return {
+            supportedAssets: ['BTC', 'ETH', 'USDT', 'USDC', 'BNB', 'SOL'],
+            supportedNetworks: ['BTC', 'ETH', 'TRON', 'POLYGON', 'BSC', 'SOLANA'],
+            supportedFiat: ['USD', 'EUR', 'GBP', 'ZAR'],
+            country: 'GLOBAL',
+            kycRequired: true,
+            onRampLimits: {
+                min: 20,
+                max: 50000,
+            },
+            offRampLimits: {
+                min: 30,
+                max: 50000,
+            },
+            fees: {
+                onRampPercent: 4.5,
+                offRampPercent: 1.0,
+            },
+        };
+    }
+    signWidgetUrl(queryString) {
+        return crypto_1.default
+            .createHmac('sha256', this.secretKey)
+            .update(queryString)
+            .digest('base64');
+    }
+    mapMoonPayStatus(moonpayStatus) {
+        const statusMap = {
+            waitingPayment: 'pending',
+            pending: 'pending',
+            waitingAuthorization: 'pending',
+            completed: 'completed',
+            failed: 'failed',
+            expired: 'expired',
+        };
+        return statusMap[moonpayStatus] || 'pending';
+    }
+}
+exports.MoonPayProvider = MoonPayProvider;

package/dist/crypto/router.d.ts

@@ -0,0 +1,36 @@
+/**
+ * CryptoRampRouter — Multi-provider crypto routing
+ */
+import { CryptoRamp } from './index';
+import { OnRampParams, OffRampParams, RampQuote, RampResult } from './types';
+export interface CryptoRampRouterConfig {
+    providers: Array<{
+        provider: CryptoRamp;
+        priority?: number;
+    }>;
+    strategy?: 'cheapest' | 'priority' | 'round-robin';
+    fallback?: {
+        enabled: boolean;
+        maxAttempts?: number;
+        retryDelayMs?: number;
+    };
+    allowExperimental?: boolean;
+    circuitBreakerStore?: import('../circuit-breaker-store').CircuitBreakerStore;
+}
+export declare class CryptoRampRouter {
+    private providers;
+    private strategy;
+    private fallback;
+    private allowExperimental;
+    private circuitBreakers;
+    private rrIndex;
+    private config;
+    constructor(config: CryptoRampRouterConfig);
+    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, provider?: string): Promise<RampResult>;
+    private filterProviders;
+    private orderProviders;
+    private sleep;
+}

package/dist/crypto/router.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * CryptoRampRouter — Multi-provider crypto routing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoRampRouter = void 0;
+const routing_types_1 = require("../routing-types");
+const circuit_breaker_1 = require("../circuit-breaker");
+function sanitizeErrorMessage(msg) {
+    if (!msg)
+        return 'unknown error';
+    return msg
+        .replace(/\b[A-Za-z0-9_-]{32,}\b/g, '[REDACTED]')
+        .replace(/(api[_-]?key|secret|token|password)["':=\s]+\S+/gi, '$1=[REDACTED]')
+        .slice(0, 500);
+}
+class CryptoRampRouter {
+    constructor(config) {
+        this.rrIndex = 0;
+        this.config = config;
+        this.providers = config.providers.map(p => ({
+            instance: p.provider,
+            priority: p.priority,
+        }));
+        this.strategy = config.strategy ?? 'cheapest';
+        this.fallback = {
+            enabled: config.fallback?.enabled ?? true,
+            maxAttempts: config.fallback?.maxAttempts ?? 3,
+            retryDelayMs: config.fallback?.retryDelayMs ?? 250,
+        };
+        this.allowExperimental = config.allowExperimental ?? false;
+        this.circuitBreakers = new Map();
+        for (const p of this.providers) {
+            const name = p.instance.getProviderName();
+            this.circuitBreakers.set(name, new circuit_breaker_1.CircuitBreaker(name, {
+                store: config.circuitBreakerStore,
+            }));
+        }
+    }
+    async getQuote(direction, fiatAmount, fiatCurrency, cryptoAsset, network) {
+        const filtered = this.filterProviders({ fiatCurrency, asset: cryptoAsset, network });
+        if (filtered.length === 0) {
+            throw new Error(`No providers support ${cryptoAsset} on ${network} with ${fiatCurrency}`);
+        }
+        const ordered = this.orderProviders(filtered, direction);
+        const attempts = [];
+        let lastError = null;
+        for (const providerMeta of ordered) {
+            const providerName = providerMeta.instance.getProviderName();
+            const breaker = this.circuitBreakers.get(providerName);
+            if (breaker && (await breaker.isOpen())) {
+                attempts.push({
+                    provider: providerName,
+                    status: 'skipped',
+                    errorMessage: 'Circuit breaker open',
+                    latencyMs: 0,
+                });
+                continue;
+            }
+            const startTime = Date.now();
+            try {
+                const result = await providerMeta.instance.getQuote(direction, fiatAmount, fiatCurrency, cryptoAsset, network);
+                const latencyMs = Date.now() - startTime;
+                if (breaker)
+                    await breaker.recordSuccess();
+                attempts.push({
+                    provider: providerName,
+                    status: 'success',
+                    latencyMs,
+                });
+                return result;
+            }
+            catch (error) {
+                const latencyMs = Date.now() - startTime;
+                lastError = error;
+                if (breaker)
+                    await breaker.recordFailure();
+                attempts.push({
+                    provider: providerName,
+                    status: 'failed',
+                    errorCode: error.code,
+                    errorMessage: sanitizeErrorMessage(error.message),
+                    latencyMs,
+                });
+                if (!this.fallback.enabled || attempts.length >= this.fallback.maxAttempts) {
+                    break;
+                }
+                await this.sleep(this.fallback.retryDelayMs);
+            }
+        }
+        throw new routing_types_1.RoutingError(`All providers failed: ${lastError?.message || 'Unknown error'}`, attempts);
+    }
+    async createOnRamp(params) {
+        if (!Number.isFinite(params.fiatAmount) || params.fiatAmount <= 0) {
+            throw new Error('Invalid amount: must be a positive finite number');
+        }
+        const filtered = this.filterProviders(params);
+        if (filtered.length === 0) {
+            throw new Error(`No providers support ${params.asset} on ${params.network} with ${params.fiatCurrency}`);
+        }
+        const ordered = this.orderProviders(filtered, 'on');
+        const attempts = [];
+        let lastError = null;
+        for (const providerMeta of ordered) {
+            const providerName = providerMeta.instance.getProviderName();
+            const breaker = this.circuitBreakers.get(providerName);
+            if (breaker && (await breaker.isOpen())) {
+                attempts.push({
+                    provider: providerName,
+                    status: 'skipped',
+                    errorMessage: 'Circuit breaker open',
+                    latencyMs: 0,
+                });
+                continue;
+            }
+            const startTime = Date.now();
+            try {
+                const result = await providerMeta.instance.createOnRamp(params);
+                const latencyMs = Date.now() - startTime;
+                if (breaker)
+                    await breaker.recordSuccess();
+                attempts.push({
+                    provider: providerName,
+                    status: 'success',
+                    latencyMs,
+                });
+                const routingMeta = {
+                    attempts,
+                    chosenProvider: providerName,
+                    strategy: this.strategy,
+                };
+                return {
+                    ...result,
+                    routingMeta,
+                };
+            }
+            catch (error) {
+                const latencyMs = Date.now() - startTime;
+                lastError = error;
+                if (breaker)
+                    await breaker.recordFailure();
+                attempts.push({
+                    provider: providerName,
+                    status: 'failed',
+                    errorCode: error.code,
+                    errorMessage: sanitizeErrorMessage(error.message),
+                    latencyMs,
+                });
+                if (!this.fallback.enabled || attempts.length >= this.fallback.maxAttempts) {
+                    break;
+                }
+                await this.sleep(this.fallback.retryDelayMs);
+            }
+        }
+        throw new routing_types_1.RoutingError(`All providers failed: ${lastError?.message || 'Unknown error'}`, attempts);
+    }
+    async createOffRamp(params) {
+        if (!Number.isFinite(params.cryptoAmount) || params.cryptoAmount <= 0) {
+            throw new Error('Invalid amount: must be a positive finite number');
+        }
+        const filtered = this.filterProviders(params);
+        if (filtered.length === 0) {
+            throw new Error(`No providers support ${params.asset} on ${params.network} with ${params.fiatCurrency}`);
+        }
+        const ordered = this.orderProviders(filtered, 'off');
+        const attempts = [];
+        let lastError = null;
+        for (const providerMeta of ordered) {
+            const providerName = providerMeta.instance.getProviderName();
+            const breaker = this.circuitBreakers.get(providerName);
+            if (breaker && (await breaker.isOpen())) {
+                attempts.push({
+                    provider: providerName,
+                    status: 'skipped',
+                    errorMessage: 'Circuit breaker open',
+                    latencyMs: 0,
+                });
+                continue;
+            }
+            const startTime = Date.now();
+            try {
+                const result = await providerMeta.instance.createOffRamp(params);
+                const latencyMs = Date.now() - startTime;
+                if (breaker)
+                    await breaker.recordSuccess();
+                attempts.push({
+                    provider: providerName,
+                    status: 'success',
+                    latencyMs,
+                });
+                const routingMeta = {
+                    attempts,
+                    chosenProvider: providerName,
+                    strategy: this.strategy,
+                };
+                return {
+                    ...result,
+                    routingMeta,
+                };
+            }
+            catch (error) {
+                const latencyMs = Date.now() - startTime;
+                lastError = error;
+                if (breaker)
+                    await breaker.recordFailure();
+                attempts.push({
+                    provider: providerName,
+                    status: 'failed',
+                    errorCode: error.code,
+                    errorMessage: sanitizeErrorMessage(error.message),
+                    latencyMs,
+                });
+                if (!this.fallback.enabled || attempts.length >= this.fallback.maxAttempts) {
+                    break;
+                }
+                await this.sleep(this.fallback.retryDelayMs);
+            }
+        }
+        throw new routing_types_1.RoutingError(`All providers failed: ${lastError?.message || 'Unknown error'}`, attempts);
+    }
+    async getRamp(id, provider) {
+        if (provider) {
+            const providerMeta = this.providers.find(p => p.instance.getProviderName() === provider);
+            if (!providerMeta) {
+                throw new Error(`Provider ${provider} not found in router`);
+            }
+            return providerMeta.instance.getRamp(id);
+        }
+        let lastError = null;
+        for (const providerMeta of this.providers) {
+            try {
+                return await providerMeta.instance.getRamp(id);
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        throw new Error(`Ramp ${id} not found in any provider: ${lastError?.message || 'Unknown error'}`);
+    }
+    filterProviders(params) {
+        return this.providers.filter(p => {
+            const caps = p.instance.getCapabilities();
+            if (!this.allowExperimental && caps.experimental === true) {
+                return false;
+            }
+            if (!caps.supportedAssets.includes(params.asset)) {
+                return false;
+            }
+            if (!caps.supportedNetworks.includes(params.network)) {
+                return false;
+            }
+            if (!caps.supportedFiat.includes(params.fiatCurrency)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    orderProviders(providers, direction) {
+        switch (this.strategy) {
+            case 'cheapest':
+                return [...providers].sort((a, b) => {
+                    const capsA = a.instance.getCapabilities();
+                    const capsB = b.instance.getCapabilities();
+                    const feeA = direction === 'on' ? capsA.fees.onRampPercent : capsA.fees.offRampPercent;
+                    const feeB = direction === 'on' ? capsB.fees.onRampPercent : capsB.fees.offRampPercent;
+                    return feeA - feeB;
+                });
+            case 'priority':
+                return [...providers].sort((a, b) => {
+                    const priorityA = a.priority ?? 0;
+                    const priorityB = b.priority ?? 0;
+                    return priorityB - priorityA;
+                });
+            case 'round-robin': {
+                const idx = this.rrIndex;
+                this.rrIndex = (this.rrIndex + 1) % providers.length;
+                return [...providers.slice(idx), ...providers.slice(0, idx)];
+            }
+            default:
+                return providers;
+        }
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.CryptoRampRouter = CryptoRampRouter;

package/dist/crypto/types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Crypto on/off-ramp types
+ */
+import { Customer, Currency } from '../types';
+import { RoutingMeta } from '../routing-types';
+export type CryptoAsset = 'BTC' | 'ETH' | 'USDT' | 'USDC' | 'BNB' | 'SOL' | string;
+export type CryptoNetwork = 'BTC' | 'ETH' | 'TRON' | 'POLYGON' | 'BSC' | 'SOLANA' | string;
+export type RampDirection = 'on' | 'off';
+export type RampStatus = 'pending' | 'completed' | 'failed' | 'expired';
+export interface OnRampParams {
+    fiatAmount: number;
+    fiatCurrency: Currency;
+    asset: CryptoAsset;
+    network: CryptoNetwork;
+    destinationWallet: string;
+    customer: Customer;
+    urls: {
+        success: string;
+        cancel: string;
+        webhook: string;
+    };
+    reference: string;
+    metadata?: Record<string, any>;
+}
+export interface BankAccount {
+    accountNumber: string;
+    branchCode: string;
+    accountHolder: string;
+    bankName: string;
+}
+export interface OffRampParams {
+    cryptoAmount: number;
+    asset: CryptoAsset;
+    network: CryptoNetwork;
+    sourceWallet?: string;
+    fiatCurrency: Currency;
+    bankAccount: BankAccount;
+    customer: Customer;
+    urls?: {
+        success: string;
+        cancel: string;
+        webhook: string;
+    };
+    reference: string;
+    metadata?: Record<string, any>;
+}
+export interface RampQuote {
+    fiatAmount: number;
+    cryptoAmount: number;
+    rate: number;
+    feeFixed: number;
+    feePercent: number;
+    feeTotal: number;
+    expiresAt: string;
+}
+export interface RampResult {
+    id: string;
+    direction: RampDirection;
+    status: RampStatus;
+    quote: RampQuote;
+    checkoutUrl?: string;
+    depositAddress?: string;
+    depositTag?: string;
+    txHash?: string;
+    createdAt: string;
+    expiresAt?: string;
+    raw?: any;
+    routingMeta?: RoutingMeta;
+}
+export interface CryptoRampCapabilities {
+    supportedAssets: CryptoAsset[];
+    supportedNetworks: CryptoNetwork[];
+    supportedFiat: Currency[];
+    country: string;
+    kycRequired: boolean;
+    onRampLimits?: {
+        min: number;
+        max: number;
+    };
+    offRampLimits?: {
+        min: number;
+        max: number;
+    };
+    fees: {
+        onRampPercent: number;
+        offRampPercent: number;
+    };
+    experimental?: boolean;
+}

package/dist/crypto/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Crypto on/off-ramp types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });