@effectstream/wallets 0.100.0

package/README.md

@@ -0,0 +1 @@
+# Effectstream Wallets

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@effectstream/wallets",
+  "version": "0.100.0",
+  "license": "MIT",
+  "exports": "./src/mod.ts",
+  "dependencies": {
+    "@effectstream/concise": "0.100.0",
+    "@effectstream/crypto": "0.100.0",
+    "@effectstream/event-client": "0.100.0",
+    "@effectstream/utils": "0.100.0",
+    "@aurowallet/mina-provider": "^1.0.12",
+    "@metamask/providers": "^22.1.0",
+    "@midnight-ntwrk/dapp-connector-api": "4.0.1",
+    "@perawallet/connect": "^1.4.2",
+    "@polkadot/api": "15.10.2",
+    "@polkadot/extension-dapp": "^0.58.10",
+    "@polkadot/extension-inject": "^0.58.10",
+    "@polkadot/util": "^13.4.3",
+    "@polkadot/util-crypto": "^13.4.3",
+    "@types/semver": "7.7.1",
+    "assert-never": "^1.4.0",
+    "avail-js-sdk": "^0.4.2",
+    "bech32": "^2.0.0",
+    "ethers": "^6.15.0",
+    "semver": "^7.7.3",
+    "viem": "2.37.3",
+    "web3": "^4.16.0",
+    "web3-utils": "^4.3.3"
+  }
+}

package/src/IProvider.ts

@@ -0,0 +1,62 @@
+import { AddressType } from "@effectstream/utils";
+
+
+export type WalletOption = {
+  name: string; // name of the wallet used in APIs (as opposed to a human-friendly string)
+  displayName: string;
+  /**
+   * URI-encoded image
+   * DANGER: SVGs can contain Javascript, so these should only be rendered with <img> tags
+   *
+   * Note: not every wallet type has an image (ex: locally generated keypairs)
+   * Example values:
+   * data:image/svg+xml,...
+   * data:image/png;base64,...
+   */
+  icon?: undefined | string;
+};
+
+export type ActiveConnection<T> = {
+  metadata: WalletOption;
+  api: T;
+};
+export type ConnectionOption<T> = {
+  metadata: WalletOption;
+  api: () => Promise<T>;
+};
+export async function optionToActive<T>(option: ConnectionOption<T>): Promise<ActiveConnection<T>> {
+  const connection = {
+    metadata: option.metadata,
+    api: await option.api(),
+  };
+  return connection;
+}
+
+export interface IConnector<T> {
+  getProvider(): undefined | IProvider<T>;
+  getOrThrowProvider(): IProvider<T>;
+  isConnected(): boolean;
+}
+
+export interface IInjectedConnector<T> {
+  /** connect while letting Paima pick all the connection logic for you */
+  connectSimple(): Promise<IProvider<T>>;
+  /** connect to an explicit API that Paima supports */
+  connectNamed(name: string): Promise<IProvider<T>>;
+  /** connect to an API that you've initialized yourself externally */
+  connectExternal(conn: ActiveConnection<T>): Promise<IProvider<T>>;
+}
+
+// Exported to package 
+export type AddressAndType = {
+  type: AddressType;
+  address: string;
+};
+
+export type UserSignature = string;
+
+export interface IProvider<T> {
+  getConnection(): ActiveConnection<T>;
+  signMessage(message: string): Promise<UserSignature>;
+  getAddress(): AddressAndType;
+}

package/src/algorand/algorand.ts

