@funnelfox/billing 0.8.0-beta.3 → 0.8.0-ffb-395.4

package/dist/chunk-index.es.js

@@ -489,7 +489,7 @@ var PaymentMethod;
 /**
  * @fileoverview Constants for Funnefox SDK
  */
-const SDK_VERSION = '0.8.0-beta.3';
+const SDK_VERSION = '0.9.0-beta.1';
 const DEFAULTS = {
     BASE_URL: 'https://billing.funnelfox.com',
     REGION: 'default',
@@ -528,6 +528,7 @@ const API_ENDPOINTS = {
     UPDATE_CLIENT_SESSION: '/v1/checkout/update_client_session',
     CREATE_PAYMENT: '/v1/checkout/create_payment',
     RESUME_PAYMENT: '/v1/checkout/resume_payment',
+    STRIPE_CREATE_PAYMENT: '/v1/stripe/create_payment',
     ONE_CLICK: '/v1/checkout/one_click',
     CREATE_SIMPLE_CLIENT_SESSION: '/v1/checkout/create_simple_client_session',
 };
@@ -1057,6 +1058,9 @@ class PrimerWrapper {
         }
         return element;
     }
+    refreshClientSession() {
+        return this.currentHeadless?.then(headless => headless.refreshClientSession());
+    }
 }
 PrimerWrapper.headlessManager = new HeadlessManager();
 
@@ -1123,7 +1127,7 @@ class APIClient {
     async createClientSession(params) {
         const payload = {
             region: params.region || 'default',
-            integration_type: 'primer',
+            integration_type: params.integration ?? 'primer',
             pp_ident: params.priceId,
             external_id: params.externalId,
             email_address: params.email,
@@ -1169,6 +1173,15 @@ class APIClient {
             body: JSON.stringify(payload),
         }));
     }
