@unicitylabs/sphere-sdk 0.15.0 → 0.16.0-dev.2

package/dist/impl/browser/index.cjs

@@ -143,6 +143,58 @@ var logger = {
   }
 };
 
+// core/global-cell.ts
+var CELLS_KEY = "__sphere_sdk_cells_v1__";
+var bundleLocalBag = null;
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function installBag(host, fresh) {
+  try {
+    Object.defineProperty(host, CELLS_KEY, {
+      value: fresh,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    return host[CELLS_KEY] === fresh;
+  } catch {
+    return false;
+  }
+}
+function cellBag() {
+  if (bundleLocalBag) return bundleLocalBag;
+  const host = globalThis;
+  const found = host[CELLS_KEY];
+  if (isObject(found)) return found;
+  const fresh = {};
+  if (!installBag(host, fresh)) bundleLocalBag = fresh;
+  return fresh;
+}
+function accepted(intact, candidate) {
+  try {
+    return intact(candidate);
+  } catch {
+    return false;
+  }
+}
+function put(bag, name, cell) {
+  try {
+    bag[name] = cell;
+    if (bag[name] === cell) return;
+  } catch {
+  }
+  if (bag !== bundleLocalBag) bundleLocalBag = { [name]: cell };
+}
+function sharedCell(name, create, intact) {
+  const bag = cellBag();
+  const found = bag[name];
+  if (isObject(found) && accepted(intact, found)) return found;
+  const fresh = create();
+  put(bag, name, fresh);
+  return fresh;
+}
+
 // core/errors.ts
 var SphereError = class extends Error {
   code;
@@ -245,7 +297,6 @@ function isNetworkScopedAddressKey(key) {
   return false;
 }
 var DEFAULT_NOSTR_RELAYS = [
-  "wss://relay.unicity.network",
   "wss://relay.damus.io",
   "wss://nos.lol",
   "wss://relay.nostr.band"
@@ -258,13 +309,9 @@ var NOSTR_EVENT_KINDS = {
   /** Public broadcast */
   BROADCAST: 1
 };
-var DEFAULT_AGGREGATOR_URL = "https://aggregator.unicity.network/rpc";
-var DEV_AGGREGATOR_URL = "https://dev-aggregator.dyndns.org/rpc";
 var DEFAULT_AGGREGATOR_TIMEOUT = 3e4;
 var DEFAULT_BASE_PATH = "m/44'/0'/0'";
 var DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
-var TOKEN_REGISTRY_URL = "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.testnet.json";
-var TOKEN_REGISTRY_REFRESH_INTERVAL = 36e5;
 var TEST_NOSTR_RELAYS = [
   "wss://nostr-relay.testnet.unicity.network"
 ];
@@ -274,16 +321,25 @@ var DEFAULT_GROUP_RELAYS = [
 var NETWORKS = {
   mainnet: {
     name: "Mainnet",
-    aggregatorUrl: DEFAULT_AGGREGATOR_URL,
-    nostrRelays: DEFAULT_NOSTR_RELAYS,
+    networkId: 1,
+    // v3 state-transition gateway (networkId 1 comes from the trust base). apiKey is env-injected;
+    // unlike testnet2's, a mainnet gateway key is a SECRET — never commit one.
+    aggregatorUrl: "https://gateway.mainnet.unicity.network",
+    // Mainnet has no relay of its own yet — it shares the testnet relay until one is stood up.
+    // Consequence while shared: nametag bindings for both networks live in ONE namespace, and
+    // since bindings carry no network the cross-network recipient guard can only signal (#734).
+    nostrRelays: TEST_NOSTR_RELAYS,
     groupRelays: DEFAULT_GROUP_RELAYS,
-    tokenRegistryUrl: TOKEN_REGISTRY_URL
+    // Published, but currently only the non-fungible base token type — no fungible
+    // coins yet, so those still miss the registry (decimals 0, symbol falls back to
+    // six hex chars). Presentation only: the money path treats coinId as opaque bytes.
+    tokenRegistryUrl: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.mainnet.json"
   },
   // v1 cutover: 'testnet' now POINTS AT TESTNET2 (the v2 gateway network). The
   // old goggregator testnet spoke the removed v1 protocol — a v2 engine cannot
   // run against it. 'testnet2' stays as an alias of the same configuration.
   testnet: {
-    name: "Testnet2",
+    name: "Testnet",
     networkId: 4,
     // v2 state-transition gateway (networkId 4 comes from the trust base). apiKey is env-injected.
     aggregatorUrl: "https://gateway.testnet2.unicity.network",
@@ -293,7 +349,7 @@ var NETWORKS = {
     tokenRegistryUrl: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.testnet2.json"
   },
   testnet2: {
-    name: "Testnet2",
+    name: "Testnet",
     networkId: 4,
     // v2 state-transition gateway (networkId 4 comes from the trust base). apiKey is env-injected.
     aggregatorUrl: "https://gateway.testnet2.unicity.network",
@@ -301,19 +357,10 @@ var NETWORKS = {
     // reuse testnet infra (shared relays/ipfs)
     groupRelays: DEFAULT_GROUP_RELAYS,
     tokenRegistryUrl: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.testnet2.json"
-  },
-  // NOTE: mainnet/dev still point at v1-era aggregators. The v2 engine cannot
-  // operate against them until their gateways are cut over to the v2 protocol —
-  // wallet operations on these networks fail loudly (AGGREGATOR_ERROR) until then.
-  dev: {
-    name: "Development",
-    aggregatorUrl: DEV_AGGREGATOR_URL,
-    nostrRelays: TEST_NOSTR_RELAYS,
-    groupRelays: DEFAULT_GROUP_RELAYS,
-    tokenRegistryUrl: TOKEN_REGISTRY_URL
   }
 };
 var SPHERE_NETWORKS = {
+  mainnet: { id: NETWORKS.mainnet.networkId, name: "mainnet" },
   testnet2: { id: NETWORKS.testnet2.networkId, name: "testnet2" }
 };
 var TIMEOUTS = {
@@ -329,12 +376,106 @@ var TIMEOUTS = {
   SYNC_INTERVAL: 6e4
 };
 
+// storage/tracked-addresses.ts
+function isDerivableIndex(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 4294967295;
+}
+function num(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function toEntry(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const e = value;
+  if (!isDerivableIndex(e.index)) return null;
+  return {
+    ...e,
+    index: e.index,
+    hidden: e.hidden === true,
+    createdAt: num(e.createdAt, 0),
+    updatedAt: num(e.updatedAt, 0)
+  };
+}
+function parseTrackedAddresses(raw) {
+  if (!raw) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null) return [];
+  const addresses = parsed.addresses;
+  if (!Array.isArray(addresses)) return [];
+  const entries = [];
+  for (const row of addresses) {
+    const entry = toEntry(row);
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+function mergeTrackedAddresses(onDisk, incoming) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const entry of onDisk) {
+    if (isDerivableIndex(entry.index)) merged.set(entry.index, entry);
+  }
+  for (const entry of incoming) {
+    if (!isDerivableIndex(entry.index)) {
+      throw new SphereError(
+        `Tracked address index ${String(entry.index)} is not a BIP32 child number: it must be an integer in 0\u20260xffffffff. Refusing the write \u2014 such a row derives another address's keys (1.5 parses to 1) instead of its own.`,
+        "VALIDATION_ERROR"
+      );
+    }
+    const existing = merged.get(entry.index);
+    if (!existing) {
+      merged.set(entry.index, entry);
+      continue;
+    }
+    const winner = entry.updatedAt >= existing.updatedAt ? entry : existing;
+    merged.set(entry.index, {
+      ...existing,
+      ...winner,
+      index: entry.index,
+      createdAt: Math.min(existing.createdAt, entry.createdAt)
+    });
+  }
+  return Array.from(merged.values()).sort((a, b) => a.index - b.index);
+}
+
 // impl/browser/storage/LocalStorageProvider.ts
+var storeIdentity = sharedCell(
+  "impl.browser.localStorage.identity@1",
+  () => ({ tags: /* @__PURE__ */ new WeakMap(), writeChains: /* @__PURE__ */ new Map(), seq: 0 }),
+  (cell) => {
+    const c = cell;
+    return c.tags instanceof WeakMap && c.writeChains instanceof Map && typeof c.seq === "number";
+  }
+);
+function storageObjectTag(storage) {
+  let tag = storeIdentity.tags.get(storage);
+  if (!tag) {
+    tag = String(++storeIdentity.seq);
+    storeIdentity.tags.set(storage, tag);
+  }
+  return tag;
+}
+var trackedWriteChains = storeIdentity.writeChains;
+function serializeTrackedWrite(storeId, task) {
+  const previous = trackedWriteChains.get(storeId) ?? Promise.resolve();
+  const run = previous.then(task);
+  const tail = run.then(() => void 0, () => void 0);
+  trackedWriteChains.set(storeId, tail);
+  void tail.then(() => {
+    if (trackedWriteChains.get(storeId) === tail) trackedWriteChains.delete(storeId);
+  });
+  return run;
+}
 var LocalStorageProvider = class {
   id = "localStorage";
   name = "Local Storage";
   type = "local";
   description = "Browser localStorage for single-device persistence";
+  /** The `Storage` object + prefix — two providers over one pair share erasure (#766). */
+  backingStoreId;
   config;
   network;
   identity = null;
@@ -347,6 +488,7 @@ var LocalStorageProvider = class {
       debug: config?.debug ?? false
     };
     this.network = config?.network;
+    this.backingStoreId = `localstorage:${storageObjectTag(storage)}:${encodeURIComponent(this.config.prefix)}`;
   }
   // ===========================================================================
   // BaseProvider Implementation
@@ -422,18 +564,27 @@ var LocalStorageProvider = class {
       await this.remove(key);
     }
   }
+  /**
+   * Persist the tracked-address registry by MERGING, never replacing.
+   *
+   * Every Sphere over this storage holds its own snapshot and writes it in
+   * full, so a wholesale write drops the addresses this writer never saw
+   * (#766 item 5 — a lost update, reproducible on one network). localStorage
+   * offers no transaction, so the read-merge-write is serialized by BACKING
+   * STORE — see `serializeTrackedWrite`, and the realm limit stated there.
+   */
   async saveTrackedAddresses(entries) {
-    await this.set(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES, JSON.stringify({ version: 1, addresses: entries }));
+    await serializeTrackedWrite(this.backingStoreId, async () => {
+      const onDisk = parseTrackedAddresses(await this.get(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES));
+      const file = {
+        version: 1,
+        addresses: mergeTrackedAddresses(onDisk, entries)
+      };
+      await this.set(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES, JSON.stringify(file));
+    });
   }
   async loadTrackedAddresses() {
-    const data = await this.get(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES);
-    if (!data) return [];
-    try {
-      const parsed = JSON.parse(data);
-      return parsed.addresses ?? [];
-    } catch {
-      return [];
-    }
+    return parseTrackedAddresses(await this.get(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES));
   }
   // ===========================================================================
   // Helpers
@@ -520,6 +671,8 @@ var IndexedDBStorageProvider = class {
   name = "IndexedDB Storage";
   type = "local";
   description = "Browser IndexedDB for large-capacity persistence";
+  /** The database + prefix pair — two providers over one pair share erasure (#766). */
+  backingStoreId;
   prefix;
   dbName;
   network;
@@ -534,6 +687,7 @@ var IndexedDBStorageProvider = class {
     this.dbName = config?.dbName ?? DB_NAME;
     this.network = config?.network;
     this.debug = config?.debug ?? false;
+    this.backingStoreId = `indexeddb:${encodeURIComponent(this.dbName)}:${encodeURIComponent(this.prefix)}`;
   }
   // ===========================================================================
   // BaseProvider Implementation
@@ -663,18 +817,27 @@ var IndexedDBStorageProvider = class {
       await this.remove(key);
     }
   }
+  /**
+   * Persist the tracked-address registry by MERGING, never replacing.
+   *
+   * Every Sphere over this storage holds its own snapshot and writes it in
+   * full, so a wholesale write drops the addresses this writer never saw
+   * (#766 item 5 — a lost update, reproducible on one network). The read, the
+   * merge and the write share ONE transaction: a lock on this object would
+   * order only this object's calls, and `backingStoreId` exists precisely
+   * because two provider objects — or two TABS — can address one database.
+   * IndexedDB serializes overlapping readwrite transactions across every
+   * connection, so both are covered.
+   */
   async saveTrackedAddresses(entries) {
-    await this.set(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES, JSON.stringify({ version: 1, addresses: entries }));
+    this.ensureConnected();
+    await this.idbMergeTrackedAddresses(
+      this.getFullKey(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES),
+      entries
+    );
   }
   async loadTrackedAddresses() {
-    const data = await this.get(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES);
-    if (!data) return [];
-    try {
-      const parsed = JSON.parse(data);
-      return parsed.addresses ?? [];
-    } catch {
-      return [];
-    }
+    return parseTrackedAddresses(await this.get(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES));
   }
   // ===========================================================================
   // Helpers
@@ -791,6 +954,25 @@ var IndexedDBStorageProvider = class {
       request.onsuccess = () => resolve(request.result ?? []);
     });
   }
+  idbMergeTrackedAddresses(key, entries) {
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, "readwrite");
+      const store = tx.objectStore(STORE_NAME);
+      const read = store.get(key);
+      read.onerror = () => reject(read.error);
+      read.onsuccess = () => {
+        const onDisk = parseTrackedAddresses(read.result?.v ?? null);
+        const file = {
+          version: 1,
+          addresses: mergeTrackedAddresses(onDisk, entries)
+        };
+        store.put({ k: key, v: JSON.stringify(file) });
+      };
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      tx.onabort = () => reject(tx.error ?? new Error("tracked-address write aborted"));
+    });
+  }
   idbClear() {
     return new Promise((resolve, reject) => {
       const tx = this.db.transaction(STORE_NAME, "readwrite");
@@ -1369,14 +1551,10 @@ var NostrTransportProvider = class _NostrTransportProvider {
           });
         }
       });
-      await Promise.race([
-        this.nostrClient.connect(...this.config.relays),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(
-            `Transport connection timed out after ${this.config.timeout}ms`
-          )), this.config.timeout)
-        )
-      ]);
+      await this.connectWithDeadline(
+        this.nostrClient,
+        `Transport connection timed out after ${this.config.timeout}ms`
+      );
       if (!this.nostrClient.isConnected()) {
         throw new SphereError("Failed to connect to any relay", "TRANSPORT_ERROR");
       }
