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

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

@@ -18,24 +18,25 @@ class BaseProvider extends BaseController {
     // set to true when the keyExportEnabled flag is set by code.
     // This is to prevent the flag from being overridden by the dashboard config.
     _defineProperty(this, "keyExportFlagSetByCode", false);
-    if (!config.chainConfig) throw WalletInitializationError.invalidProviderConfigError("Please provide chainConfig");
-    if (!config.chainConfig.chainId) throw WalletInitializationError.invalidProviderConfigError("Please provide chainId inside chainConfig");
-    if (!config.chainConfig.rpcTarget) throw WalletInitializationError.invalidProviderConfigError("Please provide rpcTarget inside chainConfig");
+    const {
+      chain
+    } = config;
+    if (!chain) throw WalletInitializationError.invalidProviderConfigError("Please provide chain");
+    if (!chain.chainId) throw WalletInitializationError.invalidProviderConfigError("Please provide chainId inside chain");
+    if (!chain.rpcTarget) throw WalletInitializationError.invalidProviderConfigError("Please provide rpcTarget inside chain");
     if (typeof config.keyExportEnabled === "boolean") this.keyExportFlagSetByCode = true;
     this.defaultState = {
       chainId: "loading"
     };
     this.defaultConfig = {
-      chainConfig: config.chainConfig,
-      networks: {
-        [config.chainConfig.chainId]: config.chainConfig
-      },
+      chain: config.chain,
+      chains: config.chains,
       keyExportEnabled: typeof config.keyExportEnabled === "boolean" ? config.keyExportEnabled : true
     };
     super.initialize();
   }
-  get currentChainConfig() {
-    return this.config.chainConfig;
+  get currentChain() {
+    return this.config.chains.find(chain => chain.chainId === this.state.chainId);
   }
   get provider() {
     return this._providerEngineProxy;
@@ -87,25 +88,18 @@ class BaseProvider extends BaseController {
       result: res
     })).catch(err => callback(err, null));
   }
-  addChain(chainConfig) {
-    if (!chainConfig.chainId) throw rpcErrors.invalidParams("chainId is required");
-    if (!chainConfig.rpcTarget) throw rpcErrors.invalidParams("chainId is required");
-    this.configure({
-      networks: _objectSpread(_objectSpread({}, this.config.networks), {}, {
-        [chainConfig.chainId]: chainConfig
-      })
-    });
-  }
-  getChainConfig(chainId) {
-    var _this$config$networks;
-    const chainConfig = (_this$config$networks = this.config.networks) === null || _this$config$networks === void 0 ? void 0 : _this$config$networks[chainId];
-    if (!chainConfig) throw rpcErrors.invalidRequest(`Chain ${chainId} is not supported, please add chainConfig for it`);
-    return chainConfig;
-  }
   updateProviderEngineProxy(provider) {
     if (this._providerEngineProxy) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       this._providerEngineProxy.setTarget(provider);
+      // re-emit events from provider
+      this._providerEngineProxy.eventNames().forEach(event => {
+        provider.on(event, (...args) => {
+          // eslint-disable-next-line
+          this.emit(event, ...args);
+        });
+      });
+      this.handleChainChangedProvider();
     } else {
       this._providerEngineProxy = createEventEmitterProxy(provider);
     }
@@ -120,6 +114,17 @@ class BaseProvider extends BaseController {
   getProviderEngineProxy() {
     return this._providerEngineProxy;
   }
+  getChain(chainId) {
+    return this.config.chains.find(chain => chain.chainId === chainId);
+  }
+  handleChainChangedProvider() {
+    // This is only added because we don't have ethereum and solana private key providers anymore
+    this.provider.on("chainChanged", chainId => {
+      this.update({
+        chainId
+      });
+    });
+  }
 }
 
 export { BaseProvider };

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

@@ -1,5 +1,4 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { createEventEmitterProxy } from '@toruslabs/base-controllers';
 import { JRPCEngine, providerFromEngine, createScaffoldMiddleware, createAsyncMiddleware } from '@web3auth/auth';
 import { BaseProvider } from './baseProvider.js';
 
