@unicitylabs/sphere-sdk 0.8.0-dev.3 → 0.8.0-dev.5

package/dist/impl/nodejs/index.cjs

@@ -26900,7 +26900,7 @@ function getEmbeddedTrustBase(network) {
     case "dev":
       return TRUSTBASE_DEV;
     default:
-      return TRUSTBASE_TESTNET;
+      throw new SphereError(`getEmbeddedTrustBase: unknown network "${network}"`, "INVALID_CONFIG");
   }
 }
 var BaseTrustBaseLoader = class {
@@ -26920,11 +26920,23 @@ var BaseTrustBaseLoader = class {
 // impl/nodejs/oracle/index.ts
 var NodeTrustBaseLoader = class extends BaseTrustBaseLoader {
   filePath;
-  constructor(filePathOrNetwork) {
+  /**
+   * @param filePathOrNetwork - a NetworkType, or a file path to load the trust base from
+   * @param fallbackNetwork - network used for the embedded fallback when a file path is
+   *   supplied (and the file is missing/unreadable). Required when filePathOrNetwork is a
+   *   path — we must never silently fall back to testnet on a different network.
+   */
+  constructor(filePathOrNetwork, fallbackNetwork) {
     if (!filePathOrNetwork) {
-      super("testnet");
+      throw new SphereError("NodeTrustBaseLoader: network or trustBasePath is required.", "INVALID_CONFIG");
     } else if (filePathOrNetwork.includes("/") || filePathOrNetwork.includes(".")) {
-      super("testnet");
+      if (!fallbackNetwork) {
+        throw new SphereError(
+          "NodeTrustBaseLoader: fallbackNetwork is required when a trustBasePath is supplied.",
+          "INVALID_CONFIG"
+        );
+      }
+      super(fallbackNetwork);
       this.filePath = filePathOrNetwork;
     } else {
       super(filePathOrNetwork);
@@ -26942,14 +26954,21 @@ var NodeTrustBaseLoader = class extends BaseTrustBaseLoader {
     return null;
   }
 };
-function createNodeTrustBaseLoader(filePathOrNetwork) {
-  return new NodeTrustBaseLoader(filePathOrNetwork);
+function createNodeTrustBaseLoader(filePathOrNetwork, fallbackNetwork) {
+  return new NodeTrustBaseLoader(filePathOrNetwork, fallbackNetwork);
 }
 function createUnicityAggregatorProvider(config) {
   const { trustBasePath, network, ...restConfig } = config;
+  if (!trustBasePath && !network) {
+    throw new SphereError(
+      "createUnicityAggregatorProvider: network or trustBaseUrl required.",
+      "INVALID_CONFIG"
+    );
+  }
   return new UnicityAggregatorProvider({
     ...restConfig,
-    trustBaseLoader: createNodeTrustBaseLoader(trustBasePath ?? network ?? "testnet")
+    // When a path is supplied, `network` (if any) is the embedded-fallback network.
+    trustBaseLoader: createNodeTrustBaseLoader(trustBasePath ?? network, network)
   });
 }
 var createUnicityOracleProvider = createUnicityAggregatorProvider;
@@ -29328,6 +29347,19 @@ var TokenRegistry = class _TokenRegistry {
   // ===========================================================================
   // Cache (StorageProvider)
   // ===========================================================================
+  /**
+   * Per-network cache keys. The registry cache MUST be namespaced by remoteUrl:
+   * testnet and testnet2 ship DIFFERENT coinIds for the same symbol, so a single
+   * global key let a stale testnet snapshot be served for a testnet2 request —
+   * wrong/missing icons AND self-mint resolving the wrong-network coinId. Keying
+   * by remoteUrl isolates the snapshots so a network can never read another's.
+   */
+  cacheKeys() {
+    const base = STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE;
+    const baseTs = STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE_TS;
+    if (!this.remoteUrl) return { data: base, ts: baseTs };
+    return { data: `${base}:${this.remoteUrl}`, ts: `${baseTs}:${this.remoteUrl}` };
+  }
   /**
    * Load definitions from StorageProvider cache.
    * Only applies if cache exists and is fresh (within refreshIntervalMs).
@@ -29335,9 +29367,10 @@ var TokenRegistry = class _TokenRegistry {
   async loadFromCache() {
     if (!this.storage) return false;
     try {
+      const { data: dataKey, ts: tsKey } = this.cacheKeys();
       const [cached, cachedTs] = await Promise.all([
-        this.storage.get(STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE),
-        this.storage.get(STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE_TS)
+        this.storage.get(dataKey),
+        this.storage.get(tsKey)
       ]);
       if (!cached || !cachedTs) return false;
       const ts = parseInt(cachedTs, 10);
@@ -29360,9 +29393,10 @@ var TokenRegistry = class _TokenRegistry {
   async saveToCache(definitions) {
     if (!this.storage) return;
     try {
+      const { data: dataKey, ts: tsKey } = this.cacheKeys();
       await Promise.all([
-        this.storage.set(STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE, JSON.stringify(definitions)),
-        this.storage.set(STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE_TS, String(Date.now()))
+        this.storage.set(dataKey, JSON.stringify(definitions)),
+        this.storage.set(tsKey, String(Date.now()))
       ]);
     } catch {
     }
@@ -29701,7 +29735,10 @@ function createNodeProviders(config) {
       );
     }
   }
-  const network = config?.network ?? "mainnet";
+  if (!config?.network) {
+    throw new SphereError("createNodeProviders: config.network is required.", "INVALID_CONFIG");
+  }
+  const network = config.network;
   const globalDebug = config?.debug ?? false;
   logger.configure({ debug: globalDebug });
   if (config?.transport?.debug) logger.setTagDebug("Nostr", true);