@kheopskit/core 0.0.1-alpha.0

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@kheopskit/core",
+  "version": "0.0.1-alpha.0",
+  "description": "",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "peerDependencies": {
+    "polkadot-api": ">=1.10.0",
+    "rxjs": ">=7.8.0"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "mipd": "^0.0.7",
+    "viem": "^2.29.1"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.16",
+    "polkadot-api": "^1.10.1",
+    "rxjs": "^7.8.2"
+  },
+  "tsup": {
+    "entry": [
+      "src/index.ts"
+    ],
+    "splitting": false,
+    "sourcemap": true,
+    "clean": true,
+    "dts": true,
+    "format": [
+      "esm",
+      "cjs"
+    ],
+    "target": "es2020"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist"
+  }
+}

package/src/api/accounts.ts

@@ -0,0 +1,30 @@
+import { combineLatest, map, Observable, of, shareReplay } from "rxjs";
+import type { ResolvedConfig } from "./config";
+import { ethereumAccounts$ } from "./ethereum/accounts";
+import { polkadotAccounts$ } from "./polkadot/accounts";
+import type { WalletAccount } from "./types";
+
+export const getAccounts$ = (config: ResolvedConfig) => {
+  return new Observable<WalletAccount[]>((subscriber) => {
+    const observables = config.platforms.map<Observable<WalletAccount[]>>(
+      (platform) => {
+        switch (platform) {
+          case "polkadot":
+            return polkadotAccounts$;
+          case "ethereum":
+            return ethereumAccounts$;
+        }
+      }
+    );
+
+    const accounts$ = observables.length
+      ? combineLatest(observables).pipe(map((accounts) => accounts.flat()))
+      : of([]);
+
+    const sub = accounts$.subscribe(subscriber);
+
+    return () => {
+      sub.unsubscribe();
+    };
+  }).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+};

package/src/api/config.ts

@@ -0,0 +1,12 @@
+import type { KheopskitConfig } from "./types";
+
+export type ResolvedConfig = Required<KheopskitConfig>;
+
+export const DEFAULT_CONFIG: ResolvedConfig = {
+  autoReconnect: true,
+  platforms: ["polkadot"],
+};
+
+export const resolveConfig = (config: KheopskitConfig): ResolvedConfig => {
+  return Object.assign({}, DEFAULT_CONFIG, config);
+};

package/src/api/ethereum/accounts.ts

@@ -0,0 +1,86 @@
+import type { EthereumWallet } from "@/api/types";
+import { getAccountId, type AccountId } from "@/utils";
+import {
+  combineLatest,
+  map,
+  Observable,
+  of,
+  shareReplay,
+  switchMap,
+} from "rxjs";
+import { getAddress, type EIP1193Provider } from "viem";
+import { ethereumWallets$ } from "./wallets";
+
+export type EthereumAccount = {
+  id: AccountId;
+  platform: "ethereum";
+  provider: EIP1193Provider;
+  address: `0x${string}`;
+  walletName: string;
+  walletId: string;
+  isWalletDefault: boolean;
+};
+
+const getWalletAccounts$ = (
+  wallet: EthereumWallet
+): Observable<EthereumAccount[]> => {
+  if (!wallet.isEnabled) return of([]);
+
+  return new Observable<EthereumAccount[]>((subscriber) => {
+    const getAccount = (address: string, i: number): EthereumAccount => ({
+      id: getAccountId(wallet.id, address),
+      platform: "ethereum",
+      provider: wallet.provider as EIP1193Provider,
+      address: getAddress(address),
+      walletName: wallet.name,
+      walletId: wallet.id,
+      isWalletDefault: i === 0,
+    });
+
+    const listener = (addresses: string[]) => {
+      subscriber.next(addresses.map(getAccount));
+    };
+
+    // subscribe to changes
+    wallet.provider.on("accountsChanged", listener);
+
+    // initial value
+    wallet.provider
+      .request({ method: "eth_accounts" })
+      .then((addresses: string[]) => {
+        subscriber.next(addresses.map(getAccount));
+      })
+      .catch((err) => {
+        console.error("Failed to get accounts", err);
+        subscriber.next([]);
+      });
+
+    return () => {
+      wallet.provider.removeListener("accountsChanged", listener);
+    };
+  });
+};
+
+export const ethereumAccounts$ = new Observable<EthereumAccount[]>(
+  (subscriber) => {
+    const sub = ethereumWallets$
+      .pipe(
+        map((wallets) => wallets.filter((w) => w.isEnabled)),
+        switchMap((wallets) =>
+          wallets.length
+            ? combineLatest(wallets.map(getWalletAccounts$))
+            : of([])
+        ),
+        map((accounts) => accounts.flat())
+      )
+      .subscribe(subscriber);
+
+    return () => {
+      sub.unsubscribe();
+    };
+  }
+).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+
+ethereumAccounts$.subscribe(() => {
+  console.count("[kheopskit] ethereumAccounts$ emit");
+});

