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

package/dest/sequencer/block_builder.d.ts

@@ -0,0 +1,27 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { DateProvider } from '@aztec/foundation/timer';
+import { PublicProcessor } from '@aztec/simulator/server';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import type { BuildBlockResult, FullNodeBlockBuilderConfig, IFullNodeBlockBuilder, MerkleTreeWriteOperations, PublicProcessorLimits, PublicProcessorValidator, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { GlobalVariables, Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+export declare function buildBlock(pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, l1ToL2Messages: Fr[], newGlobalVariables: GlobalVariables, opts: PublicProcessorLimits | undefined, worldStateFork: MerkleTreeWriteOperations, processor: PublicProcessor, validator: PublicProcessorValidator, l1Constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>, dateProvider: DateProvider, telemetryClient?: TelemetryClient): Promise<BuildBlockResult>;
+export declare class FullNodeBlockBuilder implements IFullNodeBlockBuilder {
+    private config;
+    private worldState;
+    private contractDataSource;
+    private dateProvider;
+    private telemetryClient;
+    constructor(config: FullNodeBlockBuilderConfig, worldState: WorldStateSynchronizer, contractDataSource: ContractDataSource, dateProvider: DateProvider, telemetryClient?: TelemetryClient);
+    getConfig(): FullNodeBlockBuilderConfig;
+    updateConfig(config: Partial<FullNodeBlockBuilderConfig>): void;
+    makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations): Promise<{
+        processor: PublicProcessor;
+        validator: PublicProcessorValidator;
+    }>;
+    private syncToPreviousBlock;
+    buildBlock(pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, l1ToL2Messages: Fr[], globalVariables: GlobalVariables, opts: PublicProcessorLimits, suppliedFork?: MerkleTreeWriteOperations): Promise<BuildBlockResult>;
+    getFork(blockNumber: number): Promise<MerkleTreeWriteOperations>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/sequencer/block_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_builder.d.ts","sourceRoot":"","sources":["../../src/sequencer/block_builder.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAInD,OAAO,EAAE,YAAY,EAAkB,MAAM,yBAAyB,CAAC;AAGvE,OAAO,EAGL,eAAe,EAEhB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,6BAA6B,CAAC;AAE1F,OAAO,KAAK,EACV,gBAAgB,EAChB,0BAA0B,EAC1B,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,EACvB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAMnF,wBAAsB,UAAU,CAC9B,UAAU,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC,EAC5C,cAAc,EAAE,EAAE,EAAE,EACpB,kBAAkB,EAAE,eAAe,EACnC,IAAI,mCAA4B,EAChC,cAAc,EAAE,yBAAyB,EACzC,SAAS,EAAE,eAAe,EAC1B,SAAS,EAAE,wBAAwB,EACnC,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,CAAC,EACtE,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAsC,GACtD,OAAO,CAAC,gBAAgB,CAAC,CA4C3B;AAWD,qBAAa,oBAAqB,YAAW,qBAAqB;IAE9D,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,eAAe;IALzB,YACU,MAAM,EAAE,0BAA0B,EAClC,UAAU,EAAE,sBAAsB,EAClC,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAsC,EAC7D;IAEG,SAAS,IAAI,0BAA0B,CAE7C;IAEM,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,0BAA0B,CAAC,QAE9D;IAEY,oBAAoB,CAAC,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,yBAAyB;;;OA0ClG;YAEa,mBAAmB;IAU3B,UAAU,CACd,UAAU,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC,EAC5C,cAAc,EAAE,EAAE,EAAE,EACpB,eAAe,EAAE,eAAe,EAChC,IAAI,EAAE,qBAAqB,EAC3B,YAAY,CAAC,EAAE,yBAAyB,GACvC,OAAO,CAAC,gBAAgB,CAAC,CAsC3B;IAED,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAE/D;CACF"}

package/dest/sequencer/block_builder.js

@@ -0,0 +1,134 @@
+import { MerkleTreeId } from '@aztec/aztec.js/trees';
+import { merge, pick } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { bufferToHex } from '@aztec/foundation/string';
+import { Timer, elapsed } from '@aztec/foundation/timer';
+import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
+import { LightweightBlockFactory } from '@aztec/prover-client/block-factory';
+import { GuardedMerkleTreeOperations, PublicContractsDB, PublicProcessor, TelemetryPublicTxSimulator } from '@aztec/simulator/server';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { Gas } from '@aztec/stdlib/gas';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { createValidatorForBlockBuilding } from '../tx_validator/tx_validator_factory.js';
+const log = createLogger('block-builder');
+export async function buildBlock(pendingTxs, l1ToL2Messages, newGlobalVariables, opts = {}, worldStateFork, processor, validator, l1Constants, dateProvider, telemetryClient = getTelemetryClient()) {
+    const blockBuildingTimer = new Timer();
+    const blockNumber = newGlobalVariables.blockNumber;
+    const slot = newGlobalVariables.slotNumber;
+    const msgCount = l1ToL2Messages.length;
+    const stateReference = await worldStateFork.getStateReference();
+    const archiveTree = await worldStateFork.getTreeInfo(MerkleTreeId.ARCHIVE);
+    log.verbose(`Building block ${blockNumber} for slot ${slot}`, {
+        slot,
+        slotStart: new Date(Number(getTimestampForSlot(slot, l1Constants)) * 1000),
+        now: new Date(dateProvider.now()),
+        blockNumber,
+        msgCount,
+        initialStateReference: stateReference.toInspect(),
+        initialArchiveRoot: bufferToHex(archiveTree.root),
+        opts
+    });
+    const blockFactory = new LightweightBlockFactory(worldStateFork, telemetryClient);
+    await blockFactory.startNewBlock(newGlobalVariables, l1ToL2Messages);
+    const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(()=>processor.process(pendingTxs, opts, validator));
+    // All real transactions have been added, set the block as full and pad if needed
+    await blockFactory.addTxs(processedTxs);
+    const block = await blockFactory.setBlockCompleted();
+    // How much public gas was processed
+    const publicGas = processedTxs.reduce((acc, tx)=>acc.add(tx.gasUsed.publicGas), Gas.empty());
+    const res = {
+        block,
+        publicGas,
+        publicProcessorDuration,
+        numMsgs: l1ToL2Messages.length,
+        numTxs: processedTxs.length,
+        failedTxs: failedTxs,
+        blockBuildingTimer,
+        usedTxs
+    };
+    log.trace('Built block', res.block.header);
+    return res;
+}
+const FullNodeBlockBuilderConfigKeys = [
+    'l1GenesisTime',
+    'slotDuration',
+    'l1ChainId',
+    'rollupVersion',
+    'txPublicSetupAllowList',
+    'fakeProcessingDelayPerTxMs'
+];
+export class FullNodeBlockBuilder {
+    config;
+    worldState;
+    contractDataSource;
+    dateProvider;
+    telemetryClient;
+    constructor(config, worldState, contractDataSource, dateProvider, telemetryClient = getTelemetryClient()){
+        this.config = config;
+        this.worldState = worldState;
+        this.contractDataSource = contractDataSource;
+        this.dateProvider = dateProvider;
+        this.telemetryClient = telemetryClient;
+    }
+    getConfig() {
+        return pick(this.config, ...FullNodeBlockBuilderConfigKeys);
+    }
+    updateConfig(config) {
+        this.config = merge(this.config, pick(config, ...FullNodeBlockBuilderConfigKeys));
+    }
+    async makeBlockBuilderDeps(globalVariables, fork) {
+        const txPublicSetupAllowList = this.config.txPublicSetupAllowList ?? await getDefaultAllowedSetupFunctions();
+        const contractsDB = new PublicContractsDB(this.contractDataSource);
+        const guardedFork = new GuardedMerkleTreeOperations(fork);
+        const publicTxSimulator = new TelemetryPublicTxSimulator(guardedFork, contractsDB, globalVariables, this.telemetryClient, PublicSimulatorConfig.from({
+            skipFeeEnforcement: false,
+            collectDebugLogs: false,
+            collectHints: false,
+            maxDebugLogMemoryReads: 0,
+            collectStatistics: false,
+            collectCallMetadata: false
+        }));
+        const processor = new PublicProcessor(globalVariables, guardedFork, contractsDB, publicTxSimulator, this.dateProvider, this.telemetryClient, undefined, this.config);
+        const validator = createValidatorForBlockBuilding(fork, this.contractDataSource, globalVariables, txPublicSetupAllowList);
+        return {
+            processor,
+            validator
+        };
+    }
+    async syncToPreviousBlock(parentBlockNumber, timeout) {
+        await retryUntil(()=>this.worldState.syncImmediate(parentBlockNumber, true).then((syncedTo)=>syncedTo >= parentBlockNumber), 'sync to previous block', timeout, 0.1);
+        log.debug(`Synced to previous block ${parentBlockNumber}`);
+    }
+    async buildBlock(pendingTxs, l1ToL2Messages, globalVariables, opts, suppliedFork) {
+        const parentBlockNumber = globalVariables.blockNumber - 1;
+        const syncTimeout = opts.deadline ? (opts.deadline.getTime() - this.dateProvider.now()) / 1000 : undefined;
+        await this.syncToPreviousBlock(parentBlockNumber, syncTimeout);
+        const fork = suppliedFork ?? await this.worldState.fork(parentBlockNumber);
+        try {
+            const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, fork);
+            const res = await buildBlock(pendingTxs, l1ToL2Messages, globalVariables, opts, fork, processor, validator, this.config, this.dateProvider, this.telemetryClient);
+            return res;
+        } finally{
+            // If the fork was supplied, we don't close it.
+            // Otherwise, we wait a bit to close the fork we just created,
+            // since the processor may still be working on a dangling tx
+            // which was interrupted due to the processingDeadline being hit.
+            if (!suppliedFork) {
+                // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                setTimeout(async ()=>{
+                    try {
+                        await fork.close();
+                    } catch (err) {
+                        // This can happen if the sequencer is stopped before we hit this timeout.
+                        log.warn(`Error closing forks for block processing`, err);
+                    }
+                }, 5000);
+            }
+        }
+    }
+    getFork(blockNumber) {
+        return this.worldState.fork(blockNumber);
+    }
+}

