@imtbl/sdk 1.19.2-alpha.1 → 1.19.2-alpha.2

package/dist/index.js

@@ -17,8 +17,8 @@ import jwt_decode from 'jwt-decode';
 import * as crypto from 'crypto';
 import { Magic } from 'magic-sdk';
 import { OpenIdExtension } from '@magic-ext/oidc';
-import { generateLegacyStarkPrivateKey as generateLegacyStarkPrivateKey$1, createStarkSigner as createStarkSigner$1, Config, TransfersApi as TransfersApi$2, OrdersApi as OrdersApi$3, UsersApi as UsersApi$2, Contracts, TradesApi as TradesApi$2, ExchangesApi as ExchangesApi$2, WithdrawalsApi as WithdrawalsApi$2, MintsApi as MintsApi$2, DepositsApi as DepositsApi$2, EncodingApi as EncodingApi$2, TokensApi as TokensApi$3 } from '@imtbl/core-sdk';
-import { StaticJsonRpcProvider, Web3Provider } from '@ethersproject/providers';
+import { generateLegacyStarkPrivateKey as generateLegacyStarkPrivateKey$1, createStarkSigner as createStarkSigner$1 } from '@imtbl/core-sdk';
+import { JsonRpcProvider, Web3Provider } from '@ethersproject/providers';
 import { EventEmitter } from 'events';
 import { walletContracts } from '@0xsequence/abi';
 import { v1 } from '@0xsequence/core';