+    async createStripePayment(params) {
+        return (await this.request(API_ENDPOINTS.STRIPE_CREATE_PAYMENT, {
+            method: 'POST',
+            body: JSON.stringify({
+                order_id: params.orderId,
+                payment_method_id: params.paymentMethodId,
+            }),
+        }));
+    }
     async resumePayment(params) {
         const payload = {
             order_id: params.orderId,
@@ -1259,6 +1272,45 @@ class APIClient {
     }
 }
 
+class SessionService {
+    constructor() {
+        this.cache = new Map();
+    }
+    buildCacheKey(p) {
+        return [p.orgId, p.priceId, p.externalId, p.email, p.integration].join('-');
+    }
+    makeClient(orgId, baseUrl) {
+        return new APIClient({
+            baseUrl: baseUrl || DEFAULTS.BASE_URL,
+            orgId,
+            timeout: DEFAULTS.REQUEST_TIMEOUT,
+            retryAttempts: DEFAULTS.RETRY_ATTEMPTS,
+        });
+    }
+    createSession(p) {
+        const key = this.buildCacheKey(p);
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        const client = this.makeClient(p.orgId, p.baseUrl);
+        const req = client.createClientSession({
+            priceId: p.priceId,
+            externalId: p.externalId,
+            email: p.email,
+            region: p.region || DEFAULTS.REGION,
+            clientMetadata: p.clientMetadata,
+            countryCode: p.countryCode,
+            integration: p.integration,
+        });
+        this.cache.set(key, req);
+        return req;
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+}
+var sessionService = new SessionService();
+
 var loaderHtml = "<div class=\"ff-sdk-loader-container\">\n  <div class=\"ff-sdk-loader\"></div>\n</div>\n";
 
 if(typeof document!=="undefined")document.head.appendChild(document.createElement("style")).textContent=".ff-sdk-loader-container {\n    position: absolute;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    background-color: rgba(255, 255, 255);\n    z-index: 2;\n}\n\n.ff-sdk-loader {\n    width: 24px;\n    height: 24px;\n    border: 4px solid #e32f41;\n    border-top: 4px solid transparent;\n    border-radius: 50%;\n    animation: spin 1s linear infinite;\n}\n\n@keyframes spin {\n    0% {\n      transform: rotate(0deg);\n    }\n    100% {\n      transform: rotate(360deg);\n    }\n  }";
@@ -1853,6 +1905,12 @@ class CheckoutInstance extends EventEmitter {
         this.cardEmailAddress = this.checkoutConfig.customer.email;
         this.shouldApplySessionCardholderNameConfig =
             this.checkoutConfig.card?.cardholderName?.required === undefined;
+        this.apiClient = new APIClient({
+            baseUrl: this.baseUrl || DEFAULTS.BASE_URL,
+            orgId: this.orgId,
+            timeout: DEFAULTS.REQUEST_TIMEOUT,
+            retryAttempts: DEFAULTS.RETRY_ATTEMPTS,
+        });
         this._setupCallbackBridges();
     }
     _setupCallbackBridges() {
@@ -1894,68 +1952,38 @@ class CheckoutInstance extends EventEmitter {
         }
     }
     async createSession() {
-        this.apiClient = new APIClient({
-            baseUrl: this.baseUrl || DEFAULTS.BASE_URL,
+        const response = await sessionService.createSession({
             orgId: this.orgId,
-            timeout: DEFAULTS.REQUEST_TIMEOUT,
-            retryAttempts: DEFAULTS.RETRY_ATTEMPTS,
-        });
-        const sessionParams = {
+            baseUrl: this.baseUrl,
             priceId: this.checkoutConfig.priceId,
             externalId: this.checkoutConfig.customer.externalId,
             email: this.checkoutConfig.customer.email,
-            region: this.region || DEFAULTS.REGION,
+            region: this.region,
             clientMetadata: this.checkoutConfig.clientMetadata,
             countryCode: this.checkoutConfig.customer.countryCode,
-        };
-        const cacheKey = [
-            this.orgId,
-            this.checkoutConfig.priceId,
-            this.checkoutConfig.customer.externalId,
-            this.checkoutConfig.customer.email,
-        ].join('-');
-        let sessionResponse;
-        // Return cached response if payload hasn't changed
-        const cachedResponse = CheckoutInstance.sessionCache.get(cacheKey);
-        if (cachedResponse) {
-            sessionResponse = await cachedResponse;
-        }
-        else {
-            const sessionRequest = this.apiClient
-                .createClientSession(sessionParams)
-                .then((response) => {
-                const cachedResponse = response;
-                if (response.data?.stripe_public_key) {
-                    const stripePublicKey = response.data.stripe_public_key;
-                    cachedResponse.radarSessionId = loadStripe(stripePublicKey)
-                        .then(stripe => stripe
-                        ? stripe
-                            .createRadarSession()
-                            .then(session => session?.radarSession?.id || '')
-                            .catch(() => '')
-                        : '')
-                        .catch(() => '');
-                }
-                // Initialize Airwallex device fingerprinting if enabled by backend
-                if (response.data?.airwallex_risk_enabled) {
-                    const isLivemode = response.data?.is_livemode;
-                    const deviceId = generateUUID();
-                    cachedResponse.airwallexDeviceId = loadAirwallexDeviceFingerprint(deviceId, isLivemode)
-                        .then(() => deviceId)
-                        .catch(() => {
-                        // Silently fail - return deviceId anyway
-                        return deviceId;
-                    });
-                }
-                return cachedResponse;
-            });
-            // Cache the successful response
-            CheckoutInstance.sessionCache.set(cacheKey, sessionRequest);
-            sessionResponse = await sessionRequest;
+            integration: 'primer',
+        });
+        const sessionResponse = response;
+        if (response.data?.stripe_public_key) {
+            const stripePublicKey = response.data.stripe_public_key;
+            sessionResponse.radarSessionId = loadStripe(stripePublicKey)
+                .then(stripe => stripe
+                ? stripe
+                    .createRadarSession()
+                    .then(session => session?.radarSession?.id || '')
+                    .catch(() => '')
+                : '')
+                .catch(() => '');
+        }
+        if (response.data?.airwallex_risk_enabled) {
+            const isLivemode = response.data?.is_livemode;
+            const deviceId = generateUUID();
+            sessionResponse.airwallexDeviceId = loadAirwallexDeviceFingerprint(deviceId, isLivemode)
+                .then(() => deviceId)
+                .catch(() => deviceId);
         }
         this.cachedSessionResponse = sessionResponse;
-        this.isTelemetryEnabled =
-            !!sessionResponse.data?.sdk_telemetry_enabled || true;
+        this.isTelemetryEnabled = !!sessionResponse.data?.sdk_telemetry_enabled;
         this.isCollectingApplePayEmail =
             !!sessionResponse.data?.collect_apple_pay_email;
         this.applySessionCardFieldConfig(sessionResponse);
@@ -2209,9 +2237,9 @@ class CheckoutInstance extends EventEmitter {
             throw new CheckoutError('Cannot update price while payment is processing');
         }
         try {
+            this.onLoaderChangeWithRace(true);
             this._setState('updating');
-            // Invalidate session cache
-            CheckoutInstance.sessionCache.clear();
+            sessionService.clearCache();
             await this.apiClient.updateClientSession({
                 orderId: this.orderId,
                 clientToken: this.clientToken,
@@ -2219,9 +2247,12 @@ class CheckoutInstance extends EventEmitter {
                 clientMetadata,
             });
             this.checkoutConfig.priceId = newPriceId;
+            await this.primerWrapper.refreshClientSession();
+            this.onLoaderChangeWithRace(false);
             this._setState('ready');
         }
         catch (error) {
+            this.onLoaderChangeWithRace(false);
             this._setState('error');
             this.emit(EVENTS.ERROR, error);
             throw error;
@@ -2241,7 +2272,7 @@ class CheckoutInstance extends EventEmitter {
             return;
         try {
             this.stopUnhandledTelemetry();
-            CheckoutInstance.sessionCache.clear();
+            sessionService.clearCache();
             await this.primerWrapper.destroy();
             this._setState('destroyed');
             this.orderId = null;
@@ -2437,8 +2468,12 @@ class CheckoutInstance extends EventEmitter {
             baseUrl: this.baseUrl,
             enabled: this.isTelemetryEnabled,
             getContext: () => ({
+                checkoutId: this.id,
                 orderId: this.orderId,
                 priceId: this.checkoutConfig.priceId,
+                state: this.state,
+                paymentMethod: this.telemetryPaymentMethod,
+                reqId: this.cachedSessionResponse?.req_id,
             }),
         });
     }
@@ -2448,7 +2483,6 @@ class CheckoutInstance extends EventEmitter {
         this.telemetryPaymentMethod = undefined;
     }
 }
-CheckoutInstance.sessionCache = new Map();
 
 /**
  * @fileoverview Public API with configuration and orchestration logic
@@ -2639,6 +2673,79 @@ async function getAvailablePaymentMethods(params) {
         throw error;
     }
 }
+async function createStripeCardForm(element, params) {
+    const config = resolveConfig(params, 'createStripeCardForm');
+    const [session, { mountStripeCardForm }] = await Promise.all([
+        sessionService.createSession({
+            orgId: config.orgId,
+            baseUrl: config.baseUrl,
+            region: config.region,
+            priceId: params.priceId,
+            externalId: params.externalId,
+            email: params.email,
+            clientMetadata: params.clientMetadata,
+            countryCode: params.countryCode,
+            integration: 'stripe',
+        }),
+        import('./chunk-stripe-card-form.es.js'),
+    ]);
+    const apiClient = new APIClient({
+        orgId: config.orgId,
+        baseUrl: config.baseUrl || DEFAULTS.BASE_URL,
+    });
+    return mountStripeCardForm(element, session, { ...params, apiClient });
+}
+async function purchaseStripeWallet(params) {
+    const config = resolveConfig(params, 'purchaseStripeWallet');
+    const [session, { purchaseWallet }] = await Promise.all([
+        sessionService.createSession({
+            orgId: config.orgId,
+            baseUrl: config.baseUrl,
+            region: config.region,
+            priceId: params.priceId,
+            externalId: params.externalId,
+            email: params.email,
+            clientMetadata: params.clientMetadata,
+            countryCode: params.countryCode,
+            integration: 'stripe',
+        }),
+        import('./chunk-stripe-wallet.es.js'),
+    ]);
+    const apiClient = new APIClient({
+        orgId: config.orgId,
+        baseUrl: config.baseUrl || DEFAULTS.BASE_URL,
+    });
+    return purchaseWallet(session, { ...params, apiClient });
+}
+async function getAvailableStripeWallet(params) {
+    const config = resolveConfig(params, 'getAvailableStripeWallet');
+    const [session, { getAvailableWallet }] = await Promise.all([
+        sessionService.createSession({
+            orgId: config.orgId,
+            baseUrl: config.baseUrl,
+            region: config.region,
+            priceId: params.priceId,
+            externalId: params.externalId,
+            email: params.email,
+            clientMetadata: params.clientMetadata,
+            countryCode: params.countryCode,
+            integration: 'stripe',
+        }),
+        import('./chunk-stripe-wallet.es.js'),
+    ]);
+    const result = await getAvailableWallet(session);
+    if (result === 'APPLE_PAY')
+        return PaymentMethod.APPLE_PAY;
+    if (result === 'GOOGLE_PAY')
+        return PaymentMethod.GOOGLE_PAY;
+    return null;
+}
+async function getAvailableStripePaymentMethods(params) {
+    const wallet = await getAvailableStripeWallet(params);
+    return wallet
+        ? [PaymentMethod.PAYMENT_CARD, wallet]
+        : [PaymentMethod.PAYMENT_CARD];
+}
 
 /**
  * @fileoverview Main entry point for @funnelfox/billing
@@ -2650,9 +2757,15 @@ const Billing = {
     initMethod: initMethod,
     silentPurchase: silentPurchase,
     getAvailablePaymentMethods: getAvailablePaymentMethods,
+    stripe: {
+        createCardForm: createStripeCardForm,
+        purchaseWallet: purchaseStripeWallet,
+        getAvailableWallet: getAvailableStripeWallet,
+        getAvailablePaymentMethods: getAvailableStripePaymentMethods,
+    },
 };
 if (typeof window !== 'undefined') {
     window.Billing = Billing;
 }
 
-export { APIError as A, Billing as B, CheckoutError as C, DEFAULT_BUTTONS_OPTIONS as D, EVENTS as E, FunnefoxSDKError as F, NetworkError as N, PaymentMethod as P, SDK_VERSION as S, ValidationError as V, PrimerError as a, ConfigurationError as b, DEFAULTS as c, CHECKOUT_STATES as d, ERROR_CODES as e, configure as f, createCheckout as g, createClientSession as h, getAvailablePaymentMethods as i };
+export { APIError as A, Billing as B, CheckoutError as C, DEFAULT_BUTTONS_OPTIONS as D, EVENTS as E, FunnefoxSDKError as F, NetworkError as N, PaymentMethod as P, SDK_VERSION as S, ValidationError as V, PrimerError as a, ConfigurationError as b, DEFAULTS as c, CHECKOUT_STATES as d, ERROR_CODES as e, configure as f, createCheckout as g, createClientSession as h, getAvailablePaymentMethods as i, loadStripe as l };

package/dist/chunk-stripe-card-form.cjs.js

@@ -0,0 +1,80 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+'use strict';
+
+var stripeLoader = require('./chunk-stripe-loader.cjs.js');
+require('./chunk-index.cjs.js');
+
+async function mountStripeCardForm(element, session, params) {
+    const { stripe_public_key, amount, currency, order_id, is_link_enabled } = session.data;
+    const stripe = await stripeLoader.getStripe(stripe_public_key);
+    if (!stripe)
+        throw new Error('Failed to load Stripe');
+    const stripeElements = stripe.elements({
+        mode: 'subscription',
+        amount,
+        currency,
+        paymentMethodCreation: 'manual',
+        paymentMethodTypes: is_link_enabled ? ['card', 'link'] : ['card'],
+        appearance: params.appearance,
+    });
+    const paymentElement = stripeElements.create('payment', {
+        layout: 'tabs',
+        wallets: {
+            applePay: params.showWallets ? 'auto' : 'never',
+            googlePay: params.showWallets ? 'auto' : 'never',
+        },
+        terms: { card: 'never' },
+    });
+    paymentElement.mount(element);
+    await new Promise((resolve, reject) => {
+        paymentElement.once('ready', () => resolve());
+        // 'loaderror' is a valid Stripe event but not yet in the @stripe/stripe-js types
+        paymentElement.once('loaderror', e => reject(e.error));
+    });
+    params.onRenderSuccess?.();
+    return {
+        submit: async () => {
+            params.onLoaderChange?.(true);
+            try {
+                const { error: submitError } = await stripeElements.submit();
+                if (submitError)
+                    throw submitError;
+                const { error, paymentMethod } = await stripe.createPaymentMethod({
+                    elements: stripeElements,
+                });
+                if (error)
+                    throw error;
+                const raw = await params.apiClient.createStripePayment({
+                    orderId: order_id,
+                    paymentMethodId: paymentMethod.id,
+                });
+                const result = params.apiClient.processPaymentResponse(raw);
+                if (result.type === 'action_required') {
+                    const { error: confirmError } = await stripe.confirmPayment({
+                        clientSecret: result.clientToken,
+                        redirect: 'if_required',
+                        confirmParams: { return_url: window.location.href },
+                    });
+                    if (confirmError)
+                        throw confirmError;
+                }
+                params.onPaymentSuccess?.(paymentMethod, order_id);
+            }
+            catch (err) {
+                params.onPaymentFail?.(err);
+                throw err;
+            }
+            finally {
+                params.onLoaderChange?.(false);
+            }
+        },
+    };
+}
+
+exports.mountStripeCardForm = mountStripeCardForm;

package/dist/chunk-stripe-card-form.es.js

@@ -0,0 +1,78 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+import { g as getStripe } from './chunk-stripe-loader.es.js';
+import './chunk-index.es.js';
+
+async function mountStripeCardForm(element, session, params) {
+    const { stripe_public_key, amount, currency, order_id, is_link_enabled } = session.data;
+    const stripe = await getStripe(stripe_public_key);
+    if (!stripe)
+        throw new Error('Failed to load Stripe');
+    const stripeElements = stripe.elements({
+        mode: 'subscription',
+        amount,
+        currency,
+        paymentMethodCreation: 'manual',
+        paymentMethodTypes: is_link_enabled ? ['card', 'link'] : ['card'],
+        appearance: params.appearance,
+    });
+    const paymentElement = stripeElements.create('payment', {
+        layout: 'tabs',
+        wallets: {
+            applePay: params.showWallets ? 'auto' : 'never',
+            googlePay: params.showWallets ? 'auto' : 'never',
+        },
+        terms: { card: 'never' },
+    });
+    paymentElement.mount(element);
+    await new Promise((resolve, reject) => {
+        paymentElement.once('ready', () => resolve());
+        // 'loaderror' is a valid Stripe event but not yet in the @stripe/stripe-js types
+        paymentElement.once('loaderror', e => reject(e.error));
+    });
+    params.onRenderSuccess?.();
+    return {
+        submit: async () => {
+            params.onLoaderChange?.(true);
+            try {
+                const { error: submitError } = await stripeElements.submit();
+                if (submitError)
+                    throw submitError;
+                const { error, paymentMethod } = await stripe.createPaymentMethod({
+                    elements: stripeElements,
+                });
+                if (error)
+                    throw error;
+                const raw = await params.apiClient.createStripePayment({
+                    orderId: order_id,
+                    paymentMethodId: paymentMethod.id,
+                });
+                const result = params.apiClient.processPaymentResponse(raw);
+                if (result.type === 'action_required') {
+                    const { error: confirmError } = await stripe.confirmPayment({
+                        clientSecret: result.clientToken,
+                        redirect: 'if_required',
+                        confirmParams: { return_url: window.location.href },
+                    });
+                    if (confirmError)
+                        throw confirmError;
+                }
+                params.onPaymentSuccess?.(paymentMethod, order_id);
+            }
+            catch (err) {
+                params.onPaymentFail?.(err);
+                throw err;
+            }
+            finally {
+                params.onLoaderChange?.(false);
+            }
+        },
+    };
+}
+
+export { mountStripeCardForm };

package/dist/chunk-stripe-loader.cjs.js

@@ -0,0 +1,20 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+'use strict';
+
+var index = require('./chunk-index.cjs.js');
+
+const cache = new Map();
+function getStripe(publicKey) {
+    if (!cache.has(publicKey)) {
+        cache.set(publicKey, index.loadStripe(publicKey));
+    }
+    return cache.get(publicKey);
+}
+
+exports.getStripe = getStripe;

package/dist/chunk-stripe-loader.es.js

@@ -0,0 +1,18 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+import { l as loadStripe } from './chunk-index.es.js';
+
+const cache = new Map();
+function getStripe(publicKey) {
+    if (!cache.has(publicKey)) {
+        cache.set(publicKey, loadStripe(publicKey));
+    }
+    return cache.get(publicKey);
+}
+
+export { getStripe as g };

package/dist/chunk-stripe-wallet.cjs.js

@@ -0,0 +1,111 @@
+/**
+ * @funnelfox/billing v0.1.0
+ * JavaScript SDK for Funnelfox billing with Primer integration
+ * 
+ * @author Funnelfox
+ * @license MIT
+ */
+'use strict';
+
+var stripeLoader = require('./chunk-stripe-loader.cjs.js');
+require('./chunk-index.cjs.js');
+
+function buildPaymentRequest(stripe, data, totalLabel) {
+    const raw = data.apple_pay_recurring_payment_request;
+    if (raw) {
+        const parseDates = (b) => {
+            if (b.recurringPaymentStartDate)
+                Object.assign(b, {
+                    recurringPaymentStartDate: new Date(b.recurringPaymentStartDate),
+                });
+            if (b.recurringPaymentEndDate)
+                Object.assign(b, {
+                    recurringPaymentEndDate: new Date(b.recurringPaymentEndDate),
+                });
+        };
+        parseDates(raw.regularBilling);
+        if (raw.trialBilling)
+            parseDates(raw.trialBilling);
+    }
+    const applePay = raw
+        ? { recurringPaymentRequest: raw }
+        : undefined;
+    return stripe.paymentRequest({
+        country: data.country,
+        currency: data.currency,
+        total: {
+            label: totalLabel?.trim() || 'Total',
+            amount: data.amount,
+        },
+        requestPayerName: false,
+        requestPayerEmail: false,
+        applePay,
+    });
+}
+async function getAvailableWallet(session) {
+    const { stripe_public_key } = session.data;
+    const stripe = await stripeLoader.getStripe(stripe_public_key);
+    if (!stripe)
+        throw new Error('Failed to load Stripe');
+    const paymentRequest = buildPaymentRequest(stripe, session.data);
+    const result = await paymentRequest.canMakePayment();
+    if (!result)
+        return null;
+    if (result.applePay)
+        return 'APPLE_PAY';
+    if (result.googlePay)
+        return 'GOOGLE_PAY';
+    return null;
+}
+async function purchaseWallet(session, params) {
+    const { stripe_public_key, order_id } = session.data;
+    const stripe = await stripeLoader.getStripe(stripe_public_key);
+    if (!stripe)
+        throw new Error('Failed to load Stripe');
+    const paymentRequest = buildPaymentRequest(stripe, session.data, params.totalLabel);
+    const canPay = await paymentRequest.canMakePayment();
+    if (!canPay)
+        throw new Error('No wallet payment method available');
+    return new Promise((resolve, reject) => {
+        paymentRequest.on('paymentmethod', async (event) => {
+            params.onLoaderChange?.(true);
+            try {
+                const raw = await params.apiClient.createStripePayment({
+                    orderId: order_id,
+                    paymentMethodId: event.paymentMethod.id,
+                });
+                const result = params.apiClient.processPaymentResponse(raw);
+                if (result.type === 'action_required') {
+                    const { error } = await stripe.confirmPayment({
+                        clientSecret: result.clientToken,
+                        redirect: 'if_required',
+                        confirmParams: { return_url: window.location.href },
+                    });
+                    if (error) {
+                        event.complete('fail');
+                        throw error;
+                    }
+                }
+                event.complete('success');
+                params.onPaymentSuccess?.(event.paymentMethod, order_id);
+                resolve();
+            }
+            catch (err) {
+                event.complete('fail');
+                params.onPaymentFail?.(err);
+                reject(err);
+            }
+            finally {
+                params.onLoaderChange?.(false);
+            }
+        });
+        paymentRequest.on('cancel', () => {
+            params.onPaymentCancel?.();
+            resolve();
+        });
+        paymentRequest.show();
+    });
+}
+
+exports.getAvailableWallet = getAvailableWallet;
+exports.purchaseWallet = purchaseWallet;