@effectstream/wallets 0.100.0

package/src/utils.test.ts

@@ -0,0 +1,64 @@
+import { test, expect } from "bun:test";
+import {
+  connectInjectedWallet,
+} from "./utils.ts";
+import type { IInjectedConnector, IProvider } from "./IProvider.ts";
+import { AddressType } from "@effectstream/utils";
+
+const MOCK_ADDRESS = "0xmock";
+const MOCK_METADATA = { name: "MockWallet", displayName: "Mock Wallet", icon: "", version: "1.0" };
+
+// Mock provider
+const createMockProvider = (): IProvider<unknown> => ({
+  getConnection: () => ({ metadata: MOCK_METADATA, api: {} }),
+  getAddress: () => ({ type: AddressType.EVM, address: MOCK_ADDRESS }),
+  signMessage: async () => "0xsig",
+});
+
+// Mock connector
+const createMockConnector = (shouldFail = false): IInjectedConnector<unknown> => ({
+  connectSimple: async () => {
+    if (shouldFail) throw new Error("Simple connect failed");
+    return createMockProvider();
+  },
+  connectNamed: async (name: string) => {
+    if (shouldFail) throw new Error(`Named connect to ${name} failed`);
+    return createMockProvider();
+  },
+  connectExternal: async () => {
+    if (shouldFail) throw new Error("External connect failed");
+    return createMockProvider();
+  },
+});
+
+test("connectInjectedWallet - simple login success", async () => {
+  const connector = createMockConnector();
+  const provider = await connectInjectedWallet("Test", undefined, connector);
+  expect(provider.getAddress().address).toEqual(MOCK_ADDRESS);
+});
+
+test("connectInjectedWallet - named login success", async () => {
+  const connector = createMockConnector();
+  const preference = { name: "MockWallet" };
+  const provider = await connectInjectedWallet("Test", preference, connector);
+  expect(provider.getAddress().address).toEqual(MOCK_ADDRESS);
+});
+
+test("connectInjectedWallet - external connection success", async () => {
+  const connector = createMockConnector();
+  const preference = {
+    connection: {
+        api: {},
+        metadata: MOCK_METADATA
+    }
+  };
+  const provider = await connectInjectedWallet("Test", preference, connector);
+  expect(provider.getAddress().address).toEqual(MOCK_ADDRESS);
+});
+
+test("connectInjectedWallet - handles failure", async () => {
+  const connector = createMockConnector(true);
+  expect(
+    connectInjectedWallet("Test", undefined, connector),
+  ).rejects.toThrow("Simple connect failed");
+});

package/src/utils.ts

