@imtbl/sdk 0.1.10-alpha.4 → 0.2.1-alpha

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');
@@ -10,7 +11,6 @@ var encUtils = require('enc-utils');
 var providers = require('@ethersproject/providers');
 var FormData$2 = require('form-data');
 var ethers = require('ethers');
-var dotenv = require('dotenv');
 var seaportJs = require('@opensea/seaport-js');
 var units = require('@ethersproject/units');
 var bignumber = require('@ethersproject/bignumber');
@@ -5457,7 +5457,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.1.10-alpha.4',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.2.1-alpha',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -5723,7 +5723,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.1.10-alpha.4',
+    sdkVersion: 'ts-immutable-sdk-0.2.1-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -10000,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,
@@ -10025,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;
@@ -10060,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 };
@@ -10072,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();
@@ -10091,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 {
@@ -10624,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);
@@ -10931,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;
@@ -11846,49 +12055,11 @@ class ImmutableApiClientFactory {
     }
 }
 
-// eslint-disable-next-line
-dotenv.config();
-function getConfigFromEnv() {
-    if (!process.env.ORDERBOOK_MR_API_URL
-        || !process.env.SEAPORT_CONTRACT_ADDRESS
-        || !process.env.ZONE_CONTRACT_ADDRESS) {
-        throw new Error('missing config');
-    }
-    return {
-        apiUrl: process.env.ORDERBOOK_MR_API_URL,
-        seaportContractAddress: process.env.SEAPORT_CONTRACT_ADDRESS,
-        zoneContractAddress: process.env.ZONE_CONTRACT_ADDRESS,
-    };
-}
-
-dotenv.config();
-function getLocalhostProvider() {
-    const endpoint = process.env.LOCAL_RPC_ENDPOINT;
-    if (!endpoint) {
-        throw new Error('LOCAL_RPC_ENDPOINT not set');
-    }
-    return new ethers.providers.JsonRpcProvider(endpoint);
-}
-
-dotenv.config();
-
-const LOCAL_CHAIN_NAME = 'imtbl-zkevm-local';
 const DEVNET_CHAIN_NAME = 'imtbl-zkevm-devnet';
 const TESTNET_CHAIN_NAME = 'imtbl-zkevm-testnet';
 const MAINNET_CHAIN_NAME = 'imtbl-zkevm-mainnet';