@@ -159,7 +159,7 @@ const flattenProperties$1 = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION$1 = '1.19.2-alpha.1';
+const SDK_VERSION$1 = '1.19.2-alpha.2';
 const getReferrer$1 = () => {
     if (isNode$1()) {
         return '';
@@ -13535,7 +13535,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.19.2-alpha.1' };
+const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.19.2-alpha.2' };
 const createConfig$1 = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -13607,7 +13607,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders$1 = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.19.2-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.19.2-alpha.2',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -14081,7 +14081,7 @@ var blockchain_data = /*#__PURE__*/Object.freeze({
 /* eslint-disable @typescript-eslint/naming-convention */
 class ApiConfiguration extends index$2.Configuration {
 }
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.19.2-alpha.1' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.19.2-alpha.2' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -14120,7 +14120,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.19.2-alpha.1',
+    sdkVersion: 'ts-immutable-sdk-1.19.2-alpha.2',
     baseConfig,
 });
 const production = ({ baseConfig }) => createImmutableXConfiguration({
@@ -25615,9 +25615,9 @@ function digestOfTransactionsAndNonce(nonce, normalisedTransactions) {
     const packMetaTransactionsNonceData = utils$3.defaultAbiCoder.encode(['uint256', META_TRANSACTIONS_TYPE], [nonce, normalisedTransactions]);
     return utils$3.keccak256(packMetaTransactionsNonceData);
 }
-const getNonce = async (staticJsonRpcProvider, smartContractWalletAddress) => {
+const getNonce = async (jsonRpcProvider, smartContractWalletAddress) => {
     try {
-        const contract = new Contract$1(smartContractWalletAddress, walletContracts.mainModule.abi, staticJsonRpcProvider);
+        const contract = new Contract$1(smartContractWalletAddress, walletContracts.mainModule.abi, jsonRpcProvider);
         const result = await contract.nonce();
         if (result instanceof BigNumber$1) {
             return result;
@@ -25719,11 +25719,11 @@ const getEip155ChainId = (chainId) => `eip155:${chainId}`;
 
 class RelayerClient {
     config;
-    staticJsonRpcProvider;
+    jsonRpcProvider;
     authManager;
-    constructor({ config, staticJsonRpcProvider, authManager }) {
+    constructor({ config, jsonRpcProvider, authManager }) {
         this.config = config;
-        this.staticJsonRpcProvider = staticJsonRpcProvider;
+        this.jsonRpcProvider = jsonRpcProvider;
         this.authManager = authManager;
     }
     async postToRelayer(request) {
@@ -25748,7 +25748,7 @@ class RelayerClient {
         return jsonResponse;
     }
     async ethSendTransaction(to, data) {
-        const { chainId } = await this.staticJsonRpcProvider.ready;
+        const { chainId } = await this.jsonRpcProvider.ready;
         const payload = {
             method: 'eth_sendTransaction',
             params: [{
@@ -25769,7 +25769,7 @@ class RelayerClient {
         return result;
     }
     async imGetFeeOptions(userAddress, data) {
-        const { chainId } = await this.staticJsonRpcProvider.ready;
+        const { chainId } = await this.jsonRpcProvider.ready;
         const payload = {
             method: 'im_getFeeOptions',
             params: [{
@@ -25782,7 +25782,7 @@ class RelayerClient {
         return result;
     }
     async imSignTypedData(address, eip712Payload) {
-        const { chainId } = await this.staticJsonRpcProvider.ready;
+        const { chainId } = await this.jsonRpcProvider.ready;
         const payload = {
             method: 'im_signTypedData',
             params: [{
@@ -25829,11 +25829,11 @@ class JsonRpcError extends Error {
 }
 
 const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
-async function registerZkEvmUser({ authManager, ethSigner, multiRollupApiClients, accessToken, staticJsonRpcProvider, }) {
+async function registerZkEvmUser({ authManager, ethSigner, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
     const [ethereumAddress, ethereumSignature, network, chainListResponse] = await Promise.all([
         ethSigner.getAddress(),
         signRaw(MESSAGE_TO_SIGN, ethSigner),
-        staticJsonRpcProvider.ready,
+        jsonRpcProvider.ready,
         multiRollupApiClients.chainsApi.listChains(),
     ]);
     const eipChainId = getEip155ChainId(network.chainId);
@@ -26054,15 +26054,15 @@ const getMetaTransactions = async (metaTransaction, nonce, chainId, walletAddres
     }
     return [metaTransaction, feeMetaTransaction];
 };
-const sendTransaction$1 = ({ params, ethSigner, staticJsonRpcProvider, relayerClient, guardianClient, zkevmAddress, }) => guardianClient
+const sendTransaction$1 = ({ params, ethSigner, jsonRpcProvider, relayerClient, guardianClient, zkevmAddress, }) => guardianClient
     .withConfirmationScreen({ width: 480, height: 720 })(async () => {
     const transactionRequest = params[0];
     if (!transactionRequest.to) {
         throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'eth_sendTransaction requires a "to" field');
     }
-    const { chainId } = await staticJsonRpcProvider.ready;
+    const { chainId } = await jsonRpcProvider.ready;
     const chainIdBigNumber = BigNumber$1.from(chainId);
-    const nonce = await getNonce(staticJsonRpcProvider, zkevmAddress);
+    const nonce = await getNonce(jsonRpcProvider, zkevmAddress);
     const metaTransaction = {
         to: transactionRequest.to,
         data: transactionRequest.data,
@@ -26150,14 +26150,14 @@ const transformTypedData = (typedData, chainId) => {
     }
     return transformedTypedData;
 };
-const signTypedDataV4 = async ({ params, method, ethSigner, staticJsonRpcProvider, relayerClient, guardianClient, }) => guardianClient
+const signTypedDataV4 = async ({ params, method, ethSigner, jsonRpcProvider, relayerClient, guardianClient, }) => guardianClient
     .withConfirmationScreen({ width: 480, height: 720 })(async () => {
     const fromAddress = params[0];
     const typedDataParam = params[1];
     if (!fromAddress || !typedDataParam) {
         throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `${method} requires an address and a typed data JSON`);
     }
-    const { chainId } = await staticJsonRpcProvider.ready;
+    const { chainId } = await jsonRpcProvider.ready;
     const typedData = transformTypedData(typedDataParam, chainId);
     await guardianClient.validateMessage({ chainID: String(chainId), payload: typedData });
     const relayerSignature = await relayerClient.imSignTypedData(fromAddress, typedData);
@@ -26170,7 +26170,7 @@ class ZkEvmProvider {
     #config;
     #eventEmitter;
     #guardianClient;
-    #staticJsonRpcProvider; // Used for read
+    #jsonRpcProvider; // Used for read
     #magicAdapter;
     #multiRollupApiClients;
     #relayerClient;
@@ -26190,19 +26190,19 @@ class ZkEvmProvider {
         this.#config = config;
         this.#guardianClient = guardianClient;
         if (config.crossSdkBridgeEnabled) {
-            // StaticJsonRpcProvider by default sets the referrer as "client".
+            // JsonRpcProvider by default sets the referrer as "client".
             // On Unreal 4 this errors as the browser used is expecting a valid URL.
-            this.#staticJsonRpcProvider = new StaticJsonRpcProvider({
+            this.#jsonRpcProvider = new JsonRpcProvider({
                 url: this.#config.zkEvmRpcUrl,
                 fetchOptions: { referrer: 'http://imtblgamesdk.local' },
             });
         }
         else {
-            this.#staticJsonRpcProvider = new StaticJsonRpcProvider(this.#config.zkEvmRpcUrl);
+            this.#jsonRpcProvider = new JsonRpcProvider(this.#config.zkEvmRpcUrl);
         }
         this.#relayerClient = new RelayerClient({
             config: this.#config,
-            staticJsonRpcProvider: this.#staticJsonRpcProvider,
+            jsonRpcProvider: this.#jsonRpcProvider,
             authManager: this.#authManager,
         });
         this.#multiRollupApiClients = multiRollupApiClients;
@@ -26273,7 +26273,7 @@ class ZkEvmProvider {
                         authManager: this.#authManager,
                         multiRollupApiClients: this.#multiRollupApiClients,
                         accessToken: user.accessToken,
-                        staticJsonRpcProvider: this.#staticJsonRpcProvider,
+                        jsonRpcProvider: this.#jsonRpcProvider,
                     });
                 }
                 else {
@@ -26291,7 +26291,7 @@ class ZkEvmProvider {
                     params: request.params || [],
                     ethSigner,
                     guardianClient: this.#guardianClient,
-                    staticJsonRpcProvider: this.#staticJsonRpcProvider,
+                    jsonRpcProvider: this.#jsonRpcProvider,
                     relayerClient: this.#relayerClient,
                     zkevmAddress: this.#zkEvmAddress,
                 });
@@ -26309,7 +26309,7 @@ class ZkEvmProvider {
                     method: request.method,
                     params: request.params || [],
                     ethSigner,
-                    staticJsonRpcProvider: this.#staticJsonRpcProvider,
+                    jsonRpcProvider: this.#jsonRpcProvider,
                     relayerClient: this.#relayerClient,
                     guardianClient: this.#guardianClient,
                 });
@@ -26328,7 +26328,7 @@ class ZkEvmProvider {
             case 'eth_getTransactionByHash':
             case 'eth_getTransactionReceipt':
             case 'eth_getTransactionCount': {
-                return this.#staticJsonRpcProvider.send(request.method, request.params || []);
+                return this.#jsonRpcProvider.send(request.method, request.params || []);
             }
             default: {
                 throw new JsonRpcError(ProviderErrorCode.UNSUPPORTED_METHOD, 'Method not supported');
@@ -45415,7 +45415,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.19.2-alpha.1';
+const SDK_VERSION = '1.19.2-alpha.2';
 const getReferrer = () => {
     if (isNode()) {
         return '';
@@ -50610,7 +50610,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '1.19.2-alpha.1';
+const SDK_VERSION_MARKER = '1.19.2-alpha.2';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -51419,7 +51419,7 @@ async function bridgeToL2GasEstimator(readOnlyProviders, config) {
     const toChainId = getL2ChainId(config);
     const provider = readOnlyProviders.get(fromChainId);
     if (!provider)
-        throw new Error(`Missing StaticJsonRpcProvider for chain id: ${fromChainId}`);
+        throw new Error(`Missing JsonRpcProvider for chain id: ${fromChainId}`);
     try {
         const tokenBridge = createBridgeInstance(fromChainId, toChainId, readOnlyProviders, config);
         // This gas estimate does not include an ERC20 approval
@@ -52346,7 +52346,7 @@ async function createReadOnlyProviders(config, existingReadOnlyProviders) {
     });
     allowedNetworks.networks.forEach((networkInfo) => {
         const rpcUrl = config.networkMap.get(networkInfo.chainId)?.rpcUrls[0];
-        const provider = new StaticJsonRpcProvider(rpcUrl);
+        const provider = new JsonRpcProvider(rpcUrl);
         readOnlyProviders.set(networkInfo.chainId, provider);
     });
     return readOnlyProviders;
@@ -54745,7 +54745,7 @@ async function validateChain(signer, config) {
 async function transfer({ signers: { ethSigner, starkSigner }, request, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new TransfersApi$2(config.immutableXConfig.apiConfiguration);
+    const transfersApi = new index$2.TransfersApi(config.immutableXConfig.apiConfiguration);
     const transferAmount = request.type === 'ERC721' ? '1' : request.amount;
     const signableResult = await transfersApi.getSignableTransferV1({
         getSignableTransferRequest: {
@@ -54785,7 +54785,7 @@ async function transfer({ signers: { ethSigner, starkSigner }, request, config,
 async function batchTransfer({ signers: { ethSigner, starkSigner }, request, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new TransfersApi$2(config.immutableXConfig.apiConfiguration);
+    const transfersApi = new index$2.TransfersApi(config.immutableXConfig.apiConfiguration);
     const signableRequests = request.map((nftTransfer) => ({
         amount: '1',
         token: convertToSignableToken({
@@ -54841,7 +54841,7 @@ async function batchTransfer({ signers: { ethSigner, starkSigner }, request, con
 async function createOrder({ signers, request, config, }) {
     await validateChain(signers.ethSigner, config.immutableXConfig);
     const ethAddress = await signers.ethSigner.getAddress();
-    const ordersApi = new OrdersApi$3(config.immutableXConfig.apiConfiguration);
+    const ordersApi = new index$2.OrdersApi(config.immutableXConfig.apiConfiguration);
     const amountSell = request.sell.type === 'ERC721' ? '1' : request.sell.amount;
     const amountBuy = request.buy.type === 'ERC721' ? '1' : request.buy.amount;
     const getSignableOrderRequest = {
@@ -54883,7 +54883,7 @@ async function createOrder({ signers, request, config, }) {
     };
 }
 async function cancelOrder({ signers, request, config, }) {
-    const ordersApi = new OrdersApi$3(config.immutableXConfig.apiConfiguration);
+    const ordersApi = new index$2.OrdersApi(config.immutableXConfig.apiConfiguration);
     const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrderV3({
         getSignableCancelOrderRequest: {
             order_id: request.order_id,
@@ -54910,7 +54910,7 @@ async function cancelOrder({ signers, request, config, }) {
 
 async function registerOffchain(signers, config) {
     await validateChain(signers.ethSigner, config.immutableXConfig);
-    const usersApi = new UsersApi$2(config.immutableXConfig.apiConfiguration);
+    const usersApi = new index$2.UsersApi(config.immutableXConfig.apiConfiguration);
     const userAddress = await signers.ethSigner.getAddress();
     const starkPublicKey = await signers.starkSigner.getAddress();
     const signableResult = await usersApi.getSignableRegistrationOffchain({
@@ -54934,7 +54934,7 @@ async function registerOffchain(signers, config) {
 }
 async function isRegisteredOffchain(ethAddress, config) {
     try {
-        const usersApi = new UsersApi$2(config.immutableXConfig.apiConfiguration);
+        const usersApi = new index$2.UsersApi(config.immutableXConfig.apiConfiguration);
         const getUsersResult = await usersApi.getUsers({
             user: ethAddress,
         });
@@ -54950,7 +54950,7 @@ async function isRegisteredOffchain(ethAddress, config) {
 }
 async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
     await validateChain(ethSigner, config.immutableXConfig);
-    const registrationContract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
+    const registrationContract = exportContracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
     try {
         return await registrationContract.isRegistered(starkPublicKey);
     }
@@ -54984,7 +54984,7 @@ const assertIsDefined = (value) => {
 async function prepareWithdrawalAction(params) {
     const { signers: { ethSigner, starkSigner }, type, config, } = params;
     await validateChain(ethSigner, params.config);
-    const withdrawalsApi = new WithdrawalsApi$2(config.apiConfiguration);
+    const withdrawalsApi = new index$2.WithdrawalsApi(config.apiConfiguration);
     const withdrawalAmount = type === 'ERC721' ? '1' : params.amount;
     const signableWithdrawalResult = await withdrawalsApi.getSignableWithdrawal({
         getSignableWithdrawalRequest: {
@@ -55012,7 +55012,7 @@ async function prepareWithdrawalAction(params) {
 }
 
 async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
-    const encodingApi = new EncodingApi$2(config.apiConfiguration);
+    const encodingApi = new index$2.EncodingApi(config.apiConfiguration);
     const result = await encodingApi.encodeAsset({
         assetType,
         encodeAssetRequest: {
@@ -55028,14 +55028,14 @@ async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
 async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
     const etherKey = await ethSigner.getAddress();
     const imxConfig = config.immutableXConfig;
-    const usersApi = new UsersApi$2(imxConfig.apiConfiguration);
+    const usersApi = new index$2.UsersApi(imxConfig.apiConfiguration);
     const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
+    const contract = exportContracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function executeWithdrawERC20(ethSigner, assetType, starkPublicKey, config) {
-    const contract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const contract = exportContracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
     return ethSigner.sendTransaction(populatedTransaction);
 }
@@ -55058,15 +55058,15 @@ async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token,
 }
 
 async function executeWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
-    const contract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const contract = exportContracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.withdrawAndMint(starkPublicKey, assetType, mintingBlob);
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function executeRegisterAndWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
     const etherKey = await ethSigner.getAddress();
-    const usersApi = new UsersApi$2(config.apiConfiguration);
+    const usersApi = new index$2.UsersApi(config.apiConfiguration);
     const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
+    const contract = exportContracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.regsiterAndWithdrawAndMint(etherKey, starkPublicKey, signableResult.operator_signature, assetType, mintingBlob);
     return ethSigner.sendTransaction(populatedTransaction);
 }
@@ -55091,14 +55091,14 @@ async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token
 }
 async function executeRegisterAndWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
     const etherKey = await ethSigner.getAddress();
-    const usersApi = new UsersApi$2(config.apiConfiguration);
+    const usersApi = new index$2.UsersApi(config.apiConfiguration);
     const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
+    const contract = exportContracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.registerAndWithdrawNft(etherKey, starkPublicKey, signableResult.operator_signature, assetType, tokenId);
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
-    const contract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const contract = exportContracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.withdrawNft(starkPublicKey, assetType, tokenId);
     return ethSigner.sendTransaction(populatedTransaction);
 }
@@ -55119,7 +55119,7 @@ async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token
     const { tokenAddress } = token;
     const { tokenId } = token;
     const imxConfig = config.immutableXConfig;
-    const mintsApi = new MintsApi$2(imxConfig.apiConfiguration);
+    const mintsApi = new index$2.MintsApi(imxConfig.apiConfiguration);
     return await mintsApi
         .getMintableTokenDetailsByClientTokenId({
         tokenAddress,
@@ -55144,14 +55144,14 @@ async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token
 
 async function executeRegisterAndWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
     const etherKey = await ethSigner.getAddress();
-    const usersApi = new UsersApi$2(config.apiConfiguration);
+    const usersApi = new index$2.UsersApi(config.apiConfiguration);
     const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
+    const contract = exportContracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function executeWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
-    const contract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const contract = exportContracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
     return ethSigner.sendTransaction(populatedTransaction);
 }
@@ -55201,7 +55201,7 @@ async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, toke
 async function createTrade({ signers: { ethSigner, starkSigner }, request, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
-    const tradesApi = new TradesApi$2(config.immutableXConfig.apiConfiguration);
+    const tradesApi = new index$2.TradesApi(config.immutableXConfig.apiConfiguration);
     const signableResult = await tradesApi.getSignableTrade({
         getSignableTradeRequest: {
             user: ethAddress,
@@ -55237,13 +55237,13 @@ async function createTrade({ signers: { ethSigner, starkSigner }, request, confi
 
 async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
     const etherKey = await ethSigner.getAddress();
-    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const coreContract = exportContracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
     const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
     const populatedTransaction = await coreContract.populateTransaction.registerAndDepositEth(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId);
     return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
 }
 async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const coreContract = exportContracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
     const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
     return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
 }
@@ -55255,9 +55255,9 @@ async function depositEth({ signers: { ethSigner }, deposit, config, }) {
     };
     const amount = parseUnits(deposit.amount, 'wei');
     const imxConfig = config.immutableXConfig;
-    const depositsApi = new DepositsApi$2(imxConfig.apiConfiguration);
-    const encodingApi = new EncodingApi$2(imxConfig.apiConfiguration);
-    const usersApi = new UsersApi$2(imxConfig.apiConfiguration);
+    const depositsApi = new index$2.DepositsApi(imxConfig.apiConfiguration);
+    const encodingApi = new index$2.EncodingApi(imxConfig.apiConfiguration);
+    const usersApi = new index$2.UsersApi(imxConfig.apiConfiguration);
     const getSignableDepositRequest = {
         user,
         token: {
@@ -55289,13 +55289,13 @@ async function depositEth({ signers: { ethSigner }, deposit, config, }) {
 
 async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config, usersApi) {
     const etherKey = await ethSigner.getAddress();
-    const coreContract = Contracts.Core.connect(config.coreContractAddress, ethSigner);
+    const coreContract = exportContracts.Core.connect(config.coreContractAddress, ethSigner);
     const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
     const populatedTransaction = await coreContract.populateTransaction.registerAndDepositERC20(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId, quantizedAmount);
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = Contracts.Core.connect(config.coreContractAddress, ethSigner);
+    const coreContract = exportContracts.Core.connect(config.coreContractAddress, ethSigner);
     const populatedTransaction = await coreContract.populateTransaction.depositERC20(starkPublicKey, assetType, vaultId, quantizedAmount);
     return ethSigner.sendTransaction(populatedTransaction);
 }
@@ -55303,10 +55303,10 @@ async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
     const user = await ethSigner.getAddress();
-    const tokensApi = new TokensApi$3(apiConfiguration);
-    const depositsApi = new DepositsApi$2(apiConfiguration);
-    const encodingApi = new EncodingApi$2(apiConfiguration);
-    const usersApi = new UsersApi$2(apiConfiguration);
+    const tokensApi = new index$2.TokensApi(apiConfiguration);
+    const depositsApi = new index$2.DepositsApi(apiConfiguration);
+    const encodingApi = new index$2.EncodingApi(apiConfiguration);
+    const usersApi = new index$2.UsersApi(apiConfiguration);
     // Get decimals for this specific ERC20
     const token = await tokensApi.getToken({ address: deposit.tokenAddress });
     // TODO: remove once fixed
@@ -55318,7 +55318,7 @@ async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
     };
     const amount = parseUnits(deposit.amount, 0); // 0 to always use undecimalized value
     // Approve whether an amount of token from an account can be spent by a third-party account
-    const tokenContract = Contracts.IERC20.connect(deposit.tokenAddress, ethSigner);
+    const tokenContract = exportContracts.IERC20.connect(deposit.tokenAddress, ethSigner);
     const approveTransaction = await tokenContract.populateTransaction.approve(ethConfiguration.coreContractAddress, amount);
     await ethSigner.sendTransaction(approveTransaction);
     const getSignableDepositRequest = {
@@ -55356,7 +55356,7 @@ async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
 }
 
 async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const coreContract = exportContracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
     const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
     return ethSigner.sendTransaction(populatedTransaction);
 }
@@ -55364,9 +55364,9 @@ async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const user = await ethSigner.getAddress();
     const { immutableXConfig } = config;
-    const depositsApi = new DepositsApi$2(immutableXConfig.apiConfiguration);
-    const encodingApi = new EncodingApi$2(immutableXConfig.apiConfiguration);
-    const usersApi = new UsersApi$2(immutableXConfig.apiConfiguration);
+    const depositsApi = new index$2.DepositsApi(immutableXConfig.apiConfiguration);
+    const encodingApi = new index$2.EncodingApi(immutableXConfig.apiConfiguration);
+    const usersApi = new index$2.UsersApi(immutableXConfig.apiConfiguration);
     const data = {
         token_address: deposit.tokenAddress,
         token_id: deposit.tokenId,
@@ -55401,7 +55401,7 @@ async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
     const vaultId = signableDepositResult.data.vault_id;
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
     // Approve whether an amount of token from an account can be spent by a third-party account
-    const tokenContract = Contracts.IERC721.connect(deposit.tokenAddress, ethSigner);
+    const tokenContract = exportContracts.IERC721.connect(deposit.tokenAddress, ethSigner);
     const operator = immutableXConfig.ethConfiguration.coreContractAddress;
     const isApprovedForAll = await tokenContract.isApprovedForAll(user, operator);
     if (!isApprovedForAll) {
@@ -55409,7 +55409,7 @@ async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
     }
     if (!isRegistered) {
         const signableResult = await getSignableRegistrationOnchain(user, starkPublicKey, usersApi);
-        const coreContract = Contracts.Core.connect(immutableXConfig.ethConfiguration.coreContractAddress, ethSigner);
+        const coreContract = exportContracts.Core.connect(immutableXConfig.ethConfiguration.coreContractAddress, ethSigner);
         // Note: proxy registration contract registerAndDepositNft method is not used as
         // it currently fails erc721 transfer ownership check
         await coreContract.registerUser(user, starkPublicKey, signableResult.operator_signature);
@@ -55434,7 +55434,7 @@ async function deposit({ signers, deposit, config }) {
 
 async function exchangeTransfer({ signers, request, config, }) {
     await validateChain(signers.ethSigner, config.immutableXConfig);
-    const exchangeApi = new ExchangesApi$2(config.immutableXConfig.apiConfiguration);
+    const exchangeApi = new index$2.ExchangesApi(config.immutableXConfig.apiConfiguration);
     const ethAddress = await signers.ethSigner.getAddress();
     const transferAmount = request.amount;
     const signableResult = await exchangeApi.getExchangeSignableTransfer({
@@ -55793,18 +55793,8 @@ class ProviderConfiguration {
             this.immutableXConfig = overrides.immutableXConfig;
         }
         else {
-            // TODO: remove once a sensible default is chosen
-            // eslint-disable-next-line default-case
-            switch (baseConfig.environment) {
-                case Environment$1.SANDBOX: {
-                    this.immutableXConfig = Config.SANDBOX;
-                    break;
-                }
-                case Environment$1.PRODUCTION: {
-                    this.immutableXConfig = Config.PRODUCTION;
-                    break;
-                }
-            }
+            const clientConfig = new ImxConfiguration({ baseConfig });
+            this.immutableXConfig = clientConfig.immutableXConfig;
         }
     }
 }

package/dist/orderbook.js

@@ -131,7 +131,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.19.2-alpha.1';
+const SDK_VERSION = '1.19.2-alpha.2';
 const getReferrer = () => {
     if (isNode()) {
         return '';