@web3auth/no-modal 9.5.4 → 10.0.0-alpha.0

package/dist/lib.esm/providers/ethereum-provider/providers/privateKeyProviders/TransactionFormatter/formatter.js

@@ -0,0 +1,378 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { addHexPrefix, stripHexPrefix } from '@ethereumjs/util';
+import { BigNumber } from 'bignumber.js';
+import { log } from '../../../../../base/loglevel.js';
+import { hexWEIToDecGWEI, decGWEIToHexWEI } from '../../converter.js';
+import { bnLessThan, hexToBn, BnMultiplyByFraction, bnToHex } from '../../utils.js';
+import { TRANSACTION_ENVELOPE_TYPES, EIP1559APIEndpoint, GAS_ESTIMATE_TYPES, LegacyGasAPIEndpoint, TRANSACTION_TYPES } from './constants.js';
+import { fetchEip1159GasEstimates, fetchLegacyGasPriceEstimates } from './utils.js';
+
+class TransactionFormatter {
+  constructor({
+    getProviderEngineProxy
+  }) {
+    // https://0x.org/docs/introduction/0x-cheat-sheet#swap-api-endpoints
+    _defineProperty(this, "API_SUPPORTED_CHAINIDS", new Set(["0x1", "0x5", "0x13881", "0xa4b1", "0xa86a", "0x2105", "0x38", "0xfa", "0xa", "0x89"]));
+    _defineProperty(this, "chainConfig", null);
+    _defineProperty(this, "getProviderEngineProxy", void 0);
+    _defineProperty(this, "isEIP1559Compatible", false);
+    this.getProviderEngineProxy = getProviderEngineProxy;
+  }
+  get providerProxy() {
+    return this.getProviderEngineProxy();
+  }
+  async init() {
+    this.chainConfig = await this.providerProxy.request({
+      method: "eth_provider_config"
+    });
+    this.isEIP1559Compatible = await this.getEIP1559Compatibility();
+  }
+  async formatTransaction(txParams) {
+    if (!this.chainConfig) throw new Error("Chain config not initialized");
+    const clonedTxParams = _objectSpread({}, txParams);
+    if (clonedTxParams.nonce === undefined) clonedTxParams.nonce = await this.providerProxy.request({
+      method: "eth_getTransactionCount",
+      params: [txParams.from, "latest"]
+    });
+    if (!this.isEIP1559Compatible && clonedTxParams.gasPrice) {
+      if (clonedTxParams.maxFeePerGas) delete clonedTxParams.maxFeePerGas;
+      if (clonedTxParams.maxPriorityFeePerGas) delete clonedTxParams.maxPriorityFeePerGas;
+      // if user provides gas Limit, we should use it instead
+      // if gas is not provided explicitly, estimate it.
+      if (!clonedTxParams.gasLimit) {
+        if (!clonedTxParams.gas) {
+          const defaultGasLimit = await this.getDefaultGasLimit(clonedTxParams);
+          if (defaultGasLimit) {
+            clonedTxParams.gasLimit = defaultGasLimit;
+          }
+        } else {
+          clonedTxParams.gasLimit = addHexPrefix(clonedTxParams.gas);
+        }
+      }
+      return clonedTxParams;
+    }
+    if (!clonedTxParams.gasLimit) {
+      if (!clonedTxParams.gas) {
+        const defaultGasLimit = await this.getDefaultGasLimit(clonedTxParams);
+        if (defaultGasLimit) {
+          clonedTxParams.gasLimit = defaultGasLimit;
+        }
+      } else {
+        clonedTxParams.gasLimit = addHexPrefix(clonedTxParams.gas);
+      }
+    }
+    const {
+      gasPrice: defaultGasPrice,
+      maxFeePerGas: defaultMaxFeePerGas,
+      maxPriorityFeePerGas: defaultMaxPriorityFeePerGas
+    } = await this.getDefaultGasFees(clonedTxParams);
+    if (this.isEIP1559Compatible) {
+      // If the dapp has suggested a gas price, but no maxFeePerGas or maxPriorityFeePerGas
+      //  then we set maxFeePerGas and maxPriorityFeePerGas to the suggested gasPrice.
+      if (clonedTxParams.gasPrice && !clonedTxParams.maxFeePerGas && !clonedTxParams.maxPriorityFeePerGas) {
+        clonedTxParams.maxFeePerGas = clonedTxParams.gasPrice;
+        clonedTxParams.maxPriorityFeePerGas = bnLessThan(typeof defaultMaxPriorityFeePerGas === "string" ? stripHexPrefix(defaultMaxPriorityFeePerGas) : defaultMaxPriorityFeePerGas, typeof clonedTxParams.gasPrice === "string" ? stripHexPrefix(clonedTxParams.gasPrice) : clonedTxParams.gasPrice.toString()) ? addHexPrefix(defaultMaxPriorityFeePerGas) : addHexPrefix(clonedTxParams.gasPrice.toString());
+      } else {
+        if (defaultMaxFeePerGas && !clonedTxParams.maxFeePerGas) {
+          // If the dapp has not set the gasPrice or the maxFeePerGas, then we set maxFeePerGas
+          // with the one returned by the gasFeeController, if that is available.
+          clonedTxParams.maxFeePerGas = addHexPrefix(defaultMaxFeePerGas);
+        }
+        if (defaultMaxPriorityFeePerGas && !clonedTxParams.maxPriorityFeePerGas) {
+          // If the dapp has not set the gasPrice or the maxPriorityFeePerGas, then we set maxPriorityFeePerGas
+          // with the one returned by the gasFeeController, if that is available.
+          clonedTxParams.maxPriorityFeePerGas = addHexPrefix(defaultMaxPriorityFeePerGas);
+        }
+        if (defaultGasPrice && !clonedTxParams.maxFeePerGas) {
+          // If the dapp has not set the gasPrice or the maxFeePerGas, and no maxFeePerGas is available
+          // then we set maxFeePerGas to the defaultGasPrice, assuming it is
+          // available.
+          clonedTxParams.maxFeePerGas = addHexPrefix(defaultGasPrice);
+        }
+        if (clonedTxParams.maxFeePerGas && !clonedTxParams.maxPriorityFeePerGas) {
+          // If the dapp has not set the gasPrice or the maxPriorityFeePerGas, and no maxPriorityFeePerGas is
+          // available  then we set maxPriorityFeePerGas to
+          // clonedTxParams.maxFeePerGas, which will either be the gasPrice from the controller, the maxFeePerGas
+          // set by the dapp, or the maxFeePerGas from the controller.
+          clonedTxParams.maxPriorityFeePerGas = clonedTxParams.maxFeePerGas;
+        }
+      }
+
+      // We remove the gasPrice param entirely when on an eip1559 compatible network
+
+      delete clonedTxParams.gasPrice;
+    } else {
+      // We ensure that maxFeePerGas and maxPriorityFeePerGas are not in the transaction params
+      // when not on a EIP1559 compatible network
+
+      delete clonedTxParams.maxPriorityFeePerGas;
+      delete clonedTxParams.maxFeePerGas;
+    }
+
+    // If we have gotten to this point, and none of gasPrice, maxPriorityFeePerGas or maxFeePerGas are
+    // set on txParams, it means that either we are on a non-EIP1559 network and the dapp didn't suggest
+    // a gas price, or we are on an EIP1559 network, and none of gasPrice, maxPriorityFeePerGas or maxFeePerGas
+    // were available from either the dapp or the network.
+    if (defaultGasPrice && !clonedTxParams.gasPrice && !clonedTxParams.maxPriorityFeePerGas && !clonedTxParams.maxFeePerGas) {
+      clonedTxParams.gasPrice = defaultGasPrice;
+    }
+    clonedTxParams.type = Number.parseInt(this.isEIP1559Compatible ? TRANSACTION_ENVELOPE_TYPES.FEE_MARKET : TRANSACTION_ENVELOPE_TYPES.LEGACY, 16);
+    clonedTxParams.chainId = this.chainConfig.chainId;
+    return clonedTxParams;
+  }
+  async fetchEthGasPriceEstimate() {
+    const gasPrice = await this.providerProxy.request({
+      method: "eth_gasPrice",
+      params: []
+    });
+    return {
+      gasPrice: hexWEIToDecGWEI(gasPrice).toString()
+    };
+  }
+  async fetchGasEstimatesViaEthFeeHistory() {
+    const noOfBlocks = 10;
+    const newestBlock = "latest";
+    // get the 10, 50 and 95th percentile of the tip fees from the last 10 blocks
+    const percentileValues = [10, 50, 95];
+    const feeHistory = await this.providerProxy.request({
+      method: "eth_feeHistory",
+      params: [noOfBlocks, newestBlock, percentileValues]
+    });
+
+    // this is in hex wei
+    const finalBaseFeePerGas = feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1];
+    // this is in hex wei
+    const priorityFeeCalcs = feeHistory.reward.reduce((acc, curr) => {
+      return {
+        slow: acc.slow.plus(new BigNumber(curr[0], 16)),
+        average: acc.average.plus(new BigNumber(curr[1], 16)),
+        fast: acc.fast.plus(new BigNumber(curr[2], 16))
+      };
+    }, {
+      slow: new BigNumber(0),
+      average: new BigNumber(0),
+      fast: new BigNumber(0)
+    });
+    return {
+      estimatedBaseFee: hexWEIToDecGWEI(finalBaseFeePerGas).toString(),
+      high: {
+        maxWaitTimeEstimate: 30000,
+        minWaitTimeEstimate: 15000,
+        suggestedMaxFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.fast.plus(finalBaseFeePerGas).toString(16)).toString(),
+        suggestedMaxPriorityFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.fast.toString(16)).toString()
+      },
+      medium: {
+        maxWaitTimeEstimate: 45000,
+        minWaitTimeEstimate: 15000,
+        suggestedMaxFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.average.plus(finalBaseFeePerGas).toString(16)).toString(),
+        suggestedMaxPriorityFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.average.toString(16)).toString()
+      },
+      low: {
+        maxWaitTimeEstimate: 60000,
+        minWaitTimeEstimate: 15000,
+        suggestedMaxFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.slow.plus(finalBaseFeePerGas).toString(16)).toString(),
+        suggestedMaxPriorityFeePerGas: hexWEIToDecGWEI(priorityFeeCalcs.slow.toString(16)).toString()
+      }
+    };
+  }
+  async getEIP1559Compatibility() {
+    const latestBlock = await this.providerProxy.request({
+      method: "eth_getBlockByNumber",
+      params: ["latest", false]
+    });
+    const supportsEIP1559 = latestBlock && latestBlock.baseFeePerGas !== undefined;
+    return !!supportsEIP1559;
+  }
+  async fetchGasFeeEstimateData() {
+    if (!this.chainConfig) throw new Error("Chain config not initialized");
+    const isLegacyGasAPICompatible = this.chainConfig.chainId === "0x1";
+    const chainId = Number.parseInt(this.chainConfig.chainId, 16);
+    let gasData;
+    try {
+      if (this.isEIP1559Compatible) {
+        let estimates;
+        try {
+          if (this.API_SUPPORTED_CHAINIDS.has(this.chainConfig.chainId)) {
+            estimates = await fetchEip1159GasEstimates(EIP1559APIEndpoint.replace("<chain_id>", `${chainId}`));
+          } else {
+            throw new Error("Chain id not supported by api");
+          }
+        } catch (error) {
+          estimates = await this.fetchGasEstimatesViaEthFeeHistory();
+        }
+        gasData = {
+          gasFeeEstimates: estimates,
+          gasEstimateType: GAS_ESTIMATE_TYPES.FEE_MARKET
+        };
+      } else if (isLegacyGasAPICompatible) {
+        const estimates = await fetchLegacyGasPriceEstimates(LegacyGasAPIEndpoint.replace("<chain_id>", `${chainId}`));
+        gasData = {
+          gasFeeEstimates: estimates,
+          gasEstimateType: GAS_ESTIMATE_TYPES.LEGACY
+        };
+      } else {
+        throw new Error("Main gas fee/price estimation failed. Use fallback");
+      }
+    } catch (e) {
+      try {
+        const estimates = await this.fetchEthGasPriceEstimate();
+        gasData = {
+          gasFeeEstimates: estimates,
+          gasEstimateType: GAS_ESTIMATE_TYPES.ETH_GASPRICE
+        };
+      } catch (error) {
+        throw new Error(`Gas fee/price estimation failed. Message: ${error.message}`);
+      }
+    }
+    return gasData;
+  }
+  async getDefaultGasFees(txParams) {
+    if (!this.isEIP1559Compatible && txParams.gasPrice || this.isEIP1559Compatible && txParams.maxFeePerGas && txParams.maxPriorityFeePerGas) {
+      return {};
+    }
+    try {
+      const {
+        gasFeeEstimates,
+        gasEstimateType
+      } = await this.fetchGasFeeEstimateData();
+      if (this.isEIP1559Compatible && gasEstimateType === GAS_ESTIMATE_TYPES.FEE_MARKET) {
+        const {
+          medium: {
+            suggestedMaxPriorityFeePerGas,
+            suggestedMaxFeePerGas
+          } = {}
+        } = gasFeeEstimates;
+        if (suggestedMaxPriorityFeePerGas && suggestedMaxFeePerGas) {
+          return {
+            maxFeePerGas: addHexPrefix(decGWEIToHexWEI(suggestedMaxFeePerGas)),
+            maxPriorityFeePerGas: addHexPrefix(decGWEIToHexWEI(suggestedMaxPriorityFeePerGas))
+          };
+        }
+      } else if (gasEstimateType === GAS_ESTIMATE_TYPES.LEGACY) {
+        // The LEGACY type includes low, medium and high estimates of
+        // gas price values.
+        return {
+          gasPrice: addHexPrefix(decGWEIToHexWEI(gasFeeEstimates.medium))
+        };
+      } else if (gasEstimateType === GAS_ESTIMATE_TYPES.ETH_GASPRICE) {
+        // The ETH_GASPRICE type just includes a single gas price property,
+        // which we can assume was retrieved from eth_gasPrice
+        return {
+          gasPrice: addHexPrefix(decGWEIToHexWEI(gasFeeEstimates.gasPrice))
+        };
+      }
+    } catch (error) {
+      log.error(error);
+    }
+    const {
+      gasPrice
+    } = await this.fetchEthGasPriceEstimate();
+    return {
+      gasPrice: addHexPrefix(decGWEIToHexWEI(gasPrice))
+    };
+  }
+  async estimateTxGas(txMeta) {
+    const txParams = _objectSpread({}, txMeta);
+
+    // `eth_estimateGas` can fail if the user has insufficient balance for the
+    // value being sent, or for the gas cost. We don't want to check their
+    // balance here, we just want the gas estimate. The gas price is removed
+    // to skip those balance checks. We check balance elsewhere. We also delete
+    // maxFeePerGas and maxPriorityFeePerGas to support EIP-1559 txs.
+    delete txParams.gasPrice;
+    delete txParams.maxFeePerGas;
+    delete txParams.maxPriorityFeePerGas;
+    const gas = await this.providerProxy.request({
+      method: "eth_estimateGas",
+      params: [txParams]
+    });
+    return gas;
+  }
+  async analyzeGasUsage(txMeta) {
+    const block = await this.providerProxy.request({
+      method: "eth_getBlockByNumber",
+      params: ["latest", false]
+    });
+    // fallback to block gasLimit
+    const blockGasLimitBN = hexToBn(block.gasLimit);
+    const saferGasLimitBN = BnMultiplyByFraction(blockGasLimitBN, 19, 20);
+    let estimatedGasHex = bnToHex(saferGasLimitBN);
+    try {
+      estimatedGasHex = await this.estimateTxGas(txMeta);
+    } catch (error) {
+      log.warn(error);
+    }
+    return {
+      blockGasLimit: block.gasLimit,
+      estimatedGasHex
+    };
+  }
+  addGasBuffer(initialGasLimitHex, blockGasLimitHex, multiplier = 1.5) {
+    const initialGasLimitBn = hexToBn(initialGasLimitHex);
+    const blockGasLimitBn = hexToBn(blockGasLimitHex);
+    const upperGasLimitBn = blockGasLimitBn.muln(0.9);
+    const bufferedGasLimitBn = initialGasLimitBn.muln(multiplier);
+
+    // if initialGasLimit is above blockGasLimit, dont modify it
+    if (initialGasLimitBn.gt(upperGasLimitBn)) return bnToHex(initialGasLimitBn);
+    // if bufferedGasLimit is below blockGasLimit, use bufferedGasLimit
+    if (bufferedGasLimitBn.lt(upperGasLimitBn)) return bnToHex(bufferedGasLimitBn);
+    // otherwise use blockGasLimit
+    return bnToHex(upperGasLimitBn);
+  }
+  async determineTransactionCategory(txParameters) {
+    const {
+      data,
+      to
+    } = txParameters;
+    let code = "";
+    let txCategory;
+    if (data && !to) {
+      txCategory = TRANSACTION_TYPES.DEPLOY_CONTRACT;
+    } else {
+      try {
+        code = await this.providerProxy.request({
+          method: "eth_getCode",
+          params: [to, "latest"]
+        });
+      } catch (error) {
+        log.warn(error);
+      }
+      const codeIsEmpty = !code || code === "0x" || code === "0x0";
+      txCategory = codeIsEmpty ? TRANSACTION_TYPES.SENT_ETHER : TRANSACTION_TYPES.CONTRACT_INTERACTION;
+    }
+    return {
+      transactionCategory: txCategory,
+      code
+    };
+  }
+  async getDefaultGasLimit(txParams) {
+    const {
+      transactionCategory
+    } = await this.determineTransactionCategory(_objectSpread({}, txParams));
+    if (txParams.gas) {
+      return addHexPrefix(txParams.gas);
+    }
+    if (txParams.to && transactionCategory === TRANSACTION_TYPES.SENT_ETHER) {
+      // if there's data in the params, but there's no contract code, it's not a valid transaction
+      if (txParams.data) {
+        throw Error("TxGasUtil - Trying to call a function on a non-contract address");
+      }
+      const TWENTY_ONE_THOUSAND = 21000;
+
+      // This is a standard ether simple send, gas requirement is exactly 21k
+      return addHexPrefix(TWENTY_ONE_THOUSAND.toString(16));
+    }
+    const {
+      blockGasLimit,
+      estimatedGasHex
+    } = await this.analyzeGasUsage(txParams);
+
+    // add additional gas buffer to our estimation for safety
+    const gasLimit = this.addGasBuffer(addHexPrefix(estimatedGasHex), blockGasLimit);
+    return gasLimit;
+  }
+}
+
+export { TransactionFormatter };

