@tomo-inc/wallet-adaptor-base 0.0.1

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@tomo-inc/wallet-adaptor-base",
+  "version": "0.0.1",
+  "author": "tomo.inc",
+  "license": "MIT",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "@solana/spl-token": "^0.4.13",
+    "@solana/web3.js": "^1.98.0",
+    "@aptos-labs/ts-sdk": "^5.1.1",
+    "viem": "2.21.54",
+    "@tomo-inc/wallet-connect-protocol": "0.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
+  }
+}

package/project.json

@@ -0,0 +1,67 @@
+{
+  "name": "wallet-adaptor-base",
+  "sourceRoot": "packages/wallet-adaptor-base/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "nx:run-commands",
+      "outputs": ["{projectRoot}/dist"],
+      "options": {
+        "command": "tsup src/index.ts --format esm,cjs --dts --treeshake",
+        "cwd": "packages/wallet-adaptor-base"
+      }
+    },
+    "dev": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "tsup src/index.ts --format esm,cjs --dts --watch",
+        "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": {
+        "command": "eslint src/**/*.ts",
+        "cwd": "packages/wallet-adaptor-base"
+      }
+    },
+    "lint:fix": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "eslint src/**/*.ts --fix",
+        "cwd": "packages/wallet-adaptor-base"
+      }
+    },
+    "format": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "prettier --write \"src/**/*.{ts,tsx}\"",
+        "cwd": "packages/wallet-adaptor-base"
+      }
+    },
+    "test": {
+      "executor": "nx:run-commands",
+      "outputs": ["{projectRoot}/coverage"],
+      "options": {
+        "command": "vitest run",
+        "cwd": "packages/wallet-adaptor-base"
+      }
+    },
+    "test:watch": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "vitest",
+        "cwd": "packages/wallet-adaptor-base"
+      }
+    }
+  },
+  "tags": ["npm:public", "scope:wallet-adaptor-base", "type:library"]
+}

package/src/chains/type.ts

@@ -0,0 +1,3 @@
+export type ChainConfig = any;
+
+export type WagmiChainConfig = any;

package/src/chains/utils.ts

@@ -0,0 +1,20 @@
+import { AdaptorChainType } from "../type";
+import { ChainConfig, WagmiChainConfig } from "./type";
+
+export function chainInfoAdapter(
+  chainConfig: ChainConfig | WagmiChainConfig,
+  chainInfoType: string,
+  chainType: AdaptorChainType,
+): any {
+  if (chainType === "evm") {
+    console.log(chainConfig);
+  }
+  switch (chainInfoType) {
+    case "wagmi":
+      return null as any;
+    case "tomo":
+      return null as any;
+    default:
+      return null as any;
+  }
+}

package/src/index.ts

@@ -0,0 +1,93 @@
+import { AdaptorChainType, Connector, WalletConnectorType } from "./type";
+import { uniqueConnectors } from "./utils/utils";
+import { defaultConnectors } from "./wallets";
+import { WagmiWalletConfig, WalletConfig } from "./wallets/Wallet";
+import { connectorDector, supportedWalletConfigTypes, walletConfigAdapter } from "./wallets/detector";
+import { eip6963Wallets } from "./wallets/wallet-eip6963";
+import { walletStandardWallets } from "./wallets/wallet-standard";
+import { setWalletConnectConfig, walletConnectWallets } from "./wallets/wallet-walletconnect";
+export * from "./type";
+export { setWalletConnectConfig };
+export type { WalletConfig };
+
+//wallets list
+export const TomoDefaultConnectors = defaultConnectors
+  .filter((wallet) => wallet?.info?.links?.chrome_install !== undefined)
+  .sort((a, _b) => (a.isInstalled ? -1 : 1));
+
+export async function loadConnectors({
+  chainType = "all",
+  recommonedConnectors,
+  connectorTypes = [],
+}: {
+  chainType?: AdaptorChainType;
+  recommonedConnectors?: (WalletConfig | WagmiWalletConfig)[];
+  connectorTypes?: WalletConnectorType[];
+}): Promise<{
+  all: Connector[];
+  recommoned: Connector[];
+}> {
+  const recommonedWalletConfigs = recommonedConnectors || [];
+
+  const evmWallets = await eip6963Wallets();
+  const { solanaWallets, aptosWallets } = (await walletStandardWallets()) as {
+    solanaWallets: Connector[];
+    aptosWallets: Connector[];
+  };
+
+  // WalletConnect wallets from WalletConnect Cloud Explorer API
+  const wcWallets = await walletConnectWallets();
+
+  let recommonedConnectorsDetected: Connector[] = [];
+  if (recommonedWalletConfigs.length > 0) {
+    recommonedConnectorsDetected = recommonedWalletConfigs.map((walletConfig, index) => {
+      const connectorType = connectorTypes[index];
+      if (!supportedWalletConfigTypes[connectorType]) {
+        throw new Error(`Unsupported wallet config type: ${connectorType}`);
+      }
+      const _walletConfig = walletConfigAdapter(walletConfig, connectorType);
+      return {
+        ...connectorDector(_walletConfig),
+        recommoned: true,
+      };
+    });
+  }
+
+  const connectorsFromConfig = uniqueConnectors([...recommonedConnectorsDetected, ...defaultConnectors]);
+
+  // Include WalletConnect wallets along with other detected wallets
+  const connectorsDetected = [...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 };
+    } else {
+      connectorsFromConfig.push(connector);
+    }
+  }
+
+  const allConnectors = connectorsFromConfig
+    .filter((wallet) => (chainType !== "all" ? !!wallet.providers[chainType] : true))
+    .sort((a, b) => {
+      // First priority: recommoned wallets
+      if (a.recommoned && !b.recommoned) return -1;
+      if (!a.recommoned && b.recommoned) return 1;
+
+      // Second priority: installed wallets
+      if (a.isInstalled && !b.isInstalled) return -1;
+      if (!a.isInstalled && b.isInstalled) return 1;
+
+      // Equal priority: maintain original order
+      return 0;
+    });
+
+  return {
+    all: allConnectors,
+    recommoned: recommonedConnectorsDetected,
+  };
+}
+
+//api
+export * from "./wallet-api";

