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

package/dist/lib.esm/{adapters/base-evm-adapter/baseEvmAdapter.js → connectors/base-evm-connector/baseEvmConnector.js}

@@ -1,23 +1,24 @@
 import { signChallenge, verifySignedChallenge } from '@toruslabs/base-controllers';
-import { getChainConfig } from '../../base/chain/config.js';
-import { CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
-import { WalletLoginError } from '../../base/errors/index.js';
-import { getSavedToken, checkIfTokenIsExpired, saveToken, clearToken } from '../../base/adapter/utils.js';
-import { BaseAdapter } from '../../base/adapter/baseAdapter.js';
-import { ADAPTER_STATUS, ADAPTER_EVENTS } from '../../base/adapter/constants.js';
+import { EVM_METHOD_TYPES } from '@web3auth/ws-embed';
+import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import '@web3auth/auth';
+import { getSavedToken, checkIfTokenIsExpired, saveToken, clearToken } from '../../base/connector/utils.js';
+import '../../base/loglevel.js';
+import '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+import '../../base/wallet/index.js';
 
-class BaseEvmAdapter extends BaseAdapter {
-  async init(_) {
-    if (!this.chainConfig) this.chainConfig = getChainConfig(CHAIN_NAMESPACES.EIP155, 1);
-  }
+class BaseEvmConnector extends BaseConnector {
+  async init(_) {}
   async authenticateUser() {
-    if (!this.provider || this.status !== ADAPTER_STATUS.CONNECTED) throw WalletLoginError.notConnectedError();
-    const {
-      chainNamespace,
-      chainId
-    } = this.chainConfig;
+    if (!this.provider || this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError();
+    if (!this.coreOptions) throw WalletInitializationError.invalidParams("Please initialize Web3Auth with valid options");
     const accounts = await this.provider.request({
-      method: "eth_accounts"
+      method: EVM_METHOD_TYPES.GET_ACCOUNTS
     });
     if (accounts && accounts.length > 0) {
       const existingToken = getSavedToken(accounts[0], this.name);
@@ -29,6 +30,14 @@ class BaseEvmAdapter extends BaseAdapter {
           };
         }
       }
+      const chainId = await this.provider.request({
+        method: "eth_chainId"
+      });
+      const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!currentChainConfig) throw WalletInitializationError.invalidParams("chainConfig is required before authentication");
+      const {
+        chainNamespace
+      } = currentChainConfig;
       const payload = {
         domain: window.location.origin,
         uri: window.location.href,
@@ -41,10 +50,10 @@ class BaseEvmAdapter extends BaseAdapter {
       const challenge = await signChallenge(payload, chainNamespace);
       const hexChallenge = `0x${Buffer.from(challenge, "utf8").toString("hex")}`;
       const signedMessage = await this.provider.request({
-        method: "personal_sign",
+        method: EVM_METHOD_TYPES.PERSONAL_SIGN,
         params: [hexChallenge, accounts[0]]
       });
-      const idToken = await verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.sessionTime, this.clientId, this.web3AuthNetwork);
+      const idToken = await verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.coreOptions.sessionTime, this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
       saveToken(accounts[0], this.name, idToken);
       return {
         idToken
@@ -63,8 +72,8 @@ class BaseEvmAdapter extends BaseAdapter {
   }
   async disconnect() {
     this.rehydrated = false;
-    this.emit(ADAPTER_EVENTS.DISCONNECTED);
+    this.emit(CONNECTOR_EVENTS.DISCONNECTED);
   }
 }
 
-export { BaseEvmAdapter };
+export { BaseEvmConnector };

package/dist/lib.esm/connectors/base-solana-connector/baseSolanaConnector.js

@@ -0,0 +1,81 @@
+import { signChallenge, verifySignedChallenge } from '@toruslabs/base-controllers';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import '@web3auth/auth';
+import { getSavedToken, checkIfTokenIsExpired, saveToken, clearToken } from '../../base/connector/utils.js';
+import '../../base/loglevel.js';
+import '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+import '../../base/wallet/index.js';
+
+class BaseSolanaConnector extends BaseConnector {
+  async init(_) {}
+  async authenticateUser() {
+    if (!this.provider || this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError();
+    if (!this.coreOptions) throw WalletInitializationError.invalidParams("Please initialize Web3Auth with a valid options");
+    const accounts = await this.provider.request({
+      method: SOLANA_METHOD_TYPES.GET_ACCOUNTS
+    });
+    if (accounts && accounts.length > 0) {
+      const existingToken = getSavedToken(accounts[0], this.name);
+      if (existingToken) {
+        const isExpired = checkIfTokenIsExpired(existingToken);
+        if (!isExpired) {
+          return {
+            idToken: existingToken
+          };
+        }
+      }
+      const chainId = await this.provider.request({
+        method: "solana_chainId"
+      });
+      const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!currentChainConfig) throw WalletInitializationError.invalidParams("chainConfig is required before authentication");
+      const {
+        chainNamespace
+      } = currentChainConfig;
+      const payload = {
+        domain: window.location.origin,
+        uri: window.location.href,
+        address: accounts[0],
+        chainId: parseInt(chainId, 16),
+        version: "1",
+        nonce: Math.random().toString(36).slice(2),
+        issuedAt: new Date().toISOString()
+      };
+      const challenge = await signChallenge(payload, chainNamespace);
+      const signedMessage = await this.provider.request({
+        method: SOLANA_METHOD_TYPES.SIGN_MESSAGE,
+        params: {
+          data: challenge,
+          display: "utf8"
+        }
+      });
+      const idToken = await verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.coreOptions.sessionTime, this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
+      saveToken(accounts[0], this.name, idToken);
+      return {
+        idToken
+      };
+    }
+    throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+  }
+  async disconnectSession() {
+    super.checkDisconnectionRequirements();
+    const accounts = await this.provider.request({
+      method: SOLANA_METHOD_TYPES.GET_ACCOUNTS
+    });
+    if (accounts && accounts.length > 0) {
+      clearToken(accounts[0], this.name);
+    }
+  }
+  async disconnect() {
+    this.rehydrated = false;
+    this.emit(CONNECTOR_EVENTS.DISCONNECTED);
+  }
+}
+
+export { BaseSolanaConnector };

package/dist/lib.esm/connectors/coinbase-connector/coinbaseConnector.js

@@ -0,0 +1,157 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { createCoinbaseWalletSDK } from '@coinbase/wallet-sdk';
+import { WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import '@web3auth/auth';
+import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import 'jwt-decode';
+import '../../base/loglevel.js';
+import '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import '@toruslabs/constants';
+import '@toruslabs/http-helpers';
+import { BaseEvmConnector } from '../base-evm-connector/baseEvmConnector.js';
+
+class CoinbaseConnector extends BaseEvmConnector {
+  constructor(connectorOptions) {
+    super(connectorOptions);
+    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.EIP155);
+    _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.EIP155);
+    _defineProperty(this, "type", CONNECTOR_CATEGORY.EXTERNAL);
+    _defineProperty(this, "name", WALLET_CONNECTORS.COINBASE);
+    _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
+    _defineProperty(this, "coinbaseProvider", null);
+    _defineProperty(this, "coinbaseOptions", {
+      appName: "Web3Auth"
+    });
+    this.coinbaseOptions = _objectSpread(_objectSpread({}, this.coinbaseOptions), connectorOptions.connectorSettings);
+  }
+  get provider() {
+    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.coinbaseProvider) {
+      return this.coinbaseProvider;
+    }
+    return null;
+  }
+  set provider(_) {
+    throw new Error("Not implemented");
+  }
+  async init(options) {
+    await super.init(options);
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    super.checkInitializationRequirements({
+      chainConfig
+    });
+    const coinbaseInstance = createCoinbaseWalletSDK(_objectSpread(_objectSpread({}, this.coinbaseOptions), {}, {
+      preference: {
+        options: this.coinbaseOptions.options || "smartWalletOnly"
+      },
+      appChainIds: this.coreOptions.chains.map(x => Number.parseInt(x.chainId, 16)),
+      appName: this.coinbaseOptions.appName || "Web3Auth",
+      appLogoUrl: this.coinbaseOptions.appLogoUrl || ""
+    }));
+    this.coinbaseProvider = coinbaseInstance.getProvider();
+    this.status = CONNECTOR_STATUS.READY;
+    this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.COINBASE);
+    try {
+      if (options.autoConnect) {
+        this.rehydrated = true;
+        await this.connect({
+          chainId: options.chainId
+        });
+      }
+    } catch (error) {
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
+    }
+  }
+  async connect({
+    chainId
+  }) {
+    super.checkConnectionRequirements();
+    if (!this.coinbaseProvider) throw WalletLoginError.notConnectedError("Connector is not initialized");
+    this.status = CONNECTOR_STATUS.CONNECTING;
+    this.emit(CONNECTOR_EVENTS.CONNECTING, {
+      connector: WALLET_CONNECTORS.COINBASE
+    });
+    try {
+      const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+      if (!chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+      await this.coinbaseProvider.request({
+        method: "eth_requestAccounts"
+      });
+      const currentChainId = await this.coinbaseProvider.request({
+        method: "eth_chainId"
+      });
+      if (currentChainId !== chainConfig.chainId) {
+        await this.switchChain(chainConfig, true);
+      }
+      this.status = CONNECTOR_STATUS.CONNECTED;
+      if (!this.provider) throw WalletLoginError.notConnectedError("Failed to connect with provider");
+      this.provider.once("disconnect", () => {
+        // ready to be connected again
+        this.disconnect();
+      });
+      this.emit(CONNECTOR_EVENTS.CONNECTED, {
+        connector: WALLET_CONNECTORS.COINBASE,
+        reconnected: this.rehydrated,
+        provider: this.provider
+      });
+      return this.provider;
+    } catch (error) {
+      // ready again to be connected
+      this.status = CONNECTOR_STATUS.READY;
+      this.rehydrated = false;
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
+      if (error instanceof Web3AuthError) throw error;
+      throw WalletLoginError.connectionError("Failed to login with coinbase wallet", error);
+    }
+  }
+  async disconnect(options = {
+    cleanup: false
+  }) {
+    var _this$provider;
+    await super.disconnectSession();
+    (_this$provider = this.provider) === null || _this$provider === void 0 || _this$provider.removeAllListeners();
+    if (options.cleanup) {
+      this.status = CONNECTOR_STATUS.NOT_READY;
+      this.coinbaseProvider = null;
+    } else {
+      // ready to be connected again
+      this.status = CONNECTOR_STATUS.READY;
+    }
+    await super.disconnect();
+  }
+  async getUserInfo() {
+    if (this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    return {};
+  }
+  async switchChain(params, init = false) {
+    super.checkSwitchChainRequirements(params, init);
+    await this.coinbaseProvider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{
+        chainId: params.chainId
+      }]
+    });
+  }
+  async enableMFA() {
+    throw new Error("Method Not implemented");
+  }
+  async manageMFA() {
+    throw new Error("Method Not implemented");
+  }
+}
+const coinbaseConnector = params => {
+  return ({
+    coreOptions
+  }) => {
+    return new CoinbaseConnector({
+      connectorSettings: params,
+      coreOptions
+    });
+  };
+};
+
+export { coinbaseConnector };