package/src/api/ethereum/wallets.ts

@@ -0,0 +1,103 @@
+import { store } from "@/api/store";
+import type { EthereumWallet } from "@/api/types";
+import { getWalletId, type WalletId } from "@/utils/WalletId";
+import { createStore, type EIP6963ProviderDetail } from "mipd";
+import {
+  BehaviorSubject,
+  combineLatest,
+  map,
+  Observable,
+  shareReplay,
+} from "rxjs";
+import type { EIP1193Provider } from "viem";
+
+const providersDetails$ = new Observable<EIP6963ProviderDetail[]>(
+  (subscriber) => {
+    const store = createStore();
+
+    const unsubscribe = store.subscribe((providerDetails) => {
+      subscriber.next(providerDetails as EIP6963ProviderDetail[]);
+    });
+
+    const providerDetails = store.getProviders();
+
+    subscriber.next(providerDetails as EIP6963ProviderDetail[]);
+
+    return () => {
+      unsubscribe();
+      store.destroy();
+    };
+  }
+).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+
+providersDetails$.subscribe(() => {
+  console.count("[kheopskit] providers$ emit");
+});
+
+export const ethereumWallets$ = new Observable<EthereumWallet[]>(
+  (subscriber) => {
+    const enabledWalletIds$ = new BehaviorSubject<Set<WalletId>>(new Set());
+
+    const connectWallet = async (
+      walletId: WalletId,
+      provider: EIP1193Provider
+    ) => {
+      if (enabledWalletIds$.value.has(walletId))
+        throw new Error(`Extension ${walletId} already connected`);
+
+      provider.request({
+        method: "eth_requestAccounts",
+      });
+
+      const newSet = new Set(enabledWalletIds$.value);
+      newSet.add(walletId);
+      enabledWalletIds$.next(newSet);
+
+      store.addEnabledWalletId(walletId);
+    };
+
+    const disconnectWallet = async (
+      walletId: WalletId,
+      _provider: EIP1193Provider
+    ) => {
+      if (!enabledWalletIds$.value.has(walletId))
+        throw new Error(`Extension ${walletId} is not connected`);
+      const newSet = new Set(enabledWalletIds$.value);
+      newSet.delete(walletId);
+      enabledWalletIds$.next(newSet);
+
+      store.removeEnabledWalletId(walletId);
+    };
+
+    const sub = combineLatest([providersDetails$, enabledWalletIds$])
+      .pipe(
+        map(([providerDetails, enabledWalletIds]) => {
+          return providerDetails.map((pd): EthereumWallet => {
+            const walletId = getWalletId("ethereum", pd.info.rdns);
+            const provider = pd.provider as EIP1193Provider;
+
+            return {
+              platform: "ethereum",
+              id: walletId,
+              name: pd.info.name,
+              icon: pd.info.icon,
+              provider,
+              isEnabled: enabledWalletIds.has(walletId),
+              providerId: pd.info.rdns,
+              connect: () => connectWallet(walletId, provider),
+              disconnect: () => disconnectWallet(walletId, provider),
+            };
+          });
+        })
+      )
+      .subscribe(subscriber);
+
+    return () => {
+      sub.unsubscribe();
+    };
+  }
+).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+
+ethereumWallets$.subscribe(() => {
+  console.count("[kheopskit] ethereumWallets$ emit");
+});

package/src/api/index.ts

@@ -0,0 +1,2 @@
+export * from "./kheopskit";
+export * from "./types";

package/src/api/kheopskit.ts