package/src/svg.d.ts

@@ -0,0 +1,4 @@
+declare module "*.svg" {
+  const content: string;
+  export default content;
+}

package/src/type.ts

@@ -0,0 +1,99 @@
+export type WalletProvider = any;
+
+export enum ProviderProtocol {
+  EIP6963 = "eip6963",
+  WALLET_STANDARD = "wallet-standard",
+  WALLET_CONNECT = "wallet-connect",
+}
+
+export enum ProviderChainType {
+  inject = "inject",
+  deeplink = "deeplink",
+  walletConnect = "walletConnect",
+}
+
+export type WalletConnectorType = "wagmi" | "tomo";
+
+export type AdaptorChainType = "all" | "evm" | "solana" | "aptos";
+
+export const SupportedChainTypes = ["evm", "solana", "aptos"];
+
+export interface WalletInfo {
+  uuid: string;
+  name: string;
+  namespace?: string;
+  icon: string;
+  iconBackground?: string;
+  rdns?: string;
+  isWalletConnect?: boolean;
+  links: {
+    homepage?: string;
+    ios_install?: string;
+    android_install?: string;
+    chrome_install?: string;
+
+    mobile?: string;
+    qrCode?: string;
+    edge?: string;
+    firefox?: string;
+    opera?: string;
+    safari?: string;
+    macos?: string;
+    windows?: string;
+    linux?: string;
+    desktop?: string;
+  };
+}
+
+export interface ConnectorProvider {
+  provider: any;
+  protocol: ProviderProtocol;
+}
+
+export interface Connector {
+  info: WalletInfo;
+  isInstalled?: boolean;
+  recommoned?: boolean;
+
+  providers: {
+    evm?: ConnectorProvider;
+    solana?: ConnectorProvider;
+    aptos?: ConnectorProvider;
+  };
+}
+
+export interface SignInParams {
+  scheme?: "https" | "http";
+  domain: string;
+  uri?: string;
+  chainId?: string;
+  address?: string;
+  statement: string;
+  version?: string;
+  nonce: string;
+  issuedAt?: string;
+  resources?: `https://${string}`[];
+}
+
+export interface WalletOptions {
+  chainType: AdaptorChainType;
+  account: {
+    address: string;
+    chainId?: string;
+    network?: string;
+  };
+  provider: WalletProvider;
+}
+
+export interface ChainInfo {
+  chainId: string;
+  chainName: string;
+  rpcUrls: string[];
+  iconUrls: string[];
+  nativeCurrency: {
+    name: string;
+    symbol: string;
+    decimals: number;
+  };
+  blockExplorerUrls: string[];
+}

package/src/utils/browsers.ts

