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

package/dist/lib.cjs/types/providers/ethereum-provider/providers/privateKeyProviders/TransactionFormatter/interfaces.d.ts

@@ -1,46 +0,0 @@
-import { GAS_ESTIMATE_TYPES, TRANSACTION_TYPES } from "./constants";
-export type LegacyGasData = {
-    low: string;
-    medium: string;
-    high: string;
-};
-export type EIP1559GasDataItem = {
-    suggestedMaxPriorityFeePerGas: string;
-    suggestedMaxFeePerGas: string;
-    minWaitTimeEstimate: number;
-    maxWaitTimeEstimate: number;
-};
-export type EthereumGasFeeEstimates = {
-    estimatedBaseFee: string;
-    low: EIP1559GasDataItem;
-    medium: EIP1559GasDataItem;
-    high: EIP1559GasDataItem;
-};
-export type EIP1159GasData = EthereumGasFeeEstimates & {
-    networkCongestion: number;
-    latestPriorityFeeRange: string[];
-    historicalPriorityFeeRange: string[];
-    historicalBaseFeeRange: string[];
-    priorityFeeTrend: string;
-    baseFeeTrend: string;
-};
-export type FallbackGasData = {
-    gasPrice: string;
-};
-export type TxType = (typeof TRANSACTION_TYPES)[keyof typeof TRANSACTION_TYPES];
-export type GasType = (typeof GAS_ESTIMATE_TYPES)[keyof typeof GAS_ESTIMATE_TYPES];
-export type GasData = {
-    gasEstimateType: string;
-    gasFeeEstimates: LegacyGasData | EthereumGasFeeEstimates | FallbackGasData;
-};
-export interface FeeHistoryResponse {
-    baseFeePerGas: string[];
-    gasUsedRatio: string[];
-    oldestBlock: string;
-    reward: string[][];
-}
-export declare enum SignTypedDataVersion {
-    V1 = "V1",
-    V3 = "V3",
-    V4 = "V4"
-}

package/dist/lib.cjs/types/providers/ethereum-provider/providers/privateKeyProviders/TransactionFormatter/utils.d.ts

@@ -1,11 +0,0 @@
-import { TypedMessageParams } from "../../../rpc/interfaces";
-import { EthereumGasFeeEstimates, LegacyGasData } from "./interfaces";
-export declare function normalizeGWEIDecimalNumbers(n: string | BigNumber): string;
-export declare function fetchEip1159GasEstimates(url: string): Promise<EthereumGasFeeEstimates>;
-/**
- * Hit the legacy MetaSwaps gasPrices estimate api and return the low, medium
- * high values from that API.
- */
-export declare function fetchLegacyGasPriceEstimates(url: string): Promise<LegacyGasData>;
-export declare function validateAddress(address: string, propertyName: string): void;
-export declare function validateTypedSignMessageDataV4(messageData: TypedMessageParams, currentChainId: string): Promise<void>;

package/dist/lib.cjs/types/providers/ethereum-provider/providers/privateKeyProviders/index.d.ts

@@ -1 +0,0 @@
-export * from "./TransactionFormatter";

package/dist/lib.cjs/types/providers/ethereum-provider/providers/utils.d.ts

@@ -1,5 +0,0 @@
-import BN from "bn.js";
-export declare function bnLessThan(a: string | number, b: string | number): boolean;
-export declare function bnToHex(inputBn: BN): `0x${string}`;
-export declare function hexToBn(inputHex: string): BN;
-export declare function BnMultiplyByFraction(targetBN: BN, numerator: number | string, denominator: number | string): BN;

package/dist/lib.cjs/types/providers/ethereum-provider/rpc/walletMidddleware.d.ts

@@ -1,3 +0,0 @@
-import { JRPCMiddleware } from "@web3auth/auth";
-import type { WalletMiddlewareOptions } from "./interfaces";
-export declare function createWalletMiddleware({ getAccounts, getPrivateKey, getPublicKey, processEthSignMessage, processPersonalMessage, processTransaction, processSignTransaction, processTypedMessageV4, }: WalletMiddlewareOptions): JRPCMiddleware<string, unknown>;

package/dist/lib.cjs/types/providers/solana-provider/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./interface";
-export * from "./providers";
-export * from "./rpc";
-export * from "./solanaWallet";

package/dist/lib.cjs/types/providers/solana-provider/interface.d.ts

