@unicitylabs/sphere-sdk 0.1.2 → 0.1.4

package/dist/impl/browser/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // impl/browser/index.ts
@@ -22,7 +32,6 @@ var browser_exports = {};
 __export(browser_exports, {
   BrowserTrustBaseLoader: () => BrowserTrustBaseLoader,
   IndexedDBTokenStorageProvider: () => IndexedDBTokenStorageProvider,
-  IpfsStorageProvider: () => IpfsStorageProvider,
   LocalStorageProvider: () => LocalStorageProvider,
   NostrTransportProvider: () => NostrTransportProvider,
   UnicityAggregatorProvider: () => UnicityAggregatorProvider,
@@ -32,7 +41,6 @@ __export(browser_exports, {
   createBrowserTrustBaseLoader: () => createBrowserTrustBaseLoader,
   createBrowserWebSocket: () => createBrowserWebSocket,
   createIndexedDBTokenStorageProvider: () => createIndexedDBTokenStorageProvider,
-  createIpfsStorageProvider: () => createIpfsStorageProvider,
   createLocalStorageProvider: () => createLocalStorageProvider,
   createNostrTransportProvider: () => createNostrTransportProvider,
   createUnicityAggregatorProvider: () => createUnicityAggregatorProvider,
@@ -62,7 +70,7 @@ var LocalStorageProvider = class {
   constructor(config) {
     const storage = config?.storage ?? this.getStorageSafe();
     this.config = {
-      prefix: config?.prefix ?? "sphere_sdk2_",
+      prefix: config?.prefix ?? "sphere_",
       storage,
       debug: config?.debug ?? false
     };
@@ -99,7 +107,7 @@ var LocalStorageProvider = class {
   // ===========================================================================
   setIdentity(identity) {
     this.identity = identity;
-    this.log("Identity set:", identity.address);
+    this.log("Identity set:", identity.l1Address);
   }
   async get(key) {
     this.ensureConnected();
@@ -166,7 +174,7 @@ var LocalStorageProvider = class {
   // Private Methods
   // ===========================================================================
   getFullKey(key) {
-    const addressPart = this.identity?.address ?? "default";
+    const addressPart = this.identity?.l1Address ?? "default";
     return `${this.config.prefix}${addressPart}_${key}`;
   }
   ensureConnected() {
@@ -213,676 +221,6 @@ function createLocalStorageProvider(config) {
   return new LocalStorageProvider(config);
 }
 
-// constants.ts
-var STORAGE_PREFIX = "sphere_";
-var STORAGE_KEYS = {
-  /** Encrypted BIP39 mnemonic */
-  MNEMONIC: `${STORAGE_PREFIX}mnemonic`,
-  /** Encrypted master private key */
-  MASTER_KEY: `${STORAGE_PREFIX}master_key`,
-  /** BIP32 chain code */
-  CHAIN_CODE: `${STORAGE_PREFIX}chain_code`,
-  /** HD derivation path (full path like m/44'/0'/0'/0/0) */
-  DERIVATION_PATH: `${STORAGE_PREFIX}derivation_path`,
-  /** Base derivation path (like m/44'/0'/0' without chain/index) */
-  BASE_PATH: `${STORAGE_PREFIX}base_path`,
-  /** Derivation mode: bip32, wif_hmac, legacy_hmac */
-  DERIVATION_MODE: `${STORAGE_PREFIX}derivation_mode`,
-  /** Wallet source: mnemonic, file, unknown */
-  WALLET_SOURCE: `${STORAGE_PREFIX}wallet_source`,
-  /** Wallet existence flag */
-  WALLET_EXISTS: `${STORAGE_PREFIX}wallet_exists`,
-  /** Registered nametag (legacy - single address) */
-  NAMETAG: `${STORAGE_PREFIX}nametag`,
-  /** Current active address index */
-  CURRENT_ADDRESS_INDEX: `${STORAGE_PREFIX}current_address_index`,
-  /** Address nametags map (JSON: { "0": "alice", "1": "bob" }) */
-  ADDRESS_NAMETAGS: `${STORAGE_PREFIX}address_nametags`,
-  /** Token data */
-  TOKENS: `${STORAGE_PREFIX}tokens`,
-  /** Pending transfers */
-  PENDING_TRANSFERS: `${STORAGE_PREFIX}pending_transfers`,
-  /** Transfer outbox */
-  OUTBOX: `${STORAGE_PREFIX}outbox`,
-  /** Conversations */
-  CONVERSATIONS: `${STORAGE_PREFIX}conversations`,
-  /** Messages */
-  MESSAGES: `${STORAGE_PREFIX}messages`,
-  /** Transaction history */
-  TRANSACTION_HISTORY: `${STORAGE_PREFIX}transaction_history`,
-  /** Archived tokens (spent token history) */
-  ARCHIVED_TOKENS: `${STORAGE_PREFIX}archived_tokens`,
-  /** Tombstones (records of deleted/spent tokens) */
-  TOMBSTONES: `${STORAGE_PREFIX}tombstones`,
-  /** Forked tokens (alternative histories) */
-  FORKED_TOKENS: `${STORAGE_PREFIX}forked_tokens`
-};
-var DEFAULT_NOSTR_RELAYS = [
-  "wss://relay.unicity.network",
-  "wss://relay.damus.io",
-  "wss://nos.lol",
-  "wss://relay.nostr.band"
-];
-var NOSTR_EVENT_KINDS = {
-  /** NIP-04 encrypted direct message */
-  DIRECT_MESSAGE: 4,
-  /** Token transfer (Unicity custom - 31113) */
-  TOKEN_TRANSFER: 31113,
-  /** Payment request (Unicity custom - 31115) */
-  PAYMENT_REQUEST: 31115,
-  /** Payment request response (Unicity custom - 31116) */
-  PAYMENT_REQUEST_RESPONSE: 31116,
-  /** Nametag binding (NIP-78 app-specific data) */
-  NAMETAG_BINDING: 30078,
-  /** Public broadcast */
-  BROADCAST: 1
-};
-var DEFAULT_AGGREGATOR_URL = "https://aggregator.unicity.network/rpc";
-var DEV_AGGREGATOR_URL = "https://dev-aggregator.dyndns.org/rpc";
-var TEST_AGGREGATOR_URL = "https://goggregator-test.unicity.network";
-var DEFAULT_AGGREGATOR_TIMEOUT = 3e4;
-var DEFAULT_IPFS_GATEWAYS = [
-  "https://ipfs.unicity.network",
-  "https://dweb.link",
-  "https://ipfs.io"
-];
-var DEFAULT_IPFS_BOOTSTRAP_PEERS = [
-  "/dns4/unicity-ipfs2.dyndns.org/tcp/4001/p2p/12D3KooWLNi5NDPPHbrfJakAQqwBqymYTTwMQXQKEWuCrJNDdmfh",
-  "/dns4/unicity-ipfs3.dyndns.org/tcp/4001/p2p/12D3KooWQ4aujVE4ShLjdusNZBdffq3TbzrwT2DuWZY9H1Gxhwn6",
-  "/dns4/unicity-ipfs4.dyndns.org/tcp/4001/p2p/12D3KooWJ1ByPfUzUrpYvgxKU8NZrR8i6PU1tUgMEbQX9Hh2DEn1",
-  "/dns4/unicity-ipfs5.dyndns.org/tcp/4001/p2p/12D3KooWB1MdZZGHN5B8TvWXntbycfe7Cjcz7n6eZ9eykZadvmDv"
-];
-var DEFAULT_BASE_PATH = "m/44'/0'/0'";
-var DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
-var DEFAULT_ELECTRUM_URL = "wss://fulcrum.alpha.unicity.network:50004";
-var TEST_ELECTRUM_URL = "wss://fulcrum.alpha.testnet.unicity.network:50004";
-var TEST_NOSTR_RELAYS = [
-  "wss://nostr-relay.testnet.unicity.network"
-];
-var NETWORKS = {
-  mainnet: {
-    name: "Mainnet",
-    aggregatorUrl: DEFAULT_AGGREGATOR_URL,
-    nostrRelays: DEFAULT_NOSTR_RELAYS,
-    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
-    electrumUrl: DEFAULT_ELECTRUM_URL
-  },
-  testnet: {
-    name: "Testnet",
-    aggregatorUrl: TEST_AGGREGATOR_URL,
-    nostrRelays: TEST_NOSTR_RELAYS,
-    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
-    electrumUrl: TEST_ELECTRUM_URL
-  },
-  dev: {
-    name: "Development",
-    aggregatorUrl: DEV_AGGREGATOR_URL,
-    nostrRelays: TEST_NOSTR_RELAYS,
-    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
-    electrumUrl: TEST_ELECTRUM_URL
-  }
-};
-var TIMEOUTS = {
-  /** WebSocket connection timeout */
-  WEBSOCKET_CONNECT: 1e4,
-  /** Nostr relay reconnect delay */
-  NOSTR_RECONNECT_DELAY: 3e3,
-  /** Max reconnect attempts */
-  MAX_RECONNECT_ATTEMPTS: 5,
-  /** Proof polling interval */
-  PROOF_POLL_INTERVAL: 1e3,
-  /** Sync interval */
-  SYNC_INTERVAL: 6e4
-};
-
-// impl/browser/storage/IpfsStorageProvider.ts
-var import_helia = require("helia");
-var import_json = require("@helia/json");
-var import_bootstrap = require("@libp2p/bootstrap");
-var import_keys = require("@libp2p/crypto/keys");
-var import_peer_id = require("@libp2p/peer-id");
-var import_hkdf = require("@noble/hashes/hkdf.js");
-var import_sha2 = require("@noble/hashes/sha2.js");
-var import_cid = require("multiformats/cid");
-var HKDF_INFO = new TextEncoder().encode("ipfs-storage-key");
-var IpfsStorageProvider = class {
-  id = "ipfs";
-  name = "IPFS Storage";
-  type = "p2p";
-  description = "Decentralized storage via IPFS/IPNS";
-  config;
-  identity = null;
-  status = "disconnected";
-  ipnsName = null;
-  lastCid = null;
-  eventCallbacks = /* @__PURE__ */ new Set();
-  // Helia instance for browser-based IPFS
-  helia = null;
-  heliaJson = null;
-  ipnsKeyPair = null;
-  /** Get the last published CID */
-  getLastCid() {
-    return this.lastCid;
-  }
-  // Local cache for faster loads
-  localCache = null;
-  cacheTimestamp = 0;
-  constructor(config) {
-    this.config = {
-      gateways: config?.gateways ?? [...DEFAULT_IPFS_GATEWAYS],
-      bootstrapPeers: config?.bootstrapPeers ?? [...DEFAULT_IPFS_BOOTSTRAP_PEERS],
-      enableIpns: config?.enableIpns ?? true,
-      ipnsTimeout: config?.ipnsTimeout ?? 3e4,
-      fetchTimeout: config?.fetchTimeout ?? 15e3,
-      debug: config?.debug ?? false
-    };
-  }
-  // ===========================================================================
-  // BaseProvider Implementation
-  // ===========================================================================
-  async connect() {
-    if (this.status === "connected") return;
-    this.status = "connecting";
-    try {
-      await this.testGatewayConnectivity();
-      await this.initializeHelia();
-      this.status = "connected";
-      this.log("Connected to IPFS gateways and Helia initialized");
-    } catch (error) {
-      this.status = "error";
-      throw new Error(`IPFS connection failed: ${error}`);
-    }
-  }
-  /**
-   * Initialize Helia browser IPFS node
-   */
-  async initializeHelia() {
-    if (this.helia) return;
-    try {
-      this.log("Initializing Helia with bootstrap peers...");
-      this.helia = await (0, import_helia.createHelia)({
-        libp2p: {
-          peerDiscovery: [
-            (0, import_bootstrap.bootstrap)({ list: this.config.bootstrapPeers })
-          ],
-          connectionManager: {
-            maxConnections: 10
-          }
-        }
-      });
-      this.heliaJson = (0, import_json.json)(this.helia);
-      const peerId = this.helia.libp2p.peerId.toString();
-      this.log("Helia initialized, browser peer ID:", peerId.slice(0, 20) + "...");
-      setTimeout(() => {
-        const connections = this.helia?.libp2p.getConnections() || [];
-        this.log(`Active Helia connections: ${connections.length}`);
-      }, 3e3);
-    } catch (error) {
-      this.log("Helia initialization failed (will use HTTP only):", error);
-    }
-  }
-  async disconnect() {
-    if (this.helia) {
-      try {
-        await this.helia.stop();
-      } catch (error) {
-        this.log("Error stopping Helia:", error);
-      }
-      this.helia = null;
-      this.heliaJson = null;
-    }
-    this.status = "disconnected";
-    this.localCache = null;
-    this.ipnsKeyPair = null;
-    this.log("Disconnected from IPFS");
-  }
-  isConnected() {
-    return this.status === "connected";
-  }
-  getStatus() {
-    return this.status;
-  }
-  // ===========================================================================
-  // TokenStorageProvider Implementation
-  // ===========================================================================
-  async setIdentity(identity) {
-    this.identity = identity;
-    try {
-      const walletSecret = this.hexToBytes(identity.privateKey);
-      const derivedKey = (0, import_hkdf.hkdf)(import_sha2.sha256, walletSecret, void 0, HKDF_INFO, 32);
-      this.ipnsKeyPair = await (0, import_keys.generateKeyPairFromSeed)("Ed25519", derivedKey);
-      const peerId = (0, import_peer_id.peerIdFromPrivateKey)(this.ipnsKeyPair);
-      this.ipnsName = peerId.toString();
-      this.log("Identity set, IPNS name:", this.ipnsName);
-    } catch {
-      this.ipnsName = identity.ipnsName ?? this.deriveIpnsNameSimple(identity.privateKey);
-      this.log("Identity set with fallback IPNS name:", this.ipnsName);
-    }
-  }
-  async initialize() {
-    if (!this.identity) {
-      throw new Error("Identity must be set before initialization");
-    }
-    try {
-      await this.connect();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async shutdown() {
-    await this.disconnect();
-  }
-  async save(data) {
-    this.ensureReady();
-    this.emitEvent({ type: "storage:saving", timestamp: Date.now() });
-    try {
-      const dataToSave = {
-        ...data,
-        _meta: {
-          ...data._meta,
-          updatedAt: Date.now(),
-          ipnsName: this.ipnsName ?? void 0
-        }
-      };
-      const cid = await this.publishToGateways(dataToSave);
-      if (this.config.enableIpns && this.ipnsName) {
-        await this.publishIpns(cid);
-      }
-      this.localCache = dataToSave;
-      this.cacheTimestamp = Date.now();
-      this.lastCid = cid;
-      this.emitEvent({ type: "storage:saved", timestamp: Date.now(), data: { cid } });
-      return {
-        success: true,
-        cid,
-        timestamp: Date.now()
-      };
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      this.emitEvent({ type: "storage:error", timestamp: Date.now(), error: errorMsg });
-      return {
-        success: false,
-        error: errorMsg,
-        timestamp: Date.now()
-      };
-    }
-  }
-  async load(identifier) {
-    this.ensureReady();
-    this.emitEvent({ type: "storage:loading", timestamp: Date.now() });
-    try {
-      const cacheAge = Date.now() - this.cacheTimestamp;
-      if (this.localCache && cacheAge < 6e4) {
-        this.log("Returning cached data");
-        return {
-          success: true,
-          data: this.localCache,
-          source: "cache",
-          timestamp: Date.now()
-        };
-      }
-      let cid = identifier ?? null;
-      if (!cid && this.config.enableIpns && this.ipnsName) {
-        cid = await this.resolveIpns(this.ipnsName);
-      }
-      if (!cid) {
-        return {
-          success: true,
-          data: void 0,
-          source: "remote",
-          timestamp: Date.now()
-        };
-      }
-      const data = await this.fetchFromGateways(cid);
-      this.localCache = data;
-      this.cacheTimestamp = Date.now();
-      this.lastCid = cid;
-      this.emitEvent({ type: "storage:loaded", timestamp: Date.now() });
-      return {
-        success: true,
-        data,
-        source: "remote",
-        timestamp: Date.now()
-      };
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      this.emitEvent({ type: "storage:error", timestamp: Date.now(), error: errorMsg });
-      if (this.localCache) {
-        return {
-          success: true,
-          data: this.localCache,
-          source: "cache",
-          timestamp: Date.now()
-        };
-      }
-      return {
-        success: false,
-        error: errorMsg,
-        source: "remote",
-        timestamp: Date.now()
-      };
-    }
-  }
-  async sync(localData) {
-    this.ensureReady();
-    this.emitEvent({ type: "sync:started", timestamp: Date.now() });
-    try {
-      const remoteResult = await this.load();
-      const remoteData = remoteResult.data;
-      if (!remoteData) {
-        await this.save(localData);
-        this.emitEvent({ type: "sync:completed", timestamp: Date.now() });
-        return {
-          success: true,
-          merged: localData,
-          added: 0,
-          removed: 0,
-          conflicts: 0
-        };
-      }
-      const mergeResult = this.mergeData(localData, remoteData);
-      await this.save(mergeResult.merged);
-      this.emitEvent({ type: "sync:completed", timestamp: Date.now() });
-      return {
-        success: true,
-        merged: mergeResult.merged,
-        added: mergeResult.added,
-        removed: mergeResult.removed,
-        conflicts: mergeResult.conflicts
-      };
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      this.emitEvent({ type: "sync:error", timestamp: Date.now(), error: errorMsg });
-      return {
-        success: false,
-        added: 0,
-        removed: 0,
-        conflicts: 0,
-        error: errorMsg
-      };
-    }
-  }
-  async exists() {
-    if (!this.ipnsName) return false;
-    try {
-      const cid = await this.resolveIpns(this.ipnsName);
-      return cid !== null;
-    } catch {
-      return false;
-    }
-  }
-  async clear() {
-    const emptyData = {
-      _meta: {
-        version: 0,
-        address: this.identity?.address ?? "",
-        formatVersion: "2.0",
-        updatedAt: Date.now()
-      },
-      _tombstones: []
-    };
-    const result = await this.save(emptyData);
-    return result.success;
-  }
-  onEvent(callback) {
-    this.eventCallbacks.add(callback);
-    return () => this.eventCallbacks.delete(callback);
-  }
-  // ===========================================================================
-  // Private: IPFS Operations
-  // ===========================================================================
-  async testGatewayConnectivity() {
-    const gateway = this.config.gateways[0];
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5e3);
-    try {
-      const response = await fetch(`${gateway}/api/v0/version`, {
-        method: "POST",
-        signal: controller.signal
-      });
-      if (!response.ok) throw new Error("Gateway not responding");
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-  async publishToGateways(data) {
-    const content = JSON.stringify(data);
-    const blob = new Blob([content], { type: "application/json" });
-    const promises = [];
-    for (const gateway of this.config.gateways) {
-      promises.push(this.publishToGateway(gateway, blob));
-    }
-    if (this.heliaJson) {
-      promises.push(this.publishToHelia(data));
-    }
-    try {
-      const cid = await Promise.any(promises);
-      this.log("Published to IPFS, CID:", cid);
-      return cid;
-    } catch {
-      throw new Error("All publish attempts failed");
-    }
-  }
-  /**
-   * Publish data via Helia (browser DHT)
-   */
-  async publishToHelia(data) {
-    if (!this.heliaJson) {
-      throw new Error("Helia not initialized");
-    }
-    const cid = await this.heliaJson.add(data);
-    this.log("Published via Helia, CID:", cid.toString());
-    return cid.toString();
-  }
-  async publishToGateway(gateway, blob) {
-    const formData = new FormData();
-    formData.append("file", blob);
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.config.fetchTimeout);
-    try {
-      const response = await fetch(`${gateway}/api/v0/add?pin=true`, {
-        method: "POST",
-        body: formData,
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        throw new Error(`Gateway ${gateway} returned ${response.status}`);
-      }
-      const result = await response.json();
-      return result.Hash;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-  async publishIpns(cid) {
-    if (!this.identity) return;
-    const promises = this.config.gateways.map(
-      (gateway) => this.publishIpnsToGateway(gateway, cid).catch(() => null)
-    );
-    await Promise.allSettled(promises);
-    this.log("Published IPNS:", this.ipnsName, "->", cid);
-  }
-  async publishIpnsToGateway(gateway, cid) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.config.ipnsTimeout);
-    try {
-      const response = await fetch(
-        `${gateway}/api/v0/name/publish?arg=${cid}&key=${this.ipnsName}`,
-        {
-          method: "POST",
-          signal: controller.signal
-        }
-      );
-      if (!response.ok) {
-        throw new Error(`IPNS publish failed: ${response.status}`);
-      }
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-  async resolveIpns(name) {
-    for (const gateway of this.config.gateways) {
-      try {
-        return await this.resolveIpnsFromGateway(gateway, name);
-      } catch {
-        continue;
-      }
-    }
-    return null;
-  }
-  async resolveIpnsFromGateway(gateway, name) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.config.fetchTimeout);
-    try {
-      const response = await fetch(`${gateway}/api/v0/name/resolve?arg=${name}`, {
-        method: "POST",
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        throw new Error(`IPNS resolve failed: ${response.status}`);
-      }
-      const result = await response.json();
-      return result.Path.replace("/ipfs/", "");
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-  async fetchFromGateways(cid) {
-    const promises = [];
-    for (const gateway of this.config.gateways) {
-      promises.push(this.fetchFromGateway(gateway, cid));
-    }
-    if (this.heliaJson) {
-      promises.push(this.fetchFromHelia(cid));
-    }
-    return Promise.any(promises);
-  }
-  /**
-   * Fetch content via Helia (browser DHT)
-   */
-  async fetchFromHelia(cidString) {
-    if (!this.heliaJson) {
-      throw new Error("Helia not initialized");
-    }
-    const cid = import_cid.CID.parse(cidString);
-    const data = await this.heliaJson.get(cid);
-    this.log("Fetched via Helia, CID:", cidString);
-    return data;
-  }
-  async fetchFromGateway(gateway, cid) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.config.fetchTimeout);
-    try {
-      const response = await fetch(`${gateway}/ipfs/${cid}`, {
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        throw new Error(`Fetch failed: ${response.status}`);
-      }
-      return response.json();
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-  // ===========================================================================
-  // Private: Merge Logic
-  // ===========================================================================
-  mergeData(local, remote) {
-    const localVersion = local._meta?.version ?? 0;
-    const remoteVersion = remote._meta?.version ?? 0;
-    const baseMeta = remoteVersion > localVersion ? remote._meta : local._meta;
-    const tombstones = /* @__PURE__ */ new Map();
-    for (const t of local._tombstones ?? []) {
-      tombstones.set(t.tokenId, t);
-    }
-    for (const t of remote._tombstones ?? []) {
-      const existing = tombstones.get(t.tokenId);
-      if (!existing || t.timestamp > existing.timestamp) {
-        tombstones.set(t.tokenId, t);
-      }
-    }
-    const merged = {
-      _meta: {
-        ...baseMeta,
-        version: Math.max(localVersion, remoteVersion) + 1,
-        updatedAt: Date.now()
-      },
-      _tombstones: Array.from(tombstones.values())
-    };
-    let added = 0;
-    let conflicts = 0;
-    const processedKeys = /* @__PURE__ */ new Set();
-    for (const key of Object.keys(local)) {
-      if (!key.startsWith("_") || key === "_meta" || key === "_tombstones") continue;
-      processedKeys.add(key);
-      const tokenId = key.slice(1);
-      if (tombstones.has(tokenId)) continue;
-      const localToken = local[key];
-      const remoteToken = remote[key];
-      if (remoteToken) {
-        conflicts++;
-        merged[key] = localToken;
-      } else {
-        merged[key] = localToken;
-      }
-    }
-    for (const key of Object.keys(remote)) {
-      if (!key.startsWith("_") || key === "_meta" || key === "_tombstones") continue;
-      if (processedKeys.has(key)) continue;
-      const tokenId = key.slice(1);
-      if (tombstones.has(tokenId)) continue;
-      merged[key] = remote[key];
-      added++;
-    }
-    return { merged, added, removed: 0, conflicts };
-  }
-  // ===========================================================================
-  // Private: Helpers
-  // ===========================================================================
-  ensureReady() {
-    if (this.status !== "connected") {
-      throw new Error("IpfsStorageProvider not connected");
-    }
-    if (!this.identity) {
-      throw new Error("Identity not set");
-    }
-  }
-  /**
-   * Simple IPNS name derivation (fallback when libp2p is unavailable)
-   */
-  deriveIpnsNameSimple(privateKey) {
-    return `12D3KooW${privateKey.slice(0, 40)}`;
-  }
-  /**
-   * Convert hex string to Uint8Array
-   */
-  hexToBytes(hex) {
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < bytes.length; i++) {
-      bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
-    }
-    return bytes;
-  }
-  emitEvent(event) {
-    for (const callback of this.eventCallbacks) {
-      try {
-        callback(event);
-      } catch (error) {
-        console.error("[IpfsStorageProvider] Event callback error:", error);
-      }
-    }
-  }
-  log(...args) {
-    if (this.config.debug) {
-      console.log("[IpfsStorageProvider]", ...args);
-    }
-  }
-};
-function createIpfsStorageProvider(config) {
-  return new IpfsStorageProvider(config);
-}
-
 // impl/browser/storage/IndexedDBTokenStorageProvider.ts
 var DB_NAME = "sphere-token-storage";
 var DB_VERSION = 1;
@@ -902,7 +240,7 @@ var IndexedDBTokenStorageProvider = class {
   }
   setIdentity(identity) {
     this.identity = identity;
-    this.dbName = `${DB_NAME}-${identity.address.slice(0, 20)}`;
+    this.dbName = `${DB_NAME}-${identity.l1Address.slice(0, 20)}`;
   }
   async initialize() {
     try {
@@ -947,7 +285,7 @@ var IndexedDBTokenStorageProvider = class {
       const data = {
         _meta: {
           version: 1,
-          address: this.identity?.address ?? "",
+          address: this.identity?.l1Address ?? "",
           formatVersion: "2.0",
           updatedAt: Date.now()
         }
@@ -1175,34 +513,750 @@ var IndexedDBTokenStorageProvider = class {
     });
   }
 };
-function createIndexedDBTokenStorageProvider(config) {
-  return new IndexedDBTokenStorageProvider(config);
-}
-
-// transport/NostrTransportProvider.ts
-var import_buffer = require("buffer");
-var import_nostr_js_sdk = require("@unicitylabs/nostr-js-sdk");
-
-// transport/websocket.ts
-var WebSocketReadyState = {
-  CONNECTING: 0,
-  OPEN: 1,
-  CLOSING: 2,
-  CLOSED: 3
+function createIndexedDBTokenStorageProvider(config) {
+  return new IndexedDBTokenStorageProvider(config);
+}
+
+// transport/NostrTransportProvider.ts
+var import_buffer = require("buffer");
+
+// node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n, title = "") {
+  if (!Number.isSafeInteger(n) || n < 0) {
+    const prefix = title && `"${title}" `;
+    throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+  }
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash must wrapped by utils.createHasher");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// node_modules/@noble/hashes/hmac.js
+var _HMAC = class {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  finished = false;
+  destroyed = false;
+  constructor(hash, key) {
+    ahash(hash);
+    abytes(key, void 0, "key");
+    this.iHash = hash.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash.create();
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    clean(pad);
+  }
+  update(buf) {
+    aexists(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    abytes(out, this.outputLen, "output");
+    this.finished = true;
+    this.iHash.digestInto(out);
+    this.oHash.update(out);
+    this.oHash.digestInto(out);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+};
+var hmac = (hash, key, message) => new _HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new _HMAC(hash, key);
+
+// node_modules/@noble/hashes/hkdf.js
+function extract(hash, ikm, salt) {
+  ahash(hash);
+  if (salt === void 0)
+    salt = new Uint8Array(hash.outputLen);
+  return hmac(hash, salt, ikm);
+}
+var HKDF_COUNTER = /* @__PURE__ */ Uint8Array.of(0);
+var EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+function expand(hash, prk, info, length = 32) {
+  ahash(hash);
+  anumber(length, "length");
+  const olen = hash.outputLen;
+  if (length > 255 * olen)
+    throw new Error("Length must be <= 255*HashLen");
+  const blocks = Math.ceil(length / olen);
+  if (info === void 0)
+    info = EMPTY_BUFFER;
+  else
+    abytes(info, void 0, "info");
+  const okm = new Uint8Array(blocks * olen);
+  const HMAC = hmac.create(hash, prk);
+  const HMACTmp = HMAC._cloneInto();
+  const T = new Uint8Array(HMAC.outputLen);
+  for (let counter = 0; counter < blocks; counter++) {
+    HKDF_COUNTER[0] = counter + 1;
+    HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T).update(info).update(HKDF_COUNTER).digestInto(T);
+    okm.set(T, olen * counter);
+    HMAC._cloneInto(HMACTmp);
+  }
+  HMAC.destroy();
+  HMACTmp.destroy();
+  clean(T, HKDF_COUNTER);
+  return okm.slice(0, length);
+}
+var hkdf = (hash, ikm, salt, info, length) => expand(hash, extract(hash, ikm, salt), info, length);
+
+// node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+  blockLen;
+  outputLen;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor();
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+  constructor(outputLen) {
+    super(64, outputLen, 8, false);
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var _SHA256 = class extends SHA2_32B {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  A = SHA256_IV[0] | 0;
+  B = SHA256_IV[1] | 0;
+  C = SHA256_IV[2] | 0;
+  D = SHA256_IV[3] | 0;
+  E = SHA256_IV[4] | 0;
+  F = SHA256_IV[5] | 0;
+  G = SHA256_IV[6] | 0;
+  H = SHA256_IV[7] | 0;
+  constructor() {
+    super(32);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+
+// transport/NostrTransportProvider.ts
+var import_nostr_js_sdk = require("@unicitylabs/nostr-js-sdk");
+
+// core/crypto.ts
+var bip39 = __toESM(require("bip39"), 1);
+var import_crypto_js = __toESM(require("crypto-js"), 1);
+var import_elliptic = __toESM(require("elliptic"), 1);
+
+// core/bech32.ts
+var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function convertBits(data, fromBits, toBits, pad) {
+  let acc = 0;
+  let bits = 0;
+  const ret = [];
+  const maxv = (1 << toBits) - 1;
+  for (let i = 0; i < data.length; i++) {
+    const value = data[i];
+    if (value < 0 || value >> fromBits !== 0) return null;
+    acc = acc << fromBits | value;
+    bits += fromBits;
+    while (bits >= toBits) {
+      bits -= toBits;
+      ret.push(acc >> bits & maxv);
+    }
+  }
+  if (pad) {
+    if (bits > 0) {
+      ret.push(acc << toBits - bits & maxv);
+    }
+  } else if (bits >= fromBits || acc << toBits - bits & maxv) {
+    return null;
+  }
+  return ret;
+}
+function hrpExpand(hrp) {
+  const ret = [];
+  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) >> 5);
+  ret.push(0);
+  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) & 31);
+  return ret;
+}
+function bech32Polymod(values) {
+  let chk = 1;
+  for (let p = 0; p < values.length; p++) {
+    const top = chk >> 25;
+    chk = (chk & 33554431) << 5 ^ values[p];
+    for (let i = 0; i < 5; i++) {
+      if (top >> i & 1) chk ^= GENERATOR[i];
+    }
+  }
+  return chk;
+}
+function bech32Checksum(hrp, data) {
+  const values = hrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0]);
+  const mod = bech32Polymod(values) ^ 1;
+  const ret = [];
+  for (let p = 0; p < 6; p++) {
+    ret.push(mod >> 5 * (5 - p) & 31);
+  }
+  return ret;
+}
+function encodeBech32(hrp, version, program) {
+  if (version < 0 || version > 16) {
+    throw new Error("Invalid witness version");
+  }
+  const converted = convertBits(Array.from(program), 8, 5, true);
+  if (!converted) {
+    throw new Error("Failed to convert bits");
+  }
+  const data = [version].concat(converted);
+  const checksum = bech32Checksum(hrp, data);
+  const combined = data.concat(checksum);
+  let out = hrp + "1";
+  for (let i = 0; i < combined.length; i++) {
+    out += CHARSET[combined[i]];
+  }
+  return out;
+}
+
+// core/crypto.ts
+var ec = new import_elliptic.default.ec("secp256k1");
+var CURVE_ORDER = BigInt(
+  "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"
+);
+function getPublicKey(privateKey, compressed = true) {
+  const keyPair = ec.keyFromPrivate(privateKey, "hex");
+  return keyPair.getPublic(compressed, "hex");
+}
+function sha2562(data, inputEncoding = "hex") {
+  const parsed = inputEncoding === "hex" ? import_crypto_js.default.enc.Hex.parse(data) : import_crypto_js.default.enc.Utf8.parse(data);
+  return import_crypto_js.default.SHA256(parsed).toString();
+}
+function ripemd160(data, inputEncoding = "hex") {
+  const parsed = inputEncoding === "hex" ? import_crypto_js.default.enc.Hex.parse(data) : import_crypto_js.default.enc.Utf8.parse(data);
+  return import_crypto_js.default.RIPEMD160(parsed).toString();
+}
+function hash160(data) {
+  const sha = sha2562(data, "hex");
+  return ripemd160(sha, "hex");
+}
+function hash160ToBytes(hash160Hex) {
+  const matches = hash160Hex.match(/../g);
+  if (!matches) return new Uint8Array(0);
+  return Uint8Array.from(matches.map((x) => parseInt(x, 16)));
+}
+function publicKeyToAddress(publicKey, prefix = "alpha", witnessVersion = 0) {
+  const pubKeyHash = hash160(publicKey);
+  const programBytes = hash160ToBytes(pubKeyHash);
+  return encodeBech32(prefix, witnessVersion, programBytes);
+}
+
+// transport/websocket.ts
+var WebSocketReadyState = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+function defaultUUIDGenerator() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// constants.ts
+var STORAGE_PREFIX = "sphere_";
+var STORAGE_KEYS = {
+  /** Encrypted BIP39 mnemonic */
+  MNEMONIC: `${STORAGE_PREFIX}mnemonic`,
+  /** Encrypted master private key */
+  MASTER_KEY: `${STORAGE_PREFIX}master_key`,
+  /** BIP32 chain code */
+  CHAIN_CODE: `${STORAGE_PREFIX}chain_code`,
+  /** HD derivation path (full path like m/44'/0'/0'/0/0) */
+  DERIVATION_PATH: `${STORAGE_PREFIX}derivation_path`,
+  /** Base derivation path (like m/44'/0'/0' without chain/index) */
+  BASE_PATH: `${STORAGE_PREFIX}base_path`,
+  /** Derivation mode: bip32, wif_hmac, legacy_hmac */
+  DERIVATION_MODE: `${STORAGE_PREFIX}derivation_mode`,
+  /** Wallet source: mnemonic, file, unknown */
+  WALLET_SOURCE: `${STORAGE_PREFIX}wallet_source`,
+  /** Wallet existence flag */
+  WALLET_EXISTS: `${STORAGE_PREFIX}wallet_exists`,
+  /** Registered nametag (legacy - single address) */
+  NAMETAG: `${STORAGE_PREFIX}nametag`,
+  /** Current active address index */
+  CURRENT_ADDRESS_INDEX: `${STORAGE_PREFIX}current_address_index`,
+  /** Address nametags map (JSON: { "0": "alice", "1": "bob" }) */
+  ADDRESS_NAMETAGS: `${STORAGE_PREFIX}address_nametags`,
+  /** Token data */
+  TOKENS: `${STORAGE_PREFIX}tokens`,
+  /** Pending transfers */
+  PENDING_TRANSFERS: `${STORAGE_PREFIX}pending_transfers`,
+  /** Transfer outbox */
+  OUTBOX: `${STORAGE_PREFIX}outbox`,
+  /** Conversations */
+  CONVERSATIONS: `${STORAGE_PREFIX}conversations`,
+  /** Messages */
+  MESSAGES: `${STORAGE_PREFIX}messages`,
+  /** Transaction history */
+  TRANSACTION_HISTORY: `${STORAGE_PREFIX}transaction_history`,
+  /** Archived tokens (spent token history) */
+  ARCHIVED_TOKENS: `${STORAGE_PREFIX}archived_tokens`,
+  /** Tombstones (records of deleted/spent tokens) */
+  TOMBSTONES: `${STORAGE_PREFIX}tombstones`,
+  /** Forked tokens (alternative histories) */
+  FORKED_TOKENS: `${STORAGE_PREFIX}forked_tokens`
+};
+var DEFAULT_NOSTR_RELAYS = [
+  "wss://relay.unicity.network",
+  "wss://relay.damus.io",
+  "wss://nos.lol",
+  "wss://relay.nostr.band"
+];
+var NOSTR_EVENT_KINDS = {
+  /** NIP-04 encrypted direct message */
+  DIRECT_MESSAGE: 4,
+  /** Token transfer (Unicity custom - 31113) */
+  TOKEN_TRANSFER: 31113,
+  /** Payment request (Unicity custom - 31115) */
+  PAYMENT_REQUEST: 31115,
+  /** Payment request response (Unicity custom - 31116) */
+  PAYMENT_REQUEST_RESPONSE: 31116,
+  /** Nametag binding (NIP-78 app-specific data) */
+  NAMETAG_BINDING: 30078,
+  /** Public broadcast */
+  BROADCAST: 1
+};
+var DEFAULT_AGGREGATOR_URL = "https://aggregator.unicity.network/rpc";
+var DEV_AGGREGATOR_URL = "https://dev-aggregator.dyndns.org/rpc";
+var TEST_AGGREGATOR_URL = "https://goggregator-test.unicity.network";
+var DEFAULT_AGGREGATOR_TIMEOUT = 3e4;
+var DEFAULT_IPFS_GATEWAYS = [
+  "https://ipfs.unicity.network",
+  "https://dweb.link",
+  "https://ipfs.io"
+];
+var DEFAULT_BASE_PATH = "m/44'/0'/0'";
+var DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
+var DEFAULT_ELECTRUM_URL = "wss://fulcrum.alpha.unicity.network:50004";
+var TEST_ELECTRUM_URL = "wss://fulcrum.alpha.testnet.unicity.network:50004";
+var TEST_NOSTR_RELAYS = [
+  "wss://nostr-relay.testnet.unicity.network"
+];
+var NETWORKS = {
+  mainnet: {
+    name: "Mainnet",
+    aggregatorUrl: DEFAULT_AGGREGATOR_URL,
+    nostrRelays: DEFAULT_NOSTR_RELAYS,
+    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
+    electrumUrl: DEFAULT_ELECTRUM_URL
+  },
+  testnet: {
+    name: "Testnet",
+    aggregatorUrl: TEST_AGGREGATOR_URL,
+    nostrRelays: TEST_NOSTR_RELAYS,
+    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
+    electrumUrl: TEST_ELECTRUM_URL
+  },
+  dev: {
+    name: "Development",
+    aggregatorUrl: DEV_AGGREGATOR_URL,
+    nostrRelays: TEST_NOSTR_RELAYS,
+    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
+    electrumUrl: TEST_ELECTRUM_URL
+  }
+};
+var TIMEOUTS = {
+  /** WebSocket connection timeout */
+  WEBSOCKET_CONNECT: 1e4,
+  /** Nostr relay reconnect delay */
+  NOSTR_RECONNECT_DELAY: 3e3,
+  /** Max reconnect attempts */
+  MAX_RECONNECT_ATTEMPTS: 5,
+  /** Proof polling interval */
+  PROOF_POLL_INTERVAL: 1e3,
+  /** Sync interval */
+  SYNC_INTERVAL: 6e4
 };
-function defaultUUIDGenerator() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
 
 // transport/NostrTransportProvider.ts
 var EVENT_KINDS = NOSTR_EVENT_KINDS;
+function deriveNametagEncryptionKey(privateKeyHex) {
+  const privateKeyBytes = import_buffer.Buffer.from(privateKeyHex, "hex");
+  const saltInput = new TextEncoder().encode("sphere-nametag-salt");
+  const salt = sha256(saltInput);
+  const info = new TextEncoder().encode("nametag-encryption");
+  return hkdf(sha256, privateKeyBytes, salt, info, 32);
+}
+async function encryptNametag(nametag, privateKeyHex) {
+  const key = deriveNametagEncryptionKey(privateKeyHex);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encoder = new TextEncoder();
+  const data = encoder.encode(nametag);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    new Uint8Array(key).buffer,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt"]
+  );
+  const encrypted = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv: new Uint8Array(iv).buffer },
+    cryptoKey,
+    new Uint8Array(data).buffer
+  );
+  const combined = new Uint8Array(iv.length + encrypted.byteLength);
+  combined.set(iv, 0);
+  combined.set(new Uint8Array(encrypted), iv.length);
+  return import_buffer.Buffer.from(combined).toString("base64");
+}
+async function decryptNametag(encryptedBase64, privateKeyHex) {
+  try {
+    const key = deriveNametagEncryptionKey(privateKeyHex);
+    const combined = import_buffer.Buffer.from(encryptedBase64, "base64");
+    const iv = combined.slice(0, 12);
+    const ciphertext = combined.slice(12);
+    const cryptoKey = await crypto.subtle.importKey(
+      "raw",
+      new Uint8Array(key).buffer,
+      { name: "AES-GCM" },
+      false,
+      ["decrypt"]
+    );
+    const decrypted = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: new Uint8Array(iv).buffer },
+      cryptoKey,
+      new Uint8Array(ciphertext).buffer
+    );
+    const decoder = new TextDecoder();
+    return decoder.decode(decrypted);
+  } catch {
+    return null;
+  }
+}
 var NostrTransportProvider = class {
   id = "nostr";
   name = "Nostr Transport";
@@ -1212,9 +1266,10 @@ var NostrTransportProvider = class {
   identity = null;
   keyManager = null;
   status = "disconnected";
-  // WebSocket connections to relays
-  connections = /* @__PURE__ */ new Map();
-  reconnectAttempts = /* @__PURE__ */ new Map();
+  // NostrClient from nostr-js-sdk handles all WebSocket management,
+  // keepalive pings, reconnection, and NIP-42 authentication
+  nostrClient = null;
+  mainSubscriptionId = null;
   // Event handlers
   messageHandlers = /* @__PURE__ */ new Set();
   transferHandlers = /* @__PURE__ */ new Set();
@@ -1222,9 +1277,6 @@ var NostrTransportProvider = class {
   paymentRequestResponseHandlers = /* @__PURE__ */ new Set();
   broadcastHandlers = /* @__PURE__ */ new Map();
   eventCallbacks = /* @__PURE__ */ new Set();
-  // Subscriptions
-  subscriptions = /* @__PURE__ */ new Map();
-  // subId -> relays
   constructor(config) {
     this.config = {
       relays: config.relays ?? [...DEFAULT_NOSTR_RELAYS],
@@ -1244,16 +1296,43 @@ var NostrTransportProvider = class {
     if (this.status === "connected") return;
     this.status = "connecting";
     try {
-      const connectPromises = this.config.relays.map(
-        (relay) => this.connectToRelay(relay)
-      );
-      await Promise.allSettled(connectPromises);
-      if (this.connections.size === 0) {
+      if (!this.keyManager) {
+        const tempKey = import_buffer.Buffer.alloc(32);
+        crypto.getRandomValues(tempKey);
+        this.keyManager = import_nostr_js_sdk.NostrKeyManager.fromPrivateKey(tempKey);
+      }
+      this.nostrClient = new import_nostr_js_sdk.NostrClient(this.keyManager, {
+        autoReconnect: this.config.autoReconnect,
+        reconnectIntervalMs: this.config.reconnectDelay,
+        maxReconnectIntervalMs: this.config.reconnectDelay * 16,
+        // exponential backoff cap
+        pingIntervalMs: 15e3
+        // 15 second keepalive pings (more aggressive to prevent drops)
+      });
+      this.nostrClient.addConnectionListener({
+        onConnect: (url) => {
+          this.log("NostrClient connected to relay:", url);
+          this.emitEvent({ type: "transport:connected", timestamp: Date.now() });
+        },
+        onDisconnect: (url, reason) => {
+          this.log("NostrClient disconnected from relay:", url, "reason:", reason);
+        },
+        onReconnecting: (url, attempt) => {
+          this.log("NostrClient reconnecting to relay:", url, "attempt:", attempt);
+          this.emitEvent({ type: "transport:reconnecting", timestamp: Date.now() });
+        },
+        onReconnected: (url) => {
+          this.log("NostrClient reconnected to relay:", url);
+          this.emitEvent({ type: "transport:connected", timestamp: Date.now() });
+        }
+      });
+      await this.nostrClient.connect(...this.config.relays);
+      if (!this.nostrClient.isConnected()) {
         throw new Error("Failed to connect to any relay");
       }
       this.status = "connected";
       this.emitEvent({ type: "transport:connected", timestamp: Date.now() });
-      this.log("Connected to", this.connections.size, "relays");
+      this.log("Connected to", this.nostrClient.getConnectedRelays().size, "relays");
       if (this.identity) {
         this.subscribeToEvents();
       }
@@ -1263,17 +1342,19 @@ var NostrTransportProvider = class {
     }
   }
   async disconnect() {
-    for (const [url, ws] of this.connections) {
-      ws.close();
-      this.connections.delete(url);
+    if (this.nostrClient) {
+      this.nostrClient.disconnect();
+      this.nostrClient = null;
     }
-    this.subscriptions.clear();
+    this.mainSubscriptionId = null;
+    this.walletSubscriptionId = null;
+    this.chatSubscriptionId = null;
     this.status = "disconnected";
     this.emitEvent({ type: "transport:disconnected", timestamp: Date.now() });
     this.log("Disconnected from all relays");
   }
   isConnected() {
-    return this.status === "connected" && this.connections.size > 0;
+    return this.status === "connected" && this.nostrClient?.isConnected() === true;
   }
   getStatus() {
     return this.status;
@@ -1291,7 +1372,8 @@ var NostrTransportProvider = class {
    * Get list of currently connected relay URLs
    */
   getConnectedRelays() {
-    return Array.from(this.connections.keys());
+    if (!this.nostrClient) return [];
+    return Array.from(this.nostrClient.getConnectedRelays());
   }
   /**
    * Add a new relay dynamically
@@ -1303,9 +1385,9 @@ var NostrTransportProvider = class {
       return false;
     }
     this.config.relays.push(relayUrl);
-    if (this.status === "connected") {
+    if (this.status === "connected" && this.nostrClient) {
       try {
-        await this.connectToRelay(relayUrl);
+        await this.nostrClient.connect(relayUrl);
         this.log("Added and connected to relay:", relayUrl);
         this.emitEvent({
           type: "transport:relay_added",
@@ -1333,6 +1415,8 @@ var NostrTransportProvider = class {
   /**
    * Remove a relay dynamically
    * Will disconnect from the relay if connected
+   * NOTE: NostrClient doesn't support removing individual relays at runtime.
+   * We remove from config so it won't be used on next connect().
    */
   async removeRelay(relayUrl) {
     const index = this.config.relays.indexOf(relayUrl);
@@ -1341,19 +1425,13 @@ var NostrTransportProvider = class {
       return false;
     }
     this.config.relays.splice(index, 1);
-    const ws = this.connections.get(relayUrl);
-    if (ws) {
-      ws.close();
-      this.connections.delete(relayUrl);
-      this.reconnectAttempts.delete(relayUrl);
-      this.log("Removed and disconnected from relay:", relayUrl);
-    }
+    this.log("Removed relay from config:", relayUrl);
     this.emitEvent({
       type: "transport:relay_removed",
       timestamp: Date.now(),
       data: { relay: relayUrl }
     });
-    if (this.connections.size === 0 && this.status === "connected") {
+    if (this.nostrClient && !this.nostrClient.isConnected() && this.status === "connected") {
       this.status = "error";
       this.emitEvent({
         type: "transport:error",
@@ -1373,8 +1451,8 @@ var NostrTransportProvider = class {
    * Check if a relay is currently connected
    */
   isRelayConnected(relayUrl) {
-    const ws = this.connections.get(relayUrl);
-    return ws !== void 0 && ws.readyState === WebSocketReadyState.OPEN;
+    if (!this.nostrClient) return false;
+    return this.nostrClient.getConnectedRelays().has(relayUrl);
   }
   // ===========================================================================
   // TransportProvider Implementation
@@ -1385,7 +1463,37 @@ var NostrTransportProvider = class {
     this.keyManager = import_nostr_js_sdk.NostrKeyManager.fromPrivateKey(secretKey);
     const nostrPubkey = this.keyManager.getPublicKeyHex();
     this.log("Identity set, Nostr pubkey:", nostrPubkey.slice(0, 16) + "...");
-    if (this.isConnected()) {
+    if (this.nostrClient && this.status === "connected") {
+      this.log("Identity changed while connected - recreating NostrClient");
+      const oldClient = this.nostrClient;
+      this.nostrClient = new import_nostr_js_sdk.NostrClient(this.keyManager, {
+        autoReconnect: this.config.autoReconnect,
+        reconnectIntervalMs: this.config.reconnectDelay,
+        maxReconnectIntervalMs: this.config.reconnectDelay * 16,
+        pingIntervalMs: 15e3
+        // 15 second keepalive pings
+      });
+      this.nostrClient.addConnectionListener({
+        onConnect: (url) => {
+          this.log("NostrClient connected to relay:", url);
+        },
+        onDisconnect: (url, reason) => {
+          this.log("NostrClient disconnected from relay:", url, "reason:", reason);
+        },
+        onReconnecting: (url, attempt) => {
+          this.log("NostrClient reconnecting to relay:", url, "attempt:", attempt);
+        },
+        onReconnected: (url) => {
+          this.log("NostrClient reconnected to relay:", url);
+        }
+      });
+      this.nostrClient.connect(...this.config.relays).then(() => {
+        this.subscribeToEvents();
+        oldClient.disconnect();
+      }).catch((err) => {
+        this.log("Failed to reconnect with new identity:", err);
+      });
+    } else if (this.isConnected()) {
       this.subscribeToEvents();
     }
   }
@@ -1401,18 +1509,17 @@ var NostrTransportProvider = class {
   }
   async sendMessage(recipientPubkey, content) {
     this.ensureReady();
-    const event = await this.createEncryptedEvent(
-      EVENT_KINDS.DIRECT_MESSAGE,
-      content,
-      [["p", recipientPubkey]]
-    );
-    await this.publishEvent(event);
+    const nostrRecipient = recipientPubkey.length === 66 && (recipientPubkey.startsWith("02") || recipientPubkey.startsWith("03")) ? recipientPubkey.slice(2) : recipientPubkey;
+    const senderNametag = this.identity?.nametag;
+    const wrappedContent = senderNametag ? JSON.stringify({ senderNametag, text: content }) : content;
+    const giftWrap = import_nostr_js_sdk.NIP17.createGiftWrap(this.keyManager, nostrRecipient, wrappedContent);
+    await this.publishEvent(giftWrap);
     this.emitEvent({
       type: "message:sent",
       timestamp: Date.now(),
       data: { recipient: recipientPubkey }
     });
-    return event.id;
+    return giftWrap.id;
   }
   onMessage(handler) {
     this.messageHandlers.add(handler);
@@ -1529,6 +1636,118 @@ var NostrTransportProvider = class {
     if (pubkeyTag?.[1]) return pubkeyTag[1];
     return null;
   }
+  async resolveNametagInfo(nametag) {
+    this.ensureReady();
+    const hashedNametag = (0, import_nostr_js_sdk.hashNametag)(nametag);
+    let events = await this.queryEvents({
+      kinds: [EVENT_KINDS.NAMETAG_BINDING],
+      "#t": [hashedNametag],
+      limit: 1
+    });
+    if (events.length === 0) {
+      events = await this.queryEvents({
+        kinds: [EVENT_KINDS.NAMETAG_BINDING],
+        "#d": [hashedNametag],
+        limit: 1
+      });
+    }
+    if (events.length === 0) return null;
+    const bindingEvent = events[0];
+    try {
+      const content = JSON.parse(bindingEvent.content);
+      if (content.public_key && content.l1_address) {
+        const l3Address = `PROXY:${hashedNametag}`;
+        return {
+          nametag,
+          transportPubkey: bindingEvent.pubkey,
+          chainPubkey: content.public_key,
+          l1Address: content.l1_address,
+          directAddress: content.direct_address || "",
+          proxyAddress: l3Address,
+          timestamp: bindingEvent.created_at * 1e3
+        };
+      }
+      this.log("Legacy nametag event without extended fields:", nametag);
+      const pubkeyTag = bindingEvent.tags.find((t) => t[0] === "pubkey");
+      const l1Tag = bindingEvent.tags.find((t) => t[0] === "l1");
+      if (pubkeyTag?.[1] && l1Tag?.[1]) {
+        const l3Address = `PROXY:${hashedNametag}`;
+        return {
+          nametag,
+          transportPubkey: bindingEvent.pubkey,
+          chainPubkey: pubkeyTag[1],
+          l1Address: l1Tag[1],
+          directAddress: "",
+          proxyAddress: l3Address,
+          timestamp: bindingEvent.created_at * 1e3
+        };
+      }
+      return {
+        nametag,
+        transportPubkey: bindingEvent.pubkey,
+        chainPubkey: "",
+        // Cannot derive from 32-byte Nostr pubkey
+        l1Address: "",
+        // Cannot derive without 33-byte pubkey
+        directAddress: "",
+        proxyAddress: `PROXY:${hashedNametag}`,
+        timestamp: bindingEvent.created_at * 1e3
+      };
+    } catch {
+      return {
+        nametag,
+        transportPubkey: bindingEvent.pubkey,
+        chainPubkey: "",
+        l1Address: "",
+        directAddress: "",
+        proxyAddress: `PROXY:${hashedNametag}`,
+        timestamp: bindingEvent.created_at * 1e3
+      };
+    }
+  }
+  /**
+   * Recover nametag for the current identity by searching for encrypted nametag events
+   * Used after wallet import to recover associated nametag
+   * @returns Decrypted nametag or null if none found
+   */
+  async recoverNametag() {
+    this.ensureReady();
+    if (!this.identity || !this.keyManager) {
+      throw new Error("Identity not set");
+    }
+    const nostrPubkey = this.getNostrPubkey();
+    this.log("Searching for nametag events for pubkey:", nostrPubkey.slice(0, 16) + "...");
+    const events = await this.queryEvents({
+      kinds: [EVENT_KINDS.NAMETAG_BINDING],
+      authors: [nostrPubkey],
+      limit: 10
+      // Get recent events in case of updates
+    });
+    if (events.length === 0) {
+      this.log("No nametag events found for this pubkey");
+      return null;
+    }
+    events.sort((a, b) => b.created_at - a.created_at);
+    for (const event of events) {
+      try {
+        const content = JSON.parse(event.content);
+        if (content.encrypted_nametag) {
+          const decrypted = await decryptNametag(
+            content.encrypted_nametag,
+            this.identity.privateKey
+          );
+          if (decrypted) {
+            this.log("Recovered nametag:", decrypted);
+            return decrypted;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    this.log("Could not decrypt nametag from any event");
+    return null;
+  }
   async publishNametag(nametag, address) {
     this.ensureReady();
     const hashedNametag = (0, import_nostr_js_sdk.hashNametag)(nametag);
@@ -1539,8 +1758,11 @@ var NostrTransportProvider = class {
     await this.publishEvent(event);
     this.log("Published nametag binding:", nametag);
   }
-  async registerNametag(nametag, _publicKey) {
+  async registerNametag(nametag, _publicKey, directAddress = "") {
     this.ensureReady();
+    if (!this.identity) {
+      throw new Error("Identity not set");
+    }
     const nostrPubkey = this.getNostrPubkey();
     const existing = await this.resolveNametag(nametag);
     this.log("registerNametag:", nametag, "existing:", existing, "myPubkey:", nostrPubkey);
@@ -1548,27 +1770,42 @@ var NostrTransportProvider = class {
       this.log("Nametag already taken:", nametag, "- owner:", existing);
       return false;
     }
+    const privateKeyHex = this.identity.privateKey;
+    const compressedPubkey = getPublicKey(privateKeyHex, true);
+    const l1Address = publicKeyToAddress(compressedPubkey, "alpha");
+    const encryptedNametag = await encryptNametag(nametag, privateKeyHex);
     const hashedNametag = (0, import_nostr_js_sdk.hashNametag)(nametag);
     const content = JSON.stringify({
       nametag_hash: hashedNametag,
       address: nostrPubkey,
-      verified: Date.now()
+      verified: Date.now(),
+      // Extended fields for nametag recovery and address lookup
+      encrypted_nametag: encryptedNametag,
+      public_key: compressedPubkey,
+      l1_address: l1Address,
+      direct_address: directAddress
     });
     const event = await this.createEvent(EVENT_KINDS.NAMETAG_BINDING, content, [
       ["d", hashedNametag],
       ["nametag", hashedNametag],
       ["t", hashedNametag],
-      ["address", nostrPubkey]
+      ["address", nostrPubkey],
+      // Extended tags for indexing
+      ["pubkey", compressedPubkey],
+      ["l1", l1Address]
     ]);
     await this.publishEvent(event);
-    this.log("Registered nametag:", nametag, "for pubkey:", nostrPubkey.slice(0, 16) + "...");
+    this.log("Registered nametag:", nametag, "for pubkey:", nostrPubkey.slice(0, 16) + "...", "l1:", l1Address.slice(0, 12) + "...");
     return true;
   }
+  // Track broadcast subscriptions
+  broadcastSubscriptions = /* @__PURE__ */ new Map();
+  // key -> subId
   subscribeToBroadcast(tags, handler) {
     const key = tags.sort().join(":");
     if (!this.broadcastHandlers.has(key)) {
       this.broadcastHandlers.set(key, /* @__PURE__ */ new Set());
-      if (this.isConnected()) {
+      if (this.isConnected() && this.nostrClient) {
         this.subscribeToTags(tags);
       }
     }
@@ -1577,6 +1814,11 @@ var NostrTransportProvider = class {
       this.broadcastHandlers.get(key)?.delete(handler);
       if (this.broadcastHandlers.get(key)?.size === 0) {
         this.broadcastHandlers.delete(key);
+        const subId = this.broadcastSubscriptions.get(key);
+        if (subId && this.nostrClient) {
+          this.nostrClient.unsubscribe(subId);
+          this.broadcastSubscriptions.delete(key);
+        }
       }
     };
   }
@@ -1595,81 +1837,19 @@ var NostrTransportProvider = class {
     return () => this.eventCallbacks.delete(callback);
   }
   // ===========================================================================
-  // Private: Connection Management
-  // ===========================================================================
-  async connectToRelay(url) {
-    return new Promise((resolve, reject) => {
-      const ws = this.config.createWebSocket(url);
-      const timeout = setTimeout(() => {
-        ws.close();
-        reject(new Error(`Connection timeout: ${url}`));
-      }, this.config.timeout);
-      ws.onopen = () => {
-        clearTimeout(timeout);
-        this.connections.set(url, ws);
-        this.reconnectAttempts.set(url, 0);
-        this.log("Connected to relay:", url);
-        resolve();
-      };
-      ws.onerror = (error) => {
-        clearTimeout(timeout);
-        this.log("Relay error:", url, error);
-        reject(error);
-      };
-      ws.onclose = () => {
-        this.connections.delete(url);
-        if (this.config.autoReconnect && this.status === "connected") {
-          this.scheduleReconnect(url);
-        }
-      };
-      ws.onmessage = (event) => {
-        this.handleRelayMessage(url, event.data);
-      };
-    });
-  }
-  scheduleReconnect(url) {
-    const attempts = this.reconnectAttempts.get(url) ?? 0;
-    if (attempts >= this.config.maxReconnectAttempts) {
-      this.log("Max reconnect attempts reached for:", url);
-      return;
-    }
-    this.reconnectAttempts.set(url, attempts + 1);
-    const delay = this.config.reconnectDelay * Math.pow(2, attempts);
-    this.emitEvent({ type: "transport:reconnecting", timestamp: Date.now() });
-    setTimeout(() => {
-      this.connectToRelay(url).catch(() => {
-      });
-    }, delay);
-  }
-  // ===========================================================================
   // Private: Message Handling
   // ===========================================================================
-  handleRelayMessage(relay, data) {
-    try {
-      const message = JSON.parse(data);
-      const [type, ...args] = message;
-      switch (type) {
-        case "EVENT":
-          this.handleEvent(args[1]);
-          break;
-        case "EOSE":
-          break;
-        case "OK":
-          break;
-        case "NOTICE":
-          this.log("Relay notice:", relay, args[0]);
-          break;
-      }
-    } catch (error) {
-      this.log("Failed to parse relay message:", error);
-    }
-  }
   async handleEvent(event) {
+    this.log("Processing event kind:", event.kind, "id:", event.id?.slice(0, 12));
     try {
       switch (event.kind) {
         case EVENT_KINDS.DIRECT_MESSAGE:
           await this.handleDirectMessage(event);
           break;
+        case import_nostr_js_sdk.EventKinds.GIFT_WRAP:
+          this.log("Handling gift wrap (NIP-17 DM)");
+          await this.handleGiftWrap(event);
+          break;
         case EVENT_KINDS.TOKEN_TRANSFER:
           await this.handleTokenTransfer(event);
           break;
@@ -1688,23 +1868,54 @@ var NostrTransportProvider = class {
     }
   }
   async handleDirectMessage(event) {
-    if (!this.identity || !this.keyManager) return;
-    if (event.pubkey === this.keyManager.getPublicKeyHex()) return;
-    const content = await this.decryptContent(event.content, event.pubkey);
-    const message = {
-      id: event.id,
-      senderPubkey: event.pubkey,
-      content,
-      timestamp: event.created_at * 1e3,
-      encrypted: true
-    };
-    this.emitEvent({ type: "message:received", timestamp: Date.now() });
-    for (const handler of this.messageHandlers) {
+    this.log("Ignoring NIP-04 kind 4 event (DMs use NIP-17):", event.id?.slice(0, 12));
+  }
+  async handleGiftWrap(event) {
+    if (!this.identity || !this.keyManager) {
+      this.log("handleGiftWrap: no identity/keyManager");
+      return;
+    }
+    try {
+      const pm = import_nostr_js_sdk.NIP17.unwrap(event, this.keyManager);
+      this.log("Gift wrap unwrapped, sender:", pm.senderPubkey?.slice(0, 16), "kind:", pm.kind);
+      if (pm.senderPubkey === this.keyManager.getPublicKeyHex()) {
+        this.log("Skipping own message");
+        return;
+      }
+      if (pm.kind !== import_nostr_js_sdk.EventKinds.CHAT_MESSAGE) {
+        this.log("Skipping non-chat message, kind:", pm.kind);
+        return;
+      }
+      let content = pm.content;
+      let senderNametag;
       try {
-        handler(message);
-      } catch (error) {
-        this.log("Message handler error:", error);
+        const parsed = JSON.parse(content);
+        if (typeof parsed === "object" && parsed.text !== void 0) {
+          content = parsed.text;
+          senderNametag = parsed.senderNametag || void 0;
+        }
+      } catch {
+      }
+      this.log("DM received from:", senderNametag || pm.senderPubkey?.slice(0, 16), "content:", content?.slice(0, 50));
+      const message = {
+        id: pm.eventId,
+        senderTransportPubkey: pm.senderPubkey,
+        senderNametag,
+        content,
+        timestamp: pm.timestamp * 1e3,
+        encrypted: true
+      };
+      this.emitEvent({ type: "message:received", timestamp: Date.now() });
+      this.log("Dispatching to", this.messageHandlers.size, "handlers");
+      for (const handler of this.messageHandlers) {
+        try {
+          handler(message);
+        } catch (error) {
+          this.log("Message handler error:", error);
+        }
       }
+    } catch (err) {
+      this.log("Gift wrap decrypt failed (expected if not for us):", err?.message?.slice(0, 50));
     }
   }
   async handleTokenTransfer(event) {
@@ -1713,7 +1924,7 @@ var NostrTransportProvider = class {
     const payload = JSON.parse(content);
     const transfer = {
       id: event.id,
-      senderPubkey: event.pubkey,
+      senderTransportPubkey: event.pubkey,
       payload,
       timestamp: event.created_at * 1e3
     };
@@ -1733,7 +1944,7 @@ var NostrTransportProvider = class {
       const requestData = JSON.parse(content);
       const request = {
         id: event.id,
-        senderPubkey: event.pubkey,
+        senderTransportPubkey: event.pubkey,
         request: {
           requestId: requestData.requestId,
           amount: requestData.amount,
@@ -1763,7 +1974,7 @@ var NostrTransportProvider = class {
       const responseData = JSON.parse(content);
       const response = {
         id: event.id,
-        responderPubkey: event.pubkey,
+        responderTransportPubkey: event.pubkey,
         response: {
           requestId: responseData.requestId,
           responseType: responseData.responseType,
@@ -1788,7 +1999,7 @@ var NostrTransportProvider = class {
     const tags = event.tags.filter((t) => t[0] === "t").map((t) => t[1]);
     const broadcast = {
       id: event.id,
-      authorPubkey: event.pubkey,
+      authorTransportPubkey: event.pubkey,
       content: event.content,
       tags,
       timestamp: event.created_at * 1e3
@@ -1843,109 +2054,149 @@ var NostrTransportProvider = class {
     return this.createEvent(kind, encrypted, tags);
   }
   async publishEvent(event) {
-    const message = JSON.stringify(["EVENT", event]);
-    const publishPromises = Array.from(this.connections.values()).map((ws) => {
-      return new Promise((resolve, reject) => {
-        if (ws.readyState !== WebSocketReadyState.OPEN) {
-          reject(new Error("WebSocket not open"));
-          return;
-        }
-        ws.send(message);
-        resolve();
-      });
-    });
-    await Promise.any(publishPromises);
+    if (!this.nostrClient) {
+      throw new Error("NostrClient not initialized");
+    }
+    const sdkEvent = import_nostr_js_sdk.Event.fromJSON(event);
+    await this.nostrClient.publishEvent(sdkEvent);
   }
-  async queryEvents(filter) {
-    if (this.connections.size === 0) {
+  async queryEvents(filterObj) {
+    if (!this.nostrClient || !this.nostrClient.isConnected()) {
       throw new Error("No connected relays");
     }
-    const queryPromises = Array.from(this.connections.values()).map(
-      (ws) => this.queryEventsFromRelay(ws, filter)
-    );
-    const results = await Promise.allSettled(queryPromises);
-    for (const result of results) {
-      if (result.status === "fulfilled" && result.value.length > 0) {
-        return result.value;
-      }
-    }
-    return [];
-  }
-  async queryEventsFromRelay(ws, filter) {
-    const subId = this.config.generateUUID().slice(0, 8);
     const events = [];
+    const filter = new import_nostr_js_sdk.Filter(filterObj);
     return new Promise((resolve) => {
       const timeout = setTimeout(() => {
-        this.unsubscribeFromRelay(ws, subId);
+        if (subId) {
+          this.nostrClient?.unsubscribe(subId);
+        }
         resolve(events);
       }, 5e3);
-      const originalHandler = ws.onmessage;
-      ws.onmessage = (event) => {
-        const message = JSON.parse(event.data);
-        const [type, sid, data] = message;
-        if (sid !== subId) {
-          originalHandler?.call(ws, event);
-          return;
-        }
-        if (type === "EVENT") {
-          events.push(data);
-        } else if (type === "EOSE") {
+      const subId = this.nostrClient.subscribe(filter, {
+        onEvent: (event) => {
+          events.push({
+            id: event.id,
+            kind: event.kind,
+            content: event.content,
+            tags: event.tags,
+            pubkey: event.pubkey,
+            created_at: event.created_at,
+            sig: event.sig
+          });
+        },
+        onEndOfStoredEvents: () => {
           clearTimeout(timeout);
-          ws.onmessage = originalHandler;
-          this.unsubscribeFromRelay(ws, subId);
+          this.nostrClient?.unsubscribe(subId);
           resolve(events);
         }
-      };
-      ws.send(JSON.stringify(["REQ", subId, filter]));
+      });
     });
   }
-  unsubscribeFromRelay(ws, subId) {
-    if (ws.readyState === WebSocketReadyState.OPEN) {
-      ws.send(JSON.stringify(["CLOSE", subId]));
-    }
-  }
   // ===========================================================================
   // Private: Subscriptions
   // ===========================================================================
+  // Track subscription IDs for cleanup
+  walletSubscriptionId = null;
+  chatSubscriptionId = null;
   subscribeToEvents() {
-    if (!this.identity || !this.keyManager) return;
-    const subId = "main";
+    this.log("subscribeToEvents called, identity:", !!this.identity, "keyManager:", !!this.keyManager, "nostrClient:", !!this.nostrClient);
+    if (!this.identity || !this.keyManager || !this.nostrClient) {
+      this.log("subscribeToEvents: skipped - no identity, keyManager, or nostrClient");
+      return;
+    }
+    if (this.walletSubscriptionId) {
+      this.nostrClient.unsubscribe(this.walletSubscriptionId);
+      this.walletSubscriptionId = null;
+    }
+    if (this.chatSubscriptionId) {
+      this.nostrClient.unsubscribe(this.chatSubscriptionId);
+      this.chatSubscriptionId = null;
+    }
+    if (this.mainSubscriptionId) {
+      this.nostrClient.unsubscribe(this.mainSubscriptionId);
+      this.mainSubscriptionId = null;
+    }
     const nostrPubkey = this.keyManager.getPublicKeyHex();
-    const filter = {
-      kinds: [
-        EVENT_KINDS.DIRECT_MESSAGE,
-        EVENT_KINDS.TOKEN_TRANSFER,
-        EVENT_KINDS.PAYMENT_REQUEST,
-        EVENT_KINDS.PAYMENT_REQUEST_RESPONSE
-      ],
-      "#p": [nostrPubkey],
-      since: Math.floor(Date.now() / 1e3) - 86400
-      // Last 24h
-    };
-    const message = JSON.stringify(["REQ", subId, filter]);
-    for (const ws of this.connections.values()) {
-      if (ws.readyState === WebSocketReadyState.OPEN) {
-        ws.send(message);
+    this.log("Subscribing with Nostr pubkey:", nostrPubkey);
+    const walletFilter = new import_nostr_js_sdk.Filter();
+    walletFilter.kinds = [
+      EVENT_KINDS.DIRECT_MESSAGE,
+      EVENT_KINDS.TOKEN_TRANSFER,
+      EVENT_KINDS.PAYMENT_REQUEST,
+      EVENT_KINDS.PAYMENT_REQUEST_RESPONSE
+    ];
+    walletFilter["#p"] = [nostrPubkey];
+    walletFilter.since = Math.floor(Date.now() / 1e3) - 86400;
+    this.walletSubscriptionId = this.nostrClient.subscribe(walletFilter, {
+      onEvent: (event) => {
+        this.log("Received wallet event kind:", event.kind, "id:", event.id?.slice(0, 12));
+        this.handleEvent({
+          id: event.id,
+          kind: event.kind,
+          content: event.content,
+          tags: event.tags,
+          pubkey: event.pubkey,
+          created_at: event.created_at,
+          sig: event.sig
+        });
+      },
+      onEndOfStoredEvents: () => {
+        this.log("Wallet subscription ready (EOSE)");
+      },
+      onError: (_subId, error) => {
+        this.log("Wallet subscription error:", error);
       }
-    }
-    this.subscriptions.set(subId, Array.from(this.connections.keys()));
-    this.log("Subscribed to events");
+    });
+    this.log("Wallet subscription created, subId:", this.walletSubscriptionId);
+    const chatFilter = new import_nostr_js_sdk.Filter();
+    chatFilter.kinds = [import_nostr_js_sdk.EventKinds.GIFT_WRAP];
+    chatFilter["#p"] = [nostrPubkey];
+    this.chatSubscriptionId = this.nostrClient.subscribe(chatFilter, {
+      onEvent: (event) => {
+        this.log("Received chat event kind:", event.kind, "id:", event.id?.slice(0, 12));
+        this.handleEvent({
+          id: event.id,
+          kind: event.kind,
+          content: event.content,
+          tags: event.tags,
+          pubkey: event.pubkey,
+          created_at: event.created_at,
+          sig: event.sig
+        });
+      },
+      onEndOfStoredEvents: () => {
+        this.log("Chat subscription ready (EOSE)");
+      },
+      onError: (_subId, error) => {
+        this.log("Chat subscription error:", error);
+      }
+    });
+    this.log("Chat subscription created, subId:", this.chatSubscriptionId);
   }
   subscribeToTags(tags) {
-    const subId = `tags:${tags.join(":")}`;
-    const filter = {
+    if (!this.nostrClient) return;
+    const key = tags.sort().join(":");
+    const filter = new import_nostr_js_sdk.Filter({
       kinds: [EVENT_KINDS.BROADCAST],
       "#t": tags,
       since: Math.floor(Date.now() / 1e3) - 3600
       // Last hour
-    };
-    const message = JSON.stringify(["REQ", subId, filter]);
-    for (const ws of this.connections.values()) {
-      if (ws.readyState === WebSocketReadyState.OPEN) {
-        ws.send(message);
+    });
+    const subId = this.nostrClient.subscribe(filter, {
+      onEvent: (event) => {
+        this.handleBroadcast({
+          id: event.id,
+          kind: event.kind,
+          content: event.content,
+          tags: event.tags,
+          pubkey: event.pubkey,
+          created_at: event.created_at,
+          sig: event.sig
+        });
       }
-    }
-    this.subscriptions.set(subId, Array.from(this.connections.keys()));
+    });
+    this.broadcastSubscriptions.set(key, subId);
   }
   // ===========================================================================
   // Private: Encryption
@@ -2401,13 +2652,70 @@ 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_MAINNET = null;
+var TRUSTBASE_DEV = TRUSTBASE_TESTNET;
+
+// impl/shared/trustbase-loader.ts
+function getEmbeddedTrustBase(network) {
+  switch (network) {
+    case "mainnet":
+      return TRUSTBASE_MAINNET;
+    case "testnet":
+      return TRUSTBASE_TESTNET;
+    case "dev":
+      return TRUSTBASE_DEV;
+    default:
+      return TRUSTBASE_TESTNET;
+  }
+}
+var BaseTrustBaseLoader = class {
+  network;
+  constructor(network = "testnet") {
+    this.network = network;
+  }
+  async load() {
+    const external = await this.loadFromExternal();
+    if (external) {
+      return external;
+    }
+    return getEmbeddedTrustBase(this.network);
+  }
+};
+
 // impl/browser/oracle/index.ts
-var BrowserTrustBaseLoader = class {
+var BrowserTrustBaseLoader = class extends BaseTrustBaseLoader {
   url;
-  constructor(url = "/trustbase-testnet.json") {
-    this.url = url;
+  constructor(networkOrUrl = "testnet") {
+    if (networkOrUrl.startsWith("/") || networkOrUrl.startsWith("http")) {
+      super("testnet");
+      this.url = networkOrUrl;
+    } else {
+      super(networkOrUrl);
+    }
   }
-  async load() {
+  async loadFromExternal() {
+    if (!this.url) return null;
     try {
       const response = await fetch(this.url);
       if (response.ok) {
@@ -2418,14 +2726,14 @@ var BrowserTrustBaseLoader = class {
     return null;
   }
 };
-function createBrowserTrustBaseLoader(url) {
-  return new BrowserTrustBaseLoader(url);
+function createBrowserTrustBaseLoader(networkOrUrl) {
+  return new BrowserTrustBaseLoader(networkOrUrl);
 }
 function createUnicityAggregatorProvider(config) {
-  const { trustBaseUrl, ...restConfig } = config;
+  const { trustBaseUrl, network, ...restConfig } = config;
   return new UnicityAggregatorProvider({
     ...restConfig,
-    trustBaseLoader: createBrowserTrustBaseLoader(trustBaseUrl)
+    trustBaseLoader: createBrowserTrustBaseLoader(trustBaseUrl ?? network ?? "testnet")
   });
 }
 var createUnicityOracleProvider = createUnicityAggregatorProvider;
@@ -2456,18 +2764,18 @@ function downloadWalletText(sphere, options = {}) {
   downloadTextFile(content, filename);
 }
 function downloadWalletJSON(sphere, options = {}) {
-  const json2 = sphere.exportToJSON({
+  const json = sphere.exportToJSON({
     password: options.password,
     addressCount: options.addressCount,
     includeMnemonic: options.includeMnemonic
   });
   const filename = options.filename ? `${options.filename}.json` : `sphere-wallet-${Date.now()}.json`;
-  const jsonString = options.pretty !== false ? JSON.stringify(json2, null, 2) : JSON.stringify(json2);
+  const jsonString = options.pretty !== false ? JSON.stringify(json, null, 2) : JSON.stringify(json);
   downloadFile(jsonString, filename, "application/json");
 }
-function downloadWalletJSONData(json2, filename) {
+function downloadWalletJSONData(json, filename) {
   const name = filename || `sphere-wallet-${Date.now()}.json`;
-  downloadJSONFile(json2, name.endsWith(".json") ? name : `${name}.json`);
+  downloadJSONFile(json, name.endsWith(".json") ? name : `${name}.json`);
 }
 function readFileAsText(file) {
   return new Promise((resolve, reject) => {
@@ -2617,11 +2925,17 @@ function createBrowserProviders(config) {
       apiKey: oracleConfig.apiKey,
       timeout: oracleConfig.timeout,
       skipVerification: oracleConfig.skipVerification,
-      debug: oracleConfig.debug
+      debug: oracleConfig.debug,
+      network
     }),
     tokenStorage: createIndexedDBTokenStorageProvider(),
     l1: l1Config,
     tokenSyncConfig
   };
 }
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=index.cjs.map