populate atomicalOps + counterpartyMessages satellite arrays

Per-block satellite rows for the two protocols whose downstream
charts want per-op / per-message-type breakdowns:

  atomicals.atomicalOps[] — one entry per atomical artifact, with
                            (txId, operation, ticker). Ticker is
                            args.request_ticker for FT-family ops,
                            null otherwise. CBOR decode failure on
                            getArgs() is swallowed; the op record
                            still gets pushed.

  counterparty.counterpartyMessages[] — one entry per counterparty
                                         message, with (txId,
                                         messageType, messageTypeId,
                                         encoding). Mirrors what the
                                         backend's counterparty
                                         satellite table will store.

Tests use real fixture txns:
- Atomicals DFT mint of "atom" → ['dft', 'atom']
- Counterparty enhanced_send (messageTypeId 2, opreturn encoding)
- CAT-21 genesis tx → both arrays empty

Author: hans-crypto

src/digital-artifact-analyser.service.satellites.spec.ts

@@ -0,0 +1,42 @@
+import { readTransaction } from '../testdata/test.helper';
+import { DigitalArtifactAnalyserService } from './digital-artifact-analyser.service';
+import { TransactionSimplePlus } from './types/transaction-simple';
+
+// Real mainnet atomicals DFT mint — operation 'dft', ticker 'atom'
+const ATOMICAL_DFT_TXID = '1d2f39f54320631d0432fa495a45a4f298a2ca1b18adef8e4356e327d003a694';
+
+// Real mainnet Counterparty enhanced_send — message type ID 2
+const ENHANCED_SEND_TXID = 'f3981dac3d2d43abf6c3bb059fbd998bcd8f76c4174fd1e2668599b9713649c9';
+
+describe('DigitalArtifactAnalyserService — satellite arrays', () => {
+
+  it('records every atomical operation in atomicalOps with operation + ticker', async () => {
+    const tx = readTransaction(ATOMICAL_DFT_TXID) as unknown as TransactionSimplePlus;
+    const stats = await DigitalArtifactAnalyserService.analyseTransactions([tx]);
+
+    expect(stats.atomicals.atomicalOps).toEqual([
+      { txId: ATOMICAL_DFT_TXID, operation: 'dft', ticker: 'atom' },
+    ]);
+  });
+
+  it('records every counterparty message in counterpartyMessages with messageType + id + encoding', async () => {
+    const tx = readTransaction(ENHANCED_SEND_TXID) as unknown as TransactionSimplePlus;
+    const stats = await DigitalArtifactAnalyserService.analyseTransactions([tx]);
+
+    expect(stats.counterparty.counterpartyMessages).toHaveLength(1);
+    const message = stats.counterparty.counterpartyMessages[0];
+    expect(message.txId).toBe(ENHANCED_SEND_TXID);
+    expect(message.messageType).toBe('enhanced_send');
+    expect(message.messageTypeId).toBe(2);
+    expect(message.encoding).toBe('opreturn');
+  });
+
+  it('returns empty arrays when neither atomicals nor counterparty are present', async () => {
+    // CAT-21 genesis tx: no atomical, no counterparty.
+    const tx = readTransaction('98316dcb21daaa221865208fe0323616ee6dd84e6020b78bc6908e914ac03892') as unknown as TransactionSimplePlus;
+    const stats = await DigitalArtifactAnalyserService.analyseTransactions([tx]);
+
+    expect(stats.atomicals.atomicalOps).toEqual([]);
+    expect(stats.counterparty.counterpartyMessages).toEqual([]);
+  });
+});

src/digital-artifact-analyser.service.ts

@@ -9,9 +9,12 @@ import { isUncommonGoodsMint } from './rune/rune-parser.service.helper';
 import { Src20ParserService } from './src20/src20-parser.service';
 import { DigitalArtifact, DigitalArtifactType } from './types/digital-artifact';
 import { ParsedAtomical } from './types/parsed-atomical';
+import { ParsedCounterparty } from './types/parsed-counterparty';
 import {
+  AtomicalOp,
   Brc20DeployAttempt,
   Cat21Mint,
+  CounterpartyMessage,
   getArtifactTypeMap,
   getEmptyInscriptionSizeAggregate,
   getEmptyStats,
@@ -231,6 +234,13 @@ export class DigitalArtifactAnalyserService {
     const brc20DeployAttempts: Brc20DeployAttempt[] = [];
     const src20DeployAttempts: Src20DeployAttempt[] = [];
 
+    // Per-tx satellite arrays. atomicalOps records every atomical operation
+    // (mint or update); counterpartyMessages records every CNTRPRTY message.
+    // The backend writes these to dedicated satellite tables for per-op /
+    // per-message-type charts.
+    const atomicalOps: AtomicalOp[] = [];
+    const counterpartyMessages: CounterpartyMessage[] = [];
+
     // index is zero-based, we start at -1 so that the 1st txn has number 0
     let txIndex = -1;
     for (const tx of transactions) {
@@ -377,12 +387,44 @@ export class DigitalArtifactAnalyserService {
           }
         }
 
-        // ** Atomical Fees
+        // ** Atomical Fees + per-op satellite row
         if ((flags & OrdpoolTransactionFlags.ordpool_atomical) === OrdpoolTransactionFlags.ordpool_atomical) {
           if (!atomicalFeeAdded) {
             totalAtomicalFees += txFee;
             atomicalFeeAdded = true;
           }
+
+          // Record one row per atomical artifact for the satellite table.
+          // Ticker comes from CBOR `args.request_ticker` (FT-family ops);
+          // null for ops that don't carry one. getArgs() may return null
+          // if CBOR decoding fails — defensive read.
+          const atomical = artifact as ParsedAtomical;
+          let ticker: string | null = null;
+          try {
+            const args = atomical.getArgs();
+            const rawTicker = args?.['request_ticker'];
+            if (typeof rawTicker === 'string' && rawTicker.length > 0) {
+              ticker = rawTicker;
+            }
+          } catch {
+            // CBOR decoding failed; leave ticker null, keep the op record.
+          }
+          atomicalOps.push({
+            txId: tx.txid,
+            operation: atomical.operation,
+            ticker,
+          });
+        }
+
+        // ** Counterparty per-message satellite row
+        if ((flags & OrdpoolTransactionFlags.ordpool_counterparty) === OrdpoolTransactionFlags.ordpool_counterparty) {
+          const counterparty = artifact as ParsedCounterparty;
+          counterpartyMessages.push({
+            txId: tx.txid,
+            messageType: counterparty.messageType,
+            messageTypeId: counterparty.messageTypeId,
+            encoding: counterparty.encoding,
+          });
         }
 
         // ** Inscription Mint Fees + extra stats for inscriptions
@@ -532,6 +574,8 @@ export class DigitalArtifactAnalyserService {
     stats.src20.src20DeployAttempts = src20DeployAttempts;
 
     stats.cat21.cat21MintActivity = cat21MintActivity;
+    stats.atomicals.atomicalOps = atomicalOps;
+    stats.counterparty.counterpartyMessages = counterpartyMessages;
 
     // CAT-21 block aggregates derived from the per-cat satellite array.
     // All NULLable for blocks without cats. Note: cat *numbers* are NOT