@imtbl/sdk 1.21.0 → 1.21.2-alpha

package/dist/passport.js

@@ -5,10 +5,10 @@ import { keccak256 } from '@ethersproject/keccak256';
 import { toUtf8Bytes } from '@ethersproject/strings';
 import BN from 'bn.js';
 import * as encUtils from 'enc-utils';
-import '@ethersproject/bytes';
+import { splitSignature } from '@ethersproject/bytes';
 import hashJS from 'hash.js';
 import { ec, curves } from 'elliptic';
-import 'ethereumjs-wallet';
+import { hdkey } from 'ethereumjs-wallet';
 import 'assert';
 import { utils as utils$2, BigNumber, Contract, errors, ethers, constants } from 'ethers';
 import '@ethersproject/abstract-signer';
@@ -17,7 +17,6 @@ import jwt_decode from 'jwt-decode';
 import * as crypto from 'crypto';
 import { Magic } from 'magic-sdk';
 import { OpenIdExtension } from '@magic-ext/oidc';
-import { generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
 import { StaticJsonRpcProvider, Web3Provider } from '@ethersproject/providers';
 import { EventEmitter } from 'events';
 import { walletContracts } from '@0xsequence/abi';
@@ -8654,12 +8653,13 @@ const ActivitiesApiAxiosParamCreator = function (configuration) {
          * @param {string} fromUpdatedAt From indexed at including given date
          * @param {string} [toUpdatedAt] To indexed at including given date
          * @param {string} [contractAddress] The contract address of the collection
+         * @param {ActivityType} [activityType] The activity type
          * @param {string} [pageCursor] Encoded page cursor to retrieve previous or next page. Use the value returned in the response.
          * @param {number} [pageSize] Maximum number of items to return
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listActivityHistory: async (chainName, fromUpdatedAt, toUpdatedAt, contractAddress, pageCursor, pageSize, options = {}) => {
+        listActivityHistory: async (chainName, fromUpdatedAt, toUpdatedAt, contractAddress, activityType, pageCursor, pageSize, options = {}) => {
             // verify required parameter 'chainName' is not null or undefined
             assertParamExists$2('listActivityHistory', 'chainName', chainName);
             // verify required parameter 'fromUpdatedAt' is not null or undefined
@@ -8688,6 +8688,9 @@ const ActivitiesApiAxiosParamCreator = function (configuration) {
             if (contractAddress !== undefined) {
                 localVarQueryParameter['contract_address'] = contractAddress;
             }
+            if (activityType !== undefined) {
+                localVarQueryParameter['activity_type'] = activityType;
+            }
             if (pageCursor !== undefined) {
                 localVarQueryParameter['page_cursor'] = pageCursor;
             }
@@ -8748,13 +8751,14 @@ const ActivitiesApiFp = function (configuration) {
          * @param {string} fromUpdatedAt From indexed at including given date
          * @param {string} [toUpdatedAt] To indexed at including given date
          * @param {string} [contractAddress] The contract address of the collection
+         * @param {ActivityType} [activityType] The activity type
          * @param {string} [pageCursor] Encoded page cursor to retrieve previous or next page. Use the value returned in the response.
          * @param {number} [pageSize] Maximum number of items to return
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listActivityHistory(chainName, fromUpdatedAt, toUpdatedAt, contractAddress, pageCursor, pageSize, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listActivityHistory(chainName, fromUpdatedAt, toUpdatedAt, contractAddress, pageCursor, pageSize, options);
+        async listActivityHistory(chainName, fromUpdatedAt, toUpdatedAt, contractAddress, activityType, pageCursor, pageSize, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listActivityHistory(chainName, fromUpdatedAt, toUpdatedAt, contractAddress, activityType, pageCursor, pageSize, options);
             return createRequestFunction$2(localVarAxiosArgs, globalAxios$1, BASE_PATH$2, configuration);
         },
     };
@@ -8797,7 +8801,7 @@ class ActivitiesApi extends BaseAPI$2 {
      * @memberof ActivitiesApi
      */
     listActivityHistory(requestParameters, options) {
-        return ActivitiesApiFp(this.configuration).listActivityHistory(requestParameters.chainName, requestParameters.fromUpdatedAt, requestParameters.toUpdatedAt, requestParameters.contractAddress, requestParameters.pageCursor, requestParameters.pageSize, options).then((request) => request(this.axios, this.basePath));
+        return ActivitiesApiFp(this.configuration).listActivityHistory(requestParameters.chainName, requestParameters.fromUpdatedAt, requestParameters.toUpdatedAt, requestParameters.contractAddress, requestParameters.activityType, requestParameters.pageCursor, requestParameters.pageSize, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
@@ -9472,7 +9476,7 @@ const NftsApiAxiosParamCreator = function (configuration) {
          * @summary Mint NFTs
          * @param {string} contractAddress The address of contract
          * @param {string} chainName The name of chain
-         * @param {CreateMintRequestRequest} createMintRequestRequest the request body
+         * @param {CreateMintRequestRequest} createMintRequestRequest Create Mint Request Body
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -9512,7 +9516,7 @@ const NftsApiAxiosParamCreator = function (configuration) {
          * @summary Get mint request by reference ID
          * @param {string} contractAddress The address of contract
          * @param {string} chainName The name of chain
-         * @param {string} referenceId The ID of the mint request
+         * @param {string} referenceId The id of the mint request
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -9783,7 +9787,7 @@ const NftsApiFp = function (configuration) {
          * @summary Mint NFTs
          * @param {string} contractAddress The address of contract
          * @param {string} chainName The name of chain
-         * @param {CreateMintRequestRequest} createMintRequestRequest the request body
+         * @param {CreateMintRequestRequest} createMintRequestRequest Create Mint Request Body
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -9796,7 +9800,7 @@ const NftsApiFp = function (configuration) {
          * @summary Get mint request by reference ID
          * @param {string} contractAddress The address of contract
          * @param {string} chainName The name of chain
-         * @param {string} referenceId The ID of the mint request
+         * @param {string} referenceId The id of the mint request
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
@@ -10158,6 +10162,7 @@ const OrdersApiAxiosParamCreator = function (configuration) {
          * @param {string} chainName
          * @param {OrderStatusName} [status] Order status to filter by
          * @param {string} [sellItemContractAddress] Sell item contract address to filter by
+         * @param {ListListingsBuyItemTypeEnum} [buyItemType] Buy item type to filter by
          * @param {string} [buyItemContractAddress] Buy item contract address to filter by
          * @param {string} [accountAddress] The account address of the user who created the listing
          * @param {string} [sellItemMetadataId] The metadata_id of the sell item
@@ -10170,7 +10175,7 @@ const OrdersApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listListings: async (chainName, status, sellItemContractAddress, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, options = {}) => {
+        listListings: async (chainName, status, sellItemContractAddress, buyItemType, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, options = {}) => {
             // verify required parameter 'chainName' is not null or undefined
             assertParamExists$2('listListings', 'chainName', chainName);
             const localVarPath = `/v1/chains/{chain_name}/orders/listings`
@@ -10190,6 +10195,9 @@ const OrdersApiAxiosParamCreator = function (configuration) {
             if (sellItemContractAddress !== undefined) {
                 localVarQueryParameter['sell_item_contract_address'] = sellItemContractAddress;
             }
+            if (buyItemType !== undefined) {
+                localVarQueryParameter['buy_item_type'] = buyItemType;
+            }
             if (buyItemContractAddress !== undefined) {
                 localVarQueryParameter['buy_item_contract_address'] = buyItemContractAddress;
             }
@@ -10357,6 +10365,7 @@ const OrdersApiFp = function (configuration) {
          * @param {string} chainName
          * @param {OrderStatusName} [status] Order status to filter by
          * @param {string} [sellItemContractAddress] Sell item contract address to filter by
+         * @param {ListListingsBuyItemTypeEnum} [buyItemType] Buy item type to filter by
          * @param {string} [buyItemContractAddress] Buy item contract address to filter by
          * @param {string} [accountAddress] The account address of the user who created the listing
          * @param {string} [sellItemMetadataId] The metadata_id of the sell item
@@ -10369,8 +10378,8 @@ const OrdersApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listListings(chainName, status, sellItemContractAddress, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listListings(chainName, status, sellItemContractAddress, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, options);
+        async listListings(chainName, status, sellItemContractAddress, buyItemType, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listListings(chainName, status, sellItemContractAddress, buyItemType, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, options);
             return createRequestFunction$2(localVarAxiosArgs, globalAxios$1, BASE_PATH$2, configuration);
         },
         /**
@@ -10463,7 +10472,7 @@ let OrdersApi$2 = class OrdersApi extends BaseAPI$2 {
      * @memberof OrdersApi
      */
     listListings(requestParameters, options) {
-        return OrdersApiFp(this.configuration).listListings(requestParameters.chainName, requestParameters.status, requestParameters.sellItemContractAddress, requestParameters.buyItemContractAddress, requestParameters.accountAddress, requestParameters.sellItemMetadataId, requestParameters.sellItemTokenId, requestParameters.fromUpdatedAt, requestParameters.pageSize, requestParameters.sortBy, requestParameters.sortDirection, requestParameters.pageCursor, options).then((request) => request(this.axios, this.basePath));
+        return OrdersApiFp(this.configuration).listListings(requestParameters.chainName, requestParameters.status, requestParameters.sellItemContractAddress, requestParameters.buyItemType, requestParameters.buyItemContractAddress, requestParameters.accountAddress, requestParameters.sellItemMetadataId, requestParameters.sellItemTokenId, requestParameters.fromUpdatedAt, requestParameters.pageSize, requestParameters.sortBy, requestParameters.sortDirection, requestParameters.pageCursor, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * List all trades
@@ -10503,6 +10512,7 @@ const PassportApiAxiosParamCreator = function (configuration) {
          * @param {string} chainName
          * @param {CreateCounterfactualAddressRequest} createCounterfactualAddressRequest
          * @param {*} [options] Override http request option.
+         * @deprecated
          * @throws {RequiredError}
          */
         createCounterfactualAddress: async (chainName, createCounterfactualAddressRequest, options = {}) => {
@@ -10539,6 +10549,7 @@ const PassportApiAxiosParamCreator = function (configuration) {
          * @summary Deprecated Create a counterfactual address
          * @param {CreateCounterfactualAddressRequestDeprecated} createCounterfactualAddressRequestDeprecated
          * @param {*} [options] Override http request option.
+         * @deprecated
          * @throws {RequiredError}
          */
         createCounterfactualAddressDeprecated: async (createCounterfactualAddressRequestDeprecated, options = {}) => {
@@ -10605,22 +10616,20 @@ const PassportApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Get a contract abi by contract address and method id
-         * @summary Get a contract abi
+         * Get all the Ethereum linked addresses for a user based on its userId
+         * @summary Get Ethereum linked addresses for a user
+         * @param {string} userId The user\'s userId
          * @param {string} chainName
-         * @param {string} contractAddress contract address
-         * @param {string} methodId method id
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getContractAbi: async (chainName, contractAddress, methodId, options = {}) => {
+        getLinkedAddresses: async (userId, chainName, options = {}) => {
+            // verify required parameter 'userId' is not null or undefined
+            assertParamExists$2('getLinkedAddresses', 'userId', userId);
             // verify required parameter 'chainName' is not null or undefined
-            assertParamExists$2('getContractAbi', 'chainName', chainName);
-            // verify required parameter 'contractAddress' is not null or undefined
-            assertParamExists$2('getContractAbi', 'contractAddress', contractAddress);
-            // verify required parameter 'methodId' is not null or undefined
-            assertParamExists$2('getContractAbi', 'methodId', methodId);
-            const localVarPath = `/v1/chains/{chain_name}/passport/transaction-metadata`
+            assertParamExists$2('getLinkedAddresses', 'chainName', chainName);
+            const localVarPath = `/v1/chains/{chain_name}/passport/users/{user_id}/linked-addresses`
+                .replace(`{${"user_id"}}`, encodeURIComponent(String(userId)))
                 .replace(`{${"chain_name"}}`, encodeURIComponent(String(chainName)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL$2);
@@ -10634,12 +10643,6 @@ const PassportApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject$1(localVarHeaderParameter, configuration);
-            if (contractAddress !== undefined) {
-                localVarQueryParameter['contract_address'] = contractAddress;
-            }
-            if (methodId !== undefined) {
-                localVarQueryParameter['method_id'] = methodId;
-            }
             setSearchParams$2(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -10650,19 +10653,51 @@ const PassportApiAxiosParamCreator = function (configuration) {
         },
         /**
          * Get all the Ethereum linked addresses for a user based on its userId
-         * @summary Get Ethereum linked addresses for a user
+         * @summary Deprecated Get Ethereum linked addresses for a user
          * @param {string} userId The user\'s userId
-         * @param {string} chainName
          * @param {*} [options] Override http request option.
+         * @deprecated
          * @throws {RequiredError}
          */
-        getLinkedAddresses: async (userId, chainName, options = {}) => {
+        getLinkedAddressesDeprecated: async (userId, options = {}) => {
             // verify required parameter 'userId' is not null or undefined
-            assertParamExists$2('getLinkedAddresses', 'userId', userId);
+            assertParamExists$2('getLinkedAddressesDeprecated', 'userId', userId);
+            const localVarPath = `/passport-mr/v1/users/{userId}/linked-addresses`
+                .replace(`{${"userId"}}`, encodeURIComponent(String(userId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL$2);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject$1(localVarHeaderParameter, configuration);
+            setSearchParams$2(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString$2(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Get transaction metadata for a given encoded transaction
+         * @summary Get transaction metadata
+         * @param {string} chainName
+         * @param {GetTransactionMetadataRequest} getTransactionMetadataRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getTransactionMetadata: async (chainName, getTransactionMetadataRequest, options = {}) => {
             // verify required parameter 'chainName' is not null or undefined
-            assertParamExists$2('getLinkedAddresses', 'chainName', chainName);
-            const localVarPath = `/v1/chains/{chain_name}/passport/users/{user_id}/linked-addresses`
-                .replace(`{${"user_id"}}`, encodeURIComponent(String(userId)))
+            assertParamExists$2('getTransactionMetadata', 'chainName', chainName);
+            // verify required parameter 'getTransactionMetadataRequest' is not null or undefined
+            assertParamExists$2('getTransactionMetadata', 'getTransactionMetadataRequest', getTransactionMetadataRequest);
+            const localVarPath = `/v1/chains/{chain_name}/passport/transaction-metadata`
                 .replace(`{${"chain_name"}}`, encodeURIComponent(String(chainName)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL$2);
@@ -10670,32 +10705,47 @@ const PassportApiAxiosParamCreator = function (configuration) {
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject$1(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams$2(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded$2(getTransactionMetadataRequest, localVarRequestOptions, configuration);
             return {
                 url: toPathString$2(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * Get all the Ethereum linked addresses for a user based on its userId
-         * @summary Deprecated Get Ethereum linked addresses for a user
-         * @param {string} userId The user\'s userId
+         * Get transaction metadata for a given encoded transaction
+         * @summary Get transaction metadata
+         * @param {string} chainName
+         * @param {string} contractAddress The address of the contract intended for interaction with this transaction
+         * @param {string} methodId The method ID of the contract intended for interaction with this transaction
+         * @param {string} transactionId ID of the given transaction to be decoded
+         * @param {string} transactionData Encoded transaction data
          * @param {*} [options] Override http request option.
+         * @deprecated
          * @throws {RequiredError}
          */
-        getLinkedAddressesDeprecated: async (userId, options = {}) => {
-            // verify required parameter 'userId' is not null or undefined
-            assertParamExists$2('getLinkedAddressesDeprecated', 'userId', userId);
-            const localVarPath = `/passport-mr/v1/users/{userId}/linked-addresses`
-                .replace(`{${"userId"}}`, encodeURIComponent(String(userId)));
+        getTransactionMetadataDeprecated: async (chainName, contractAddress, methodId, transactionId, transactionData, options = {}) => {
+            // verify required parameter 'chainName' is not null or undefined
+            assertParamExists$2('getTransactionMetadataDeprecated', 'chainName', chainName);
+            // verify required parameter 'contractAddress' is not null or undefined
+            assertParamExists$2('getTransactionMetadataDeprecated', 'contractAddress', contractAddress);
+            // verify required parameter 'methodId' is not null or undefined
+            assertParamExists$2('getTransactionMetadataDeprecated', 'methodId', methodId);
+            // verify required parameter 'transactionId' is not null or undefined
+            assertParamExists$2('getTransactionMetadataDeprecated', 'transactionId', transactionId);
+            // verify required parameter 'transactionData' is not null or undefined
+            assertParamExists$2('getTransactionMetadataDeprecated', 'transactionData', transactionData);
+            const localVarPath = `/v1/chains/{chain_name}/passport/transaction-metadata`
+                .replace(`{${"chain_name"}}`, encodeURIComponent(String(chainName)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL$2);
             let baseOptions;
@@ -10708,6 +10758,18 @@ const PassportApiAxiosParamCreator = function (configuration) {
             // authentication BearerAuth required
             // http bearer authentication required
             await setBearerAuthToObject$1(localVarHeaderParameter, configuration);
+            if (contractAddress !== undefined) {
+                localVarQueryParameter['contract_address'] = contractAddress;
+            }
+            if (methodId !== undefined) {
+                localVarQueryParameter['method_id'] = methodId;
+            }
+            if (transactionId !== undefined) {
+                localVarQueryParameter['transaction_id'] = transactionId;
+            }
+            if (transactionData !== undefined) {
+                localVarQueryParameter['transaction_data'] = transactionData;
+            }
             setSearchParams$2(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -10731,6 +10793,7 @@ const PassportApiFp = function (configuration) {
          * @param {string} chainName
          * @param {CreateCounterfactualAddressRequest} createCounterfactualAddressRequest
          * @param {*} [options] Override http request option.
+         * @deprecated
          * @throws {RequiredError}
          */
         async createCounterfactualAddress(chainName, createCounterfactualAddressRequest, options) {
@@ -10742,6 +10805,7 @@ const PassportApiFp = function (configuration) {
          * @summary Deprecated Create a counterfactual address
          * @param {CreateCounterfactualAddressRequestDeprecated} createCounterfactualAddressRequestDeprecated
          * @param {*} [options] Override http request option.
+         * @deprecated
          * @throws {RequiredError}
          */
         async createCounterfactualAddressDeprecated(createCounterfactualAddressRequestDeprecated, options) {
@@ -10760,19 +10824,6 @@ const PassportApiFp = function (configuration) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.createCounterfactualAddressV2(chainName, createCounterfactualAddressRequest, options);
             return createRequestFunction$2(localVarAxiosArgs, globalAxios$1, BASE_PATH$2, configuration);
         },
-        /**
-         * Get a contract abi by contract address and method id
-         * @summary Get a contract abi
-         * @param {string} chainName
-         * @param {string} contractAddress contract address
-         * @param {string} methodId method id
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async getContractAbi(chainName, contractAddress, methodId, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getContractAbi(chainName, contractAddress, methodId, options);
-            return createRequestFunction$2(localVarAxiosArgs, globalAxios$1, BASE_PATH$2, configuration);
-        },
         /**
          * Get all the Ethereum linked addresses for a user based on its userId
          * @summary Get Ethereum linked addresses for a user
@@ -10790,12 +10841,41 @@ const PassportApiFp = function (configuration) {
          * @summary Deprecated Get Ethereum linked addresses for a user
          * @param {string} userId The user\'s userId
          * @param {*} [options] Override http request option.
+         * @deprecated
          * @throws {RequiredError}
          */
         async getLinkedAddressesDeprecated(userId, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.getLinkedAddressesDeprecated(userId, options);
             return createRequestFunction$2(localVarAxiosArgs, globalAxios$1, BASE_PATH$2, configuration);
         },
+        /**
+         * Get transaction metadata for a given encoded transaction
+         * @summary Get transaction metadata
+         * @param {string} chainName
+         * @param {GetTransactionMetadataRequest} getTransactionMetadataRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getTransactionMetadata(chainName, getTransactionMetadataRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getTransactionMetadata(chainName, getTransactionMetadataRequest, options);
+            return createRequestFunction$2(localVarAxiosArgs, globalAxios$1, BASE_PATH$2, configuration);
+        },
+        /**
+         * Get transaction metadata for a given encoded transaction
+         * @summary Get transaction metadata
+         * @param {string} chainName
+         * @param {string} contractAddress The address of the contract intended for interaction with this transaction
+         * @param {string} methodId The method ID of the contract intended for interaction with this transaction
+         * @param {string} transactionId ID of the given transaction to be decoded
+         * @param {string} transactionData Encoded transaction data
+         * @param {*} [options] Override http request option.
+         * @deprecated
+         * @throws {RequiredError}
+         */
+        async getTransactionMetadataDeprecated(chainName, contractAddress, methodId, transactionId, transactionData, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getTransactionMetadataDeprecated(chainName, contractAddress, methodId, transactionId, transactionData, options);
+            return createRequestFunction$2(localVarAxiosArgs, globalAxios$1, BASE_PATH$2, configuration);
+        },
     };
 };
 /**
@@ -10810,6 +10890,7 @@ class PassportApi extends BaseAPI$2 {
      * @summary Create a counterfactual address
      * @param {PassportApiCreateCounterfactualAddressRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
+     * @deprecated
      * @throws {RequiredError}
      * @memberof PassportApi
      */
@@ -10821,6 +10902,7 @@ class PassportApi extends BaseAPI$2 {
      * @summary Deprecated Create a counterfactual address
      * @param {PassportApiCreateCounterfactualAddressDeprecatedRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
+     * @deprecated
      * @throws {RequiredError}
      * @memberof PassportApi
      */
@@ -10838,17 +10920,6 @@ class PassportApi extends BaseAPI$2 {
     createCounterfactualAddressV2(requestParameters, options) {
         return PassportApiFp(this.configuration).createCounterfactualAddressV2(requestParameters.chainName, requestParameters.createCounterfactualAddressRequest, options).then((request) => request(this.axios, this.basePath));
     }
-    /**
-     * Get a contract abi by contract address and method id
-     * @summary Get a contract abi
-     * @param {PassportApiGetContractAbiRequest} requestParameters Request parameters.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof PassportApi
-     */
-    getContractAbi(requestParameters, options) {
-        return PassportApiFp(this.configuration).getContractAbi(requestParameters.chainName, requestParameters.contractAddress, requestParameters.methodId, options).then((request) => request(this.axios, this.basePath));
-    }
     /**
      * Get all the Ethereum linked addresses for a user based on its userId
      * @summary Get Ethereum linked addresses for a user
@@ -10865,12 +10936,36 @@ class PassportApi extends BaseAPI$2 {
      * @summary Deprecated Get Ethereum linked addresses for a user
      * @param {PassportApiGetLinkedAddressesDeprecatedRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
+     * @deprecated
      * @throws {RequiredError}
      * @memberof PassportApi
      */
     getLinkedAddressesDeprecated(requestParameters, options) {
         return PassportApiFp(this.configuration).getLinkedAddressesDeprecated(requestParameters.userId, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Get transaction metadata for a given encoded transaction
+     * @summary Get transaction metadata
+     * @param {PassportApiGetTransactionMetadataRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PassportApi
+     */
+    getTransactionMetadata(requestParameters, options) {
+        return PassportApiFp(this.configuration).getTransactionMetadata(requestParameters.chainName, requestParameters.getTransactionMetadataRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Get transaction metadata for a given encoded transaction
+     * @summary Get transaction metadata
+     * @param {PassportApiGetTransactionMetadataDeprecatedRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     * @memberof PassportApi
+     */
+    getTransactionMetadataDeprecated(requestParameters, options) {
+        return PassportApiFp(this.configuration).getTransactionMetadataDeprecated(requestParameters.chainName, requestParameters.contractAddress, requestParameters.methodId, requestParameters.transactionId, requestParameters.transactionData, options).then((request) => request(this.axios, this.basePath));
+    }
 }
 
 /* tslint:disable */
@@ -11213,6 +11308,7 @@ var MintRequestStatus;
 var NFTContractType;
 (function (NFTContractType) {
     NFTContractType["Erc721"] = "ERC721";
+    NFTContractType["Erc1155"] = "ERC1155";
 })(NFTContractType || (NFTContractType = {}));
 
 /* tslint:disable */
@@ -11350,7 +11446,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-1.21.0' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-1.21.2-alpha' };
 const createConfig$1 = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -11529,7 +11625,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.21.0';
+const SDK_VERSION = '1.21.2-alpha';
 const getReferrer = () => {
     if (isNode()) {
         return '';
@@ -11779,7 +11875,7 @@ const addKeysToHeadersOverride = (baseConfig, overrides) => {
 /* eslint-disable @typescript-eslint/naming-convention */
 class ApiConfiguration extends index$2.Configuration {
 }
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.21.0' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.21.2-alpha' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -11818,7 +11914,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.21.0',
+    sdkVersion: 'ts-immutable-sdk-1.21.2-alpha',
     baseConfig,
 });
 const production = ({ baseConfig }) => createImmutableXConfiguration({
@@ -13999,6 +14095,12 @@ const constantPointsHex = [
         '5d8f4897ce44007ec5bfcb9aeb78b8f6e1d40a514f72d213c9300d2770d2b8c',
     ],
 ];
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const DEFAULT_SIGNATURE_MESSAGE = 'Only sign this request if you’ve initiated an action with Immutable X.';
+const DEFAULT_ACCOUNT_LAYER = 'starkex';
+const DEFAULT_ACCOUNT_APPLICATION = 'immutablex';
+const DEFAULT_ACCOUNT_INDEX = '1';
 const prime = new BN('800000000000011000000000000000000000000000000000000000000000001', 16);
 const order = new BN('08000000 00000010 ffffffff ffffffff b781126d cae7b232 1e66a241 adc64d2f', 16);
 const starkEc = new ec(new curves.PresetCurve({
@@ -14036,8 +14138,50 @@ new BN('8000000000000000', 16);
 new BN('800000000000011000000000000000000000000000000000000000000000001', 16);
 // Equals 2**251. This value limits msgHash and the signature parts.
 new BN('800000000000000000000000000000000000000000000000000000000000000', 16);
-new BN('08000000 00000010 ffffffff ffffffff b781126d cae7b232 1e66a241 adc64d2f', 16);
-new BN('FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141', 16);
+const ORDER = new BN('08000000 00000010 ffffffff ffffffff b781126d cae7b232 1e66a241 adc64d2f', 16);
+const SECP_ORDER = new BN('FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141', 16);
+
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-plusplus */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function getIntFromBits(hex, start, end = undefined) {
+    const bin = encUtils.hexToBinary(hex);
+    const bits = bin.slice(start, end);
+    const int = encUtils.binaryToNumber(bits);
+    return int;
+}
+function getAccountPath(layer, application, ethereumAddress, index) {
+    const layerHash = hashJS.sha256().update(layer).digest('hex');
+    const applicationHash = hashJS.sha256().update(application).digest('hex');
+    const layerInt = getIntFromBits(layerHash, -31);
+    const applicationInt = getIntFromBits(applicationHash, -31);
+    const ethAddressInt1 = getIntFromBits(ethereumAddress, -31);
+    const ethAddressInt2 = getIntFromBits(ethereumAddress, -62, -31);
+    return `m/2645'/${layerInt}'/${applicationInt}'/${ethAddressInt1}'/${ethAddressInt2}'/${index}`;
+}
+function hashKeyWithIndex$1(key, index) {
+    return new BN(hashJS
+        .sha256()
+        .update(encUtils.hexToBuffer(encUtils.removeHexPrefix(key)
+        + encUtils.sanitizeBytes(encUtils.numberToHex(index), 2)))
+        .digest('hex'), 16);
+}
+function grindKey$1(privateKey) {
+    let i = 0;
+    let key = hashKeyWithIndex$1(privateKey, i);
+    while (!key.lt(SECP_ORDER.sub(SECP_ORDER.mod(ORDER)))) {
+        key = hashKeyWithIndex$1(key.toString(16), i);
+        i = i++;
+    }
+    return key.mod(ORDER).toString('hex');
+}
+function getPrivateKeyFromPath$1(seed, path) {
+    return hdkey
+        .fromMasterSeed(Buffer.from(seed.slice(2), 'hex')) // assuming seed is '0x...'
+        .derivePath(path)
+        .getWallet()
+        .getPrivateKeyString();
+}
 
 var Errors;
 (function (Errors) {
@@ -14045,6 +14189,84 @@ var Errors;
     Errors["StarkCurveInvalidMessageLength"] = "invalid message length";
 })(Errors || (Errors = {}));
 
+class StandardStarkSigner {
+    privateKey;
+    keyPair;
+    constructor(privateKey) {
+        this.privateKey = privateKey;
+        this.keyPair = starkEc.keyFromPrivate(privateKey, 'hex');
+    }
+    getAddress() {
+        const xCoordinate = this.keyPair.getPublic().getX().toString('hex');
+        return encUtils.sanitizeHex(xCoordinate);
+    }
+    async signMessage(msg) {
+        return this.serialize(this.keyPair.sign(this.fixMsgHashLen(msg)));
+    }
+    // eslint-disable-next-line class-methods-use-this
+    serialize(sig) {
+        return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString('hex'), 64)
+            + encUtils.padLeft(sig.s.toString('hex'), 64));
+    }
+    /*
+   The function _truncateToN in lib/elliptic/ec/index.js does a shift-right of delta bits,
+   if delta is positive, where
+     delta = msgHash.byteLength() * 8 - starkEx.n.bitLength().
+   This function does the opposite operation so that
+     _truncateToN(fixMsgHashLen(msgHash)) == msgHash.
+  */
+    // eslint-disable-next-line class-methods-use-this
+    fixMsgHashLen(msg) {
+        // eslint-disable-next-line no-param-reassign
+        msg = encUtils.removeHexPrefix(msg);
+        // eslint-disable-next-line no-param-reassign
+        msg = new BN(msg, 'hex').toString('hex');
+        if (msg.length <= 62) {
+            // In this case, msg should not be transformed, as the byteLength() is at most 31,
+            // so delta < 0 (see _truncateToN).
+            return msg;
+        }
+        if (msg.length !== 63) {
+            throw new Error(Errors.StarkCurveInvalidMessageLength);
+        }
+        // In this case delta will be 4 so we perform a shift-left of 4 bits by adding a ZERO_BN.
+        return `${msg}0`;
+    }
+}
+/**
+ * Creates a new Stark Signer
+ * @params starkPrivateKey - the private key as a hex string
+ * @returns a StarkSigner
+ */
+function createStarkSigner(starkPrivateKey) {
+    return new StandardStarkSigner(starkPrivateKey);
+}
+
+/**
+ * @description Gets the account (stark public key) value of the requested user
+ * (ethAddress) for Production environment only.
+ * @param ethAddress {string}
+ * @returns {Promise<StarkUserResponse | undefined>}
+ */
+async function getStarkPublicKeyFromImx(ethAddress) {
+    try {
+        if (ethAddress) {
+            const response = await globalAxios$1.get(`https://api.x.immutable.com/v1/users/${ethAddress}`);
+            const user = response.data;
+            if (user?.accounts && user.accounts.length > 0) {
+                // Only one account per user
+                return { starkPublicKey: user.accounts[0], accountNotFound: false };
+            }
+        }
+    }
+    catch (error) {
+        if (globalAxios$1.isAxiosError(error) && error.response?.data.code === 'account_not_found') {
+            return { starkPublicKey: '', accountNotFound: true };
+        }
+    }
+    return undefined;
+}
+
 /*
 Stark-friendly elliptic curve
 
@@ -14084,6 +14306,161 @@ new ec(new curves.PresetCurve({
         '5668060aa49730b7be4801df46ec62de53ecd11abe43a32873000c36e8dc1f',
     ],
 }));
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const MAX_ALLOWED_VAL = () => {
+    const sha256EcMaxDigest = new BN('1 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000', 16);
+    return sha256EcMaxDigest.sub(sha256EcMaxDigest.mod(starkEcOrder));
+};
+// Create a hash from a key + an index
+function hashKeyWithIndex(key, index) {
+    return new BN(hashJS
+        .sha256()
+        .update(encUtils.hexToBuffer(encUtils.removeHexPrefix(key)
+        + encUtils.sanitizeBytes(encUtils.numberToHex(index), 2)))
+        .digest('hex'), 16);
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// DANGER: DO NOT MODIFY GRIND KEY / KEY GENERATION LOGIC.
+//////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+The grindKeyV201 function is used to provide a backwards compatible way to re-generate keys if any of the accounts were created using v2.0.1 of core-sdk.
+*/
+function grindKeyV201(keySeed) {
+    const maxAllowedVal = MAX_ALLOWED_VAL();
+    // The key passed to hashKeyWithIndex must have a length of 64 characters
+    // to ensure that the correct number of leading zeroes are used as input
+    // to the hashing loop
+    let key = hashKeyWithIndex(keySeed.toString('hex', 64), 0);
+    // Make sure the produced key is devided by the Stark EC order, and falls within the range
+    // [0, maxAllowedVal).
+    for (let i = 0; key.gte(maxAllowedVal); i++) {
+        key = hashKeyWithIndex(key.toString('hex'), i);
+    }
+    return key.umod(starkEcOrder).toString('hex');
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// DANGER: DO NOT MODIFY GRIND KEY / KEY GENERATION LOGIC.
+//////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+This grindKey function is the default logic to be used by all our SDKs including the imx-sdk-js. All the accounts
+that were created using imx-sdk-js are to be supported by the legacy.grindKey function.
+
+This function receives a key seed and produces an appropriate StarkEx key from a uniform
+distribution.
+
+Although it is possible to define a StarkEx key as a residue between the StarkEx EC order and a
+random 256bit digest value, the result would be a biased key. In order to prevent this bias, we
+deterministically search (by applying more hashes, AKA grinding) for a value lower than the largest
+256bit multiple of StarkEx EC order.
+
+https://github.com/starkware-libs/starkware-crypto-utils/blob/dev/src/js/key_derivation.js#L119
+
+The accounts that has been created with versions released between 1.0.0-beta.3 and 2.0.0 are fine as it uses this method.
+Although this logic has been in place in core-sdk since the following commit, it was momentarily changed in version 2.0.1 to use gringKeyV201 method.
+https://github.com/immutable/imx-core-sdk/commit/3d9e35b4598784589bd7f121f26e105493196716
+*/
+function grindKey(keySeed) {
+    const maxAllowedVal = MAX_ALLOWED_VAL();
+    // The key passed to hashKeyWithIndex must have a length of 64 characters
+    // to ensure that the correct number of leading zeroes are used as input
+    // to the hashing loop
+    let key = hashKeyWithIndex(keySeed.toString('hex', 64), 0);
+    // Make sure the produced key is devided by the Stark EC order, and falls within the range
+    // [0, maxAllowedVal).
+    for (let i = 1; key.gte(maxAllowedVal); i++) {
+        key = hashKeyWithIndex(key.toString('hex'), i);
+    }
+    return key.umod(starkEcOrder).toString('hex');
+}
+// Check if the hash value of the the given PrivateKey falls above the starkEcOrder limit.
+// This function is only serving the context of DX-2184, used to determine if we need to validate the generated key
+// against the one recorded in IMX servers.
+function checkIfHashedKeyIsAboveLimit(keySeed) {
+    const maxAllowedVal = MAX_ALLOWED_VAL();
+    // The key passed to hashKeyWithIndex must have a length of 64 characters
+    // to ensure that the correct number of leading zeroes are used as input
+    // to the hashing loop
+    const key = hashKeyWithIndex(keySeed.toString('hex', 64), 0);
+    return key.gte(maxAllowedVal);
+}
+function getPrivateKeyFromPath(seed, path) {
+    const privateKey = hdkey
+        .fromMasterSeed(Buffer.from(seed.slice(2), 'hex')) // assuming seed is '0x...'
+        .derivePath(path)
+        .getWallet()
+        .getPrivateKey();
+    return new BN(privateKey);
+}
+async function getKeyFromPath(seed, path, ethAddress) {
+    const privateKeySeed = getPrivateKeyFromPath(seed, path);
+    const starkPrivateKey = grindKey(privateKeySeed);
+    // The following logic is added in response to bug found in DX-2167 and DX-2184.
+    // To provide a backwards compatible way to fetch keys across link/js SDK and Core SDK.
+    // Note: The issue we are addressing here is that if the hashKeyWithIndex value is above the limit, then we perform
+    //     hash again with index until it comes below the limit. But for the first time the index is not incremented in
+    //     imx-sdk-js where as it was in core-sdk that was the difference. For this reason it would have worked for cases
+    //     where the hashed value was less than the limit and fails only when it is above the limit.
+    //     Refer, https://immutable.atlassian.net/browse/DX-2167
+    // Same code as grindKey, required to check if the generated private key
+    // goes above the limit when hashed for first time to identify if we need to do backwards
+    // compatibility check:
+    // The bug only exists if the hashed value of given seed is above the stark curve limit.
+    if (!checkIfHashedKeyIsAboveLimit(privateKeySeed)) {
+        return starkPrivateKey;
+    }
+    // Check if the generated stark public key matches with the existing account value for that user.
+    // We are only validating for Production environment.
+    // For Sandbox account/key mismatch, solution is to discard the old account and create a new one.
+    const imxResponse = await getStarkPublicKeyFromImx(ethAddress);
+    // If the account is not found or account matches we just return the key pair at the end of this method.
+    // Only need to so alternative method if the account is found but the stark public key does not match.
+    if (imxResponse === undefined) {
+        throw new Error('Error fetching stark public key from IMX');
+    }
+    // If the account is not found it is a new account, just return the Stark Private Key that is generated by grindKey function.
+    if (imxResponse.accountNotFound) {
+        return starkPrivateKey;
+    }
+    const registeredStarkPublicKeyBN = new BN(encUtils.removeHexPrefix(imxResponse.starkPublicKey), 16);
+    let starkPublicKey = await createStarkSigner(starkPrivateKey).getAddress();
+    // If the user account matches with generated stark public key user, just return Stark Private Key.
+    if (registeredStarkPublicKeyBN.eq(new BN(encUtils.removeHexPrefix(starkPublicKey), 16))) {
+        return starkPrivateKey;
+    }
+    // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+    // This is backwards compatible crypto (core-sdk) version 2.0.1
+    // If we are here, we found the account but did not match with the recorded user account.
+    // Lets try to use grindKeyV201 method from backwards compatible logic to generate a key and see if that matches.
+    const starkPrivateKeyV201Compatible = grindKeyV201(privateKeySeed);
+    starkPublicKey = await createStarkSigner(starkPrivateKeyV201Compatible).getAddress();
+    if (registeredStarkPublicKeyBN.eq(new BN(encUtils.removeHexPrefix(starkPublicKey), 16))) {
+        return starkPrivateKeyV201Compatible;
+    }
+    // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+    // This section is legacy crypto, compatible with imx-sdk-js released before 1.43.5
+    const privateKeyString = getPrivateKeyFromPath$1(seed, path);
+    const starkPrivateKeyLegacy = grindKey$1(privateKeyString);
+    starkPublicKey = await createStarkSigner(starkPrivateKeyLegacy).getAddress();
+    if (registeredStarkPublicKeyBN.eq(new BN(encUtils.removeHexPrefix(starkPublicKey), 16))) {
+        return starkPrivateKeyLegacy;
+    }
+    // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+    // Account is found, but did not match with stark public keys generated by either grindKey or grindKeyV1 method.
+    // Will have to contact support for further investigation.
+    throw new Error('Can not deterministically generate stark private key - please contact support');
+}
+/**
+ * Generates a deterministic Stark private key from the provided signer.
+ * @returns the private key as a hex string
+ */
+async function generateLegacyStarkPrivateKey(signer) {
+    const address = (await signer.getAddress()).toLowerCase();
+    const signature = await signer.signMessage(DEFAULT_SIGNATURE_MESSAGE);
+    const seed = splitSignature(signature).s;
+    const path = getAccountPath(DEFAULT_ACCOUNT_LAYER, DEFAULT_ACCOUNT_APPLICATION, address, DEFAULT_ACCOUNT_INDEX);
+    const key = await getKeyFromPath(seed, path, address);
+    return key.padStart(64, '0');
+}
 
 async function mintingWorkflow(signer, request, mintsApi) {
     // TODO: improve this object key rearrangement.