@aztec/sequencer-client 0.71.0 → 0.73.0

package/dest/publisher/sequencer-publisher.js

@@ -0,0 +1,555 @@
+var _a;
+import { createBlobSinkClient } from '@aztec/blob-sink/client';
+import { ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayload, } from '@aztec/circuit-types';
+import { EthAddress } from '@aztec/circuits.js';
+import { FormattedViemError, formatViemError, } from '@aztec/ethereum';
+import { toHex } from '@aztec/foundation/bigint-buffer';
+import { Blob } from '@aztec/foundation/blob';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { EmpireBaseAbi, ForwarderAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import pick from 'lodash.pick';
+import { encodeFunctionData, getAddress, getContract } from 'viem';
+import { SequencerPublisherMetrics } from './sequencer-publisher-metrics.js';
+export var VoteType;
+(function (VoteType) {
+    VoteType[VoteType["GOVERNANCE"] = 0] = "GOVERNANCE";
+    VoteType[VoteType["SLASHING"] = 1] = "SLASHING";
+})(VoteType || (VoteType = {}));
+export class SequencerPublisher {
+    constructor(config, deps) {
+        this.interrupted = false;
+        this.governanceLog = createLogger('sequencer:publisher:governance');
+        this.governancePayload = EthAddress.ZERO;
+        this.slashingLog = createLogger('sequencer:publisher:slashing');
+        this.getSlashPayload = undefined;
+        this.myLastVotes = {
+            [VoteType.GOVERNANCE]: 0n,
+            [VoteType.SLASHING]: 0n,
+        };
+        this.log = createLogger('sequencer:publisher');
+        this.requests = [];
+        this.ethereumSlotDuration = BigInt(config.ethereumSlotDuration);
+        this.epochCache = deps.epochCache;
+        if (config.l1Contracts.governanceProposerAddress) {
+            this.governanceProposerAddress = EthAddress.fromString(config.l1Contracts.governanceProposerAddress.toString());
+        }
+        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;
+    }
+    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.callbackBundledTransactions(validRequests, result);
+            return result;
+        }
+        catch (err) {
+            const { message, metaMessages } = formatViemError(err);
+            this.log.error(`Failed to publish bundled transactions`, message, { metaMessages });
+            return undefined;
+        }
+    }
+    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'];
+        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;
+        });
+    }
+    /**
+     * @returns The epoch that is currently claimable, undefined otherwise
+     */
+    getClaimableEpoch() {
+        const acceptedErrors = ['Rollup__NoEpochToProve', 'Rollup__ProofRightAlreadyClaimed'];
+        return this.rollupContract.getClaimableEpoch().catch(err => {
+            if (acceptedErrors.find(e => err.message.includes(e))) {
+                return undefined;
+            }
+            throw err;
+        });
+    }
+    /**
+     * @notice  Will filter out invalid quotes according to L1
+     * @param quotes - The quotes to filter
+     * @returns The filtered quotes
+     */
+    filterValidQuotes(quotes) {
+        return Promise.all(quotes.map(x => this.rollupContract
+            // validate throws if the quote is not valid
+            // else returns void
+            .validateProofQuote(x.toViemArgs(), this.getForwarderAddress().toString(), this.ethereumSlotDuration)
+            .then(() => x)
+            .catch(err => {
+            this.log.error(`Failed to validate proof quote`, err, { quote: x.toInspect() });
+            return undefined;
+        }))).then(quotes => quotes.filter((q) => !!q));
+    }
+    /**
+     * @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);
+    }
+    /**
+     * 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) {
+        // @todo This function can be optimized by doing some of the computations locally instead of calling the L1 contracts
+        if (this.myLastVotes[voteType] >= slotNumber) {
+            return false;
+        }
+        const voteConfig = async () => {
+            if (voteType === VoteType.GOVERNANCE) {
+                if (this.governancePayload.equals(EthAddress.ZERO)) {
+                    return undefined;
+                }
+                if (!this.governanceProposerAddress) {
+                    return undefined;
+                }
+                return {
+                    payload: this.governancePayload,
+                    voteContractAddress: this.governanceProposerAddress,
+                    logger: this.governanceLog,
+                };
+            }
+            else if (voteType === VoteType.SLASHING) {
+                if (!this.getSlashPayload) {
+                    return undefined;
+                }
+                const slashingProposerAddress = await this.rollupContract.getSlashingProposerAddress();
+                if (!slashingProposerAddress) {
+                    return undefined;
+                }
+                const slashPayload = await this.getSlashPayload(slotNumber);
+                if (!slashPayload) {
+                    return undefined;
+                }
+                return {
+                    payload: slashPayload,
+                    voteContractAddress: slashingProposerAddress,
+                    logger: this.slashingLog,
+                };
+            }
+            else {
+                throw new Error('Invalid vote type');
+            }
+        };
+        const vConfig = await voteConfig();
+        if (!vConfig) {
+            return false;
+        }
+        const { payload, voteContractAddress } = vConfig;
+        const voteContract = getContract({
+            address: getAddress(voteContractAddress.toString()),
+            abi: EmpireBaseAbi,
+            client: this.l1TxUtils.walletClient,
+        });
+        const [proposer, roundNumber] = await Promise.all([
+            this.rollupContract.getProposerAt(timestamp),
+            voteContract.read.computeRound([slotNumber]),
+        ]);
+        if (proposer.toLowerCase() !== this.getForwarderAddress().toString().toLowerCase()) {
+            return false;
+        }
+        const [slotForLastVote] = await voteContract.read.rounds([this.rollupContract.address, roundNumber]);
+        if (slotForLastVote >= slotNumber) {
+            return false;
+        }
+        const cachedLastVote = this.myLastVotes[voteType];
+        this.myLastVotes[voteType] = slotNumber;
+        this.addRequest({
+            action: voteType === VoteType.GOVERNANCE ? 'governance-vote' : 'slashing-vote',
+            request: {
+                to: voteContractAddress.toString(),
+                data: encodeFunctionData({
+                    abi: EmpireBaseAbi,
+                    functionName: 'vote',
+                    args: [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;
+    }
+    /**
+     * 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;
+    }
+    /** Enqueues a claimEpochProofRight transaction to submit a chosen prover quote for the previous epoch. */
+    enqueueClaimEpochProofRight(proofQuote) {
+        const timer = new Timer();
+        this.addRequest({
+            action: 'claim',
+            request: {
+                to: this.rollupContract.address,
+                data: encodeFunctionData({
+                    abi: RollupAbi,
+                    functionName: 'claimEpochProofRight',
+                    args: [proofQuote.toViemArgs()],
+                }),
+            },
+            lastValidL2Slot: this.getCurrentL2Slot(),
+            onResult: (_request, result) => {
+                if (!result) {
+                    return;
+                }
+                const { receipt, stats } = result;
+                if (receipt.status === 'success') {
+                    const publishStats = {
+                        gasPrice: receipt.effectiveGasPrice,
+                        gasUsed: receipt.gasUsed,
+                        transactionHash: receipt.transactionHash,
+                        blobDataGas: 0n,
+                        blobGasUsed: 0n,
+                        ...pick(stats, 'calldataGas', 'calldataSize', 'sender'),
+                    };
+                    this.log.verbose(`Submitted claim epoch proof right to L1 rollup contract`, {
+                        ...publishStats,
+                        ...proofQuote.toInspect(),
+                    });
+                    this.metrics.recordClaimEpochProofRightTx(timer.ms(), publishStats);
+                }
+                else {
+                    this.metrics.recordFailedTx('claimEpochProofRight');
+                    // TODO: Get the error message from the reverted tx
+                    this.log.error(`Claim epoch proof right tx reverted`, {
+                        txHash: receipt.transactionHash,
+                        ...proofQuote.toInspect(),
+                    });
+                }
+            },
+        });
+        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,
+                    provingCostModifier: 0n,
+                },
+                blockHash: `0x${encodedData.blockHash.toString('hex')}`,
+                txHashes,
+            },
+            attestations,
+            // TODO(#9101): Extract blobs from beacon chain => calldata will only contain what's needed to verify blob and body input can be removed
+            `0x${encodedData.body.toString('hex')}`,
+            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: _a.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: _a.PROPOSE_GAS_GUESS * 2n,
+        }, [
+            {
+                address: this.rollupContract.address,
+                // @note we override checkBlob to false since blobs are not part simulate()
+                stateDiff: [
+                    {
+                        slot: toHex(9n, true),
+                        value: toHex(0n, true),
+                    },
+                ],
+            },
+        ], {
+            // @note fallback gas estimate to use if the node doesn't support simulation API
+            fallbackGasEstimate: _a.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();
+        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: block.hash().toString(),
+                        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);
+    }
+}
+_a = SequencerPublisher;
+// @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)
+SequencerPublisher.PROPOSE_GAS_GUESS = 12000000n;
+SequencerPublisher.PROPOSE_AND_CLAIM_GAS_GUESS = _a.PROPOSE_GAS_GUESS + 100000n;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sequencer-publisher.js","sourceRoot":"","sources":["../../src/publisher/sequencer-publisher.ts"],"names":[],"mappings":"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"}

