@imtbl/sdk 0.0.1-alpha.2 → 0.1.0-alpha

package/dist/provider.js

@@ -1,6 +1,6 @@
+import { Config, TransfersApi, OrdersApi, UsersApi, Contracts, TradesApi, ExchangesApi, WithdrawalsApi, MintsApi, DepositsApi, EncodingApi, TokensApi } from '@imtbl/core-sdk';
 import BN from 'bn.js';
 import * as encUtils from 'enc-utils';
-import { Config, TransfersApi, OrdersApi, UsersApi, Contracts, TradesApi, ExchangesApi, WithdrawalsApi, MintsApi, DepositsApi, EncodingApi, TokensApi } from '@imtbl/core-sdk';
 import { parseUnits } from '@ethersproject/units';
 import { BigNumber } from '@ethersproject/bignumber';
 import { ethers } from 'ethers';
@@ -78,18 +78,9 @@ function convertToSignableToken(token) {
 
 var Environment;
 (function (Environment) {
-    Environment["DEVELOPMENT"] = "development";
-    Environment["SANDBOX"] = "sandbox";
     Environment["PRODUCTION"] = "production";
+    Environment["SANDBOX"] = "sandbox";
 })(Environment || (Environment = {}));
-({
-    ...Config.PRODUCTION,
-    env: Environment.PRODUCTION,
-});
-({
-    ...Config.SANDBOX,
-    env: Environment.SANDBOX,
-});
 
 function isChainValid(chainID, config) {
     return chainID === config.ethConfiguration.chainID;
@@ -100,10 +91,10 @@ async function validateChain(signer, config) {
         throw new Error('The wallet used for this operation is not connected to the correct network.');
 }
 
-async function transfer({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
+async function transfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new TransfersApi(config.getStarkExConfig().apiConfiguration);
+    const transfersApi = new TransfersApi(config.immutableXConfig.apiConfiguration);
     const transferAmount = request.type === 'ERC721' ? '1' : request.amount;
     const signableResult = await transfersApi.getSignableTransferV1({
         getSignableTransferRequest: {
@@ -115,7 +106,7 @@ async function transfer({ signers: { ethSigner, starkExSigner }, request, config
     });
     const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
     const ethSignature = await signRaw(signableMessage, ethSigner);
-    const starkSignature = await starkExSigner.signMessage(payloadHash);
+    const starkSignature = await starkSigner.signMessage(payloadHash);
     const transferSigningParams = {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         sender_stark_key: signableResult.data.sender_stark_key,
@@ -140,10 +131,10 @@ async function transfer({ signers: { ethSigner, starkExSigner }, request, config
         transfer_id: response?.data.transfer_id,
     };
 }
-async function batchTransfer({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
+async function batchTransfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new TransfersApi(config.getStarkExConfig().apiConfiguration);
+    const transfersApi = new TransfersApi(config.immutableXConfig.apiConfiguration);
     const signableRequests = request.map((nftTransfer) => {
         return {
             amount: '1',
@@ -168,7 +159,7 @@ async function batchTransfer({ signers: { ethSigner, starkExSigner }, request, c
     const ethSignature = await signRaw(signableMessage, ethSigner);
     const requests = [];
     for (const resp of signableResult.data.signable_responses) {
-        const starkSignature = await starkExSigner.signMessage(resp.payload_hash);
+        const starkSignature = await starkSigner.signMessage(resp.payload_hash);
         const req = {
             sender_vault_id: resp.sender_vault_id,
             receiver_stark_key: resp.receiver_stark_key,
@@ -197,9 +188,9 @@ async function batchTransfer({ signers: { ethSigner, starkExSigner }, request, c
 }
 
 async function createOrder({ signers, request, config, }) {
-    await validateChain(signers.ethSigner, config.getStarkExConfig());
+    await validateChain(signers.ethSigner, config.immutableXConfig);
     const ethAddress = await signers.ethSigner.getAddress();
-    const ordersApi = new OrdersApi(config.getStarkExConfig().apiConfiguration);
+    const ordersApi = new 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 = {
@@ -216,7 +207,7 @@ async function createOrder({ signers, request, config, }) {
     });
     const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableOrderResponse.data;
     const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkExSigner.signMessage(payloadHash);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
     const resp = getSignableOrderResponse.data;
     const orderParams = {
         createOrderRequest: {
@@ -242,7 +233,7 @@ async function createOrder({ signers, request, config, }) {
     };
 }
 async function cancelOrder({ signers, request, config, }) {
-    const ordersApi = new OrdersApi(config.getStarkExConfig().apiConfiguration);
+    const ordersApi = new OrdersApi(config.immutableXConfig.apiConfiguration);
     const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
         getSignableCancelOrderRequest: {
             order_id: request.order_id,
@@ -250,7 +241,7 @@ async function cancelOrder({ signers, request, config, }) {
     });
     const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
     const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkExSigner.signMessage(payloadHash);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
     const ethAddress = await signers.ethSigner.getAddress();
     const cancelOrderResponse = await ordersApi.cancelOrder({
         id: request.order_id.toString(),
@@ -268,10 +259,10 @@ async function cancelOrder({ signers, request, config, }) {
 }
 
 async function registerOffchain(signers, config) {
-    await validateChain(signers.ethSigner, config.getStarkExConfig());
-    const usersApi = new UsersApi(config.getStarkExConfig().apiConfiguration);
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const usersApi = new UsersApi(config.immutableXConfig.apiConfiguration);
     const userAddress = await signers.ethSigner.getAddress();
-    const starkPublicKey = await signers.starkExSigner.getAddress();
+    const starkPublicKey = await signers.starkSigner.getAddress();
     const signableResult = await usersApi.getSignableRegistrationOffchain({
         getSignableRegistrationRequest: {
             ether_key: userAddress,
@@ -280,7 +271,7 @@ async function registerOffchain(signers, config) {
     });
     const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
     const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkExSigner.signMessage(payloadHash);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
     const registeredUser = await usersApi.registerUser({
         registerUserRequest: {
             eth_signature: ethSignature,
@@ -292,8 +283,8 @@ async function registerOffchain(signers, config) {
     return registeredUser.data;
 }
 async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
-    await validateChain(ethSigner, config.getStarkExConfig());
-    const registrationContract = Contracts.Registration.connect(config.getStarkExConfig().ethConfiguration.registrationContractAddress, ethSigner);
+    await validateChain(ethSigner, config.immutableXConfig);
+    const registrationContract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
     try {
         return await registrationContract.isRegistered(starkPublicKey);
     }
@@ -323,7 +314,7 @@ const assertIsDefined = (value) => {
     throw new Error('undefined field exception');
 };
 async function prepareWithdrawalAction(params) {
-    const { signers: { ethSigner, starkExSigner }, type, config, } = params;
+    const { signers: { ethSigner, starkSigner }, type, config, } = params;
     await validateChain(ethSigner, params.config);
     const withdrawalsApi = new WithdrawalsApi(config.apiConfiguration);
     const withdrawalAmount = type === 'ERC721' ? '1' : params.amount;
@@ -335,7 +326,7 @@ async function prepareWithdrawalAction(params) {
         },
     });
     const { signable_message: signableMessage, payload_hash: payloadHash } = signableWithdrawalResult.data;
-    const starkSignature = await starkExSigner.signMessage(payloadHash);
+    const starkSignature = await starkSigner.signMessage(payloadHash);
     const { ethAddress, ethSignature } = await signMessage(signableMessage, ethSigner);
     const prepareWithdrawalResponse = await withdrawalsApi.createWithdrawal({
         createWithdrawalRequest: {
@@ -368,10 +359,10 @@ async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
 
 async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
     const etherKey = await ethSigner.getAddress();
-    const starkExConfig = config.getStarkExConfig();
-    const usersApi = new UsersApi(starkExConfig.apiConfiguration);
+    const imxConfig = config.immutableXConfig;
+    const usersApi = new UsersApi(imxConfig.apiConfiguration);
     const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.getStarkExConfig().ethConfiguration.registrationContractAddress, ethSigner);
+    const contract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
     return ethSigner.sendTransaction(populatedTransaction);
 }
@@ -381,9 +372,9 @@ async function executeWithdrawERC20(ethSigner, assetType, starkPublicKey, config
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
-    const starkExConfig = config.getStarkExConfig();
-    const assetType = await getEncodeAssetInfo('asset', 'ERC20', starkExConfig, {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC20', imxConfig, {
         token_address: token.tokenAddress,
     });
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
@@ -396,7 +387,7 @@ async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token,
         });
     }
     else {
-        return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, starkExConfig);
+        return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
 }
 
@@ -419,8 +410,8 @@ function getMintingBlob(token) {
     return encUtils.sanitizeHex(encUtils.utf8ToHex(`{${id}}:{${blueprint}}`));
 }
 async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.getStarkExConfig();
-    const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', starkExConfig, {
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', imxConfig, {
         id: token.data.id,
         token_address: token.data.tokenAddress,
         ...(token.data.blueprint && { blueprint: token.data.blueprint }),
@@ -428,10 +419,10 @@ async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token
     const mintingBlob = getMintingBlob(token);
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
     if (!isRegistered) {
-        return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, starkExConfig);
+        return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
     }
     else {
-        return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, starkExConfig);
+        return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
     }
 }
 async function executeRegisterAndWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
@@ -448,25 +439,25 @@ async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, token
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.getStarkExConfig();
-    const assetType = await getEncodeAssetInfo('asset', 'ERC721', starkExConfig, {
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC721', imxConfig, {
         token_id: token.tokenId,
         token_address: token.tokenAddress,
     });
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
     if (!isRegistered) {
-        return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, starkExConfig);
+        return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
     }
     else {
-        return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, starkExConfig);
+        return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
     }
 }
 async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
+    await validateChain(ethSigner, config.immutableXConfig);
     const tokenAddress = token.tokenAddress;
     const tokenId = token.tokenId;
-    const starkExConfig = config.getStarkExConfig();
-    const mintsApi = new MintsApi(starkExConfig.apiConfiguration);
+    const imxConfig = config.immutableXConfig;
+    const mintsApi = new MintsApi(imxConfig.apiConfiguration);
     return await mintsApi
         .getMintableTokenDetailsByClientTokenId({
         tokenAddress,
@@ -503,23 +494,22 @@ async function executeWithdrawEth(ethSigner, assetType, starkPublicKey, config)
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
-    const starkExConfig = config.getStarkExConfig();
-    const assetType = await getEncodeAssetInfo('asset', 'ETH', starkExConfig);
+    await validateChain(ethSigner, config.immutableXConfig);
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ETH', imxConfig);
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
     if (!isRegistered) {
-        return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, starkExConfig);
+        return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
     else {
-        return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, starkExConfig);
+        return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
 }
 
 async function prepareWithdrawal({ signers, withdrawal, config, }) {
-    const starkExConfig = config.getStarkExConfig();
     return prepareWithdrawalAction({
         signers,
-        config: starkExConfig,
+        config: config.immutableXConfig,
         ...withdrawal,
     });
 }
@@ -544,10 +534,10 @@ async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, toke
     }
 }
 
-async function createTrade({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
+async function createTrade({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
-    const tradesApi = new TradesApi(config.getStarkExConfig().apiConfiguration);
+    const tradesApi = new TradesApi(config.immutableXConfig.apiConfiguration);
     const signableResult = await tradesApi.getSignableTrade({
         getSignableTradeRequest: {
             user: ethAddress,
@@ -557,7 +547,7 @@ async function createTrade({ signers: { ethSigner, starkExSigner }, request, con
     });
     const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
     const ethSignature = await signRaw(signableMessage, ethSigner);
-    const starkSignature = await starkExSigner.signMessage(payloadHash);
+    const starkSignature = await starkSigner.signMessage(payloadHash);
     const createTradeResponse = await tradesApi.createTrade({
         createTradeRequest: {
             amount_buy: signableResult.data.amount_buy,
@@ -582,16 +572,16 @@ async function createTrade({ signers: { ethSigner, starkExSigner }, request, con
 }
 
 async function depositEth({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
+    await validateChain(ethSigner, config.immutableXConfig);
     const user = await ethSigner.getAddress();
     const data = {
         decimals: 18,
     };
     const amount = parseUnits(deposit.amount, 'wei');
-    const starkExConfig = config.getStarkExConfig();
-    const depositsApi = new DepositsApi(starkExConfig.apiConfiguration);
-    const encodingApi = new EncodingApi(starkExConfig.apiConfiguration);
-    const usersApi = new UsersApi(starkExConfig.apiConfiguration);
+    const imxConfig = config.immutableXConfig;
+    const depositsApi = new DepositsApi(imxConfig.apiConfiguration);
+    const encodingApi = new EncodingApi(imxConfig.apiConfiguration);
+    const usersApi = new UsersApi(imxConfig.apiConfiguration);
     const getSignableDepositRequest = {
         user,
         token: {
@@ -616,10 +606,10 @@ async function depositEth({ signers: { ethSigner }, deposit, config, }) {
     const vaultId = signableDepositResult.data.vault_id;
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
     if (!isRegistered) {
-        return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, starkExConfig, usersApi);
+        return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig, usersApi);
     }
     else {
-        return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, starkExConfig);
+        return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
     }
 }
 async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
@@ -636,8 +626,8 @@ async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, v
 }
 
 async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
-    const { apiConfiguration, ethConfiguration } = config.getStarkExConfig();
+    await validateChain(ethSigner, config.immutableXConfig);
+    const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
     const user = await ethSigner.getAddress();
     const tokensApi = new TokensApi(apiConfiguration);
     const depositsApi = new DepositsApi(apiConfiguration);
@@ -704,12 +694,12 @@ async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetT
 }
 
 async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
+    await validateChain(ethSigner, config.immutableXConfig);
     const user = await ethSigner.getAddress();
-    const starkExConfig = config.getStarkExConfig();
-    const depositsApi = new DepositsApi(starkExConfig.apiConfiguration);
-    const encodingApi = new EncodingApi(starkExConfig.apiConfiguration);
-    const usersApi = new UsersApi(starkExConfig.apiConfiguration);
+    const { immutableXConfig } = config;
+    const depositsApi = new DepositsApi(immutableXConfig.apiConfiguration);
+    const encodingApi = new EncodingApi(immutableXConfig.apiConfiguration);
+    const usersApi = new UsersApi(immutableXConfig.apiConfiguration);
     const data = {
         token_address: deposit.tokenAddress,
         token_id: deposit.tokenId,
@@ -745,18 +735,18 @@ async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
     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 operator = starkExConfig.ethConfiguration.coreContractAddress;
+    const operator = immutableXConfig.ethConfiguration.coreContractAddress;
     const isApprovedForAll = await tokenContract.isApprovedForAll(user, operator);
     if (!isApprovedForAll) {
         await tokenContract.setApprovalForAll(operator, true);
     }
     if (!isRegistered) {
         const signableResult = await getSignableRegistrationOnchain(user, starkPublicKey, usersApi);
-        const coreContract = Contracts.Core.connect(starkExConfig.ethConfiguration.coreContractAddress, ethSigner);
+        const coreContract = Contracts.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);
     }
-    return executeDepositERC721(ethSigner, deposit.tokenId, assetType, starkPublicKey, vaultId, starkExConfig);
+    return executeDepositERC721(ethSigner, deposit.tokenId, assetType, starkPublicKey, vaultId, immutableXConfig);
 }
 async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
     const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
@@ -776,8 +766,8 @@ async function deposit({ signers, deposit, config }) {
 }
 
 async function exchangeTransfer({ signers, request, config, }) {
-    await validateChain(signers.ethSigner, config.getStarkExConfig());
-    const exchangeApi = new ExchangesApi(config.getStarkExConfig().apiConfiguration);
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const exchangeApi = new ExchangesApi(config.immutableXConfig.apiConfiguration);
     const ethAddress = await signers.ethSigner.getAddress();
     const transferAmount = request.amount;
     const signableResult = await exchangeApi.getExchangeSignableTransfer({
@@ -791,7 +781,7 @@ async function exchangeTransfer({ signers, request, config, }) {
     });
     const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
     const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkExSigner.signMessage(payloadHash);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
     const transferSigningParams = {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         sender_stark_key: signableResult.data.sender_stark_key,
@@ -821,9 +811,9 @@ async function exchangeTransfer({ signers, request, config, }) {
 class GenericIMXProvider {
     config;
     signers;
-    constructor(config, ethSigner, starkExSigner) {
+    constructor(config, ethSigner, starkSigner) {
         this.config = config;
-        this.signers = { ethSigner, starkExSigner };
+        this.signers = { ethSigner, starkSigner };
     }
     async getAddress() {
         return await this.signers.ethSigner.getAddress();
@@ -882,7 +872,7 @@ class GenericIMXProvider {
         });
     }
     async isRegisteredOnchain() {
-        const starkPublicKey = await this.signers.starkExSigner.getAddress();
+        const starkPublicKey = await this.signers.starkSigner.getAddress();
         return isRegisteredOnChain(starkPublicKey, this.signers.ethSigner, this.config);
     }
     prepareWithdrawal(request) {
@@ -1000,7 +990,6 @@ class ImxSigner {
 
 const IMX_WALLET_IFRAME_ID = 'imx-wallet-app';
 const IMX_WALLET_IFRAME_HOSTS = {
-    [Environment.DEVELOPMENT]: 'http://localhost:8080',
     [Environment.SANDBOX]: 'https://wallets.sandbox.immutable.com',
     [Environment.PRODUCTION]: 'https://wallets.immutable.com',
 };
@@ -1094,16 +1083,15 @@ const withProviderError = async (fn, customError) => {
 
 class MetaMaskIMXProvider extends GenericIMXProvider {
     static imxSigner;
-    constructor(config, ethSigner, starkExSigner) {
-        super(config, ethSigner, starkExSigner);
+    constructor(config, ethSigner, starkSigner) {
+        super(config, ethSigner, starkSigner);
     }
     static async connect(config) {
-        const starkExConfig = config.getStarkExConfig();
         return await withProviderError(async () => {
             const metaMaskProvider = await connect$1({
-                chainID: starkExConfig.ethConfiguration.chainID,
+                chainID: config.immutableXConfig.ethConfiguration.chainID,
             });
-            this.imxSigner = await connect(metaMaskProvider, starkExConfig.env);
+            this.imxSigner = await connect(metaMaskProvider, config.baseConfig.environment);
             return new MetaMaskIMXProvider(config, metaMaskProvider.getSigner(), this.imxSigner);
         }, { type: ProviderErrorType.WALLET_CONNECTION_ERROR });
     }
@@ -1125,4 +1113,27 @@ class MetaMaskIMXProvider extends GenericIMXProvider {
     }
 }
 
-export { GenericIMXProvider, MetaMaskIMXProvider };
+class ProviderConfiguration {
+    immutableXConfig;
+    baseConfig;
+    constructor({ baseConfig, overrides }) {
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            this.immutableXConfig = overrides.immutableXConfig;
+        }
+        else {
+            switch (baseConfig.environment) {
+                case Environment.SANDBOX: {
+                    this.immutableXConfig = Config.SANDBOX;
+                    break;
+                }
+                case Environment.PRODUCTION: {
+                    this.immutableXConfig = Config.PRODUCTION;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+export { GenericIMXProvider, MetaMaskIMXProvider, ProviderConfiguration };

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@imtbl/sdk",
   "description": "Immutable Unified SDK",
-  "version": "0.0.1-alpha.2",
+  "version": "0.1.0-alpha",
   "author": "Immutable",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",
   "dependencies": {
-    "@biom3/design-tokens": "0.1.4-beta",
-    "@biom3/react": "^0.1.3-beta",
     "@ethersproject/providers": "^5.7.2",
-    "@imtbl/core-sdk": "^1.0.2-alpha.5",
+    "@imtbl/core-sdk": "^1.1.1-alpha.1",
     "@magic-ext/oidc": "^1.0.1",
     "@metamask/detect-provider": "^2.0.0",
     "axios": "^1.3.5",
@@ -17,19 +15,19 @@
     "magic-sdk": "^13.3.1",
     "oidc-client-ts": "^2.2.1",
     "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "react-router-dom": "^6.10.0"
+    "react-dom": "^18.2.0"
   },
   "devDependencies": {
     "@imtbl/checkout-sdk-web": "0.0.0",
     "@imtbl/checkout-ui-types": "0.0.0",
     "@imtbl/config": "0.0.0",
+    "@imtbl/immutablex-client": "0.0.0",
     "@imtbl/passport": "0.0.0",
     "@imtbl/provider": "0.0.0",
-    "@imtbl/starkex": "0.0.0",
     "@rollup/plugin-commonjs": "^24.0.1",
     "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^15.0.2",
+    "@rollup/plugin-replace": "^5.0.2",
     "@rollup/plugin-typescript": "^11.0.0",
     "@yarnpkg/cli": "3.5.0",
     "@yarnpkg/core": "3.5.0",
@@ -40,17 +38,22 @@
     "typescript": "^4.9.5"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=16.11.0"
   },
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/base.d.ts",
-      "import": "./dist/base.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
-    "./starkex": {
-      "types": "./dist/starkex.d.ts",
-      "import": "./dist/starkex.js"
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js"
+    },
+    "./immutablex_client": {
+      "types": "./dist/immutablex_client.d.ts",
+      "import": "./dist/immutablex_client.js"
     },
     "./passport": {
       "types": "./dist/passport.d.ts",
@@ -75,13 +78,18 @@
   "homepage": "https://github.com/immutable/ts-immutable-sdk#readme",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "repository": "immutable/ts-immutable-sdk.git",
   "scripts": {
-    "build": "yarn packageList && yarn updateDependencies && rm -rf dist && NODE_ENV=production rollup --config rollup.config.js && rm -rf dist/types",
+    "build": "yarn packageList && yarn updateDependencies && yarn regenModules && rm -rf dist && NODE_ENV=production rollup --config rollup.config.js && rm -rf dist/types",
+    "build:only": "rm -rf dist && NODE_ENV=production rollup --config rollup.config.js && rm -rf dist/types",
+    "generateIndex": "node scripts/generateIndex.js",
     "lint": "eslint ./src --ext .ts,.jsx,.tsx --max-warnings=0",
     "packageList": "./scripts/generate-package-list.sh",
+    "regenModules": "yarn generateIndex && yarn updateExports",
     "typecheck": "tsc --noEmit --jsx preserve",
-    "updateDependencies": "node ./scripts/updateDependencies.js"
+    "updateDependencies": "yarn packageList && node ./scripts/updateDependencies.js",
+    "updateExports": "node scripts/updateExports.js"
   },
   "type": "module",
   "types": "./dist/index.d.ts"