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

package/dist/impl/nodejs/index.cjs

@@ -2631,9 +2631,9 @@ var require_dispatcher_base = __commonJS({
       }
       close(callback) {
         if (callback === void 0) {
-          return new Promise((resolve, reject) => {
+          return new Promise((resolve2, reject) => {
             this.close((err, data) => {
-              return err ? reject(err) : resolve(data);
+              return err ? reject(err) : resolve2(data);
             });
           });
         }
@@ -2671,9 +2671,9 @@ var require_dispatcher_base = __commonJS({
           err = null;
         }
         if (callback === void 0) {
-          return new Promise((resolve, reject) => {
+          return new Promise((resolve2, reject) => {
             this.destroy(err, (err2, data) => {
-              return err2 ? reject(err2) : resolve(data);
+              return err2 ? reject(err2) : resolve2(data);
             });
           });
         }
@@ -6127,8 +6127,8 @@ var require_promise = __commonJS({
     function createDeferredPromise() {
       let res;
       let rej;
-      const promise = new Promise((resolve, reject) => {
-        res = resolve;
+      const promise = new Promise((resolve2, reject) => {
+        res = resolve2;
         rej = reject;
       });
       return { promise, resolve: res, reject: rej };
@@ -7435,12 +7435,12 @@ upgrade: ${upgrade}\r
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve, reject) => {
+      const waitForDrain = () => new Promise((resolve2, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve;
+          callback = resolve2;
         }
       });
       socket.on("close", onDrain).on("drain", onDrain);
@@ -8252,12 +8252,12 @@ var require_client_h2 = __commonJS({
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve, reject) => {
+      const waitForDrain = () => new Promise((resolve2, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve;
+          callback = resolve2;
         }
       });
       h2stream.on("close", onDrain).on("drain", onDrain);
@@ -8559,16 +8559,16 @@ var require_client = __commonJS({
         return this[kNeedDrain] < 2;
       }
       [kClose]() {
-        return new Promise((resolve) => {
+        return new Promise((resolve2) => {
           if (this[kSize]) {
-            this[kClosedResolve] = resolve;
+            this[kClosedResolve] = resolve2;
           } else {
-            resolve(null);
+            resolve2(null);
           }
         });
       }
       [kDestroy](err) {
-        return new Promise((resolve) => {
+        return new Promise((resolve2) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i = 0; i < requests.length; i++) {
             const request = requests[i];
@@ -8579,7 +8579,7 @@ var require_client = __commonJS({
               this[kClosedResolve]();
               this[kClosedResolve] = null;
             }
-            resolve(null);
+            resolve2(null);
           };
           if (this[kHTTPContext]) {
             this[kHTTPContext].destroy(err, callback);
@@ -8970,8 +8970,8 @@ var require_pool_base = __commonJS({
           }
           return Promise.all(closeAll);
         } else {
-          return new Promise((resolve) => {
-            this[kClosedResolve] = resolve;
+          return new Promise((resolve2) => {
+            this[kClosedResolve] = resolve2;
           });
         }
       }
@@ -10500,7 +10500,7 @@ var require_readable = __commonJS({
         if (this._readableState.closeEmitted) {
           return Promise.resolve(null);
         }
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           if (this[kContentLength] && this[kContentLength] > limit || this[kBytesRead] > limit) {
             this.destroy(new AbortError());
           }
@@ -10514,11 +10514,11 @@ var require_readable = __commonJS({
               if (signal.aborted) {
                 reject(signal.reason ?? new AbortError());
               } else {
-                resolve(null);
+                resolve2(null);
               }
             });
           } else {
-            this.on("close", resolve);
+            this.on("close", resolve2);
           }
           this.on("error", noop).on("data", () => {
             if (this[kBytesRead] > limit) {
@@ -10546,7 +10546,7 @@ var require_readable = __commonJS({
     }
     function consume(stream, type) {
       assert(!stream[kConsume]);
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         if (isUnusable(stream)) {
           const rState = stream._readableState;
           if (rState.destroyed && rState.closeEmitted === false) {
@@ -10561,7 +10561,7 @@ var require_readable = __commonJS({
             stream[kConsume] = {
               type,
               stream,
-              resolve,
+              resolve: resolve2,
               reject,
               length: 0,
               body: []
@@ -10635,18 +10635,18 @@ var require_readable = __commonJS({
       return buffer;
     }
     function consumeEnd(consume2, encoding) {
-      const { type, body, resolve, stream, length } = consume2;
+      const { type, body, resolve: resolve2, stream, length } = consume2;
       try {
         if (type === "text") {
-          resolve(chunksDecode(body, length, encoding));
+          resolve2(chunksDecode(body, length, encoding));
         } else if (type === "json") {
-          resolve(JSON.parse(chunksDecode(body, length, encoding)));
+          resolve2(JSON.parse(chunksDecode(body, length, encoding)));
         } else if (type === "arrayBuffer") {
-          resolve(chunksConcat(body, length).buffer);
+          resolve2(chunksConcat(body, length).buffer);
         } else if (type === "blob") {
-          resolve(new Blob(body, { type: stream[kContentType] }));
+          resolve2(new Blob(body, { type: stream[kContentType] }));
         } else if (type === "bytes") {
-          resolve(chunksConcat(body, length));
+          resolve2(chunksConcat(body, length));
         }
         consumeFinish(consume2);
       } catch (err) {
@@ -10835,9 +10835,9 @@ var require_api_request = __commonJS({
     };
     function request(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           request.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve(data);
+            return err ? reject(err) : resolve2(data);
           });
         });
       }
@@ -11049,9 +11049,9 @@ var require_api_stream = __commonJS({
     };
     function stream(opts, factory, callback) {
       if (callback === void 0) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           stream.call(this, opts, factory, (err, data) => {
-            return err ? reject(err) : resolve(data);
+            return err ? reject(err) : resolve2(data);
           });
         });
       }
@@ -11339,9 +11339,9 @@ var require_api_upgrade = __commonJS({
     };
     function upgrade(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           upgrade.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve(data);
+            return err ? reject(err) : resolve2(data);
           });
         });
       }
@@ -11434,9 +11434,9 @@ var require_api_connect = __commonJS({
     };
     function connect(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           connect.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve(data);
+            return err ? reject(err) : resolve2(data);
           });
         });
       }
@@ -12684,7 +12684,7 @@ var require_snapshot_recorder = __commonJS({
   "node_modules/undici/lib/mock/snapshot-recorder.js"(exports2, module2) {
     "use strict";
     var { writeFile, readFile, mkdir } = require("fs/promises");
-    var { dirname, resolve } = require("path");
+    var { dirname, resolve: resolve2 } = require("path");
     var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = require("timers");
     var { InvalidArgumentError, UndiciError } = require_errors();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -12885,7 +12885,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile(resolve(path2), "utf8");
+          const data = await readFile(resolve2(path2), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -12914,7 +12914,7 @@ var require_snapshot_recorder = __commonJS({
         if (!path2) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
-        const resolvedPath = resolve(path2);
+        const resolvedPath = resolve2(path2);
         await mkdir(dirname(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
@@ -19471,7 +19471,7 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url = requestCurrentURL(request);
         const agent = fetchParams.controller.dispatcher;
-        return new Promise((resolve, reject) => agent.dispatch(
+        return new Promise((resolve2, reject) => agent.dispatch(
           {
             path: url.pathname + url.search,
             origin: url.origin,
@@ -19551,7 +19551,7 @@ var require_fetch = __commonJS({
                 }
               }
               const onError = this.onError.bind(this);
-              resolve({
+              resolve2({
                 status,
                 statusText,
                 headersList,
@@ -19594,7 +19594,7 @@ var require_fetch = __commonJS({
               for (let i = 0; i < rawHeaders.length; i += 2) {
                 headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true);
               }
-              resolve({
+              resolve2({
                 status,
                 statusText: STATUS_CODES[status],
                 headersList,
@@ -23689,7 +23689,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"
@@ -23702,13 +23701,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"
 ];
@@ -23718,10 +23713,19 @@ 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
@@ -23745,19 +23749,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 = {
@@ -23773,11 +23768,98 @@ var TIMEOUTS = {
   SYNC_INTERVAL: 6e4
 };
 
+// core/errors.ts
+var SphereError = class extends Error {
+  code;
+  cause;
+  /**
+   * #441 deferred-paid linkage: the transferId of the possibly-committed send,
+   * stamped by `sendOnce` before the error leaves so a payment-request consumer
+   * can durably journal request→transfer and resolve 'paid' only when that
+   * transfer actually completes (never optimistically). Present ONLY on
+   * possibly-committed outcomes ({@link isPossiblyCommittedSendOutcome}).
+   */
+  transferId;
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "SphereError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+
+// 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/nodejs/storage/FileStorageProvider.ts
 var FileStorageProvider = class {
   id = "file-storage";
   name = "File Storage";
   type = "local";
+  /** The resolved wallet file — two providers over one path share erasure (#766). */
+  backingStoreId;
   dataDir;
   filePath;
   isTxtMode;
@@ -23787,14 +23869,15 @@ var FileStorageProvider = class {
   _identity = null;
   constructor(config) {
     if (typeof config === "string") {
-      this.dataDir = config;
-      this.filePath = path.join(config, "wallet.json");
+      this.dataDir = path.resolve(config);
+      this.filePath = path.join(this.dataDir, "wallet.json");
     } else {
-      this.dataDir = config.dataDir;
-      this.filePath = path.join(config.dataDir, config.fileName ?? "wallet.json");
+      this.dataDir = path.resolve(config.dataDir);
+      this.filePath = path.join(this.dataDir, config.fileName ?? "wallet.json");
       this.network = config.network;
     }
     this.isTxtMode = this.filePath.endsWith(".txt");
+    this.backingStoreId = `file:${this.filePath}`;
   }
   setIdentity(identity) {
     this._identity = identity;
@@ -23891,18 +23974,40 @@ var FileStorageProvider = class {
     }
     await this.save();
   }
+  /** Serializes the read-merge-write below, per provider instance. */
+  trackedWrites = Promise.resolve();
+  /**
+   * 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). Concurrent
+   * calls are serialized on `trackedWrites` so a read can never interleave
+   * with another call's write.
+   *
+   * Deliberately PER OBJECT, unlike the browser providers. Two objects over one
+   * `dataDir` share a `backingStoreId` but not this cache, and `save()` rewrites the
+   * WHOLE file from it — so a sibling's *unrelated* `set()` rolls the registry back
+   * regardless of how this one write is serialized. Sharing the chain here would make
+   * the cross-object contract case pass while leaving the provider unsafe. The real
+   * fix is #771 (refresh from disk under a per-file lock, on every write); until then
+   * `backingStoreId` scopes TEARDOWN only. Reviewers keep re-finding this — see the
+   * `unsupported:` note in tests/unit/storage/tracked-addresses-providers.test.ts.
+   */
   async saveTrackedAddresses(entries) {
-    await this.set(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES, JSON.stringify({ version: 1, addresses: entries }));
+    const run = this.trackedWrites.then(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));
+    });
+    this.trackedWrites = run.then(() => void 0, () => void 0);
+    await run;
   }
   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));
   }
   /**
    * Get full storage key with address prefix for per-address keys
@@ -24421,26 +24526,6 @@ var logger = {
   }
 };
 
-// core/errors.ts
-var SphereError = class extends Error {
-  code;
-  cause;
-  /**
-   * #441 deferred-paid linkage: the transferId of the possibly-committed send,
-   * stamped by `sendOnce` before the error leaves so a payment-request consumer
-   * can durably journal request→transfer and resolve 'paid' only when that
-   * transfer actually completes (never optimistically). Present ONLY on
-   * possibly-committed outcomes ({@link isPossiblyCommittedSendOutcome}).
-   */
-  transferId;
-  constructor(message, code, cause) {
-    super(message);
-    this.name = "SphereError";
-    this.code = code;
-    this.cause = cause;
-  }
-};
-
 // transport/websocket.ts
 function defaultUUIDGenerator() {
   if (typeof crypto !== "undefined" && crypto.randomUUID) {
@@ -24613,14 +24698,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");
       }
@@ -24635,6 +24716,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();
@@ -24753,19 +24855,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,
@@ -24774,7 +24879,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);
         },
@@ -24788,18 +24893,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) {
@@ -25566,14 +25696,14 @@ var NostrTransportProvider = class _NostrTransportProvider {
     const client = this.nostrClient;
     const events = [];
     let subId;
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       let timeout;
       let settled = false;
       const settle = () => {
         if (settled) return;
         settled = true;
         clearTimeout(timeout);
-        resolve();
+        resolve2();
       };
       try {
         subId = client.subscribe(walletFilter, {
@@ -25616,7 +25746,7 @@ var NostrTransportProvider = class _NostrTransportProvider {
     const events = [];
     const filter = new import_nostr_js_sdk.Filter(filterObj);
     let subId;
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let settled = false;
       const timeout = setTimeout(() => {
         if (settled) return;
@@ -25628,7 +25758,7 @@ var NostrTransportProvider = class _NostrTransportProvider {
           }
         }
         logger.warn("Nostr", `queryEvents timed out after 15s, returning ${events.length} event(s)`, { kinds: filterObj.kinds, limit: filterObj.limit });
-        resolve(events);
+        resolve2(events);
       }, 15e3);
       const settle = () => {
         if (settled) return;
@@ -25640,7 +25770,7 @@ var NostrTransportProvider = class _NostrTransportProvider {
           } catch {
           }
         }
-        resolve(events);
+        resolve2(events);
       };
       try {
         subId = client.subscribe(filter, {
@@ -25659,7 +25789,7 @@ var NostrTransportProvider = class _NostrTransportProvider {
         });
       } catch {
         clearTimeout(timeout);
-        resolve(events);
+        resolve2(events);
         return;
       }
     });
@@ -26099,26 +26229,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,
@@ -26157,8 +26267,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) {
@@ -26171,8 +26317,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");
   }
@@ -26268,6 +26412,7 @@ function createWalletApiProviders(base, config) {
 
 // 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,
@@ -26288,7 +26433,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"
@@ -26553,419 +26698,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];
@@ -27057,8 +26789,7 @@ function createNodeProviders(config) {
   }
   const network = config.network;
   assertNetworkConsistency(network);
-  const globalDebug = config?.debug ?? false;
-  logger.configure({ debug: globalDebug });
+  if (config?.debug !== void 0) logger.configure({ debug: config.debug });
   if (config?.transport?.debug) logger.setTagDebug("Nostr", true);
   if (config?.oracle?.debug) logger.setTagDebug("Aggregator", true);
   if (config?.price?.debug) logger.setTagDebug("Price", true);
@@ -27072,8 +26803,6 @@ function createNodeProviders(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,