@@ -0,0 +1,168 @@
+import { PeraWalletConnect } from "@perawallet/connect";
+import { AddressType, uint8ArrayToHexString } from "@effectstream/utils";
+import {
+  type IConnector,
+  type IInjectedConnector,
+  type ConnectionOption,
+  optionToActive,
+  type ActiveConnection,
+  type IProvider,
+  type AddressAndType,
+  type UserSignature,
+} from "../IProvider.ts";
+import { getWindow } from "../windows.ts";
+import { CryptoManager } from "@effectstream/crypto";
+
+export type AlgorandApi = PeraWalletConnect;
+export type AlgorandAddress = string;
+
+export class AlgorandConnector
+  implements IConnector<AlgorandApi>, IInjectedConnector<AlgorandApi>
+{
+  private provider: AlgorandProvider | undefined;
+  private static INSTANCE: undefined | AlgorandConnector = undefined;
+
+  static getWalletOptions(): ConnectionOption<AlgorandApi>[] {
+    // Algorand has no standard for wallet discovery
+    // The closest that exists is ARC11 (https://arc.algorand.foundation/ARCs/arc-0011)
+    // but it doesn't give any information about which wallet is injected
+    // and, similar to window.ethereum, has wallets overriding each other
+    // and Pera wallet doesn't even use this standard
+    // instead, the best we can do is check if Pera injected its UI component in the window
+    if (
+      (getWindow() as any)?.customElements.get("pera-wallet-connect-modal") ==
+      null
+    ) {
+      return [];
+    }
+    return [
+      {
+        metadata: {
+          name: "pera",
+          displayName: "Pera Wallet",
+        },
+        api: async (): Promise<AlgorandApi> => {
+          // const { PeraWalletConnect } = await import("@perawallet/connect");
+          const peraWallet = new PeraWalletConnect();
+          return peraWallet;
+        },
+      },
+    ];
+  }
+
+  static instance(): AlgorandConnector {
+    if (AlgorandConnector.INSTANCE == null) {
+      const newInstance = new AlgorandConnector();
+      AlgorandConnector.INSTANCE = newInstance;
+    }
+    return AlgorandConnector.INSTANCE;
+  }
+  connectSimple = async (): Promise<AlgorandProvider> => {
+    if (this.provider != null) {
+      return this.provider;
+    }
+    const options = AlgorandConnector.getWalletOptions();
+    if (options.length === 0) {
+      throw new Error(`No Algorand wallet found`);
+    }
+    return await this.connectExternal(await optionToActive(options[0]));
+  };
+  connectExternal = async (
+    conn: ActiveConnection<AlgorandApi>
+  ): Promise<AlgorandProvider> => {
+    if (this.provider?.getConnection().metadata?.name === conn.metadata.name) {
+      return this.provider;
+    }
+    this.provider = await AlgorandProvider.init(conn);
+    return this.provider;
+  };
+  connectNamed = async (name: string): Promise<AlgorandProvider> => {
+    if (this.provider?.getConnection().metadata?.name === name) {
+      return this.provider;
+    }
+    const provider = AlgorandConnector.getWalletOptions().find(
+      (entry) => entry.metadata.name === name
+    );
+    if (provider == null) {
+      throw new Error(`AlgorandProvider: unsupported connection type ${name}`);
+    }
+    return await this.connectExternal(await optionToActive(provider));
+  };
+  getProvider = (): undefined | AlgorandProvider => {
+    return this.provider;
+  };
+  getOrThrowProvider = (): AlgorandProvider => {
+    if (this.provider == null) {
+      throw new Error(`AlgorandConnector provider isn't initialized yet`);
+    }
+    return this.provider;
+  };
+  isConnected = (): boolean => {
+    return this.provider != null;
+  };
+}
+
+export class AlgorandProvider implements IProvider<AlgorandApi> {
+  constructor(
+    private readonly conn: ActiveConnection<AlgorandApi>,
+    readonly address: AlgorandAddress
+  ) {}
+  static init = async (
+    conn: ActiveConnection<AlgorandApi>
+  ): Promise<AlgorandProvider> => {
+    let newAccounts: string[] = [];
+    // conn.api.isConnected starts as false, even if connected
+    // if connected and connected() is called, then an error is thrown
+    try { 
+      newAccounts = await conn.api.reconnectSession();
+      if ( newAccounts.length < 1) {
+        throw new Error("[peraLogin] no addresses returned!");
+      }
+    } catch (error) {
+      newAccounts = await conn.api.connect();
+    }
+
+    if (newAccounts.length < 1) {
+      throw new Error("[peraLogin] no addresses returned!");
+    }
+    return new AlgorandProvider(conn, newAccounts[0]);
+  };
+  getConnection = (): ActiveConnection<AlgorandApi> => {
+    return this.conn;
+  };
+  getAddress = (): AddressAndType => {
+    return {
+      type: AddressType.ALGORAND,
+      address: this.address,
+    };
+  };
+  signMessage = async (message: string): Promise<UserSignature> => {
+    const txn = await CryptoManager.Algorand().buildAlgorandTransaction(
+      this.getAddress().address,
+      message
+    );
+    const signerTx = {
+      txn,
+      signers: [this.getAddress().address],
+    };
+
+    const signedTxs = await this.conn.api.signTransaction(
+      [[signerTx]],
+      this.getAddress().address
+    );
+    if (signedTxs.length !== 1) {
+      throw new Error(
+        `[signMessageAlgorand] invalid number of signatures returned: ${signedTxs.length}`
+      );
+    }
+    const signedTx = await CryptoManager.Algorand().decodeSignedTransaction(
+      signedTxs[0]
+    );
+    const signature = signedTx.sig;
+    if (!signature) {
+      throw new Error(`[signMessageAlgorand] signature missing in signed Tx`);
+    }
+    const hexSignature = uint8ArrayToHexString(signature);
+    return hexSignature;
+  };
+}

