@toruslabs/ethereum-controllers 5.11.0 → 6.0.1

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,7 +124,8 @@ __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),
@@ -148,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),
@@ -168,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),
@@ -176,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),
@@ -208,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),
@@ -247,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),
@@ -260,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"
@@ -1009,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",
@@ -1283,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
 
 
@@ -1373,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`);
   }
 }
 
@@ -1383,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]})`);
   }
 }
 
@@ -1397,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");
       }
   }
 }
@@ -1413,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.');
   }
 }
 
@@ -1428,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;
 }
@@ -1442,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
@@ -1480,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:
@@ -1921,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
@@ -2630,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
 
 
@@ -2697,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();
@@ -2814,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);
     });
@@ -2846,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)) {
@@ -2872,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.`);
@@ -2899,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.");
   }
@@ -2925,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,
@@ -3057,157 +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);
-    if (!msgObject) {
-      throw new Error("Message not found");
-    }
-    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);
-    if (!msgObject) {
-      throw new Error(`Message not found`);
-    }
-    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
 
 
@@ -3436,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,
@@ -3473,8 +3229,8 @@ class TypedMessageController extends AbstractMessageController {
     }
     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
       }));
@@ -3486,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, {
@@ -3528,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;
@@ -3545,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;
@@ -3557,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;
@@ -3578,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;
@@ -3646,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);
@@ -3656,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;
@@ -3691,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
@@ -3755,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
@@ -3770,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;
@@ -3836,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;
@@ -3855,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;
@@ -3873,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({
@@ -3897,10 +3547,6 @@ function createEthereumMiddleware(providerHandlers) {
     processTransaction
   }), createProcessEthSignMessage({
     processEthSignMessage
-  }), createProcessTypedMessage({
-    processTypedMessage
-  }), createProcessTypedMessageV3({
-    processTypedMessageV3
   }), createProcessTypedMessageV4({
     processTypedMessageV4
   }), createProcessPersonalMessage({
@@ -3909,10 +3555,6 @@ function createEthereumMiddleware(providerHandlers) {
     getPendingNonce
   }), createPendingTxMiddleware({
     getPendingTransactionByHash
-  }), createProcessEncryptionPublicKeyMiddleware({
-    processEncryptionPublicKey
-  }), createProcessDecryptMessageMiddleware({
-    processDecryptMessage
   }), createProcessSwitchEthereumChain({
     processSwitchEthereumChain
   }), createProcessAddEthereumChain({
@@ -4064,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 }),
@@ -4233,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
@@ -5699,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,
@@ -5782,7 +5423,6 @@ class PendingTransactionTracker extends openlogin_jrpc_namespaceObject.SafeEvent
         };
         this.emit(base_controllers_namespaceObject.TX_EVENTS.TX_WARNING, {
           txMeta,
-          error,
           txId: txMeta.id
         });
       }
@@ -5872,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)) {
@@ -6406,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),
@@ -6438,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);
     });
@@ -6509,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
     });
@@ -6781,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);
@@ -6857,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