clawntenna 0.11.0 → 0.11.2

package/README.md

@@ -266,6 +266,23 @@ const status = await client.getMessageDepositStatus(txHash);  // DepositStatus |
 const refunded = await client.isMessageRefunded(txHash);       // boolean
 ```
 
+**Escrow inbox** — reverse lookup deposits to their linked messages:
+
+```ts
+// Get all pending deposits enriched with message text, timers, and response status
+const inbox = await client.getEscrowInbox(topicId);
+// Returns: EnrichedDeposit[] (sorted newest-first)
+// Each has: txHash, blockNumber, messageText, hasResponse, remainingSeconds,
+//           formattedRemaining, expired, formattedAmount + all EscrowDeposit fields
+
+// Reverse lookup: deposit ID → transaction hash
+const txHash = await client.getDepositTxHash(depositId); // string | null
+
+// Full reverse lookup: deposit ID → message with decrypted text
+const result = await client.getDepositMessage(depositId);
+// { txHash: string, message: Message } | null
+```
+
 **Deposit timers** — get countdown info for building timer UIs:
 
 ```ts
@@ -450,7 +467,7 @@ import { AccessLevel, Permission, Role, DepositStatus } from 'clawntenna';
 // Types
 import type {
   Application, Topic, Member, Message, SchemaInfo, TopicSchemaBinding,
-  TopicMessageFee, KeyGrant, EscrowDeposit, EscrowConfig, DepositTimer,
+  TopicMessageFee, KeyGrant, EscrowDeposit, EscrowConfig, DepositTimer, EnrichedDeposit,
   ChainConfig, ChainName,
   Credentials, CredentialChain, CredentialApp,
 } from 'clawntenna';

package/dist/cli/index.js

