@unicitylabs/sphere-sdk 0.1.9 → 0.2.1

package/dist/impl/nodejs/index.js

@@ -22,8 +22,10 @@ var STORAGE_KEYS_GLOBAL = {
   WALLET_EXISTS: "wallet_exists",
   /** Current active address index */
   CURRENT_ADDRESS_INDEX: "current_address_index",
-  /** Index of address nametags (JSON: { "0": "alice", "1": "bob" }) - for discovery */
-  ADDRESS_NAMETAGS: "address_nametags"
+  /** Nametag cache per address (separate from tracked addresses registry) */
+  ADDRESS_NAMETAGS: "address_nametags",
+  /** Active addresses registry (JSON: TrackedAddressesStorage) */
+  TRACKED_ADDRESSES: "tracked_addresses"
 };
 var STORAGE_KEYS_ADDRESS = {
   /** Pending transfers for this address */
@@ -213,6 +215,19 @@ var FileStorageProvider = class {
     }
     await this.save();
   }
+  async saveTrackedAddresses(entries) {
+    await this.set(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES, JSON.stringify({ version: 1, addresses: entries }));
+  }
+  async loadTrackedAddresses() {
+    const data = await this.get(STORAGE_KEYS_GLOBAL.TRACKED_ADDRESSES);
+    if (!data) return [];
+    try {
+      const parsed = JSON.parse(data);
+      return parsed.addresses ?? [];
+    } catch {
+      return [];
+    }
+  }
   /**
    * Get full storage key with address prefix for per-address keys
    */