package/src/algorand/wrapper.ts

@@ -0,0 +1,22 @@
+import type { Result } from "@effectstream/utils";
+import type { IProvider } from "../IProvider.ts";
+import type { WalletMode, ApiForMode } from "../utils.ts";
+import { type LoginInfoMap, connectInjected } from "../wallet-modes.ts";
+import { AlgorandConnector } from "./algorand.ts";
+
+export async function algorandLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.Algorand]
+): Promise<Result<IProvider<ApiForMode<WalletMode.Algorand>>>> {
+  const loginResult = await connectInjected(
+    "algorandLoginWrapper",
+    loginInfo,
+    AlgorandConnector.instance()
+  );
+  if (loginResult.success === false) {
+    return loginResult;
+  }
+  return {
+    success: true,
+    result: loginResult.result,
+  };
+}

package/src/avail/avail.ts

@@ -0,0 +1,81 @@
+import { Buffer } from "node:buffer";
+import { utf8ToHex } from 'web3-utils';
+import type { ApiPromise } from "avail-js-sdk";
+import { AddressType } from "@effectstream/utils";
+import type { IProvider, ActiveConnection, AddressAndType, UserSignature } from "../IProvider.ts";
+type PolkadotAddress = string;
+import { u8aToHex } from "@polkadot/util";
+
+// Problematic dependency for deno-fresh
+import type { Keyring } from "avail-js-sdk";
+
+// Problematic dependency for deno-vite
+// import type { Keyring } from "@polkadot/api";
+export type AvailJsApi = { rpc: ApiPromise; keyring: Keyring };
+
+export class AvailConnector {
+  private provider: AvailJsProvider | undefined;
+  private static INSTANCE: undefined | AvailConnector = undefined;
+
+  static instance(): AvailConnector {
+    if (AvailConnector.INSTANCE == null) {
+      const newInstance = new AvailConnector();
+      AvailConnector.INSTANCE = newInstance;
+    }
+    return AvailConnector.INSTANCE;
+  }
+
+  connectExternal = async (conn: AvailJsApi): Promise<AvailJsProvider> => {
+    this.provider = await AvailJsProvider.init(conn);
+    return this.provider;
+  };
+
+  getProvider = (): undefined | AvailJsProvider => {
+    return this.provider;
+  };
+  getOrThrowProvider = (): AvailJsProvider => {
+    if (this.provider == null) {
+      throw new Error(`AvailJsConnector not initialized yet`);
+    }
+    return this.provider;
+  };
+  isConnected = (): boolean => {
+    return this.provider != null;
+  };
+}
+
+export class AvailJsProvider implements IProvider<AvailJsApi> {
+  constructor(
+    private readonly conn: ActiveConnection<AvailJsApi>,
+    readonly address: PolkadotAddress
+  ) {}
+
+  static init = async (api: AvailJsApi): Promise<AvailJsProvider> => {
+    const pair = api.keyring.getPairs()[0];
+
+    const conn = {
+      api: api,
+      metadata: {
+        name: 'AvailJs',
+        displayName: 'AvailJs',
+      },
+    };
+    return new AvailJsProvider(conn, pair.address);
+  };
+
+  getConnection = (): ActiveConnection<AvailJsApi> => {
+    return this.conn;
+  };
+  getAddress = (): AddressAndType => {
+    return {
+      type: AddressType.AVAIL,
+      address: this.address,
+    };
+  };
+  signMessage = async (message: string): Promise<UserSignature> => {
+    const hexMessage = utf8ToHex(message);
+    const buffer = Buffer.from(hexMessage.slice(2), 'hex');
+    const signature = this.conn.api.keyring.getPairs()[0].sign(buffer);
+    return u8aToHex(signature);
+  };
+}

package/src/avail/wrapper.ts

