@effectstream/wallets 0.100.0

package/src/midnight/midnight.ts

@@ -0,0 +1,196 @@
+import { AddressType, type MidnightAddress } from "@effectstream/utils";
+import type {
+  ConnectedAPI,
+  InitialAPI,
+  Signature,
+} from "@midnight-ntwrk/dapp-connector-api";
+import semver from "semver";
+import {
+  type IInjectedConnector,
+  type ActiveConnection,
+  type IProvider,
+  type AddressAndType,
+  type UserSignature,
+  type IConnector,
+  type ConnectionOption,
+  optionToActive,
+} from "../IProvider.ts";
+import { getWindow } from "../windows.ts";
+
+export type MidnightApi = ConnectedAPI;
+
+const COMPATIBLE_CONNECTOR_API_VERSION = ">=1.0.0";
+const DEFAULT_NETWORK_ID = "undeployed";
+
+// TODO Implement this class
+export class MidnightConnector
+  implements IConnector<MidnightApi>, IInjectedConnector<MidnightApi> {
+  private provider: MidnightProvider | undefined;
+  private static INSTANCE: undefined | MidnightConnector = undefined;
+  private static networkId = DEFAULT_NETWORK_ID;
+  
+  static getWalletOptions(): ConnectionOption<MidnightApi>[] {
+    const midnightApi: Record<string, InitialAPI> = (getWindow() as any)
+      ?.midnight ?? {};
+    console.log("MidnightConnector.getWalletOptions: window.midnight content:", midnightApi);
+    const options = Object.entries(midnightApi).reduce((options, [key, api]) => {
+      console.log(`MidnightConnector.getWalletOptions: Checking wallet "${key}"`, api);
+      if (!isInitialApi(api)) {
+        console.log(`MidnightConnector.getWalletOptions: Wallet "${key}" is NOT a valid InitialAPI (missing connect or apiVersion)`);
+        return options;
+      }
+      if (!isCompatibleApiVersion(api.apiVersion)) {
+        console.log(`MidnightConnector.getWalletOptions: Wallet "${key}" has incompatible version ${api.apiVersion} (required: ${COMPATIBLE_CONNECTOR_API_VERSION})`);
+        return options;
+      }
+      const name = api.rdns?.trim() || key;
+      const displayName = api.name?.trim() || name;
+      console.log(`MidnightConnector.getWalletOptions: Wallet "${key}" is COMPATIBLE. Name: ${name}, DisplayName: ${displayName}`);
+      options.push({
+        metadata: {
+          name,
+          displayName,
+          icon: api.icon,
+        },
+        api: () => connectWithNetwork(api, MidnightConnector.networkId),
+      });
+      return options;
+    }, [] as ConnectionOption<MidnightApi>[]);
+    console.log(`MidnightConnector.getWalletOptions: Found ${options.length} compatible wallets`);
+    return options;
+  }
+  
+  static instance(): MidnightConnector {
+    if (MidnightConnector.INSTANCE == null) {
+      const newInstance = new MidnightConnector();
+      MidnightConnector.INSTANCE = newInstance;
+    }
+    return MidnightConnector.INSTANCE;
+  }
+
+  setNetworkId = (networkId: string): void => {
+    MidnightConnector.networkId = networkId || DEFAULT_NETWORK_ID;
+  };
+
+  getOrThrowProvider = (): MidnightProvider => {
+    if (this.provider == null) {
+      throw new Error(`MidnightConnector provider isn't initialized yet`);
+    }
+    return this.provider;
+  };
+  
+  getProvider = (): undefined | MidnightProvider => {
+    return this.provider;
+  };
+
+  isConnected(): boolean {
+    return this.provider != null;
+  }
+
+  connectSimple = async (): Promise<MidnightProvider> => {
+    if (this.provider != null) {
+      return this.provider;
+    }
+    const options = MidnightConnector.getWalletOptions();
+    if (options.length === 0) {
+      throw new Error(`No Midnight wallet found`);
+    }
+
+    return await this.connectExternal(await optionToActive(options[0]));
+  };
+
+  connectNamed = async (name: string): Promise<MidnightProvider> => {
+    if (this.provider?.getConnection().metadata?.name === name) {
+      return this.provider;
+    }
+    const provider = MidnightConnector.getWalletOptions().find(
+      entry => entry.metadata.name === name
+    );
+    if (provider == null) {
+      throw new Error(`Midnight wallet ${name} not found`);
+    }
+    return await this.connectExternal(await optionToActive(provider));
+  }
+
+  connectExternal = async (conn: ActiveConnection<MidnightApi>): Promise<MidnightProvider> => {
+    if (this.provider?.getConnection().metadata?.name === conn.metadata.name) {
+      return this.provider;
+    }
+    this.provider = await MidnightProvider.init(conn);
+    return this.provider;
+  }
+
+}
+
+// TODO Implement this class
+export class MidnightProvider implements IProvider<MidnightApi> {
+  constructor(
+    private readonly conn: ActiveConnection<MidnightApi>,
+    readonly address: MidnightAddress
+  ) {}
+
+  static init = async (
+    conn: ActiveConnection<MidnightApi>
+  ): Promise<MidnightProvider> => {
+    const hexAddress = await MidnightProvider.fetchAddress(conn);
+    // const prefix = pickBech32Prefix(hexAddress);
+    // const words = bech32.toWords(hexStringToUint8Array(hexAddress));
+    // const userAddress = bech32.encode(prefix, words, 200);
+
+    return new MidnightProvider(conn, hexAddress as MidnightAddress);
+  };
+
+  getConnection(): ActiveConnection<MidnightApi> {
+    return this.conn;
+  }
+  
+  signMessage = async (
+    message: string,
+    keyType: "unshielded" = "unshielded"
+  ): Promise<UserSignature> => {
+    const signature = (await this.conn.api.signData(message, {
+      encoding: "text",
+      keyType,
+    })) as Signature;
+    return signature.signature;
+  };
+
+  getAddress(): AddressAndType {
+    return {
+      type: AddressType.MIDNIGHT,
+      address: this.address,
+    }
+  }
+
+  static fetchAddress = async (conn: ActiveConnection<MidnightApi>): Promise<string> => {
+    const addresses = await conn.api.getShieldedAddresses();
+    if (!addresses?.shieldedAddress) {
+      throw new Error("Midnight wallet did not return a shielded address");
+    }
+    return addresses.shieldedAddress;
+  };
+}
+
+const isInitialApi = (api: InitialAPI | undefined): api is InitialAPI => {
+  return (
+    !!api &&
+    typeof api.connect === "function" &&
+    typeof api.apiVersion === "string"
+  );
+};
+
+const isCompatibleApiVersion = (apiVersion: string): boolean => {
+  return semver.satisfies(
+    apiVersion,
+    COMPATIBLE_CONNECTOR_API_VERSION,
+    { includePrerelease: true }
+  );
+};
+
+const connectWithNetwork = async (
+  api: InitialAPI,
+  networkId: string
+): Promise<ConnectedAPI> => {
+  const connect = api.connect.bind(api);
+  return await connect(networkId);
+};

