@toruslabs/ethereum-controllers 5.10.1 → 6.0.0

package/dist/ethereumControllers.cjs.js

@@ -14,13 +14,6 @@ module.exports = require("@ethereumjs/common");
 
 module.exports = require("@ethereumjs/tx");
 
-/***/ }),
-
-/***/ 731:
-/***/ ((module) => {
-
-module.exports = require("jsonschema");
-
 /***/ })
 
 /******/ 	});
@@ -131,10 +124,12 @@ __webpack_require__.d(__webpack_exports__, {
   ARBITRUM_TESTNET_CHAIN_ID: () => (/* reexport */ ARBITRUM_TESTNET_CHAIN_ID),
   AVALANCHE_MAINNET_CHAIN_ID: () => (/* reexport */ AVALANCHE_MAINNET_CHAIN_ID),
   AVALANCHE_TESTNET_CHAIN_ID: () => (/* reexport */ AVALANCHE_TESTNET_CHAIN_ID),
-  AccountTrackerController: () => (/* reexport */ Account_AccountTrackerController),
+  AbstractMessageController: () => (/* reexport */ AbstractMessageController),
+  AccountTrackerController: () => (/* reexport */ AccountTrackerController),
   AddChainController: () => (/* reexport */ AddChainController),
   BASE_CHAIN_ID: () => (/* reexport */ BASE_CHAIN_ID),
   BASE_TESTNET_CHAIN_ID: () => (/* reexport */ BASE_TESTNET_CHAIN_ID),
+  BNToHex: () => (/* reexport */ BNToHex),
   BSC_MAINNET_CHAIN_ID: () => (/* reexport */ BSC_MAINNET_CHAIN_ID),
   BSC_TESTNET_CHAIN_ID: () => (/* reexport */ BSC_TESTNET_CHAIN_ID),
   CELO_MAINNET_CHAIN_ID: () => (/* reexport */ CELO_MAINNET_CHAIN_ID),
@@ -147,13 +142,11 @@ __webpack_require__.d(__webpack_exports__, {
   CONTRACT_TYPE_ETH: () => (/* reexport */ CONTRACT_TYPE_ETH),
   CurrencyController: () => (/* reexport */ CurrencyController),
   DEFAULT_CURRENCY: () => (/* reexport */ DEFAULT_CURRENCY),
-  DecryptMessageController: () => (/* reexport */ DecryptMessageController),
   ERC1155_INTERFACE_ID: () => (/* reexport */ ERC1155_INTERFACE_ID),
   ERC721_ENUMERABLE_INTERFACE_ID: () => (/* reexport */ ERC721_ENUMERABLE_INTERFACE_ID),
   ERC721_INTERFACE_ID: () => (/* reexport */ ERC721_INTERFACE_ID),
   ERC721_METADATA_INTERFACE_ID: () => (/* reexport */ ERC721_METADATA_INTERFACE_ID),
   ETHERSCAN_SUPPORTED_CHAINS: () => (/* reexport */ ETHERSCAN_SUPPORTED_CHAINS),
-  EncryptionPublicKeyController: () => (/* reexport */ EncryptionPublicKeyController),
   GAS_ESTIMATE_TYPES: () => (/* reexport */ GAS_ESTIMATE_TYPES),
   GAS_LIMITS: () => (/* reexport */ GAS_LIMITS),
   GasFeeController: () => (/* reexport */ GasFeeController),
@@ -167,7 +160,7 @@ __webpack_require__.d(__webpack_exports__, {
   NetworkController: () => (/* reexport */ NetworkController),
   NftHandler: () => (/* reexport */ NftHandler),
   NftsController: () => (/* reexport */ NftsController),
-  NonceTracker: () => (/* reexport */ Transaction_NonceTracker),
+  NonceTracker: () => (/* reexport */ NonceTracker),
   OLD_ERC721_LIST: () => (/* reexport */ OLD_ERC721_LIST),
   OPTIMISM_MAINNET_CHAIN_ID: () => (/* reexport */ OPTIMISM_MAINNET_CHAIN_ID),
   OPTIMISM_TESTNET_CHAIN_ID: () => (/* reexport */ OPTIMISM_TESTNET_CHAIN_ID),
@@ -175,7 +168,7 @@ __webpack_require__.d(__webpack_exports__, {
   POLYGON_CHAIN_ID: () => (/* reexport */ POLYGON_CHAIN_ID),
   PendingTransactionTracker: () => (/* reexport */ PendingTransactionTracker),
   PersonalMessageController: () => (/* reexport */ PersonalMessageController),
-  PollingBlockTracker: () => (/* reexport */ Block_PollingBlockTracker),
+  PollingBlockTracker: () => (/* reexport */ PollingBlockTracker),
   PreferencesController: () => (/* reexport */ PreferencesController),
   SEPOLIA_CHAIN_ID: () => (/* reexport */ SEPOLIA_CHAIN_ID),
   SIMPLEHASH_SUPPORTED_CHAINS: () => (/* reexport */ SIMPLEHASH_SUPPORTED_CHAINS),
@@ -207,14 +200,10 @@ __webpack_require__.d(__webpack_exports__, {
   createPendingNonceMiddleware: () => (/* reexport */ createPendingNonceMiddleware),
   createPendingTxMiddleware: () => (/* reexport */ createPendingTxMiddleware),
   createProcessAddEthereumChain: () => (/* reexport */ createProcessAddEthereumChain),
-  createProcessDecryptMessageMiddleware: () => (/* reexport */ createProcessDecryptMessageMiddleware),
-  createProcessEncryptionPublicKeyMiddleware: () => (/* reexport */ createProcessEncryptionPublicKeyMiddleware),
   createProcessEthSignMessage: () => (/* reexport */ createProcessEthSignMessage),
   createProcessPersonalMessage: () => (/* reexport */ createProcessPersonalMessage),
   createProcessSwitchEthereumChain: () => (/* reexport */ createProcessSwitchEthereumChain),
   createProcessTransactionMiddleware: () => (/* reexport */ createProcessTransactionMiddleware),
-  createProcessTypedMessage: () => (/* reexport */ createProcessTypedMessage),
-  createProcessTypedMessageV3: () => (/* reexport */ createProcessTypedMessageV3),
   createProcessTypedMessageV4: () => (/* reexport */ createProcessTypedMessageV4),
   createProviderConfigMiddleware: () => (/* reexport */ createProviderConfigMiddleware),
   createRequestAccountsMiddleware: () => (/* reexport */ createRequestAccountsMiddleware),
@@ -236,6 +225,7 @@ __webpack_require__.d(__webpack_exports__, {
   getEtherScanHashLink: () => (/* reexport */ getEtherScanHashLink),
   getFinalStates: () => (/* reexport */ getFinalStates),
   getIpfsEndpoint: () => (/* reexport */ getIpfsEndpoint),
+  hexToBn: () => (/* reexport */ hexToBn),
   hexWEIToDecGWEI: () => (/* reexport */ hexWEIToDecGWEI),
   idleTimeTracker: () => (/* reexport */ idleTimeTracker),
   isAddressByChainId: () => (/* reexport */ isAddressByChainId),
@@ -245,7 +235,6 @@ __webpack_require__.d(__webpack_exports__, {
   normalizeAndValidateTxParams: () => (/* reexport */ normalizeAndValidateTxParams),
   normalizeMessageData: () => (/* reexport */ normalizeMessageData),
   normalizeTxParameters: () => (/* reexport */ normalizeTxParameters),
-  parseDecryptMessageData: () => (/* reexport */ parseDecryptMessageData),
   parseStandardTokenTransactionData: () => (/* reexport */ parseStandardTokenTransactionData),
   readAddressAsContract: () => (/* reexport */ readAddressAsContract),
   replayHistory: () => (/* reexport */ replayHistory),
@@ -258,15 +247,12 @@ __webpack_require__.d(__webpack_exports__, {
   transactionMatchesNetwork: () => (/* reexport */ transactionMatchesNetwork),
   validateAddChainData: () => (/* reexport */ validateAddChainData),
   validateAddress: () => (/* reexport */ validateAddress),
-  validateDecryptedMessageData: () => (/* reexport */ validateDecryptedMessageData),
-  validateEncryptionPublicKeyMessageData: () => (/* reexport */ validateEncryptionPublicKeyMessageData),
   validateFrom: () => (/* reexport */ validateFrom),
   validateRecipient: () => (/* reexport */ validateRecipient),
   validateSignMessageData: () => (/* reexport */ validateSignMessageData),
   validateSwitchChainData: () => (/* reexport */ validateSwitchChainData),
   validateTxParameters: () => (/* reexport */ validateTxParameters),
-  validateTypedSignMessageDataV1: () => (/* reexport */ validateTypedSignMessageDataV1),
-  validateTypedSignMessageDataV3V4: () => (/* reexport */ validateTypedSignMessageDataV3V4)
+  validateTypedSignMessageDataV4: () => (/* reexport */ validateTypedSignMessageDataV4)
 });
 
 ;// CONCATENATED MODULE: external "@babel/runtime/helpers/objectSpread2"
@@ -1007,14 +993,10 @@ const METHOD_TYPES = {
   ETH_REQUEST_ACCOUNTS: "eth_requestAccounts",
   ETH_SEND_RAW_TRANSACTION: "eth_sendRawTransaction",
   ETH_SIGN: "eth_sign",
-  ETH_SIGN_TYPED_DATA: "eth_signTypedData",
-  ETH_SIGN_TYPED_DATA_V3: "eth_signTypedData_v3",
   ETH_SIGN_TYPED_DATA_V4: "eth_signTypedData_v4",
   PERSONAL_SIGN: "personal_sign",
   ETH_GET_TRANSACTION_COUNT: "eth_getTransactionCount",
   ETH_GET_TRANSACTION_BY_HASH: "eth_getTransactionByHash",
-  ETH_GET_ENCRYPTION_PUBLIC_KEY: "eth_getEncryptionPublicKey",
-  ETH_DECRYPT: "eth_decrypt",
   ETH_GET_TRANSACTION_RECEIPT: "eth_getTransactionReceipt",
   WATCH_ASSET: "wallet_watchAsset",
   ETH_GET_BLOCK_BY_HASH: "eth_getBlockByHash",
@@ -1281,14 +1263,13 @@ class AccountTrackerController extends base_controllers_namespaceObject.BaseCont
     }
   }
 }
-/* harmony default export */ const Account_AccountTrackerController = (AccountTrackerController);
 ;// CONCATENATED MODULE: external "@ethereumjs/util"
 const util_namespaceObject = require("@ethereumjs/util");
 ;// CONCATENATED MODULE: external "bignumber.js"
 const external_bignumber_js_namespaceObject = require("bignumber.js");
 var external_bignumber_js_default = /*#__PURE__*/__webpack_require__.n(external_bignumber_js_namespaceObject);
-;// CONCATENATED MODULE: external "@toruslabs/openlogin-jrpc"
-const openlogin_jrpc_namespaceObject = require("@toruslabs/openlogin-jrpc");
+;// CONCATENATED MODULE: external "@web3auth/auth"
+const auth_namespaceObject = require("@web3auth/auth");
 ;// CONCATENATED MODULE: ./src/Transaction/TransactionUtils.ts
 
 
@@ -1371,7 +1352,7 @@ function isLegacyTransaction(transaction) {
  */
 function ensureMutuallyExclusiveFieldsNotProvided(txParams, fieldBeingValidated, mutuallyExclusiveField) {
   if (typeof txParams[mutuallyExclusiveField] !== "undefined") {
-    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: specified ${fieldBeingValidated} but also included ${mutuallyExclusiveField}, these cannot be mixed`);
+    throw auth_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: specified ${fieldBeingValidated} but also included ${mutuallyExclusiveField}, these cannot be mixed`);
   }
 }
 
@@ -1381,7 +1362,7 @@ function ensureMutuallyExclusiveFieldsNotProvided(txParams, fieldBeingValidated,
  */
 function ensureFieldIsString(txParams, field) {
   if (typeof txParams[field] !== "string") {
-    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: ${field} is not a string. got: (${txParams[field]})`);
+    throw auth_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: ${field} is not a string. got: (${txParams[field]})`);
   }
 }
 
@@ -1395,13 +1376,13 @@ function ensureProperTransactionEnvelopeTypeProvided(txParams, field) {
     case "maxFeePerGas":
     case "maxPriorityFeePerGas":
       if (txParams.type && txParams.type !== TRANSACTION_ENVELOPE_TYPES.FEE_MARKET) {
-        throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + `including maxFeePerGas and maxPriorityFeePerGas requires type: "${TRANSACTION_ENVELOPE_TYPES.FEE_MARKET}"`);
+        throw auth_namespaceObject.rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + `including maxFeePerGas and maxPriorityFeePerGas requires type: "${TRANSACTION_ENVELOPE_TYPES.FEE_MARKET}"`);
       }
       break;
     case "gasPrice":
     default:
       if (txParams.type && txParams.type === TRANSACTION_ENVELOPE_TYPES.FEE_MARKET) {
-        throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + "included a gasPrice instead of maxFeePerGas and maxPriorityFeePerGas");
+        throw auth_namespaceObject.rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + "included a gasPrice instead of maxFeePerGas and maxPriorityFeePerGas");
       }
   }
 }
@@ -1411,10 +1392,10 @@ function ensureProperTransactionEnvelopeTypeProvided(txParams, field) {
  */
 function validateFrom(txParams) {
   if (!(typeof txParams.from === "string")) {
-    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid "from" address "${txParams.from}": not a string.`);
+    throw auth_namespaceObject.rpcErrors.invalidParams(`Invalid "from" address "${txParams.from}": not a string.`);
   }
   if (!(0,util_namespaceObject.isValidAddress)(txParams.from)) {
-    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams('Invalid "from" address.');
+    throw auth_namespaceObject.rpcErrors.invalidParams('Invalid "from" address.');
   }
 }
 
@@ -1426,10 +1407,10 @@ function validateRecipient(txParameters) {
     if (txParameters.data) {
       delete txParameters.to;
     } else {
-      throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams('Invalid "to" address.');
+      throw auth_namespaceObject.rpcErrors.invalidParams('Invalid "to" address.');
     }
   } else if (txParameters.to !== undefined && !(0,util_namespaceObject.isValidAddress)(txParameters.to)) {
-    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams('Invalid "to" address.');
+    throw auth_namespaceObject.rpcErrors.invalidParams('Invalid "to" address.');
   }
   return txParameters;
 }
@@ -1440,15 +1421,15 @@ function validateRecipient(txParameters) {
  */
 function validateTxParameters(txParams, eip1559Compatibility = true) {
   if (!txParams || typeof txParams !== "object" || Array.isArray(txParams)) {
-    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams("Invalid transaction params: must be an object.");
+    throw auth_namespaceObject.rpcErrors.invalidParams("Invalid transaction params: must be an object.");
   }
   if (!txParams.to && !txParams.data) {
-    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams('Invalid transaction params: must specify "data" for contract deployments, or "to" (and optionally "data") for all other types of transactions.');
+    throw auth_namespaceObject.rpcErrors.invalidParams('Invalid transaction params: must specify "data" for contract deployments, or "to" (and optionally "data") for all other types of transactions.');
   }
   if (isEIP1559Transaction({
     transaction: txParams
   }) && !eip1559Compatibility) {
-    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams("Invalid transaction params: params specify an EIP-1559 transaction but the current network does not support EIP-1559");
+    throw auth_namespaceObject.rpcErrors.invalidParams("Invalid transaction params: params specify an EIP-1559 transaction but the current network does not support EIP-1559");
   }
   Object.entries(txParams).forEach(([key, value]) => {
     // validate types
@@ -1478,15 +1459,15 @@ function validateTxParameters(txParams, eip1559Compatibility = true) {
       case "value":
         ensureFieldIsString(txParams, "value");
         if (value.toString().includes("-")) {
-          throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction value "${value}": not a positive number.`);
+          throw auth_namespaceObject.rpcErrors.invalidParams(`Invalid transaction value "${value}": not a positive number.`);
         }
         if (value.toString().includes(".")) {
-          throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction value of "${value}": number must be in wei.`);
+          throw auth_namespaceObject.rpcErrors.invalidParams(`Invalid transaction value of "${value}": number must be in wei.`);
         }
         break;
       case "chainId":
         if (typeof value !== "number" && typeof value !== "string") {
-          throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: ${key} is not a Number or hex string. got: (${value})`);
+          throw auth_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: ${key} is not a Number or hex string. got: (${value})`);
         }
         break;
       default:
@@ -1621,6 +1602,12 @@ async function determineTransactionType(txParams, provider) {
 
 
 
+function hexToBn(hex) {
+  return new (external_bignumber_js_default())((0,util_namespaceObject.stripHexPrefix)(hex), 16);
+}
+function BNToHex(bn) {
+  return (0,util_namespaceObject.addHexPrefix)(bn.toString(16));
+}
 function getEtherScanHashLink(txHash, chainId) {
   if (!SUPPORTED_NETWORKS[chainId]) return "";
   return `${SUPPORTED_NETWORKS[chainId].blockExplorerUrl}/tx/${txHash}`;
@@ -1913,7 +1900,6 @@ class PollingBlockTracker extends base_controllers_namespaceObject.BaseBlockTrac
     }
   }
 }
-/* harmony default export */ const Block_PollingBlockTracker = (PollingBlockTracker);
 ;// CONCATENATED MODULE: external "@toruslabs/http-helpers"
 const http_helpers_namespaceObject = require("@toruslabs/http-helpers");
 ;// CONCATENATED MODULE: ./src/Currency/CurrencyController.ts
@@ -2622,8 +2608,6 @@ class GasFeeController extends base_controllers_namespaceObject.BaseController {
     return calculateTimeEstimate(maxPriorityFeePerGas, maxFeePerGas, this.state.gasFeeEstimates);
   }
 }
-;// CONCATENATED MODULE: external "@metamask/eth-sig-util"
-const eth_sig_util_namespaceObject = require("@metamask/eth-sig-util");
 ;// CONCATENATED MODULE: ./src/Keyring/KeyringController.ts
 
 
@@ -2689,41 +2673,22 @@ class KeyringController extends base_controllers_namespaceObject.BaseKeyringCont
     const wallet = this._getWalletForAccount(address);
     const privKey = this.getBufferPrivateKey(wallet.privateKey);
     const messageSig = (0,util_namespaceObject.ecsign)(Buffer.from((0,util_namespaceObject.stripHexPrefix)(data), "hex"), privKey);
-    const sig = (0,eth_sig_util_namespaceObject.concatSig)(Buffer.from((0,util_namespaceObject.bigIntToBytes)(messageSig.v)), Buffer.from(messageSig.r), Buffer.from(messageSig.s));
+    const sig = (0,base_controllers_namespaceObject.concatSig)(Buffer.from((0,util_namespaceObject.bigIntToBytes)(messageSig.v)), Buffer.from(messageSig.r), Buffer.from(messageSig.s));
     return sig;
   }
-
-  // For personal_sign, we need to prefix the message: ensure input is hashed and not buffer of utf-8
   async signPersonalMessage(data, address) {
     const wallet = this._getWalletForAccount(address);
-    const privKey = this.getBufferPrivateKey(wallet.privateKey);
-    const sig = (0,eth_sig_util_namespaceObject.personalSign)({
-      privateKey: privKey,
-      data
-    });
-    return sig;
+    const privKey = new external_ethers_namespaceObject.SigningKey((0,util_namespaceObject.addHexPrefix)(wallet.privateKey));
+    const signature = privKey.sign((0,external_ethers_namespaceObject.hashMessage)(data)).serialized;
+    return signature;
   }
 
   // personal_signTypedData, signs data along with the schema
-  async signTypedData(typedData, address, version) {
-    const wallet = this._getWalletForAccount(address);
-    const privKey = this.getBufferPrivateKey(wallet.privateKey);
-    return (0,eth_sig_util_namespaceObject.signTypedData)({
-      privateKey: privKey,
-      data: typedData,
-      version
-    });
-  }
-  signEncryptionPublicKey(address) {
-    const wallet = this._getWalletForAccount(address);
-    return (0,eth_sig_util_namespaceObject.getEncryptionPublicKey)((0,util_namespaceObject.stripHexPrefix)(wallet.privateKey));
-  }
-  decryptMessage(data, address) {
+  async signTypedData(typedData, address) {
     const wallet = this._getWalletForAccount(address);
-    return (0,eth_sig_util_namespaceObject.decrypt)({
-      encryptedData: data,
-      privateKey: (0,util_namespaceObject.stripHexPrefix)(wallet.privateKey)
-    });
+    const privKey = new external_ethers_namespaceObject.SigningKey((0,util_namespaceObject.addHexPrefix)(wallet.privateKey));
+    const signature = privKey.sign(external_ethers_namespaceObject.TypedDataEncoder.hash(typedData.domain, typedData.types, typedData.message)).serialized;
+    return signature;
   }
   _getWalletForAccount(account) {
     const address = account.toLowerCase();
@@ -2806,15 +2771,15 @@ class AbstractMessageController extends base_controllers_namespaceObject.BaseCon
     return new Promise((resolve, reject) => {
       const handleFinished = msg => {
         if (msg.status === MessageStatus.REJECTED) {
-          return reject(openlogin_jrpc_namespaceObject.providerErrors.userRejectedRequest(`${messageName} Signature: User denied message signature`));
+          return reject(auth_namespaceObject.providerErrors.userRejectedRequest(`${messageName} Signature: User denied message signature`));
         }
         if (msg.status === MessageStatus.FAILED) {
-          return reject(openlogin_jrpc_namespaceObject.rpcErrors.internal(`${messageName} Signature: failed to sign message ${msg.error}`));
+          return reject(auth_namespaceObject.rpcErrors.internal(`${messageName} Signature: failed to sign message ${msg.error}`));
         }
         if (msg.status === MessageStatus.SIGNED) {
           return resolve(msg.rawSig);
         }
-        return reject(openlogin_jrpc_namespaceObject.rpcErrors.internal(`${messageName} Signature: Unknown problem: ${JSON.stringify(msgParams)}`));
+        return reject(auth_namespaceObject.rpcErrors.internal(`${messageName} Signature: Unknown problem: ${JSON.stringify(msgParams)}`));
       };
       this.once(`${msgParams.id}:finished`, handleFinished);
     });
@@ -2838,7 +2803,6 @@ class AbstractMessageController extends base_controllers_namespaceObject.BaseCon
 ;// CONCATENATED MODULE: ./src/Message/utils.ts
 
 
-
 const hexRe = /^[0-9A-Fa-f]+$/gu;
 function validateAddress(address, propertyName) {
   if (!address || typeof address !== "string" || !(0,util_namespaceObject.isValidAddress)(address)) {
@@ -2864,19 +2828,7 @@ function normalizeMessageData(data) {
   } catch (e) {}
   return (0,util_namespaceObject.bytesToHex)(Buffer.from(data, "utf8"));
 }
-function validateTypedSignMessageDataV1(messageData) {
-  validateAddress(messageData.from, "from");
-  if (!messageData.data || !Array.isArray(messageData.data)) {
-    throw new Error(`Invalid message "data": ${messageData.data} must be a valid array.`);
-  }
-  try {
-    // typedSignatureHash will throw if the data is invalid.
-    (0,eth_sig_util_namespaceObject.typedSignatureHash)(messageData.data);
-  } catch (e) {
-    throw new Error(`Expected EIP712 typed data.`);
-  }
-}
-async function validateTypedSignMessageDataV3V4(messageData, currentChainId) {
+async function validateTypedSignMessageDataV4(messageData, currentChainId) {
   validateAddress(messageData.from, "from");
   if (!messageData.data || Array.isArray(messageData.data) || typeof messageData.data !== "object" && typeof messageData.data !== "string") {
     throw new Error(`Invalid message "data": Must be a valid string or object.`);
@@ -2891,13 +2843,6 @@ async function validateTypedSignMessageDataV3V4(messageData, currentChainId) {
       throw new Error("Data must be passed as a valid JSON string.");
     }
   }
-  const {
-    validate
-  } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 731, 23));
-  const validation = validate(data, eth_sig_util_namespaceObject.TYPED_MESSAGE_SCHEMA);
-  if (validation.errors.length > 0) {
-    throw new Error("Data must conform to EIP-712 schema. See https://git.io/fNtcx.");
-  }
   if (!currentChainId) {
     throw new Error("Current chainId cannot be null or undefined.");
   }
@@ -2917,23 +2862,6 @@ async function validateTypedSignMessageDataV3V4(messageData, currentChainId) {
     }
   }
 }
-function validateEncryptionPublicKeyMessageData(messageData) {
-  const {
-    from
-  } = messageData;
-  validateAddress(from, "from");
-}
-function validateDecryptedMessageData(messageData) {
-  const {
-    from
-  } = messageData;
-  validateAddress(from, "from");
-}
-function parseDecryptMessageData(data) {
-  const stripped = (0,util_namespaceObject.stripHexPrefix)(data);
-  const buffer = Buffer.from(stripped, "hex");
-  return JSON.parse(buffer.toString("utf8"));
-}
 async function validateAddChainData(data) {
   const {
     chainId,
@@ -3002,6 +2930,9 @@ class AddChainController extends AbstractMessageController {
   }
   async processAddChain(messageId) {
     const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error("Message not found");
+    }
     try {
       await this.approveMessage(messageId, msgObject.messageParams);
       await this.addChain(msgObject.messageParams);
@@ -3021,10 +2952,12 @@ class AddChainController extends AbstractMessageController {
     return this.waitForFinishStatus(messageParams, this.name);
   }
   async addUnapprovedMessage(messageParams, req) {
-    validateAddChainData(messageParams);
+    // set message params origin first to satisfy the eslint rule (origin won't be checked by validateAddChainData)
+    // for "Possible race condition: `messageParams.origin` might be assigned based on an outdated state of `messageParams`"
     if (req) {
       messageParams.origin = req.origin;
     }
+    await validateAddChainData(messageParams);
     const messageId = messageParams.id || (0,base_controllers_namespaceObject.randomId)();
     const messageData = {
       id: messageId,
@@ -3044,151 +2977,6 @@ class AddChainController extends AbstractMessageController {
     return Promise.resolve(messageParams);
   }
 }
-;// CONCATENATED MODULE: ./src/Message/DecryptMessageController.ts
-
-
-// import { isValidAddress } from "@ethereumjs/util";
-
-
-
-
-
-class DecryptMessageController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    decryptMessage,
-    getNetworkIdentifier
-  }) {
-    super({
-      config,
-      state,
-      getNetworkIdentifier
-    });
-    defineProperty_default()(this, "name", "DecryptMessageController");
-    defineProperty_default()(this, "decryptMessage", void 0);
-    this.decryptMessage = decryptMessage;
-    this.initialize();
-  }
-  async processDecryptMessage(messageId) {
-    const msgObject = this.getMessage(messageId);
-    try {
-      const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
-      const parsedData = parseDecryptMessageData(cleanMsgParams.data);
-      const rawSig = this.decryptMessage(parsedData, cleanMsgParams.from);
-      this.updateMessage(objectSpread2_default()(objectSpread2_default()({}, msgObject), {}, {
-        rawSig
-      }));
-      this.setMessageStatus(messageId, MessageStatus.SIGNED);
-      return rawSig;
-    } catch (error) {
-      external_loglevel_default().error(error);
-      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
-      this.setMessageStatus(messageId, MessageStatus.FAILED);
-    }
-  }
-  async addNewUnapprovedMessage(messageParams, req) {
-    await this.addUnapprovedMessage(messageParams, req);
-    return this.waitForFinishStatus(messageParams, this.name);
-  }
-  async addUnapprovedMessage(messageParams, req) {
-    validateDecryptedMessageData(messageParams);
-    if (req) {
-      messageParams.origin = req.origin;
-    }
-    messageParams.data = normalizeMessageData(messageParams.data);
-    const messageId = messageParams.id || (0,base_controllers_namespaceObject.randomId)();
-    const messageData = {
-      id: messageId,
-      messageParams,
-      status: MessageStatus.UNAPPROVED,
-      time: Date.now(),
-      type: METHOD_TYPES.ETH_DECRYPT
-    };
-    await this.addMessage(messageData);
-    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
-      messageData,
-      req
-    });
-    return messageId;
-  }
-  prepMessageForSigning(messageParams) {
-    return Promise.resolve(objectSpread2_default()({}, messageParams));
-  }
-}
-;// CONCATENATED MODULE: ./src/Message/EncryptionPublicKeyController.ts
-
-
-// import { isValidAddress } from "@ethereumjs/util";
-
-
-
-
-
-class EncryptionPublicKeyController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    signEncryptionPublicKey,
-    getNetworkIdentifier
-  }) {
-    super({
-      config,
-      state,
-      getNetworkIdentifier
-    });
-    defineProperty_default()(this, "name", "EncryptionPublicKeyController");
-    defineProperty_default()(this, "signEncryptionPublicKey", void 0);
-    this.signEncryptionPublicKey = signEncryptionPublicKey;
-    this.initialize();
-  }
-  async processGetEncryptionPublicKey(messageId) {
-    const msgObject = this.getMessage(messageId);
-    try {
-      const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
-      const publicKey = this.signEncryptionPublicKey(cleanMsgParams.from);
-      this.updateMessage(objectSpread2_default()(objectSpread2_default()({}, msgObject), {}, {
-        rawSig: publicKey
-      }));
-      this.setMessageStatus(messageId, MessageStatus.SIGNED);
-      return publicKey;
-    } catch (error) {
-      external_loglevel_default().error(error);
-      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
-      this.setMessageStatus(messageId, MessageStatus.FAILED);
-    }
-  }
-  async addNewUnapprovedMessage(messageParams, req) {
-    await this.addUnapprovedMessage(messageParams, req);
-    return this.waitForFinishStatus(messageParams, this.name);
-  }
-  async addUnapprovedMessage(messageParams, req) {
-    validateEncryptionPublicKeyMessageData(messageParams);
-    if (req) {
-      messageParams.origin = req.origin;
-    }
-    const messageId = messageParams.id || (0,base_controllers_namespaceObject.randomId)();
-    const messageData = {
-      id: messageId,
-      messageParams,
-      status: MessageStatus.UNAPPROVED,
-      time: Date.now(),
-      type: METHOD_TYPES.ETH_GET_ENCRYPTION_PUBLIC_KEY
-    };
-    await this.addMessage(messageData);
-    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
-      messageData,
-      req
-    });
-    return messageId;
-  }
-  prepMessageForSigning(messageParams) {
-    // From should be the public key for the encryption
-    return Promise.resolve(objectSpread2_default()(objectSpread2_default()({}, messageParams), {}, {
-      from: messageParams.data
-    }));
-  }
-}
 ;// CONCATENATED MODULE: ./src/Message/MessageController.ts
 
 
@@ -3216,6 +3004,9 @@ class MessageController extends AbstractMessageController {
   }
   async processSignMessage(messageId) {
     const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
     try {
       const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
       const rawSig = await this.signMessage(cleanMsgParams.data, cleanMsgParams.from);
@@ -3286,6 +3077,9 @@ class PersonalMessageController extends AbstractMessageController {
   }
   async processSignPersonalMessage(messageId) {
     const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
     try {
       const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
       const rawSig = await this.signPersonalMessage(cleanMsgParams.data, cleanMsgParams.from);
@@ -3356,6 +3150,9 @@ class SwitchChainController extends AbstractMessageController {
   }
   async processSwitchChain(messageId) {
     const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
     try {
       await this.approveMessage(messageId, msgObject.messageParams);
       this.switchChain({
@@ -3408,19 +3205,6 @@ class SwitchChainController extends AbstractMessageController {
 
 
 
-
-function getMessageType(version) {
-  switch (version) {
-    case eth_sig_util_namespaceObject.SignTypedDataVersion.V1:
-      return METHOD_TYPES.ETH_SIGN_TYPED_DATA;
-    case eth_sig_util_namespaceObject.SignTypedDataVersion.V3:
-      return METHOD_TYPES.ETH_SIGN_TYPED_DATA_V3;
-    case eth_sig_util_namespaceObject.SignTypedDataVersion.V4:
-      return METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4;
-    default:
-      return METHOD_TYPES.ETH_SIGN_TYPED_DATA;
-  }
-}
 class TypedMessageController extends AbstractMessageController {
   constructor({
     config,
@@ -3440,10 +3224,13 @@ class TypedMessageController extends AbstractMessageController {
   }
   async processSignTypedMessage(messageId) {
     const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
     try {
       const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
-      const msgData = cleanMsgParams.version === eth_sig_util_namespaceObject.SignTypedDataVersion.V1 ? cleanMsgParams.data : JSON.parse(cleanMsgParams.data);
-      const rawSig = await this.signTypedData(msgData, cleanMsgParams.from, cleanMsgParams.version);
+      const msgData = JSON.parse(cleanMsgParams.data);
+      const rawSig = await this.signTypedData(msgData, cleanMsgParams.from);
       this.updateMessage(objectSpread2_default()(objectSpread2_default()({}, msgObject), {}, {
         rawSig
       }));
@@ -3455,32 +3242,26 @@ class TypedMessageController extends AbstractMessageController {
       this.setMessageStatus(messageId, MessageStatus.FAILED);
     }
   }
-  async addNewUnapprovedMessage(messageParams, req, version) {
-    await this.addUnapprovedMessage(messageParams, req, version);
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
     return this.waitForFinishStatus(messageParams, this.name);
   }
-  async addUnapprovedMessage(messageParams, req, version) {
-    if (version === eth_sig_util_namespaceObject.SignTypedDataVersion.V1) {
-      validateTypedSignMessageDataV1(messageParams);
-    }
-    if (version === eth_sig_util_namespaceObject.SignTypedDataVersion.V3 || version === eth_sig_util_namespaceObject.SignTypedDataVersion.V4) {
-      const currentChainId = this.getNetworkIdentifier();
-      await validateTypedSignMessageDataV3V4(messageParams, currentChainId);
-    }
-    if (typeof messageParams.data !== "string" && (version === eth_sig_util_namespaceObject.SignTypedDataVersion.V3 || version === eth_sig_util_namespaceObject.SignTypedDataVersion.V4)) {
+  async addUnapprovedMessage(messageParams, req) {
+    const currentChainId = this.getNetworkIdentifier();
+    await validateTypedSignMessageDataV4(messageParams, currentChainId);
+    if (typeof messageParams.data !== "string") {
       messageParams.data = JSON.stringify(messageParams.data);
     }
     if (req) {
       messageParams.origin = req.origin;
     }
-    messageParams.version = version;
     const messageId = messageParams.id || (0,base_controllers_namespaceObject.randomId)();
     const messageData = {
       id: messageId,
       messageParams,
       status: MessageStatus.UNAPPROVED,
       time: Date.now(),
-      type: getMessageType(version)
+      type: METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4
     };
     await this.addMessage(messageData);
     this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
@@ -3497,11 +3278,10 @@ class TypedMessageController extends AbstractMessageController {
 
 
 
-
 function createGetAccountsMiddleware({
   getAccounts
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
     } = request;
@@ -3514,7 +3294,7 @@ function createGetAccountsMiddleware({
 function createProcessTransactionMiddleware({
   processTransaction
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
     } = request;
@@ -3526,7 +3306,7 @@ function createProcessTransactionMiddleware({
 function createProcessEthSignMessage({
   processEthSignMessage
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
     } = request;
@@ -3547,60 +3327,10 @@ function createProcessEthSignMessage({
     response.result = await processEthSignMessage(msgParams, request);
   });
 }
-function createProcessTypedMessage({
-  processTypedMessage
-}) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA) return next();
-    if (!processTypedMessage) throw new Error("WalletMiddleware - opts.processTypedMessage not  provided");
-    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [typedData, address]`);
-      const params = request.params;
-      const message = typeof params[0] === "string" ? JSON.parse(params[0]) : params[0];
-      const address = params[1];
-      msgParams = {
-        from: address,
-        data: message,
-        version: eth_sig_util_namespaceObject.SignTypedDataVersion.V1
-      };
-    }
-    response.result = await processTypedMessage(msgParams, request);
-  });
-}
-function createProcessTypedMessageV3({
-  processTypedMessageV3
-}) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA_V3) return next();
-    if (!processTypedMessageV3) throw new Error("WalletMiddleware - opts.processTypedMessageV3 is not provided");
-    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, typedData]`);
-      const params = request.params;
-      const address = params[0];
-      const message = params[1];
-      msgParams = {
-        from: address,
-        data: message,
-        version: eth_sig_util_namespaceObject.SignTypedDataVersion.V3
-      };
-    }
-    response.result = await processTypedMessageV3(msgParams, request);
-  });
-}
 function createProcessTypedMessageV4({
   processTypedMessageV4
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
     } = request;
@@ -3615,8 +3345,7 @@ function createProcessTypedMessageV4({
       const message = params[1];
       msgParams = {
         from: address,
-        data: message,
-        version: eth_sig_util_namespaceObject.SignTypedDataVersion.V4
+        data: message
       };
     }
     response.result = await processTypedMessageV4(msgParams, request);
@@ -3625,7 +3354,7 @@ function createProcessTypedMessageV4({
 function createProcessPersonalMessage({
   processPersonalMessage
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
     } = request;
@@ -3660,7 +3389,7 @@ function createProcessPersonalMessage({
 function createPendingNonceMiddleware({
   getPendingNonce
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       params,
       method
@@ -3724,7 +3453,7 @@ function formatTxMetaForRpcResult(txMeta) {
 function createPendingTxMiddleware({
   getPendingTransactionByHash
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       params,
       method
@@ -3739,54 +3468,10 @@ function createPendingTxMiddleware({
     return undefined;
   });
 }
-function createProcessEncryptionPublicKeyMiddleware({
-  processEncryptionPublicKey
-}) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_GET_ENCRYPTION_PUBLIC_KEY) return next();
-    if (!processEncryptionPublicKey) throw new Error("WalletMiddleware - opts.processEncryptionPublicKey not provided");
-    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address]`);
-      const [address] = request.params;
-      msgParams = {
-        data: address,
-        from: address
-      };
-    }
-    response.result = await processEncryptionPublicKey(msgParams, request);
-  });
-}
-function createProcessDecryptMessageMiddleware({
-  processDecryptMessage
-}) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_DECRYPT) return next();
-    if (!processDecryptMessage) throw new Error("WalletMiddleware - opts.processDecryptMessage not provided");
-    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [message, address]`);
-      const [message, address] = request.params;
-      msgParams = {
-        data: message,
-        from: address
-      };
-    }
-    response.result = await processDecryptMessage(msgParams, request);
-  });
-}
 function createProcessSwitchEthereumChain({
   processSwitchEthereumChain
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
     } = request;
@@ -3805,7 +3490,7 @@ function createProcessSwitchEthereumChain({
 function createProcessAddEthereumChain({
   processAddEthereumChain
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
     } = request;
@@ -3824,7 +3509,7 @@ function createProcessAddEthereumChain({
 function createRequestAccountsMiddleware({
   requestAccounts
 }) {
-  return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
+  return (0,auth_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
     } = request;
@@ -3842,20 +3527,16 @@ function createEthereumMiddleware(providerHandlers) {
     getAccounts,
     processTransaction,
     processEthSignMessage,
-    processTypedMessage,
-    processTypedMessageV3,
     processTypedMessageV4,
     processPersonalMessage,
     getPendingNonce,
     getPendingTransactionByHash,
-    processEncryptionPublicKey,
-    processDecryptMessage,
     processSwitchEthereumChain,
     processAddEthereumChain,
     getProviderState,
     version
   } = providerHandlers;
-  return (0,openlogin_jrpc_namespaceObject.mergeMiddleware)([(0,openlogin_jrpc_namespaceObject.createScaffoldMiddleware)({
+  return (0,auth_namespaceObject.mergeMiddleware)([(0,auth_namespaceObject.createScaffoldMiddleware)({
     version,
     [base_controllers_namespaceObject.PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: getProviderState
   }), createRequestAccountsMiddleware({
@@ -3866,10 +3547,6 @@ function createEthereumMiddleware(providerHandlers) {
     processTransaction
   }), createProcessEthSignMessage({
     processEthSignMessage
-  }), createProcessTypedMessage({
-    processTypedMessage
-  }), createProcessTypedMessageV3({
-    processTypedMessageV3
   }), createProcessTypedMessageV4({
     processTypedMessageV4
   }), createProcessPersonalMessage({
@@ -3878,10 +3555,6 @@ function createEthereumMiddleware(providerHandlers) {
     getPendingNonce
   }), createPendingTxMiddleware({
     getPendingTransactionByHash
-  }), createProcessEncryptionPublicKeyMiddleware({
-    processEncryptionPublicKey
-  }), createProcessDecryptMessageMiddleware({
-    processDecryptMessage
   }), createProcessSwitchEthereumChain({
     processSwitchEthereumChain
   }), createProcessAddEthereumChain({
@@ -4033,14 +3706,14 @@ function createJsonRpcClient(providerConfig, networkConfig) {
   const fetchMiddleware = (0,base_controllers_namespaceObject.createFetchMiddleware)({
     rpcTarget
   });
-  const blockProvider = (0,openlogin_jrpc_namespaceObject.providerFromMiddleware)(fetchMiddleware);
-  const blockTracker = new Block_PollingBlockTracker({
+  const blockProvider = (0,auth_namespaceObject.providerFromMiddleware)(fetchMiddleware);
+  const blockTracker = new PollingBlockTracker({
     config: objectSpread2_default()(objectSpread2_default()({}, networkConfig), {}, {
       provider: blockProvider
     }),
     state: {}
   });
-  const networkMiddleware = (0,openlogin_jrpc_namespaceObject.mergeMiddleware)([createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig),
+  const networkMiddleware = (0,auth_namespaceObject.mergeMiddleware)([createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig),
   // No need for the following middlewares for web because all browser sessions are quite short lived and each session is limited to scope of a window/tab
   // createBlockRefRewriteMiddleware({ blockTracker }),
   // createBlockCacheMiddleware({ blockTracker }),
@@ -4087,7 +3760,7 @@ class NetworkController extends base_controllers_namespaceObject.BaseController
       properties: {
         EIPS_1559: undefined
       },
-      providerConfig: SUPPORTED_NETWORKS.mainnet
+      providerConfig: SUPPORTED_NETWORKS[MAINNET_CHAIN_ID]
     };
 
     // when a new network is set,
@@ -4202,10 +3875,10 @@ class NetworkController extends base_controllers_namespaceObject.BaseController
     blockTracker
   }) {
     const ethereumMiddleware = createEthereumMiddleware(this.baseProviderHandlers);
-    const engine = new openlogin_jrpc_namespaceObject.JRPCEngine();
+    const engine = new auth_namespaceObject.JRPCEngine();
     engine.push(ethereumMiddleware);
     engine.push(networkMiddleware);
-    const provider = (0,openlogin_jrpc_namespaceObject.providerFromEngine)(engine);
+    const provider = (0,auth_namespaceObject.providerFromEngine)(engine);
     this.setProvider({
       provider,
       blockTracker
@@ -4849,7 +4522,8 @@ class PreferencesController extends base_controllers_namespaceObject.BasePrefere
   async refetchEtherscanTx(address) {
     var _this$getAddressState3;
     const selectedAddress = address || this.state.selectedAddress;
-    const lowerCaseSelectedAddress = selectedAddress.toLowerCase();
+    if (!selectedAddress) return [];
+    const lowerCaseSelectedAddress = selectedAddress === null || selectedAddress === void 0 ? void 0 : selectedAddress.toLowerCase();
     if ((_this$getAddressState3 = this.getAddressState(selectedAddress)) !== null && _this$getAddressState3 !== void 0 && _this$getAddressState3.jwtToken) {
       const {
         chainId
@@ -5667,14 +5341,13 @@ class NonceTracker {
     };
   }
 }
-/* harmony default export */ const Transaction_NonceTracker = (NonceTracker);
 ;// CONCATENATED MODULE: ./src/Transaction/PendingTransactionTracker.ts
 
 
 
 
 
-class PendingTransactionTracker extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
+class PendingTransactionTracker extends auth_namespaceObject.SafeEventEmitter {
   constructor({
     provider,
     nonceTracker,
@@ -5750,7 +5423,6 @@ class PendingTransactionTracker extends openlogin_jrpc_namespaceObject.SafeEvent
         };
         this.emit(base_controllers_namespaceObject.TX_EVENTS.TX_WARNING, {
           txMeta,
-          error,
           txId: txMeta.id
         });
       }
@@ -5772,11 +5444,11 @@ class PendingTransactionTracker extends openlogin_jrpc_namespaceObject.SafeEvent
     if (txBlockDistance <= Math.min(50, 2 ** retryCount)) return undefined;
 
     // Only auto-submit already-signed txs:
-    if (!("rawTx" in txMeta)) return this.approveTransaction(txMeta.id);
+    if (!("rawTransaction" in txMeta)) return this.approveTransaction(txMeta.id);
     const {
-      rawTx
+      rawTransaction
     } = txMeta;
-    const txHash = await this.publishTransaction(rawTx);
+    const txHash = await this.publishTransaction(rawTransaction);
 
     // Increment successful tries:
     this.emit(base_controllers_namespaceObject.TX_EVENTS.TX_RETRY, {
@@ -5840,7 +5512,8 @@ class PendingTransactionTracker extends openlogin_jrpc_namespaceObject.SafeEvent
         message: "There was a problem loading this transaction."
       };
       this.emit(base_controllers_namespaceObject.TX_EVENTS.TX_WARNING, {
-        txMeta
+        txMeta,
+        txId
       });
     }
     if (await this._checkIfTxWasDropped(txMeta)) {
@@ -6042,6 +5715,7 @@ class TransactionStateManager extends base_controllers_namespaceObject.BaseTrans
     });
   }
   generateTxMeta(opts = {}) {
+    var _opts$transaction;
     const chainId = this.getCurrentChainId();
     if (chainId === "loading") throw new Error("Torus is having trouble connecting to the network");
     let dappSuggestedGasFees = null;
@@ -6067,7 +5741,7 @@ class TransactionStateManager extends base_controllers_namespaceObject.BaseTrans
       }
     }
     return objectSpread2_default()({
-      id: opts.transaction.id || (0,base_controllers_namespaceObject.randomId)(),
+      id: ((_opts$transaction = opts.transaction) === null || _opts$transaction === void 0 ? void 0 : _opts$transaction.id) || (0,base_controllers_namespaceObject.randomId)(),
       time: Date.now(),
       status: base_controllers_namespaceObject.TransactionStatus.unapproved,
       loadingDefaults: true,
@@ -6373,7 +6047,7 @@ class TransactionController extends TransactionStateManager {
     this.signEthTx = signEthTx;
     this.provider = provider;
     this.txGasUtil = new TransactionGasUtil(this.provider, this.blockTracker);
-    this.nonceTracker = new Transaction_NonceTracker({
+    this.nonceTracker = new NonceTracker({
       provider,
       blockTracker,
       getConfirmedTransactions: this.getConfirmedTransactions.bind(this),
@@ -6405,15 +6079,15 @@ class TransactionController extends TransactionStateManager {
     return new Promise((resolve, reject) => {
       const handleFinished = msg => {
         if (msg.status === base_controllers_namespaceObject.TransactionStatus.rejected) {
-          return reject(openlogin_jrpc_namespaceObject.providerErrors.userRejectedRequest(`Transaction Signature: User denied message signature`));
+          return reject(auth_namespaceObject.providerErrors.userRejectedRequest(`Transaction Signature: User denied message signature`));
         }
         if (msg.status === base_controllers_namespaceObject.TransactionStatus.failed) {
-          return reject(openlogin_jrpc_namespaceObject.rpcErrors.internal(`Transaction Signature: failed to sign message ${msg.error}`));
+          return reject(auth_namespaceObject.rpcErrors.internal(`Transaction Signature: failed to sign message ${msg.error}`));
         }
         if (msg.status === base_controllers_namespaceObject.TransactionStatus.submitted) {
           return resolve(msg.transactionHash);
         }
-        return reject(openlogin_jrpc_namespaceObject.rpcErrors.internal(`Transaction Signature: Unknown problem: ${JSON.stringify(txMeta.transaction)}`));
+        return reject(auth_namespaceObject.rpcErrors.internal(`Transaction Signature: Unknown problem: ${JSON.stringify(txMeta.transaction)}`));
       };
       this.once(`${txMeta.id}:finished`, handleFinished);
     });
@@ -6476,6 +6150,7 @@ class TransactionController extends TransactionStateManager {
     const {
       TransactionFactory
     } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 81, 23));
+    // TODO: fix this when @ethereumjs/tx is updated.
     const unsignedEthTx = TransactionFactory.fromTxData(txParams, {
       common
     });
@@ -6748,12 +6423,12 @@ class TransactionController extends TransactionStateManager {
         this.updateTransactionInState(txMeta);
       }
     });
-    this.pendingTxTracker.on(base_controllers_namespaceObject.TX_EVENTS.TX_RETRY, txMeta => {
-      if (!("retryCount" in txMeta)) {
-        txMeta.retryCount = 0;
+    this.pendingTxTracker.on(base_controllers_namespaceObject.TX_EVENTS.TX_RETRY, data => {
+      if (!("retryCount" in data.txMeta)) {
+        data.txMeta.retryCount = 0;
       }
-      txMeta.retryCount += 1;
-      this.updateTransactionInState(txMeta);
+      data.txMeta.retryCount += 1;
+      this.updateTransactionInState(data.txMeta);
     });
     this.pendingTxTracker.on(base_controllers_namespaceObject.TX_EVENTS.TX_FAILED, data => {
       this.setTxStatusFailed(data.txId, data.error);
@@ -6824,9 +6499,16 @@ class TransactionController extends TransactionStateManager {
     });
   }
 }
-;// CONCATENATED MODULE: ./src/index.ts
+;// CONCATENATED MODULE: ./src/utils/interfaces.ts
+
 
 
+/**
+ * Ref - https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt
+ */
+
+// TODO:// mark fields which will be optional.
+;// CONCATENATED MODULE: ./src/index.ts