@aztec/sequencer-client 0.0.0-test.0

package/dest/publisher/sequencer-publisher.js

@@ -0,0 +1,481 @@
+import { Blob } from '@aztec/blob-lib';
+import { createBlobSinkClient } from '@aztec/blob-sink/client';
+import { FormattedViemError, RollupContract, formatViemError } from '@aztec/ethereum';
+import { toHex } from '@aztec/foundation/bigint-buffer';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { ForwarderAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayload } from '@aztec/stdlib/p2p';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import pick from 'lodash.pick';
+import { encodeFunctionData } from 'viem';
+import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
+export var VoteType = /*#__PURE__*/ function(VoteType) {
+    VoteType[VoteType["GOVERNANCE"] = 0] = "GOVERNANCE";
+    VoteType[VoteType["SLASHING"] = 1] = "SLASHING";
+    return VoteType;
+}({});
+export class SequencerPublisher {
+    interrupted = false;
+    metrics;
+    epochCache;
+    forwarderContract;
+    governanceLog = createLogger('sequencer:publisher:governance');
+    governanceProposerAddress;
+    governancePayload = EthAddress.ZERO;
+    slashingLog = createLogger('sequencer:publisher:slashing');
+    slashingProposerAddress;
+    getSlashPayload = undefined;
+    myLastVotes = {
+        [0]: 0n,
+        [1]: 0n
+    };
+    log = createLogger('sequencer:publisher');
+    ethereumSlotDuration;
+    blobSinkClient;
+    // @note - with blobs, the below estimate seems too large.
+    // Total used for full block from int_l1_pub e2e test: 1m (of which 86k is 1x blob)
+    // Total used for emptier block from above test: 429k (of which 84k is 1x blob)
+    static PROPOSE_GAS_GUESS = 12_000_000n;
+    l1TxUtils;
+    rollupContract;
+    govProposerContract;
+    slashingProposerContract;
+    requests = [];
+    constructor(config, deps){
+        this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
+        this.epochCache = deps.epochCache;
+        this.blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config);
+        const telemetry = deps.telemetry ?? getTelemetryClient();
+        this.metrics = new SequencerPublisherMetrics(telemetry, 'SequencerPublisher');
+        this.l1TxUtils = deps.l1TxUtils;
+        this.rollupContract = deps.rollupContract;
+        this.forwarderContract = deps.forwarderContract;
+        this.govProposerContract = deps.governanceProposerContract;
+        this.slashingProposerContract = deps.slashingProposerContract;
+    }
+    registerSlashPayloadGetter(callback) {
+        this.getSlashPayload = callback;
+    }
+    getForwarderAddress() {
+        return EthAddress.fromString(this.forwarderContract.getAddress());
+    }
+    getSenderAddress() {
+        return EthAddress.fromString(this.l1TxUtils.getSenderAddress());
+    }
+    getGovernancePayload() {
+        return this.governancePayload;
+    }
+    setGovernancePayload(payload) {
+        this.governancePayload = payload;
+    }
+    addRequest(request) {
+        this.requests.push(request);
+    }
+    getCurrentL2Slot() {
+        return this.epochCache.getEpochAndSlotNow().slot;
+    }
+    /**
+   * Sends all requests that are still valid.
+   * @returns one of:
+   * - A receipt and stats if the tx succeeded
+   * - a receipt and errorMsg if it failed on L1
+   * - undefined if no valid requests are found OR the tx failed to send.
+   */ async sendRequests() {
+        const requestsToProcess = [
+            ...this.requests
+        ];
+        this.requests = [];
+        if (this.interrupted) {
+            return undefined;
+        }
+        const currentL2Slot = this.getCurrentL2Slot();
+        this.log.debug(`Current L2 slot: ${currentL2Slot}`);
+        const validRequests = requestsToProcess.filter((request)=>request.lastValidL2Slot >= currentL2Slot);
+        if (validRequests.length !== requestsToProcess.length) {
+            this.log.warn(`Some requests were expired for slot ${currentL2Slot}`, {
+                validRequests: validRequests.map((request)=>({
+                        action: request.action,
+                        lastValidL2Slot: request.lastValidL2Slot
+                    })),
+                requests: requestsToProcess.map((request)=>({
+                        action: request.action,
+                        lastValidL2Slot: request.lastValidL2Slot
+                    }))
+            });
+        }
+        if (validRequests.length === 0) {
+            this.log.debug(`No valid requests to send`);
+            return undefined;
+        }
+        // @note - we can only have one gas config and one blob config per bundle
+        // find requests with gas and blob configs
+        // See https://github.com/AztecProtocol/aztec-packages/issues/11513
+        const gasConfigs = requestsToProcess.filter((request)=>request.gasConfig);
+        const blobConfigs = requestsToProcess.filter((request)=>request.blobConfig);
+        if (gasConfigs.length > 1 || blobConfigs.length > 1) {
+            throw new Error('Multiple gas or blob configs found');
+        }
+        const gasConfig = gasConfigs[0]?.gasConfig;
+        const blobConfig = blobConfigs[0]?.blobConfig;
+        try {
+            this.log.debug('Forwarding transactions', {
+                validRequests: validRequests.map((request)=>request.action)
+            });
+            const result = await this.forwarderContract.forward(validRequests.map((request)=>request.request), this.l1TxUtils, gasConfig, blobConfig, this.log);
+            this.callbackBundledTransactions(validRequests, result);
+            return result;
+        } catch (err) {
+            const viemError = formatViemError(err);
+            this.log.error(`Failed to publish bundled transactions`, viemError);
+            return undefined;
+        } finally{
+            try {
+                this.metrics.recordSenderBalance(await this.l1TxUtils.getSenderBalance(), this.l1TxUtils.getSenderAddress());
+            } catch (err) {
+                this.log.warn(`Failed to record balance after sending tx: ${err}`);
+            }
+        }
+    }
+    callbackBundledTransactions(requests, result) {
+        const success = result?.receipt.status === 'success';
+        const logger = success ? this.log.info : this.log.error;
+        for (const request of requests){
+            logger(`Bundled [${request.action}] transaction [${success ? 'succeeded' : 'failed'}]`);
+            request.onResult?.(request.request, result);
+        }
+    }
+    /**
+   * @notice  Will call `canProposeAtNextEthBlock` to make sure that it is possible to propose
+   * @param tipArchive - The archive to check
+   * @returns The slot and block number if it is possible to propose, undefined otherwise
+   */ canProposeAtNextEthBlock(tipArchive) {
+        const ignoredErrors = [
+            'SlotAlreadyInChain',
+            'InvalidProposer',
+            'InvalidArchive'
+        ];
+        return this.rollupContract.canProposeAtNextEthBlock(tipArchive, this.getForwarderAddress().toString(), this.ethereumSlotDuration).catch((err)=>{
+            if (err instanceof FormattedViemError && ignoredErrors.find((e)=>err.message.includes(e))) {
+                this.log.debug(err.message);
+            } else {
+                this.log.error(err.name, err);
+            }
+            return undefined;
+        });
+    }
+    /**
+   * @notice  Will call `validateHeader` to make sure that it is possible to propose
+   *
+   * @dev     Throws if unable to propose
+   *
+   * @param header - The header to propose
+   * @param digest - The digest that attestations are signing over
+   *
+   */ async validateBlockForSubmission(header, attestationData = {
+        digest: Buffer.alloc(32),
+        signatures: []
+    }) {
+        const ts = BigInt((await this.l1TxUtils.getBlock()).timestamp + this.ethereumSlotDuration);
+        const formattedSignatures = attestationData.signatures.map((attest)=>attest.toViemSignature());
+        const flags = {
+            ignoreDA: true,
+            ignoreSignatures: formattedSignatures.length == 0
+        };
+        const args = [
+            `0x${header.toBuffer().toString('hex')}`,
+            formattedSignatures,
+            `0x${attestationData.digest.toString('hex')}`,
+            ts,
+            `0x${header.contentCommitment.blobsHash.toString('hex')}`,
+            flags
+        ];
+        await this.rollupContract.validateHeader(args, this.getForwarderAddress().toString());
+        return ts;
+    }
+    async getCurrentEpochCommittee() {
+        const committee = await this.rollupContract.getCurrentEpochCommittee();
+        return committee.map(EthAddress.fromString);
+    }
+    async enqueueCastVoteHelper(slotNumber, timestamp, voteType, payload, base) {
+        if (this.myLastVotes[voteType] >= slotNumber) {
+            return false;
+        }
+        if (payload.equals(EthAddress.ZERO)) {
+            return false;
+        }
+        const round = await base.computeRound(slotNumber);
+        const [proposer, roundInfo] = await Promise.all([
+            this.rollupContract.getProposerAt(timestamp),
+            base.getRoundInfo(this.rollupContract.address, round)
+        ]);
+        if (proposer.toLowerCase() !== this.getForwarderAddress().toString().toLowerCase()) {
+            return false;
+        }
+        if (roundInfo.lastVote >= slotNumber) {
+            return false;
+        }
+        const cachedLastVote = this.myLastVotes[voteType];
+        this.myLastVotes[voteType] = slotNumber;
+        this.addRequest({
+            action: voteType === 0 ? 'governance-vote' : 'slashing-vote',
+            request: base.createVoteRequest(payload.toString()),
+            lastValidL2Slot: slotNumber,
+            onResult: (_request, result)=>{
+                if (!result || result.receipt.status !== 'success') {
+                    this.myLastVotes[voteType] = cachedLastVote;
+                } else {
+                    this.log.info(`Cast [${voteType}] vote for slot ${slotNumber}`);
+                }
+            }
+        });
+        return true;
+    }
+    async getVoteConfig(slotNumber, voteType) {
+        if (voteType === 0) {
+            return {
+                payload: this.governancePayload,
+                base: this.govProposerContract
+            };
+        } else if (voteType === 1) {
+            if (!this.getSlashPayload) {
+                return undefined;
+            }
+            const slashPayload = await this.getSlashPayload(slotNumber);
+            if (!slashPayload) {
+                return undefined;
+            }
+            return {
+                payload: slashPayload,
+                base: this.slashingProposerContract
+            };
+        }
+        throw new Error('Unreachable: Invalid vote type');
+    }
+    /**
+   * Enqueues a castVote transaction to cast a vote for a given slot number.
+   * @param slotNumber - The slot number to cast a vote for.
+   * @param timestamp - The timestamp of the slot to cast a vote for.
+   * @param voteType - The type of vote to cast.
+   * @returns True if the vote was successfully enqueued, false otherwise.
+   */ async enqueueCastVote(slotNumber, timestamp, voteType) {
+        const voteConfig = await this.getVoteConfig(slotNumber, voteType);
+        if (!voteConfig) {
+            return false;
+        }
+        const { payload, base } = voteConfig;
+        return this.enqueueCastVoteHelper(slotNumber, timestamp, voteType, payload, base);
+    }
+    /**
+   * Proposes a L2 block on L1.
+   *
+   * @param block - L2 block to propose.
+   * @returns True if the tx has been enqueued, throws otherwise. See #9315
+   */ async enqueueProposeL2Block(block, attestations, txHashes, opts = {}) {
+        const consensusPayload = new ConsensusPayload(block.header, block.archive.root, txHashes ?? []);
+        const digest = await getHashedSignaturePayload(consensusPayload, SignatureDomainSeparator.blockAttestation);
+        const blobs = await Blob.getBlobs(block.body.toBlobFields());
+        const proposeTxArgs = {
+            header: block.header.toBuffer(),
+            archive: block.archive.root.toBuffer(),
+            blockHash: (await block.header.hash()).toBuffer(),
+            body: block.body.toBuffer(),
+            blobs,
+            attestations,
+            txHashes: txHashes ?? []
+        };
+        // @note  This will make sure that we are passing the checks for our header ASSUMING that the data is also made available
+        //        This means that we can avoid the simulation issues in later checks.
+        //        By simulation issue, I mean the fact that the block.timestamp is equal to the last block, not the next, which
+        //        make time consistency checks break.
+        const ts = await this.validateBlockForSubmission(block.header, {
+            digest: digest.toBuffer(),
+            signatures: attestations ?? []
+        });
+        this.log.debug(`Submitting propose transaction`);
+        await this.addProposeTx(block, proposeTxArgs, opts, ts);
+        return true;
+    }
+    /**
+   * Calling `interrupt` will cause any in progress call to `publishRollup` to return `false` asap.
+   * Be warned, the call may return false even if the tx subsequently gets successfully mined.
+   * In practice this shouldn't matter, as we'll only ever be calling `interrupt` when we know it's going to fail.
+   * A call to `restart` is required before you can continue publishing.
+   */ interrupt() {
+        this.interrupted = true;
+        this.l1TxUtils.interrupt();
+    }
+    /** Restarts the publisher after calling `interrupt`. */ restart() {
+        this.interrupted = false;
+        this.l1TxUtils.restart();
+    }
+    async prepareProposeTx(encodedData, timestamp) {
+        const kzg = Blob.getViemKzgInstance();
+        const blobInput = Blob.getEthBlobEvaluationInputs(encodedData.blobs);
+        this.log.debug('Validating blob input', {
+            blobInput
+        });
+        const blobEvaluationGas = await this.l1TxUtils.estimateGas(this.l1TxUtils.walletClient.account, {
+            to: this.rollupContract.address,
+            data: encodeFunctionData({
+                abi: RollupAbi,
+                functionName: 'validateBlobs',
+                args: [
+                    blobInput
+                ]
+            })
+        }, {}, {
+            blobs: encodedData.blobs.map((b)=>b.data),
+            kzg
+        }).catch((err)=>{
+            const { message, metaMessages } = formatViemError(err);
+            this.log.error(`Failed to validate blobs`, message, {
+                metaMessages
+            });
+            throw new Error('Failed to validate blobs');
+        });
+        const attestations = encodedData.attestations ? encodedData.attestations.map((attest)=>attest.toViemSignature()) : [];
+        const txHashes = encodedData.txHashes ? encodedData.txHashes.map((txHash)=>txHash.toString()) : [];
+        const args = [
+            {
+                header: `0x${encodedData.header.toString('hex')}`,
+                archive: `0x${encodedData.archive.toString('hex')}`,
+                oracleInput: {
+                    // We are currently not modifying these. See #9963
+                    feeAssetPriceModifier: 0n
+                },
+                blockHash: `0x${encodedData.blockHash.toString('hex')}`,
+                txHashes
+            },
+            attestations,
+            blobInput
+        ];
+        const rollupData = encodeFunctionData({
+            abi: RollupAbi,
+            functionName: 'propose',
+            args
+        });
+        const forwarderData = encodeFunctionData({
+            abi: ForwarderAbi,
+            functionName: 'forward',
+            args: [
+                [
+                    this.rollupContract.address
+                ],
+                [
+                    rollupData
+                ]
+            ]
+        });
+        const simulationResult = await this.l1TxUtils.simulateGasUsed({
+            to: this.getForwarderAddress().toString(),
+            data: forwarderData,
+            gas: SequencerPublisher.PROPOSE_GAS_GUESS
+        }, {
+            // @note we add 1n to the timestamp because geth implementation doesn't like simulation timestamp to be equal to the current block timestamp
+            time: timestamp + 1n,
+            // @note reth should have a 30m gas limit per block but throws errors that this tx is beyond limit
+            gasLimit: SequencerPublisher.PROPOSE_GAS_GUESS * 2n
+        }, [
+            {
+                address: this.rollupContract.address,
+                // @note we override checkBlob to false since blobs are not part simulate()
+                stateDiff: [
+                    {
+                        slot: toHex(RollupContract.checkBlobStorageSlot, true),
+                        value: toHex(0n, true)
+                    }
+                ]
+            }
+        ], {
+            // @note fallback gas estimate to use if the node doesn't support simulation API
+            fallbackGasEstimate: SequencerPublisher.PROPOSE_GAS_GUESS
+        }).catch((err)=>{
+            const { message, metaMessages } = formatViemError(err);
+            this.log.error(`Failed to simulate gas used`, message, {
+                metaMessages
+            });
+            throw new Error('Failed to simulate gas used');
+        });
+        return {
+            args,
+            blobEvaluationGas,
+            rollupData,
+            simulationResult
+        };
+    }
+    async addProposeTx(block, encodedData, opts = {}, timestamp) {
+        const timer = new Timer();
+        const kzg = Blob.getViemKzgInstance();
+        const { rollupData, simulationResult, blobEvaluationGas } = await this.prepareProposeTx(encodedData, timestamp);
+        const startBlock = await this.l1TxUtils.getBlockNumber();
+        const blockHash = await block.hash();
+        return this.addRequest({
+            action: 'propose',
+            request: {
+                to: this.rollupContract.address,
+                data: rollupData
+            },
+            lastValidL2Slot: block.header.globalVariables.slotNumber.toBigInt(),
+            gasConfig: {
+                ...opts,
+                gasLimit: this.l1TxUtils.bumpGasLimit(simulationResult + blobEvaluationGas)
+            },
+            blobConfig: {
+                blobs: encodedData.blobs.map((b)=>b.data),
+                kzg
+            },
+            onResult: (request, result)=>{
+                if (!result) {
+                    return;
+                }
+                const { receipt, stats, errorMsg } = result;
+                if (receipt.status === 'success') {
+                    const endBlock = receipt.blockNumber;
+                    const inclusionBlocks = Number(endBlock - startBlock);
+                    const publishStats = {
+                        gasPrice: receipt.effectiveGasPrice,
+                        gasUsed: receipt.gasUsed,
+                        blobGasUsed: receipt.blobGasUsed ?? 0n,
+                        blobDataGas: receipt.blobGasPrice ?? 0n,
+                        transactionHash: receipt.transactionHash,
+                        ...pick(stats, 'calldataGas', 'calldataSize', 'sender'),
+                        ...block.getStats(),
+                        eventName: 'rollup-published-to-l1',
+                        blobCount: encodedData.blobs.length,
+                        inclusionBlocks
+                    };
+                    this.log.verbose(`Published L2 block to L1 rollup contract`, {
+                        ...stats,
+                        ...block.getStats()
+                    });
+                    this.metrics.recordProcessBlockTx(timer.ms(), publishStats);
+                    // Send the blobs to the blob sink
+                    this.sendBlobsToBlobSink(receipt.blockHash, encodedData.blobs).catch((_err)=>{
+                        this.log.error('Failed to send blobs to blob sink');
+                    });
+                    return true;
+                } else {
+                    this.metrics.recordFailedTx('process');
+                    this.log.error(`Rollup process tx reverted. ${errorMsg ?? 'No error message'}`, undefined, {
+                        ...block.getStats(),
+                        txHash: receipt.transactionHash,
+                        blockHash,
+                        slotNumber: block.header.globalVariables.slotNumber.toBigInt()
+                    });
+                }
+            }
+        });
+    }
+    /**
+   * Send blobs to the blob sink
+   *
+   * If a blob sink url is configured, then we send blobs to the blob sink
+   * - for now we use the blockHash as the identifier for the blobs;
+   *   In the future this will move to be the beacon block id - which takes a bit more work
+   *   to calculate and will need to be mocked in e2e tests
+   */ sendBlobsToBlobSink(blockHash, blobs) {
+        return this.blobSinkClient.sendBlobsToBlobSink(blockHash, blobs);
+    }
+}