@@ -0,0 +1,44 @@
+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 AvailJsApi, AvailConnector } from "./avail.ts";
+
+// Problematic dependency for deno-fresh
+import { Keyring } from "avail-js-sdk";
+
+// Problematic dependency for deno-vite
+// import { Keyring } from "@polkadot/api";
+
+async function connectWallet(
+  loginInfo: LoginInfoMap[WalletMode.AvailJs]
+): Promise<Result<IProvider<AvailJsApi>>> {
+  try {
+    console.log(`availJsLoginWrapper: Attempting to log into ${loginInfo.connection.metadata.name}`);
+    const keyring = new Keyring({ type: 'sr25519' });
+    keyring.addFromUri(loginInfo.seed);
+
+    const provider = await AvailConnector.instance().connectExternal({
+      rpc: loginInfo.connection.api,
+      keyring: keyring,
+    });
+
+    return {
+      success: true,
+      result: provider,
+    };
+  } catch (err: any) {
+    console.log(`availJsLoginWrapper: Error while logging into wallet name}`);
+    return {
+      success: false,
+      errorMessage: err.message ?? String(err),
+    }
+  }
+}
+
+export async function availJsLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.AvailJs]
+): Promise<Result<IProvider<ApiForMode<WalletMode.AvailJs>>>> {
+  const loginResult = await connectWallet(loginInfo);
+  return loginResult;
+}

package/src/cardano/cardano.ts

