@web3auth/no-modal 10.16.0 → 11.0.0-beta.1

package/dist/lib.esm/vue/composables/useWalletUI.js

@@ -1,7 +1,7 @@
 import { ref } from 'vue';
 import { useWalletServicesPlugin } from './useWalletServicesPlugin.js';
-import { WalletServicesPluginError } from '../../base/plugin/errors.js';
 import { log } from '../../base/loglevel.js';
+import { WalletServicesPluginError } from '../../base/plugin/errors.js';
 
 const useWalletUI = () => {
   const {

package/dist/lib.esm/vue/composables/useWallets.js

@@ -0,0 +1,35 @@
+import { ref } from 'vue';
+import { useWeb3AuthInner } from './useWeb3AuthInner.js';
+import { WalletInitializationError } from '../../base/errors/index.js';
+import { log } from '../../base/loglevel.js';
+
+const useWallets = () => {
+  const {
+    web3Auth
+  } = useWeb3AuthInner();
+  const loading = ref(false);
+  const error = ref(null);
+  const wallets = ref([]);
+  const syncWallets = async () => {
+    if (!web3Auth.value) throw WalletInitializationError.notReady();
+    error.value = null;
+    loading.value = true;
+    try {
+      const result = await web3Auth.value.getConnectedAccountsWithProviders();
+      wallets.value = result;
+    } catch (err) {
+      log.error("Error getting wallets", err);
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    loading,
+    error,
+    wallets,
+    syncWallets
+  };
+};
+
+export { useWallets };

package/dist/lib.esm/vue/composables/useWeb3Auth.js

@@ -1,32 +1,7 @@
 import { useWeb3AuthInner } from './useWeb3AuthInner.js';
 
 const useWeb3Auth = () => {
-  const {
-    initError,
-    isConnected,
-    isInitialized,
-    isInitializing,
-    isAuthorized,
-    provider,
-    status,
-    web3Auth,
-    getPlugin,
-    chainId,
-    chainNamespace
-  } = useWeb3AuthInner();
-  return {
-    initError,
-    isConnected,
-    isInitialized,
-    isInitializing,
-    isAuthorized,
-    provider,
-    status,
-    web3Auth,
-    chainId,
-    chainNamespace,
-    getPlugin
-  };
+  return useWeb3AuthInner();
 };
 
 export { useWeb3Auth };

package/dist/lib.esm/vue/composables/useWeb3AuthConnect.js

@@ -17,7 +17,7 @@ const useWeb3AuthConnect = () => {
     }
     if (newVal && !connectorName.value) {
       var _web3Auth$value;
-      connectorName.value = (_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.connectedConnectorName;
+      connectorName.value = (_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.primaryConnectorName;
     }
   }, {
     immediate: true
@@ -28,7 +28,7 @@ const useWeb3AuthConnect = () => {
       error.value = null;
       loading.value = true;
       const localProvider = await web3Auth.value.connectTo(connectorType, loginParams);
-      connectorName.value = web3Auth.value.connectedConnectorName;
+      connectorName.value = web3Auth.value.primaryConnectorName;
       return localProvider;
     } catch (err) {
       log.error("Error connecting", err);

package/dist/lib.esm/vue/composables/useWeb3AuthInner.js

@@ -1,11 +1,7 @@
-import { inject } from 'vue';
-import { Web3AuthContextKey } from '../../base/composables/index.js';
-import { WalletInitializationError } from '../../base/errors/index.js';
+import { useInjectedWeb3AuthInnerContext } from './useInjectedWeb3AuthInnerContext.js';
 
 const useWeb3AuthInner = () => {
-  const context = inject(Web3AuthContextKey);
-  if (!context) throw WalletInitializationError.fromCode(1000, "usage of `useWeb3Auth` not wrapped in `Web3AuthProvider`.");
-  return context;
+  return useInjectedWeb3AuthInnerContext();
 };
 
 export { useWeb3AuthInner };

package/dist/lib.esm/vue/index.js

@@ -1,10 +1,13 @@
+export { useWalletServicesInnerContextValue } from './useWalletServicesInnerContextValue.js';
+export { useWeb3AuthInnerContextValue } from './useWeb3AuthInnerContextValue.js';
 export { Web3AuthProvider } from './Web3AuthProvider.js';
 export { WalletServicesContextKey } from './context/WalletServicesContext.js';
+export { useAuthTokenInfo } from './composables/useAuthTokenInfo.js';
 export { useChain } from './composables/useChain.js';
 export { useCheckout } from './composables/useCheckout.js';
 export { useEnableMFA } from './composables/useEnableMFA.js';
 export { useFunding } from './composables/useFunding.js';
-export { useIdentityToken } from './composables/useIdentityToken.js';
+export { useInjectedWeb3AuthInnerContext } from './composables/useInjectedWeb3AuthInnerContext.js';
 export { useManageMFA } from './composables/useManageMFA.js';
 export { useReceive } from './composables/useReceive.js';
 export { useSwap } from './composables/useSwap.js';
@@ -12,6 +15,7 @@ export { useSwitchChain } from './composables/useSwitchChain.js';
 export { useWalletConnectScanner } from './composables/useWalletConnectScanner.js';
 export { useWalletServicesPlugin } from './composables/useWalletServicesPlugin.js';
 export { useWalletUI } from './composables/useWalletUI.js';
+export { useWallets } from './composables/useWallets.js';
 export { useWeb3Auth } from './composables/useWeb3Auth.js';
 export { useWeb3AuthConnect } from './composables/useWeb3AuthConnect.js';
 export { useWeb3AuthDisconnect } from './composables/useWeb3AuthDisconnect.js';

package/dist/lib.esm/vue/solana/composables/useSignAndSendTransaction.js

@@ -2,6 +2,7 @@ import { ref } from 'vue';
 import { WalletInitializationError } from '../../../base/errors/index.js';
 import { useSolanaWallet } from './useSolanaWallet.js';
 import { log } from '../../../base/loglevel.js';
+import { walletSignAndSendTransaction } from '../../../base/wallet/solana.js';
 
 const useSignAndSendTransaction = () => {
   const {
@@ -15,7 +16,7 @@ const useSignAndSendTransaction = () => {
     error.value = null;
     try {
       if (!solanaWallet.value) throw WalletInitializationError.notReady();
-      const signature = await solanaWallet.value.signAndSendTransaction(transaction);
+      const signature = await walletSignAndSendTransaction(solanaWallet.value, transaction);
       data.value = signature;
       return signature;
     } catch (err) {

package/dist/lib.esm/vue/solana/composables/useSignMessage.js

@@ -2,6 +2,7 @@ import { ref } from 'vue';
 import { useSolanaWallet } from './useSolanaWallet.js';
 import { WalletInitializationError } from '../../../base/errors/index.js';
 import { log } from '../../../base/loglevel.js';
+import { walletSignMessage } from '../../../base/wallet/solana.js';
 
 const useSignMessage = () => {
   const {
@@ -17,7 +18,7 @@ const useSignMessage = () => {
     try {
       var _accounts$value;
       if (!solanaWallet.value) throw WalletInitializationError.notReady();
-      const signature = await solanaWallet.value.signMessage(message, from !== null && from !== void 0 ? from : (_accounts$value = accounts.value) === null || _accounts$value === void 0 ? void 0 : _accounts$value[0]);
+      const signature = await walletSignMessage(solanaWallet.value, message, from !== null && from !== void 0 ? from : (_accounts$value = accounts.value) === null || _accounts$value === void 0 ? void 0 : _accounts$value[0]);
       data.value = signature;
       return signature;
     } catch (err) {

package/dist/lib.esm/vue/solana/composables/useSignTransaction.js

@@ -1,7 +1,8 @@
 import { ref } from 'vue';
-import { WalletInitializationError } from '../../../base/errors/index.js';
 import { useSolanaWallet } from './useSolanaWallet.js';
+import { WalletInitializationError } from '../../../base/errors/index.js';
 import { log } from '../../../base/loglevel.js';
+import { walletSignTransaction } from '../../../base/wallet/solana.js';
 
 const useSignTransaction = () => {
   const {
@@ -15,7 +16,7 @@ const useSignTransaction = () => {
     error.value = null;
     try {
       if (!solanaWallet.value) throw WalletInitializationError.notReady();
-      const signedTransaction = await solanaWallet.value.signTransaction(transaction);
+      const signedTransaction = await walletSignTransaction(solanaWallet.value, transaction);
       data.value = signedTransaction;
       return signedTransaction;
     } catch (err) {

package/dist/lib.esm/vue/solana/composables/useSolanaClient.js

@@ -0,0 +1,12 @@
+import { inject, ref } from 'vue';
+import { SOLANA_CLIENT_KEY } from '../constants.js';
+
+/**
+ * Injects the Solana Framework Kit client when inside SolanaProvider and Web3Auth is connected on Solana.
+ * Otherwise returns null.
+ */
+function useSolanaClient() {
+  return inject(SOLANA_CLIENT_KEY, ref(null));
+}
+
+export { useSolanaClient };

package/dist/lib.esm/vue/solana/composables/useSolanaWallet.js

@@ -1,64 +1,82 @@
-import { Connection } from '@solana/web3.js';
-import { ref, shallowRef, computed, watch } from 'vue';
+import { createSolanaRpc } from '@solana/kit';
+import { StandardEvents } from '@wallet-standard/features';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+import { ref, shallowRef, onScopeDispose, watch } from 'vue';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import { SolanaWallet } from '../../../providers/solana-provider/solanaWallet.js';
+import { WALLET_CONNECTORS } from '../../../base/wallet/index.js';
 import { useWeb3Auth } from '../../composables/useWeb3Auth.js';
 import { useChain } from '../../composables/useChain.js';
 
 const useSolanaWallet = () => {
   const {
-    provider,
+    connection,
     web3Auth
   } = useWeb3Auth();
   const {
     chainNamespace
   } = useChain();
-  const accounts = ref([]);
+  const accounts = ref(null);
   const solanaWallet = shallowRef(null);
-  const connection = shallowRef(null);
-  const isSolana = computed(() => chainNamespace.value === CHAIN_NAMESPACES.SOLANA);
-  const setupWallet = async () => {
-    var _web3Auth$value;
-    if (!isSolana.value) {
-      return;
-    }
-    if (!provider.value) {
-      return;
-    }
-    solanaWallet.value = new SolanaWallet(provider.value);
-    const result = await solanaWallet.value.getAccounts();
-    if ((result === null || result === void 0 ? void 0 : result.length) > 0) {
-      accounts.value = result;
-    }
-    if ((_web3Auth$value = web3Auth.value) !== null && _web3Auth$value !== void 0 && (_web3Auth$value = _web3Auth$value.currentChain) !== null && _web3Auth$value !== void 0 && _web3Auth$value.rpcTarget) {
-      connection.value = new Connection(web3Auth.value.currentChain.rpcTarget);
+  const rpc = shallowRef(null);
+  let unsubscribeStandardEvents = null;
+  const teardownWalletListeners = () => {
+    var _unsubscribeStandardE;
+    (_unsubscribeStandardE = unsubscribeStandardEvents) === null || _unsubscribeStandardE === void 0 || _unsubscribeStandardE();
+    unsubscribeStandardEvents = null;
+  };
+  const syncAccounts = () => {
+    var _solanaWallet$value$a, _solanaWallet$value;
+    const accts = (_solanaWallet$value$a = (_solanaWallet$value = solanaWallet.value) === null || _solanaWallet$value === void 0 ? void 0 : _solanaWallet$value.accounts.map(a => a.address)) !== null && _solanaWallet$value$a !== void 0 ? _solanaWallet$value$a : [];
+    accounts.value = accts.length > 0 ? accts : null;
+  };
+  const setupWallet = () => {
+    var _connection$value$sol, _connection$value, _web3Auth$value;
+    teardownWalletListeners();
+    const wallet = (_connection$value$sol = (_connection$value = connection.value) === null || _connection$value === void 0 ? void 0 : _connection$value.solanaWallet) !== null && _connection$value$sol !== void 0 ? _connection$value$sol : null;
+    if (!wallet) return;
+    solanaWallet.value = wallet;
+    syncAccounts();
+    unsubscribeStandardEvents = wallet.features[StandardEvents].on("change", syncAccounts);
+    if ((_web3Auth$value = web3Auth.value) !== null && _web3Auth$value !== void 0 && (_web3Auth$value = _web3Auth$value.currentChain) !== null && _web3Auth$value !== void 0 && _web3Auth$value.rpcTarget && chainNamespace.value === CHAIN_NAMESPACES.SOLANA) {
+      rpc.value = createSolanaRpc(web3Auth.value.currentChain.rpcTarget);
     }
   };
   const resetWallet = () => {
+    teardownWalletListeners();
     solanaWallet.value = null;
     accounts.value = null;
-    connection.value = null;
+    rpc.value = null;
   };
-  if (provider.value && !solanaWallet.value) {
-    setupWallet();
-  }
-  watch([provider, chainNamespace], async ([newProvider, newChainNamespace]) => {
-    if (!newProvider || newChainNamespace !== CHAIN_NAMESPACES.SOLANA) {
-      if (solanaWallet.value) {
-        resetWallet();
-      }
-      return;
+  onScopeDispose(teardownWalletListeners);
+  const getPrivateKey = async () => {
+    var _connection$value2, _web3Auth$value$prima;
+    if (!web3Auth.value) throw new Error("Web3Auth not initialized");
+    if (((_connection$value2 = connection.value) === null || _connection$value2 === void 0 ? void 0 : _connection$value2.connectorName) !== WALLET_CONNECTORS.AUTH) {
+      throw new Error("getPrivateKey is only supported with the Auth connector");
     }
-    if (newProvider && !solanaWallet.value) {
-      setupWallet();
+    const provider = (_web3Auth$value$prima = web3Auth.value.primaryConnector) === null || _web3Auth$value$prima === void 0 ? void 0 : _web3Auth$value$prima.provider;
+    if (!provider) throw new Error("Provider not available");
+    const privateKey = await provider.request({
+      method: SOLANA_METHOD_TYPES.SOLANA_PRIVATE_KEY
+    });
+    if (!privateKey) throw new Error("Failed to retrieve private key");
+    return privateKey;
+  };
+  watch([connection, chainNamespace], ([newConnection, newChainNamespace]) => {
+    if (!(newConnection !== null && newConnection !== void 0 && newConnection.solanaWallet)) {
+      if (solanaWallet.value) resetWallet();
+      return;
     }
+    // setup wallet if not setup or chain namespace is changed to solana
+    if (!solanaWallet.value || newChainNamespace === CHAIN_NAMESPACES.SOLANA) setupWallet();
   }, {
     immediate: true
   });
   return {
     solanaWallet,
     accounts,
-    connection
+    rpc,
+    getPrivateKey
   };
 };
 

package/dist/lib.esm/vue/solana/constants.js

@@ -0,0 +1,3 @@
+const SOLANA_CLIENT_KEY = Symbol("SolanaClient");
+
+export { SOLANA_CLIENT_KEY };

package/dist/lib.esm/vue/solana/index.js

@@ -1,4 +1,7 @@
+export { SOLANA_CLIENT_KEY } from './constants.js';
+export { SolanaProvider } from './provider.js';
 export { useSignAndSendTransaction } from './composables/useSignAndSendTransaction.js';
 export { useSignMessage } from './composables/useSignMessage.js';
 export { useSignTransaction } from './composables/useSignTransaction.js';
+export { useSolanaClient } from './composables/useSolanaClient.js';
 export { useSolanaWallet } from './composables/useSolanaWallet.js';

package/dist/lib.esm/vue/solana/provider.js

@@ -0,0 +1,99 @@
+import { createWalletStandardConnector, createClient } from '@solana/client';
+import { defineComponent, ref, provide, watch, h, Fragment } from 'vue';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { SOLANA_CLIENT_KEY } from './constants.js';
+import { useWeb3Auth } from '../composables/useWeb3Auth.js';
+import { log } from '../../base/loglevel.js';
+
+const disposeClient = async client => {
+  try {
+    await client.actions.disconnectWallet();
+  } catch (e) {
+    log.warn("Solana client disconnect", e);
+  }
+  client.destroy();
+};
+
+/**
+ * Syncs Web3Auth Solana connection with Framework Kit client.
+ * When user is connected via Web3Auth and current chain is Solana, creates a Framework Kit client
+ * with Web3Auth as the wallet connector and connects it (same pattern as Wagmi provider).
+ */
+const SolanaProvider = defineComponent({
+  name: "SolanaProvider",
+  setup(_, {
+    slots
+  }) {
+    const {
+      isConnected,
+      connection,
+      web3Auth
+    } = useWeb3Auth();
+    const clientRef = ref(null);
+
+    // provide the client to the app
+    provide(SOLANA_CLIENT_KEY, clientRef);
+
+    // watch for changes in the connection and chain namespace
+    watch([isConnected, connection], async ([newIsConnected, newConnection]) => {
+      var _web3Auth$value;
+      if (!newIsConnected || !(newConnection !== null && newConnection !== void 0 && newConnection.solanaWallet)) {
+        if (clientRef.value) {
+          await disposeClient(clientRef.value);
+          clientRef.value = null;
+        }
+        return;
+      }
+      const currentChain = web3Auth.value.currentChain;
+      let chainConfig;
+      if ((currentChain === null || currentChain === void 0 ? void 0 : currentChain.chainNamespace) === CHAIN_NAMESPACES.SOLANA) {
+        chainConfig = currentChain;
+      } else {
+        // use the 1st Solana chain if current chain is not solana
+        chainConfig = web3Auth.value.coreOptions.chains.find(c => c.chainNamespace === CHAIN_NAMESPACES.SOLANA);
+        if (!chainConfig) return;
+      }
+
+      // only reconnect for the primary connector
+      if (newConnection.connectorName !== ((_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.primaryConnectorName)) return;
+      const prevClient = clientRef.value;
+      try {
+        // create a wallet standard connector from connected wallet
+        const solanaWalletId = "wallet-standard:" + connection.value.connectorName;
+        const connector = createWalletStandardConnector(connection.value.solanaWallet, {
+          id: solanaWalletId,
+          name: connection.value.connectorName
+        });
+
+        // create a solana client
+        const {
+          rpcTarget,
+          wsTarget
+        } = chainConfig;
+        const client = createClient({
+          endpoint: rpcTarget,
+          websocketEndpoint: wsTarget,
+          walletConnectors: [connector]
+        });
+        clientRef.value = client;
+        if (prevClient) await disposeClient(prevClient);
+
+        // connect the client to the wallet
+        await client.actions.connectWallet(solanaWalletId, {
+          autoConnect: true
+        });
+      } catch (err) {
+        log.error("Failed to create or connect Solana client", err);
+        clientRef.value = null;
+      }
+    }, {
+      immediate: true
+    });
+    return () => {
+      var _slots$default, _slots$default2;
+      return h(Fragment, null, (_slots$default = (_slots$default2 = slots.default) === null || _slots$default2 === void 0 ? void 0 : _slots$default2.call(slots)) !== null && _slots$default !== void 0 ? _slots$default : []);
+    };
+  }
+});
+
+export { SolanaProvider };

package/dist/lib.esm/vue/useWalletServicesInnerContextValue.js

@@ -0,0 +1,58 @@
+import { shallowRef, ref, watch } from 'vue';
+import { EVM_PLUGINS, PLUGIN_EVENTS } from '../base/plugin/IPlugin.js';
+import { CONNECTED_STATUSES } from '../base/connector/connectorStatus.js';
+
+function useWalletServicesInnerContextValue(web3AuthContext) {
+  const {
+    getPlugin,
+    isInitialized,
+    isConnected
+  } = web3AuthContext;
+  const walletServicesPlugin = shallowRef(null);
+  const ready = ref(false);
+  const connecting = ref(false);
+  watch(isInitialized, newIsInitialized => {
+    if (newIsInitialized) {
+      const plugin = getPlugin(EVM_PLUGINS.WALLET_SERVICES);
+      walletServicesPlugin.value = plugin;
+    }
+  });
+  watch(isConnected, newIsConnected => {
+    if (newIsConnected) {
+      const plugin = getPlugin(EVM_PLUGINS.WALLET_SERVICES);
+      walletServicesPlugin.value = plugin;
+      // When rehydrating, the connected listener may be registered after the connected event is emitted.
+      if (CONNECTED_STATUSES.includes(plugin === null || plugin === void 0 ? void 0 : plugin.status)) ready.value = true;
+    }
+  });
+  watch(walletServicesPlugin, (newWalletServicesPlugin, prevWalletServicesPlugin) => {
+    const connectedListener = () => {
+      ready.value = true;
+    };
+    const disconnectedListener = () => {
+      ready.value = false;
+    };
+    const connectingListener = () => {
+      connecting.value = true;
+    };
+    const previousPlugin = prevWalletServicesPlugin;
+    const currentPlugin = newWalletServicesPlugin;
+    if (previousPlugin && currentPlugin !== previousPlugin) {
+      previousPlugin.removeListener(PLUGIN_EVENTS.CONNECTED, connectedListener);
+      previousPlugin.removeListener(PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+      previousPlugin.removeListener(PLUGIN_EVENTS.CONNECTING, connectingListener);
+    }
+    if (currentPlugin && currentPlugin !== previousPlugin) {
+      currentPlugin.on(PLUGIN_EVENTS.CONNECTED, connectedListener);
+      currentPlugin.on(PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+      currentPlugin.on(PLUGIN_EVENTS.CONNECTING, connectingListener);
+    }
+  });
+  return {
+    plugin: walletServicesPlugin,
+    ready,
+    connecting
+  };
+}
+
+export { useWalletServicesInnerContextValue };