package/dest/sequencer/allowed.d.ts

@@ -0,0 +1,3 @@
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+export declare function getDefaultAllowedSetupFunctions(): Promise<AllowedElement[]>;
+//# sourceMappingURL=allowed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"allowed.d.ts","sourceRoot":"","sources":["../../src/sequencer/allowed.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAItE,wBAAsB,+BAA+B,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CA2BjF"}

package/dest/sequencer/allowed.js

@@ -0,0 +1,27 @@
+import { FPCContract } from '@aztec/noir-contracts.js/FPC';
+import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+let defaultAllowedSetupFunctions = undefined;
+export async function getDefaultAllowedSetupFunctions() {
+    if (defaultAllowedSetupFunctions === undefined) {
+        defaultAllowedSetupFunctions = [
+            // needed for authwit support
+            {
+                address: ProtocolContractAddress.AuthRegistry
+            },
+            // needed for claiming on the same tx as a spend
+            {
+                address: ProtocolContractAddress.FeeJuice
+            },
+            // needed for private transfers via FPC
+            {
+                classId: (await getContractClassFromArtifact(TokenContractArtifact)).id
+            },
+            {
+                classId: (await getContractClassFromArtifact(FPCContract.artifact)).id
+            }
+        ];
+    }
+    return defaultAllowedSetupFunctions;
+}

