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

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

@@ -27,45 +27,17 @@ function createEthMiddleware(providerHandlers) {
   return ethMiddleware;
 }
 function createEthChainSwitchMiddleware({
-  addChain,
   switchChain
 }) {
-  async function addNewChain(req, res) {
+  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;
-    if (!chainParams) throw rpcErrors.invalidParams("Missing chain params");
-    if (!chainParams.chainId) throw rpcErrors.invalidParams("Missing chainId in chainParams");
-    if (!chainParams.rpcUrls || chainParams.rpcUrls.length === 0) throw rpcErrors.invalidParams("Missing rpcUrls in chainParams");
-    if (!chainParams.nativeCurrency) throw rpcErrors.invalidParams("Missing nativeCurrency in chainParams");
-    res.result = await addChain(chainParams);
-  }
-  async function updateChain(req, res) {
-    var _req$params2;
-    const chainParams = (_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.length ? req.params[0] : undefined;
     if (!chainParams) throw rpcErrors.invalidParams("Missing chainId");
     res.result = await switchChain(chainParams);
   }
   return createScaffoldMiddleware({
-    wallet_addEthereumChain: createAsyncMiddleware(addNewChain),
     wallet_switchEthereumChain: createAsyncMiddleware(updateChain)
   });
 }
 
-// #region account middlewares
-function createEthAccountMiddleware({
-  updatePrivatekey
-}) {
-  async function updateAccount(req, res) {
-    var _req$params3;
-    const accountParams = (_req$params3 = req.params) !== null && _req$params3 !== void 0 && _req$params3.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, createEthChainSwitchMiddleware, createEthMiddleware };
+export { createEthChainSwitchMiddleware, createEthMiddleware };

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

@@ -14,11 +14,9 @@ function createWalletMiddleware({
   if (!getAccounts) {
     throw new Error("opts.getAccounts is required");
   }
-
   //
   // utility
   //
-
   /**
    * Validates the keyholder address, and returns a normalized (i.e. lowercase)
    * copy of it.
@@ -39,19 +37,15 @@ function createWalletMiddleware({
       message: `Invalid parameters: must provide an Ethereum address.`
     });
   }
-
   //
   // account lookups
   //
-
   async function lookupAccounts(req, res) {
     res.result = await getAccounts(req);
   }
-
   //
   // transaction signatures
   //
-
   async function sendTransaction(req, res) {
     if (!processTransaction) {
       throw rpcErrors.methodNotSupported();
@@ -72,11 +66,9 @@ function createWalletMiddleware({
     txParams.from = await validateAndNormalizeKeyholder(txParams.from, req);
     res.result = await processSignTransaction(txParams, req);
   }
-
   //
   // message signatures
   //
-
   async function ethSign(req, res) {
     if (!processEthSignMessage) {
       throw rpcErrors.methodNotSupported();

package/dist/lib.esm/providers/solana-provider/providers/injectedProviders/base/baseInjectedProvider.js

@@ -1,8 +1,21 @@
 import { JRPCEngine, providerFromEngine } from '@web3auth/auth';
 import { WalletLoginError } from '../../../../../base/errors/index.js';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '../../../../../base/wallet/index.js';
+import '../../../../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../../../../base/loglevel.js';
+import '../../../../../base/plugin/errors.js';
+import '../../../../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+import { BaseProvider } from '../../../../base-provider/baseProvider.js';
+import '../../../../base-provider/CommonJRPCProvider.js';
+import '../../../../base-provider/commonPrivateKeyProvider.js';
+import '../../../../base-provider/utils.js';
 import { createConfigMiddleware } from '../../../rpc/JrpcClient.js';
 import { createSolanaMiddleware } from '../../../rpc/solanaRpcMiddlewares.js';
-import { BaseProvider } from '../../../../base-provider/baseProvider.js';
 
 class BaseInjectedProvider extends BaseProvider {
   constructor({
@@ -15,14 +28,15 @@ class BaseInjectedProvider extends BaseProvider {
     });
   }
   async switchChain(_) {
-    throw WalletLoginError.unsupportedOperation("Chain switching is not supported by this adapter");
+    throw WalletLoginError.unsupportedOperation("Chain switching is not supported by this connector");
   }
-  async setupProvider(injectedProvider) {
+  async setupProvider(injectedProvider, chainId) {
     const engine = new JRPCEngine();
+    const chain = this.getChain(chainId);
     const providerHandlers = this.getProviderHandlers(injectedProvider);
     const solanaMiddleware = createSolanaMiddleware(providerHandlers);
     engine.push(solanaMiddleware);
-    const configMiddleware = createConfigMiddleware(this.config.chainConfig);
+    const configMiddleware = createConfigMiddleware(chain);
     engine.push(configMiddleware);
     const injectedProviderProxy = this.getInjectedProviderProxy(injectedProvider);
     if (injectedProviderProxy) {
@@ -30,16 +44,13 @@ class BaseInjectedProvider extends BaseProvider {
     }
     const provider = providerFromEngine(engine);
     this.updateProviderEngineProxy(provider);
-    await this.lookupNetwork();
+    await this.lookupNetwork(injectedProvider, chainId);
   }
-  async lookupNetwork() {
-    const {
-      chainConfig
-    } = this.config;
+  async lookupNetwork(_injectedProvider, chainId) {
     this.update({
-      chainId: chainConfig.chainId
+      chainId
     });
-    return chainConfig.chainId || "";
+    return chainId || "";
   }
   getInjectedProviderProxy(_) {
     return undefined;

package/dist/lib.esm/providers/solana-provider/providers/injectedProviders/base/providerHandlers.js

@@ -1,5 +1,5 @@
+import { bs58 } from '@toruslabs/bs58';
 import { rpcErrors } from '@web3auth/auth';
-import bs58 from 'bs58';
 
 const getBaseProviderHandlers = injectedProvider => {
   const providerHandlers = {
@@ -21,8 +21,8 @@ const getBaseProviderHandlers = injectedProvider => {
       return transaction;
     },
     signMessage: async req => {
-      const sigData = await injectedProvider.signMessage(req.params.message, req.params.display);
-      return sigData.signature;
+      const sigData = await injectedProvider.signMessage(req.params.data, req.params.from, req.params.display);
+      return sigData;
     },
     signAllTransactions: async req => {
       var _req$params, _req$params2;
@@ -34,9 +34,7 @@ const getBaseProviderHandlers = injectedProvider => {
     },
     signAndSendTransaction: async req => {
       const txRes = await injectedProvider.signAndSendTransaction(req.params.message);
-      return {
-        signature: txRes.signature
-      };
+      return txRes;
     }
   };
   return providerHandlers;

package/dist/lib.esm/providers/solana-provider/providers/injectedProviders/walletStandardProvider.js

@@ -1,9 +1,97 @@
+import { SolanaSignAndSendTransaction, SolanaSignTransaction, SolanaSignMessage } from '@solana/wallet-standard-features';
+import { PublicKey, VersionedTransaction } from '@solana/web3.js';
+import { bs58 } from '@toruslabs/bs58';
+import { WalletLoginError } from '../../../../base/errors/index.js';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '@web3auth/auth';
+import '../../../../base/wallet/index.js';
+import '../../../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../../../base/loglevel.js';
+import '../../../../base/plugin/errors.js';
+import '../../../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
 import { BaseInjectedProvider } from './base/baseInjectedProvider.js';
 import { getBaseProviderHandlers } from './base/providerHandlers.js';
+import { getSolanaChainByChainConfig } from './utils.js';
 
 class WalletStandardProvider extends BaseInjectedProvider {
-  getProviderHandlers(injectedProvider) {
-    return getBaseProviderHandlers(injectedProvider);
+  getProviderHandlers(wallet) {
+    const chainIdentifier = getSolanaChainByChainConfig(this.config.chain);
+    const currentAccount = () => {
+      const account = wallet === null || wallet === void 0 ? void 0 : wallet.accounts[0];
+      if (!account) throw WalletLoginError.notConnectedError();
+      return account;
+    };
+    /**
+     * Signs a message and returns the signature
+     * @param message - The message to sign
+     * @returns The signature of the message encoded in base58
+     */
+    const signMessage = async message => {
+      const account = currentAccount();
+      const uint8ArrayMessage = new Uint8Array(Buffer.from(message, "utf-8"));
+      const signature = await wallet.features[SolanaSignMessage].signMessage({
+        account,
+        message: uint8ArrayMessage
+      });
+      return bs58.encode(signature[0].signature);
+    };
+    /**
+     * Signs a transaction and returns the signature
+     * @param transaction - The transaction to sign
+     * @returns The signature of the transaction encoded in base58
+     */
+    const signTransaction = async transaction => {
+      const account = currentAccount();
+      const output = await wallet.features[SolanaSignTransaction].signTransaction({
+        account,
+        transaction: new Uint8Array(Buffer.from(transaction, "base64")),
+        chain: chainIdentifier
+      });
+      return bs58.encode(VersionedTransaction.deserialize(output[0].signedTransaction).signatures[0]);
+    };
+    /**
+     * Signs multiple transactions and returns the serialized transactions
+     * @param transactions - The transactions to sign
+     * @returns The serialized transactions encoded in base64
+     */
+    const signAllTransactions = async transactions => {
+      const account = currentAccount();
+      return Promise.all(transactions.map(async transaction => {
+        const output = await wallet.features[SolanaSignTransaction].signTransaction({
+          account,
+          transaction: new Uint8Array(Buffer.from(transaction, "base64")),
+          chain: chainIdentifier
+        });
+        return Buffer.from(output[0].signedTransaction).toString("base64");
+      }));
+    };
+    /**
+     * Signs a transaction and sends it to the network
+     * @param transaction - The transaction to sign and send
+     * @returns The signature of the transaction encoded in base58
+     */
+    const signAndSendTransaction = async transaction => {
+      const account = currentAccount();
+      const output = await wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction({
+        account,
+        transaction: new Uint8Array(Buffer.from(transaction, "base64")),
+        chain: chainIdentifier
+      });
+      return bs58.encode(output[0].signature);
+    };
+    return getBaseProviderHandlers({
+      get publicKey() {
+        return new PublicKey(currentAccount().publicKey);
+      },
+      signMessage,
+      signTransaction,
+      signAllTransactions,
+      signAndSendTransaction
+    });
   }
 }
 

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

@@ -1,11 +1,22 @@
 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 { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import '../../../../base/wallet/index.js';
+import '../../../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../../../base/loglevel.js';
+import '../../../../base/plugin/errors.js';
+import '../../../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+import { BaseProvider } from '../../../base-provider/baseProvider.js';
+import '../../../base-provider/CommonJRPCProvider.js';
+import '../../../base-provider/commonPrivateKeyProvider.js';
+import '../../../base-provider/utils.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 +35,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 +43,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 +58,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 +83,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 +95,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 +114,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 +148,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

@@ -1,8 +1,18 @@
 import { Keypair, VersionedTransaction } from '@solana/web3.js';
+import { bs58 } from '@toruslabs/bs58';
 import { sign } from '@toruslabs/tweetnacl-js';
 import { rpcErrors, providerErrors } from '@web3auth/auth';
-import bs58 from 'bs58';
 import { WalletInitializationError } from '../../../../base/errors/index.js';
+import '@toruslabs/base-controllers';
+import '@babel/runtime/helpers/defineProperty';
+import '../../../../base/wallet/index.js';
+import '../../../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../../../base/loglevel.js';
+import '../../../../base/plugin/errors.js';
+import '../../../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
 
 async function getProviderHandlers({
   privKey,
@@ -35,21 +45,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 +68,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 +78,7 @@ async function getProviderHandlers({
           preflightCommitment: "confirmed"
         }]
       });
-      return {
-        signature: sig
-      };
+      return sig;
     },
     signAllTransactions: async req => {
       var _req$params4, _req$params5, _req$params6;
@@ -84,15 +86,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 { mergeMiddleware, createAsyncMiddleware } 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