@aztec/aztec-node 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/sentinel/store.ts

@@ -0,0 +1,184 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { BufferReader, numToUInt8, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type {
+  ValidatorStatusHistory,
+  ValidatorStatusInSlot,
+  ValidatorsEpochPerformance,
+} from '@aztec/stdlib/validators';
+
+export class SentinelStore {
+  public static readonly SCHEMA_VERSION = 2;
+
+  // a map from validator address to their ValidatorStatusHistory
+  private readonly historyMap: AztecAsyncMap<`0x${string}`, Buffer>;
+
+  // a map from validator address to their historical proven epoch performance
+  // e.g. { validator: [{ epoch: 1, missed: 1, total: 10 }, { epoch: 2, missed: 3, total: 7 }, ...] }
+  private readonly provenMap: AztecAsyncMap<`0x${string}`, Buffer>;
+
+  constructor(
+    private store: AztecAsyncKVStore,
+    private config: { historyLength: number; historicProvenPerformanceLength: number },
+  ) {
+    this.historyMap = store.openMap('sentinel-validator-status');
+    this.provenMap = store.openMap('sentinel-validator-proven');
+  }
+
+  public getHistoryLength() {
+    return this.config.historyLength;
+  }
+
+  public getHistoricProvenPerformanceLength() {
+    return this.config.historicProvenPerformanceLength;
+  }
+
+  public async updateProvenPerformance(epoch: bigint, performance: ValidatorsEpochPerformance) {
+    await this.store.transactionAsync(async () => {
+      for (const [who, { missed, total }] of Object.entries(performance)) {
+        await this.pushValidatorProvenPerformanceForEpoch({ who: EthAddress.fromString(who), missed, total, epoch });
+      }
+    });
+  }
+
+  public async getProvenPerformance(who: EthAddress): Promise<{ missed: number; total: number; epoch: bigint }[]> {
+    const currentPerformanceBuffer = await this.provenMap.getAsync(who.toString());
+    return currentPerformanceBuffer ? this.deserializePerformance(currentPerformanceBuffer) : [];
+  }
+
+  private async pushValidatorProvenPerformanceForEpoch({
+    who,
+    missed,
+    total,
+    epoch,
+  }: {
+    who: EthAddress;
+    missed: number;
+    total: number;
+    epoch: bigint;
+  }) {
+    const currentPerformance = await this.getProvenPerformance(who);
+    const existingIndex = currentPerformance.findIndex(p => p.epoch === epoch);
+    if (existingIndex !== -1) {
+      currentPerformance[existingIndex] = { missed, total, epoch };
+    } else {
+      currentPerformance.push({ missed, total, epoch });
+    }
+
+    // This should be sorted by epoch, but just in case.
+    // Since we keep the size small, this is not a big deal.
+    currentPerformance.sort((a, b) => Number(a.epoch - b.epoch));
+
+    // keep the most recent `historicProvenPerformanceLength` entries.
+    const performanceToKeep = currentPerformance.slice(-this.config.historicProvenPerformanceLength);
+
+    await this.provenMap.set(who.toString(), this.serializePerformance(performanceToKeep));
+  }
+
+  public async updateValidators(slot: bigint, statuses: Record<`0x${string}`, ValidatorStatusInSlot | undefined>) {
+    await this.store.transactionAsync(async () => {
+      for (const [who, status] of Object.entries(statuses)) {
+        if (status) {
+          await this.pushValidatorStatusForSlot(EthAddress.fromString(who), slot, status);
+        }
+      }
+    });
+  }
+
+  private async pushValidatorStatusForSlot(
+    who: EthAddress,
+    slot: bigint,
+    status: 'block-mined' | 'block-proposed' | 'block-missed' | 'attestation-sent' | 'attestation-missed',
+  ) {
+    await this.store.transactionAsync(async () => {
+      const currentHistory = (await this.getHistory(who)) ?? [];
+      const newHistory = [...currentHistory, { slot, status }].slice(-this.config.historyLength);
+      await this.historyMap.set(who.toString(), this.serializeHistory(newHistory));
+    });
+  }
+
+  public async getHistories(): Promise<Record<`0x${string}`, ValidatorStatusHistory>> {
+    const histories: Record<`0x${string}`, ValidatorStatusHistory> = {};
+    for await (const [address, history] of this.historyMap.entriesAsync()) {
+      histories[address] = this.deserializeHistory(history);
+    }
+    return histories;
+  }
+
+  public async getHistory(address: EthAddress): Promise<ValidatorStatusHistory | undefined> {
+    const data = await this.historyMap.getAsync(address.toString());
+    return data && this.deserializeHistory(data);
+  }
+
+  private serializePerformance(performance: { missed: number; total: number; epoch: bigint }[]): Buffer {
+    return serializeToBuffer(
+      performance.map(p => [numToUInt32BE(Number(p.epoch)), numToUInt32BE(p.missed), numToUInt32BE(p.total)]),
+    );
+  }
+
+  private deserializePerformance(buffer: Buffer): { missed: number; total: number; epoch: bigint }[] {
+    const reader = new BufferReader(buffer);
+    const performance: { missed: number; total: number; epoch: bigint }[] = [];
+    while (!reader.isEmpty()) {
+      performance.push({
+        epoch: BigInt(reader.readNumber()),
+        missed: reader.readNumber(),
+        total: reader.readNumber(),
+      });
+    }
+    return performance;
+  }
+
+  private serializeHistory(history: ValidatorStatusHistory): Buffer {
+    return serializeToBuffer(
+      history.map(h => [numToUInt32BE(Number(h.slot)), numToUInt8(this.statusToNumber(h.status))]),
+    );
+  }
+
+  private deserializeHistory(buffer: Buffer): ValidatorStatusHistory {
+    const reader = new BufferReader(buffer);
+    const history: ValidatorStatusHistory = [];
+    while (!reader.isEmpty()) {
+      const slot = BigInt(reader.readNumber());
+      const status = this.statusFromNumber(reader.readUInt8());
+      history.push({ slot, status });
+    }
+    return history;
+  }
+
+  private statusToNumber(status: ValidatorStatusInSlot): number {
+    switch (status) {
+      case 'block-mined':
+        return 1;
+      case 'block-proposed':
+        return 2;
+      case 'block-missed':
+        return 3;
+      case 'attestation-sent':
+        return 4;
+      case 'attestation-missed':
+        return 5;
+      default: {
+        const _exhaustive: never = status;
+        throw new Error(`Unknown status: ${status}`);
+      }
+    }
+  }
+
+  private statusFromNumber(status: number): ValidatorStatusInSlot {
+    switch (status) {
+      case 1:
+        return 'block-mined';
+      case 2:
+        return 'block-proposed';
+      case 3:
+        return 'block-missed';
+      case 4:
+        return 'attestation-sent';
+      case 5:
+        return 'attestation-missed';
+      default:
+        throw new Error(`Unknown status: ${status}`);
+    }
+  }
+}

package/src/test/index.ts

@@ -0,0 +1,32 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { P2P } from '@aztec/p2p';
+import { SequencerClient } from '@aztec/sequencer-client';
+import { EpochPruneWatcher, type SlasherClientInterface } from '@aztec/slasher';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { L2LogsSource, Service, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { GlobalVariableBuilder as GlobalVariableBuilderInterface } from '@aztec/stdlib/tx';
+
+import type { AztecNodeConfig } from '../aztec-node/config.js';
+import { AztecNodeService } from '../aztec-node/server.js';
+import { Sentinel } from '../sentinel/sentinel.js';
+
+export declare class TestAztecNodeService extends AztecNodeService {
+  declare public config: AztecNodeConfig;
+  declare public p2pClient: P2P;
+  declare public blockSource: L2BlockSource & Partial<Service>;
+  declare public logsSource: L2LogsSource;
+  declare public contractDataSource: ContractDataSource;
+  declare public l1ToL2MessageSource: L1ToL2MessageSource;
+  declare public worldStateSynchronizer: WorldStateSynchronizer;
+  declare public sequencer: SequencerClient | undefined;
+  declare public slasherClient: SlasherClientInterface | undefined;
+  declare public validatorsSentinel: Sentinel | undefined;
+  declare public epochPruneWatcher: EpochPruneWatcher | undefined;
+  declare public l1ChainId: number;
+  declare public version: number;
+  declare public globalVariableBuilder: GlobalVariableBuilderInterface;
+  declare public epochCache: EpochCacheInterface;
+  declare public packageVersion: string;
+}

package/dest/aztec-node/http_rpc_server.d.ts

@@ -1,8 +0,0 @@
-import { type AztecNode } from '@aztec/stdlib/interfaces/client';
-/**
- * Wrap an AztecNode instance with a JSON RPC HTTP server.
- * @param node - The AztecNode
- * @returns An JSON-RPC HTTP server
- */
-export declare function createAztecNodeRpcServer(node: AztecNode): import("@aztec/foundation/json-rpc/server").SafeJsonRpcServer;
-//# sourceMappingURL=http_rpc_server.d.ts.map

package/dest/aztec-node/http_rpc_server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http_rpc_server.d.ts","sourceRoot":"","sources":["../../src/aztec-node/http_rpc_server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAsB,MAAM,iCAAiC,CAAC;AAGrF;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,SAAS,iEAEvD"}

package/dest/aztec-node/http_rpc_server.js

@@ -1,9 +0,0 @@
-import { AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
-import { createTracedJsonRpcServer } from '@aztec/telemetry-client';
-/**
- * Wrap an AztecNode instance with a JSON RPC HTTP server.
- * @param node - The AztecNode
- * @returns An JSON-RPC HTTP server
- */ export function createAztecNodeRpcServer(node) {
-    return createTracedJsonRpcServer(node, AztecNodeApiSchema);
-}

package/src/aztec-node/http_rpc_server.ts

@@ -1,11 +0,0 @@
-import { type AztecNode, AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
-import { createTracedJsonRpcServer } from '@aztec/telemetry-client';
-
-/**
- * Wrap an AztecNode instance with a JSON RPC HTTP server.
- * @param node - The AztecNode
- * @returns An JSON-RPC HTTP server
- */
-export function createAztecNodeRpcServer(node: AztecNode) {
-  return createTracedJsonRpcServer(node, AztecNodeApiSchema);
-}