@imtbl/sdk 0.4.0-alpha.1 → 0.4.0-alpha.3

package/dist/index.cjs

@@ -9,8 +9,11 @@ var oidc = require('@magic-ext/oidc');
 var BN$2 = require('bn.js');
 var encUtils = require('enc-utils');
 var providers = require('@ethersproject/providers');
-var FormData$2 = require('form-data');
+var events = require('events');
 var ethers = require('ethers');
+var abi = require('@0xsequence/abi');
+var config = require('@0xsequence/config');
+var FormData$2 = require('form-data');
 var seaportJs = require('@opensea/seaport-js');
 var units = require('@ethersproject/units');
 var bignumber = require('@ethersproject/bignumber');
@@ -3265,6 +3268,94 @@ axios$1.default = axios$1;
 // this module should only have a default export
 var globalAxios$1 = axios$1;
 
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Immutable X API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 3.0
+ * Contact: support@immutable.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+let Configuration$1 = class Configuration {
+    /**
+     * parameter for apiKey security
+     * @param name security name
+     * @memberof Configuration
+     */
+    apiKey;
+    /**
+     * parameter for basic security
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    username;
+    /**
+     * parameter for basic security
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    password;
+    /**
+     * parameter for oauth2 security
+     * @param name security name
+     * @param scopes oauth2 scope
+     * @memberof Configuration
+     */
+    accessToken;
+    /**
+     * override base path
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    basePath;
+    /**
+     * base options for axios calls
+     *
+     * @type {any}
+     * @memberof Configuration
+     */
+    baseOptions;
+    /**
+     * The FormData constructor that will be used to create multipart form data
+     * requests. You can inject this here so that execution environments that
+     * do not support the FormData class can still run the generated client.
+     *
+     * @type {new () => FormData}
+     */
+    formDataCtor;
+    constructor(param = {}) {
+        this.apiKey = param.apiKey;
+        this.username = param.username;
+        this.password = param.password;
+        this.accessToken = param.accessToken;
+        this.basePath = param.basePath;
+        this.baseOptions = param.baseOptions;
+        this.formDataCtor = param.formDataCtor;
+    }
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime) {
+        const jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
+    }
+};
+
 /* tslint:disable */
 /* eslint-disable */
 /**
@@ -4973,7 +5064,7 @@ class TokensApi extends BaseAPI$1 {
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-let Configuration$1 = class Configuration {
+let Configuration$2 = class Configuration {
     /**
      * parameter for apiKey security
      * @param name security name
@@ -5406,7 +5497,7 @@ var index = /*#__PURE__*/Object.freeze({
   CollectionsApiAxiosParamCreator: CollectionsApiAxiosParamCreator,
   CollectionsApiFactory: CollectionsApiFactory,
   CollectionsApiFp: CollectionsApiFp,
-  Configuration: Configuration$1,
+  Configuration: Configuration$2,
   CreateOrderProtocolDataOrderTypeEnum: CreateOrderProtocolDataOrderTypeEnum,
   ERC20ItemItemTypeEnum: ERC20ItemItemTypeEnum,
   ERC721ItemItemTypeEnum: ERC721ItemItemTypeEnum,
@@ -5438,6 +5529,69 @@ var index = /*#__PURE__*/Object.freeze({
   TokensApiFp: TokensApiFp
 });
 
+class MultiRollupApiClients {
+    config;
+    activitiesApi;
+    chainsApi;
+    collectionApi;
+    nftOwnersApi;
+    nftsApi;
+    ordersApi;
+    passportApi;
+    constructor(config) {
+        this.config = config;
+        this.activitiesApi = new ActivitiesApi(config.indexer);
+        this.chainsApi = new ChainsApi(config.indexer);
+        this.collectionApi = new CollectionsApi(config.indexer);
+        this.nftOwnersApi = new NftOwnersApi(config.indexer);
+        this.nftsApi = new NftsApi(config.indexer);
+        this.ordersApi = new OrdersApi(config.orderBook);
+        this.passportApi = new PassportApi(config.passport);
+    }
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.4.0-alpha.3' };
+const createConfig = ({ basePath, headers, }) => {
+    if (!basePath.trim()) {
+        throw Error('basePath can not be empty');
+    }
+    const composedHeaders = { ...defaultHeaders$1, ...(headers || {}) };
+    const apiConfigOptions = {
+        basePath,
+        baseOptions: { headers: composedHeaders },
+    };
+    return new Configuration$1(apiConfigOptions);
+};
+/**
+ * Creates a Configuration for the specified environment
+ * @returns an MultiRollupAPIConfiguration
+ */
+const multiRollupConfig = {
+    getProduction: () => ({
+        indexer: createConfig({
+            basePath: 'https://indexer-mr.imtbl.com',
+        }),
+        orderBook: createConfig({
+            basePath: 'https://order-book-mr.imtbl.com',
+        }),
+        passport: createConfig({
+            basePath: 'https://api.immutable.com',
+        }),
+    }),
+    getSandbox: () => ({
+        indexer: createConfig({
+            basePath: 'https://indexer-mr.sandbox.imtbl.com',
+        }),
+        orderBook: createConfig({
+            basePath: 'https://order-book-mr.sandbox.imtbl.com',
+        }),
+        passport: createConfig({
+            basePath: 'https://api.sandbox.immutable.com',
+        }),
+    }),
+};
+
 /**
  * Custom Error class that is returned from the API when a request fails
  */
@@ -5457,7 +5611,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.4.0-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.4.0-alpha.3',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -5723,7 +5877,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.4.0-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-0.4.0-alpha.3',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -9447,6 +9601,8 @@ var globalAxios = axios;
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+// Some imports not used depending on template conditions
+// @ts-ignore
 const BASE_PATH = "https://guardian.sandbox.imtbl.com".replace(/\/+$/, "");
 /**
  *
@@ -9474,10 +9630,10 @@ class BaseAPI {
  */
 class RequiredError extends Error {
     field;
+    name = "RequiredError";
     constructor(field, msg) {
         super(msg);
         this.field = field;
-        this.name = "RequiredError";
     }
 }
 
@@ -9522,8 +9678,6 @@ const setBearerAuthToObject = async function (object, configuration) {
     }
 };
 function setFlattenedQueryParams(urlSearchParams, parameter, key = "") {
-    if (parameter == null)
-        return;
     if (typeof parameter === "object") {
         if (Array.isArray(parameter)) {
             parameter.forEach(item => setFlattenedQueryParams(urlSearchParams, item, key));
@@ -9679,7 +9833,7 @@ const TransactionsApiAxiosParamCreator = function (configuration) {
          * @summary Info for a specific transaction
          * @param {string} transactionID The id of the starkex transaction to retrieve
          * @param {'starkex' | 'evm'} chainType roll up type
-         * @param {number} [chainID] ID of evm chain
+         * @param {string} [chainID] ID of evm chain
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -9754,7 +9908,7 @@ const TransactionsApiFp = function (configuration) {
          * @summary Info for a specific transaction
          * @param {string} transactionID The id of the starkex transaction to retrieve
          * @param {'starkex' | 'evm'} chainType roll up type
-         * @param {number} [chainID] ID of evm chain
+         * @param {string} [chainID] ID of evm chain
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -10071,10 +10225,12 @@ class AuthManager {
     userManager;
     config;
     deviceCredentialsManager;
+    logoutMode;
     constructor(config) {
         this.config = config;
         this.userManager = new oidcClientTs.UserManager(getAuthConfiguration(config));
         this.deviceCredentialsManager = new DeviceCredentialsManager();
+        this.logoutMode = config.oidcConfiguration.logoutMode || 'redirect';
     }
     static mapOidcUserToDomainModel = (oidcUser) => {
         const passport = oidcUser.profile?.passport;
@@ -10228,7 +10384,15 @@ class AuthManager {
         return response.data;
     }
     async logout() {
-        return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
+        return withPassportError(async () => {
+            if (this.logoutMode === 'silent') {
+                return this.userManager.signoutSilent();
+            }
+            return this.userManager.signoutRedirect();
+        }, PassportErrorType.LOGOUT_ERROR);
+    }
+    async logoutSilentCallback(url) {
+        return this.userManager.signoutSilentCallback(url);
     }
     async logoutDeviceFlow() {
         return withPassportError(async () => {
@@ -10431,6 +10595,7 @@ async function createOrder$1({ starkSigner, user, request, ordersApi, guardianCl
             amount_sell: amountSell,
             token_sell: convertToSignableToken(request.sell),
             fees: request.fees,
+            split_fees: true,
             expiration_timestamp: request.expiration_timestamp,
         };
         const getSignableOrderResponse = await ordersApi.getSignableOrder({
@@ -10885,6 +11050,10 @@ class PassportConfiguration {
     magicProviderId;
     oidcConfiguration;
     baseConfig;
+    zkEvmChainId;
+    zkEvmRpcUrl;
+    relayerUrl;
+    multiRollupConfig;
     constructor({ baseConfig, overrides, ...oidcConfiguration }) {
         validateConfiguration(oidcConfiguration, [
             'clientId',
@@ -10897,10 +11066,16 @@ class PassportConfiguration {
             validateConfiguration(overrides, [
                 'network',
                 'authenticationDomain',
+                'passportDomain',
                 'magicPublishableApiKey',
                 'magicProviderId',
-                'passportDomain',
+                'zkEvmRpcUrl',
+                'zkEvmChainId',
+                'relayerUrl',
                 'imxPublicApiDomain',
+                'indexerMrBasePath',
+                'orderBookMrBasePath',
+                'passportMrBasePath',
             ], 'overrides');
             this.network = overrides.network;
             this.authenticationDomain = overrides.authenticationDomain;
@@ -10908,6 +11083,20 @@ class PassportConfiguration {
             this.imxPublicApiDomain = overrides.imxPublicApiDomain;
             this.magicPublishableApiKey = overrides.magicPublishableApiKey;
             this.magicProviderId = overrides.magicProviderId;
+            this.zkEvmRpcUrl = overrides.zkEvmRpcUrl;
+            this.zkEvmChainId = overrides.zkEvmChainId;
+            this.relayerUrl = overrides.relayerUrl;
+            this.multiRollupConfig = {
+                indexer: createConfig({
+                    basePath: overrides.indexerMrBasePath,
+                }),
+                orderBook: createConfig({
+                    basePath: overrides.orderBookMrBasePath,
+                }),
+                passport: createConfig({
+                    basePath: overrides.passportMrBasePath,
+                }),
+            };
         }
         else {
             switch (baseConfig.environment) {
@@ -10918,6 +11107,10 @@ class PassportConfiguration {
                     this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
                     this.passportDomain = 'https://passport.immutable.com';
                     this.imxPublicApiDomain = 'https://api.immutable.com';
+                    this.zkEvmRpcUrl = ''; // TODO: ID-785 Update once mainnet has been deployed
+                    this.zkEvmChainId = ''; // TODO: ID-785 Update once mainnet has been deployed
+                    this.relayerUrl = 'https://api.immutable.com/relayer-mr';
+                    this.multiRollupConfig = multiRollupConfig.getProduction();
                     break;
                 }
                 case exports.Environment.SANDBOX:
@@ -10928,6 +11121,10 @@ class PassportConfiguration {
                     this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
                     this.passportDomain = 'https://passport.sandbox.immutable.com';
                     this.imxPublicApiDomain = 'https://api.sandbox.immutable.com';
+                    this.zkEvmRpcUrl = 'https://zkevm-rpc.sandbox.x.immutable.com';
+                    this.zkEvmChainId = 'eip155:13392';
+                    this.relayerUrl = 'https://api.sandbox.immutable.com/relayer-mr';
+                    this.multiRollupConfig = multiRollupConfig.getSandbox();
                     break;
                 }
             }
@@ -11088,6 +11285,537 @@ class ConfirmationScreen {
     }
 }
 
+var RelayerTransactionStatus;
+(function (RelayerTransactionStatus) {
+    RelayerTransactionStatus["PENDING"] = "PENDING";
+    RelayerTransactionStatus["SUBMITTED"] = "SUBMITTED";
+    RelayerTransactionStatus["SUCCESSFUL"] = "SUCCESSFUL";
+    RelayerTransactionStatus["REVERTED"] = "REVERTED";
+    RelayerTransactionStatus["FAILED"] = "FAILED";
+})(RelayerTransactionStatus || (RelayerTransactionStatus = {}));
+exports.ProviderEvent = void 0;
+(function (ProviderEvent) {
+    ProviderEvent["ACCOUNTS_CHANGED"] = "accountsChanged";
+})(exports.ProviderEvent || (exports.ProviderEvent = {}));
+
+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 }) {
+        this.config = config;
+    }
+    async postToRelayer(request) {
+        const body = {
+            id: 1,
+            jsonrpc: '2.0',
+            ...request,
+        };
+        const response = await fetch(`${this.config.relayerUrl}/v1/transactions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        const jsonResponse = await response.json();
+        if (jsonResponse.error) {
+            throw jsonResponse.error;
+        }
+        return jsonResponse;
+    }
+    async ethSendTransaction(to, data) {
+        const payload = {
+            method: 'eth_sendTransaction',
+            params: [{
+                    to,
+                    data,
+                    chainId: this.config.zkEvmChainId.toString(),
+                }],
+        };
+        const { result } = await this.postToRelayer(payload);
+        return result;
+    }
+    async imGetTransactionByHash(hash) {
+        const payload = {
+            method: 'im_getTransactionByHash',
+            params: [hash],
+        };
+        const { result } = await this.postToRelayer(payload);
+        return result;
+    }
+    async imGetFeeOptions(userAddress, data) {
+        const payload = {
+            method: 'im_getFeeOptions',
+            params: [{
+                    userAddress,
+                    data,
+                    chainId: this.config.zkEvmChainId.toString(),
+                }],
+        };
+        const { result } = await this.postToRelayer(payload);
+        return result;
+    }
+}
+
+/**
+ * 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["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+})(exports.RpcErrorCode || (exports.RpcErrorCode = {}));
+class JsonRpcError extends Error {
+    message;
+    code;
+    constructor(code, message) {
+        super(message);
+        this.message = message;
+        this.code = code;
+    }
+}
+
+const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
+async function registerZkEvmUser({ authManager, magicProvider, multiRollupApiClients, accessToken, }) {
+    const web3Provider = new providers.Web3Provider(magicProvider);
+    const ethSigner = web3Provider.getSigner();
+    const ethereumAddress = await ethSigner.getAddress();
+    const ethereumSignature = await signRaw(MESSAGE_TO_SIGN, ethSigner);
+    const headers = { Authorization: `Bearer ${accessToken}` };
+    try {
+        await multiRollupApiClients.passportApi.createCounterfactualAddress({
+            createCounterfactualAddressRequest: {
+                ethereumAddress,
+                ethereumSignature,
+            },
+        }, { headers });
+    }
+    catch (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(exports.RpcErrorCode.INTERNAL_ERROR, 'Failed to refresh user details');
+    }
+    return user;
+}
+
+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');
+    }
+    const magicProvider = await magicAdapter.login(user.idToken, config.network);
+    if (!user.zkEvm) {
+        // Generate counterfactual address and retrieve updated Auth0 user
+        const userZkevm = await registerZkEvmUser({
+            authManager,
+            magicProvider,
+            multiRollupApiClients,
+            accessToken: user.accessToken,
+        });
+        return {
+            user: userZkevm,
+            magicProvider,
+        };
+    }
+    return {
+        user: user,
+        magicProvider,
+    };
+};
+
+// These are ignored by the Relayer but for consistency we set them to the
+// appropriate values for a 1/1 wallet.
+//
+// Weight of a single signature in the multisig
+const SIGNATURE_WEIGHT = 1;
+// Total required weight in the multisig
+const SIGNATURE_THRESHOLD = 1;
+const ETH_SIGN_FLAG = '02';
+const ETH_SIGN_PREFIX = '\x19\x01';
+const META_TRANSACTIONS_TYPE = `tuple(
+  bool delegateCall,
+  bool revertOnError,
+  uint256 gasLimit,
+  address target,
+  uint256 value,
+  bytes data
+)[]`;
+function getNormalisedTransactions(txs) {
+    return txs.map((t) => ({
+        delegateCall: t.delegateCall === true,
+        revertOnError: t.revertOnError === true,
+        gasLimit: t.gasLimit ?? ethers.ethers.constants.Zero,
+        target: t.to ?? ethers.ethers.constants.AddressZero,
+        value: t.value ?? ethers.ethers.constants.Zero,
+        data: t.data ?? [],
+    }));
+}
+function digestOfTransactionsAndNonce(nonce, normalisedTransactions) {
+    const packMetaTransactionsNonceData = ethers.ethers.utils.defaultAbiCoder.encode(['uint256', META_TRANSACTIONS_TYPE], [nonce, normalisedTransactions]);
+    return ethers.ethers.utils.keccak256(packMetaTransactionsNonceData);
+}
+const getNonce = async (jsonRpcProvider, 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();
+    }
+    return 0;
+};
+const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walletAddress, signer) => {
+    const normalisedMetaTransactions = getNormalisedTransactions(metaTransactions);
+    // Get the hash
+    const digest = digestOfTransactionsAndNonce(nonce, normalisedMetaTransactions);
+    const completePayload = ethers.ethers.utils.solidityPack(['string', 'uint256', 'address', 'bytes32'], [ETH_SIGN_PREFIX, chainId, walletAddress, digest]);
+    const hash = ethers.ethers.utils.keccak256(completePayload);
+    // Sign the digest
+    const hashArray = ethers.ethers.utils.arrayify(hash);
+    const ethsigNoType = await signer.signMessage(hashArray);
+    const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
+    // Add metadata
+    const encodedSignature = config.encodeSignature({
+        threshold: SIGNATURE_THRESHOLD,
+        signers: [
+            {
+                weight: SIGNATURE_WEIGHT,
+                signature: signedDigest,
+            },
+        ],
+    });
+    // Encode the transaction;
+    const walletInterface = new ethers.ethers.utils.Interface(abi.walletContracts.mainModule.abi);
+    return walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [
+        normalisedMetaTransactions,
+        nonce,
+        encodedSignature,
+    ]);
+};
+const chainIdNumber = (chainId) => {
+    const caip2Components = chainId.split(':');
+    if (caip2Components.length !== 2) {
+        throw new Error('Invalid configuration, chain ID is not in CAIP-2 format');
+    }
+    return ethers.BigNumber.from(caip2Components[1]);
+};
+
+const MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES = 30;
+const TRANSACTION_HASH_RETRIEVAL_WAIT = 1000;
+const converBigNumberishToNumber = (value) => ethers.BigNumber.from(value).toNumber();
+const transformGardianTransactions = (txs) => {
+    try {
+        return txs.map((t) => ({
+            delegateCall: t.delegateCall === true,
+            revertOnError: t.revertOnError === true,
+            gasLimit: t.gasLimit ? converBigNumberishToNumber(t.gasLimit).toString() : '0',
+            target: t.to ?? ethers.ethers.constants.AddressZero,
+            value: t.value ? converBigNumberishToNumber(t.value).toString() : '0',
+            data: t.data ? t.data.toString() : '0x00',
+        }));
+    }
+    catch (error) {
+        const errorMessage = (error instanceof Error) ? error.message : String(error);
+        throw new JsonRpcError(exports.RpcErrorCode.INVALID_PARAMS, `Transaction failed to parsing: ${errorMessage}`);
+    }
+};
+const guardianValidation = async ({ transactionAPI, chainId, nonce, user, metaTransactions, }) => {
+    const headers = { Authorization: `Bearer ${user.accessToken}` };
+    const guardianTransactions = transformGardianTransactions(metaTransactions);
+    try {
+        await transactionAPI.evaluateTransaction({
+            id: 'evm',
+            transactionEvaluationRequest: {
+                chainType: 'evm',
+                chainId,
+                transactionData: {
+                    nonce,
+                    userAddress: user.zkEvm.ethAddress,
+                    metaTransactions: guardianTransactions,
+                },
+            },
+        }, { headers });
+    }
+    catch (error) {
+        const errorMessage = (error instanceof Error) ? error.message : String(error);
+        throw new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, `Transaction failed to validate with error: ${errorMessage}`);
+    }
+};
+const sendTransaction = async ({ params, magicProvider, jsonRpcProvider, relayerClient, transactionAPI, config, user, }) => {
+    const transactionRequest = params[0];
+    if (!transactionRequest.to) {
+        throw new JsonRpcError(exports.RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
+    }
+    const chainId = chainIdNumber(config.zkEvmChainId);
+    const magicWeb3Provider = new providers.Web3Provider(magicProvider);
+    const signer = magicWeb3Provider.getSigner();
+    const nonce = await getNonce(jsonRpcProvider, user.zkEvm.ethAddress);
+    const metaTransaction = {
+        to: transactionRequest.to,
+        data: transactionRequest.data,
+        nonce,
+        value: transactionRequest.value,
+        revertOnError: true,
+    };
+    // NOTE: We sign the transaction before getting the fee options because
+    // accurate estimation of a transaction gas cost is only possible if the smart
+    // wallet contract can actually execute it (in a simulated environment) - and
+    // it can only execute signed transactions.
+    const signedTransaction = await getSignedMetaTransactions([metaTransaction], nonce, chainId, user.zkEvm.ethAddress, signer);
+    // TODO: ID-698 Add support for non-native gas payments (e.g ERC20, feeTransaction initialisation must change)
+    // NOTE: "Fee Options" represent the multiple ways we could pay for the gas
+    // used in this transaction. Each fee option has a "recipientAddress" we
+    // should transfer the payment to, an amount and a currency. We choose one
+    // option and build a transaction that sends the expected currency amount for
+    // that option to the specified address.
+    const feeOptions = await relayerClient.imGetFeeOptions(user.zkEvm.ethAddress, signedTransaction);
+    const imxFeeOption = feeOptions.find((feeOption) => feeOption.tokenSymbol === 'IMX');
+    if (!imxFeeOption) {
+        throw new Error('Failed to retrieve fees for IMX token');
+    }
+    const feeMetaTransaction = {
+        nonce,
+        to: imxFeeOption.recipientAddress,
+        value: imxFeeOption.tokenPrice,
+        revertOnError: true,
+    };
+    await guardianValidation({
+        transactionAPI,
+        chainId: config.zkEvmChainId,
+        nonce: converBigNumberishToNumber(nonce),
+        user,
+        metaTransactions: [metaTransaction, feeMetaTransaction],
+    });
+    // NOTE: We sign again because we now are adding the fee transaction, so the
+    // whole payload is different and needs a new signature.
+    const signedTransactions = await getSignedMetaTransactions([metaTransaction, feeMetaTransaction], nonce, chainId, user.zkEvm.ethAddress, signer);
+    // TODO: ID-697 Evaluate transactions through Guardian
+    const relayerId = await relayerClient.ethSendTransaction(user.zkEvm.ethAddress, signedTransactions);
+    const retrieveRelayerTransaction = async () => {
+        const tx = await relayerClient.imGetTransactionByHash(relayerId);
+        // NOTE: The transaction hash is only available from the Relayer once the
+        // transaction is actually submitted onchain. Hence we need to poll the
+        // Relayer get transaction endpoint until the status transitions to one that
+        // has the hash available.
+        if (tx.status === RelayerTransactionStatus.PENDING) {
+            throw new Error();
+        }
+        return tx;
+    };
+    const relayerTransaction = await retryWithDelay(retrieveRelayerTransaction, {
+        retries: MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES,
+        interval: TRANSACTION_HASH_RETRIEVAL_WAIT,
+        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(exports.RpcErrorCode.RPC_SERVER_ERROR, `Transaction failed to submit with status ${relayerTransaction.status}`);
+    }
+    return relayerTransaction.hash;
+};
+
+class ZkEvmProvider {
+    authManager;
+    config;
+    confirmationScreen;
+    magicAdapter;
+    relayerClient;
+    transactionAPI;
+    multiRollupApiClients;
+    jsonRpcProvider; // Used for read
+    eventEmitter;
+    magicProvider; // Used for signing
+    user;
+    constructor({ authManager, magicAdapter, config, confirmationScreen, multiRollupApiClients, }) {
+        this.authManager = authManager;
+        this.magicAdapter = magicAdapter;
+        this.config = config;
+        this.confirmationScreen = confirmationScreen;
+        this.relayerClient = new RelayerClient({ config });
+        this.transactionAPI = new TransactionsApi(new Configuration({
+            basePath: this.config.imxPublicApiDomain,
+        }));
+        this.jsonRpcProvider = new providers.JsonRpcProvider(this.config.zkEvmRpcUrl);
+        this.multiRollupApiClients = multiRollupApiClients;
+        this.eventEmitter = new TypedEventEmitter();
+    }
+    isLoggedIn() {
+        return this.magicProvider !== undefined && this.user !== undefined;
+    }
+    async performRequest(request) {
+        switch (request.method) {
+            case 'eth_requestAccounts': {
+                if (this.isLoggedIn()) {
+                    return [this.user.zkEvm.ethAddress];
+                }
+                const { magicProvider, user } = await loginZkEvmUser({
+                    authManager: this.authManager,
+                    config: this.config,
+                    magicAdapter: this.magicAdapter,
+                    multiRollupApiClients: this.multiRollupApiClients,
+                });
+                this.user = user;
+                this.magicProvider = magicProvider;
+                this.eventEmitter.emit(exports.ProviderEvent.ACCOUNTS_CHANGED, [this.user.zkEvm.ethAddress]);
+                return [this.user.zkEvm.ethAddress];
+            }
+            case 'eth_sendTransaction': {
+                if (!this.isLoggedIn()) {
+                    throw new JsonRpcError(exports.ProviderErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
+                }
+                return sendTransaction({
+                    params: request.params || [],
+                    magicProvider: this.magicProvider,
+                    transactionAPI: this.transactionAPI,
+                    jsonRpcProvider: this.jsonRpcProvider,
+                    config: this.config,
+                    relayerClient: this.relayerClient,
+                    user: this.user,
+                });
+            }
+            case 'eth_accounts': {
+                return this.isLoggedIn() ? [this.user.zkEvm.ethAddress] : [];
+            }
+            // Pass through methods
+            case 'eth_gasPrice':
+            case 'eth_getBalance':
+            case 'eth_getStorageAt':
+            case 'eth_estimateGas':
+            case 'eth_call':
+            case 'eth_blockNumber':
+            case 'eth_chainId':
+            case 'eth_getBlockByHash':
+            case 'eth_getBlockByNumber':
+            case 'eth_getTransactionByHash':
+            case 'eth_getTransactionReceipt':
+            case 'eth_getTransactionCount': {
+                return this.jsonRpcProvider.send(request.method, request.params || []);
+            }
+            default: {
+                throw new JsonRpcError(exports.ProviderErrorCode.UNSUPPORTED_METHOD, 'Method not supported');
+            }
+        }
+    }
+    async performJsonRpcRequest(request) {
+        const { id, jsonrpc } = request;
+        try {
+            const result = await this.performRequest(request);
+            return {
+                id,
+                jsonrpc,
+                result,
+            };
+        }
+        catch (error) {
+            let jsonRpcError;
+            if (error instanceof JsonRpcError) {
+                jsonRpcError = error;
+            }
+            else if (error instanceof Error) {
+                jsonRpcError = new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, error.message);
+            }
+            else {
+                jsonRpcError = new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+            }
+            return {
+                id,
+                jsonrpc,
+                error: jsonRpcError,
+            };
+        }
+    }
+    async request(request) {
+        try {
+            return this.performRequest(request);
+        }
+        catch (error) {
+            if (error instanceof JsonRpcError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, error.message);
+            }
+            throw new JsonRpcError(exports.RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+        }
+    }
+    sendAsync(request, callback) {
+        if (!callback) {
+            throw new Error('No callback provided');
+        }
+        if (Array.isArray(request)) {
+            Promise.all(request.map(this.performJsonRpcRequest)).then((result) => {
+                callback(null, result);
+            }).catch((error) => {
+                callback(error, []);
+            });
+        }
+        else {
+            this.performJsonRpcRequest(request).then((result) => {
+                callback(null, result);
+            }).catch((error) => {
+                callback(error, null);
+            });
+        }
+    }
+    async send(request, callbackOrParams, callback) {
+        // Web3 >= 1.0.0-beta.38 calls `send` with method and parameters.
+        if (typeof request === 'string') {
+            if (typeof callbackOrParams === 'function') {
+                return this.sendAsync({
+                    method: request,
+                    params: [],
+                }, callbackOrParams);
+            }
+            if (callback) {
+                return this.sendAsync({
+                    method: request,
+                    params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
+                }, callback);
+            }
+            return this.request({
+                method: request,
+                params: Array.isArray(callbackOrParams) ? callbackOrParams : [],
+            });
+        }
+        // Web3 <= 1.0.0-beta.37 uses `send` with a callback for async queries.
+        if (typeof callbackOrParams === 'function') {
+            return this.sendAsync(request, callbackOrParams);
+        }
+        if (!Array.isArray(request) && typeof request === 'object') {
+            return this.performJsonRpcRequest(request);
+        }
+        throw new JsonRpcError(exports.RpcErrorCode.INVALID_REQUEST, 'Invalid request');
+    }
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    removeListener(event, listener) {
+        this.eventEmitter.removeListener(event, listener);
+    }
+}
+
 class Passport {
     authManager;
     config;
@@ -11095,6 +11823,7 @@ class Passport {
     immutableXClient;
     magicAdapter;
     passportImxProviderFactory;
+    multiRollupApiClients;
     constructor(passportModuleConfiguration) {
         this.config = new PassportConfiguration(passportModuleConfiguration);
         this.authManager = new AuthManager(this.config);
@@ -11104,6 +11833,7 @@ class Passport {
             || new ImmutableXClient({
                 baseConfig: passportModuleConfiguration.baseConfig,
             });
+        this.multiRollupApiClients = new MultiRollupApiClients(this.config.multiRollupConfig);
         this.passportImxProviderFactory = new PassportImxProviderFactory({
             authManager: this.authManager,
             config: this.config,
@@ -11133,12 +11863,29 @@ class Passport {
     async connectImxWithCredentials(tokenResponse) {
         return this.passportImxProviderFactory.getProviderWithCredentials(tokenResponse);
     }
+    // TODO ID-926 Make method public once development has been finalised
+    connectEvm() {
+        return new ZkEvmProvider({
+            authManager: this.authManager,
+            magicAdapter: this.magicAdapter,
+            config: this.config,
+            confirmationScreen: this.confirmationScreen,
+            multiRollupApiClients: this.multiRollupApiClients,
+        });
+    }
     async loginCallback() {
         return this.authManager.loginCallback();
     }
     async logout() {
         return this.authManager.logout();
     }
+    /**
+     * This method should only be called from the logout redirect uri
+     * when logout mode is 'silent'.
+     */
+    async logoutSilentCallback(url) {
+        return this.authManager.logoutSilentCallback(url);
+    }
     async logoutDeviceFlow() {
         return this.authManager.logoutDeviceFlow();
     }
@@ -12055,31 +12802,25 @@ class ImmutableApiClientFactory {
     }
 }
 
-const DEVNET_CHAIN_NAME = 'imtbl-zkevm-devnet';
 const TESTNET_CHAIN_NAME = 'imtbl-zkevm-testnet';
 const MAINNET_CHAIN_NAME = 'imtbl-zkevm-mainnet';
-function getOrderbookConfig(chainName) {
-    switch (chainName) {
-        case DEVNET_CHAIN_NAME:
+function getOrderbookConfig(environment) {
+    switch (environment) {
+        case exports.Environment.SANDBOX:
             return {
-                seaportContractAddress: '0x41388404Efb7a68Fd31d75CEf71dF91e2BDBa2fb',
-                zoneContractAddress: '0xCb5063b0c1dcF4f7fed8E7eaa79faf9859792767',
-                apiEndpoint: 'https://order-book-mr.dev.imtbl.com',
-                provider: new ethers.providers.JsonRpcProvider('https://zkevm-rpc.dev.x.immutable.com'),
-            };
-        case TESTNET_CHAIN_NAME:
-            return {
-                seaportContractAddress: '0x45E23dA18804F99Cf67408AeBE85F67c958381Ff',
-                zoneContractAddress: '0x25b00b7eb97eab6194798E9B8eF63Aa526D5bd7E',
+                seaportContractAddress: '0x474989C4D25DD41B0B9b1ECb4643B9Fe25f83B19',
+                zoneContractAddress: '0x6FeDb4949E5b452700A8a8956999a7E05B6770F3',
                 apiEndpoint: 'https://order-book-mr.sandbox.imtbl.com',
+                chainName: TESTNET_CHAIN_NAME,
                 provider: new ethers.providers.JsonRpcProvider('https://zkevm-rpc.sandbox.x.immutable.com'),
             };
-        case MAINNET_CHAIN_NAME:
-            // not yet deployed
+        // not yet deployed
+        case exports.Environment.PRODUCTION:
             return {
                 seaportContractAddress: '',
                 zoneContractAddress: '',
                 apiEndpoint: 'https://order-book-mr.imtbl.com',
+                chainName: MAINNET_CHAIN_NAME,
                 provider: new ethers.providers.JsonRpcProvider('https://zkevm-rpc.x.immutable.com'),
             };
         default:
@@ -13038,21 +13779,19 @@ class Orderbook {
     apiClient;
     seaport;
     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');
-        }
-        this.orderbookConfig = maybeConfig;
-        const { apiEndpoint } = this.orderbookConfig;
-        if (!apiEndpoint) {
-            throw new Error('API endpoint must be provided as an override');
+    constructor(config) {
+        const obConfig = getOrderbookConfig(config.baseConfig.environment);
+        const finalConfig = {
+            ...obConfig,
+            ...config.overrides,
+        };
+        if (!finalConfig) {
+            throw new Error('Orderbook configuration not passed, please specify the environment under config.baseConfig.environment');
         }
-        // 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.orderbookConfig = finalConfig;
+        const { apiEndpoint, chainName } = this.orderbookConfig;
+        if (!apiEndpoint) {
+            throw new Error('API endpoint must be provided');
         }
         this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainName, this.orderbookConfig.seaportContractAddress).create();
         const seaportLibFactory = new SeaportLibFactory(this.orderbookConfig.seaportContractAddress, this.orderbookConfig.provider);
@@ -24387,7 +25126,7 @@ const ETH_MAINNET_CHAIN_ID = 'eip155:1';
 /**
  * @constant {string} ZKEVM_DEVNET_CHAIN_ID - The chain ID for the zkEVM devnet (EIP-155 compatible format).
  */
-const ZKEVM_DEVNET_CHAIN_ID = 'eip155:13403';
+const ZKEVM_DEVNET_CHAIN_ID = 'eip155:13423';
 /**
 /**
  * @constant {string} ZKEVM_TESTNET_CHAIN_ID - The chain ID for the zkEVM testnet (EIP-155 compatible format).
@@ -24445,14 +25184,14 @@ const SUPPORTED_BRIDGES_FOR_ENVIRONMENT = {
  */
 const CONTRACTS_FOR_BRIDGE = new Map()
     .set(ETH_SEPOLIA_TO_ZKEVM_DEVNET, {
-    rootChainERC20Predicate: '0x15Dd735de418B6d290727aed82cC25F8966dE4A5',
-    rootChainStateSender: '0xb3Bac13799dAca9D9eC9307303a65fA1218b4724',
+    rootChainERC20Predicate: '0xf0b3435411A74F1aeCBD0fd6D53a90D5227fEeba',
+    rootChainStateSender: '0x868097dbAcfD431F441d09D0e4D3B5eD3182E597',
     childChainERC20Predicate: '0x0000000000000000000000000000000000001004',
     childChainStateReceiver: '0x0000000000000000000000000000000000001001',
 })
     .set(ETH_SEPOLIA_TO_ZKEVM_TESTNET, {
-    rootChainERC20Predicate: '0x9A7E4C4337a70C6754a9672F5ba69084463794B8',
-    rootChainStateSender: '0xfBfF6FD165adFA113bE39eE85ef030A996153253',
+    rootChainERC20Predicate: '0x0C15a8359865867CdCC44f98b2F3fd5DF098C7E0',
+    rootChainStateSender: '0x4C80001188db53dbc2eaAb32d5ef825feEedECA5',
     childChainERC20Predicate: '0x0000000000000000000000000000000000001004',
     childChainStateReceiver: '0x0000000000000000000000000000000000001001',
 })
@@ -25044,7 +25783,7 @@ function getQuote(otherCurrency, tradeType, tradeInfo, slippage) {
 }
 
 const IMMUTABLE_TESTNET_RPC_URL = 'https://zkevm-rpc.sandbox.x.immutable.com';
-const IMMUTABLE_TESTNET_CHAIN_ID = 13392;
+const IMMUTABLE_TESTNET_CHAIN_ID = 13372;
 
 const TIMX_IMMUTABLE_TESTNET = {
     chainId: IMMUTABLE_TESTNET_CHAIN_ID,
@@ -26683,16 +27422,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.
@@ -26702,6 +27453,7 @@ function validateOverrides(overrides) {
 class ExchangeConfiguration {
     baseConfig;
     chain;
+    secondaryFees;
     constructor({ chainId, baseConfig, overrides }) {
         this.baseConfig = baseConfig;
         if (overrides) {
@@ -26713,8 +27465,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);
@@ -26728,11 +27482,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,
@@ -26815,6 +27571,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 */ 
@@ -26891,8 +27650,8 @@ const $762782b6c862d954$export$db5daa1b5156ccfe = [
  */ exports.ChainId = void 0;
 (function(ChainId) {
     ChainId[ChainId["IMTBL_ZKEVM_MAINNET"] = 13371] = "IMTBL_ZKEVM_MAINNET";
-    ChainId[ChainId["IMTBL_ZKEVM_TESTNET"] = 13392] = "IMTBL_ZKEVM_TESTNET";
-    ChainId[ChainId["IMTBL_ZKEVM_DEVNET"] = 13403] = "IMTBL_ZKEVM_DEVNET";
+    ChainId[ChainId["IMTBL_ZKEVM_TESTNET"] = 13372] = "IMTBL_ZKEVM_TESTNET";
+    ChainId[ChainId["IMTBL_ZKEVM_DEVNET"] = 13423] = "IMTBL_ZKEVM_DEVNET";
     ChainId[ChainId["ETHEREUM"] = 1] = "ETHEREUM";
     ChainId[ChainId["SEPOLIA"] = 11155111] = "SEPOLIA";
 })(exports.ChainId || (exports.ChainId = {}));
@@ -26977,6 +27736,10 @@ const $d85ad1457a3f1a83$export$161d4a74df65fc08 = {
     [(exports.Environment).SANDBOX]: "https://checkout-api.sandbox.immutable.com",
     [(exports.Environment).PRODUCTION]: "https://checkout-api.immutable.com"
 };
+const $d85ad1457a3f1a83$export$7b057be2a3f512cc = {
+    [(exports.Environment).SANDBOX]: "https://zkevm-rpc.sandbox.x.immutable.com",
+    [(exports.Environment).PRODUCTION]: "https://zkevm-rpc.x.immutable.com"
+};
 const $d85ad1457a3f1a83$export$6f24f3cef7d501c4 = new Map([
     [
         (exports.ChainId).ETHEREUM,
@@ -27002,7 +27765,7 @@ const $d85ad1457a3f1a83$export$6f24f3cef7d501c4 = new Map([
             chainIdHex: `0x${(exports.ChainId).IMTBL_ZKEVM_MAINNET.toString(16)}`,
             chainName: (exports.ChainName).IMTBL_ZKEVM_MAINNET,
             rpcUrls: [
-                "https://zkevm-rpc.x.immutable.com"
+                "https://rpc.immutable.com"
             ],
             nativeCurrency: {
                 name: "IMX",
@@ -27037,7 +27800,7 @@ const $d85ad1457a3f1a83$export$3e81fc0987227f10 = new Map([
             chainIdHex: `0x${(exports.ChainId).IMTBL_ZKEVM_TESTNET.toString(16)}`,
             chainName: (exports.ChainName).IMTBL_ZKEVM_TESTNET,
             rpcUrls: [
-                "https://zkevm-rpc.sandbox.x.immutable.com"
+                "https://rpc.testnet.immutable.com"
             ],
             nativeCurrency: {
                 name: "IMX",
@@ -27413,16 +28176,19 @@ async function $5c763be0b0b81038$var$getMetaMaskProvider() {
     if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", (exports.CheckoutErrorType).METAMASK_PROVIDER_ERROR);
     return new (providers.Web3Provider)(provider);
 }
-async function $5c763be0b0b81038$export$500fbc0cd14cdbaa(defaultProvider) {
-    let web3Provider = null;
-    switch(defaultProvider){
+async function $5c763be0b0b81038$export$500fbc0cd14cdbaa(walletProviderName) {
+    let provider = null;
+    switch(walletProviderName){
         case (exports.WalletProviderName).METAMASK:
-            web3Provider = await $5c763be0b0b81038$var$getMetaMaskProvider();
+            provider = await $5c763be0b0b81038$var$getMetaMaskProvider();
             break;
         default:
             throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider not supported", (exports.CheckoutErrorType).DEFAULT_PROVIDER_ERROR);
     }
-    return web3Provider;
+    return {
+        provider: provider,
+        walletProviderName: walletProviderName
+    };
 }
 
 
@@ -27431,9 +28197,8 @@ async function $5c763be0b0b81038$export$500fbc0cd14cdbaa(defaultProvider) {
 
 
 
-
 function $bb88265fe45a0393$export$ebe4804963e71f98(web3Provider) {
-    if (web3Provider && web3Provider instanceof (providers.Web3Provider) && web3Provider.provider?.request) return true;
+    if (web3Provider && web3Provider.provider?.request && typeof web3Provider.provider.request === "function") return true;
     return false;
 }
 async function $bb88265fe45a0393$export$9e1fd9cc88c637a0(config, web3Provider, validateProviderOptions) {
@@ -27643,10 +28408,23 @@ class $4013c5c91bb535f6$export$6ad73ea7e1b6f37f extends Error {
         this.message = message;
     }
 }
-const $4013c5c91bb535f6$var$networkMap = (prod, dev)=>{
-    if (dev) return $d85ad1457a3f1a83$export$3a9ebede6a150274;
-    if (prod) return $d85ad1457a3f1a83$export$6f24f3cef7d501c4;
-    return $d85ad1457a3f1a83$export$3e81fc0987227f10;
+const $4013c5c91bb535f6$var$networkMap = (prod, dev, local)=>{
+    let networks;
+    if (dev) networks = ($d85ad1457a3f1a83$export$3a9ebede6a150274);
+    else if (prod) {
+        networks = ($d85ad1457a3f1a83$export$6f24f3cef7d501c4);
+        if (local) {
+            const rpcUrls = networks.get((exports.ChainId).IMTBL_ZKEVM_MAINNET)?.rpcUrls;
+            rpcUrls?.splice(0, 1, ($d85ad1457a3f1a83$export$7b057be2a3f512cc)[(exports.Environment).PRODUCTION]);
+        }
+    } else {
+        networks = ($d85ad1457a3f1a83$export$3e81fc0987227f10);
+        if (local) {
+            const rpcUrls = networks.get((exports.ChainId).IMTBL_ZKEVM_TESTNET)?.rpcUrls;
+            rpcUrls?.splice(0, 1, ($d85ad1457a3f1a83$export$7b057be2a3f512cc)[(exports.Environment).SANDBOX]);
+        }
+    }
+    return networks;
 };
 const $4013c5c91bb535f6$export$9b794d067cdd1af6 = (config)=>{
     // DevMode and Sandbox will both use Sepolia.
@@ -27664,6 +28442,11 @@ class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
     // This will be used to get around the lack of
     // Environment.DEVELOPMENT
     isDevelopment = false;
+    // This is a hidden feature that is only available
+    // when building the project from source code.
+    // This will be used to get around the lack of
+    // Environment.LOCAL_DEVELOPMENT
+    isLocal = false;
     isProduction;
     remote;
     environment;
@@ -27673,7 +28456,7 @@ class $4013c5c91bb535f6$export$4823433c4a67bbc6 {
         this.environment = config.baseConfig.environment;
         // Developer mode will super set any environment configuration
         this.isProduction = !this.isDevelopment && this.environment === (exports.Environment).PRODUCTION;
-        this.networkMap = $4013c5c91bb535f6$var$networkMap(this.isProduction, this.isDevelopment);
+        this.networkMap = $4013c5c91bb535f6$var$networkMap(this.isProduction, this.isDevelopment, this.isLocal);
         this.remote = new ($a492ee374ae7b613$export$d902b56530cd5f87)({
             isDevelopment: this.isDevelopment,
             isProduction: this.isProduction
@@ -27819,10 +28602,7 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
    * @param {CreateProviderParams} params - The parameters for creating the provider.
    * @returns {Promise<CreateProviderResult>} A promise that resolves to the created provider.
    */ async createProvider(params) {
-        const web3Provider = await $5c763be0b0b81038$export$500fbc0cd14cdbaa(params.walletProvider);
-        return {
-            provider: web3Provider
-        };
+        return await $5c763be0b0b81038$export$500fbc0cd14cdbaa(params.walletProvider);
     }
     /**
    * Checks if a wallet is connected to the specified provider.
@@ -27939,7 +28719,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.4.0-alpha.1";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.4.0-alpha.3";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 
@@ -29758,6 +30538,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;