@imtbl/sdk 0.2.0-alpha → 0.2.2-alpha

package/dist/checkout_widgets.d.ts

@@ -15288,8 +15288,8 @@ interface ImtblWalletProps extends React.DetailedHTMLProps<React.HTMLAttributes<
  * @property {string | undefined} walletProvider - The preferred wallet provider to connect to.
  * @property {string | undefined} widgetConfig - The configuration for the swap widget.
  * @property {string | undefined} amount - The amount to swap.
- * @property {string | undefined} fromContractAddress - The contract address of the source token.
- * @property {string | undefined} toContractAddress - The contract address of the destination token.
+ * @property {string | undefined} fromContractAddress - The contract address of the source token. If the string is 'NATIVE' then the native token will be used.
+ * @property {string | undefined} toContractAddress - The contract address of the destination token. If the string is 'NATIVE' then the native token will be used.
  */
 interface ImtblSwapProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     walletProvider?: string;
@@ -15344,9 +15344,9 @@ declare function ConnectReact(): JSX.Element;
  * @interface SwapReactProps
  * @property {WalletProviderName | undefined} walletProvider - The name of the wallet provider.
  * @property {Web3Provider | undefined} provider - The Web3 provider.
- * @property {string | undefined} fromContractAddress - The address of the contract swapping from.
+ * @property {string | undefined} fromContractAddress - The address of the contract swapping from. If the string is 'NATIVE' then the native token is used.
  * @property {string | undefined} amount - The amount.
- * @property {string | undefined} toContractAddress - The address of the contract swapping to.
+ * @property {string | undefined} toContractAddress - The address of the contract swapping to. If the string is 'NATIVE' then the native token is used.
  */
 interface SwapReactProps {
     walletProvider?: WalletProviderName;

package/dist/checkout_widgets.js

@@ -4,7 +4,7 @@ import { useEffect } from 'react';
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.2.0-alpha";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.2.2-alpha";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/immutablex_client.js

@@ -16,7 +16,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.2.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.2.2-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build

package/dist/index.cjs

@@ -3,6 +3,7 @@
 var axios$2 = require('axios');
 var coreSdk = require('@imtbl/core-sdk');
 var oidcClientTs = require('oidc-client-ts');
+var jwt_decode = require('jwt-decode');
 var magicSdk = require('magic-sdk');
 var oidc = require('@magic-ext/oidc');
 var BN$2 = require('bn.js');
@@ -5456,7 +5457,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.2.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.2.2-alpha',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -5722,7 +5723,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.2.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.2.2-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -9999,6 +10000,43 @@ const withPassportError = async (fn, customErrorType) => {
     }
 };
 
+const keyCrendentials = 'passport_credentials';
+const validCredentialsMinTtlSec = 3600; // 1 hour
+class DeviceCredentialsManager {
+    saveCredentials(tokenResponse) {
+        localStorage.setItem(keyCrendentials, JSON.stringify(tokenResponse));
+    }
+    getCredentials() {
+        const credentialsJson = localStorage.getItem(keyCrendentials);
+        if (credentialsJson) {
+            return JSON.parse(credentialsJson);
+        }
+        return null;
+    }
+    areValid(tokenResponse) {
+        if (tokenResponse) {
+            const accessTokenValid = this.isTokenValid(tokenResponse.access_token);
+            const idTokenValid = this.isTokenValid(tokenResponse.id_token);
+            return accessTokenValid && idTokenValid;
+        }
+        return false;
+    }
+    isTokenValid(jwt) {
+        const tokenPayload = jwt_decode(jwt);
+        const expiresAt = tokenPayload.exp ?? 0;
+        const now = (Date.now() / 1000) + validCredentialsMinTtlSec;
+        return expiresAt > now;
+    }
+    clearCredentials() {
+        localStorage.removeItem(keyCrendentials);
+    }
+}
+
+const formUrlEncodedHeader = {
+    headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+    },
+};
 const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
     const baseConfiguration = {
         authority: authenticationDomain,
@@ -10024,12 +10062,19 @@ const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
     }
     return baseConfiguration;
 };