@@ -0,0 +1,23 @@
+import { combineLatest, map, Observable, shareReplay } from "rxjs";
+import { getAccounts$ } from "./accounts";
+import { resolveConfig } from "./config";
+import type { KheopskitConfig, Wallet, WalletAccount } from "./types";
+import { getWallets$ } from "./wallets";
+
+export type { KheopskitConfig } from "./types";
+
+export const getKheopskit$ = (config: KheopskitConfig) => {
+  const c = resolveConfig(config);
+
+  return new Observable<{ wallets: Wallet[]; accounts: WalletAccount[] }>(
+    (subscriber) => {
+      const subscription = combineLatest([getWallets$(c), getAccounts$(c)])
+        .pipe(map(([wallets, accounts]) => ({ wallets, accounts })))
+        .subscribe(subscriber);
+
+      return () => {
+        subscription.unsubscribe();
+      };
+    }
+  ).pipe(shareReplay({ bufferSize: 1, refCount: true }));
+};

package/src/api/polkadot/accounts.ts

@@ -0,0 +1,71 @@
+import type { PolkadotWallet } from "@/api/types";
+import { getAccountId, type AccountId } from "@/utils";
+import type { InjectedPolkadotAccount } from "polkadot-api/pjs-signer";
+import {
+  combineLatest,
+  map,
+  Observable,
+  of,
+  shareReplay,
+  switchMap,
+} from "rxjs";
+import { polkadotWallets$ } from "./wallets";
+
+export type PolkadotAccount = InjectedPolkadotAccount & {
+  id: AccountId;
+  platform: "polkadot";
+  walletName: string;
+  walletId: string;
+};
+
+const getWalletAccounts$ = (
+  wallet: PolkadotWallet
+): Observable<PolkadotAccount[]> => {
+  if (!wallet.isEnabled) return of([]);
+
+  return new Observable<PolkadotAccount[]>((subscriber) => {
+    const getAccount = (account: InjectedPolkadotAccount): PolkadotAccount => ({
+      id: getAccountId(wallet.id, account.address),
+      ...account,
+      platform: "polkadot",
+      walletName: wallet.name,
+      walletId: wallet.id,
+    });
+
+    // subscribe to changes
+    const unsubscribe = wallet.extension.subscribe((accounts) => {
+      subscriber.next(accounts.map(getAccount));
+    });
+
+    // initial value
+    subscriber.next(wallet.extension.getAccounts().map(getAccount));
+
+    return () => {
+      return unsubscribe();
+    };
+  });
+};
+
+export const polkadotAccounts$ = new Observable<PolkadotAccount[]>(
+  (subscriber) => {
+    const sub = polkadotWallets$
+      .pipe(
+        map((wallets) => wallets.filter((w) => w.isEnabled)),
+        switchMap((wallets) =>
+          wallets.length
+            ? combineLatest(wallets.map(getWalletAccounts$))
+            : of([])
+        ),
+        map((accounts) => accounts.flat())
+      )
+      .subscribe(subscriber);
+
+    return () => {
+      sub.unsubscribe();
+    };
+  }
+).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+
+polkadotAccounts$.subscribe(() => {
+  console.count("[kheopskit] polkadotAccounts$ emit");
+});

package/src/api/polkadot/wallets.ts

