@web3auth/no-modal 10.15.0 → 11.0.0-beta.0

package/dist/lib.esm/providers/ethereum-mpc-provider/providers/signingProviders/EthereumSigningProvider.js

@@ -1,206 +0,0 @@
-import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { isHexString } from '@ethereumjs/util';
-import { providerErrors, JRPCEngine, providerFromEngine, rpcErrors } from '@web3auth/auth';
-import { createEthAccountMiddleware } from '../../rpc/ethRpcMiddlewares.js';
-import { getProviderHandlers } from './signingUtils.js';
-import { TransactionFormatter } from '../../../ethereum-provider/providers/privateKeyProviders/TransactionFormatter/formatter.js';
-import { BaseProvider } from '../../../base-provider/baseProvider.js';
-import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import { WalletInitializationError } from '../../../../base/errors/index.js';
-import { createEthMiddleware, createEthChainSwitchMiddleware } from '../../../ethereum-provider/rpc/ethRpcMiddlewares.js';
-import { createEthJsonRpcClient } from '../../../ethereum-provider/rpc/jrpcClient.js';
-
-var _EthereumSigningProvider;
-class EthereumSigningProvider extends BaseProvider {
-  constructor({
-    config,
-    state
-  }) {
-    super({
-      config: {
-        chain: _objectSpread(_objectSpread({}, config.chain), {}, {
-          chainNamespace: CHAIN_NAMESPACES.EIP155 // TODO: is this needed ?
-        }),
-        chains: config.chains
-      },
-      state
-    });
-    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", CHAIN_NAMESPACES.EIP155);
-  }
-  async enable() {
-    if (!this.state.signMethods) throw providerErrors.custom({
-      message: "signMethods are not found in state, plz pass it in constructor state param",
-      code: 4902
-    });
-    await this.setupProvider(this.state.signMethods, this.chainId);
-    return this._providerEngineProxy.request({
-      method: "eth_accounts"
-    });
-  }
-  async setupProvider(params, chainId) {
-    const {
-      sign,
-      getPublic
-    } = params;
-    const chain = this.getChain(chainId);
-    const {
-      chainNamespace
-    } = chain;
-    if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
-    const txFormatter = new TransactionFormatter({
-      getProviderEngineProxy: this.getProviderEngineProxy.bind(this)
-    });
-    const providerHandlers = getProviderHandlers({
-      txFormatter,
-      sign,
-      getPublic,
-      getProviderEngineProxy: this.getProviderEngineProxy.bind(this)
-    });
-    const ethMiddleware = createEthMiddleware(providerHandlers);
-    const chainSwitchMiddleware = this.getChainSwitchMiddleware();
-    const engine = new JRPCEngine();
-    // Not a partial anymore because of checks in ctor
-    const {
-      networkMiddleware
-    } = createEthJsonRpcClient(chain);
-    engine.push(ethMiddleware);
-    engine.push(chainSwitchMiddleware);
-    engine.push(this.getAccountMiddleware());
-    engine.push(networkMiddleware);
-    const provider = providerFromEngine(engine);
-    this.updateProviderEngineProxy(provider);
-    await txFormatter.init();
-    await this.lookupNetwork(params, chainId);
-    this.state.signMethods = {
-      sign,
-      getPublic
-    };
-    this.emit("chainChanged", chainId);
-    this.emit("connect", {
-      chainId
-    });
-    this.update({
-      chainId
-    });
-  }
-  async updateAccount(params) {
-    if (!this._providerEngineProxy) throw providerErrors.custom({
-      message: "Provider is not initialized",
-      code: 4902
-    });
-    const currentSignMethods = this.state.signMethods;
-    if (!currentSignMethods) {
-      throw providerErrors.custom({
-        message: "signing methods are unavailable ",
-        code: 4092
-      });
-    }
-    const currentPubKey = (await currentSignMethods.getPublic()).toString("hex");
-    const updatePubKey = (await params.signMethods.getPublic()).toString("hex");
-    if (currentPubKey !== updatePubKey) {
-      await this.setupProvider(params.signMethods, this.chainId);
-      const accounts = await this._providerEngineProxy.request({
-        method: "eth_accounts"
-      });
-      this.emit("accountsChanged", accounts);
-    }
-  }
-  async switchChain(params) {
-    if (!this._providerEngineProxy) throw providerErrors.custom({
-      message: "Provider is not initialized",
-      code: 4902
-    });
-    if (!this.state.signMethods) {
-      throw providerErrors.custom({
-        message: "sign methods are undefined",
-        code: 4902
-      });
-    }
-    if (params.chainId === this.chainId) {
-      return;
-    }
-    this.update({
-      chainId: "loading"
-    });
-    await this.setupProvider(this.state.signMethods, params.chainId);
-  }
-  async addChain(chainConfig) {
-    if (!this._providerEngineProxy) throw providerErrors.custom({
-      message: "Provider is not initialized",
-      code: 4902
-    });
-    if (!this.state.signMethods) {
-      throw providerErrors.custom({
-        message: "sign methods are undefined",
-        code: 4902
-      });
-    }
-    // find existing chain config with the same chainId
-    const existingChain = this.config.chains.find(chain => chain.chainId === chainConfig.chainId);
-    if (existingChain) {
-      return;
-    }
-    // add the chain config to the config
-    this.config.chains.push({
-      chainId: chainConfig.chainId,
-      displayName: chainConfig.chainName,
-      rpcTarget: chainConfig.rpcUrls[0],
-      chainNamespace: CHAIN_NAMESPACES.EIP155,
-      blockExplorerUrl: chainConfig.blockExplorerUrls[0],
-      logo: chainConfig.iconUrls[0],
-      tickerName: chainConfig.nativeCurrency.name,
-      ticker: chainConfig.nativeCurrency.symbol,
-      decimals: chainConfig.nativeCurrency.decimals
-    });
-  }
-  async lookupNetwork(_, chainId) {
-    if (!this._providerEngineProxy) throw providerErrors.custom({
-      message: "Provider is not initialized",
-      code: 4902
-    });
-    if (!chainId) throw rpcErrors.invalidParams("chainId is required while lookupNetwork");
-    const network = await this._providerEngineProxy.request({
-      method: "net_version",
-      params: []
-    });
-    const finalNetwork = isHexString(network) ? parseInt(network, 16) : parseInt(network, 10);
-    if (parseInt(chainId, 16) !== finalNetwork) throw providerErrors.chainDisconnected(`Invalid network, net_version is: ${network}`);
-    return network;
-  }
-  getChainSwitchMiddleware() {
-    const chainSwitchHandlers = {
-      switchChain: async params => {
-        const {
-          chainId
-        } = params;
-        await this.switchChain({
-          chainId
-        });
-      },
-      addChain: async params => {
-        await this.addChain(params);
-      }
-    };
-    const chainSwitchMiddleware = createEthChainSwitchMiddleware(chainSwitchHandlers);
-    return chainSwitchMiddleware;
-  }
-  getAccountMiddleware() {
-    const accountHandlers = {
-      };
-    return createEthAccountMiddleware(accountHandlers);
-  }
-}
-_EthereumSigningProvider = EthereumSigningProvider;
-_defineProperty(EthereumSigningProvider, "getProviderInstance", async params => {
-  const providerFactory = new _EthereumSigningProvider({
-    config: {
-      chain: params.chain,
-      chains: params.chains
-    }
-  });
-  await providerFactory.setupProvider(params.signMethods, params.chain.chainId);
-  return providerFactory;
-});
-
-export { EthereumSigningProvider };

