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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/wallet-adaptor-base",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "author": "tomo.inc",
   "license": "MIT",
   "private": false,
@@ -16,9 +16,11 @@
     }
   },
   "dependencies": {
+    "@aptos-labs/ts-sdk": "^5.1.1",
+    "@binance/w3w-utils": "^1.1.6",
     "@solana/spl-token": "^0.4.13",
     "@solana/web3.js": "^1.98.0",
-    "@aptos-labs/ts-sdk": "^5.1.1",
+    "@wallet-standard/core": "^1.1.0",
     "viem": "2.21.54",
     "@tomo-inc/wallet-connect-protocol": "0.0.3"
   },

package/project.json

@@ -7,14 +7,14 @@
       "executor": "nx:run-commands",
       "outputs": ["{projectRoot}/dist"],
       "options": {
-        "command": "tsup src/index.ts --format esm,cjs --dts --treeshake",
+        "command": "tsup",
         "cwd": "packages/wallet-adaptor-base"
       }
     },
     "dev": {
       "executor": "nx:run-commands",
       "options": {
-        "command": "tsup src/index.ts --format esm,cjs --dts --watch",
+        "command": "tsup --watch",
         "cwd": "packages/wallet-adaptor-base"
       }
     },

package/src/global.d.ts

@@ -0,0 +1,7 @@
+declare global {
+  interface Window {
+    ethereum?: any;
+  }
+}
+
+export {};

package/src/index.ts

@@ -1,8 +1,9 @@
 import { AdaptorChainType, Connector, WalletConnectorType } from "./type";
+import { isMobile } from "./utils/isMobile";
 import { uniqueConnectors } from "./utils/utils";
-import { defaultConnectors } from "./wallets";
-import { WagmiWalletConfig, WalletConfig } from "./wallets/Wallet";
+import { defaultConnectors } from "./wallets/defaultConnectors";
 import { connectorDector, supportedWalletConfigTypes, walletConfigAdapter } from "./wallets/detector";
+import { WagmiWalletConfig, WalletConfig } from "./wallets/Wallet";
 import { eip6963Wallets } from "./wallets/wallet-eip6963";
 import { walletStandardWallets } from "./wallets/wallet-standard";
 import { setWalletConnectConfig, walletConnectWallets } from "./wallets/wallet-walletconnect";
