@unicitylabs/sphere-sdk 0.1.2 → 0.1.4

package/dist/impl/nodejs/index.cjs

@@ -75,6 +75,9 @@ var FileStorageProvider = class {
     return this._identity;
   }
   async connect() {
+    if (this.status === "connected") {
+      return;
+    }
     if (!fs.existsSync(this.dataDir)) {
       fs.mkdirSync(this.dataDir, { recursive: true });
     }
@@ -183,7 +186,7 @@ var FileTokenStorageProvider = class {
     const data = {
       _meta: {
         version: 1,
-        address: this.identity?.address ?? "",
+        address: this.identity?.l1Address ?? "",
         formatVersion: "2.0",
         updatedAt: Date.now()
       }
@@ -298,15 +301,556 @@ var import_ws = __toESM(require("ws"), 1);
 
 // 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();
@@ -436,6 +980,59 @@ var TIMEOUTS = {
 
 // 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";
@@ -445,9 +1042,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();
@@ -455,9 +1053,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],
@@ -477,16 +1072,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();
       }
@@ -496,17 +1118,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;
@@ -524,7 +1148,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
@@ -536,9 +1161,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",
@@ -566,6 +1191,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);
@@ -574,19 +1201,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",
@@ -606,8 +1227,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
@@ -618,7 +1239,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();
     }
   }
@@ -634,18 +1285,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);
@@ -762,6 +1412,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);
@@ -772,8 +1534,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);
@@ -781,27 +1546,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);
       }
     }
@@ -810,6 +1590,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);
+        }
       }
     };
   }
@@ -828,81 +1613,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;
@@ -921,23 +1644,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) {
@@ -946,7 +1700,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
     };
@@ -966,7 +1720,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,
@@ -996,7 +1750,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,
@@ -1021,7 +1775,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
@@ -1076,109 +1830,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
@@ -1639,13 +2433,72 @@ 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/nodejs/oracle/index.ts
-var NodeTrustBaseLoader = class {
+var NodeTrustBaseLoader = class extends BaseTrustBaseLoader {
   filePath;
-  constructor(filePath = "./trustbase-testnet.json") {
-    this.filePath = filePath;
+  constructor(filePathOrNetwork) {
+    if (!filePathOrNetwork) {
+      super("testnet");
+    } else if (filePathOrNetwork.includes("/") || filePathOrNetwork.includes(".")) {
+      super("testnet");
+      this.filePath = filePathOrNetwork;
+    } else {
+      super(filePathOrNetwork);
+    }
   }
-  async load() {
+  async loadFromExternal() {
+    if (!this.filePath) return null;
     try {
       if (fs3.existsSync(this.filePath)) {
         const content = fs3.readFileSync(this.filePath, "utf-8");
@@ -1656,14 +2509,14 @@ var NodeTrustBaseLoader = class {
     return null;
   }
 };
-function createNodeTrustBaseLoader(filePath) {
-  return new NodeTrustBaseLoader(filePath);
+function createNodeTrustBaseLoader(filePathOrNetwork) {
+  return new NodeTrustBaseLoader(filePathOrNetwork);
 }
 function createUnicityAggregatorProvider(config) {
-  const { trustBasePath, ...restConfig } = config;
+  const { trustBasePath, network, ...restConfig } = config;
   return new UnicityAggregatorProvider({
     ...restConfig,
-    trustBaseLoader: createNodeTrustBaseLoader(trustBasePath)
+    trustBaseLoader: createNodeTrustBaseLoader(trustBasePath ?? network ?? "testnet")
   });
 }
 var createUnicityOracleProvider = createUnicityAggregatorProvider;
@@ -1742,7 +2595,8 @@ function createNodeProviders(config) {
       timeout: oracleConfig.timeout,
       trustBasePath: oracleConfig.trustBasePath,
       skipVerification: oracleConfig.skipVerification,
-      debug: oracleConfig.debug
+      debug: oracleConfig.debug,
+      network
     }),
     l1: l1Config
   };
@@ -1764,4 +2618,9 @@ function createNodeProviders(config) {
   createUnicityAggregatorProvider,
   createUnicityOracleProvider
 });
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=index.cjs.map