@xsolla/payment-client-core 0.2.43 → 0.2.45

package/fesm2022/xsolla-payment-client-core.mjs

@@ -1,11 +1,11 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Inject, Pipe, isDevMode, NgModule } from '@angular/core';
+import { InjectionToken, Injectable, Inject, isDevMode, Pipe, NgModule } from '@angular/core';
 import { firstValueFrom, lastValueFrom, map, Subject, BehaviorSubject, filter as filter$1, takeUntil, skip, take, of, interval, throwError } from 'rxjs';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpHeaders, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { UntypedFormGroup, Validators, UntypedFormControl, FormGroup, ReactiveFormsModule } from '@angular/forms';
 import JSEncrypt from 'jsencrypt';
-import { UntypedFormGroup, Validators, UntypedFormControl, ReactiveFormsModule } from '@angular/forms';
-import { filter, map as map$1, tap, debounce, catchError } from 'rxjs/operators';
+import { filter, map as map$1, tap, debounce, debounceTime, catchError } from 'rxjs/operators';
 import * as i1$1 from '@angular/router';
 import { CommonModule } from '@angular/common';
 
@@ -540,6 +540,7 @@ var FieldNames;
     FieldNames["description"] = "description";
     FieldNames["email"] = "email";
     FieldNames["psEmail"] = "psEmail";
+    FieldNames["psAccountCountry"] = "psAccountCountry";
     FieldNames["bazitemail"] = "bazitemail";
     FieldNames["euCheck"] = "eu_check";
     FieldNames["extraCvv"] = "extra_cvv";
@@ -595,6 +596,8 @@ var FieldNames;
     FieldNames["payInstanceAccountId"] = "payInstanceAccountId";
     FieldNames["getApplePaySessionUrl"] = "getApplePaySessionUrl";
     FieldNames["payViaCheckoutUrl"] = "payViaCheckoutUrl";
+    FieldNames["googlePayInitData"] = "googlePayInitData";
+    FieldNames["googlePayPaymentData"] = "googlePayPaymentData";
 })(FieldNames || (FieldNames = {}));
 
 class SubmitResponse {
@@ -685,6 +688,145 @@ var InputEventName;
 
 const googlePayPid = 3431;
 
+var ErrorTags;
+(function (ErrorTags) {
+    ErrorTags["APP"] = "appError";
+    ErrorTags["HTTP"] = "httpError";
+    ErrorTags["JS"] = "jsError";
+    ErrorTags["WS"] = "webSocket";
+    ErrorTags["ENCRYPT"] = "encrypt";
+    ErrorTags["APPLEPAY"] = "applepay";
+    ErrorTags["HEADLESS_UI"] = "headlessUi";
+    ErrorTags["GOOGLEPAY"] = "googlepay";
+    ErrorTags["PAYTM"] = "paytm";
+})(ErrorTags || (ErrorTags = {}));
+
+class TaggedError extends Error {
+    constructor(message, tags) {
+        super(message);
+        this.tags = [];
+        this.parentTag = ErrorTags.HEADLESS_UI;
+        this.tags = this.childTag
+            ? [this.parentTag, this.childTag]
+            : [this.parentTag];
+        if (tags) {
+            const newTags = tags.filter((t, i, arr) => !this.tags.includes(t) && arr.indexOf(t) == i);
+            this.tags = [...this.tags, ...newTags];
+        }
+    }
+}
+
+class ElkLoggerService {
+    constructor(window, settingsService, http, ngZone) {
+        this.window = window;
+        this.settingsService = settingsService;
+        this.http = http;
+        this.ngZone = ngZone;
+        this.vendors = new RegExp('node_modules\\/(@angular|zone).*.js$');
+        this.stackTrace = this.loadStackTrace();
+    }
+    handleError(error) {
+        this.ngZone.runOutsideAngular(() => {
+            if (isDevMode()) {
+                console.error(error);
+                return;
+            }
+            this.parseError(error).catch(console.log);
+        });
+    }
+    log(message, tags, extra) {
+        const logTags = [ErrorTags.HEADLESS_UI, ...tags];
+        if (isDevMode()) {
+            console.log(message, tags);
+            return;
+        }
+        const logMessage = {
+            additionalInfo: this.getAdditionalInfo(),
+            extra,
+            message,
+        };
+        this.sendLog(logMessage, logTags);
+    }
+    async parseError(error) {
+        const errorObj = error instanceof TaggedError
+            ? error
+            : new TaggedError(error.message || error.toString());
+        errorObj.trace = await this.getErrorTrace(errorObj);
+        errorObj.additionalInfo = this.getAdditionalInfo();
+        const { tags } = errorObj;
+        const cleanError = this.removeErrorMetaFields(errorObj);
+        this.sendLog(cleanError, tags);
+        return errorObj;
+    }
+    async loadStackTrace() {
+        const library = await import('stacktrace-js');
+        return library.default;
+    }
+    async getErrorTrace(error) {
+        const stackTrace = await this.stackTrace;
+        const stackFramesArr = await stackTrace.fromError(error);
+        const filteredFramesArr = stackFramesArr.filter(({ fileName }) => fileName && !this.vendors.test(fileName));
+        return filteredFramesArr
+            .map((stackFrame) => stackFrame.toString())
+            .join('\n');
+    }
+    getAdditionalInfo() {
+        const extractUrlHost = (url) => url.replace(/^https?:\/\/([^/?#]+).*$/i, '$1');
+        return {
+            location: {
+                url: this.window.location.href,
+            },
+            project: {
+                id: this.settingsService.project.id,
+            },
+            referrer: {
+                url: this.window.document.referrer,
+            },
+            viewport: {
+                width: this.window.document.documentElement.clientWidth,
+                height: this.window.document.documentElement.clientHeight,
+            },
+            cdn_address: this.settingsService.settings.cdnUrl
+                ? extractUrlHost(this.settingsService.settings.cdnUrl)
+                : 'none',
+            country: this.settingsService.user.country.value,
+            local: this.settingsService.user.country.localized_name,
+        };
+    }
+    removeErrorMetaFields(error) {
+        const metaPropList = [
+            'parentTag',
+            'childTag',
+            'RESTRICTED_KEYS_REGEXP',
+            'tags',
+        ];
+        Object.keys(error).forEach((key) => {
+            if (metaPropList.includes(key))
+                delete error[key];
+        });
+        // implementing own 'message' property from prototype
+        return { ...error, message: error.message };
+    }
+    sendLog(message, tags) {
+        const url = `https://logs-01.xsolla.com/tag/${tags.join(',')}`;
+        firstValueFrom(this.http.post(url, message, {
+            headers: new HttpHeaders().set('Content-Type', 'text/plain'),
+            responseType: 'text',
+        })).catch((err) => console.error('Elk Logger: request error', err));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, deps: [{ token: windowToken }, { token: SettingsService }, { token: i1.HttpClient }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: SettingsService }, { type: i1.HttpClient }, { type: i0.NgZone }] });
+
 const initializeResponseFactoryToken = new InjectionToken('InitializeResponse');
 const initializeResponseFactoryProvider = {
     provide: initializeResponseFactoryToken,
@@ -697,6 +839,7 @@ var UserBehaviourEventName;
     UserBehaviourEventName["showMethodHeader"] = "show-method-header";
     UserBehaviourEventName["showErrorMessage"] = "show-error-message";
     UserBehaviourEventName["openStatusError"] = "open-status-error";
+    UserBehaviourEventName["sysTrackedScripts"] = "sys-tracked_scripts";
 })(UserBehaviourEventName || (UserBehaviourEventName = {}));
 
 const userBehaviourEventTypes = {
@@ -1922,34 +2065,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: UnescapeHtmlPipe }] });
 