package/dist/lib.esm/providers/ethereum-mpc-provider/providers/signingProviders/signingUtils.js

@@ -1,163 +0,0 @@
-import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { publicToAddress, toBytes, isHexString, stripHexPrefix, intToBytes } from '@ethereumjs/util';
-import { concatSig } from '@toruslabs/base-controllers';
-import { providerErrors } from '@web3auth/auth';
-import { hashMessage, Signature } from 'ethers';
-import { validateTypedData, hexToBytes, hashTypedData } from 'viem';
-import { validateTypedSignMessageDataV4 } from '../../../ethereum-provider/providers/privateKeyProviders/TransactionFormatter/utils.js';
-import { SignTypedDataVersion } from '../../../ethereum-provider/providers/privateKeyProviders/TransactionFormatter/interfaces.js';
-import { log } from '../../../../base/loglevel.js';
-
-async function signTx(txParams, sign, txFormatter) {
-  const {
-    Transaction
-  } = await import('ethers');
-  const finalTxParams = await txFormatter.formatTransaction(txParams);
-  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 msgHash = stripHexPrefix(ethTx.unsignedHash);
-  const vrs = await sign(Buffer.from(msgHash, "hex"));
-  let {
-    v
-  } = vrs;
-  const {
-    r,
-    s
-  } = vrs;
-
-  // mpc-core-kit workaround (revert back to 0/1)
-  if (v > 1) {
-    v = v - 27;
-  }
-
-  // addSignature will handle the v value
-  const tx = ethTx;
-  tx.signature = Signature.from({
-    v,
-    r: `0x${r.toString("hex")}`,
-    s: `0x${s.toString("hex")}`
-  });
-  return tx.serialized;
-}
-async function signMessage(sign, data) {
-  const message = stripHexPrefix(data);
-  const msgSig = await sign(Buffer.from(message, "hex"));
-  let modifiedV = msgSig.v;
-  if (modifiedV <= 1) {
-    modifiedV = modifiedV + 27;
-  }
-  const rawMsgSig = concatSig(Buffer.from(intToBytes(modifiedV)), msgSig.r, msgSig.s);
-  return rawMsgSig;
-}
-async function personalSign(sign, data) {
-  if (data === null || data === undefined) {
-    throw new Error("Missing data parameter");
-  }
-  // 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 msgHash = hashMessage(message);
-  const prefix = Buffer.from(`\u0019Ethereum Signed Message:\n${message.length}`, "utf-8");
-  const sig = await sign(Buffer.from(msgHash.slice(2), "hex"), Buffer.concat([prefix, message]));
-  let modifiedV = sig.v;
-  if (modifiedV <= 1) {
-    modifiedV = modifiedV + 27;
-  }
-  const serialized = concatSig(Buffer.from(toBytes(modifiedV)), sig.r, sig.s);
-  return serialized;
-}
-function validateVersion(version, allowedVersions) {
-  if (!Object.keys(SignTypedDataVersion).includes(version)) {
-    throw new Error(`Invalid version: '${version}'`);
-  }
-}
-async function signTypedData(sign, data, version) {
-  validateVersion(version); // Note: this is intentional;
-  if (data === null || data === undefined) {
-    throw new Error("Missing data parameter");
-  }
-  const message = typeof data === "string" ? JSON.parse(data) : data;
-  validateTypedData(message);
-  const {
-    v,
-    r,
-    s
-  } = await sign(Buffer.from(hexToBytes(hashTypedData(message))));
-  let modifiedV = v;
-  if (modifiedV <= 1) {
-    modifiedV = modifiedV + 27;
-  }
-  return concatSig(Buffer.from(toBytes(modifiedV)), r, s);
-}
-function getProviderHandlers({
-  txFormatter,
-  sign,
-  getPublic,
-  getProviderEngineProxy
-}) {
-  return {
-    getAccounts: async _ => {
-      const pubKey = await getPublic();
-      return [`0x${Buffer.from(publicToAddress(pubKey)).toString("hex")}`];
-    },
-    getPrivateKey: async _ => {
-      throw providerErrors.custom({
-        message: "MPC Provider cannot return private key",
-        code: 4902
-      });
-    },
-    getPublicKey: async _ => {
-      const pubKey = await getPublic();
-      return `0x${pubKey.toString("hex")}`;
-    },
-    processTransaction: async (txParams, _) => {
-      const providerEngineProxy = getProviderEngineProxy();
-      if (!providerEngineProxy) throw providerErrors.custom({
-        message: "Provider is not initialized",
-        code: 4902
-      });
-      const serializedTxn = await signTx(txParams, sign, txFormatter);
-      const txHash = await providerEngineProxy.request({
-        method: "eth_sendRawTransaction",
-        params: [serializedTxn]
-      });
-      return txHash;
-    },
-    processSignTransaction: async (txParams, _) => {
-      const providerEngineProxy = getProviderEngineProxy();
-      if (!providerEngineProxy) throw providerErrors.custom({
-        message: "Provider is not initialized",
-        code: 4902
-      });
-      const serializedTxn = await signTx(txParams, sign, txFormatter);
-      return serializedTxn;
-    },
-    processEthSignMessage: async (msgParams, _) => {
-      const rawMessageSig = signMessage(sign, msgParams.data);
-      return rawMessageSig;
-    },
-    processPersonalMessage: async (msgParams, _) => {
-      const sig = personalSign(sign, msgParams.data);
-      return sig;
-    },
-    processTypedMessageV4: async (msgParams, _) => {
-      log.debug("processTypedMessageV4", msgParams);
-      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 sig = signTypedData(sign, data, SignTypedDataVersion.V4);
-      return sig;
-    }
-  };
-}
-
-export { getProviderHandlers };

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