@@ -1,22 +0,0 @@
-import type { Transaction, VersionedTransaction } from "@solana/web3.js";
-import { RequestArguments } from "../../base";
-export type TransactionOrVersionedTransaction = Transaction | VersionedTransaction;
-export interface ISolanaWallet {
-    publicKey?: {
-        toBytes(): Uint8Array;
-    };
-    signAndSendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
-    signTransaction?<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
-    signAllTransactions?<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<string[]>;
-    signMessage(message: string, pubKey: string): Promise<string>;
-    request<T, U>(args: RequestArguments<T>): Promise<U>;
-}
-export interface IBaseWalletProvider {
-    publicKey?: {
-        toBytes(): Uint8Array;
-    };
-    signMessage?(message: string, pubKey: string, display?: "hex" | "utf8"): Promise<string>;
-    signTransaction?(transaction: string): Promise<string>;
-    signAllTransactions?(transactions: string[]): Promise<string[]>;
-    signAndSendTransaction?(transaction: string): Promise<string>;
-}

package/dist/lib.cjs/types/providers/solana-provider/providers/index.d.ts

@@ -1 +0,0 @@
-export * from "./injectedProviders";

package/dist/lib.cjs/types/providers/solana-provider/providers/injectedProviders/base/baseInjectedProvider.d.ts

@@ -1,16 +0,0 @@
-import { JRPCMiddleware } from "@web3auth/auth";
-import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../../../providers/base-provider";
-import { ISolanaProviderHandlers } from "../../../rpc";
-export declare abstract class BaseInjectedProvider<P> extends BaseProvider<BaseProviderConfig, BaseProviderState, P> {
-    constructor({ config, state }: {
-        config: BaseProviderConfig;
-        state?: BaseProviderState;
-    });
-    switchChain(_: {
-        chainId: string;
-    }): Promise<void>;
-    setupProvider(injectedProvider: P, chainId: string): Promise<void>;
-    protected lookupNetwork(_injectedProvider: P, chainId: string): Promise<string>;
-    protected getInjectedProviderProxy(_: P): JRPCMiddleware<unknown, unknown>;
-    protected abstract getProviderHandlers(injectedProvider: P): ISolanaProviderHandlers;
-}

package/dist/lib.cjs/types/providers/solana-provider/providers/injectedProviders/base/providerHandlers.d.ts

@@ -1,3 +0,0 @@
-import { IBaseWalletProvider } from "../../../interface";
-import { ISolanaProviderHandlers } from "../../../rpc";
-export declare const getBaseProviderHandlers: (injectedProvider: IBaseWalletProvider) => ISolanaProviderHandlers;

package/dist/lib.cjs/types/providers/solana-provider/providers/injectedProviders/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./utils";
-export * from "./walletStandardProvider";

package/dist/lib.cjs/types/providers/solana-provider/providers/injectedProviders/utils.d.ts

@@ -1,3 +0,0 @@
-import { IdentifierString } from "@wallet-standard/base";
-import { CustomChainConfig } from "../../../../base";
-export declare const getSolanaChainByChainConfig: (chainConfig: CustomChainConfig) => IdentifierString;

package/dist/lib.cjs/types/providers/solana-provider/providers/injectedProviders/walletStandardProvider.d.ts

@@ -1,9 +0,0 @@
-import { type SolanaSignAndSendTransactionFeature, type SolanaSignMessageFeature, type SolanaSignTransactionFeature } from "@solana/wallet-standard-features";
-import { type WalletWithFeatures } from "@wallet-standard/base";
-import { type StandardConnectFeature, type StandardDisconnectFeature, type StandardEventsFeature } from "@wallet-standard/features";
-import { type ISolanaProviderHandlers } from "../../rpc";
-import { BaseInjectedProvider } from "./base/baseInjectedProvider";
-export type WalletStandard = WalletWithFeatures<StandardConnectFeature & StandardEventsFeature & StandardDisconnectFeature & SolanaSignAndSendTransactionFeature & SolanaSignMessageFeature & SolanaSignTransactionFeature>;
-export declare class WalletStandardProvider extends BaseInjectedProvider<WalletStandard> {
-    protected getProviderHandlers(wallet: WalletStandard): ISolanaProviderHandlers;
-}

package/dist/lib.cjs/types/providers/solana-provider/rpc/JrpcClient.d.ts

@@ -1,9 +0,0 @@
-import { Block, JRPCMiddleware } from "@web3auth/auth";
-import { CustomChainConfig } from "../../../base";
-export declare function createSolanaChainIdMiddleware(chainId: string): JRPCMiddleware<unknown, string>;
-export declare function createSolanaProviderConfigMiddleware(providerConfig: CustomChainConfig): JRPCMiddleware<unknown, CustomChainConfig>;
-export declare function createConfigMiddleware(providerConfig: CustomChainConfig): JRPCMiddleware<unknown, unknown>;
-export declare function createSolanaJsonRpcClient(providerConfig: CustomChainConfig): {
-    networkMiddleware: JRPCMiddleware<unknown, unknown>;
-    fetchMiddleware: JRPCMiddleware<string[], Block>;
-};

