paybridge 0.1.2 → 0.2.1

package/dist/providers/stripe.js

@@ -0,0 +1,370 @@
+"use strict";
+/**
+ * Stripe payment provider
+ * Global payment processor supporting 135+ currencies
+ * @see https://stripe.com/docs/api
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripeProvider = void 0;
+const crypto = __importStar(require("crypto"));
+const base_1 = require("./base");
+const currency_1 = require("../utils/currency");
+class StripeProvider extends base_1.PaymentProvider {
+    constructor(config) {
+        super();
+        this.name = 'stripe';
+        this.supportedCurrencies = ['USD', 'EUR', 'GBP', 'ZAR', 'NGN'];
+        this.baseUrl = 'https://api.stripe.com/v1';
+        this.apiKey = config.apiKey;
+        this.webhookSecret = config.webhookSecret;
+        this.sandbox = config.sandbox ?? this.apiKey.startsWith('sk_test_');
+    }
+    buildFormData(data, prefix = '') {
+        const parts = [];
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined || value === null)
+                continue;
+            const fieldName = prefix ? `${prefix}[${key}]` : key;
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                parts.push(this.buildFormData(value, fieldName));
+            }
+            else {
+                parts.push(`${encodeURIComponent(fieldName)}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        return parts.join('&');
+    }
+    async apiRequest(method, path, data) {
+        const url = `${this.baseUrl}${path}`;
+        const body = data ? this.buildFormData(data) : undefined;
+        const response = await fetch(url, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Stripe API error (${method} ${path}): ${response.status} - ${errorText}`);
+        }
+        return (await response.json());
+    }
+    async createPayment(params) {
+        this.validateCurrency(params.currency);
+        const amountInMinorUnits = (0, currency_1.toMinorUnit)(params.amount, params.currency);
+        const currencyLower = params.currency.toLowerCase();
+        const metadata = {
+            reference: params.reference,
+        };
+        if (params.metadata) {
+            for (const [key, value] of Object.entries(params.metadata)) {
+                metadata[key] = String(value);
+            }
+        }
+        const sessionData = {
+            mode: 'payment',
+            'line_items[0][price_data][currency]': currencyLower,
+            'line_items[0][price_data][unit_amount]': amountInMinorUnits,
+            'line_items[0][price_data][product_data][name]': params.description || params.reference,
+            'line_items[0][quantity]': 1,
+            success_url: params.urls.success,
+            cancel_url: params.urls.cancel,
+            client_reference_id: params.reference,
+            customer_email: params.customer.email,
+        };
+        for (const [key, value] of Object.entries(metadata)) {
+            sessionData[`metadata[${key}]`] = value;
+        }
+        const response = await this.apiRequest('POST', '/checkout/sessions', sessionData);
+        return {
+            id: response.id,
+            checkoutUrl: response.url,
+            status: 'pending',
+            amount: (0, currency_1.toMajorUnit)(response.amount_total || amountInMinorUnits, params.currency),
+            currency: (response.currency || currencyLower).toUpperCase(),
+            reference: response.client_reference_id || params.reference,
+            provider: 'stripe',
+            createdAt: new Date(response.created * 1000).toISOString(),
+            expiresAt: response.expires_at ? new Date(response.expires_at * 1000).toISOString() : undefined,
+            raw: response,
+        };
+    }
+    async createSubscription(params) {
+        this.validateCurrency(params.currency);
+        const amountInMinorUnits = (0, currency_1.toMinorUnit)(params.amount, params.currency);
+        const currencyLower = params.currency.toLowerCase();
+        const intervalMap = {
+            weekly: 'week',
+            monthly: 'month',
+            yearly: 'year',
+        };
+        const stripeInterval = intervalMap[params.interval];
+        const metadata = {
+            reference: params.reference,
+        };
+        if (params.metadata) {
+            for (const [key, value] of Object.entries(params.metadata)) {
+                metadata[key] = String(value);
+            }
+        }
+        const sessionData = {
+            mode: 'subscription',
+            'line_items[0][price_data][currency]': currencyLower,
+            'line_items[0][price_data][unit_amount]': amountInMinorUnits,
+            'line_items[0][price_data][recurring][interval]': stripeInterval,
+            'line_items[0][price_data][product_data][name]': params.description || params.reference,
+            'line_items[0][quantity]': 1,
+            success_url: params.urls.success,
+            cancel_url: params.urls.cancel,
+            client_reference_id: params.reference,
+            customer_email: params.customer.email,
+        };
+        for (const [key, value] of Object.entries(metadata)) {
+            sessionData[`metadata[${key}]`] = value;
+        }
+        const response = await this.apiRequest('POST', '/checkout/sessions', sessionData);
+        return {
+            id: response.id,
+            checkoutUrl: response.url,
+            status: 'pending',
+            amount: (0, currency_1.toMajorUnit)(response.amount_total || amountInMinorUnits, params.currency),
+            currency: (response.currency || currencyLower).toUpperCase(),
+            interval: params.interval,
+            reference: response.client_reference_id || params.reference,
+            provider: 'stripe',
+            startsAt: params.startDate,
+            createdAt: new Date(response.created * 1000).toISOString(),
+            raw: response,
+        };
+    }
+    async getPayment(id) {
+        const session = await this.apiRequest('GET', `/checkout/sessions/${id}`);
+        let status = 'pending';
+        if (session.payment_status === 'paid') {
+            status = 'completed';
+        }
+        else if (session.payment_status === 'unpaid' && session.status === 'open') {
+            status = 'pending';
+        }
+        else if (session.status === 'expired') {
+            status = 'failed';
+        }
+        const currency = (session.currency || 'USD').toUpperCase();
+        return {
+            id: session.id,
+            checkoutUrl: session.url || '',
+            status,
+            amount: (0, currency_1.toMajorUnit)(session.amount_total || 0, currency),
+            currency,
+            reference: session.client_reference_id || session.id,
+            provider: 'stripe',
+            createdAt: new Date(session.created * 1000).toISOString(),
+            expiresAt: session.expires_at ? new Date(session.expires_at * 1000).toISOString() : undefined,
+            raw: session,
+        };
+    }
+    async refund(params) {
+        let paymentIntentId;
+        if (params.paymentId.startsWith('cs_')) {
+            const session = await this.apiRequest('GET', `/checkout/sessions/${params.paymentId}`);
+            paymentIntentId = session.payment_intent;
+            if (!paymentIntentId) {
+                throw new Error('Session has no payment_intent - payment may not be completed yet');
+            }
+        }
+        else {
+            paymentIntentId = params.paymentId;
+        }
+        const refundData = {
+            payment_intent: paymentIntentId,
+        };
+        if (params.amount !== undefined) {
+            refundData.amount = (0, currency_1.toMinorUnit)(params.amount, 'USD');
+        }
+        if (params.reason) {
+            refundData.reason = 'requested_by_customer';
+            refundData['metadata[reason]'] = params.reason;
+        }
+        const response = await this.apiRequest('POST', '/refunds', refundData);
+        const currency = (response.currency || 'USD').toUpperCase();
+        return {
+            id: response.id,
+            status: response.status === 'succeeded' ? 'completed' : 'pending',
+            amount: (0, currency_1.toMajorUnit)(response.amount || 0, currency),
+            currency,
+            paymentId: params.paymentId,
+            createdAt: new Date(response.created * 1000).toISOString(),
+            raw: response,
+        };
+    }
+    parseWebhook(body, _headers) {
+        const event = typeof body === 'string' ? JSON.parse(body) : body;
+        const typeMap = {
+            'checkout.session.completed': 'payment.completed',
+            'checkout.session.expired': 'payment.cancelled',
+            'checkout.session.async_payment_failed': 'payment.failed',
+            'payment_intent.succeeded': 'payment.completed',
+            'payment_intent.payment_failed': 'payment.failed',
+            'charge.refunded': 'refund.completed',
+            'customer.subscription.created': 'subscription.created',
+            'customer.subscription.deleted': 'subscription.cancelled',
+        };
+        const eventType = typeMap[event.type] || 'payment.pending';
+        const data = event.data?.object || {};
+        let payment;
+        let subscription;
+        let refund;
+        if (event.type.startsWith('checkout.session') || event.type.startsWith('payment_intent')) {
+            const currency = (data.currency || 'USD').toUpperCase();
+            let status = 'pending';
+            if (data.payment_status === 'paid' || data.status === 'succeeded') {
+                status = 'completed';
+            }
+            else if (data.status === 'expired') {
+                status = 'failed';
+            }
+            else if (event.type.includes('failed')) {
+                status = 'failed';
+            }
+            payment = {
+                id: data.id,
+                checkoutUrl: data.url || '',
+                status,
+                amount: (0, currency_1.toMajorUnit)(data.amount_total || data.amount || 0, currency),
+                currency,
+                reference: data.client_reference_id || data.id,
+                provider: 'stripe',
+                createdAt: new Date((data.created || Date.now() / 1000) * 1000).toISOString(),
+            };
+        }
+        else if (event.type.startsWith('customer.subscription')) {
+            const currency = (data.currency || 'USD').toUpperCase();
+            subscription = {
+                id: data.id,
+                checkoutUrl: '',
+                status: event.type.includes('deleted') ? 'cancelled' : 'active',
+                amount: (0, currency_1.toMajorUnit)(data.plan?.amount || 0, currency),
+                currency,
+                interval: 'monthly',
+                reference: data.metadata?.reference || data.id,
+                provider: 'stripe',
+                createdAt: new Date((data.created || Date.now() / 1000) * 1000).toISOString(),
+            };
+        }
+        else if (event.type === 'charge.refunded') {
+            const currency = (data.currency || 'USD').toUpperCase();
+            refund = {
+                id: data.refunds?.data?.[0]?.id || data.id,
+                status: 'completed',
+                amount: (0, currency_1.toMajorUnit)(data.amount_refunded || 0, currency),
+                currency,
+                paymentId: data.payment_intent || data.id,
+                createdAt: new Date((data.created || Date.now() / 1000) * 1000).toISOString(),
+            };
+        }
+        return {
+            type: eventType,
+            payment,
+            subscription,
+            refund,
+            raw: event,
+        };
+    }
+    /**
+     * Verify webhook signature using Stripe's scheme.
+     *
+     * CRITICAL: body must be the raw string or Buffer from the webhook request.
+     * Passing a parsed JSON object will cause signature verification to fail.
+     */
+    verifyWebhook(body, headers) {
+        if (!this.webhookSecret) {
+            return false;
+        }
+        const signature = headers?.['stripe-signature'] || headers?.['Stripe-Signature'];
+        if (!signature) {
+            return false;
+        }
+        const parts = signature.split(',').reduce((acc, part) => {
+            const [key, value] = part.split('=');
+            if (key && value) {
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
+        const timestamp = parts.t;
+        const expectedSig = parts.v1;
+        if (!timestamp || !expectedSig) {
+            return false;
+        }
+        const timestampNum = parseInt(timestamp, 10);
+        const now = Math.floor(Date.now() / 1000);
+        if (now - timestampNum > 300) {
+            return false;
+        }
+        const rawBody = typeof body === 'string' ? body : body.toString('utf8');
+        const signedPayload = `${timestamp}.${rawBody}`;
+        const computedSig = crypto
+            .createHmac('sha256', this.webhookSecret)
+            .update(signedPayload)
+            .digest('hex');
+        try {
+            const computedBuffer = Buffer.from(computedSig, 'hex');
+            const expectedBuffer = Buffer.from(expectedSig, 'hex');
+            if (computedBuffer.length !== expectedBuffer.length) {
+                return false;
+            }
+            return crypto.timingSafeEqual(computedBuffer, expectedBuffer);
+        }
+        catch {
+            return false;
+        }
+    }
+    getCapabilities() {
+        return {
+            fees: {
+                fixed: 0.30,
+                percent: 2.9,
+                currency: 'USD',
+            },
+            currencies: this.supportedCurrencies,
+            country: 'GLOBAL',
+            avgLatencyMs: 400,
+        };
+    }
+}
+exports.StripeProvider = StripeProvider;

package/dist/providers/yoco.d.ts

@@ -5,6 +5,7 @@
  */
 import { PaymentProvider } from './base';
 import { CreatePaymentParams, PaymentResult, CreateSubscriptionParams, SubscriptionResult, RefundParams, RefundResult, WebhookEvent } from '../types';
+import { ProviderCapabilities } from '../routing-types';
 interface YocoConfig {
     apiKey: string;
     sandbox: boolean;
@@ -19,11 +20,22 @@ export declare class YocoProvider extends PaymentProvider {
     private webhookSecret?;
     constructor(config: YocoConfig);
     createPayment(params: CreatePaymentParams): Promise<PaymentResult>;
+    /**
+     * Yoco does not support subscriptions in the standard Online Payments API.
+     * Use the Yoco Recurring Billing API directly or choose another provider.
+     */
     createSubscription(params: CreateSubscriptionParams): Promise<SubscriptionResult>;
     getPayment(id: string): Promise<PaymentResult>;
     refund(params: RefundParams): Promise<RefundResult>;
     parseWebhook(body: any, _headers?: any): WebhookEvent;
+    /**
+     * Verify webhook signature using Yoco's Svix-based signing scheme.
+     *
+     * CRITICAL: body must be the raw string or Buffer from the webhook request.
+     * Passing a parsed JSON object will cause signature verification to fail.
+     */
     verifyWebhook(body: string | Buffer, headers?: any): boolean;
+    getCapabilities(): ProviderCapabilities;
     private mapYocoStatus;
     private mapYocoEventType;
 }

package/dist/providers/yoco.js

@@ -26,18 +26,6 @@ class YocoProvider extends base_1.PaymentProvider {
     // ==================== Payment Methods ====================
     async createPayment(params) {
         this.validateCurrency(params.currency);
-        // TODO: Implement Yoco checkout creation
-        // POST /v1/checkouts
-        // Amount must be in CENTS (minor unit)
-        // Auth: Bearer {secret_key}
-        // Body: {
-        //   amount: 29900, // cents
-        //   currency: "ZAR",
-        //   cancelUrl: "...",
-        //   successUrl: "...",
-        //   failureUrl: "...",
-        //   metadata: { ... }
-        // }
         const amountInCents = (0, currency_1.toMinorUnit)(params.amount, params.currency);
         const requestBody = {
             amount: amountInCents,
@@ -47,59 +35,111 @@ class YocoProvider extends base_1.PaymentProvider {
             failureUrl: params.urls.cancel,
             metadata: {
                 reference: params.reference,
-                description: params.description,
+                description: params.description || '',
                 customerName: params.customer.name,
                 customerEmail: params.customer.email,
                 ...params.metadata,
             },
         };
-        // TODO: Make actual API request
-        console.warn('[PayBridge:Yoco] createPayment not yet implemented:', requestBody);
-        throw new Error('Yoco provider not yet fully implemented. Coming soon!');
+        const response = await fetch(`${this.baseUrl}/checkouts`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+                'Idempotency-Key': crypto_1.default.randomUUID(),
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Yoco API error (POST /checkouts): ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        return {
+            id: data.id,
+            checkoutUrl: data.redirectUrl,
+            status: this.mapYocoStatus(data.status),
+            amount: (0, currency_1.toMajorUnit)(data.amount, params.currency),
+            currency: data.currency,
+            reference: data.metadata?.reference || params.reference,
+            provider: 'yoco',
+            createdAt: new Date().toISOString(),
+            raw: data,
+        };
     }
+    /**
+     * Yoco does not support subscriptions in the standard Online Payments API.
+     * Use the Yoco Recurring Billing API directly or choose another provider.
+     */
     async createSubscription(params) {
         this.validateCurrency(params.currency);
-        // TODO: Implement Yoco subscription creation
-        // Yoco may not support subscriptions directly - need to check their API
-        // May need to implement via recurring charges or use Yoco recurring billing
-        console.warn('[PayBridge:Yoco] createSubscription not yet implemented');
-        throw new Error('Yoco subscriptions not yet implemented. Coming soon!');
+        throw new Error('Yoco does not support subscriptions. Use the Yoco Recurring Billing API directly or choose another provider.');
     }
     async getPayment(id) {
-        // TODO: Implement Yoco payment status check
-        // GET /v1/checkouts/{id}
-        // Auth: Bearer {secret_key}
-        console.warn('[PayBridge:Yoco] getPayment not yet implemented:', id);
-        throw new Error('Yoco getPayment not yet implemented. Coming soon!');
+        const response = await fetch(`${this.baseUrl}/checkouts/${id}`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Yoco API error (GET /checkouts/${id}): ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        return {
+            id: data.id,
+            checkoutUrl: data.redirectUrl || '',
+            status: this.mapYocoStatus(data.status),
+            amount: (0, currency_1.toMajorUnit)(data.amount, 'ZAR'),
+            currency: data.currency,
+            reference: data.metadata?.reference || id,
+            provider: 'yoco',
+            createdAt: new Date().toISOString(),
+            raw: data,
+        };
     }
     async refund(params) {
-        // TODO: Implement Yoco refund
-        // POST /v1/refunds
-        // Amount in CENTS
-        // Auth: Bearer {secret_key}
-        // Body: {
-        //   paymentId: "...",
-        //   amount: 29900 // cents, optional for partial refund
-        // }
-        const amountInCents = params.amount ? (0, currency_1.toMinorUnit)(params.amount, 'ZAR') : undefined;
-        console.warn('[PayBridge:Yoco] refund not yet implemented:', { ...params, amountInCents });
-        throw new Error('Yoco refunds not yet implemented. Coming soon!');
+        const requestBody = {
+            checkoutId: params.paymentId,
+        };
+        if (params.amount !== undefined) {
+            requestBody.amount = (0, currency_1.toMinorUnit)(params.amount, 'ZAR');
+        }
+        if (params.reason) {
+            requestBody.metadata = { reason: params.reason };
+        }
+        const response = await fetch(`${this.baseUrl}/refunds`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+                'Idempotency-Key': crypto_1.default.randomUUID(),
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Yoco API error (POST /refunds): ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        const status = this.mapYocoStatus(data.status);
+        const refundStatus = status === 'completed' ? 'completed' :
+            status === 'failed' ? 'failed' : 'pending';
+        return {
+            id: data.id,
+            status: refundStatus,
+            amount: (0, currency_1.toMajorUnit)(data.amount, 'ZAR'),
+            currency: data.currency,
+            paymentId: params.paymentId,
+            createdAt: new Date().toISOString(),
+            raw: data,
+        };
     }
     // ==================== Webhooks ====================
     parseWebhook(body, _headers) {
         const event = typeof body === 'string' ? JSON.parse(body) : body;
-        // TODO: Map Yoco webhook structure to PayBridge WebhookEvent
-        // Yoco webhook payload structure:
-        // {
-        //   type: "payment.succeeded" | "payment.failed" | "payment.refunded",
-        //   payload: {
-        //     id: "...",
-        //     amount: 29900, // cents
-        //     currency: "ZAR",
-        //     status: "succeeded" | "failed" | "refunded",
-        //     metadata: { ... }
-        //   }
-        // }
         const yocoStatus = event.payload?.status || event.status;
         const status = this.mapYocoStatus(yocoStatus);
         const eventType = this.mapYocoEventType(event.type);
@@ -118,29 +158,85 @@ class YocoProvider extends base_1.PaymentProvider {
             raw: event,
         };
     }
+    /**
+     * Verify webhook signature using Yoco's Svix-based signing scheme.
+     *
+     * CRITICAL: body must be the raw string or Buffer from the webhook request.
+     * Passing a parsed JSON object will cause signature verification to fail.
+     */
     verifyWebhook(body, headers) {
-        const signature = headers?.['x-yoco-signature'] || headers?.signature;
-        if (!signature || !this.webhookSecret) {
-            // No signature validation configured
-            return true;
+        if (!this.webhookSecret) {
+            return false;
+        }
+        const webhookId = headers?.['webhook-id'];
+        const webhookTimestamp = headers?.['webhook-timestamp'];
+        const webhookSignature = headers?.['webhook-signature'];
+        if (!webhookId || !webhookTimestamp || !webhookSignature) {
+            return false;
+        }
+        const timestamp = parseInt(webhookTimestamp, 10);
+        const now = Math.floor(Date.now() / 1000);
+        if (now - timestamp > 300) {
+            return false;
+        }
+        const rawBody = typeof body === 'string' ? body : body.toString('utf8');
+        const signedPayload = `${webhookId}.${webhookTimestamp}.${rawBody}`;
+        let secretBytes;
+        if (this.webhookSecret.startsWith('whsec_')) {
+            secretBytes = Buffer.from(this.webhookSecret.slice(6), 'base64');
+        }
+        else {
+            secretBytes = Buffer.from(this.webhookSecret, 'utf8');
+        }
+        const computedSig = crypto_1.default
+            .createHmac('sha256', secretBytes)
+            .update(signedPayload, 'utf8')
+            .digest('base64');
+        const signatures = webhookSignature.split(' ');
+        for (const sig of signatures) {
+            const [version, expectedSig] = sig.split(',');
+            if (version === 'v1') {
+                try {
+                    const computedBuffer = Buffer.from(computedSig, 'base64');
+                    const expectedBuffer = Buffer.from(expectedSig, 'base64');
+                    if (computedBuffer.length === expectedBuffer.length) {
+                        if (crypto_1.default.timingSafeEqual(computedBuffer, expectedBuffer)) {
+                            return true;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
         }
-        // TODO: Implement Yoco signature validation
-        // Yoco uses HMAC-SHA256 with X-Yoco-Signature header
-        const expectedSignature = crypto_1.default
-            .createHmac('sha256', this.webhookSecret)
-            .update(body)
-            .digest('hex');
-        return signature === expectedSignature;
+        return false;
+    }
+    // ==================== Capabilities ====================
+    getCapabilities() {
+        return {
+            fees: {
+                fixed: 0,
+                percent: 2.95,
+                currency: 'ZAR',
+            },
+            currencies: this.supportedCurrencies,
+            country: 'ZA',
+            avgLatencyMs: 500,
+        };
     }
     // ==================== Helpers ====================
     mapYocoStatus(yocoStatus) {
         const statusMap = {
+            created: 'pending',
+            pending: 'pending',
+            processing: 'pending',
+            completed: 'completed',
             succeeded: 'completed',
             successful: 'completed',
             failed: 'failed',
             cancelled: 'cancelled',
             refunded: 'refunded',
-            pending: 'pending',
         };
         return statusMap[yocoStatus?.toLowerCase()] || 'pending';
     }
@@ -151,6 +247,8 @@ class YocoProvider extends base_1.PaymentProvider {
             'payment.failed': 'payment.failed',
             'payment.cancelled': 'payment.cancelled',
             'payment.refunded': 'refund.completed',
+            'refund.succeeded': 'refund.completed',
+            'refund.failed': 'payment.failed',
         };
         return typeMap[yocoType] || 'payment.pending';
     }