@@ -1,20 +0,0 @@
-import { createScaffoldMiddleware, createAsyncMiddleware, rpcErrors } from '@web3auth/auth';
-
-// #region account middlewares
-function createEthAccountMiddleware({
-  updatePrivatekey
-}) {
-  async function updateAccount(req, res) {
-    var _req$params;
-    const accountParams = (_req$params = req.params) !== null && _req$params !== void 0 && _req$params.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 };

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

@@ -1,85 +0,0 @@
-import { stripHexPrefix } from '@ethereumjs/util';
-import { BigNumber } from 'bignumber.js';
-
-// Big Number Constants
-const BIG_NUMBER_WEI_MULTIPLIER = new BigNumber("1e18");
-const BIG_NUMBER_GWEI_MULTIPLIER = new BigNumber("1e9");
-const BIG_NUMBER_ETH_MULTIPLIER = new BigNumber("1");
-
-// Setter Maps
-const toBigNumber = {
-  hex: n => typeof n === "string" ? new BigNumber(stripHexPrefix(n), 16) : new BigNumber(n, 16),
-  dec: n => new BigNumber(n, 10)
-};
-const toNormalizedDenomination = {
-  WEI: bigNumber => bigNumber.div(BIG_NUMBER_WEI_MULTIPLIER),
-  GWEI: bigNumber => bigNumber.div(BIG_NUMBER_GWEI_MULTIPLIER),
-  ETH: bigNumber => bigNumber.div(BIG_NUMBER_ETH_MULTIPLIER)
-};
-const toSpecifiedDenomination = {
-  WEI: bigNumber => bigNumber.times(BIG_NUMBER_WEI_MULTIPLIER).dp(0, BigNumber.ROUND_HALF_UP),
-  GWEI: bigNumber => bigNumber.times(BIG_NUMBER_GWEI_MULTIPLIER).dp(9, BigNumber.ROUND_HALF_UP),
-  ETH: bigNumber => bigNumber.times(BIG_NUMBER_ETH_MULTIPLIER).dp(9, BigNumber.ROUND_HALF_UP)
-};
-const baseChange = {
-  hex: n => n.toString(16),
-  dec: n => new BigNumber(n).toString(10)
-};
-const converter = params => {
-  const {
-    value,
-    fromNumericBase,
-    fromDenomination,
-    toNumericBase,
-    toDenomination,
-    numberOfDecimals
-  } = params;
-  let convertedValue = toBigNumber[fromNumericBase](value);
-  if (fromDenomination) {
-    convertedValue = toNormalizedDenomination[fromDenomination](convertedValue);
-  }
-  if (toDenomination) {
-    convertedValue = toSpecifiedDenomination[toDenomination](convertedValue);
-  }
-  if (numberOfDecimals) {
-    convertedValue = convertedValue.dp(numberOfDecimals, BigNumber.ROUND_HALF_DOWN);
-  }
-  if (toNumericBase) {
-    convertedValue = baseChange[toNumericBase](convertedValue);
-  }
-  return convertedValue;
-};
-const conversionUtil = (value, {
-  fromNumericBase = "hex",
-  toNumericBase,
-  fromDenomination,
-  toDenomination,
-  numberOfDecimals
-}) => {
-  return converter({
-    fromNumericBase,
-    toNumericBase,
-    fromDenomination,
-    toDenomination,
-    numberOfDecimals,
-    value: value || "0"
-  });
-};
-function decGWEIToHexWEI(decGWEI) {
-  return conversionUtil(decGWEI, {
-    fromNumericBase: "dec",
-    toNumericBase: "hex",
-    fromDenomination: "GWEI",
-    toDenomination: "WEI"
-  });
-}
-function hexWEIToDecGWEI(decGWEI) {
-  return conversionUtil(decGWEI, {
-    fromNumericBase: "hex",
-    toNumericBase: "dec",
-    fromDenomination: "WEI",
-    toDenomination: "GWEI"
-  });
-}
-
-export { conversionUtil, decGWEIToHexWEI, hexWEIToDecGWEI };

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

@@ -1,21 +0,0 @@
-const LegacyGasAPIEndpoint = "https://gas-api.metaswap.codefi.network/networks/<chain_id>/gasPrices";
-const EIP1559APIEndpoint = "https://gas-api.metaswap.codefi.network/networks/<chain_id>/suggestedGasFees";
-const TRANSACTION_ENVELOPE_TYPES = {
-  LEGACY: "0x0",
-  ACCESS_LIST: "0x1",
-  FEE_MARKET: "0x2"
-};
-const TRANSACTION_TYPES = {
-  SENT_ETHER: "sentEther",
-  CONTRACT_INTERACTION: "contractInteraction",
-  DEPLOY_CONTRACT: "contractDeployment",
-  STANDARD_TRANSACTION: "transaction"
-};
-const GAS_ESTIMATE_TYPES = {
-  FEE_MARKET: "fee-market",
-  LEGACY: "legacy",
-  ETH_GASPRICE: "eth_gasPrice",
-  NONE: "none"
-};
-
-export { EIP1559APIEndpoint, GAS_ESTIMATE_TYPES, LegacyGasAPIEndpoint, TRANSACTION_ENVELOPE_TYPES, TRANSACTION_TYPES };