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

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

@@ -0,0 +1,37 @@
+import { createFetchMiddleware } from '@toruslabs/base-controllers';
+import { mergeMiddleware } from '@web3auth/auth';
+
+function createEthChainIdMiddleware(chainId) {
+  return (req, res, next, end) => {
+    if (req.method === "eth_chainId") {
+      res.result = chainId;
+      return end();
+    }
+    return next();
+  };
+}
+function createEthProviderConfigMiddleware(providerConfig) {
+  return (req, res, next, end) => {
+    if (req.method === "eth_provider_config") {
+      res.result = providerConfig;
+      return end();
+    }
+    return next();
+  };
+}
+function createEthJsonRpcClient(providerConfig) {
+  const {
+    chainId,
+    rpcTarget
+  } = providerConfig;
+  const fetchMiddleware = createFetchMiddleware({
+    rpcTarget
+  });
+  const networkMiddleware = mergeMiddleware([createEthChainIdMiddleware(chainId), createEthProviderConfigMiddleware(providerConfig), fetchMiddleware]);
+  return {
+    networkMiddleware,
+    fetchMiddleware
+  };
+}
+
+export { createEthChainIdMiddleware, createEthJsonRpcClient, createEthProviderConfigMiddleware };

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

@@ -0,0 +1,177 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { createScaffoldMiddleware, createAsyncMiddleware, rpcErrors } from '@web3auth/auth';
+
+function createWalletMiddleware({
+  getAccounts,
+  getPrivateKey,
+  getPublicKey,
+  processEthSignMessage,
+  processPersonalMessage,
+  processTransaction,
+  processSignTransaction,
+  processTypedMessageV4
+}) {
+  if (!getAccounts) {
+    throw new Error("opts.getAccounts is required");
+  }
+
+  //
+  // utility
+  //
+
+  /**
+   * Validates the keyholder address, and returns a normalized (i.e. lowercase)
+   * copy of it.
+   *
+   * an error
+   */
+  async function validateAndNormalizeKeyholder(address, req) {
+    if (typeof address === "string" && address.length > 0) {
+      // ensure address is included in provided accounts
+      const accounts = await getAccounts(req);
+      const normalizedAccounts = accounts.map(_address => _address.toLowerCase());
+      const normalizedAddress = address.toLowerCase();
+      if (normalizedAccounts.includes(normalizedAddress)) {
+        return normalizedAddress;
+      }
+    }
+    throw rpcErrors.invalidParams({
+      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();
+    }
+    const txParams = req.params[0] || {
+      from: ""
+    };
+    txParams.from = await validateAndNormalizeKeyholder(txParams.from, req);
+    res.result = await processTransaction(txParams, req);
+  }
+  async function signTransaction(req, res) {
+    if (!processSignTransaction) {
+      throw rpcErrors.methodNotSupported();
+    }
+    const txParams = req.params[0] || {
+      from: ""
+    };
+    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();
+    }
+    let msgParams = req.params;
+    const extraParams = req.params[2] || {};
+    if (Array.isArray(req.params)) {
+      if (!(req.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${req.method} method. expected [address, message]`);
+      const params = req.params;
+      const address = params[0];
+      const message = params[1];
+      msgParams = {
+        from: address,
+        data: message
+      };
+    }
+    msgParams = _objectSpread(_objectSpread({}, extraParams), msgParams);
+    res.result = await processEthSignMessage(msgParams, req);
+  }
+  async function signTypedDataV4(req, res) {
+    if (!processTypedMessageV4) {
+      throw rpcErrors.methodNotSupported();
+    }
+    if (!(req !== null && req !== void 0 && req.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = req.params;
+    if (Array.isArray(req.params)) {
+      if (!(req.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${req.method} method. expected [address, typedData]`);
+      const params = req.params;
+      const address = params[0];
+      const message = params[1];
+      msgParams = {
+        from: address,
+        data: message
+      };
+    }
+    res.result = await processTypedMessageV4(msgParams, req);
+  }
+  async function personalSign(req, res) {
+    if (!processPersonalMessage) {
+      throw rpcErrors.methodNotSupported();
+    }
+    let msgParams = req.params;
+    const extraParams = req.params[2] || {};
+    if (Array.isArray(req.params)) {
+      if (!(req.params.length >= 2)) throw new Error(`WalletMiddleware - incorrect params for ${req.method} method. expected [message, address]`);
+      const params = req.params;
+      if (typeof params[0] === "object") {
+        const {
+          challenge,
+          address
+        } = params[0];
+        msgParams = {
+          from: address,
+          data: challenge
+        };
+      } else {
+        const message = params[0];
+        const address = params[1];
+        msgParams = {
+          from: address,
+          data: message
+        };
+      }
+    }
+    msgParams = _objectSpread(_objectSpread({}, extraParams), msgParams);
+    res.result = await processPersonalMessage(msgParams, req);
+  }
+  async function fetchPrivateKey(req, res) {
+    if (!getPrivateKey) {
+      throw rpcErrors.methodNotSupported();
+    }
+    res.result = await getPrivateKey(req);
+  }
+  async function fetchPublicKey(req, res) {
+    if (!getPublicKey) {
+      throw rpcErrors.methodNotSupported();
+    }
+    res.result = await getPublicKey(req);
+  }
+  return createScaffoldMiddleware({
+    // account lookups
+    eth_accounts: createAsyncMiddleware(lookupAccounts),
+    eth_requestAccounts: createAsyncMiddleware(lookupAccounts),
+    eth_private_key: createAsyncMiddleware(fetchPrivateKey),
+    eth_public_key: createAsyncMiddleware(fetchPublicKey),
+    public_key: createAsyncMiddleware(fetchPublicKey),
+    private_key: createAsyncMiddleware(fetchPrivateKey),
+    // tx signatures
+    eth_sendTransaction: createAsyncMiddleware(sendTransaction),
+    eth_signTransaction: createAsyncMiddleware(signTransaction),
+    // message signatures
+    eth_sign: createAsyncMiddleware(ethSign),
+    eth_signTypedData_v4: createAsyncMiddleware(signTypedDataV4),
+    personal_sign: createAsyncMiddleware(personalSign)
+  });
+}
+
+export { createWalletMiddleware };

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

@@ -0,0 +1,49 @@
+import { JRPCEngine, providerFromEngine } from '@web3auth/auth';
+import { WalletLoginError } from '../../../../../base/errors/index.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({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+  }
+  async switchChain(_) {
+    throw WalletLoginError.unsupportedOperation("Chain switching is not supported by this adapter");
+  }
+  async setupProvider(injectedProvider) {
+    const engine = new JRPCEngine();
+    const providerHandlers = this.getProviderHandlers(injectedProvider);
+    const solanaMiddleware = createSolanaMiddleware(providerHandlers);
+    engine.push(solanaMiddleware);
+    const configMiddleware = createConfigMiddleware(this.config.chainConfig);
+    engine.push(configMiddleware);
+    const injectedProviderProxy = this.getInjectedProviderProxy(injectedProvider);
+    if (injectedProviderProxy) {
+      engine.push(injectedProviderProxy);
+    }
+    const provider = providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+    await this.lookupNetwork();
+  }
+  async lookupNetwork() {
+    const {
+      chainConfig
+    } = this.config;
+    this.update({
+      chainId: chainConfig.chainId
+    });
+    return chainConfig.chainId || "";
+  }
+  getInjectedProviderProxy(_) {
+    return undefined;
+  }
+}
+
+export { BaseInjectedProvider };

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