package/dest/sequencer/allowed.d.ts

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

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

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

package/dest/sequencer/allowed.js

@@ -3,7 +3,7 @@ import { FPCContract } from '@aztec/noir-contracts.js/FPC';
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 let defaultAllowedSetupFunctions = undefined;
-export function getDefaultAllowedSetupFunctions() {
+export async function getDefaultAllowedSetupFunctions() {
     if (defaultAllowedSetupFunctions === undefined) {
         defaultAllowedSetupFunctions = [
             // needed for authwit support
@@ -14,16 +14,16 @@ export function getDefaultAllowedSetupFunctions() {
             {
                 address: ProtocolContractAddress.FeeJuice,
                 // We can't restrict the selector because public functions get routed via dispatch.
-                // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
+                // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),(Field,Field))'),
             },
             // needed for private transfers via FPC
             {
-                classId: getContractClassFromArtifact(TokenContractArtifact).id,
+                classId: (await getContractClassFromArtifact(TokenContractArtifact)).id,
                 // We can't restrict the selector because public functions get routed via dispatch.
-                // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),Field)'),
+                // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),(Field,Field))'),
             },
             {
-                classId: getContractClassFromArtifact(FPCContract.artifact).id,
+                classId: (await getContractClassFromArtifact(FPCContract.artifact)).id,
                 // We can't restrict the selector because public functions get routed via dispatch.
                 // selector: FunctionSelector.fromSignature('prepare_fee((Field),Field,(Field),Field)'),
             },
@@ -31,4 +31,4 @@ export function getDefaultAllowedSetupFunctions() {
     }
     return defaultAllowedSetupFunctions;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsb3dlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXF1ZW5jZXIvYWxsb3dlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0QsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDdkUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFcEUsSUFBSSw0QkFBNEIsR0FBaUMsU0FBUyxDQUFDO0FBRTNFLE1BQU0sVUFBVSwrQkFBK0I7SUFDN0MsSUFBSSw0QkFBNEIsS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUMvQyw0QkFBNEIsR0FBRztZQUM3Qiw2QkFBNkI7WUFDN0I7Z0JBQ0UsT0FBTyxFQUFFLHVCQUF1QixDQUFDLFlBQVk7YUFDOUM7WUFDRCxnREFBZ0Q7WUFDaEQ7Z0JBQ0UsT0FBTyxFQUFFLHVCQUF1QixDQUFDLFFBQVE7Z0JBQ3pDLG1GQUFtRjtnQkFDbkYsdUZBQXVGO2FBQ3hGO1lBQ0QsdUNBQXVDO1lBQ3ZDO2dCQUNFLE9BQU8sRUFBRSw0QkFBNEIsQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDLEVBQUU7Z0JBQy9ELG1GQUFtRjtnQkFDbkYsdUZBQXVGO2FBQ3hGO1lBQ0Q7Z0JBQ0UsT0FBTyxFQUFFLDRCQUE0QixDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsQ0FBQyxFQUFFO2dCQUM5RCxtRkFBbUY7Z0JBQ25GLHdGQUF3RjthQUN6RjtTQUNGLENBQUM7SUFDSixDQUFDO0lBQ0QsT0FBTyw0QkFBNEIsQ0FBQztBQUN0QyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsb3dlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXF1ZW5jZXIvYWxsb3dlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0QsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDdkUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFcEUsSUFBSSw0QkFBNEIsR0FBaUMsU0FBUyxDQUFDO0FBRTNFLE1BQU0sQ0FBQyxLQUFLLFVBQVUsK0JBQStCO0lBQ25ELElBQUksNEJBQTRCLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDL0MsNEJBQTRCLEdBQUc7WUFDN0IsNkJBQTZCO1lBQzdCO2dCQUNFLE9BQU8sRUFBRSx1QkFBdUIsQ0FBQyxZQUFZO2FBQzlDO1lBQ0QsZ0RBQWdEO1lBQ2hEO2dCQUNFLE9BQU8sRUFBRSx1QkFBdUIsQ0FBQyxRQUFRO2dCQUN6QyxtRkFBbUY7Z0JBQ25GLCtGQUErRjthQUNoRztZQUNELHVDQUF1QztZQUN2QztnQkFDRSxPQUFPLEVBQUUsQ0FBQyxNQUFNLDRCQUE0QixDQUFDLHFCQUFxQixDQUFDLENBQUMsQ0FBQyxFQUFFO2dCQUN2RSxtRkFBbUY7Z0JBQ25GLCtGQUErRjthQUNoRztZQUNEO2dCQUNFLE9BQU8sRUFBRSxDQUFDLE1BQU0sNEJBQTRCLENBQUMsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsRUFBRTtnQkFDdEUsbUZBQW1GO2dCQUNuRix3RkFBd0Y7YUFDekY7U0FDRixDQUFDO0lBQ0osQ0FBQztJQUNELE9BQU8sNEJBQTRCLENBQUM7QUFDdEMsQ0FBQyJ9

package/dest/sequencer/metrics.d.ts

@@ -15,7 +15,7 @@ export declare class SequencerMetrics {
     recordTimeToCollectAttestations(time: number): void;
     recordBlockBuilderTreeInsertions(timeUs: number): void;
     recordCancelledBlock(): void;
-    recordPublishedBlock(buildDurationMs: number, totalMana: number): void;
+    recordBuiltBlock(buildDurationMs: number, totalMana: number): void;
     recordFailedBlock(): void;
     recordNewBlock(blockNumber: number, txCount: number): void;
     recordStateTransitionBufferMs(durationMs: number, state: SequencerState): void;