@tomo-inc/wallet-adaptor-base 0.0.1

package/src/wallets/providers/WalletConnectProvider.ts

@@ -0,0 +1,346 @@
+/**
+ * WalletConnect Provider
+ *
+ * Implements standard Ethereum provider interface using WalletConnect protocol
+ * Compatible with EIP-1193 provider interface
+ */
+
+import type { NamespaceConfig, SessionInfo } from "@tomo-inc/wallet-connect-protocol";
+import { WalletConnectClient } from "@tomo-inc/wallet-connect-protocol";
+
+export interface WalletConnectProviderConfig {
+  projectId: string;
+  metadata: {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+  };
+  chains?: string[];
+  optionalChains?: string[];
+  methods?: string[];
+  events?: string[];
+}
+
+const defaultNamespaces: Record<string, NamespaceConfig> = {
+  eip155: {
+    chains: ["eip155:1"],
+    methods: [
+      "eth_sendTransaction",
+      "eth_signTransaction",
+      "eth_sign",
+      "personal_sign",
+      "eth_signTypedData",
+      "eth_signTypedData_v4",
+      "eth_chainId",
+    ],
+    events: ["chainChanged", "accountsChanged"],
+  },
+};
+
+export class WalletConnectProvider {
+  private client: WalletConnectClient;
+  private session: SessionInfo | null = null;
+  private accounts: string[] = [];
+  private chainId: string = "0x1"; // Default to Ethereum 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;
+
+  constructor(config: WalletConnectProviderConfig) {
+    this.client = new WalletConnectClient({
+      projectId: config.projectId,
+      metadata: config.metadata,
+    });
+
+    this.setupClientListeners();
+  }
+
+  /**
+   * Setup WalletConnect client event listeners
+   */
+  private setupClientListeners() {
+    this.client.on("session_proposal", () => {
+      // Session connected
+      const sessions = this.client.getActiveSessions();
+      if (sessions.length > 0) {
+        this.session = sessions[0];
+        this.updateAccountsFromSession();
+        this.emit("connect", { chainId: this.chainId });
+      }
+    });
+
+    this.client.on("session_delete", () => {
+      this.session = null;
+      this.accounts = [];
+      this.emit("disconnect");
+    });
+
+    this.client.on("session_update", () => {
+      this.updateAccountsFromSession();
+      this.emit("accountsChanged", this.accounts);
+    });
+
+    this.client.on("display_uri", (e: { uri: string }) => {
+      this.uri = e.uri;
+      this.emit("uri_changed", e);
+    });
+  }
+
+  /**
+   * Update accounts from current session
+   */
+  private updateAccountsFromSession() {
+    if (!this.session) return;
+
+    const allAccounts = Object.values(this.session.namespaces).flatMap((ns: any) => ns.accounts || []);
+
+    this.accounts = allAccounts.map((account: string) => {
+      const parts = account.split(":");
+      return parts[2] || account;
+    });
+
+    if (allAccounts.length > 0) {
+      const chainIdPart = allAccounts[0].split(":")[1];
+      this.chainId = "0x" + parseInt(chainIdPart).toString(16);
+    }
+  }
+
+  public async getUri(config: { requiredNamespaces: Record<string, NamespaceConfig> }): Promise<string> {
+    // Create connection and get URI
+    const uri = await this.client.connect({
+      requiredNamespaces: config.requiredNamespaces || defaultNamespaces,
+    });
+
+    this.uri = uri;
+    return uri;
+  }
+  /**
+   * Initialize the provider
+   */
+  async initialize(): Promise<void> {
+    await this.client.initialize();
+    // get all active sessions and store in sessionMap
+    const sessions = this.client.getActiveSessions();
+    sessions.forEach((session: SessionInfo) => {
+      this.sessionMap.set(session.topic, session);
+    });
+    this.uri = await this.getUri({
+      requiredNamespaces: defaultNamespaces,
+    });
+  }
+
+  /**
+   * Connect to wallet via WalletConnect
+   * Returns URI and QR code immediately for display
+   * Connection completion is notified via 'connect' event
+   */
+  async connect(): Promise<string[] | undefined> {
+    // Start waiting for connection in background (don't await)
+    // Connection will emit 'connect' event when established
+    const connected = await this.waitForConnection().catch((error) => {
+      console.error("WalletConnect connection failed:", error);
+      this.emit("error", error);
+      return false;
+    });
+
+    if (connected) {
+      return this.accounts;
+    }
+  }
+
+  /**
+   * Wait for WalletConnect session to be established
+   */
+  private waitForConnection(): Promise<boolean | undefined> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Connection timeout"));
+      }, 300000); // 5 minutes
+
+      const checkConnection = () => {
+        const sessions = this.client.getActiveSessions();
+        const newSessions = sessions.filter((session: SessionInfo) => !this.sessionMap.has(session.topic));
+        if (newSessions.length > 0) {
+          clearTimeout(timeout);
+          this.session = newSessions[0];
+          this.updateAccountsFromSession();
+          this.emit("connect", { chainId: this.chainId });
+          resolve(true);
+        } else {
+          setTimeout(checkConnection, 500);
+        }
+      };
+
+      checkConnection();
+    });
+  }
+
+  /**
+   * Disconnect from wallet
+   */
+  async disconnect(): Promise<void> {
+    if (this.session) {
+      await this.client.disconnectSession(this.session.topic);
+      this.session = null;
+      this.accounts = [];
+      this.emit("disconnect");
+    }
+  }
+
+  /**
+   * Send JSON-RPC request (EIP-1193)
+   */
+  async request(args: { method: string; params?: any[] }): Promise<any> {
+    // eth_requestAccounts
+    if (args.method === "eth_requestAccounts") {
+      if (this.accounts.length > 0) {
+        return this.accounts;
+      }
+      if (this.uri === null) {
+        this.uri = await this.getUri({
+          requiredNamespaces: defaultNamespaces,
+        });
+      }
+      return this.connect();
+    }
+
+    if (!this.session) {
+      throw new Error("Not connected. Please call connect() first.");
+    }
+
+    if (args.method === "eth_chainId") {
+      return this.chainId || "0x1"; // default to Ethereum mainnet
+    }
+
+    try {
+      const result = await this.client.sendRequest({
+        topic: this.session.topic,
+        chainId: `eip155:${parseInt(this.chainId, 16)}`,
+        request: {
+          method: args.method,
+          params: args.params || [],
+        },
+      });
+
+      return result;
+    } catch (error: any) {
+      throw new Error(error.message || "Request failed");
+    }
+  }
+
+  /**
+   * Get current accounts
+   */
+  async getAccounts(): Promise<string[]> {
+    if (!this.session) {
+      return [];
+    }
+    return this.accounts;
+  }
+
+  /**
+   * Get current chain ID
+   */
+  async getChainId(): Promise<string> {
+    return this.chainId;
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean {
+    return this.session !== null && this.accounts.length > 0;
+  }
+
+  /**
+   * Get active session
+   */
+  getSession(): SessionInfo | null {
+    return this.session;
+  }
+
+  /**
+   * Event emitter - on
+   */
+  on(event: string, listener: (...args: any[]) => void): void {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, new Set());
+    }
+    this.eventListeners.get(event)!.add(listener);
+  }
+
+  /**
+   * Event emitter - off
+   */
+  off(event: string, listener: (...args: any[]) => void): void {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+
+  /**
+   * Event emitter - emit
+   */
+  private emit(event: string, data?: any): void {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.forEach((listener) => {
+        try {
+          listener(data);
+        } catch (error) {
+          console.error(`Error in ${event} listener:`, error);
+        }
+      });
+    }
+  }
+
+  /**
+   * Helper: Sign message
+   */
+  async signMessage(message: string): Promise<string> {
+    if (!this.accounts[0]) {
+      throw new Error("No account connected");
+    }
+
+    return this.request({
+      method: "personal_sign",
+      params: [message, this.accounts[0]],
+    });
+  }
+
+  /**
+   * Helper: Sign typed data
+   */
+  async signTypedData(typedData: any): Promise<string> {
+    if (!this.accounts[0]) {
+      throw new Error("No account connected");
+    }
+
+    return this.request({
+      method: "eth_signTypedData_v4",
+      params: [this.accounts[0], JSON.stringify(typedData)],
+    });
+  }
+
+  /**
+   * Helper: Send transaction
+   */
+  async sendTransaction(transaction: any): Promise<string> {
+    return this.request({
+      method: "eth_sendTransaction",
+      params: [transaction],
+    });
+  }
+
+  /**
+   * Helper: Switch chain
+   */
+  async switchChain(_chainId: string): Promise<void> {
+    // WalletConnect doesn't support switching chains dynamically
+    // User needs to reconnect with different chain
+    throw new Error("Please reconnect to switch chains");
+  }
+}

