@unicitylabs/sphere-sdk 0.2.2 → 0.2.3

package/README.md

@@ -152,7 +152,7 @@ const providers = createBrowserProviders({
   oracle: { url: 'https://custom-aggregator.example.com' }, // custom oracle
 });
 
-// Enable L1 with network defaults
+// L1 is enabled by default — customize if needed
 const providers = createBrowserProviders({
   network: 'testnet',
   l1: { enableVesting: true },  // uses testnet electrum URL automatically
@@ -332,17 +332,20 @@ sphere.payments.onPaymentRequest((request) => {
 Access L1 payments through `sphere.payments.l1`:
 
 ```typescript
-// L1 configuration is optional (has defaults)
+// L1 is enabled by default with lazy Fulcrum connection.
+// Connection to Fulcrum is deferred until first L1 operation.
 const { sphere } = await Sphere.init({
   ...providers,
   autoGenerate: true,
-  l1: {
-    electrumUrl: 'wss://fulcrum.alpha.unicity.network:50004',  // default
-    defaultFeeRate: 10,  // sat/byte, default
-    enableVesting: true, // default
-  },
+  // L1 config is optional — defaults are applied automatically:
+  // electrumUrl: network-specific (mainnet: fulcrum.alpha.unicity.network)
+  // defaultFeeRate: 10 sat/byte
+  // enableVesting: true
 });
 
+// To explicitly disable L1:
+// const { sphere } = await Sphere.init({ ...providers, l1: null });
+
 // Get L1 balance
 const balance = await sphere.payments.l1.getBalance();
 console.log('L1 Balance:', balance.total);
@@ -847,14 +850,6 @@ const providers = createBrowserProviders({
   },
 });
 
-// Enable multiple sync backends
-const providers = createBrowserProviders({
-  network: 'mainnet',
-  tokenSync: {
-    ipfs: { enabled: true, useDht: true },
-    cloud: { enabled: true, provider: 'aws', bucket: 'my-backup' },  // future
-  },
-});
 ```
 
 ## Token Sync Backends
@@ -864,7 +859,7 @@ The SDK supports multiple token sync backends that can be enabled independently:
 | Backend | Status | Description |
 |---------|--------|-------------|
 | `ipfs` | ✅ Ready | Decentralized IPFS/IPNS with Helia browser DHT |
-| `mongodb` | ✅ Ready | MongoDB for centralized token storage |
+| `mongodb` | 🚧 Planned | MongoDB for centralized token storage |
 | `file` | 🚧 Planned | Local file system (Node.js) |
 | `cloud` | 🚧 Planned | Cloud storage (AWS S3, GCP, Azure) |
 
@@ -880,29 +875,6 @@ const providers = createBrowserProviders({
     },
   },
 });
-
-// Enable MongoDB sync
-const providers = createBrowserProviders({
-  network: 'mainnet',
-  tokenSync: {
-    mongodb: {
-      enabled: true,
-      uri: 'mongodb://localhost:27017',
-      database: 'sphere_wallet',
-      collection: 'tokens',
-    },
-  },
-});
-
-// Multiple backends for redundancy
-const providers = createBrowserProviders({
-  tokenSync: {
-    ipfs: { enabled: true },
-    mongodb: { enabled: true, uri: 'mongodb://localhost:27017', database: 'wallet' },
-    file: { enabled: true, directory: './tokens', format: 'txf' },
-    cloud: { enabled: true, provider: 'aws', bucket: 'wallet-backup' },
-  },
-});
 ```
 
 ## Custom Token Storage Provider
@@ -985,32 +957,32 @@ const { sphere } = await Sphere.init({
 
 ## Dynamic Provider Management (Runtime)
 
-After `Sphere.init()` is called, you can add/remove token storage providers dynamically through UI:
+After `Sphere.init()` is called, you can add/remove token storage providers dynamically:
 
 ```typescript
-import { createMongoDbStorageProvider } from './my-mongodb-provider';
+import { createIpfsStorageProvider } from '@unicitylabs/sphere-sdk/impl/browser/ipfs';
 
-// Add a new provider at runtime (e.g., user enables MongoDB sync in settings)
-const mongoProvider = createMongoDbStorageProvider({
-  uri: 'mongodb://localhost:27017',
-  database: 'sphere_wallet',
+// Add a new provider at runtime (e.g., user enables IPFS sync in settings)
+const ipfsProvider = createIpfsStorageProvider({
+  gateways: ['https://ipfs.io'],
+  useDht: true,
 });
 
-await sphere.addTokenStorageProvider(mongoProvider);
+await sphere.addTokenStorageProvider(ipfsProvider);
 
 // Provider is now active and will be used in sync operations
 
 // Check if provider exists
-if (sphere.hasTokenStorageProvider('mongodb-token-storage')) {
-  console.log('MongoDB sync is enabled');
+if (sphere.hasTokenStorageProvider('ipfs-token-storage')) {
+  console.log('IPFS sync is enabled');
 }
 
 // Get all active providers
 const providers = sphere.getTokenStorageProviders();
 console.log('Active providers:', Array.from(providers.keys()));
 
-// Remove a provider (e.g., user disables MongoDB sync)
-await sphere.removeTokenStorageProvider('mongodb-token-storage');
+// Remove a provider (e.g., user disables IPFS sync)
+await sphere.removeTokenStorageProvider('ipfs-token-storage');
 
 // Listen for per-provider sync events
 sphere.on('sync:provider', (event) => {
@@ -1026,25 +998,6 @@ sphere.on('sync:provider', (event) => {
 await sphere.payments.sync();
 ```
 
-### Multiple Providers Example
-
-```typescript
-// User configures multiple sync backends via UI
-const ipfsProvider = createIpfsStorageProvider({ gateways: ['https://ipfs.io'] });
-const mongoProvider = createMongoDbStorageProvider({ uri: 'mongodb://...' });
-const s3Provider = createS3StorageProvider({ bucket: 'wallet-backup' });
-
-// Add all providers
-await sphere.addTokenStorageProvider(ipfsProvider);
-await sphere.addTokenStorageProvider(mongoProvider);
-await sphere.addTokenStorageProvider(s3Provider);
-
-// Sync syncs with ALL active providers
-// If one fails, others continue (fault-tolerant)
-const result = await sphere.payments.sync();
-console.log(`Synced: +${result.added} -${result.removed}`);
-```
-
 ## Dynamic Relay Management
 
 Nostr relays can be added or removed at runtime through the transport provider:

package/dist/core/index.cjs

@@ -1553,7 +1553,7 @@ var L1PaymentsModule = class {
   _transport;
   constructor(config) {
     this._config = {
-      electrumUrl: config?.electrumUrl ?? "wss://fulcrum.alpha.unicity.network:50004",
+      electrumUrl: config?.electrumUrl ?? "wss://fulcrum.unicity.network:50004",
       network: config?.network ?? "mainnet",
       defaultFeeRate: config?.defaultFeeRate ?? 10,
       enableVesting: config?.enableVesting ?? true
@@ -1585,10 +1585,17 @@ var L1PaymentsModule = class {
         });
       }
     }
-    if (this._config.electrumUrl) {
+    this._initialized = true;
+  }
+  /**
+   * Ensure the Fulcrum WebSocket is connected. Called lazily before any
+   * operation that needs the network. If the singleton is already connected
+   * (e.g. by the address scanner), this is a no-op.
+   */
+  async ensureConnected() {
+    if (!isWebSocketConnected() && this._config.electrumUrl) {
       await connect(this._config.electrumUrl);
     }
-    this._initialized = true;
   }
   destroy() {
     if (isWebSocketConnected()) {
@@ -1646,6 +1653,7 @@ var L1PaymentsModule = class {
   }
   async send(request) {
     this.ensureInitialized();
+    await this.ensureConnected();
     if (!this._wallet || !this._identity) {
       return { success: false, error: "No wallet available" };
     }
@@ -1680,6 +1688,7 @@ var L1PaymentsModule = class {
   }
   async getBalance() {
     this.ensureInitialized();
+    await this.ensureConnected();
     const addresses = this._getWatchedAddresses();
     let totalAlpha = 0;
     let vestedSats = BigInt(0);
@@ -1711,6 +1720,7 @@ var L1PaymentsModule = class {
   }
   async getUtxos() {
     this.ensureInitialized();
+    await this.ensureConnected();
     const result = [];
     const currentHeight = await getCurrentBlockHeight();
     const allUtxos = await this._getAllUtxos();
@@ -1746,42 +1756,73 @@ var L1PaymentsModule = class {
     return result;
   }
   async getHistory(limit) {
+    await this.ensureConnected();
     this.ensureInitialized();
     const addresses = this._getWatchedAddresses();
     const transactions = [];
     const seenTxids = /* @__PURE__ */ new Set();
     const currentHeight = await getCurrentBlockHeight();
+    const txCache = /* @__PURE__ */ new Map();
+    const fetchTx = async (txid) => {
+      if (txCache.has(txid)) return txCache.get(txid);
+      const detail = await getTransaction(txid);
+      txCache.set(txid, detail);
+      return detail;
+    };
+    const addressSet = new Set(addresses.map((a) => a.toLowerCase()));
     for (const address of addresses) {
       const history = await getTransactionHistory(address);
       for (const item of history) {
         if (seenTxids.has(item.tx_hash)) continue;
         seenTxids.add(item.tx_hash);
-        const tx = await getTransaction(item.tx_hash);
+        const tx = await fetchTx(item.tx_hash);
         if (!tx) continue;
-        const isSend = tx.vin?.some(
-          (vin) => addresses.includes(vin.txid ?? "")
-        );
-        let amount = "0";
+        let isSend = false;
+        for (const vin of tx.vin ?? []) {
+          if (!vin.txid) continue;
+          const prevTx = await fetchTx(vin.txid);
+          if (prevTx?.vout?.[vin.vout]) {
+            const prevOut = prevTx.vout[vin.vout];
+            const prevAddrs = [
+              ...prevOut.scriptPubKey?.addresses ?? [],
+              ...prevOut.scriptPubKey?.address ? [prevOut.scriptPubKey.address] : []
+            ];
+            if (prevAddrs.some((a) => addressSet.has(a.toLowerCase()))) {
+              isSend = true;
+              break;
+            }
+          }
+        }
+        let amountToUs = 0;
+        let amountToOthers = 0;
         let txAddress = address;
+        let externalAddress = "";
         if (tx.vout) {
           for (const vout of tx.vout) {
-            const voutAddresses = vout.scriptPubKey?.addresses ?? [];
-            if (vout.scriptPubKey?.address) {
-              voutAddresses.push(vout.scriptPubKey.address);
-            }
-            const matchedAddr = voutAddresses.find((a) => addresses.includes(a));
-            if (matchedAddr) {
-              amount = Math.floor((vout.value ?? 0) * 1e8).toString();
-              txAddress = matchedAddr;
-              break;
+            const voutAddresses = [
+              ...vout.scriptPubKey?.addresses ?? [],
+              ...vout.scriptPubKey?.address ? [vout.scriptPubKey.address] : []
+            ];
+            const isOurs = voutAddresses.some((a) => addressSet.has(a.toLowerCase()));
+            const valueSats = Math.floor((vout.value ?? 0) * 1e8);
+            if (isOurs) {
+              amountToUs += valueSats;
+              if (!txAddress) txAddress = voutAddresses[0];
+            } else {
+              amountToOthers += valueSats;
+              if (!externalAddress && voutAddresses.length > 0) {
+                externalAddress = voutAddresses[0];
+              }
             }
           }
         }
+        const amount = isSend ? amountToOthers.toString() : amountToUs.toString();
+        const displayAddress = isSend ? externalAddress || txAddress : txAddress;
         transactions.push({
           txid: item.tx_hash,
           type: isSend ? "send" : "receive",
           amount,
-          address: txAddress,
+          address: displayAddress,
           confirmations: item.height > 0 ? currentHeight - item.height : 0,
           timestamp: tx.time ? tx.time * 1e3 : Date.now(),
           blockHeight: item.height > 0 ? item.height : void 0
@@ -1793,6 +1834,7 @@ var L1PaymentsModule = class {
   }
   async getTransaction(txid) {
     this.ensureInitialized();
+    await this.ensureConnected();
     const tx = await getTransaction(txid);
     if (!tx) return null;
     const addresses = this._getWatchedAddresses();
@@ -1828,6 +1870,7 @@ var L1PaymentsModule = class {
   }
   async estimateFee(to, amount) {
     this.ensureInitialized();
+    await this.ensureConnected();
     if (!this._wallet) {
       return { fee: "0", feeRate: this._config.defaultFeeRate ?? 10 };
     }
@@ -2347,7 +2390,9 @@ var STORAGE_KEYS_GLOBAL = {
   /** Nametag cache per address (separate from tracked addresses registry) */
   ADDRESS_NAMETAGS: "address_nametags",
   /** Active addresses registry (JSON: TrackedAddressesStorage) */
-  TRACKED_ADDRESSES: "tracked_addresses"
+  TRACKED_ADDRESSES: "tracked_addresses",
+  /** Last processed Nostr wallet event timestamp (unix seconds), keyed per pubkey */
+  LAST_WALLET_EVENT_TS: "last_wallet_event_ts"
 };
 var STORAGE_KEYS_ADDRESS = {
   /** Pending transfers for this address */
@@ -3751,7 +3796,7 @@ async function parseTokenInfo(tokenData) {
     try {
       const sdkToken = await import_Token6.Token.fromJSON(data);
       if (sdkToken.id) {
-        defaultInfo.tokenId = sdkToken.id.toString();
+        defaultInfo.tokenId = sdkToken.id.toJSON();
       }
       if (sdkToken.coins && sdkToken.coins.coins) {
         const rawCoins = sdkToken.coins.coins;
@@ -4042,8 +4087,7 @@ var PaymentsModule = class _PaymentsModule {
       maxRetries: config?.maxRetries ?? 3,
       debug: config?.debug ?? false
     };
-    const l1Enabled = config?.l1?.electrumUrl && config.l1.electrumUrl.length > 0;
-    this.l1 = l1Enabled ? new L1PaymentsModule(config?.l1) : null;
+    this.l1 = config?.l1 === null ? null : new L1PaymentsModule(config?.l1);
   }
   /** Get module configuration */
   getConfig() {
@@ -4705,13 +4749,16 @@ var PaymentsModule = class _PaymentsModule {
     if (this.paymentRequests.find((r) => r.id === transportRequest.id)) {
       return;
     }
+    const coinId = transportRequest.request.coinId;
+    const registry = TokenRegistry.getInstance();
+    const coinDef = registry.getDefinition(coinId);
     const request = {
       id: transportRequest.id,
       senderPubkey: transportRequest.senderTransportPubkey,
+      senderNametag: transportRequest.senderNametag,
       amount: transportRequest.request.amount,
-      coinId: transportRequest.request.coinId,
-      symbol: transportRequest.request.coinId,
-      // Use coinId as symbol for now
+      coinId,
+      symbol: coinDef?.symbol || coinId.slice(0, 8),
       message: transportRequest.request.message,
       recipientNametag: transportRequest.request.recipientNametag,
       requestId: transportRequest.request.requestId,
@@ -7730,8 +7777,8 @@ var Sphere = class _Sphere {
     if (options.nametag) {
       await sphere.registerNametag(options.nametag);
     } else {
-      await sphere.syncIdentityWithTransport();
       await sphere.recoverNametagFromTransport();
+      await sphere.syncIdentityWithTransport();
     }
     return sphere;
   }
@@ -7778,9 +7825,14 @@ var Sphere = class _Sphere {
     if (!options.mnemonic && !options.masterKey) {
       throw new Error("Either mnemonic or masterKey is required");
     }
+    console.log("[Sphere.import] Starting import...");
+    console.log("[Sphere.import] Clearing existing wallet data...");
     await _Sphere.clear({ storage: options.storage, tokenStorage: options.tokenStorage });
+    console.log("[Sphere.import] Clear done");
     if (!options.storage.isConnected()) {
+      console.log("[Sphere.import] Reconnecting storage...");
       await options.storage.connect();
+      console.log("[Sphere.import] Storage reconnected");
     }
     const sphere = new _Sphere(
       options.storage,
@@ -7794,9 +7846,12 @@ var Sphere = class _Sphere {
       if (!_Sphere.validateMnemonic(options.mnemonic)) {
         throw new Error("Invalid mnemonic");
       }
+      console.log("[Sphere.import] Storing mnemonic...");
       await sphere.storeMnemonic(options.mnemonic, options.derivationPath, options.basePath);
+      console.log("[Sphere.import] Initializing identity from mnemonic...");
       await sphere.initializeIdentityFromMnemonic(options.mnemonic, options.derivationPath);
     } else if (options.masterKey) {
+      console.log("[Sphere.import] Storing master key...");
       await sphere.storeMasterKey(
         options.masterKey,
         options.chainCode,
@@ -7804,24 +7859,35 @@ var Sphere = class _Sphere {
         options.basePath,
         options.derivationMode
       );
+      console.log("[Sphere.import] Initializing identity from master key...");
       await sphere.initializeIdentityFromMasterKey(
         options.masterKey,
         options.chainCode,
         options.derivationPath
       );
     }
+    console.log("[Sphere.import] Initializing providers...");
     await sphere.initializeProviders();
+    console.log("[Sphere.import] Providers initialized. Initializing modules...");
     await sphere.initializeModules();
+    console.log("[Sphere.import] Modules initialized");
     if (!options.nametag) {
+      console.log("[Sphere.import] Recovering nametag from transport...");
       await sphere.recoverNametagFromTransport();
+      console.log("[Sphere.import] Nametag recovery done");
+      await sphere.syncIdentityWithTransport();
     }
+    console.log("[Sphere.import] Finalizing wallet creation...");
     await sphere.finalizeWalletCreation();
     sphere._initialized = true;
     _Sphere.instance = sphere;
+    console.log("[Sphere.import] Tracking address 0...");
     await sphere.ensureAddressTracked(0);
     if (options.nametag) {
+      console.log("[Sphere.import] Registering nametag...");
       await sphere.registerNametag(options.nametag);
     }
+    console.log("[Sphere.import] Import complete");
     return sphere;
   }
   /**
@@ -7846,6 +7912,10 @@ var Sphere = class _Sphere {
   static async clear(storageOrOptions) {
     const storage = "get" in storageOrOptions ? storageOrOptions : storageOrOptions.storage;
     const tokenStorage = "get" in storageOrOptions ? void 0 : storageOrOptions.tokenStorage;
+    if (!storage.isConnected()) {
+      await storage.connect();
+    }
+    console.log("[Sphere.clear] Removing storage keys...");
     await storage.remove(STORAGE_KEYS_GLOBAL.MNEMONIC);
     await storage.remove(STORAGE_KEYS_GLOBAL.MASTER_KEY);
     await storage.remove(STORAGE_KEYS_GLOBAL.CHAIN_CODE);
@@ -7858,12 +7928,30 @@ var Sphere = class _Sphere {
     await storage.remove(STORAGE_KEYS_GLOBAL.ADDRESS_NAMETAGS);
     await storage.remove(STORAGE_KEYS_ADDRESS.PENDING_TRANSFERS);
     await storage.remove(STORAGE_KEYS_ADDRESS.OUTBOX);
+    console.log("[Sphere.clear] Storage keys removed");
     if (tokenStorage?.clear) {
-      await tokenStorage.clear();
+      console.log("[Sphere.clear] Clearing token storage...");
+      try {
+        await Promise.race([
+          tokenStorage.clear(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("tokenStorage.clear() timed out after 2s")), 2e3)
+          )
+        ]);
+        console.log("[Sphere.clear] Token storage cleared");
+      } catch (err) {
+        console.warn("[Sphere.clear] Token storage clear failed/timed out:", err);
+      }
     }
+    console.log("[Sphere.clear] Destroying vesting classifier...");
     await vestingClassifier.destroy();
+    console.log("[Sphere.clear] Vesting classifier destroyed");
     if (_Sphere.instance) {
+      console.log("[Sphere.clear] Destroying Sphere instance...");
       await _Sphere.instance.destroy();
+      console.log("[Sphere.clear] Sphere instance destroyed");
+    } else {
+      console.log("[Sphere.clear] No Sphere instance to destroy");
     }
   }
   /**
@@ -8244,7 +8332,8 @@ var Sphere = class _Sphere {
           storage: options.storage,
           transport: options.transport,
           oracle: options.oracle,
-          tokenStorage: options.tokenStorage
+          tokenStorage: options.tokenStorage,
+          l1: options.l1
         });
         return { success: true, mnemonic };
       }
@@ -8257,7 +8346,8 @@ var Sphere = class _Sphere {
           storage: options.storage,
           transport: options.transport,
           oracle: options.oracle,
-          tokenStorage: options.tokenStorage
+          tokenStorage: options.tokenStorage,
+          l1: options.l1
         });
         return { success: true };
       }
@@ -8316,7 +8406,8 @@ var Sphere = class _Sphere {
         transport: options.transport,
         oracle: options.oracle,
         tokenStorage: options.tokenStorage,
-        nametag: options.nametag
+        nametag: options.nametag,
+        l1: options.l1
       });
       return { success: true, sphere, mnemonic };
     }
@@ -8345,7 +8436,8 @@ var Sphere = class _Sphere {
         transport: options.transport,
         oracle: options.oracle,
         tokenStorage: options.tokenStorage,
-        nametag: options.nametag
+        nametag: options.nametag,
+        l1: options.l1
       });
       return { success: true, sphere };
     }
@@ -8376,7 +8468,8 @@ var Sphere = class _Sphere {
         transport: options.transport,
         oracle: options.oracle,
         tokenStorage: options.tokenStorage,
-        nametag: options.nametag
+        nametag: options.nametag,
+        l1: options.l1
       });
       return { success: true, sphere };
     }
@@ -8395,7 +8488,8 @@ var Sphere = class _Sphere {
           storage: options.storage,
           transport: options.transport,
           oracle: options.oracle,
-          tokenStorage: options.tokenStorage
+          tokenStorage: options.tokenStorage,
+          l1: options.l1
         });
         if (result.success) {
           const sphere2 = _Sphere.getInstance();
@@ -8444,7 +8538,8 @@ var Sphere = class _Sphere {
           transport: options.transport,
           oracle: options.oracle,
           tokenStorage: options.tokenStorage,
-          nametag: options.nametag
+          nametag: options.nametag,
+          l1: options.l1
         });
         return { success: true, sphere: sphere2, mnemonic };
       }
@@ -8457,7 +8552,8 @@ var Sphere = class _Sphere {
         transport: options.transport,
         oracle: options.oracle,
         tokenStorage: options.tokenStorage,
-        nametag: options.nametag
+        nametag: options.nametag,
+        l1: options.l1
       });
       return { success: true, sphere };
     }
@@ -9320,35 +9416,40 @@ var Sphere = class _Sphere {
     if (this._identity?.nametag) {
       return;
     }
-    if (!this._transport.recoverNametag) {
+    let recoveredNametag = null;
+    if (this._transport.recoverNametag) {
+      try {
+        recoveredNametag = await this._transport.recoverNametag();
+      } catch {
+      }
+    }
+    if (!recoveredNametag && this._transport.resolveAddressInfo && this._identity?.l1Address) {
+      try {
+        const info = await this._transport.resolveAddressInfo(this._identity.l1Address);
+        if (info?.nametag) {
+          recoveredNametag = info.nametag;
+        }
+      } catch {
+      }
+    }
+    if (!recoveredNametag) {
       return;
     }
     try {
-      const recoveredNametag = await this._transport.recoverNametag();
-      if (recoveredNametag) {
-        if (this._identity) {
-          this._identity.nametag = recoveredNametag;
-          await this._updateCachedProxyAddress();
-        }
-        const entry = await this.ensureAddressTracked(this._currentAddressIndex);
-        let nametags = this._addressNametags.get(entry.addressId);
-        if (!nametags) {
-          nametags = /* @__PURE__ */ new Map();
-          this._addressNametags.set(entry.addressId, nametags);
-        }
-        const nextIndex = nametags.size;
-        nametags.set(nextIndex, recoveredNametag);
-        await this.persistAddressNametags();
-        if (this._transport.publishIdentityBinding) {
-          await this._transport.publishIdentityBinding(
-            this._identity.chainPubkey,
-            this._identity.l1Address,
-            this._identity.directAddress || "",
-            recoveredNametag
-          );
-        }
-        this.emitEvent("nametag:recovered", { nametag: recoveredNametag });
+      if (this._identity) {
+        this._identity.nametag = recoveredNametag;
+        await this._updateCachedProxyAddress();
       }
+      const entry = await this.ensureAddressTracked(this._currentAddressIndex);
+      let nametags = this._addressNametags.get(entry.addressId);
+      if (!nametags) {
+        nametags = /* @__PURE__ */ new Map();
+        this._addressNametags.set(entry.addressId, nametags);
+      }
+      const nextIndex = nametags.size;
+      nametags.set(nextIndex, recoveredNametag);
+      await this.persistAddressNametags();
+      this.emitEvent("nametag:recovered", { nametag: recoveredNametag });
     } catch {
     }
   }
@@ -9557,8 +9658,12 @@ var Sphere = class _Sphere {
     for (const provider of this._tokenStorageProviders.values()) {
       provider.setIdentity(this._identity);
     }
-    await this._storage.connect();
-    await this._transport.connect();
+    if (!this._storage.isConnected()) {
+      await this._storage.connect();
+    }
+    if (!this._transport.isConnected()) {
+      await this._transport.connect();
+    }
     await this._oracle.initialize();
     for (const provider of this._tokenStorageProviders.values()) {
       await provider.initialize();