@imtbl/sdk 0.3.0-alpha.2 → 0.3.0-alpha.3

package/dist/index.cjs

@@ -12,6 +12,7 @@ var providers = require('@ethersproject/providers');
 var ethers = require('ethers');
 var abi = require('@0xsequence/abi');
 var config = require('@0xsequence/config');
+var events = require('events');
 var FormData$2 = require('form-data');
 var seaportJs = require('@opensea/seaport-js');
 var units = require('@ethersproject/units');
@@ -5550,7 +5551,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.3.0-alpha.2' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.3.0-alpha.3' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -5610,7 +5611,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.3.0-alpha.2',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.3.0-alpha.3',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -5876,7 +5877,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.3.0-alpha.2',
+    sdkVersion: 'ts-immutable-sdk-0.3.0-alpha.3',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -11315,7 +11316,7 @@ function digestOfTransactionsAndNonce(nonce, normalisedTransactions) {
     return ethers.ethers.utils.keccak256(packMetaTransactionsNonceData);
 }
 const getNonce = async (jsonRpcProvider, smartContractWalletAddress) => {
-    const code = await jsonRpcProvider.send('eth_getCode', [smartContractWalletAddress]);
+    const code = await jsonRpcProvider.send('eth_getCode', [smartContractWalletAddress, 'latest']);
     if (code && code !== '0x') {
         const contract = new ethers.ethers.Contract(smartContractWalletAddress, abi.walletContracts.mainModule.abi, jsonRpcProvider);
         return contract.nonce();
@@ -11366,17 +11367,30 @@ var RelayerTransactionStatus;
     RelayerTransactionStatus["REVERTED"] = "REVERTED";
     RelayerTransactionStatus["FAILED"] = "FAILED";
 })(RelayerTransactionStatus || (RelayerTransactionStatus = {}));
