@unicitylabs/sphere-sdk 0.5.7 → 0.6.0-dev.1

package/dist/impl/browser/index.cjs

@@ -1385,114 +1385,6 @@ 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;
@@ -1759,122 +1651,6 @@ var sha256 = /* @__PURE__ */ createHasher(
 // 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 SphereError("Invalid witness version", "VALIDATION_ERROR");
-  }
-  const converted = convertBits(Array.from(program), 8, 5, true);
-  if (!converted) {
-    throw new SphereError("Failed to convert bits", "VALIDATION_ERROR");
-  }
-  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);
-}
-function hexToBytes2(hex) {
-  const matches = hex.match(/../g);
-  if (!matches) {
-    return new Uint8Array(0);
-  }
-  return Uint8Array.from(matches.map((x) => parseInt(x, 16)));
-}
-
 // transport/websocket.ts
 var WebSocketReadyState = {
   CONNECTING: 0,
@@ -1897,63 +1673,6 @@ function defaultUUIDGenerator() {
 var COMPOSING_INDICATOR_KIND = 25050;
 var TIMESTAMP_RANDOMIZATION = 2 * 24 * 60 * 60;
 var EVENT_KINDS = NOSTR_EVENT_KINDS;
-function hashAddressForTag(address) {
-  const bytes = new TextEncoder().encode("unicity:address:" + address);
-  return import_buffer.Buffer.from(sha256(bytes)).toString("hex");
-}
-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";
@@ -2422,138 +2141,51 @@ var NostrTransportProvider = class {
   }
   async resolveNametag(nametag) {
     this.ensureConnected();
-    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];
-    if (bindingEvent.pubkey) {
-      return bindingEvent.pubkey;
-    }
-    const pubkeyTag = bindingEvent.tags.find((t) => t[0] === "p");
-    if (pubkeyTag?.[1]) return pubkeyTag[1];
-    return null;
+    return this.nostrClient.queryPubkeyByNametag(nametag);
   }
   async resolveNametagInfo(nametag) {
     this.ensureConnected();
-    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) {
+    const binding = await this.nostrClient.queryBindingByNametag(nametag);
+    if (!binding) {
       logger.debug("Nostr", `resolveNametagInfo: no binding events found for Unicity ID "${nametag}"`);
       return null;
     }
-    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) {
-        return {
-          nametag,
-          transportPubkey: bindingEvent.pubkey,
-          chainPubkey: content.public_key,
-          l1Address: content.l1_address,
-          directAddress: content.direct_address || "",
-          proxyAddress,
-          timestamp: bindingEvent.created_at * 1e3
-        };
-      }
-      logger.debug("Nostr", "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]) {
-        return {
-          nametag,
-          transportPubkey: bindingEvent.pubkey,
-          chainPubkey: pubkeyTag[1],
-          l1Address: l1Tag[1],
-          directAddress: "",
-          proxyAddress,
-          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,
-        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: proxyAddr.toString(),
-        timestamp: bindingEvent.created_at * 1e3
-      };
-    }
+    return this.bindingInfoToPeerInfo(binding, nametag);
   }
   /**
    * 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.
+   * Performs reverse lookup via nostr-js-sdk with first-seen-wins anti-hijacking.
    */
   async resolveAddressInfo(address) {
     this.ensureConnected();
-    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
-      };
+    const binding = await this.nostrClient.queryBindingByAddress(address);
+    if (!binding) return null;
+    return this.bindingInfoToPeerInfo(binding);
+  }
+  /**
+   * Convert a BindingInfo (from nostr-js-sdk) to PeerInfo (sphere-sdk type).
+   * Computes PROXY address from nametag if available.
+   */
+  async bindingInfoToPeerInfo(binding, nametag) {
+    const nametagValue = nametag || binding.nametag;
+    let proxyAddress = binding.proxyAddress;
+    if (nametagValue && !proxyAddress) {
+      try {
+        const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
+        const proxyAddr = await ProxyAddress.fromNameTag(nametagValue);
+        proxyAddress = proxyAddr.toString();
+      } catch {
+      }
     }
+    return {
+      nametag: nametagValue,
+      transportPubkey: binding.transportPubkey,
+      chainPubkey: binding.publicKey || "",
+      l1Address: binding.l1Address || "",
+      directAddress: binding.directAddress || "",
+      proxyAddress,
+      timestamp: binding.timestamp
+    };
   }
   /**
    * Resolve transport pubkey (Nostr pubkey) to full peer info.
@@ -2655,7 +2287,7 @@ var NostrTransportProvider = class {
       try {
         const content = JSON.parse(event.content);
         if (content.encrypted_nametag) {
-          const decrypted = await decryptNametag(
+          const decrypted = await (0, import_nostr_js_sdk.decryptNametag)(
             content.encrypted_nametag,
             this.identity.privateKey
           );
@@ -2673,11 +2305,10 @@ var NostrTransportProvider = class {
   }
   /**
    * 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.
+   * Without nametag: publishes base binding (chainPubkey, l1Address, directAddress)
+   * using a per-identity d-tag for address discovery.
+   * With nametag: delegates to nostr-js-sdk's publishNametagBinding which handles
+   * conflict detection (first-seen-wins), encryption, and indexed tags.
    *
    * @returns true if successful, false if nametag is taken by another pubkey
    */
