@dynamic-labs/utils 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/index.cjs

@@ -35,6 +35,8 @@ var CookieInvalidError = require('./errors/CookieInvalidError.cjs');
 var AccessBlockedError = require('./errors/AccessBlockedError.cjs');
 var EmbeddedWalletException = require('./errors/EmbeddedWalletException.cjs');
 var MfaInvalidOtpError = require('./errors/MfaInvalidOtpError.cjs');
+var ExternalAuthError = require('./errors/ExternalAuthError.cjs');
+var WalletAddressMismatchError = require('./errors/WalletAddressMismatchError.cjs');
 var CancellablePromise = require('./CancellablePromise/CancellablePromise.cjs');
 var isFunction = require('./isFunction/isFunction.cjs');
 var isMobile = require('./isMobile.cjs');
@@ -43,7 +45,6 @@ var bufferToBase64 = require('./bufferToBase64.cjs');
 var last = require('./last.cjs');
 var getProvidersFromWindow = require('./getProvidersFromWindow.cjs');
 var sleep = require('./sleep/sleep.cjs');
-var getOrMapViemChain = require('./getOrMapViemChain.cjs');
 var retryableFn = require('./retryableFn.cjs');
 var wrapMethodWithCallback = require('./wrapMethodWithCallback/wrapMethodWithCallback.cjs');
 var DeferredPromise = require('./DeferredPromise/DeferredPromise.cjs');
@@ -55,12 +56,18 @@ var formatNumberText = require('./formatNumberText/formatNumberText.cjs');
 var ceil = require('./ceil/ceil.cjs');
 var trimEnd = require('./trimEnd/trimEnd.cjs');
 var isLedgerAddressViaVerifiedCredentials = require('./isLedgerAddressViaVerifiedCredentials.cjs');
+var nativeMobileOauthStateParam = require('./nativeMobileOauthStateParam.cjs');
+var eip6963Provider = require('./eip6963/eip6963Provider.cjs');
 var runSafe = require('./runSafe/runSafe.cjs');
 var PlatformService = require('./services/PlatformService/PlatformService.cjs');
 var createBrowserPlatformService = require('./services/PlatformService/createBrowserPlatformService/createBrowserPlatformService.cjs');
 var FetchService = require('./services/FetchService/FetchService.cjs');
+var Oauth2Service = require('./services/Oauth2Service/Oauth2Service.cjs');
+var createWindowOauth2Service = require('./services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.cjs');
 var template = require('./template/template.cjs');
 var get = require('./get/get.cjs');
+var hexToString = require('./hexToString/hexToString.cjs');
+var isHex = require('./isHex/isHex.cjs');
 
 
 
@@ -96,6 +103,8 @@ exports.CookieInvalidError = CookieInvalidError.CookieInvalidError;
 exports.AccessBlockedError = AccessBlockedError.AccessBlockedError;
 exports.EmbeddedWalletException = EmbeddedWalletException.EmbeddedWalletException;
 exports.MfaInvalidOtpError = MfaInvalidOtpError.MfaInvalidOtpError;
+exports.ExternalAuthError = ExternalAuthError.ExternalAuthError;
+exports.WalletAddressMismatchError = WalletAddressMismatchError.WalletAddressMismatchError;
 exports.CancellablePromise = CancellablePromise.CancellablePromise;
 exports.isFunction = isFunction.isFunction;
 exports.getAndroidVersion = isMobile.getAndroidVersion;
@@ -115,9 +124,6 @@ exports.bufferToBase64 = bufferToBase64.bufferToBase64;
 exports.last = last.last;
 exports.getProvidersFromWindow = getProvidersFromWindow.getProvidersFromWindow;
 exports.sleep = sleep.sleep;
-exports.getChain = getOrMapViemChain.getChain;
-exports.getOrMapViemChain = getOrMapViemChain.getOrMapViemChain;
-exports.mapChain = getOrMapViemChain.mapChain;
 exports.FALLBACK_UNDEFINED = retryableFn.FALLBACK_UNDEFINED;
 exports.retryableFn = retryableFn.retryableFn;
 exports.wrapMethodWithCallback = wrapMethodWithCallback.wrapMethodWithCallback;
@@ -130,9 +136,16 @@ exports.formatNumberText = formatNumberText.formatNumberText;
 exports.ceil = ceil.ceil;
 exports.trimEnd = trimEnd.trimEnd;
 exports.isLedgerAddressViaVerifiedCredentials = isLedgerAddressViaVerifiedCredentials.isLedgerAddressViaVerifiedCredentials;