+function wait$1(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
 class AuthManager {
     userManager;
     config;
+    deviceCredentialsManager;
     constructor(config) {
         this.config = config;
         this.userManager = new oidcClientTs.UserManager(getAuthConfiguration(config));
+        this.deviceCredentialsManager = new DeviceCredentialsManager();
     }
     static mapOidcUserToDomainModel = (oidcUser) => {
         const passport = oidcUser.profile?.passport;
@@ -10059,6 +10104,27 @@ class AuthManager {
         }
         return user;
     };
+    static mapDeviceTokenResponseToDomainUserModel = (tokenResponse) => {
+        const idTokenPayload = jwt_decode(tokenResponse.id_token);
+        const user = {
+            idToken: tokenResponse.id_token,
+            accessToken: tokenResponse.access_token,
+            refreshToken: tokenResponse.refresh_token,
+            profile: {
+                sub: idTokenPayload.sub,
+                email: idTokenPayload.email,
+                nickname: idTokenPayload.nickname,
+            },
+        };
+        if (idTokenPayload?.passport?.imx_eth_address) {
+            user.imx = {
+                ethAddress: idTokenPayload?.passport?.imx_eth_address,
+                starkAddress: idTokenPayload?.passport?.imx_stark_address,
+                userAdminAddress: idTokenPayload?.passport?.imx_user_admin_address,
+            };
+        }
+        return user;
+    };
     async login() {
         return withPassportError(async () => {
             const popupWindowFeatures = { width: 410, height: 450 };
@@ -10071,9 +10137,104 @@ class AuthManager {
     async loginCallback() {
         return withPassportError(async () => this.userManager.signinPopupCallback(), PassportErrorType.AUTHENTICATION_ERROR);
     }
+    async loginWithDeviceFlow() {
+        return withPassportError(async () => {
+            const response = await axios$2.post(`${this.config.authenticationDomain}/oauth/device/code`, {
+                client_id: this.config.oidcConfiguration.clientId,
+                scope: this.config.oidcConfiguration.scope,
+                audience: this.config.oidcConfiguration.audience,
+            }, formUrlEncodedHeader);
+            return {
+                code: response.data.user_code,
+                deviceCode: response.data.device_code,
+                url: response.data.verification_uri_complete,
+                interval: response.data.interval,
+            };
+        }, PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    /* eslint-disable no-await-in-loop */
+    async connectImxDeviceFlow(deviceCode, interval, timeoutMs) {
+        return withPassportError(async () => {
+            const startTime = Date.now();
+            const loopCondition = true;
+            while (loopCondition) {
+                if (timeoutMs != null && Date.now() - startTime > timeoutMs) {
+                    throw new Error('Timed out');
+                }
+                await wait$1(interval * 1000);
+                try {
+                    const tokenResponse = await this.getDeviceFlowToken(deviceCode);
+                    const user = AuthManager.mapDeviceTokenResponseToDomainUserModel(tokenResponse);
+                    // Only persist credentials that contain the necessary data
+                    if (user.imx?.ethAddress && user.imx?.starkAddress && user.imx?.userAdminAddress) {
+                        this.deviceCredentialsManager.saveCredentials(tokenResponse);
+                    }
+                    return user;
+                }
+                catch (error) {
+                    if (axios$2.isAxiosError(error)) {
+                        const responseError = error.response?.data;
+                        switch (responseError.error) {
+                            case 'authorization_pending':
+                                break;
+                            case 'slow_down':
+                                break;
+                            case 'expired_token':
+                                throw new Error('Token expired, please log in again');
+                            case 'access_denied':
+                                throw new Error('User denied access');
+                            default:
+                                throw new Error('Error getting token');
+                        }
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            throw new Error('Failed to get credentials');
+        }, PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    /* eslint-enable no-await-in-loop */
+    async getDeviceFlowToken(deviceCode) {
+        const response = await axios$2.post(`${this.config.authenticationDomain}/oauth/token`, {
+            client_id: this.config.oidcConfiguration.clientId,
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+            device_code: deviceCode,
+        }, formUrlEncodedHeader);
+        return response.data;
+    }
+    async connectImxWithCredentials(tokenResponse) {
+        return withPassportError(async () => {
+            if (this.deviceCredentialsManager.areValid(tokenResponse)) {
+                // Credentials exist and are still valid
+                return AuthManager.mapDeviceTokenResponseToDomainUserModel(tokenResponse);
+            }
+            const refreshToken = tokenResponse?.refresh_token ?? null;
+            if (refreshToken) {
+                // Token is no longer valid, but refresh token can be used to a new one
+                const newTokenResponse = await this.refreshToken(refreshToken);
+                return AuthManager.mapDeviceTokenResponseToDomainUserModel(newTokenResponse);
+            }
+            return null;
+        }, PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    async refreshToken(refreshToken) {
+        const response = await axios$2.post(`${this.config.authenticationDomain}/oauth/token`, {
+            client_id: this.config.oidcConfiguration.clientId,
+            grant_type: 'refresh_token',
+            refresh_token: refreshToken,
+        }, formUrlEncodedHeader);
+        return response.data;
+    }
     async logout() {
         return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
     }
+    async logoutDeviceFlow() {
+        return withPassportError(async () => {
+            this.deviceCredentialsManager.clearCredentials();
+        }, PassportErrorType.LOGOUT_ERROR);
+    }
     async loginSilent() {
         return withPassportError(async () => {
             const existedUser = await this.getUser();
@@ -10090,12 +10251,28 @@ class AuthManager {
     async getUser() {
         return withPassportError(async () => {
             const oidcUser = await this.userManager.getUser();
-            if (!oidcUser) {
-                return null;
+            if (oidcUser) {
+                return AuthManager.mapOidcUserToDomainModel(oidcUser);
             }
-            return AuthManager.mapOidcUserToDomainModel(oidcUser);
+            const deviceToken = this.deviceCredentialsManager.getCredentials();
+            if (deviceToken) {
+                return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
+            }
+            return null;
         }, PassportErrorType.NOT_LOGGED_IN_ERROR);
     }
+    async getUserDeviceFlow() {
+        return withPassportError(async () => {
+            const deviceToken = this.deviceCredentialsManager.getCredentials();
+            if (deviceToken) {
+                return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
+            }
+            return null;
+        }, PassportErrorType.NOT_LOGGED_IN_ERROR);
+    }
+    checkStoredDeviceFlowCredentials() {
+        return this.deviceCredentialsManager.getCredentials();
+    }
 }
 
 class MagicAdapter {
@@ -10623,6 +10800,17 @@ class PassportImxProviderFactory {
         }
         return this.createProviderInstance(user);
     }
+    async getProviderWithDeviceFlow(deviceCode, interval, timeoutMs) {
+        const user = await this.authManager.connectImxDeviceFlow(deviceCode, interval, timeoutMs);
+        return this.createProviderInstance(user);
+    }
+    async getProviderWithCredentials(tokenResponse) {
+        const user = await this.authManager.connectImxWithCredentials(tokenResponse);
+        if (!user) {
+            return null;
+        }
+        return this.createProviderInstance(user);
+    }
     async createProviderInstance(user) {
         if (!user.idToken) {
             throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
@@ -10930,16 +11118,38 @@ class Passport {
     async connectImx() {
         return this.passportImxProviderFactory.getProvider();
     }
+    async loginWithDeviceFlow() {
+        return this.authManager.loginWithDeviceFlow();
+    }
+    async connectImxDeviceFlow(deviceCode, interval, timeoutMs) {
+        return this.passportImxProviderFactory.getProviderWithDeviceFlow(deviceCode, interval, timeoutMs);
+    }
+    /**
+     * @returns {boolean} the stored device flow credentials if they exist
+     */
+    checkStoredDeviceFlowCredentials() {
+        return this.authManager.checkStoredDeviceFlowCredentials();
+    }
+    async connectImxWithCredentials(tokenResponse) {
+        return this.passportImxProviderFactory.getProviderWithCredentials(tokenResponse);
+    }
     async loginCallback() {
         return this.authManager.loginCallback();
     }
     async logout() {
         return this.authManager.logout();
     }
+    async logoutDeviceFlow() {
+        return this.authManager.logoutDeviceFlow();
+    }
     async getUserInfo() {
         const user = await this.authManager.getUser();
         return user?.profile;
     }
+    async getUserInfoDeviceFlow() {
+        const user = await this.authManager.getUserDeviceFlow();
+        return user?.profile;
+    }
     async getIdToken() {
         const user = await this.authManager.getUser();
         return user?.idToken;
@@ -12834,16 +13044,14 @@ class Orderbook {
         if (!maybeConfig) {
             throw new Error('Orderbook configuration not passed, either select one of the preseet chainNames or pass in localConfig');
         }
+        const { chainName, provider } = config.overrides;
+        maybeConfig.provider = provider
+            || maybeConfig.provider;
         this.orderbookConfig = maybeConfig;
         const { apiEndpoint } = this.orderbookConfig;
         if (!apiEndpoint) {
             throw new Error('API endpoint must be provided as an override');
         }
-        // TODO: Move chainId lookup to a map based on env. Just using override to get dev started
-        const chainName = config.overrides?.chainName;
-        if (!chainName) {
-            throw new Error('chainName must be provided as an override');
-        }
         this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainName, this.orderbookConfig.seaportContractAddress).create();
         const seaportLibFactory = new SeaportLibFactory(this.orderbookConfig.seaportContractAddress, this.orderbookConfig.provider);
         this.seaport = new Seaport(seaportLibFactory, this.orderbookConfig.provider, this.orderbookConfig.seaportContractAddress, this.orderbookConfig.zoneContractAddress);
@@ -27729,7 +27937,7 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.2.0-alpha";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.2.2-alpha";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/index.d.ts

@@ -12758,6 +12758,19 @@ interface PassportOverrides {
 }
 interface PassportModuleConfiguration extends ModuleConfiguration<PassportOverrides>, OidcConfiguration {
 }
+type DeviceConnectResponse = {
+    code: string;
+    deviceCode: string;
+    url: string;
+    interval: number;
+};
+type DeviceTokenResponse = {
+    access_token: string;
+    refresh_token?: string;
+    id_token: string;
+    token_type: string;
+    expires_in: number;
+};
 
 declare class Passport {
     private readonly authManager;
@@ -12769,9 +12782,18 @@ declare class Passport {
     constructor(passportModuleConfiguration: PassportModuleConfiguration);
     connectImxSilent(): Promise<IMXProvider | null>;
     connectImx(): Promise<IMXProvider>;
+    loginWithDeviceFlow(): Promise<DeviceConnectResponse>;
+    connectImxDeviceFlow(deviceCode: string, interval: number, timeoutMs?: number): Promise<IMXProvider | null>;
+    /**
+     * @returns {boolean} the stored device flow credentials if they exist
+     */
+    checkStoredDeviceFlowCredentials(): DeviceTokenResponse | null;
+    connectImxWithCredentials(tokenResponse: DeviceTokenResponse): Promise<IMXProvider | null>;
     loginCallback(): Promise<void>;
     logout(): Promise<void>;
+    logoutDeviceFlow(): Promise<void>;
     getUserInfo(): Promise<UserProfile | undefined>;
+    getUserInfoDeviceFlow(): Promise<UserProfile | undefined>;
     getIdToken(): Promise<string | undefined>;
     getAccessToken(): Promise<string | undefined>;
 }
@@ -28181,8 +28203,8 @@ interface ImtblWalletProps extends React.DetailedHTMLProps<React.HTMLAttributes<
  * @property {string | undefined} walletProvider - The preferred wallet provider to connect to.
  * @property {string | undefined} widgetConfig - The configuration for the swap widget.
  * @property {string | undefined} amount - The amount to swap.
- * @property {string | undefined} fromContractAddress - The contract address of the source token.
- * @property {string | undefined} toContractAddress - The contract address of the destination token.
+ * @property {string | undefined} fromContractAddress - The contract address of the source token. If the string is 'NATIVE' then the native token will be used.
+ * @property {string | undefined} toContractAddress - The contract address of the destination token. If the string is 'NATIVE' then the native token will be used.
  */
 interface ImtblSwapProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     walletProvider?: string;
@@ -28237,9 +28259,9 @@ declare function ConnectReact(): JSX.Element;
  * @interface SwapReactProps
  * @property {WalletProviderName | undefined} walletProvider - The name of the wallet provider.
  * @property {Web3Provider | undefined} provider - The Web3 provider.
- * @property {string | undefined} fromContractAddress - The address of the contract swapping from.
+ * @property {string | undefined} fromContractAddress - The address of the contract swapping from. If the string is 'NATIVE' then the native token is used.
  * @property {string | undefined} amount - The amount.
- * @property {string | undefined} toContractAddress - The address of the contract swapping to.
+ * @property {string | undefined} toContractAddress - The address of the contract swapping to. If the string is 'NATIVE' then the native token is used.
  */
 interface SwapReactProps {
     walletProvider?: WalletProviderName;
@@ -28494,4 +28516,4 @@ declare class ERC721PermissionedMintable {
     }): Promise<PopulatedTransaction>;
 }
 
-export { APIError, ActivityType, AllowedNetworkConfig, BlockchainData, BlockchainDataModuleConfiguration, BridgeEventType, BridgeFailed, BridgeReact, BridgeReactProps, BridgeSuccess, CHECKOUT_API_BASE_URL, ChainId, ChainName, CheckConnectionParams, CheckConnectionResult, Checkout, CheckoutErrorType, CheckoutModuleConfiguration, CheckoutWidgetTagNames, CheckoutWidgets, CheckoutWidgetsConfig, ConnectEventType, ConnectParams, ConnectReact, ConnectResult, ConnectionFailed, ConnectionSuccess, DexConfig, ERC20, ERC721PermissionedMintable, Environment, ErrorType, GasEstimateBridgeToL2Result, GasEstimateParams, GasEstimateSwapResult, GasEstimateTokenConfig, GasEstimateType, GenericIMXProvider, GetAllBalancesParams, GetAllBalancesResult, GetBalanceParams, GetBalanceResult, GetNetworkAllowListParams, GetNetworkAllowListResult, GetNetworkParams, GetTokenAllowListParams, GetTokenAllowListResult, GetWalletAllowListParams, GetWalletAllowListResult, IMTBLWidgetEvents, IMXProvider, ImmutableConfiguration, ImmutableXClient, ImtblBridgeProps, ImtblConnectProps, ImtblSwapProps, ImtblWalletProps, ImxModuleConfiguration as ImxClientModuleConfiguration, WalletConnection as ImxClientWalletConnection, MetaMaskIMXProvider, ModuleConfiguration, NetworkFilter, NetworkFilterTypes, NetworkInfo, Networks, OrchestrationEventType, Orderbook, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, ProviderConfiguration, RemoteConfiguration, RequestBridgeEvent, RequestConnectEvent, RequestOnrampEvent, RequestSwapEvent, RequestWalletEvent, SemanticVersion, SendTransactionParams, SendTransactionResult, SwapEventType, SwapFailed, SwapReact, SwapReactProps, SwapRejected, SwapSuccess, SwitchNetworkParams, SwitchNetworkResult, TokenFilter, TokenFilterTypes, TokenInfo, UpdateConfig, UserProfile, WalletDisconnectWalletEvent, WalletEventType, WalletFilter, WalletFilterTypes, WalletInfo, WalletNetworkSwitchEvent, WalletProviderName, WalletReact, WalletReactProps, WidgetEvent, WidgetTheme, createStarkSigner as imxClientCreateStarkSigner, generateLegacyStarkPrivateKey as imxClientGenerateLegacyStarkPrivateKey, module };
+export { APIError, ActivityType, AllowedNetworkConfig, BlockchainData, BlockchainDataModuleConfiguration, BridgeEventType, BridgeFailed, BridgeReact, BridgeReactProps, BridgeSuccess, CHECKOUT_API_BASE_URL, ChainId, ChainName, CheckConnectionParams, CheckConnectionResult, Checkout, CheckoutErrorType, CheckoutModuleConfiguration, CheckoutWidgetTagNames, CheckoutWidgets, CheckoutWidgetsConfig, ConnectEventType, ConnectParams, ConnectReact, ConnectResult, ConnectionFailed, ConnectionSuccess, DeviceConnectResponse, DeviceTokenResponse, DexConfig, ERC20, ERC721PermissionedMintable, Environment, ErrorType, GasEstimateBridgeToL2Result, GasEstimateParams, GasEstimateSwapResult, GasEstimateTokenConfig, GasEstimateType, GenericIMXProvider, GetAllBalancesParams, GetAllBalancesResult, GetBalanceParams, GetBalanceResult, GetNetworkAllowListParams, GetNetworkAllowListResult, GetNetworkParams, GetTokenAllowListParams, GetTokenAllowListResult, GetWalletAllowListParams, GetWalletAllowListResult, IMTBLWidgetEvents, IMXProvider, ImmutableConfiguration, ImmutableXClient, ImtblBridgeProps, ImtblConnectProps, ImtblSwapProps, ImtblWalletProps, ImxModuleConfiguration as ImxClientModuleConfiguration, WalletConnection as ImxClientWalletConnection, MetaMaskIMXProvider, ModuleConfiguration, NetworkFilter, NetworkFilterTypes, NetworkInfo, Networks, OrchestrationEventType, Orderbook, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, ProviderConfiguration, RemoteConfiguration, RequestBridgeEvent, RequestConnectEvent, RequestOnrampEvent, RequestSwapEvent, RequestWalletEvent, SemanticVersion, SendTransactionParams, SendTransactionResult, SwapEventType, SwapFailed, SwapReact, SwapReactProps, SwapRejected, SwapSuccess, SwitchNetworkParams, SwitchNetworkResult, TokenFilter, TokenFilterTypes, TokenInfo, UpdateConfig, UserProfile, WalletDisconnectWalletEvent, WalletEventType, WalletFilter, WalletFilterTypes, WalletInfo, WalletNetworkSwitchEvent, WalletProviderName, WalletReact, WalletReactProps, WidgetEvent, WidgetTheme, createStarkSigner as imxClientCreateStarkSigner, generateLegacyStarkPrivateKey as imxClientGenerateLegacyStarkPrivateKey, module };