@@ -2687,102 +2318,41 @@ var NostrTransportProvider = class {
       throw new SphereError("Identity not set", "NOT_INITIALIZED");
     }
     const nostrPubkey = this.getNostrPubkey();
-    const dTagBytes = new TextEncoder().encode("unicity:identity:" + nostrPubkey);
-    const dTag = import_buffer.Buffer.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) {
-        logger.debug("Nostr", "Unicity ID 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 = (0, import_nostr_js_sdk.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) {
-      logger.debug("Nostr", "Published identity binding with Unicity ID:", nametag, "for pubkey:", nostrPubkey.slice(0, 16) + "...");
-    } else {
-      logger.debug("Nostr", "Published identity binding (no Unicity ID) for pubkey:", nostrPubkey.slice(0, 16) + "...");
-    }
-    return true;
-  }
-  /** @deprecated Use publishIdentityBinding instead */
-  async publishNametag(nametag, address) {
-    this.ensureReady();
-    const hashedNametag = (0, import_nostr_js_sdk.hashNametag)(nametag);
-    const event = await this.createEvent(EVENT_KINDS.NAMETAG_BINDING, address, [
-      ["d", hashedNametag],
-      ["a", address]
-    ]);
-    await this.publishEvent(event);
-    logger.debug("Nostr", "Published Unicity ID binding:", nametag);
-  }
-  async registerNametag(nametag, _publicKey, directAddress = "") {
-    this.ensureReady();
-    if (!this.identity) {
-      throw new SphereError("Identity not set", "NOT_INITIALIZED");
-    }
-    const nostrPubkey = this.getNostrPubkey();
-    const existing = await this.resolveNametag(nametag);
-    logger.debug("Nostr", "registerNametag:", nametag, "existing:", existing, "myPubkey:", nostrPubkey);
-    if (existing && existing !== nostrPubkey) {
-      logger.debug("Nostr", "Unicity ID already taken:", nametag, "- owner:", existing);
-      return false;
+      try {
+        const success2 = await this.nostrClient.publishNametagBinding(
+          nametag,
+          nostrPubkey,
+          {
+            publicKey: chainPubkey,
+            l1Address,
+            directAddress,
+            proxyAddress: proxyAddr.toString()
+          }
+        );
+        if (success2) {
+          logger.debug("Nostr", "Published identity binding with Unicity ID:", nametag, "for pubkey:", nostrPubkey.slice(0, 16) + "...");
+        }
+        return success2;
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("already claimed")) {
+          logger.debug("Nostr", "Unicity ID already taken:", nametag);
+          return false;
+        }
+        throw error;
+      }
     }
-    const privateKeyHex = this.identity.privateKey;
-    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 = (0, import_nostr_js_sdk.hashNametag)(nametag);
-    const content = JSON.stringify({
-      nametag_hash: hashedNametag,
-      address: nostrPubkey,
-      verified: Date.now(),
-      // Extended fields for nametag recovery and address lookup
-      encrypted_nametag: encryptedNametag,
-      public_key: compressedPubkey,
-      l1_address: l1Address,
-      direct_address: directAddress,
-      proxy_address: proxyAddress
+    const success = await this.nostrClient.publishIdentityBinding({
+      publicKey: chainPubkey,
+      l1Address,
+      directAddress
     });
-    const tags = [
-      ["d", hashedNametag],
-      ["nametag", hashedNametag],
-      ["t", hashedNametag],
-      ["t", hashAddressForTag(directAddress)],
-      ["t", hashAddressForTag(proxyAddress)],
-      ["address", nostrPubkey],
-      ["pubkey", compressedPubkey],
-      ["l1", l1Address]
-    ];
-    const event = await this.createEvent(EVENT_KINDS.NAMETAG_BINDING, content, tags);
-    await this.publishEvent(event);
-    logger.debug("Nostr", "Registered Unicity ID:", nametag, "for pubkey:", nostrPubkey.slice(0, 16) + "...", "l1:", l1Address.slice(0, 12) + "...");
-    return true;
+    if (success) {
+      logger.debug("Nostr", "Published identity binding (no Unicity ID) for pubkey:", nostrPubkey.slice(0, 16) + "...");
+    }
+    return success;
   }
   // Track broadcast subscriptions
   broadcastSubscriptions = /* @__PURE__ */ new Map();
@@ -4064,6 +3634,130 @@ var InMemoryIpfsStatePersistence = class {
   }
 };
 
+// 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);
+
+// 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);
+var ec = new import_elliptic.default.ec("secp256k1");
+var CURVE_ORDER = BigInt(
+  "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"
+);
+function hexToBytes2(hex) {
+  const matches = hex.match(/../g);
+  if (!matches) {
+    return new Uint8Array(0);
+  }
+  return Uint8Array.from(matches.map((x) => parseInt(x, 16)));
+}
+
 // impl/shared/ipfs/ipns-key-derivation.ts
 var IPNS_HKDF_INFO = "ipfs-storage-ed25519-v1";
 var libp2pCryptoModule = null;