package/src/midnight/wrapper.ts

@@ -0,0 +1,36 @@
+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 { MidnightConnector } from "./midnight.ts";
+
+export async function checkMidnightWalletStatus(): Promise<Result<string>> {
+  const provider = MidnightConnector.instance().getProvider();
+  if (provider == null) {
+    return {
+      success: false,
+      errorMessage: "No Midnight wallet found",
+    };
+  }
+
+  return { success: true, result: "OK" };
+}
+
+export async function midnightLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.Midnight]
+): Promise<Result<IProvider<ApiForMode<WalletMode.Midnight>>>> {
+  const connector = MidnightConnector.instance();
+  connector.setNetworkId(loginInfo.networkId ?? "undeployed");
+  const loginResult = await connectInjected(
+    "midnightLoginWrapper",
+    loginInfo,
+    connector
+  );
+  if (loginResult.success === false) {
+    return loginResult;
+  }
+  return {
+    success: true,
+    result: loginResult.result,
+  };
+}

package/src/mina/mina.ts

@@ -0,0 +1,175 @@
+import * as AuroMinaApi from "@aurowallet/mina-provider";
+import { AddressType } from "@effectstream/utils";
+import {
+  type IConnector,
+  type IInjectedConnector,
+  type ConnectionOption,
+  type IProvider,
+  optionToActive,
+  type ActiveConnection,
+  type AddressAndType,
+  type UserSignature,
+} from "../IProvider.ts";
+import { getWindow } from "../windows.ts";
+
+export type MinaApi = AuroMinaApi.default;
+
+type MinaAddress = any;
+
+// JSR Error: modifying global types is not allowed
+// declare global {
+//   interface Window {
+//     mina?: Record<string, { name?: string; enable?: () => Promise<MinaApi> }>;
+//   }
+// }
+
+export class MinaConnector
+  implements IConnector<MinaApi>, IInjectedConnector<MinaApi>
+{
+  private provider: MinaProvider | undefined;
+  private static INSTANCE: undefined | MinaConnector = undefined;
+
+  static getWalletOptions(): ConnectionOption<MinaApi>[] {
+    const minaApi: Record<string, { name?: string; enable?: () => Promise<MinaApi> }> = (getWindow() as any)?.mina;
+    if (minaApi == null || !minaApi.isAuro) return [];
+
+    return [
+      {
+        metadata: {
+          name: "auro",
+          displayName: "Auro Wallet",
+        },
+        api: async (): Promise<MinaApi> => {
+          return minaApi as unknown as MinaApi;
+        },
+      },
+    ];
+  }
+
+  static instance(): MinaConnector {
+    if (MinaConnector.INSTANCE == null) {
+      const newInstance = new MinaConnector();
+      MinaConnector.INSTANCE = newInstance;
+    }
+    return MinaConnector.INSTANCE;
+  }
+
+  async connectSimple(): Promise<IProvider<any>> {
+    if (this.provider != null) {
+      return this.provider;
+    }
+
+    const options = MinaConnector.getWalletOptions();
+
+    if (options.length === 0) {
+      throw new Error(`No Mina wallet found`);
+    }
+
+    return await this.connectExternal(await optionToActive(options[0]));
+  }
+
+  async connectNamed(name: string): Promise<IProvider<any>> {
+    if (this.provider?.getConnection().metadata?.name === name) {
+      return this.provider;
+    }
+    const provider = MinaConnector.getWalletOptions().find(
+      (entry) => entry.metadata.name === name
+    );
+    if (provider == null) {
+      throw new Error(`MinaProvider: unsupported connection type ${name}`);
+    }
+    return await this.connectExternal(await optionToActive(provider));
+  }
+
+  connectExternal = async (
+    conn: ActiveConnection<MinaApi>
+  ): Promise<MinaProvider> => {
+    if (this.provider?.getConnection().metadata?.name === conn.metadata.name) {
+      return this.provider;
+    }
+
+    this.provider = await MinaProvider.init(conn);
+
+    conn.api.on("accountsChanged", (accounts) => {
+      if (!accounts || !accounts[0] || accounts[0] !== this.provider?.address) {
+        this.provider = undefined;
+      }
+    });
+
+    return this.provider;
+  };
+  getProvider = (): undefined | MinaProvider => {
+    return this.provider;
+  };
+  getOrThrowProvider = (): MinaProvider => {
+    if (this.provider == null) {
+      throw new Error(`MinaConnector provider isn't initialized yet`);
+    }
+    return this.provider;
+  };
+  isConnected = (): boolean => {
+    return this.provider != null;
+  };
+}
+
+export class MinaProvider implements IProvider<MinaApi> {
+  constructor(
+    private readonly conn: ActiveConnection<MinaApi>,
+    readonly address: MinaAddress
+  ) {}
+
+  static init = async (
+    conn: ActiveConnection<MinaApi>
+  ): Promise<MinaProvider> => {
+    const address = await MinaProvider.fetchAddress(conn);
+
+    return new MinaProvider(conn, address);
+  };
+  getConnection = (): ActiveConnection<MinaApi> => {
+    return this.conn;
+  };
+  getAddress = (): AddressAndType => {
+    return {
+      type: AddressType.MINA,
+      address: this.address,
+    };
+  };
+  signMessage = async (message: string): Promise<UserSignature> => {
+    // There is no way of choosing the signing account here. At most we could
+    // monitor the changed events and erroring out if it changed.
+    const signed = await this.conn.api.signMessage({ message: message });
+
+    if ("signature" in signed) {
+      const { signature } = signed;
+
+      const networkKind = await this.conn.api.requestNetwork();
+
+      // only these two options are used
+      // https://github.com/aurowallet/auro-wallet-browser-extension/blob/624de322dd99baaa09617bbad4a4a838f0a88edc/src/background/lib/index.js#L17
+      // this is part of the hashed message
+      const network =
+        networkKind.networkID === "mina:mainnet" ? "mainnet" : "testnet";
+
+      return `${signature.field};${signature.scalar};${network}`;
+    } else {
+      throw new Error("Failed to sign message");
+    }
+  };
+
+  static fetchAddress = async (
+    conn: ActiveConnection<MinaApi>
+  ): Promise<string> => {
+    try {
+      const addresses = await conn.api.requestAccounts();
+      if ("length" in addresses && addresses.length > 0) {
+        return addresses[0];
+      } else {
+        throw new Error("requestAccounts request failed");
+      }
+    } catch (err) {
+      console.log("[pickMinaAddress] error calling requestAccounts:", err);
+    }
+
+    throw new Error("[pickMinaAddress] no used or unused addresses");
+  };
+}