@@ -0,0 +1,133 @@
+import type {
+  ActiveConnection,
+  IConnector,
+  IInjectedConnector,
+  IProvider,
+} from "./IProvider.ts";
+
+import { AlgorandConnector } from "./algorand/algorand.ts";
+import { EthersConnector } from "./evm/ethers.ts";
+import { EvmInjectedConnector } from "./evm/injected.ts";
+import { CardanoConnector } from "./cardano/cardano.ts";
+import { PolkadotConnector } from "./polkadot/polkadot.ts";
+import { MinaConnector } from "./mina/mina.ts";
+import { AvailConnector } from "./avail/avail.ts";
+import { MidnightConnector } from "./midnight/midnight.ts";
+
+export const enum WalletMode {
+  EvmInjected,
+  EvmEthers,
+  Midnight,
+  Cardano,
+  Polkadot,
+  Algorand,
+  Mina,
+  AvailJs,
+}
+
+export const WalletNameMap: Record<WalletMode, string> = {
+  [WalletMode.EvmInjected]: "EVM",
+  [WalletMode.EvmEthers]: "EVM",
+  [WalletMode.Midnight]: "Midnight",
+  [WalletMode.Cardano]: "Cardano",
+  [WalletMode.Polkadot]: 'Polkadot',
+  [WalletMode.Algorand]: 'Algorand',
+  [WalletMode.Mina]: "Mina",
+  [WalletMode.AvailJs]: "Avail",
+};
+
+export const WalletModeMap = {
+  [WalletMode.EvmInjected]: EvmInjectedConnector.instance(),
+  [WalletMode.EvmEthers]: EthersConnector.instance(),
+  [WalletMode.Midnight]: MidnightConnector.instance(),
+  [WalletMode.Cardano]: CardanoConnector.instance(),
+  [WalletMode.Polkadot]: PolkadotConnector.instance(),
+  [WalletMode.Algorand]: AlgorandConnector.instance(),
+  [WalletMode.Mina]: MinaConnector.instance(),
+  [WalletMode.AvailJs]: AvailConnector.instance(),
+};
+
+type ExtractGeneric<T> = T extends IConnector<infer U> ? U : never;
+export type ApiForMode<Mode extends WalletMode> = ExtractGeneric<
+  (typeof WalletModeMap)[Mode]
+>;
+
+export type InjectionPreference<T> =
+  | {
+    name: string;
+  }
+  | {
+    connection: ActiveConnection<T>;
+  };
+
+export async function allInjectedWallets(config: {
+  signatureSupport: boolean,
+  transactionSupport: boolean,
+} = { 
+  signatureSupport: true,
+  transactionSupport: true,
+}): Promise<{
+  [WalletMode.EvmInjected]: ReturnType<
+    typeof EvmInjectedConnector.getWalletOptions
+  >;
+  [WalletMode.Cardano]: ReturnType<typeof CardanoConnector.getWalletOptions>;
+  [WalletMode.Polkadot]: Awaited<
+    ReturnType<typeof PolkadotConnector.getWalletOptions>
+  >;
+  [WalletMode.Algorand]: ReturnType<typeof AlgorandConnector.getWalletOptions>;
+  [WalletMode.Mina]: ReturnType<typeof MinaConnector.getWalletOptions>;
+  [WalletMode.Midnight]: ReturnType<typeof MidnightConnector.getWalletOptions>;
+}> {
+  const signatureSupport = config.signatureSupport;
+  const transactionSupport = config.transactionSupport;
+  const wallets = {
+    // EVM, CARDANO, MINA, POLKADOR Wallets have full support for signatures and transactions.
+    [WalletMode.EvmInjected]: EvmInjectedConnector.getWalletOptions(),
+    [WalletMode.Cardano]: CardanoConnector.getWalletOptions(),
+    [WalletMode.Polkadot]: await PolkadotConnector.getWalletOptions(),
+    [WalletMode.Mina]: MinaConnector.getWalletOptions(),
+    // TODO: Algorand signature support is not implemented yet.
+    // NOTE: Midnight Do not support signature yet.
+    [WalletMode.Algorand]: signatureSupport? [] : AlgorandConnector.getWalletOptions(),
+    [WalletMode.Midnight]: signatureSupport? [] : MidnightConnector.getWalletOptions(),
+  };
+
+  return wallets;
+}
+export async function connectInjectedWallet<Api>(
+  typeName: string,
+  preference: undefined | InjectionPreference<Api>,
+  connector: IInjectedConnector<Api>,
+): Promise<IProvider<Api>> {
+  if (preference == null) {
+    console.log(`${typeName} Attempting simple login`);
+    const provider = await connector.connectSimple();
+    return provider;
+  } else if ("name" in preference) {
+    const walletName = preference.name;
+    console.log(`${typeName} Attempting to log into ${walletName}`);
+    const provider = await connector.connectNamed(walletName);
+    return provider;
+  } else if ("connection" in preference) {
+    const walletName = preference.connection.metadata.name;
+    console.log(`${typeName} Attempting to log into ${walletName}`);
+    const provider = await connector.connectExternal(preference.connection);
+    return provider;
+  }
+  throw new Error("Invalid preference");
+}
+
+export function callProvider<
+  Mode extends WalletMode,
+  Api extends ApiForMode<Mode>,
+  Func extends keyof IProvider<Api>,
+>(
+  mode: Mode,
+  funcName: Func,
+  ...args: Parameters<IProvider<Api>[Func]>
+): ReturnType<IProvider<Api>[Func]> {
+  const provider = WalletModeMap[mode].getOrThrowProvider();
+  const func = provider[funcName];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return (func as any)(...args);
+}

