@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/archiver/errors.ts

@@ -3,3 +3,24 @@ export class NoBlobBodiesFoundError extends Error {
     super(`No blob bodies found for block ${l2BlockNum}`);
   }
 }
+
+export class InitialBlockNumberNotSequentialError extends Error {
+  constructor(
+    public readonly newBlockNumber: number,
+    public readonly previousBlockNumber: number | undefined,
+  ) {
+    super(
+      `Cannot insert new block ${newBlockNumber} given previous block number in store is ${
+        previousBlockNumber ?? 'undefined'
+      }`,
+    );
+  }
+}
+
+export class BlockNumberNotSequentialError extends Error {
+  constructor(newBlockNumber: number, previous: number | undefined) {
+    super(
+      `Cannot insert new block ${newBlockNumber} given previous block number in batch is ${previous ?? 'undefined'}`,
+    );
+  }
+}

package/src/archiver/index.ts

@@ -1,7 +1,6 @@
 export * from './archiver.js';
 export * from './config.js';
-export { type L1Published, type L1PublishedData } from './structs/published.js';
-export { MemoryArchiverStore } from './memory_archiver_store/memory_archiver_store.js';
+export { type PublishedL2Block, type L1PublishedData } from './structs/published.js';
 export type { ArchiverDataStore } from './archiver_store.js';
-export { KVArchiverDataStore } from './kv_archiver_store/kv_archiver_store.js';
+export { KVArchiverDataStore, ARCHIVER_DB_VERSION } from './kv_archiver_store/kv_archiver_store.js';
 export { ContractInstanceStore } from './kv_archiver_store/contract_instance_store.js';

