@tomo-inc/wallet-adaptor-base 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/wallet-adaptor-base",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "author": "tomo.inc",
   "license": "MIT",
   "private": false,

package/project.json

@@ -18,14 +18,6 @@
         "cwd": "packages/wallet-adaptor-base"
       }
     },
-    "prepare": {
-      "executor": "nx:run-commands",
-      "dependsOn": ["build"],
-      "options": {
-        "command": "pnpm build",
-        "cwd": "packages/wallet-adaptor-base"
-      }
-    },
     "lint": {
       "executor": "nx:run-commands",
       "options": {

package/src/wallet-api/connect.ts

@@ -42,14 +42,12 @@ export const connect = async (
     if (provider?.connect) {
       res = await provider.connect();
       address = res?.publicKey?.toString() || "";
-    }
-    if (provider?.request) {
+    } else if (provider?.request) {
       res = await provider.request({
         method: "connect",
       });
       address = res?.publicKey?.toString() || "";
-    }
-    if (provider?.["standard:connect"]) {
+    } else if (provider?.["standard:connect"]) {
       res = await provider["standard:connect"]?.connect();
       address = res?.accounts?.[0]?.address || "";
     }

package/src/wallets/providers/WalletConnectProvider.ts

@@ -20,6 +20,7 @@ export interface WalletConnectProviderConfig {
   optionalChains?: string[];
   methods?: string[];
   events?: string[];
+  namespaces?: Record<string, NamespaceConfig>;
 }
 
 const defaultNamespaces: Record<string, NamespaceConfig> = {
@@ -47,6 +48,7 @@ export class WalletConnectProvider {
   private sessionMap: Map<string, SessionInfo> = new Map();
   public uri: string | null = null;
   public qrCode: string | null = null;
+  private namespaces: Record<string, NamespaceConfig> = defaultNamespaces;
 
   constructor(config: WalletConnectProviderConfig) {
     this.client = new WalletConnectClient({
@@ -54,6 +56,8 @@ export class WalletConnectProvider {
       metadata: config.metadata,
     });
 
+    this.namespaces = config.namespaces || defaultNamespaces;
+
     this.setupClientListeners();
   }
 
@@ -107,13 +111,20 @@ export class WalletConnectProvider {
     }
   }
 
-  public async getUri(config: { requiredNamespaces: Record<string, NamespaceConfig> }): Promise<string> {
+  public async getUri(): Promise<string> {
+    // Return existing URI if available to avoid creating duplicate proposals
+    if (this.uri) {
+      this.emit("uri_changed", { uri: this.uri });
+      return this.uri;
+    }
+
     // Create connection and get URI
     const uri = await this.client.connect({
-      requiredNamespaces: config.requiredNamespaces || defaultNamespaces,
+      requiredNamespaces: this.namespaces,
     });
 
     this.uri = uri;
+    this.emit("uri_changed", { uri: this.uri });
     return uri;
   }
   /**
@@ -126,9 +137,11 @@ export class WalletConnectProvider {
     sessions.forEach((session: SessionInfo) => {
       this.sessionMap.set(session.topic, session);
     });
-    this.uri = await this.getUri({
-      requiredNamespaces: defaultNamespaces,
-    });
+
+    // Only create new URI if we don't have an active session
+    if (sessions.length === 0) {
+      this.uri = await this.getUri();
+    }
   }
 
   /**
@@ -139,6 +152,8 @@ export class WalletConnectProvider {
   async connect(): Promise<string[] | undefined> {
     // Start waiting for connection in background (don't await)
     // Connection will emit 'connect' event when established
+    this.uri = await this.getUri();
+    this.emit("uri_changed", { uri: this.uri });
     const connected = await this.waitForConnection().catch((error) => {
       console.error("WalletConnect connection failed:", error);
       this.emit("error", error);
@@ -199,11 +214,6 @@ export class WalletConnectProvider {
       if (this.accounts.length > 0) {
         return this.accounts;
       }
-      if (this.uri === null) {
-        this.uri = await this.getUri({
-          requiredNamespaces: defaultNamespaces,
-        });
-      }
       return this.connect();
     }
 

package/src/wallets/providers/WalletConnectSolanaProvider.ts

@@ -19,6 +19,7 @@ export interface WalletConnectSolanaProviderConfig {
   chains?: string[];
   methods?: string[];
   events?: string[];
+  namespaces?: Record<string, NamespaceConfig>;
 }
 
 const defaultSolanaNamespaces: Record<string, NamespaceConfig> = {
@@ -39,12 +40,13 @@ const defaultSolanaNamespaces: Record<string, NamespaceConfig> = {
 export class WalletConnectSolanaProvider {
   private client: WalletConnectClient;
   private session: SessionInfo | null = null;
-  private accounts: string[] = [];
+  private accounts: { publicKey: string }[] = [];
   private chainId: string = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"; // Default to Solana mainnet
   private eventListeners: Map<string, Set<(...args: any[]) => void>> = new Map();
   private sessionMap: Map<string, SessionInfo> = new Map();
   public uri: string | null = null;
   public qrCode: string | null = null;
+  private namespaces: Record<string, NamespaceConfig> = defaultSolanaNamespaces;
 
   constructor(config: WalletConnectSolanaProviderConfig) {
     this.client = new WalletConnectClient({
@@ -52,6 +54,8 @@ export class WalletConnectSolanaProvider {
       metadata: config.metadata,
     });
 
+    this.namespaces = config.namespaces || defaultSolanaNamespaces;
+
     this.setupClientListeners();
   }
 
@@ -94,11 +98,13 @@ export class WalletConnectSolanaProvider {
 
     const allAccounts = Object.values(this.session.namespaces).flatMap((ns: any) => ns.accounts || []);
 
-    this.accounts = allAccounts.map((account: string) => {
-      const parts = account.split(":");
-      // Solana account format: solana:chainId:pubkey
-      return parts[2] || account;
-    });
+    this.accounts = allAccounts
+      .filter((account: string) => account.startsWith("solana:"))
+      .map((account) => {
+        const parts = account.split(":");
+        // Solana account format: solana:chainId:pubkey
+        return { publicKey: parts[2] };
+      });
 
     if (allAccounts.length > 0) {
       const chainIdPart = allAccounts[0].split(":")[1];
@@ -106,13 +112,20 @@ export class WalletConnectSolanaProvider {
     }
   }
 
-  public async getUri(config: { requiredNamespaces: Record<string, NamespaceConfig> }): Promise<string> {
+  public async getUri(): Promise<string> {
+    // Return existing URI if available to avoid creating duplicate proposals
+    if (this.uri) {
+      this.emit("uri_changed", { uri: this.uri });
+      return this.uri;
+    }
+
     // Create connection and get URI
     const uri = await this.client.connect({
-      requiredNamespaces: config.requiredNamespaces || defaultSolanaNamespaces,
+      requiredNamespaces: this.namespaces,
     });
 
     this.uri = uri;
+    this.emit("uri_changed", { uri: this.uri });
     return uri;
   }
 
@@ -126,16 +139,17 @@ export class WalletConnectSolanaProvider {
     sessions.forEach((session: SessionInfo) => {
       this.sessionMap.set(session.topic, session);
     });
-    this.uri = await this.getUri({
-      requiredNamespaces: defaultSolanaNamespaces,
-    });
   }
 
   /**
    * Connect to wallet via WalletConnect
    * Returns accounts when connected
    */
-  async connect(): Promise<string[] | undefined> {
+  async connect(): Promise<{ publicKey: string } | undefined> {
+    if (this.accounts.length > 0) {
+      return this.accounts[0];
+    }
+    this.uri = await this.getUri();
     // Start waiting for connection in background (don't await)
     // Connection will emit 'connect' event when established
     const connected = await this.waitForConnection().catch((error) => {
@@ -145,7 +159,7 @@ export class WalletConnectSolanaProvider {
     });
 
     if (connected) {
-      return this.accounts;
+      return this.accounts?.length > 0 ? this.accounts[0] : undefined;
     }
   }
 
@@ -195,20 +209,15 @@ export class WalletConnectSolanaProvider {
     // solana_requestAccounts
     if (args.method === "solana_requestAccounts") {
       if (this.accounts.length > 0) {
-        return this.accounts.map((account) => ({ pubkey: account }));
-      }
-      if (this.uri === null) {
-        this.uri = await this.getUri({
-          requiredNamespaces: defaultSolanaNamespaces,
-        });
+        return { publicKey: this.accounts[0] };
       }
       const accounts = await this.connect();
-      return accounts?.map((account) => ({ pubkey: account })) || [];
+      return accounts;
     }
 
     // solana_getAccounts
     if (args.method === "solana_getAccounts") {
-      return this.accounts.map((account) => ({ pubkey: account }));
+      return this.accounts || [];
     }
 
     if (!this.session) {
@@ -234,9 +243,9 @@ export class WalletConnectSolanaProvider {
   /**
    * Get current accounts
    */
-  async getAccounts(): Promise<string[]> {
+  async getAccounts(): Promise<{ publicKey: string }[]> {
     if (!this.session) {
-      return [];
+      return [{ publicKey: "" }];
     }
     return this.accounts;
   }

package/src/wallets/wallet-walletconnect.ts

@@ -1,3 +1,4 @@
+import { NamespaceConfig } from "@tomo-inc/wallet-connect-protocol";
 import { Connector, ProviderProtocol } from "../type";
 import { walletConnectWallet } from "./default/walletConnectWallet/walletConnectWallet";
 import { WalletConnectProvider } from "./providers/WalletConnectProvider";
@@ -15,6 +16,8 @@ let walletConnectConfig: {
     url: string;
     icons: string[];
   };
+  solanaNamespaces?: Record<string, NamespaceConfig>;
+  evmNamespaces?: Record<string, NamespaceConfig>;
 } | null = null;
 
 let providerInstance: WalletConnectProvider | null = null;
@@ -66,13 +69,13 @@ function convertWalletToConnector(wallet: ReturnType<typeof walletConnectWallet>
     isInstalled: true, // Always available
     providers: {
       evm: {
-        provider: createWalletConnectEVMProvider(),
+        provider: createWalletConnectEVMProvider(walletConnectConfig?.evmNamespaces),
+        protocol: ProviderProtocol.WALLET_CONNECT,
+      },
+      solana: {
+        provider: createWalletConnectSolanaProvider(walletConnectConfig?.solanaNamespaces),
         protocol: ProviderProtocol.WALLET_CONNECT,
       },
-      // solana: {
-      //   provider: createWalletConnectSolanaProvider(),
-      //   protocol: ProviderProtocol.WALLET_CONNECT,
-      // },
     },
   };
 }
@@ -81,14 +84,17 @@ function convertWalletToConnector(wallet: ReturnType<typeof walletConnectWallet>
  * Create a WalletConnect provider instance
  * Provider will be initialized when connect() is called
  */
-export function createWalletConnectEVMProvider(): any {
+export function createWalletConnectEVMProvider(namespaces?: Record<string, NamespaceConfig>): any {
   const getProvider = async () => {
     if (!providerInstance) {
       if (!walletConnectConfig) {
         throw new Error("WalletConnect not configured. Please call setWalletConnectConfig() first.");
       }
 
-      providerInstance = new WalletConnectProvider(walletConnectConfig);
+      providerInstance = new WalletConnectProvider({
+        ...walletConnectConfig,
+        namespaces: namespaces || walletConnectConfig?.evmNamespaces,
+      });
       await providerInstance.initialize();
     }
     return providerInstance;
@@ -143,14 +149,17 @@ export function createWalletConnectEVMProvider(): any {
  * Create a WalletConnect Solana provider instance
  * Provider will be initialized when connect() is called
  */
-function createWalletConnectSolanaProvider(): any {
+function createWalletConnectSolanaProvider(namespaces?: Record<string, NamespaceConfig>): any {
   const getProvider = async () => {
     if (!solanaProviderInstance) {
       if (!walletConnectConfig) {
         throw new Error("WalletConnect not configured. Please call setWalletConnectConfig() first.");
       }
 
-      solanaProviderInstance = new WalletConnectSolanaProvider(walletConnectConfig);
+      solanaProviderInstance = new WalletConnectSolanaProvider({
+        ...walletConnectConfig,
+        namespaces: namespaces || walletConnectConfig?.solanaNamespaces || {},
+      });
       await solanaProviderInstance.initialize();
     }
     return solanaProviderInstance;

package/tsup.config.ts

@@ -1,6 +1,6 @@
-import { defineConfig } from "tsup";
-import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
+import { readdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { join } from "path";
+import { defineConfig } from "tsup";
 
 // Recursively find all JS files in dist directory
 function findJsFiles(dir: string, fileList: string[] = []): string[] {
@@ -24,6 +24,7 @@ export default defineConfig({
   treeshake: true,
   clean: true,
   platform: "browser",
+  tsconfig: "tsconfig.json",
   loader: {
     ".svg": "base64",
   },