ots: isOtsCommit tristate (closes the strip-wire OTS hole)

Implements the design from ORDPOOL-FLAGS-ARCHITECTURE.md §4. The OTS
bit is the only indexer-derived ordpool flag; the frontend cannot
recompute it from witness bytes. Strip wire surfaces (REST /api/tx/:txid,
WS track-tx) were silently dropping it. This commit fills the hole
without touching the upstream wire shapes.

Backend:
  - New optional field on TransactionExtended: isOtsCommit?: boolean | null.
    null = 'not computed' (bulk surfaces leave it absent; OTS bit travels
    in tx.flags there). true/false = server-attached answer from
    ordpoolOtsTxidSet.has(txid).
  - bitcoin.routes.ts:getTransaction attaches isOtsCommit before
    res.json(transaction). O(1) Set.has() lookup.
  - websocket-handler.ts track-tx attaches isOtsCommit on both
    $getMempoolTransactionExtended call sites (esplora + bitcoind backends).
  - New lazy endpoint: GET /api/v1/ordpool/ots/is-commit/:txid ->
    { result: boolean }. Validates txid via isValidTxid, Cache-Control:
    public, max-age=60 (matches OTS poller cycle and the false-monotonicity
    window).

Frontend:
  - New OtsKnowledgeService in services/ordinals/. Three-source decision:
    server-attached tristate -> OP_RETURN fast path (no OP_RETURN ->
    definitely false, no fetch) -> lazy backend probe (cached).
  - Cache semantics: true cached forever (monotonic), false cached 60s
    (poller can later flip to true). Probe failures degrade to false
    WITHOUT caching the failure (so retries work).
  - transaction.utils.ts::getTransactionFlags gains an optional
    otsKnowledge parameter, applies the OTS bit via the three-source
    logic before returning. When undefined (utility-only callers), still
    respects the server-attached tristate.
  - 3 component call sites updated to inject + pass the service:
    transaction.component, transaction-raw.component, tracker.component.

Regression tests:
  - 5 backend tests for the new lazy endpoint (positive, negative,
    Cache-Control header, malformed-txid rejection, wrong-length
    rejection). Mocks ordpoolOtsTxidSet (the IO boundary).
  - 11 frontend tests for OtsKnowledgeService covering every branch of
    the three-source logic + cache semantics + graceful degradation
    under probe failure.

Test count delta: backend 299 -> 304, frontend 173 -> 184.
AOT prod build clean.

Author: hans-crypto

backend/.test-count-baseline.json

@@ -1,4 +1,4 @@
 {
-  "passing": 299,
+  "passing": 304,
   "note": "Floor for .github/workflows/test-count-floor-backend.yml. Count of passing tests from the single jest config (node). Only an ordpool core maintainer is authorised to lower this number; every other change that reduces test count is treated as an accident and rejected. To raise the floor after legitimately adding tests, bump this value and commit. See also workspace CLAUDE.md, HARD RULE 'Never delete a passing test without explicit permission'."
 }

backend/src/api/bitcoin/bitcoin.routes.ts

@@ -2,6 +2,9 @@ import { Application, Request, Response } from 'express';
 import axios from 'axios';
 import * as bitcoinjs from 'bitcoinjs-lib';
 import config from '../../config';
+// HACK -- Ordpool: tristate OTS-commit knowledge on strip wire surfaces;
+// see ORDPOOL-FLAGS-ARCHITECTURE.md §4.
+import ordpoolOtsTxidSet from '../ordpool-ots-txid-set';
 import websocketHandler from '../websocket-handler';
 import mempool from '../mempool';
 import feeApi from '../fee-api';
@@ -251,6 +254,11 @@ class BitcoinRoutes {
     }
     try {
       const transaction = await transactionUtils.$getTransactionExtended(req.params.txId, true, false, false, true);
+      // HACK -- Ordpool: strip-path wire surface -- tx.flags is absent
+      // here (upstream's strip-and-recompute pattern). Attach the tristate
+      // OTS-commit answer so the frontend can apply the ordpool_ots bit
+      // without recomputation. O(1) Set.has() lookup.
+      transaction.isOtsCommit = ordpoolOtsTxidSet.has(req.params.txId);
       res.json(transaction);
     } catch (e) {
       let statusCode = 500;

backend/src/api/explorer/_ordpool/ordpool.routes.test.ts

@@ -36,6 +36,12 @@ jest.mock('../../../repositories/OrdpoolOtsRepository', () => ({
     getByBlockheight: jest.fn(),
   },
 }));