-function localChainConfig() {
-    const localConfig = getConfigFromEnv();
-    return {
-        seaportContractAddress: localConfig.seaportContractAddress,
-        zoneContractAddress: localConfig.zoneContractAddress,
-        apiEndpoint: localConfig.apiUrl,
-        provider: getLocalhostProvider(),
-    };
-}
 function getOrderbookConfig(chainName) {
     switch (chainName) {
-        case LOCAL_CHAIN_NAME:
-            return localChainConfig();
         case DEVNET_CHAIN_NAME:
             return {
                 seaportContractAddress: '0x41388404Efb7a68Fd31d75CEf71dF91e2BDBa2fb',
@@ -12864,24 +13035,26 @@ class SeaportLibFactory {
  * @param {OrderbookModuleConfiguration} config - Configuration for Immutable services.
  */
 class Orderbook {
-    config;
     apiClient;
     seaport;
-    constructor(config) {
-        this.config = config;
-        const orderbookConfig = getOrderbookConfig(config.overrides?.chainName);
-        const apiEndpoint = orderbookConfig?.apiEndpoint;
+    orderbookConfig;
+    constructor(config, localConfig) {
+        // either use preconfigured config or local config passed in
+        const maybeConfig = getOrderbookConfig(config.overrides?.chainName) || localConfig;
+        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, orderbookConfig.seaportContractAddress).create();
-        const seaportLibFactory = new SeaportLibFactory(orderbookConfig.seaportContractAddress, orderbookConfig.provider);
-        this.seaport = new Seaport(seaportLibFactory, orderbookConfig.provider, orderbookConfig.seaportContractAddress, orderbookConfig.zoneContractAddress);
+        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);
     }
     /**
      * Get an order by ID
@@ -12909,8 +13082,7 @@ class Orderbook {
      * the order components that can be submitted to `createListing` with a signature.
      */
     async prepareListing({ makerAddress, sell, buy, orderExpiry, }) {
-        const orderbookConfig = getOrderbookConfig(this.config.overrides?.chainName);
-        const erc721 = new ERC721Factory(sell.contractAddress, orderbookConfig.provider).create();
+        const erc721 = new ERC721Factory(sell.contractAddress, this.orderbookConfig.provider).create();
         const royaltyInfo = await erc721.royaltyInfo(sell.tokenId, buy.amount);
         return this.seaport.prepareSeaportOrder(makerAddress, sell, buy, royaltyInfo, 
         // Default order start to now
@@ -24384,9 +24556,8 @@ class ExchangeError extends Error {
     }
 }
 class InvalidConfigurationError extends ExchangeError {
-    constructor() {
-        const message = 'Invalid configuration';
-        super(message, ExchangeErrorCode.INVALID_CONFIGURATION);
+    constructor(message) {
+        super(message || 'Invalid configuration', ExchangeErrorCode.INVALID_CONFIGURATION);
     }
 }
 class ChainNotSupportedError extends ExchangeError {
@@ -26487,20 +26658,84 @@ function getSwap(nativeToken, routeAndQuote, fromAddress, slippage, deadline, pe
     };
 }
 
+const CONTRACTS_FOR_CHAIN_ID = {
+    [IMMUTABLE_TESTNET_CHAIN_ID]: {
+        multicall: '0xb18c44b211065E69844FbA9AE146DA362104AfBf',
+        coreFactory: '0x12739A8f1A8035F439092D016DAE19A2874F30d2',
+        quoterV2: '0xF674847fBcca5C80315e3AE37043Dce99F6CC529',
+        peripheryRouter: '0x0Afe6F5f4DC34461A801420634239FFaD50A2e44',
+    },
+};
+const SUPPORTED_SANDBOX_CHAINS = {
+    [IMMUTABLE_TESTNET_CHAIN_ID]: {
+        chainId: IMMUTABLE_TESTNET_CHAIN_ID,
+        rpcUrl: IMMUTABLE_TESTNET_RPC_URL,
+        contracts: CONTRACTS_FOR_CHAIN_ID[IMMUTABLE_TESTNET_CHAIN_ID],
+        commonRoutingTokens: IMMUTABLE_TESTNET_COMMON_ROUTING_TOKENS,
+        nativeToken: TIMX_IMMUTABLE_TESTNET,
+    },
+};
+const SUPPORTED_PRODUCTION_CHAINS = {};
+const SUPPORTED_CHAIN_IDS_FOR_ENVIRONMENT = {
+    [exports.Environment.SANDBOX]: SUPPORTED_SANDBOX_CHAINS,
+    [exports.Environment.PRODUCTION]: SUPPORTED_PRODUCTION_CHAINS,
+};
+function validateOverrides(overrides) {
+    Object.entries(overrides).forEach(([key, value]) => {
+        if (!value) {
+            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}`);
+        }
+    });
+}
+/**
+ * {@link ExchangeConfiguration} is used to configure the {@link Exchange} class.
+ * @param chainId the ID of the chain to configure. {@link SUPPORTED_CHAIN_IDS_FOR_ENVIRONMENT} contains the supported chains for each environment.
+ * @param baseConfig the base {@link ImmutableConfiguration} for the {@link Exchange} class
+ */
+class ExchangeConfiguration {
+    baseConfig;
+    chain;
+    constructor({ chainId, baseConfig, overrides }) {
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            validateOverrides(overrides);
+            this.chain = {
+                chainId,
+                rpcUrl: overrides.rpcURL,
+                contracts: overrides.exchangeContracts,
+                commonRoutingTokens: overrides.commonRoutingTokens,
+                nativeToken: overrides.nativeToken,
+            };
+            return;
+        }
+        const chain = SUPPORTED_CHAIN_IDS_FOR_ENVIRONMENT[baseConfig.environment][chainId];
+        if (!chain) {
+            throw new ChainNotSupportedError(chainId, baseConfig.environment);
+        }
+        this.chain = chain;
+    }
+}
+
 class Exchange {
     provider;
     router;
     chainId;
     nativeToken;
     constructor(configuration) {
-        this.chainId = configuration.chain.chainId;
-        this.nativeToken = configuration.chain.nativeToken;
-        this.provider = new ethers.ethers.providers.JsonRpcProvider(configuration.chain.rpcUrl);
-        this.router = new Router(this.provider, configuration.chain.commonRoutingTokens, {
-            multicallAddress: configuration.chain.contracts.multicall,
-            factoryAddress: configuration.chain.contracts.coreFactory,
-            quoterAddress: configuration.chain.contracts.quoterV2,
-            peripheryRouterAddress: configuration.chain.contracts.peripheryRouter,
+        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.router = new Router(this.provider, config.chain.commonRoutingTokens, {
+            multicallAddress: config.chain.contracts.multicall,
+            factoryAddress: config.chain.contracts.coreFactory,
+            quoterAddress: config.chain.contracts.quoterV2,
+            peripheryRouterAddress: config.chain.contracts.peripheryRouter,
         });
     }
     static validate(tokenInAddress, tokenOutAddress, maxHops, slippagePercent, fromAddress) {
@@ -26580,67 +26815,6 @@ class Exchange {
     }
 }
 
-const CONTRACTS_FOR_CHAIN_ID = {
-    [IMMUTABLE_TESTNET_CHAIN_ID]: {
-        multicall: '0xb18c44b211065E69844FbA9AE146DA362104AfBf',
-        coreFactory: '0x12739A8f1A8035F439092D016DAE19A2874F30d2',
-        quoterV2: '0xF674847fBcca5C80315e3AE37043Dce99F6CC529',
-        peripheryRouter: '0x0Afe6F5f4DC34461A801420634239FFaD50A2e44',
-    },
-};
-const SUPPORTED_SANDBOX_CHAINS = {
-    [IMMUTABLE_TESTNET_CHAIN_ID]: {
-        chainId: IMMUTABLE_TESTNET_CHAIN_ID,
-        rpcUrl: IMMUTABLE_TESTNET_RPC_URL,
-        contracts: CONTRACTS_FOR_CHAIN_ID[IMMUTABLE_TESTNET_CHAIN_ID],
-        commonRoutingTokens: IMMUTABLE_TESTNET_COMMON_ROUTING_TOKENS,
-        nativeToken: TIMX_IMMUTABLE_TESTNET,
-    },
-};
-const SUPPORTED_PRODUCTION_CHAINS = {};
-const SUPPORTED_CHAIN_IDS_FOR_ENVIRONMENT = {
-    [exports.Environment.SANDBOX]: SUPPORTED_SANDBOX_CHAINS,
-    [exports.Environment.PRODUCTION]: SUPPORTED_PRODUCTION_CHAINS,
-};
-function validateOverrides(overrides) {
-    if (!overrides.rpcURL || !overrides.exchangeContracts || !overrides.commonRoutingTokens || !overrides.nativeToken) {
-        throw new InvalidConfigurationError();
-    }
-    Object.values(overrides.exchangeContracts).forEach((contract) => {
-        if (!isValidNonZeroAddress(contract)) {
-            throw new InvalidConfigurationError();
-        }
-    });
-}
-/**
- * {@link ExchangeConfiguration} is used to configure the {@link Exchange} class.
- * @param chainId the ID of the chain to configure. {@link SUPPORTED_CHAIN_IDS_FOR_ENVIRONMENT} contains the supported chains for each environment.
- * @param baseConfig the base {@link ImmutableConfiguration} for the {@link Exchange} class
- */
-class ExchangeConfiguration {
-    baseConfig;
-    chain;
-    constructor({ chainId, baseConfig, overrides }) {
-        this.baseConfig = baseConfig;
-        if (overrides) {
-            validateOverrides(overrides);
-            this.chain = {
-                chainId,
-                rpcUrl: overrides.rpcURL,
-                contracts: overrides.exchangeContracts,
-                commonRoutingTokens: overrides.commonRoutingTokens,
-                nativeToken: overrides.nativeToken,
-            };
-            return;
-        }
-        const chain = SUPPORTED_CHAIN_IDS_FOR_ENVIRONMENT[baseConfig.environment][chainId];
-        if (!chain) {
-            throw new ChainNotSupportedError(chainId, baseConfig.environment);
-        }
-        this.chain = chain;
-    }
-}
-
 /* eslint-disable class-methods-use-this */ 
 
 const $762782b6c862d954$export$db5daa1b5156ccfe = [
@@ -27393,13 +27567,13 @@ async function $67fc622a2b913d5f$export$989eefe1274a439c(fromChainId, toChainId,
 }
 async function $67fc622a2b913d5f$export$7cf6178417769841(chainId, config) {
     const dexConfig = await config.remote.getConfig("dex");
-    return new (Exchange)(new (ExchangeConfiguration)({
+    return new (Exchange)({
         chainId: chainId,
         baseConfig: new (ImmutableConfiguration)({
             environment: config.environment
         }),
         overrides: dexConfig?.overrides
-    }));
+    });
 }
 
 
@@ -27763,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.1.10-alpha.4";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.2.1-alpha";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;