+exports.nativeMobileOauthStateParam = nativeMobileOauthStateParam.nativeMobileOauthStateParam;
+exports.Eip6963Provider = eip6963Provider.Eip6963Provider;
+exports.Eip6963ProviderSingleton = eip6963Provider.Eip6963ProviderSingleton;
 exports.runSafe = runSafe.runSafe;
 exports.PlatformService = PlatformService.PlatformService;
 exports.createBrowserPlatformService = createBrowserPlatformService.createBrowserPlatformService;
 exports.FetchService = FetchService.FetchService;
+exports.Oauth2Service = Oauth2Service.Oauth2Service;
+exports.createWindowOauth2Service = createWindowOauth2Service.createWindowOauth2Service;
 exports.template = template.template;
 exports.get = get.get;
+exports.hexToString = hexToString.hexToString;
+exports.isHex = isHex.isHex;

package/src/index.d.ts

@@ -9,7 +9,6 @@ export * from './bufferToBase64';
 export * from './last';
 export * from './getProvidersFromWindow';
 export * from './sleep';
-export * from './getOrMapViemChain';
 export * from './retryableFn';
 export * from './wrapMethodWithCallback';
 export * from './DeferredPromise';
@@ -21,8 +20,13 @@ export * from './formatNumberText';
 export * from './ceil';
 export * from './trimEnd';
 export * from './isLedgerAddressViaVerifiedCredentials';
+export * from './nativeMobileOauthStateParam';
+export * from './eip6963';
 export { runSafe } from './runSafe';
 export { PlatformService, createBrowserPlatformService, type IPlatformService, } from './services/PlatformService';
 export { FetchService } from './services/FetchService';
+export { Oauth2Service, type GetOauthCodeError, type GetOauthCodeProps, type IOauth2Service, createWindowOauth2Service, } from './services/Oauth2Service';
 export { template } from './template';
 export { get } from './get';
+export { hexToString } from './hexToString';
+export { isHex } from './isHex';

package/src/index.js

@@ -31,6 +31,8 @@ export { CookieInvalidError } from './errors/CookieInvalidError.js';
 export { AccessBlockedError } from './errors/AccessBlockedError.js';
 export { EmbeddedWalletException } from './errors/EmbeddedWalletException.js';
 export { MfaInvalidOtpError } from './errors/MfaInvalidOtpError.js';
+export { ExternalAuthError } from './errors/ExternalAuthError.js';
+export { WalletAddressMismatchError } from './errors/WalletAddressMismatchError.js';
 export { CancellablePromise } from './CancellablePromise/CancellablePromise.js';
 export { isFunction } from './isFunction/isFunction.js';
 export { getAndroidVersion, isAndroid, isIOS, isIPad, isIPhone, isIPhone8OrEarlier, isLegacySafari, isMobile, isSamsungBrowser, isWindows } from './isMobile.js';
@@ -39,7 +41,6 @@ export { bufferToBase64 } from './bufferToBase64.js';
 export { last } from './last.js';
 export { getProvidersFromWindow } from './getProvidersFromWindow.js';
 export { sleep } from './sleep/sleep.js';
-export { getChain, getOrMapViemChain, mapChain } from './getOrMapViemChain.js';
 export { FALLBACK_UNDEFINED, retryableFn } from './retryableFn.js';
 export { wrapMethodWithCallback } from './wrapMethodWithCallback/wrapMethodWithCallback.js';
 export { DeferredPromise } from './DeferredPromise/DeferredPromise.js';
@@ -51,9 +52,15 @@ export { formatNumberText } from './formatNumberText/formatNumberText.js';
 export { ceil } from './ceil/ceil.js';
 export { trimEnd } from './trimEnd/trimEnd.js';
 export { isLedgerAddressViaVerifiedCredentials } from './isLedgerAddressViaVerifiedCredentials.js';
+export { nativeMobileOauthStateParam } from './nativeMobileOauthStateParam.js';
+export { Eip6963Provider, Eip6963ProviderSingleton } from './eip6963/eip6963Provider.js';
 export { runSafe } from './runSafe/runSafe.js';
 export { PlatformService } from './services/PlatformService/PlatformService.js';
 export { createBrowserPlatformService } from './services/PlatformService/createBrowserPlatformService/createBrowserPlatformService.js';
 export { FetchService } from './services/FetchService/FetchService.js';
