@unicitylabs/sphere-sdk 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -1665,6 +1665,7 @@ var L1PaymentsModule = class {
   _chainCode;
   _addresses = [];
   _wallet;
+  _transport;
   constructor(config) {
     this._config = {
       electrumUrl: config?.electrumUrl ?? "wss://fulcrum.alpha.unicity.network:50004",
@@ -1677,13 +1678,14 @@ var L1PaymentsModule = class {
     this._identity = deps.identity;
     this._chainCode = deps.chainCode;
     this._addresses = deps.addresses ?? [];
+    this._transport = deps.transport;
     this._wallet = {
       masterPrivateKey: deps.identity.privateKey,
       chainCode: deps.chainCode,
       addresses: [
         {
-          address: deps.identity.address,
-          publicKey: deps.identity.publicKey,
+          address: deps.identity.l1Address,
+          publicKey: deps.identity.chainPubkey,
           privateKey: deps.identity.privateKey,
           path: "m/0",
           index: 0
@@ -1691,7 +1693,7 @@ var L1PaymentsModule = class {
       ]
     };
     for (const addr of this._addresses) {
-      if (addr !== deps.identity.address) {
+      if (addr !== deps.identity.l1Address) {
         this._wallet.addresses.push({
           address: addr,
           path: null,
@@ -1714,18 +1716,64 @@ var L1PaymentsModule = class {
     this._addresses = [];
     this._wallet = void 0;
   }
+  /**
+   * Check if a string looks like an L1 address (alpha1... or alphat1...)
+   */
+  isL1Address(value) {
+    return value.startsWith("alpha1") || value.startsWith("alphat1");
+  }
+  /**
+   * Resolve recipient to L1 address
+   * Supports: L1 address (alpha1...), nametag (with or without @)
+   */
+  async resolveL1Address(recipient) {
+    if (recipient.startsWith("@")) {
+      const nametag = recipient.slice(1);
+      return this.resolveNametagToL1Address(nametag);
+    }
+    if (this.isL1Address(recipient)) {
+      return recipient;
+    }
+    try {
+      const l1Address = await this.resolveNametagToL1Address(recipient);
+      return l1Address;
+    } catch {
+      throw new Error(
+        `Recipient "${recipient}" is not a valid nametag or L1 address. Use @nametag for explicit nametag or a valid alpha1... address.`
+      );
+    }
+  }
+  /**
+   * Resolve nametag to L1 address using transport provider
+   */
+  async resolveNametagToL1Address(nametag) {
+    if (!this._transport?.resolveNametagInfo) {
+      throw new Error("Transport provider does not support nametag resolution");
+    }
+    const info = await this._transport.resolveNametagInfo(nametag);
+    if (!info) {
+      throw new Error(`Nametag not found: ${nametag}`);
+    }
+    if (!info.l1Address) {
+      throw new Error(
+        `Nametag @${nametag} does not have L1 address information. The owner needs to update their nametag registration.`
+      );
+    }
+    return info.l1Address;
+  }
   async send(request) {
     this.ensureInitialized();
     if (!this._wallet || !this._identity) {
       return { success: false, error: "No wallet available" };
     }
     try {
+      const recipientAddress = await this.resolveL1Address(request.to);
       const amountAlpha = parseInt(request.amount, 10) / 1e8;
       const results = await sendAlpha(
         this._wallet,
-        request.to,
+        recipientAddress,
         amountAlpha,
-        this._identity.address
+        this._identity.l1Address
       );
       if (results && results.length > 0) {
         const txids = results.map((r) => r.txid);
@@ -1947,8 +1995,8 @@ var L1PaymentsModule = class {
   }
   _getWatchedAddresses() {
     const addresses = [...this._addresses];
-    if (this._identity?.address && !addresses.includes(this._identity.address)) {
-      addresses.unshift(this._identity.address);
+    if (this._identity?.l1Address && !addresses.includes(this._identity.l1Address)) {
+      addresses.unshift(this._identity.l1Address);
     }
     return addresses;
   }
@@ -2938,12 +2986,10 @@ function countCommittedTransactions(token) {
 
 // modules/payments/PaymentsModule.ts
 var import_Token4 = require("@unicitylabs/state-transition-sdk/lib/token/Token");
-var import_TokenId3 = require("@unicitylabs/state-transition-sdk/lib/token/TokenId");
 var import_CoinId3 = require("@unicitylabs/state-transition-sdk/lib/token/fungible/CoinId");
 var import_TransferCommitment2 = require("@unicitylabs/state-transition-sdk/lib/transaction/TransferCommitment");
 var import_TransferTransaction = require("@unicitylabs/state-transition-sdk/lib/transaction/TransferTransaction");
 var import_SigningService = require("@unicitylabs/state-transition-sdk/lib/sign/SigningService");
-var import_ProxyAddress = require("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
 var import_AddressScheme = require("@unicitylabs/state-transition-sdk/lib/address/AddressScheme");
 var import_UnmaskedPredicate3 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate");
 var import_TokenState3 = require("@unicitylabs/state-transition-sdk/lib/token/TokenState");
@@ -3234,7 +3280,8 @@ var PaymentsModule = class {
       this.l1.initialize({
         identity: deps.identity,
         chainCode: deps.chainCode,
-        addresses: deps.l1Addresses
+        addresses: deps.l1Addresses,
+        transport: deps.transport
       });
     }
     this.unsubscribeTransfers = deps.transport.onTokenTransfer((transfer) => {
@@ -3631,7 +3678,7 @@ var PaymentsModule = class {
     }
     const request = {
       id: transportRequest.id,
-      senderPubkey: transportRequest.senderPubkey,
+      senderPubkey: transportRequest.senderTransportPubkey,
       amount: transportRequest.request.amount,
       coinId: transportRequest.request.coinId,
       symbol: transportRequest.request.coinId,
@@ -3743,7 +3790,7 @@ var PaymentsModule = class {
     }
     const response = {
       id: transportResponse.id,
-      responderPubkey: transportResponse.responderPubkey,
+      responderPubkey: transportResponse.responderTransportPubkey,
       requestId: transportResponse.response.requestId,
       responseType: transportResponse.response.responseType,
       message: transportResponse.response.message,
@@ -4497,6 +4544,23 @@ var PaymentsModule = class {
   // ===========================================================================
   // Private: Transfer Operations
   // ===========================================================================
+  /**
+   * Detect if a string is an L3 address (not a nametag)
+   * Returns true for: hex pubkeys (64+ chars), PROXY:, DIRECT: prefixed addresses
+   */
+  isL3Address(value) {
+    if (value.startsWith("PROXY:") || value.startsWith("DIRECT:")) {
+      return true;
+    }
+    if (value.length >= 64 && /^[0-9a-fA-F]+$/.test(value)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Resolve recipient to Nostr pubkey for messaging
+   * Supports: nametag (with or without @), hex pubkey
+   */
   async resolveRecipient(recipient) {
     if (recipient.startsWith("@")) {
       const nametag = recipient.slice(1);
@@ -4506,7 +4570,19 @@ var PaymentsModule = class {
       }
       return pubkey;
     }
-    return recipient;
+    if (this.isL3Address(recipient)) {
+      return recipient;
+    }
+    if (this.deps?.transport.resolveNametag) {
+      const pubkey = await this.deps.transport.resolveNametag(recipient);
+      if (pubkey) {
+        this.log(`Resolved "${recipient}" as nametag to pubkey`);
+        return pubkey;
+      }
+    }
+    throw new Error(
+      `Recipient "${recipient}" is not a valid nametag or address. Use @nametag for explicit nametag or a valid hex pubkey/PROXY:/DIRECT: address.`
+    );
   }
   /**
    * Create SDK TransferCommitment for a token transfer
@@ -4538,19 +4614,74 @@ var PaymentsModule = class {
     return import_SigningService.SigningService.createFromSecret(privateKeyBytes);
   }
   /**
-   * Resolve recipient to IAddress
+   * Create DirectAddress from a public key using UnmaskedPredicateReference
+   */
+  async createDirectAddressFromPubkey(pubkeyHex) {
+    const { UnmaskedPredicateReference: UnmaskedPredicateReference3 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
+    const { TokenType: TokenType3 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenType");
+    const UNICITY_TOKEN_TYPE_HEX3 = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
+    const tokenType = new TokenType3(Buffer.from(UNICITY_TOKEN_TYPE_HEX3, "hex"));
+    const pubkeyBytes = new Uint8Array(
+      pubkeyHex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
+    );
+    const addressRef = await UnmaskedPredicateReference3.create(
+      tokenType,
+      "secp256k1",
+      pubkeyBytes,
+      import_HashAlgorithm3.HashAlgorithm.SHA256
+    );
+    return addressRef.toAddress();
+  }
+  /**
+   * Resolve nametag to 33-byte compressed public key using resolveNametagInfo
+   * Returns null if nametag not found or publicKey not available
+   */
+  async resolveNametagToPublicKey(nametag) {
+    if (!this.deps?.transport.resolveNametagInfo) {
+      this.log("resolveNametagInfo not available on transport");
+      return null;
+    }
+    const info = await this.deps.transport.resolveNametagInfo(nametag);
+    if (!info) {
+      this.log(`Nametag "${nametag}" not found`);
+      return null;
+    }
+    if (!info.chainPubkey) {
+      this.log(`Nametag "${nametag}" has no 33-byte chainPubkey (legacy event)`);
+      return null;
+    }
+    return info.chainPubkey;
+  }
+  /**
+   * Resolve recipient to IAddress for L3 transfers
+   * Supports: nametag (with or without @), PROXY:, DIRECT:, hex pubkey
    */
   async resolveRecipientAddress(recipient) {
+    const { AddressFactory } = await import("@unicitylabs/state-transition-sdk/lib/address/AddressFactory");
     if (recipient.startsWith("@")) {
       const nametag = recipient.slice(1);
-      const tokenId2 = await import_TokenId3.TokenId.fromNameTag(nametag);
-      return import_ProxyAddress.ProxyAddress.fromTokenId(tokenId2);
+      const publicKey2 = await this.resolveNametagToPublicKey(nametag);
+      if (publicKey2) {
+        this.log(`Resolved @${nametag} to 33-byte publicKey for DirectAddress`);
+        return this.createDirectAddressFromPubkey(publicKey2);
+      }
+      throw new Error(`Nametag "${nametag}" not found or missing publicKey`);
     }
-    const pubkeyBytes = new Uint8Array(
-      recipient.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
+    if (recipient.startsWith("PROXY:") || recipient.startsWith("DIRECT:")) {
+      return AddressFactory.createAddress(recipient);
+    }
+    if (recipient.length === 66 && /^[0-9a-fA-F]+$/.test(recipient)) {
+      this.log(`Creating DirectAddress from 33-byte compressed pubkey`);
+      return this.createDirectAddressFromPubkey(recipient);
+    }
+    const publicKey = await this.resolveNametagToPublicKey(recipient);
+    if (publicKey) {
+      this.log(`Resolved "${recipient}" as nametag to 33-byte publicKey for DirectAddress`);
+      return this.createDirectAddressFromPubkey(publicKey);
+    }
+    throw new Error(
+      `Recipient "${recipient}" is not a valid nametag or L3 address. Use @nametag for explicit nametag or a valid 33-byte hex pubkey/PROXY:/DIRECT: address.`
     );
-    const tokenId = new import_TokenId3.TokenId(pubkeyBytes.slice(0, 32));
-    return import_ProxyAddress.ProxyAddress.fromTokenId(tokenId);
   }
   async handleIncomingTransfer(transfer) {
     try {
@@ -4608,7 +4739,39 @@ var PaymentsModule = class {
             }
           }
         } else {
-          tokenData = sourceTokenInput;
+          this.log("Finalizing DIRECT address transfer for state tracking...");
+          try {
+            const signingService = await this.createSigningService();
+            const transferSalt = transferTx.data.salt;
+            const recipientPredicate = await import_UnmaskedPredicate3.UnmaskedPredicate.create(
+              sourceToken.id,
+              sourceToken.type,
+              signingService,
+              import_HashAlgorithm3.HashAlgorithm.SHA256,
+              transferSalt
+            );
+            const recipientState = new import_TokenState3.TokenState(recipientPredicate, null);
+            const stClient = this.deps.oracle.getStateTransitionClient?.();
+            const trustBase = this.deps.oracle.getTrustBase?.();
+            if (!stClient || !trustBase) {
+              this.log("Cannot finalize DIRECT transfer - missing client, using source token");
+              tokenData = sourceTokenInput;
+            } else {
+              finalizedSdkToken = await stClient.finalizeTransaction(
+                trustBase,
+                sourceToken,
+                recipientState,
+                transferTx,
+                []
+                // No nametag tokens needed for DIRECT
+              );
+              tokenData = finalizedSdkToken.toJSON();
+              this.log("DIRECT transfer finalized successfully");
+            }
+          } catch (finalizeError) {
+            this.log("DIRECT finalization failed, using source token:", finalizeError);
+            tokenData = sourceTokenInput;
+          }
         }
       } else if (payload.token) {
         tokenData = payload.token;
@@ -4642,7 +4805,7 @@ var PaymentsModule = class {
       await this.addToken(token);
       const incomingTransfer = {
         id: transfer.id,
-        senderPubkey: transfer.senderPubkey,
+        senderPubkey: transfer.senderTransportPubkey,
         tokens: [token],
         memo: payload.memo,
         receivedAt: transfer.timestamp
@@ -4710,7 +4873,7 @@ var PaymentsModule = class {
       tokens,
       {
         version: 1,
-        address: this.deps.identity.address,
+        address: this.deps.identity.l1Address,
         ipnsName: this.deps.identity.ipnsName ?? ""
       },
       {
@@ -4814,7 +4977,7 @@ var CommunicationsModule = class {
     const eventId = await this.deps.transport.sendMessage(recipientPubkey, content);
     const message = {
       id: eventId,
-      senderPubkey: this.deps.identity.publicKey,
+      senderPubkey: this.deps.identity.chainPubkey,
       senderNametag: this.deps.identity.nametag,
       recipientPubkey,
       content,
@@ -4841,7 +5004,7 @@ var CommunicationsModule = class {
   getConversations() {
     const conversations = /* @__PURE__ */ new Map();
     for (const message of this.messages.values()) {
-      const peer = message.senderPubkey === this.deps?.identity.publicKey ? message.recipientPubkey : message.senderPubkey;
+      const peer = message.senderPubkey === this.deps?.identity.chainPubkey ? message.recipientPubkey : message.senderPubkey;
       if (!conversations.has(peer)) {
         conversations.set(peer, []);
       }
@@ -4871,7 +5034,7 @@ var CommunicationsModule = class {
    */
   getUnreadCount(peerPubkey) {
     let messages = Array.from(this.messages.values()).filter(
-      (m) => !m.isRead && m.senderPubkey !== this.deps?.identity.publicKey
+      (m) => !m.isRead && m.senderPubkey !== this.deps?.identity.chainPubkey
     );
     if (peerPubkey) {
       messages = messages.filter((m) => m.senderPubkey === peerPubkey);
@@ -4896,7 +5059,7 @@ var CommunicationsModule = class {
     const eventId = await this.deps.transport.publishBroadcast?.(content, tags);
     const message = {
       id: eventId ?? crypto.randomUUID(),
-      authorPubkey: this.deps.identity.publicKey,
+      authorPubkey: this.deps.identity.chainPubkey,
       authorNametag: this.deps.identity.nametag,
       content,
       timestamp: Date.now(),
@@ -4947,11 +5110,12 @@ var CommunicationsModule = class {
   // Private: Message Handling
   // ===========================================================================
   handleIncomingMessage(msg) {
-    if (msg.senderPubkey === this.deps?.identity.publicKey) return;
+    if (msg.senderTransportPubkey === this.deps?.identity.chainPubkey) return;
     const message = {
       id: msg.id,
-      senderPubkey: msg.senderPubkey,
-      recipientPubkey: this.deps.identity.publicKey,
+      senderPubkey: msg.senderTransportPubkey,
+      senderNametag: msg.senderNametag,
+      recipientPubkey: this.deps.identity.chainPubkey,
       content: msg.content,
       timestamp: msg.timestamp,
       isRead: false
@@ -4973,7 +5137,7 @@ var CommunicationsModule = class {
   handleIncomingBroadcast(incoming) {
     const message = {
       id: incoming.id,
-      authorPubkey: incoming.authorPubkey,
+      authorPubkey: incoming.authorTransportPubkey,
       content: incoming.content,
       timestamp: incoming.timestamp,
       tags: incoming.tags
@@ -5715,6 +5879,7 @@ var import_SigningService2 = require("@unicitylabs/state-transition-sdk/lib/sign
 var import_TokenType2 = require("@unicitylabs/state-transition-sdk/lib/token/TokenType");
 var import_HashAlgorithm4 = require("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm");
 var import_UnmaskedPredicateReference2 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
+var import_nostr_js_sdk = require("@unicitylabs/nostr-js-sdk");
 var UNICITY_TOKEN_TYPE_HEX2 = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
 async function deriveL3PredicateAddress(privateKey) {
   const secret = Buffer.from(privateKey, "hex");
@@ -5773,12 +5938,13 @@ var Sphere = class _Sphere {
    */
   static async exists(storage) {
     try {
-      const exists = await storage.get(STORAGE_KEYS.WALLET_EXISTS);
-      if (exists === "true") {
-        const mnemonic = await storage.get(STORAGE_KEYS.MNEMONIC);
-        const masterKey = await storage.get(STORAGE_KEYS.MASTER_KEY);
-        return !!(mnemonic || masterKey);
+      if (!storage.isConnected()) {
+        await storage.connect();
       }
+      const mnemonic = await storage.get(STORAGE_KEYS.MNEMONIC);
+      if (mnemonic) return true;
+      const masterKey = await storage.get(STORAGE_KEYS.MASTER_KEY);
+      if (masterKey) return true;
       return false;
     } catch {
       return false;
@@ -5871,6 +6037,8 @@ var Sphere = class _Sphere {
     _Sphere.instance = sphere;
     if (options.nametag) {
       await sphere.registerNametag(options.nametag);
+    } else {
+      await sphere.recoverNametagFromNostr();
     }
     return sphere;
   }
@@ -5892,15 +6060,6 @@ var Sphere = class _Sphere {
     await sphere.initializeProviders();
     await sphere.initializeModules();
     await sphere.syncNametagWithNostr();
-    if (sphere._identity?.nametag && !sphere._payments.hasNametag()) {
-      console.log(`[Sphere] Minting missing nametag token for @${sphere._identity.nametag}...`);
-      const result = await sphere.mintNametag(sphere._identity.nametag);
-      if (!result.success) {
-        console.warn(`[Sphere] Failed to mint nametag token: ${result.error}`);
-      } else {
-        console.log(`[Sphere] Nametag token minted successfully`);
-      }
-    }
     sphere._initialized = true;
     _Sphere.instance = sphere;
     return sphere;
@@ -5942,6 +6101,9 @@ var Sphere = class _Sphere {
     }
     await sphere.initializeProviders();
     await sphere.initializeModules();
+    if (!options.nametag) {
+      await sphere.recoverNametagFromNostr();
+    }
     await sphere.finalizeWalletCreation();
     sphere._initialized = true;
     _Sphere.instance = sphere;
@@ -6015,9 +6177,9 @@ var Sphere = class _Sphere {
   get identity() {
     if (!this._identity) return null;
     return {
-      publicKey: this._identity.publicKey,
-      address: this._identity.address,
-      predicateAddress: this._identity.predicateAddress,
+      chainPubkey: this._identity.chainPubkey,
+      l1Address: this._identity.l1Address,
+      directAddress: this._identity.directAddress,
       ipnsName: this._identity.ipnsName,
       nametag: this._identity.nametag
     };
@@ -6134,7 +6296,7 @@ var Sphere = class _Sphere {
       if (this._masterKey) {
         address0 = this.deriveAddress(0).address;
       } else if (this._identity) {
-        address0 = this._identity.address;
+        address0 = this._identity.l1Address;
       }
     } catch {
     }
@@ -6181,8 +6343,8 @@ var Sphere = class _Sphere {
       } catch {
         if (i === 0 && this._identity) {
           addresses.push({
-            address: this._identity.address,
-            publicKey: this._identity.publicKey,
+            address: this._identity.l1Address,
+            publicKey: this._identity.chainPubkey,
             path: this.getDefaultAddressPath(),
             index: 0
           });
@@ -6261,7 +6423,7 @@ var Sphere = class _Sphere {
       } catch {
         if (i === 0 && this._identity) {
           addresses.push({
-            address: this._identity.address,
+            address: this._identity.l1Address,
             path: this.getDefaultAddressPath(),
             index: 0,
             isChange: false
@@ -6615,9 +6777,9 @@ var Sphere = class _Sphere {
     const nametag = this._addressNametags.get(index);
     this._identity = {
       privateKey: addressInfo.privateKey,
-      publicKey: addressInfo.publicKey,
-      address: addressInfo.address,
-      predicateAddress,
+      chainPubkey: addressInfo.publicKey,
+      l1Address: addressInfo.address,
+      directAddress: predicateAddress,
       ipnsName: "12D3KooW" + ipnsHash,
       nametag
     };
@@ -6630,13 +6792,13 @@ var Sphere = class _Sphere {
     }
     await this.reinitializeModulesForNewAddress();
     this.emitEvent("identity:changed", {
-      address: this._identity.address,
-      predicateAddress: this._identity.predicateAddress,
-      publicKey: this._identity.publicKey,
+      l1Address: this._identity.l1Address,
+      directAddress: this._identity.directAddress,
+      chainPubkey: this._identity.chainPubkey,
       nametag: this._identity.nametag,
       addressIndex: index
     });
-    console.log(`[Sphere] Switched to address ${index}:`, this._identity.address);
+    console.log(`[Sphere] Switched to address ${index}:`, this._identity.l1Address);
   }
   /**
    * Re-initialize modules after address switch
@@ -6694,7 +6856,7 @@ var Sphere = class _Sphere {
     );
     return {
       ...info,
-      address: "alpha1" + info.address.slice(0, 38)
+      address: publicKeyToAddress(info.publicKey, "alpha")
     };
   }
   /**
@@ -6721,11 +6883,10 @@ var Sphere = class _Sphere {
       path
     );
     const publicKey = getPublicKey(derived.privateKey);
-    const addressHash = hash160(publicKey);
     return {
       privateKey: derived.privateKey,
       publicKey,
-      address: "alpha1" + addressHash.slice(0, 38),
+      address: publicKeyToAddress(publicKey, "alpha"),
       path,
       index
     };
@@ -6813,6 +6974,17 @@ var Sphere = class _Sphere {
   hasNametag() {
     return !!this._identity?.nametag;
   }
+  /**
+   * Get the PROXY address for the current nametag
+   * PROXY addresses are derived from the nametag hash and require
+   * the nametag token to claim funds sent to them
+   * @returns PROXY address string or undefined if no nametag
+   */
+  getProxyAddress() {
+    const nametag = this._identity?.nametag;
+    if (!nametag) return void 0;
+    return `PROXY:${(0, import_nostr_js_sdk.hashNametag)(nametag)}`;
+  }
   /**
    * Register a nametag for the current active address
    * Each address can have its own independent nametag
@@ -6841,7 +7013,11 @@ var Sphere = class _Sphere {
       throw new Error(`Nametag already registered for address ${this._currentAddressIndex}: @${this._identity.nametag}`);
     }
     if (this._transport.registerNametag) {
-      const success = await this._transport.registerNametag(cleanNametag, this._identity.publicKey);
+      const success = await this._transport.registerNametag(
+        cleanNametag,
+        this._identity.chainPubkey,
+        this._identity.directAddress || ""
+      );
       if (!success) {
         throw new Error("Failed to register nametag. It may already be taken.");
       }
@@ -6935,7 +7111,11 @@ var Sphere = class _Sphere {
       return;
     }
     try {
-      const success = await this._transport.registerNametag(nametag, this._identity.publicKey);
+      const success = await this._transport.registerNametag(
+        nametag,
+        this._identity.chainPubkey,
+        this._identity.directAddress || ""
+      );
       if (success) {
         console.log(`[Sphere] Nametag @${nametag} synced with Nostr`);
       } else {
@@ -6945,6 +7125,38 @@ var Sphere = class _Sphere {
       console.warn(`[Sphere] Nametag sync failed:`, error);
     }
   }
+  /**
+   * Recover nametag from Nostr after wallet import
+   * Searches for encrypted nametag events authored by this wallet's pubkey
+   * and decrypts them to restore the nametag association
+   */
+  async recoverNametagFromNostr() {
+    if (this._identity?.nametag) {
+      return;
+    }
+    if (!this._transport.recoverNametag) {
+      return;
+    }
+    try {
+      const recoveredNametag = await this._transport.recoverNametag();
+      if (recoveredNametag) {
+        if (this._identity) {
+          this._identity.nametag = recoveredNametag;
+        }
+        this._addressNametags.set(this._currentAddressIndex, recoveredNametag);
+        await this._storage.set(STORAGE_KEYS.NAMETAG, recoveredNametag);
+        if (this._transport.registerNametag) {
+          await this._transport.registerNametag(
+            recoveredNametag,
+            this._identity.chainPubkey,
+            this._identity.directAddress || ""
+          );
+        }
+        this.emitEvent("nametag:recovered", { nametag: recoveredNametag });
+      }
+    } catch {
+    }
+  }
   /**
    * Validate nametag format
    */
@@ -7026,7 +7238,6 @@ var Sphere = class _Sphere {
     const encryptedMasterKey = await this._storage.get(STORAGE_KEYS.MASTER_KEY);
     const chainCode = await this._storage.get(STORAGE_KEYS.CHAIN_CODE);
     const derivationPath = await this._storage.get(STORAGE_KEYS.DERIVATION_PATH);
-    const savedNametag = await this._storage.get(STORAGE_KEYS.NAMETAG);
     const savedBasePath = await this._storage.get(STORAGE_KEYS.BASE_PATH);
     const savedDerivationMode = await this._storage.get(STORAGE_KEYS.DERIVATION_MODE);
     const savedSource = await this._storage.get(STORAGE_KEYS.WALLET_SOURCE);
@@ -7035,7 +7246,6 @@ var Sphere = class _Sphere {
     this._derivationMode = savedDerivationMode ?? "bip32";
     this._source = savedSource ?? "unknown";
     this._currentAddressIndex = savedAddressIndex ? parseInt(savedAddressIndex, 10) : 0;
-    await this.loadAddressNametags();
     if (encryptedMnemonic) {
       const mnemonic = this.decrypt(encryptedMnemonic);
       if (!mnemonic) {
@@ -7061,6 +7271,11 @@ var Sphere = class _Sphere {
     } else {
       throw new Error("No wallet data found in storage");
     }
+    if (this._identity) {
+      this._storage.setIdentity(this._identity);
+    }
+    await this.loadAddressNametags();
+    const savedNametag = await this._storage.get(STORAGE_KEYS.NAMETAG);
     if (this._currentAddressIndex > 0 && this._masterKey) {
       const addressInfo = this.deriveAddress(this._currentAddressIndex, false);
       const ipnsHash = sha256(addressInfo.publicKey, "hex").slice(0, 40);
@@ -7068,56 +7283,64 @@ var Sphere = class _Sphere {
       const nametag = this._addressNametags.get(this._currentAddressIndex);
       this._identity = {
         privateKey: addressInfo.privateKey,
-        publicKey: addressInfo.publicKey,
-        address: addressInfo.address,
-        predicateAddress,
+        chainPubkey: addressInfo.publicKey,
+        l1Address: addressInfo.address,
+        directAddress: predicateAddress,
         ipnsName: "12D3KooW" + ipnsHash,
         nametag
       };
-      console.log(`[Sphere] Restored to address ${this._currentAddressIndex}:`, this._identity.address);
+      this._storage.setIdentity(this._identity);
+      console.log(`[Sphere] Restored to address ${this._currentAddressIndex}:`, this._identity.l1Address);
     } else {
       if (savedNametag && this._identity) {
-        this._identity.nametag = savedNametag;
+        let nametag = savedNametag;
+        if (savedNametag.startsWith("{")) {
+          try {
+            const parsed = JSON.parse(savedNametag);
+            nametag = parsed["0"] || parsed[0] || Object.values(parsed)[0];
+          } catch {
+          }
+        }
+        this._identity.nametag = nametag;
         if (!this._addressNametags.has(0)) {
-          this._addressNametags.set(0, savedNametag);
+          this._addressNametags.set(0, nametag);
         }
-        console.log("[Sphere] Restored nametag:", savedNametag);
       } else if (this._identity) {
         const nametag = this._addressNametags.get(0);
         if (nametag) {
           this._identity.nametag = nametag;
-          console.log("[Sphere] Restored nametag from map:", nametag);
         }
       }
     }
   }
   async initializeIdentityFromMnemonic(mnemonic, derivationPath) {
-    const path = derivationPath ?? DEFAULT_DERIVATION_PATH;
+    const basePath = derivationPath ?? DEFAULT_BASE_PATH;
+    const fullPath = `${basePath}/0/0`;
     const masterKey = identityFromMnemonicSync(mnemonic);
     const derivedKey = deriveKeyAtPath(
       masterKey.privateKey,
       masterKey.chainCode,
-      `${path}/0/0`
+      fullPath
     );
     const publicKey = getPublicKey(derivedKey.privateKey);
-    const addressHash = hash160(publicKey);
+    const address = publicKeyToAddress(publicKey, "alpha");
     const ipnsHash = sha256(publicKey, "hex").slice(0, 40);
     const predicateAddress = await deriveL3PredicateAddress(derivedKey.privateKey);
     this._identity = {
       privateKey: derivedKey.privateKey,
-      publicKey,
-      address: "alpha1" + addressHash.slice(0, 38),
-      predicateAddress,
+      chainPubkey: publicKey,
+      l1Address: address,
+      directAddress: predicateAddress,
       ipnsName: "12D3KooW" + ipnsHash
     };
     this._masterKey = masterKey;
-    console.log("[Sphere] Identity initialized from mnemonic, path:", path);
   }
   async initializeIdentityFromMasterKey(masterKey, chainCode, derivationPath) {
-    const path = derivationPath ?? DEFAULT_DERIVATION_PATH;
+    const basePath = derivationPath ?? DEFAULT_BASE_PATH;
+    const fullPath = `${basePath}/0/0`;
     let privateKey;
     if (chainCode) {
-      const derivedKey = deriveKeyAtPath(masterKey, chainCode, `${path}/0/0`);
+      const derivedKey = deriveKeyAtPath(masterKey, chainCode, fullPath);
       privateKey = derivedKey.privateKey;
       this._masterKey = {
         privateKey: masterKey,
@@ -7128,17 +7351,16 @@ var Sphere = class _Sphere {
       this._masterKey = null;
     }
     const publicKey = getPublicKey(privateKey);
-    const addressHash = hash160(publicKey);
+    const address = publicKeyToAddress(publicKey, "alpha");
     const ipnsHash = sha256(publicKey, "hex").slice(0, 40);
     const predicateAddress = await deriveL3PredicateAddress(privateKey);
     this._identity = {
       privateKey,
-      publicKey,
-      address: "alpha1" + addressHash.slice(0, 38),
-      predicateAddress,
+      chainPubkey: publicKey,
+      l1Address: address,
+      directAddress: predicateAddress,
       ipnsName: "12D3KooW" + ipnsHash
     };
-    console.log("[Sphere] Identity initialized from master key, path:", path, "chainCode:", !!chainCode);
   }
   // ===========================================================================
   // Private: Provider & Module Initialization