-var ErrorTags;
-(function (ErrorTags) {
-    ErrorTags["APP"] = "appError";
-    ErrorTags["HTTP"] = "httpError";
-    ErrorTags["JS"] = "jsError";
-    ErrorTags["WS"] = "webSocket";
-    ErrorTags["ENCRYPT"] = "encrypt";
-    ErrorTags["APPLEPAY"] = "applepay";
-    ErrorTags["HEADLESS_UI"] = "headlessUi";
-    ErrorTags["GOOGLEPAY"] = "googlepay";
-    ErrorTags["PAYTM"] = "paytm";
-})(ErrorTags || (ErrorTags = {}));
-
-class TaggedError extends Error {
-    constructor(message, tags) {
-        super(message);
-        this.tags = [];
-        this.parentTag = ErrorTags.HEADLESS_UI;
-        this.tags = this.childTag
-            ? [this.parentTag, this.childTag]
-            : [this.parentTag];
-        if (tags) {
-            const newTags = tags.filter((t, i, arr) => !this.tags.includes(t) && arr.indexOf(t) == i);
-            this.tags = [...this.tags, ...newTags];
-        }
-    }
-}
-
 class EncryptCreditCardError extends TaggedError {
     constructor(message, tags) {
         tags = tags ? [...tags, ErrorTags.ENCRYPT] : [ErrorTags.ENCRYPT];
@@ -2340,6 +2455,7 @@ var EventParameterType;
     EventParameterType["float"] = "2";
     EventParameterType["bool"] = "3";
     EventParameterType["intArray"] = "4";
+    EventParameterType["stringArray"] = "5";
 })(EventParameterType || (EventParameterType = {}));
 
 class EventBuilderService {
@@ -2443,6 +2559,7 @@ class EventBuilderService {
             case EventParameterType.int:
                 value = parseInt(String(value), 10);
                 return isNaN(value) ? 0 : value;
+            case EventParameterType.stringArray:
             case EventParameterType.intArray:
                 return Array.isArray(value) ? value : [];
             case EventParameterType.float:
@@ -2936,6 +3053,8 @@ class SyncRequest extends XpsApiPartRequest {
         this.addXpsParameters({
             ...fieldsValues,
             change_element: changedField.name,
+            fix_command: changedField.javascript?.change?.staticParams?.fix_command ??
+                this.xps_fix_command,
         });
     }
     getFieldsValues(changedField, fields, form) {
@@ -3067,13 +3186,13 @@ class SyncService extends EmitDataService {
         const control = this.form.get(field.name);
         return control?.errors ?? null;
     }
-    async request(field) {
+    async request(field, fields, form) {
         const paymentSettingsParams = this.paymentSettingsService.getPaymentSettingsParams(this.paymentConfiguration);
         const requestParams = this.requestFactory({
             token: this.settingsService.token,
             changedField: field,
-            fields: this.fields,
-            form: this.form,
+            fields: fields ?? this.fields,
+            form: form ?? this.form,
             ...paymentSettingsParams,
         });
         const encryptedRequest = this.encryptCreditCardService.encryptCreditCard(requestParams);
@@ -5146,6 +5265,9 @@ class FinanceDetailsService extends EmitDataService {
             super.emit(financeDetails);
         }
     }
+    getDetailsFromSummary(summary) {
+        return this.summaryFinanceDetailsAdapterService.getFinanceDetails(summary);
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FinanceDetailsService, deps: [{ token: SessionService }, { token: SummaryFinanceDetailsAdapterService }, { token: StatusFinanceDetailsAdapterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: FinanceDetailsService, providedIn: 'root' }); }
 }
@@ -5365,117 +5487,6 @@ class WsError extends TaggedError {
     }
 }
 
-class ElkLoggerService {
-    constructor(window, settingsService, http, ngZone) {
-        this.window = window;
-        this.settingsService = settingsService;
-        this.http = http;
-        this.ngZone = ngZone;
-        this.vendors = new RegExp('node_modules\\/(@angular|zone).*.js$');
-        this.stackTrace = this.loadStackTrace();
-    }
-    handleError(error) {
-        this.ngZone.runOutsideAngular(() => {
-            if (isDevMode()) {
-                console.error(error);
-                return;
-            }
-            this.parseError(error).catch(console.log);
-        });
-    }
-    log(message, tags, extra) {
-        const logTags = [ErrorTags.HEADLESS_UI, ...tags];
-        if (isDevMode()) {
-            console.log(message, tags);
-            return;
-        }
-        const logMessage = {
-            additionalInfo: this.getAdditionalInfo(),
-            extra,
-            message,
-        };
-        this.sendLog(logMessage, logTags);
-    }
-    async parseError(error) {
-        const errorObj = error instanceof TaggedError
-            ? error
-            : new TaggedError(error.message || error.toString());
-        errorObj.trace = await this.getErrorTrace(errorObj);
-        errorObj.additionalInfo = this.getAdditionalInfo();
-        const { tags } = errorObj;
-        const cleanError = this.removeErrorMetaFields(errorObj);
-        this.sendLog(cleanError, tags);
-        return errorObj;
-    }
-    async loadStackTrace() {
-        const library = await import('stacktrace-js');
-        return library.default;
-    }
-    async getErrorTrace(error) {
-        const stackTrace = await this.stackTrace;
-        const stackFramesArr = await stackTrace.fromError(error);
-        const filteredFramesArr = stackFramesArr.filter(({ fileName }) => fileName && !this.vendors.test(fileName));
-        return filteredFramesArr
-            .map((stackFrame) => stackFrame.toString())
-            .join('\n');
-    }
-    getAdditionalInfo() {
-        const extractUrlHost = (url) => url.replace(/^https?:\/\/([^/?#]+).*$/i, '$1');
-        return {
-            location: {
-                url: this.window.location.href,
-            },
-            project: {
-                id: this.settingsService.project.id,
-            },
-            referrer: {
-                url: this.window.document.referrer,
-            },
-            viewport: {
-                width: this.window.document.documentElement.clientWidth,
-                height: this.window.document.documentElement.clientHeight,
-            },
-            cdn_address: this.settingsService.settings.cdnUrl
-                ? extractUrlHost(this.settingsService.settings.cdnUrl)
-                : 'none',
-            country: this.settingsService.user.country.value,
-            local: this.settingsService.user.country.localized_name,
-        };
-    }
-    removeErrorMetaFields(error) {
-        const metaPropList = [
-            'parentTag',
-            'childTag',
-            'RESTRICTED_KEYS_REGEXP',
-            'tags',
-        ];
-        Object.keys(error).forEach((key) => {
-            if (metaPropList.includes(key))
-                delete error[key];
-        });
-        // implementing own 'message' property from prototype
-        return { ...error, message: error.message };
-    }
-    sendLog(message, tags) {
-        const url = `https://logs-01.xsolla.com/tag/${tags.join(',')}`;
-        firstValueFrom(this.http.post(url, message, {
-            headers: new HttpHeaders().set('Content-Type', 'text/plain'),
-            responseType: 'text',
-        })).catch((err) => console.error('Elk Logger: request error', err));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, deps: [{ token: windowToken }, { token: SettingsService }, { token: i1.HttpClient }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ElkLoggerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [windowToken]
-                }] }, { type: SettingsService }, { type: i1.HttpClient }, { type: i0.NgZone }] });
-
 class CentrifugoWebSocketService {
     static { this.reconnectionTimeoutIncrementFactor = 2; }
     static { this.timeoutsMs = {
@@ -6114,6 +6125,88 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
                 }]
         }] });
 
