@routstr/sdk 0.1.0 → 0.1.2

package/dist/storage/index.js

@@ -0,0 +1,861 @@
+'use strict';
+
+var vanilla = require('zustand/vanilla');
+var cashuTs = require('@cashu/cashu-ts');
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// storage/drivers/localStorage.ts
+var canUseLocalStorage = () => {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+};
+var isQuotaExceeded = (error) => {
+  const e = error;
+  return !!e && (e?.name === "QuotaExceededError" || e?.code === 22 || e?.code === 1014);
+};
+var NON_CRITICAL_KEYS = /* @__PURE__ */ new Set(["modelsFromAllProviders"]);
+var localStorageDriver = {
+  async getItem(key, defaultValue) {
+    if (!canUseLocalStorage()) return defaultValue;
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item === null) return defaultValue;
+      try {
+        return JSON.parse(item);
+      } catch (parseError) {
+        if (typeof defaultValue === "string") {
+          return item;
+        }
+        throw parseError;
+      }
+    } catch (error) {
+      console.error(`Error retrieving item with key "${key}":`, error);
+      if (canUseLocalStorage()) {
+        try {
+          window.localStorage.removeItem(key);
+        } catch (removeError) {
+          console.error(
+            `Error removing corrupted item with key "${key}":`,
+            removeError
+          );
+        }
+      }
+      return defaultValue;
+    }
+  },
+  async setItem(key, value) {
+    if (!canUseLocalStorage()) return;
+    try {
+      window.localStorage.setItem(key, JSON.stringify(value));
+    } catch (error) {
+      if (isQuotaExceeded(error)) {
+        if (NON_CRITICAL_KEYS.has(key)) {
+          console.warn(
+            `Storage quota exceeded; skipping non-critical key "${key}".`
+          );
+          return;
+        }
+        try {
+          window.localStorage.removeItem("modelsFromAllProviders");
+        } catch {
+        }
+        try {
+          window.localStorage.setItem(key, JSON.stringify(value));
+          return;
+        } catch (retryError) {
+          console.warn(
+            `Storage quota exceeded; unable to persist key "${key}" after cleanup attempt.`,
+            retryError
+          );
+          return;
+        }
+      }
+      console.error(`Error storing item with key "${key}":`, error);
+    }
+  },
+  async removeItem(key) {
+    if (!canUseLocalStorage()) return;
+    try {
+      window.localStorage.removeItem(key);
+    } catch (error) {
+      console.error(`Error removing item with key "${key}":`, error);
+    }
+  }
+};
+
+// storage/drivers/memory.ts
+var createMemoryDriver = (seed) => {
+  const store = /* @__PURE__ */ new Map();
+  if (seed) {
+    for (const [key, value] of Object.entries(seed)) {
+      store.set(key, value);
+    }
+  }
+  return {
+    async getItem(key, defaultValue) {
+      const item = store.get(key);
+      if (item === void 0) return defaultValue;
+      try {
+        return JSON.parse(item);
+      } catch (parseError) {
+        if (typeof defaultValue === "string") {
+          return item;
+        }
+        throw parseError;
+      }
+    },
+    async setItem(key, value) {
+      store.set(key, JSON.stringify(value));
+    },
+    async removeItem(key) {
+      store.delete(key);
+    }
+  };
+};
+
+// storage/drivers/sqlite.ts
+var isBun = () => {
+  return typeof process.versions.bun !== "undefined";
+};
+var createDatabase = (dbPath) => {
+  if (isBun()) {
+    throw new Error(
+      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
+    );
+  }
+  let Database = null;
+  try {
+    Database = __require("better-sqlite3");
+  } catch (error) {
+    throw new Error(
+      `better-sqlite3 is required for sqlite storage. Install it to use sqlite storage. (${error})`
+    );
+  }
+  return new Database(dbPath);
+};
+var createSqliteDriver = (options = {}) => {
+  const dbPath = options.dbPath || "routstr.sqlite";
+  const tableName = options.tableName || "sdk_storage";
+  const db = createDatabase(dbPath);
+  db.exec(
+    `CREATE TABLE IF NOT EXISTS ${tableName} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
+  );
+  const selectStmt = db.prepare(`SELECT value FROM ${tableName} WHERE key = ?`);
+  const upsertStmt = db.prepare(
+    `INSERT INTO ${tableName} (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  );
+  const deleteStmt = db.prepare(`DELETE FROM ${tableName} WHERE key = ?`);
+  return {
+    async getItem(key, defaultValue) {
+      try {
+        const row = selectStmt.get(key);
+        if (!row || typeof row.value !== "string") return defaultValue;
+        try {
+          return JSON.parse(row.value);
+        } catch (parseError) {
+          if (typeof defaultValue === "string") {
+            return row.value;
+          }
+          throw parseError;
+        }
+      } catch (error) {
+        console.error(`SQLite getItem failed for key "${key}":`, error);
+        return defaultValue;
+      }
+    },
+    async setItem(key, value) {
+      try {
+        upsertStmt.run(key, JSON.stringify(value));
+      } catch (error) {
+        console.error(`SQLite setItem failed for key "${key}":`, error);
+      }
+    },
+    async removeItem(key) {
+      try {
+        deleteStmt.run(key);
+      } catch (error) {
+        console.error(`SQLite removeItem failed for key "${key}":`, error);
+      }
+    }
+  };
+};
+
+// storage/drivers/indexedDB.ts
+var openDatabase = (dbName, storeName) => {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+};
+var createIndexedDBDriver = (options = {}) => {
+  const dbName = options.dbName || "routstr-sdk";
+  const storeName = options.storeName || "sdk_storage";
+  let dbPromise = null;
+  const getDb = () => {
+    if (!dbPromise) {
+      dbPromise = openDatabase(dbName, storeName);
+    }
+    return dbPromise;
+  };
+  return {
+    async getItem(key, defaultValue) {
+      try {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+          const tx = db.transaction(storeName, "readonly");
+          const store = tx.objectStore(storeName);
+          const request = store.get(key);
+          request.onsuccess = () => {
+            const raw = request.result;
+            if (raw === void 0) {
+              resolve(defaultValue);
+              return;
+            }
+            if (typeof raw === "string") {
+              try {
+                resolve(JSON.parse(raw));
+              } catch {
+                if (typeof defaultValue === "string") {
+                  resolve(raw);
+                } else {
+                  resolve(defaultValue);
+                }
+              }
+            } else {
+              resolve(raw);
+            }
+          };
+          request.onerror = () => reject(request.error);
+        });
+      } catch (error) {
+        console.error(`IndexedDB getItem failed for key "${key}":`, error);
+        return defaultValue;
+      }
+    },
+    async setItem(key, value) {
+      try {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+          const tx = db.transaction(storeName, "readwrite");
+          const store = tx.objectStore(storeName);
+          store.put(JSON.stringify(value), key);
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => reject(tx.error);
+        });
+      } catch (error) {
+        console.error(`IndexedDB setItem failed for key "${key}":`, error);
+      }
+    },
+    async removeItem(key) {
+      try {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+          const tx = db.transaction(storeName, "readwrite");
+          const store = tx.objectStore(storeName);
+          store.delete(key);
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => reject(tx.error);
+        });
+      } catch (error) {
+        console.error(`IndexedDB removeItem failed for key "${key}":`, error);
+      }
+    }
+  };
+};
+
+// storage/keys.ts
+var SDK_STORAGE_KEYS = {
+  MODELS_FROM_ALL_PROVIDERS: "modelsFromAllProviders",
+  LAST_USED_MODEL: "lastUsedModel",
+  BASE_URLS_LIST: "base_urls_list",
+  DISABLED_PROVIDERS: "disabled_providers",
+  MINTS_FROM_ALL_PROVIDERS: "mints_from_all_providers",
+  INFO_FROM_ALL_PROVIDERS: "info_from_all_providers",
+  LAST_MODELS_UPDATE: "lastModelsUpdate",
+  LAST_BASE_URLS_UPDATE: "lastBaseUrlsUpdate",
+  LOCAL_CASHU_TOKENS: "local_cashu_tokens",
+  API_KEYS: "api_keys",
+  CHILD_KEYS: "child_keys",
+  ROUTSTR21_MODELS: "routstr21Models",
+  CACHED_RECEIVE_TOKENS: "cached_receive_tokens"
+};
+
+// storage/store.ts
+var normalizeBaseUrl = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var getTokenBalance = (token) => {
+  try {
+    const decoded = cashuTs.getDecodedToken(token);
+    const unitDivisor = decoded.unit === "msat" ? 1e3 : 1;
+    let sum = 0;
+    for (const proof of decoded.proofs) {
+      sum += proof.amount / unitDivisor;
+    }
+    return sum;
+  } catch {
+    return 0;
+  }
+};
+var createSdkStore = async ({
+  driver
+}) => {
+  const [
+    rawModels,
+    lastUsedModel,
+    rawBaseUrls,
+    lastBaseUrlsUpdate,
+    rawDisabledProviders,
+    rawMints,
+    rawInfo,
+    rawLastModelsUpdate,
+    rawCachedTokens,
+    rawApiKeys,
+    rawChildKeys,
+    rawRoutstr21Models,
+    rawCachedReceiveTokens
+  ] = await Promise.all([
+    driver.getItem(
+      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, null),
+    driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, null),
+    driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []),
+    driver.getItem(
+      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(
+      SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(
+      SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
+      {}
+    ),
+    driver.getItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, []),
+    driver.getItem(SDK_STORAGE_KEYS.API_KEYS, []),
+    driver.getItem(SDK_STORAGE_KEYS.CHILD_KEYS, []),
+    driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
+    driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, [])
+  ]);
+  const modelsFromAllProviders = Object.fromEntries(
+    Object.entries(rawModels).map(([baseUrl, models]) => [
+      normalizeBaseUrl(baseUrl),
+      models
+    ])
+  );
+  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl(url));
+  const disabledProviders = rawDisabledProviders.map(
+    (url) => normalizeBaseUrl(url)
+  );
+  const mintsFromAllProviders = Object.fromEntries(
+    Object.entries(rawMints).map(([baseUrl, mints]) => [
+      normalizeBaseUrl(baseUrl),
+      mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
+    ])
+  );
+  const infoFromAllProviders = Object.fromEntries(
+    Object.entries(rawInfo).map(([baseUrl, info]) => [
+      normalizeBaseUrl(baseUrl),
+      info
+    ])
+  );
+  const lastModelsUpdate = Object.fromEntries(
+    Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
+      normalizeBaseUrl(baseUrl),
+      timestamp
+    ])
+  );
+  const cachedTokens = rawCachedTokens.map((entry) => ({
+    ...entry,
+    baseUrl: normalizeBaseUrl(entry.baseUrl),
+    balance: typeof entry.balance === "number" ? entry.balance : getTokenBalance(entry.token),
+    lastUsed: entry.lastUsed ?? null
+  }));
+  const apiKeys = rawApiKeys.map((entry) => ({
+    ...entry,
+    baseUrl: normalizeBaseUrl(entry.baseUrl),
+    balance: entry.balance ?? 0,
+    lastUsed: entry.lastUsed ?? null
+  }));
+  const childKeys = rawChildKeys.map((entry) => ({
+    parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
+    childKey: entry.childKey,
+    balance: entry.balance ?? 0,
+    balanceLimit: entry.balanceLimit,
+    validityDate: entry.validityDate,
+    createdAt: entry.createdAt ?? Date.now()
+  }));
+  const routstr21Models = rawRoutstr21Models;
+  const cachedReceiveTokens = rawCachedReceiveTokens.map((entry) => ({
+    token: entry.token,
+    amount: entry.amount,
+    unit: entry.unit || "sat",
+    createdAt: entry.createdAt ?? Date.now()
+  }));
+  return vanilla.createStore((set, get) => ({
+    modelsFromAllProviders,
+    lastUsedModel,
+    baseUrlsList,
+    lastBaseUrlsUpdate,
+    disabledProviders,
+    mintsFromAllProviders,
+    infoFromAllProviders,
+    lastModelsUpdate,
+    cachedTokens,
+    apiKeys,
+    childKeys,
+    routstr21Models,
+    cachedReceiveTokens,
+    setModelsFromAllProviders: (value) => {
+      const normalized = {};
+      for (const [baseUrl, models] of Object.entries(value)) {
+        normalized[normalizeBaseUrl(baseUrl)] = models;
+      }
+      void driver.setItem(
+        SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
+        normalized
+      );
+      set({ modelsFromAllProviders: normalized });
+    },
+    setLastUsedModel: (value) => {
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
+      set({ lastUsedModel: value });
+    },
+    setBaseUrlsList: (value) => {
+      const normalized = value.map((url) => normalizeBaseUrl(url));
+      void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
+      set({ baseUrlsList: normalized });
+    },
+    setBaseUrlsLastUpdate: (value) => {
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
+      set({ lastBaseUrlsUpdate: value });
+    },
+    setDisabledProviders: (value) => {
+      const normalized = value.map((url) => normalizeBaseUrl(url));
+      void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
+      set({ disabledProviders: normalized });
+    },
+    setMintsFromAllProviders: (value) => {
+      const normalized = {};
+      for (const [baseUrl, mints] of Object.entries(value)) {
+        normalized[normalizeBaseUrl(baseUrl)] = mints.map(
+          (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
+        );
+      }
+      void driver.setItem(
+        SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+        normalized
+      );
+      set({ mintsFromAllProviders: normalized });
+    },
+    setInfoFromAllProviders: (value) => {
+      const normalized = {};
+      for (const [baseUrl, info] of Object.entries(value)) {
+        normalized[normalizeBaseUrl(baseUrl)] = info;
+      }
+      void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
+      set({ infoFromAllProviders: normalized });
+    },
+    setLastModelsUpdate: (value) => {
+      const normalized = {};
+      for (const [baseUrl, timestamp] of Object.entries(value)) {
+        normalized[normalizeBaseUrl(baseUrl)] = timestamp;
+      }
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
+      set({ lastModelsUpdate: normalized });
+    },
+    setCachedTokens: (value) => {
+      set((state) => {
+        const updates = typeof value === "function" ? value(state.cachedTokens) : value;
+        const normalized = updates.map((entry) => ({
+          ...entry,
+          baseUrl: normalizeBaseUrl(entry.baseUrl),
+          balance: typeof entry.balance === "number" ? entry.balance : getTokenBalance(entry.token),
+          lastUsed: entry.lastUsed ?? null
+        }));
+        void driver.setItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, normalized);
+        return { cachedTokens: normalized };
+      });
+    },
+    setApiKeys: (value) => {
+      set((state) => {
+        const updates = typeof value === "function" ? value(state.apiKeys) : value;
+        const normalized = updates.map((entry) => ({
+          ...entry,
+          baseUrl: normalizeBaseUrl(entry.baseUrl),
+          balance: entry.balance ?? 0,
+          lastUsed: entry.lastUsed ?? null
+        }));
+        void driver.setItem(SDK_STORAGE_KEYS.API_KEYS, normalized);
+        return { apiKeys: normalized };
+      });
+    },
+    setChildKeys: (value) => {
+      set((state) => {
+        const updates = typeof value === "function" ? value(state.childKeys) : value;
+        const normalized = updates.map((entry) => ({
+          parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
+          childKey: entry.childKey,
+          balance: entry.balance ?? 0,
+          balanceLimit: entry.balanceLimit,
+          validityDate: entry.validityDate,
+          createdAt: entry.createdAt ?? Date.now()
+        }));
+        void driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
+        return { childKeys: normalized };
+      });
+    },
+    setRoutstr21Models: (value) => {
+      void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
+      set({ routstr21Models: value });
+    },
+    setCachedReceiveTokens: (value) => {
+      const normalized = value.map((entry) => ({
+        token: entry.token,
+        amount: entry.amount,
+        unit: entry.unit || "sat",
+        createdAt: entry.createdAt ?? Date.now()
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
+      set({ cachedReceiveTokens: normalized });
+    }
+  }));
+};
+var createDiscoveryAdapterFromStore = (store) => ({
+  getCachedModels: () => store.getState().modelsFromAllProviders,
+  setCachedModels: (models) => store.getState().setModelsFromAllProviders(models),
+  getCachedMints: () => store.getState().mintsFromAllProviders,
+  setCachedMints: (mints) => store.getState().setMintsFromAllProviders(mints),
+  getCachedProviderInfo: () => store.getState().infoFromAllProviders,
+  setCachedProviderInfo: (info) => store.getState().setInfoFromAllProviders(info),
+  getProviderLastUpdate: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const timestamps = store.getState().lastModelsUpdate;
+    return timestamps[normalized] || null;
+  },
+  setProviderLastUpdate: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const timestamps = { ...store.getState().lastModelsUpdate };
+    timestamps[normalized] = timestamp;
+    store.getState().setLastModelsUpdate(timestamps);
+  },
+  getLastUsedModel: () => store.getState().lastUsedModel,
+  setLastUsedModel: (modelId) => store.getState().setLastUsedModel(modelId),
+  getDisabledProviders: () => store.getState().disabledProviders,
+  getBaseUrlsList: () => store.getState().baseUrlsList,
+  setBaseUrlsList: (urls) => store.getState().setBaseUrlsList(urls),
+  getBaseUrlsLastUpdate: () => store.getState().lastBaseUrlsUpdate,
+  setBaseUrlsLastUpdate: (timestamp) => store.getState().setBaseUrlsLastUpdate(timestamp),
+  getRoutstr21Models: () => store.getState().routstr21Models,
+  setRoutstr21Models: (models) => store.getState().setRoutstr21Models(models)
+});
+var createStorageAdapterFromStore = (store) => ({
+  getToken: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const entry = store.getState().cachedTokens.find((token) => token.baseUrl === normalized);
+    if (!entry) return null;
+    const next = store.getState().cachedTokens.map(
+      (token) => token.baseUrl === normalized ? { ...token, lastUsed: Date.now() } : token
+    );
+    store.getState().setCachedTokens(next);
+    return entry.token;
+  },
+  setToken: (baseUrl, token) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const tokens = store.getState().cachedTokens;
+    const balance = getTokenBalance(token);
+    const existingIndex = tokens.findIndex(
+      (entry) => entry.baseUrl === normalized
+    );
+    if (existingIndex !== -1) {
+      throw new Error(`Token already exists for baseUrl: ${normalized}`);
+    }
+    const next = [...tokens];
+    next.push({
+      baseUrl: normalized,
+      token,
+      balance,
+      lastUsed: Date.now()
+    });
+    store.getState().setCachedTokens(next);
+  },
+  removeToken: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const next = store.getState().cachedTokens.filter((entry) => entry.baseUrl !== normalized);
+    store.getState().setCachedTokens(next);
+  },
+  updateTokenBalance: (baseUrl, balance) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const tokens = store.getState().cachedTokens;
+    const next = tokens.map(
+      (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
+    );
+    store.getState().setCachedTokens(next);
+  },
+  getCachedTokenDistribution: () => {
+    const cachedTokens = store.getState().cachedTokens;
+    const distributionMap = {};
+    for (const entry of cachedTokens) {
+      const sum = entry.balance || 0;
+      if (sum > 0) {
+        distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
+      }
+    }
+    return Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
+  },
+  getApiKeyDistribution: () => {
+    const apiKeys = store.getState().apiKeys;
+    const distributionMap = {};
+    for (const entry of apiKeys) {
+      const sum = entry.balance || 0;
+      if (sum > 0) {
+        distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
+      }
+    }
+    return Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
+  },
+  saveProviderInfo: (baseUrl, info) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const next = { ...store.getState().infoFromAllProviders };
+    next[normalized] = info;
+    store.getState().setInfoFromAllProviders(next);
+  },
+  getProviderInfo: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    return store.getState().infoFromAllProviders[normalized] || null;
+  },
+  // ========== API Keys (for apikeys mode) ==========
+  getApiKey: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const entry = store.getState().apiKeys.find((key) => key.baseUrl === normalized);
+    if (!entry) return null;
+    const next = store.getState().apiKeys.map(
+      (key) => key.baseUrl === normalized ? { ...key, lastUsed: Date.now() } : key
+    );
+    store.getState().setApiKeys(next);
+    return entry;
+  },
+  setApiKey: (baseUrl, key) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const keys = store.getState().apiKeys;
+    const existingIndex = keys.findIndex(
+      (entry) => entry.baseUrl === normalized
+    );
+    if (existingIndex !== -1) {
+      throw new Error(`ApiKey already exists for baseUrl: ${normalized}`);
+    }
+    const next = [...keys];
+    next.push({
+      baseUrl: normalized,
+      key,
+      balance: 0,
+      lastUsed: Date.now()
+    });
+    store.getState().setApiKeys(next);
+  },
+  updateApiKeyBalance: (baseUrl, balance) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const keys = store.getState().apiKeys;
+    const next = keys.map(
+      (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
+    );
+    store.getState().setApiKeys(next);
+  },
+  removeApiKey: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const next = store.getState().apiKeys.filter((entry) => entry.baseUrl !== normalized);
+    store.getState().setApiKeys(next);
+  },
+  getAllApiKeys: () => {
+    return store.getState().apiKeys.map((entry) => ({
+      baseUrl: entry.baseUrl,
+      key: entry.key,
+      balance: entry.balance,
+      lastUsed: entry.lastUsed
+    }));
+  },
+  // ========== Child Keys ==========
+  getChildKey: (parentBaseUrl) => {
+    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const entry = store.getState().childKeys.find((key) => key.parentBaseUrl === normalized);
+    if (!entry) return null;
+    return {
+      parentBaseUrl: entry.parentBaseUrl,
+      childKey: entry.childKey,
+      balance: entry.balance,
+      balanceLimit: entry.balanceLimit,
+      validityDate: entry.validityDate,
+      createdAt: entry.createdAt
+    };
+  },
+  setChildKey: (parentBaseUrl, childKey, balance, validityDate, balanceLimit) => {
+    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const keys = store.getState().childKeys;
+    const existingIndex = keys.findIndex(
+      (entry) => entry.parentBaseUrl === normalized
+    );
+    if (existingIndex !== -1) {
+      const next = keys.map(
+        (entry) => entry.parentBaseUrl === normalized ? {
+          ...entry,
+          childKey,
+          balance: balance ?? 0,
+          validityDate,
+          balanceLimit,
+          createdAt: Date.now()
+        } : entry
+      );
+      store.getState().setChildKeys(next);
+    } else {
+      const next = [...keys];
+      next.push({
+        parentBaseUrl: normalized,
+        childKey,
+        balance: balance ?? 0,
+        validityDate,
+        balanceLimit,
+        createdAt: Date.now()
+      });
+      store.getState().setChildKeys(next);
+    }
+  },
+  updateChildKeyBalance: (parentBaseUrl, balance) => {
+    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const keys = store.getState().childKeys;
+    const next = keys.map(
+      (entry) => entry.parentBaseUrl === normalized ? { ...entry, balance } : entry
+    );
+    store.getState().setChildKeys(next);
+  },
+  removeChildKey: (parentBaseUrl) => {
+    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const next = store.getState().childKeys.filter((entry) => entry.parentBaseUrl !== normalized);
+    store.getState().setChildKeys(next);
+  },
+  getAllChildKeys: () => {
+    return store.getState().childKeys.map((entry) => ({
+      parentBaseUrl: entry.parentBaseUrl,
+      childKey: entry.childKey,
+      balance: entry.balance,
+      balanceLimit: entry.balanceLimit,
+      validityDate: entry.validityDate,
+      createdAt: entry.createdAt
+    }));
+  },
+  getCachedReceiveTokens: () => {
+    return store.getState().cachedReceiveTokens;
+  },
+  setCachedReceiveTokens: (tokens) => {
+    store.getState().setCachedReceiveTokens(tokens);
+  }
+});
+var createProviderRegistryFromStore = (store) => ({
+  getModelsForProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    return store.getState().modelsFromAllProviders[normalized] || [];
+  },
+  getDisabledProviders: () => store.getState().disabledProviders,
+  getProviderMints: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    return store.getState().mintsFromAllProviders[normalized] || [];
+  },
+  getProviderInfo: async (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const cached = store.getState().infoFromAllProviders[normalized];
+    if (cached) return cached;
+    try {
+      const response = await fetch(`${normalized}v1/info`);
+      if (!response.ok) {
+        throw new Error(`Failed ${response.status}`);
+      }
+      const info = await response.json();
+      const next = { ...store.getState().infoFromAllProviders };
+      next[normalized] = info;
+      store.getState().setInfoFromAllProviders(next);
+      return info;
+    } catch (error) {
+      console.warn(`Failed to fetch provider info from ${normalized}:`, error);
+      return null;
+    }
+  },
+  getAllProvidersModels: () => store.getState().modelsFromAllProviders
+});
+
+// storage/index.ts
+var isBrowser = () => {
+  try {
+    return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+  } catch {
+    return false;
+  }
+};
+var isNode = () => {
+  try {
+    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+  } catch {
+    return false;
+  }
+};
+var defaultDriver = null;
+var isBun2 = () => {
+  return typeof process.versions.bun !== "undefined";
+};
+var getDefaultSdkDriver = () => {
+  if (defaultDriver) return defaultDriver;
+  if (isBrowser()) {
+    defaultDriver = localStorageDriver;
+    return defaultDriver;
+  }
+  if (isBun2()) {
+    defaultDriver = createMemoryDriver();
+    return defaultDriver;
+  }
+  if (isNode()) {
+    defaultDriver = createSqliteDriver();
+    return defaultDriver;
+  }
+  defaultDriver = createMemoryDriver();
+  return defaultDriver;
+};
+var defaultStorePromise = null;
+var getDefaultSdkStore = () => {
+  if (!defaultStorePromise) {
+    defaultStorePromise = createSdkStore({ driver: getDefaultSdkDriver() });
+  }
+  return defaultStorePromise;
+};
+var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
+var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
+var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(await getDefaultSdkStore());
+
+exports.SDK_STORAGE_KEYS = SDK_STORAGE_KEYS;
+exports.createDiscoveryAdapterFromStore = createDiscoveryAdapterFromStore;
+exports.createIndexedDBDriver = createIndexedDBDriver;
+exports.createMemoryDriver = createMemoryDriver;
+exports.createProviderRegistryFromStore = createProviderRegistryFromStore;
+exports.createSdkStore = createSdkStore;
+exports.createSqliteDriver = createSqliteDriver;
+exports.createStorageAdapterFromStore = createStorageAdapterFromStore;
+exports.getDefaultDiscoveryAdapter = getDefaultDiscoveryAdapter;
+exports.getDefaultProviderRegistry = getDefaultProviderRegistry;
+exports.getDefaultSdkDriver = getDefaultSdkDriver;
+exports.getDefaultSdkStore = getDefaultSdkStore;
+exports.getDefaultStorageAdapter = getDefaultStorageAdapter;
+exports.localStorageDriver = localStorageDriver;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map