@web3auth/no-modal 9.7.0 → 10.0.0-alpha.1

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

@@ -0,0 +1,174 @@
+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 { CHAIN_NAMESPACES } from '../../../../base/chain/IChainInterface.js';
+import { WalletInitializationError } from '../../../../base/errors/index.js';
+import { BaseProvider } from '../../../base-provider/baseProvider.js';
+import { createEthAccountMiddleware } from '../../rpc/ethRpcMiddlewares.js';
+import { getProviderHandlers } from './signingUtils.js';
+import { TransactionFormatter } from '../../../ethereum-provider/providers/privateKeyProviders/TransactionFormatter/formatter.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 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
+        });
+      }
+    };
+    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

@@ -0,0 +1,163 @@
+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 { log } from '../../../../base/loglevel.js';
+import { validateTypedSignMessageDataV4 } from '../../../ethereum-provider/providers/privateKeyProviders/TransactionFormatter/utils.js';
+import { SignTypedDataVersion } from '../../../ethereum-provider/providers/privateKeyProviders/TransactionFormatter/interfaces.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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,21 @@
+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 };