package/dest/sequencer/config.d.ts

@@ -1,2 +1,7 @@
+import type { GovernanceProposerContract, RollupContract } from '@aztec/ethereum';
 export { type SequencerConfig } from '@aztec/stdlib/config';
-//# sourceMappingURL=config.d.ts.map
+export type SequencerContracts = {
+    rollupContract: RollupContract;
+    governanceProposerContract: GovernanceProposerContract;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VxdWVuY2VyL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSwwQkFBMEIsRUFBRSxjQUFjLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUVsRixPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUU1RCxNQUFNLE1BQU0sa0JBQWtCLEdBQUc7SUFDL0IsY0FBYyxFQUFFLGNBQWMsQ0FBQztJQUMvQiwwQkFBMEIsRUFBRSwwQkFBMEIsQ0FBQztDQUN4RCxDQUFDIn0=

package/dest/sequencer/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/sequencer/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/sequencer/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAElF,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,0BAA0B,EAAE,0BAA0B,CAAC;CACxD,CAAC"}

package/dest/sequencer/errors.d.ts

@@ -0,0 +1,11 @@
+import type { SequencerState } from './utils.js';
+export declare class SequencerTooSlowError extends Error {
+    readonly proposedState: SequencerState;
+    readonly maxAllowedTime: number;
+    readonly currentTime: number;
+    constructor(proposedState: SequencerState, maxAllowedTime: number, currentTime: number);
+}
+export declare class SequencerInterruptedError extends Error {
+    constructor();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VxdWVuY2VyL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFakQscUJBQWEscUJBQXNCLFNBQVEsS0FBSzthQUU1QixhQUFhLEVBQUUsY0FBYzthQUM3QixjQUFjLEVBQUUsTUFBTTthQUN0QixXQUFXLEVBQUUsTUFBTTtJQUhyQyxZQUNrQixhQUFhLEVBQUUsY0FBYyxFQUM3QixjQUFjLEVBQUUsTUFBTSxFQUN0QixXQUFXLEVBQUUsTUFBTSxFQU1wQztDQUNGO0FBRUQscUJBQWEseUJBQTBCLFNBQVEsS0FBSztJQUNsRCxjQUdDO0NBQ0YifQ==

package/dest/sequencer/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/sequencer/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,aAAa,EAAE,cAAc;aAC7B,cAAc,EAAE,MAAM;aACtB,WAAW,EAAE,MAAM;IAHrC,YACkB,aAAa,EAAE,cAAc,EAC7B,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EAMpC;CACF;AAED,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,cAGC;CACF"}

package/dest/sequencer/errors.js

@@ -0,0 +1,15 @@
+export class SequencerTooSlowError extends Error {
+    proposedState;
+    maxAllowedTime;
+    currentTime;
+    constructor(proposedState, maxAllowedTime, currentTime){
+        super(`Too far into slot for ${proposedState} (time into slot ${currentTime}s greater than ${maxAllowedTime}s allowance)`), this.proposedState = proposedState, this.maxAllowedTime = maxAllowedTime, this.currentTime = currentTime;
+        this.name = 'SequencerTooSlowError';
+    }
+}
+export class SequencerInterruptedError extends Error {
+    constructor(){
+        super(`Sequencer was interrupted`);
+        this.name = 'SequencerInterruptedError';
+    }
+}

package/dest/sequencer/index.d.ts

@@ -1,4 +1,4 @@
+export * from './block_builder.js';
 export * from './config.js';
 export * from './sequencer.js';
-export * from './allowed.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXF1ZW5jZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDIn0=

package/dest/sequencer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sequencer/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sequencer/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

package/dest/sequencer/index.js

@@ -1,3 +1,3 @@
+export * from './block_builder.js';
 export * from './config.js';
 export * from './sequencer.js';
-export * from './allowed.js';

package/dest/sequencer/metrics.d.ts

@@ -1,24 +1,40 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import type { RollupContract } from '@aztec/ethereum';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
-import { type SequencerState, type SequencerStateCallback } from './utils.js';
+import { type Hex } from 'viem';
+import type { SequencerState } from './utils.js';
 export declare class SequencerMetrics {
+    private rollup;
     readonly tracer: Tracer;
+    private meter;
     private blockCounter;
     private blockBuildDuration;
     private blockBuildManaPerSecond;
     private stateTransitionBufferDuration;
-    private currentBlockNumber;
-    private currentBlockSize;
-    private blockBuilderInsertions;
     private timeToCollectAttestations;
-    constructor(client: TelemetryClient, getState: SequencerStateCallback, name?: string);
-    startCollectingAttestationsTimer(): () => void;
-    recordTimeToCollectAttestations(time: number): void;
-    recordBlockBuilderTreeInsertions(timeUs: number): void;
-    recordCancelledBlock(): void;
+    private allowanceToCollectAttestations;
+    private requiredAttestions;
+    private collectedAttestions;
+    private rewards;
+    private slots;
+    private filledSlots;
+    private blockProposalFailed;
+    private blockProposalSuccess;
+    private blockProposalPrecheckFailed;
+    private slashingAttempts;
+    private lastSeenSlot?;
+    constructor(client: TelemetryClient, rollup: RollupContract, name?: string);
+    recordRequiredAttestations(requiredAttestationsCount: number, allowanceMs: number): void;
+    recordCollectedAttestations(count: number, durationMs: number): void;
     recordBuiltBlock(buildDurationMs: number, totalMana: number): void;
     recordFailedBlock(): void;
-    recordNewBlock(blockNumber: number, txCount: number): void;
     recordStateTransitionBufferMs(durationMs: number, state: SequencerState): void;
-    private setCurrentBlock;
+    incOpenSlot(slot: SlotNumber, proposer: string): void;
+    incFilledSlot(proposer: string, coinbase: Hex | EthAddress | undefined): Promise<void>;
+    recordBlockProposalFailed(reason?: string): void;
+    recordBlockProposalSuccess(): void;
+    recordBlockProposalPrecheckFailed(checkType: string): void;
+    recordSlashingAttempt(actionCount: number): void;
 }
-//# sourceMappingURL=metrics.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

package/dest/sequencer/metrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../src/sequencer/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,sBAAsB,EAA0B,MAAM,YAAY,CAAC;AAEtG,qBAAa,gBAAgB;IAC3B,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,kBAAkB,CAAY;IACtC,OAAO,CAAC,uBAAuB,CAAQ;IACvC,OAAO,CAAC,6BAA6B,CAAY;IACjD,OAAO,CAAC,kBAAkB,CAAQ;IAClC,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,sBAAsB,CAAY;IAE1C,OAAO,CAAC,yBAAyB,CAAQ;gBAE7B,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,sBAAsB,EAAE,IAAI,SAAc;IAyDzF,gCAAgC,IAAI,MAAM,IAAI;IAS9C,+BAA+B,CAAC,IAAI,EAAE,MAAM;IAI5C,gCAAgC,CAAC,MAAM,EAAE,MAAM;IAI/C,oBAAoB;IAOpB,gBAAgB,CAAC,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAQ3D,iBAAiB;IAOjB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAInD,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc;IAMvE,OAAO,CAAC,eAAe;CAIxB"}
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../src/sequencer/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAML,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,KAAK,GAAG,EAAe,MAAM,MAAM,CAAC;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,gBAAgB;IA6BzB,OAAO,CAAC,MAAM;IA5BhB,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,OAAO,CAAC,KAAK,CAAQ;IAErB,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,kBAAkB,CAAY;IACtC,OAAO,CAAC,uBAAuB,CAAQ;IACvC,OAAO,CAAC,6BAA6B,CAAY;IAGjD,OAAO,CAAC,yBAAyB,CAAQ;IACzC,OAAO,CAAC,8BAA8B,CAAQ;IAC9C,OAAO,CAAC,kBAAkB,CAAQ;IAClC,OAAO,CAAC,mBAAmB,CAAQ;IAEnC,OAAO,CAAC,OAAO,CAAQ;IAEvB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,WAAW,CAAgB;IAEnC,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,OAAO,CAAC,oBAAoB,CAAgB;IAC5C,OAAO,CAAC,2BAA2B,CAAgB;IACnD,OAAO,CAAC,gBAAgB,CAAgB;IAExC,OAAO,CAAC,YAAY,CAAC,CAAa;IAElC,YACE,MAAM,EAAE,eAAe,EACf,MAAM,EAAE,cAAc,EAC9B,IAAI,SAAc,EAuGnB;IAEM,0BAA0B,CAAC,yBAAyB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QAOvF;IAEM,2BAA2B,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAGnE;IAED,gBAAgB,CAAC,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QAM1D;IAED,iBAAiB,SAIhB;IAED,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,QAItE;IAED,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,QAW7C;IAEK,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAiB3F;IAED,yBAAyB,CAAC,MAAM,CAAC,EAAE,MAAM,QAIxC;IAED,0BAA0B,SAEzB;IAED,iCAAiC,CAAC,SAAS,EAAE,MAAM,QAIlD;IAED,qBAAqB,CAAC,WAAW,EAAE,MAAM,QAExC;CACF"}

package/dest/sequencer/metrics.js

@@ -1,78 +1,113 @@
 import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
-import { sequencerStateToNumber } from './utils.js';
+import { formatUnits } from 'viem';
 export class SequencerMetrics {
+    rollup;
     tracer;
+    meter;
     blockCounter;
     blockBuildDuration;
     blockBuildManaPerSecond;
     stateTransitionBufferDuration;
-    currentBlockNumber;
-    currentBlockSize;
-    blockBuilderInsertions;
+    // these are gauges because for individual sequencers building a block is not something that happens often enough to warrant a histogram
     timeToCollectAttestations;
-    constructor(client, getState, name = 'Sequencer'){
-        const meter = client.getMeter(name);
+    allowanceToCollectAttestations;
+    requiredAttestions;
+    collectedAttestions;
+    rewards;
+    slots;
+    filledSlots;
+    blockProposalFailed;
+    blockProposalSuccess;
+    blockProposalPrecheckFailed;
+    slashingAttempts;
+    lastSeenSlot;
+    constructor(client, rollup, name = 'Sequencer'){
+        this.rollup = rollup;
+        this.meter = client.getMeter(name);
         this.tracer = client.getTracer(name);
-        this.blockCounter = meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
-        this.blockBuildDuration = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
+        this.blockCounter = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
+        this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
             unit: 'ms',
             description: 'Duration to build a block',
             valueType: ValueType.INT
         });
-        this.blockBuildManaPerSecond = meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND, {
+        this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND, {
             unit: 'mana/s',
             description: 'Mana per second when building a block',
             valueType: ValueType.INT
         });
-        this.stateTransitionBufferDuration = meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION, {
+        this.stateTransitionBufferDuration = this.meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION, {
             unit: 'ms',
             description: 'The time difference between when the sequencer needed to transition to a new state and when it actually did.',
             valueType: ValueType.INT
         });
-        const currentState = meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_STATE, {
-            description: 'Current state of the sequencer'
+        // Init gauges and counters
+        this.blockCounter.add(0, {
+            [Attributes.STATUS]: 'failed'
         });
-        currentState.addCallback((observer)=>{
-            observer.observe(sequencerStateToNumber(getState()));
+        this.blockCounter.add(0, {
+            [Attributes.STATUS]: 'built'
         });
-        this.currentBlockNumber = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_NUMBER, {
-            description: 'Current block number',
-            valueType: ValueType.INT
+        this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS, {
+            valueType: ValueType.DOUBLE,
+            description: 'The rewards earned'
         });
-        this.currentBlockSize = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_SIZE, {
-            description: 'Current block size',
-            valueType: ValueType.INT
+        this.slots = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLOT_COUNT, {
+            valueType: ValueType.INT,
+            description: 'The number of slots this sequencer was selected for'
         });
-        this.timeToCollectAttestations = meter.createGauge(Metrics.SEQUENCER_TIME_TO_COLLECT_ATTESTATIONS, {
+        /**
+     * NOTE: we do not track missed slots as a separate metric. That would be difficult to determine
+     * Instead, use a computed metric, `slots - filledSlots` to get the number of slots a sequencer has missed.
+     */ this.filledSlots = this.meter.createUpDownCounter(Metrics.SEQUENCER_FILLED_SLOT_COUNT, {
+            valueType: ValueType.INT,
+            description: 'The number of slots this sequencer has filled'
+        });
+        this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION, {
             description: 'The time spent collecting attestations from committee members',
+            unit: 'ms',
             valueType: ValueType.INT
         });
-        this.blockBuilderInsertions = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_INSERTION_TIME, {
-            description: 'Timer for tree insertions performed by the block builder',
-            unit: 'us',
+        this.allowanceToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_TIME_ALLOWANCE, {
+            description: 'Maximum amount of time to collect attestations',
+            unit: 'ms',
             valueType: ValueType.INT
         });
-        this.setCurrentBlock(0, 0);
-    }
-    startCollectingAttestationsTimer() {
-        const startTime = Date.now();
-        const stop = ()=>{
-            const duration = Date.now() - startTime;
-            this.recordTimeToCollectAttestations(duration);
-        };
-        return stop.bind(this);
-    }
-    recordTimeToCollectAttestations(time) {
-        this.timeToCollectAttestations.record(time);
+        this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT, {
+            valueType: ValueType.INT,
+            description: 'The minimum number of attestations required to publish a block'
+        });
+        this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT, {
+            valueType: ValueType.INT,
+            description: 'The minimum number of attestations required to publish a block'
+        });
+        this.blockProposalFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT, {
+            valueType: ValueType.INT,
+            description: 'The number of times block proposal failed (including validation builds)'
+        });
+        this.blockProposalSuccess = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT, {
+            valueType: ValueType.INT,
+            description: 'The number of times block proposal succeeded (including validation builds)'
+        });
+        this.blockProposalPrecheckFailed = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT, {
+            valueType: ValueType.INT,
+            description: 'The number of times block proposal pre-build checks failed'
+        });
+        this.slashingAttempts = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT, {
+            valueType: ValueType.INT,
+            description: 'The number of slashing action attempts'
+        });
     }
