@effectstream/wallets 0.100.0

package/src/evm/injected.ts

@@ -0,0 +1,429 @@
+import type { MetaMaskInpageProvider } from "@metamask/providers";
+import { AddressType } from "@effectstream/utils";
+import {
+  type ActiveConnection,
+  type AddressAndType,
+  type ConnectionOption,
+  type IInjectedConnector,
+  type IProvider,
+  optionToActive,
+  type UserSignature,
+} from "../IProvider.ts";
+import type { EvmAddress } from "./types.ts";
+import { getWindow } from "../windows.ts";
+import { utf8ToHex } from "web3-utils";
+import * as CHAINS from "viem/chains";
+import type { Chain } from "viem/chains";
+
+type EIP1193Provider = MetaMaskInpageProvider;
+
+interface EIP5749ProviderInfo {
+  uuid: string;
+  name: string;
+  icon: `data:image/svg+xml;base64,${string}`;
+  description: string;
+}
+interface EIP5749ProviderWithInfo extends EIP1193Provider {
+  info: EIP5749ProviderInfo;
+}
+interface EIP5749EVMProviders {
+  /**
+   * The key is RECOMMENDED to be the name of the extension in snake_case. It MUST contain only lowercase letters, numbers, and underscores.
+   */
+  [index: string]: EIP5749ProviderWithInfo;
+}
+
+interface EIP6963ProviderInfo {
+  uuid: string;
+  name: string;
+  icon: string;
+  rdns: string;
+}
+interface EIP6963ProviderDetail {
+  info: EIP6963ProviderInfo;
+  provider: EIP1193Provider;
+}
+interface EIP6963AnnounceProviderEvent extends CustomEvent {
+  type: "eip6963:announceProvider";
+  detail: EIP6963ProviderDetail;
+}
+
+const eip5953Providers: EIP6963ProviderDetail[] = [];
+
+const windowObj = getWindow();
+if (windowObj && (windowObj as any).addEventListener) {
+    (windowObj as any).addEventListener(
+  "eip6963:announceProvider",
+  (event: EIP6963AnnounceProviderEvent) => {
+    eip5953Providers.push(event.detail);
+  });
+}
+if (windowObj && windowObj.dispatchEvent) {
+    windowObj?.dispatchEvent(new Event("eip6963:requestProvider"));
+}
+const CHAIN_NOT_ADDED_ERROR_CODE = 4902;
+
+/**
+ * Type definition from EIP3085 (https://eips.ethereum.org/EIPS/eip-3085)
+ * I couldn't find this part of any NPM library for some reason
+ */
+interface AddEthereumChainParameter {
+  chainId: string;
+  blockExplorerUrls?: string[];
+  chainName?: string;
+  iconUrls?: string[];
+  nativeCurrency?: {
+    name: string;
+    symbol: string;
+    decimals: number;
+  };
+  rpcUrls?: string[];
+}
+
+export type EvmApi = EIP1193Provider;
+
+export class EvmInjectedConnector implements IInjectedConnector<EvmApi> {
+  private provider: EvmInjectedProvider | undefined;
+  private static INSTANCE: undefined | EvmInjectedConnector = undefined;
+
+  /**
+   * Wallets may inject themselves using multiple competing standards
+   * We have to track all of them (with duplicates) internally
+   * To make sure `connectNamed` calls properly find wallets no matter the name used
+   */
+  static getPossiblyDuplicateWalletOptions(): ConnectionOption<EvmApi>[] {
+    const allWallets: ConnectionOption<EvmApi>[] = [];
+
+    const windowObj = getWindow();
+    if (windowObj == null) return [];
+
+    // 1) Add EIP6963 and prioritize it for deduplicating
+    {
+      const eip6963Options = eip5953Providers.map(({ info, provider }) => ({
+        metadata: {
+          name: info.rdns,
+          displayName: info.name,
+          icon: info.icon,
+        },
+        api: (): Promise<MetaMaskInpageProvider> => Promise.resolve(provider),
+      }));
+      allWallets.push(...eip6963Options);
+    }
+
+    // 2) Add EIP5749
+    {
+      const eip5749Providers: EIP5749EVMProviders =
+        (windowObj as any).evmproviders ?? {};
+      const eip5749Options = Object.entries(eip5749Providers).map(
+        ([key, provider]) => ({
+          metadata: {
+            name: key,
+            displayName: provider.info.name,
+            icon: provider.info.icon,
+          },
+          api: (): Promise<EIP5749ProviderWithInfo> =>
+            Promise.resolve(provider),
+        }),
+      );
+      allWallets.push(...eip5749Options);
+    }
+
+    // some wallets aggressively put themselves in the list of wallets the user has installed
+    // even if the user has never actually used these
+    // we put these wallets at the bottom of the priority
+    const aggressiveWallets = ["com.brave.wallet"];
+    allWallets.sort((a, b) => {
+      const aAggressive = aggressiveWallets.includes(a.metadata.name);
+      const bAggressive = aggressiveWallets.includes(b.metadata.name);
+      if (aAggressive && !bAggressive) return 1;
+      if (bAggressive && !aAggressive) return -1;
+      return 0;
+    });
+    return allWallets;
+  }
+  static getWalletOptions(): ConnectionOption<EvmApi>[] {
+    const withDuplicates = EvmInjectedConnector
+      .getPossiblyDuplicateWalletOptions();
+    const seenNames: Set<string> = new Set();
+    const seenDisplayNames: Set<string> = new Set();
+
+    const result: ConnectionOption<EvmApi>[] = [];
+    for (const option of withDuplicates) {
+      const lowerCaseName = option.metadata.displayName.toLowerCase();
+      if (seenNames.has(option.metadata.name)) continue;
+      if (seenDisplayNames.has(lowerCaseName)) continue;
+      seenNames.add(option.metadata.name);
+      seenDisplayNames.add(lowerCaseName);
+      result.push(option);
+    }
+
+    return result;
+  }
+
+  static instance(): EvmInjectedConnector {
+    if (EvmInjectedConnector.INSTANCE == null) {
+      const newInstance = new EvmInjectedConnector();
+      EvmInjectedConnector.INSTANCE = newInstance;
+    }
+    return EvmInjectedConnector.INSTANCE;
+  }
+  connectSimple = async (): Promise<EvmInjectedProvider> => {
+    if (this.provider != null) {
+      return this.provider;
+    }
+    const options = EvmInjectedConnector.getWalletOptions();
+    if (options.length === 0) {
+      throw new Error(`No EVM wallet found`);
+    }
+    return await this.connectExternal(await optionToActive(options[0]));
+  };
+  connectExternal = async (
+    conn: ActiveConnection<EvmApi>,
+  ): Promise<EvmInjectedProvider> => {
+    if (this.provider?.getConnection().metadata?.name === conn.metadata.name) {
+      return this.provider;
+    }
+    this.provider = await EvmInjectedProvider.init(conn);
+
+    // Update the selected Eth address if the user changes after logging in.
+    // warning: not supported by all wallets (ex: Flint)
+    const ethereum: EIP1193Provider = (getWindow() as any).ethereum;
+    ethereum?.on("accountsChanged", (newAccounts) => {
+      const accounts = newAccounts as string[];
+      if (!accounts || !accounts[0] || accounts[0] !== this.provider?.address) {
+        this.provider = undefined;
+      }
+    });
+    return this.provider;
+  };
+  connectNamed = async (name: string): Promise<EvmInjectedProvider> => {
+    if (this.provider?.getConnection().metadata?.name === name) {
+      return this.provider;
+    }
+
+    // the eip6963 name for Metamask is io.metamask
+    // but we want to keep simply "metamask" working for backwards compatibility with older versions of Paima
+    const adjustedName = name.toLocaleLowerCase() === "metamask"
+      ? "io.metamask"
+      : name;
+    const provider = EvmInjectedConnector.getPossiblyDuplicateWalletOptions()
+      .find(
+        (entry) => entry.metadata.name === adjustedName,
+      );
+    if (provider == null) {
+      throw new Error(`EVM wallet ${name} not found`);
+    }
+    return await this.connectExternal(await optionToActive(provider));
+  };
+  getProvider = (): undefined | EvmInjectedProvider => {
+    return this.provider;
+  };
+  getOrThrowProvider = (): EvmInjectedProvider => {
+    if (this.provider == null) {
+      throw new Error(`EvmInjectedConnector not initialized yet`);
+    }
+    return this.provider;
+  };
+  isConnected = (): boolean => {
+    return this.provider != null;
+  };
+
+  switchChain = async (hexChainId: string, chain?: Chain): Promise<void> => {
+    try {
+      // careful: not all wallets support switching chains
+      await this.provider?.getConnection().api.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: hexChainId }],
+      });
+
+      await this.verifyWalletChain(hexChainId);
+    } catch (se: any) {
+      // deno-lint-ignore no-prototype-builtins
+      if (se.hasOwnProperty("code") && se.code === CHAIN_NOT_ADDED_ERROR_CODE) {
+        let targetChain: Chain | undefined = undefined;
+        Object.entries(CHAINS).forEach(([key, value]) => {
+          const possibleChain = value as Chain;
+          if (
+            typeof possibleChain === "object" &&
+            // deno-lint-ignore no-prototype-builtins
+            possibleChain.hasOwnProperty("id") &&
+            possibleChain.id === parseInt(hexChainId, 16)
+          ) {
+            targetChain = possibleChain;
+          }
+        });
+
+        if (chain) {
+          targetChain = chain;
+        }
+        if (!targetChain) {
+          throw new Error(`[switchChain] error: Chain not found`);
+        }
+
+        await this.addChain({
+          chainId: hexChainId,
+          chainName: targetChain.name,
+          nativeCurrency: {
+            name: targetChain.nativeCurrency.name,
+            symbol: targetChain.nativeCurrency.symbol,
+            decimals: targetChain.nativeCurrency.decimals,
+          },
+          rpcUrls: [targetChain.rpcUrls.default.http[0]],
+          blockExplorerUrls: targetChain.blockExplorers?.default.url
+            ? [targetChain.blockExplorers?.default.url]
+            : undefined,
+        });
+      } else {
+        throw new Error(`[switchChain] error: ${se?.message} ` +  se?.code);
+      }
+    }
+  };
+  verifyWalletChain = async (chainId: string): Promise<boolean> => {
+    try {
+      const walletChain = await this.provider?.getConnection().api.request({
+        method: "eth_chainId",
+      });
+      return parseInt(walletChain as string, 16) === parseInt(chainId, 16);
+    } catch (e: any) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      throw new Error(`[verifyWalletChain] error: ${e?.message} ` + e?.code);
+    }
+  };
+  addChain = async (newChain: AddEthereumChainParameter): Promise<void> => {
+    try {
+      // careful: not all wallets support adding arbitrary chains
+      await this.provider?.getConnection().api.request({
+        method: "wallet_addEthereumChain",
+        params: [newChain],
+      });
+    } catch (e: any) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      throw new Error(`[addChain] error: ${e?.message} ` + e?.code);
+    }
+  };
+}
+
+/**
+ * For some reason I can't find any official type definitions for this
+ * https://docs.metamask.io/wallet/reference/eth_sendtransaction/
+ */
+type Web3TransactionRequest = {
+  to?: string;
+  from: string;
+
+  gas?: string;
+  gasPrice?: string;
+
+  data: string;
+  value?: string;
+
+  maxPriorityFeePerGas?: string;
+  maxFeePerGas?: string;
+};
+
+export class EvmInjectedProvider implements IProvider<EvmApi> {
+  constructor(
+    private readonly conn: ActiveConnection<EvmApi>,
+    readonly address: EvmAddress,
+  ) {}
+  static init = async (
+    conn: ActiveConnection<EvmApi>,
+  ): Promise<EvmInjectedProvider> => {
+    const accounts = (await conn.api.request({
+      method: "eth_requestAccounts",
+    })) as string[];
+    if (!accounts || accounts.length === 0) {
+      throw new Error("Unknown error while receiving EVM accounts");
+    }
+
+    return new EvmInjectedProvider(conn, accounts[0]);
+  };
+  getConnection = (): ActiveConnection<EvmApi> => {
+    return this.conn;
+  };
+  getAddress = (): AddressAndType => {
+    return {
+      type: AddressType.EVM,
+      address: this.address.toLowerCase(),
+    };
+  };
+  signMessage = async (message: string): Promise<UserSignature> => {
+    const hexMessage = utf8ToHex(message);
+    const signature = await this.conn.api.request({
+      method: "personal_sign",
+      params: [hexMessage, this.getAddress().address, ""],
+    });
+    if (typeof signature !== "string") {
+      console.log("[signMessageEth] invalid signature:", signature);
+      throw new Error(
+        `[signMessageEth] Received signature of type ${typeof signature}`,
+      );
+    }
+    return signature;
+  };
+  verifyWalletChain = async (): Promise<boolean> => {
+    try {
+      const walletChain = await this.conn.api.request({
+        method: "eth_chainId",
+      });
+      return true;
+      // TODO We have to move this to the top level
+      // return (
+      //   parseInt(walletChain as string, 16) ===
+      //   parseInt(this.gameInfo.gameChainId, 16)
+      // );
+    } catch (e: any) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      throw new Error(`[verifyWalletChain] error: ${e?.message} ` + e?.code);
+    }
+  };
+  addChain = async (newChain: AddEthereumChainParameter): Promise<void> => {
+    try {
+      // careful: not all wallets support adding arbitrary chains
+      await this.conn.api.request({
+        method: "wallet_addEthereumChain",
+        params: [newChain],
+      });
+    } catch (e: any) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      throw new Error(`[addChain] error: ${e?.message} ` + e?.code);
+    }
+  };
+  switchChain = async (hexChainId: string): Promise<void> => {
+    try {
+      // careful: not all wallets support switching chains
+      await this.conn.api.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: hexChainId }],
+      });
+    } catch (e: any) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      throw new Error(`[switchChain] error: ${e?.message} ` + e?.code);
+    }
+  };
+  sendTransaction = async (
+    tx: Web3TransactionRequest,
+  ): Promise<{
+    txHash: string;
+  }> => {
+    await this.verifyWalletChain();
+    try {
+      const hash = await this.conn.api.request({
+        method: "eth_sendTransaction",
+        params: [tx],
+      });
+      if (typeof hash !== "string") {
+        console.log("[sendTransaction] invalid signature:", hash);
+        throw new Error(
+          `[sendTransaction] Received "hash" of type ${typeof hash}`,
+        );
+      }
+      return {
+        txHash: hash,
+      };
+    } catch (e: any) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      throw new Error(`[sendTransaction] error: ${e?.message} ` + e?.code);
+    }
+  };
+}

