@kheopskit/core 0.0.1-alpha.1 → 0.0.2

package/src/api/ethereum/accounts.ts

@@ -1,76 +1,207 @@
-import type { EthereumAccount, EthereumWallet } from "@/api/types";
+import type {
+  EthereumAccount,
+  EthereumAppKitWallet,
+  EthereumInjectedWallet,
+  EthereumWallet,
+} from "@/api/types";
 import { getWalletAccountId } from "@/utils";
+import { getCachedObservable$ } from "@/utils/getCachedObservable";
+import type UniversalProvider from "@walletconnect/universal-provider";
 import {
+  Observable,
+  ReplaySubject,
   combineLatest,
+  distinctUntilChanged,
   map,
-  Observable,
   of,
   shareReplay,
   switchMap,
 } from "rxjs";
-import { getAddress, type EIP1193Provider } from "viem";
-import { ethereumWallets$ } from "./wallets";
+import {
+  type EIP1193Provider,
+  createWalletClient,
+  custom,
+  getAddress,
+} from "viem";
 
-const getWalletAccounts$ = (
-  wallet: EthereumWallet
+const getInjectedWalletAccounts$ = (
+  wallet: EthereumInjectedWallet,
 ): Observable<EthereumAccount[]> => {
   if (!wallet.isConnected) return of([]);
 
-  return new Observable<EthereumAccount[]>((subscriber) => {
-    const getAccount = (address: string, i: number): EthereumAccount => ({
-      id: getWalletAccountId(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));
-    };
+  return getCachedObservable$(`accounts:${wallet.id}`, () =>
+    new Observable<EthereumAccount[]>((subscriber) => {
+      const getAccount = (address: string, i: number): EthereumAccount => {
+        // console.log("[Injected] createWalletClient", address);
+        const client = createWalletClient({
+          account: address as `0x${string}`,
+          transport: custom(wallet.provider as EIP1193Provider),
+        });
 
-    // subscribe to changes
-    wallet.provider.on("accountsChanged", listener);
+        return {
+          id: getWalletAccountId(wallet.id, address),
+          platform: "ethereum",
+          client,
+          address: getAddress(address),
+          walletName: wallet.name,
+          walletId: wallet.id,
+          isWalletDefault: i === 0,
+        };
+      };
 
-    // initial value
-    wallet.provider
-      .request({ method: "eth_accounts" })
-      .then((addresses: string[]) => {
+      const handleAccountsChanged = (addresses: string[]) => {
         subscriber.next(addresses.map(getAccount));
-      })
-      .catch((err) => {
-        console.error("Failed to get accounts", err);
-        subscriber.next([]);
-      });
+      };
 
-    return () => {
-      wallet.provider.removeListener("accountsChanged", listener);
-    };
+      // subscribe to changes
+      wallet.provider.on("accountsChanged", handleAccountsChanged);
+
+      // 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",
+          handleAccountsChanged,
+        );
+      };
+    }).pipe(shareReplay({ refCount: true, bufferSize: 1 })),
+  );
+};
+
+const wrapWalletConnectProvider = (
+  provider: EIP1193Provider,
+  sessionTopic: string,
+  caipNetworkId: string,
+): EIP1193Provider => {
+  return new Proxy(provider, {
+    get(target, prop, receiver) {
+      if (prop !== "request") return Reflect.get(target, prop, receiver);
+
+      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+      return (args: any) => {
+        // console.log("request", { target, prop, receiver, caipNetworkId, args });
+
+        if (args && typeof args === "object" && args.method) {
+          if (!args.topic) args.topic = sessionTopic;
+          if (!args.chainId) args.chainId = caipNetworkId;
+        }
+        return target.request(args);
+      };
+    },
   });
 };
 
-export const ethereumAccounts$ = new Observable<EthereumAccount[]>(
-  (subscriber) => {
-    const sub = ethereumWallets$
+const getAppKitAccounts$ = (
+  wallet: EthereumAppKitWallet,
+): Observable<EthereumAccount[]> => {
+  const account = wallet.appKit.getAccount("eip155");
+  const provider = wallet.appKit.getProvider<UniversalProvider>("eip155");
+
+  if (
+    !wallet.isConnected ||
+    !wallet.appKit ||
+    !account?.allAccounts.length ||
+    !provider?.session
+  )
+    return of([]);
+
+  return getCachedObservable$("accounts:appKit", () =>
+    new Observable<EthereumAccount[]>((subscriber) => {
+      const caipNetworkId$ = new ReplaySubject<string>(1);
+
+      const handleChainChanged = (chainId: unknown) => {
+        caipNetworkId$.next(`eip155:${chainId}`);
+      };
+
+      provider.on("chainChanged", handleChainChanged);
+      provider.request({ method: "eth_chainId" }).then(handleChainChanged);
+
+      const sub = caipNetworkId$
+        .pipe(
+          distinctUntilChanged(),
+          map((caipNetworkId) =>
+            custom(
+              wrapWalletConnectProvider(
+                provider as EIP1193Provider,
+                // biome-ignore lint/style/noNonNullAssertion: <explanation>
+                provider.session!.topic,
+                caipNetworkId,
+              ),
+            ),
+          ),
+          map((transport) =>
+            account.allAccounts.map((acc, i): EthereumAccount => {
+              // console.log("[AppKit] createWalletClient", acc);
+              const client = createWalletClient({
+                account: acc.address as `0x${string}`,
+                transport,
+              });
+
+              return {
+                id: getWalletAccountId(wallet.id, acc.address),
+                platform: "ethereum",
+                walletName: wallet.name,
+                walletId: wallet.id,
+                address: acc.address as `0x${string}`,
+                client,
+                isWalletDefault: i === 0,
+              };
+            }),
+          ),
+        )
+        .subscribe(subscriber);
+
+      return () => {
+        provider.off("chainChanged", handleChainChanged);
+        sub.unsubscribe();
+      };
+    }).pipe(shareReplay({ refCount: true, bufferSize: 1 })),
+  );
+};
+
+export const getEthereumAccounts$ = (
+  ethereumWallets: Observable<EthereumWallet[]>,
+) =>
+  new Observable<EthereumAccount[]>((subscriber) => {
+    const sub = ethereumWallets
       .pipe(
         map((wallets) => wallets.filter((w) => w.isConnected)),
-        switchMap((wallets) =>
-          wallets.length
-            ? combineLatest(wallets.map(getWalletAccounts$))
-            : of([])
-        ),
-        map((accounts) => accounts.flat())
+        switchMap((wallets) => {
+          return wallets.length
+            ? combineLatest([
+                ...wallets
+                  .filter((w) => w.type === "injected")
+                  .map(getInjectedWalletAccounts$),
+                ...wallets
+                  .filter((w) => w.type === "appKit")
+                  .map(getAppKitAccounts$),
+                // todo appkit
+              ])
+            : of([]);
+        }),
+        map((accounts) => accounts.flat()),
+        distinctUntilChanged(isSameAccountsList),
       )
       .subscribe(subscriber);
 
     return () => {
       sub.unsubscribe();
     };
-  }
-).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+  }).pipe(
+    // logObservable("ethereumAccounts$", true),
+    shareReplay({ refCount: true, bufferSize: 1 }),
+  );
 
-ethereumAccounts$.subscribe(() => {
-  console.count("[kheopskit] ethereumAccounts$ emit");
-});
+const isSameAccountsList = (a: EthereumAccount[], b: EthereumAccount[]) => {
+  if (a.length !== b.length) return false;
+  return a.every((account, i) => account.id === b[i]?.id);
+};

package/src/api/ethereum/wallets.ts

@@ -1,15 +1,20 @@
 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 type {
+  EthereumInjectedWallet,
+  EthereumWallet,
+  KheopskitConfig,
+} from "@/api/types";
+import { type WalletId, getWalletId } from "@/utils/WalletId";
+import { type EIP6963ProviderDetail, createStore } from "mipd";
 import {
   BehaviorSubject,
+  Observable,
   combineLatest,
   map,
-  Observable,
   shareReplay,
 } from "rxjs";
 import type { EIP1193Provider } from "viem";
+import { getAppKitWallets$ } from "../appKit";
 
 const providersDetails$ = new Observable<EIP6963ProviderDetail[]>(
   (subscriber) => {
@@ -27,25 +32,21 @@ const providersDetails$ = new Observable<EIP6963ProviderDetail[]>(
       unsubscribe();
       store.destroy();
     };
-  }
+  },
 ).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
 