+class InitializeSpecialButtonActionCreator {
+    constructor(elkLoggerService) {
+        this.elkLoggerService = elkLoggerService;
+        this.type = 'special_button';
+        this.pids = [googlePayPid];
+        this.sdkPaymentMethodsName = new Map([
+            [googlePayPid, 'google-pay'],
+        ]);
+    }
+    getActionData(response) {
+        return {
+            type: this.type,
+            data: {
+                buttonName: this.getPaymentMethodName(response.paymentForm?.pid),
+            },
+        };
+    }
+    isSuitable(response) {
+        if (!response.paymentForm)
+            return false;
+        const hasGooglePayInitDataField = response.paymentForm.fields.some((field) => field.name === FieldNames.googlePayInitData);
+        return (this.pids.includes(response.paymentForm.pid) && hasGooglePayInitDataField);
+    }
+    getPaymentMethodName(pid = 0) {
+        const buttonName = this.sdkPaymentMethodsName.get(pid);
+        if (!buttonName) {
+            this.elkLoggerService.log('No special button for provided pid', [ErrorTags.GOOGLEPAY], {
+                pid,
+            });
+            throw new Error('Special button not found');
+        }
+        return buttonName;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeSpecialButtonActionCreator, deps: [{ token: ElkLoggerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeSpecialButtonActionCreator }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeSpecialButtonActionCreator, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: ElkLoggerService }] });
+
+const initializeNextActionsToken = new InjectionToken('InitializeNextActions');
+const initializeNextActions = [
+    InitializeSpecialButtonActionCreator,
+];
+
+class InitializeNextActionService {
+    constructor(initializeNextActionTokens, injector) {
+        this.initializeNextActionTokens = initializeNextActionTokens;
+        this.injector = injector;
+        this.initializeNextActionsList = [];
+        this.fillNextActionsList();
+    }
+    getNextAction(response) {
+        const nextAction = this.findNextAction(response);
+        if (!nextAction)
+            return null;
+        return nextAction.getActionData(response);
+    }
+    fillNextActionsList() {
+        this.initializeNextActionTokens.forEach((nextAction) => {
+            const item = this.injector.get(nextAction);
+            this.initializeNextActionsList.push(item);
+        });
+    }
+    findNextAction(response) {
+        return this.initializeNextActionsList.find((nextAction) => {
+            return nextAction.isSuitable(response);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeNextActionService, deps: [{ token: initializeNextActionsToken }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeNextActionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InitializeNextActionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [initializeNextActionsToken]
+                }] }, { type: i0.Injector }] });
+
 var ThreeDsStatusWebSocketTypes;
 (function (ThreeDsStatusWebSocketTypes) {
     ThreeDsStatusWebSocketTypes["status3DS_changed"] = "status3DS_changed";
@@ -6605,7 +6698,8 @@ class PaymentService {
     get formResponseValue() {
         return this._formResponse$.getValue();
     }
-    constructor(initializeService, submitService, syncService, formService, statusService, financeDetailsService, creditCardStateService, nextActionService, controlConfigService, threeDsService, formMessagesService, settingsService, countryService, checkStatusActionCreator, printInstructionService) {
+    constructor(elkLoggerService, initializeService, submitService, syncService, formService, statusService, financeDetailsService, creditCardStateService, nextActionService, initializeNextActionService, controlConfigService, threeDsService, formMessagesService, settingsService, countryService, checkStatusActionCreator, printInstructionService) {
+        this.elkLoggerService = elkLoggerService;
         this.initializeService = initializeService;
         this.submitService = submitService;
         this.syncService = syncService;
@@ -6614,6 +6708,7 @@ class PaymentService {
         this.financeDetailsService = financeDetailsService;
         this.creditCardStateService = creditCardStateService;
         this.nextActionService = nextActionService;
+        this.initializeNextActionService = initializeNextActionService;
         this.controlConfigService = controlConfigService;
         this.threeDsService = threeDsService;
         this.formMessagesService = formMessagesService;
@@ -6658,6 +6753,7 @@ class PaymentService {
         return {
             fields: this.fields.filter((field) => field?.isVisible === "1" /* XpsBoolean.true */),
             isFormAutoSubmitted: isNeedAutoSubmit,
+            nextAction: this.initializeNextActionService.getNextAction(this.data),
         };
     }
     async submit() {
@@ -6689,6 +6785,26 @@ class PaymentService {
         this.syncService.setup(this.form, this.fields, this.config);
         return this.nextActionService.getNextAction(submitResponse);
     }
+    async submitWithFields(fields) {
+        if (!this.form) {
+            this.elkLoggerService.log('submit error: trying to submit with no form', [
+                ErrorTags.GOOGLEPAY,
+            ]);
+            throw new Error('form is empty!');
+        }
+        this.isSavingMethodMode = this.fields.some(({ name, value }) => name === 'savePsAccountOnly' && value === "1" /* XpsBoolean.true */);
+        const submitResponse = await this.submitService.request(fields ?? this.fields, this.form, this.config);
+        this.data = submitResponse;
+        this.emitFormResponse(this.data);
+        if (!this.isSavingMethodMode) {
+            this.emitFinanceDetails(submitResponse.summary);
+        }
+        this.emitFormMessages(submitResponse.messages);
+        this.fields = this.getFields();
+        this.form = this.formService.createForm(this.fields);
+        this.syncService.setup(this.form, this.fields, this.config);
+        return submitResponse;
+    }
     getFields() {
         if (this.data instanceof SubmitResponse) {
             return this.data.fields ?? [];
@@ -6706,17 +6822,21 @@ class PaymentService {
             status: control.status,
         };
     }
-    getInitialDataForSdkPaymentSystems() {
-        if (!isSubmitResponse(this.data)) {
+    async getInitialDataForSdkPaymentSystems() {
+        if (!this.data) {
             throw new Error('Should submit form first');
         }
-        return {
-            data: this.data.parameters.checkout.data.data,
+        const sdkPaymentData = this.getSdkPaymentDataFromResponse(this.data);
+        return Promise.resolve({
+            data: sdkPaymentData.checkoutData,
             sandbox: this.settingsService.isSandboxMode()
                 ? "1" /* XpsBoolean.true */
                 : "0" /* XpsBoolean.false */,
             country: this.countryService.getCountry(),
-        };
+            fields: sdkPaymentData.fields,
+            submitResponse: isSubmitResponse(this.data) ? this.data : null,
+            summary: sdkPaymentData.summary,
+        });
     }
     getQrCode() {
         if (!isSubmitResponse(this.data)) {
@@ -6768,6 +6888,9 @@ class PaymentService {
         }
         return this.syncService.validate(field);
     }
+    async calculateField(changedField, fields) {
+        return this.syncService.request(changedField, fields, new FormGroup({}));
+    }
     runThreeDs() {
         if (!isSubmitResponse(this.data)) {
             throw new Error('Should submit form first');
@@ -6972,7 +7095,21 @@ class PaymentService {
             (visibleFields.length === 0 &&
                 suitablePids.includes(response.paymentForm.pid)));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentService, deps: [{ token: InitializeService }, { token: SubmitService }, { token: SyncService }, { token: FormService }, { token: StatusService }, { token: FinanceDetailsService }, { token: CreditCardStateService }, { token: NextActionService }, { token: ControlConfigService }, { token: ThreeDsService }, { token: FormMessagesService }, { token: SettingsService }, { token: CountryService }, { token: CheckStatusActionCreator }, { token: PrintInstructionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    getSdkPaymentDataFromResponse(data) {
+        if (isSubmitResponse(data)) {
+            return {
+                checkoutData: data.parameters.checkout.data.data,
+                fields: data.fields,
+                summary: data.summary,
+            };
+        }
+        return {
+            checkoutData: null,
+            fields: data.paymentForm?.fields ?? [],
+            summary: data.paymentForm?.summary ?? null,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentService, deps: [{ token: ElkLoggerService }, { token: InitializeService }, { token: SubmitService }, { token: SyncService }, { token: FormService }, { token: StatusService }, { token: FinanceDetailsService }, { token: CreditCardStateService }, { token: NextActionService }, { token: InitializeNextActionService }, { token: ControlConfigService }, { token: ThreeDsService }, { token: FormMessagesService }, { token: SettingsService }, { token: CountryService }, { token: CheckStatusActionCreator }, { token: PrintInstructionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PaymentService, decorators: [{
@@ -6980,7 +7117,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: InitializeService }, { type: SubmitService }, { type: SyncService }, { type: FormService }, { type: StatusService }, { type: FinanceDetailsService }, { type: CreditCardStateService }, { type: NextActionService }, { type: ControlConfigService }, { type: ThreeDsService }, { type: FormMessagesService }, { type: SettingsService }, { type: CountryService }, { type: CheckStatusActionCreator }, { type: PrintInstructionService }] });
+        }], ctorParameters: () => [{ type: ElkLoggerService }, { type: InitializeService }, { type: SubmitService }, { type: SyncService }, { type: FormService }, { type: StatusService }, { type: FinanceDetailsService }, { type: CreditCardStateService }, { type: NextActionService }, { type: InitializeNextActionService }, { type: ControlConfigService }, { type: ThreeDsService }, { type: FormMessagesService }, { type: SettingsService }, { type: CountryService }, { type: CheckStatusActionCreator }, { type: PrintInstructionService }] });
 
 const euCountries = new Set([
     'AT',
@@ -7537,8 +7674,88 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
                     args: [sendInstructionStatusResponseFactoryToken]
                 }] }] });
 
+class ScriptTrackerService {
+    constructor(userBehaviourAnalyticsService) {
+        this.userBehaviourAnalyticsService = userBehaviourAnalyticsService;
+        this.currentScripts = new Set();
+        this.scriptHostBlacklist = [
+            'https://cdn.xsolla.net/headless-checkout-prod',
+        ];
+        this.SCRIPT_DEBOUNCE_TIME_MS = 1000;
+        this.scriptTracked$ = new Subject();
+    }
+    initScriptTracking(environment) {
+        if (environment !== 'production') {
+            return;
+        }
+        this.scriptTracked$
+            .pipe(debounceTime(this.SCRIPT_DEBOUNCE_TIME_MS))
+            .subscribe(() => this.handleScriptData());
+        this.checkCurrentScripts();
+        this.setupScriptObserver();
+    }
+    handleScriptData() {
+        const scriptsData = this.getTrackedScripts();
+        this.userBehaviourAnalyticsService.send(UserBehaviourEventName.sysTrackedScripts, userBehaviourEventTypes.manual, {
+            value: scriptsData,
+            valueType: EventParameterType.stringArray,
+        });
+    }
+    getTrackedScripts() {
+        return Array.from(this.currentScripts.values());
+    }
+    checkCurrentScripts() {
+        const scripts = Array.from(document.getElementsByTagName('script'));
+        scripts.forEach((script) => {
+            this.trackScript(script);
+        });
+    }
+    setupScriptObserver() {
+        if (typeof MutationObserver === 'undefined') {
+            return;
+        }
+        const observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type !== 'childList') {
+                    return;
+                }
+                mutation.addedNodes.forEach((node) => {
+                    if (node.nodeName === 'SCRIPT') {
+                        this.trackScript(node);
+                    }
+                });
+            });
+        });
+        observer.observe(document.documentElement, {
+            childList: true,
+            subtree: true,
+        });
+    }
+    trackScript(script) {
+        if (!script.src || this.currentScripts.has(script.src)) {
+            return;
+        }
+        const isScriptInBlacklist = this.scriptHostBlacklist.some((host) => {
+            return script.src.includes(host);
+        });
+        if (isScriptInBlacklist) {
+            return;
+        }
+        this.currentScripts.add(script.src);
+        this.scriptTracked$.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ScriptTrackerService, deps: [{ token: UserBehaviourAnalyticsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ScriptTrackerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: ScriptTrackerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: UserBehaviourAnalyticsService }] });
+
 class CoreLibraryService {
-    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, paymentConfigService, paymentService, deviceFingerPrintService, financeDetailsService, legalService, statusService, nextActionService, creditCardService, creditCardStateService, formMessagesService, editSavedMethodsService, userBehaviourAnalyticsService, performanceService, combinedPaymentMethodsService, countriesApiService, sendInstructionService) {
+    constructor(settingsService, countryService, paymentMethodsService, savedMethodsService, userBalanceService, paymentConfigService, paymentService, deviceFingerPrintService, financeDetailsService, legalService, statusService, nextActionService, creditCardService, creditCardStateService, formMessagesService, editSavedMethodsService, userBehaviourAnalyticsService, performanceService, combinedPaymentMethodsService, countriesApiService, sendInstructionService, scriptTrackerService) {
         this.settingsService = settingsService;
         this.countryService = countryService;
         this.paymentMethodsService = paymentMethodsService;
@@ -7560,6 +7777,7 @@ class CoreLibraryService {
         this.combinedPaymentMethodsService = combinedPaymentMethodsService;
         this.countriesApiService = countriesApiService;
         this.sendInstructionService = sendInstructionService;
+        this.scriptTrackerService = scriptTrackerService;
         this.paymentMethods = {
             getList: async (isSaveMethodMode) => this.paymentMethodsService.getList(isSaveMethodMode),
             getQuickMethods: async () => this.paymentMethodsService.getQuickMethods(),
@@ -7569,7 +7787,12 @@ class CoreLibraryService {
             deleteSavedMethod: async (id, type) => this.editSavedMethodsService.deleteSavedMethodRequest(id, type),
         };
         this.sdkPaymentSystems = {
-            getInitialData: () => this.paymentService.getInitialDataForSdkPaymentSystems(),
+            getInitialData: async () => this.paymentService.getInitialDataForSdkPaymentSystems(),
+        };
+        this.finance = {
+            getDetailsFromSummary: (summary) => {
+                return this.financeDetailsService.getDetailsFromSummary(summary);
+            },
         };
     }
     async init(configuration) {
@@ -7577,10 +7800,17 @@ class CoreLibraryService {
         this.performanceService.init();
         this.userBehaviourAnalyticsService.init();
         this.deviceFingerPrintService.init();
+        this.scriptTrackerService.initScriptTracking(configuration.environment);
     }
     async getStatus(url) {
         return this.statusService.getStatusWithUrlSearchParams(url);
     }
+    async calculateField(changedField, fields) {
+        return this.paymentService.calculateField(changedField, fields);
+    }
+    async submit(fields) {
+        return this.paymentService.submitWithFields(fields);
+    }
     sendAnalytics(action, type, options) {
         this.userBehaviourAnalyticsService.send(action, type, options);
     }
@@ -7667,7 +7897,7 @@ class CoreLibraryService {
     get formResponseValue() {
         return this.paymentService.formResponseValue;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CoreLibraryService, deps: [{ token: SettingsService }, { token: CountryService }, { token: PaymentMethodsService }, { token: SavedMethodsService }, { token: UserBalanceService }, { token: PaymentConfigService }, { token: PaymentService }, { token: DeviceFingerPrintService }, { token: FinanceDetailsService }, { token: LegalService }, { token: StatusService }, { token: NextActionService }, { token: CreditCardService }, { token: CreditCardStateService }, { token: FormMessagesService }, { token: EditSavedMethodsService }, { token: UserBehaviourAnalyticsService }, { token: PerformanceService }, { token: CombinedPaymentMethodsService }, { token: CountriesApiService }, { token: SendInstructionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CoreLibraryService, deps: [{ token: SettingsService }, { token: CountryService }, { token: PaymentMethodsService }, { token: SavedMethodsService }, { token: UserBalanceService }, { token: PaymentConfigService }, { token: PaymentService }, { token: DeviceFingerPrintService }, { token: FinanceDetailsService }, { token: LegalService }, { token: StatusService }, { token: NextActionService }, { token: CreditCardService }, { token: CreditCardStateService }, { token: FormMessagesService }, { token: EditSavedMethodsService }, { token: UserBehaviourAnalyticsService }, { token: PerformanceService }, { token: CombinedPaymentMethodsService }, { token: CountriesApiService }, { token: SendInstructionService }, { token: ScriptTrackerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CoreLibraryService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: CoreLibraryService, decorators: [{
@@ -7675,7 +7905,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: SettingsService }, { type: CountryService }, { type: PaymentMethodsService }, { type: SavedMethodsService }, { type: UserBalanceService }, { type: PaymentConfigService }, { type: PaymentService }, { type: DeviceFingerPrintService }, { type: FinanceDetailsService }, { type: LegalService }, { type: StatusService }, { type: NextActionService }, { type: CreditCardService }, { type: CreditCardStateService }, { type: FormMessagesService }, { type: EditSavedMethodsService }, { type: UserBehaviourAnalyticsService }, { type: PerformanceService }, { type: CombinedPaymentMethodsService }, { type: CountriesApiService }, { type: SendInstructionService }] });
+        }], ctorParameters: () => [{ type: SettingsService }, { type: CountryService }, { type: PaymentMethodsService }, { type: SavedMethodsService }, { type: UserBalanceService }, { type: PaymentConfigService }, { type: PaymentService }, { type: DeviceFingerPrintService }, { type: FinanceDetailsService }, { type: LegalService }, { type: StatusService }, { type: NextActionService }, { type: CreditCardService }, { type: CreditCardStateService }, { type: FormMessagesService }, { type: EditSavedMethodsService }, { type: UserBehaviourAnalyticsService }, { type: PerformanceService }, { type: CombinedPaymentMethodsService }, { type: CountriesApiService }, { type: SendInstructionService }, { type: ScriptTrackerService }] });
 
 class HttpError extends AppError {
     constructor(error, req) {
@@ -7860,7 +8090,12 @@ class CoreLibraryModule {
                 provide: nextActionsToken,
                 useValue: nextActions,
             },
+            {
+                provide: initializeNextActionsToken,
+                useValue: initializeNextActions,
+            },
             ...nextActions,
+            ...initializeNextActions,
             ...flowUpdateNextActions,
             printInstructionRequestFactoryProvider,
             sendInstructionRequestFactoryProvider,
@@ -7897,7 +8132,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
                             provide: nextActionsToken,
                             useValue: nextActions,
                         },
+                        {
+                            provide: initializeNextActionsToken,
+                            useValue: initializeNextActions,
+                        },
                         ...nextActions,
+                        ...initializeNextActions,
                         ...flowUpdateNextActions,
                         printInstructionRequestFactoryProvider,
                         sendInstructionRequestFactoryProvider,
@@ -7984,6 +8224,195 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
                     args: [windowToken]
                 }] }] });
 
+class GooglePayCheckoutPaymentService {
+    constructor(paymentSystemProcessingService) {
+        this.paymentSystemProcessingService = paymentSystemProcessingService;
+        this.checkout = null;
+    }
+    preparePayment({ initParams, checkDeviceData, }) {
+        if (!initParams || !checkDeviceData.base64checkoutData)
+            return null;
+        this.initParams = initParams;
+        this.checkout =
+            this.paymentSystemProcessingService.getDecodedCheckout(checkDeviceData.base64checkoutData);
+        if (!this.checkout)
+            return null;
+        const checkoutData = this.checkout.request.form.fields;
+        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
+        const isReadyToPayRequest = JSON.parse(checkoutData.isReadyToPayRequest);
+        const result = { paymentDataRequest, isReadyToPayRequest };
+        if (checkoutData.amexCardNotification) {
+            result.amexCardNotification = JSON.parse(checkoutData.amexCardNotification);
+        }
+        return result;
+    }
+    getPaymentRequest() {
+        if (!this.checkout)
+            return null;
+        const checkoutData = this.checkout.request.form.fields;
+        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
+        paymentDataRequest.transactionInfo = {
+            currencyCode: checkoutData.currency,
+            totalPriceStatus: 'FINAL',
+            totalPrice: checkoutData.sum?.toString(),
+            countryCode: this.initParams.country.toUpperCase(),
+        };
+        return paymentDataRequest;
+    }
+    getAllowedPaymentMethods() {
+        if (!this.checkout)
+            return [];
+        const paymentDataRequest = JSON.parse(this.checkout.request.form.fields.paymentDataRequest);
+        return paymentDataRequest.allowedPaymentMethods;
+    }
+    handleSuccessfulPayment(response) {
+        if (!this.checkout)
+            return;
+        let returnUrl = this.checkout.request.form.fields.returnSuccessUrl;
+        const data = this.checkout.request.form.fields;
+        returnUrl += `&cpf_number=${data.cpf_number}&descriptor=${data.descriptor}&paymentData=${JSON.stringify(response)}`;
+        this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+    }
+    handleFailedPayment(error) {
+        if (!this.checkout)
+            return;
+        const statusCode = error?.statusCode;
+        const isStatusCanceled = statusCode && this.isCancelledStatus(statusCode);
+        if (isStatusCanceled)
+            return;
+        const returnUrl = this.checkout.request.form.fields.returnFailUrl;
+        this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+    }
+    isCancelledStatus(statusCode) {
+        return statusCode.toLowerCase() === 'canceled';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayCheckoutPaymentService, deps: [{ token: PaymentSystemProcessingService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayCheckoutPaymentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayCheckoutPaymentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: PaymentSystemProcessingService }] });
+
+class GooglePayInstantPaymentService {
+    constructor(summaryFinanceDetailsAdapterService) {
+        this.summaryFinanceDetailsAdapterService = summaryFinanceDetailsAdapterService;
+        this.googleInitData = null;
+    }
+    preparePayment({ initParams, checkDeviceData, }) {
+        if (!initParams)
+            return null;
+        this.initParams = initParams;
+        this.googleInitData = this.extractGoogleInitData(initParams.fields);
+        if (!this.googleInitData)
+            return null;
+        const displayItems = checkDeviceData.summary
+            ? this.getItemsTaxes(checkDeviceData.summary)
+            : [];
+        this.googleInitData.paymentDataRequest = {
+            ...this.googleInitData.paymentDataRequest,
+            transactionInfo: {
+                ...this.googleInitData.paymentDataRequest.transactionInfo,
+                totalPriceStatus: 'ESTIMATED',
+                totalPrice: this.googleInitData.paymentDataRequest.transactionInfo.totalPrice?.toString(),
+                countryCode: initParams.country.toUpperCase() ??
+                    this.googleInitData.paymentDataRequest.transactionInfo.countryCode?.toUpperCase(),
+                totalPriceLabel: this.googleInitData.paymentDataRequest.transactionInfo
+                    .totalPriceLabel ?? 'Total',
+                displayItems,
+            },
+            shippingAddressRequired: true,
+            callbackIntents: ['SHIPPING_ADDRESS', 'PAYMENT_AUTHORIZATION'],
+        };
+        return this.googleInitData;
+    }
+    getPaymentRequest() {
+        if (!this.googleInitData)
+            return null;
+        return {
+            ...this.googleInitData.paymentDataRequest,
+            transactionInfo: {
+                ...this.googleInitData.paymentDataRequest.transactionInfo,
+                totalPriceStatus: 'ESTIMATED',
+                totalPrice: this.googleInitData.paymentDataRequest.transactionInfo.totalPrice?.toString(),
+                countryCode: this.initParams.country.toUpperCase() ??
+                    this.googleInitData.paymentDataRequest.transactionInfo.countryCode?.toUpperCase(),
+            },
+            shippingAddressRequired: true,
+            callbackIntents: ['SHIPPING_ADDRESS', 'PAYMENT_AUTHORIZATION'],
+        };
+    }
+    getAllowedPaymentMethods() {
+        if (!this.googleInitData)
+            return [];
+        return this.googleInitData.paymentDataRequest.allowedPaymentMethods;
+    }
+    extractGoogleInitData(fields) {
+        try {
+            const googlePayInitData = fields.filter((field) => field.name === FieldNames.googlePayInitData)[0]?.value;
+            const data = JSON.parse(googlePayInitData ?? null);
+            return data;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    getItemsTaxes(summary) {
+        const financeResponse = this.summaryFinanceDetailsAdapterService.getFinanceDetails(summary);
+        const newCartPricing = financeResponse.cartSummary;
+        if (!newCartPricing.total?.money?.amount || !financeResponse.finance) {
+            return [];
+        }
+        const newPrice = {
+            total: this.getTotalAmount(financeResponse.finance),
+            subtotalDetails: newCartPricing.subtotalDetails,
+            subtotalPayment: newCartPricing.subtotalPayment,
+            totalDetails: newCartPricing.totalDetails,
+        };
+        const displayItems = [];
+        if (newPrice.subtotalPayment?.money?.amount) {
+            displayItems.push({
+                label: newPrice.subtotalPayment.title || 'Subtotal',
+                amount: newPrice.subtotalPayment.money?.amount.toString(),
+            });
+        }
+        let paymentsDetails = [];
+        if (newPrice.subtotalDetails?.length) {
+            paymentsDetails = newPrice.subtotalDetails;
+        }
+        if (newPrice.totalDetails?.length) {
+            paymentsDetails = paymentsDetails.concat(newPrice.totalDetails);
+        }
+        paymentsDetails.forEach((cartItem) => {
+            if (!cartItem.title || !cartItem.money?.amount) {
+                return;
+            }
+            displayItems.push({
+                label: cartItem.title,
+                amount: cartItem.money.amount.toString(),
+            });
+        });
+        return displayItems.map((item) => ({
+            label: item.label ?? '',
+            type: 'TAX',
+            price: item.amount,
+        }));
+    }
+    getTotalAmount(finance) {
+        return finance?.grand_total?.amount ?? finance?.total?.amount;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayInstantPaymentService, deps: [{ token: SummaryFinanceDetailsAdapterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayInstantPaymentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayInstantPaymentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: SummaryFinanceDetailsAdapterService }] });
+
 class GooglePayService {
     get libraryWasInitialized() {
         return !!this.window.google;
@@ -7991,14 +8420,17 @@ class GooglePayService {
     get googlePaymentClientWasInitialized() {
         return !!this.googlePaymentClient;
     }
-    constructor(window, paymentSystemProcessingService, injector) {
+    constructor(window, elkLoggerService, paymentSystemProcessingService, googlePayCheckoutPaymentService, googlePayInstantPaymentService, injector) {
         this.window = window;
+        this.elkLoggerService = elkLoggerService;
         this.paymentSystemProcessingService = paymentSystemProcessingService;
+        this.googlePayCheckoutPaymentService = googlePayCheckoutPaymentService;
+        this.googlePayInstantPaymentService = googlePayInstantPaymentService;
         this.injector = injector;
         this.googlePayScriptUrl = 'https://pay.google.com/gp/p/js/pay.js';
         this.readyToPay = new BehaviorSubject(null);
-        this.checkout = null;
         this.googlePaymentClient = null;
+        this.paymentService = null;
     }
     get readyToPay$() {
         return this.readyToPay.asObservable();
@@ -8007,8 +8439,9 @@ class GooglePayService {
         return this.readyToPay.getValue();
     }
     initGooglePayLibrary(data) {
-        this.isSandbox = data.isSandbox;
-        this.country = data.country;
+        this.initParams = data;
+        this.onPaymentDataChanged = data.onPaymentDataChanged;
+        this.onPaymentAuthorized = data.onPaymentAuthorized;
         if (this.libraryWasInitialized && this.googlePaymentClientWasInitialized) {
             return;
         }
@@ -8018,28 +8451,36 @@ class GooglePayService {
         }
         this.paymentSystemProcessingService.loadScript(this.googlePayScriptUrl, this.onLoadScript.bind(this));
     }
-    checkPaymentDevice(base64checkoutData) {
+    checkPaymentDevice(data) {
         this.paymentSystemProcessingService.initialize$
             .pipe(filter$1(Boolean), take(1))
             .subscribe(() => {
-            this.checkout =
-                this.paymentSystemProcessingService.getDecodedCheckout(base64checkoutData);
-            if (!this.checkout || !this.googlePaymentClient) {
-                throw new AppError(`Google Pay: no checkout or google payment client, checkout - ${Boolean(this.checkout).toString()}, client - ${Boolean(this.googlePaymentClient).toString()}`);
+            if (!this.googlePaymentClient) {
+                this.elkLoggerService.log('Google payment client is not initialized', [ErrorTags.GOOGLEPAY]);
+                throw new AppError(`Google Pay: Google payment client is not initialized`);
+            }
+            this.paymentService = this.getPaymentService();
+            const initData = this.paymentService.preparePayment({
+                initParams: this.initParams,
+                checkDeviceData: data,
+            });
+            if (!initData) {
+                this.elkLoggerService.log('No initialization data', [
+                    ErrorTags.GOOGLEPAY,
+                ]);
+                throw new AppError('Google Pay: no initialization data');
             }
-            const checkoutData = this.checkout.request.form.fields;
-            const isReadyToPayRequest = JSON.parse(checkoutData.isReadyToPayRequest);
             this.googlePaymentClient
-                .isReadyToPay(isReadyToPayRequest)
+                .isReadyToPay(initData.isReadyToPayRequest)
                 .then((response) => {
                 if (response.result && this.googlePaymentClient) {
-                    this.googlePaymentClient.prefetchPaymentData(JSON.parse(checkoutData.paymentDataRequest));
+                    this.googlePaymentClient.prefetchPaymentData(initData.paymentDataRequest);
                     return this.readyToPay.next(true);
                 }
                 this.readyToPay.next(false);
                 const result = response.result?.toString() ?? '';
                 const isHavePaymentClient = Boolean(this.googlePaymentClient).toString();
-                throw new Error(`Google Pay: possibly no response.result or googlePaymentClient is missing, result - ${result}, isHavePaymentClient - ${isHavePaymentClient}`);
+                throw new AppError(`Google Pay: possibly no response.result or googlePaymentClient is missing, result - ${result}, isHavePaymentClient - ${isHavePaymentClient}`);
             })
                 .catch((error) => {
                 this.readyToPay.next(false);
@@ -8052,60 +8493,46 @@ class GooglePayService {
         });
     }
     async proceedCheckout() {
-        if (!this.checkout || !this.googlePaymentClient) {
-            const isHaveCheckout = !!this.checkout;
-            const isHaveClient = !!this.googlePaymentClient;
-            throw new AppError(`Google Pay: no checkout or google payment client, checkout - ${isHaveCheckout.toString()}, client - ${isHaveClient.toString()}`);
+        if (!this.googlePaymentClient) {
+            this.elkLoggerService.log('Google payment client is not initialized to proceed checkout', [ErrorTags.GOOGLEPAY]);
+            throw new AppError(`Google Pay. proceedCheckout: no google payment client`);
+        }
+        if (!this.paymentService) {
+            this.elkLoggerService.log('Google payment service is not initialized to proceed checkout', [ErrorTags.GOOGLEPAY]);
+            throw new AppError(`Google Pay. proceedCheckout: no google payment service`);
+        }
+        const paymentDataRequest = this.paymentService.getPaymentRequest();
+        if (!paymentDataRequest) {
+            this.elkLoggerService.log('No data for payment data request', [
+                ErrorTags.GOOGLEPAY,
+            ]);
+            throw new AppError(`Google Pay: No data for payment data request`);
         }
-        const checkoutData = this.checkout.request.form.fields;
-        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
-        paymentDataRequest.transactionInfo = {
-            currencyCode: checkoutData.currency,
-            totalPriceStatus: 'FINAL',
-            totalPrice: checkoutData.sum,
-            countryCode: this.country,
-        };
         const checkStatusAction = this.injector
             .get(CheckStatusActionCreator)
             .getActionData();
         try {
             const paymentData = await this.googlePaymentClient.loadPaymentData(paymentDataRequest);
             if (!paymentData?.paymentMethodData?.tokenizationData?.token) {
+                this.elkLoggerService.log('Token is missing', [ErrorTags.GOOGLEPAY]);
                 throw new AppError('Google Pay: token is missing');
             }
-            if (!this.checkout) {
-                throw new AppError('Google Pay: no checkout data in then');
-            }
-            let returnUrl = this.checkout.request.form.fields.returnSuccessUrl;
-            const data = this.checkout.request.form.fields;
-            returnUrl += `&cpf_number=${data.cpf_number}&descriptor=${data.descriptor}&paymentData=${JSON.stringify(paymentData)}`;
-            this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+            this.paymentService.handleSuccessfulPayment?.(paymentData);
             return checkStatusAction;
         }
         catch (error) {
-            if (!this.checkout) {
-                throw new AppError(`Google Pay: no checkout data`);
-            }
-            const statusCode = error
-                ?.statusCode;
-            const isStatusCanceled = statusCode && this.isCancelledStatus(statusCode);
-            if (isStatusCanceled) {
-                return null;
-            }
-            const returnUrl = this.checkout.request.form.fields.returnFailUrl;
-            this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+            this.paymentService.handleFailedPayment?.(error);
             return checkStatusAction;
         }
     }
     createButton(onClickHandler, buttonColor = 'default') {
-        if (!this.checkout || !this.googlePaymentClient) {
+        if (!this.googlePaymentClient) {
             return null;
         }
-        const checkoutData = this.checkout.request.form.fields;
-        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
+        const allowedPaymentMethods = this.paymentService?.getAllowedPaymentMethods() || [];
         return this.googlePaymentClient.createButton({
             onClick: onClickHandler,
-            allowedPaymentMethods: paymentDataRequest.allowedPaymentMethods,
+            allowedPaymentMethods: allowedPaymentMethods,
             buttonSizeMode: 'fill',
             buttonType: 'buy',
             buttonColor,
@@ -8115,11 +8542,18 @@ class GooglePayService {
         if (!this.window.google) {
             return;
         }
-        const environment = this.isSandbox ? 'TEST' : 'PRODUCTION';
+        const environment = this.initParams.isSandbox ? 'TEST' : 'PRODUCTION';
+        const googlePaymentClientData = {
+            environment,
+        };
+        if (this.initParams.isInstantPayFlow) {
+            googlePaymentClientData.paymentDataCallbacks = {
+                onPaymentDataChanged: this.onPaymentDataChanged,
+                onPaymentAuthorized: this.onPaymentAuthorized,
+            };
+        }
         this.googlePaymentClient =
-            new this.window.google.payments.api.PaymentsClient({
-                environment,
-            });
+            new this.window.google.payments.api.PaymentsClient(googlePaymentClientData);
     }
     onLoadScript() {
         if (!this.window.google) {
@@ -8138,10 +8572,12 @@ class GooglePayService {
             this.paymentSystemProcessingService.emitInitialize(true);
         }
     }
-    isCancelledStatus(statusCode) {
-        return statusCode.toLowerCase() === 'canceled';
+    getPaymentService() {
+        if (this.initParams.isInstantPayFlow)
+            return this.googlePayInstantPaymentService;
+        return this.googlePayCheckoutPaymentService;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayService, deps: [{ token: windowToken }, { token: PaymentSystemProcessingService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayService, deps: [{ token: windowToken }, { token: ElkLoggerService }, { token: PaymentSystemProcessingService }, { token: GooglePayCheckoutPaymentService }, { token: GooglePayInstantPaymentService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: GooglePayService, decorators: [{
@@ -8152,7 +8588,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [windowToken]
-                }] }, { type: PaymentSystemProcessingService }, { type: i0.Injector }] });
+                }] }, { type: ElkLoggerService }, { type: PaymentSystemProcessingService }, { type: GooglePayCheckoutPaymentService }, { type: GooglePayInstantPaymentService }, { type: i0.Injector }] });
 
 const applePayVersion = 3;