package/src/evm/types.ts

@@ -0,0 +1,2 @@
+export type EvmAddress = string;
+export const DEFAULT_GAS_LIMIT = 100000;

package/src/evm/wrapper-ethers.ts

@@ -0,0 +1,49 @@
+import type { Result } from "@effectstream/utils";
+import type { IProvider } from "../IProvider.ts";
+import type { WalletMode, ApiForMode } from "../utils.ts";
+import type { LoginInfoMap } from "../wallet-modes.ts";
+import { type EthersApi, EthersConnector } from "./ethers.ts";
+
+async function connectWallet(
+  loginInfo: LoginInfoMap[WalletMode.EvmEthers]
+): Promise<Result<IProvider<EthersApi>>> {
+  const name = loginInfo.connection.metadata.name;
+  try {
+    console.log(`ethersLoginWrapper: Attempting to log into ${name}`);
+    const provider = await EthersConnector.instance().connectExternal(
+      loginInfo.connection.api
+    );
+    return {
+      success: true,
+      result: provider,
+    };
+  } catch (err) {
+    console.log(`ethersLoginWrapper: Error while logging into wallet name}`);
+
+    return {
+      success: false,
+      errorMessage: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+export async function ethersLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.EvmEthers]
+): Promise<Result<IProvider<ApiForMode<WalletMode.EvmEthers>>>> {
+  const loginResult = await connectWallet(loginInfo);
+  if (loginResult.success === false) {
+    return loginResult;
+  }
+  try {
+    // TODO Move this to the top level
+    // await updateFee();
+  } catch (err) {
+    // errorFxn(PaimaMiddlewareErrorCode.ERROR_UPDATING_FEE, err);
+    // The fee has a default value, so this is not fatal and we can continue.
+    // If the fee has increased beyond the default value, posting won't work.
+  }
+
+  return {
+    success: true,
+    result: loginResult.result,
+  };
+}

package/src/evm/wrapper-injected.ts

@@ -0,0 +1,103 @@
+import type { Result } from "@effectstream/utils";
+import type { IProvider } from "../IProvider.ts";
+import type { ApiForMode, WalletMode } from "../utils.ts";
+import { connectInjected, type LoginInfoMap } from "../wallet-modes.ts";
+import { EvmInjectedConnector } from "./injected.ts";
+import type { Chain } from "viem/chains";
+interface SwitchError {
+  code: number;
+}
+
+async function switchChain(chain: Chain | undefined): Promise<boolean> {
+  if (!chain) {
+    // We can't switch to a chain if we don't know what chain to switch to.
+    return false;
+  }
+  const hexChainId = "0x" + chain.id.toString(16);
+  await EvmInjectedConnector.instance().switchChain(
+    hexChainId,
+    chain,
+  );
+  return await verifyWalletChain(chain);
+}
+
+async function verifyWalletChain(chain: Chain | undefined): Promise<boolean> {
+  if (!chain) {
+    return false;
+  }
+  const hexChainId = "0x" + chain.id.toString(16);
+  return await EvmInjectedConnector.instance().verifyWalletChain(hexChainId);
+}
+
+export async function checkEthWalletStatus(): Promise<Result<string>> {
+  // const errorFxn = buildEndpointErrorFxn('checkEthWalletStatus');
+
+  // if (!hasLogin(WalletMode.EvmInjected)) {
+  //   return { success: true, message: '' };
+  // }
+  if (EvmInjectedConnector.instance().getProvider() === null) {
+    return { success: false, errorMessage: "No address selected" };
+  }
+
+  try {
+    if (!(await verifyWalletChain(undefined))) {
+      return { success: false, errorMessage: "EVM_WRONG_CHAIN" };
+    }
+  } catch (err) {
+    return { success: false, errorMessage: "EVM_CHAIN_VERIFICATION" };
+  }
+
+  return { success: true, result: "OK" };
+}
+
+export async function evmLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.EvmInjected],
+): Promise<Result<IProvider<ApiForMode<WalletMode.EvmInjected>>>> {
+  // const errorFxn = buildEndpointErrorFxn('evmLoginWrapper');
+
+  // const evmConfig = await GlobalConfig.mainEvmConfig();
+  // if (evmConfig == null) {
+  //   return errorFxn(
+  //     PaimaMiddlewareErrorCode.EVM_LOGIN,
+  //     new Error(`No EVM network found in configuration`)
+  //   );
+  // }
+  // const [_, config] = evmConfig;
+  // const gameInfo = {
+  //   gameName: getGameName(),
+  //   gameChainId: '0x' + config.chainId.toString(16),
+  // };
+  const loginResult = await connectInjected(
+    "evmLoginWrapper",
+    loginInfo,
+    EvmInjectedConnector.instance(),
+  );
+  if (loginResult.success === false) {
+    return loginResult;
+  }
+
+  try {
+    // TODO Move this to the top level
+    // await updateFee();
+  } catch (err) {
+    // errorFxn(PaimaMiddlewareErrorCode.ERROR_UPDATING_FEE, err);
+    // The fee has a default value, so this is not fatal and we can continue.
+    // If the fee has increased beyond the default value, posting won't work.
+  }
+  try {
+    if (loginInfo.checkChainId !== false) {
+      if (!(await verifyWalletChain(loginInfo.chain))) {
+        if (!(await switchChain(loginInfo.chain))) {
+          return { success: false, errorMessage: "EVM_CHAIN_SWITCH" };
+        }
+      }
+    }
+  } catch (err) {
+    return { success: false, errorMessage: "EVM_CHAIN_SWITCH" };
+  }
+
+  return {
+    success: true,
+    result: loginResult.result,
+  };
+}