+export { Oauth2Service } from './services/Oauth2Service/Oauth2Service.js';
+export { createWindowOauth2Service } from './services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.js';
 export { template } from './template/template.js';
 export { get } from './get/get.js';
+export { hexToString } from './hexToString/hexToString.js';
+export { isHex } from './isHex/isHex.js';

package/src/isHex/index.d.ts

@@ -0,0 +1 @@
+export { isHex } from './isHex';

package/src/isHex/isHex.cjs

@@ -0,0 +1,20 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Checks if the provided string is a valid hexadecimal string.
+ * @param str The string to check.
+ * @returns `true` if the string is a valid hexadecimal string, `false` otherwise.
+ */
+const isHex = (str) => {
+    if (typeof str !== 'string') {
+        throw new Error('Input must be a string');
+    }
+    const normalizedStr = str.startsWith('0x') ? str.substring(2) : str;
+    const regex = /^[0-9a-fA-F]+$/;
+    return regex.test(normalizedStr);
+};
+
+exports.isHex = isHex;

package/src/isHex/isHex.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if the provided string is a valid hexadecimal string.
+ * @param str The string to check.
+ * @returns `true` if the string is a valid hexadecimal string, `false` otherwise.
+ */
+export declare const isHex: (str: string) => boolean;

package/src/isHex/isHex.js

@@ -0,0 +1,16 @@
+'use client'
+/**
+ * Checks if the provided string is a valid hexadecimal string.
+ * @param str The string to check.
+ * @returns `true` if the string is a valid hexadecimal string, `false` otherwise.
+ */
+const isHex = (str) => {
+    if (typeof str !== 'string') {
+        throw new Error('Input must be a string');
+    }
+    const normalizedStr = str.startsWith('0x') ? str.substring(2) : str;
+    const regex = /^[0-9a-fA-F]+$/;
+    return regex.test(normalizedStr);
+};
+
+export { isHex };

package/src/nativeMobileOauthStateParam.cjs

@@ -0,0 +1,13 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Represents the value that separates the random string from the
+ * mobile deeplink URL in the state param from the oauth messages
+ * emitted from native mobile apps.
+ */
+const nativeMobileOauthStateParam = '_client-redirect:';
+
+exports.nativeMobileOauthStateParam = nativeMobileOauthStateParam;

package/src/nativeMobileOauthStateParam.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents the value that separates the random string from the
+ * mobile deeplink URL in the state param from the oauth messages
+ * emitted from native mobile apps.
+ */
+export declare const nativeMobileOauthStateParam = "_client-redirect:";
+/**
+ * Represents the format of the state variable exchanged in oauth2 messages
+ * by native mobile devices.
+ *
+ * It has a random state string followed byt the client redirect URL as configured
+ * in the Client.
+ */
+export type NativeMobileOauthState = `${string}${typeof nativeMobileOauthStateParam}${string}`;

package/src/nativeMobileOauthStateParam.js

@@ -0,0 +1,9 @@
+'use client'
+/**
+ * Represents the value that separates the random string from the
+ * mobile deeplink URL in the state param from the oauth messages
+ * emitted from native mobile apps.
+ */
+const nativeMobileOauthStateParam = '_client-redirect:';
+
+export { nativeMobileOauthStateParam };

package/src/retryableFn.cjs

@@ -9,8 +9,12 @@ require('./errors/TransactionGasCannotBeSponsoredError.cjs');
 require('./logger/logger.cjs');
 require('./bufferPolyfill.cjs');
 var sleep = require('./sleep/sleep.cjs');
-require('viem/chains');
+require('./services/PlatformService/PlatformService.cjs');
 require('tldts');
