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

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,9 +78,18 @@ function convertToSignableToken(token) {
 
 var Environment;
 (function (Environment) {
-    Environment["PRODUCTION"] = "production";
+    Environment["DEVELOPMENT"] = "development";
     Environment["SANDBOX"] = "sandbox";
+    Environment["PRODUCTION"] = "production";
 })(Environment || (Environment = {}));
+({
+    ...Config.PRODUCTION,
+    env: Environment.PRODUCTION,
+});
+({
+    ...Config.SANDBOX,
+    env: Environment.SANDBOX,
+});
 
 function isChainValid(chainID, config) {
     return chainID === config.ethConfiguration.chainID;
@@ -92,9 +101,9 @@ async function validateChain(signer, config) {
 }
 
 async function transfer({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
+    await validateChain(ethSigner, config.getStarkExConfig());
     const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new TransfersApi(config.immutableXConfig.apiConfiguration);
+    const transfersApi = new TransfersApi(config.getStarkExConfig().apiConfiguration);
     const transferAmount = request.type === 'ERC721' ? '1' : request.amount;
     const signableResult = await transfersApi.getSignableTransferV1({
         getSignableTransferRequest: {
@@ -132,9 +141,9 @@ async function transfer({ signers: { ethSigner, starkExSigner }, request, config
     };
 }
 async function batchTransfer({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
+    await validateChain(ethSigner, config.getStarkExConfig());
     const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new TransfersApi(config.immutableXConfig.apiConfiguration);
+    const transfersApi = new TransfersApi(config.getStarkExConfig().apiConfiguration);
     const signableRequests = request.map((nftTransfer) => {
         return {
             amount: '1',
@@ -188,9 +197,9 @@ async function batchTransfer({ signers: { ethSigner, starkExSigner }, request, c
 }
 
 async function createOrder({ signers, request, config, }) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
+    await validateChain(signers.ethSigner, config.getStarkExConfig());
     const ethAddress = await signers.ethSigner.getAddress();
-    const ordersApi = new OrdersApi(config.immutableXConfig.apiConfiguration);
+    const ordersApi = new OrdersApi(config.getStarkExConfig().apiConfiguration);
     const amountSell = request.sell.type === 'ERC721' ? '1' : request.sell.amount;
     const amountBuy = request.buy.type === 'ERC721' ? '1' : request.buy.amount;
     const getSignableOrderRequest = {
@@ -233,7 +242,7 @@ async function createOrder({ signers, request, config, }) {
     };
 }
 async function cancelOrder({ signers, request, config, }) {
-    const ordersApi = new OrdersApi(config.immutableXConfig.apiConfiguration);
+    const ordersApi = new OrdersApi(config.getStarkExConfig().apiConfiguration);
     const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
         getSignableCancelOrderRequest: {
             order_id: request.order_id,
@@ -259,8 +268,8 @@ async function cancelOrder({ signers, request, config, }) {
 }
 
 async function registerOffchain(signers, config) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
-    const usersApi = new UsersApi(config.immutableXConfig.apiConfiguration);
+    await validateChain(signers.ethSigner, config.getStarkExConfig());
+    const usersApi = new UsersApi(config.getStarkExConfig().apiConfiguration);
     const userAddress = await signers.ethSigner.getAddress();
     const starkPublicKey = await signers.starkExSigner.getAddress();
     const signableResult = await usersApi.getSignableRegistrationOffchain({
@@ -283,8 +292,8 @@ async function registerOffchain(signers, config) {
     return registeredUser.data;
 }
 async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const registrationContract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
+    await validateChain(ethSigner, config.getStarkExConfig());
+    const registrationContract = Contracts.Registration.connect(config.getStarkExConfig().ethConfiguration.registrationContractAddress, ethSigner);
     try {
         return await registrationContract.isRegistered(starkPublicKey);
     }
@@ -359,10 +368,10 @@ async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
 
 async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
     const etherKey = await ethSigner.getAddress();
-    const starkExConfig = config.immutableXConfig;
+    const starkExConfig = config.getStarkExConfig();
     const usersApi = new UsersApi(starkExConfig.apiConfiguration);
     const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
+    const contract = Contracts.Registration.connect(config.getStarkExConfig().ethConfiguration.registrationContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
     return ethSigner.sendTransaction(populatedTransaction);
 }
@@ -372,8 +381,8 @@ async function executeWithdrawERC20(ethSigner, assetType, starkPublicKey, config
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const starkExConfig = config.immutableXConfig;
+    await validateChain(ethSigner, config.getStarkExConfig());
+    const starkExConfig = config.getStarkExConfig();
     const assetType = await getEncodeAssetInfo('asset', 'ERC20', starkExConfig, {
         token_address: token.tokenAddress,
     });
@@ -410,7 +419,7 @@ function getMintingBlob(token) {
     return encUtils.sanitizeHex(encUtils.utf8ToHex(`{${id}}:{${blueprint}}`));
 }
 async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.immutableXConfig;
+    const starkExConfig = config.getStarkExConfig();
     const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', starkExConfig, {
         id: token.data.id,
         token_address: token.data.tokenAddress,
@@ -439,7 +448,7 @@ async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, token
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.immutableXConfig;
+    const starkExConfig = config.getStarkExConfig();
     const assetType = await getEncodeAssetInfo('asset', 'ERC721', starkExConfig, {
         token_id: token.tokenId,
         token_address: token.tokenAddress,
@@ -453,10 +462,10 @@ async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config
     }
 }
 async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
+    await validateChain(ethSigner, config.getStarkExConfig());
     const tokenAddress = token.tokenAddress;
     const tokenId = token.tokenId;
-    const starkExConfig = config.immutableXConfig;
+    const starkExConfig = config.getStarkExConfig();
     const mintsApi = new MintsApi(starkExConfig.apiConfiguration);
     return await mintsApi
         .getMintableTokenDetailsByClientTokenId({
@@ -494,8 +503,8 @@ async function executeWithdrawEth(ethSigner, assetType, starkPublicKey, config)
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const starkExConfig = config.immutableXConfig;
+    await validateChain(ethSigner, config.getStarkExConfig());
+    const starkExConfig = config.getStarkExConfig();
     const assetType = await getEncodeAssetInfo('asset', 'ETH', starkExConfig);
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
     if (!isRegistered) {
@@ -507,9 +516,10 @@ async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config,
 }
 
 async function prepareWithdrawal({ signers, withdrawal, config, }) {
+    const starkExConfig = config.getStarkExConfig();
     return prepareWithdrawalAction({
         signers,
-        config: config.immutableXConfig,
+        config: starkExConfig,
         ...withdrawal,
     });
 }
@@ -535,9 +545,9 @@ async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, toke
 }
 
 async function createTrade({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
+    await validateChain(ethSigner, config.getStarkExConfig());
     const ethAddress = await ethSigner.getAddress();
-    const tradesApi = new TradesApi(config.immutableXConfig.apiConfiguration);
+    const tradesApi = new TradesApi(config.getStarkExConfig().apiConfiguration);
     const signableResult = await tradesApi.getSignableTrade({
         getSignableTradeRequest: {
             user: ethAddress,
@@ -572,13 +582,13 @@ async function createTrade({ signers: { ethSigner, starkExSigner }, request, con
 }
 
 async function depositEth({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
+    await validateChain(ethSigner, config.getStarkExConfig());
     const user = await ethSigner.getAddress();
     const data = {
         decimals: 18,
     };
     const amount = parseUnits(deposit.amount, 'wei');
-    const starkExConfig = config.immutableXConfig;
+    const starkExConfig = config.getStarkExConfig();
     const depositsApi = new DepositsApi(starkExConfig.apiConfiguration);
     const encodingApi = new EncodingApi(starkExConfig.apiConfiguration);
     const usersApi = new UsersApi(starkExConfig.apiConfiguration);
@@ -626,8 +636,8 @@ async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, v
 }
 
 async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
+    await validateChain(ethSigner, config.getStarkExConfig());
+    const { apiConfiguration, ethConfiguration } = config.getStarkExConfig();
     const user = await ethSigner.getAddress();
     const tokensApi = new TokensApi(apiConfiguration);
     const depositsApi = new DepositsApi(apiConfiguration);
@@ -694,12 +704,12 @@ async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetT
 }
 
 async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
+    await validateChain(ethSigner, config.getStarkExConfig());
     const user = await ethSigner.getAddress();
-    const { immutableXConfig } = config;
-    const depositsApi = new DepositsApi(immutableXConfig.apiConfiguration);
-    const encodingApi = new EncodingApi(immutableXConfig.apiConfiguration);
-    const usersApi = new UsersApi(immutableXConfig.apiConfiguration);
+    const starkExConfig = config.getStarkExConfig();
+    const depositsApi = new DepositsApi(starkExConfig.apiConfiguration);
+    const encodingApi = new EncodingApi(starkExConfig.apiConfiguration);
+    const usersApi = new UsersApi(starkExConfig.apiConfiguration);
     const data = {
         token_address: deposit.tokenAddress,
         token_id: deposit.tokenId,
@@ -735,18 +745,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 = immutableXConfig.ethConfiguration.coreContractAddress;
+    const operator = starkExConfig.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(immutableXConfig.ethConfiguration.coreContractAddress, ethSigner);
+        const coreContract = Contracts.Core.connect(starkExConfig.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, immutableXConfig);
+    return executeDepositERC721(ethSigner, deposit.tokenId, assetType, starkPublicKey, vaultId, starkExConfig);
 }
 async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
     const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
@@ -766,8 +776,8 @@ async function deposit({ signers, deposit, config }) {
 }
 
 async function exchangeTransfer({ signers, request, config, }) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
-    const exchangeApi = new ExchangesApi(config.immutableXConfig.apiConfiguration);
+    await validateChain(signers.ethSigner, config.getStarkExConfig());
+    const exchangeApi = new ExchangesApi(config.getStarkExConfig().apiConfiguration);
     const ethAddress = await signers.ethSigner.getAddress();
     const transferAmount = request.amount;
     const signableResult = await exchangeApi.getExchangeSignableTransfer({
@@ -990,6 +1000,7 @@ 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',
 };
@@ -1087,11 +1098,12 @@ 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: config.immutableXConfig.ethConfiguration.chainID,
+                chainID: starkExConfig.ethConfiguration.chainID,
             });
-            this.imxSigner = await connect(metaMaskProvider, config.baseConfig.environment);
+            this.imxSigner = await connect(metaMaskProvider, starkExConfig.env);
             return new MetaMaskIMXProvider(config, metaMaskProvider.getSigner(), this.imxSigner);
         }, { type: ProviderErrorType.WALLET_CONNECTION_ERROR });
     }
@@ -1113,27 +1125,4 @@ class MetaMaskIMXProvider extends GenericIMXProvider {
     }
 }
 
-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 };
+export { GenericIMXProvider, MetaMaskIMXProvider };

package/dist/starkex.d.ts

@@ -1,5 +1,3 @@
-import { StarkExConfiguration } from 'config';
-
 // TypeScript Version: 3.0
 
 type AxiosRequestHeaders = Record<string, string | number | boolean>;
@@ -199,7 +197,7 @@ interface ConfigurationParameters {
     baseOptions?: any;
     formDataCtor?: new () => any;
 }
-declare class Configuration {
+declare class Configuration$1 {
     /**
      * parameter for apiKey security
      * @param name security name
@@ -270,8 +268,8 @@ declare class Configuration {
 declare class BaseAPI {
     protected basePath: string;
     protected axios: AxiosInstance;
-    protected configuration: Configuration | undefined;
-    constructor(configuration?: Configuration, basePath?: string, axios?: AxiosInstance);
+    protected configuration: Configuration$1 | undefined;
+    constructor(configuration?: Configuration$1, basePath?: string, axios?: AxiosInstance);
 }
 
 /**
@@ -8399,7 +8397,43 @@ declare class WithdrawalsApi extends BaseAPI {
     listWithdrawals(requestParameters?: WithdrawalsApiListWithdrawalsRequest, options?: AxiosRequestConfig): Promise<AxiosResponse<ListWithdrawalsResponse, any>>;
 }
 
-declare const StarkExAPIFactory: (config: StarkExConfiguration) => {
+/**
+ * The configuration for the Ethereum network
+ */
+interface EthConfiguration {
+    coreContractAddress: string;
+    registrationContractAddress: string;
+    chainID: number;
+}
+/**
+ * The configuration for the ImmutableX client
+ */
+interface ImmutableXConfiguration {
+    /**
+     * The configuration for the API client
+     */
+    apiConfiguration: Configuration$1;
+    /**
+     * The configuration for the Ethereum network
+     */
+    ethConfiguration: EthConfiguration;
+}
+
+declare enum Environment {
+    DEVELOPMENT = "development",
+    SANDBOX = "sandbox",
+    PRODUCTION = "production"
+}
+type StarkExConfig = ImmutableXConfiguration & {
+    env: Environment;
+};
+declare class Configuration {
+    private readonly starkExConfig;
+    constructor(config: StarkExConfig);
+    getStarkExConfig(): StarkExConfig;
+}
+
+declare const StarkExAPIFactory: (config: Configuration) => {
     depositsApi: DepositsApi;
     mintsApi: MintsApi;
     ordersApi: OrdersApi;

package/dist/starkex.js

@@ -2,7 +2,7 @@ import { ImmutableX } from '@imtbl/core-sdk';
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
 const StarkExAPIFactory = (config) => {
-    const imtblClient = new ImmutableX(config.immutableXConfig);
+    const imtblClient = new ImmutableX(config.getStarkExConfig());
     const { deposit, registerOffchain, isRegisteredOnchain, prepareWithdrawal, completeWithdrawal, createOrder, cancelOrder, createTrade, transfer, batchNftTransfer, ...StarkEx } = imtblClient;
     return { ...StarkEx };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imtbl/sdk",
   "description": "Immutable Unified SDK",
-  "version": "0.0.1-alpha",
+  "version": "0.0.1-alpha.2",
   "author": "Immutable",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",
   "dependencies": {
@@ -11,14 +11,6 @@
     "@imtbl/core-sdk": "^1.0.2-alpha.5",
     "@magic-ext/oidc": "^1.0.1",
     "@metamask/detect-provider": "^2.0.0",
-    "@swc/helpers": "~0.5.0",
-    "@typescript-eslint/eslint-plugin": "^5.57.1",
-    "@typescript-eslint/parser": "^5.57.1",
-    "@uniswap/router-sdk": "^1.4.0",
-    "@uniswap/swap-router-contracts": "^1.3.0",
-    "@uniswap/v3-core": "^1.0.1",
-    "@uniswap/v3-periphery": "^1.4.3",
-    "@uniswap/v3-sdk": "^3.9.0",
     "axios": "^1.3.5",
     "eslint": "^8.37.0",
     "ethers": "^5.7.2",
@@ -26,8 +18,7 @@
     "oidc-client-ts": "^2.2.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "react-router-dom": "^6.10.0",
-    "rxjs": "^7.8.0"
+    "react-router-dom": "^6.10.0"
   },
   "devDependencies": {
     "@imtbl/checkout-sdk-web": "0.0.0",