@@ -0,0 +1,39 @@
+export function isSafari(): boolean {
+  return (
+    typeof navigator !== "undefined" &&
+    typeof navigator.userAgent !== "undefined" &&
+    /Version\/([0-9._]+).*Safari/.test(navigator.userAgent) // Source: https://github.com/DamonOehlman/detect-browser/blob/master/src/index.ts
+  );
+}
+
+export function isArc(): boolean {
+  return (
+    typeof document !== "undefined" && getComputedStyle(document.body).getPropertyValue("--arc-palette-focus") !== ""
+  );
+}
+
+export enum BrowserType {
+  Arc = "Arc",
+  Brave = "Brave",
+  Browser = "Browser",
+  Chrome = "Chrome",
+  Edge = "Edge",
+  Firefox = "Firefox",
+  Opera = "Opera",
+  Safari = "Safari",
+}
+
+export function getBrowser(): BrowserType {
+  // bail out if `navigator` or `navigator.userAgent` is not available
+  if (typeof navigator === "undefined") return BrowserType.Browser;
+  const ua = navigator.userAgent?.toLowerCase();
+  // @ts-expect-error - brave is not in the navigator type
+  if (navigator.brave?.isBrave) return BrowserType.Brave;
+  if (ua?.indexOf("edg/") > -1) return BrowserType.Edge;
+  if (ua?.indexOf("op") > -1) return BrowserType.Opera;
+  if (isArc()) return BrowserType.Arc;
+  if (ua?.indexOf("chrome") > -1) return BrowserType.Chrome;
+  if (ua?.indexOf("firefox") > -1) return BrowserType.Firefox;
+  if (isSafari()) return BrowserType.Safari;
+  return BrowserType.Browser;
+}

package/src/utils/chainId.ts

@@ -0,0 +1,27 @@
+import { isHex, toHex, fromHex, isAddressEqual } from "viem";
+
+export const isHexChainId = (chainIdHex: string) => {
+  return isHex(chainIdHex);
+};
+
+export const isSameAddress = (addr1: "0x${string}", addr2: "0x${string}") => {
+  return isAddressEqual(addr1, addr2);
+};
+
+export const getAllTypeChainIds = ({ chainId, chainType }: { chainId: string | number; chainType: string }) => {
+  if (isHex(chainId)) {
+    const chainIdHex = chainId;
+    chainId = fromHex(chainId, "number").toString();
+    return {
+      chainId,
+      chainIdHex,
+      chainUid: `${chainType}:${chainId}`,
+    };
+  }
+  const chainIdHex = toHex(Number(chainId));
+  return {
+    chainId,
+    chainIdHex,
+    chainUid: `${chainType}:${chainId}`,
+  };
+};

package/src/utils/isMobile.ts

@@ -0,0 +1,22 @@
+export function isAndroid(): boolean {
+  return typeof navigator !== "undefined" && /android/i.test(navigator.userAgent);
+}
+
+export function isSmallIOS(): boolean {
+  return typeof navigator !== "undefined" && /iPhone|iPod/.test(navigator.userAgent);
+}
+
+export function isLargeIOS(): boolean {
+  return (
+    typeof navigator !== "undefined" &&
+    (/iPad/.test(navigator.userAgent) || (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1))
+  );
+}
+
+export function isIOS(): boolean {
+  return isSmallIOS() || isLargeIOS();
+}
+
+export function isMobile(): boolean {
+  return isAndroid() || isIOS();
+}

package/src/utils/utils.ts

@@ -0,0 +1,14 @@
+import { Connector } from "type";
+
+export function uniqueConnectors(allConnectors: Connector[]) {
+  const connectors: Connector[] = [];
+  const seenRdns = new Set();
+  allConnectors.forEach((connector) => {
+    const key = encodeURIComponent(connector.info.rdns || connector.info.name);
+    if (!seenRdns.has(key)) {
+      seenRdns.add(key);
+      connectors.push(connector);
+    }
+  });
+  return connectors;
+}

package/src/wallet-api/balance.ts

@@ -0,0 +1,96 @@
+import { PublicKey, Connection } from "@solana/web3.js";
+import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+import { WalletOptions } from "type";
+
+export interface BalanceParams {
+  address?: string;
+  chainId: string;
+  type?: "erc20" | "spl" | "native";
+}
+
+export interface ITokenInfo {
+  name: string;
+  symbol: string;
+  decimals: number;
+  address?: string;
+  icon: string;
+  price?: number;
+}
+
+export const getBalance = async (
+  token: BalanceParams,
+  walletOptions: WalletOptions,
+): Promise<{ total: number; tokenInfo: ITokenInfo }> => {
+  const { provider, chainType, account } = walletOptions;
+  const { address } = account;
+  const { chainId } = token;
+  if (!provider) {
+    throw new Error("Provider is required");
+  }
+  if (!chainType) {
+    throw new Error("Chain type is required");
+  }
+
+  const tokenInfo: any = null;
+  if (chainType === "evm") {
+    if (!chainId || chainId !== account.chainId) {
+      throw new Error("Chain id is required and must be current chain id");
+    }
+
+    const balance = await provider.request({
+      method: "eth_getBalance",
+      params: [address, "latest"],
+    });
+    return {
+      total: Number(balance || "0") || 0,
+      tokenInfo,
+    };
+  }
+
+  if (chainType === "solana") {
+    const rpcUrl = "https://rpc.ankr.com/solana/c2d7e8a3db5dce62e202db3d28cca25e74da5028abbf20764e2961918ba34dfc";
+    const connection = new Connection(rpcUrl);
+
+    const balances = await connection.getMultipleAccountsInfo([address].map((addr) => new PublicKey(addr)));
+    console.log("solana balances", balances);
+
+    return {
+      total: balances[0]?.lamports || 0,
+      tokenInfo,
+    };
+  }
+
+  //https://www.npmjs.com/package/@aptos-labs/ts-sdk
+  if (chainType === "aptos") {
+    if (!address) {
+      throw new Error("Address is required for Aptos balance query");
+    }
+
+    let balance = 0;
+    try {
+      const network = account?.network?.toLowerCase() as Network;
+      const aptos = new Aptos(new AptosConfig({ network }));
+
+      const resourceType = "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>";
+
+      const accountResource = await aptos.getAccountResource<{
+        coin: { value: string };
+      }>({
+        accountAddress: address,
+        resourceType,
+      });
+
+      balance = Number(accountResource?.coin?.value || "0") || 0;
+    } catch (error) {
+      console.error("Failed to get Aptos balance:", error);
+      throw error;
+    }
+
+    return {
+      total: balance,
+      tokenInfo,
+    };
+  }
+
+  throw new Error(`getBalance not supported in ${chainType}`);
+};