@@ -1391,6 +1569,27 @@ var NostrTransportProvider = class _NostrTransportProvider {
       throw error;
     }
   }
+  /**
+   * Race one client's relay connect against the configured timeout.
+   *
+   * The timer is cleared in a `finally` on EVERY path. `Promise.race` does not
+   * cancel the loser: an un-cleared `setTimeout` keeps Node's event loop pinned
+   * for the whole `config.timeout` after the call has already returned (and
+   * then rejects a promise nobody is listening to any more).
+   */
+  async connectWithDeadline(client, timeoutMessage) {
+    let timer;
+    try {
+      await Promise.race([
+        client.connect(...this.config.relays),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error(timeoutMessage)), this.config.timeout);
+        })
+      ]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
   async disconnect() {
     if (this.nostrClient) {
       this.nostrClient.disconnect();
@@ -1509,19 +1708,22 @@ var NostrTransportProvider = class _NostrTransportProvider {
   // TransportProvider Implementation
   // ===========================================================================
   async setIdentity(identity) {
-    this.identity = identity;
-    this.processedEventIds.clear();
-    this.lastEventTs = 0;
-    this.lastDmEventTs = 0;
-    this.fallbackDmSince = null;
     const secretKey = import_buffer.Buffer.from(identity.privateKey, "hex");
-    this.keyManager = import_nostr_js_sdk.NostrKeyManager.fromPrivateKey(secretKey);
-    const nostrPubkey = this.keyManager.getPublicKeyHex();
-    logger.debug("Nostr", "Identity set, Nostr pubkey:", nostrPubkey.slice(0, 16) + "...");
+    const nextKeyManager = import_nostr_js_sdk.NostrKeyManager.fromPrivateKey(secretKey);
+    const nostrPubkey = nextKeyManager.getPublicKeyHex();
+    logger.debug("Nostr", "Identity staged, Nostr pubkey:", nostrPubkey.slice(0, 16) + "...");
+    const applyStagedIdentity = () => {
+      this.identity = identity;
+      this.keyManager = nextKeyManager;
+      this.processedEventIds.clear();
+      this.lastEventTs = 0;
+      this.lastDmEventTs = 0;
+      this.fallbackDmSince = null;
+    };
     if (this.nostrClient && this.status === "connected") {
       logger.debug("Nostr", "Identity changed while connected - recreating NostrClient");
       const oldClient = this.nostrClient;
-      this.nostrClient = new import_nostr_js_sdk.NostrClient(this.keyManager, {
+      const nextClient = new import_nostr_js_sdk.NostrClient(nextKeyManager, {
         autoReconnect: this.config.autoReconnect,
         reconnectIntervalMs: this.config.reconnectDelay,
         maxReconnectIntervalMs: this.config.reconnectDelay * 16,
@@ -1530,7 +1732,7 @@ var NostrTransportProvider = class _NostrTransportProvider {
         queryTimeoutMs: 2e4
         // see same option above for rationale
       });
-      this.nostrClient.addConnectionListener({
+      nextClient.addConnectionListener({
         onConnect: (url) => {
           logger.debug("Nostr", "NostrClient connected to relay:", url);
         },
@@ -1544,18 +1746,43 @@ var NostrTransportProvider = class _NostrTransportProvider {
           logger.debug("Nostr", "NostrClient reconnected to relay:", url);
         }
       });
-      await Promise.race([
-        this.nostrClient.connect(...this.config.relays),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(
-            `Transport reconnection timed out after ${this.config.timeout}ms`
-          )), this.config.timeout)
-        )
-      ]);
-      await this.subscribeToEvents();
-      oldClient.disconnect();
+      try {
+        await this.connectWithDeadline(
+          nextClient,
+          `Transport reconnection timed out after ${this.config.timeout}ms`
+        );
+      } catch (error) {
+        try {
+          nextClient.disconnect();
+        } catch {
+        }
+        throw error;
+      }
+      if (this.nostrClient !== oldClient || this.status !== "connected") {
+        try {
+          nextClient.disconnect();
+        } catch {
+        }
+        throw new SphereError(
+          "Transport client changed or left the connected state during setIdentity - identity not applied",
+          "TRANSPORT_ERROR"
+        );
+      }
+      this.nostrClient = nextClient;
+      applyStagedIdentity();
+      try {
+        await this.subscribeToEvents();
+      } finally {
+        try {
+          oldClient.disconnect();
+        } catch {
+        }
+      }
     } else if (this.isConnected()) {
+      applyStagedIdentity();
       await this.subscribeToEvents();
+    } else {
+      applyStagedIdentity();
     }
   }
   setFallbackSince(sinceSeconds) {
@@ -2850,26 +3077,6 @@ var UnicityAggregatorProvider = class {
 var UnicityOracleProvider = UnicityAggregatorProvider;
 
 // assets/trustbase.ts
-var TRUSTBASE_TESTNET = {
-  version: 1,
-  networkId: 3,
-  epoch: 1,
-  epochStartRound: 1,
-  rootNodes: [
-    {
-      nodeId: "16Uiu2HAkyQRiA7pMgzgLj9GgaBJEJa8zmx9dzqUDa6WxQPJ82ghU",
-      sigKey: "0x039afb2acb65f5fbc272d8907f763d0a5d189aadc9b97afdcc5897ea4dd112e68b",
-      stake: 1
-    }
-  ],
-  quorumThreshold: 1,
-  stateHash: "",
-  changeRecordHash: "",
-  previousEntryHash: "",
-  signatures: {
-    "16Uiu2HAkyQRiA7pMgzgLj9GgaBJEJa8zmx9dzqUDa6WxQPJ82ghU": "0xf157c9fdd8a378e3ca70d354ccc4475ab2cd8de360127bc46b0aeab4b453a80f07fd9136a5843b60a8babaff23e20acc8879861f7651440a5e2829f7541b31f100"
-  }
-};
 var TRUSTBASE_TESTNET2 = {
   version: 1,
   networkId: 4,
@@ -2908,8 +3115,44 @@ var TRUSTBASE_TESTNET2 = {
     "16Uiu2HAmU5T1TqKyKkUB3sitWb431hVFfp9nqvaLgVagQF6ywLFF": "0x9f28f3e3c50d4bfdaf54d7290fbbe311fffb3be2281a1d211be56818fa43d06a2e9a81925e9d365e552c8b772c99285a686de1d9fb581920be7524c7a5d467a301"
   }
 };
-var TRUSTBASE_MAINNET = null;
-var TRUSTBASE_DEV = TRUSTBASE_TESTNET;
+var TRUSTBASE_MAINNET = {
+  version: 1,
+  networkId: 1,
+  epoch: 1,
+  epochStartRound: 1,
+  rootNodes: [
+    {
+      nodeId: "16Uiu2HAkvk4EpXoyh7SVLTX3TcsZkjbni5jY1sBgJ7qCEWfx1Gma",
+      sigKey: "0x03059e30b5c980ce92e2c6d4e14775838be91a6f0e993f3a4899ab459c4b5225f2",
+      stake: 1
+    },
+    {
+      nodeId: "16Uiu2HAmF9Mq9pH9yUTdao3TpJeFZY9oX9gyMqfxggVA4fNmzmXr",
+      sigKey: "0x03a514db8b17b1c79b4a6affeb5d88a129c4d5ff0f92c8f86c311971b0beb94335",
+      stake: 1
+    },
+    {
+      nodeId: "16Uiu2HAmLAHTSMvZ2apRRtBN9piYVhaK2i7sTMaQeSWSxsLh75TG",
+      sigKey: "0x02e5669b2daa5d1afccfe66603f7d3fe171ecbd7ed891487ab3683cdebc3c3cd8b",
+      stake: 1
+    },
+    {
+      nodeId: "16Uiu2HAmNNaWfK4RTTAq7Ap8w2yZUryrEejqmmGf44ogMaYEnkJ4",
+      sigKey: "0x03ffee964da8ca276d4fc1cf391929e6759db106ef1d0aea998154b51e5a7fb1b7",
+      stake: 1
+    }
+  ],
+  quorumThreshold: 3,
+  stateHash: "",
+  changeRecordHash: "",
+  previousEntryHash: "",
+  signatures: {
+    "16Uiu2HAkvk4EpXoyh7SVLTX3TcsZkjbni5jY1sBgJ7qCEWfx1Gma": "0xc2f1d67dbb47fe4dcf502301d8cd5021b8903c0d3385781653d09c703d566a3a3a4e59c75792b36f929e32564ddc14c40ef728c0bde5859774d08d802de2318c00",
+    "16Uiu2HAmF9Mq9pH9yUTdao3TpJeFZY9oX9gyMqfxggVA4fNmzmXr": "0x3e3ad3a7540daa0eded457e31d2ebcacfb354036798f49f63433d26c44857e76157e4abd36cbb1d39de8cdf6e1d33f88b250077d4347c3e5bf0f35a64f2d815300",
+    "16Uiu2HAmLAHTSMvZ2apRRtBN9piYVhaK2i7sTMaQeSWSxsLh75TG": "0x6101bd9df8ab87439d90b52cd74727bc8bf31dd74173c8f731ec3ea501d3d86556ba7c0e84643337959f3be0e448637c301e8e0b28196e780d4f2ff930d9062100",
+    "16Uiu2HAmNNaWfK4RTTAq7Ap8w2yZUryrEejqmmGf44ogMaYEnkJ4": "0xda13c777b832425e5cbd8d6e49eb08ddbde35c1e4a9bee8bd495c3883f039e434b64560865c3bc52b68d65780932b1f2bf8971f245d2244face822af5984945c00"
+  }
+};
 
 // impl/shared/trustbase-loader.ts
 function getEmbeddedTrustBase(network) {
@@ -2922,8 +3165,6 @@ function getEmbeddedTrustBase(network) {
     case "testnet":
     case "testnet2":
       return TRUSTBASE_TESTNET2;
-    case "dev":
-      return TRUSTBASE_DEV;
     default:
       throw new SphereError(`getEmbeddedTrustBase: unknown network "${network}"`, "INVALID_CONFIG");
   }
@@ -3080,6 +3321,7 @@ async function readFileAsUint8Array(file) {
 
 // impl/shared/network.ts
 var EXPECTED_NETWORK_ID = {
+  mainnet: 1,
   // v1 cutover: 'testnet' is an alias of testnet2 (the v2 gateway network),
   // so both expect the testnet2 trust base (networkId 4).
   testnet: 4,
@@ -3100,7 +3342,7 @@ function assertNetworkConsistency(network) {
     );
   }
   const expected = EXPECTED_NETWORK_ID[network];
-  if (expected !== void 0 && networkId !== expected) {
+  if (networkId !== expected) {
     throw new SphereError(
       `Network "${network}" trust base networkId ${networkId} does not match expected ${expected} (wrong trust base wired to this network).`,
       "INVALID_CONFIG"
@@ -3365,419 +3607,6 @@ function createPriceProvider(config) {
   }
 }
 
-// registry/TokenRegistry.ts
-var FETCH_TIMEOUT_MS = 1e4;
-var TokenRegistry = class _TokenRegistry {
-  static instance = null;
-  definitionsById;
-  definitionsBySymbol;
-  definitionsByName;
-  // Remote refresh state
-  remoteUrl = null;
-  storage = null;
-  refreshIntervalMs = TOKEN_REGISTRY_REFRESH_INTERVAL;
-  refreshTimer = null;
-  lastRefreshAt = 0;
-  refreshPromise = null;
-  initialLoadPromise = null;
-  constructor() {
-    this.definitionsById = /* @__PURE__ */ new Map();
-    this.definitionsBySymbol = /* @__PURE__ */ new Map();
-    this.definitionsByName = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Get singleton instance of TokenRegistry
-   */
-  static getInstance() {
-    if (!_TokenRegistry.instance) {
-      _TokenRegistry.instance = new _TokenRegistry();
-    }
-    return _TokenRegistry.instance;
-  }
-  /**
-   * Configure remote registry refresh with persistent caching.
-   *
-   * On first call:
-   * 1. Loads cached data from StorageProvider (if available and fresh)
-   * 2. Starts periodic remote fetch (if autoRefresh is true, which is default)
-   *
-   * @param options - Configuration options
-   * @param options.remoteUrl - Remote URL to fetch definitions from
-   * @param options.storage - StorageProvider for persistent caching
-   * @param options.refreshIntervalMs - Refresh interval in ms (default: 1 hour)
-   * @param options.autoRefresh - Start auto-refresh immediately (default: true)
-   */
-  static configure(options) {
-    const instance = _TokenRegistry.getInstance();
-    if (options.remoteUrl !== void 0) {
-      instance.remoteUrl = options.remoteUrl;
-    }
-    if (options.storage !== void 0) {
-      instance.storage = options.storage;
-    }
-    if (options.refreshIntervalMs !== void 0) {
-      instance.refreshIntervalMs = options.refreshIntervalMs;
-    }
-    const autoRefresh = options.autoRefresh ?? true;
-    instance.initialLoadPromise = instance.performInitialLoad(autoRefresh);
-  }
-  /**
-   * Reset the singleton instance (useful for testing).
-   * Stops auto-refresh if running.
-   */
-  static resetInstance() {
-    if (_TokenRegistry.instance) {
-      _TokenRegistry.instance.stopAutoRefresh();
-    }
-    _TokenRegistry.instance = null;
-  }
-  /**
-   * Destroy the singleton: stop auto-refresh and reset.
-   */
-  static destroy() {
-    _TokenRegistry.resetInstance();
-  }
-  /**
-   * Wait for the initial data load (cache or remote) to complete.
-   * Returns true if data was loaded, false if not (timeout or no data source).
-   *
-   * @param timeoutMs - Maximum wait time in ms (default: 10s). Set to 0 for no timeout.
-   */
-  static async waitForReady(timeoutMs = 1e4) {
-    const instance = _TokenRegistry.getInstance();
-    if (!instance.initialLoadPromise) {
-      return instance.definitionsById.size > 0;
-    }
-    if (timeoutMs <= 0) {
-      return instance.initialLoadPromise;
-    }
-    return Promise.race([
-      instance.initialLoadPromise,
-      new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs))
-    ]);
-  }
-  // ===========================================================================
-  // Initial Load
-  // ===========================================================================
-  /**
-   * Perform initial data load: try cache first, fall back to remote fetch.
-   * After initial data is available, start periodic auto-refresh if configured.
-   */
-  async performInitialLoad(autoRefresh) {
-    let loaded = false;
-    if (this.storage) {
-      loaded = await this.loadFromCache();
-    }
-    if (loaded) {
-      if (autoRefresh && this.remoteUrl) {
-        this.startAutoRefresh();
-      }
-      return true;
-    }
-    if (autoRefresh && this.remoteUrl) {
-      loaded = await this.refreshFromRemote();
-      this.stopAutoRefresh();
-      this.refreshTimer = setInterval(() => {
-        this.refreshFromRemote();
-      }, this.refreshIntervalMs);
-      return loaded;
-    }
-    return false;
-  }
-  // ===========================================================================
-  // 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).
-   */
-  async loadFromCache() {
-    if (!this.storage) return false;
-    try {
-      const { data: dataKey, ts: tsKey } = this.cacheKeys();
-      const [cached, cachedTs] = await Promise.all([
-        this.storage.get(dataKey),
-        this.storage.get(tsKey)
-      ]);
-      if (!cached || !cachedTs) return false;
-      const ts = parseInt(cachedTs, 10);
-      if (isNaN(ts)) return false;
-      const age = Date.now() - ts;
-      if (age > this.refreshIntervalMs) return false;
-      if (this.lastRefreshAt > ts) return false;
-      const data = JSON.parse(cached);
-      if (!this.isValidDefinitionsArray(data)) return false;
-      this.applyDefinitions(data);
-      this.lastRefreshAt = ts;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Save definitions to StorageProvider cache.
-   */
-  async saveToCache(definitions) {
-    if (!this.storage) return;
-    try {
-      const { data: dataKey, ts: tsKey } = this.cacheKeys();
-      await Promise.all([
-        this.storage.set(dataKey, JSON.stringify(definitions)),
-        this.storage.set(tsKey, String(Date.now()))
-      ]);
-    } catch {
-    }
-  }
-  // ===========================================================================
-  // Remote Refresh
-  // ===========================================================================
-  /**
-   * Apply an array of token definitions to the internal maps.
-   * Clears existing data before applying.
-   */
-  applyDefinitions(definitions) {
-    this.definitionsById.clear();
-    this.definitionsBySymbol.clear();
-    this.definitionsByName.clear();
-    for (const def of definitions) {
-      const idLower = def.id.toLowerCase();
-      this.definitionsById.set(idLower, def);
-      if (def.symbol) {
-        this.definitionsBySymbol.set(def.symbol.toUpperCase(), def);
-      }
-      this.definitionsByName.set(def.name.toLowerCase(), def);
-    }
-  }
-  /**
-   * Validate that data is an array of objects with 'id' field
-   */
-  isValidDefinitionsArray(data) {
-    return Array.isArray(data) && data.every((item) => item && typeof item === "object" && "id" in item);
-  }
-  /**
-   * Fetch token definitions from the remote URL and update the registry.
-   * On success, also persists to StorageProvider cache.
-   * Returns true on success, false on failure. On failure, existing data is preserved.
-   * Concurrent calls are deduplicated — only one fetch runs at a time.
-   */
-  async refreshFromRemote() {
-    if (!this.remoteUrl) {
-      return false;
-    }
-    if (this.refreshPromise) {
-      return this.refreshPromise;
-    }
-    this.refreshPromise = this.doRefresh();
-    try {
-      return await this.refreshPromise;
-    } finally {
-      this.refreshPromise = null;
-    }
-  }
-  async doRefresh() {
-    try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-      let response;
-      try {
-        response = await fetch(this.remoteUrl, {
-          headers: { Accept: "application/json" },
-          signal: controller.signal
-        });
-      } finally {
-        clearTimeout(timer);
-      }
-      if (!response.ok) {
-        logger.warn("TokenRegistry", `Remote fetch failed: HTTP ${response.status} ${response.statusText}`);
-        return false;
-      }
-      const data = await response.json();
-      if (!this.isValidDefinitionsArray(data)) {
-        logger.warn("TokenRegistry", "Remote data is not a valid token definitions array");
-        return false;
-      }
-      const definitions = data;
-      this.applyDefinitions(definitions);
-      this.lastRefreshAt = Date.now();
-      this.saveToCache(definitions);
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.warn("TokenRegistry", `Remote refresh failed: ${message}`);
-      return false;
-    }
-  }
-  /**
-   * Start periodic auto-refresh from the remote URL.
-   * Does an immediate fetch, then repeats at the configured interval.
-   */
-  startAutoRefresh(intervalMs) {
-    this.stopAutoRefresh();
-    if (intervalMs !== void 0) {
-      this.refreshIntervalMs = intervalMs;
-    }
-    this.refreshFromRemote();
-    this.refreshTimer = setInterval(() => {
-      this.refreshFromRemote();
-    }, this.refreshIntervalMs);
-  }
-  /**
-   * Stop periodic auto-refresh
-   */
-  stopAutoRefresh() {
-    if (this.refreshTimer !== null) {
-      clearInterval(this.refreshTimer);
-      this.refreshTimer = null;
-    }
-  }
-  /**
-   * Timestamp of the last successful remote refresh (0 if never refreshed)
-   */
-  getLastRefreshAt() {
-    return this.lastRefreshAt;
-  }
-  // ===========================================================================
-  // Lookup Methods
-  // ===========================================================================
-  /**
-   * Get token definition by hex coin ID
-   * @param coinId - 64-character hex string
-   * @returns Token definition or undefined if not found
-   */
-  getDefinition(coinId) {
-    if (!coinId) return void 0;
-    return this.definitionsById.get(coinId.toLowerCase());
-  }
-  /**
-   * Get token definition by symbol (e.g., "UCT", "BTC")
-   * @param symbol - Token symbol (case-insensitive)
-   * @returns Token definition or undefined if not found
-   */
-  getDefinitionBySymbol(symbol) {
-    if (!symbol) return void 0;
-    return this.definitionsBySymbol.get(symbol.toUpperCase());
-  }
-  /**
-   * Get token definition by name (e.g., "bitcoin", "ethereum")
-   * @param name - Token name (case-insensitive)
-   * @returns Token definition or undefined if not found
-   */
-  getDefinitionByName(name) {
-    if (!name) return void 0;
-    return this.definitionsByName.get(name.toLowerCase());
-  }
-  /**
-   * Get token symbol for a coin ID
-   * @param coinId - 64-character hex string
-   * @returns Symbol (e.g., "UCT") or truncated ID if not found
-   */
-  getSymbol(coinId) {
-    const def = this.getDefinition(coinId);
-    if (def?.symbol) {
-      return def.symbol;
-    }
-    return coinId.slice(0, 6).toUpperCase();
-  }
-  /**
-   * Get token name for a coin ID
-   * @param coinId - 64-character hex string
-   * @returns Name (e.g., "Bitcoin") or coin ID if not found
-   */
-  getName(coinId) {
-    const def = this.getDefinition(coinId);
-    if (def?.name) {
-      return def.name.charAt(0).toUpperCase() + def.name.slice(1);
-    }
-    return coinId;
-  }
-  /**
-   * Get decimal places for a coin ID
-   * @param coinId - 64-character hex string
-   * @returns Decimals or 0 if not found
-   */
-  getDecimals(coinId) {
-    const def = this.getDefinition(coinId);
-    return def?.decimals ?? 0;
-  }
-  /**
-   * Get icon URL for a coin ID
-   * @param coinId - 64-character hex string
-   * @param preferPng - Prefer PNG format over SVG
-   * @returns Icon URL or null if not found
-   */
-  getIconUrl(coinId, preferPng = true) {
-    const def = this.getDefinition(coinId);
-    if (!def?.icons || def.icons.length === 0) {
-      return null;
-    }
-    if (preferPng) {
-      const pngIcon = def.icons.find((i) => i.url.toLowerCase().includes(".png"));
-      if (pngIcon) return pngIcon.url;
-    }
-    return def.icons[0].url;
-  }
-  /**
-   * Check if a coin ID is known in the registry
-   * @param coinId - 64-character hex string
-   * @returns true if the coin is in the registry
-   */
-  isKnown(coinId) {
-    return this.definitionsById.has(coinId.toLowerCase());
-  }
-  /**
-   * Get all token definitions
-   * @returns Array of all token definitions
-   */
-  getAllDefinitions() {
-    return Array.from(this.definitionsById.values());
-  }
-  /**
-   * Get all fungible token definitions
-   * @returns Array of fungible token definitions
-   */
-  getFungibleTokens() {
-    return this.getAllDefinitions().filter((def) => def.assetKind === "fungible");
-  }
-  /**
-   * Get all non-fungible token definitions
-   * @returns Array of non-fungible token definitions
-   */
-  getNonFungibleTokens() {
-    return this.getAllDefinitions().filter((def) => def.assetKind === "non-fungible");
-  }
-  /**
-   * Get coin ID by symbol
-   * @param symbol - Token symbol (e.g., "UCT")
-   * @returns Coin ID hex string or undefined if not found
-   */
-  getCoinIdBySymbol(symbol) {
-    const def = this.getDefinitionBySymbol(symbol);
-    return def?.id;
-  }
-  /**
-   * Get coin ID by name
-   * @param name - Token name (e.g., "bitcoin")
-   * @returns Coin ID hex string or undefined if not found
-   */
-  getCoinIdByName(name) {
-    const def = this.getDefinitionByName(name);
-    return def?.id;
-  }
-};
-
 // impl/shared/resolvers.ts
 function getNetworkConfig(network = "mainnet") {
   return NETWORKS[network];
@@ -3871,8 +3700,6 @@ function createBrowserProviders(config) {
   const priceConfig = resolvePriceConfig(config?.price, storage);
   const groupChat = resolveGroupChatConfig(network, config?.groupChat);
   const market = resolveMarketConfig(config?.market);
-  const networkConfig = getNetworkConfig(network);
-  TokenRegistry.configure({ remoteUrl: networkConfig.tokenRegistryUrl, storage });
   return {
     storage,
     groupChat,