@@ -0,0 +1,103 @@
+import { store } from "@/api/store";
+import type { PolkadotWallet } from "@/api/types";
+import { getWalletId, parseWalletId, type WalletId } from "@/utils/WalletId";
+import { isEqual } from "lodash";
+import {
+  connectInjectedExtension,
+  getInjectedExtensions,
+  type InjectedExtension,
+} from "polkadot-api/pjs-signer";
+import {
+  BehaviorSubject,
+  combineLatest,
+  distinctUntilChanged,
+  map,
+  mergeMap,
+  Observable,
+  of,
+  shareReplay,
+  timer,
+} from "rxjs";
+
+const getInjectedWalletsIds = () =>
+  getInjectedExtensions().map((name) => getWalletId("polkadot", name));
+
+const polkadotInjectedWallets$ = new Observable<PolkadotWallet[]>(
+  (subscriber) => {
+    const enabledExtensions$ = new BehaviorSubject<
+      Map<WalletId, InjectedExtension>
+    >(new Map());
+
+    const connect = async (walletId: WalletId) => {
+      if (enabledExtensions$.value.has(walletId))
+        throw new Error(`Extension ${walletId} already connected`);
+      const { identifier } = parseWalletId(walletId);
+      const extension = await connectInjectedExtension(identifier);
+
+      const newMap = new Map(enabledExtensions$.value);
+      newMap.set(walletId, extension);
+      enabledExtensions$.next(newMap);
+
+      store.addEnabledWalletId(walletId);
+    };
+
+    const disconnect = (walletId: WalletId) => {
+      if (!enabledExtensions$.value.has(walletId))
+        throw new Error(`Extension ${walletId} is not connected`);
+
+      const newMap = new Map(enabledExtensions$.value);
+      newMap.delete(walletId);
+      enabledExtensions$.next(newMap);
+
+      store.removeEnabledWalletId(walletId);
+    };
+
+    const walletIds$ = of(0, 200, 500, 1000) // poll for wallets that register after page load
+      .pipe(
+        mergeMap((time) => timer(time)),
+        map(() => getInjectedWalletsIds()),
+        distinctUntilChanged<WalletId[]>(isEqual)
+      );
+
+    const subscription = combineLatest([walletIds$, enabledExtensions$])
+      .pipe(
+        map(([walletIds, enabledExtensions]) => {
+          return walletIds.map((id): PolkadotWallet => {
+            const { identifier } = parseWalletId(id);
+            const extension = enabledExtensions.get(id);
+
+            return extension
+              ? {
+                  id,
+                  platform: "polkadot",
+                  name: identifier,
+                  extensionId: identifier,
+                  isEnabled: true,
+                  extension,
+                  disconnect: () => disconnect(id),
+                }
+              : {
+                  id,
+                  platform: "polkadot",
+                  name: identifier,
+                  extensionId: identifier,
+                  isEnabled: false,
+                  connect: () => connect(id),
+                };
+          });
+        })
+      )
+      .subscribe(subscriber);
+
+    return () => {
+      subscription.unsubscribe();
+    };
+  }
+).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+
+// TODO merge with wallet connect
+export const polkadotWallets$ = polkadotInjectedWallets$;
+
+polkadotWallets$.subscribe(() => {
+  console.count("[kheopskit] polkadotWallets$ emit");
+});

package/src/api/store.ts

@@ -0,0 +1,33 @@
+import { createStore } from "@/utils/createStore";
+import type { KheopskitStoreData } from "./types";
+import { uniq } from "lodash";
+import { parseWalletId, type WalletId } from "@/utils/WalletId";
+
+const LOCAL_STORAGE_KEY = "kheopskit";
+
+const DEFAULT_SETTINGS: KheopskitStoreData = {};
+
+const storage = createStore(LOCAL_STORAGE_KEY, DEFAULT_SETTINGS);
+
+export const addEnabledWalletId = (walletId: WalletId) => {
+  parseWalletId(walletId); // validate walletId
+  storage.mutate((prev) => ({
+    ...prev,
+    autoReconnect: uniq((prev.autoReconnect ?? []).concat(walletId)),
+  }));
+};
+
+export const removeEnabledWalletId = (walletId: WalletId) => {
+  storage.mutate((prev) => ({
+    ...prev,
+    autoReconnect: uniq(
+      (prev.autoReconnect ?? []).filter((id) => id !== walletId)
+    ),
+  }));
+};
+
+export const store = {
+  observable: storage.observable,
+  addEnabledWalletId,
+  removeEnabledWalletId,
+};

package/src/api/types.ts

