@unicitylabs/sphere-sdk 0.1.8 → 0.2.0

package/dist/impl/browser/index.js

@@ -21,8 +21,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 */
@@ -215,6 +217,19 @@ var LocalStorageProvider = class {
       await this.remove(key);
     }
   }
+  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 [];
+    }
+  }
   // ===========================================================================
   // Helpers
   // ===========================================================================
@@ -1182,6 +1197,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");
@@ -1590,6 +1609,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);
@@ -1633,15 +1674,17 @@ var NostrTransportProvider = class {
     const bindingEvent = events[0];
     try {
       const content = JSON.parse(bindingEvent.content);
+      const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
+      const proxyAddr = await ProxyAddress.fromNameTag(nametag);
+      const proxyAddress = proxyAddr.toString();
       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,
+          proxyAddress,
           timestamp: bindingEvent.created_at * 1e3
         };
       }
@@ -1649,14 +1692,13 @@ var NostrTransportProvider = class {
       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,
+          proxyAddress,
           timestamp: bindingEvent.created_at * 1e3
         };
       }
@@ -1668,17 +1710,90 @@ var NostrTransportProvider = class {
         l1Address: "",
         // Cannot derive without 33-byte pubkey
         directAddress: "",
-        proxyAddress: `PROXY:${hashedNametag}`,
+        proxyAddress,
         timestamp: bindingEvent.created_at * 1e3
       };
     } catch {
+      const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
+      const proxyAddr = await ProxyAddress.fromNameTag(nametag);
       return {
         nametag,
         transportPubkey: bindingEvent.pubkey,
         chainPubkey: "",
         l1Address: "",
         directAddress: "",
-        proxyAddress: `PROXY:${hashedNametag}`,
+        proxyAddress: proxyAddr.toString(),
+        timestamp: bindingEvent.created_at * 1e3
+      };
+    }
+  }
+  /**
+   * 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
       };
     }
@@ -1726,6 +1841,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);
@@ -1752,6 +1924,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,
@@ -1761,17 +1936,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;
@@ -2776,6 +2954,113 @@ async function readFileAsUint8Array(file) {
   return new Uint8Array(buffer);
 }
 
+// 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];
@@ -2824,6 +3109,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
+  };
+}
 function resolveArrayConfig(defaults, replace, additional) {
   if (replace) {
     return replace;
@@ -2891,6 +3189,7 @@ function createBrowserProviders(config) {
   const oracleConfig = resolveOracleConfig(network, config?.oracle);
   const l1Config = resolveL1Config(network, config?.l1);
   const tokenSyncConfig = resolveTokenSyncConfig(network, config?.tokenSync);
+  const priceConfig = resolvePriceConfig(config?.price);
   return {
     storage: createLocalStorageProvider(config?.storage),
     transport: createNostrTransportProvider({
@@ -2911,6 +3210,7 @@ function createBrowserProviders(config) {
     }),
     tokenStorage: createIndexedDBTokenStorageProvider(),
     l1: l1Config,
+    price: priceConfig ? createPriceProvider(priceConfig) : void 0,
     tokenSyncConfig
   };
 }