@@ -0,0 +1,194 @@
+import { bech32 } from "bech32";
+import { hexStringToUint8Array, AddressType } from "@effectstream/utils";
+import { 
+  type IConnector, 
+  type IInjectedConnector, 
+  type ConnectionOption, 
+  optionToActive, 
+  type ActiveConnection, 
+  type IProvider, 
+  type AddressAndType, 
+  type UserSignature,
+} from "../IProvider.ts";
+import { getWindow } from "../windows.ts";
+import { utf8ToHex } from "web3-utils";
+
+// TODO: proper type definitions for CIP30
+export type CardanoApi = any;
+/** bech32 */
+export type CardanoAddress = {
+  bech32: string;
+  hex: string;
+};
+
+// JSR Error: modifying global types is not allowed
+// declare global {
+//   interface Window {
+//     cardano?: Record<string, { name?: string; enable?: () => Promise<CardanoApi> }>;
+//   }
+// }
+
+// 4 helpers to convert hex addresses to bech32
+const NETWORK_TAG_MAINNET = '1';
+const NETWORK_TAG_TESTNET = '0';
+const PREFIX_MAINNET = 'addr';
+const PREFIX_TESTNET = 'addr_test';
+
+export class CardanoConnector implements IConnector<CardanoApi>, IInjectedConnector<CardanoApi> {
+  private provider: CardanoProvider | undefined;
+  private static INSTANCE: undefined | CardanoConnector = undefined;
+
+  static getWalletOptions(): ConnectionOption<CardanoApi>[] {
+    const cardanoApi: Record<string, { name?: string; enable?: () => Promise<CardanoApi> }> = (getWindow() as any)?.cardano;
+    if (cardanoApi == null) return [];
+
+    const options = Object.entries(cardanoApi).reduce((options, [key, info]) => {
+      if (info.name != null && info.enable != null) {
+        options.push({
+          metadata: {
+            name: key,
+            displayName: info.name,
+            icon: 'icon' in info ? (info.icon as string) : undefined,
+          },
+          api: info.enable,
+        });
+      }
+      return options;
+    }, [] as ConnectionOption<CardanoApi>[]);
+    return options;
+  }
+
+  static instance(): CardanoConnector {
+    if (CardanoConnector.INSTANCE == null) {
+      const newInstance = new CardanoConnector();
+      CardanoConnector.INSTANCE = newInstance;
+    }
+    return CardanoConnector.INSTANCE;
+  }
+  connectSimple = async (): Promise<CardanoProvider> => {
+    if (this.provider != null) {
+      return this.provider;
+    }
+    const options = CardanoConnector.getWalletOptions();
+    if (options.length === 0) {
+      throw new Error(`No Cardano wallet found`);
+    }
+
+    // flint has some custom support for Paima, so best to return this one first if it exists
+    const flintWallet = options.find(option => option.metadata.name === 'flint');
+    if (flintWallet != null) {
+      return await this.connectExternal(await optionToActive(flintWallet));
+    }
+    return await this.connectExternal(await optionToActive(options[0]));
+  };
+  connectNamed = async (name: string): Promise<CardanoProvider> => {
+    if (this.provider?.getConnection().metadata?.name === name) {
+      return this.provider;
+    }
+    const provider = CardanoConnector.getWalletOptions().find(
+      entry => entry.metadata.name === name
+    );
+    if (provider == null) {
+      throw new Error(`Cardano wallet ${name} not found`);
+    }
+    return await this.connectExternal(await optionToActive(provider));
+  };
+  connectExternal = async (
+    conn: ActiveConnection<CardanoApi>
+  ): Promise<CardanoProvider> => {
+    if (this.provider?.getConnection().metadata?.name === conn.metadata.name) {
+      return this.provider;
+    }
+    this.provider = await CardanoProvider.init(conn);
+    return this.provider;
+  };
+  getProvider = (): undefined | CardanoProvider => {
+    return this.provider;
+  };
+  getOrThrowProvider = (): CardanoProvider => {
+    if (this.provider == null) {
+      throw new Error(`CardanoConnector provider isn't initialized yet`);
+    }
+    return this.provider;
+  };
+  isConnected = (): boolean => {
+    return this.provider != null;
+  };
+}
+
+function pickBech32Prefix(hexAddress: string): string {
+  if (hexAddress.length < 2) {
+    throw new Error(
+      `[cardanoLoginSpecific] Invalid address returned from wallet: ${hexAddress}`
+    );
+  }
+  const networkTag = hexAddress.at(1);
+  switch (networkTag) {
+    case NETWORK_TAG_MAINNET:
+      return PREFIX_MAINNET;
+    case NETWORK_TAG_TESTNET:
+      return PREFIX_TESTNET;
+    default:
+      throw new Error(
+        `[cardanoLoginSpecific] Invalid network tag in address ${hexAddress}`
+      );
+  }
+}
+
+export class CardanoProvider implements IProvider<CardanoApi> {
+  constructor(
+    private readonly conn: ActiveConnection<CardanoApi>,
+    readonly address: CardanoAddress
+  ) {}
+
+  static init = async (
+    conn: ActiveConnection<CardanoApi>
+  ): Promise<CardanoProvider> => {
+    const hexAddress = await CardanoProvider.fetchAddress(conn);
+    const prefix = pickBech32Prefix(hexAddress);
+    const words = bech32.toWords(hexStringToUint8Array(hexAddress));
+    const userAddress = bech32.encode(prefix, words, 200);
+
+    return new CardanoProvider(conn, {
+      bech32: userAddress,
+      hex: hexAddress,
+    });
+  };
+  getConnection = (): ActiveConnection<CardanoApi> => {
+    return this.conn;
+  };
+  getAddress = (): AddressAndType => {
+    return {
+      type: AddressType.CARDANO,
+      address: this.address.bech32,
+    };
+  };
+  signMessage = async (message: string): Promise<UserSignature> => {
+    const hexMessage = utf8ToHex(message).slice(2);
+    const address = (this.conn.metadata.name === 'nami' || this.conn.metadata.name === 'subwallet') ? this.address.hex : this.address.bech32;
+    const { signature, key } = await this.conn.api.signData(address, hexMessage);
+    return `${signature}+${key}`;
+  };
+
+  static fetchAddress = async (conn: ActiveConnection<CardanoApi>): Promise<string> => {
+    try {
+      const addresses = await conn.api.getUsedAddresses();
+      if (addresses.length > 0) {
+        return addresses[0];
+      }
+    } catch (err) {
+      console.log('[pickCardanoAddress] error calling getUsedAddresses:', err);
+    }
+
+    try {
+      const unusedAddresses = await conn.api.getUnusedAddresses();
+      if (unusedAddresses.length > 0) {
+        return unusedAddresses[0];
+      }
+    } catch (err) {
+      console.log('[pickCardanoAddress] error calling getUnusedAddresses:', err);
+    }
+
+    throw new Error('[pickCardanoAddress] no used or unused addresses');
+  };
+}

package/src/cardano/wrapper.ts

@@ -0,0 +1,34 @@
+import type { Result } from "@effectstream/utils";
+import type { IProvider } from "../IProvider.ts";
+import type { WalletMode, ApiForMode } from "../utils.ts";
+import { type LoginInfoMap, connectInjected } from "../wallet-modes.ts";
+import { CardanoConnector } from "./cardano.ts";
+
+export async function checkCardanoWalletStatus(): Promise<Result<string>> {
+  const provider = CardanoConnector.instance().getProvider();
+  if (provider == null) {
+    return {
+      success: false,
+      errorMessage: "No Cardano wallet found",
+    };
+  }
+
+  return { success: true, result: "OK" };
+}
+
+export async function cardanoLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.Cardano]
+): Promise<Result<IProvider<ApiForMode<WalletMode.Cardano>>>> {
+  const loginResult = await connectInjected(
+    "cardanoLoginWrapper",
+    loginInfo,
+    CardanoConnector.instance()
+  );
+  if (loginResult.success === false) {
+    return loginResult;
+  }
+  return {
+    success: true,
+    result: loginResult.result,
+  };
+}