@@ -0,0 +1,92 @@
+import type { WalletId } from "@/utils/WalletId";
+import type { EIP1193Provider } from "viem";
+import type {
+  InjectedAccount,
+  InjectedExtension,
+  PolkadotSigner,
+} from "polkadot-api/pjs-signer";
+import type { PolkadotAccount } from "./polkadot/accounts";
+import type { EthereumAccount } from "./ethereum/accounts";
+
+type AccountStorageBase = {
+  wallet: string;
+  address: string;
+};
+
+export type EthereumAccountStorage = AccountStorageBase & {
+  platform: "ethereum";
+};
+
+export type PolkadotAccountStorage = AccountStorageBase & {
+  platform: "polkadot";
+  name: InjectedAccount["name"];
+  type: InjectedAccount["type"]; // required, right?
+  genesisHash: InjectedAccount["genesisHash"];
+};
+
+export type AccountStorage = PolkadotAccountStorage | EthereumAccountStorage;
+
+export type Account<T extends AccountStorage> = T & {
+  id: string;
+  signer: T extends PolkadotAccountStorage ? PolkadotSigner : null;
+};
+
+export type PlatformData<T extends AccountStorageBase> = {
+  enabledExtensionIds: string[];
+  accounts: T[];
+  defaultAccountId: string | null;
+};
+
+export type KheopskitStoreData = {
+  // polkadot?: PlatformData<PolkadotAccountStorage>;
+  // ethereum?: PlatformData<EthereumAccountStorage>;
+  autoReconnect?: WalletId[];
+};
+
+export type KheopskitConfig = {
+  autoReconnect?: boolean;
+  platforms: WalletPlatform[];
+};
+
+export type PolkadotDisabledInjectedWallet = {
+  id: WalletId;
+  platform: "polkadot";
+  extensionId: string;
+  name: string;
+  isEnabled: false;
+  connect: () => Promise<void>;
+};
+
+export type PolkadotEnabledInjectedWallet = {
+  id: WalletId;
+  platform: "polkadot";
+  extensionId: string;
+  extension: InjectedExtension;
+  name: string;
+  isEnabled: true;
+  disconnect: () => void;
+};
+
+// TODO export type PolkadotWalletConnectWallet = {}
+
+export type PolkadotWallet =
+  | PolkadotDisabledInjectedWallet
+  | PolkadotEnabledInjectedWallet;
+
+export type EthereumWallet = {
+  platform: "ethereum";
+  id: WalletId;
+  providerId: string;
+  provider: EIP1193Provider;
+  name: string;
+  icon: string;
+  isEnabled: boolean;
+  connect: () => Promise<void>;
+  disconnect: () => void;
+};
+
+export type Wallet = PolkadotWallet | EthereumWallet;
+
+export type WalletPlatform = Wallet["platform"];
+
+export type WalletAccount = PolkadotAccount | EthereumAccount;

package/src/api/wallets.ts

@@ -0,0 +1,70 @@
+import {
+  combineLatest,
+  distinct,
+  filter,
+  map,
+  mergeMap,
+  Observable,
+  of,
+  shareReplay,
+  take,
+} from "rxjs";
+import type { ResolvedConfig } from "./config";
+import { ethereumWallets$ } from "./ethereum/wallets";
+import { polkadotWallets$ } from "./polkadot/wallets";
+import { store } from "./store";
+import type { Wallet } from "./types";
+
+// lock the list of wallets to auto reconnect on first call
+const autoReconnectWalletIds$ = store.observable.pipe(
+  map((s) => s.autoReconnect ?? []),
+  take(1),
+  shareReplay(1)
+);
+
+export const getWallets$ = (config: ResolvedConfig) => {
+  return new Observable<Wallet[]>((subscriber) => {
+    const observables = config.platforms.map<Observable<Wallet[]>>(
+      (platform) => {
+        switch (platform) {
+          case "polkadot":
+            return polkadotWallets$;
+          case "ethereum":
+            return ethereumWallets$;
+        }
+      }
+    );
+
+    const wallets$ = observables.length
+      ? combineLatest(observables).pipe(map((wallets) => wallets.flat()))
+      : of([]);
+
+    const subAutoReconnect = combineLatest([wallets$, autoReconnectWalletIds$])
+      .pipe(
+        filter(([, walletIds]) => config.autoReconnect && !!walletIds?.length),
+        mergeMap(([wallets, walletIds]) =>
+          wallets.filter((wallet) => walletIds?.includes(wallet.id))
+        ),
+        distinct((w) => w.id)
+      )
+      .subscribe(async (wallet) => {
+        if (wallet.isEnabled) {
+          console.warn("Wallet %s already connected", wallet.id);
+          return;
+        }
+
+        try {
+          await wallet.connect();
+        } catch (err) {
+          console.error("Failed to reconnect wallet %s", wallet.id, { err });
+        }
+      });
+
+    const subWallets = wallets$.subscribe(subscriber);
+
+    return () => {
+      subAutoReconnect.unsubscribe();
+      subWallets.unsubscribe();
+    };
+  }).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./api";
+
+export type { KheopskitConfig } from "./api/types";