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

package/dist/lib.esm/connectors/wallet-connect-v2-connector/WalletConnectV2Provider.js

@@ -1,16 +1,14 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { getAccountsFromNamespaces, parseAccountId } from '@walletconnect/utils';
-import { providerErrors, JRPCEngine, providerFromEngine } from '@web3auth/auth';
+import { providerErrors, JRPCEngineV2, providerFromEngineV2 } from '@web3auth/auth';
 import { formatChainId } from './utils.js';
-import { switchChain, addChain, getAccounts, getEthProviderHandlers, getSolProviderHandlers } from './walletConnectV2Utils.js';
-import { createEthMiddleware, createEthChainSwitchMiddleware } from '../../providers/ethereum-provider/rpc/ethRpcMiddlewares.js';
-import { createEthJsonRpcClient } from '../../providers/ethereum-provider/rpc/jrpcClient.js';
-import { createSolanaMiddleware } from '../../providers/solana-provider/rpc/solanaRpcMiddlewares.js';
-import { createSolanaJsonRpcClient } from '../../providers/solana-provider/rpc/JrpcClient.js';
+import { switchChain, addChain, getAccounts, getEthProviderHandlers } from './walletConnectV2Utils.js';
 import { BaseProvider } from '../../providers/base-provider/baseProvider.js';
 import { WalletLoginError } from '../../base/errors/index.js';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { createEthMiddleware, createEthChainSwitchMiddleware } from '../../providers/ethereum-provider/rpc/ethRpcMiddlewares.js';
+import { createEthJsonRpcClient } from '../../providers/ethereum-provider/rpc/jrpcClient.js';
 import { log } from '../../base/loglevel.js';
 
 var _WalletConnectV2Provider;
@@ -91,7 +89,11 @@ class WalletConnectV2Provider extends BaseProvider {
     if (chain.chainNamespace === CHAIN_NAMESPACES.EIP155) {
       await this.setupEthEngine(connector, chainId);
     } else if (chain.chainNamespace === CHAIN_NAMESPACES.SOLANA) {
-      await this.setupSolEngine(connector, chainId);
+      // Solana operations are handled via WCSolanaWallet directly; only update accounts state.
+      const accounts = await getAccounts(connector);
+      this.update({
+        accounts: accounts || []
+      });
     } else {
       throw new Error(`Unsupported chainNamespace: ${chain.chainNamespace}`);
     }
@@ -116,34 +118,13 @@ class WalletConnectV2Provider extends BaseProvider {
     });
     const ethMiddleware = createEthMiddleware(providerHandlers);
     const chainSwitchMiddleware = this.getEthChainSwitchMiddleware();
-    const engine = new JRPCEngine();
     const {
       networkMiddleware
     } = createEthJsonRpcClient(chain);
