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

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;
@@ -101,9 +92,9 @@ async function validateChain(signer, config) {
 }
 
 async function transfer({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
+    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: {
@@ -141,9 +132,9 @@ async function transfer({ signers: { ethSigner, starkExSigner }, request, config
     };
 }
 async function batchTransfer({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
+    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',
@@ -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 = {
@@ -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,
@@ -268,8 +259,8 @@ 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 signableResult = await usersApi.getSignableRegistrationOffchain({
@@ -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);
     }
@@ -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 starkExConfig = config.immutableXConfig;
     const usersApi = new UsersApi(starkExConfig.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,8 +372,8 @@ 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();
+    await validateChain(ethSigner, config.immutableXConfig);
+    const starkExConfig = config.immutableXConfig;
     const assetType = await getEncodeAssetInfo('asset', 'ERC20', starkExConfig, {
         token_address: token.tokenAddress,
     });
@@ -419,7 +410,7 @@ function getMintingBlob(token) {
     return encUtils.sanitizeHex(encUtils.utf8ToHex(`{${id}}:{${blueprint}}`));
 }
 async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.getStarkExConfig();
+    const starkExConfig = config.immutableXConfig;
     const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', starkExConfig, {
         id: token.data.id,
         token_address: token.data.tokenAddress,
@@ -448,7 +439,7 @@ async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, token
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.getStarkExConfig();
+    const starkExConfig = config.immutableXConfig;
     const assetType = await getEncodeAssetInfo('asset', 'ERC721', starkExConfig, {
         token_id: token.tokenId,
         token_address: token.tokenAddress,
@@ -462,10 +453,10 @@ async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config
     }
 }
 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 starkExConfig = config.immutableXConfig;
     const mintsApi = new MintsApi(starkExConfig.apiConfiguration);
     return await mintsApi
         .getMintableTokenDetailsByClientTokenId({
@@ -503,8 +494,8 @@ 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();
+    await validateChain(ethSigner, config.immutableXConfig);
+    const starkExConfig = config.immutableXConfig;
     const assetType = await getEncodeAssetInfo('asset', 'ETH', starkExConfig);
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
     if (!isRegistered) {
@@ -516,10 +507,9 @@ async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config,
 }
 
 async function prepareWithdrawal({ signers, withdrawal, config, }) {
-    const starkExConfig = config.getStarkExConfig();
     return prepareWithdrawalAction({
         signers,
-        config: starkExConfig,
+        config: config.immutableXConfig,
         ...withdrawal,
     });
 }
@@ -545,9 +535,9 @@ async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, toke
 }
 
 async function createTrade({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
+    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,
@@ -582,13 +572,13 @@ 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 starkExConfig = config.immutableXConfig;
     const depositsApi = new DepositsApi(starkExConfig.apiConfiguration);
     const encodingApi = new EncodingApi(starkExConfig.apiConfiguration);
     const usersApi = new UsersApi(starkExConfig.apiConfiguration);
@@ -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({
@@ -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',
 };
@@ -1098,12 +1087,11 @@ class MetaMaskIMXProvider extends GenericIMXProvider {
         super(config, ethSigner, starkExSigner);
     }
     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 };