@imtbl/sdk 0.1.6-alpha → 0.1.7-alpha.1

package/dist/passport.js

@@ -1,3 +1,5 @@
+import * as guardian from '@imtbl/guardian';
+export { guardian };
 import { ImmutableX, Config, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
 import { UserManager } from 'oidc-client-ts';
 import { ethers } from 'ethers';
@@ -20,7 +22,7 @@ const production = () => Config.createConfig({
     chainID: 1,
     coreContractAddress: '0x5FDCCA53617f4d2b9134B29090C87D01058e27e9',
     registrationContractAddress: '0x72a06bf2a1CE5e39cBA06c0CAb824960B587d64c',
-    sdkVersion: 'ts-immutable-sdk-0.1.6-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.1.7-alpha.1',
 });
 /**
  * Set `sdkVersion` on config
@@ -30,7 +32,7 @@ const sandbox = () => Config.createConfig({
     chainID: 5,
     coreContractAddress: '0x7917eDb51ecD6CdB3F9854c3cc593F33de10c623',
     registrationContractAddress: '0x1C97Ada273C9A52253f463042f29117090Cd7D83',
-    sdkVersion: 'ts-immutable-sdk-0.1.6-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.1.7-alpha.1',
 });
 class ImxConfiguration {
     immutableXConfig;
@@ -519,24 +521,25 @@ class ImmutableXClient {
 function serializeEthSignature(sig) {
     // This is because golang appends a recovery param
     // https://github.com/ethers-io/ethers.js/issues/823
-    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64) +
-        encUtils.padLeft(sig.s.toString(16), 64) +
-        encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
+    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64)
+        + encUtils.padLeft(sig.s.toString(16), 64)
+        + encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
 }
 function importRecoveryParam(v) {
+    const isValidBigNumber = new BN(v, 16).cmp(new BN(27)) !== -1
+        ? new BN(v, 16).sub(new BN(27)).toNumber()
+        : new BN(v, 16).toNumber();
     return v.trim()
-        ? new BN(v, 16).cmp(new BN(27)) !== -1
-            ? new BN(v, 16).sub(new BN(27)).toNumber()
-            : new BN(v, 16).toNumber()
+        ? isValidBigNumber
         : undefined;
 }
 // used chained with serializeEthSignature. serializeEthSignature(deserializeSignature(...))
 function deserializeSignature(sig, size = 64) {
-    sig = encUtils.removeHexPrefix(sig);
+    const removedHexPrefixSig = encUtils.removeHexPrefix(sig);
     return {
-        r: new BN(sig.substring(0, size), 'hex'),
-        s: new BN(sig.substring(size, size * 2), 'hex'),
-        recoveryParam: importRecoveryParam(sig.substring(size * 2, size * 2 + 2)),
+        r: new BN(removedHexPrefixSig.substring(0, size), 'hex'),
+        s: new BN(removedHexPrefixSig.substring(size, size * 2), 'hex'),
+        recoveryParam: importRecoveryParam(removedHexPrefixSig.substring(size * 2, size * 2 + 2)),
     };
 }
 async function signRaw(payload, signer) {
@@ -567,6 +570,7 @@ function convertToSignableToken(token) {
                 },
             };
         case 'ETH':
+        default:
             return {
                 type: 'ETH',
                 data: {
@@ -1261,7 +1265,7 @@ class PassportImxProvider {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
     getAddress() {
-        return Promise.resolve(this.starkSigner.getAddress());
+        return Promise.resolve(this.user.etherKey);
     }
 }
 
@@ -1371,6 +1375,7 @@ async function registerPassport({ ethSigner, starkSigner, usersApi }, authorizat
 }
 
 // TODO: Remove this once the dependency has been added
+// eslint-disable-next-line import/no-extraneous-dependencies
 class Passport {
     authManager;
     magicAdapter;

package/dist/provider.d.ts

@@ -925,7 +925,6 @@ declare class GenericIMXProvider implements IMXProvider {
 
 declare class MetaMaskIMXProvider extends GenericIMXProvider {
     private static imxSigner;
-    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

@@ -10,24 +10,25 @@ import detectEthereumProvider from '@metamask/detect-provider';
 function serializeEthSignature(sig) {
     // This is because golang appends a recovery param
     // https://github.com/ethers-io/ethers.js/issues/823
-    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64) +
-        encUtils.padLeft(sig.s.toString(16), 64) +
-        encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
+    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64)
+        + encUtils.padLeft(sig.s.toString(16), 64)
+        + encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
 }
 function importRecoveryParam(v) {
+    const isValidBigNumber = new BN(v, 16).cmp(new BN(27)) !== -1
+        ? new BN(v, 16).sub(new BN(27)).toNumber()
+        : new BN(v, 16).toNumber();
     return v.trim()
-        ? new BN(v, 16).cmp(new BN(27)) !== -1
-            ? new BN(v, 16).sub(new BN(27)).toNumber()
-            : new BN(v, 16).toNumber()
+        ? isValidBigNumber
         : undefined;
 }
 // used chained with serializeEthSignature. serializeEthSignature(deserializeSignature(...))
 function deserializeSignature(sig, size = 64) {
-    sig = encUtils.removeHexPrefix(sig);
+    const removedHexPrefixSig = encUtils.removeHexPrefix(sig);
     return {
-        r: new BN(sig.substring(0, size), 'hex'),
-        s: new BN(sig.substring(size, size * 2), 'hex'),
-        recoveryParam: importRecoveryParam(sig.substring(size * 2, size * 2 + 2)),
+        r: new BN(removedHexPrefixSig.substring(0, size), 'hex'),
+        s: new BN(removedHexPrefixSig.substring(size, size * 2), 'hex'),
+        recoveryParam: importRecoveryParam(removedHexPrefixSig.substring(size * 2, size * 2 + 2)),
     };
 }
 async function signRaw(payload, signer) {
@@ -67,6 +68,7 @@ function convertToSignableToken(token) {
                 },
             };
         case 'ETH':
+        default:
             return {
                 type: 'ETH',
                 data: {
@@ -87,8 +89,9 @@ function isChainValid(chainID, config) {
 }
 async function validateChain(signer, config) {
     const chainID = await signer.getChainId();
-    if (!isChainValid(chainID, config))
+    if (!isChainValid(chainID, config)) {
         throw new Error('The wallet used for this operation is not connected to the correct network.');
+    }
 }
 
 async function transfer({ signers: { ethSigner, starkSigner }, request, config, }) {
@@ -135,17 +138,15 @@ async function batchTransfer({ signers: { ethSigner, starkSigner }, request, con
     await validateChain(ethSigner, config.immutableXConfig);
     const ethAddress = await ethSigner.getAddress();
     const transfersApi = new TransfersApi(config.immutableXConfig.apiConfiguration);
-    const signableRequests = request.map((nftTransfer) => {
-        return {
-            amount: '1',
-            token: convertToSignableToken({
-                type: 'ERC721',
-                tokenId: nftTransfer.tokenId,
-                tokenAddress: nftTransfer.tokenAddress,
-            }),
-            receiver: nftTransfer.receiver,
-        };
-    });
+    const signableRequests = request.map((nftTransfer) => ({
+        amount: '1',
+        token: convertToSignableToken({
+            type: 'ERC721',
+            tokenId: nftTransfer.tokenId,
+            tokenAddress: nftTransfer.tokenAddress,
+        }),
+        receiver: nftTransfer.receiver,
+    }));
     const signableResult = await transfersApi.getSignableTransfer({
         getSignableTransferRequestV2: {
             sender_ether_key: ethAddress,
@@ -159,6 +160,8 @@ async function batchTransfer({ signers: { ethSigner, starkSigner }, request, con
     const ethSignature = await signRaw(signableMessage, ethSigner);
     const requests = [];
     for (const resp of signableResult.data.signable_responses) {
+        // TODO: remove once fixed
+        // eslint-disable-next-line no-await-in-loop
         const starkSignature = await starkSigner.signMessage(resp.payload_hash);
         const req = {
             sender_vault_id: resp.sender_vault_id,
@@ -386,9 +389,7 @@ async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token,
             config,
         });
     }
-    else {
-        return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
-    }
+    return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
 }
 
 async function executeWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
@@ -405,7 +406,7 @@ async function executeRegisterAndWithdrawMintableERC721(ethSigner, assetType, st
     return ethSigner.sendTransaction(populatedTransaction);
 }
 function getMintingBlob(token) {
-    const id = token.data.id;
+    const { id } = token.data;
     const blueprint = token.data.blueprint || '';
     return encUtils.sanitizeHex(encUtils.utf8ToHex(`{${id}}:{${blueprint}}`));
 }
@@ -421,9 +422,7 @@ async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token
     if (!isRegistered) {
         return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
     }
-    else {
-        return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
-    }
+    return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
 }
 async function executeRegisterAndWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
     const etherKey = await ethSigner.getAddress();
@@ -448,14 +447,12 @@ async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config
     if (!isRegistered) {
         return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
     }
-    else {
-        return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
-    }
+    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 { tokenAddress } = token;
+    const { tokenId } = token;
     const imxConfig = config.immutableXConfig;
     const mintsApi = new MintsApi(imxConfig.apiConfiguration);
     return await mintsApi
@@ -467,7 +464,7 @@ async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token
         type: 'ERC721',
         data: {
             id: tokenId,
-            tokenAddress: tokenAddress,
+            tokenAddress,
             blueprint: mintableToken.data.blueprint,
         },
     }, config))
@@ -501,9 +498,7 @@ async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config,
     if (!isRegistered) {
         return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
-    else {
-        return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
-    }
+    return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
 }
 
 async function prepareWithdrawal({ signers, withdrawal, config, }) {
@@ -513,7 +508,11 @@ async function prepareWithdrawal({ signers, withdrawal, config, }) {
         ...withdrawal,
     });
 }
+// TODO: remove once fixed
+// eslint-disable-next-line consistent-return
 async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, token, config, }) {
+    // TODO: please add a reasonable default here
+    // eslint-disable-next-line default-case
     switch (token.type) {
         case 'ETH':
             return completeEthWithdrawalAction({ ethSigner, starkPublicKey, config });
@@ -571,6 +570,18 @@ async function createTrade({ signers: { ethSigner, starkSigner }, request, confi
     return createTradeResponse.data;
 }
 
+async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
+    const etherKey = await ethSigner.getAddress();
+    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositEth(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId);
+    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+}
+async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
+    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+}
 async function depositEth({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const user = await ethSigner.getAddress();
@@ -608,23 +619,21 @@ async function depositEth({ signers: { ethSigner }, deposit, config, }) {
     if (!isRegistered) {
         return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig, usersApi);
     }
-    else {
-        return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
-    }
+    return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
 }
-async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
+
+async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config, usersApi) {
     const etherKey = await ethSigner.getAddress();
-    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const coreContract = Contracts.Core.connect(config.coreContractAddress, ethSigner);
     const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositEth(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId);
-    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositERC20(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId, quantizedAmount);
+    return ethSigner.sendTransaction(populatedTransaction);
 }
-async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
-    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = Contracts.Core.connect(config.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction.depositERC20(starkPublicKey, assetType, vaultId, quantizedAmount);
+    return ethSigner.sendTransaction(populatedTransaction);
 }
-
 async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
@@ -635,6 +644,8 @@ async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
     const usersApi = new UsersApi(apiConfiguration);
     // Get decimals for this specific ERC20
     const token = await tokensApi.getToken({ address: deposit.tokenAddress });
+    // TODO: remove once fixed
+    // eslint-disable-next-line radix
     const decimals = parseInt(token.data.decimals);
     const data = {
         decimals,
@@ -676,23 +687,14 @@ async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
     if (!isRegistered) {
         return executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration, usersApi);
     }
-    else {
-        return executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration);
-    }
+    return executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration);
 }
-async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = Contracts.Core.connect(config.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction.depositERC20(starkPublicKey, assetType, vaultId, quantizedAmount);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config, usersApi) {
-    const etherKey = await ethSigner.getAddress();
-    const coreContract = Contracts.Core.connect(config.coreContractAddress, ethSigner);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositERC20(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId, quantizedAmount);
+
+async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
     return ethSigner.sendTransaction(populatedTransaction);
 }
-
 async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
     await validateChain(ethSigner, config.immutableXConfig);
     const user = await ethSigner.getAddress();
@@ -743,18 +745,18 @@ async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
     if (!isRegistered) {
         const signableResult = await getSignableRegistrationOnchain(user, starkPublicKey, usersApi);
         const coreContract = Contracts.Core.connect(immutableXConfig.ethConfiguration.coreContractAddress, ethSigner);
-        // Note: proxy registration contract registerAndDepositNft method is not used as it currently fails erc721 transfer ownership check
+        // 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);
 }
-async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
 
+// TODO: remove once fixed deposit variable shadowing
+// eslint-disable-next-line consistent-return, @typescript-eslint/no-shadow
 async function deposit({ signers, deposit, config }) {
+    // TODO: please add a reasonable default here
+    // eslint-disable-next-line default-case
     switch (deposit.type) {
         case 'ETH':
             return depositEth({ signers, deposit, config });
@@ -892,7 +894,10 @@ class GenericIMXProvider {
 }
 
 const WALLET_ACTION = {
+    // TODO: remove once fixed - consider using an enum
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     SWITCH_CHAIN: 'wallet_switchEthereumChain',
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     CONNECT: 'eth_requestAccounts',
 };
 function isRequestableProvider(provider) {
@@ -909,6 +914,8 @@ async function connectProvider(provider, chainID) {
 }
 
 const ERRORS = {
+    // TODO: remove once fixed - consider using something in line with the naming convention
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     PROVIDER_NOT_FOUND: 'The Metamask provider was not found',
 };
 async function connect$1({ chainID, }) {
@@ -1083,9 +1090,6 @@ const withProviderError = async (fn, customError) => {
 
 class MetaMaskIMXProvider extends GenericIMXProvider {
     static imxSigner;
-    constructor(config, ethSigner, starkSigner) {
-        super(config, ethSigner, starkSigner);
-    }
     static async connect(config) {
         return await withProviderError(async () => {
             const metaMaskProvider = await connect$1({
@@ -1107,9 +1111,7 @@ class MetaMaskIMXProvider extends GenericIMXProvider {
         if (!this.imxSigner) {
             throw new ProviderError('Attempted to sign a message with the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
         }
-        return withProviderError(async () => {
-            return await this.imxSigner.signMessage(message);
-        }, { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
+        return withProviderError(async () => await this.imxSigner.signMessage(message), { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
     }
 }
 
@@ -1122,6 +1124,8 @@ class ProviderConfiguration {
             this.immutableXConfig = overrides.immutableXConfig;
         }
         else {
+            // TODO: remove once a sensible default is chosen
+            // eslint-disable-next-line default-case
             switch (baseConfig.environment) {
                 case Environment.SANDBOX: {
                     this.immutableXConfig = Config.SANDBOX;

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "@imtbl/sdk",
   "description": "Immutable Unified SDK",
-  "version": "0.1.6-alpha",
+  "version": "0.1.7-alpha.1",
   "author": "Immutable",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",
   "dependencies": {
+    "@ethersproject/abstract-signer": "^5.7.0",
     "@ethersproject/providers": "^5.7.2",
+    "@ethersproject/wallet": "^5.7.0",
     "@imtbl/core-sdk": "^1.1.1-alpha.1",
     "@magic-ext/oidc": "^1.0.1",
     "@metamask/detect-provider": "^2.0.0",
+    "@opensea/seaport-js": "^1.3.0",
     "axios": "^1.3.5",
+    "bn.js": "^5.2.1",
+    "enc-utils": "^3.0.0",
     "ethers": "^5.7.2",
     "magic-sdk": "^13.3.1",
     "oidc-client-ts": "^2.2.1"
@@ -18,7 +23,9 @@
     "@imtbl/checkout-sdk": "0.0.0",
     "@imtbl/checkout-widgets": "0.0.0",
     "@imtbl/config": "0.0.0",
+    "@imtbl/cryptofiat": "0.0.0",
     "@imtbl/immutablex-client": "0.0.0",
+    "@imtbl/orderbook": "0.0.0",
     "@imtbl/passport": "0.0.0",
     "@imtbl/provider": "0.0.0",
     "@rollup/plugin-commonjs": "^24.0.1",
@@ -28,7 +35,8 @@
     "@rollup/plugin-typescript": "^11.0.0",
     "@yarnpkg/cli": "3.5.0",
     "@yarnpkg/core": "3.5.0",
-    "eslint": "^8.37.0",
+    "eslint": "^8.40.0",
+    "glob": "^10.2.3",
     "rollup": "^3.17.2",
     "rollup-plugin-dts": "^5.3.0",
     "semver": "^7.4.0",
@@ -56,6 +64,10 @@
       "types": "./dist/passport.d.ts",
       "import": "./dist/passport.js"
     },
+    "./orderbook": {
+      "types": "./dist/orderbook.d.ts",
+      "import": "./dist/orderbook.js"
+    },
     "./provider": {
       "types": "./dist/provider.d.ts",
       "import": "./dist/provider.js"
@@ -84,6 +96,7 @@
   "scripts": {
     "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",
+    "copyBrowserBundles": "node scripts/copyBrowserBundles.js",
     "generateIndex": "node scripts/generateIndex.js",
     "lint": "eslint ./src --ext .ts,.jsx,.tsx --max-warnings=0",
     "packageList": "./scripts/generate-package-list.sh",