-providersDetails$.subscribe(() => {
-  console.count("[kheopskit] providers$ emit");
-});
-
-export const ethereumWallets$ = new Observable<EthereumWallet[]>(
+const ethereumInjectedWallets$ = new Observable<EthereumInjectedWallet[]>(
   (subscriber) => {
     const enabledWalletIds$ = new BehaviorSubject<Set<WalletId>>(new Set());
 
     const connectWallet = async (
       walletId: WalletId,
-      provider: EIP1193Provider
+      provider: EIP1193Provider,
     ) => {
       if (enabledWalletIds$.value.has(walletId))
         throw new Error(`Extension ${walletId} already connected`);
 
-      provider.request({
+      await provider.request({
         method: "eth_requestAccounts",
       });
 
@@ -56,10 +57,7 @@ export const ethereumWallets$ = new Observable<EthereumWallet[]>(
       store.addEnabledWalletId(walletId);
     };
 
-    const disconnectWallet = async (
-      walletId: WalletId,
-      _provider: EIP1193Provider
-    ) => {
+    const disconnectWallet = async (walletId: WalletId) => {
       if (!enabledWalletIds$.value.has(walletId))
         throw new Error(`Extension ${walletId} is not connected`);
       const newSet = new Set(enabledWalletIds$.value);
@@ -72,12 +70,13 @@ export const ethereumWallets$ = new Observable<EthereumWallet[]>(
     const sub = combineLatest([providersDetails$, enabledWalletIds$])
       .pipe(
         map(([providerDetails, enabledWalletIds]) => {
-          return providerDetails.map((pd): EthereumWallet => {
+          return providerDetails.map((pd): EthereumInjectedWallet => {
             const walletId = getWalletId("ethereum", pd.info.rdns);
             const provider = pd.provider as EIP1193Provider;
 
             return {
               platform: "ethereum",
+              type: "injected",
               id: walletId,
               name: pd.info.name,
               icon: pd.info.icon,
@@ -85,19 +84,34 @@ export const ethereumWallets$ = new Observable<EthereumWallet[]>(
               isConnected: enabledWalletIds.has(walletId),
               providerId: pd.info.rdns,
               connect: () => connectWallet(walletId, provider),
-              disconnect: () => disconnectWallet(walletId, provider),
+              disconnect: () => disconnectWallet(walletId),
             };
           });
-        })
+        }),
       )
       .subscribe(subscriber);
 
     return () => {
       sub.unsubscribe();
     };
-  }
+  },
 ).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
 
-ethereumWallets$.subscribe(() => {
-  console.count("[kheopskit] ethereumWallets$ emit");
-});
+export const getEthereumWallets$ = (config: KheopskitConfig) => {
+  return new Observable<EthereumWallet[]>((subscriber) => {
+    const subscription = combineLatest([
+      ethereumInjectedWallets$,
+      getAppKitWallets$(config)?.pipe(map((w) => w.ethereum)),
+    ])
+      .pipe(
+        map(([injectedWallets, appKitWallet]) =>
+          appKitWallet ? [...injectedWallets, appKitWallet] : injectedWallets,
+        ),
+      )
+      .subscribe(subscriber);
+
+    return () => {
+      subscription.unsubscribe();
+    };
+  }).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+};

package/src/api/index.ts

@@ -1,2 +1,3 @@
 export * from "./kheopskit";
 export * from "./types";
+export { resolveConfig } from "./config";

package/src/api/kheopskit.ts

@@ -1,4 +1,11 @@
-import { combineLatest, map, Observable, shareReplay } from "rxjs";
+import { logObservable } from "@/utils/logObservable";
+import {
+  Observable,
+  combineLatest,
+  map,
+  shareReplay,
+  throttleTime,
+} from "rxjs";
 import { getAccounts$ } from "./accounts";
 import { resolveConfig } from "./config";
 import type { KheopskitConfig, Wallet, WalletAccount } from "./types";
@@ -6,18 +13,33 @@ import { getWallets$ } from "./wallets";
 
 export type { KheopskitConfig } from "./types";
 
-export const getKheopskit$ = (config: KheopskitConfig) => {
-  const c = resolveConfig(config);
+export type KheopskitState = {
+  wallets: Wallet[];
+  accounts: WalletAccount[];
+  config: KheopskitConfig;
+};
+
+export const getKheopskit$ = (config?: Partial<KheopskitConfig>) => {
+  const kc = resolveConfig(config);
+
+  console.debug("[kheopskit] config", kc);
+
+  return new Observable<KheopskitState>((subscriber) => {
+    const wallets$ = getWallets$(kc);
 
-  return new Observable<{ wallets: Wallet[]; accounts: WalletAccount[] }>(
-    (subscriber) => {
-      const subscription = combineLatest([getWallets$(c), getAccounts$(c)])
-        .pipe(map(([wallets, accounts]) => ({ wallets, accounts })))
-        .subscribe(subscriber);
+    const subscription = combineLatest({
+      wallets: wallets$,
+      accounts: getAccounts$(kc, wallets$),
+    })
+      .pipe(map(({ wallets, accounts }) => ({ config: kc, wallets, accounts })))
+      .subscribe(subscriber);
 
-      return () => {
-        subscription.unsubscribe();
-      };
-    }
-  ).pipe(shareReplay({ bufferSize: 1, refCount: true }));
+    return () => {
+      subscription.unsubscribe();
+    };
+  }).pipe(
+    throttleTime(50, undefined, { leading: true, trailing: true }),
+    logObservable("kheopskit$", { enabled: kc.debug, printValue: true }),
+    shareReplay({ bufferSize: 1, refCount: true }),
+  );
 };

package/src/api/polkadot/accounts.ts

@@ -1,18 +1,29 @@
-import type { PolkadotAccount, PolkadotWallet } from "@/api/types";
+import type {
+  PolkadotAccount,
+  PolkadotAppKitWallet,
+  PolkadotInjectedWallet,
+  PolkadotWallet,
+} from "@/api/types";
 import { getWalletAccountId } from "@/utils";
-import type { InjectedPolkadotAccount } from "polkadot-api/pjs-signer";
+import type { AppKit } from "@reown/appkit/core";
+import type UniversalProvider from "@walletconnect/universal-provider";
 import {
+  type InjectedExtension,
+  type InjectedPolkadotAccount,
+  getPolkadotSignerFromPjs,
+} from "polkadot-api/pjs-signer";
+import {
+  Observable,
   combineLatest,
+  distinctUntilChanged,
   map,
-  Observable,
   of,
   shareReplay,
   switchMap,
 } from "rxjs";
-import { polkadotWallets$ } from "./wallets";
 
-const getWalletAccounts$ = (
-  wallet: PolkadotWallet
+const getInjectedWalletAccounts$ = (
+  wallet: PolkadotInjectedWallet,
 ): Observable<PolkadotAccount[]> => {
   if (!wallet.isConnected) return of([]);
 
@@ -25,13 +36,15 @@ const getWalletAccounts$ = (
       walletId: wallet.id,
     });
 
+    const extension = wallet.extension as InjectedExtension;
+
     // subscribe to changes
-    const unsubscribe = wallet.extension.subscribe((accounts) => {
+    const unsubscribe = extension.subscribe((accounts) => {
       subscriber.next(accounts.map(getAccount));
     });
 
     // initial value
-    subscriber.next(wallet.extension.getAccounts().map(getAccount));
+    subscriber.next(extension.getAccounts().map(getAccount));
 
     return () => {
       return unsubscribe();
@@ -39,26 +52,108 @@ const getWalletAccounts$ = (
   });
 };
 
-export const polkadotAccounts$ = new Observable<PolkadotAccount[]>(
-  (subscriber) => {
+const getAppKitPolkadotSigner = (appKit: AppKit, address: string) => {
+  const provider = appKit.getProvider<UniversalProvider>("polkadot");
+  if (!provider) throw new Error("No provider found");
+  if (!provider.session) throw new Error("No session found");
+
+  return getPolkadotSignerFromPjs(
+    address,
+    (transactionPayload) => {
+      if (!provider.session) throw new Error("No session found");
+
+      return provider.client.request({
+        topic: provider.session.topic,
+        chainId: `polkadot:${transactionPayload.genesisHash.substring(2, 34)}`,
+        request: {
+          method: "polkadot_signTransaction",
+          params: {
+            address,
+            transactionPayload,
+          },
+        },
+      });
+    },
+    async ({ address, data }) => {
+      if (!provider.session) throw new Error("No session found");
+      const networks = appKit.getCaipNetworks("polkadot");
+      const chainId = networks[0]?.caipNetworkId;
+      if (!chainId) throw new Error("No chainId found");
+
+      return provider.client.request({
+        topic: provider.session.topic,
+        chainId,
+        request: {
+          method: "polkadot_signMessage",
+          params: {
+            address,
+            message: data,
+          },
+        },
+      });
+    },
+  );
+};
+
+const getAppKitAccounts$ = (wallet: PolkadotAppKitWallet) => {
+  const account = wallet.appKit.getAccount("polkadot");
+  const provider = wallet.appKit.getProvider<UniversalProvider>("polkadot");
+
+  if (
+    !wallet.isConnected ||
+    !wallet.appKit ||
+    !account?.allAccounts.length ||
+    !provider?.session
+  )
+    return of([]);
+
+  return of(
+    account.allAccounts.map(
+      (acc): PolkadotAccount => ({
+        id: getWalletAccountId(wallet.id, acc.address),
+        platform: "polkadot",
+        walletName: wallet.name,
+        walletId: wallet.id,
+        address: acc.address,
+        polkadotSigner: getAppKitPolkadotSigner(wallet.appKit, acc.address),
+        genesisHash: null,
+        name: `${wallet.name} Polkadot`,
+        type: "sr25519",
+      }),
+    ),
+  );
+};
+
+export const getPolkadotAccounts$ = (
+  polkadotWallets$: Observable<PolkadotWallet[]>,
+) =>
+  new Observable<PolkadotAccount[]>((subscriber) => {
     const sub = polkadotWallets$
       .pipe(
         map((wallets) => wallets.filter((w) => w.isConnected)),
         switchMap((wallets) =>
           wallets.length
-            ? combineLatest(wallets.map(getWalletAccounts$))
-            : of([])
+            ? combineLatest([
+                ...wallets
+                  .filter((w) => w.type === "injected")
+                  .map(getInjectedWalletAccounts$),
+                ...wallets
+                  .filter((w) => w.type === "appKit")
+                  .map(getAppKitAccounts$),
+              ])
+            : of([]),
         ),
-        map((accounts) => accounts.flat())
+        map((accounts) => accounts.flat()),
+        distinctUntilChanged(isSameAccountsList),
       )
       .subscribe(subscriber);
 
     return () => {
       sub.unsubscribe();
     };
-  }
-).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+  }).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
 
-polkadotAccounts$.subscribe(() => {
-  console.count("[kheopskit] polkadotAccounts$ emit");
-});
+const isSameAccountsList = (a: PolkadotAccount[], b: PolkadotAccount[]) => {
+  if (a.length !== b.length) return false;
+  return a.every((account, i) => account.id === b[i]?.id);
+};