package/src/wallet-modes.ts

@@ -0,0 +1,124 @@
+import type { ApiPromise } from "avail-js-sdk";
+import type { Result } from "@effectstream/utils";
+import type { AlgorandApi } from "./algorand/algorand.ts";
+import type { CardanoApi } from "./cardano/cardano.ts";
+import type { EthersApi } from "./evm/ethers.ts";
+import type { EvmApi } from "./evm/injected.ts";
+import type {
+  ActiveConnection,
+  IInjectedConnector,
+  IProvider,
+} from "./IProvider.ts";
+import type { MinaApi } from "./mina/mina.ts";
+import type { PolkadotApi } from "./polkadot/polkadot.ts";
+import {
+  connectInjectedWallet,
+  type InjectionPreference,
+  WalletMode,
+} from "./utils.ts";
+import { AddressType } from "@effectstream/utils";
+import type { MidnightApi } from "./midnight/midnight.ts";
+import type { Chain } from "viem/chains";
+import { Wallet } from "ethers";
+
+export type BaseLoginInfo<Api> = {
+  preference?: InjectionPreference<Api>;
+};
+export type LoginInfoMap = {
+  [WalletMode.EvmInjected]: BaseLoginInfo<EvmApi> & {
+    /** If true even EVM wallet inputs will be batched (sign data and send to the batcher) */
+    preferBatchedMode: boolean;
+    /**
+     * By default, Paima will try and switch the wallet's network to the one used for the game
+     * This uses EIP3326 (https://eips.ethereum.org/EIPS/eip-3326)
+     * This may not be desired, since not all wallets support switching to an arbitrary network
+     * Set to false if you only need to sign data. Otherwise, keep as true
+     * @default true
+     */
+    checkChainId?: boolean;
+    chain?: Chain;
+  };
+  [WalletMode.EvmEthers]: {
+    connection: ActiveConnection<EthersApi>;
+    preferBatchedMode: boolean;
+  };
+  [WalletMode.Cardano]: BaseLoginInfo<CardanoApi>;
+  [WalletMode.Polkadot]: BaseLoginInfo<PolkadotApi>;
+  [WalletMode.Algorand]: BaseLoginInfo<AlgorandApi>;
+  [WalletMode.Mina]: BaseLoginInfo<MinaApi>;
+  [WalletMode.AvailJs]: {
+    connection: ActiveConnection<ApiPromise>;
+    preferBatchedMode: boolean;
+    seed: string;
+  };
+  [WalletMode.Midnight]: BaseLoginInfo<MidnightApi> & {
+    networkId?: string;
+  };
+};
+
+type ToUnion<T> = {
+  [K in keyof T]: { mode: K } & T[K];
+}[keyof T];
+
+export type LoginInfo = ToUnion<LoginInfoMap>;
+
+function getWalletName(info: BaseLoginInfo<unknown>): undefined | string {
+  if (info.preference == null) return undefined;
+  if ("name" in info.preference) {
+    return info.preference.name;
+  }
+  return info.preference.connection.metadata.name;
+}
+export async function connectInjected<Api>(
+  typeName: string,
+  loginInfo: BaseLoginInfo<Api>,
+  connector: IInjectedConnector<Api>,
+): Promise<Result<IProvider<Api>>> {
+  try {
+    const provider = await connectInjectedWallet(
+      typeName,
+      loginInfo.preference,
+      connector,
+    );
+    return {
+      success: true,
+      result: provider,
+    };
+  } catch (err) {
+    console.log(
+      `${typeName} Error while logging into wallet ${
+        getWalletName(loginInfo) ?? "simple"
+      }`,
+    );
+
+    return {
+      success: false,
+      errorMessage: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+export function getAddressType(mode: WalletMode): AddressType {
+  switch (mode) {
+
+    case WalletMode.EvmInjected:
+    case WalletMode.EvmEthers:
+      return AddressType.EVM;
+    case WalletMode.Cardano:
+      return AddressType.CARDANO;
+    case WalletMode.Polkadot:
+      return AddressType.POLKADOT;
+    case WalletMode.Algorand:
+      return AddressType.ALGORAND;
+    case WalletMode.Mina:
+      return AddressType.MINA;
+    case WalletMode.Midnight:
+      return AddressType.MIDNIGHT;
+    case WalletMode.AvailJs:
+      return AddressType.AVAIL;
+    case WalletMode.Polkadot:
+      return AddressType.POLKADOT;
+    default:
+      throw new Error(`Unsupported wallet mode: ${mode}`);
+  }
+};

package/src/wallets.ts

@@ -0,0 +1,62 @@
+import type { IProvider } from "./IProvider.ts";
+import { algorandLoginWrapper } from "./algorand/wrapper.ts";
+import { cardanoLoginWrapper } from "./cardano/wrapper.ts";
+import { evmLoginWrapper } from "./evm/wrapper-injected.ts";
+import { polkadotLoginWrapper } from "./polkadot/wrapper.ts";
+import { ethersLoginWrapper } from "./evm/wrapper-ethers.ts";
+import { minaLoginWrapper } from "./mina/wrapper.ts";
+import { availJsLoginWrapper } from "./avail/wrapper.ts";
+import { WalletMode } from "./utils.ts";
+import type { Result } from "@effectstream/utils";
+import type { Wallet } from "./types.ts";
+import type { LoginInfo } from "./wallet-modes.ts";
+// import { assertNever } from "assert-never";
+import { midnightLoginWrapper } from "./midnight/wrapper.ts";
+
+export async function walletLogin(
+  loginInfo: LoginInfo
+): Promise<Result<Wallet>> {
+  const provider = await login(loginInfo);
+  if (provider.success === false) return provider;
+
+  return {
+    success: true,
+    result: {
+      provider: provider.result,
+      walletAddress: provider.result.getAddress().address,
+      metadata: provider.result.getConnection().metadata,
+    },
+  };
+}
+
+
+async function login(loginInfo: LoginInfo): Promise<Result<IProvider<unknown>>> {
+  switch (loginInfo.mode) {
+    case WalletMode.EvmInjected: {
+      return await evmLoginWrapper(loginInfo);
+    }
+    case WalletMode.EvmEthers: {
+      return await ethersLoginWrapper(loginInfo);
+    }
+    case WalletMode.Cardano: {
+      return await cardanoLoginWrapper(loginInfo);
+    }
+    case WalletMode.Polkadot: {
+      return await polkadotLoginWrapper(loginInfo);
+    }
+    case WalletMode.Algorand: {
+      return await algorandLoginWrapper(loginInfo);
+    }
+    case WalletMode.Mina: {
+      return await minaLoginWrapper(loginInfo);
+    }
+    case WalletMode.AvailJs: {
+      return await availJsLoginWrapper(loginInfo);
+    }
+    case WalletMode.Midnight: {
+      return await midnightLoginWrapper(loginInfo);
+    }
+    default:
+      throw new Error(`Unsupported wallet mode: ${(loginInfo as any).mode}`);
+  }
+};

package/src/windows.ts

@@ -0,0 +1,10 @@
+/**
+ * Paima might be used in non-browser environments where window isn't defined
+ */
+export function getWindow() /*: (Window & typeof globalThis) | undefined*/ {
+    // recall: this is different semantically to window?.foo
+    // since window?.foo can still give ReferenceError: window is not defined
+    // dnt-shim-ignore
+    return typeof window === 'undefined' ? undefined : window;
+}
+