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

package/dist/lib.esm/providers/solana-provider/providers/privateKeyProvider/solanaPrivateKeyProvider.js

@@ -2,10 +2,10 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { providerErrors, getED25519Key, 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 { createSolanaJsonRpcClient } from '../../rpc/JrpcClient.js';
 import { createSolanaMiddleware, createSolanaChainSwitchMiddleware, createSolanaAccountMiddleware } from '../../rpc/solanaRpcMiddlewares.js';
 import { getProviderHandlers } from './solanaPrivateKeyUtils.js';
-import { BaseProvider } from '../../../base-provider/baseProvider.js';
 
 var _SolanaPrivateKeyProvider;
 class SolanaPrivateKeyProvider extends BaseProvider {
@@ -24,7 +24,7 @@ class SolanaPrivateKeyProvider extends BaseProvider {
       message: "Private key is not found in state, plz pass it in constructor state param",
       code: 4902
     });
-    await this.setupProvider(this.state.privateKey);
+    await this.setupProvider(this.state.privateKey, this.chainId);
     return this._providerEngineProxy.request({
       method: "eth_accounts"
     });
@@ -32,10 +32,11 @@ class SolanaPrivateKeyProvider extends BaseProvider {
   getEd25519Key(privateKey) {
     return getED25519Key(privateKey).sk.toString("hex").padStart(128, "0");
   }
-  async setupProvider(privKey) {
+  async setupProvider(privKey, chainId) {
+    const chain = this.getChain(chainId);
     const {
       chainNamespace
-    } = this.config.chainConfig;
+    } = chain;
     if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
     const providerHandlers = await getProviderHandlers({
       privKey,
@@ -46,14 +47,21 @@ class SolanaPrivateKeyProvider extends BaseProvider {
     const engine = new JRPCEngine();
     const {
       networkMiddleware
-    } = createSolanaJsonRpcClient(this.config.chainConfig);
+    } = createSolanaJsonRpcClient(chain);
     engine.push(this.getChainSwitchMiddleware());
     engine.push(this.getAccountMiddleware());
     engine.push(solanaMiddleware);
     engine.push(networkMiddleware);
     const provider = providerFromEngine(engine);
     this.updateProviderEngineProxy(provider);
-    await this.lookupNetwork();
+    await this.lookupNetwork(chainId);
+    this.emit("chainChanged", chainId);
+    this.emit("connect", {
+      chainId
+    });
+    this.update({
+      chainId
+    });
   }
   async updateAccount(params) {
     if (!this._providerEngineProxy) throw providerErrors.custom({
@@ -64,7 +72,7 @@ class SolanaPrivateKeyProvider extends BaseProvider {
       method: "solanaPrivateKey"
     });
     if (existingKey !== params.privateKey) {
-      await this.setupProvider(params.privateKey);
+      await this.setupProvider(params.privateKey, this.chainId);
       const accounts = await this._providerEngineProxy.request({
         method: "requestAccounts"
       });
@@ -76,19 +84,17 @@ class SolanaPrivateKeyProvider extends BaseProvider {
       message: "Provider is not initialized",
       code: 4902
     });
-    const chainConfig = this.getChainConfig(params.chainId);
+    const newChainId = params.chainId;
+    if (this.chainId === newChainId) return;
     this.update({
       chainId: "loading"
     });
-    this.configure({
-      chainConfig
-    });
     const privKey = await this._providerEngineProxy.request({
       method: "solanaPrivateKey"
     });
-    await this.setupProvider(privKey);
+    await this.setupProvider(privKey, newChainId);
   }
-  async lookupNetwork() {
+  async lookupNetwork(chainId) {
     if (!this._providerEngineProxy) throw providerErrors.custom({
       message: "Provider is not initialized",
       code: 4902
@@ -97,48 +103,11 @@ class SolanaPrivateKeyProvider extends BaseProvider {
       method: "getHealth",
       params: []
     });
-    const {
-      chainConfig
-    } = this.config;
-    if (health !== "ok") throw WalletInitializationError.rpcConnectionError(`Failed to lookup network for following rpc target: ${chainConfig.rpcTarget}`);
-    this.update({
-      chainId: chainConfig.chainId
-    });
-    if (this.state.chainId !== chainConfig.chainId) {
-      this.emit("chainChanged", this.state.chainId);
-      this.emit("connect", {
-        chainId: this.state.chainId
-      });
-    }
-    return this.state.chainId;
+    const chain = this.getChain(chainId);
+    if (health !== "ok") throw WalletInitializationError.rpcConnectionError(`Failed to lookup network for following rpc target: ${chain.rpcTarget}`);
   }
   getChainSwitchMiddleware() {
     const chainSwitchHandlers = {
-      addNewChainConfig: async req => {
-        if (!req.params) throw rpcErrors.invalidParams("Missing request params");
-        const {
-          chainId,
-          chainName,
-          rpcUrls,
-          blockExplorerUrls,
-          nativeCurrency,
-          iconUrls
-        } = req.params;
-        if (!chainId) throw rpcErrors.invalidParams("Missing chainId in chainParams");
-        if (!rpcUrls || rpcUrls.length === 0) throw rpcErrors.invalidParams("Missing rpcUrls in chainParams");
-        if (!nativeCurrency) throw rpcErrors.invalidParams("Missing nativeCurrency in chainParams");
-        this.addChain({
-          chainNamespace: CHAIN_NAMESPACES.SOLANA,
-          chainId,
-          ticker: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.symbol) || "SOL",
-          tickerName: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.name) || "Solana",
-          displayName: chainName,
-          rpcTarget: rpcUrls[0],
-          blockExplorerUrl: (blockExplorerUrls === null || blockExplorerUrls === void 0 ? void 0 : blockExplorerUrls[0]) || "",
-          decimals: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.decimals) || 9,
-          logo: (iconUrls === null || iconUrls === void 0 ? void 0 : iconUrls[0]) || "https://images.toruswallet.io/sol.svg"
-        });
-      },
       switchSolanaChain: async req => {
         if (!req.params) throw rpcErrors.invalidParams("Missing request params");
         if (!req.params.chainId) throw rpcErrors.invalidParams("Missing chainId");
@@ -168,10 +137,11 @@ _SolanaPrivateKeyProvider = SolanaPrivateKeyProvider;
 _defineProperty(SolanaPrivateKeyProvider, "getProviderInstance", async params => {
   const providerFactory = new _SolanaPrivateKeyProvider({
     config: {
-      chainConfig: params.chainConfig
+      chain: params.chain,
+      chains: params.chains
     }
   });
-  await providerFactory.setupProvider(params.privKey);
+  await providerFactory.setupProvider(params.privKey, params.chain.chainId);
   return providerFactory;
 });
 

package/dist/lib.esm/providers/solana-provider/providers/privateKeyProvider/solanaPrivateKeyUtils.js

@@ -35,21 +35,18 @@ async function getProviderHandlers({
       if (!((_req$params = req.params) !== null && _req$params !== void 0 && _req$params.message)) {
         throw rpcErrors.invalidParams("message");
       }
-      const transaction = req.params.message;
-      if (transaction.version !== undefined || transaction instanceof VersionedTransaction) {
-        transaction.sign([keyPair]);
-      } else {
-        transaction.partialSign(keyPair);
-      }
-      return transaction;
+      const serializedTransaction = req.params.message;
+      const transaction = VersionedTransaction.deserialize(Buffer.from(serializedTransaction, "base64"));
+      transaction.sign([keyPair]);
+      return bs58.encode(transaction.signatures[0]);
     },
     signMessage: async req => {
       var _req$params2;
-      if (!((_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.message)) {
-        throw rpcErrors.invalidParams("message");
+      if (!((_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.data)) {
+        throw rpcErrors.invalidParams("data");
       }
-      const signedMsg = sign.detached(req.params.message, keyPair.secretKey);
-      return signedMsg;
+      const signedMsg = sign.detached(Buffer.from(req.params.data, "utf-8"), keyPair.secretKey);
+      return bs58.encode(signedMsg);
     },
     signAndSendTransaction: async req => {
       var _req$params3;
@@ -61,12 +58,9 @@ async function getProviderHandlers({
         message: "Provider is not initialized",
         code: 4902
       });
-      const transaction = req.params.message;
-      if (transaction.version !== undefined || transaction instanceof VersionedTransaction) {
-        transaction.sign([keyPair]);
-      } else {
-        transaction.partialSign(keyPair);
-      }
+      const serializedTransaction = req.params.message;
+      const transaction = VersionedTransaction.deserialize(Buffer.from(serializedTransaction, "base64"));
+      transaction.sign([keyPair]);
       const sig = await _providerEngineProxy.request({
         method: "sendTransaction",
         params: [Buffer.from(transaction.serialize()).toString("base64"), {
@@ -74,9 +68,7 @@ async function getProviderHandlers({
           preflightCommitment: "confirmed"
         }]
       });
-      return {
-        signature: sig
-      };
+      return sig;
     },
     signAllTransactions: async req => {
       var _req$params4, _req$params5, _req$params6;
@@ -84,15 +76,14 @@ async function getProviderHandlers({
         throw rpcErrors.invalidParams("message");
       }
       const txns = (_req$params6 = req.params) === null || _req$params6 === void 0 ? void 0 : _req$params6.message;
+      const res = [];
       for (const tx of txns || []) {
-        const transaction = tx;
-        if (transaction.version !== undefined || transaction instanceof VersionedTransaction) {
-          transaction.sign([keyPair]);
-        } else {
-          transaction.partialSign(keyPair);
-        }
+        const serializedTransaction = tx;
+        const transaction = VersionedTransaction.deserialize(Buffer.from(serializedTransaction, "base64"));
+        transaction.sign([keyPair]);
+        res.push(Buffer.from(transaction.serialize()).toString("base64"));
       }
-      return txns;
+      return res;
     }
   };
   return providerHandlers;

package/dist/lib.esm/providers/solana-provider/rpc/solanaRpcMiddlewares.js

@@ -1,4 +1,5 @@
 import { createAsyncMiddleware, mergeMiddleware } from '@web3auth/auth';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
 
 function createGetAccountsMiddleware({
   getAccounts
@@ -7,7 +8,7 @@ function createGetAccountsMiddleware({
     const {
       method
     } = request;
-    if (method !== "getAccounts") return next();
+    if (method !== SOLANA_METHOD_TYPES.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);
@@ -36,7 +37,7 @@ function createRequestAccountsMiddleware({
     const {
       method
     } = request;
-    if (method !== "requestAccounts") return next();
+    if (method !== SOLANA_METHOD_TYPES.SOLANA_REQUEST_ACCOUNTS) return next();
     if (!requestAccounts) throw new Error("WalletMiddleware - opts.requestAccounts not provided");
     // This calls the UI login function
     const accounts = await requestAccounts(request);
@@ -72,13 +73,12 @@ function createSolanaMiddleware(providerHandlers) {
     requestAccounts
   }), createGetAccountsMiddleware({
     getAccounts
-  }), createGenericJRPCMiddleware("signTransaction", signTransaction), createGenericJRPCMiddleware("signAndSendTransaction", signAndSendTransaction), createGenericJRPCMiddleware("signAllTransactions", signAllTransactions), createGenericJRPCMiddleware("signMessage", signMessage), createGenericJRPCMiddleware("solanaPrivateKey", getPrivateKey), createGenericJRPCMiddleware("private_key", getPrivateKey), createGenericJRPCMiddleware("public_key", getPublicKey), createGenericJRPCMiddleware("solanaPublicKey", getPublicKey), createGenericJRPCMiddleware("solanaSecretKey", getSecretKey)]);
+  }), createGenericJRPCMiddleware(SOLANA_METHOD_TYPES.SIGN_TRANSACTION, signTransaction), createGenericJRPCMiddleware(SOLANA_METHOD_TYPES.SEND_TRANSACTION, signAndSendTransaction), createGenericJRPCMiddleware(SOLANA_METHOD_TYPES.SIGN_ALL_TRANSACTIONS, signAllTransactions), createGenericJRPCMiddleware(SOLANA_METHOD_TYPES.SIGN_MESSAGE, signMessage), createGenericJRPCMiddleware("solanaPrivateKey", getPrivateKey), createGenericJRPCMiddleware("private_key", getPrivateKey), createGenericJRPCMiddleware("public_key", getPublicKey), createGenericJRPCMiddleware("solanaPublicKey", getPublicKey), createGenericJRPCMiddleware("solanaSecretKey", getSecretKey)]);
 }
 function createSolanaChainSwitchMiddleware({
-  addNewChainConfig,
   switchSolanaChain
 }) {
-  return mergeMiddleware([createGenericJRPCMiddleware("addSolanaChain", addNewChainConfig), createGenericJRPCMiddleware("switchSolanaChain", switchSolanaChain)]);
+  return mergeMiddleware([createGenericJRPCMiddleware("switchSolanaChain", switchSolanaChain)]);
 }
 function createSolanaAccountMiddleware({
   updatePrivatekey

package/dist/lib.esm/providers/solana-provider/solanaWallet.js

@@ -1,4 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { VersionedTransaction } from '@solana/web3.js';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
 
 class SolanaWallet {
   constructor(provider) {
@@ -7,46 +9,62 @@ class SolanaWallet {
   }
   async requestAccounts() {
     const accounts = await this.provider.request({
-      method: "requestAccounts"
+      method: SOLANA_METHOD_TYPES.SOLANA_REQUEST_ACCOUNTS
     });
     return accounts;
   }
   async signAndSendTransaction(transaction) {
-    const {
-      signature
-    } = await this.provider.request({
-      method: "signAndSendTransaction",
+    const signature = await this.provider.request({
+      method: SOLANA_METHOD_TYPES.SEND_TRANSACTION,
       params: {
-        message: transaction
+        message: this.serializeTransaction(transaction)
       }
     });
-    return {
-      signature
-    };
+    return signature;
   }
+
+  /**
+   * Signs a transaction and returns the signature
+   * @param transaction - The transaction to sign
+   * @returns The signature of the transaction encoded in base58
+   */
   async signTransaction(transaction) {
-    const signedTransaction = await this.provider.request({
-      method: "signTransaction",
+    const signature = await this.provider.request({
+      method: SOLANA_METHOD_TYPES.SIGN_TRANSACTION,
       params: {
-        message: transaction
+        message: this.serializeTransaction(transaction)
       }
     });
-    return signedTransaction;
+    return signature;
   }
+
+  /**
+   * Signs multiple transactions and returns the serialized transactions
+   * @param transactions - The transactions to sign
+   * @returns The serialized transactions encoded in base64
+   */
   async signAllTransactions(transactions) {
+    const serializedTransactions = transactions.map(tx => this.serializeTransaction(tx));
     const signedTransactions = await this.provider.request({
-      method: "signAllTransactions",
+      method: SOLANA_METHOD_TYPES.SIGN_ALL_TRANSACTIONS,
       params: {
-        message: transactions
+        message: serializedTransactions
       }
     });
     return signedTransactions;
   }
-  async signMessage(data) {
+
+  /**
+   * Signs a message and returns the signature
+   * @param message - The message to sign
+   * @returns The signature of the message encoded in base58
+   */
+  async signMessage(message, pubKey) {
     const response = await this.provider.request({
-      method: "signMessage",
+      method: SOLANA_METHOD_TYPES.SIGN_MESSAGE,
       params: {
-        message: data
+        data: message,
+        from: pubKey
       }
     });
     return response;
@@ -55,6 +73,14 @@ class SolanaWallet {
     const result = await this.provider.request(args);
     return result;
   }
+  serializeTransaction(transaction) {
+    if (transaction instanceof VersionedTransaction) {
+      return Buffer.from(transaction.serialize()).toString("base64");
+    }
+    return Buffer.from(transaction.serialize({
+      requireAllSignatures: false
+    })).toString("base64");
+  }
 }
 
 export { SolanaWallet };

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

@@ -2,10 +2,10 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 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 { createXrplJsonRpcClient } from '../../rpc/JrpcClient.js';
 import { RPC_METHODS, createXRPLMiddleware, creatXrplChainSwitchMiddleware } from '../../rpc/xrplRpcMiddlewares.js';
 import { getProviderHandlers } from './xrplWalletUtils.js';
-import { BaseProvider } from '../../../base-provider/baseProvider.js';
 
 var _XrplPrivateKeyProvider;
 class XrplPrivateKeyProvider extends BaseProvider {
@@ -24,114 +24,78 @@ class XrplPrivateKeyProvider extends BaseProvider {
       message: "Private key is not found in state, plz pass it in constructor state param",
       code: 4902
     });
-    await this.setupProvider(this.state.privateKey);
+    await this.setupProvider(this.state.privateKey, this.chainId);
     return this._providerEngineProxy.request({
       method: RPC_METHODS.GET_ACCOUNTS
     });
   }
-  async setupProvider(privKey) {
+  async setupProvider(privKey, chainId) {
+    const chain = this.getChain(chainId);
     const {
       wsTarget,
       chainNamespace
-    } = this.config.chainConfig;
+    } = chain;
     if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
     if (!wsTarget) {
       throw WalletInitializationError.invalidParams(`wsTarget is required in chainConfig for xrplProvider`);
     }
     const providerHandlers = await getProviderHandlers({
       privKey,
-      chainConfig: this.config.chainConfig,
+      chainConfig: chain,
       keyExportEnabled: this.config.keyExportEnabled
     });
     const xrplWalletMiddleware = createXRPLMiddleware(providerHandlers);
     const engine = new JRPCEngine();
     const {
       networkMiddleware
-    } = createXrplJsonRpcClient(this.config.chainConfig);
+    } = createXrplJsonRpcClient(chain);
     engine.push(this.getChainSwitchMiddleware());
     engine.push(xrplWalletMiddleware);
     engine.push(networkMiddleware);
     const provider = providerFromEngine(engine);
     this.updateProviderEngineProxy(provider);
-    await this.lookupNetwork();
+    await this.lookupNetwork(privKey, chainId);
+    this.emit("chainChanged", chainId);
+    this.emit("connect", {
+      chainId
+    });
+    this.update({
+      chainId
+    });
   }
   async switchChain(params) {
     if (!this._providerEngineProxy) throw providerErrors.custom({
       message: "Provider is not initialized",
       code: 4902
     });
-    const chainConfig = this.getChainConfig(params.chainId);
+    if (this.chainId === params.chainId) return;
     this.update({
       chainId: "loading"
     });
-    this.configure({
-      chainConfig
-    });
     const {
       privateKey
     } = await this._providerEngineProxy.request({
       method: RPC_METHODS.GET_KEY_PAIR
     });
-    await this.setupProvider(privateKey);
+    await this.setupProvider(privateKey, params.chainId);
   }
-  async lookupNetwork() {
+  async lookupNetwork(_privKey, chainId) {
     if (!this._providerEngineProxy) throw providerErrors.custom({
       message: "Provider is not initialized",
       code: 4902
     });
-    const {
-      chainId
-    } = this.config.chainConfig;
     if (!chainId) throw rpcErrors.invalidParams("chainId is required while lookupNetwork");
     const pingResponse = await this._providerEngineProxy.request({
       method: "ping",
       params: []
     });
     if ((pingResponse === null || pingResponse === void 0 ? void 0 : pingResponse.status) !== "success") {
-      const {
-        chainConfig
-      } = this.config;
-      throw WalletInitializationError.rpcConnectionError(`Failed to ping network for following rpc target: ${chainConfig.rpcTarget}`);
+      const chain = this.getChain(chainId);
+      throw WalletInitializationError.rpcConnectionError(`Failed to ping network for following rpc target: ${chain.rpcTarget}`);
     }
-    if (this.state.chainId !== chainId) {
-      this.emit("chainChanged", chainId);
-      this.emit("connect", {
-        chainId
-      });
-    }
-    this.update({
-      chainId
-    });
   }
   getChainSwitchMiddleware() {
     const chainSwitchHandlers = {
-      addChainConfig: async req => {
-        if (!req.params) throw rpcErrors.invalidParams("Missing request params");
-        const {
-          chainId,
-          ticker,
-          tickerName,
-          displayName,
-          rpcTarget,
-          wsTarget,
-          blockExplorerUrl,
-          logo
-        } = req.params;
-        if (!chainId) throw rpcErrors.invalidParams("Missing chainId in chainParams");
-        if (!rpcTarget) throw rpcErrors.invalidParams("Missing rpcTarget in chainParams");
-        if (!wsTarget) throw rpcErrors.invalidParams("Missing wsTarget in chainParams");
-        this.addChain({
-          chainNamespace: CHAIN_NAMESPACES.XRPL,
-          chainId,
-          ticker: ticker || "XRP",
-          tickerName: tickerName || "XRPL",
-          displayName: displayName || "XRPL",
-          rpcTarget,
-          wsTarget,
-          blockExplorerUrl,
-          logo
-        });
-      },
       switchChain: async req => {
         if (!req.params) throw rpcErrors.invalidParams("Missing request params");
         if (!req.params.chainId) throw rpcErrors.invalidParams("Missing chainId");
@@ -146,10 +110,11 @@ _XrplPrivateKeyProvider = XrplPrivateKeyProvider;
 _defineProperty(XrplPrivateKeyProvider, "getProviderInstance", async params => {
   const providerFactory = new _XrplPrivateKeyProvider({
     config: {
-      chainConfig: params.chainConfig
+      chain: params.chain,
+      chains: params.chains
     }
   });
-  await providerFactory.setupProvider(params.privKey);
+  await providerFactory.setupProvider(params.privKey, params.chain.chainId);
   return providerFactory;
 });
 

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

@@ -8,7 +8,6 @@ const RPC_METHODS = {
   SIGN_MESSAGE: "xrpl_signMessage",
   SIGN_TRANSACTION: "xrpl_signTransaction",
   SUBMIT_TRANSACTION: "xrpl_submitTransaction",
-  ADD_CHAIN: "xrpl_addChain",
   SWITCH_CHAIN: "xrpl_switchChain",
   CHAIN_ID: "xrpl_chainId",
   PROVIDER_CHAIN_CONFIG: "xrpl_providerChainConfig"
@@ -58,10 +57,9 @@ function createXRPLMiddleware(providerHandlers) {
   }), 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)]);
 }
 function creatXrplChainSwitchMiddleware({
-  addChainConfig,
   switchChain
 }) {
-  return mergeMiddleware([createGenericJRPCMiddleware(RPC_METHODS.ADD_CHAIN, addChainConfig), createGenericJRPCMiddleware(RPC_METHODS.SWITCH_CHAIN, switchChain)]);
+  return mergeMiddleware([createGenericJRPCMiddleware(RPC_METHODS.SWITCH_CHAIN, switchChain)]);
 }
 
 export { RPC_METHODS, creatXrplChainSwitchMiddleware, createGenericJRPCMiddleware, createGetAccountsMiddleware, createXRPLMiddleware };