package/dist/lib.cjs/types/providers/solana-provider/rpc/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./interfaces";
-export * from "./JrpcClient";
-export * from "./solanaRpcMiddlewares";

package/dist/lib.cjs/types/providers/solana-provider/rpc/interfaces.d.ts

@@ -1,27 +0,0 @@
-import { JRPCRequest } from "@web3auth/auth";
-export interface ISolanaChainSwitchHandlers {
-    switchSolanaChain: (req: JRPCRequest<{
-        chainId: string;
-    }>) => Promise<void>;
-}
-export interface ISolanaProviderHandlers {
-    requestAccounts: (req: JRPCRequest<unknown>) => Promise<string[]>;
-    getAccounts: (req: JRPCRequest<unknown>) => Promise<string[]>;
-    getPublicKey: (req: JRPCRequest<unknown>) => Promise<string>;
-    getPrivateKey: (req: JRPCRequest<unknown>) => Promise<string>;
-    getSecretKey: (req: JRPCRequest<unknown>) => Promise<string>;
-    signMessage: (req: JRPCRequest<{
-        data: string;
-        from: string;
-        display?: string;
-    }>) => Promise<string>;
-    signTransaction: (req: JRPCRequest<{
-        message: string;
-    }>) => Promise<string>;
-    signAllTransactions: (req: JRPCRequest<{
-        message: string[];
-    }>) => Promise<string[]>;
-    signAndSendTransaction: (req: JRPCRequest<{
-        message: string;
-    }>) => Promise<string>;
-}

package/dist/lib.cjs/types/providers/solana-provider/rpc/solanaRpcMiddlewares.d.ts

@@ -1,20 +0,0 @@
-import { JRPCMiddleware, JRPCRequest } from "@web3auth/auth";
-import { ISolanaChainSwitchHandlers, ISolanaProviderHandlers } from "./interfaces";
-export declare function createGetAccountsMiddleware({ getAccounts, }: {
-    getAccounts: ISolanaProviderHandlers["getAccounts"];
-}): JRPCMiddleware<unknown, unknown>;
-export declare function createGetPublicKeyMiddleware({ getPublicKey, }: {
-    getPublicKey: ISolanaProviderHandlers["getPublicKey"];
-}): JRPCMiddleware<unknown, unknown>;
-export declare function createRequestAccountsMiddleware({ requestAccounts, }: {
-    requestAccounts: ISolanaProviderHandlers["requestAccounts"];
-}): JRPCMiddleware<unknown, unknown>;
-export declare function createGenericJRPCMiddleware<T, U>(targetMethod: string, handler: (req: JRPCRequest<T>) => Promise<U>): JRPCMiddleware<T, U>;
-export declare function createSolanaMiddleware(providerHandlers: ISolanaProviderHandlers): JRPCMiddleware<unknown, unknown>;
-export declare function createSolanaChainSwitchMiddleware({ switchSolanaChain }: ISolanaChainSwitchHandlers): JRPCMiddleware<unknown, unknown>;
-export interface ISolanaAccountHandlers {
-    updatePrivatekey: (req: JRPCRequest<{
-        privateKey: string;
-    }>) => Promise<void>;
-}
-export declare function createSolanaAccountMiddleware({ updatePrivatekey }: ISolanaAccountHandlers): JRPCMiddleware<unknown, unknown>;

package/dist/lib.cjs/types/providers/solana-provider/solanaWallet.d.ts

@@ -1,29 +0,0 @@
-import { IProvider, RequestArguments } from "../../base";
-import { ISolanaWallet, type TransactionOrVersionedTransaction } from "./interface";
-export declare class SolanaWallet implements ISolanaWallet {
-    provider: IProvider;
-    constructor(provider: IProvider);
-    requestAccounts(): Promise<string[]>;
-    getAccounts(): Promise<string[]>;
-    signAndSendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
-    /**
-     * Signs a transaction and returns the signature
-     * @param transaction - The transaction to sign
-     * @returns The signature of the transaction encoded in base58
-     */
-    signTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
-    /**
-     * Signs multiple transactions and returns the serialized transactions
-     * @param transactions - The transactions to sign
-     * @returns The serialized transactions encoded in base64
-     */
-    signAllTransactions<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<string[]>;
-    /**
-     * Signs a message and returns the signature
-     * @param message - The message to sign
-     * @returns The signature of the message encoded in base58
-     */
-    signMessage(message: string, pubKey: string): Promise<string>;
-    request<T, U>(args: RequestArguments<T>): Promise<U>;
-    private serializeTransaction;
-}

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

@@ -1 +0,0 @@
-export { EthereumSigningProvider } from './providers/signingProviders/EthereumSigningProvider.js';

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 };