@@ -0,0 +1,45 @@
+import { rpcErrors } from '@web3auth/auth';
+import bs58 from 'bs58';
+
+const getBaseProviderHandlers = injectedProvider => {
+  const providerHandlers = {
+    requestAccounts: async () => {
+      return injectedProvider.publicKey ? [bs58.encode(injectedProvider.publicKey.toBytes())] : [];
+    },
+    getPublicKey: async () => {
+      return injectedProvider.publicKey ? bs58.encode(injectedProvider.publicKey.toBytes()) : "";
+    },
+    getAccounts: async () => injectedProvider.publicKey ? [bs58.encode(injectedProvider.publicKey.toBytes())] : [],
+    getPrivateKey: async () => {
+      throw rpcErrors.methodNotSupported();
+    },
+    getSecretKey: async () => {
+      throw rpcErrors.methodNotSupported();
+    },
+    signTransaction: async req => {
+      const transaction = await injectedProvider.signTransaction(req.params.message);
+      return transaction;
+    },
+    signMessage: async req => {
+      const sigData = await injectedProvider.signMessage(req.params.message, req.params.display);
+      return sigData.signature;
+    },
+    signAllTransactions: async req => {
+      var _req$params, _req$params2;
+      if (!((_req$params = req.params) !== null && _req$params !== void 0 && _req$params.message) || !((_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.message.length)) {
+        throw rpcErrors.invalidParams("message");
+      }
+      const transaction = await injectedProvider.signAllTransactions(req.params.message);
+      return transaction;
+    },
+    signAndSendTransaction: async req => {
+      const txRes = await injectedProvider.signAndSendTransaction(req.params.message);
+      return {
+        signature: txRes.signature
+      };
+    }
+  };
+  return providerHandlers;
+};
+
+export { getBaseProviderHandlers };

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

@@ -0,0 +1,10 @@
+import { createAsyncMiddleware } from '@web3auth/auth';
+
+function createInjectedProviderProxyMiddleware(provider) {
+  return createAsyncMiddleware(async (req, res, _next) => {
+    const result = await provider.request(req);
+    res.result = result;
+  });
+}
+
+export { createInjectedProviderProxyMiddleware };

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

@@ -0,0 +1,73 @@
+import { rpcErrors } from '@web3auth/auth';
+
+const getTorusHandlers = injectedProvider => {
+  const providerHandlers = {
+    requestAccounts: async () => {
+      const accounts = await injectedProvider.request({
+        method: "solana_requestAccounts",
+        params: {}
+      });
+      return accounts;
+    },
+    getPublicKey: async () => {
+      const publicKeys = await injectedProvider.request({
+        method: "solana_requestAccounts",
+        params: {}
+      });
+      return publicKeys[0];
+    },
+    getAccounts: async () => {
+      const accounts = await injectedProvider.request({
+        method: "solana_requestAccounts",
+        params: {}
+      });
+      return accounts;
+    },
+    getPrivateKey: async () => {
+      throw rpcErrors.methodNotSupported();
+    },
+    getSecretKey: async () => {
+      throw rpcErrors.methodNotSupported();
+    },
+    signMessage: async req => {
+      var _req$params;
+      if (!((_req$params = req.params) !== null && _req$params !== void 0 && _req$params.message)) {
+        throw rpcErrors.invalidParams("message");
+      }
+      const message = await injectedProvider.signMessage(req.params.message);
+      return message;
+    },
+    signTransaction: async req => {
+      var _req$params2;
+      if (!((_req$params2 = req.params) !== null && _req$params2 !== void 0 && _req$params2.message)) {
+        throw rpcErrors.invalidParams("message");
+      }
+      const txMessage = req.params.message;
+      const response = await injectedProvider.signTransaction(txMessage);
+      return response;
+    },
+    signAndSendTransaction: async req => {
+      var _req$params3;
+      if (!((_req$params3 = req.params) !== null && _req$params3 !== void 0 && _req$params3.message)) {
+        throw rpcErrors.invalidParams("message");
+      }
+      const txMessage = req.params.message;
+      const response = await injectedProvider.sendTransaction(txMessage);
+      return {
+        signature: response
+      };
+    },
+    signAllTransactions: async req => {
+      var _req$params4, _req$params5;
+      if (!((_req$params4 = req.params) !== null && _req$params4 !== void 0 && _req$params4.message) || !((_req$params5 = req.params) !== null && _req$params5 !== void 0 && _req$params5.message.length)) {
+        throw rpcErrors.invalidParams("message");
+      }
+      const transactions = req.params.message;
+      const response = await injectedProvider.signAllTransactions(transactions);
+      return response;
+    }
+  };
+  return providerHandlers;
+};
+
+export { getTorusHandlers };

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

@@ -0,0 +1,107 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { providerErrors, JRPCEngine, providerFromEngine } from '@web3auth/auth';
+import { WalletInitializationError } from '../../../../../base/errors/index.js';
+import { isHexStrict } from '../../../../../base/utils.js';
+import { createSolanaMiddleware } from '../../../rpc/solanaRpcMiddlewares.js';
+import { createInjectedProviderProxyMiddleware } from '../injectedProviderProxy.js';
+import { getTorusHandlers } from './providerHandlers.js';
+import { BaseProvider } from '../../../../base-provider/baseProvider.js';
+
+class TorusInjectedProvider extends BaseProvider {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", "solana");
+  }
+  async switchChain(params) {
+    // overrides the base provider implementation
+    await this.provider.request({
+      method: "switchSolanaChain",
+      params: [{
+        chainId: params.chainId
+      }]
+    });
+  }
+  async addChain(chainConfig) {
+    super.addChain(chainConfig);
+    await this.provider.request({
+      method: "addNewChainConfig",
+      params: [{
+        chainId: chainConfig.chainId,
+        chainName: chainConfig.displayName,
+        rpcUrls: [chainConfig.rpcTarget],
+        blockExplorerUrls: [chainConfig.blockExplorerUrl],
+        iconUrls: [chainConfig.logo],
+        nativeCurrency: {
+          name: chainConfig.tickerName,
+          symbol: chainConfig.ticker,
+          decimals: chainConfig.decimals || 18
+        }
+      }]
+    });
+  }
+  async setupProvider(injectedProvider) {
+    this.handleInjectedProviderUpdate(injectedProvider);
+    const {
+      chainNamespace
+    } = this.config.chainConfig;
+    if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
+    await this.setupEngine(injectedProvider);
+  }
+  async lookupNetwork() {
+    if (!this.provider) throw providerErrors.custom({
+      message: "Torus solana provider is not initialized",
+      code: 4902
+    });
+    const {
+      chainId
+    } = this.config.chainConfig;
+    const connectedChainId = await this.provider.request({
+      method: "solana_chainId"
+    });
+    const connectedHexChainId = isHexStrict(connectedChainId.toString()) ? connectedChainId : `0x${parseInt(connectedChainId, 10).toString(16)}`;
+    if (chainId !== connectedHexChainId) throw WalletInitializationError.rpcConnectionError(`Invalid network, net_version is: ${connectedHexChainId}, expected: ${chainId}`);
+    this.update({
+      chainId: connectedHexChainId
+    });
+    this.emit("connect", {
+      chainId: this.state.chainId
+    });
+    this.emit("chainChanged", this.state.chainId);
+    return this.state.chainId;
+  }
+  async setupEngine(injectedProvider) {
+    const providerHandlers = getTorusHandlers(injectedProvider);
+    const solanaMiddleware = createSolanaMiddleware(providerHandlers);
+    const injectedProviderProxy = createInjectedProviderProxyMiddleware(injectedProvider);
+    const engine = new JRPCEngine();
+    engine.push(solanaMiddleware);
+    engine.push(injectedProviderProxy);
+    const provider = providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+    await this.lookupNetwork();
+  }
+  async handleInjectedProviderUpdate(injectedProvider) {
+    injectedProvider.on("accountsChanged", async accounts => {
+      this.emit("accountsChanged", accounts);
+    });
+    injectedProvider.on("chainChanged", async chainId => {
+      const connectedHexChainId = isHexStrict(chainId) ? chainId : `0x${parseInt(chainId, 10).toString(16)}`;
+      // Check if chainId changed and trigger event
+      this.configure({
+        chainConfig: _objectSpread(_objectSpread({}, this.config.chainConfig), {}, {
+          chainId: connectedHexChainId
+        })
+      });
+      await this.setupProvider(injectedProvider);
+    });
+  }
+}
+
+export { TorusInjectedProvider };

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

