@elisym/sdk 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1199 @@
+'use strict';
+
+var nostrTools = require('nostr-tools');
+var nip44 = require('nostr-tools/nip44');
+var nip17 = require('nostr-tools/nip17');
+var nip59 = require('nostr-tools/nip59');
+var web3_js = require('@solana/web3.js');
+var Decimal = require('decimal.js-light');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var nip44__namespace = /*#__PURE__*/_interopNamespace(nip44);
+var nip17__namespace = /*#__PURE__*/_interopNamespace(nip17);
+var nip59__namespace = /*#__PURE__*/_interopNamespace(nip59);
+var Decimal__default = /*#__PURE__*/_interopDefault(Decimal);
+
+// src/core/pool.ts
+
+// src/constants.ts
+var RELAYS = [
+  "wss://relay.damus.io",
+  "wss://nos.lol",
+  "wss://relay.nostr.band",
+  "wss://relay.primal.net",
+  "wss://relay.snort.social"
+];
+var KIND_APP_HANDLER = 31990;
+var KIND_JOB_REQUEST_BASE = 5e3;
+var KIND_JOB_RESULT_BASE = 6e3;
+var KIND_JOB_FEEDBACK = 7e3;
+var DEFAULT_KIND_OFFSET = 100;
+var KIND_GIFT_WRAP = 1059;
+var KIND_JOB_REQUEST = KIND_JOB_REQUEST_BASE + DEFAULT_KIND_OFFSET;
+var KIND_JOB_RESULT = KIND_JOB_RESULT_BASE + DEFAULT_KIND_OFFSET;
+function jobRequestKind(offset) {
+  return KIND_JOB_REQUEST_BASE + offset;
+}
+function jobResultKind(offset) {
+  return KIND_JOB_RESULT_BASE + offset;
+}
+var KIND_PING = 20200;
+var KIND_PONG = 20201;
+var LAMPORTS_PER_SOL = 1e9;
+var PROTOCOL_FEE_BPS = 300;
+var PROTOCOL_TREASURY = "GY7vnWMkKpftU4nQ16C2ATkj1JwrQpHhknkaBUn67VTy";
+
+// src/core/pool.ts
+var NostrPool = class {
+  pool;
+  relays;
+  constructor(relays = RELAYS) {
+    this.pool = new nostrTools.SimplePool();
+    this.relays = relays;
+  }
+  async querySync(filter) {
+    return Promise.race([
+      this.pool.querySync(this.relays, filter),
+      new Promise(
+        (resolve) => setTimeout(() => resolve([]), 15e3)
+      )
+    ]);
+  }
+  async queryBatched(filter, keys, batchSize = 250) {
+    const batches = [];
+    for (let i = 0; i < keys.length; i += batchSize) {
+      const batch = keys.slice(i, i + batchSize);
+      batches.push(
+        Promise.race([
+          this.pool.querySync(this.relays, {
+            ...filter,
+            authors: batch
+          }),
+          new Promise(
+            (resolve) => setTimeout(() => resolve([]), 15e3)
+          )
+        ])
+      );
+    }
+    return (await Promise.all(batches)).flat();
+  }
+  async queryBatchedByTag(filter, tagName, values, batchSize = 250) {
+    const batches = [];
+    for (let i = 0; i < values.length; i += batchSize) {
+      const batch = values.slice(i, i + batchSize);
+      batches.push(
+        Promise.race([
+          this.pool.querySync(this.relays, {
+            ...filter,
+            [`#${tagName}`]: batch
+          }),
+          new Promise(
+            (resolve) => setTimeout(() => resolve([]), 15e3)
+          )
+        ])
+      );
+    }
+    return (await Promise.all(batches)).flat();
+  }
+  async publish(event) {
+    try {
+      await Promise.any(this.pool.publish(this.relays, event));
+    } catch (err) {
+      if (err instanceof AggregateError) {
+        throw new Error(
+          `Failed to publish to all ${this.relays.length} relays: ${err.errors.map((e) => e.message).join(", ")}`
+        );
+      }
+      throw err;
+    }
+  }
+  /** Publish to all relays and wait for all to settle. Throws if none accepted. */
+  async publishAll(event) {
+    const results = await Promise.allSettled(this.pool.publish(this.relays, event));
+    const anyOk = results.some((r) => r.status === "fulfilled");
+    if (!anyOk) {
+      throw new Error(
+        `Failed to publish to all ${this.relays.length} relays`
+      );
+    }
+  }
+  subscribe(filter, onEvent) {
+    return this.pool.subscribeMany(
+      this.relays,
+      filter,
+      { onevent: onEvent }
+    );
+  }
+  /**
+   * Subscribe and wait until at least one relay confirms the subscription
+   * is active (EOSE). Resolves on the first relay that responds.
+   * Essential for ephemeral events where the subscription must be live
+   * before publishing.
+   */
+  subscribeAndWait(filter, onEvent, timeoutMs = 3e3) {
+    return new Promise((resolve) => {
+      let resolved = false;
+      const done = () => {
+        if (resolved) return;
+        resolved = true;
+        resolve(combinedSub);
+      };
+      const subs = [];
+      for (const relay of this.relays) {
+        const sub = this.pool.subscribeMany(
+          [relay],
+          filter,
+          {
+            onevent: onEvent,
+            oneose: done
+          }
+        );
+        subs.push(sub);
+      }
+      const combinedSub = {
+        close: (reason) => {
+          for (const s of subs) s.close(reason);
+        }
+      };
+      setTimeout(done, timeoutMs);
+    });
+  }
+  /**
+   * Tear down pool and create a fresh one.
+   * Works around nostr-tools `onerror → skipReconnection = true` bug
+   * that permanently kills subscriptions. Callers must re-subscribe.
+   */
+  reset() {
+    try {
+      this.pool.close(this.relays);
+    } catch {
+    }
+    this.pool = new nostrTools.SimplePool();
+  }
+  /**
+   * Lightweight connectivity probe. Returns true if at least one relay responds.
+   */
+  async probe(timeoutMs = 3e3) {
+    let timer;
+    try {
+      await Promise.race([
+        this.pool.querySync(this.relays, { kinds: [0], limit: 1 }),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("probe timeout")), timeoutMs);
+        })
+      ]);
+      return true;
+    } catch {
+      return false;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  getRelays() {
+    return this.relays;
+  }
+  close() {
+    this.pool.close(this.relays);
+  }
+};
+var ElisymIdentity = class _ElisymIdentity {
+  secretKey;
+  publicKey;
+  npub;
+  constructor(secretKey) {
+    this.secretKey = secretKey;
+    this.publicKey = nostrTools.getPublicKey(secretKey);
+    this.npub = nostrTools.nip19.npubEncode(this.publicKey);
+  }
+  static generate() {
+    return new _ElisymIdentity(nostrTools.generateSecretKey());
+  }
+  static fromSecretKey(sk) {
+    return new _ElisymIdentity(sk);
+  }
+  static fromHex(hex) {
+    if (hex.length !== 64 || !/^[0-9a-fA-F]{64}$/.test(hex)) {
+      throw new Error("Invalid secret key hex: expected 64 hex characters (32 bytes).");
+    }
+    const bytes = new Uint8Array(32);
+    for (let i = 0; i < 64; i += 2) {
+      bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    }
+    return new _ElisymIdentity(bytes);
+  }
+};
+function toDTag(name) {
+  return name.toLowerCase().replace(/\s+/g, "-");
+}
+function buildAgentsFromEvents(events, network) {
+  const latestByDTag = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const dTag = event.tags.find((t) => t[0] === "d")?.[1] ?? "";
+    const key = `${event.pubkey}:${dTag}`;
+    const prev = latestByDTag.get(key);
+    if (!prev || event.created_at > prev.created_at) {
+      latestByDTag.set(key, event);
+    }
+  }
+  const accumMap = /* @__PURE__ */ new Map();
+  for (const event of latestByDTag.values()) {
+    try {
+      const card = JSON.parse(event.content);
+      if (!card.name || card.deleted) continue;
+      const agentNetwork = card.payment?.network ?? "devnet";
+      if (agentNetwork !== network) continue;
+      const kTags = event.tags.filter((t) => t[0] === "k").map((t) => parseInt(t[1] ?? "", 10)).filter((k) => !isNaN(k));
+      const entry = { card, kTags, createdAt: event.created_at };
+      const existing = accumMap.get(event.pubkey);
+      if (existing) {
+        const dupIndex = existing.entries.findIndex((e) => e.card.name === card.name);
+        if (dupIndex >= 0) {
+          existing.entries[dupIndex] = entry;
+        } else {
+          existing.entries.push(entry);
+        }
+        if (event.created_at > existing.lastSeen) {
+          existing.lastSeen = event.created_at;
+          existing.eventId = event.id;
+        }
+      } else {
+        accumMap.set(event.pubkey, {
+          pubkey: event.pubkey,
+          npub: nostrTools.nip19.npubEncode(event.pubkey),
+          entries: [entry],
+          eventId: event.id,
+          lastSeen: event.created_at
+        });
+      }
+    } catch {
+    }
+  }
+  const agentMap = /* @__PURE__ */ new Map();
+  for (const [pubkey, acc] of accumMap) {
+    const supportedKinds = [];
+    for (const e of acc.entries) {
+      for (const k of e.kTags) {
+        if (!supportedKinds.includes(k)) supportedKinds.push(k);
+      }
+    }
+    agentMap.set(pubkey, {
+      pubkey: acc.pubkey,
+      npub: acc.npub,
+      cards: acc.entries.map((e) => e.card),
+      eventId: acc.eventId,
+      supportedKinds,
+      lastSeen: acc.lastSeen
+    });
+  }
+  return agentMap;
+}
+var DiscoveryService = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  // Instance-level set — avoids module-level state leak across clients
+  allSeenAgents = /* @__PURE__ */ new Set();
+  /** Count elisym agents (kind:31990 with "elisym" tag). */
+  async fetchAllAgentCount() {
+    const events = await this.pool.querySync({
+      kinds: [KIND_APP_HANDLER],
+      "#t": ["elisym"]
+    });
+    for (const event of events) {
+      this.allSeenAgents.add(event.pubkey);
+    }
+    return this.allSeenAgents.size;
+  }
+  /**
+   * Fetch a single page of elisym agents with relay-side pagination.
+   * Uses `until` cursor for Nostr cursor-based pagination.
+   * Does NOT fetch activity (faster than fetchAgents).
+   */
+  async fetchAgentsPage(network = "devnet", limit = 20, until) {
+    const filter = {
+      kinds: [KIND_APP_HANDLER],
+      "#t": ["elisym"],
+      limit
+    };
+    if (until !== void 0) {
+      filter.until = until;
+    }
+    const events = await this.pool.querySync(filter);
+    const rawEventCount = events.length;
+    let oldestCreatedAt = null;
+    for (const event of events) {
+      if (oldestCreatedAt === null || event.created_at < oldestCreatedAt) {
+        oldestCreatedAt = event.created_at;
+      }
+    }
+    const agentMap = buildAgentsFromEvents(events, network);
+    const agents = Array.from(agentMap.values()).sort(
+      (a, b) => b.lastSeen - a.lastSeen
+    );
+    return { agents, oldestCreatedAt, rawEventCount };
+  }
+  /** Enrich agents with kind:0 metadata (name, picture, about). Mutates in place and returns the same array. */
+  async enrichWithMetadata(agents) {
+    const pubkeys = agents.map((a) => a.pubkey);
+    if (pubkeys.length === 0) return agents;
+    const metaEvents = await this.pool.queryBatched(
+      { kinds: [0] },
+      pubkeys
+    );
+    const latestMeta = /* @__PURE__ */ new Map();
+    for (const ev of metaEvents) {
+      const prev = latestMeta.get(ev.pubkey);
+      if (!prev || ev.created_at > prev.created_at) {
+        latestMeta.set(ev.pubkey, ev);
+      }
+    }
+    const agentLookup = new Map(agents.map((a) => [a.pubkey, a]));
+    for (const [pubkey, ev] of latestMeta) {
+      const agent = agentLookup.get(pubkey);
+      if (!agent) continue;
+      try {
+        const meta = JSON.parse(ev.content);
+        if (meta.picture) agent.picture = meta.picture;
+        if (meta.name) agent.name = meta.name;
+        if (meta.about) agent.about = meta.about;
+      } catch {
+      }
+    }
+    return agents;
+  }
+  /** Fetch elisym agents filtered by network. */
+  async fetchAgents(network = "devnet", limit) {
+    const filter = {
+      kinds: [KIND_APP_HANDLER],
+      "#t": ["elisym"]
+    };
+    if (limit !== void 0) filter.limit = limit;
+    const events = await this.pool.querySync(filter);
+    const agentMap = buildAgentsFromEvents(events, network);
+    const agentPubkeys = Array.from(agentMap.keys());
+    if (agentPubkeys.length > 0) {
+      const activitySince = Math.floor(Date.now() / 1e3) - 24 * 60 * 60;
+      const resultKinds = /* @__PURE__ */ new Set();
+      for (const agent of agentMap.values()) {
+        for (const k of agent.supportedKinds) {
+          if (k >= KIND_JOB_REQUEST_BASE && k < KIND_JOB_RESULT_BASE) {
+            resultKinds.add(KIND_JOB_RESULT_BASE + (k - KIND_JOB_REQUEST_BASE));
+          }
+        }
+      }
+      resultKinds.add(jobResultKind(DEFAULT_KIND_OFFSET));
+      const activityEvents = await this.pool.queryBatched(
+        {
+          kinds: [...resultKinds, KIND_JOB_FEEDBACK],
+          since: activitySince
+        },
+        agentPubkeys
+      );
+      for (const ev of activityEvents) {
+        const agent = agentMap.get(ev.pubkey);
+        if (agent && ev.created_at > agent.lastSeen) {
+          agent.lastSeen = ev.created_at;
+        }
+      }
+    }
+    const agents = Array.from(agentMap.values()).sort(
+      (a, b) => b.lastSeen - a.lastSeen
+    );
+    await this.enrichWithMetadata(agents);
+    return agents;
+  }
+  /** Publish a capability card (kind:31990) as a provider. */
+  async publishCapability(identity, card, kinds = [KIND_JOB_REQUEST]) {
+    if (!card.payment?.address) {
+      throw new Error(
+        "Cannot publish capability without a payment address. Connect a wallet before publishing."
+      );
+    }
+    const tags = [
+      ["d", toDTag(card.name)],
+      ["t", "elisym"],
+      ...card.capabilities.map((c) => ["t", c]),
+      ...kinds.map((k) => ["k", String(k)])
+    ];
+    const event = nostrTools.finalizeEvent(
+      {
+        kind: KIND_APP_HANDLER,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags,
+        content: JSON.stringify(card)
+      },
+      identity.secretKey
+    );
+    await this.pool.publish(event);
+    return event.id;
+  }
+  /** Publish a Nostr profile (kind:0) as a provider. */
+  async publishProfile(identity, name, about, picture) {
+    const content = { name, about };
+    if (picture) content.picture = picture;
+    const event = nostrTools.finalizeEvent(
+      {
+        kind: 0,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [],
+        content: JSON.stringify(content)
+      },
+      identity.secretKey
+    );
+    await this.pool.publish(event);
+    return event.id;
+  }
+  /**
+   * Delete a capability by publishing a tombstone replacement.
+   * Since kind:31990 is a parameterized replaceable event,
+   * publishing a new event with the same `d` tag and `"deleted":true`
+   * content replaces the old one on all relays.
+   */
+  async deleteCapability(identity, capabilityName) {
+    const dTag = toDTag(capabilityName);
+    const event = nostrTools.finalizeEvent(
+      {
+        kind: KIND_APP_HANDLER,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [
+          ["d", dTag],
+          ["t", "elisym"]
+        ],
+        content: JSON.stringify({ deleted: true })
+      },
+      identity.secretKey
+    );
+    await this.pool.publishAll(event);
+    return event.id;
+  }
+};
+function isEncrypted(event) {
+  return event.tags.some((t) => t[0] === "encrypted" && t[1] === "nip44");
+}
+function nip44Encrypt(plaintext, secretKey, recipientPubkey) {
+  const conversationKey = nip44__namespace.v2.utils.getConversationKey(secretKey, recipientPubkey);
+  return nip44__namespace.v2.encrypt(plaintext, conversationKey);
+}
+function nip44Decrypt(ciphertext, secretKey, senderPubkey) {
+  const conversationKey = nip44__namespace.v2.utils.getConversationKey(secretKey, senderPubkey);
+  return nip44__namespace.v2.decrypt(ciphertext, conversationKey);
+}
+function resolveRequestId(event) {
+  return event.tags.find((t) => t[0] === "e")?.[1];
+}
+var MarketplaceService = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  /** Submit a job request with NIP-44 encrypted input. Returns the event ID. */
+  async submitJobRequest(identity, options) {
+    if (!options.input) {
+      throw new Error("Job input must not be empty.");
+    }
+    const plaintext = options.input;
+    const encrypted = options.providerPubkey ? nip44Encrypt(plaintext, identity.secretKey, options.providerPubkey) : plaintext;
+    const iValue = options.providerPubkey ? "encrypted" : "";
+    const tags = [
+      ["i", iValue, "text"],
+      ["t", options.capability],
+      ["t", "elisym"],
+      ["output", "text/plain"]
+    ];
+    if (options.providerPubkey) {
+      tags.push(["p", options.providerPubkey]);
+      tags.push(["encrypted", "nip44"]);
+    }
+    const kind = jobRequestKind(options.kindOffset ?? DEFAULT_KIND_OFFSET);
+    const event = nostrTools.finalizeEvent(
+      {
+        kind,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags,
+        content: encrypted
+      },
+      identity.secretKey
+    );
+    await this.pool.publish(event);
+    return event.id;
+  }
+  /**
+   * Subscribe to job updates (feedback + results) for a given job.
+   * Returns a cleanup function.
+   */
+  subscribeToJobUpdates(jobEventId, providerPubkey, customerPublicKey, callbacks, timeoutMs = 12e4, customerSecretKey, kindOffsets) {
+    const offsets = kindOffsets ?? [DEFAULT_KIND_OFFSET];
+    const resultKinds = offsets.map(jobResultKind);
+    const since = Math.floor(Date.now() / 1e3) - 5;
+    const subs = [];
+    let resolved = false;
+    let resultDelivered = false;
+    let timer;
+    const done = () => {
+      resolved = true;
+      if (timer) clearTimeout(timer);
+      for (const s of subs) s.close();
+    };
+    const decryptResult = (ev) => {
+      if (customerSecretKey && isEncrypted(ev)) {
+        try {
+          return nip44Decrypt(ev.content, customerSecretKey, ev.pubkey);
+        } catch {
+          return ev.content;
+        }
+      }
+      return ev.content;
+    };
+    const handleResult = (ev) => {
+      if (resolved || resultDelivered) return;
+      if (providerPubkey && ev.pubkey !== providerPubkey) return;
+      resultDelivered = true;
+      callbacks.onResult?.(decryptResult(ev), ev.id);
+      done();
+    };
+    const feedbackSub = this.pool.subscribe(
+      {
+        kinds: [KIND_JOB_FEEDBACK],
+        "#e": [jobEventId],
+        since
+      },
+      (ev) => {
+        if (resolved) return;
+        if (providerPubkey && ev.pubkey !== providerPubkey) return;
+        const statusTag = ev.tags.find((t) => t[0] === "status");
+        if (statusTag?.[1] === "payment-required") {
+          const amtTag = ev.tags.find((t) => t[0] === "amount");
+          const amt = amtTag?.[1] ? parseInt(amtTag[1], 10) : 0;
+          const paymentReq = amtTag?.[2];
+          callbacks.onFeedback?.("payment-required", amt, paymentReq);
+        }
+      }
+    );
+    subs.push(feedbackSub);
+    const resultSub = this.pool.subscribe(
+      {
+        kinds: resultKinds,
+        "#e": [jobEventId],
+        since
+      },
+      handleResult
+    );
+    subs.push(resultSub);
+    const resultSub2 = this.pool.subscribe(
+      {
+        kinds: resultKinds,
+        "#p": [customerPublicKey],
+        "#e": [jobEventId],
+        since
+      },
+      handleResult
+    );
+    subs.push(resultSub2);
+    timer = setTimeout(() => {
+      if (!resolved) {
+        done();
+        callbacks.onError?.(`Timed out waiting for response (${timeoutMs / 1e3}s).`);
+      }
+    }, timeoutMs);
+    return done;
+  }
+  /** Submit payment confirmation feedback. */
+  async submitPaymentConfirmation(identity, jobEventId, providerPubkey, txSignature) {
+    const event = nostrTools.finalizeEvent(
+      {
+        kind: KIND_JOB_FEEDBACK,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [
+          ["e", jobEventId],
+          ["p", providerPubkey],
+          ["status", "payment-completed"],
+          ["tx", txSignature, "solana"],
+          ["t", "elisym"]
+        ],
+        content: ""
+      },
+      identity.secretKey
+    );
+    await this.pool.publish(event);
+  }
+  /** Submit rating feedback for a job. */
+  async submitFeedback(identity, jobEventId, providerPubkey, positive, capability) {
+    const tags = [
+      ["e", jobEventId],
+      ["p", providerPubkey],
+      ["status", "success"],
+      ["rating", positive ? "1" : "0"],
+      ["t", "elisym"]
+    ];
+    if (capability) tags.push(["t", capability]);
+    const event = nostrTools.finalizeEvent(
+      {
+        kind: KIND_JOB_FEEDBACK,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags,
+        content: positive ? "Good result" : "Poor result"
+      },
+      identity.secretKey
+    );
+    await this.pool.publish(event);
+  }
+  // --- Provider methods ---
+  /** Subscribe to incoming job requests for specific kinds. */
+  subscribeToJobRequests(identity, kinds, onRequest) {
+    return this.pool.subscribe(
+      {
+        kinds,
+        "#p": [identity.publicKey],
+        since: Math.floor(Date.now() / 1e3)
+      },
+      onRequest
+    );
+  }
+  /** Submit a job result with NIP-44 encrypted content. Result kind is derived from the request kind. */
+  async submitJobResult(identity, requestEvent, content, amount) {
+    const encrypted = nip44Encrypt(content, identity.secretKey, requestEvent.pubkey);
+    const resultKind = KIND_JOB_RESULT_BASE + (requestEvent.kind - KIND_JOB_REQUEST_BASE);
+    const tags = [
+      ["e", requestEvent.id],
+      ["p", requestEvent.pubkey],
+      ["t", "elisym"],
+      ["encrypted", "nip44"]
+    ];
+    if (amount != null) {
+      tags.push(["amount", String(amount)]);
+    }
+    const event = nostrTools.finalizeEvent(
+      {
+        kind: resultKind,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags,
+        content: encrypted
+      },
+      identity.secretKey
+    );
+    await this.pool.publish(event);
+    return event.id;
+  }
+  /** Submit payment-required feedback with a payment request. */
+  async submitPaymentRequiredFeedback(identity, requestEvent, amount, paymentRequestJson) {
+    const event = nostrTools.finalizeEvent(
+      {
+        kind: KIND_JOB_FEEDBACK,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [
+          ["e", requestEvent.id],
+          ["p", requestEvent.pubkey],
+          ["status", "payment-required"],
+          ["amount", String(amount), paymentRequestJson, "solana"],
+          ["t", "elisym"]
+        ],
+        content: ""
+      },
+      identity.secretKey
+    );
+    await this.pool.publish(event);
+  }
+  // --- Query methods ---
+  /** Fetch recent jobs from the network. */
+  async fetchRecentJobs(agentPubkeys, limit, since, kindOffsets) {
+    const offsets = kindOffsets ?? [DEFAULT_KIND_OFFSET];
+    const requestKinds = offsets.map(jobRequestKind);
+    const resultKinds = offsets.map(jobResultKind);
+    const reqFilter = {
+      kinds: requestKinds,
+      "#t": ["elisym"],
+      ...limit != null && { limit },
+      ...since != null && { since }
+    };
+    const requests = await this.pool.querySync(reqFilter);
+    const requestIds = requests.map((r) => r.id);
+    let results = [];
+    let feedbacks = [];
+    if (requestIds.length > 0) {
+      const [resultArrays, feedbackArrays] = await Promise.all([
+        this.pool.queryBatchedByTag(
+          { kinds: resultKinds },
+          "e",
+          requestIds
+        ),
+        this.pool.queryBatchedByTag(
+          { kinds: [KIND_JOB_FEEDBACK] },
+          "e",
+          requestIds
+        )
+      ]);
+      results = resultArrays;
+      feedbacks = feedbackArrays;
+    }
+    const targetedAgentByRequest = /* @__PURE__ */ new Map();
+    for (const req of requests) {
+      const pTag = req.tags.find((t) => t[0] === "p");
+      if (pTag?.[1]) targetedAgentByRequest.set(req.id, pTag[1]);
+    }
+    const resultsByRequest = /* @__PURE__ */ new Map();
+    for (const r of results) {
+      const reqId = resolveRequestId(r);
+      if (!reqId) continue;
+      const targeted = targetedAgentByRequest.get(reqId);
+      if (targeted && r.pubkey !== targeted) continue;
+      const existing = resultsByRequest.get(reqId);
+      if (!existing || targeted && r.pubkey === targeted) {
+        resultsByRequest.set(reqId, r);
+      }
+    }
+    const feedbackByRequest = /* @__PURE__ */ new Map();
+    for (const f of feedbacks) {
+      const reqId = resolveRequestId(f);
+      if (!reqId) continue;
+      const targeted = targetedAgentByRequest.get(reqId);
+      if (targeted && f.pubkey !== targeted) continue;
+      const existing = feedbackByRequest.get(reqId);
+      if (!existing || targeted && f.pubkey === targeted) {
+        feedbackByRequest.set(reqId, f);
+      }
+    }
+    const jobs = [];
+    for (const req of requests) {
+      const result = resultsByRequest.get(req.id);
+      const feedback = feedbackByRequest.get(req.id);
+      const jobAgentPubkey = result?.pubkey ?? feedback?.pubkey;
+      if (agentPubkeys && agentPubkeys.size > 0 && jobAgentPubkey) {
+        if (!agentPubkeys.has(jobAgentPubkey)) continue;
+      }
+      const capability = req.tags.find((t) => t[0] === "t" && t[1] !== "elisym")?.[1];
+      const bid = req.tags.find((t) => t[0] === "bid")?.[1];
+      let status = "processing";
+      let amount;
+      let txHash;
+      if (result) {
+        status = "success";
+        const amtTag = result.tags.find((t) => t[0] === "amount");
+        if (amtTag?.[1]) amount = parseInt(amtTag[1], 10);
+      }
+      const allFeedbacksForReq = feedbacks.filter(
+        (f) => resolveRequestId(f) === req.id
+      );
+      for (const fb of allFeedbacksForReq) {
+        const txTag = fb.tags.find((t) => t[0] === "tx");
+        if (txTag?.[1]) {
+          txHash = txTag[1];
+          break;
+        }
+      }
+      if (feedback) {
+        if (!result) {
+          const statusTag = feedback.tags.find((t) => t[0] === "status");
+          if (statusTag?.[1]) {
+            const isTargeted = targetedAgentByRequest.has(req.id);
+            if (statusTag[1] === "payment-required" && !bid && !isTargeted) ; else {
+              status = statusTag[1];
+            }
+          }
+        }
+        if (!amount) {
+          const amtTag = feedback.tags.find((t) => t[0] === "amount");
+          if (amtTag?.[1]) amount = parseInt(amtTag[1], 10);
+        }
+      }
+      jobs.push({
+        eventId: req.id,
+        customer: req.pubkey,
+        agentPubkey: jobAgentPubkey,
+        capability,
+        bid: bid ? parseInt(bid, 10) : void 0,
+        status,
+        result: result?.content,
+        resultEventId: result?.id,
+        amount,
+        txHash,
+        createdAt: req.created_at
+      });
+    }
+    return jobs.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  /** Subscribe to live elisym events (requests, results, feedback). */
+  subscribeToEvents(kinds, onEvent) {
+    return this.pool.subscribe(
+      {
+        kinds,
+        "#t": ["elisym"],
+        since: Math.floor(Date.now() / 1e3)
+      },
+      onEvent
+    );
+  }
+};
+var MessagingService = class _MessagingService {
+  // 30s
+  constructor(pool) {
+    this.pool = pool;
+    this.sessionIdentity = ElisymIdentity.generate();
+  }
+  sessionIdentity;
+  pingCache = /* @__PURE__ */ new Map();
+  // pubkey → timestamp of last online result
+  pendingPings = /* @__PURE__ */ new Map();
+  // dedup in-flight pings
+  static PING_CACHE_TTL = 3e4;
+  /**
+   * Ping an agent via ephemeral Nostr events (kind 20200/20201).
+   * Uses a persistent session identity to avoid relay rate-limiting.
+   * Publishes to ALL relays for maximum delivery reliability.
+   * Caches results for 30s to prevent redundant publishes.
+   */
+  async pingAgent(agentPubkey, timeoutMs = 15e3, signal) {
+    const cachedAt = this.pingCache.get(agentPubkey);
+    if (cachedAt && Date.now() - cachedAt < _MessagingService.PING_CACHE_TTL) {
+      console.log(`[ping] cache hit for ${agentPubkey.slice(0, 8)}: online`);
+      return { online: true, identity: this.sessionIdentity };
+    }
+    const pending = this.pendingPings.get(agentPubkey);
+    if (pending) {
+      console.log(`[ping] dedup: reusing in-flight ping for ${agentPubkey.slice(0, 8)}`);
+      return pending;
+    }
+    const promise = this._doPing(agentPubkey, timeoutMs, signal);
+    this.pendingPings.set(agentPubkey, promise);
+    promise.finally(() => this.pendingPings.delete(agentPubkey));
+    return promise;
+  }
+  async _doPing(agentPubkey, timeoutMs, signal) {
+    const sk = this.sessionIdentity.secretKey;
+    const pk = this.sessionIdentity.publicKey;
+    const nonce = crypto.getRandomValues(new Uint8Array(16)).reduce((s, b) => s + b.toString(16).padStart(2, "0"), "");
+    const shortNonce = nonce.slice(0, 8);
+    const shortAgent = agentPubkey.slice(0, 8);
+    console.log(`[ping] \u2192 ping ${shortAgent} nonce=${shortNonce}`);
+    if (signal?.aborted) {
+      return { online: false, identity: null };
+    }
+    return new Promise(async (resolve) => {
+      let resolved = false;
+      const done = (online, reason) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timer);
+        sub.close();
+        signal?.removeEventListener("abort", onAbort);
+        console.log(`[ping] ${online ? "\u2713 ONLINE" : "\u2717 OFFLINE"} agent=${shortAgent} nonce=${shortNonce}${reason ? ` (${reason})` : ""}`);
+        if (online) this.pingCache.set(agentPubkey, Date.now());
+        resolve({ online, identity: online ? this.sessionIdentity : null });
+      };
+      const onAbort = () => done(false, "aborted");
+      signal?.addEventListener("abort", onAbort);
+      const sub = this.pool.subscribe(
+        { kinds: [KIND_PONG], "#p": [pk] },
+        (ev) => {
+          try {
+            const msg = JSON.parse(ev.content);
+            if (msg.type === "elisym_pong" && msg.nonce === nonce) {
+              console.log(`[ping] \u2190 pong from ${ev.pubkey.slice(0, 8)} nonce=${shortNonce}`);
+              done(true, "pong matched");
+            }
+          } catch {
+          }
+        }
+      );
+      const pingEvent = nostrTools.finalizeEvent(
+        {
+          kind: KIND_PING,
+          created_at: Math.floor(Date.now() / 1e3),
+          tags: [["p", agentPubkey]],
+          content: JSON.stringify({ type: "elisym_ping", nonce })
+        },
+        sk
+      );
+      this.pool.publishAll(pingEvent).then(() => console.log(`[ping] \u2713 published nonce=${shortNonce}`)).catch((err) => {
+        console.error(`[ping] \u2717 publish failed nonce=${shortNonce}`, err);
+        done(false, "publish failed");
+      });
+      const timer = setTimeout(() => done(false, "timeout"), timeoutMs);
+    });
+  }
+  /**
+   * Subscribe to incoming ephemeral ping events (kind 20200).
+   * No `since` filter needed - ephemeral events are never stored.
+   */
+  subscribeToPings(identity, onPing) {
+    return this.pool.subscribe(
+      { kinds: [KIND_PING], "#p": [identity.publicKey] },
+      (ev) => {
+        try {
+          const msg = JSON.parse(ev.content);
+          if (msg.type === "elisym_ping" && msg.nonce) {
+            onPing(ev.pubkey, msg.nonce);
+          }
+        } catch {
+        }
+      }
+    );
+  }
+  /** Send an ephemeral pong response to ALL relays. */
+  async sendPong(identity, recipientPubkey, nonce) {
+    const pongEvent = nostrTools.finalizeEvent(
+      {
+        kind: KIND_PONG,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [["p", recipientPubkey]],
+        content: JSON.stringify({ type: "elisym_pong", nonce })
+      },
+      identity.secretKey
+    );
+    await this.pool.publishAll(pongEvent);
+  }
+  /** Send a NIP-17 DM. */
+  async sendMessage(identity, recipientPubkey, content) {
+    const wrap = nip17__namespace.wrapEvent(
+      identity.secretKey,
+      { publicKey: recipientPubkey },
+      content
+    );
+    await this.pool.publish(wrap);
+  }
+  /** Fetch historical NIP-17 DMs from relays. Returns decrypted messages sorted by time. */
+  async fetchMessageHistory(identity, since) {
+    const events = await this.pool.querySync({
+      kinds: [KIND_GIFT_WRAP],
+      "#p": [identity.publicKey],
+      since
+    });
+    const seen = /* @__PURE__ */ new Set();
+    const messages = [];
+    for (const ev of events) {
+      try {
+        const rumor = nip59__namespace.unwrapEvent(ev, identity.secretKey);
+        if (seen.has(rumor.id)) continue;
+        seen.add(rumor.id);
+        messages.push({
+          senderPubkey: rumor.pubkey,
+          content: rumor.content,
+          createdAt: rumor.created_at,
+          rumorId: rumor.id
+        });
+      } catch {
+      }
+    }
+    return messages.sort((a, b) => a.createdAt - b.createdAt);
+  }
+  /** Subscribe to incoming NIP-17 DMs. */
+  subscribeToMessages(identity, onMessage, since) {
+    const seen = /* @__PURE__ */ new Set();
+    const filter = {
+      kinds: [KIND_GIFT_WRAP],
+      "#p": [identity.publicKey]
+    };
+    if (since !== void 0) filter.since = since;
+    return this.pool.subscribe(
+      filter,
+      (ev) => {
+        try {
+          const rumor = nip59__namespace.unwrapEvent(ev, identity.secretKey);
+          if (seen.has(rumor.id)) return;
+          seen.add(rumor.id);
+          onMessage(rumor.pubkey, rumor.content, rumor.created_at, rumor.id);
+        } catch {
+        }
+      }
+    );
+  }
+};
+var PaymentService = class _PaymentService {
+  /**
+   * Calculate protocol fee using Decimal basis-point math (no floats).
+   * Returns ceil(amount * PROTOCOL_FEE_BPS / 10000).
+   */
+  static calculateProtocolFee(amount) {
+    if (amount === 0) return 0;
+    return new Decimal__default.default(amount).mul(PROTOCOL_FEE_BPS).div(1e4).toDecimalPlaces(0, Decimal__default.default.ROUND_CEIL).toNumber();
+  }
+  /**
+   * Validate that a payment request has the correct recipient and protocol fee.
+   * Returns an error message if invalid, null if OK.
+   */
+  static validatePaymentFee(requestJson, expectedRecipient) {
+    let data;
+    try {
+      data = JSON.parse(requestJson);
+    } catch (e) {
+      return `Invalid payment request JSON: ${e}`;
+    }
+    if (expectedRecipient && data.recipient !== expectedRecipient) {
+      return `Recipient mismatch: expected ${expectedRecipient}, got ${data.recipient}. Provider may be attempting to redirect payment.`;
+    }
+    if (data.created_at > 0 && data.expiry_secs > 0) {
+      const elapsed = Math.floor(Date.now() / 1e3) - data.created_at;
+      if (elapsed > data.expiry_secs) {
+        return `Payment request expired (created ${data.created_at}, expiry ${data.expiry_secs}s).`;
+      }
+    }
+    const expectedFee = _PaymentService.calculateProtocolFee(data.amount);
+    const { fee_address, fee_amount } = data;
+    if (fee_address && fee_amount && fee_amount > 0) {
+      if (fee_address !== PROTOCOL_TREASURY) {
+        return `Fee address mismatch: expected ${PROTOCOL_TREASURY}, got ${fee_address}. Provider may be attempting to redirect fees.`;
+      }
+      if (fee_amount !== expectedFee) {
+        return `Fee amount mismatch: expected ${expectedFee} lamports (${PROTOCOL_FEE_BPS}bps of ${data.amount}), got ${fee_amount}. Provider may be tampering with fee.`;
+      }
+      return null;
+    }
+    if (!fee_address && !fee_amount) {
+      return `Payment request missing protocol fee (${PROTOCOL_FEE_BPS}bps). Expected fee: ${expectedFee} lamports to ${PROTOCOL_TREASURY}.`;
+    }
+    return `Invalid fee params in payment request. Expected fee: ${expectedFee} lamports to ${PROTOCOL_TREASURY}.`;
+  }
+  /**
+   * Build a Solana transaction from a payment request.
+   * The caller must sign and send via wallet adapter.
+   */
+  static buildPaymentTransaction(payerPubkey, paymentRequest) {
+    const recipient = new web3_js.PublicKey(paymentRequest.recipient);
+    const reference = new web3_js.PublicKey(paymentRequest.reference);
+    const feeAddress = paymentRequest.fee_address ? new web3_js.PublicKey(paymentRequest.fee_address) : null;
+    const feeAmount = paymentRequest.fee_amount ?? 0;
+    const providerAmount = feeAddress && feeAmount > 0 ? new Decimal__default.default(paymentRequest.amount).minus(feeAmount).toNumber() : paymentRequest.amount;
+    const transferIx = web3_js.SystemProgram.transfer({
+      fromPubkey: payerPubkey,
+      toPubkey: recipient,
+      lamports: providerAmount
+    });
+    transferIx.keys.push({
+      pubkey: reference,
+      isSigner: false,
+      isWritable: false
+    });
+    const tx = new web3_js.Transaction().add(transferIx);
+    if (feeAddress && feeAmount > 0) {
+      tx.add(
+        web3_js.SystemProgram.transfer({
+          fromPubkey: payerPubkey,
+          toPubkey: feeAddress,
+          lamports: feeAmount
+        })
+      );
+    }
+    return tx;
+  }
+  /**
+   * Create a payment request with auto-calculated protocol fee.
+   * Used by providers to generate payment requests for customers.
+   */
+  static createPaymentRequest(recipientAddress, amount, expirySecs = 600) {
+    const feeAmount = _PaymentService.calculateProtocolFee(amount);
+    const reference = web3_js.PublicKey.unique().toBase58();
+    return {
+      recipient: recipientAddress,
+      amount,
+      reference,
+      fee_address: PROTOCOL_TREASURY,
+      fee_amount: feeAmount,
+      created_at: Math.floor(Date.now() / 1e3),
+      expiry_secs: expirySecs
+    };
+  }
+};
+function formatSol(lamports) {
+  const sol = new Decimal__default.default(lamports).div(LAMPORTS_PER_SOL);
+  if (sol.gte(1e6)) return `${sol.idiv(1e6)}m SOL`;
+  if (sol.gte(1e4)) return `${sol.idiv(1e3)}k SOL`;
+  return `${compactSol(sol)} SOL`;
+}
+function compactSol(sol) {
+  if (sol.isZero()) return "0";
+  if (sol.gte(1e3)) return sol.toDecimalPlaces(0, Decimal__default.default.ROUND_FLOOR).toString();
+  const maxFrac = 9;
+  for (let d = 1; d <= maxFrac; d++) {
+    const s = sol.toFixed(d);
+    if (new Decimal__default.default(s).eq(sol)) {
+      return s.replace(/0+$/, "").replace(/\.$/, "");
+    }
+  }
+  return sol.toFixed(maxFrac).replace(/0+$/, "").replace(/\.$/, "");
+}
+function timeAgo(unix) {
+  const seconds = Math.max(0, Math.floor(Date.now() / 1e3 - unix));
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function truncateKey(hex, chars = 6) {
+  if (hex.length <= chars * 2) return hex;
+  return `${hex.slice(0, chars)}...${hex.slice(-chars)}`;
+}
+function makeNjumpUrl(eventId, relays = RELAYS) {
+  const nevent = nostrTools.nip19.neventEncode({
+    id: eventId,
+    relays: relays.slice(0, 2)
+  });
+  return `https://njump.me/${nevent}`;
+}
+
+// src/index.ts
+var ElisymClient = class {
+  pool;
+  discovery;
+  marketplace;
+  messaging;
+  constructor(config = {}) {
+    this.pool = new NostrPool(config.relays ?? RELAYS);
+    this.discovery = new DiscoveryService(this.pool);
+    this.marketplace = new MarketplaceService(this.pool);
+    this.messaging = new MessagingService(this.pool);
+  }
+  close() {
+    this.pool.close();
+  }
+};
+
+exports.DEFAULT_KIND_OFFSET = DEFAULT_KIND_OFFSET;
+exports.DiscoveryService = DiscoveryService;
+exports.ElisymClient = ElisymClient;
+exports.ElisymIdentity = ElisymIdentity;
+exports.KIND_APP_HANDLER = KIND_APP_HANDLER;
+exports.KIND_GIFT_WRAP = KIND_GIFT_WRAP;
+exports.KIND_JOB_FEEDBACK = KIND_JOB_FEEDBACK;
+exports.KIND_JOB_REQUEST = KIND_JOB_REQUEST;
+exports.KIND_JOB_REQUEST_BASE = KIND_JOB_REQUEST_BASE;
+exports.KIND_JOB_RESULT = KIND_JOB_RESULT;
+exports.KIND_JOB_RESULT_BASE = KIND_JOB_RESULT_BASE;
+exports.KIND_PING = KIND_PING;
+exports.KIND_PONG = KIND_PONG;
+exports.LAMPORTS_PER_SOL = LAMPORTS_PER_SOL;
+exports.MarketplaceService = MarketplaceService;
+exports.MessagingService = MessagingService;
+exports.NostrPool = NostrPool;
+exports.PROTOCOL_FEE_BPS = PROTOCOL_FEE_BPS;
+exports.PROTOCOL_TREASURY = PROTOCOL_TREASURY;
+exports.PaymentService = PaymentService;
+exports.RELAYS = RELAYS;
+exports.formatSol = formatSol;
+exports.jobRequestKind = jobRequestKind;
+exports.jobResultKind = jobResultKind;
+exports.makeNjumpUrl = makeNjumpUrl;
+exports.timeAgo = timeAgo;
+exports.toDTag = toDTag;
+exports.truncateKey = truncateKey;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map