@@ -56,13 +57,13 @@ export async function loadConnectors({
   const connectorsFromConfig = uniqueConnectors([...recommonedConnectorsDetected, ...defaultConnectors]);
 
   // Include WalletConnect wallets along with other detected wallets
-  const connectorsDetected = [...evmWallets, ...solanaWallets, ...aptosWallets, ...wcWallets];
+  const connectorsDetecteds = [...evmWallets, ...solanaWallets, ...aptosWallets, ...wcWallets];
 
-  for (const connector of connectorsDetected) {
-    const connectorsDetected = connectorsFromConfig.find((c) => c.info.name === connector.info.name);
-    if (connectorsDetected) {
-      connectorsDetected.isInstalled = true;
-      connectorsDetected.providers = { ...connectorsDetected.providers, ...connector.providers };
+  for (const connector of connectorsDetecteds) {
+    const _connector = connectorsFromConfig.find((c) => c.info.name === connector.info.name);
+    if (_connector) {
+      _connector.isInstalled = true;
+      _connector.providers = { ..._connector.providers, ...connector.providers };
     } else {
       connectorsFromConfig.push(connector);
     }
@@ -91,3 +92,8 @@ export async function loadConnectors({
 
 //api
 export * from "./wallet-api";
+
+// Export all wallets
+export * from "./wallets";
+
+export { isMobile };

package/src/type.ts

@@ -4,6 +4,7 @@ export enum ProviderProtocol {
   EIP6963 = "eip6963",
   WALLET_STANDARD = "wallet-standard",
   WALLET_CONNECT = "wallet-connect",
+  INJECT = "inject",
 }
 
 export enum ProviderChainType {
@@ -21,11 +22,17 @@ export const SupportedChainTypes = ["evm", "solana", "aptos"];
 export interface WalletInfo {
   uuid: string;
   name: string;
+  sameNames?: string[];
   namespace?: string;
   icon: string;
   iconBackground?: string;
   rdns?: string;
   isWalletConnect?: boolean;
+  deeplink?: string;
+  mobile?: {
+    getUri?: (uri: string) => string;
+    getDeeplink?: (dappUrl?: string, chainId?: number) => string | Promise<string>;
+  };
   links: {
     homepage?: string;
     ios_install?: string;
@@ -62,6 +69,11 @@ export interface Connector {
   };
 }
 
+export interface ConnectParams {
+  dappLink: string;
+  useWalletConnect?: boolean;
+}
+
 export interface SignInParams {
   scheme?: "https" | "http";
   domain: string;
@@ -83,6 +95,7 @@ export interface WalletOptions {
     network?: string;
   };
   provider: WalletProvider;
+  walletInfo?: WalletInfo;
 }
 
 export interface ChainInfo {

package/src/utils/browsers.ts

@@ -37,3 +37,16 @@ export function getBrowser(): BrowserType {
   if (isSafari()) return BrowserType.Safari;
   return BrowserType.Browser;
 }
+
+// open uri in new tab or window
+export function openUri(uri: string) {
+  if (uri.startsWith("http")) {
+    const link = document.createElement("a");
+    link.href = uri;
+    link.target = "_blank";
+    link.rel = "noreferrer noopener";
+    link.click();
+  } else {
+    window.location.href = uri;
+  }
+}

package/src/utils/chainId.ts

@@ -1,4 +1,4 @@
-import { isHex, toHex, fromHex, isAddressEqual } from "viem";
+import { fromHex, isAddressEqual, isHex, toHex } from "viem";
 
 export const isHexChainId = (chainIdHex: string) => {
   return isHex(chainIdHex);

package/src/utils/isMobile.ts

@@ -18,5 +18,5 @@ export function isIOS(): boolean {
 }
 
 export function isMobile(): boolean {
-  return isAndroid() || isIOS();
+  return isAndroid() || isIOS() || isLargeIOS();
 }

package/src/utils/log.ts

@@ -0,0 +1,7 @@
+const isDebug = true;
+
+export function debugLog(...args: any[]) {
+  if (isDebug) {
+    console.log(...args);
+  }
+}

package/src/utils/utils.ts

@@ -12,3 +12,8 @@ export function uniqueConnectors(allConnectors: Connector[]) {
   });
   return connectors;
 }
+
+// uint8array to hex
+export function uint8arrayToHex(uint8array: Uint8Array) {
+  return Array.from(uint8array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}

package/src/wallet-api/balance.ts

@@ -1,5 +1,5 @@
-import { PublicKey, Connection } from "@solana/web3.js";
 import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+import { Connection, PublicKey } from "@solana/web3.js";
 import { WalletOptions } from "type";
 
 export interface BalanceParams {
@@ -41,6 +41,7 @@ export const getBalance = async (
       method: "eth_getBalance",
       params: [address, "latest"],
     });
+    console.log("getBalance evm res:", chainType, provider, { address, chainId, balance });
     return {
       total: Number(balance || "0") || 0,
       tokenInfo,
@@ -52,7 +53,7 @@ export const getBalance = async (
     const connection = new Connection(rpcUrl);
 
     const balances = await connection.getMultipleAccountsInfo([address].map((addr) => new PublicKey(addr)));
-    console.log("solana balances", balances);
+    console.log("solana balances", chainType, provider, { address, chainId, balances });
 
     return {
       total: balances[0]?.lamports || 0,
@@ -86,6 +87,7 @@ export const getBalance = async (
       throw error;
     }
 
+    console.log("solana balances", chainType, provider, { address, chainId, balance });
     return {
       total: balance,
       tokenInfo,

package/src/wallet-api/chain.ts

@@ -1,4 +1,5 @@
 import { ChainInfo, WalletOptions } from "type";
+import { toHex } from "viem";
 import { getAllTypeChainIds } from "../utils/chainId";
 
 export const switchChain = async (chainId: string | number, walletOptions: WalletOptions) => {
@@ -41,8 +42,14 @@ export const addChain = async (chainInfo: ChainInfo, walletOptions: WalletOption
   }
 
   if (chainType === "evm") {
-    if (!chainInfo?.chainId || !chainInfo?.chainId.startsWith("0x")) {
-      throw new Error("Chain ID must starting with 0x");
+    if (!chainInfo?.chainId) {
+      throw new Error("Chain ID is required");
+    }
+
+    if (!chainInfo?.chainId.startsWith("0x")) {
+      const chainId = Number(chainInfo.chainId);
+      const chainIdHex = toHex(chainId);
+      chainInfo.chainId = chainIdHex;
     }
     try {
       await provider.request({

package/src/wallet-api/connect.ts

@@ -1,13 +1,28 @@
-import { WalletOptions } from "type";
+import { ConnectParams, WalletInfo, WalletOptions } from "type";
+import { openUri } from "utils/browsers";
+import { isAndroid, isIOS, isMobile } from "../utils/isMobile";
+import { createWalletConnectEVMProvider } from "../wallets/wallet-walletconnect";
 
 export const connect = async (
-  walletOptions: WalletOptions,
-): Promise<{ address: string; chainId?: string; network?: string }> => {
-  const { provider, chainType } = walletOptions;
+  connectParams: ConnectParams,
+  walletOptions: Omit<WalletOptions, "account">,
+): Promise<{ address: string; chainId?: string; network?: string; provider?: any }> => {
+  //inject provider/walletconnect provider
+  const { provider, chainType, walletInfo } = walletOptions;
+
+  if (isMobile() && walletInfo?.uuid !== "walletConnect" && !provider) {
+    const res = (await connectMobile({
+      connectParams,
+      walletOptions,
+    })) as { address: string; chainId?: string; network?: string; provider?: any };
+    const { address, chainId, network, provider: mobileProvider } = res || {};
+    return { address, chainId, network, provider: mobileProvider };
+  }
 
   if (!provider) {
     throw new Error("Provider is required");
   }
+
   if (!chainType) {
     throw new Error("Chain type is required");
   }
@@ -20,25 +35,59 @@ export const connect = async (
     address = res?.[0] || "";
     chainId = await provider.request({ method: "eth_chainId" });
   }
+
+  // console.log("connect request:", chainType, provider);
   if (chainType === "solana") {
     let res = null;
     if (provider?.connect) {
       res = await provider.connect();
+      address = res?.publicKey?.toString() || "";
     }
     if (provider?.request) {
       res = await provider.request({
         method: "connect",
       });
+      address = res?.publicKey?.toString() || "";
+    }
+    if (provider?.["standard:connect"]) {
+      res = await provider["standard:connect"]?.connect();
+      address = res?.accounts?.[0]?.address || "";
     }
-    address = provider?.publicKey?.toString() || "";
     network = "mainnet-beta";
   }
+
   if (chainType === "aptos") {
-    await provider?.connect();
-    const account = await provider?.account();
-    network = ((await provider?.network()) || "Mainnet") as string;
-    address = account?.address || "";
+    if (provider?.connect) {
+      await provider?.connect();
+    } else if (provider?.request) {
+      await provider.request({ method: "connect" });
+    } else if (provider?.["aptos:connect"]) {
+      await provider["aptos:connect"]?.connect();
+    }
+
+    if (provider?.account) {
+      const account = await provider?.account();
+      address = account?.address || "";
+    } else if (provider?.["aptos:account"]) {
+      const account = await provider?.["aptos:account"]?.account();
+      const addressData = account?.address?.data;
+      const hexString = addressData
+        ? Array.from(addressData as Uint8Array)
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join("")
+        : null;
+      address = `0x${hexString}`;
+    }
+
+    // if (provider?.network) {
+    //   network = ((await provider?.network()) || "Mainnet") as string;
+    // }
+    // if (provider?.["aptos:network"]) {
+    //   network = ((await provider?.["aptos:network"]?.network())?.name || "Mainnet") as string;
+    // }
+    network = "mainnet";
   }
+  console.log("connect res:", chainType, provider, { address, chainId, network });
   return { address, chainId, network };
 };
 
@@ -56,10 +105,91 @@ export const disconnect = async (walletOptions: WalletOptions): Promise<boolean>
     await provider.request({ method: "wallet_revokePermissions" });
   }
   if (chainType === "solana") {
-    await provider.disconnect();
+    if (provider?.disconnect) {
+      await provider.disconnect();
+      return true;
+    }
+    if (provider?.["standard:disconnect"]) {
+      await provider["standard:disconnect"]?.disconnect();
+      return true;
+    }
   }
   if (chainType === "aptos") {
-    await provider.disconnect();
+    if (provider?.disconnect) {
+      await provider.disconnect();
+      return true;
+    }
+    if (provider?.["aptos:disconnect"]) {
+      await provider["aptos:disconnect"]?.disconnect();
+      return true;
+    }
+  }
+  return false;
+};
+
+export const connectMobile = async ({
+  connectParams,
+  walletOptions,
+}: {
+  connectParams: ConnectParams;
+  walletOptions: Omit<WalletOptions, "account">;
+}) => {
+  const { useWalletConnect, dappLink } = connectParams;
+  const { mobile, links } = walletOptions.walletInfo as WalletInfo;
+  const connectWithWalletConnect = () => {
+    return new Promise((resolve, reject) => {
+      // const { chainType } = walletOptions;
+      const { mobile, uuid } = (walletOptions.walletInfo as WalletInfo) || {};
+
+      // Wrap async operations in an IIFE
+      (async () => {
+        try {
+          // TODO: support other chain types
+          const wcInstance = createWalletConnectEVMProvider();
+          // for getting the provider instance
+          const mobileProvider = await wcInstance.getProvider();
+          const wcUri = wcInstance.connectUri;
+          const mobileUri = await mobile?.getUri?.(wcUri);
+
+          if (!mobileUri) {
+            resolve({ address: "", chainId: "" });
+            return;
+          }
+
+          if (uuid !== "walletConnect") openUri(mobileUri);
+          const res = await wcInstance.connect().catch((error: any) => {
+            reject(error);
+          });
+          const address = res?.[0] || "";
+          const chainId = await mobileProvider.request({ method: "eth_chainId" });
+          resolve({ address, chainId, provider: mobileProvider });
+        } catch (error) {
+          reject(error);
+        }
+      })();
+    });
+  };
+  if (useWalletConnect) {
+    return connectWithWalletConnect();
+  } else if (mobile?.getDeeplink) {
+    const deeplink = await mobile?.getDeeplink?.(dappLink);
+    if (deeplink) {
+      openUri(deeplink);
+    }
+  } else if (mobile?.getUri) {
+    return connectWithWalletConnect();
+  } else if (links.android_install || links.ios_install || links.homepage) {
+    if (isAndroid()) {
+      openUri(links.android_install || links.homepage || "");
+    } else if (isIOS()) {
+      openUri(links.ios_install || links.homepage || "");
+    } else {
+      openUri(links.homepage || "");
+    }
+    throw new Error(`${walletOptions.walletInfo?.name} not supported`);
+  } else {
+    throw new Error(`${walletOptions.walletInfo?.name} not supported`);
   }
-  return true;
+  // in mobile, don't return anything, just wait for the mobile wallet to be opened
+  return new Promise(() => {});
 };

package/src/wallet-api/sign-in.ts

@@ -1,5 +1,6 @@
 import { SignInParams, WalletOptions } from "type";
-
+import { uint8arrayToHex } from "utils/utils";
+import { signMessage } from "./sign-message";
 /*
 const params = {
   domain: window.location.host,
@@ -12,7 +13,10 @@ const params = {
 };
 */
 
-export const signInWithWallet = async (signInData: SignInParams, walletOptions: WalletOptions) => {
+export const signInWithWallet = async (
+  signInData: SignInParams,
+  walletOptions: WalletOptions & { isInstalled?: boolean },
+): Promise<string> => {
   const { chainType, account, provider } = walletOptions;
 
   if (!provider) {
@@ -20,23 +24,16 @@ export const signInWithWallet = async (signInData: SignInParams, walletOptions:
   }
 
   const message = signInMessageBuilder(signInData, walletOptions);
-  const { address } = account;
-
   if (chainType === "evm") {
-    try {
-      const sign: string = await provider.request({
-        method: "personal_sign",
-        params: [message, address],
-      });
-      return sign;
-    } catch (error) {
-      throw error as Error;
-    }
+    return await signMessage({ message, nonce: signInData.nonce }, walletOptions);
+  }
+  if (chainType === "aptos") {
+    return await signMessage({ message, nonce: signInData.nonce }, walletOptions);
   }
 
   if (chainType === "solana") {
     try {
-      if (provider?.signIn) {
+      if (provider?.signIn || provider?.["solana:signIn"]) {
         // Create params object without address, scheme, and chainId
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { address: _address, scheme: _scheme, chainId: _chainId, ...signInDataWithoutFields } = signInData;
@@ -44,25 +41,25 @@ export const signInWithWallet = async (signInData: SignInParams, walletOptions:
         const { address: _accountAddress, chainId: _accountChainId, ...accountWithoutFields } = account;
         const params = { ...signInDataWithoutFields, ...accountWithoutFields };
 
-        const { signature } = await provider.signIn(params);
+        const res = provider.signIn ? await provider.signIn(params) : await provider["solana:signIn"]?.signIn(params);
+        let signature = "";
+        if (typeof res === "object" && res?.signature) {
+          signature = res?.signature?.toHex?.() || uint8arrayToHex(res?.signature as Uint8Array) || "";
+        } else if (Array.isArray(res)) {
+          signature = res?.[0]?.signature?.toHex?.() || uint8arrayToHex(res?.[0]?.signature as Uint8Array) || "";
+        } else {
+          signature = res || "";
+        }
+        console.log("signInWithWallet solana res:", chainType, provider, { params, signature });
         return signature;
       }
-      const encodedMessage = new TextEncoder().encode(message);
-      const { signature } = await provider.signMessage(encodedMessage, "utf8");
-      return signature;
+
+      return await signMessage({ message, nonce: signInData.nonce }, walletOptions);
     } catch (error) {
       throw error as Error;
     }
   }
 
-  if (chainType === "aptos") {
-    const { signature } = await provider.signMessage({
-      message,
-      nonce: signInData.nonce,
-    });
-    return signature;
-  }
-
   throw new Error(`signInWithWallet not supported in ${chainType}`);
 };