paybridge 0.5.0 → 0.7.0

package/dist/cli/runners.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runners = void 0;
+const index_1 = require("../index");
+const crypto_1 = require("../crypto");
+const timestamp = Date.now();
+const testCustomer = {
+    name: 'Test User',
+    email: 'test@example.com',
+    phone: '0825551234',
+};
+const testUrls = {
+    success: 'https://example.com/success',
+    cancel: 'https://example.com/cancel',
+    webhook: 'https://example.com/webhook',
+};
+exports.runners = [
+    {
+        name: 'softycomp',
+        envRequired: ['SOFTYCOMP_API_KEY', 'SOFTYCOMP_SECRET_KEY'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'softycomp',
+                credentials: {
+                    apiKey: process.env.SOFTYCOMP_API_KEY,
+                    secretKey: process.env.SOFTYCOMP_SECRET_KEY,
+                },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'ZAR',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'yoco',
+        envRequired: ['YOCO_API_KEY'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'yoco',
+                credentials: { apiKey: process.env.YOCO_API_KEY },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'ZAR',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'ozow',
+        envRequired: ['OZOW_API_KEY', 'OZOW_SITE_CODE', 'OZOW_PRIVATE_KEY'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'ozow',
+                credentials: {
+                    apiKey: process.env.OZOW_API_KEY,
+                    siteCode: process.env.OZOW_SITE_CODE,
+                    privateKey: process.env.OZOW_PRIVATE_KEY,
+                },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'ZAR',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'payfast',
+        envRequired: ['PAYFAST_MERCHANT_ID', 'PAYFAST_MERCHANT_KEY'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'payfast',
+                credentials: {
+                    merchantId: process.env.PAYFAST_MERCHANT_ID,
+                    merchantKey: process.env.PAYFAST_MERCHANT_KEY,
+                    passphrase: process.env.PAYFAST_PASSPHRASE,
+                },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'ZAR',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'paystack',
+        envRequired: ['PAYSTACK_API_KEY'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'paystack',
+                credentials: { apiKey: process.env.PAYSTACK_API_KEY },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'NGN',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'stripe',
+        envRequired: ['STRIPE_API_KEY'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'stripe',
+                credentials: { apiKey: process.env.STRIPE_API_KEY },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'USD',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'peach',
+        envRequired: ['PEACH_ACCESS_TOKEN', 'PEACH_ENTITY_ID'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'peach',
+                credentials: {
+                    apiKey: process.env.PEACH_ACCESS_TOKEN,
+                    secretKey: process.env.PEACH_ENTITY_ID,
+                },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'ZAR',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'flutterwave',
+        envRequired: ['FLUTTERWAVE_API_KEY'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'flutterwave',
+                credentials: { apiKey: process.env.FLUTTERWAVE_API_KEY },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'NGN',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'adyen',
+        envRequired: ['ADYEN_API_KEY', 'ADYEN_MERCHANT_ACCOUNT'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'adyen',
+                credentials: {
+                    apiKey: process.env.ADYEN_API_KEY,
+                    merchantAccount: process.env.ADYEN_MERCHANT_ACCOUNT,
+                },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'EUR',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'mercadopago',
+        envRequired: ['MERCADOPAGO_ACCESS_TOKEN'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'mercadopago',
+                credentials: { apiKey: process.env.MERCADOPAGO_ACCESS_TOKEN },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'BRL',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'razorpay',
+        envRequired: ['RAZORPAY_KEY_ID', 'RAZORPAY_KEY_SECRET'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'razorpay',
+                credentials: {
+                    apiKey: process.env.RAZORPAY_KEY_ID,
+                    secretKey: process.env.RAZORPAY_KEY_SECRET,
+                },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'INR',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'mollie',
+        envRequired: ['MOLLIE_API_KEY'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'mollie',
+                credentials: { apiKey: process.env.MOLLIE_API_KEY },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'EUR',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'square',
+        envRequired: ['SQUARE_ACCESS_TOKEN', 'SQUARE_LOCATION_ID'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'square',
+                credentials: {
+                    apiKey: process.env.SQUARE_ACCESS_TOKEN,
+                    locationId: process.env.SQUARE_LOCATION_ID,
+                },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'USD',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'pesapal',
+        envRequired: ['PESAPAL_CONSUMER_KEY', 'PESAPAL_CONSUMER_SECRET'],
+        run: async () => {
+            const pay = new index_1.PayBridge({
+                provider: 'pesapal',
+                credentials: {
+                    apiKey: process.env.PESAPAL_CONSUMER_KEY,
+                    secretKey: process.env.PESAPAL_CONSUMER_SECRET,
+                },
+                sandbox: true,
+            });
+            const payment = await pay.createPayment({
+                amount: 1.0,
+                currency: 'KES',
+                reference: `cli-test-${timestamp}`,
+                customer: testCustomer,
+                urls: testUrls,
+            });
+            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+        },
+    },
+    {
+        name: 'moonpay',
+        envRequired: ['MOONPAY_API_KEY', 'MOONPAY_SECRET_KEY'],
+        run: async () => {
+            const ramp = new crypto_1.CryptoRamp({
+                provider: 'moonpay',
+                credentials: {
+                    apiKey: process.env.MOONPAY_API_KEY,
+                    secretKey: process.env.MOONPAY_SECRET_KEY,
+                },
+                sandbox: true,
+            });
+            const result = await ramp.createOnRamp({
+                fiatAmount: 1.0,
+                fiatCurrency: 'USD',
+                asset: 'BTC',
+                network: 'BTC',
+                destinationWallet: '1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa',
+                customer: testCustomer,
+                urls: testUrls,
+                reference: `cli-test-${timestamp}`,
+            });
+            return { id: result.id, checkoutUrl: result.checkoutUrl, status: result.status };
+        },
+    },
+];

package/dist/cli/utils.d.ts

@@ -0,0 +1,16 @@
+export declare const colors: {
+    reset: string;
+    bright: string;
+    dim: string;
+    green: string;
+    yellow: string;
+    red: string;
+    cyan: string;
+};
+export declare function colorize(text: string, color: keyof typeof colors): string;
+export declare function padEnd(str: string, length: number): string;
+export declare function formatTable(rows: string[][], padding?: number): string;
+export declare function readStdin(): Promise<string>;
+export declare function parseHeaders(headerFlags: string[]): Record<string, string>;
+export declare function printHelp(toStderr?: boolean): void;
+export declare function printVersion(): void;

package/dist/cli/utils.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+exports.colorize = colorize;
+exports.padEnd = padEnd;
+exports.formatTable = formatTable;
+exports.readStdin = readStdin;
+exports.parseHeaders = parseHeaders;
+exports.printHelp = printHelp;
+exports.printVersion = printVersion;
+exports.colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+};
+function colorize(text, color) {
+    return `${exports.colors[color]}${text}${exports.colors.reset}`;
+}
+function padEnd(str, length) {
+    while (str.length < length) {
+        str += ' ';
+    }
+    return str;
+}
+function formatTable(rows, padding = 2) {
+    if (rows.length === 0)
+        return '';
+    const colWidths = [];
+    for (const row of rows) {
+        row.forEach((cell, i) => {
+            colWidths[i] = Math.max(colWidths[i] || 0, cell.length);
+        });
+    }
+    return rows
+        .map((row) => row.map((cell, i) => padEnd(cell, colWidths[i])).join(' '.repeat(padding)))
+        .join('\n');
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function parseHeaders(headerFlags) {
+    const headers = {};
+    for (const flag of headerFlags) {
+        const [key, ...valueParts] = flag.split('=');
+        if (key && valueParts.length > 0) {
+            headers[key.trim()] = valueParts.join('=').trim();
+        }
+    }
+    return headers;
+}
+function printHelp(toStderr = false) {
+    const output = `
+paybridge — unified payment SDK CLI
+
+USAGE
+  paybridge <command> [options]
+
+COMMANDS
+  test <provider>         Run sandbox createPayment validation for a provider
+  test --all              Run validation for every provider with env vars set
+  providers [--json]      List all providers with capabilities (table or JSON)
+  webhook verify <p>      Verify webhook signature (raw body from stdin)
+  webhook parse <p>       Parse webhook event (raw body from stdin)
+  quote <p> [opts]        Get a crypto on/off-ramp quote
+  help, -h, --help        Print this help
+  version, -v             Print version
+
+PROVIDER ENV VARS
+  See SETUP.md or run 'paybridge test --all' for the full list.
+
+EXAMPLES
+  paybridge providers
+  paybridge test stripe
+  STRIPE_API_KEY=sk_test_... paybridge test stripe
+  echo '{"id":"evt_x"}' | paybridge webhook parse paystack \\
+    --header x-paystack-signature=abc
+
+Docs: https://github.com/kobie3717/paybridge
+`.trim();
+    if (toStderr) {
+        console.error(output);
+    }
+    else {
+        console.log(output);
+    }
+}
+function printVersion() {
+    const pkg = require('../../package.json');
+    console.log(`paybridge v${pkg.version}`);
+}

package/dist/crypto/index.d.ts

@@ -8,8 +8,10 @@ export * from './base';
 export * from './moonpay';
 export * from './yellowcard';
 export * from './mock';
+export * from './transak';
+export * from './ramp';
 export * from './router';
-export type CryptoProvider = 'moonpay' | 'yellowcard' | 'mock';
+export type CryptoProvider = 'moonpay' | 'yellowcard' | 'mock' | 'transak' | 'ramp';
 export interface CryptoRampConfig {
     provider: CryptoProvider;
     credentials: {

package/dist/crypto/index.js

@@ -21,11 +21,15 @@ exports.CryptoRamp = void 0;
 const moonpay_1 = require("./moonpay");
 const yellowcard_1 = require("./yellowcard");
 const mock_1 = require("./mock");
+const transak_1 = require("./transak");
+const ramp_1 = require("./ramp");
 __exportStar(require("./types"), exports);
 __exportStar(require("./base"), exports);
 __exportStar(require("./moonpay"), exports);
 __exportStar(require("./yellowcard"), exports);
 __exportStar(require("./mock"), exports);
+__exportStar(require("./transak"), exports);
+__exportStar(require("./ramp"), exports);
 __exportStar(require("./router"), exports);
 class CryptoRamp {
     constructor(config) {
@@ -59,6 +63,25 @@ class CryptoRamp {
                     sandbox,
                     webhookSecret,
                 });
+            case 'transak':
+                if (!credentials.apiKey || !credentials.secretKey) {
+                    throw new Error('Transak requires apiKey and secretKey');
+                }
+                return new transak_1.TransakProvider({
+                    apiKey: credentials.apiKey,
+                    apiSecret: credentials.secretKey,
+                    sandbox,
+                    webhookSecret,
+                });
+            case 'ramp':
+                if (!credentials.apiKey) {
+                    throw new Error('Ramp Network requires apiKey (hostApiKey)');
+                }
+                return new ramp_1.RampProvider({
+                    hostApiKey: credentials.apiKey,
+                    webhookSecret,
+                    sandbox,
+                });
             case 'mock':
                 return new mock_1.MockCryptoRampProvider();
             default:

package/dist/crypto/ramp.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Ramp Network crypto on/off-ramp provider
+ * @see https://docs.ramp.network/
+ */
+import { CryptoRampProvider } from './base';
+import { OnRampParams, OffRampParams, RampQuote, RampResult, CryptoRampCapabilities } from './types';
+interface RampConfig {
+    hostApiKey: string;
+    webhookSecret?: string;
+    sandbox: boolean;
+}
+export declare class RampProvider extends CryptoRampProvider {
+    readonly name = "ramp";
+    private hostApiKey;
+    private webhookSecret?;
+    private sandbox;
+    private widgetUrl;
+    private apiUrl;
+    constructor(config: RampConfig);
+    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;
+    /**
+     * Ramp Network webhook verification (HMAC placeholder).
+     *
+     * TODO(verify): Ramp Network uses ECDSA secp256k1 for webhook signatures.
+     * This implementation uses HMAC-SHA256 as a placeholder. Production deployments
+     * should implement ECDSA verification using Ramp's public key.
+     */
+    verifyWebhook(body: string | Buffer, headers?: any): boolean;
+    getCapabilities(): CryptoRampCapabilities;
+    private mapRampStatus;
+}
+export {};