+jest.mock('../../ordpool-ots-txid-set', () => ({
+  __esModule: true,
+  default: {
+    has: jest.fn(),
+  },
+}));
 jest.mock('./ordpool-inscriptions.api', () => ({ __esModule: true, default: {} }));
 jest.mock('./ordpool-stamps.api', () => ({ __esModule: true, default: {} }));
 jest.mock('./ordpool-atomicals.api', () => ({ __esModule: true, default: {} }));
@@ -205,3 +211,67 @@ describe('$getIndexerProgress route handler', () => {
     });
   });
 });
+
+describe('$isOtsCommit route handler', () => {
+
+  // The handler is the lazy lookup the frontend uses when neither the
+  // strip-wire `tx.isOtsCommit` attachment nor the client-side OP_RETURN
+  // fast-path could decide. Tiny surface: validate txid, look up the
+  // set, set Cache-Control, return { result: boolean }.
+  // See ORDPOOL-FLAGS-ARCHITECTURE.md §4 for the full design.
+
+  // tslint:disable-next-line:no-var-requires
+  const ordpoolOtsTxidSet = require('../../ordpool-ots-txid-set').default;
+
+  async function call$isOtsCommit(txid: string) {
+    const res = makeRes();
+    await (generalOrdpoolRoutes as any).$isOtsCommit({ params: { txid } } as unknown as Request, res);
+    return res as Response & { status: jest.Mock; json: jest.Mock; send: jest.Mock; setHeader: jest.Mock };
+  }
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('returns { result: true } when the txid is in the set', async () => {
+    (ordpoolOtsTxidSet.has as jest.Mock).mockReturnValue(true);
+
+    const txid = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+    const res = await call$isOtsCommit(txid);
+
+    expect(ordpoolOtsTxidSet.has).toHaveBeenCalledWith(txid);
+    expect(res.json).toHaveBeenCalledWith({ result: true });
+    expect(res.status).not.toHaveBeenCalled();
+  });
+
+  it('returns { result: false } when the txid is not in the set', async () => {
+    (ordpoolOtsTxidSet.has as jest.Mock).mockReturnValue(false);
+
+    const res = await call$isOtsCommit('a'.repeat(64));
+
+    expect(res.json).toHaveBeenCalledWith({ result: false });
+  });
+
+  it('sets Cache-Control: public, max-age=60 to match the OTS poller cycle', async () => {
+    (ordpoolOtsTxidSet.has as jest.Mock).mockReturnValue(false);
+
+    const res = await call$isOtsCommit('b'.repeat(64));
+
+    expect(res.setHeader).toHaveBeenCalledWith('Cache-Control', 'public, max-age=60');
+  });
+
+  it('rejects malformed txids (not 64 hex chars)', async () => {
+    const res = await call$isOtsCommit('not-a-txid');
+
+    expect(res.status).toHaveBeenCalledWith(400);
+    expect(res.send).toHaveBeenCalledWith('invalid txid');
+    expect(ordpoolOtsTxidSet.has).not.toHaveBeenCalled();
+  });
+
+  it('rejects txids with the wrong length', async () => {
+    const res = await call$isOtsCommit('abc');
+
+    expect(res.status).toHaveBeenCalledWith(400);
+    expect(ordpoolOtsTxidSet.has).not.toHaveBeenCalled();
+  });
+});

backend/src/api/explorer/_ordpool/ordpool.routes.ts

@@ -6,6 +6,7 @@ import blocks from '../../blocks';
 import OrdpoolMissingStats from '../../ordpool-missing-stats';
 import ordpoolBlocksRepository from '../../../repositories/OrdpoolBlocksRepository';
 import ordpoolOtsRepository from '../../../repositories/OrdpoolOtsRepository';