package/src/wallet-api/chain.ts

@@ -0,0 +1,59 @@
+import { ChainInfo, WalletOptions } from "type";
+import { getAllTypeChainIds } from "../utils/chainId";
+
+export const switchChain = async (chainId: string | number, walletOptions: WalletOptions) => {
+  const { provider, chainType } = walletOptions;
+
+  if (!provider) {
+    throw new Error("Provider is required");
+  }
+  if (!chainType) {
+    throw new Error("Chain type is required");
+  }
+
+  if (chainType === "evm") {
+    const { chainIdHex } = getAllTypeChainIds({ chainId, chainType });
+    if (!chainId || !chainIdHex) {
+      throw new Error("Chain ID is required, or invalid chain ID");
+    }
+    try {
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: chainIdHex }],
+      });
+      return true;
+    } catch (error) {
+      throw error as Error;
+    }
+  }
+
+  throw new Error(`switchChain Not supported in ${chainType}`);
+};
+
+export const addChain = async (chainInfo: ChainInfo, walletOptions: WalletOptions) => {
+  const { provider, chainType } = walletOptions;
+
+  if (!provider) {
+    throw new Error("Provider is required");
+  }
+  if (!chainType) {
+    throw new Error("Chain type is required");
+  }
+
+  if (chainType === "evm") {
+    if (!chainInfo?.chainId || !chainInfo?.chainId.startsWith("0x")) {
+      throw new Error("Chain ID must starting with 0x");
+    }
+    try {
+      await provider.request({
+        method: "wallet_addEthereumChain",
+        params: [chainInfo],
+      });
+      return true;
+    } catch (error: any) {
+      throw error as Error;
+    }
+  }
+
+  throw new Error(`addChain Not supported in ${chainType}`);
+};

package/src/wallet-api/connect.ts

@@ -0,0 +1,65 @@
+import { WalletOptions } from "type";
+
+export const connect = async (
+  walletOptions: WalletOptions,
+): Promise<{ address: string; chainId?: string; network?: string }> => {
+  const { provider, chainType } = walletOptions;
+
+  if (!provider) {
+    throw new Error("Provider is required");
+  }
+  if (!chainType) {
+    throw new Error("Chain type is required");
+  }
+
+  let chainId = "";
+  let address = "";
+  let network = "";
+  if (chainType === "evm") {
+    const res = await provider.request({ method: "eth_requestAccounts" });
+    address = res?.[0] || "";
+    chainId = await provider.request({ method: "eth_chainId" });
+  }
+  if (chainType === "solana") {
+    let res = null;
+    if (provider?.connect) {
+      res = await provider.connect();
+    }
+    if (provider?.request) {
+      res = await provider.request({
+        method: "connect",
+      });
+    }
+    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 || "";
+  }
+  return { address, chainId, network };
+};
+
+export const disconnect = async (walletOptions: WalletOptions): Promise<boolean> => {
+  const { provider, chainType } = walletOptions;
+
+  if (!provider) {
+    throw new Error("Provider is required");
+  }
+  if (!chainType) {
+    throw new Error("chainType is required");
+  }
+
+  if (chainType === "evm") {
+    await provider.request({ method: "wallet_revokePermissions" });
+  }
+  if (chainType === "solana") {
+    await provider.disconnect();
+  }
+  if (chainType === "aptos") {
+    await provider.disconnect();
+  }
+  return true;
+};

package/src/wallet-api/index.ts

@@ -0,0 +1,5 @@
+export * from "./connect";
+export * from "./sign-in";
+export * from "./chain";
+export * from "./balance";
+export * from "./sign-message";