@@ -0,0 +1,10 @@
+import { BaseInjectedProvider } from './base/baseInjectedProvider.js';
+import { getBaseProviderHandlers } from './base/providerHandlers.js';
+
+class WalletStandardProvider extends BaseInjectedProvider {
+  getProviderHandlers(injectedProvider) {
+    return getBaseProviderHandlers(injectedProvider);
+  }
+}
+
+export { WalletStandardProvider };

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

@@ -0,0 +1,178 @@
+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 { 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 {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "PROVIDER_CHAIN_NAMESPACE", CHAIN_NAMESPACES.SOLANA);
+  }
+  async enable() {
+    if (!this.state.privateKey) throw providerErrors.custom({
+      message: "Private key is not found in state, plz pass it in constructor state param",
+      code: 4902
+    });
+    await this.setupProvider(this.state.privateKey);
+    return this._providerEngineProxy.request({
+      method: "eth_accounts"
+    });
+  }
+  getEd25519Key(privateKey) {
+    return getED25519Key(privateKey).sk.toString("hex").padStart(128, "0");
+  }
+  async setupProvider(privKey) {
+    const {
+      chainNamespace
+    } = this.config.chainConfig;
+    if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
+    const providerHandlers = await getProviderHandlers({
+      privKey,
+      getProviderEngineProxy: this.getProviderEngineProxy.bind(this),
+      keyExportEnabled: this.config.keyExportEnabled
+    });
+    const solanaMiddleware = createSolanaMiddleware(providerHandlers);
+    const engine = new JRPCEngine();
+    const {
+      networkMiddleware
+    } = createSolanaJsonRpcClient(this.config.chainConfig);
+    engine.push(this.getChainSwitchMiddleware());
+    engine.push(this.getAccountMiddleware());
+    engine.push(solanaMiddleware);
+    engine.push(networkMiddleware);
+    const provider = providerFromEngine(engine);
+    this.updateProviderEngineProxy(provider);
+    await this.lookupNetwork();
+  }
+  async updateAccount(params) {
+    if (!this._providerEngineProxy) throw providerErrors.custom({
+      message: "Provider is not initialized",
+      code: 4902
+    });
+    const existingKey = await this._providerEngineProxy.request({
+      method: "solanaPrivateKey"
+    });
+    if (existingKey !== params.privateKey) {
+      await this.setupProvider(params.privateKey);
+      const accounts = await this._providerEngineProxy.request({
+        method: "requestAccounts"
+      });
+      this.emit("accountsChanged", accounts);
+    }
+  }
+  async switchChain(params) {
+    if (!this._providerEngineProxy) throw providerErrors.custom({
+      message: "Provider is not initialized",
+      code: 4902
+    });
+    const chainConfig = this.getChainConfig(params.chainId);
+    this.update({
+      chainId: "loading"
+    });
+    this.configure({
+      chainConfig
+    });
+    const privKey = await this._providerEngineProxy.request({
+      method: "solanaPrivateKey"
+    });
+    await this.setupProvider(privKey);
+  }
+  async lookupNetwork() {
+    if (!this._providerEngineProxy) throw providerErrors.custom({
+      message: "Provider is not initialized",
+      code: 4902
+    });
+    const health = await this._providerEngineProxy.request({
+      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;
+  }
+  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");
+        await this.switchChain(req.params);
+      }
+    };
+    const chainSwitchMiddleware = createSolanaChainSwitchMiddleware(chainSwitchHandlers);
+    return chainSwitchMiddleware;
+  }
+  getAccountMiddleware() {
+    const accountHandlers = {
+      updatePrivatekey: async req => {
+        if (!req.params) throw rpcErrors.invalidParams("Missing request params");
+        if (!req.params.privateKey) throw rpcErrors.invalidParams("Missing privateKey");
+        const {
+          privateKey
+        } = req.params;
+        await this.updateAccount({
+          privateKey
+        });
+      }
+    };
+    return createSolanaAccountMiddleware(accountHandlers);
+  }
+}
+_SolanaPrivateKeyProvider = SolanaPrivateKeyProvider;
+_defineProperty(SolanaPrivateKeyProvider, "getProviderInstance", async params => {
+  const providerFactory = new _SolanaPrivateKeyProvider({
+    config: {
+      chainConfig: params.chainConfig
+    }
+  });
+  await providerFactory.setupProvider(params.privKey);
+  return providerFactory;
+});
+
+export { SolanaPrivateKeyProvider };