-    recordBlockBuilderTreeInsertions(timeUs) {
-        this.blockBuilderInsertions.record(Math.ceil(timeUs));
+    recordRequiredAttestations(requiredAttestationsCount, allowanceMs) {
+        this.requiredAttestions.record(requiredAttestationsCount);
+        this.allowanceToCollectAttestations.record(Math.ceil(allowanceMs));
+        // reset
+        this.collectedAttestions.record(0);
+        this.timeToCollectAttestations.record(0);
     }
-    recordCancelledBlock() {
-        this.blockCounter.add(1, {
-            [Attributes.STATUS]: 'cancelled'
-        });
-        this.setCurrentBlock(0, 0);
+    recordCollectedAttestations(count, durationMs) {
+        this.collectedAttestions.record(count);
+        this.timeToCollectAttestations.record(Math.ceil(durationMs));
     }
     recordBuiltBlock(buildDurationMs, totalMana) {
         this.blockCounter.add(1, {
@@ -85,18 +120,55 @@ export class SequencerMetrics {
         this.blockCounter.add(1, {
             [Attributes.STATUS]: 'failed'
         });
-        this.setCurrentBlock(0, 0);
-    }
-    recordNewBlock(blockNumber, txCount) {
-        this.setCurrentBlock(blockNumber, txCount);
     }
     recordStateTransitionBufferMs(durationMs, state) {
         this.stateTransitionBufferDuration.record(durationMs, {
             [Attributes.SEQUENCER_STATE]: state
         });
     }
-    setCurrentBlock(blockNumber, txCount) {
-        this.currentBlockNumber.record(blockNumber);
-        this.currentBlockSize.record(txCount);
+    incOpenSlot(slot, proposer) {
+        // sequencer went through the loop a second time. Noop
+        if (slot === this.lastSeenSlot) {
+            return;
+        }
+        this.slots.add(1, {
+            [Attributes.BLOCK_PROPOSER]: proposer
+        });
+        this.lastSeenSlot = slot;
+    }
+    async incFilledSlot(proposer, coinbase) {
+        this.filledSlots.add(1, {
+            [Attributes.BLOCK_PROPOSER]: proposer
+        });
+        this.lastSeenSlot = undefined;
+        if (coinbase) {
+            try {
+                const rewards = await this.rollup.getSequencerRewards(coinbase);
+                const fmt = parseFloat(formatUnits(rewards, 18));
+                this.rewards.record(fmt, {
+                    [Attributes.COINBASE]: coinbase.toString()
+                });
+            } catch  {
+            // no-op
+            }
+        }
+    }
+    recordBlockProposalFailed(reason) {
+        this.blockProposalFailed.add(1, {
+            ...reason && {
+                [Attributes.ERROR_TYPE]: reason
+            }
+        });
+    }
+    recordBlockProposalSuccess() {
+        this.blockProposalSuccess.add(1);
+    }
+    recordBlockProposalPrecheckFailed(checkType) {
+        this.blockProposalPrecheckFailed.add(1, {
+            [Attributes.ERROR_TYPE]: checkType
+        });
+    }
+    recordSlashingAttempt(actionCount) {
+        this.slashingAttempts.add(actionCount);
     }
 }