@dynamic-labs/utils 3.0.0-alpha.13 → 3.0.0-alpha.14

package/CHANGELOG.md

@@ -1,4 +1,41 @@
 
+## [3.0.0-alpha.14](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.13...v3.0.0-alpha.14) (2024-07-09)
+
+
+### ⚠ BREAKING CHANGES
+
+* remove setPrimaryWallet in favor of useSwitchWallet (#6212)
+* move getBalance method to wallet so it can be fetched for any wallet not just the active one (#6200)
+* make Wallet a class instead of just a type (#6094)
+
+### Features
+
+* add @dynamic-labs/solana-extension ([#6140](https://github.com/dynamic-labs/DynamicAuth/issues/6140)) ([c0e2a06](https://github.com/dynamic-labs/DynamicAuth/commit/c0e2a067dd83163094b58a15696df8654da47c65))
+* add solana support for multi-asset ([#6222](https://github.com/dynamic-labs/DynamicAuth/issues/6222)) ([9660d79](https://github.com/dynamic-labs/DynamicAuth/commit/9660d7962f1fb01011d68397bb367fdfc5335ca9))
+
+
+### Bug Fixes
+
+* allow closing re-connect wallet modal ([#6250](https://github.com/dynamic-labs/DynamicAuth/issues/6250)) ([55ba25b](https://github.com/dynamic-labs/DynamicAuth/commit/55ba25bd3e907629aaa26e788885bfa38f8fe350))
+* move getBalance method to wallet so it can be fetched for any wallet not just the active one ([#6200](https://github.com/dynamic-labs/DynamicAuth/issues/6200)) ([ee94773](https://github.com/dynamic-labs/DynamicAuth/commit/ee94773df9b31462a325666760fcf1fc70dec68a))
+* move getNameService method to wallet so name service data can be fetched for any wallet ([#6205](https://github.com/dynamic-labs/DynamicAuth/issues/6205)) ([6671ae9](https://github.com/dynamic-labs/DynamicAuth/commit/6671ae92532ffc1889e24519e75f47d336ac0da6))
+* relax phone number length validation ([#6226](https://github.com/dynamic-labs/DynamicAuth/issues/6226)) ([f0969b4](https://github.com/dynamic-labs/DynamicAuth/commit/f0969b4fbdafde07125cddecb16b4bfd011ea65e))
+* sdkHasLoaded flipping back to false with otp ([#6242](https://github.com/dynamic-labs/DynamicAuth/issues/6242)) ([32ad9dd](https://github.com/dynamic-labs/DynamicAuth/commit/32ad9dd2dae7775f494506773fb343fe1a249c65))
+* send transaction demo undefined address/value ([#6248](https://github.com/dynamic-labs/DynamicAuth/issues/6248)) ([036a511](https://github.com/dynamic-labs/DynamicAuth/commit/036a511fb848ef461edd9b7a5d79d478b0f1cf23))
+* set last active account on accountChange request ([#6218](https://github.com/dynamic-labs/DynamicAuth/issues/6218)) ([05797d2](https://github.com/dynamic-labs/DynamicAuth/commit/05797d292aab8b4de02555594d4d1bbd4c9543eb))
+* show ledger toggle when linking wallet ([#6202](https://github.com/dynamic-labs/DynamicAuth/issues/6202)) ([a449c0b](https://github.com/dynamic-labs/DynamicAuth/commit/a449c0bfc4e3a75ccd7084b930c48fbd6c14f691))
+* show user wallet in profile view on single wallet mode even if it's not primary ([#6187](https://github.com/dynamic-labs/DynamicAuth/issues/6187)) ([ffaaeb2](https://github.com/dynamic-labs/DynamicAuth/commit/ffaaeb2c6cbb2868a381d85451ae5574024156bb))
+* stop auto-switching to connected secondary wallet if primary wallet is not connected ([#6196](https://github.com/dynamic-labs/DynamicAuth/issues/6196)) ([4e8bcd2](https://github.com/dynamic-labs/DynamicAuth/commit/4e8bcd2d02d3fca54a0ed29c45b386ae99266b84))
+* stop coinbase and solflare popups when secondary ([#6225](https://github.com/dynamic-labs/DynamicAuth/issues/6225)) ([7e9c104](https://github.com/dynamic-labs/DynamicAuth/commit/7e9c1049a09c9fd513c9a2a746d6baac916f1bf4))
+* stop sending double sign request on network switch ([e325709](https://github.com/dynamic-labs/DynamicAuth/commit/e325709bb5d2d1331fe16cc705398fc7b1cc292a))
+* tunrkey solana signer accept uint8array message ([#6137](https://github.com/dynamic-labs/DynamicAuth/issues/6137)) ([70f89ce](https://github.com/dynamic-labs/DynamicAuth/commit/70f89ce0dafa4c99b318c9c5adce59083cd6d284))
+* update formatting of phantom bitcoin publickey ([#6210](https://github.com/dynamic-labs/DynamicAuth/issues/6210)) ([f58cea9](https://github.com/dynamic-labs/DynamicAuth/commit/f58cea99333fd7c6af8f56f637ee32f1f7ce8d76))
+* use white color in farcaster qr code when in dark mode ([#6245](https://github.com/dynamic-labs/DynamicAuth/issues/6245)) ([a91958d](https://github.com/dynamic-labs/DynamicAuth/commit/a91958d8773be138da8f54791c4c67866257bbad))
+
+
+* make Wallet a class instead of just a type ([#6094](https://github.com/dynamic-labs/DynamicAuth/issues/6094)) ([6dc4672](https://github.com/dynamic-labs/DynamicAuth/commit/6dc4672951cfadc22a6c569e74eae3485bd472f3))
+* remove setPrimaryWallet in favor of useSwitchWallet ([#6212](https://github.com/dynamic-labs/DynamicAuth/issues/6212)) ([de125e1](https://github.com/dynamic-labs/DynamicAuth/commit/de125e1ebbc20507e4ec07f337f5f5fd13aabcbe))
+
 ## [3.0.0-alpha.13](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.12...v3.0.0-alpha.13) (2024-06-27)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/utils",
-  "version": "3.0.0-alpha.13",
+  "version": "3.0.0-alpha.14",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
@@ -28,8 +28,8 @@
   "dependencies": {
     "@dynamic-labs/sdk-api-core": "0.0.470",
     "tldts": "6.0.16",
-    "@dynamic-labs/logger": "3.0.0-alpha.13",
-    "@dynamic-labs/types": "3.0.0-alpha.13",
+    "@dynamic-labs/logger": "3.0.0-alpha.14",
+    "@dynamic-labs/types": "3.0.0-alpha.14",
     "buffer": "6.0.3",
     "stream": "0.0.2"
   },

package/src/errors/WalletAddressMismatchError.cjs

@@ -0,0 +1,17 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var DynamicError = require('./DynamicError.cjs');
+
+class WalletAddressMismatchError extends DynamicError.DynamicError {
+    constructor(message, { activeAddress, expectedAddress, walletName, }) {
+        super(message, 'wallet_address_mismatch_error');
+        this.expectedAddress = expectedAddress;
+        this.activeAddress = activeAddress;
+        this.walletName = walletName;
+    }
+}
+
+exports.WalletAddressMismatchError = WalletAddressMismatchError;

package/src/errors/WalletAddressMismatchError.d.ts

@@ -0,0 +1,11 @@
+import { DynamicError } from './DynamicError';
+export declare class WalletAddressMismatchError extends DynamicError {
+    expectedAddress: string | undefined;
+    activeAddress: string | undefined;
+    walletName: string | undefined;
+    constructor(message: string, { activeAddress, expectedAddress, walletName, }: {
+        activeAddress?: string;
+        expectedAddress?: string;
+        walletName?: string;
+    });
+}

package/src/errors/WalletAddressMismatchError.js

@@ -0,0 +1,13 @@
+'use client'
+import { DynamicError } from './DynamicError.js';
+
+class WalletAddressMismatchError extends DynamicError {
+    constructor(message, { activeAddress, expectedAddress, walletName, }) {
+        super(message, 'wallet_address_mismatch_error');
+        this.expectedAddress = expectedAddress;
+        this.activeAddress = activeAddress;
+        this.walletName = walletName;
+    }
+}
+
+export { WalletAddressMismatchError };

package/src/errors/index.d.ts

@@ -30,3 +30,4 @@ export * from './AccessBlockedError';
 export * from './EmbeddedWalletException';
 export * from './MfaInvalidOtpError';
 export * from './ExternalAuthError';
+export * from './WalletAddressMismatchError';

package/src/handleMobileWalletRedirect/handleMobileWalletRedirect.cjs

@@ -10,6 +10,9 @@ var isMobile = require('../isMobile.cjs');
 require('../../_virtual/_tslib.cjs');
 require('../bufferPolyfill.cjs');
 require('tldts');
+require('../services/Oauth2Service/Oauth2Service.cjs');
+require('@dynamic-labs/types');
+require('@dynamic-labs/sdk-api-core');
 
 const handleMobileWalletRedirect = ({ nativeLink, universalLink, }) => {
     const url = encodeURIComponent(window.location.toString());

package/src/handleMobileWalletRedirect/handleMobileWalletRedirect.js

@@ -6,6 +6,9 @@ import { isSamsungBrowser } from '../isMobile.js';
 import '../../_virtual/_tslib.js';
 import '../bufferPolyfill.js';
 import 'tldts';
+import '../services/Oauth2Service/Oauth2Service.js';
+import '@dynamic-labs/types';
+import '@dynamic-labs/sdk-api-core';
 
 const handleMobileWalletRedirect = ({ nativeLink, universalLink, }) => {
     const url = encodeURIComponent(window.location.toString());

package/src/index.cjs

@@ -36,6 +36,7 @@ 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');
@@ -60,6 +61,8 @@ 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');
@@ -100,6 +103,7 @@ 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;
@@ -137,6 +141,8 @@ 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;

package/src/index.d.ts

@@ -24,6 +24,7 @@ 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';

package/src/index.js

@@ -32,6 +32,7 @@ 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';
@@ -56,6 +57,8 @@ 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';

package/src/retryableFn.cjs

@@ -10,6 +10,9 @@ require('./logger/logger.cjs');
 require('./bufferPolyfill.cjs');
 var sleep = require('./sleep/sleep.cjs');
 require('tldts');
+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

@@ -6,6 +6,9 @@ import './logger/logger.js';
 import './bufferPolyfill.js';
 import { sleep } from './sleep/sleep.js';
 import 'tldts';
+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/Oauth2Service/Oauth2Service.cjs

@@ -0,0 +1,34 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var types = require('@dynamic-labs/types');
+var createWindowOauth2Service = require('./createWindowOauth2Service/createWindowOauth2Service.cjs');
+
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class Oauth2Service {
+    static get implementation() {
+        if (!Oauth2Service._implementation) {
+            return createWindowOauth2Service.createWindowOauth2Service();
+        }
+        return Oauth2Service._implementation;
+    }
+    static setImplementation(implementation) {
+        Oauth2Service._implementation = implementation;
+    }
+    static get getOauthCode() {
+        return Oauth2Service.implementation.getOauthCode;
+    }
+}
+// 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 {
+    static _implementation: IOauth2Service;
+    static get implementation(): IOauth2Service;
+    static setImplementation(implementation: IOauth2Service): void;
+    static get getOauthCode(): (props: GetOauthCodeProps) => Promise<string>;
+    static isGetOauthCodeError: (error: any) => error is GetOauthCodeError;
+}

package/src/services/Oauth2Service/Oauth2Service.js

@@ -0,0 +1,30 @@
+'use client'
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
+import { createWindowOauth2Service } from './createWindowOauth2Service/createWindowOauth2Service.js';
+
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class Oauth2Service {
+    static get implementation() {
+        if (!Oauth2Service._implementation) {
+            return createWindowOauth2Service();
+        }
+        return Oauth2Service._implementation;
+    }
+    static setImplementation(implementation) {
+        Oauth2Service._implementation = implementation;
+    }
+    static get getOauthCode() {
+        return Oauth2Service.implementation.getOauthCode;
+    }
+}
+// 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;

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.js

@@ -0,0 +1,166 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
+import { OauthResultStatus } from '@dynamic-labs/sdk-api-core';
+import { logger } from '../../../logger/logger.js';
+
+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) => __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.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.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.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: SocialOAuthErrorCode.SESSION_TIMEOUT,
+                    message: `Connecting ${provider} account session timeout.`,
+                });
+                return;
+            }
+            clearListeners();
+            const { code, error, state: authState } = message;
+            if (error && error !== 'undefined') {
+                typedReject({
+                    code: 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: SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: Invalid random state`,
+                });
+                return;
+            }
+            if (!code) {
+                typedReject({
+                    code: 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 = () => __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) !== 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(() => __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: SocialOAuthErrorCode.OAUTH_WINDOW_TIMEOUT,
+                        message: `Connecting ${provider} account window timeout.`,
+                    });
+                }
+                setIsProcessing(false);
+                onSettled === null || onSettled === void 0 ? void 0 : onSettled();
+            }), authWindowTimeout);
+        }
+    }),
+});
+
+export { createWindowOauth2Service };

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

@@ -0,0 +1 @@
+export * from './createWindowOauth2Service';

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

@@ -0,0 +1,2 @@
+export * from './Oauth2Service';
+export * from './createWindowOauth2Service';