package/src/mina/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 { MinaConnector } from "./mina.ts";
+
+export async function minaLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.Mina]
+): Promise<Result<IProvider<ApiForMode<WalletMode.Mina>>>> {
+  const loginResult = await connectInjected(
+    "minaLoginWrapper",
+    loginInfo,
+    MinaConnector.instance()
+  );
+  if (loginResult.success === false) {
+    return loginResult;
+  }
+  return {
+    success: true,
+    result: loginResult.result,
+  };
+}

package/src/mod.ts

@@ -0,0 +1,10 @@
+export type { IProvider, AddressAndType, UserSignature, WalletOption } from "./IProvider.ts";
+export type { Wallet } from "./types.ts";
+export type { AddressType, WalletAddress } from "@effectstream/utils";
+export { accountPayload_, accountMessages } from "@effectstream/concise";
+export { WalletMode, WalletNameMap } from "./utils.ts";
+// Main entry point
+export { walletLogin } from "./wallets.ts";
+export { allInjectedWallets } from "./utils.ts";
+export { getAddressType } from "./wallet-modes.ts";
+export * from "./effectstream.ts";

package/src/polkadot/polkadot.ts

@@ -0,0 +1,166 @@
+import type {
+  InjectedExtension,
+  InjectedWindowProvider,
+} from "@polkadot/extension-inject/types";
+import { AddressType } from "@effectstream/utils";
+import {
+  type IConnector,
+  type IInjectedConnector,
+  type ConnectionOption,
+  type ActiveConnection,
+  optionToActive,
+  type IProvider,
+  type AddressAndType,
+  type UserSignature,
+} from "../IProvider.ts";
+import { utf8ToHex } from "web3-utils";
+import { getWindow } from "../windows.ts";
+
+// @polkadot/extension-dapp is browser-only (its bundle touches `window` at module
+// load). Import it lazily inside the methods that need it so this file can be
+// parsed in Node/Bun test contexts — matches the non-browser design note in
+// ../windows.ts.
+export type PolkadotAddress = string;
+export type PolkadotApi = InjectedExtension;
+
+// declare global {
+//   interface Window {
+//     injectedWeb3?: Record<string, InjectedWindowProvider>;
+//   }
+// }
+
+export class PolkadotConnector
+  implements IConnector<PolkadotApi>, IInjectedConnector<PolkadotApi>
+{
+  private provider: PolkadotProvider | undefined;
+  private static INSTANCE: undefined | PolkadotConnector = undefined;
+
+  static async getWalletOptions(): Promise<ConnectionOption<PolkadotApi>[]> {
+    const injectedWeb3: Record<string, InjectedWindowProvider> = (getWindow() as any)?.injectedWeb3;
+    if (injectedWeb3 == null) return [];
+    return Object.keys(injectedWeb3).map((wallet) => ({
+      metadata: {
+        name: wallet,
+        // polkadot provides no way to get a human-friendly name or icon for wallets
+        displayName: wallet,
+      },
+      api: async (): Promise<PolkadotApi> => {
+        const { web3Enable, web3FromSource } = await import("@polkadot/extension-dapp");
+        await web3Enable(/*gameName*/ "paima");
+        const injector = await web3FromSource(wallet);
+        return injector;
+      },
+    }));
+  }
+
+  static instance(): PolkadotConnector {
+    if (PolkadotConnector.INSTANCE == null) {
+      const newInstance = new PolkadotConnector();
+      PolkadotConnector.INSTANCE = newInstance;
+    }
+    return PolkadotConnector.INSTANCE;
+  }
+  connectSimple = async (): Promise<PolkadotProvider> => {
+    if (this.provider != null) {
+      return this.provider;
+    }
+
+    const { web3Enable, web3Accounts, web3FromAddress } = await import("@polkadot/extension-dapp");
+    const extensions = await web3Enable(/*gameName*/ "paima");
+    if (extensions.length === 0) {
+      throw new Error(`[polkadot] no extension detected`);
+    }
+
+    // we get all accounts instead of picking a specific extension
+    // because some extensions could have no accounts in them
+    const allAccounts = await web3Accounts();
+    for (const account of allAccounts) {
+      const injector = await web3FromAddress(account.address);
+      if (injector.signer.signRaw == null) continue;
+      return await this.connectExternal({
+        metadata: {
+          name: account.meta.source,
+          // polkadot provides no way to get a human-friendly name or icon for wallets
+          displayName: account.meta.source,
+        },
+        api: injector,
+      });
+    }
+    throw new Error("[polkadot] No account detected that supports signing! Found extensions: " + extensions.map(e => e.name).join(", "));
+  };
+  connectExternal = async (
+    conn: ActiveConnection<PolkadotApi>
+  ): Promise<PolkadotProvider> => {
+    if (this.provider?.getConnection().metadata?.name === conn.metadata.name) {
+      return this.provider;
+    }
+    this.provider = await PolkadotProvider.init(conn);
+    return this.provider;
+  };
+  connectNamed = async (name: string): Promise<PolkadotProvider> => {
+    if (this.provider?.getConnection().metadata?.name === name) {
+      return this.provider;
+    }
+    const provider = (await PolkadotConnector.getWalletOptions()).find(
+      (entry) => entry.metadata.name === name
+    );
+    if (provider == null) {
+      throw new Error(`Polkadot wallet ${name} not found`);
+    }
+    return await this.connectExternal(await optionToActive(provider));
+  };
+  getProvider = (): undefined | PolkadotProvider => {
+    return this.provider;
+  };
+  getOrThrowProvider = (): PolkadotProvider => {
+    if (this.provider == null) {
+      throw new Error(`PolkadotConnector not initialized yet`);
+    }
+    return this.provider;
+  };
+  isConnected = (): boolean => {
+    return this.provider != null;
+  };
+}
+
+export class PolkadotProvider implements IProvider<PolkadotApi> {
+  constructor(
+    private readonly conn: ActiveConnection<PolkadotApi>,
+    readonly address: PolkadotAddress
+  ) {}
+  static init = async (
+    conn: ActiveConnection<PolkadotApi>
+  ): Promise<PolkadotProvider> => {
+    // { address, name, type: "sr25519" }
+    const addresses = await conn.api.accounts.get(true);
+    const account = addresses.filter(a => a.type === "sr25519")[0]?.address;
+    if (account == null) {
+      throw new Error("Unknown error while receiving Polkadot accounts");
+    }
+
+    return new PolkadotProvider(conn, account);
+  };
+  getConnection = (): ActiveConnection<PolkadotApi> => {
+    return this.conn;
+  };
+  getAddress = (): AddressAndType => {
+    return {
+      type: AddressType.POLKADOT,
+      address: this.address,
+    };
+  };
+  signMessage = async (message: string): Promise<UserSignature> => {
+    if (this.conn.api.signer.signRaw == null) {
+      throw new Error(
+        `[polkadot] extension ${this.conn.metadata.name} does not support signRaw`
+      );
+    }
+    const hexMessage = utf8ToHex(message);
+    const { signature } = await this.conn.api.signer.signRaw({
+      address: this.getAddress().address,
+      data: hexMessage,
+      type: "bytes",
+    });
+    return signature;
+  };
+}