+import ordpoolOtsTxidSet from '../../ordpool-ots-txid-set';
 import ordpoolSkippedBlocksRepository from '../../../repositories/OrdpoolSkippedBlocksRepository';
 import ordpoolAtomicalsApi from './ordpool-atomicals.api';
 import ordpoolInscriptionsApi from './ordpool-inscriptions.api';
@@ -32,6 +33,7 @@ class GeneralOrdpoolRoutes {
       .get(config.MEMPOOL.API_URL_PREFIX + 'ordpool/ots/block/:height', this.$getOtsBlock)
       .get(config.MEMPOOL.API_URL_PREFIX + 'ordpool/ots/upgrade/:calendar/:hash', this.$proxyOtsUpgrade)
       .get(config.MEMPOOL.API_URL_PREFIX + 'ordpool/ots/stamp-calendars', this.$getOtsStampCalendars)
+      .get(config.MEMPOOL.API_URL_PREFIX + 'ordpool/ots/is-commit/:txid', this.$isOtsCommit)
       .get('/content/:inscriptionId', this.getInscriptionContent)
       .get('/preview/:inscriptionId', this.getInscriptionPreview)
       .get('/stamp-content/:txid', this.getStampContent)
@@ -147,6 +149,30 @@ class GeneralOrdpoolRoutes {
     res.json({ calendars: getOtsCalendars() });
   }
 
+  /**
+   * Lazy point lookup against the in-memory ordpoolOtsTxidSet: "is this
+   * tx a known OTS calendar batch commit?" Used by the frontend only
+   * when the strip-wire surfaces (REST /tx/:txid, WS track-tx) didn't
+   * already attach the answer as `tx.isOtsCommit`, and when the client-
+   * side OP_RETURN fast-path can't decide. See ORDPOOL-FLAGS-ARCHITECTURE.md
+   * §4 for the full design.
+   *
+   * Cache-Control max-age=60 matches the OTS poller's cycle: a `false`
+   * answer can flip to `true` once the poller learns about a new
+   * calendar batch, but never within a 60-second window (the answer is
+   * monotonic in the `false -> true` direction only).
+   */
+  // https://ordpool.space/api/v1/ordpool/ots/is-commit/abcd...1234
+  private async $isOtsCommit(req: Request, res: Response): Promise<void> {
+    const txid = req.params.txid;
+    if (!isValidTxid(txid)) {
+      res.status(400).send('invalid txid');
+      return;
+    }
+    res.setHeader('Cache-Control', 'public, max-age=60');
+    res.json({ result: ordpoolOtsTxidSet.has(txid) });
+  }
+
   /** All OTS commits at a given block height. Empty array if none. */
   // https://ordpool.space/api/v1/ordpool/ots/block/948192
   private async $getOtsBlock(req: Request, res: Response): Promise<void> {

backend/src/api/websocket-handler.ts

@@ -10,6 +10,9 @@ import memPool from './mempool';
 import backendInfo from './backend-info';
 import mempoolBlocks from './mempool-blocks';
 import { Common } from './common';
+// HACK -- Ordpool: tristate OTS-commit knowledge for the WS track-tx
+// strip-path; see ORDPOOL-FLAGS-ARCHITECTURE.md §4.
+import ordpoolOtsTxidSet from './ordpool-ots-txid-set';
 import loadingIndicators from './loading-indicators';
 import config from '../config';
 import transactionUtils from './transaction-utils';
@@ -210,6 +213,8 @@ class WebsocketHandler {
                       // tx.prevout is missing from transactions when in bitcoind mode
                       try {
                         const fullTx = await transactionUtils.$getMempoolTransactionExtended(tx.txid, true);
+                        // HACK -- Ordpool: strip-path -- attach OTS-commit tristate.
+                        fullTx.isOtsCommit = ordpoolOtsTxidSet.has(tx.txid);
                         response['tx'] = JSON.stringify(fullTx);
                       } catch (e) {
                         logger.debug('Error finding transaction: ' + (e instanceof Error ? e.message : e));
@@ -218,6 +223,8 @@ class WebsocketHandler {
                   } else {
                     try {
                       const fullTx = await transactionUtils.$getMempoolTransactionExtended(client['track-tx'], true);
+                      // HACK -- Ordpool: strip-path -- attach OTS-commit tristate.
+                      fullTx.isOtsCommit = ordpoolOtsTxidSet.has(client['track-tx']);
                       response['tx'] = JSON.stringify(fullTx);
                     } catch (e) {
                       logger.debug('Error finding transaction. ' + (e instanceof Error ? e.message : e));

backend/src/mempool.interfaces.ts

@@ -139,6 +139,17 @@ export interface TransactionExtended extends IEsploraApi.Transaction {
   replacement?: boolean;
   uid?: number;
   flags?: number;
+  // HACK -- Ordpool: tristate OTS-commit knowledge for strip-wire surfaces
+  // (REST /api/v1/tx/:txId and the WS track-tx push). The frontend cannot
+  // recompute ordpool_ots locally -- it's the only indexer-derived flag --
+  // so on the strip path we attach the answer here:
+  //   true  -- ordpoolOtsTxidSet.has(txid) was true at serialization time
+  //   false -- ordpoolOtsTxidSet.has(txid) was false at serialization time
+  //   null  -- we didn't compute it (most call sites; the bulk wire shapes
+  //            already carry the OTS bit in tx.flags so they leave this
+  //            field absent and the frontend uses tx.flags directly)
+  // See ORDPOOL-FLAGS-ARCHITECTURE.md §4 for the full design.
+  isOtsCommit?: boolean | null;
   clusterId?: number;
   chunkIndex?: number;
 }

frontend/.test-count-baseline.json

@@ -1,4 +1,4 @@
 {
-  "passing": 173,
+  "passing": 184,
   "note": "Floor for .github/workflows/test-count-floor-frontend.yml. Count of passing tests from the single jest config (jsdom). Only an ordpool core maintainer is authorised to lower this number; every other change that reduces test count is treated as an accident and rejected. To raise the floor after legitimately adding tests, bump this value and commit. See also workspace CLAUDE.md, HARD RULE 'Never delete a passing test without explicit permission'."
 }

frontend/src/app/components/tracker/tracker.component.ts

@@ -1,5 +1,6 @@
 import { Component, OnInit, OnDestroy, HostListener, Inject, ChangeDetectorRef, ChangeDetectionStrategy, NgZone } from '@angular/core';
 import { ElectrsApiService } from '@app/services/electrs-api.service';
+import { OtsKnowledgeService } from '@app/services/ordinals/ots-knowledge.service';
 import { ActivatedRoute, ParamMap, Router } from '@angular/router';
 import {
   switchMap,
@@ -150,6 +151,8 @@ export class TrackerComponent implements OnInit, OnDestroy {
     private zone: NgZone,
     private storageService: StorageService,
     @Inject(ZONE_SERVICE) private zoneService: any,
+    // HACK -- Ordpool: resolves the indexer-derived ordpool_ots bit.
+    private otsKnowledge: OtsKnowledgeService,
   ) {}
 
   ngOnInit() {
@@ -788,7 +791,7 @@ export class TrackerComponent implements OnInit, OnDestroy {
   async checkAccelerationEligibility(): Promise<void> {
     if (this.tx) {
       const txHeight = this.tx.status?.block_height || (this.stateService.latestBlockHeight >= 0 ? this.stateService.latestBlockHeight + 1 : null);
-      this.tx.flags = await getTransactionFlags(this.tx, null, null, txHeight, this.stateService.network);
+      this.tx.flags = await getTransactionFlags(this.tx, null, null, txHeight, this.stateService.network, this.otsKnowledge);
       const replaceableInputs = (this.tx.flags & (TransactionFlags.sighash_none | TransactionFlags.sighash_acp)) > 0n;
       const highSigop = (this.tx.sigops * 20) > this.tx.weight;
       this.eligibleForAcceleration = !replaceableInputs && !highSigop;

frontend/src/app/components/transaction/transaction-raw.component.ts

@@ -4,6 +4,7 @@ import { VbytesPipe } from '@app/shared/pipes/bytes-pipe/vbytes.pipe';
 import { WuBytesPipe } from '@app/shared/pipes/bytes-pipe/wubytes.pipe';
 import { Transaction, Vout } from '@interfaces/electrs.interface';
 import { StateService } from '@app/services/state.service';
+import { OtsKnowledgeService } from '@app/services/ordinals/ots-knowledge.service';
 import { Filter, toFilters } from '@app/shared/filters.utils';
 import { decodeRawTransaction, getTransactionFlags, addInnerScriptsToVin, countSigops, fillUnsignedInput } from '@app/shared/transaction.utils';
 import { catchError, firstValueFrom, Subscription, switchMap, tap, throwError, timer } from 'rxjs';
@@ -84,6 +85,8 @@ export class TransactionRawComponent implements OnInit, OnDestroy {
     public bytesPipe: BytesPipe,
     public vbytesPipe: VbytesPipe,
     public wuBytesPipe: WuBytesPipe,
+    // HACK -- Ordpool: resolves the indexer-derived ordpool_ots bit.
+    private otsKnowledge: OtsKnowledgeService,
   ) {}
 
   ngOnInit(): void {
@@ -276,7 +279,7 @@ export class TransactionRawComponent implements OnInit, OnDestroy {
     });
 
     const txHeight = this.transaction.status?.block_height || (this.stateService.latestBlockHeight >= 0 ? this.stateService.latestBlockHeight + 1 : null);
-    this.transaction.flags = await getTransactionFlags(this.transaction, this.cpfpInfo, null, txHeight, this.stateService.network);
+    this.transaction.flags = await getTransactionFlags(this.transaction, this.cpfpInfo, null, txHeight, this.stateService.network, this.otsKnowledge);
     this.filters = this.transaction.flags ? toFilters(this.transaction.flags).filter(f => f.txPage) : [];
 
     this.setupGraph();

frontend/src/app/components/transaction/transaction.component.ts

@@ -1,5 +1,6 @@
 import { Component, OnInit, AfterViewInit, OnDestroy, HostListener, ViewChild, ElementRef, Inject, ChangeDetectorRef } from '@angular/core';
 import { ElectrsApiService } from '@app/services/electrs-api.service';
+import { OtsKnowledgeService } from '@app/services/ordinals/ots-knowledge.service';
 import { ActivatedRoute, ParamMap, Router } from '@angular/router';
 import { TransactionsListComponent } from '@components/transactions-list/transactions-list.component';
 import {
@@ -217,6 +218,9 @@ export class TransactionComponent implements OnInit, AfterViewInit, OnDestroy {
     private etaService: EtaService,
     private cd: ChangeDetectorRef,
     @Inject(ZONE_SERVICE) private zoneService: any,
+    // HACK -- Ordpool: resolves the indexer-derived ordpool_ots bit; see
+    // ORDPOOL-FLAGS-ARCHITECTURE.md §4.
+    private otsKnowledge: OtsKnowledgeService,
   ) {
 
     // HACK, redirect to the correct URL if someone accidently insert a inscription ID
@@ -1013,7 +1017,7 @@ export class TransactionComponent implements OnInit, AfterViewInit, OnDestroy {
       this.taprootEnabled = !this.tx.status.confirmed || isFeatureActive(this.stateService.network, this.tx.status.block_height, 'taproot');
       this.rbfEnabled = !this.tx.status.confirmed || isFeatureActive(this.stateService.network, this.tx.status.block_height, 'rbf');
       const txHeight = this.tx.status?.block_height || (this.stateService.latestBlockHeight >= 0 ? this.stateService.latestBlockHeight + 1 : null);
-      this.tx.flags = await getTransactionFlags(this.tx, null, null, txHeight, this.stateService.network);
+      this.tx.flags = await getTransactionFlags(this.tx, null, null, txHeight, this.stateService.network, this.otsKnowledge);
       // HACK: always show all flags, because why not?
       // this.filters = this.tx.flags ? toFilters(this.tx.flags).filter(f => f.txPage) : [];
       this.filters = this.tx.flags ? toFilters(this.tx.flags) : [];