package/src/wallets/providers/WalletConnectSolanaProvider.ts

@@ -0,0 +1,351 @@
+/**
+ * WalletConnect Solana Provider
+ *
+ * Implements Solana provider interface using WalletConnect protocol
+ * Compatible with WalletConnect Solana JSON-RPC methods
+ */
+
+import type { NamespaceConfig, SessionInfo } from "@tomo-inc/wallet-connect-protocol";
+import { WalletConnectClient } from "@tomo-inc/wallet-connect-protocol";
+
+export interface WalletConnectSolanaProviderConfig {
+  projectId: string;
+  metadata: {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+  };
+  chains?: string[];
+  methods?: string[];
+  events?: string[];
+}
+
+const defaultSolanaNamespaces: Record<string, NamespaceConfig> = {
+  solana: {
+    chains: ["solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"], // Solana mainnet
+    methods: [
+      "solana_getAccounts",
+      "solana_requestAccounts",
+      "solana_signMessage",
+      "solana_signTransaction",
+      "solana_signAllTransactions",
+      "solana_signAndSendTransaction",
+    ],
+    events: ["accountsChanged"],
+  },
+};
+
+export class WalletConnectSolanaProvider {
+  private client: WalletConnectClient;
+  private session: SessionInfo | null = null;
+  private accounts: 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;
+
+  constructor(config: WalletConnectSolanaProviderConfig) {
+    this.client = new WalletConnectClient({
+      projectId: config.projectId,
+      metadata: config.metadata,
+    });
+
+    this.setupClientListeners();
+  }
+
+  /**
+   * Setup WalletConnect client event listeners
+   */
+  private setupClientListeners() {
+    this.client.on("session_proposal", () => {
+      // Session connected
+      const sessions = this.client.getActiveSessions();
+      if (sessions.length > 0) {
+        this.session = sessions[0];
+        this.updateAccountsFromSession();
+        this.emit("connect", { chainId: this.chainId });
+      }
+    });
+
+    this.client.on("session_delete", () => {
+      this.session = null;
+      this.accounts = [];
+      this.emit("disconnect");
+    });
+
+    this.client.on("session_update", () => {
+      this.updateAccountsFromSession();
+      this.emit("accountsChanged", this.accounts);
+    });
+
+    this.client.on("display_uri", (e: { uri: string }) => {
+      this.uri = e.uri;
+      this.emit("uri_changed", e);
+    });
+  }
+
+  /**
+   * Update accounts from current session
+   */
+  private updateAccountsFromSession() {
+    if (!this.session) return;
+
+    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;
+    });
+
+    if (allAccounts.length > 0) {
+      const chainIdPart = allAccounts[0].split(":")[1];
+      this.chainId = `solana:${chainIdPart}`;
+    }
+  }
+
+  public async getUri(config: { requiredNamespaces: Record<string, NamespaceConfig> }): Promise<string> {
+    // Create connection and get URI
+    const uri = await this.client.connect({
+      requiredNamespaces: config.requiredNamespaces || defaultSolanaNamespaces,
+    });
+
+    this.uri = uri;
+    return uri;
+  }
+
+  /**
+   * Initialize the provider
+   */
+  async initialize(): Promise<void> {
+    await this.client.initialize();
+    // get all active sessions and store in sessionMap
+    const sessions = this.client.getActiveSessions();
+    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> {
+    // Start waiting for connection in background (don't await)
+    // Connection will emit 'connect' event when established
+    const connected = await this.waitForConnection().catch((error) => {
+      console.error("WalletConnect Solana connection failed:", error);
+      this.emit("error", error);
+      return false;
+    });
+
+    if (connected) {
+      return this.accounts;
+    }
+  }
+
+  /**
+   * Wait for WalletConnect session to be established
+   */
+  private waitForConnection(): Promise<boolean | undefined> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Connection timeout"));
+      }, 300000); // 5 minutes
+
+      const checkConnection = () => {
+        const sessions = this.client.getActiveSessions();
+        const newSessions = sessions.filter((session: SessionInfo) => !this.sessionMap.has(session.topic));
+        if (newSessions.length > 0) {
+          clearTimeout(timeout);
+          this.session = newSessions[0];
+          this.updateAccountsFromSession();
+          this.emit("connect", { chainId: this.chainId });
+          resolve(true);
+        } else {
+          setTimeout(checkConnection, 500);
+        }
+      };
+
+      checkConnection();
+    });
+  }
+
+  /**
+   * Disconnect from wallet
+   */
+  async disconnect(): Promise<void> {
+    if (this.session) {
+      await this.client.disconnectSession(this.session.topic);
+      this.session = null;
+      this.accounts = [];
+      this.emit("disconnect");
+    }
+  }
+
+  /**
+   * Send JSON-RPC request (Solana WalletConnect methods)
+   */
+  async request(args: { method: string; params?: any }): Promise<any> {
+    // 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,
+        });
+      }
+      const accounts = await this.connect();
+      return accounts?.map((account) => ({ pubkey: account })) || [];
+    }
+
+    // solana_getAccounts
+    if (args.method === "solana_getAccounts") {
+      return this.accounts.map((account) => ({ pubkey: account }));
+    }
+
+    if (!this.session) {
+      throw new Error("Not connected. Please call connect() first.");
+    }
+
+    try {
+      const result = await this.client.sendRequest({
+        topic: this.session.topic,
+        chainId: this.chainId,
+        request: {
+          method: args.method,
+          params: args.params || [],
+        },
+      });
+
+      return result;
+    } catch (error: any) {
+      throw new Error(error.message || "Request failed");
+    }
+  }
+
+  /**
+   * Get current accounts
+   */
+  async getAccounts(): Promise<string[]> {
+    if (!this.session) {
+      return [];
+    }
+    return this.accounts;
+  }
+
+  /**
+   * Get current chain ID
+   */
+  async getChainId(): Promise<string> {
+    return this.chainId;
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean {
+    return this.session !== null && this.accounts.length > 0;
+  }
+
+  /**
+   * Get active session
+   */
+  getSession(): SessionInfo | null {
+    return this.session;
+  }
+
+  /**
+   * Event emitter - on
+   */
+  on(event: string, listener: (...args: any[]) => void): void {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, new Set());
+    }
+    this.eventListeners.get(event)!.add(listener);
+  }
+
+  /**
+   * Event emitter - off
+   */
+  off(event: string, listener: (...args: any[]) => void): void {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+
+  /**
+   * Event emitter - emit
+   */
+  private emit(event: string, data?: any): void {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.forEach((listener) => {
+        try {
+          listener(data);
+        } catch (error) {
+          console.error(`Error in ${event} listener:`, error);
+        }
+      });
+    }
+  }
+
+  /**
+   * Helper: Sign message
+   */
+  async signMessage(message: string, pubkey: string): Promise<string> {
+    const result = await this.request({
+      method: "solana_signMessage",
+      params: {
+        message,
+        pubkey,
+      },
+    });
+    return result.signature;
+  }
+
+  /**
+   * Helper: Sign transaction
+   */
+  async signTransaction(transaction: string): Promise<{ signature: string; transaction?: string }> {
+    return this.request({
+      method: "solana_signTransaction",
+      params: {
+        transaction,
+      },
+    });
+  }
+
+  /**
+   * Helper: Sign all transactions
+   */
+  async signAllTransactions(transactions: string[]): Promise<{ transactions: string[] }> {
+    return this.request({
+      method: "solana_signAllTransactions",
+      params: {
+        transactions,
+      },
+    });
+  }
+
+  /**
+   * Helper: Sign and send transaction
+   */
+  async signAndSendTransaction(transaction: string, sendOptions?: any): Promise<{ signature: string }> {
+    return this.request({
+      method: "solana_signAndSendTransaction",
+      params: {
+        transaction,
+        sendOptions,
+      },
+    });
+  }
+}