@@ -22,9 +21,6 @@ class CommonPrivateKeyProvider extends BaseProvider {
   set provider(_) {
     throw new Error("Method not implemented.");
   }
-  addChain(_) {
-    throw new Error("Method not implemented.");
-  }
   async setupProvider(privKey) {
     const privKeyMiddleware = this.getPrivKeyMiddleware(privKey);
     const engine = new JRPCEngine();
@@ -32,14 +28,6 @@ class CommonPrivateKeyProvider extends BaseProvider {
     const provider = providerFromEngine(engine);
     this.updateProviderEngineProxy(provider);
   }
-  updateProviderEngineProxy(provider) {
-    if (this._providerEngineProxy) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      this._providerEngineProxy.setTarget(provider);
-    } else {
-      this._providerEngineProxy = createEventEmitterProxy(provider);
-    }
-  }
   async switchChain(_) {
     return Promise.resolve();
   }
@@ -77,7 +65,8 @@ _CommonPrivateKeyProvider = CommonPrivateKeyProvider;
 _defineProperty(CommonPrivateKeyProvider, "getProviderInstance", async params => {
   const providerFactory = new _CommonPrivateKeyProvider({
     config: {
-      chainConfig: params.chainConfig
+      chain: params.chain,
+      chains: params.chains
     }
   });
   await providerFactory.setupProvider(params.privKey);

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

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

package/dist/lib.esm/providers/ethereum-mpc-provider/providers/signingProviders/EthereumSigningProvider.js

@@ -4,10 +4,10 @@ import { isHexString } from '@ethereumjs/util';
 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 { createEthAccountMiddleware } from '../../rpc/ethRpcMiddlewares.js';
 import { getProviderHandlers } from './signingUtils.js';
 import { TransactionFormatter } from '../../../ethereum-provider/providers/privateKeyProviders/TransactionFormatter/formatter.js';
-import { BaseProvider } from '../../../base-provider/baseProvider.js';
 import { createEthMiddleware, createEthChainSwitchMiddleware } from '../../../ethereum-provider/rpc/ethRpcMiddlewares.js';
 import { createEthJsonRpcClient } from '../../../ethereum-provider/rpc/jrpcClient.js';
 
@@ -19,9 +19,10 @@ class EthereumSigningProvider extends BaseProvider {
   }) {
     super({
       config: {
-        chainConfig: _objectSpread(_objectSpread({}, config.chainConfig), {}, {
-          chainNamespace: CHAIN_NAMESPACES.EIP155
-        })
+        chain: _objectSpread(_objectSpread({}, config.chain), {}, {
+          chainNamespace: CHAIN_NAMESPACES.EIP155 // TODO: is this needed ?
+        }),
+        chains: config.chains
       },
       state
     });
@@ -32,18 +33,20 @@ class EthereumSigningProvider extends BaseProvider {
       message: "signMethods are not found in state, plz pass it in constructor state param",
       code: 4902
     });
-    await this.setupProvider(this.state.signMethods);
+    await this.setupProvider(this.state.signMethods, this.chainId);
     return this._providerEngineProxy.request({
       method: "eth_accounts"
     });
   }
-  async setupProvider({
-    sign,
-    getPublic
-  }) {
+  async setupProvider(params, chainId) {
+    const {
+      sign,
+      getPublic
+    } = params;
+    const chain = this.getChain(chainId);
     const {
       chainNamespace
-    } = this.config.chainConfig;
+    } = chain;
     if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
     const txFormatter = new TransactionFormatter({
       getProviderEngineProxy: this.getProviderEngineProxy.bind(this)
@@ -60,7 +63,7 @@ class EthereumSigningProvider extends BaseProvider {
     // Not a partial anymore because of checks in ctor
     const {
       networkMiddleware
-    } = createEthJsonRpcClient(this.config.chainConfig);
+    } = createEthJsonRpcClient(chain);
     engine.push(ethMiddleware);
     engine.push(chainSwitchMiddleware);
     engine.push(this.getAccountMiddleware());
@@ -68,11 +71,18 @@ class EthereumSigningProvider extends BaseProvider {
     const provider = providerFromEngine(engine);
     this.updateProviderEngineProxy(provider);
     await txFormatter.init();
-    await this.lookupNetwork();
+    await this.lookupNetwork(params, chainId);
     this.state.signMethods = {
       sign,
       getPublic
     };
+    this.emit("chainChanged", chainId);
+    this.emit("connect", {
+      chainId
+    });
+    this.update({
+      chainId
+    });
   }
   async updateAccount(params) {
     if (!this._providerEngineProxy) throw providerErrors.custom({
@@ -89,7 +99,7 @@ class EthereumSigningProvider extends BaseProvider {
     const currentPubKey = (await currentSignMethods.getPublic()).toString("hex");
     const updatePubKey = (await params.signMethods.getPublic()).toString("hex");
     if (currentPubKey !== updatePubKey) {
-      await this.setupProvider(params.signMethods);
+      await this.setupProvider(params.signMethods, this.chainId);
       const accounts = await this._providerEngineProxy.request({
         method: "eth_accounts"
       });
@@ -101,29 +111,25 @@ class EthereumSigningProvider extends BaseProvider {
       message: "Provider is not initialized",
       code: 4902
     });
-    const chainConfig = this.getChainConfig(params.chainId);
-    this.update({
-      chainId: "loading"
-    });
-    this.configure({
-      chainConfig
-    });
     if (!this.state.signMethods) {
       throw providerErrors.custom({
         message: "sign methods are undefined",
         code: 4902
       });
     }
-    await this.setupProvider(this.state.signMethods);
+    if (params.chainId === this.chainId) {
+      return;
+    }
+    this.update({
+      chainId: "loading"
+    });
+    await this.setupProvider(this.state.signMethods, params.chainId);
   }
-  async lookupNetwork() {
+  async lookupNetwork(_, 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 network = await this._providerEngineProxy.request({
       method: "net_version",
@@ -131,40 +137,10 @@ class EthereumSigningProvider extends BaseProvider {
     });
     const finalNetwork = isHexString(network) ? parseInt(network, 16) : parseInt(network, 10);
     if (parseInt(chainId, 16) !== finalNetwork) throw providerErrors.chainDisconnected(`Invalid network, net_version is: ${network}`);
-    if (this.state.chainId !== chainId) {
-      this.emit("chainChanged", chainId);
-      this.emit("connect", {
-        chainId
-      });
-    }
-    this.update({
-      chainId
-    });
     return network;
   }
   getChainSwitchMiddleware() {
     const chainSwitchHandlers = {
-      addChain: async params => {
-        const {
-          chainId,
-          chainName,
-          rpcUrls,
-          blockExplorerUrls,
-          nativeCurrency,
-          iconUrls
-        } = params;
-        this.addChain({
-          chainNamespace: CHAIN_NAMESPACES.EIP155,
-          chainId,
-          ticker: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.symbol) || "ETH",
-          tickerName: (nativeCurrency === null || nativeCurrency === void 0 ? void 0 : nativeCurrency.name) || "Ether",
-          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) || 18,
-          logo: (iconUrls === null || iconUrls === void 0 ? void 0 : iconUrls[0]) || "https://images.toruswallet.io/eth.svg"
-        });
-      },
       switchChain: async params => {
         const {
           chainId
@@ -187,10 +163,11 @@ _EthereumSigningProvider = EthereumSigningProvider;
 _defineProperty(EthereumSigningProvider, "getProviderInstance", async params => {
   const providerFactory = new _EthereumSigningProvider({
     config: {
-      chainConfig: params.chainConfig
+      chain: params.chain,
+      chains: params.chains
     }
   });
-  await providerFactory.setupProvider(params.signMethods);
+  await providerFactory.setupProvider(params.signMethods, params.chain.chainId);
   return providerFactory;
 });
 

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/solana-provider/providers/injectedProviders/base/baseInjectedProvider.js

@@ -1,8 +1,8 @@
 import { JRPCEngine, providerFromEngine } from '@web3auth/auth';
 import { WalletLoginError } from '../../../../../base/errors/index.js';
+import { BaseProvider } from '../../../../base-provider/baseProvider.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 +15,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 +31,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

@@ -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,90 @@
+import { SolanaSignAndSendTransaction, SolanaSignTransaction, SolanaSignMessage } from '@solana/wallet-standard-features';
+import { PublicKey, VersionedTransaction } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { WalletLoginError } from '../../../../base/errors/index.js';
 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
+    });
   }
 }