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

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

@@ -1,60 +1,39 @@
 'use strict';
 
 var auth = require('@web3auth/auth');
-var walletMidddleware = require('./walletMidddleware.js');
+var walletMiddleware = require('./walletMiddleware.js');
 
 function createEthMiddleware(providerHandlers) {
-  const {
-    getAccounts,
-    getPrivateKey,
-    getPublicKey,
-    processTransaction,
-    processSignTransaction,
-    processEthSignMessage,
-    processTypedMessageV4,
-    processPersonalMessage,
-    processGetCapabilities,
-    processSendCalls,
-    processGetCallsStatus,
-    processShowCallsStatus
-  } = providerHandlers;
-  const ethMiddleware = auth.mergeMiddleware([auth.createScaffoldMiddleware({
-    eth_syncing: false
-  }), walletMidddleware.createWalletMiddleware({
-    getAccounts,
-    getPrivateKey,
-    getPublicKey,
-    processTransaction,
-    processEthSignMessage,
-    processSignTransaction,
-    processTypedMessageV4,
-    processPersonalMessage,
-    processGetCapabilities,
-    processSendCalls,
-    processGetCallsStatus,
-    processShowCallsStatus
-  })]);
-  return ethMiddleware;
+  const engine = auth.JRPCEngineV2.create({
+    middleware: [auth.createScaffoldMiddlewareV2({
+      eth_syncing: false
+    }), walletMiddleware.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 auth.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 auth.rpcErrors.invalidParams("Missing chainConfig");
-    res.result = await addChain(chainConfig);
+    await addChain(chainConfig);
+    return null;
   }
-  return auth.createScaffoldMiddleware({
-    wallet_switchEthereumChain: auth.createAsyncMiddleware(updateChain),
-    wallet_addEthereumChain: auth.createAsyncMiddleware(addChainConfig)
+  return auth.createScaffoldMiddlewareV2({
+    wallet_switchEthereumChain: walletSwitchEthereumChainHandler,
+    wallet_addEthereumChain: walletAddEthereumChainHandler
   });
 }
 

package/dist/lib.cjs/providers/ethereum-provider/rpc/jrpcClient.js

@@ -4,21 +4,21 @@ var baseControllers = require('@toruslabs/base-controllers');
 var auth = require('@web3auth/auth');
 
 function createEthChainIdMiddleware(chainId) {
-  return (req, res, next, end) => {
-    if (req.method === "eth_chainId") {
-      res.result = chainId;
-      return end();
-    }
-    return next();
+  return ({
+    request,
+    next
+  }) => {
+    if (request.method === "eth_chainId") return chainId;
+    return next(request);
   };
 }
 function createEthProviderConfigMiddleware(providerConfig) {
-  return (req, res, next, end) => {
-    if (req.method === "eth_provider_config") {
-      res.result = providerConfig;
-      return end();
-    }
-    return next();
+  return ({
+    request,
+    next
+  }) => {
+    if (request.method === "eth_provider_config") return providerConfig;
+    return next(request);
   };
 }
 function createEthJsonRpcClient(providerConfig) {
@@ -26,16 +26,15 @@ function createEthJsonRpcClient(providerConfig) {
     chainId,
     rpcTarget
   } = providerConfig;
-  const fetchMiddleware = baseControllers.createFetchMiddleware({
-    rpcTarget
+  const engine = auth.JRPCEngineV2.create({
+    middleware: [createEthChainIdMiddleware(chainId), createEthProviderConfigMiddleware(providerConfig), baseControllers.createFetchMiddleware({
+      rpcTarget
+    })]
   });
-  const networkMiddleware = auth.mergeMiddleware([createEthChainIdMiddleware(chainId), createEthProviderConfigMiddleware(providerConfig), fetchMiddleware]);
+  const networkMiddleware = engine.asMiddleware();
   return {
-    networkMiddleware,
-    fetchMiddleware
+    networkMiddleware
   };
 }
 
-exports.createEthChainIdMiddleware = createEthChainIdMiddleware;
 exports.createEthJsonRpcClient = createEthJsonRpcClient;
-exports.createEthProviderConfigMiddleware = createEthProviderConfigMiddleware;

package/dist/lib.cjs/providers/ethereum-provider/rpc/walletMiddleware.js

@@ -0,0 +1,200 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var auth = require('@web3auth/auth');
+var viem = require('viem');
+
+function createWalletMiddlewareV2({
+  getAccounts,
+  getPrivateKey,
+  getPublicKey,
+  processEthSignMessage,
+  processPersonalMessage,
+  processTransaction,
+  processSignTransaction,
+  processTypedMessageV4,
+  processGetCapabilities,
+  processSendCalls,
+  processGetCallsStatus,
+  processShowCallsStatus
+}) {
+  if (!getAccounts) throw new Error("opts.getAccounts is required");
+  async function validateAndNormalizeKeyholder(address, req) {
+    if (typeof address === "string" && address.length > 0) {
+      const accounts = await getAccounts(req);
+      const normalizedAddress = address.toLowerCase();
+      if (accounts.map(a => a.toLowerCase()).includes(normalizedAddress)) return normalizedAddress;
+    }
+    throw auth.rpcErrors.invalidParams({
+      message: `Invalid parameters: must provide an Ethereum address.`
+    });
+  }
+  // Account lookups
+  function ethAccountsHandler(p) {
+    return getAccounts(p.request);
+  }
+  // Tx signatures
+  async function ethSendTransactionHandler(p) {
+    var _req$params$, _req$params;
+    if (!processTransaction) throw auth.rpcErrors.methodNotSupported();
+    const req = p.request;
+    const txParams = (_req$params$ = (_req$params = req.params) === null || _req$params === void 0 ? void 0 : _req$params[0]) !== null && _req$params$ !== void 0 ? _req$params$ : {
+      from: ""
+    };
+    txParams.from = await validateAndNormalizeKeyholder(txParams.from, req);
+    return processTransaction(txParams, req);
+  }
+  async function ethSignTransactionHandler(p) {
+    var _req$params$2, _req$params2;
+    if (!processSignTransaction) throw auth.rpcErrors.methodNotSupported();
+    const req = p.request;
+    const txParams = (_req$params$2 = (_req$params2 = req.params) === null || _req$params2 === void 0 ? void 0 : _req$params2[0]) !== null && _req$params$2 !== void 0 ? _req$params$2 : {
+      from: ""
+    };
+    txParams.from = await validateAndNormalizeKeyholder(txParams.from, req);
+    return processSignTransaction(txParams, req);
+  }
+  // Message signatures
+  async function ethSignHandler(p) {
+    if (!processEthSignMessage) throw auth.rpcErrors.methodNotSupported();
+    const req = p.request;
+    let msgParams;
+    if (Array.isArray(req.params)) {
+      if (req.params.length !== 2) throw new Error(`WalletMiddleware - incorrect params for eth_sign. expected [address, message]`);
+      const [address, message] = req.params;
+      msgParams = {
+        from: address,
+        data: message
+      };
+    } else {
+      var _req$params3;
+      msgParams = (_req$params3 = req.params) !== null && _req$params3 !== void 0 ? _req$params3 : {
+        from: "",
+        data: ""
+      };
+    }
+    return processEthSignMessage(msgParams, req);
+  }
+  async function ethSignTypedDataV4Handler(p) {
+    if (!processTypedMessageV4) throw auth.rpcErrors.methodNotSupported();
+    const req = p.request;
+    if (!(req !== null && req !== void 0 && req.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams;
+    if (Array.isArray(req.params)) {
+      if (req.params.length !== 2) throw new Error(`WalletMiddleware - incorrect params for eth_signTypedData_v4. expected [address, typedData]`);
+      const [address, message] = req.params;
+      msgParams = {
+        from: address,
+        data: message
+      };
+    } else {
+      msgParams = req.params;
+    }
+    return processTypedMessageV4(msgParams, req);
+  }
+  async function personalSignHandler(p) {
+    if (!processPersonalMessage) throw auth.rpcErrors.methodNotSupported();
+    const req = p.request;
+    let msgParams;
+    if (Array.isArray(req.params)) {
+      if (req.params.length < 2) throw new Error(`WalletMiddleware - incorrect params for personal_sign. expected [message, address]`);
+      const params = req.params;
+      if (typeof params[0] === "object" && params[0] !== null && "challenge" in params[0] && "address" in params[0]) {
+        const {
+          challenge,
+          address
+        } = params[0];
+        msgParams = {
+          from: address,
+          data: challenge
+        };
+      } else {
+        msgParams = {
+          from: params[1],
+          data: typeof params[0] === "string" ? params[0] : ""
+        };
+      }
+    } else {
+      var _req$params4;
+      msgParams = (_req$params4 = req.params) !== null && _req$params4 !== void 0 ? _req$params4 : {
+        from: "",
+        data: ""
+      };
+    }
+    return processPersonalMessage(msgParams, req);
+  }
+  async function ethPrivateKeyHandler(p) {
+    if (!getPrivateKey) throw auth.rpcErrors.methodNotSupported();
+    return getPrivateKey(p.request);
+  }
+  async function ethPublicKeyHandler(p) {
+    if (!getPublicKey) throw auth.rpcErrors.methodNotSupported();
+    return getPublicKey(p.request);
+  }
+  async function walletGetCapabilitiesHandler(p) {
+    var _req$params$3;
+    if (!processGetCapabilities) throw auth.rpcErrors.methodNotSupported();
+    const req = p.request;
+    if (!req.params || !Array.isArray(req.params) || req.params.length < 2) throw auth.rpcErrors.invalidParams("Invalid parameters");
+    const account = req.params[0];
+    if (!viem.isHex(account)) throw auth.rpcErrors.invalidParams("Invalid account address");
+    let chainIds = (_req$params$3 = req.params[1]) !== null && _req$params$3 !== void 0 ? _req$params$3 : [];
+    if (!Array.isArray(chainIds)) throw auth.rpcErrors.invalidParams(`Invalid params, received: ${chainIds}. expected: Array`);
+    chainIds = chainIds.map(chainId => viem.isHex(chainId) ? chainId : viem.toHex(chainId));
+    const getCapabilitiesParams = [account, chainIds];
+    return processGetCapabilities(getCapabilitiesParams);
+  }
+  async function walletSendCallsHandler(p) {
+    if (!processSendCalls) throw auth.rpcErrors.methodNotSupported();
+    const req = p.request;
+    const params = Array.isArray(req.params) ? req.params[0] : req.params;
+    if (!params || typeof params !== "object") throw auth.rpcErrors.invalidParams("Missing or invalid params for wallet_sendCalls");
+    if (!params.version || typeof params.version !== "string") throw auth.rpcErrors.invalidParams(`Invalid version: expected string, got "${params.version || "undefined"}"`);
+    if (!params.chainId) throw auth.rpcErrors.invalidParams("Missing required field: chainId");
+    if (!Array.isArray(params.calls) || params.calls.length === 0) throw auth.rpcErrors.invalidParams("calls must be a non-empty array");
+    const from = params.from;
+    if (from) await validateAndNormalizeKeyholder(from, req);
+    const walletSendCallsParams = _objectSpread(_objectSpread({}, params), {}, {
+      chainId: viem.isHex(params.chainId) ? params.chainId : viem.toHex(params.chainId)
+    });
+    return processSendCalls(walletSendCallsParams);
+  }
+  async function walletBatchCallStatusHandler(p) {
+    if (!processGetCallsStatus) throw auth.rpcErrors.methodNotSupported();
+    const req = p.request;
+    const batchId = Array.isArray(req.params) ? req.params[0] : req.params;
+    if (!batchId || typeof batchId !== "string") throw auth.rpcErrors.invalidParams("Missing or invalid batchId");
+    return processGetCallsStatus(batchId);
+  }
+  async function walletShowCallsStatusHandler(p) {
+    if (!processShowCallsStatus) throw auth.rpcErrors.methodNotSupported();
+    const req = p.request;
+    const batchId = Array.isArray(req.params) ? req.params[0] : req.params;
+    if (!batchId || typeof batchId !== "string") throw auth.rpcErrors.invalidParams("Missing or invalid batchId");
+    await processShowCallsStatus(batchId);
+    return true;
+  }
+  return auth.createScaffoldMiddlewareV2({
+    // account lookups
+    eth_accounts: ethAccountsHandler,
+    eth_requestAccounts: ethAccountsHandler,
+    eth_private_key: ethPrivateKeyHandler,
+    eth_public_key: ethPublicKeyHandler,
+    public_key: ethPublicKeyHandler,
+    private_key: ethPrivateKeyHandler,
+    // tx signatures
+    eth_sendTransaction: ethSendTransactionHandler,
+    eth_signTransaction: ethSignTransactionHandler,
+    // message signatures
+    eth_sign: ethSignHandler,
+    eth_signTypedData_v4: ethSignTypedDataV4Handler,
+    personal_sign: personalSignHandler,
+    // EIP5792
+    wallet_getCapabilities: walletGetCapabilitiesHandler,
+    wallet_sendCalls: walletSendCallsHandler,
+    wallet_batchCallStatus: walletBatchCallStatusHandler,
+    wallet_showCallsStatus: walletShowCallsStatusHandler
+  });
+}
+
+exports.createWalletMiddlewareV2 = createWalletMiddlewareV2;

package/dist/lib.cjs/providers/xrpl-provider/providers/privateKeyProviders/xrplPrivateKeyProvider.js

@@ -6,15 +6,17 @@ require('@babel/runtime/helpers/objectSpread2');
 require('@segment/analytics-next');
 require('../../../../base/loglevel.js');
 var baseControllers = require('@toruslabs/base-controllers');
+require('@toruslabs/session-manager');
 var index = require('../../../../base/errors/index.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../../../../base/constants.js');
 require('../../../../base/wallet/index.js');
 require('../../../../base/connector/connectorStatus.js');
 require('../../../../base/connector/constants.js');
 require('jwt-decode');
 require('../../../../base/plugin/errors.js');
 require('../../../../base/plugin/IPlugin.js');
-require('@toruslabs/constants');
-require('@toruslabs/http-helpers');
 var baseProvider = require('../../../base-provider/baseProvider.js');
 require('../../../base-provider/CommonJRPCProvider.js');
 require('../../../base-provider/commonPrivateKeyProvider.js');
@@ -61,14 +63,14 @@ class XrplPrivateKeyProvider extends baseProvider.BaseProvider {
       keyExportEnabled: this.config.keyExportEnabled
     });
     const xrplWalletMiddleware = xrplRpcMiddlewares.createXRPLMiddleware(providerHandlers);
-    const engine = new auth.JRPCEngine();
     const {
       networkMiddleware
     } = JrpcClient.createXrplJsonRpcClient(chain);
-    engine.push(this.getChainSwitchMiddleware());
-    engine.push(xrplWalletMiddleware);
-    engine.push(networkMiddleware);
-    const provider = auth.providerFromEngine(engine);
+    const chainSwitchMiddleware = xrplRpcMiddlewares.creatXrplChainSwitchMiddleware(params => this.switchChain(params));
+    const engine = auth.JRPCEngineV2.create({
+      middleware: [chainSwitchMiddleware, xrplWalletMiddleware, networkMiddleware]
+    });
+    const provider = auth.providerFromEngineV2(engine);
     this.updateProviderEngineProxy(provider);
     await this.lookupNetwork(privKey, chainId);
     this.emit("chainChanged", chainId);
@@ -110,17 +112,6 @@ class XrplPrivateKeyProvider extends baseProvider.BaseProvider {
       throw index.WalletInitializationError.rpcConnectionError(`Failed to ping network for following rpc target: ${chain.rpcTarget}`);
     }
   }
-  getChainSwitchMiddleware() {
-    const chainSwitchHandlers = {
-      switchChain: async req => {
-        if (!req.params) throw auth.rpcErrors.invalidParams("Missing request params");
-        if (!req.params.chainId) throw auth.rpcErrors.invalidParams("Missing chainId");
-        await this.switchChain(req.params);
-      }
-    };
-    const chainSwitchMiddleware = xrplRpcMiddlewares.creatXrplChainSwitchMiddleware(chainSwitchHandlers);
-    return chainSwitchMiddleware;
-  }
 }
 _XrplPrivateKeyProvider = XrplPrivateKeyProvider;
 _defineProperty(XrplPrivateKeyProvider, "getProviderInstance", async params => {

package/dist/lib.cjs/providers/xrpl-provider/providers/privateKeyProviders/xrplWalletUtils.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var metadataHelpers = require('@toruslabs/metadata-helpers');
 var auth = require('@web3auth/auth');
 var rippleKeypairs = require('ripple-keypairs');
 var xrpl = require('xrpl');
@@ -7,7 +8,7 @@ var ECDSA = require('xrpl/dist/npm/ECDSA');
 
 const deriveKeypair = web3authKey => {
   const seed = rippleKeypairs.generateSeed({
-    entropy: Buffer.from(web3authKey.padStart(64, "0"), "hex"),
+    entropy: metadataHelpers.hexToBytes(web3authKey.padStart(64, "0")),
     algorithm: "ecdsa-secp256k1"
   });
   const wallet = xrpl.Wallet.fromSecret(seed, {

package/dist/lib.cjs/providers/xrpl-provider/rpc/JrpcClient.js

@@ -5,44 +5,37 @@ var auth = require('@web3auth/auth');
 var xrplRpcMiddlewares = require('./xrplRpcMiddlewares.js');
 
 function createXrplChainIdMiddleware(chainId) {
-  return (req, res, next, end) => {
-    if (req.method === xrplRpcMiddlewares.RPC_METHODS.CHAIN_ID) {
-      res.result = chainId;
-      return end();
-    }
-    return next();
+  return ({
+    request,
+    next
+  }) => {
+    if (request.method === xrplRpcMiddlewares.RPC_METHODS.CHAIN_ID) return chainId;
+    return next(request);
   };
 }
 function createXrplProviderConfigMiddleware(providerConfig) {
-  return (req, res, next, end) => {
-    if (req.method === xrplRpcMiddlewares.RPC_METHODS.PROVIDER_CHAIN_CONFIG) {
-      res.result = providerConfig;
-      return end();
-    }
-    return next();
+  return ({
+    request,
+    next
+  }) => {
+    if (request.method === xrplRpcMiddlewares.RPC_METHODS.PROVIDER_CHAIN_CONFIG) return providerConfig;
+    return next(request);
   };
 }
-function createConfigMiddleware(providerConfig) {
-  const {
-    chainId
-  } = providerConfig;
-  return auth.mergeMiddleware([createXrplChainIdMiddleware(chainId), createXrplProviderConfigMiddleware(providerConfig)]);
-}
 function createXrplJsonRpcClient(providerConfig) {
   const {
+    chainId,
     rpcTarget
   } = providerConfig;
-  const fetchMiddleware = baseControllers.createFetchMiddleware({
-    rpcTarget
+  const engine = auth.JRPCEngineV2.create({
+    middleware: [createXrplChainIdMiddleware(chainId), createXrplProviderConfigMiddleware(providerConfig), baseControllers.createFetchMiddleware({
+      rpcTarget
+    })]
   });
-  const networkMiddleware = auth.mergeMiddleware([createConfigMiddleware(providerConfig), fetchMiddleware]);
+  const networkMiddleware = engine.asMiddleware();
   return {
-    networkMiddleware,
-    fetchMiddleware
+    networkMiddleware
   };
 }
 
-exports.createConfigMiddleware = createConfigMiddleware;
-exports.createXrplChainIdMiddleware = createXrplChainIdMiddleware;
 exports.createXrplJsonRpcClient = createXrplJsonRpcClient;
-exports.createXrplProviderConfigMiddleware = createXrplProviderConfigMiddleware;

package/dist/lib.cjs/providers/xrpl-provider/rpc/xrplRpcMiddlewares.js

@@ -14,35 +14,15 @@ const RPC_METHODS = {
   CHAIN_ID: "xrpl_chainId",
   PROVIDER_CHAIN_CONFIG: "xrpl_providerChainConfig"
 };
-function createGetAccountsMiddleware({
-  getAccounts
-}) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    // hack to override big ids from fetch middleware which are not supported in xrpl servers
-    // TODO: fix this for xrpl controllers.
+/** Normalizes request.id for XRPL servers that don't support large IDs from fetch middleware. */
+function createRequestIdNormalizerMiddleware() {
+  return ({
+    request,
+    next
+  }) => {
     request.id = baseControllers.randomId();
-    if (method !== RPC_METHODS.GET_ACCOUNTS) return next();
-    if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
-    // This calls from the prefs controller
-    const accounts = await getAccounts(request);
-    response.result = accounts;
-    return undefined;
-  });
-}
-function createGenericJRPCMiddleware(targetMethod, handler) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== targetMethod) return next();
-    if (!handler) throw new Error(`WalletMiddleware - ${targetMethod} not provided`);
-    const result = await handler(request);
-    response.result = result;
-    return undefined;
-  });
+    return next(request);
+  };
 }
 function createXRPLMiddleware(providerHandlers) {
   const {
@@ -53,18 +33,47 @@ function createXRPLMiddleware(providerHandlers) {
     getKeyPair,
     getPublicKey
   } = providerHandlers;
-  return auth.mergeMiddleware([createGetAccountsMiddleware({
-    getAccounts
-  }), createGenericJRPCMiddleware(RPC_METHODS.SIGN_TRANSACTION, signTransaction), createGenericJRPCMiddleware(RPC_METHODS.SUBMIT_TRANSACTION, submitTransaction), createGenericJRPCMiddleware(RPC_METHODS.SIGN_MESSAGE, signMessage), createGenericJRPCMiddleware(RPC_METHODS.GET_KEY_PAIR, getKeyPair), createGenericJRPCMiddleware(RPC_METHODS.GET_PUBLIC_KEY, getPublicKey)]);
+  const scaffold = auth.createScaffoldMiddlewareV2({
+    [RPC_METHODS.GET_ACCOUNTS]: params => {
+      if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
+      return getAccounts(params.request);
+    },
+    [RPC_METHODS.SIGN_TRANSACTION]: params => {
+      return signTransaction(params.request);
+    },
+    [RPC_METHODS.SUBMIT_TRANSACTION]: params => {
+      return submitTransaction(params.request);
+    },
+    [RPC_METHODS.SIGN_MESSAGE]: params => {
+      return signMessage(params.request);
+    },
+    [RPC_METHODS.GET_KEY_PAIR]: params => {
+      return getKeyPair(params.request);
+    },
+    [RPC_METHODS.GET_PUBLIC_KEY]: params => {
+      return getPublicKey(params.request);
+    }
+  });
+  const engine = auth.JRPCEngineV2.create({
+    middleware: [createRequestIdNormalizerMiddleware(), scaffold]
+  });
+  return engine.asMiddleware();
 }
-function creatXrplChainSwitchMiddleware({
-  switchChain
-}) {
-  return auth.mergeMiddleware([createGenericJRPCMiddleware(RPC_METHODS.SWITCH_CHAIN, switchChain)]);
+function creatXrplChainSwitchMiddleware(switchChain) {
+  async function switchChainHandler(params) {
+    const req = params.request;
+    if (!req.params) throw auth.rpcErrors.invalidParams("Missing request params");
+    if (!req.params.chainId) throw auth.rpcErrors.invalidParams("Missing chainId");
+    await switchChain({
+      chainId: req.params.chainId
+    });
+    return undefined;
+  }
+  return auth.createScaffoldMiddlewareV2({
+    [RPC_METHODS.SWITCH_CHAIN]: switchChainHandler
+  });
 }
 
 exports.RPC_METHODS = RPC_METHODS;
 exports.creatXrplChainSwitchMiddleware = creatXrplChainSwitchMiddleware;
-exports.createGenericJRPCMiddleware = createGenericJRPCMiddleware;
-exports.createGetAccountsMiddleware = createGetAccountsMiddleware;
 exports.createXRPLMiddleware = createXRPLMiddleware;

package/dist/lib.cjs/react/context/WalletServicesInnerContext.js

@@ -1,21 +1,7 @@
 'use strict';
 
 var react = require('react');
-require('@babel/runtime/helpers/objectSpread2');
-require('@babel/runtime/helpers/defineProperty');
-require('@segment/analytics-next');
-require('../../base/loglevel.js');
-require('@toruslabs/base-controllers');
-require('@web3auth/auth');
-require('../../base/errors/index.js');
-require('../../base/wallet/index.js');
-require('../../base/connector/connectorStatus.js');
-var constants = require('../../base/connector/constants.js');
-require('jwt-decode');
-require('../../base/plugin/errors.js');
-var IPlugin = require('../../base/plugin/IPlugin.js');
-require('@toruslabs/constants');
-require('@toruslabs/http-helpers');
+var useWalletServicesContextValue = require('./useWalletServicesContextValue.js');
 
 const WalletServicesContext = react.createContext(null);
 function WalletServicesContextProvider({
@@ -23,60 +9,7 @@ function WalletServicesContextProvider({
   context
 }) {
   const web3AuthContext = react.useContext(context);
-  const {
-    getPlugin,
-    isInitialized,
-    isConnected
-  } = web3AuthContext;
-  const [ready, setReady] = react.useState(false);
-  const [connecting, setConnecting] = react.useState(false);
-  const [walletServicesPlugin, setWalletServicesPlugin] = react.useState(null);
-  react.useEffect(() => {
-    if (isInitialized) {
-      const plugin = getPlugin(IPlugin.EVM_PLUGINS.WALLET_SERVICES);
-      setWalletServicesPlugin(plugin);
-    }
-  }, [isInitialized, getPlugin]);
-  react.useEffect(() => {
-    if (isConnected) {
-      const plugin = getPlugin(IPlugin.EVM_PLUGINS.WALLET_SERVICES);
-      setWalletServicesPlugin(plugin);
-      // when rehydrating, the connectedListener may be registered after the connected event is emitted, we need to check the status here
-      if ((plugin === null || plugin === void 0 ? void 0 : plugin.status) === constants.CONNECTOR_STATUS.CONNECTED) setReady(true);
-    }
-  }, [isConnected, getPlugin, walletServicesPlugin]);
-  react.useEffect(() => {
-    const connectedListener = () => {
-      setReady(true);
-      setConnecting(false);
-    };
-    const disconnectedListener = () => {
-      setReady(false);
-      setConnecting(false);
-    };
-    const connectingListener = () => {
-      setConnecting(true);
-    };
-    if (walletServicesPlugin) {
-      walletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
-      walletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
-      walletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.CONNECTING, connectingListener);
-    }
-    return () => {
-      if (walletServicesPlugin) {
-        walletServicesPlugin.removeListener(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
-        walletServicesPlugin.removeListener(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
-        walletServicesPlugin.removeListener(IPlugin.PLUGIN_EVENTS.CONNECTING, connectingListener);
-      }
-    };
-  }, [walletServicesPlugin]);
-  const value = react.useMemo(() => {
-    return {
-      plugin: walletServicesPlugin,
-      ready,
-      connecting
-    };
-  }, [walletServicesPlugin, ready, connecting]);
+  const value = useWalletServicesContextValue.useWalletServicesContextValue(web3AuthContext);
   return react.createElement(WalletServicesContext.Provider, {
     value
   }, children);