@elisym/sdk 0.10.4 → 0.12.0

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var memo = require('@solana-program/memo');
 var system = require('@solana-program/system');
 var token = require('@solana-program/token');
 var kit = require('@solana/kit');
@@ -64,6 +65,7 @@ var LAMPORTS_PER_SOL = 1e9;
 var PROTOCOL_FEE_BPS = 300;
 var PROTOCOL_TREASURY = "GY7vnWMkKpftU4nQ16C2ATkj1JwrQpHhknkaBUn67VTy";
 var PROTOCOL_PROGRAM_ID_DEVNET = "BrX1CRkSgvcjxBvc2bgc3QqgWjinusofDmeP7ZVxvwrE";
+var ELISYM_PROTOCOL_TAG = "ELiZksgwDt41LaeuPDLkUfWgFXhGgVayTMP7L5nTSEL8";
 function getProtocolProgramId(cluster) {
   switch (cluster) {
     case "devnet":
@@ -119,13 +121,13 @@ function decodeConfig(encodedAccount) {
     getConfigDecoder()
   );
 }
-async function fetchConfig(rpc, address3, config) {
-  const maybeAccount = await fetchMaybeConfig(rpc, address3, config);
+async function fetchConfig(rpc, address4, config) {
+  const maybeAccount = await fetchMaybeConfig(rpc, address4, config);
   kit.assertAccountExists(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeConfig(rpc, address3, config) {
-  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
+async function fetchMaybeConfig(rpc, address4, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address4, config);
   return decodeConfig(maybeAccount);
 }
 if (process.env.NODE_ENV !== "production") ;
@@ -597,7 +599,9 @@ var SolanaPaymentStrategy = class {
     if (!Number.isInteger(computeUnitLimit) || computeUnitLimit <= 0) {
       throw new Error(`Invalid computeUnitLimit: ${computeUnitLimit}. Must be a positive integer.`);
     }
-    const paymentInstructions = await buildPaymentInstructions(paymentRequest, payerSigner);
+    const paymentInstructions = await buildPaymentInstructions(paymentRequest, payerSigner, {
+      jobEventId: options?.jobEventId
+    });
     const priorityFeeMicroLamports = options?.priorityFeeMicroLamports ?? await estimatePriorityFeeMicroLamports(rpc, {
       percentile: options?.priorityFeePercentile ?? DEFAULT_PRIORITY_FEE_PERCENTILE
     });
@@ -894,9 +898,10 @@ function bigIntDelta(post, pre) {
 function waitMs(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function buildPaymentInstructions(paymentRequest, payerSigner) {
+async function buildPaymentInstructions(paymentRequest, payerSigner, options) {
   const recipient = kit.address(paymentRequest.recipient);
   const reference = kit.address(paymentRequest.reference);
+  const protocolTag = kit.address(ELISYM_PROTOCOL_TAG);
   const feeAmount = paymentRequest.fee_amount ?? 0;
   const providerAmount = paymentRequest.fee_address && feeAmount > 0 ? paymentRequest.amount - feeAmount : paymentRequest.amount;
   if (providerAmount <= 0) {
@@ -904,6 +909,7 @@ async function buildPaymentInstructions(paymentRequest, payerSigner) {
       `Fee amount (${feeAmount}) exceeds or equals total amount (${paymentRequest.amount}). Cannot create transaction with non-positive provider amount.`
     );
   }
+  const memoInstruction = options?.jobEventId ? memo.getAddMemoInstruction({ memo: `elisym:v1:${options.jobEventId}` }) : null;
   const asset = resolveAssetFromPaymentRequest(paymentRequest);
   if (!asset.mint) {
     const providerTransferIx2 = system.getTransferSolInstruction({
@@ -911,14 +917,19 @@ async function buildPaymentInstructions(paymentRequest, payerSigner) {
       destination: recipient,
       amount: BigInt(providerAmount)
     });
-    const providerTransferIxWithReference2 = {
+    const providerTransferIxWithMarkers2 = {
       ...providerTransferIx2,
       accounts: [
         ...providerTransferIx2.accounts,
-        { address: reference, role: kit.AccountRole.READONLY }
+        { address: reference, role: kit.AccountRole.READONLY },
+        { address: protocolTag, role: kit.AccountRole.READONLY }
       ]
     };
-    const instructions2 = [providerTransferIxWithReference2];
+    const instructions2 = [];
+    if (memoInstruction) {
+      instructions2.push(memoInstruction);
+    }
+    instructions2.push(providerTransferIxWithMarkers2);
     if (paymentRequest.fee_address && feeAmount > 0) {
       instructions2.push(
         system.getTransferSolInstruction({
@@ -943,6 +954,9 @@ async function buildPaymentInstructions(paymentRequest, payerSigner) {
     mint
   });
   const instructions = [];
+  if (memoInstruction) {
+    instructions.push(memoInstruction);
+  }
   instructions.push(
     token.getCreateAssociatedTokenIdempotentInstruction(
       {
@@ -982,11 +996,15 @@ async function buildPaymentInstructions(paymentRequest, payerSigner) {
     amount: BigInt(providerAmount),
     decimals: asset.decimals
   });
-  const providerTransferIxWithReference = {
+  const providerTransferIxWithMarkers = {
     ...providerTransferIx,
-    accounts: [...providerTransferIx.accounts, { address: reference, role: kit.AccountRole.READONLY }]
+    accounts: [
+      ...providerTransferIx.accounts,
+      { address: reference, role: kit.AccountRole.READONLY },
+      { address: protocolTag, role: kit.AccountRole.READONLY }
+    ]
   };
-  instructions.push(providerTransferIxWithReference);
+  instructions.push(providerTransferIxWithMarkers);
   if (treasuryAta && paymentRequest.fee_address && feeAmount > 0) {
     instructions.push(
       token.getTransferCheckedInstruction({
@@ -1014,6 +1032,7 @@ async function createPaymentRequestWithOnchainConfig(rpc, programId, recipient,
 var RANKING_ACTIVITY_WINDOW_SECS = 30 * 24 * 60 * 60;
 var RANKING_BUCKET_SIZE_SECS = 60;
 var COLD_START_BUCKET = -Infinity;
+var NEVER_ABORTED_SIGNAL = new AbortController().signal;
 function toDTag(name) {
   const tag = name.toLowerCase().replace(/[^a-z0-9\s-]/g, (ch) => "_" + ch.charCodeAt(0).toString(16).padStart(2, "0")).replace(/\s+/g, "-").replace(/^-+|-+$/g, "");
   if (!tag) {
@@ -1043,13 +1062,63 @@ function compareAgentsByRank(a, b) {
   }
   return kb.lastSeen - ka.lastSeen;
 }
+function parseCapabilityEvent(event, network) {
+  if (!nostrTools.verifyEvent(event)) {
+    return null;
+  }
+  if (!event.content) {
+    return null;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(event.content);
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const candidate = raw;
+  if (typeof candidate.name !== "string" || !candidate.name) {
+    return null;
+  }
+  if (typeof candidate.description !== "string") {
+    return null;
+  }
+  if (!Array.isArray(candidate.capabilities) || !candidate.capabilities.every((cap) => typeof cap === "string")) {
+    return null;
+  }
+  if (candidate.deleted) {
+    return null;
+  }
+  const card = candidate;
+  if (card.payment && (typeof card.payment.chain !== "string" || typeof card.payment.network !== "string" || typeof card.payment.address !== "string")) {
+    return null;
+  }
+  if (card.payment?.job_price !== null && card.payment?.job_price !== void 0 && (!Number.isInteger(card.payment.job_price) || card.payment.job_price < 0)) {
+    return null;
+  }
+  const agentNetwork = card.payment?.network ?? "devnet";
+  if (agentNetwork !== network) {
+    return null;
+  }
+  const kTags = event.tags.filter((tag) => tag[0] === "k").map((tag) => parseInt(tag[1] ?? "", 10)).filter((kind) => !isNaN(kind));
+  return {
+    pubkey: event.pubkey,
+    npub: nostrTools.nip19.npubEncode(event.pubkey),
+    cards: [card],
+    eventId: event.id,
+    supportedKinds: kTags,
+    lastSeen: event.created_at
+  };
+}
 function buildAgentsFromEvents(events, network) {
   const latestByDTag = /* @__PURE__ */ new Map();
   for (const event of events) {
     if (!nostrTools.verifyEvent(event)) {
       continue;
     }
-    const dTag = event.tags.find((t) => t[0] === "d")?.[1] ?? "";
+    const dTag = event.tags.find((tag) => tag[0] === "d")?.[1] ?? "";
     const key = `${event.pubkey}:${dTag}`;
     const prev = latestByDTag.get(key);
     if (!prev || event.created_at > prev.created_at) {
@@ -1058,82 +1127,51 @@ function buildAgentsFromEvents(events, network) {
   }
   const accumMap = /* @__PURE__ */ new Map();
   for (const event of latestByDTag.values()) {
-    try {
-      if (!event.content) {
-        continue;
-      }
-      const raw = JSON.parse(event.content);
-      if (!raw || typeof raw !== "object") {
-        continue;
-      }
-      if (typeof raw.name !== "string" || !raw.name) {
-        continue;
-      }
-      if (typeof raw.description !== "string") {
-        continue;
-      }
-      if (!Array.isArray(raw.capabilities) || !raw.capabilities.every((c) => typeof c === "string")) {
-        continue;
-      }
-      if (raw.deleted) {
-        continue;
-      }
-      const card = raw;
-      if (card.payment && (typeof card.payment.chain !== "string" || typeof card.payment.network !== "string" || typeof card.payment.address !== "string")) {
-        continue;
-      }
-      if (card.payment?.job_price !== null && card.payment?.job_price !== void 0 && (!Number.isInteger(card.payment.job_price) || card.payment.job_price < 0)) {
-        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) {
-          if (entry.createdAt >= existing.entries[dupIndex].createdAt) {
-            existing.entries[dupIndex] = entry;
+    const parsed = parseCapabilityEvent(event, network);
+    if (!parsed) {
+      continue;
+    }
+    const card = parsed.cards[0];
+    const cardKinds = parsed.supportedKinds;
+    const createdAt = parsed.lastSeen;
+    const existing = accumMap.get(parsed.pubkey);
+    if (existing) {
+      const prevForName = existing.perCard.get(card.name);
+      if (prevForName) {
+        if (createdAt >= prevForName.createdAt) {
+          const idx = existing.agent.cards.findIndex(
+            (existingCard) => existingCard.name === card.name
+          );
+          if (idx >= 0) {
+            existing.agent.cards[idx] = card;
           }
-        } else {
-          existing.entries.push(entry);
-        }
-        if (event.created_at > existing.lastSeen) {
-          existing.lastSeen = event.created_at;
-          existing.eventId = event.id;
+          existing.perCard.set(card.name, { createdAt, kTags: cardKinds });
         }
       } else {
-        accumMap.set(event.pubkey, {
-          pubkey: event.pubkey,
-          npub: nostrTools.nip19.npubEncode(event.pubkey),
-          entries: [entry],
-          eventId: event.id,
-          lastSeen: event.created_at
-        });
+        existing.agent.cards.push(card);
+        existing.perCard.set(card.name, { createdAt, kTags: cardKinds });
       }
-    } catch {
+      if (createdAt > existing.agent.lastSeen) {
+        existing.agent.lastSeen = createdAt;
+        existing.agent.eventId = parsed.eventId;
+      }
+    } else {
+      accumMap.set(parsed.pubkey, {
+        agent: parsed,
+        perCard: /* @__PURE__ */ new Map([[card.name, { createdAt, kTags: cardKinds }]])
+      });
     }
   }
   const agentMap = /* @__PURE__ */ new Map();
   for (const [pubkey, acc] of accumMap) {
     const kindsSet = /* @__PURE__ */ new Set();
-    for (const e of acc.entries) {
-      for (const k of e.kTags) {
-        kindsSet.add(k);
-      }
-    }
-    const supportedKinds = [...kindsSet];
-    agentMap.set(pubkey, {
-      pubkey: acc.pubkey,
-      npub: acc.npub,
-      cards: acc.entries.map((e) => e.card),
-      eventId: acc.eventId,
-      supportedKinds,
-      lastSeen: acc.lastSeen
-    });
+    for (const { kTags } of acc.perCard.values()) {
+      for (const kind of kTags) {
+        kindsSet.add(kind);
+      }
+    }
+    acc.agent.supportedKinds = [...kindsSet];
+    agentMap.set(pubkey, acc.agent);
   }
   return agentMap;
 }
@@ -1141,21 +1179,6 @@ var DiscoveryService = class {
   constructor(pool) {
     this.pool = pool;
   }
-  /** Count elisym agents (kind:31990 with "elisym" tag). */
-  async fetchAllAgentCount() {
-    const events = await this.pool.querySync({
-      kinds: [KIND_APP_HANDLER],
-      "#t": ["elisym"]
-    });
-    const uniquePubkeys = /* @__PURE__ */ new Set();
-    for (const event of events) {
-      if (!nostrTools.verifyEvent(event)) {
-        continue;
-      }
-      uniquePubkeys.add(event.pubkey);
-    }
-    return uniquePubkeys.size;
-  }
   /**
    * Fetch a single page of elisym agents with relay-side pagination.
    * Uses `until` cursor for Nostr cursor-based pagination.
@@ -1263,6 +1286,19 @@ var DiscoveryService = class {
     const events = await this.pool.querySync(filter);
     const agentMap = buildAgentsFromEvents(events, network);
     const agents = Array.from(agentMap.values());
+    return this.runEnrichment(agents, agentMap, NEVER_ABORTED_SIGNAL);
+  }
+  /**
+   * Enrich an agent map with paid-job stats, feedback counters, and kind:0
+   * metadata, then return them sorted by `compareAgentsByRank`. Mutates the
+   * passed-in `Agent` objects in place.
+   *
+   * Shared between `fetchAgents` (one-shot) and `streamAgents` (post-EOSE
+   * second pass). The `signal` short-circuits the post-query work; in-flight
+   * pool queries are not cancellable today (they fall through to the standard
+   * timeout) and the caller drops the resolved value.
+   */
+  async runEnrichment(agents, agentMap, signal) {
     const agentPubkeys = Array.from(agentMap.keys());
     if (agentPubkeys.length === 0) {
       return agents;
@@ -1270,9 +1306,9 @@ var DiscoveryService = class {
     const activitySince = Math.floor(Date.now() / 1e3) - RANKING_ACTIVITY_WINDOW_SECS;
     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));
+      for (const supportedKind of agent.supportedKinds) {
+        if (supportedKind >= KIND_JOB_REQUEST_BASE && supportedKind < KIND_JOB_RESULT_BASE) {
+          resultKinds.add(KIND_JOB_RESULT_BASE + (supportedKind - KIND_JOB_REQUEST_BASE));
         }
       }
     }
@@ -1292,6 +1328,9 @@ var DiscoveryService = class {
       ),
       this.enrichWithMetadata(agents)
     ]);
+    if (signal.aborted) {
+      return agents;
+    }
     const deliveredJobsByProvider = /* @__PURE__ */ new Map();
     for (const ev of resultEvents) {
       if (!nostrTools.verifyEvent(ev)) {
@@ -1304,7 +1343,7 @@ var DiscoveryService = class {
       if (ev.created_at > agent.lastSeen) {
         agent.lastSeen = ev.created_at;
       }
-      const jobEventId = ev.tags.find((t) => t[0] === "e")?.[1];
+      const jobEventId = ev.tags.find((tag) => tag[0] === "e")?.[1];
       if (jobEventId) {
         let delivered = deliveredJobsByProvider.get(ev.pubkey);
         if (!delivered) {
@@ -1318,7 +1357,7 @@ var DiscoveryService = class {
       if (!nostrTools.verifyEvent(ev)) {
         continue;
       }
-      const targetPubkey = ev.tags.find((t) => t[0] === "p")?.[1];
+      const targetPubkey = ev.tags.find((tag) => tag[0] === "p")?.[1];
       if (!targetPubkey) {
         continue;
       }
@@ -1329,17 +1368,17 @@ var DiscoveryService = class {
       if (ev.created_at > agent.lastSeen) {
         agent.lastSeen = ev.created_at;
       }
-      const rating = ev.tags.find((t) => t[0] === "rating")?.[1];
+      const rating = ev.tags.find((tag) => tag[0] === "rating")?.[1];
       if (rating === "1" || rating === "0") {
         agent.totalRatingCount = (agent.totalRatingCount ?? 0) + 1;
         if (rating === "1") {
           agent.positiveCount = (agent.positiveCount ?? 0) + 1;
         }
       }
-      const status = ev.tags.find((t) => t[0] === "status")?.[1];
-      const txTag = ev.tags.find((t) => t[0] === "tx");
+      const status = ev.tags.find((tag) => tag[0] === "status")?.[1];
+      const txTag = ev.tags.find((tag) => tag[0] === "tx");
       const txSignature = txTag?.[1];
-      const jobEventId = ev.tags.find((t) => t[0] === "e")?.[1];
+      const jobEventId = ev.tags.find((tag) => tag[0] === "e")?.[1];
       const hasDeliveredResult = jobEventId !== void 0 && deliveredJobsByProvider.get(targetPubkey)?.has(jobEventId) === true;
       if (status === "payment-completed" && typeof txSignature === "string" && txSignature && hasDeliveredResult) {
         if (!agent.lastPaidJobAt || ev.created_at > agent.lastPaidJobAt) {
@@ -1351,6 +1390,135 @@ var DiscoveryService = class {
     agents.sort(compareAgentsByRank);
     return agents;
   }
+  /**
+   * Stream elisym agents progressively as relays deliver events.
+   *
+   * Two live subscriptions:
+   *   - kind:31990 (capability cards) - emits `onAgent(agent)` for every new or
+   *     updated `(pubkey, d-tag)`. The emitted Agent is the merged view across
+   *     all surviving cards for that author.
+   *   - kind:6100 (default-offset job results) tagged `t=elisym` since 30d ago -
+   *     emits `onPaidJob(pubkey, ts)` for each delivered result. Custom-kind
+   *     results (offset != 100) are not on this stream; they enter the final
+   *     ranking via the post-EOSE enrichment pass.
+   *
+   * After capabilities EOSE, an enrichment pass runs in parallel to the live
+   * subscriptions and produces a ranked snapshot via `onComplete`. The snapshot
+   * is a clone, so further live updates do not mutate it.
+   *
+   * `closer.close()` tears down both subscriptions and aborts an in-flight
+   * enrichment. If `opts.signal` is provided, aborting it does the same.
+   */
+  streamAgents(network, opts) {
+    const eventsByPubkey = /* @__PURE__ */ new Map();
+    const agentByPubkey = /* @__PURE__ */ new Map();
+    const eoseSeen = { caps: false, results: false };
+    let enrichmentStarted = false;
+    const enrichmentAbort = new AbortController();
+    const onExternalAbort = () => enrichmentAbort.abort();
+    if (opts.signal) {
+      if (opts.signal.aborted) {
+        enrichmentAbort.abort();
+      } else {
+        opts.signal.addEventListener("abort", onExternalAbort, { once: true });
+      }
+    }
+    const checkEose = () => {
+      if (eoseSeen.caps && eoseSeen.results) {
+        opts.onEose?.();
+      }
+    };
+    const startEnrichment = () => {
+      if (enrichmentStarted) {
+        return;
+      }
+      enrichmentStarted = true;
+      const snapshotAgents = Array.from(agentByPubkey.values()).map((agent) => ({ ...agent }));
+      const snapshotMap = new Map(snapshotAgents.map((agent) => [agent.pubkey, agent]));
+      void this.runEnrichment(snapshotAgents, snapshotMap, enrichmentAbort.signal).then(
+        (sorted) => {
+          if (enrichmentAbort.signal.aborted) {
+            return;
+          }
+          opts.onComplete?.(sorted);
+        },
+        () => {
+        }
+      );
+    };
+    const capSub = this.pool.subscribe(
+      { kinds: [KIND_APP_HANDLER], "#t": ["elisym"] },
+      (event) => {
+        const dTag = event.tags.find((tag) => tag[0] === "d")?.[1] ?? "";
+        let perDTag = eventsByPubkey.get(event.pubkey);
+        const prev = perDTag?.get(dTag);
+        if (prev && event.created_at <= prev.created_at) {
+          return;
+        }
+        if (!nostrTools.verifyEvent(event)) {
+          return;
+        }
+        if (!event.content) {
+          return;
+        }
+        let payload;
+        try {
+          payload = JSON.parse(event.content);
+        } catch {
+          return;
+        }
+        const isTombstone = payload !== null && typeof payload === "object" && Boolean(payload.deleted);
+        if (!isTombstone && !parseCapabilityEvent(event, network)) {
+          return;
+        }
+        if (!perDTag) {
+          perDTag = /* @__PURE__ */ new Map();
+          eventsByPubkey.set(event.pubkey, perDTag);
+        }
+        perDTag.set(dTag, event);
+        const merged = buildAgentsFromEvents(Array.from(perDTag.values()), network).get(
+          event.pubkey
+        );
+        if (!merged) {
+          agentByPubkey.delete(event.pubkey);
+          return;
+        }
+        agentByPubkey.set(event.pubkey, merged);
+        opts.onAgent(merged);
+      },
+      {
+        oneose: () => {
+          eoseSeen.caps = true;
+          startEnrichment();
+          checkEose();
+        }
+      }
+    );
+    const activitySince = Math.floor(Date.now() / 1e3) - RANKING_ACTIVITY_WINDOW_SECS;
+    const resultsSub = this.pool.subscribe(
+      { kinds: [KIND_JOB_RESULT], "#t": ["elisym"], since: activitySince },
+      (event) => {
+        if (!nostrTools.verifyEvent(event)) {
+          return;
+        }
+        opts.onPaidJob?.(event.pubkey, event.created_at);
+      },
+      {
+        oneose: () => {
+          eoseSeen.results = true;
+          checkEose();
+        }
+      }
+    );
+    return {
+      close: (reason) => {
+        capSub.close(reason);
+        resultsSub.close(reason);
+        enrichmentAbort.abort();
+        opts.signal?.removeEventListener("abort", onExternalAbort);
+      }
+    };
+  }
   /**
    * Publish a capability card (kind:31990) as a provider.
    * Solana address is validated for Base58 format only - full decode
@@ -2566,8 +2734,11 @@ var NostrPool = class {
       throw new Error(`Failed to publish to all ${this.relays.length} relays`);
     }
   }
-  subscribe(filter, onEvent) {
-    const rawSub = this.pool.subscribeMany(this.relays, filter, { onevent: onEvent });
+  subscribe(filter, onEvent, opts) {
+    const rawSub = this.pool.subscribeMany(this.relays, filter, {
+      onevent: onEvent,
+      oneose: opts?.oneose
+    });
     const tracked = {
       close: (reason) => {
         this.activeSubscriptions.delete(tracked);
@@ -2918,6 +3089,83 @@ async function doVerifyOnce(rpc, txSignature, expectedRecipient) {
   }
   return { verified: false, txSignature: sigStr, reason: "recipient_mismatch" };
 }
+var DEFAULT_LIMIT = 1e3;
+var NATIVE_KEY = "native";
+async function aggregateNetworkStats(rpc, options) {
+  const limit = options?.limit ?? DEFAULT_LIMIT;
+  const concurrency = options?.concurrency ?? DEFAULTS.QUERY_MAX_CONCURRENCY;
+  const tag = kit.address(ELISYM_PROTOCOL_TAG);
+  const signatures = await rpc.getSignaturesForAddress(tag, { limit, before: options?.before }).send();
+  const validSigs = signatures.filter((entry) => entry.err === null);
+  if (validSigs.length === 0) {
+    return { jobCount: 0, volumeByAsset: {} };
+  }
+  const volumeByAsset = {};
+  let jobCount = 0;
+  for (let start = 0; start < validSigs.length; start += concurrency) {
+    const batch = validSigs.slice(start, start + concurrency);
+    const txResults = await Promise.all(
+      batch.map(
+        (entry) => rpc.getTransaction(entry.signature, {
+          commitment: "confirmed",
+          encoding: "json",
+          maxSupportedTransactionVersion: 0
+        }).send().catch(() => null)
+      )
+    );
+    for (const tx of txResults) {
+      if (!tx?.meta || tx.meta.err) {
+        continue;
+      }
+      jobCount += 1;
+      accumulateTransfers(tx, volumeByAsset);
+    }
+  }
+  const latest = validSigs[0]?.signature;
+  const oldest = validSigs.at(-1)?.signature;
+  return {
+    jobCount,
+    volumeByAsset,
+    latestSignature: latest,
+    oldestSignature: oldest
+  };
+}
+function accumulateTransfers(tx, volumeByAsset) {
+  const raw = tx;
+  const meta = raw.meta;
+  if (!meta) {
+    return;
+  }
+  const preTokens = meta.preTokenBalances ?? [];
+  const postTokens = meta.postTokenBalances ?? [];
+  const isSpl = postTokens.length > 0 || preTokens.length > 0;
+  if (isSpl) {
+    accumulateSplDeltas(preTokens, postTokens, volumeByAsset);
+    return;
+  }
+  accumulateNativeDeltas(meta.preBalances, meta.postBalances, volumeByAsset);
+}
+function accumulateSplDeltas(pre, post, volumeByAsset) {
+  for (const postEntry of post) {
+    const preEntry = pre.find((entry) => entry.accountIndex === postEntry.accountIndex);
+    const preAmount = preEntry ? BigInt(preEntry.uiTokenAmount.amount) : 0n;
+    const postAmount = BigInt(postEntry.uiTokenAmount.amount);
+    const delta = postAmount - preAmount;
+    if (delta > 0n) {
+      volumeByAsset[postEntry.mint] = (volumeByAsset[postEntry.mint] ?? 0n) + delta;
+    }
+  }
+}
+function accumulateNativeDeltas(pre, post, volumeByAsset) {
+  for (let i = 1; i < post.length; i++) {
+    const preValue = pre[i] ?? 0n;
+    const postValue = post[i] ?? 0n;
+    const delta = BigInt(postValue) - BigInt(preValue);
+    if (delta > 0n) {
+      volumeByAsset[NATIVE_KEY] = (volumeByAsset[NATIVE_KEY] ?? 0n) + delta;
+    }
+  }
+}
 var SessionSpendLimitEntrySchema = zod.z.object({
   chain: zod.z.enum(["solana"]),
   token: zod.z.string().min(1).max(16).regex(/^[a-z0-9]+$/, "token must be lowercase alphanumeric"),
@@ -3123,6 +3371,7 @@ exports.DEFAULTS = DEFAULTS;
 exports.DEFAULT_KIND_OFFSET = DEFAULT_KIND_OFFSET;
 exports.DEFAULT_REDACT_PATHS = DEFAULT_REDACT_PATHS;
 exports.DiscoveryService = DiscoveryService;
+exports.ELISYM_PROTOCOL_TAG = ELISYM_PROTOCOL_TAG;
 exports.ElisymClient = ElisymClient;
 exports.ElisymIdentity = ElisymIdentity;
 exports.GlobalConfigSchema = GlobalConfigSchema;
@@ -3152,6 +3401,7 @@ exports.SECRET_REDACT_PATHS = SECRET_REDACT_PATHS;
 exports.SessionSpendLimitEntrySchema = SessionSpendLimitEntrySchema;
 exports.SolanaPaymentStrategy = SolanaPaymentStrategy;
 exports.USDC_SOLANA_DEVNET = USDC_SOLANA_DEVNET;
+exports.aggregateNetworkStats = aggregateNetworkStats;
 exports.assertExpiry = assertExpiry;
 exports.assertLamports = assertLamports;
 exports.assetByKey = assetByKey;