-    engine.push(ethMiddleware);
-    engine.push(chainSwitchMiddleware);
-    engine.push(networkMiddleware);
-    const provider = providerFromEngine(engine);
-    this.updateProviderEngineProxy(provider);
-  }
-  async setupSolEngine(connector, chainId) {
-    const chain = this.getChain(chainId);
-    const providerHandlers = getSolProviderHandlers({
-      connector,
-      chainId
+    const engine = JRPCEngineV2.create({
+      middleware: [ethMiddleware, chainSwitchMiddleware, networkMiddleware]
     });
-    const jrpcRes = await getAccounts(connector);
-    this.update({
-      accounts: jrpcRes || []
-    });
-    const solMiddleware = createSolanaMiddleware(providerHandlers);
-    const engine = new JRPCEngine();
-    const {
-      networkMiddleware
-    } = createSolanaJsonRpcClient(chain);
-    engine.push(solMiddleware);
-    engine.push(networkMiddleware);
-    const provider = providerFromEngine(engine);
+    const provider = providerFromEngineV2(engine);
     this.updateProviderEngineProxy(provider);
   }
   getEthChainSwitchMiddleware() {

package/dist/lib.esm/connectors/wallet-connect-v2-connector/config.js

@@ -1,6 +1,6 @@
 import { getSiteIcon, getSiteName } from '../utils.js';
-import { SOLANA_CAIP_CHAIN_MAP } from '../../base/constants.js';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { SOLANA_CAIP_CHAIN_MAP } from '../../base/constants.js';
 
 let DEFAULT_EIP155_METHODS = /*#__PURE__*/function (DEFAULT_EIP155_METHODS) {
   DEFAULT_EIP155_METHODS["ETH_SEND_TRANSACTION"] = "eth_sendTransaction";

package/dist/lib.esm/connectors/wallet-connect-v2-connector/walletConnectV2Connector.js

@@ -1,21 +1,24 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { CHAIN_NAMESPACES, getErrorAnalyticsProperties, signChallenge, verifySignedChallenge } from '@toruslabs/base-controllers';
+import { CHAIN_NAMESPACES, getErrorAnalyticsProperties, signChallenge } from '@toruslabs/base-controllers';
 import Client from '@walletconnect/sign-client';
 import { isValidArray, getSdkError } from '@walletconnect/utils';
-import { EVM_METHOD_TYPES, SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+import { EVM_METHOD_TYPES } from '@web3auth/ws-embed';
 import deepmerge from 'deepmerge';
+import { generateSiweNonce } from 'viem/siwe';
 import { getWalletConnectV2Settings } from './config.js';
 import { WalletConnectV2Provider } from './WalletConnectV2Provider.js';
-import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { WCSolanaWallet } from './wcSolanaWallet.js';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
 import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
-import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
 import { WalletInitializationError, WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
 import { log } from '../../base/loglevel.js';
-import { getCaipChainId } from '../../base/utils.js';
+import { getCaipChainId, citadelServerUrl } from '../../base/utils.js';
 import { ANALYTICS_EVENTS } from '../../base/analytics.js';
-import { getSavedToken, checkIfTokenIsExpired, saveToken } from '../../base/connector/utils.js';
+import { SOLANA_CAIP_CHAIN_MAP } from '../../base/constants.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import { walletSignMessage } from '../../base/wallet/solana.js';
 
 class WalletConnectV2Connector extends BaseConnector {
   constructor(options) {
@@ -33,6 +36,7 @@ class WalletConnectV2Connector extends BaseConnector {
     _defineProperty(this, "connector", null);
     _defineProperty(this, "activeSession", null);
     _defineProperty(this, "wcProvider", null);
+    _defineProperty(this, "_solanaWallet", null);
     _defineProperty(this, "analytics", void 0);
     this.connectorOptions = _objectSpread({}, options);
     const {
@@ -60,6 +64,9 @@ class WalletConnectV2Connector extends BaseConnector {
     }
     return null;
   }
+  get solanaWallet() {
+    return this._solanaWallet;
+  }
   set provider(_) {
     throw new Error("Not implemented");
   }
@@ -100,7 +107,7 @@ class WalletConnectV2Connector extends BaseConnector {
         try {
           await this.onConnectHandler({
             chain: chainConfig,
-            getIdentityToken: options.getIdentityToken
+            getAuthTokenInfo: options.getAuthTokenInfo
           });
         } catch (error) {
           log.error("wallet auto connect", error);
@@ -114,7 +121,7 @@ class WalletConnectV2Connector extends BaseConnector {
   }
   async connect({
     chainId,
-    getIdentityToken
+    getAuthTokenInfo
   }) {
     super.checkConnectionRequirements();
     const chainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
@@ -167,18 +174,26 @@ class WalletConnectV2Connector extends BaseConnector {
       if (this.connected) {
         await this.onConnectHandler({
           chain: chainConfig,
-          getIdentityToken
+          getAuthTokenInfo
         });
-        return this.provider;
+        return {
+          ethereumProvider: this.provider,
+          solanaWallet: this._solanaWallet,
+          connectorName: this.name
+        };
       }
       if (this.status !== CONNECTOR_STATUS.CONNECTING) {
         await this.createNewSession({
           chainConfig,
           trackCompletionEvents,
-          getIdentityToken
+          getAuthTokenInfo
         });
       }
-      return this.provider;
+      return {
+        ethereumProvider: this.provider,
+        solanaWallet: this._solanaWallet,
+        connectorName: this.name
+      };
     } catch (error) {
       log.error("Wallet connect v2 connector error while connecting", error);
       // ready again to be connected
@@ -227,7 +242,9 @@ class WalletConnectV2Connector extends BaseConnector {
       topic: (_this$activeSession3 = this.activeSession) === null || _this$activeSession3 === void 0 ? void 0 : _this$activeSession3.topic,
       reason: getSdkError("USER_DISCONNECTED")
     });
+    await this.clearWalletSession();
     this.rehydrated = false;
+    this._solanaWallet = null;
     if (cleanup) {
       this.connector = null;
       this.status = CONNECTOR_STATUS.NOT_READY;
@@ -237,9 +254,11 @@ class WalletConnectV2Connector extends BaseConnector {
       this.status = CONNECTOR_STATUS.READY;
     }
     this.activeSession = null;
-    this.emit(CONNECTOR_EVENTS.DISCONNECTED);
+    this.emit(CONNECTOR_EVENTS.DISCONNECTED, {
+      connector: WALLET_CONNECTORS.WALLET_CONNECT_V2
+    });
   }
-  async getIdentityToken() {
+  async getAuthTokenInfo() {
     if (!this.provider || !this.canAuthorize) throw WalletLoginError.notConnectedError();
     this.status = CONNECTOR_STATUS.AUTHORIZING;
     this.emit(CONNECTOR_EVENTS.AUTHORIZING, {
@@ -253,52 +272,59 @@ class WalletConnectV2Connector extends BaseConnector {
     const {
       chainNamespace
     } = currentChainConfig;
-    const accounts = await this.provider.request({
-      method: chainNamespace === CHAIN_NAMESPACES.EIP155 ? EVM_METHOD_TYPES.GET_ACCOUNTS : SOLANA_METHOD_TYPES.GET_ACCOUNTS
+    const accounts = chainNamespace === CHAIN_NAMESPACES.SOLANA && this._solanaWallet ? this._solanaWallet.accounts.map(a => a.address) : await this.provider.request({
+      method: EVM_METHOD_TYPES.GET_ACCOUNTS
     });
     if (accounts && accounts.length > 0) {
-      const existingToken = getSavedToken(accounts[0], this.name);
-      if (existingToken) {
-        const isExpired = checkIfTokenIsExpired(existingToken);
-        if (!isExpired) {
-          this.status = CONNECTOR_STATUS.AUTHORIZED;
-          this.emit(CONNECTOR_EVENTS.AUTHORIZED, {
-            connector: WALLET_CONNECTORS.WALLET_CONNECT_V2,
-            identityTokenInfo: {
-              idToken: existingToken
-            }
-          });
-          return {
-            idToken: existingToken
-          };
-        }
-      }
-      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._getSignedMessage(challenge, accounts, chainNamespace);
-      const idToken = await verifySignedChallenge(chainNamespace, signedMessage, challenge, this.name, this.coreOptions.sessionTime, this.coreOptions.clientId, this.coreOptions.web3AuthNetwork);
-      saveToken(accounts[0], this.name, idToken);
-      this.status = CONNECTOR_STATUS.AUTHORIZED;
-      this.emit(CONNECTOR_EVENTS.AUTHORIZED, {
-        connector: WALLET_CONNECTORS.WALLET_CONNECT_V2,
-        identityTokenInfo: {
-          idToken
-        }
+      const cached = await this.getCachedOrNullAuthTokenInfo(accounts[0]);
+      if (cached) return cached;
+      const authServer = citadelServerUrl(this.coreOptions.authBuildEnv);
+      const {
+        challenge,
+        signature
+      } = await this.generateChallengeAndSign(authServer, accounts);
+      return this.verifyAndAuthorize({
+        chainNamespace,
+        signedMessage: signature,
+        challenge,
+        authServer
       });
-      return {
-        idToken
-      };
     }
     throw WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
   }
+  async generateChallengeAndSign(authServerUrl, accounts) {
+    const {
+      chainId
+    } = this.provider;
+    const currentChainConfig = this.coreOptions.chains.find(x => x.chainId === chainId);
+    if (!currentChainConfig) throw WalletLoginError.connectionError("Chain config is not available");
+    const {
+      chainNamespace
+    } = currentChainConfig;
+    const accountsToUse = accounts || (chainNamespace === CHAIN_NAMESPACES.SOLANA && this._solanaWallet ? this._solanaWallet.accounts.map(a => a.address) : await this.provider.request({
+      method: EVM_METHOD_TYPES.GET_ACCOUNTS
+    }));
+    if (!accountsToUse || accountsToUse.length === 0) {
+      throw WalletLoginError.notConnectedError("No accounts found in the connected wallet");
+    }
+    const payload = {
+      domain: window.location.origin,
+      uri: window.location.href,
+      address: accountsToUse[0],
+      chainId: parseInt(chainId, 16),
+      version: "1",
+      nonce: generateSiweNonce(),
+      issuedAt: new Date().toISOString()
+    };
+    const authServer = authServerUrl || citadelServerUrl(this.coreOptions.authBuildEnv);
+    const challenge = await signChallenge(payload, chainNamespace, authServer);
+    const signature = await this._getSignedMessage(challenge, accountsToUse, chainNamespace);
+    return {
+      challenge,
+      signature,
+      chainNamespace
+    };
+  }
   async enableMFA() {
     throw new Error("Method Not implemented");
   }
@@ -329,7 +355,7 @@ class WalletConnectV2Connector extends BaseConnector {
     forceNewSession = false,
     chainConfig,
     trackCompletionEvents,
-    getIdentityToken
+    getAuthTokenInfo
   }) {
     try {
       var _this$activeSession4, _this$connectorOption7;
@@ -379,7 +405,7 @@ class WalletConnectV2Connector extends BaseConnector {
       await this.onConnectHandler({
         chain: chainConfig,
         trackCompletionEvents,
-        getIdentityToken
+        getAuthTokenInfo
       });
       if (qrcodeModal) {
         qrcodeModal.closeModal();
@@ -394,7 +420,7 @@ class WalletConnectV2Connector extends BaseConnector {
           return this.createNewSession({
             forceNewSession: true,
             chainConfig,
-            getIdentityToken
+            getAuthTokenInfo
           });
         }
         if (this.status === CONNECTOR_STATUS.READY) {
@@ -410,9 +436,9 @@ class WalletConnectV2Connector extends BaseConnector {
   async onConnectHandler({
     chain,
     trackCompletionEvents,
-    getIdentityToken
+    getAuthTokenInfo
   }) {
-    var _this$connectorOption8;
+    var _this$connectorOption8, _this$activeSession$n, _this$activeSession6;
     if (!this.connector || !this.wcProvider) throw WalletInitializationError.notReady("Wallet connect connector is not ready yet");
     this.subscribeEvents();
     if ((_this$connectorOption8 = this.connectorOptions.connectorSettings) !== null && _this$connectorOption8 !== void 0 && _this$connectorOption8.qrcodeModal) {
@@ -426,20 +452,31 @@ class WalletConnectV2Connector extends BaseConnector {
       });
     }
     await this.wcProvider.setupProvider(this.connector);
+    // Derive the active Solana chain from the WC session namespaces (genesis hash → hex chainId),
+    // rather than picking the first Solana chain from coreOptions which may not match the session.
+    const sessionSolanaChains = (_this$activeSession$n = (_this$activeSession6 = this.activeSession) === null || _this$activeSession6 === void 0 || (_this$activeSession6 = _this$activeSession6.namespaces) === null || _this$activeSession6 === void 0 || (_this$activeSession6 = _this$activeSession6.solana) === null || _this$activeSession6 === void 0 ? void 0 : _this$activeSession6.chains) !== null && _this$activeSession$n !== void 0 ? _this$activeSession$n : [];
+    if (sessionSolanaChains.length > 0) {
+      const reverseMap = Object.fromEntries(Object.entries(SOLANA_CAIP_CHAIN_MAP).map(([hex, hash]) => [hash, hex]));
+      const genesisHash = sessionSolanaChains[0].split(":")[1];
+      const hexChainId = reverseMap[genesisHash];
+      const solanaChain = hexChainId ? this.coreOptions.chains.find(c => c.chainId === hexChainId) : null;
+      if (solanaChain) {
+        this._solanaWallet = await WCSolanaWallet.create(this.connector, solanaChain);
+      }
+    }
     this.cleanupPendingPairings();
     this.status = CONNECTOR_STATUS.CONNECTED;
 
     // track connection events
     if (trackCompletionEvents) trackCompletionEvents();
-    let identityTokenInfo;
     this.emit(CONNECTOR_EVENTS.CONNECTED, {
-      connector: WALLET_CONNECTORS.WALLET_CONNECT_V2,
+      connectorName: WALLET_CONNECTORS.WALLET_CONNECT_V2,
       reconnected: this.rehydrated,
-      provider: this.provider,
-      identityTokenInfo
+      ethereumProvider: this.provider,
+      solanaWallet: this._solanaWallet
     });
-    if (getIdentityToken) {
-      identityTokenInfo = await this.getIdentityToken();
+    if (getAuthTokenInfo) {
+      await this.getAuthTokenInfo();
     }
   }
   subscribeEvents() {
@@ -469,10 +506,10 @@ class WalletConnectV2Connector extends BaseConnector {
     this.connector.events.on("session_expire", ({
       topic
     }) => {
-      var _this$activeSession6;
+      var _this$activeSession7;
       // Session has expired -> clean up the session
       log.info("Session expired event received for topic:", topic);
-      if (((_this$activeSession6 = this.activeSession) === null || _this$activeSession6 === void 0 ? void 0 : _this$activeSession6.topic) === topic) {
+      if (((_this$activeSession7 = this.activeSession) === null || _this$activeSession7 === void 0 ? void 0 : _this$activeSession7.topic) === topic) {
         this.disconnect({
           sessionRemovedByWallet: true
         }).catch(error => {
@@ -482,13 +519,13 @@ class WalletConnectV2Connector extends BaseConnector {
     });
   }
   async _getSignedMessage(challenge, accounts, chainNamespace) {
-    const signedMessage = await this.provider.request({
-      method: chainNamespace === CHAIN_NAMESPACES.EIP155 ? EVM_METHOD_TYPES.PERSONAL_SIGN : SOLANA_METHOD_TYPES.SIGN_MESSAGE,
-      params: chainNamespace === CHAIN_NAMESPACES.EIP155 ? [challenge, accounts[0]] : {
-        data: challenge
-      }
+    if (chainNamespace === CHAIN_NAMESPACES.SOLANA && this._solanaWallet) {
+      return walletSignMessage(this._solanaWallet, challenge, accounts[0]);
+    }
+    return this.provider.request({
+      method: EVM_METHOD_TYPES.PERSONAL_SIGN,
+      params: [challenge, accounts[0]]
     });
-    return signedMessage;
   }
 }
 const walletConnectV2Connector = params => {

package/dist/lib.esm/connectors/wallet-connect-v2-connector/walletConnectV2Utils.js

@@ -1,12 +1,11 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
-import { bs58 } from '@toruslabs/bs58';
 import { EIP_5792_METHODS } from '@toruslabs/ethereum-controllers';
 import { getAccountsFromNamespaces, parseAccountId } from '@walletconnect/utils';
 import { providerErrors, rpcErrors } from '@web3auth/auth';
-import { EVM_METHOD_TYPES, SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+import { EVM_METHOD_TYPES } from '@web3auth/ws-embed';
 import { formatChainId } from './utils.js';
 import { WalletLoginError } from '../../base/errors/index.js';
-import { SOLANA_CAIP_CHAIN_MAP } from '../../base/constants.js';
+import { log } from '../../base/loglevel.js';
 
 async function getLastActiveSession(signClient) {
   if (signClient.session.length) {
@@ -28,7 +27,16 @@ async function sendJrpcRequest(signClient, chainId, method, params) {
   }
   if (typeof window !== "undefined" && isMobileDevice()) {
     if (session.peer.metadata.redirect && session.peer.metadata.redirect.native) {
-      window.open(session.peer.metadata.redirect.native, "_blank");
+      const redirectUrl = session.peer.metadata.redirect.native;
+      try {
+        const parsedUrl = new URL(redirectUrl);
+        if (["javascript:", "data:", "vbscript:"].includes(parsedUrl.protocol)) {
+          throw new Error("Invalid redirect scheme");
+        }
+        window.open(parsedUrl.href, "_blank");
+      } catch (e) {
+        log.error("Invalid redirect URL", e);
+      }
     }
   }
   return signClient.request({
@@ -55,6 +63,14 @@ async function getAccounts(signClient) {
   }
   throw WalletLoginError.connectionError("Failed to get accounts");
 }
+async function getSolanaAccounts(signClient) {
+  const session = await getLastActiveSession(signClient);
+  if (!session) {
+    throw providerErrors.disconnected();
+  }
+  const accounts = getAccountsFromNamespaces(session.namespaces);
+  return [...new Set(accounts.filter(add => add.startsWith("solana:")).map(add => parseAccountId(add).address))];
+}
 function getEthProviderHandlers({
   connector,
   chainId
@@ -110,50 +126,6 @@ function getEthProviderHandlers({
     }
   };
 }
-function getSolProviderHandlers({
-  connector,
-  chainId
-}) {
-  return {
-    requestAccounts: async _ => {
-      return getAccounts(connector);
-    },
-    getPrivateKey: async () => {
-      throw rpcErrors.methodNotSupported();
-    },
-    getSecretKey: async () => {
-      throw rpcErrors.methodNotSupported();
-    },
-    getPublicKey: async () => {
-      throw rpcErrors.methodNotSupported();
-    },
-    getAccounts: async _ => {
-      return getAccounts(connector);
-    },
-    signAllTransactions: async _ => {
-      throw rpcErrors.methodNotSupported();
-    },
-    signAndSendTransaction: async _ => {
-      throw rpcErrors.methodNotSupported();
-    },
-    signMessage: async req => {
-      const methodRes = await sendJrpcRequest(connector, `solana:${SOLANA_CAIP_CHAIN_MAP[chainId]}`, SOLANA_METHOD_TYPES.SIGN_MESSAGE, {
-        message: bs58.encode(Buffer.from(req.params.data, "utf-8"))
-      });
-      return methodRes.signature;
-    },
-    signTransaction: async req => {
-      const accounts = await getAccounts(connector);
-      if (accounts.length === 0) {
-        throw providerErrors.disconnected();
-      }
-      const methodRes = await sendJrpcRequest(connector, `solana:${SOLANA_CAIP_CHAIN_MAP[chainId]}`, SOLANA_METHOD_TYPES.SIGN_TRANSACTION, {
-        transaction: req.params.message
-      });
-      return methodRes.signature;
-    }
-  };
-}
 async function switchChain({
   connector,
   chainId,
@@ -181,4 +153,4 @@ async function addChain({
   await sendJrpcRequest(connector, `eip155:${chainId}`, "wallet_addEthereumChain", [formattedChainConfig]);
 }
 
-export { addChain, getAccounts, getEthProviderHandlers, getSolProviderHandlers, sendJrpcRequest, switchChain };
+export { addChain, getAccounts, getEthProviderHandlers, getSolanaAccounts, sendJrpcRequest, switchChain };

package/dist/lib.esm/connectors/wallet-connect-v2-connector/wcSolanaWallet.js

@@ -0,0 +1,130 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { getBase64EncodedWireTransaction, getBase64Decoder, getBase58Encoder, getTransactionDecoder, getBase64Encoder, getBase58Decoder } from '@solana/kit';
+import { SolanaSignTransaction, SolanaSignMessage, SolanaSignAndSendTransaction } from '@solana/wallet-standard-features';
+import { StandardEvents, StandardDisconnect, StandardConnect } from '@wallet-standard/features';
+import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
+import { sendJrpcRequest, getSolanaAccounts } from './walletConnectV2Utils.js';
+import { WEB3AUTH_ICON } from '../../base/wallet/index.js';
+import { SOLANA_CAIP_CHAIN_MAP } from '../../base/constants.js';
+import { getSolanaChainByChainConfig } from '../../base/wallet/solana.js';
+
+const base58Encoder = getBase58Encoder();
+const base58Decoder = getBase58Decoder();
+const base64Decoder = getBase64Decoder();
+const base64Encoder = getBase64Encoder();
+const transactionDecoder = getTransactionDecoder();
+/**
+ * WCSolanaWallet implements the Wallet Standard interface by routing directly to
+ * a WalletConnect SignClient — no intermediate JRPC engine needed.
+ */
+class WCSolanaWallet {
+  constructor(connector, wcCaipChainId, chainIdentifier, accounts) {
+    _defineProperty(this, "version", "1.0.0");
+    _defineProperty(this, "name", "WalletConnect");
+    _defineProperty(this, "icon", WEB3AUTH_ICON);
+    _defineProperty(this, "chains", void 0);
+    _defineProperty(this, "features", void 0);
+    _defineProperty(this, "_accounts", void 0);
+    _defineProperty(this, "_listeners", {});
+    this.chains = chainIdentifier ? [chainIdentifier] : [];
+    this._accounts = accounts;
+    this.features = {
+      [StandardConnect]: {
+        version: "1.0.0",
+        connect: async () => ({
+          accounts: this._accounts
+        })
+      },
+      [StandardDisconnect]: {
+        version: "1.0.0",
+        disconnect: async () => {}
+      },
+      [StandardEvents]: {
+        version: "1.0.0",
+        on: (event, listener) => {
+          var _this$_listeners, _this$_listeners$even;
+          ((_this$_listeners$even = (_this$_listeners = this._listeners)[event]) !== null && _this$_listeners$even !== void 0 ? _this$_listeners$even : _this$_listeners[event] = new Set()).add(listener);
+          return () => this._listeners[event].delete(listener);
+        }
+      },
+      [SolanaSignAndSendTransaction]: {
+        version: "1.0.0",
+        supportedTransactionVersions: ["legacy", 0],
+        signAndSendTransaction: async (...inputs) => {
+          return Promise.all(inputs.map(async input => {
+            const base64Tx = base64Decoder.decode(input.transaction);
+            const result = await sendJrpcRequest(connector, wcCaipChainId, "solana_signAndSendTransaction", {
+              transaction: base64Tx
+            });
+            return {
+              signature: new Uint8Array(base58Encoder.encode(result.signature))
+            };
+          }));
+        }
+      },
+      [SolanaSignMessage]: {
+        version: "1.0.0",
+        signMessage: async (...inputs) => {
+          return Promise.all(inputs.map(async input => {
+            const base58Message = base58Decoder.decode(new Uint8Array(input.message));
+            const result = await sendJrpcRequest(connector, wcCaipChainId, SOLANA_METHOD_TYPES.SIGN_MESSAGE, {
+              message: base58Message
+            });
+            return {
+              signedMessage: new Uint8Array(input.message),
+              signature: new Uint8Array(base58Encoder.encode(result.signature))
+            };
+          }));
+        }
+      },
+      [SolanaSignTransaction]: {
+        version: "1.0.0",
+        supportedTransactionVersions: ["legacy", 0],
+        signTransaction: async (...inputs) => {
+          return Promise.all(inputs.map(async input => {
+            const base64Tx = base64Decoder.decode(input.transaction);
+            const result = await sendJrpcRequest(connector, wcCaipChainId, SOLANA_METHOD_TYPES.SIGN_TRANSACTION, {
+              transaction: base64Tx
+            });
+            // Reconstruct signed transaction by inserting signature into decoded tx
+            const sigBytes = new Uint8Array(base58Encoder.encode(result.signature));
+            const decodedTx = transactionDecoder.decode(input.transaction);
+            const signedTx = _objectSpread(_objectSpread({}, decodedTx), {}, {
+              signatures: _objectSpread(_objectSpread({}, decodedTx.signatures), {}, {
+                [input.account.address]: sigBytes
+              })
+            });
+            const signedBase64 = getBase64EncodedWireTransaction(signedTx);
+            return {
+              signedTransaction: new Uint8Array(base64Encoder.encode(signedBase64))
+            };
+          }));
+        }
+      }
+    };
+  }
+  get accounts() {
+    return this._accounts;
+  }
+
+  /**
+   * Creates a WCSolanaWallet by reading accounts from the active WC session.
+   */
+  static async create(connector, chainConfig) {
+    const chainIdentifier = getSolanaChainByChainConfig(chainConfig);
+    const wcCaipChainId = `solana:${SOLANA_CAIP_CHAIN_MAP[chainConfig.chainId]}`;
+    const addresses = await getSolanaAccounts(connector);
+    if (!addresses.length) return null;
+    const accountFeatures = [SolanaSignAndSendTransaction, SolanaSignMessage, SolanaSignTransaction];
+    const accounts = addresses.map(address => ({
+      address,
+      publicKey: new Uint8Array(base58Encoder.encode(address)),
+      chains: chainIdentifier ? [chainIdentifier] : [],
+      features: accountFeatures
+    }));
+    return new WCSolanaWallet(connector, wcCaipChainId, chainIdentifier, accounts);
+  }
+}
+
+export { WCSolanaWallet };