ordpool-stats: add 'OpenTimestamps' chart type (stamps per period)

New 'ots' ChartType in the /ordpool-stats family. Single line series
showing the number of confirmed OTS calendar batch-commit transactions
per period.

Backend:
  - New OtsStatistic interface (count per period).
  - getOrdpoolStatistics dispatches 'ots' to a new getSatelliteTotal
    helper (single COUNT(*) per period, no per-discriminator split --
    we want a tidy single-series sparkline, not a per-calendar fan-out).
  - Joins ordpool_stats_ots on sat.blockhash = b.hash so still-pending
    rows (NULL blockhash, not yet confirmed) get filtered automatically.
  - 1 new statistics-api spec asserts the new SQL shape.

Frontend:
  - ChartType + ExtractStatistic both extended with 'ots'.
  - getSeriesData('ots', ...) emits one line: 'OpenTimestamps batch commits'.
  - getTooltipContent('ots', ...) shows 'OTS batch commits: N'.
  - formatChartHeading + formatChartDescription handle the new type.
  - One more button in ordpool-stats.component.html ('OpenTimestamps').
  - 2 new helper specs pin the series shape + tooltip text.

289 backend tests pass (was 288). 173 frontend tests pass (was 171).
AOT prod build clean.

\xf0\x9f\x98\xba

Author: hans-crypto

backend/src/api/explorer/_ordpool/ordpool-statistics-interface.ts

@@ -19,7 +19,8 @@ export type ChartType =
   | 'cat21-stats'            // CAT-21 block aggregates: genesis count, fee-rate spread
   | 'rune-activity'          // unique runes minted + top mint count, in pairs
   | 'atomical-ops'           // per-operation counts from satellite (dft/nft/mod/...)
