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

package/dist/lib.esm/plugins/wallet-services-plugin/plugin.js

@@ -17,26 +17,16 @@ class WalletServicesPlugin extends SafeEventEmitter {
     _defineProperty(this, "SUPPORTED_CONNECTORS", [WALLET_CONNECTORS.AUTH]);
     _defineProperty(this, "pluginNamespace", PLUGIN_NAMESPACES.MULTICHAIN);
     _defineProperty(this, "wsEmbedInstance", void 0);
-    _defineProperty(this, "provider", null);
     _defineProperty(this, "web3auth", null);
     _defineProperty(this, "isInitialized", false);
     _defineProperty(this, "analytics", void 0);
   }
-  get proxyProvider() {
-    var _this$wsEmbedInstance;
-    return (_this$wsEmbedInstance = this.wsEmbedInstance) !== null && _this$wsEmbedInstance !== void 0 && _this$wsEmbedInstance.provider ? this.wsEmbedInstance.provider : null;
-  }
   async initWithWeb3Auth(web3auth, _whiteLabel, analytics) {
     if (this.isInitialized) return;
     if (!web3auth) throw WalletServicesPluginError.web3authRequired();
-    if (web3auth.provider && !this.SUPPORTED_CONNECTORS.includes(web3auth.connectedConnectorName)) throw WalletServicesPluginError.notInitialized();
+    if (web3auth.connection && !this.SUPPORTED_CONNECTORS.includes(web3auth.connectedConnectorName)) throw WalletServicesPluginError.notInitialized();
     const currentChainConfig = web3auth.currentChain;
     if (![CHAIN_NAMESPACES.EIP155, CHAIN_NAMESPACES.SOLANA].includes(currentChainConfig === null || currentChainConfig === void 0 ? void 0 : currentChainConfig.chainNamespace)) throw WalletServicesPluginError.unsupportedChainNamespace();
-
-    // Not connected yet to auth
-    if (web3auth.provider) {
-      this.provider = web3auth.provider;
-    }
     this.web3auth = web3auth;
     this.analytics = analytics;
 
@@ -48,23 +38,14 @@ class WalletServicesPlugin extends SafeEventEmitter {
     this.status = PLUGIN_STATUS.READY;
     this.emit(PLUGIN_EVENTS.READY);
   }
-  initWithProvider() {
-    throw new Error("Method not implemented.");
-  }
   async connect() {
     // if web3auth is being used and connected to unsupported connector throw error
     if (!this.isInitialized) throw WalletServicesPluginError.notInitialized();
     this.emit(PLUGIN_EVENTS.CONNECTING);
     this.status = PLUGIN_STATUS.CONNECTING;
-    if (!this.provider) {
-      var _this$web3auth;
-      if ((_this$web3auth = this.web3auth) !== null && _this$web3auth !== void 0 && _this$web3auth.provider) {
-        this.provider = this.web3auth.provider;
-      }
-    }
     if (!CAN_AUTHORIZE_STATUSES.includes(this.web3auth.status)) {
       throw WalletServicesPluginError.web3AuthNotConnected();
-    } else if (!this.web3auth.provider) {
+    } else if (!this.web3auth.connection) {
       throw WalletServicesPluginError.providerRequired();
     }
     try {
@@ -79,8 +60,8 @@ class WalletServicesPlugin extends SafeEventEmitter {
     }
   }
   async showWalletConnectScanner(showWalletConnectParams) {
-    var _this$wsEmbedInstance2, _this$analytics;
-    if (!((_this$wsEmbedInstance2 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance2 !== void 0 && _this$wsEmbedInstance2.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    var _this$wsEmbedInstance, _this$analytics;
+    if (!((_this$wsEmbedInstance = this.wsEmbedInstance) !== null && _this$wsEmbedInstance !== void 0 && _this$wsEmbedInstance.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
 
     // analytics
     (_this$analytics = this.analytics) === null || _this$analytics === void 0 || _this$analytics.track(ANALYTICS_EVENTS.WALLET_CONNECT_SCANNER_CLICKED, {
@@ -89,8 +70,8 @@ class WalletServicesPlugin extends SafeEventEmitter {
     return this.wsEmbedInstance.showWalletConnectScanner(showWalletConnectParams);
   }
   async showFunding(showFundingParams) {
-    var _this$wsEmbedInstance3, _this$analytics2;
-    if (!((_this$wsEmbedInstance3 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance3 !== void 0 && _this$wsEmbedInstance3.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    var _this$wsEmbedInstance2, _this$analytics2;
+    if (!((_this$wsEmbedInstance2 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance2 !== void 0 && _this$wsEmbedInstance2.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
 
     // analytics
     (_this$analytics2 = this.analytics) === null || _this$analytics2 === void 0 || _this$analytics2.track(ANALYTICS_EVENTS.WALLET_FUNDING_CLICKED, {
@@ -99,8 +80,8 @@ class WalletServicesPlugin extends SafeEventEmitter {
     return this.wsEmbedInstance.showFunding(showFundingParams);
   }
   async showCheckout(showCheckoutParams) {
-    var _this$wsEmbedInstance4, _this$analytics3;
-    if (!((_this$wsEmbedInstance4 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance4 !== void 0 && _this$wsEmbedInstance4.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    var _this$wsEmbedInstance3, _this$analytics3;
+    if (!((_this$wsEmbedInstance3 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance3 !== void 0 && _this$wsEmbedInstance3.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
 
     // analytics
     (_this$analytics3 = this.analytics) === null || _this$analytics3 === void 0 || _this$analytics3.track(ANALYTICS_EVENTS.WALLET_CHECKOUT_CLICKED, {
@@ -116,8 +97,8 @@ class WalletServicesPlugin extends SafeEventEmitter {
     return this.wsEmbedInstance.showCheckout(showCheckoutParams);
   }
   async showReceive(showReceiveParams) {
-    var _this$wsEmbedInstance5, _this$analytics4;
-    if (!((_this$wsEmbedInstance5 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance5 !== void 0 && _this$wsEmbedInstance5.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    var _this$wsEmbedInstance4, _this$analytics4;
+    if (!((_this$wsEmbedInstance4 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance4 !== void 0 && _this$wsEmbedInstance4.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
 
     // analytics
     (_this$analytics4 = this.analytics) === null || _this$analytics4 === void 0 || _this$analytics4.track(ANALYTICS_EVENTS.WALLET_RECEIVE_CLICKED, {
@@ -126,8 +107,8 @@ class WalletServicesPlugin extends SafeEventEmitter {
     return this.wsEmbedInstance.showReceive(showReceiveParams);
   }
   async showWalletUi(showWalletUiParams) {
-    var _this$wsEmbedInstance6, _this$analytics5;
-    if (!((_this$wsEmbedInstance6 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance6 !== void 0 && _this$wsEmbedInstance6.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    var _this$wsEmbedInstance5, _this$analytics5;
+    if (!((_this$wsEmbedInstance5 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance5 !== void 0 && _this$wsEmbedInstance5.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
 
     // analytics
     (_this$analytics5 = this.analytics) === null || _this$analytics5 === void 0 || _this$analytics5.track(ANALYTICS_EVENTS.WALLET_UI_CLICKED, {
@@ -137,8 +118,8 @@ class WalletServicesPlugin extends SafeEventEmitter {
     return this.wsEmbedInstance.showWalletUi(showWalletUiParams);
   }
   async showSwap(showSwapParams) {
-    var _this$wsEmbedInstance7, _this$analytics6;
-    if (!((_this$wsEmbedInstance7 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance7 !== void 0 && _this$wsEmbedInstance7.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
+    var _this$wsEmbedInstance6, _this$analytics6;
+    if (!((_this$wsEmbedInstance6 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance6 !== void 0 && _this$wsEmbedInstance6.isLoggedIn)) throw WalletServicesPluginError.walletPluginNotConnected();
 
     // analytics
     (_this$analytics6 = this.analytics) === null || _this$analytics6 === void 0 || _this$analytics6.track(ANALYTICS_EVENTS.WALLET_SWAP_CLICKED, {
@@ -151,13 +132,13 @@ class WalletServicesPlugin extends SafeEventEmitter {
     return this.wsEmbedInstance.showSwap(showSwapParams);
   }
   async cleanup() {
-    var _this$wsEmbedInstance8;
-    return (_this$wsEmbedInstance8 = this.wsEmbedInstance) === null || _this$wsEmbedInstance8 === void 0 ? void 0 : _this$wsEmbedInstance8.cleanUp();
+    var _this$wsEmbedInstance7;
+    return (_this$wsEmbedInstance7 = this.wsEmbedInstance) === null || _this$wsEmbedInstance7 === void 0 ? void 0 : _this$wsEmbedInstance7.cleanUp();
   }
   async disconnect() {
-    var _this$wsEmbedInstance9;
+    var _this$wsEmbedInstance8;
     if (this.status !== PLUGIN_STATUS.CONNECTED) throw WalletServicesPluginError.invalidSession("Wallet Services plugin is not connected");
-    if ((_this$wsEmbedInstance9 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance9 !== void 0 && _this$wsEmbedInstance9.isLoggedIn) {
+    if ((_this$wsEmbedInstance8 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance8 !== void 0 && _this$wsEmbedInstance8.isLoggedIn) {
       await this.wsEmbedInstance.logout();
     }
     this.emit(PLUGIN_EVENTS.DISCONNECTED);

package/dist/lib.esm/providers/account-abstraction-provider/index.js

@@ -1,2 +1,6 @@
-export { accountAbstractionProvider, toEoaProvider } from './providers/AccountAbstractionProvider.js';
+import { toEoaProvider, accountAbstractionProvider } from './providers/AccountAbstractionProvider.js';
 export { BiconomySmartAccount, KernelSmartAccount, MetamaskSmartAccount, NexusSmartAccount, SMART_ACCOUNT, SafeSmartAccount, TrustSmartAccount } from '@toruslabs/ethereum-controllers';
+
+
+
+export { accountAbstractionProvider, toEoaProvider };

package/dist/lib.esm/providers/account-abstraction-provider/providers/AccountAbstractionProvider.js

@@ -2,7 +2,7 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { SMART_ACCOUNT, METHOD_TYPES } from '@toruslabs/ethereum-controllers';
 export { SMART_ACCOUNT } from '@toruslabs/ethereum-controllers';
-import { JRPCEngine, providerFromEngine, providerErrors } from '@web3auth/auth';
+import { JRPCEngineV2, providerFromEngineV2, providerErrors } from '@web3auth/auth';
 import { defineChain, createPublicClient, http, createWalletClient, custom } from 'viem';
 import { createPaymasterClient, createBundlerClient } from 'viem/account-abstraction';
 import { createEoaMiddleware, providerAsMiddleware, createAaMiddleware } from '../rpc/ethRpcMiddlewares.js';
@@ -130,15 +130,15 @@ class AccountAbstractionProvider extends BaseProvider {
     });
 
     // setup rpc engine and AA middleware
-    const engine = new JRPCEngine();
     const aaMiddleware = await createAaMiddleware({
       eoaProvider,
       handlers: providerHandlers
     });
-    engine.push(aaMiddleware);
     const eoaMiddleware = providerAsMiddleware(eoaProvider);
-    engine.push(eoaMiddleware);
-    const provider = providerFromEngine(engine);
+    const engine = JRPCEngineV2.create({
+      middleware: [aaMiddleware, eoaMiddleware]
+    });
+    const provider = providerFromEngineV2(engine);
     this.updateProviderEngineProxy(provider);
     eoaProvider.once("chainChanged", chainId => {
       this.update({
@@ -251,13 +251,13 @@ const accountAbstractionProvider = async ({
 };
 const toEoaProvider = async aaProvider => {
   // derive EOA provider from AA provider
-  const engine = new JRPCEngine();
   const eoaMiddleware = await createEoaMiddleware({
     aaProvider
   });
-  engine.push(eoaMiddleware);
-  engine.push(providerAsMiddleware(aaProvider));
-  return providerFromEngine(engine);
+  const engine = JRPCEngineV2.create({
+    middleware: [eoaMiddleware, providerAsMiddleware(aaProvider)]
+  });
+  return providerFromEngineV2(engine);
 };
 
 export { accountAbstractionProvider, toEoaProvider };

package/dist/lib.esm/providers/account-abstraction-provider/providers/utils.js

@@ -1,5 +1,5 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { isHexString, addHexPrefix } from '@ethereumjs/util';
+import { isHexString, add0x } from '@toruslabs/metadata-helpers';
 import { providerErrors } from '@web3auth/auth';
 import { createWalletClient, http } from 'viem';
 import { log } from '../../../base/loglevel.js';
@@ -37,7 +37,7 @@ function getProviderHandlers({
       });
     },
     processTransaction: async txParams => {
-      if (txParams.input && !txParams.data) txParams.data = addHexPrefix(txParams.input);
+      if (txParams.input && !txParams.data) txParams.data = add0x(txParams.input);
       const {
         to,
         value,
@@ -99,7 +99,7 @@ function getProviderHandlers({
       return walletClient.signMessage({
         account: smartAccount,
         message: isHexString(message) ? {
-          raw: message
+          raw: add0x(message)
         } : message
       });
     },

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

@@ -1,6 +1,6 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { METHOD_TYPES } from '@toruslabs/ethereum-controllers';
-import { createScaffoldMiddleware, createAsyncMiddleware, rpcErrors } from '@web3auth/auth';
+import { createScaffoldMiddlewareV2, rpcErrors } from '@web3auth/auth';
 
 async function createAaMiddleware({
   eoaProvider,
@@ -45,26 +45,28 @@ async function createAaMiddleware({
       message: `Invalid parameters: must provide valid sender address.`
     });
   }
-  async function lookupAccounts(req, res) {
-    res.result = await handlers.getAccounts(req);
+  async function lookupAccounts(params) {
+    return handlers.getAccounts(params.request);
   }
-  async function fetchPrivateKey(req, res) {
+  async function fetchPrivateKey(params) {
     if (!handlers.getPrivateKey) {
       throw rpcErrors.methodNotSupported();
     }
-    res.result = await handlers.getPrivateKey(req);
+    return handlers.getPrivateKey(params.request);
   }
-  async function sendTransaction(req, res) {
+  async function sendTransaction(params) {
     if (!handlers.processTransaction) {
       throw rpcErrors.methodNotSupported();
     }
+    const req = params.request;
     const txParams = req.params[0] || {
       from: ""
     };
     txParams.from = await validateAndNormalizeKeyholder(txParams.from, req);
-    res.result = handlers.processTransaction(txParams, req);
+    return handlers.processTransaction(txParams, req);
   }
-  async function signTransaction(req, res) {
+  async function signTransaction(params) {
+    const req = params.request;
     const txParams = req.params[0] || {
       from: ""
     };
@@ -73,9 +75,10 @@ async function createAaMiddleware({
     if (txParams.from) {
       txParams.from = await normalizeSignSenderAddress(txParams.from, req);
     }
-    res.result = await handlers.processSignTransaction(txParams, req);
+    return handlers.processSignTransaction(txParams, req);
   }
-  async function ethSign(req, res) {
+  async function ethSign(params) {
+    const req = params.request;
     let msgParams = req.params;
     const extraParams = req.params[2] || {};
     if (Array.isArray(req.params)) {
@@ -89,9 +92,10 @@ async function createAaMiddleware({
       };
     }
     msgParams = _objectSpread(_objectSpread({}, extraParams), msgParams);
-    res.result = await handlers.processEthSignMessage(msgParams, req);
+    return handlers.processEthSignMessage(msgParams, req);
   }
-  async function signTypedDataV4(req, res) {
+  async function signTypedDataV4(params) {
+    const req = params.request;
     if (!(req !== null && req !== void 0 && req.params)) throw new Error("WalletMiddleware - missing params");
     let msgParams = req.params;
     if (Array.isArray(req.params)) {
@@ -104,9 +108,10 @@ async function createAaMiddleware({
         data: message
       };
     }
-    res.result = await handlers.processTypedMessageV4(msgParams, req);
+    return handlers.processTypedMessageV4(msgParams, req);
   }
-  async function personalSign(req, res) {
+  async function personalSign(params) {
+    const req = params.request;
     let msgParams = req.params;
     const extraParams = req.params[2] || {};
     if (Array.isArray(req.params)) {
@@ -131,61 +136,59 @@ async function createAaMiddleware({
       }
     }
     msgParams = _objectSpread(_objectSpread({}, extraParams), msgParams);
-    res.result = await handlers.processPersonalMessage(msgParams, req);
+    return handlers.processPersonalMessage(msgParams, req);
   }
-  async function fetchPublicKey(req, res) {
+  async function fetchPublicKey(params) {
     if (!handlers.getPublicKey) {
       throw rpcErrors.methodNotSupported();
     }
-    res.result = await handlers.getPublicKey(req);
+    return handlers.getPublicKey(params.request);
   }
-  return createScaffoldMiddleware({
+  return createScaffoldMiddlewareV2({
     // account lookups
-    eth_accounts: createAsyncMiddleware(lookupAccounts),
-    eth_requestAccounts: createAsyncMiddleware(lookupAccounts),
-    eth_private_key: createAsyncMiddleware(fetchPrivateKey),
-    private_key: createAsyncMiddleware(fetchPrivateKey),
-    eth_public_key: createAsyncMiddleware(fetchPublicKey),
-    public_key: createAsyncMiddleware(fetchPublicKey),
+    eth_accounts: lookupAccounts,
+    eth_requestAccounts: lookupAccounts,
+    eth_private_key: fetchPrivateKey,
+    private_key: fetchPrivateKey,
+    eth_public_key: fetchPublicKey,
+    public_key: fetchPublicKey,
     // tx signatures
-    eth_sendTransaction: createAsyncMiddleware(sendTransaction),
-    eth_signTransaction: createAsyncMiddleware(signTransaction),
+    eth_sendTransaction: sendTransaction,
+    eth_signTransaction: signTransaction,
     // message signatures
-    eth_sign: createAsyncMiddleware(ethSign),
-    eth_signTypedData_v4: createAsyncMiddleware(signTypedDataV4),
-    personal_sign: createAsyncMiddleware(personalSign)
+    eth_sign: ethSign,
+    eth_signTypedData_v4: signTypedDataV4,
+    personal_sign: personalSign
   });
 }
 async function createEoaMiddleware({
   aaProvider
 }) {
-  async function getAccounts(_req, res) {
+  async function getAccounts() {
     const [, eoaAddress] = await aaProvider.request({
       method: METHOD_TYPES.GET_ACCOUNTS
     });
-    res.result = [eoaAddress];
+    return [eoaAddress];
   }
-  async function requestAccounts(_req, res) {
+  async function requestAccounts() {
     const [, eoaAddress] = await aaProvider.request({
       method: METHOD_TYPES.ETH_REQUEST_ACCOUNTS
     });
-    res.result = [eoaAddress];
+    return [eoaAddress];
   }
-  return createScaffoldMiddleware({
-    eth_accounts: createAsyncMiddleware(getAccounts),
-    eth_requestAccounts: createAsyncMiddleware(requestAccounts)
+  return createScaffoldMiddlewareV2({
+    eth_accounts: getAccounts,
+    eth_requestAccounts: requestAccounts
   });
 }
 function providerAsMiddleware(provider) {
-  return async (req, res, _next, end) => {
-    // send request to provider
-    try {
-      const providerRes = await provider.request(req);
-      res.result = providerRes;
-      return end();
-    } catch (error) {
-      return end(error);
-    }
+  return async ({
+    request
+  }) => {
+    return provider.request({
+      method: request.method,
+      params: request.params
+    });
   };
 }
 

package/dist/lib.esm/providers/base-provider/CommonJRPCProvider.js

@@ -1,5 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { providerErrors, JRPCEngine, providerFromEngine } from '@web3auth/auth';
+import { providerErrors, providerFromMiddlewareV2 } from '@web3auth/auth';
 import { BaseProvider } from './baseProvider.js';
 import { createJsonRpcClient } from './jrpcClient.js';
 
@@ -23,9 +23,7 @@ class CommonJRPCProvider extends BaseProvider {
     const {
       networkMiddleware
     } = createJsonRpcClient(chain);
-    const engine = new JRPCEngine();
-    engine.push(networkMiddleware);
-    const provider = providerFromEngine(engine);
+    const provider = providerFromMiddlewareV2(networkMiddleware);
     this.updateProviderEngineProxy(provider);
     this.emit("chainChanged", chainId);
     this.emit("connect", {

package/dist/lib.esm/providers/base-provider/commonPrivateKeyProvider.js

@@ -1,5 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { JRPCEngine, providerFromEngine, createScaffoldMiddleware, createAsyncMiddleware } from '@web3auth/auth';
+import { JRPCEngineV2, providerFromEngineV2, createScaffoldMiddlewareV2 } from '@web3auth/auth';
 import { BaseProvider } from './baseProvider.js';
 
 var _CommonPrivateKeyProvider;
@@ -23,9 +23,10 @@ class CommonPrivateKeyProvider extends BaseProvider {
   }
   async setupProvider(privKey) {
     const privKeyMiddleware = this.getPrivKeyMiddleware(privKey);
-    const engine = new JRPCEngine();
-    engine.push(privKeyMiddleware);
-    const provider = providerFromEngine(engine);
+    const engine = JRPCEngineV2.create({
+      middleware: [privKeyMiddleware]
+    });
+    const provider = providerFromEngineV2(engine);
     this.updateProviderEngineProxy(provider);
   }
   async switchChain(_) {
@@ -49,15 +50,11 @@ class CommonPrivateKeyProvider extends BaseProvider {
   createPrivKeyMiddleware({
     getPrivatekey
   }) {
-    async function getPrivatekeyHandler(_, res) {
-      try {
-        res.result = await getPrivatekey();
-      } catch (error) {
-        res.error = error instanceof Error ? error.message : error;
-      }
+    async function getPrivatekeyHandler() {
+      return getPrivatekey();
     }
-    return createScaffoldMiddleware({
-      private_key: createAsyncMiddleware(getPrivatekeyHandler)
+    return createScaffoldMiddlewareV2({
+      private_key: getPrivatekeyHandler
     });
   }
 }

package/dist/lib.esm/providers/base-provider/index.js

@@ -1,5 +1,9 @@
 export { BaseProvider } from './baseProvider.js';
 export { CommonJRPCProvider } from './CommonJRPCProvider.js';
-export { CommonPrivateKeyProvider } from './commonPrivateKeyProvider.js';
-export { EIP1193_EVENTS, createRandomId } from './utils.js';
+import { CommonPrivateKeyProvider } from './commonPrivateKeyProvider.js';
+export { EIP1193_EVENTS } from './utils.js';
 export { getED25519Key } from '@web3auth/auth';
+
+
+
+export { CommonPrivateKeyProvider };

package/dist/lib.esm/providers/base-provider/jrpcClient.js

@@ -1,22 +1,22 @@
 import { createFetchMiddleware } from '@toruslabs/base-controllers';
-import { mergeMiddleware } from '@web3auth/auth';
+import { JRPCEngineV2 } from '@web3auth/auth';
 
 function createChainIdMiddleware(chainId) {
-  return (req, res, next, end) => {
-    if (req.method === "chainId") {
-      res.result = chainId;
-      return end();
-    }
-    return next();
+  return ({
+    request,
+    next
+  }) => {
+    if (request.method === "chainId") return chainId;
+    return next(request);
   };
 }
 function createProviderConfigMiddleware(providerConfig) {
-  return (req, res, next, end) => {
-    if (req.method === "provider_config") {
-      res.result = providerConfig;
-      return end();
-    }
-    return next();
+  return ({
+    request,
+    next
+  }) => {
+    if (request.method === "provider_config") return providerConfig;
+    return next(request);
   };
 }
 function createJsonRpcClient(providerConfig) {
@@ -24,14 +24,15 @@ function createJsonRpcClient(providerConfig) {
     chainId,
     rpcTarget
   } = providerConfig;
-  const fetchMiddleware = createFetchMiddleware({
-    rpcTarget
+  const engine = JRPCEngineV2.create({
+    middleware: [createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig), createFetchMiddleware({
+      rpcTarget
+    })]
   });
-  const networkMiddleware = mergeMiddleware([createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig), fetchMiddleware]);
+  const networkMiddleware = engine.asMiddleware();
   return {
-    networkMiddleware,
-    fetchMiddleware
+    networkMiddleware
   };
 }
 
-export { createChainIdMiddleware, createJsonRpcClient, createProviderConfigMiddleware };
+export { createJsonRpcClient };

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

@@ -1,7 +1,5 @@
-import getCreateRandomId from 'json-rpc-random-id';
 export { getED25519Key } from '@web3auth/auth';
 
-const createRandomId = getCreateRandomId();
 let EIP1193_EVENTS = /*#__PURE__*/function (EIP1193_EVENTS) {
   EIP1193_EVENTS["ACCOUNTS_CHANGED"] = "accountsChanged";
   EIP1193_EVENTS["CHAIN_CHANGED"] = "chainChanged";
@@ -11,4 +9,4 @@ let EIP1193_EVENTS = /*#__PURE__*/function (EIP1193_EVENTS) {
   return EIP1193_EVENTS;
 }({});
 
-export { EIP1193_EVENTS, createRandomId };
+export { EIP1193_EVENTS };

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

@@ -1,50 +1,37 @@
-import { mergeMiddleware, createScaffoldMiddleware, createAsyncMiddleware, rpcErrors } from '@web3auth/auth';
-import { createWalletMiddleware } from './walletMidddleware.js';
+import { createScaffoldMiddlewareV2, JRPCEngineV2, rpcErrors } from '@web3auth/auth';
+import { createWalletMiddlewareV2 } from './walletMiddleware.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;
+  const engine = JRPCEngineV2.create({
+    middleware: [createScaffoldMiddlewareV2({
+      eth_syncing: false
+    }), createWalletMiddlewareV2(providerHandlers)]
+  });
+  return engine.asMiddleware();
 }
 function createEthChainSwitchMiddleware({
   switchChain,
   addChain
 }) {
-  async function updateChain(req, res) {
-    var _req$params;
-    const chainParams = (_req$params = req.params) !== null && _req$params !== void 0 && _req$params.length ? req.params[0] : undefined;
+  async function walletSwitchEthereumChainHandler(params) {
+    var _request$params;
+    const request = params.request;
+    const chainParams = (_request$params = request.params) !== null && _request$params !== void 0 && _request$params.length ? request.params[0] : undefined;
     if (!chainParams) throw rpcErrors.invalidParams("Missing chainId");
-    res.result = await switchChain(chainParams);
+    await switchChain(chainParams);
+    return null;
   }
-  async function addChainConfig(req, res) {
-    var _req$params2;
-    const chainConfig = (_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.length ? req.params[0] : undefined;
+  async function walletAddEthereumChainHandler(params) {
+    var _request$params2;
+    const request = params.request;
+    const chainConfig = (_request$params2 = request.params) !== null && _request$params2 !== void 0 && _request$params2.length ? request.params[0] : undefined;
     if (!chainConfig) throw rpcErrors.invalidParams("Missing chainConfig");
-    res.result = await addChain(chainConfig);
+    await addChain(chainConfig);
+    return null;
   }
-  return createScaffoldMiddleware({
-    wallet_switchEthereumChain: createAsyncMiddleware(updateChain),
-    wallet_addEthereumChain: createAsyncMiddleware(addChainConfig)
+  return createScaffoldMiddlewareV2({
+    wallet_switchEthereumChain: walletSwitchEthereumChainHandler,
+    wallet_addEthereumChain: walletAddEthereumChainHandler
   });
 }