@@ -296,7 +311,12 @@ var FileTokenStorageProvider = class {
       }
     };
     try {
-      const files = fs2.readdirSync(this.tokensDir).filter((f) => f.endsWith(".json") && f !== "_meta.json");
+      const files = fs2.readdirSync(this.tokensDir).filter(
+        (f) => f.endsWith(".json") && f !== "_meta.json" && f !== "_tombstones.json" && !f.startsWith("archived_") && // Skip archived tokens
+        !f.startsWith("token-") && // Skip legacy token format
+        !f.startsWith("nametag-")
+        // Skip nametag files (not tokens)
+      );
       for (const file of files) {
         try {
           const basename2 = path2.basename(file, ".json");
@@ -314,6 +334,14 @@ var FileTokenStorageProvider = class {
         } catch {
         }
       }
+      const tombstonesPath = path2.join(this.tokensDir, "_tombstones.json");
+      if (fs2.existsSync(tombstonesPath)) {
+        try {
+          const content = fs2.readFileSync(tombstonesPath, "utf-8");
+          data._tombstones = JSON.parse(content);
+        } catch {
+        }
+      }
       return {
         success: true,
         data,
@@ -358,6 +386,10 @@ var FileTokenStorageProvider = class {
             fs2.unlinkSync(filePath);
           }
         }
+        fs2.writeFileSync(
+          path2.join(this.tokensDir, "_tombstones.json"),
+          JSON.stringify(data._tombstones, null, 2)
+        );
       }
       return {
         success: true,
@@ -1006,6 +1038,10 @@ function defaultUUIDGenerator() {
 
 // transport/NostrTransportProvider.ts
 var EVENT_KINDS = NOSTR_EVENT_KINDS;
+function hashAddressForTag(address) {
+  const bytes = new TextEncoder().encode("unicity:address:" + address);
+  return Buffer2.from(sha256(bytes)).toString("hex");
+}
 function deriveNametagEncryptionKey(privateKeyHex) {
   const privateKeyBytes = Buffer2.from(privateKeyHex, "hex");
   const saltInput = new TextEncoder().encode("sphere-nametag-salt");
@@ -1259,7 +1295,7 @@ var NostrTransportProvider = class {
   // ===========================================================================
   // TransportProvider Implementation
   // ===========================================================================
-  setIdentity(identity) {
+  async setIdentity(identity) {
     this.identity = identity;
     const secretKey = Buffer2.from(identity.privateKey, "hex");
     this.keyManager = NostrKeyManager.fromPrivateKey(secretKey);
@@ -1289,12 +1325,9 @@ var NostrTransportProvider = class {
           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);
-      });
+      await this.nostrClient.connect(...this.config.relays);
+      this.subscribeToEvents();
+      oldClient.disconnect();
     } else if (this.isConnected()) {
       this.subscribeToEvents();
     }
@@ -1414,6 +1447,28 @@ var NostrTransportProvider = class {
     this.paymentRequestResponseHandlers.add(handler);
     return () => this.paymentRequestResponseHandlers.delete(handler);
   }
+  /**
+   * Resolve any identifier to full peer information.
+   * Routes to the appropriate specific resolve method based on identifier format.
+   */
+  async resolve(identifier) {
+    if (identifier.startsWith("@")) {
+      return this.resolveNametagInfo(identifier.slice(1));
+    }
+    if (identifier.startsWith("DIRECT:") || identifier.startsWith("PROXY:")) {
+      return this.resolveAddressInfo(identifier);
+    }
+    if (identifier.startsWith("alpha1") || identifier.startsWith("alphat1")) {
+      return this.resolveAddressInfo(identifier);
+    }
+    if (/^0[23][0-9a-f]{64}$/i.test(identifier)) {
+      return this.resolveAddressInfo(identifier);
+    }
+    if (/^[0-9a-f]{64}$/i.test(identifier)) {
+      return this.resolveTransportPubkeyInfo(identifier);
+    }
+    return this.resolveNametagInfo(identifier);
+  }
   async resolveNametag(nametag) {
     this.ensureReady();
     const hashedNametag = hashNametag(nametag);
@@ -1510,6 +1565,77 @@ var NostrTransportProvider = class {
       };
     }
   }
+  /**
+   * Resolve a DIRECT://, PROXY://, or L1 address to full peer info.
+   * Performs reverse lookup: hash(address) → query '#t' tag → parse binding event.
+   * Works with both new identity binding events and legacy nametag binding events.
+   */
+  async resolveAddressInfo(address) {
+    this.ensureReady();
+    const addressHash = hashAddressForTag(address);
+    const events = await this.queryEvents({
+      kinds: [EVENT_KINDS.NAMETAG_BINDING],
+      "#t": [addressHash],
+      limit: 1
+    });
+    if (events.length === 0) return null;
+    const bindingEvent = events[0];
+    try {
+      const content = JSON.parse(bindingEvent.content);
+      return {
+        nametag: content.nametag || void 0,
+        transportPubkey: bindingEvent.pubkey,
+        chainPubkey: content.public_key || "",
+        l1Address: content.l1_address || "",
+        directAddress: content.direct_address || "",
+        proxyAddress: content.proxy_address || void 0,
+        timestamp: bindingEvent.created_at * 1e3
+      };
+    } catch {
+      return {
+        transportPubkey: bindingEvent.pubkey,
+        chainPubkey: "",
+        l1Address: "",
+        directAddress: "",
+        timestamp: bindingEvent.created_at * 1e3
+      };
+    }
+  }
+  /**
+   * Resolve transport pubkey (Nostr pubkey) to full peer info.
+   * Queries binding events authored by the given pubkey.
+   */
+  async resolveTransportPubkeyInfo(transportPubkey) {
+    this.ensureReady();
+    const events = await this.queryEvents({
+      kinds: [EVENT_KINDS.NAMETAG_BINDING],
+      authors: [transportPubkey],
+      limit: 5
+    });
+    if (events.length === 0) return null;
+    events.sort((a, b) => b.created_at - a.created_at);
+    const bindingEvent = events[0];
+    try {
+      const content = JSON.parse(bindingEvent.content);
+      return {
+        nametag: content.nametag || void 0,
+        transportPubkey: bindingEvent.pubkey,
+        chainPubkey: content.public_key || "",
+        l1Address: content.l1_address || "",
+        directAddress: content.direct_address || "",
+        proxyAddress: content.proxy_address || void 0,
+        timestamp: bindingEvent.created_at * 1e3
+      };
+    } catch {
+      return {
+        transportPubkey: bindingEvent.pubkey,
+        chainPubkey: "",
+        l1Address: "",
+        directAddress: "",
+        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
@@ -1553,6 +1679,63 @@ var NostrTransportProvider = class {
     this.log("Could not decrypt nametag from any event");
     return null;
   }
+  /**
+   * Publish identity binding event on Nostr.
+   * Without nametag: publishes base binding (chainPubkey, l1Address, directAddress).
+   * With nametag: also publishes nametag hash, proxy address, encrypted nametag for recovery.
+   *
+   * Uses kind 30078 parameterized replaceable event with d=SHA256('unicity:identity:' + nostrPubkey).
+   * Each HD address index has its own Nostr key → its own binding event.
+   *
+   * @returns true if successful, false if nametag is taken by another pubkey
+   */
+  async publishIdentityBinding(chainPubkey, l1Address, directAddress, nametag) {
+    this.ensureReady();
+    if (!this.identity) {
+      throw new Error("Identity not set");
+    }
+    const nostrPubkey = this.getNostrPubkey();
+    const dTagBytes = new TextEncoder().encode("unicity:identity:" + nostrPubkey);
+    const dTag = Buffer2.from(sha256(dTagBytes)).toString("hex");
+    const contentObj = {
+      public_key: chainPubkey,
+      l1_address: l1Address,
+      direct_address: directAddress
+    };
+    const tags = [
+      ["d", dTag],
+      ["t", hashAddressForTag(chainPubkey)],
+      ["t", hashAddressForTag(directAddress)],
+      ["t", hashAddressForTag(l1Address)]
+    ];
+    if (nametag) {
+      const existing = await this.resolveNametag(nametag);
+      if (existing && existing !== nostrPubkey) {
+        this.log("Nametag already taken:", nametag, "- owner:", existing);
+        return false;
+      }
+      const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
+      const proxyAddr = await ProxyAddress.fromNameTag(nametag);
+      const proxyAddress = proxyAddr.toString();
+      const encryptedNametag = await encryptNametag(nametag, this.identity.privateKey);
+      const hashedNametag = hashNametag(nametag);
+      contentObj.nametag = nametag;
+      contentObj.encrypted_nametag = encryptedNametag;
+      contentObj.proxy_address = proxyAddress;
+      tags.push(["t", hashedNametag]);
+      tags.push(["t", hashAddressForTag(proxyAddress)]);
+    }
+    const content = JSON.stringify(contentObj);
+    const event = await this.createEvent(EVENT_KINDS.NAMETAG_BINDING, content, tags);
+    await this.publishEvent(event);
+    if (nametag) {
+      this.log("Published identity binding with nametag:", nametag, "for pubkey:", nostrPubkey.slice(0, 16) + "...");
+    } else {
+      this.log("Published identity binding (no nametag) for pubkey:", nostrPubkey.slice(0, 16) + "...");
+    }
+    return true;
+  }
+  /** @deprecated Use publishIdentityBinding instead */
   async publishNametag(nametag, address) {
     this.ensureReady();
     const hashedNametag = hashNametag(nametag);
@@ -1579,6 +1762,9 @@ var NostrTransportProvider = class {
     const compressedPubkey = getPublicKey(privateKeyHex, true);
     const l1Address = publicKeyToAddress(compressedPubkey, "alpha");
     const encryptedNametag = await encryptNametag(nametag, privateKeyHex);
+    const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
+    const proxyAddr = await ProxyAddress.fromNameTag(nametag);
+    const proxyAddress = proxyAddr.toString();
     const hashedNametag = hashNametag(nametag);
     const content = JSON.stringify({
       nametag_hash: hashedNametag,
@@ -1588,17 +1774,20 @@ var NostrTransportProvider = class {
       encrypted_nametag: encryptedNametag,
       public_key: compressedPubkey,
       l1_address: l1Address,
-      direct_address: directAddress
+      direct_address: directAddress,
+      proxy_address: proxyAddress
     });
-    const event = await this.createEvent(EVENT_KINDS.NAMETAG_BINDING, content, [
+    const tags = [
       ["d", hashedNametag],
       ["nametag", hashedNametag],
       ["t", hashedNametag],
+      ["t", hashAddressForTag(directAddress)],
+      ["t", hashAddressForTag(proxyAddress)],
       ["address", nostrPubkey],
-      // Extended tags for indexing
       ["pubkey", compressedPubkey],
       ["l1", l1Address]
-    ]);
+    ];
+    const event = await this.createEvent(EVENT_KINDS.NAMETAG_BINDING, content, tags);
     await this.publishEvent(event);
     this.log("Registered nametag:", nametag, "for pubkey:", nostrPubkey.slice(0, 16) + "...", "l1:", l1Address.slice(0, 12) + "...");
     return true;
@@ -2550,6 +2739,113 @@ function createUnicityAggregatorProvider(config) {
 }
 var createUnicityOracleProvider = createUnicityAggregatorProvider;
 
+// price/CoinGeckoPriceProvider.ts
+var CoinGeckoPriceProvider = class {
+  platform = "coingecko";
+  cache = /* @__PURE__ */ new Map();
+  apiKey;
+  cacheTtlMs;
+  timeout;
+  debug;
+  baseUrl;
+  constructor(config) {
+    this.apiKey = config?.apiKey;
+    this.cacheTtlMs = config?.cacheTtlMs ?? 6e4;
+    this.timeout = config?.timeout ?? 1e4;
+    this.debug = config?.debug ?? false;
+    this.baseUrl = config?.baseUrl ?? (this.apiKey ? "https://pro-api.coingecko.com/api/v3" : "https://api.coingecko.com/api/v3");
+  }
+  async getPrices(tokenNames) {
+    if (tokenNames.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const now = Date.now();
+    const result = /* @__PURE__ */ new Map();
+    const uncachedNames = [];
+    for (const name of tokenNames) {
+      const cached = this.cache.get(name);
+      if (cached && cached.expiresAt > now) {
+        if (cached.price !== null) {
+          result.set(name, cached.price);
+        }
+      } else {
+        uncachedNames.push(name);
+      }
+    }
+    if (uncachedNames.length === 0) {
+      return result;
+    }
+    try {
+      const ids = uncachedNames.join(",");
+      const url = `${this.baseUrl}/simple/price?ids=${encodeURIComponent(ids)}&vs_currencies=usd,eur&include_24hr_change=true`;
+      const headers = { Accept: "application/json" };
+      if (this.apiKey) {
+        headers["x-cg-pro-api-key"] = this.apiKey;
+      }
+      if (this.debug) {
+        console.log(`[CoinGecko] Fetching prices for: ${uncachedNames.join(", ")}`);
+      }
+      const response = await fetch(url, {
+        headers,
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!response.ok) {
+        throw new Error(`CoinGecko API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      for (const [name, values] of Object.entries(data)) {
+        if (values && typeof values === "object") {
+          const price = {
+            tokenName: name,
+            priceUsd: values.usd ?? 0,
+            priceEur: values.eur,
+            change24h: values.usd_24h_change,
+            timestamp: now
+          };
+          this.cache.set(name, { price, expiresAt: now + this.cacheTtlMs });
+          result.set(name, price);
+        }
+      }
+      for (const name of uncachedNames) {
+        if (!result.has(name)) {
+          this.cache.set(name, { price: null, expiresAt: now + this.cacheTtlMs });
+        }
+      }
+      if (this.debug) {
+        console.log(`[CoinGecko] Fetched ${result.size} prices`);
+      }
+    } catch (error) {
+      if (this.debug) {
+        console.warn("[CoinGecko] Fetch failed, using stale cache:", error);
+      }
+      for (const name of uncachedNames) {
+        const stale = this.cache.get(name);
+        if (stale?.price) {
+          result.set(name, stale.price);
+        }
+      }
+    }
+    return result;
+  }
+  async getPrice(tokenName) {
+    const prices = await this.getPrices([tokenName]);
+    return prices.get(tokenName) ?? null;
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+};
+
+// price/index.ts
+function createPriceProvider(config) {
+  switch (config.platform) {
+    case "coingecko":
+      return new CoinGeckoPriceProvider(config);
+    default:
+      throw new Error(`Unsupported price platform: ${String(config.platform)}`);
+  }
+}
+
 // impl/shared/resolvers.ts
 function getNetworkConfig(network = "mainnet") {
   return NETWORKS[network];
@@ -2598,6 +2894,19 @@ function resolveL1Config(network, config) {
     enableVesting: config.enableVesting
   };
 }
+function resolvePriceConfig(config) {
+  if (config === void 0) {
+    return void 0;
+  }
+  return {
+    platform: config.platform ?? "coingecko",
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    cacheTtlMs: config.cacheTtlMs,
+    timeout: config.timeout,
+    debug: config.debug
+  };
+}
 
 // impl/nodejs/index.ts
 function createNodeProviders(config) {
@@ -2605,6 +2914,7 @@ function createNodeProviders(config) {
   const transportConfig = resolveTransportConfig(network, config?.transport);
   const oracleConfig = resolveOracleConfig(network, config?.oracle);
   const l1Config = resolveL1Config(network, config?.l1);
+  const priceConfig = resolvePriceConfig(config?.price);
   return {
     storage: createFileStorageProvider({
       dataDir: config?.dataDir ?? "./sphere-data"
@@ -2627,7 +2937,8 @@ function createNodeProviders(config) {
       debug: oracleConfig.debug,
       network
     }),
-    l1: l1Config
+    l1: l1Config,
+    price: priceConfig ? createPriceProvider(priceConfig) : void 0
   };
 }
 export {