package/src/archiver/instrumentation.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import {
   Attributes,
   type Gauge,
@@ -18,32 +18,43 @@ export class ArchiverInstrumentation {
 
   private blockHeight: Gauge;
   private txCount: UpDownCounter;
-  private syncDuration: Histogram;
-  private l1BlocksSynced: UpDownCounter;
   private l1BlockHeight: Gauge;
   private proofsSubmittedDelay: Histogram;
   private proofsSubmittedCount: UpDownCounter;
   private dbMetrics: LmdbMetrics;
+
+  private pruneDuration: Histogram;
   private pruneCount: UpDownCounter;
 
+  private syncDurationPerBlock: Histogram;
+  private syncBlockCount: UpDownCounter;
+  private manaPerBlock: Histogram;
+  private txsPerBlock: Histogram;
+
+  private syncDurationPerMessage: Histogram;
+  private syncMessageCount: UpDownCounter;
+
   private log = createLogger('archiver:instrumentation');
 
-  private constructor(private telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback) {
+  private constructor(
+    private telemetry: TelemetryClient,
+    lmdbStats?: LmdbStatsCallback,
+  ) {
     this.tracer = telemetry.getTracer('Archiver');
     const meter = telemetry.getMeter('Archiver');
+
     this.blockHeight = meter.createGauge(Metrics.ARCHIVER_BLOCK_HEIGHT, {
       description: 'The height of the latest block processed by the archiver',
       valueType: ValueType.INT,
     });
 
-    this.txCount = meter.createUpDownCounter(Metrics.ARCHIVER_TX_COUNT, {
-      description: 'The total number of transactions',
+    this.l1BlockHeight = meter.createGauge(Metrics.ARCHIVER_L1_BLOCK_HEIGHT, {
+      description: 'The height of the latest L1 block processed by the archiver',
       valueType: ValueType.INT,
     });
 
-    this.syncDuration = meter.createHistogram(Metrics.ARCHIVER_SYNC_DURATION, {
-      unit: 'ms',
-      description: 'Duration to sync a block',
+    this.txCount = meter.createUpDownCounter(Metrics.ARCHIVER_TOTAL_TXS, {
+      description: 'The total number of transactions',
       valueType: ValueType.INT,
     });
 
@@ -58,13 +69,48 @@ export class ArchiverInstrumentation {
       valueType: ValueType.INT,
     });
 
-    this.l1BlocksSynced = meter.createUpDownCounter(Metrics.ARCHIVER_L1_BLOCKS_SYNCED, {
+    this.syncDurationPerBlock = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_BLOCK, {
+      unit: 'ms',
+      description: 'Duration to sync a block',
+      valueType: ValueType.INT,
+    });
+
+    this.syncBlockCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_BLOCK_COUNT, {
       description: 'Number of blocks synced from L1',
       valueType: ValueType.INT,
     });
 
-    this.l1BlockHeight = meter.createGauge(Metrics.ARCHIVER_L1_BLOCK_HEIGHT, {
-      description: 'The height of the latest L1 block processed by the archiver',
+    this.manaPerBlock = meter.createHistogram(Metrics.ARCHIVER_MANA_PER_BLOCK, {
+      description: 'The mana consumed by blocks',
+      valueType: ValueType.DOUBLE,
+      unit: 'Mmana',
+    });
+
+    this.txsPerBlock = meter.createHistogram(Metrics.ARCHIVER_TXS_PER_BLOCK, {
+      description: 'The block tx count',
+      valueType: ValueType.INT,
+      unit: 'tx',
+    });
+
+    this.syncDurationPerMessage = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_MESSAGE, {
+      unit: 'ms',
+      description: 'Duration to sync a message',
+      valueType: ValueType.INT,
+    });
+
+    this.syncMessageCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_MESSAGE_COUNT, {
+      description: 'Number of L1 to L2 messages synced',
+      valueType: ValueType.INT,
+    });
+
+    this.pruneDuration = meter.createHistogram(Metrics.ARCHIVER_PRUNE_DURATION, {
+      unit: 'ms',
+      description: 'Duration to sync a message',
+      valueType: ValueType.INT,
+    });
+
+    this.pruneCount = meter.createUpDownCounter(Metrics.ARCHIVER_PRUNE_COUNT, {
+      description: 'Number of prunes detected',
       valueType: ValueType.INT,
     });
 
@@ -75,17 +121,14 @@ export class ArchiverInstrumentation {
       },
       lmdbStats,
     );
-
-    this.pruneCount = meter.createUpDownCounter(Metrics.ARCHIVER_PRUNE_COUNT, {
-      description: 'Number of prunes detected',
-      valueType: ValueType.INT,
-    });
   }
 
   public static async new(telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback) {
     const instance = new ArchiverInstrumentation(telemetry, lmdbStats);
 
-    instance.l1BlocksSynced.add(0);
+    instance.syncBlockCount.add(0);
+    instance.syncMessageCount.add(0);
+    instance.pruneCount.add(0);
 
     await instance.telemetry.flush();
 
@@ -96,17 +139,29 @@ export class ArchiverInstrumentation {
     return this.telemetry.isEnabled();
   }
 
-  public processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]) {
-    this.syncDuration.record(Math.ceil(syncTimePerBlock));
+  public processNewBlocks(syncTimePerBlock: number, blocks: L2BlockNew[]) {
+    this.syncDurationPerBlock.record(Math.ceil(syncTimePerBlock));
     this.blockHeight.record(Math.max(...blocks.map(b => b.number)));
-    this.l1BlocksSynced.add(blocks.length);
+    this.syncBlockCount.add(blocks.length);
+
     for (const block of blocks) {
       this.txCount.add(block.body.txEffects.length);
+      this.txsPerBlock.record(block.body.txEffects.length);
+      this.manaPerBlock.record(block.header.totalManaUsed.toNumber() / 1e6);
+    }
+  }
+
+  public processNewMessages(count: number, syncPerMessageMs: number) {
+    if (count === 0) {
+      return;
     }
+    this.syncMessageCount.add(count);
+    this.syncDurationPerMessage.record(Math.ceil(syncPerMessageMs));
   }
 
-  public processPrune() {
+  public processPrune(duration: number) {
     this.pruneCount.add(1);
+    this.pruneDuration.record(Math.ceil(duration));
   }
 
   public updateLastProvenBlock(blockNumber: number) {