-
-var RpcErrorCode;
+exports.ProviderEventNames = void 0;
+(function (ProviderEventNames) {
+    ProviderEventNames["ACCOUNTS_CHANGED"] = "accountsChanged";
+})(exports.ProviderEventNames || (exports.ProviderEventNames = {}));
+
+/**
+ * ProviderErrors should take priority over RpcErrorCodes
+ */
+exports.ProviderErrorCode = void 0;
+(function (ProviderErrorCode) {
+    ProviderErrorCode[ProviderErrorCode["USER_REJECTED_REQUEST"] = 4001] = "USER_REJECTED_REQUEST";
+    ProviderErrorCode[ProviderErrorCode["UNAUTHORIZED"] = 4100] = "UNAUTHORIZED";
+    ProviderErrorCode[ProviderErrorCode["UNSUPPORTED_METHOD"] = 4200] = "UNSUPPORTED_METHOD";
+    ProviderErrorCode[ProviderErrorCode["DISCONNECTED"] = 4900] = "DISCONNECTED";
+})(exports.ProviderErrorCode || (exports.ProviderErrorCode = {}));
+exports.RpcErrorCode = void 0;
 (function (RpcErrorCode) {
     RpcErrorCode[RpcErrorCode["RPC_SERVER_ERROR"] = -32000] = "RPC_SERVER_ERROR";
     RpcErrorCode[RpcErrorCode["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
     RpcErrorCode[RpcErrorCode["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
     RpcErrorCode[RpcErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
     RpcErrorCode[RpcErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
-    RpcErrorCode[RpcErrorCode["UNAUTHORIZED"] = -32604] = "UNAUTHORIZED";
     RpcErrorCode[RpcErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-})(RpcErrorCode || (RpcErrorCode = {}));
+})(exports.RpcErrorCode || (exports.RpcErrorCode = {}));
 class JsonRpcError extends Error {
     message;
     code;
@@ -11389,10 +11403,10 @@ class JsonRpcError extends Error {
 
 const MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES = 30;
 const TRANSACTION_HASH_RETRIEVAL_WAIT = 1000;
-const ethSendTransaction = async ({ params, magicProvider, jsonRpcProvider, relayerClient, config, user, }) => {
+const sendTransaction = async ({ params, magicProvider, jsonRpcProvider, relayerClient, config, user, }) => {
     const transactionRequest = params[0];
     if (!transactionRequest.to) {
-        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
+        throw new JsonRpcError(exports.RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
     }
     const chainId = chainIdNumber(config.zkEvmChainId);
     const magicWeb3Provider = new providers.Web3Provider(magicProvider);
@@ -11446,14 +11460,27 @@ const ethSendTransaction = async ({ params, magicProvider, jsonRpcProvider, rela
     const relayerTransaction = await retryWithDelay(retrieveRelayerTransaction, {
         retries: MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES,
         interval: TRANSACTION_HASH_RETRIEVAL_WAIT,
-        finalErr: new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, 'transaction hash not generated in time'),
+        finalErr: new JsonRpcError(exports.RpcErrorCode.RPC_SERVER_ERROR, 'transaction hash not generated in time'),
     });
     if (![RelayerTransactionStatus.SUBMITTED, RelayerTransactionStatus.SUCCESSFUL].includes(relayerTransaction.status)) {
-        throw new JsonRpcError(RpcErrorCode.RPC_SERVER_ERROR, `Transaction failed to submit with status ${relayerTransaction.status}`);
+        throw new JsonRpcError(exports.RpcErrorCode.RPC_SERVER_ERROR, `Transaction failed to submit with status ${relayerTransaction.status}`);
     }
     return relayerTransaction.hash;
 };
 
+class TypedEventEmitter {
+    emitter = new events.EventEmitter();
+    emit(eventName, ...eventArg) {
+        this.emitter.emit(eventName, ...eventArg);
+    }
+    on(eventName, handler) {
+        this.emitter.on(eventName, handler);
+    }
+    removeListener(eventName, handler) {
+        this.emitter.removeListener(eventName, handler);
+    }
+}
+
 class RelayerClient {
     config;
     constructor({ config }) {
@@ -11513,7 +11540,7 @@ class RelayerClient {
 }
 
 const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
-async function createCounterfactualAddress({ authManager, magicProvider, multiRollupApiClients, accessToken, }) {
+async function registerZkEvmUser({ authManager, magicProvider, multiRollupApiClients, accessToken, }) {
     const web3Provider = new providers.Web3Provider(magicProvider);
     const ethSigner = web3Provider.getSigner();
     const ethereumAddress = await ethSigner.getAddress();
@@ -11528,16 +11555,16 @@ async function createCounterfactualAddress({ authManager, magicProvider, multiRo
         }, { headers });
     }
     catch (error) {
-        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to create counterfactual address: ${error}`);
+        throw new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, `Failed to create counterfactual address: ${error}`);
     }
     const user = await authManager.loginSilent();
     if (!user?.zkEvm) {
-        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Failed to refresh user details');
+        throw new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, 'Failed to refresh user details');
     }
     return user;
 }
 
-const registerZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupApiClients, }) => {
+const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupApiClients, }) => {
     const user = await authManager.getUser() || await authManager.login();
     if (!user.idToken) {
         throw new Error('User is missing idToken');
@@ -11545,7 +11572,7 @@ const registerZkEvmUser = async ({ authManager, config, magicAdapter, multiRollu
     const magicProvider = await magicAdapter.login(user.idToken, config.network);
     if (!user.zkEvm) {
         // Generate counterfactual address and retrieve updated Auth0 user
-        const userZkevm = await createCounterfactualAddress({
+        const userZkevm = await registerZkEvmUser({
             authManager,
             magicProvider,
             multiRollupApiClients,
@@ -11562,7 +11589,7 @@ const registerZkEvmUser = async ({ authManager, config, magicAdapter, multiRollu
     };
 };
 
-class ZkEvmProvider {
+class ZkEvmProvider extends TypedEventEmitter {
     authManager;
     config;
     confirmationScreen;
@@ -11573,6 +11600,7 @@ class ZkEvmProvider {
     magicProvider; // Used for signing
     user;
     constructor({ authManager, magicAdapter, config, confirmationScreen, multiRollupApiClients, }) {
+        super();
         this.authManager = authManager;
         this.magicAdapter = magicAdapter;
         this.config = config;
@@ -11585,25 +11613,12 @@ class ZkEvmProvider {
         return this.magicProvider !== undefined && this.user !== undefined;
     }
     async performRequest(request) {
-        const authWrapper = (fn) => {
-            if (!this.isLoggedIn()) {
-                throw new JsonRpcError(RpcErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
-            }
-            return fn({
-                params: request.params || [],
-                magicProvider: this.magicProvider,
-                jsonRpcProvider: this.jsonRpcProvider,
-                config: this.config,
-                relayerClient: this.relayerClient,
-                user: this.user,
-            });
-        };
         switch (request.method) {
             case 'eth_requestAccounts': {
                 if (this.isLoggedIn()) {
                     return [this.user.zkEvm.ethAddress];
                 }
-                const { magicProvider, user } = await registerZkEvmUser({
+                const { magicProvider, user } = await loginZkEvmUser({
                     authManager: this.authManager,
                     config: this.config,
                     magicAdapter: this.magicAdapter,
@@ -11611,10 +11626,21 @@ class ZkEvmProvider {
                 });
                 this.user = user;
                 this.magicProvider = magicProvider;
+                this.emit(exports.ProviderEventNames.ACCOUNTS_CHANGED, [this.user.zkEvm.ethAddress]);
                 return [this.user.zkEvm.ethAddress];
             }
             case 'eth_sendTransaction': {
-                return authWrapper(ethSendTransaction);
+                if (!this.isLoggedIn()) {
+                    throw new JsonRpcError(exports.ProviderErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
+                }
+                return sendTransaction({
+                    params: request.params || [],
+                    magicProvider: this.magicProvider,
+                    jsonRpcProvider: this.jsonRpcProvider,
+                    config: this.config,
+                    relayerClient: this.relayerClient,
+                    user: this.user,
+                });
             }
             case 'eth_accounts': {
                 return this.isLoggedIn() ? [this.user.zkEvm.ethAddress] : [];
@@ -11635,7 +11661,7 @@ class ZkEvmProvider {
                 return this.jsonRpcProvider.send(request.method, request.params || []);
             }
             default: {
-                throw new JsonRpcError(RpcErrorCode.METHOD_NOT_FOUND, 'Method not supported');
+                throw new JsonRpcError(exports.ProviderErrorCode.UNSUPPORTED_METHOD, 'Method not supported');
             }
         }
     }
@@ -11655,10 +11681,10 @@ class ZkEvmProvider {
                 jsonRpcError = error;
             }
             else if (error instanceof Error) {
-                jsonRpcError = new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
+                jsonRpcError = new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, error.message);
             }
             else {
-                jsonRpcError = new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+                jsonRpcError = new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, 'Internal error');
             }
             return {
                 id,
@@ -11676,9 +11702,9 @@ class ZkEvmProvider {
                 throw error;
             }
             if (error instanceof Error) {
-                throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
+                throw new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, error.message);
             }
-            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+            throw new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, 'Internal error');
         }
     }
     sendAsync(request, callback) {
@@ -11727,7 +11753,7 @@ class ZkEvmProvider {
         if (!Array.isArray(request) && typeof request === 'object') {
             return this.performJsonRpcRequest(request);
         }
-        throw new JsonRpcError(RpcErrorCode.INVALID_REQUEST, 'Invalid request');
+        throw new JsonRpcError(exports.RpcErrorCode.INVALID_REQUEST, 'Invalid request');
     }
 }
 
@@ -27337,16 +27363,28 @@ const SUPPORTED_CHAIN_IDS_FOR_ENVIRONMENT = {
     [exports.Environment.PRODUCTION]: SUPPORTED_PRODUCTION_CHAINS,
 };
 function validateOverrides(overrides) {
-    Object.entries(overrides).forEach(([key, value]) => {
-        if (!value) {
+    const keysToCheck = ['rpcURL', 'exchangeContracts', 'commonRoutingTokens', 'nativeToken'];
+    for (const key of keysToCheck) {
+        if (!overrides[key]) {
             throw new InvalidConfigurationError(`Missing override: ${key}`);
         }
-    });
+    }
     Object.entries(overrides.exchangeContracts).forEach(([key, contract]) => {
         if (!isValidNonZeroAddress(contract)) {
             throw new InvalidConfigurationError(`Invalid exchange contract address for ${key}`);
         }
     });
+    if (!overrides.secondaryFees) {
+        return;
+    }
+    for (const secondaryFee of overrides.secondaryFees) {
+        if (!isValidNonZeroAddress(secondaryFee.feeRecipient)) {
+            throw new InvalidConfigurationError(`Invalid secondary fee recipient address: ${secondaryFee.feeRecipient}`);
+        }
+        if (secondaryFee.feeBasisPoints < 0 || secondaryFee.feeBasisPoints > 10000) {
+            throw new InvalidConfigurationError(`Invalid secondary fee percentage: ${secondaryFee.feeBasisPoints}`);
+        }
+    }
 }
 /**
  * {@link ExchangeConfiguration} is used to configure the {@link Exchange} class.
@@ -27356,6 +27394,7 @@ function validateOverrides(overrides) {
 class ExchangeConfiguration {
     baseConfig;
     chain;
+    secondaryFees;
     constructor({ chainId, baseConfig, overrides }) {
         this.baseConfig = baseConfig;
         if (overrides) {
@@ -27367,8 +27406,10 @@ class ExchangeConfiguration {
                 commonRoutingTokens: overrides.commonRoutingTokens,
                 nativeToken: overrides.nativeToken,
             };
+            this.secondaryFees = overrides.secondaryFees ? overrides.secondaryFees : [];
             return;
         }
+        this.secondaryFees = [];
         const chain = SUPPORTED_CHAIN_IDS_FOR_ENVIRONMENT[baseConfig.environment][chainId];
         if (!chain) {
             throw new ChainNotSupportedError(chainId, baseConfig.environment);
@@ -27382,11 +27423,13 @@ class Exchange {
     router;
     chainId;
     nativeToken;
+    secondaryFees;
     constructor(configuration) {
         const config = new ExchangeConfiguration(configuration);
         this.chainId = config.chain.chainId;
         this.nativeToken = config.chain.nativeToken;
         this.provider = new ethers.ethers.providers.JsonRpcProvider(config.chain.rpcUrl);
+        this.secondaryFees = config.secondaryFees;
         this.router = new Router(this.provider, config.chain.commonRoutingTokens, {
             multicallAddress: config.chain.contracts.multicall,
             factoryAddress: config.chain.contracts.coreFactory,
@@ -27469,6 +27512,9 @@ class Exchange {
     async getUnsignedSwapTxFromAmountOut(fromAddress, tokenInAddress, tokenOutAddress, amountOut, slippagePercent = DEFAULT_SLIPPAGE, maxHops = DEFAULT_MAX_HOPS, deadline = DEFAULT_DEADLINE) {
         return await this.getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, amountOut, slippagePercent, maxHops, deadline, sdkCore.TradeType.EXACT_OUTPUT);
     }
+    thereAreSecondaryFees() {
+        return this.secondaryFees.length > 0;
+    }
 }
 
 /* eslint-disable class-methods-use-this */ 
@@ -28592,7 +28638,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.3.0-alpha.2";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.3.0-alpha.3";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 
@@ -30411,6 +30457,7 @@ exports.ERC721PermissionedMintable = ERC721PermissionedMintable;
 exports.GenericIMXProvider = GenericIMXProvider;
 exports.ImmutableConfiguration = ImmutableConfiguration;
 exports.ImmutableXClient = ImmutableXClient;
+exports.JsonRpcError = JsonRpcError;
 exports.MetaMaskIMXProvider = MetaMaskIMXProvider;
 exports.Orderbook = Orderbook;
 exports.Passport = Passport;

package/dist/index.d.ts

@@ -12779,19 +12779,27 @@ type DeviceTokenResponse = {
     expires_in: number;
 };
 
+/**
+ * ProviderErrors should take priority over RpcErrorCodes
+ */
+declare enum ProviderErrorCode {
+    USER_REJECTED_REQUEST = 4001,
+    UNAUTHORIZED = 4100,
+    UNSUPPORTED_METHOD = 4200,
+    DISCONNECTED = 4900
+}
 declare enum RpcErrorCode {
     RPC_SERVER_ERROR = -32000,
     INVALID_REQUEST = -32600,
     METHOD_NOT_FOUND = -32601,
     INVALID_PARAMS = -32602,
     INTERNAL_ERROR = -32603,
-    UNAUTHORIZED = -32604,
     PARSE_ERROR = -32700
 }
 declare class JsonRpcError extends Error {
     readonly message: string;
-    readonly code: RpcErrorCode;
-    constructor(code: RpcErrorCode, message: string);
+    readonly code: ProviderErrorCode | RpcErrorCode;
+    constructor(code: ProviderErrorCode | RpcErrorCode, message: string);
 }
 
 interface RequestArguments {
@@ -12815,7 +12823,13 @@ type Provider = {
     request: (request: RequestArguments) => Promise<any>;
     sendAsync: (request: JsonRpcRequestPayload | JsonRpcRequestPayload[], callback: JsonRpcRequestCallback) => void;
     send: (request: string | JsonRpcRequestPayload | JsonRpcRequestPayload[], callbackOrParams?: JsonRpcRequestCallback | Array<any>, callback?: JsonRpcRequestCallback) => void;
+    on: (event: string, listener: (...args: any[]) => void) => void;
+    removeListener: (event: string, listener: (...args: any[]) => void) => void;
 };
+declare enum ProviderEventNames {
+    ACCOUNTS_CHANGED = "accountsChanged"
+}
+type AccountsChangedEvent = Array<string>;
 
 declare class Passport {
     private readonly authManager;
@@ -12909,6 +12923,16 @@ declare class Orderbook {
 
 declare const module = "orderbook";
 
+/**
+ * Interface representing the secondary fees for a swap
+ * @property {string} feeRecipient - The fee recipient address
+ * @property {number} feeBasisPoints - The fee percentage in basis points
+ * @example 100 basis points = 1%
+ */
+type SecondaryFee = {
+    feeRecipient: string;
+    feeBasisPoints: number;
+};
 /**
  * Interface representing a token
  * @property {number} chainId - The chain ID
@@ -12929,6 +12953,7 @@ interface ExchangeOverrides {
     exchangeContracts: ExchangeContracts;
     commonRoutingTokens: TokenInfo$1[];
     nativeToken: TokenInfo$1;
+    secondaryFees?: SecondaryFee[];
 }
 
 /**
@@ -27102,6 +27127,9 @@ declare namespace React {
     //   - "string"
     //   - union of string literals
     interface SVGAttributes<T> extends AriaAttributes, DOMAttributes<T> {
+        // React-specific Attributes
+        suppressHydrationWarning?: boolean | undefined;
+
         // Attributes which also defined in HTMLAttributes
         // See comment in SVGDOMPropertyConfig.js
         className?: string | undefined;
@@ -28566,4 +28594,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, 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, JsonRpcRequestCallback, JsonRpcRequestPayload, JsonRpcResponsePayload, MetaMaskIMXProvider, ModuleConfiguration, NetworkFilter, NetworkFilterTypes, NetworkInfo, Networks, OrchestrationEventType, Orderbook, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, Provider, ProviderConfiguration, RemoteConfiguration, RequestArguments, 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, AccountsChangedEvent, 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, JsonRpcError, JsonRpcRequestCallback, JsonRpcRequestPayload, JsonRpcResponsePayload, MetaMaskIMXProvider, ModuleConfiguration, NetworkFilter, NetworkFilterTypes, NetworkInfo, Networks, OrchestrationEventType, Orderbook, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, Provider, ProviderConfiguration, ProviderErrorCode, ProviderEventNames, RemoteConfiguration, RequestArguments, RequestBridgeEvent, RequestConnectEvent, RequestOnrampEvent, RequestSwapEvent, RequestWalletEvent, RpcErrorCode, 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 };