package/src/polkadot/wrapper.ts

@@ -0,0 +1,30 @@
+// import { buildEndpointErrorFxn, PaimaMiddlewareErrorCode } from '../errors.js';
+// import { getGameName } from '../state.js';
+// import type { LoginInfoMap } from '../types.js';
+// import { PolkadotConnector } from '@effectstream/providers';
+// import type { ApiForMode, IProvider, WalletMode } from '@effectstream/providers';
+// import { connectInjected } from './wallet-modes.js';
+// import type { Result } from '@effectstream/utils';
+
+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 { PolkadotConnector } from "./polkadot.ts";
+
+export async function polkadotLoginWrapper(
+  loginInfo: LoginInfoMap[WalletMode.Polkadot]
+): Promise<Result<IProvider<ApiForMode<WalletMode.Polkadot>>>> {
+  const loginResult = await connectInjected(
+    'polkadotLoginWrapper',
+    loginInfo,
+    PolkadotConnector.instance()
+  );
+  if (loginResult.success === false) {
+    return loginResult;
+  }
+  return {
+    success: true,
+    result: loginResult.result,
+  };
+}

package/src/types.ts

@@ -0,0 +1,61 @@
+export type Hash = string;
+import type { WalletAddress } from "@effectstream/utils";
+import type { IProvider, UserSignature, WalletOption } from "./IProvider.ts";
+
+export type SignFunction = (message: string) => Promise<UserSignature>;
+
+export type QueryValue = string | number | boolean;
+export type QueryOptions = Record<string, QueryValue>;
+
+export interface Wallet {
+  provider: IProvider<unknown>;
+  walletAddress: WalletAddress;
+  metadata: WalletOption;
+}
+
+interface BatcherPostResponseSuccessful {
+  success: true;
+  hash: Hash;
+}
+
+interface BatcherPostResponseUnsuccessful {
+  success: false;
+  message: string;
+  code?: number;
+}
+
+export type BatcherPostResponse =
+  | BatcherPostResponseSuccessful
+  | BatcherPostResponseUnsuccessful;
+
+interface BatcherTrackResponseCore {
+  success: true;
+  hash: Hash;
+}
+
+interface BatcherTrackResponsePosted extends BatcherTrackResponseCore {
+  status: "posted";
+  block_height: number;
+  transaction_hash: Hash;
+}
+
+interface BatcherTrackResponseRejected extends BatcherTrackResponseCore {
+  status: "rejected";
+  message: string;
+}
+
+interface BatcherTrackResponseOther extends BatcherTrackResponseCore {
+  status: "accepted" | "validating";
+}
+
+export type BatcherTrackResponse =
+  | BatcherTrackResponsePosted
+  | BatcherTrackResponseRejected
+  | BatcherTrackResponseOther;
+
+export type BaseSuccessResponse = {
+  success: true;
+};
+
+export type PostDataResponse = BaseSuccessResponse & { blockHeight: number };
+export type PostDataResponseAsync = BaseSuccessResponse & { hash: string };