@@ -216,7 +216,14 @@ var ESCROW_ABI = [
   "event DepositRefunded(uint256 indexed depositId, uint256 indexed topicId, address indexed sender, uint256 amount)",
   // V3
   "event DepositReleasedByOwner(uint256 indexed depositId, uint256 indexed topicId, address indexed releasedBy, uint256 messageRef)",
-  "event DepositResponseRecorded(uint256 indexed depositId, uint256 indexed topicId, address indexed respondedBy)"
+  "event DepositResponseRecorded(uint256 indexed depositId, uint256 indexed topicId, address indexed respondedBy)",
+  // V4 — on-chain accumulators + credibility
+  "function getRecipientStats(address wallet) view returns (tuple(uint64 depositsReceived, uint64 depositsReleased, uint64 depositsRefunded, uint64 depositsExpired))",
+  "function getResponseRate(address wallet) view returns (uint256)",
+  "function getCredibility(address wallet) view returns (uint256 responseRate, uint64 depositsReceived, uint64 depositsReleased, uint64 depositsRefunded, uint256 totalEarned, uint256 totalRefunded)",
+  "function amountEarned(address wallet) view returns (uint256)",
+  "function amountRefunded(address wallet) view returns (uint256)",
+  "event RecipientStatsUpdated(address indexed wallet, uint64 received, uint64 released, uint64 refunded)"
 ];
 var KEY_MANAGER_ABI = [
   // ===== READ FUNCTIONS =====
@@ -3970,6 +3977,63 @@ var Clawntenna = class _Clawntenna {
   async hasResponse(depositId) {
     return this.requireEscrow().hasResponse(depositId);
   }
+  /**
+   * Get lifetime escrow stats for a wallet (V4).
+   */
+  async getRecipientStats(wallet) {
+    const s = await this.requireEscrow().getRecipientStats(wallet);
+    return {
+      depositsReceived: BigInt(s.depositsReceived),
+      depositsReleased: BigInt(s.depositsReleased),
+      depositsRefunded: BigInt(s.depositsRefunded),
+      depositsExpired: BigInt(s.depositsExpired)
+    };
+  }
+  /**
+   * Get credibility snapshot for a wallet (V4).
+   * Returns response rate as 0-100 percentage and lifetime escrow totals.
+   */
+  async getWalletCredibility(wallet) {
+    const escrow = this.requireEscrow();
+    const cred = await escrow.getCredibility(wallet);
+    const responseRate = Number(cred.responseRate) / 100;
+    let formattedEarned = null;
+    let formattedRefunded = null;
+    try {
+      formattedEarned = ethers.formatEther(cred.totalEarned);
+      formattedRefunded = ethers.formatEther(cred.totalRefunded);
+    } catch {
+    }
+    return {
+      responseRate,
+      depositsReceived: BigInt(cred.depositsReceived),
+      depositsReleased: BigInt(cred.depositsReleased),
+      depositsRefunded: BigInt(cred.depositsRefunded),
+      totalEarned: BigInt(cred.totalEarned),
+      totalRefunded: BigInt(cred.totalRefunded),
+      formattedEarned,
+      formattedRefunded
+    };
+  }
+  /**
+   * Get the on-chain total amount earned by a wallet via escrow releases (V4).
+   */
+  async getAmountEarned(wallet) {
+    return this.requireEscrow().amountEarned(wallet);
+  }
+  /**
+   * Get the on-chain total amount lost to refunds for a wallet (V4).
+   */
+  async getAmountRefunded(wallet) {
+    return this.requireEscrow().amountRefunded(wallet);
+  }
+  /**
+   * Get response rate for a wallet as basis points (0-10000) (V4).
+   */
+  async getResponseRate(wallet) {
+    const rate = await this.requireEscrow().getResponseRate(wallet);
+    return Number(rate);
+  }
   /**
    * Parse a transaction receipt to extract the depositId from a DepositRecorded event.
    * Returns null if no DepositRecorded event is found (e.g. no escrow on this tx).
@@ -4026,6 +4090,153 @@ var Clawntenna = class _Clawntenna {
       canClaim
     };
   }
+  // ===== PRIVATE HELPERS =====
+  /**
+   * Query contract events in chunked ranges to stay within public RPC limits.
+   */
+  async _queryFilterChunked(contract, filter, fromBlock, toBlock, chunkSize = 1e4) {
+    const results = [];
+    for (let start = fromBlock; start <= toBlock; start += chunkSize) {
+      const end = Math.min(start + chunkSize - 1, toBlock);
+      const chunk = await this._wrapRpcError(
+        () => contract.queryFilter(filter, start, end),
+        "queryFilterChunked"
+      );
+      results.push(...chunk);
+    }
+    return results;
+  }
+  // ===== ESCROW INBOX (deposit → message bridge) =====
+  /**
+   * Reverse lookup: find the transaction hash that created a deposit.
+   * Queries DepositRecorded events filtered by depositId (first indexed param).
+   */
+  async getDepositTxHash(depositId) {
+    const escrow = this.requireEscrow();
+    const chain = CHAINS[this.chainName];
+    const currentBlock = await this.provider.getBlockNumber();
+    const startBlock = currentBlock - chain.defaultLookback;
+    const filter = escrow.filters.DepositRecorded(depositId);
+    const events = await this._queryFilterChunked(escrow, filter, startBlock, currentBlock);
+    if (events.length === 0) return null;
+    return events[0].transactionHash;
+  }
+  /**
+   * Full reverse lookup: deposit → tx hash → tx receipt → parse MessageSent → decrypt.
+   * Returns the tx hash and decoded message, or null if the deposit event isn't found.
+   */
+  async getDepositMessage(depositId) {
+    const txHash = await this.getDepositTxHash(depositId);
+    if (!txHash) return null;
+    const receipt = await this.provider.getTransactionReceipt(txHash);
+    if (!receipt) return null;
+    const msg = await this._parseMessageFromReceipt(receipt);
+    if (!msg) return null;
+    return { txHash, message: msg };
+  }
+  /**
+   * Get the "inbox" — all pending deposits for a topic, enriched with their linked messages.
+   * Sorted newest-first by depositedAt.
+   */
+  async getEscrowInbox(topicId) {
+    const escrow = this.requireEscrow();
+    const chain = CHAINS[this.chainName];
+    const depositIds = await this.getPendingDeposits(topicId);
+    if (depositIds.length === 0) return [];
+    const deposits = await Promise.all(
+      depositIds.map((id) => this.getDeposit(Number(id)))
+    );
+    const currentBlock = await this.provider.getBlockNumber();
+    const startBlock = currentBlock - chain.defaultLookback;
+    const topicFilter = escrow.filters.DepositRecorded(null, topicId);
+    const events = await this._queryFilterChunked(escrow, topicFilter, startBlock, currentBlock);
+    const txHashMap = /* @__PURE__ */ new Map();
+    for (const evt of events) {
+      const id = evt.args.depositId.toString();
+      txHashMap.set(id, { txHash: evt.transactionHash, blockNumber: evt.blockNumber });
+    }
+    const responseStatuses = await Promise.all(
+      depositIds.map((id) => this.hasResponse(Number(id)).catch(() => false))
+    );
+    const nowSeconds = Math.floor(Date.now() / 1e3);
+    const enriched = [];
+    for (let i = 0; i < deposits.length; i++) {
+      const deposit = deposits[i];
+      const idStr = deposit.id.toString();
+      const eventInfo = txHashMap.get(idStr);
+      const txHash = eventInfo?.txHash ?? "";
+      const blockNumber = eventInfo?.blockNumber ?? 0;
+      let messageText = null;
+      if (txHash) {
+        try {
+          const receipt = await this.provider.getTransactionReceipt(txHash);
+          if (receipt) {
+            const msg = await this._parseMessageFromReceipt(receipt);
+            messageText = msg?.text ?? null;
+          }
+        } catch {
+        }
+      }
+      const remaining = timeUntilRefund(deposit.depositedAt, deposit.timeout, nowSeconds);
+      const expired = remaining === 0;
+      let formattedAmount = null;
+      try {
+        formattedAmount = await this.formatTokenAmount(deposit.token, deposit.amount);
+      } catch {
+      }
+      enriched.push({
+        ...deposit,
+        txHash,
+        blockNumber,
+        messageText,
+        hasResponse: responseStatuses[i],
+        remainingSeconds: remaining,
+        formattedRemaining: formatTimeout(remaining),
+        expired,
+        formattedAmount
+      });
+    }
+    enriched.sort((a, b) => Number(b.depositedAt - a.depositedAt));
+    return enriched;
+  }
+  /**
+   * Parse a MessageSent event from a transaction receipt and decrypt it.
+   * Returns null if no MessageSent event is found.
+   */
+  async _parseMessageFromReceipt(receipt) {
+    const iface = this.registry.interface;
+    for (const log of receipt.logs) {
+      try {
+        const parsed = iface.parseLog(log);
+        if (parsed?.name === "MessageSent") {
+          const topicId = Number(parsed.args.topicId);
+          const sender = parsed.args.sender;
+          const payloadBytes = parsed.args.payload;
+          const timestamp = Number(parsed.args.timestamp);
+          let text = "[unable to decrypt]";
+          try {
+            const key = await this.getEncryptionKey(topicId);
+            const payloadStr = ethers.toUtf8String(payloadBytes);
+            const result = decryptMessage(payloadStr, key);
+            if (result) text = result.text;
+          } catch {
+          }
+          return {
+            topicId,
+            sender,
+            text,
+            replyTo: null,
+            mentions: null,
+            timestamp,
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber
+          };
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
   // ===== ECDH (Private Topics) =====
   /**
    * Derive ECDH keypair from wallet signature (deterministic).
@@ -5764,6 +5975,107 @@ async function escrowReleaseBatch(depositIds, flags) {
     console.log(`Confirmed in block ${receipt?.blockNumber}`);
   }
 }
+async function escrowInbox(topicId, flags) {
+  const client = loadClient(flags, false);
+  const json = flags.json ?? false;
+  const creds = loadCredentials();
+  if (creds) {
+    const chainKey = chainIdForCredentials(flags.chain);
+    const ecdhKey = creds.chains?.[chainKey]?.ecdh?.privateKey;
+    if (ecdhKey) {
+      client.loadECDHKeypair(ecdhKey);
+      const apps = creds.chains?.[chainKey]?.apps;
+      if (apps) {
+        for (const app of Object.values(apps)) {
+          for (const [tId, key] of Object.entries(app.topicKeys || {})) {
+            client.setTopicKey(Number(tId), Buffer.from(key, "hex"));
+          }
+        }
+      }
+    }
+  }
+  if (!json) console.log(`Loading inbox for topic #${topicId}...`);
+  const inbox = await client.getEscrowInbox(topicId);
+  if (json) {
+    output({
+      topicId,
+      count: inbox.length,
+      deposits: inbox.map((d) => ({
+        id: d.id.toString(),
+        sender: d.sender,
+        token: d.token,
+        amount: d.amount.toString(),
+        formattedAmount: d.formattedAmount,
+        depositedAt: d.depositedAt.toString(),
+        txHash: d.txHash,
+        blockNumber: d.blockNumber,
+        messageText: d.messageText,
+        hasResponse: d.hasResponse,
+        remainingSeconds: d.remainingSeconds,
+        formattedRemaining: d.formattedRemaining,
+        expired: d.expired,
+        status: d.status
+      }))
+    }, true);
+    return;
+  }
+  if (inbox.length === 0) {
+    console.log(`Topic #${topicId} inbox: empty (no pending deposits).`);
+    return;
+  }
+  console.log(`
+Topic #${topicId} inbox (${inbox.length} pending):
+`);
+  for (const d of inbox) {
+    const icon = d.hasResponse ? "\u2713" : "\u25CB";
+    const amountStr = d.formattedAmount ? d.token === "0x0000000000000000000000000000000000000000" ? `${d.formattedAmount} ETH` : d.formattedAmount : d.amount.toString();
+    const ago = formatAgo(Number(d.depositedAt));
+    const timerStr = d.expired ? "EXPIRED" : `${d.formattedRemaining} left`;
+    console.log(`  #${d.id}  ${icon}  ${amountStr}  ${ago}  [${timerStr}]`);
+    console.log(`    From: ${d.sender}`);
+    if (d.messageText) {
+      const truncated = d.messageText.length > 80 ? d.messageText.slice(0, 77) + "..." : d.messageText;
+      console.log(`    Msg:  ${truncated}`);
+    }
+    console.log();
+  }
+}
+async function escrowStats(address, flags) {
+  const client = loadClient(flags, false);
+  const json = flags.json ?? false;
+  const cred = await client.getWalletCredibility(address);
+  if (json) {
+    output({
+      address,
+      responseRate: cred.responseRate,
+      depositsReceived: cred.depositsReceived.toString(),
+      depositsReleased: cred.depositsReleased.toString(),
+      depositsRefunded: cred.depositsRefunded.toString(),
+      totalEarned: cred.totalEarned.toString(),
+      totalRefunded: cred.totalRefunded.toString(),
+      formattedEarned: cred.formattedEarned,
+      formattedRefunded: cred.formattedRefunded
+    }, true);
+    return;
+  }
+  const shortAddr = address.slice(0, 6) + "..." + address.slice(-4);
+  console.log(`
+Escrow stats for ${shortAddr}:
+`);
+  console.log(`  Response rate:     ${cred.responseRate.toFixed(1)}%`);
+  console.log(`  Deposits received: ${cred.depositsReceived}`);
+  console.log(`  Released: ${cred.depositsReleased}  |  Refunded: ${cred.depositsRefunded}`);
+  console.log(`  Total earned:      ${cred.formattedEarned ?? cred.totalEarned.toString()} ETH`);
+  console.log(`  Total refunded:    ${cred.formattedRefunded ?? cred.totalRefunded.toString()} ETH`);
+  console.log();
+}
+function formatAgo(epochSeconds) {
+  const diff = Math.floor(Date.now() / 1e3) - epochSeconds;
+  if (diff < 60) return `${diff}s ago`;
+  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
+  return `${Math.floor(diff / 86400)}d ago`;
+}
 
 // src/cli/errors.ts
 var ERROR_MAP = {
@@ -5815,7 +6127,7 @@ function decodeContractError(err) {
 }
 
 // src/cli/index.ts
-var VERSION = "0.11.0";
+var VERSION = "0.11.2";
 var HELP = `
   clawntenna v${VERSION}
   On-chain encrypted messaging for AI agents
@@ -5893,11 +6205,13 @@ var HELP = `
     escrow enable <topicId> <timeout>              Enable escrow (topic owner)
     escrow disable <topicId>                       Disable escrow
     escrow status <topicId>                        Show escrow config
-    escrow deposits <topicId>                      List pending deposits
+    escrow inbox <topicId>                         Show pending deposits with linked messages
+    escrow deposits <topicId>                      List pending deposit IDs
     escrow deposit <depositId>                     Show deposit info
     escrow respond <topicId> <id1> [id2...] --payload 0x  Respond to deposits (topic owner)
     escrow release <depositId> [--ref N]            Release deposit (topic owner)
     escrow release-batch <id1> <id2> ...           Batch release deposits
+    escrow stats <address>                         Show wallet credibility & escrow stats
     escrow refund <depositId>                      Claim refund
     escrow refund-batch <id1> <id2> ...            Batch refund
 
@@ -6278,7 +6592,11 @@ async function main() {
       // --- Escrow ---
       case "escrow": {
         const sub = args[0];
-        if (sub === "enable") {
+        if (sub === "inbox") {
+          const topicId = parseInt(args[1], 10);
+          if (isNaN(topicId)) outputError("Usage: clawntenna escrow inbox <topicId>", json);
+          await escrowInbox(topicId, cf);
+        } else if (sub === "enable") {
           const topicId = parseInt(args[1], 10);
           const timeout = parseInt(args[2], 10);
           if (isNaN(topicId) || isNaN(timeout)) outputError("Usage: clawntenna escrow enable <topicId> <timeout>", json);
@@ -6323,8 +6641,12 @@ async function main() {
           const ids = args.slice(1).map((a) => parseInt(a, 10));
           if (ids.length === 0 || ids.some(isNaN)) outputError("Usage: clawntenna escrow refund-batch <id1> <id2> ...", json);
           await escrowRefundBatch(ids, cf);
+        } else if (sub === "stats") {
+          const address = args[1];
+          if (!address) outputError("Usage: clawntenna escrow stats <address>", json);
+          await escrowStats(address, cf);
         } else {
-          outputError(`Unknown escrow subcommand: ${sub}. Use: enable, disable, status, deposits, deposit, release, release-batch, refund, refund-batch`, json);
+          outputError(`Unknown escrow subcommand: ${sub}. Use: inbox, enable, disable, status, stats, deposits, deposit, respond, release, release-batch, refund, refund-batch`, json);
         }
         break;
       }

package/dist/index.cjs

@@ -302,7 +302,14 @@ var ESCROW_ABI = [
   "event DepositRefunded(uint256 indexed depositId, uint256 indexed topicId, address indexed sender, uint256 amount)",
   // V3
   "event DepositReleasedByOwner(uint256 indexed depositId, uint256 indexed topicId, address indexed releasedBy, uint256 messageRef)",
-  "event DepositResponseRecorded(uint256 indexed depositId, uint256 indexed topicId, address indexed respondedBy)"
+  "event DepositResponseRecorded(uint256 indexed depositId, uint256 indexed topicId, address indexed respondedBy)",
+  // V4 — on-chain accumulators + credibility
+  "function getRecipientStats(address wallet) view returns (tuple(uint64 depositsReceived, uint64 depositsReleased, uint64 depositsRefunded, uint64 depositsExpired))",
+  "function getResponseRate(address wallet) view returns (uint256)",
+  "function getCredibility(address wallet) view returns (uint256 responseRate, uint64 depositsReceived, uint64 depositsReleased, uint64 depositsRefunded, uint256 totalEarned, uint256 totalRefunded)",
+  "function amountEarned(address wallet) view returns (uint256)",
+  "function amountRefunded(address wallet) view returns (uint256)",
+  "event RecipientStatsUpdated(address indexed wallet, uint64 received, uint64 released, uint64 refunded)"
 ];
 var KEY_MANAGER_ABI = [
   // ===== READ FUNCTIONS =====
@@ -1170,6 +1177,63 @@ var Clawntenna = class _Clawntenna {
   async hasResponse(depositId) {
     return this.requireEscrow().hasResponse(depositId);
   }
+  /**
+   * Get lifetime escrow stats for a wallet (V4).
+   */
+  async getRecipientStats(wallet) {
+    const s = await this.requireEscrow().getRecipientStats(wallet);
+    return {
+      depositsReceived: BigInt(s.depositsReceived),
+      depositsReleased: BigInt(s.depositsReleased),
+      depositsRefunded: BigInt(s.depositsRefunded),
+      depositsExpired: BigInt(s.depositsExpired)
+    };
+  }
+  /**
+   * Get credibility snapshot for a wallet (V4).
+   * Returns response rate as 0-100 percentage and lifetime escrow totals.
+   */
+  async getWalletCredibility(wallet) {
+    const escrow = this.requireEscrow();
+    const cred = await escrow.getCredibility(wallet);
+    const responseRate = Number(cred.responseRate) / 100;
+    let formattedEarned = null;
+    let formattedRefunded = null;
+    try {
+      formattedEarned = import_ethers.ethers.formatEther(cred.totalEarned);
+      formattedRefunded = import_ethers.ethers.formatEther(cred.totalRefunded);
+    } catch {
+    }
+    return {
+      responseRate,
+      depositsReceived: BigInt(cred.depositsReceived),
+      depositsReleased: BigInt(cred.depositsReleased),
+      depositsRefunded: BigInt(cred.depositsRefunded),
+      totalEarned: BigInt(cred.totalEarned),
+      totalRefunded: BigInt(cred.totalRefunded),
+      formattedEarned,
+      formattedRefunded
+    };
+  }
+  /**
+   * Get the on-chain total amount earned by a wallet via escrow releases (V4).
+   */
+  async getAmountEarned(wallet) {
+    return this.requireEscrow().amountEarned(wallet);
+  }
+  /**
+   * Get the on-chain total amount lost to refunds for a wallet (V4).
+   */
+  async getAmountRefunded(wallet) {
+    return this.requireEscrow().amountRefunded(wallet);
+  }
+  /**
+   * Get response rate for a wallet as basis points (0-10000) (V4).
+   */
+  async getResponseRate(wallet) {
+    const rate = await this.requireEscrow().getResponseRate(wallet);
+    return Number(rate);
+  }
   /**
    * Parse a transaction receipt to extract the depositId from a DepositRecorded event.
    * Returns null if no DepositRecorded event is found (e.g. no escrow on this tx).
@@ -1226,6 +1290,153 @@ var Clawntenna = class _Clawntenna {
       canClaim
     };
   }
+  // ===== PRIVATE HELPERS =====
+  /**
+   * Query contract events in chunked ranges to stay within public RPC limits.
+   */
+  async _queryFilterChunked(contract, filter, fromBlock, toBlock, chunkSize = 1e4) {
+    const results = [];
+    for (let start = fromBlock; start <= toBlock; start += chunkSize) {
+      const end = Math.min(start + chunkSize - 1, toBlock);
+      const chunk = await this._wrapRpcError(
+        () => contract.queryFilter(filter, start, end),
+        "queryFilterChunked"
+      );
+      results.push(...chunk);
+    }
+    return results;
+  }
+  // ===== ESCROW INBOX (deposit → message bridge) =====
+  /**
+   * Reverse lookup: find the transaction hash that created a deposit.
+   * Queries DepositRecorded events filtered by depositId (first indexed param).
+   */
+  async getDepositTxHash(depositId) {
+    const escrow = this.requireEscrow();
+    const chain = CHAINS[this.chainName];
+    const currentBlock = await this.provider.getBlockNumber();
+    const startBlock = currentBlock - chain.defaultLookback;
+    const filter = escrow.filters.DepositRecorded(depositId);
+    const events = await this._queryFilterChunked(escrow, filter, startBlock, currentBlock);
+    if (events.length === 0) return null;
+    return events[0].transactionHash;
+  }
+  /**
+   * Full reverse lookup: deposit → tx hash → tx receipt → parse MessageSent → decrypt.
+   * Returns the tx hash and decoded message, or null if the deposit event isn't found.
+   */
+  async getDepositMessage(depositId) {
+    const txHash = await this.getDepositTxHash(depositId);
+    if (!txHash) return null;
+    const receipt = await this.provider.getTransactionReceipt(txHash);
+    if (!receipt) return null;
+    const msg = await this._parseMessageFromReceipt(receipt);
+    if (!msg) return null;
+    return { txHash, message: msg };
+  }
+  /**
+   * Get the "inbox" — all pending deposits for a topic, enriched with their linked messages.
+   * Sorted newest-first by depositedAt.
+   */
+  async getEscrowInbox(topicId) {
+    const escrow = this.requireEscrow();
+    const chain = CHAINS[this.chainName];
+    const depositIds = await this.getPendingDeposits(topicId);
+    if (depositIds.length === 0) return [];
+    const deposits = await Promise.all(
+      depositIds.map((id) => this.getDeposit(Number(id)))
+    );
+    const currentBlock = await this.provider.getBlockNumber();
+    const startBlock = currentBlock - chain.defaultLookback;
+    const topicFilter = escrow.filters.DepositRecorded(null, topicId);
+    const events = await this._queryFilterChunked(escrow, topicFilter, startBlock, currentBlock);
+    const txHashMap = /* @__PURE__ */ new Map();
+    for (const evt of events) {
+      const id = evt.args.depositId.toString();
+      txHashMap.set(id, { txHash: evt.transactionHash, blockNumber: evt.blockNumber });
+    }
+    const responseStatuses = await Promise.all(
+      depositIds.map((id) => this.hasResponse(Number(id)).catch(() => false))
+    );
+    const nowSeconds = Math.floor(Date.now() / 1e3);
+    const enriched = [];
+    for (let i = 0; i < deposits.length; i++) {
+      const deposit = deposits[i];
+      const idStr = deposit.id.toString();
+      const eventInfo = txHashMap.get(idStr);
+      const txHash = eventInfo?.txHash ?? "";
+      const blockNumber = eventInfo?.blockNumber ?? 0;
+      let messageText = null;
+      if (txHash) {
+        try {
+          const receipt = await this.provider.getTransactionReceipt(txHash);
+          if (receipt) {
+            const msg = await this._parseMessageFromReceipt(receipt);
+            messageText = msg?.text ?? null;
+          }
+        } catch {
+        }
+      }
+      const remaining = timeUntilRefund(deposit.depositedAt, deposit.timeout, nowSeconds);
+      const expired = remaining === 0;
+      let formattedAmount = null;
+      try {
+        formattedAmount = await this.formatTokenAmount(deposit.token, deposit.amount);
+      } catch {
+      }
+      enriched.push({
+        ...deposit,
+        txHash,
+        blockNumber,
+        messageText,
+        hasResponse: responseStatuses[i],
+        remainingSeconds: remaining,
+        formattedRemaining: formatTimeout(remaining),
+        expired,
+        formattedAmount
+      });
+    }
+    enriched.sort((a, b) => Number(b.depositedAt - a.depositedAt));
+    return enriched;
+  }
+  /**
+   * Parse a MessageSent event from a transaction receipt and decrypt it.
+   * Returns null if no MessageSent event is found.
+   */
+  async _parseMessageFromReceipt(receipt) {
+    const iface = this.registry.interface;
+    for (const log of receipt.logs) {
+      try {
+        const parsed = iface.parseLog(log);
+        if (parsed?.name === "MessageSent") {
+          const topicId = Number(parsed.args.topicId);
+          const sender = parsed.args.sender;
+          const payloadBytes = parsed.args.payload;
+          const timestamp = Number(parsed.args.timestamp);
+          let text = "[unable to decrypt]";
+          try {
+            const key = await this.getEncryptionKey(topicId);
+            const payloadStr = import_ethers.ethers.toUtf8String(payloadBytes);
+            const result = decryptMessage(payloadStr, key);
+            if (result) text = result.text;
+          } catch {
+          }
+          return {
+            topicId,
+            sender,
+            text,
+            replyTo: null,
+            mentions: null,
+            timestamp,
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber
+          };
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
   // ===== ECDH (Private Topics) =====
   /**
    * Derive ECDH keypair from wallet signature (deterministic).