@tomo-inc/wallet-adaptor-base 0.0.1

package/src/wallets/wallet-eip6963.ts

@@ -0,0 +1,70 @@
+import { Connector, ProviderProtocol, WalletInfo } from "../type";
+import { uniqueConnectors } from "../utils/utils";
+
+const announceEvent = "eip6963:announceProvider";
+const requestEvent = "eip6963:requestProvider";
+const walletType = "evm";
+const timeout = 1000;
+
+export async function eip6963Wallets(): Promise<Connector[]> {
+  return new Promise((resolve) => {
+    const evmWallets: Connector[] = [];
+
+    const timeoutId = setTimeout(() => {
+      window.removeEventListener(announceEvent, handleProviderAnnouncement as EventListener);
+
+      const wallets = uniqueConnectors(evmWallets);
+      resolve(wallets);
+    }, timeout);
+
+    function handleProviderAnnouncement(event: CustomEvent<{ info: WalletInfo; provider: any }>) {
+      try {
+        const { info: wallet, provider } = event.detail;
+
+        const isInfoValid =
+          typeof wallet?.uuid === "string" &&
+          typeof wallet?.name === "string" &&
+          typeof wallet?.icon === "string" &&
+          typeof wallet?.rdns === "string";
+
+        if (wallet && provider && isInfoValid && typeof provider.request === "function") {
+          const existingWallet = evmWallets.find((w) => w.info.uuid === wallet.uuid);
+          if (!existingWallet) {
+            evmWallets.push({
+              info: {
+                uuid: wallet.rdns || encodeURIComponent(wallet.name),
+                name: wallet.name,
+                icon: wallet.icon,
+                rdns: wallet.rdns,
+                links: {
+                  homepage: (wallet as any)?.homepage || "",
+                },
+              },
+              isInstalled: true,
+              providers: {
+                [walletType]: {
+                  provider,
+                  protocol: ProviderProtocol.EIP6963,
+                },
+              },
+            });
+          }
+        }
+      } catch (error) {
+        console.warn(`${ProviderProtocol.EIP6963} detect error:`, error);
+      }
+    }
+
+    // Use type assertion to cast to EventListener since the CustomEvent is expected
+    window.addEventListener(announceEvent, handleProviderAnnouncement as EventListener);
+
+    try {
+      window.dispatchEvent(new Event(requestEvent));
+    } catch (error) {
+      console.warn(`Error ${requestEvent}:`, error);
+      clearTimeout(timeoutId);
+      window.removeEventListener(announceEvent, handleProviderAnnouncement as EventListener);
+      resolve(evmWallets);
+    }
+  });
+}

package/src/wallets/wallet-standard.ts

@@ -0,0 +1,77 @@
+import { uniqueConnectors } from "../utils/utils";
+import { Connector, ProviderProtocol } from "../type";
+
+const registerWalletEvent = "wallet-standard:register-wallet";
+const requestRegisterWalletEvent = "wallet-standard:request-register-wallet";
+const timeout = 1000;
+
+export function walletStandardWallets() {
+  return new Promise((resolve) => {
+    const wallets: Record<string, Connector[]> = {
+      solana: [] as Connector[],
+      aptos: [] as Connector[],
+      sui: [] as Connector[],
+    };
+
+    const timeoutId = setTimeout(() => {
+      window.removeEventListener(registerWalletEvent, handleWalletRegistration);
+
+      const result = {
+        solanaWallets: uniqueConnectors(wallets.solana),
+        aptosWallets: uniqueConnectors(wallets.aptos),
+        suiWallets: uniqueConnectors(wallets.sui),
+      };
+      resolve(result);
+    }, timeout);
+
+    function handleWalletRegistration(wallet: any) {
+      try {
+        console.warn(registerWalletEvent, wallet.name, wallet.features, wallet);
+        if (!wallet || !wallet?.name || !wallet?.icon || !wallet.features) {
+          return;
+        }
+
+        for (const walletType in wallets) {
+          const signTransaction = wallet.features?.[`${walletType}:signTransaction`];
+          const signMessage = wallet.features?.[`${walletType}:signMessage`];
+          const isExist = wallets[walletType].find((w) => w.info.name === wallet.name);
+          if (signTransaction && signMessage && !isExist) {
+            wallets[walletType].push({
+              info: {
+                uuid: wallet.rdns || encodeURIComponent(wallet.name),
+                name: wallet.name,
+                icon: wallet.icon,
+                rdns: wallet.rdns,
+                links: {
+                  homepage: wallet.homepage || "",
+                },
+              },
+              isInstalled: true,
+              providers: {
+                [walletType]: {
+                  provider: wallet.features,
+                  protocol: ProviderProtocol.WALLET_STANDARD,
+                },
+              },
+            });
+          }
+        }
+      } catch (error) {
+        console.warn(`${ProviderProtocol.WALLET_STANDARD} detect error:`, error);
+      }
+    }
+
+    window.addEventListener(registerWalletEvent, (data: any) => {
+      data.detail({ register: (wallet: any) => handleWalletRegistration(wallet) });
+    });
+
+    try {
+      window.dispatchEvent(new Event(requestRegisterWalletEvent));
+    } catch (error) {
+      console.warn("Error requesting wallet-standard registration:", error);
+      clearTimeout(timeoutId);
+      window.removeEventListener(registerWalletEvent, handleWalletRegistration);
+      resolve(wallets);
+    }
+  });
+}

package/src/wallets/wallet-walletconnect.ts