package/dist/lib.esm/connectors/injected-evm-connector/index.js

@@ -0,0 +1,2 @@
+export { injectedEvmConnector } from './injectedEvmConnector.js';
+export { createStore as createMipd } from 'mipd';

package/dist/lib.esm/{adapters/default-evm-adapter/injectedEvmAdapter.js → connectors/injected-evm-connector/injectedEvmConnector.js}

@@ -1,25 +1,32 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { ADAPTER_NAMESPACES, CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
 import { WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import '@web3auth/auth';
+import '../../base/wallet/index.js';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import 'jwt-decode';
 import { log } from '../../base/loglevel.js';
-import { BaseEvmAdapter } from '../base-evm-adapter/baseEvmAdapter.js';
-import { ADAPTER_CATEGORY, ADAPTER_STATUS, ADAPTER_EVENTS } from '../../base/adapter/constants.js';
+import '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import { normalizeWalletName } from '../../base/utils.js';
+import { BaseEvmConnector } from '../base-evm-connector/baseEvmConnector.js';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
 
-class InjectedEvmAdapter extends BaseEvmAdapter {
+class InjectedEvmConnector extends BaseEvmConnector {
   constructor(options) {
     super(options);
-    _defineProperty(this, "adapterNamespace", ADAPTER_NAMESPACES.EIP155);
+    _defineProperty(this, "connectorNamespace", CONNECTOR_NAMESPACES.EIP155);
     _defineProperty(this, "currentChainNamespace", CHAIN_NAMESPACES.EIP155);
-    _defineProperty(this, "type", ADAPTER_CATEGORY.EXTERNAL);
+    _defineProperty(this, "type", CONNECTOR_CATEGORY.EXTERNAL);
     _defineProperty(this, "name", void 0);
     _defineProperty(this, "isInjected", true);
-    _defineProperty(this, "status", ADAPTER_STATUS.NOT_READY);
+    _defineProperty(this, "status", CONNECTOR_STATUS.NOT_READY);
     _defineProperty(this, "injectedProvider", null);
     this.name = options.name;
     this.injectedProvider = options.provider;
   }
   get provider() {
-    if (this.status !== ADAPTER_STATUS.NOT_READY && this.injectedProvider) {
+    if (this.status !== CONNECTOR_STATUS.NOT_READY && this.injectedProvider) {
       return this.injectedProvider;
     }
     return null;
@@ -27,43 +34,51 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
   set provider(_) {
     throw new Error("Not implemented");
   }
-  async init(options = {}) {
+  async init(options) {
     await super.init(options);
-    super.checkInitializationRequirements();
-    this.status = ADAPTER_STATUS.READY;
-    this.emit(ADAPTER_EVENTS.READY, this.name);
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    super.checkInitializationRequirements({
+      chainConfig
+    });
+    this.status = CONNECTOR_STATUS.READY;
+    this.emit(CONNECTOR_EVENTS.READY, this.name);
     try {
-      log.debug(`initializing ${this.name} injected adapter`);
+      log.debug(`initializing ${this.name} injected connector`);
       if (options.autoConnect) {
         this.rehydrated = true;
-        await this.connect();
+        await this.connect({
+          chainId: options.chainId
+        });
       }
     } catch (error) {
-      this.emit(ADAPTER_EVENTS.ERRORED, error);
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
     }
   }
-  async connect() {
+  async connect({
+    chainId
+  }) {
     super.checkConnectionRequirements();
     if (!this.injectedProvider) throw WalletLoginError.connectionError("Injected provider is not available");
-    if (!this.chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
-    this.status = ADAPTER_STATUS.CONNECTING;
-    this.emit(ADAPTER_EVENTS.CONNECTING, {
-      adapter: this.name
+    const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+    if (!chainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    this.status = CONNECTOR_STATUS.CONNECTING;
+    this.emit(CONNECTOR_EVENTS.CONNECTING, {
+      connector: this.name
     });
     try {
       await this.injectedProvider.request({
         method: "eth_requestAccounts"
       });
       // switch chain if not connected to the right chain
-      if (this.injectedProvider.chainId !== this.chainConfig.chainId) {
+      if (this.injectedProvider.chainId !== chainConfig.chainId) {
         try {
-          await this.switchChain(this.chainConfig, true);
-        } catch (error) {
-          await this.addChain(this.chainConfig, true);
-          await this.switchChain(this.chainConfig, true);
+          await this.switchChain(chainConfig, true);
+        } catch {
+          await this.addChain(chainConfig, true);
+          await this.switchChain(chainConfig, true);
         }
       }
-      this.status = ADAPTER_STATUS.CONNECTED;
+      this.status = CONNECTOR_STATUS.CONNECTED;
       const accountDisconnectHandler = accounts => {
         if (accounts.length === 0) {
           var _this$injectedProvide;
@@ -72,17 +87,17 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
         }
       };
       this.injectedProvider.on("accountsChanged", accountDisconnectHandler);
-      this.emit(ADAPTER_EVENTS.CONNECTED, {
-        adapter: this.name,
+      this.emit(CONNECTOR_EVENTS.CONNECTED, {
+        connector: this.name,
         reconnected: this.rehydrated,
         provider: this.injectedProvider
       });
       return this.injectedProvider;
     } catch (error) {
       // ready again to be connected
-      this.status = ADAPTER_STATUS.READY;
+      this.status = CONNECTOR_STATUS.READY;
       this.rehydrated = false;
-      this.emit(ADAPTER_EVENTS.ERRORED, error);
+      this.emit(CONNECTOR_EVENTS.ERRORED, error);
       if (error instanceof Web3AuthError) throw error;
       throw WalletLoginError.connectionError(`Failed to login with ${this.name} injected wallet`);
     }
@@ -100,23 +115,24 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
           eth_accounts: {}
         }]
       });
-    } catch (error) {}
+    } catch {
+      // ignore error
+    }
     if (options.cleanup) {
-      this.status = ADAPTER_STATUS.NOT_READY;
+      this.status = CONNECTOR_STATUS.NOT_READY;
       this.injectedProvider = null;
     } else {
       // ready to be connected again
-      this.status = ADAPTER_STATUS.READY;
+      this.status = CONNECTOR_STATUS.READY;
     }
     await super.disconnect();
   }
   async getUserInfo() {
-    if (this.status !== ADAPTER_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+    if (this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
     return {};
   }
-  async addChain(chainConfig, init = false) {
+  async addChain(chainConfig, _init = false) {
     if (!this.injectedProvider) throw WalletLoginError.connectionError("Injected provider is not available");
-    super.checkAddChainRequirements(chainConfig, init);
     await this.injectedProvider.request({
       method: "wallet_addEthereumChain",
       params: [{
@@ -132,7 +148,6 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
         iconUrls: [chainConfig.logo]
       }]
     });
-    this.addChainConfig(chainConfig);
   }
   async switchChain(params, init = false) {
     if (!this.injectedProvider) throw WalletLoginError.connectionError("Injected provider is not available");
@@ -143,9 +158,6 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
         chainId: params.chainId
       }]
     });
-    this.setAdapterSettings({
-      chainConfig: this.getChainConfig(params.chainId)
-    });
   }
   async enableMFA() {
     throw new Error("Method Not implemented");
@@ -154,5 +166,16 @@ class InjectedEvmAdapter extends BaseEvmAdapter {
     throw new Error("Method Not implemented");
   }
 }
+const injectedEvmConnector = providerDetail => {
+  return ({
+    coreOptions
+  }) => {
+    return new InjectedEvmConnector({
+      name: normalizeWalletName(providerDetail.info.name),
+      provider: providerDetail.provider,
+      coreOptions
+    });
+  };
+};
 
-export { InjectedEvmAdapter };
+export { InjectedEvmConnector, injectedEvmConnector };

package/dist/lib.esm/connectors/injected-solana-connector/index.js

@@ -0,0 +1,18 @@
+import { SolanaSignMessage, SolanaSignTransaction, SolanaSignAndSendTransaction } from '@solana/wallet-standard-features';
+export { getWallets as createSolanaMipd } from '@wallet-standard/app';
+import { StandardConnect } from '@wallet-standard/features';
+export { walletStandardConnector } from './walletStandardConnector.js';
+
+const hasSolanaWalletStandardFeatures = wallet => {
+  const {
+    chains,
+    features
+  } = wallet;
+  const isSolana = chains.some(chain => chain.startsWith("solana"));
+  if (!isSolana) return;
+  const hasRequiredFeatures = [StandardConnect, SolanaSignMessage, SolanaSignTransaction, SolanaSignAndSendTransaction].every(feature => Object.keys(features).includes(feature));
+  if (!hasRequiredFeatures) return false;
+  return true;
+};
+
+export { hasSolanaWalletStandardFeatures };