-  | 'counterparty-messages'; // per-message-type counts from satellite
+  | 'counterparty-messages'  // per-message-type counts from satellite
+  | 'ots';                   // OpenTimestamps batch-commits per period
 
 export interface BaseStatistic {
   minHeight: number;
@@ -139,6 +140,14 @@ export interface CounterpartyMessagesStatistic extends BaseStatistic {
   count?: number;
 }
 
+// OpenTimestamps batch-commit counts per period. One row per period; the
+// `count` is the number of confirmed OTS calendar batch transactions whose
+// blockheight falls inside the period. Comes from the ordpool_stats_ots
+// satellite (the same table OtsTxidSet hydrates from on backend boot).
+export interface OtsStatistic extends BaseStatistic {
+  count?: number;
+}
+
 export type OrdpoolStatisticResponse =
   MintStatistic |
   NewTokenStatistic |
@@ -152,7 +161,8 @@ export type OrdpoolStatisticResponse =
   Cat21StatStatistic |
   RuneActivityStatistic |
   AtomicalOpsStatistic |
-  CounterpartyMessagesStatistic;
+  CounterpartyMessagesStatistic |
+  OtsStatistic;
 
 export function isMintStatistic(stat: OrdpoolStatisticResponse): stat is MintStatistic {
   return 'cat21Mints' in stat;

backend/src/api/explorer/_ordpool/ordpool-statistics.api.test.ts

@@ -80,6 +80,21 @@ describe('OrdpoolStatisticsApi', () => {
       expect(result).toEqual([{ inscriptionImages: 100, inscriptionTexts: 200, inscriptionJsons: 300 }]);
     });
 
+    it('should call the satellite-total query for ots (single COUNT(*) per period)', async () => {
+      (DB.query as jest.Mock).mockResolvedValueOnce([[{ minHeight: 800000, maxHeight: 800100, minTime: 1, maxTime: 2, count: 42 }]]);
+
+      const result = await OrdpoolStatisticsApi.getOrdpoolStatistics('ots', '1w', 'day');
+
+      // ordpool_stats_ots is the satellite, joined on sat.blockhash = b.hash
+      // so pending rows (NULL blockhash) get filtered automatically.
+      expect(DB.query).toHaveBeenCalledWith(expect.stringContaining('JOIN ordpool_stats_ots sat ON sat.blockhash = b.hash'));
+      // No discriminator -- single COUNT(*) per period, not per-calendar
+      expect(DB.query).toHaveBeenCalledWith(expect.stringContaining('COUNT(*) AS count'));
+      // The same interval filter applies as on the main path
+      expect(DB.query).toHaveBeenCalledWith(expect.stringContaining('AND b.blockTimestamp >= DATE_SUB(NOW(), INTERVAL 1 WEEK)'));
+      expect(result).toEqual([{ minHeight: 800000, maxHeight: 800100, minTime: 1, maxTime: 2, count: 42 }]);
+    });
+
     it('should apply interval filtering', async () => {
       (DB.query as jest.Mock).mockResolvedValueOnce([[{ cat21Mints: 5, inscriptionMints: 10 }]]);
 

backend/src/api/explorer/_ordpool/ordpool-statistics.api.ts

@@ -28,6 +28,14 @@ class OrdpoolStatisticsApi {
       return this.getSatelliteBreakdown(firstInscriptionHeight, sqlInterval, aggregation,
         'ordpool_stats_counterparty', 'sat.message_type', 'messageType');
     }
+    if (type === 'ots') {
+      // ordpool_stats_ots only carries confirmed-by-block rows once the
+      // poller's confirm step fills in blockhash/blockheight. Pending rows
+      // (NULL blockhash) deliberately skip aggregation -- they're not on
+      // chain yet.
+      return this.getSatelliteTotal(firstInscriptionHeight, sqlInterval, aggregation,
+        'ordpool_stats_ots');
+    }
 
     const selectClause = this.getSelectClause(type);
     const groupByClause = this.getGroupByClause(aggregation);
@@ -57,6 +65,41 @@ class OrdpoolStatisticsApi {
    *  discriminator value. Examples:
    *    atomical-ops          → discriminator = sat.operation
    *    counterparty-messages → discriminator = sat.message_type   */
+  /** Single-series total per period from a satellite table (no discriminator
+   *  column). Used by the `ots` chart -- one COUNT(*) per period. The
+   *  satellite is joined on `sat.blockhash = b.hash`; rows whose blockhash
+   *  is NULL (i.e. still pending, not yet confirmed) are filtered by the
+   *  INNER JOIN. */
+  private async getSatelliteTotal(
+    firstInscriptionHeight: number,
+    sqlInterval: string,
+    aggregation: Aggregation,
+    satelliteTable: string,
+  ): Promise<OrdpoolStatisticResponse[]> {
+    const groupByTime = this.getGroupByClause(aggregation).replace(/^GROUP BY/, '');
+    const query = `
+      SELECT
+        MIN(b.height) AS minHeight,
+        MAX(b.height) AS maxHeight,
+        MIN(UNIX_TIMESTAMP(b.blockTimestamp)) AS minTime,
+        MAX(UNIX_TIMESTAMP(b.blockTimestamp)) AS maxTime,
+        COUNT(*) AS count
+      FROM blocks b
+      JOIN ${satelliteTable} sat ON sat.blockhash = b.hash
+      WHERE b.height >= ${firstInscriptionHeight}
+        AND b.blockTimestamp >= DATE_SUB(NOW(), INTERVAL ${sqlInterval})
+      GROUP BY ${groupByTime}
+      ORDER BY b.blockTimestamp DESC
+    `;
+    try {
+      const [rows]: any[] = await DB.query(query);
+      return rows;
+    } catch (error) {
+      logger.err(`Error executing ${satelliteTable} total query: ${error}`, 'Ordpool');
+      throw error;
+    }
+  }
+
   private async getSatelliteBreakdown(
     firstInscriptionHeight: number,
     sqlInterval: string,

frontend/src/app/components/_ordpool/ordpool-stats/ordpool-stats.component.helper.spec.ts

@@ -121,6 +121,20 @@ describe('getSeriesData', () => {
     ]);
   });
 
+  it('should generate a single OTS series', () => {
+    const stats = [
+      { minHeight: 800000, maxHeight: 800100, minTime: 1734994800000, maxTime: 1734994800000, count: 7 },
+      { minHeight: 800101, maxHeight: 800200, minTime: 1734998400000, maxTime: 1734998400000, count: 12 },
+    ];
+    const result = getSeriesData('ots', stats);
+    expect(result).toEqual([
+      { name: 'OpenTimestamps batch commits', type: 'line', data: [
+        [1734994800000, 7],
+        [1734998400000, 12],
+      ] },
+    ]);
+  });
+
   it('should throw an error for unsupported chart type', () => {
     expect(() => {
       getSeriesData('unsupported-type' as any, []);
@@ -249,6 +263,13 @@ describe('getTooltipContent', () => {
     expect(result).toContain('JSON: 300');
   });
 
+  it('should generate correct tooltip content for ots', () => {
+    const stat = { minHeight: 800000, maxHeight: 800001, minTime: 1, maxTime: 2, count: 9 };
+    const result = getTooltipContent('ots', stat);
+    expect(result).toContain('Block Range: 800000 – 800001');
+    expect(result).toContain('OTS batch commits: 9');
+  });
+
   it('should throw an error for unsupported chart type', () => {
     expect(() => getTooltipContent('unsupported-type' as ChartType, mintStat)).toThrow(
       'Unsupported chart type: unsupported-type'

frontend/src/app/components/_ordpool/ordpool-stats/ordpool-stats.component.helper.ts

@@ -17,6 +17,7 @@ import {
   MintStatistic,
   NewTokenStatistic,
   OrdpoolStatisticResponse,
+  OtsStatistic,
   ProtocolStatistic,
   RuneActivityStatistic,
 } from '../../../../../../backend/src/api/explorer/_ordpool/ordpool-statistics-interface';
@@ -48,6 +49,7 @@ type ExtractStatistic<T extends ChartType> =
   T extends 'rune-activity' ? RuneActivityStatistic :
   T extends 'atomical-ops' ? AtomicalOpsStatistic :
   T extends 'counterparty-messages' ? CounterpartyMessagesStatistic :
+  T extends 'ots' ? OtsStatistic :
   never;
 
 /**
@@ -181,6 +183,9 @@ export function getSeriesData<T extends ChartType>(
     'counterparty-messages': (stats: CounterpartyMessagesStatistic[]) => [
       { name: 'Counterparty messages', type: 'line', data: stats.map((stat) => [stat.minTime, stat.count]) },
     ],
+    'ots': (stats: OtsStatistic[]) => [
+      { name: 'OpenTimestamps batch commits', type: 'line', data: stats.map((stat) => [stat.minTime, stat.count]) },
+    ],
   })(statistics);
 }
 
@@ -304,6 +309,10 @@ export function getTooltipContent(
       const s = stat as CounterpartyMessagesStatistic;
       return baseContent + `${s.messageType ?? 'unknown'}: ${s.count ?? 0}`;
     }
+    case 'ots': {
+      const s = stat as OtsStatistic;
+      return baseContent + `OTS batch commits: ${s.count ?? 0}`;
+    }
     default:
       throw new Error(`Unsupported chart type: ${type}`);
   }
@@ -343,6 +352,7 @@ export function formatChartHeading(chartType: ChartType): string {
     'rune-activity': 'Rune Activity',
     'atomical-ops': 'Atomical Operations',
     'counterparty-messages': 'Counterparty Messages',
+    'ots': 'OpenTimestamps',
   };
 
   return chartTypeHeadings[chartType];
@@ -370,6 +380,7 @@ export function formatChartDescription(chartType: ChartType, interval: Interval,
     'rune-activity': 'Rune mint activity: distinct runes seeing mints + the top single-rune mint count. Each metric is shown twice — overall and excluding UNCOMMON•GOODS (rune 1:0, which dominates every rune mint stat).',
     'atomical-ops': 'Atomical operations breakdown by op type (nft / ft / dft / dmt / dat / mod / evt / sl / splat / split / custom-color).',
     'counterparty-messages': 'Counterparty message activity per period — sends, dispensers, fairmints, bets, sweeps, and the rest of the 22+ message types.',
+    'ots': 'OpenTimestamps batch-commit transactions per period. Each row is one calendar publishing a Merkle root anchoring however many user submissions arrived since its last anchor — count goes up when calendars publish more often or more calendars are tracked.',
   };
 
   const intervalDescriptions: Record<Interval, string> = {

frontend/src/app/components/_ordpool/ordpool-stats/ordpool-stats.component.html

@@ -47,6 +47,7 @@
   <a routerLinkActive="active" class="btn btn-primary" [routerLink]="['/ordpool-stats' | relativeUrl, 'inscription-sizes', statistics.interval, statistics.aggregation]">Inscription Sizes</a>
   <a routerLinkActive="active" class="btn btn-primary" [routerLink]="['/ordpool-stats' | relativeUrl, 'inscription-types', statistics.interval, statistics.aggregation]">Inscription Types</a>
   <a routerLinkActive="active" class="btn btn-primary" [routerLink]="['/ordpool-stats' | relativeUrl, 'protocols', statistics.interval, statistics.aggregation]">Other Protocols</a>
+  <a routerLinkActive="active" class="btn btn-primary" [routerLink]="['/ordpool-stats' | relativeUrl, 'ots', statistics.interval, statistics.aggregation]">OpenTimestamps</a>
 
 </div>