@kheopskit/core 5.0.1 → 5.1.0

package/dist/index.mjs

@@ -1,26 +1,20 @@
 import {
-  acceptsCachedAccount,
+  cookieStorage,
   getCachedIcon,
   hydrateAccount,
   hydrateWallet,
+  safeLocalStorage,
   serializeAccount,
   serializeWallet,
-  setCachedIcons,
-  sortAccounts,
-  sortWallets
-} from "./chunk-YDLCHYHH.mjs";
+  setCachedIcons
+} from "./chunk-3Y5N4N3Q.mjs";
 import "./chunk-BWUUHUDK.mjs";
 import {
-  DEFAULT_STORAGE_KEY,
   KheopskitError,
-  createKheopskitStore,
-  getDefaultStore,
   getWalletAccountId,
   isValidAddress,
-  parseWalletAccountId,
-  resolveConfig,
-  store
-} from "./chunk-6XAZANB5.mjs";
+  parseWalletAccountId
+} from "./chunk-DF7EKK4G.mjs";
 import {
   WALLET_CONNECT_WALLET_ID,
   clearAllCachedObservables,
@@ -29,8 +23,9 @@ import {
   isInjectedWallet,
   isValidWalletId,
   isWalletConnectWallet,
+  isWalletPlatform,
   parseWalletId
-} from "./chunk-7QSGAJ4A.mjs";
+} from "./chunk-WOPCW2OX.mjs";
 
 // src/api/appKit.ts
 import {
@@ -204,6 +199,87 @@ var getWalletConnectWallet$ = (config) => {
   return cachedAppKit;
 };
 
+// src/api/config.ts
+var DEFAULT_STORAGE_KEY = "kheopskit";
+var DEFAULTS = {
+  autoReconnect: true,
+  debug: false,
+  storageKey: DEFAULT_STORAGE_KEY,
+  hydrationGracePeriod: 500
+};
+var resolveConfig = (config) => {
+  const platforms = config?.platforms ?? [];
+  const invalidPlatforms = platforms.filter(
+    (p) => typeof p !== "object" || p === null || typeof p.getWallets$ !== "function"
+  );
+  if (invalidPlatforms.length > 0) {
+    throw new Error(
+      `[kheopskit] config.platforms must contain plugin instances created by the per-platform factories (e.g. platforms: [polkadot(), ethereum(), solana()] imported from "@kheopskit/core/<platform>"). Invalid entries: ${JSON.stringify(invalidPlatforms)}. String platform names like "polkadot" were removed in v4 \u2014 see MIGRATING_TO_V4.md.`
+    );
+  }
+  if (platforms.length === 0) {
+    console.warn(
+      '[kheopskit] No platforms configured; wallets and accounts will be empty. Pass e.g. platforms: [polkadot()] from "@kheopskit/core/polkadot".'
+    );
+  }
+  return Object.assign({}, DEFAULTS, config, { platforms });
+};
+
+// src/utils/sortAccounts.ts
+var PLATFORM_ORDER = {
+  polkadot: 0,
+  ethereum: 1,
+  solana: 2
+};
+var byWalletName = (a1, a2) => {
+  if (a1.walletName.toLowerCase() === "talisman") return -1;
+  if (a2.walletName.toLowerCase() === "talisman") return 1;
+  return a1.walletName.localeCompare(a2.walletName);
+};
+var sortAccounts = (a1, a2) => {
+  if (a1.platform !== a2.platform)
+    return PLATFORM_ORDER[a1.platform] - PLATFORM_ORDER[a2.platform];
+  if (a1.walletName !== a2.walletName) return byWalletName(a1, a2);
+  if (a1.platform === "polkadot" && a2.platform === "polkadot")
+    return a1.name !== a2.name ? (a1.name ?? "").localeCompare(a2.name ?? "") : a1.address.localeCompare(a2.address);
+  return a1.id.localeCompare(a2.id);
+};
+
+// src/utils/sortWallets.ts
+var PLATFORM_ORDER2 = {
+  polkadot: 0,
+  ethereum: 1,
+  solana: 2
+};
+var orderOf = (wallet) => isWalletConnectWallet(wallet) ? 3 : PLATFORM_ORDER2[wallet.platform];
+var sortWallets = (w1, w2) => {
+  const o1 = orderOf(w1);
+  const o2 = orderOf(w2);
+  if (o1 !== o2) return o1 - o2;
+  if (w1.name.toLowerCase() === "talisman") return -1;
+  if (w2.name.toLowerCase() === "talisman") return 1;
+  return w1.name.localeCompare(w2.name);
+};
+
+// src/api/platform.ts
+var acceptsCachedAccount = (cached, platforms) => {
+  const plugin = platforms.find((p) => p.platform === cached.platform);
+  return plugin?.acceptsCachedAccount?.(cached) ?? true;
+};
+
+// src/api/hydration.ts
+var getHydratedSnapshot = (store, platforms, options = {}) => {
+  const cached = store.getCachedState();
+  const wallets = cached.wallets.map((cachedWallet) => {
+    const wallet = hydrateWallet(cachedWallet);
+    if (!options.icons || wallet.icon) return wallet;
+    const icon = getCachedIcon(wallet.id);
+    return icon ? { ...wallet, icon } : wallet;
+  }).sort(sortWallets);
+  const accounts = cached.accounts.filter((account) => acceptsCachedAccount(account, platforms)).map(hydrateAccount).sort(sortAccounts);
+  return { wallets, accounts };
+};
+
 // src/api/kheopskit.ts
 import {
   combineLatest as combineLatest4,
@@ -364,6 +440,307 @@ var getAccounts$ = (config, wallets) => {
   }).pipe(shareReplay3({ refCount: true, bufferSize: 1 }));
 };
 