package/dest/sequencer/config.d.ts

@@ -0,0 +1,2 @@
+export { type SequencerConfig } from '@aztec/stdlib/config';
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/sequencer/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC"}

package/dest/sequencer/config.js

@@ -0,0 +1 @@
+export { };

package/dest/sequencer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './config.js';
+export * from './sequencer.js';
+export * from './allowed.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dest/sequencer/index.js

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

package/dest/sequencer/metrics.d.ts

@@ -0,0 +1,24 @@
+import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+import { type SequencerState, type SequencerStateCallback } from './utils.js';
+export declare class SequencerMetrics {
+    readonly tracer: Tracer;
+    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;
+    recordBuiltBlock(buildDurationMs: number, totalMana: number): void;
+    recordFailedBlock(): void;
+    recordNewBlock(blockNumber: number, txCount: number): void;
+    recordStateTransitionBufferMs(durationMs: number, state: SequencerState): void;
+    private setCurrentBlock;
+}
+//# sourceMappingURL=metrics.d.ts.map

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

@@ -0,0 +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"}

package/dest/sequencer/metrics.js

@@ -0,0 +1,102 @@
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+import { sequencerStateToNumber } from './utils.js';
+export class SequencerMetrics {
+    tracer;
+    blockCounter;
+    blockBuildDuration;
+    blockBuildManaPerSecond;
+    stateTransitionBufferDuration;
+    currentBlockNumber;
+    currentBlockSize;
+    blockBuilderInsertions;
+    timeToCollectAttestations;
+    constructor(client, getState, name = 'Sequencer'){
+        const 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, {
+            unit: 'ms',
+            description: 'Duration to build a block',
+            valueType: ValueType.INT
+        });
+        this.blockBuildManaPerSecond = 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, {
+            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'
+        });
+        currentState.addCallback((observer)=>{
+            observer.observe(sequencerStateToNumber(getState()));
+        });
+        this.currentBlockNumber = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_NUMBER, {
+            description: 'Current block number',
+            valueType: ValueType.INT
+        });
+        this.currentBlockSize = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_SIZE, {
+            description: 'Current block size',
+            valueType: ValueType.INT
+        });
+        this.timeToCollectAttestations = meter.createGauge(Metrics.SEQUENCER_TIME_TO_COLLECT_ATTESTATIONS, {
+            description: 'The time spent collecting attestations from committee members',
+            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',
+            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);
+    }
+    recordBlockBuilderTreeInsertions(timeUs) {
+        this.blockBuilderInsertions.record(Math.ceil(timeUs));
+    }
+    recordCancelledBlock() {
+        this.blockCounter.add(1, {
+            [Attributes.STATUS]: 'cancelled'
+        });
+        this.setCurrentBlock(0, 0);
+    }
+    recordBuiltBlock(buildDurationMs, totalMana) {
+        this.blockCounter.add(1, {
+            [Attributes.STATUS]: 'built'
+        });
+        this.blockBuildDuration.record(Math.ceil(buildDurationMs));
+        this.blockBuildManaPerSecond.record(Math.ceil(totalMana * 1000 / buildDurationMs));
+    }
+    recordFailedBlock() {
+        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);
+    }
+}