@aztec-labs/sequencer-client 6.0.0-nightly.20260829

package/dest/config.d.ts

@@ -0,0 +1,56 @@
+import { type L1ContractsConfig } from '@aztec-labs/ethereum/config';
+import { type L1ReaderConfig } from '@aztec-labs/ethereum/l1-reader';
+import { type ConfigMappingsType } from '@aztec-labs/foundation/config';
+import { type KeyStoreConfig } from '@aztec-labs/node-keystore/config';
+import { type P2PConfig } from '@aztec-labs/p2p/config';
+import { type ChainConfig, type SequencerConfig } from '@aztec-labs/stdlib/config';
+import { type ValidatorClientConfig } from '@aztec-labs/validator-client/config';
+import { type SequencerPublisherConfig, type SequencerTxSenderConfig } from './publisher/config.js';
+export * from './publisher/config.js';
+export type { SequencerConfig };
+/**
+ * Default values for SequencerConfig.
+ * Centralized location for all sequencer configuration defaults.
+ */
+export declare const DefaultSequencerConfig: {
+    sequencerPollingIntervalMS: number;
+    minTxsPerBlock: number;
+    buildCheckpointIfEmpty: false;
+    publishTxsWithProposals: false;
+    perBlockAllocationMultiplier: number;
+    perBlockDAAllocationMultiplier: number;
+    redistributeCheckpointBudget: true;
+    blockDurationMs: number;
+    l1PublishingTime: number;
+    checkpointProposalSyncGraceSeconds: number;
+    attestationPropagationTime: number;
+    secondsBeforeInvalidatingBlockAsCommitteeMember: number;
+    secondsBeforeInvalidatingBlockAsNonCommitteeMember: number;
+    skipCollectingAttestations: false;
+    skipInvalidateBlockAsProposer: false;
+    skipWaitForValidParentCheckpointOnL1: false;
+    broadcastInvalidBlockProposal: false;
+    broadcastInvalidCheckpointProposalOnly: false;
+    injectFakeAttestation: false;
+    injectHighSValueAttestation: false;
+    injectUnrecoverableSignatureAttestation: false;
+    injectYParityAttestation: false;
+    fishermanMode: false;
+    governanceProposerForcePayloadVote: false;
+    shuffleAttestationOrdering: false;
+    skipPushProposedBlocksToArchiver: false;
+    skipPublishingCheckpointsPercent: number;
+    maxBlocksPerCheckpoint: number;
+    minPeersToPropose: number;
+};
+/**
+ * Configuration settings for the SequencerClient.
+ */
+export type SequencerClientConfig = SequencerPublisherConfig & KeyStoreConfig & ValidatorClientConfig & SequencerTxSenderConfig & SequencerConfig & L1ReaderConfig & ChainConfig & Pick<P2PConfig, 'txPublicSetupAllowListExtend'> & Pick<L1ContractsConfig, 'ethereumSlotDuration' | 'aztecSlotDuration' | 'aztecEpochDuration'>;
+export declare const sequencerConfigMappings: ConfigMappingsType<SequencerConfig>;
+export declare const sequencerClientConfigMappings: ConfigMappingsType<SequencerClientConfig>;
+/**
+ * Creates an instance of SequencerClientConfig out of environment variables using sensible defaults for integration testing if not set.
+ */
+export declare function getConfigEnvVars(): SequencerClientConfig;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUE2QixNQUFNLDZCQUE2QixDQUFDO0FBQ2hHLE9BQU8sRUFBRSxLQUFLLGNBQWMsRUFBMEIsTUFBTSxnQ0FBZ0MsQ0FBQztBQUM3RixPQUFPLEVBQ0wsS0FBSyxrQkFBa0IsRUFPeEIsTUFBTSwrQkFBK0IsQ0FBQztBQUV2QyxPQUFPLEVBQUUsS0FBSyxjQUFjLEVBQTBCLE1BQU0sa0NBQWtDLENBQUM7QUFDL0YsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFxQixNQUFNLHdCQUF3QixDQUFDO0FBRTNFLE9BQU8sRUFDTCxLQUFLLFdBQVcsRUFHaEIsS0FBSyxlQUFlLEVBR3JCLE1BQU0sMkJBQTJCLENBQUM7QUFJbkMsT0FBTyxFQUFFLEtBQUsscUJBQXFCLEVBQWlDLE1BQU0scUNBQXFDLENBQUM7QUFFaEgsT0FBTyxFQUNMLEtBQUssd0JBQXdCLEVBQzdCLEtBQUssdUJBQXVCLEVBRzdCLE1BQU0sdUJBQXVCLENBQUM7QUFFL0IsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxZQUFZLEVBQUUsZUFBZSxFQUFFLENBQUM7QUFFaEM7OztHQUdHO0FBQ0gsZUFBTyxNQUFNLHNCQUFzQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBOEJBLENBQUM7QUFFcEM7O0dBRUc7QUFDSCxNQUFNLE1BQU0scUJBQXFCLEdBQUcsd0JBQXdCLEdBQzFELGNBQWMsR0FDZCxxQkFBcUIsR0FDckIsdUJBQXVCLEdBQ3ZCLGVBQWUsR0FDZixjQUFjLEdBQ2QsV0FBVyxHQUNYLElBQUksQ0FBQyxTQUFTLEVBQUUsOEJBQThCLENBQUMsR0FDL0MsSUFBSSxDQUFDLGlCQUFpQixFQUFFLHNCQUFzQixHQUFHLG1CQUFtQixHQUFHLG9CQUFvQixDQUFDLENBQUM7QUFFL0YsZUFBTyxNQUFNLHVCQUF1QixFQUFFLGtCQUFrQixDQUFDLGVBQWUsQ0EyTXZFLENBQUM7QUFFRixlQUFPLE1BQU0sNkJBQTZCLEVBQUUsa0JBQWtCLENBQUMscUJBQXFCLENBU25GLENBQUM7QUFFRjs7R0FFRztBQUNILHdCQUFnQixnQkFBZ0IsSUFBSSxxQkFBcUIsQ0FFeEQifQ==

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAA6B,MAAM,6BAA6B,CAAC;AAChG,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,gCAAgC,CAAC;AAC7F,OAAO,EACL,KAAK,kBAAkB,EAOxB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,kCAAkC,CAAC;AAC/F,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,wBAAwB,CAAC;AAE3E,OAAO,EACL,KAAK,WAAW,EAGhB,KAAK,eAAe,EAGrB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAAE,KAAK,qBAAqB,EAAiC,MAAM,qCAAqC,CAAC;AAEhH,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAG7B,MAAM,uBAAuB,CAAC;AAE/B,cAAc,uBAAuB,CAAC;AACtC,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BA,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,GAC1D,cAAc,GACd,qBAAqB,GACrB,uBAAuB,GACvB,eAAe,GACf,cAAc,GACd,WAAW,GACX,IAAI,CAAC,SAAS,EAAE,8BAA8B,CAAC,GAC/C,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,GAAG,mBAAmB,GAAG,oBAAoB,CAAC,CAAC;AAE/F,eAAO,MAAM,uBAAuB,EAAE,kBAAkB,CAAC,eAAe,CA2MvE,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,qBAAqB,CASnF,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD"}