+// src/api/store.ts
+import { uniq } from "lodash-es";
+
+// src/utils/createStore.ts
+import { BehaviorSubject as BehaviorSubject3 } from "rxjs";
+var createStore = (key, defaultValue, storage = safeLocalStorage) => {
+  const subject = new BehaviorSubject3(
+    getStoredData(key, defaultValue, storage)
+  );
+  let unsubscribeStorage;
+  if (typeof window !== "undefined" && storage.subscribe) {
+    unsubscribeStorage = storage.subscribe(key, (newValue) => {
+      subject.next(parseData(newValue, defaultValue));
+    });
+  }
+  const update = (val) => {
+    setStoredData(key, val, storage);
+    subject.next(val);
+  };
+  return {
+    observable: subject.asObservable(),
+    set: (val) => update(val),
+    mutate: (transform) => update(transform(subject.getValue())),
+    get: () => structuredClone(subject.getValue()),
+    /**
+     * Cleanup subscriptions. Call this when the store is no longer needed.
+     */
+    destroy: () => {
+      unsubscribeStorage?.();
+      subject.complete();
+    }
+  };
+};
+var parseData = (str, defaultValue) => {
+  try {
+    if (str) return JSON.parse(str);
+  } catch {
+  }
+  return defaultValue;
+};
+var getStoredData = (key, defaultValue, storage) => {
+  const str = storage.getItem(key);
+  return parseData(str, defaultValue);
+};
+var setStoredData = (key, val, storage) => {
+  const str = JSON.stringify(val);
+  storage.setItem(key, str);
+};
+
+// src/api/compactStore.ts
+var EMPTY_STORE_DATA = {};
+var toCompactPolkadotAccountType = (type) => {
+  switch (type) {
+    case "sr25519":
+      return 0;
+    case "ed25519":
+      return 1;
+    case "ecdsa":
+      return 2;
+    case "ethereum":
+      return 3;
+    default:
+      return null;
+  }
+};
+var fromCompactPolkadotAccountType = (type) => {
+  switch (type) {
+    case 0:
+      return "sr25519";
+    case 1:
+      return "ed25519";
+    case 2:
+      return "ecdsa";
+    case 3:
+      return "ethereum";
+    default:
+      return void 0;
+  }
+};
+var toCompactPlatform = (platform) => {
+  switch (platform) {
+    case "polkadot":
+      return 0;
+    case "ethereum":
+      return 1;
+    case "solana":
+      return 2;
+  }
+};
+var fromCompactPlatform = (code) => {
+  switch (code) {
+    case 0:
+      return "polkadot";
+    case 1:
+      return "ethereum";
+    case 2:
+      return "solana";
+    default:
+      return void 0;
+  }
+};
+var isCompactStore = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  if ("cachedWallets" in value || "cachedAccounts" in value) return false;
+  return "v" in value || "w" in value || "a" in value || "r" in value;
+};
+var toCompactStore = (data) => {
+  const wallets = data.cachedWallets?.map(
+    (wallet) => [
+      wallet.id,
+      wallet.name,
+      wallet.isConnected ? 1 : 0,
+      wallet.type === "walletconnect" ? 1 : 0
+    ]
+  );
+  const accounts = data.cachedAccounts?.map(
+    (account) => [
+      account.walletId,
+      account.address,
+      account.name ?? null,
+      account.chainId ?? null,
+      toCompactPolkadotAccountType(account.polkadotAccountType),
+      toCompactPlatform(account.platform)
+    ]
+  );
+  return {
+    v: 1,
+    r: data.autoReconnect,
+    w: wallets?.length ? wallets : void 0,
+    a: accounts?.length ? accounts : void 0
+  };
+};
+var fromCompactStore = (data) => {
+  const walletNameMap = /* @__PURE__ */ new Map();
+  const wallets = [];
+  for (const item of Array.isArray(data.w) ? data.w : []) {
+    if (!Array.isArray(item)) continue;
+    const [id, name, isConnected, type] = item;
+    if (!isValidWalletId(id)) continue;
+    const isWalletConnect = id === WALLET_CONNECT_WALLET_ID;
+    const walletType = type === 1 ? "walletconnect" : "injected";
+    if (isWalletConnect !== (walletType === "walletconnect")) continue;
+    walletNameMap.set(id, name);
+    wallets.push({
+      id,
+      platform: isWalletConnect ? void 0 : parseWalletId(id).platform,
+      type: walletType,
+      name,
+      isConnected: isConnected === 1
+    });
+  }
+  const accounts = [];
+  for (const item of Array.isArray(data.a) ? data.a : []) {
+    if (!Array.isArray(item)) continue;
+    const [
+      walletId,
+      address,
+      name,
+      chainId,
+      polkadotAccountType,
+      platformCode
+    ] = item;
+    if (!isValidWalletId(walletId) || typeof address !== "string" || !address)
+      continue;
+    const platform = platformCode != null ? fromCompactPlatform(platformCode) : walletId === WALLET_CONNECT_WALLET_ID ? void 0 : parseWalletId(walletId).platform;
+    if (!isWalletPlatform(platform)) continue;
+    accounts.push({
+      id: getWalletAccountId(walletId, address),
+      platform,
+      address,
+      name: name ?? void 0,
+      chainId: chainId ?? void 0,
+      polkadotAccountType: platform === "polkadot" ? fromCompactPolkadotAccountType(polkadotAccountType) : void 0,
+      walletId,
+      walletName: walletNameMap.get(walletId) ?? walletId
+    });
+  }
+  return {
+    autoReconnect: data.r,
+    cachedWallets: wallets,
+    cachedAccounts: accounts
+  };
+};
+var decodeStore = (raw, fallback) => {
+  try {
+    const parsed = JSON.parse(raw);
+    if (isCompactStore(parsed)) return fromCompactStore(parsed);
+    return parsed;
+  } catch {
+    return fallback;
+  }
+};
+var encodeStore = (data) => JSON.stringify(toCompactStore(data));
+var createCompactCookieStorage = (initialCookies) => {
+  const base = cookieStorage(initialCookies);
+  return {
+    getItem: (key) => {
+      const raw = base.getItem(key);
+      if (!raw) return null;
+      const expanded = decodeStore(raw, EMPTY_STORE_DATA);
+      if (typeof document !== "undefined") {
+        try {
+          const parsed = JSON.parse(raw);
+          if (!isCompactStore(parsed)) {
+            base.setItem(key, encodeStore(expanded));
+          }
+        } catch {
+        }
+      }
+      return JSON.stringify(expanded);
+    },
+    setItem: (key, value) => {
+      const expanded = decodeStore(value, EMPTY_STORE_DATA);
+      base.setItem(key, encodeStore(expanded));
+    },
+    removeItem: base.removeItem,
+    subscribe: (key, callback) => {
+      const unsubscribe = base.subscribe?.(key, (value) => {
+        if (!value) {
+          callback(null);
+          return;
+        }
+        const expanded = decodeStore(value, EMPTY_STORE_DATA);
+        callback(JSON.stringify(expanded));
+      });
+      return () => {
+        unsubscribe?.();
+      };
+    }
+  };
+};
+
+// src/api/store.ts
+var DEFAULT_SETTINGS = {};
+var isValidCachedWallet = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const w = value;
+  if (!isValidWalletId(w.id)) return false;
+  if (typeof w.name !== "string" || typeof w.isConnected !== "boolean")
+    return false;
+  if (w.type === "walletconnect")
+    return w.id === WALLET_CONNECT_WALLET_ID && w.platform === void 0;
+  return w.type === "injected" && isWalletPlatform(w.platform);
+};
+var isValidCachedAccount = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const a = value;
+  return typeof a.id === "string" && !!a.id && isWalletPlatform(a.platform) && typeof a.address === "string" && !!a.address && isValidWalletId(a.walletId) && typeof a.walletName === "string";
+};
+var createKheopskitStore = (options = {}) => {
+  const { ssrCookies, storageKey = DEFAULT_STORAGE_KEY } = options;
+  const storage = ssrCookies !== void 0 ? createCompactCookieStorage(ssrCookies) : safeLocalStorage;
+  const store = createStore(storageKey, DEFAULT_SETTINGS, storage);
+  const addEnabledWalletId = (walletId) => {
+    parseWalletId(walletId);
+    store.mutate((prev) => ({
+      ...prev,
+      autoReconnect: uniq((prev.autoReconnect ?? []).concat(walletId))
+    }));
+  };
+  const removeEnabledWalletId = (walletId) => {
+    store.mutate((prev) => ({
+      ...prev,
+      autoReconnect: uniq(
+        (prev.autoReconnect ?? []).filter((id) => id !== walletId)
+      )
+    }));
+  };
+  const getCachedState = () => {
+    const data = store.get();
+    const cachedWallets = Array.isArray(data?.cachedWallets) ? data.cachedWallets : [];
+    const cachedAccounts = Array.isArray(data?.cachedAccounts) ? data.cachedAccounts : [];
+    return {
+      wallets: cachedWallets.filter(isValidCachedWallet),
+      accounts: cachedAccounts.filter(isValidCachedAccount)
+    };
+  };
+  const setCachedState = (wallets, accounts) => {
+    store.mutate((prev) => ({
+      ...prev,
+      cachedWallets: wallets,
+      cachedAccounts: accounts
+    }));
+  };
+  return {
+    observable: store.observable,
+    addEnabledWalletId,
+    removeEnabledWalletId,
+    getCachedState,
+    setCachedState
+  };
+};
+var DEFAULT_STORE_SYMBOL = /* @__PURE__ */ Symbol.for("kheopskit.defaultStore");
+var getDefaultStore = () => {
+  const g = globalThis;
+  if (!g[DEFAULT_STORE_SYMBOL]) {
+    g[DEFAULT_STORE_SYMBOL] = createKheopskitStore();
+  }
+  return g[DEFAULT_STORE_SYMBOL];
+};
+
 // src/api/wallets.ts
 import {
   combineLatest as combineLatest3,
@@ -375,14 +752,42 @@ import {
   shareReplay as shareReplay4,
   take as take2
 } from "rxjs";
-var getWallets$ = (config, store2 = store) => {
-  const autoReconnectWalletIds$ = store2.observable.pipe(
+
+// src/api/reconnectPolicy.ts
+var createReconnectPolicy = ({
+  maxAttempts = 3
+} = {}) => {
+  const reconnecting = /* @__PURE__ */ new Set();
+  const reconnected = /* @__PURE__ */ new Set();
+  const failedAttempts = /* @__PURE__ */ new Map();
+  const shouldAttempt = (walletId) => !reconnecting.has(walletId) && !reconnected.has(walletId) && (failedAttempts.get(walletId) ?? 0) < maxAttempts;
+  const attempt = async (walletId, connect) => {
+    if (!shouldAttempt(walletId)) return false;
+    reconnecting.add(walletId);
+    try {
+      await connect();
+      reconnected.add(walletId);
+      failedAttempts.delete(walletId);
+      return true;
+    } catch (err) {
+      failedAttempts.set(walletId, (failedAttempts.get(walletId) ?? 0) + 1);
+      throw err;
+    } finally {
+      reconnecting.delete(walletId);
+    }
+  };
+  return { shouldAttempt, attempt };
+};
+
+// src/api/wallets.ts
+var getWallets$ = (config, store) => {
+  const autoReconnectWalletIds$ = store.observable.pipe(
     map4((s) => s.autoReconnect ?? []),
     take2(1),
     shareReplay4({ bufferSize: 1, refCount: true })
   );
   return new Observable4((subscriber) => {
-    const ctx = { config, store: store2 };
+    const ctx = { config, store };
     const observables = config.platforms.map(
       (plugin) => plugin.getWallets$(ctx)
     );
@@ -397,32 +802,18 @@ var getWallets$ = (config, store2 = store) => {
       })
       // Note: No startWith([]) here - the hydration buffer handles initial state
     );
-    const reconnectingWallets = /* @__PURE__ */ new Set();
-    const reconnectedWallets = /* @__PURE__ */ new Set();
-    const MAX_RECONNECT_ATTEMPTS = 3;
-    const failedAttempts = /* @__PURE__ */ new Map();
+    const reconnectPolicy = createReconnectPolicy();
     const subAutoReconnect = combineLatest3([wallets$, autoReconnectWalletIds$]).pipe(
       filter2(([, walletIds]) => config.autoReconnect && !!walletIds?.length),
       mergeMap(
         ([wallets, walletIds]) => wallets.filter((wallet) => walletIds?.includes(wallet.id))
       )
     ).subscribe(async (wallet) => {
-      if (wallet.isConnected || reconnectingWallets.has(wallet.id) || reconnectedWallets.has(wallet.id) || (failedAttempts.get(wallet.id) ?? 0) >= MAX_RECONNECT_ATTEMPTS) {
-        return;
-      }
-      reconnectingWallets.add(wallet.id);
+      if (wallet.isConnected) return;
       try {
-        await wallet.connect();
-        reconnectedWallets.add(wallet.id);
-        failedAttempts.delete(wallet.id);
+        await reconnectPolicy.attempt(wallet.id, () => wallet.connect());
       } catch (err) {
-        failedAttempts.set(
-          wallet.id,
-          (failedAttempts.get(wallet.id) ?? 0) + 1
-        );
         console.error("Failed to reconnect wallet %s", wallet.id, { err });
-      } finally {
-        reconnectingWallets.delete(wallet.id);
       }
     });
     const subWallets = wallets$.subscribe(subscriber);
@@ -437,25 +828,14 @@ var getWallets$ = (config, store2 = store) => {
 var getKheopskit$ = (config, options = {}) => {
   const { ssrCookies, store: existingStore } = options;
   const kc = resolveConfig(config);
-  const store2 = existingStore ?? createKheopskitStore({ ssrCookies, storageKey: kc.storageKey });
+  const store = existingStore ?? createKheopskitStore({ ssrCookies, storageKey: kc.storageKey });
   if (kc.debug) console.debug("[kheopskit] config", kc);
   if (kc.debug && typeof window === "undefined" && ssrCookies === void 0) {
     console.warn(
       "[kheopskit] Running on server without `ssrCookies`. Wallet state will not be hydrated. Pass cookies for SSR support."
     );
   }
-  const cachedState = store2.getCachedState();
-  const cachedWallets = cachedState.wallets.map((w) => {
-    const wallet = hydrateWallet(w);
-    if (!wallet.icon) {
-      const cachedIcon = getCachedIcon(wallet.id);
-      if (cachedIcon) {
-        return { ...wallet, icon: cachedIcon };
-      }
-    }
-    return wallet;
-  });
-  const cachedAccounts = cachedState.accounts.filter((cached) => acceptsCachedAccount(cached, kc.platforms)).map(hydrateAccount);
+  const { wallets: cachedWallets, accounts: cachedAccounts } = getHydratedSnapshot(store, kc.platforms, { icons: true });
   if (kc.debug && cachedWallets.length > 0) {
     console.debug("[kheopskit] hydrating from cache:", {
       wallets: cachedWallets.length,
@@ -463,7 +843,7 @@ var getKheopskit$ = (config, options = {}) => {
     });
   }
   return new Observable5((subscriber) => {
-    const liveWallets$ = getWallets$(kc, store2);
+    const liveWallets$ = getWallets$(kc, store);
     const liveAccounts$ = getAccounts$(kc, liveWallets$);
     const bufferedWallets$ = createHydrationBuffer(
       cachedWallets,
@@ -569,7 +949,7 @@ var getKheopskit$ = (config, options = {}) => {
           accounts: relevantAccounts.length
         });
       }
-      store2.setCachedState(
+      store.setCachedState(
         wallets.items.map(serializeWallet),
         relevantAccounts.map(serializeAccount)
       );
@@ -624,6 +1004,7 @@ export {
   clearAllCachedObservables,
   createKheopskitStore,
   getDefaultStore,
+  getHydratedSnapshot,
   getKheopskit$,
   getWalletAccountId,
   getWalletId,