package/dist/lib.esm/providers/ethereum-provider/providers/privateKeyProviders/TransactionFormatter/interfaces.js

@@ -0,0 +1,8 @@
+let SignTypedDataVersion = /*#__PURE__*/function (SignTypedDataVersion) {
+  SignTypedDataVersion["V1"] = "V1";
+  SignTypedDataVersion["V3"] = "V3";
+  SignTypedDataVersion["V4"] = "V4";
+  return SignTypedDataVersion;
+}({});
+
+export { SignTypedDataVersion };

package/dist/lib.esm/providers/ethereum-provider/providers/privateKeyProviders/TransactionFormatter/utils.js

@@ -0,0 +1,88 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { isValidAddress } from '@ethereumjs/util';
+import { get } from '@toruslabs/http-helpers';
+import { decGWEIToHexWEI, hexWEIToDecGWEI } from '../../converter.js';
+
+function normalizeGWEIDecimalNumbers(n) {
+  const numberAsWEIHex = decGWEIToHexWEI(n);
+  const numberAsGWEI = hexWEIToDecGWEI(numberAsWEIHex).toString();
+  return numberAsGWEI;
+}
+async function fetchEip1159GasEstimates(url) {
+  const estimates = await get(url);
+  const normalizedEstimates = _objectSpread(_objectSpread({}, estimates), {}, {
+    estimatedBaseFee: normalizeGWEIDecimalNumbers(estimates.estimatedBaseFee),
+    low: _objectSpread(_objectSpread({}, estimates.low), {}, {
+      suggestedMaxPriorityFeePerGas: normalizeGWEIDecimalNumbers(estimates.low.suggestedMaxPriorityFeePerGas),
+      suggestedMaxFeePerGas: normalizeGWEIDecimalNumbers(estimates.low.suggestedMaxFeePerGas)
+    }),
+    medium: _objectSpread(_objectSpread({}, estimates.medium), {}, {
+      suggestedMaxPriorityFeePerGas: normalizeGWEIDecimalNumbers(estimates.medium.suggestedMaxPriorityFeePerGas),
+      suggestedMaxFeePerGas: normalizeGWEIDecimalNumbers(estimates.medium.suggestedMaxFeePerGas)
+    }),
+    high: _objectSpread(_objectSpread({}, estimates.high), {}, {
+      suggestedMaxPriorityFeePerGas: normalizeGWEIDecimalNumbers(estimates.high.suggestedMaxPriorityFeePerGas),
+      suggestedMaxFeePerGas: normalizeGWEIDecimalNumbers(estimates.high.suggestedMaxFeePerGas)
+    })
+  });
+  return normalizedEstimates;
+}
+
+/**
+ * Hit the legacy MetaSwaps gasPrices estimate api and return the low, medium
+ * high values from that API.
+ */
+async function fetchLegacyGasPriceEstimates(url) {
+  const result = await get(url, {
+    referrer: url,
+    referrerPolicy: "no-referrer-when-downgrade",
+    method: "GET",
+    mode: "cors"
+  });
+  return {
+    low: result.SafeGasPrice,
+    medium: result.ProposeGasPrice,
+    high: result.FastGasPrice
+  };
+}
+function validateAddress(address, propertyName) {
+  if (!address || typeof address !== "string" || !isValidAddress(address)) {
+    throw new Error(`Invalid "${propertyName}" address: ${address} must be a valid string.`);
+  }
+}
+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.`);
+  }
+  let data;
+  if (typeof messageData.data === "object") {
+    data = messageData.data;
+  } else {
+    try {
+      data = JSON.parse(messageData.data);
+    } catch (e) {
+      throw new Error("Data must be passed as a valid JSON string.");
+    }
+  }
+  if (!currentChainId) {
+    throw new Error("Current chainId cannot be null or undefined.");
+  }
+  let {
+    chainId
+  } = data.domain;
+  if (chainId) {
+    if (typeof chainId === "string") {
+      chainId = parseInt(chainId, chainId.startsWith("0x") ? 16 : 10);
+    }
+    const activeChainId = parseInt(currentChainId, 16);
+    if (Number.isNaN(activeChainId)) {
+      throw new Error(`Cannot sign messages for chainId "${chainId}", because Web3Auth is switching networks.`);
+    }
+    if (chainId !== activeChainId) {
+      throw new Error(`Provided chainId "${chainId}" must match the active chainId "${activeChainId}"`);
+    }
+  }
+}
+
+export { fetchEip1159GasEstimates, fetchLegacyGasPriceEstimates, normalizeGWEIDecimalNumbers, validateAddress, validateTypedSignMessageDataV4 };

package/dist/lib.esm/providers/ethereum-provider/providers/privateKeyProviders/ethPrivatekeyUtils.js

@@ -0,0 +1,104 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { isHexString, stripHexPrefix, addHexPrefix, privateToAddress } from '@ethereumjs/util';
+import { signMessage } from '@toruslabs/base-controllers';
+import { getPublicCompressed } from '@toruslabs/eccrypto';
+import { providerErrors } from '@web3auth/auth';
+import { SigningKey, hashMessage } from 'ethers';
+import { validateTypedData, hashTypedData } from 'viem';
+import { log } from '../../../../base/loglevel.js';
+import { validateTypedSignMessageDataV4 } from './TransactionFormatter/utils.js';
+
+async function signTx(txParams, privKey, txFormatter) {
+  const finalTxParams = await txFormatter.formatTransaction(txParams);
+  const {
+    Transaction
+  } = await import('ethers');
+  const ethTx = Transaction.from(_objectSpread(_objectSpread({}, finalTxParams), {}, {
+    from: undefined // from is already calculated inside Transaction.from and is not allowed to be passed in
+  }));
+  const signKey = new SigningKey(addHexPrefix(privKey));
+  ethTx.signature = signKey.sign(ethTx.unsignedHash);
+  return ethTx.serialized;
+}
+function getProviderHandlers({
+  txFormatter,
+  privKey,
+  keyExportEnabled,
+  getProviderEngineProxy
+}) {
+  return {
+    getAccounts: async _ => [`0x${Buffer.from(privateToAddress(Buffer.from(privKey, "hex"))).toString("hex")}`],
+    getPublicKey: async _ => {
+      const publicKey = getPublicCompressed(Buffer.from(stripHexPrefix(privKey), "hex"));
+      return `0x${Buffer.from(publicKey).toString("hex")}`;
+    },
+    getPrivateKey: async _ => {
+      if (!keyExportEnabled) throw providerErrors.custom({
+        message: "Private key export is disabled",
+        code: 4902
+      });
+      return privKey;
+    },
+    processTransaction: async (txParams, _) => {
+      const providerEngineProxy = getProviderEngineProxy();
+      if (!providerEngineProxy) throw providerErrors.custom({
+        message: "Provider is not initialized",
+        code: 4902
+      });
+      if (txParams.input && !txParams.data) txParams.data = addHexPrefix(txParams.input);
+      const serializedTx = await signTx(txParams, privKey, txFormatter);
+      const txHash = await providerEngineProxy.request({
+        method: "eth_sendRawTransaction",
+        params: [serializedTx]
+      });
+      return txHash;
+    },
+    processSignTransaction: async (txParams, _) => {
+      const providerEngineProxy = getProviderEngineProxy();
+      if (!providerEngineProxy) throw providerErrors.custom({
+        message: "Provider is not initialized",
+        code: 4902
+      });
+      if (txParams.input && !txParams.data) txParams.data = addHexPrefix(txParams.input);
+      const serializedTx = await signTx(txParams, privKey, txFormatter);
+      return serializedTx;
+    },
+    processEthSignMessage: async (msgParams, _) => {
+      const rawMessageSig = signMessage(privKey, msgParams.data);
+      return rawMessageSig;
+    },
+    processPersonalMessage: async (msgParams, _) => {
+      const privKeyBuffer = Buffer.from(privKey, "hex");
+      const ethersKey = new SigningKey(privKeyBuffer);
+      const {
+        data
+      } = msgParams;
+      // we need to check if the data is hex or not
+      // For historical reasons, you must submit the message to sign in hex-encoded UTF-8.
+      // https://docs.metamask.io/wallet/how-to/sign-data/#use-personal_sign
+      const message = isHexString(data) ? Buffer.from(stripHexPrefix(data), "hex") : Buffer.from(data);
+      const signature = ethersKey.sign(hashMessage(message));
+      return signature.serialized;
+    },
+    processTypedMessageV4: async (msgParams, _) => {
+      log.debug("processTypedMessageV4", msgParams);
+      const privKeyBuffer = Buffer.from(privKey, "hex");
+      const providerEngineProxy = getProviderEngineProxy();
+      if (!providerEngineProxy) throw providerErrors.custom({
+        message: "Provider is not initialized",
+        code: 4902
+      });
+      const chainId = await providerEngineProxy.request({
+        method: "eth_chainId"
+      });
+      await validateTypedSignMessageDataV4(msgParams, chainId);
+      const data = typeof msgParams.data === "string" ? JSON.parse(msgParams.data) : msgParams.data;
+      const ethersPrivateKey = new SigningKey(privKeyBuffer);
+      validateTypedData(data);
+      const signature = ethersPrivateKey.sign(hashTypedData(data)).serialized;
+      return signature;
+    }
+  };
+}
+
+export { getProviderHandlers };

package/dist/lib.esm/providers/ethereum-provider/providers/utils.js

@@ -0,0 +1,24 @@
+import { stripHexPrefix, addHexPrefix } from '@ethereumjs/util';
+import { BigNumber } from 'bignumber.js';
+import BN from 'bn.js';
+
+function bnLessThan(a, b) {
+  if (a === null || a === undefined || b === null || b === undefined) {
+    return null;
+  }
+  return new BigNumber(a, 10).lt(b, 10);
+}
+function bnToHex(inputBn) {
+  return addHexPrefix(inputBn.toString(16));
+}
+function hexToBn(inputHex) {
+  if (BN.isBN(inputHex)) return inputHex;
+  return new BN(stripHexPrefix(inputHex), 16);
+}
+function BnMultiplyByFraction(targetBN, numerator, denominator) {
+  const numberBN = new BN(numerator);
+  const denomBN = new BN(denominator);
+  return targetBN.mul(numberBN).div(denomBN);
+}
+
+export { BnMultiplyByFraction, bnLessThan, bnToHex, hexToBn };

package/dist/lib.esm/providers/ethereum-provider/rpc/ethRpcMiddlewares.js

@@ -0,0 +1,71 @@
+import { mergeMiddleware, createScaffoldMiddleware, createAsyncMiddleware, rpcErrors } from '@web3auth/auth';
+import { createWalletMiddleware } from './walletMidddleware.js';
+
+function createEthMiddleware(providerHandlers) {
+  const {
+    getAccounts,
+    getPrivateKey,
+    getPublicKey,
+    processTransaction,
+    processSignTransaction,
+    processEthSignMessage,
+    processTypedMessageV4,
+    processPersonalMessage
+  } = providerHandlers;
+  const ethMiddleware = mergeMiddleware([createScaffoldMiddleware({
+    eth_syncing: false
+  }), createWalletMiddleware({
+    getAccounts,
+    getPrivateKey,
+    getPublicKey,
+    processTransaction,
+    processEthSignMessage,
+    processSignTransaction,
+    processTypedMessageV4,
+    processPersonalMessage
+  })]);
+  return ethMiddleware;
+}
+function createEthChainSwitchMiddleware({
+  addChain,
+  switchChain
+}) {
+  async function addNewChain(req, res) {
+    var _req$params;
+    const chainParams = (_req$params = req.params) !== null && _req$params !== void 0 && _req$params.length ? req.params[0] : undefined;
+    if (!chainParams) throw rpcErrors.invalidParams("Missing chain params");
+    if (!chainParams.chainId) throw rpcErrors.invalidParams("Missing chainId in chainParams");
+    if (!chainParams.rpcUrls || chainParams.rpcUrls.length === 0) throw rpcErrors.invalidParams("Missing rpcUrls in chainParams");
+    if (!chainParams.nativeCurrency) throw rpcErrors.invalidParams("Missing nativeCurrency in chainParams");
+    res.result = await addChain(chainParams);
+  }
+  async function updateChain(req, res) {
+    var _req$params2;
+    const chainParams = (_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.length ? req.params[0] : undefined;
+    if (!chainParams) throw rpcErrors.invalidParams("Missing chainId");
+    res.result = await switchChain(chainParams);
+  }
+  return createScaffoldMiddleware({
+    wallet_addEthereumChain: createAsyncMiddleware(addNewChain),
+    wallet_switchEthereumChain: createAsyncMiddleware(updateChain)
+  });
+}
+
+// #region account middlewares
+function createEthAccountMiddleware({
+  updatePrivatekey
+}) {
+  async function updateAccount(req, res) {
+    var _req$params3;
+    const accountParams = (_req$params3 = req.params) !== null && _req$params3 !== void 0 && _req$params3.length ? req.params[0] : undefined;
+    if (!(accountParams !== null && accountParams !== void 0 && accountParams.privateKey)) throw rpcErrors.invalidParams("Missing privateKey");
+    res.result = await updatePrivatekey(accountParams);
+  }
+  return createScaffoldMiddleware({
+    wallet_updateAccount: createAsyncMiddleware(updateAccount)
+  });
+}
+
+// #endregion account middlewares
+
+export { createEthAccountMiddleware, createEthChainSwitchMiddleware, createEthMiddleware };