package/dest/config.js

@@ -0,0 +1,251 @@
+import { l1ContractsConfigMappings } from '@aztec-labs/ethereum/config';
+import { l1ReaderConfigMappings } from '@aztec-labs/ethereum/l1-reader';
+import { booleanConfigHelper, floatConfigHelper, getConfigFromMappings, numberConfigHelper, optionalNumberConfigHelper, pickConfigMappings } from '@aztec-labs/foundation/config';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { keyStoreConfigMappings } from '@aztec-labs/node-keystore/config';
+import { p2pConfigMappings } from '@aztec-labs/p2p/config';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { DEFAULT_BLOCK_DURATION_MS, DEFAULT_MAX_BLOCKS_PER_CHECKPOINT, chainConfigMappings, sharedSequencerConfigMappings } from '@aztec-labs/stdlib/config';
+import { MIN_PER_BLOCK_ALLOCATION_MULTIPLIER, MIN_PER_BLOCK_DA_ALLOCATION_MULTIPLIER } from '@aztec-labs/stdlib/gas';
+import { DEFAULT_P2P_PROPAGATION_TIME } from '@aztec-labs/stdlib/timetable';
+import { validatorClientConfigMappings } from '@aztec-labs/validator-client/config';
+import { sequencerPublisherConfigMappings, sequencerTxSenderConfigMappings } from './publisher/config.js';
+export * from './publisher/config.js';
+/**
+ * Default values for SequencerConfig.
+ * Centralized location for all sequencer configuration defaults.
+ */ export const DefaultSequencerConfig = {
+    sequencerPollingIntervalMS: 500,
+    minTxsPerBlock: 1,
+    buildCheckpointIfEmpty: false,
+    publishTxsWithProposals: false,
+    perBlockAllocationMultiplier: MIN_PER_BLOCK_ALLOCATION_MULTIPLIER,
+    perBlockDAAllocationMultiplier: MIN_PER_BLOCK_DA_ALLOCATION_MULTIPLIER,
+    redistributeCheckpointBudget: true,
+    blockDurationMs: DEFAULT_BLOCK_DURATION_MS,
+    l1PublishingTime: 12,
+    checkpointProposalSyncGraceSeconds: 2 * (DEFAULT_BLOCK_DURATION_MS / 1000),
+    attestationPropagationTime: DEFAULT_P2P_PROPAGATION_TIME,
+    secondsBeforeInvalidatingBlockAsCommitteeMember: 144,
+    secondsBeforeInvalidatingBlockAsNonCommitteeMember: 432,
+    skipCollectingAttestations: false,
+    skipInvalidateBlockAsProposer: false,
+    skipWaitForValidParentCheckpointOnL1: false,
+    broadcastInvalidBlockProposal: false,
+    broadcastInvalidCheckpointProposalOnly: false,
+    injectFakeAttestation: false,
+    injectHighSValueAttestation: false,
+    injectUnrecoverableSignatureAttestation: false,
+    injectYParityAttestation: false,
+    fishermanMode: false,
+    governanceProposerForcePayloadVote: false,
+    shuffleAttestationOrdering: false,
+    skipPushProposedBlocksToArchiver: false,
+    skipPublishingCheckpointsPercent: 0,
+    maxBlocksPerCheckpoint: DEFAULT_MAX_BLOCKS_PER_CHECKPOINT,
+    minPeersToPropose: 1
+};
+export const sequencerConfigMappings = {
+    sequencerPollingIntervalMS: {
+        env: 'SEQ_POLLING_INTERVAL_MS',
+        description: 'The number of ms to wait between polling for checking to build on the next slot.',
+        ...numberConfigHelper(DefaultSequencerConfig.sequencerPollingIntervalMS)
+    },
+    maxTxsPerCheckpoint: {
+        env: 'SEQ_MAX_TX_PER_CHECKPOINT',
+        description: 'The maximum number of txs across all blocks in a checkpoint.',
+        ...optionalNumberConfigHelper()
+    },
+    minTxsPerBlock: {
+        env: 'SEQ_MIN_TX_PER_BLOCK',
+        description: 'The minimum number of txs to include in a block.',
+        ...numberConfigHelper(DefaultSequencerConfig.minTxsPerBlock)
+    },
+    minValidTxsPerBlock: {
+        description: 'The minimum number of valid txs (after execution) to include in a block. If not set, falls back to minTxsPerBlock.'
+    },
+    publishTxsWithProposals: {
+        env: 'SEQ_PUBLISH_TXS_WITH_PROPOSALS',
+        description: 'Whether to publish txs with proposals.',
+        ...booleanConfigHelper(DefaultSequencerConfig.publishTxsWithProposals)
+    },
+    maxL2BlockGas: {
+        env: 'SEQ_MAX_L2_BLOCK_GAS',
+        description: 'The maximum L2 block gas.',
+        ...optionalNumberConfigHelper()
+    },
+    maxDABlockGas: {
+        env: 'SEQ_MAX_DA_BLOCK_GAS',
+        description: 'The maximum DA block gas.',
+        ...optionalNumberConfigHelper()
+    },
+    perBlockAllocationMultiplier: {
+        env: 'SEQ_PER_BLOCK_ALLOCATION_MULTIPLIER',
+        description: 'Per-block gas budget multiplier for both L2 and DA gas. Budget per block is (checkpointLimit / maxBlocks) * multiplier.' + ' Values greater than one allow early blocks to use more than their even share, relying on checkpoint-level capping for later blocks.',
+        ...floatConfigHelper(DefaultSequencerConfig.perBlockAllocationMultiplier)
+    },
+    perBlockDAAllocationMultiplier: {
+        env: 'SEQ_PER_BLOCK_DA_ALLOCATION_MULTIPLIER',
+        description: 'Per-block budget multiplier applied to DA gas and blob fields in place of perBlockAllocationMultiplier.' + ' Defaults higher than the general multiplier so the largest contract class deploy fits a single block.',
+        ...floatConfigHelper(DefaultSequencerConfig.perBlockDAAllocationMultiplier)
+    },
+    redistributeCheckpointBudget: {
+        env: 'SEQ_REDISTRIBUTE_CHECKPOINT_BUDGET',
+        description: 'Redistribute remaining checkpoint budget evenly across remaining blocks instead of allowing a single block to consume the entire remaining budget.',
+        ...booleanConfigHelper(DefaultSequencerConfig.redistributeCheckpointBudget)
+    },
+    coinbase: {
+        env: 'COINBASE',
+        parseEnv: (val)=>EthAddress.fromString(val),
+        description: 'Recipient of block reward.'
+    },
+    feeRecipient: {
+        env: 'FEE_RECIPIENT',
+        parseEnv: (val)=>AztecAddress.fromStringUnsafe(val),
+        description: 'Address to receive fees.'
+    },
+    acvmWorkingDirectory: {
+        env: 'ACVM_WORKING_DIRECTORY',
+        description: 'The working directory to use for simulation/proving'
+    },
+    acvmBinaryPath: {
+        env: 'ACVM_BINARY_PATH',
+        description: 'The path to the ACVM binary'
+    },
+    governanceProposerPayload: {
+        env: 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS',
+        description: 'The address of the payload for the governanceProposer',
+        parseEnv: (val)=>EthAddress.fromString(val)
+    },
+    governanceProposerForcePayloadVote: {
+        env: 'GOVERNANCE_PROPOSER_FORCE_PAYLOAD_VOTE',
+        description: 'Keep signalling the configured governance payload even if a proposal referencing it was already executed.',
+        ...booleanConfigHelper(DefaultSequencerConfig.governanceProposerForcePayloadVote)
+    },
+    l1PublishingTime: {
+        env: 'SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT',
+        description: 'How much time in seconds to allow in the slot for publishing the L1 transaction.',
+        ...numberConfigHelper(DefaultSequencerConfig.l1PublishingTime)
+    },
+    fakeProcessingDelayPerTxMs: {
+        description: 'Used for testing to introduce a fake delay after processing each tx'
+    },
+    fakeThrowAfterProcessingTxCount: {
+        description: 'Used for testing to throw an error after processing N txs'
+    },
+    secondsBeforeInvalidatingBlockAsCommitteeMember: {
+        env: 'SEQ_SECONDS_BEFORE_INVALIDATING_BLOCK_AS_COMMITTEE_MEMBER',
+        description: 'How many seconds to wait before trying to invalidate a block from the pending chain as a committee member (zero to never invalidate).' + ' The next proposer is expected to invalidate, so the committee acts as a fallback.',
+        ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsCommitteeMember)
+    },
+    secondsBeforeInvalidatingBlockAsNonCommitteeMember: {
+        env: 'SEQ_SECONDS_BEFORE_INVALIDATING_BLOCK_AS_NON_COMMITTEE_MEMBER',
+        description: 'How many seconds to wait before trying to invalidate a block from the pending chain as a non-committee member (zero to never invalidate).' + ' The next proposer is expected to invalidate, then the committee, so other sequencers act as a fallback.',
+        ...numberConfigHelper(DefaultSequencerConfig.secondsBeforeInvalidatingBlockAsNonCommitteeMember)
+    },
+    skipCollectingAttestations: {
+        description: 'Whether to skip collecting attestations from validators and only use self-attestations (for testing only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.skipCollectingAttestations)
+    },
+    skipInvalidateBlockAsProposer: {
+        description: 'Do not invalidate the previous block if invalid when we are the proposer (for testing only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.skipInvalidateBlockAsProposer)
+    },
+    skipWaitForValidParentCheckpointOnL1: {
+        description: 'Bypass the parent checkpoint validity check before submitting a pipelined checkpoint, ' + 'allowing the proposer to publish even when the parent landed on L1 with invalid attestations (for testing only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.skipWaitForValidParentCheckpointOnL1)
+    },
+    broadcastInvalidBlockProposal: {
+        description: 'Broadcast invalid block proposals with corrupted state (for testing only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.broadcastInvalidBlockProposal)
+    },
+    invalidBlockProposalIndexWithinCheckpoint: {
+        description: 'Broadcast an invalid block proposal only at this indexWithinCheckpoint (for testing only)',
+        ...optionalNumberConfigHelper()
+    },
+    broadcastInvalidCheckpointProposalOnly: {
+        description: 'Broadcast invalid checkpoint proposals while keeping the underlying block proposals valid (for testing only). When unset, the checkpoint follows broadcastInvalidBlockProposal.',
+        ...booleanConfigHelper(DefaultSequencerConfig.broadcastInvalidCheckpointProposalOnly)
+    },
+    injectFakeAttestation: {
+        description: 'Inject a fake attestation (for testing only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.injectFakeAttestation)
+    },
+    injectHighSValueAttestation: {
+        description: 'Inject a malleable attestation with a high-s value (for testing only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.injectHighSValueAttestation)
+    },
+    injectUnrecoverableSignatureAttestation: {
+        description: 'Inject an attestation with an unrecoverable signature (for testing only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.injectUnrecoverableSignatureAttestation)
+    },
+    injectYParityAttestation: {
+        description: 'Inject a non-proposer attestation slot in yParity form in the packed L1 tuple (for testing only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.injectYParityAttestation)
+    },
+    fishermanMode: {
+        env: 'FISHERMAN_MODE',
+        description: 'Whether to run in fisherman mode: builds blocks on every slot for validation without publishing to L1',
+        ...booleanConfigHelper(DefaultSequencerConfig.fishermanMode)
+    },
+    shuffleAttestationOrdering: {
+        description: 'Shuffle attestation ordering to create invalid ordering (for testing only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.shuffleAttestationOrdering)
+    },
+    ...sharedSequencerConfigMappings,
+    buildCheckpointIfEmpty: {
+        env: 'SEQ_BUILD_CHECKPOINT_IF_EMPTY',
+        description: 'Have sequencer build and publish an empty checkpoint if there are no txs',
+        ...booleanConfigHelper(DefaultSequencerConfig.buildCheckpointIfEmpty)
+    },
+    skipPushProposedBlocksToArchiver: {
+        description: 'Skip pushing proposed blocks to archiver (test only)',
+        ...booleanConfigHelper(DefaultSequencerConfig.skipPushProposedBlocksToArchiver)
+    },
+    minBlocksForCheckpoint: {
+        description: 'Minimum number of blocks required for a checkpoint proposal (test only)'
+    },
+    skipPublishingCheckpointsPercent: {
+        env: 'SEQ_SKIP_CHECKPOINT_PUBLISH_PERCENT',
+        description: 'Percent probability (0 - 100) of sequencer skipping checkpoint publishing (testing only)',
+        ...numberConfigHelper(DefaultSequencerConfig.skipPublishingCheckpointsPercent)
+    },
+    skipBroadcastProposals: {
+        description: 'Skip broadcasting checkpoint and block proposals via gossipsub when proposer (for testing only)',
+        ...booleanConfigHelper(false)
+    },
+    skipBroadcastCheckpointProposal: {
+        description: 'Skip broadcasting only the CheckpointProposal via gossipsub when proposer; the held last block is broadcast ' + 'standalone instead so peers still receive it as a proposed-but-uncheckpointed tip (for testing only)',
+        ...booleanConfigHelper(false)
+    },
+    pauseProposingForSlots: {
+        description: 'List of slots for which the sequencer will not produce a proposal (for testing only). Attestation paths are unaffected.'
+    },
+    minPeersToPropose: {
+        env: 'SEQ_MIN_PEERS_TO_PROPOSE',
+        description: 'Minimum number of connected p2p peers required to build and propose a checkpoint (zero to disable the check).' + ' Ignored when p2p is disabled by config.',
+        ...numberConfigHelper(DefaultSequencerConfig.minPeersToPropose)
+    },
+    ...pickConfigMappings(p2pConfigMappings, [
+        'txPublicSetupAllowListExtend'
+    ])
+};
+export const sequencerClientConfigMappings = {
+    ...chainConfigMappings,
+    ...validatorClientConfigMappings,
+    ...sequencerConfigMappings,
+    ...keyStoreConfigMappings,
+    ...l1ReaderConfigMappings,
+    ...sequencerTxSenderConfigMappings,
+    ...sequencerPublisherConfigMappings,
+    ...pickConfigMappings(l1ContractsConfigMappings, [
+        'ethereumSlotDuration',
+        'aztecSlotDuration',
+        'aztecEpochDuration'
+    ])
+};
+/**
+ * Creates an instance of SequencerClientConfig out of environment variables using sensible defaults for integration testing if not set.
+ */ export function getConfigEnvVars() {
+    return getConfigFromMappings(sequencerClientConfigMappings);
+}