+require('./services/FetchService/FetchService.cjs');
+require('./services/Oauth2Service/Oauth2Service.cjs');
+require('@dynamic-labs/types');
+require('@dynamic-labs/sdk-api-core');
 
 const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
 const retryableFn = (fn_1, ...args_1) => _tslib.__awaiter(void 0, [fn_1, ...args_1], void 0, function* (fn, options = {}) {

package/src/retryableFn.js

@@ -5,8 +5,12 @@ import './errors/TransactionGasCannotBeSponsoredError.js';
 import './logger/logger.js';
 import './bufferPolyfill.js';
 import { sleep } from './sleep/sleep.js';
-import 'viem/chains';
+import './services/PlatformService/PlatformService.js';
 import 'tldts';
+import './services/FetchService/FetchService.js';
+import './services/Oauth2Service/Oauth2Service.js';
+import '@dynamic-labs/types';
+import '@dynamic-labs/sdk-api-core';
 
 const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
 const retryableFn = (fn_1, ...args_1) => __awaiter(void 0, [fn_1, ...args_1], void 0, function* (fn, options = {}) {

package/src/services/FetchService/FetchService.cjs

@@ -3,22 +3,27 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+var _a, _FetchService_implementation;
 /**
  * Class implementing the fetch service with a configurable fetch implementation.
  */
 class FetchService {
     static get implementation() {
-        if (!FetchService._implementation) {
+        if (!_tslib.__classPrivateFieldGet(_a, _a, "f", _FetchService_implementation)) {
             return { fetch: window.fetch.bind(window) };
         }
-        return FetchService._implementation;
+        return _tslib.__classPrivateFieldGet(_a, _a, "f", _FetchService_implementation);
     }
-    static setImplementation(implementation) {
-        FetchService._implementation = implementation;
+    static set implementation(implementation) {
+        _tslib.__classPrivateFieldSet(_a, _a, implementation, "f", _FetchService_implementation);
     }
     static get fetch() {
-        return FetchService.implementation.fetch;
+        return _a.implementation.fetch;
     }
 }
+_a = FetchService;
+_FetchService_implementation = { value: void 0 };
 
 exports.FetchService = FetchService;

package/src/services/FetchService/FetchService.d.ts

@@ -3,8 +3,8 @@ import { IFetchService } from './types';
  * Class implementing the fetch service with a configurable fetch implementation.
  */
 export declare class FetchService {
-    static _implementation: IFetchService;
+    #private;
     static get implementation(): IFetchService;
-    static setImplementation(implementation: IFetchService): void;
+    static set implementation(implementation: IFetchService);
     static get fetch(): (input: RequestInfo, init?: RequestInit | undefined) => Promise<Response>;
 }

package/src/services/FetchService/FetchService.js

@@ -1,20 +1,25 @@
 'use client'
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../../_virtual/_tslib.js';
+
+var _a, _FetchService_implementation;
 /**
  * Class implementing the fetch service with a configurable fetch implementation.
  */
 class FetchService {
     static get implementation() {
-        if (!FetchService._implementation) {
+        if (!__classPrivateFieldGet(_a, _a, "f", _FetchService_implementation)) {
             return { fetch: window.fetch.bind(window) };
         }
-        return FetchService._implementation;
+        return __classPrivateFieldGet(_a, _a, "f", _FetchService_implementation);
     }
-    static setImplementation(implementation) {
-        FetchService._implementation = implementation;
+    static set implementation(implementation) {
+        __classPrivateFieldSet(_a, _a, implementation, "f", _FetchService_implementation);
     }
     static get fetch() {
-        return FetchService.implementation.fetch;
+        return _a.implementation.fetch;
     }
 }
+_a = FetchService;
+_FetchService_implementation = { value: void 0 };
 
 export { FetchService };

package/src/services/Oauth2Service/Oauth2Service.cjs

@@ -0,0 +1,38 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var types = require('@dynamic-labs/types');
+var createWindowOauth2Service = require('./createWindowOauth2Service/createWindowOauth2Service.cjs');
+
+var _a, _Oauth2Service_implementation;
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class Oauth2Service {
+    static get implementation() {
+        if (!_tslib.__classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation)) {
+            return createWindowOauth2Service.createWindowOauth2Service();
+        }
+        return _tslib.__classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation);
+    }
+    static set implementation(implementation) {
+        _tslib.__classPrivateFieldSet(_a, _a, implementation, "f", _Oauth2Service_implementation);
+    }
+    static get getOauthCode() {
+        return _a.implementation.getOauthCode;
+    }
+}
+_a = Oauth2Service;
+_Oauth2Service_implementation = { value: void 0 };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+Oauth2Service.isGetOauthCodeError = (error) => error === 'user-cancelled' ||
+    (typeof error === 'object' &&
+        'code' in error &&
+        Object.values(types.SocialOAuthErrorCode).includes(error.code) &&
+        'message' in error &&
+        typeof error.message === 'string');
+
+exports.Oauth2Service = Oauth2Service;

package/src/services/Oauth2Service/Oauth2Service.d.ts

@@ -0,0 +1,30 @@
+import { OauthResultResponse, Provider, ProviderEnum } from '@dynamic-labs/sdk-api-core';
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
+export type GetOauthCodeProps = {
+    provider: ProviderEnum;
+    apiProvider: Provider | undefined;
+    setIsProcessing: (value: boolean) => void;
+    onSettled?: VoidFunction;
+    getOAuthResultFromApi: () => Promise<OauthResultResponse | undefined>;
+    state: string;
+    oauthLoginUrl: URL;
+    sessionTimeout: number;
+    isMobile?: boolean;
+};
+export type IOauth2Service = {
+    getOauthCode: (props: GetOauthCodeProps) => Promise<string>;
+};
+export type GetOauthCodeError = 'user-cancelled' | {
+    code: SocialOAuthErrorCode;
+    message: string;
+};
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+export declare class Oauth2Service {
+    #private;
+    static get implementation(): IOauth2Service;
+    static set implementation(implementation: IOauth2Service);
+    static get getOauthCode(): (props: GetOauthCodeProps) => Promise<string>;
+    static isGetOauthCodeError: (error: any) => error is GetOauthCodeError;
+}

package/src/services/Oauth2Service/Oauth2Service.js

@@ -0,0 +1,34 @@
+'use client'
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../../_virtual/_tslib.js';
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
+import { createWindowOauth2Service } from './createWindowOauth2Service/createWindowOauth2Service.js';
+
+var _a, _Oauth2Service_implementation;
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class Oauth2Service {
+    static get implementation() {
+        if (!__classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation)) {
+            return createWindowOauth2Service();
+        }
+        return __classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation);
+    }
+    static set implementation(implementation) {
+        __classPrivateFieldSet(_a, _a, implementation, "f", _Oauth2Service_implementation);
+    }
+    static get getOauthCode() {
+        return _a.implementation.getOauthCode;
+    }
+}
+_a = Oauth2Service;
+_Oauth2Service_implementation = { value: void 0 };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+Oauth2Service.isGetOauthCodeError = (error) => error === 'user-cancelled' ||
+    (typeof error === 'object' &&
+        'code' in error &&
+        Object.values(SocialOAuthErrorCode).includes(error.code) &&
+        'message' in error &&
+        typeof error.message === 'string');
+
+export { Oauth2Service };

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.cjs

@@ -0,0 +1,170 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../_virtual/_tslib.cjs');
+var types = require('@dynamic-labs/types');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var logger = require('../../../logger/logger.cjs');
+
+const providersWithoutWindowOpenerReference = ['twitter'];
+let authWindowInterval;
+const createWindowOauth2Service = () => ({
+    getOauthCode: ({ apiProvider, provider, setIsProcessing, state, oauthLoginUrl, getOAuthResultFromApi, sessionTimeout, isMobile, onSettled, }) => new Promise((resolve, _reject) => {
+        // When we catch this error we assume it follows this type, so we must enforce it
+        // here to ensure the assumption is correct
+        const typedReject = (params) => _reject(params);
+        // Clear any potential pending timeouts and intervals
+        clearInterval(authWindowInterval);
+        const providersWaitingOauthMessage = {};
+        let shouldPool = false;
+        const authWindow = window.open('', '_blank', 'width=500,height=600');
+        const clearListeners = () => {
+            window.removeEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = false;
+        };
+        const handleWindowMessage = (event) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+            const message = event.data;
+            if (!(apiProvider === null || apiProvider === void 0 ? void 0 : apiProvider.redirectUrl)) {
+                return;
+            }
+            let expectedOrigin = window.location.origin;
+            if (!providersWithoutWindowOpenerReference.includes(provider)) {
+                try {
+                    const redirectUri = new URL(apiProvider.redirectUrl);
+                    expectedOrigin = redirectUri.origin;
+                }
+                catch (e) {
+                    logger.logger.error('Failed to parse social provider redirect url', {
+                        error: e,
+                    });
+                    return;
+                }
+            }
+            if ((message === null || message === void 0 ? void 0 : message.type) === 'origin_check' && authWindow) {
+                logger.logger.debug('Origin check message received. Sending response now.', {
+                    data: message,
+                    expectedOrigin,
+                });
+                authWindow.postMessage('origin_check_response', expectedOrigin);
+                return;
+            }
+            const isAuthorizationMessage = (message === null || message === void 0 ? void 0 : message.type) === 'authorization_response';
+            if (isAuthorizationMessage) {
+                logger.logger.debug('Message received', { data: message });
+            }
+            const isExpectedOrigin = event.origin === expectedOrigin;
+            const isValidMessage = isAuthorizationMessage &&
+                (message === null || message === void 0 ? void 0 : message.provider) === provider &&
+                isExpectedOrigin;
+            // don't process invalid messages for provider
+            if (!isValidMessage) {
+                return;
+            }
+            setIsProcessing(true);
+            if (!providersWaitingOauthMessage[provider]) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.SESSION_TIMEOUT,
+                    message: `Connecting ${provider} account session timeout.`,
+                });
+                return;
+            }
+            clearListeners();
+            const { code, error, state: authState } = message;
+            if (error && error !== 'undefined') {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: ${error}`,
+                });
+                return;
+            }
+            // check that the state we receive from message is the same state we calculated earlier
+            // this could be an attack
+            // this state check is used only by providers with an open window opener reference (eg, not twitter)
+            if (!providersWithoutWindowOpenerReference.includes(provider) &&
+                state !== authState) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: Invalid random state`,
+                });
+                return;
+            }
+            if (!code) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.NO_AUTH_CODE,
+                    message: `Failed to connect ${provider} social account: no authorization code`,
+                });
+                return;
+            }
+            resolve(code);
+            setIsProcessing(false);
+        });
+        if (!providersWaitingOauthMessage[provider]) {
+            window.addEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = true;
+        }
+        authWindow === null || authWindow === void 0 ? void 0 : authWindow.location.assign(oauthLoginUrl);
+        if (!providersWithoutWindowOpenerReference.includes(provider)) {
+            // For provider that support window.opener, we need to clear all states/listeners when the window is closed
+            authWindowInterval = setInterval(() => {
+                if (!(authWindow === null || authWindow === void 0 ? void 0 : authWindow.closed))
+                    return;
+                clearInterval(authWindowInterval);
+                setIsProcessing(false);
+                // user didn't complete oauth
+                if (providersWaitingOauthMessage[provider])
+                    typedReject('user-cancelled');
+            }, 2000);
+        }
+        else {
+            // For provider that don't support window.opener, we need to use a timeout to pool the oauth result
+            // If we don't get a valid result in {async sessionTimeout} ms, we'll assume the user closed the window
+            // and we'll clear all states/listeners
+            const poolOauthResult = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+                if (!shouldPool)
+                    return;
+                const result = yield getOAuthResultFromApi();
+                if (!shouldPool)
+                    return;
+                if ((result === null || result === void 0 ? void 0 : result.status) !== sdkApiCore.OauthResultStatus.Completed) {
+                    authWindowInterval = setTimeout(() => {
+                        poolOauthResult();
+                    }, 1000);
+                    return;
+                }
+                shouldPool = false;
+                const authMessage = {
+                    code: result === null || result === void 0 ? void 0 : result.code,
+                    error: result === null || result === void 0 ? void 0 : result.error,
+                    provider,
+                    type: 'authorization_response',
+                };
+                window.postMessage(authMessage, '*');
+            });
+            // start pooling oauth result
+            shouldPool = true;
+            poolOauthResult();
+            // if this is mobile, set a longer timeout to allow the user to login to the provider in the browser
+            let authWindowTimeout = sessionTimeout;
+            if (isMobile) {
+                authWindowTimeout = authWindowTimeout * 3;
+            }
+            authWindowInterval = setTimeout(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+                shouldPool = false;
+                // clear all states/listeners, assuming user closed the window before completing oauth
+                if (providersWaitingOauthMessage[provider]) {
+                    clearListeners();
+                    typedReject({
+                        code: types.SocialOAuthErrorCode.OAUTH_WINDOW_TIMEOUT,
+                        message: `Connecting ${provider} account window timeout.`,
+                    });
+                }
+                setIsProcessing(false);
+                onSettled === null || onSettled === void 0 ? void 0 : onSettled();
+            }), authWindowTimeout);
+        }
+    }),
+});
+
+exports.createWindowOauth2Service = createWindowOauth2Service;

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.d.ts

@@ -0,0 +1,2 @@
+import { IOauth2Service } from '../Oauth2Service';
+export declare const createWindowOauth2Service: () => IOauth2Service;