@kheopskit/core 0.0.1-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @kheopskit/core
+
+## 0.0.1-alpha.0
+
+### Patch Changes
+
+- [`3216d3b`](https://github.com/0xKheops/kheopskit-alpha/commit/3216d3b4ca1f2fadbebe9a4275e7b864ac89d222) Thanks [@0xKheops](https://github.com/0xKheops)! - initial alpha release

package/dist/index.d.mts

@@ -0,0 +1,94 @@
+import { Observable } from 'rxjs';
+import { EIP1193Provider } from 'viem';
+import { InjectedPolkadotAccount, InjectedExtension, InjectedAccount, PolkadotSigner } from 'polkadot-api/pjs-signer';
+
+type WalletId = string;
+
+type AccountId = string;
+
+type PolkadotAccount = InjectedPolkadotAccount & {
+    id: AccountId;
+    platform: "polkadot";
+    walletName: string;
+    walletId: string;
+};
+
+type EthereumAccount = {
+    id: AccountId;
+    platform: "ethereum";
+    provider: EIP1193Provider;
+    address: `0x${string}`;
+    walletName: string;
+    walletId: string;
+    isWalletDefault: boolean;
+};
+
+type AccountStorageBase = {
+    wallet: string;
+    address: string;
+};
+type EthereumAccountStorage = AccountStorageBase & {
+    platform: "ethereum";
+};
+type PolkadotAccountStorage = AccountStorageBase & {
+    platform: "polkadot";
+    name: InjectedAccount["name"];
+    type: InjectedAccount["type"];
+    genesisHash: InjectedAccount["genesisHash"];
+};
+type AccountStorage = PolkadotAccountStorage | EthereumAccountStorage;
+type Account<T extends AccountStorage> = T & {
+    id: string;
+    signer: T extends PolkadotAccountStorage ? PolkadotSigner : null;
+};
+type PlatformData<T extends AccountStorageBase> = {
+    enabledExtensionIds: string[];
+    accounts: T[];
+    defaultAccountId: string | null;
+};
+type KheopskitStoreData = {
+    autoReconnect?: WalletId[];
+};
+type KheopskitConfig = {
+    autoReconnect?: boolean;
+    platforms: WalletPlatform[];
+};
+type PolkadotDisabledInjectedWallet = {
+    id: WalletId;
+    platform: "polkadot";
+    extensionId: string;
+    name: string;
+    isEnabled: false;
+    connect: () => Promise<void>;
+};
+type PolkadotEnabledInjectedWallet = {
+    id: WalletId;
+    platform: "polkadot";
+    extensionId: string;
+    extension: InjectedExtension;
+    name: string;
+    isEnabled: true;
+    disconnect: () => void;
+};
+type PolkadotWallet = PolkadotDisabledInjectedWallet | PolkadotEnabledInjectedWallet;
+type EthereumWallet = {
+    platform: "ethereum";
+    id: WalletId;
+    providerId: string;
+    provider: EIP1193Provider;
+    name: string;
+    icon: string;
+    isEnabled: boolean;
+    connect: () => Promise<void>;
+    disconnect: () => void;
+};
+type Wallet = PolkadotWallet | EthereumWallet;
+type WalletPlatform = Wallet["platform"];
+type WalletAccount = PolkadotAccount | EthereumAccount;
+
+declare const getKheopskit$: (config: KheopskitConfig) => Observable<{
+    wallets: Wallet[];
+    accounts: WalletAccount[];
+}>;
+
+export { type Account, type AccountStorage, type EthereumAccountStorage, type EthereumWallet, type KheopskitConfig, type KheopskitStoreData, type PlatformData, type PolkadotAccountStorage, type PolkadotDisabledInjectedWallet, type PolkadotEnabledInjectedWallet, type PolkadotWallet, type Wallet, type WalletAccount, type WalletPlatform, getKheopskit$ };

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import { Observable } from 'rxjs';
+import { EIP1193Provider } from 'viem';
+import { InjectedPolkadotAccount, InjectedExtension, InjectedAccount, PolkadotSigner } from 'polkadot-api/pjs-signer';
+
+type WalletId = string;
+
+type AccountId = string;
+
+type PolkadotAccount = InjectedPolkadotAccount & {
+    id: AccountId;
+    platform: "polkadot";
+    walletName: string;
+    walletId: string;
+};
+
+type EthereumAccount = {
+    id: AccountId;
+    platform: "ethereum";
+    provider: EIP1193Provider;
+    address: `0x${string}`;
+    walletName: string;
+    walletId: string;
+    isWalletDefault: boolean;
+};
+
+type AccountStorageBase = {
+    wallet: string;
+    address: string;
+};
+type EthereumAccountStorage = AccountStorageBase & {
+    platform: "ethereum";
+};
+type PolkadotAccountStorage = AccountStorageBase & {
+    platform: "polkadot";
+    name: InjectedAccount["name"];
+    type: InjectedAccount["type"];
+    genesisHash: InjectedAccount["genesisHash"];
+};
+type AccountStorage = PolkadotAccountStorage | EthereumAccountStorage;
+type Account<T extends AccountStorage> = T & {
+    id: string;
+    signer: T extends PolkadotAccountStorage ? PolkadotSigner : null;
+};
+type PlatformData<T extends AccountStorageBase> = {
+    enabledExtensionIds: string[];
+    accounts: T[];
+    defaultAccountId: string | null;
+};
+type KheopskitStoreData = {
+    autoReconnect?: WalletId[];
+};
+type KheopskitConfig = {
+    autoReconnect?: boolean;
+    platforms: WalletPlatform[];
+};
+type PolkadotDisabledInjectedWallet = {
+    id: WalletId;
+    platform: "polkadot";
+    extensionId: string;
+    name: string;
+    isEnabled: false;
+    connect: () => Promise<void>;
+};
+type PolkadotEnabledInjectedWallet = {
+    id: WalletId;
+    platform: "polkadot";
+    extensionId: string;
+    extension: InjectedExtension;
+    name: string;
+    isEnabled: true;
+    disconnect: () => void;
+};
+type PolkadotWallet = PolkadotDisabledInjectedWallet | PolkadotEnabledInjectedWallet;
+type EthereumWallet = {
+    platform: "ethereum";
+    id: WalletId;
+    providerId: string;
+    provider: EIP1193Provider;
+    name: string;
+    icon: string;
+    isEnabled: boolean;
+    connect: () => Promise<void>;
+    disconnect: () => void;
+};
+type Wallet = PolkadotWallet | EthereumWallet;
+type WalletPlatform = Wallet["platform"];
+type WalletAccount = PolkadotAccount | EthereumAccount;
+
+declare const getKheopskit$: (config: KheopskitConfig) => Observable<{
+    wallets: Wallet[];
+    accounts: WalletAccount[];
+}>;
+
+export { type Account, type AccountStorage, type EthereumAccountStorage, type EthereumWallet, type KheopskitConfig, type KheopskitStoreData, type PlatformData, type PolkadotAccountStorage, type PolkadotDisabledInjectedWallet, type PolkadotEnabledInjectedWallet, type PolkadotWallet, type Wallet, type WalletAccount, type WalletPlatform, getKheopskit$ };

package/dist/index.js

@@ -0,0 +1,458 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  getKheopskit$: () => getKheopskit$
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api/kheopskit.ts
+var import_rxjs8 = require("rxjs");
+
+// src/api/accounts.ts
+var import_rxjs6 = require("rxjs");
+
+// src/utils/createStore.ts
+var import_rxjs = require("rxjs");
+var createStore = (key, defaultValue) => {
+  const subject = new import_rxjs.BehaviorSubject(getStoredData(key, defaultValue));
+  (0, import_rxjs.fromEvent)(window, "storage").pipe(
+    (0, import_rxjs.filter)((event) => event.key === key),
+    (0, import_rxjs.map)((event) => parseData(event.newValue, defaultValue))
+  ).subscribe((newValue) => subject.next(newValue));
+  const update = (val) => {
+    setStoredData(key, val);
+    subject.next(val);
+  };
+  return {
+    observable: subject.asObservable(),
+    set: (val) => update(val),
+    mutate: (transform) => update(transform(subject.getValue())),
+    get: () => structuredClone(subject.getValue())
+  };
+};
+var parseData = (str, defaultValue) => {
+  try {
+    if (str) return JSON.parse(str);
+  } catch {
+  }
+  return defaultValue;
+};
+var getStoredData = (key, defaultValue) => {
+  const str = localStorage.getItem(key);
+  return parseData(str, defaultValue);
+};
+var setStoredData = (key, val) => {
+  const str = JSON.stringify(val);
+  localStorage.setItem(key, str);
+};
+
+// src/utils/isEthereumAddress.ts
+var isEthereumAddress = (address) => /^0x[a-fA-F0-9]{40}$/.test(address);
+
+// src/utils/isSs58Address.ts
+var import_polkadot_api = require("polkadot-api");
+var accountIdEncoder = (0, import_polkadot_api.AccountId)().enc;
+var isSs58Address = (address) => {
+  try {
+    if (!address) return false;
+    accountIdEncoder(address);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+};
+
+// src/utils/isValidAddress.ts
+var isValidAddress = (address) => {
+  return address.startsWith("0x") ? isEthereumAddress(address) : isSs58Address(address);
+};
+
+// src/utils/AccountId.ts
+var getAccountId = (walletId, address) => {
+  if (!walletId) throw new Error("Missing walletId");
+  if (!isValidAddress(address)) throw new Error("Invalid address");
+  return `${walletId}::${address}`;
+};
+
+// src/utils/isWalletPlatform.ts
+var isWalletPlatform = (platform) => typeof platform === "string" && ["polkadot", "ethereum"].includes(platform);
+
+// src/api/ethereum/accounts.ts
+var import_rxjs3 = require("rxjs");
+var import_viem = require("viem");
+
+// src/api/store.ts
+var import_lodash = require("lodash");
+
+// src/utils/WalletId.ts
+var getWalletId = (platform, identifier) => {
+  if (!isWalletPlatform(platform)) throw new Error("Invalid platform");
+  if (!identifier) throw new Error("Invalid name");
+  return `${platform}:${identifier}`;
+};
+var parseWalletId = (walletId) => {
+  if (!walletId) throw new Error("Invalid walletId");
+  const [platform, identifier] = walletId.split(":");
+  if (!isWalletPlatform(platform)) throw new Error("Invalid platform");
+  if (!identifier) throw new Error("Invalid address");
+  return { platform, identifier };
+};
+
+// src/api/store.ts
+var LOCAL_STORAGE_KEY = "kheopskit";
+var DEFAULT_SETTINGS = {};
+var storage = createStore(LOCAL_STORAGE_KEY, DEFAULT_SETTINGS);
+var addEnabledWalletId = (walletId) => {
+  parseWalletId(walletId);
+  storage.mutate((prev) => ({
+    ...prev,
+    autoReconnect: (0, import_lodash.uniq)((prev.autoReconnect ?? []).concat(walletId))
+  }));
+};
+var removeEnabledWalletId = (walletId) => {
+  storage.mutate((prev) => ({
+    ...prev,
+    autoReconnect: (0, import_lodash.uniq)(
+      (prev.autoReconnect ?? []).filter((id) => id !== walletId)
+    )
+  }));
+};
+var store = {
+  observable: storage.observable,
+  addEnabledWalletId,
+  removeEnabledWalletId
+};
+
+// src/api/ethereum/wallets.ts
+var import_mipd = require("mipd");
+var import_rxjs2 = require("rxjs");
+var providersDetails$ = new import_rxjs2.Observable(
+  (subscriber) => {
+    const store2 = (0, import_mipd.createStore)();
+    const unsubscribe = store2.subscribe((providerDetails2) => {
+      subscriber.next(providerDetails2);
+    });
+    const providerDetails = store2.getProviders();
+    subscriber.next(providerDetails);
+    return () => {
+      unsubscribe();
+      store2.destroy();
+    };
+  }
+).pipe((0, import_rxjs2.shareReplay)({ refCount: true, bufferSize: 1 }));
+providersDetails$.subscribe(() => {
+  console.count("[kheopskit] providers$ emit");
+});
+var ethereumWallets$ = new import_rxjs2.Observable(
+  (subscriber) => {
+    const enabledWalletIds$ = new import_rxjs2.BehaviorSubject(/* @__PURE__ */ new Set());
+    const connectWallet = async (walletId, provider) => {
+      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, _provider) => {
+      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 = (0, import_rxjs2.combineLatest)([providersDetails$, enabledWalletIds$]).pipe(
+      (0, import_rxjs2.map)(([providerDetails, enabledWalletIds]) => {
+        return providerDetails.map((pd) => {
+          const walletId = getWalletId("ethereum", pd.info.rdns);
+          const provider = pd.provider;
+          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((0, import_rxjs2.shareReplay)({ refCount: true, bufferSize: 1 }));
+ethereumWallets$.subscribe(() => {
+  console.count("[kheopskit] ethereumWallets$ emit");
+});
+
+// src/api/ethereum/accounts.ts
+var getWalletAccounts$ = (wallet) => {
+  if (!wallet.isEnabled) return (0, import_rxjs3.of)([]);
+  return new import_rxjs3.Observable((subscriber) => {
+    const getAccount = (address, i) => ({
+      id: getAccountId(wallet.id, address),
+      platform: "ethereum",
+      provider: wallet.provider,
+      address: (0, import_viem.getAddress)(address),
+      walletName: wallet.name,
+      walletId: wallet.id,
+      isWalletDefault: i === 0
+    });
+    const listener = (addresses) => {
+      subscriber.next(addresses.map(getAccount));
+    };
+    wallet.provider.on("accountsChanged", listener);
+    wallet.provider.request({ method: "eth_accounts" }).then((addresses) => {
+      subscriber.next(addresses.map(getAccount));
+    }).catch((err) => {
+      console.error("Failed to get accounts", err);
+      subscriber.next([]);
+    });
+    return () => {
+      wallet.provider.removeListener("accountsChanged", listener);
+    };
+  });
+};
+var ethereumAccounts$ = new import_rxjs3.Observable(
+  (subscriber) => {
+    const sub = ethereumWallets$.pipe(
+      (0, import_rxjs3.map)((wallets) => wallets.filter((w) => w.isEnabled)),
+      (0, import_rxjs3.switchMap)(
+        (wallets) => wallets.length ? (0, import_rxjs3.combineLatest)(wallets.map(getWalletAccounts$)) : (0, import_rxjs3.of)([])
+      ),
+      (0, import_rxjs3.map)((accounts) => accounts.flat())
+    ).subscribe(subscriber);
+    return () => {
+      sub.unsubscribe();
+    };
+  }
+).pipe((0, import_rxjs3.shareReplay)({ refCount: true, bufferSize: 1 }));
+ethereumAccounts$.subscribe(() => {
+  console.count("[kheopskit] ethereumAccounts$ emit");
+});
+
+// src/api/polkadot/accounts.ts
+var import_rxjs5 = require("rxjs");
+
+// src/api/polkadot/wallets.ts
+var import_lodash2 = require("lodash");
+var import_pjs_signer = require("polkadot-api/pjs-signer");
+var import_rxjs4 = require("rxjs");
+var getInjectedWalletsIds = () => (0, import_pjs_signer.getInjectedExtensions)().map((name) => getWalletId("polkadot", name));
+var polkadotInjectedWallets$ = new import_rxjs4.Observable(
+  (subscriber) => {
+    const enabledExtensions$ = new import_rxjs4.BehaviorSubject(/* @__PURE__ */ new Map());
+    const connect = async (walletId) => {
+      if (enabledExtensions$.value.has(walletId))
+        throw new Error(`Extension ${walletId} already connected`);
+      const { identifier } = parseWalletId(walletId);
+      const extension = await (0, import_pjs_signer.connectInjectedExtension)(identifier);
+      const newMap = new Map(enabledExtensions$.value);
+      newMap.set(walletId, extension);
+      enabledExtensions$.next(newMap);
+      store.addEnabledWalletId(walletId);
+    };
+    const disconnect = (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$ = (0, import_rxjs4.of)(0, 200, 500, 1e3).pipe(
+      (0, import_rxjs4.mergeMap)((time) => (0, import_rxjs4.timer)(time)),
+      (0, import_rxjs4.map)(() => getInjectedWalletsIds()),
+      (0, import_rxjs4.distinctUntilChanged)(import_lodash2.isEqual)
+    );
+    const subscription = (0, import_rxjs4.combineLatest)([walletIds$, enabledExtensions$]).pipe(
+      (0, import_rxjs4.map)(([walletIds, enabledExtensions]) => {
+        return walletIds.map((id) => {
+          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((0, import_rxjs4.shareReplay)({ refCount: true, bufferSize: 1 }));
+var polkadotWallets$ = polkadotInjectedWallets$;
+polkadotWallets$.subscribe(() => {
+  console.count("[kheopskit] polkadotWallets$ emit");
+});
+
+// src/api/polkadot/accounts.ts
+var getWalletAccounts$2 = (wallet) => {
+  if (!wallet.isEnabled) return (0, import_rxjs5.of)([]);
+  return new import_rxjs5.Observable((subscriber) => {
+    const getAccount = (account) => ({
+      id: getAccountId(wallet.id, account.address),
+      ...account,
+      platform: "polkadot",
+      walletName: wallet.name,
+      walletId: wallet.id
+    });
+    const unsubscribe = wallet.extension.subscribe((accounts) => {
+      subscriber.next(accounts.map(getAccount));
+    });
+    subscriber.next(wallet.extension.getAccounts().map(getAccount));
+    return () => {
+      return unsubscribe();
+    };
+  });
+};
+var polkadotAccounts$ = new import_rxjs5.Observable(
+  (subscriber) => {
+    const sub = polkadotWallets$.pipe(
+      (0, import_rxjs5.map)((wallets) => wallets.filter((w) => w.isEnabled)),
+      (0, import_rxjs5.switchMap)(
+        (wallets) => wallets.length ? (0, import_rxjs5.combineLatest)(wallets.map(getWalletAccounts$2)) : (0, import_rxjs5.of)([])
+      ),
+      (0, import_rxjs5.map)((accounts) => accounts.flat())
+    ).subscribe(subscriber);
+    return () => {
+      sub.unsubscribe();
+    };
+  }
+).pipe((0, import_rxjs5.shareReplay)({ refCount: true, bufferSize: 1 }));
+polkadotAccounts$.subscribe(() => {
+  console.count("[kheopskit] polkadotAccounts$ emit");
+});
+
+// src/api/accounts.ts
+var getAccounts$ = (config) => {
+  return new import_rxjs6.Observable((subscriber) => {
+    const observables = config.platforms.map(
+      (platform) => {
+        switch (platform) {
+          case "polkadot":
+            return polkadotAccounts$;
+          case "ethereum":
+            return ethereumAccounts$;
+        }
+      }
+    );
+    const accounts$ = observables.length ? (0, import_rxjs6.combineLatest)(observables).pipe((0, import_rxjs6.map)((accounts) => accounts.flat())) : (0, import_rxjs6.of)([]);
+    const sub = accounts$.subscribe(subscriber);
+    return () => {
+      sub.unsubscribe();
+    };
+  }).pipe((0, import_rxjs6.shareReplay)({ refCount: true, bufferSize: 1 }));
+};
+
+// src/api/config.ts
+var DEFAULT_CONFIG = {
+  autoReconnect: true,
+  platforms: ["polkadot"]
+};
+var resolveConfig = (config) => {
+  return Object.assign({}, DEFAULT_CONFIG, config);
+};
+
+// src/api/wallets.ts
+var import_rxjs7 = require("rxjs");
+var autoReconnectWalletIds$ = store.observable.pipe(
+  (0, import_rxjs7.map)((s) => s.autoReconnect ?? []),
+  (0, import_rxjs7.take)(1),
+  (0, import_rxjs7.shareReplay)(1)
+);
+var getWallets$ = (config) => {
+  return new import_rxjs7.Observable((subscriber) => {
+    const observables = config.platforms.map(
+      (platform) => {
+        switch (platform) {
+          case "polkadot":
+            return polkadotWallets$;
+          case "ethereum":
+            return ethereumWallets$;
+        }
+      }
+    );
+    const wallets$ = observables.length ? (0, import_rxjs7.combineLatest)(observables).pipe((0, import_rxjs7.map)((wallets) => wallets.flat())) : (0, import_rxjs7.of)([]);
+    const subAutoReconnect = (0, import_rxjs7.combineLatest)([wallets$, autoReconnectWalletIds$]).pipe(
+      (0, import_rxjs7.filter)(([, walletIds]) => config.autoReconnect && !!walletIds?.length),
+      (0, import_rxjs7.mergeMap)(
+        ([wallets, walletIds]) => wallets.filter((wallet) => walletIds?.includes(wallet.id))
+      ),
+      (0, import_rxjs7.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((0, import_rxjs7.shareReplay)({ refCount: true, bufferSize: 1 }));
+};
+
+// src/api/kheopskit.ts
+var getKheopskit$ = (config) => {
+  const c = resolveConfig(config);
+  return new import_rxjs8.Observable(
+    (subscriber) => {
+      const subscription = (0, import_rxjs8.combineLatest)([getWallets$(c), getAccounts$(c)]).pipe((0, import_rxjs8.map)(([wallets, accounts]) => ({ wallets, accounts }))).subscribe(subscriber);
+      return () => {
+        subscription.unsubscribe();
+      };
+    }
+  ).pipe((0, import_rxjs8.shareReplay)({ bufferSize: 1, refCount: true }));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getKheopskit$
+});
+//# sourceMappingURL=index.js.map