package/dest/global_variable_builder/fee_predictor.d.ts

@@ -0,0 +1,49 @@
+import { type L1FeeData, type RollupContract } from '@aztec-labs/ethereum/contracts';
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import { GasFees, ManaUsageEstimate } from '@aztec-labs/stdlib/gas';
+/** Cached rollup state for fee prediction. Refreshed once per L1 block. */
+type FeeOracleState = {
+    lastSlot: SlotNumber;
+    excessMana: bigint;
+    ethPerFeeAsset: bigint;
+    manaTarget: bigint;
+    manaLimit: bigint;
+    provingCostPerManaEth: bigint;
+    epochDuration: bigint;
+    /** Pre-resolved L1 fees for each slot in the prediction window. */
+    l1FeesBySlot: L1FeeData[];
+};
+/**
+ * Predicts min fees for LAG upcoming slots based on the L1 oracle state.
+ * A new oracle update can activate at startSlot + LAG, so only the first LAG entries
+ * are guaranteed stable.
+ */
+export declare class FeePredictor {
+    private readonly rollupContract;
+    private readonly dateProvider;
+    private cachedState;
+    private readonly slotDuration;
+    private readonly l1GenesisTime;
+    private readonly ethereumSlotDuration;
+    constructor(rollupContract: RollupContract, dateProvider: DateProvider, config: {
+        slotDuration: number;
+        l1GenesisTime: bigint;
+        ethereumSlotDuration: number;
+    });
+    /** Returns predicted min fees for each slot in the prediction window, from the cached state. */
+    getPredictedMinFees(manaUsage: ManaUsageEstimate): GasFees[];
+    /** Returns whatever rollup state is currently cached, or undefined if refreshState() has never been called. */
+    getState(): FeeOracleState | undefined;
+    /**
+     * Fetches and caches rollup state for the given L1 block.
+     */
+    refreshState(blockNumber: bigint): Promise<FeeOracleState>;
+    private fetchState;
+    /** Computes per-slot fee predictions given cached state and a mana usage assumption. */
+    private computePredictions;
+    private getAssumedManaUsed;
+    private computeGasFees;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlX3ByZWRpY3Rvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2dsb2JhbF92YXJpYWJsZV9idWlsZGVyL2ZlZV9wcmVkaWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFvQyxLQUFLLGNBQWMsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3ZILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUVsRSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUVqRSxPQUFPLEVBRUwsT0FBTyxFQUVQLGlCQUFpQixFQUdsQixNQUFNLHdCQUF3QixDQUFDO0FBRWhDLDJFQUEyRTtBQUMzRSxLQUFLLGNBQWMsR0FBRztJQUNwQixRQUFRLEVBQUUsVUFBVSxDQUFDO0lBQ3JCLFVBQVUsRUFBRSxNQUFNLENBQUM7SUFDbkIsY0FBYyxFQUFFLE1BQU0sQ0FBQztJQUN2QixVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25CLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIscUJBQXFCLEVBQUUsTUFBTSxDQUFDO0lBQzlCLGFBQWEsRUFBRSxNQUFNLENBQUM7SUFDdEIsbUVBQW1FO0lBQ25FLFlBQVksRUFBRSxTQUFTLEVBQUUsQ0FBQztDQUMzQixDQUFDO0FBRUY7Ozs7R0FJRztBQUNILHFCQUFhLFlBQVk7SUFRckIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxjQUFjO0lBQy9CLE9BQU8sQ0FBQyxRQUFRLENBQUMsWUFBWTtJQVIvQixPQUFPLENBQUMsV0FBVyxDQUE2QjtJQUVoRCxPQUFPLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBUztJQUN0QyxPQUFPLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FBUztJQUN2QyxPQUFPLENBQUMsUUFBUSxDQUFDLG9CQUFvQixDQUFTO0lBRTlDLFlBQ21CLGNBQWMsRUFBRSxjQUFjLEVBQzlCLFlBQVksRUFBRSxZQUFZLEVBQzNDLE1BQU0sRUFBRTtRQUFFLFlBQVksRUFBRSxNQUFNLENBQUM7UUFBQyxhQUFhLEVBQUUsTUFBTSxDQUFDO1FBQUMsb0JBQW9CLEVBQUUsTUFBTSxDQUFBO0tBQUUsRUFLdEY7SUFFRCxnR0FBZ0c7SUFDaEcsbUJBQW1CLENBQUMsU0FBUyxFQUFFLGlCQUFpQixHQUFHLE9BQU8sRUFBRSxDQU0zRDtJQUVELCtHQUErRztJQUMvRyxRQUFRLElBQUksY0FBYyxHQUFHLFNBQVMsQ0FFckM7SUFFRDs7T0FFRztJQUNHLFlBQVksQ0FBQyxXQUFXLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FJL0Q7WUFFYSxVQUFVO0lBaUR4Qix3RkFBd0Y7SUFDeEYsT0FBTyxDQUFDLGtCQUFrQjtJQXVCMUIsT0FBTyxDQUFDLGtCQUFrQjtJQVcxQixPQUFPLENBQUMsY0FBYztDQW1CdkIifQ==

package/dest/global_variable_builder/fee_predictor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fee_predictor.d.ts","sourceRoot":"","sources":["../../src/global_variable_builder/fee_predictor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAoC,KAAK,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACvH,OAAO,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EAEL,OAAO,EAEP,iBAAiB,EAGlB,MAAM,wBAAwB,CAAC;AAEhC,2EAA2E;AAC3E,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE,UAAU,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,YAAY,EAAE,SAAS,EAAE,CAAC;CAC3B,CAAC;AAEF;;;;GAIG;AACH,qBAAa,YAAY;IAQrB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAR/B,OAAO,CAAC,WAAW,CAA6B;IAEhD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAE9C,YACmB,cAAc,EAAE,cAAc,EAC9B,YAAY,EAAE,YAAY,EAC3C,MAAM,EAAE;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAA;KAAE,EAKtF;IAED,gGAAgG;IAChG,mBAAmB,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,EAAE,CAM3D;IAED,+GAA+G;IAC/G,QAAQ,IAAI,cAAc,GAAG,SAAS,CAErC;IAED;;OAEG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAI/D;YAEa,UAAU;IAiDxB,wFAAwF;IACxF,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,cAAc;CAmBvB"}

package/dest/global_variable_builder/fee_predictor.js

@@ -0,0 +1,127 @@
+import { MAX_FEE_ASSET_PRICE_MODIFIER_BPS } from '@aztec-labs/ethereum/contracts';
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { times } from '@aztec-labs/foundation/collection';
+import { getSlotAtNextL1Block, getTimestampForSlot } from '@aztec-labs/stdlib/epoch-helpers';
+import { FEE_ORACLE_LAG, GasFees, MIN_ETH_PER_FEE_ASSET, ManaUsageEstimate, computeExcessMana, computeManaMinFee } from '@aztec-labs/stdlib/gas';
+/**
+ * Predicts min fees for LAG upcoming slots based on the L1 oracle state.
+ * A new oracle update can activate at startSlot + LAG, so only the first LAG entries
+ * are guaranteed stable.
+ */ export class FeePredictor {
+    rollupContract;
+    dateProvider;
+    cachedState;
+    slotDuration;
+    l1GenesisTime;
+    ethereumSlotDuration;
+    constructor(rollupContract, dateProvider, config){
+        this.rollupContract = rollupContract;
+        this.dateProvider = dateProvider;
+        this.slotDuration = config.slotDuration;
+        this.l1GenesisTime = config.l1GenesisTime;
+        this.ethereumSlotDuration = config.ethereumSlotDuration;
+    }
+    /** Returns predicted min fees for each slot in the prediction window, from the cached state. */ getPredictedMinFees(manaUsage) {
+        const state = this.getState();
+        if (state === undefined) {
+            throw new Error('FeePredictor.refreshState() must be called before getPredictedMinFees()');
+        }
+        return this.computePredictions(state, manaUsage);
+    }
+    /** Returns whatever rollup state is currently cached, or undefined if refreshState() has never been called. */ getState() {
+        return this.cachedState;
+    }
+    /**
+   * Fetches and caches rollup state for the given L1 block.
+   */ async refreshState(blockNumber) {
+        const state = await this.fetchState(blockNumber);
+        this.cachedState = state;
+        return state;
+    }
+    async fetchState(blockNumber) {
+        // Pin all non-constant queries to this L1 block number for a consistent snapshot.
+        const opts = {
+            blockNumber
+        };
+        // Cached constants don't need pinning
+        const [manaTarget, manaLimit, provingCostPerManaEth, epochDuration] = await Promise.all([
+            this.rollupContract.getManaTarget(),
+            this.rollupContract.getManaLimit(),
+            this.rollupContract.getProvingCostPerMana(),
+            this.rollupContract.getEpochDuration()
+        ]);
+        // First, compute the earliest possible nextSlot independently of the checkpoint, so we can
+        // evaluate pruneability at the prediction start timestamp instead of the current L1 block time.
+        // This avoids an epoch-boundary edge case where the effective parent differs between now and nextSlot.
+        const slotConfig = {
+            slotDuration: this.slotDuration,
+            l1GenesisTime: this.l1GenesisTime
+        };
+        const currentSlot = await this.rollupContract.getSlotNumber(opts);
+        const slotAtNextL1Block = getSlotAtNextL1Block(BigInt(this.dateProvider.nowInSeconds()), {
+            l1GenesisTime: this.l1GenesisTime,
+            slotDuration: this.slotDuration,
+            ethereumSlotDuration: this.ethereumSlotDuration
+        });
+        const preliminaryNextSlot = SlotNumber(Math.max(currentSlot, slotAtNextL1Block));
+        const nextSlotTimestamp = getTimestampForSlot(preliminaryNextSlot, slotConfig);
+        // Resolve the effective checkpoint at the prediction start timestamp
+        const lastCheckpoint = await this.rollupContract.getEffectivePendingCheckpoint(nextSlotTimestamp, opts);
+        const lastSlot = lastCheckpoint.slotNumber;
+        // Refine nextSlot: also account for the slot after the last checkpoint
+        const nextSlot = SlotNumber(Math.max(SlotNumber.add(lastSlot, 1), preliminaryNextSlot));
+        const feeHeader = lastCheckpoint.feeHeader;
+        const slotCount = FEE_ORACLE_LAG;
+        const timestamps = times(slotCount, (i)=>getTimestampForSlot(SlotNumber.add(nextSlot, i), slotConfig));
+        const l1FeesBySlot = await Promise.all(timestamps.map((ts)=>this.rollupContract.getL1FeesAt(ts, opts)));
+        return {
+            lastSlot,
+            excessMana: computeExcessMana(feeHeader.excessMana, feeHeader.manaUsed, manaTarget),
+            ethPerFeeAsset: feeHeader.ethPerFeeAsset,
+            manaTarget,
+            manaLimit,
+            provingCostPerManaEth,
+            epochDuration: BigInt(epochDuration),
+            l1FeesBySlot
+        };
+    }
+    /** Computes per-slot fee predictions given cached state and a mana usage assumption. */ computePredictions(state, manaUsage) {
+        const assumedManaUsed = this.getAssumedManaUsed(state, manaUsage);
+        const result = [];
+        let { excessMana } = state;
+        let { ethPerFeeAsset } = state;
+        // Slot 0: current state (next available slot after last checkpoint)
+        result.push(this.computeGasFees(state, excessMana, ethPerFeeAsset, state.l1FeesBySlot[0]));
+        // Slots 1..LAG-1: advance excessMana with the assumed mana usage per checkpoint,
+        // and decay ethPerFeeAsset by MAX_FEE_ASSET_PRICE_MODIFIER_BPS per slot for conservative estimates.
+        // Lower ethPerFeeAsset means higher fees in fee asset terms.
+        for(let i = 1; i < state.l1FeesBySlot.length; i++){
+            excessMana = computeExcessMana(excessMana, assumedManaUsed, state.manaTarget);
+            const decayed = ethPerFeeAsset * (10000n - MAX_FEE_ASSET_PRICE_MODIFIER_BPS) / 10000n;
+            ethPerFeeAsset = decayed < MIN_ETH_PER_FEE_ASSET ? MIN_ETH_PER_FEE_ASSET : decayed;
+            result.push(this.computeGasFees(state, excessMana, ethPerFeeAsset, state.l1FeesBySlot[i]));
+        }
+        return result;
+    }
+    getAssumedManaUsed(state, manaUsage) {
+        switch(manaUsage){
+            case ManaUsageEstimate.None:
+                return 0n;
+            case ManaUsageEstimate.Target:
+                return state.manaTarget;
+            case ManaUsageEstimate.Limit:
+                return state.manaLimit;
+        }
+    }
+    computeGasFees(state, excessMana, ethPerFeeAsset, l1Fees) {
+        return new GasFees(0, computeManaMinFee({
+            l1BaseFee: l1Fees.baseFee,
+            l1BlobFee: l1Fees.blobFee,
+            manaTarget: state.manaTarget,
+            epochDuration: state.epochDuration,
+            provingCostPerManaEth: state.provingCostPerManaEth,
+            excessMana,
+            ethPerFeeAsset
+        }));
+    }
+}

package/dest/global_variable_builder/fee_provider.d.ts

@@ -0,0 +1,28 @@
+import type { ViemPublicClient } from '@aztec-labs/ethereum/types';
+import type { DateProvider } from '@aztec-labs/foundation/timer';
+import { GasFees, ManaUsageEstimate } from '@aztec-labs/stdlib/gas';
+import type { FeeProvider } from '@aztec-labs/stdlib/tx';
+import type { GlobalVariableBuilderConfig } from './global_builder.js';
+/**
+ * Provides current and predicted fee information based on on-chain state.
+ */
+export declare class FeeProviderImpl implements FeeProvider {
+    private readonly dateProvider;
+    private readonly publicClient;
+    private currentMinFees;
+    private currentL1BlockNumber;
+    private refreshLoop;
+    private readonly rollupContract;
+    private readonly feePredictor;
+    private readonly ethereumSlotDuration;
+    private readonly l1GenesisTime;
+    private readonly log;
+    constructor(dateProvider: DateProvider, publicClient: ViemPublicClient, config: GlobalVariableBuilderConfig);
+    start(pollingIntervalMs?: number): Promise<void>;
+    stop(): Promise<void>;
+    private refreshFromL1;
+    private computeCurrentMinFees;
+    getCurrentMinFees(): Promise<GasFees>;
+    getPredictedMinFees(manaUsage?: ManaUsageEstimate): Promise<GasFees[]>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlX3Byb3ZpZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2xvYmFsX3ZhcmlhYmxlX2J1aWxkZXIvZmVlX3Byb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFJbkUsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFakUsT0FBTyxFQUFFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3BFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBR3pELE9BQU8sS0FBSyxFQUFFLDJCQUEyQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFLdkU7O0dBRUc7QUFDSCxxQkFBYSxlQUFnQixZQUFXLFdBQVc7SUFZL0MsT0FBTyxDQUFDLFFBQVEsQ0FBQyxZQUFZO0lBQzdCLE9BQU8sQ0FBQyxRQUFRLENBQUMsWUFBWTtJQVovQixPQUFPLENBQUMsY0FBYyxDQUFxQjtJQUMzQyxPQUFPLENBQUMsb0JBQW9CLENBQWlDO0lBQzdELE9BQU8sQ0FBQyxXQUFXLENBQTZCO0lBRWhELE9BQU8sQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFpQjtJQUNoRCxPQUFPLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBZTtJQUM1QyxPQUFPLENBQUMsUUFBUSxDQUFDLG9CQUFvQixDQUFTO0lBQzlDLE9BQU8sQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFTO0lBQ3ZDLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUF5RDtJQUU3RSxZQUNtQixZQUFZLEVBQUUsWUFBWSxFQUMxQixZQUFZLEVBQUUsZ0JBQWdCLEVBQy9DLE1BQU0sRUFBRSwyQkFBMkIsRUFXcEM7SUFFWSxLQUFLLENBQUMsaUJBQWlCLFNBQXNDLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUl6RjtJQUVZLElBQUksSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBRWpDO1lBTWEsYUFBYTtZQWdCYixxQkFBcUI7SUFrQjVCLGlCQUFpQixJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FFM0M7SUFFTSxtQkFBbUIsQ0FBQyxTQUFTLENBQUMsRUFBRSxpQkFBaUIsR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FJNUU7Q0FDRiJ9

package/dest/global_variable_builder/fee_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fee_provider.d.ts","sourceRoot":"","sources":["../../src/global_variable_builder/fee_provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAInE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAKvE;;GAEG;AACH,qBAAa,eAAgB,YAAW,WAAW;IAY/C,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAZ/B,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,oBAAoB,CAAiC;IAC7D,OAAO,CAAC,WAAW,CAA6B;IAEhD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAyD;IAE7E,YACmB,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,gBAAgB,EAC/C,MAAM,EAAE,2BAA2B,EAWpC;IAEY,KAAK,CAAC,iBAAiB,SAAsC,GAAG,OAAO,CAAC,IAAI,CAAC,CAIzF;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAEjC;YAMa,aAAa;YAgBb,qBAAqB;IAkB5B,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAE3C;IAEM,mBAAmB,CAAC,SAAS,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAI5E;CACF"}

package/dest/global_variable_builder/fee_provider.js

@@ -0,0 +1,87 @@
+import { RollupContract } from '@aztec-labs/ethereum/contracts';
+import { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { RunningPromise } from '@aztec-labs/foundation/running-promise';
+import { getNextL1SlotTimestamp } from '@aztec-labs/stdlib/epoch-helpers';
+import { GasFees, ManaUsageEstimate } from '@aztec-labs/stdlib/gas';
+import { FeePredictor } from './fee_predictor.js';
+/** Default interval for the background L1 refresh loop, well below L1's block time. */ const DEFAULT_REFRESH_POLLING_INTERVAL_MS = 1000;
+/**
+ * Provides current and predicted fee information based on on-chain state.
+ */ export class FeeProviderImpl {
+    dateProvider;
+    publicClient;
+    currentMinFees;
+    currentL1BlockNumber;
+    refreshLoop;
+    rollupContract;
+    feePredictor;
+    ethereumSlotDuration;
+    l1GenesisTime;
+    log;
+    constructor(dateProvider, publicClient, config){
+        this.dateProvider = dateProvider;
+        this.publicClient = publicClient;
+        this.currentMinFees = new GasFees(0, 0);
+        this.currentL1BlockNumber = undefined;
+        this.log = createLogger('sequencer-client:fee-provider');
+        this.ethereumSlotDuration = config.ethereumSlotDuration;
+        this.l1GenesisTime = config.l1GenesisTime;
+        this.rollupContract = new RollupContract(this.publicClient, config.rollupAddress);
+        this.feePredictor = new FeePredictor(this.rollupContract, this.dateProvider, {
+            slotDuration: config.slotDuration,
+            l1GenesisTime: config.l1GenesisTime,
+            ethereumSlotDuration: config.ethereumSlotDuration
+        });
+    }
+    async start(pollingIntervalMs = DEFAULT_REFRESH_POLLING_INTERVAL_MS) {
+        await this.refreshFromL1();
+        this.refreshLoop = new RunningPromise(()=>this.refreshFromL1(), this.log, pollingIntervalMs);
+        this.refreshLoop.start();
+    }
+    async stop() {
+        await this.refreshLoop?.stop();
+    }
+    /**
+   * Checks the current L1 block number and, if it has advanced, refreshes both the current and
+   * predicted min fees for that block.
+   */ async refreshFromL1() {
+        const blockNumber = await this.publicClient.getBlockNumber({
+            cacheTime: 0
+        });
+        if (this.currentL1BlockNumber !== undefined && blockNumber <= this.currentL1BlockNumber) {
+            return;
+        }
+        const currentMinFees = await this.computeCurrentMinFees();
+        await this.feePredictor.refreshState(blockNumber);
+        this.currentMinFees = currentMinFees;
+        this.currentL1BlockNumber = blockNumber;
+    }
+    /**
+   * Computes the "current" min fees, e.g., the price that you currently should pay to get include in the next block
+   * @returns Min fees for the next block
+   */ async computeCurrentMinFees() {
+        // Since this might be called in the middle of a slot where a block might have been published,
+        // we need to fetch the last block written, and estimate the earliest timestamp for the next block.
+        // The timestamp of that last block will act as a lower bound for the next block.
+        const lastCheckpoint = await this.rollupContract.getPendingCheckpoint();
+        const earliestTimestamp = await this.rollupContract.getTimestampForSlot(SlotNumber.fromBigInt(BigInt(lastCheckpoint.slotNumber) + 1n));
+        const nextEthTimestamp = getNextL1SlotTimestamp(this.dateProvider.nowInSeconds(), {
+            l1GenesisTime: this.l1GenesisTime,
+            ethereumSlotDuration: this.ethereumSlotDuration
+        });
+        const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
+        return new GasFees(0, await this.rollupContract.getManaMinFeeAt(timestamp, true));
+    }
+    getCurrentMinFees() {
+        return Promise.resolve(this.currentMinFees);
+    }
+    getPredictedMinFees(manaUsage) {
+        const currentMinFees = this.currentMinFees;
+        const predictedMinFees = this.feePredictor.getPredictedMinFees(manaUsage ?? ManaUsageEstimate.Target);
+        return Promise.resolve([
+            currentMinFees,
+            ...predictedMinFees
+        ]);
+    }
+}

package/dest/global_variable_builder/global_builder.d.ts

@@ -0,0 +1,28 @@
+import { type SimulationOverridesPlan } from '@aztec-labs/ethereum/contracts';
+import type { ViemPublicClient } from '@aztec-labs/ethereum/types';
+import type { SlotNumber } from '@aztec-labs/foundation/branded-types';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { type L1RollupConstants } from '@aztec-labs/stdlib/epoch-helpers';
+import type { CheckpointGlobalVariables, GlobalVariableBuilder as GlobalVariableBuilderInterface } from '@aztec-labs/stdlib/tx';
+/** Configuration for the GlobalVariableBuilder (excludes L1 client config). */
+export type GlobalVariableBuilderConfig = {
+    rollupAddress: EthAddress;
+    ethereumSlotDuration: number;
+    rollupVersion: bigint;
+} & Pick<L1RollupConstants, 'slotDuration' | 'l1GenesisTime'>;
+/**
+ * Simple global variables builder.
+ */
+export declare class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
+    private readonly publicClient;
+    private readonly rollupContract;
+    private readonly aztecSlotDuration;
+    private readonly l1GenesisTime;
+    private chainId;
+    private version;
+    constructor(publicClient: ViemPublicClient, config: GlobalVariableBuilderConfig);
+    /** Builds global variables that are constant throughout a checkpoint. */
+    buildCheckpointGlobalVariables(coinbase: EthAddress, feeRecipient: AztecAddress, slotNumber: SlotNumber, simulationOverridesPlan?: SimulationOverridesPlan): Promise<CheckpointGlobalVariables>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2xvYmFsX2J1aWxkZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nbG9iYWxfdmFyaWFibGVfYnVpbGRlci9nbG9iYWxfYnVpbGRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBRUwsS0FBSyx1QkFBdUIsRUFFN0IsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN4QyxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ25FLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBRXZFLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUF1QixNQUFNLGtDQUFrQyxDQUFDO0FBRS9GLE9BQU8sS0FBSyxFQUNWLHlCQUF5QixFQUN6QixxQkFBcUIsSUFBSSw4QkFBOEIsRUFDeEQsTUFBTSx1QkFBdUIsQ0FBQztBQUUvQiwrRUFBK0U7QUFDL0UsTUFBTSxNQUFNLDJCQUEyQixHQUFHO0lBQ3hDLGFBQWEsRUFBRSxVQUFVLENBQUM7SUFDMUIsb0JBQW9CLEVBQUUsTUFBTSxDQUFDO0lBQzdCLGFBQWEsRUFBRSxNQUFNLENBQUM7Q0FDdkIsR0FBRyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsY0FBYyxHQUFHLGVBQWUsQ0FBQyxDQUFDO0FBRTlEOztHQUVHO0FBQ0gscUJBQWEscUJBQXNCLFlBQVcsOEJBQThCO0lBU3hFLE9BQU8sQ0FBQyxRQUFRLENBQUMsWUFBWTtJQVIvQixPQUFPLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBaUI7SUFDaEQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBUztJQUMzQyxPQUFPLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FBUztJQUV2QyxPQUFPLENBQUMsT0FBTyxDQUFLO0lBQ3BCLE9BQU8sQ0FBQyxPQUFPLENBQUs7SUFFcEIsWUFDbUIsWUFBWSxFQUFFLGdCQUFnQixFQUMvQyxNQUFNLEVBQUUsMkJBQTJCLEVBU3BDO0lBRUQseUVBQXlFO0lBQzVELDhCQUE4QixDQUN6QyxRQUFRLEVBQUUsVUFBVSxFQUNwQixZQUFZLEVBQUUsWUFBWSxFQUMxQixVQUFVLEVBQUUsVUFBVSxFQUN0Qix1QkFBdUIsQ0FBQyxFQUFFLHVCQUF1QixHQUNoRCxPQUFPLENBQUMseUJBQXlCLENBQUMsQ0FZcEM7Q0FDRiJ9