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

package/dist/passport.d.ts

@@ -3,6 +3,7 @@ declare enum PassportErrorType {
     INVALID_CONFIGURATION = "INVALID_CONFIGURATION",
     WALLET_CONNECTION_ERROR = "WALLET_CONNECTION_ERROR",
     NOT_LOGGED_IN_ERROR = "NOT_LOGGED_IN_ERROR",
+    SILENT_LOGIN_ERROR = "SILENT_LOGIN_ERROR",
     REFRESH_TOKEN_ERROR = "REFRESH_TOKEN_ERROR",
     USER_REGISTRATION_ERROR = "USER_REGISTRATION_ERROR",
     LOGOUT_ERROR = "LOGOUT_ERROR",
@@ -712,12 +713,14 @@ declare class Passport {
     private magicAdapter;
     private readonly config;
     constructor(passportModuleConfiguration: PassportModuleConfiguration);
+    private getImxProvider;
+    connectImxSilent(): Promise<IMXProvider | null>;
     connectImx(): Promise<IMXProvider>;
     loginCallback(): Promise<void>;
     logout(): Promise<void>;
-    getUserInfo(): Promise<UserProfile>;
+    getUserInfo(): Promise<UserProfile | undefined>;
     getIdToken(): Promise<string | undefined>;
-    getAccessToken(): Promise<string>;
+    getAccessToken(): Promise<string | undefined>;
     private registerUser;
 }
 

package/dist/passport.js

@@ -79,6 +79,7 @@ var PassportErrorType;
     PassportErrorType["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
     PassportErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
     PassportErrorType["NOT_LOGGED_IN_ERROR"] = "NOT_LOGGED_IN_ERROR";
+    PassportErrorType["SILENT_LOGIN_ERROR"] = "SILENT_LOGIN_ERROR";
     PassportErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
     PassportErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
     PassportErrorType["LOGOUT_ERROR"] = "LOGOUT_ERROR";
@@ -160,6 +161,7 @@ class AuthManager {
     mapOidcUserToDomainModel = (oidcUser) => {
         const passport = oidcUser.profile?.passport;
         return {
+            expired: oidcUser.expired,
             idToken: oidcUser.id_token,
             accessToken: oidcUser.access_token,
             refreshToken: oidcUser.refresh_token,
@@ -173,7 +175,7 @@ class AuthManager {
     };
     async login() {
         return withPassportError(async () => {
-            const popupWindowFeatures = { width: 400, height: 420 };
+            const popupWindowFeatures = { width: 410, height: 450 };
             const oidcUser = await this.userManager.signinPopup({
                 popupWindowFeatures,
             });
@@ -186,11 +188,24 @@ class AuthManager {
     async logout() {
         return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
     }
+    async loginSilent() {
+        return withPassportError(async () => {
+            const existedUser = await this.getUser();
+            if (!existedUser) {
+                return null;
+            }
+            const oidcUser = await this.userManager.signinSilent();
+            if (!oidcUser) {
+                return null;
+            }
+            return this.mapOidcUserToDomainModel(oidcUser);
+        }, PassportErrorType.SILENT_LOGIN_ERROR);
+    }
     async getUser() {
         return withPassportError(async () => {
             const oidcUser = await this.userManager.getUser();
             if (!oidcUser) {
-                throw new Error('Failed to retrieve user');
+                return null;
             }
             return this.mapOidcUserToDomainModel(oidcUser);
         }, PassportErrorType.NOT_LOGGED_IN_ERROR);
@@ -848,9 +863,8 @@ class Passport {
         this.authManager = new AuthManager(this.config);
         this.magicAdapter = new MagicAdapter(this.config);
     }
-    async connectImx() {
-        const user = await this.authManager.login();
-        if (!user.idToken) {
+    async getImxProvider(user) {
+        if (!user || !user.idToken) {
             throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
         }
         const provider = await this.magicAdapter.login(user.idToken);
@@ -871,6 +885,17 @@ class Passport {
             passportConfig: this.config,
         });
     }
+    async connectImxSilent() {
+        const user = await this.authManager.loginSilent();
+        if (!user) {
+            return null;
+        }
+        return this.getImxProvider(user);
+    }
+    async connectImx() {
+        const user = await this.authManager.login();
+        return this.getImxProvider(user);
+    }
     async loginCallback() {
         return this.authManager.loginCallback();
     }
@@ -879,15 +904,15 @@ class Passport {
     }
     async getUserInfo() {
         const user = await this.authManager.getUser();
-        return user.profile;
+        return user?.profile;
     }
     async getIdToken() {
         const user = await this.authManager.getUser();
-        return user.idToken;
+        return user?.idToken;
     }
     async getAccessToken() {
         const user = await this.authManager.getUser();
-        return user.accessToken;
+        return user?.accessToken;
     }
     async registerUser(userAdminKeySigner, starkSigner, jwt) {
         const configuration = new Configuration({

package/dist/provider.d.ts

@@ -908,7 +908,7 @@ interface IMXProvider {
 declare class GenericIMXProvider implements IMXProvider {
     private readonly config;
     private readonly signers;
-    constructor(config: ProviderConfiguration$1, ethSigner: Signer, starkExSigner: StarkSigner);
+    constructor(config: ProviderConfiguration$1, ethSigner: Signer, starkSigner: StarkSigner);
     getAddress(): Promise<string>;
     registerOffchain(): Promise<RegisterUserResponse>;
     batchNftTransfer(request: Array<NftTransferDetails>): Promise<CreateTransferResponse>;
@@ -925,7 +925,7 @@ declare class GenericIMXProvider implements IMXProvider {
 
 declare class MetaMaskIMXProvider extends GenericIMXProvider {
     private static imxSigner;
-    constructor(config: ProviderConfiguration$1, ethSigner: Signer, starkExSigner: StarkSigner);
+    constructor(config: ProviderConfiguration$1, ethSigner: Signer, starkSigner: StarkSigner);
     static connect(config: ProviderConfiguration$1): Promise<MetaMaskIMXProvider>;
     static disconnect(): Promise<void>;
     static signMessage(message: string): Promise<string>;

package/dist/provider.js

@@ -91,7 +91,7 @@ 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, }) {
+async function transfer({ signers: { ethSigner, starkSigner }, request, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
     const transfersApi = new TransfersApi(config.immutableXConfig.apiConfiguration);
@@ -106,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,
@@ -131,7 +131,7 @@ async function transfer({ signers: { ethSigner, starkExSigner }, request, config
         transfer_id: response?.data.transfer_id,
     };
 }
-async function batchTransfer({ signers: { ethSigner, starkExSigner }, request, config, }) {
+async function batchTransfer({ signers: { ethSigner, starkSigner }, request, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
     const transfersApi = new TransfersApi(config.immutableXConfig.apiConfiguration);
@@ -159,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,
@@ -207,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: {
@@ -241,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(),
@@ -262,7 +262,7 @@ async function registerOffchain(signers, config) {
     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,
@@ -271,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,
@@ -314,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;
@@ -326,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: {
@@ -359,8 +359,8 @@ async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
 
 async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
     const etherKey = await ethSigner.getAddress();
-    const starkExConfig = config.immutableXConfig;
-    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.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
     const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
@@ -373,8 +373,8 @@ async function executeWithdrawERC20(ethSigner, assetType, starkPublicKey, config
 }
 async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
-    const starkExConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ERC20', starkExConfig, {
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC20', imxConfig, {
         token_address: token.tokenAddress,
     });
     const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
@@ -387,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);
     }
 }
 
@@ -410,8 +410,8 @@ function getMintingBlob(token) {
     return encUtils.sanitizeHex(encUtils.utf8ToHex(`{${id}}:{${blueprint}}`));
 }
 async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.immutableXConfig;
-    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 }),
@@ -419,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) {
@@ -439,25 +439,25 @@ async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, token
     return ethSigner.sendTransaction(populatedTransaction);
 }
 async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.immutableXConfig;
-    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.immutableXConfig);
     const tokenAddress = token.tokenAddress;
     const tokenId = token.tokenId;
-    const starkExConfig = config.immutableXConfig;
-    const mintsApi = new MintsApi(starkExConfig.apiConfiguration);
+    const imxConfig = config.immutableXConfig;
+    const mintsApi = new MintsApi(imxConfig.apiConfiguration);
     return await mintsApi
         .getMintableTokenDetailsByClientTokenId({
         tokenAddress,
@@ -495,14 +495,14 @@ async function executeWithdrawEth(ethSigner, assetType, starkPublicKey, config)
 }
 async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
-    const starkExConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ETH', starkExConfig);
+    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);
     }
 }
 
@@ -534,7 +534,7 @@ async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, toke
     }
 }
 
-async function createTrade({ signers: { ethSigner, starkExSigner }, request, config, }) {
+async function createTrade({ signers: { ethSigner, starkSigner }, request, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
     const tradesApi = new TradesApi(config.immutableXConfig.apiConfiguration);
@@ -547,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,
@@ -578,10 +578,10 @@ async function depositEth({ signers: { ethSigner }, deposit, config, }) {
         decimals: 18,
     };
     const amount = parseUnits(deposit.amount, 'wei');
-    const starkExConfig = config.immutableXConfig;
-    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: {
@@ -606,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) {
@@ -781,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,
@@ -811,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();
@@ -872,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) {
@@ -1083,8 +1083,8 @@ 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) {
         return await withProviderError(async () => {

package/package.json

@@ -1,53 +1,33 @@
 {
   "name": "@imtbl/sdk",
   "description": "Immutable Unified SDK",
-  "version": "0.0.1-alpha.3",
+  "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.2.4-beta",
     "@ethersproject/providers": "^5.7.2",
     "@imtbl/core-sdk": "^1.1.1-alpha.1",
     "@magic-ext/oidc": "^1.0.1",
     "@metamask/detect-provider": "^2.0.0",
-    "@rollup/plugin-replace": "^5.0.2",
-    "@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",
-    "compression": "^1.7.4",
-    "dotenv": "^16.0.3",
     "eslint": "^8.37.0",
     "ethers": "^5.7.2",
-    "express": "^4.17.1",
-    "express-formidable": "^1.2.0",
-    "helmet": "^4.2.0",
     "magic-sdk": "^13.3.1",
     "oidc-client-ts": "^2.2.1",
-    "pino": "^8.11.0",
-    "pino-http": "^8.3.3",
     "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "react-router-dom": "^6.10.0",
-    "rxjs": "^7.8.0",
-    "tsc-watch": "^6.0.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",
@@ -58,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"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js"
     },
-    "./starkex": {
-      "types": "./dist/starkex.d.ts",
-      "import": "./dist/starkex.js"
+    "./immutablex_client": {
+      "types": "./dist/immutablex_client.d.ts",
+      "import": "./dist/immutablex_client.js"
     },
     "./passport": {
       "types": "./dist/passport.d.ts",
@@ -93,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"