@@ -0,0 +1,202 @@
+import { Connector, ProviderProtocol } from "../type";
+import { walletConnectWallet } from "./default/walletConnectWallet/walletConnectWallet";
+import { WalletConnectProvider } from "./providers/WalletConnectProvider";
+import { WalletConnectSolanaProvider } from "./providers/WalletConnectSolanaProvider";
+
+/**
+ * WalletConnect wallet configuration
+ * Can be set via setWalletConnectConfig() before calling walletConnectWallets()
+ */
+let walletConnectConfig: {
+  projectId: string;
+  metadata: {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+  };
+} | null = null;
+
+let providerInstance: WalletConnectProvider | null = null;
+let solanaProviderInstance: WalletConnectSolanaProvider | null = null;
+
+/**
+ * Set WalletConnect configuration
+ * Must be called before using WalletConnect wallet
+ */
+export function setWalletConnectConfig(config: {
+  projectId: string;
+  metadata: {
+    name: string;
+    description: string;
+    url: string;
+    icons: string[];
+  };
+}): void {
+  walletConnectConfig = config;
+}
+
+/**
+ * Get WalletConnect wallet as Connector
+ * Returns a single WalletConnect connector that can connect to any mobile wallet
+ */
+export async function walletConnectWallets(): Promise<Connector[]> {
+  const wallet = walletConnectWallet();
+  const connector = convertWalletToConnector(wallet);
+  return [connector];
+}
+
+/**
+ * Convert WalletConnect Wallet to Connector format
+ */
+function convertWalletToConnector(wallet: ReturnType<typeof walletConnectWallet>): Connector {
+  return {
+    info: {
+      uuid: wallet.id,
+      name: wallet.name,
+      icon: wallet.icon,
+      iconBackground: wallet.iconBackground,
+      isWalletConnect: true,
+      links: {
+        homepage: "https://walletconnect.com",
+        qrCode: "https://walletconnect.com",
+        mobile: "https://walletconnect.com",
+      },
+    },
+    isInstalled: true, // Always available
+    providers: {
+      evm: {
+        provider: createWalletConnectEVMProvider(),
+        protocol: ProviderProtocol.WALLET_CONNECT,
+      },
+      // solana: {
+      //   provider: createWalletConnectSolanaProvider(),
+      //   protocol: ProviderProtocol.WALLET_CONNECT,
+      // },
+    },
+  };
+}
+
+/**
+ * Create a WalletConnect provider instance
+ * Provider will be initialized when connect() is called
+ */
+function createWalletConnectEVMProvider(): any {
+  const getProvider = async () => {
+    if (!providerInstance) {
+      if (!walletConnectConfig) {
+        throw new Error("WalletConnect not configured. Please call setWalletConnectConfig() first.");
+      }
+
+      providerInstance = new WalletConnectProvider(walletConnectConfig);
+      await providerInstance.initialize();
+    }
+    return providerInstance;
+  };
+  return {
+    // Lazy initialization
+    getProvider,
+
+    // EIP-1193 compatible request method
+    request: async (args: { method: string; params?: any[] }) => {
+      const provider = await getProvider();
+      return provider.request(args);
+    },
+
+    // Connect method
+    connect: async (config?: { chains?: string[] }) => {
+      const provider = await getProvider();
+      return provider.connect();
+    },
+
+    // Disconnect method
+    disconnect: async () => {
+      if (providerInstance) {
+        await providerInstance.disconnect();
+      }
+    },
+
+    // getter for connectUri
+    get connectUri() {
+      return providerInstance?.uri || null;
+    },
+
+    // Event listeners
+    on: (event: string, listener: (...args: any[]) => void) => {
+      if (providerInstance) {
+        providerInstance.on(event, listener);
+      }
+    },
+
+    off: (event: string, listener: (...args: any[]) => void) => {
+      if (providerInstance) {
+        providerInstance.off(event, listener);
+      }
+    },
+
+    // Metadata
+    isWalletConnect: true,
+  };
+}
+
+/**
+ * Create a WalletConnect Solana provider instance
+ * Provider will be initialized when connect() is called
+ */
+function createWalletConnectSolanaProvider(): any {
+  const getProvider = async () => {
+    if (!solanaProviderInstance) {
+      if (!walletConnectConfig) {
+        throw new Error("WalletConnect not configured. Please call setWalletConnectConfig() first.");
+      }
+
+      solanaProviderInstance = new WalletConnectSolanaProvider(walletConnectConfig);
+      await solanaProviderInstance.initialize();
+    }
+    return solanaProviderInstance;
+  };
+  return {
+    // Lazy initialization
+    getProvider,
+
+    // Solana WalletConnect compatible request method
+    request: async (args: { method: string; params?: any }) => {
+      const provider = await getProvider();
+      return provider.request(args);
+    },
+
+    // Connect method
+    connect: async () => {
+      const provider = await getProvider();
+      return provider.connect();
+    },
+
+    // Disconnect method
+    disconnect: async () => {
+      if (solanaProviderInstance) {
+        await solanaProviderInstance.disconnect();
+      }
+    },
+
+    // getter for connectUri
+    get connectUri() {
+      return solanaProviderInstance?.uri || null;
+    },
+
+    // Event listeners
+    on: (event: string, listener: (...args: any[]) => void) => {
+      if (solanaProviderInstance) {
+        solanaProviderInstance.on(event, listener);
+      }
+    },
+
+    off: (event: string, listener: (...args: any[]) => void) => {
+      if (solanaProviderInstance) {
+        solanaProviderInstance.off(event, listener);
+      }
+    },
+
+    // Metadata
+    isWalletConnect: true,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": "./src"
+  },
+  "include": ["src"]
+}