@aztec/sequencer-client 0.0.0-test.0

package/README.md

@@ -0,0 +1,45 @@
+# Sequencer Client
+
+The sequencer is a module responsible for creating and publishing new rollup blocks. This involves fetching txs from the P2P pool, ordering them, executing any public functions, running them through the rollup circuits, assembling the L2 block, and posting it to the L1 rollup contract along with any contract deployment public data.
+
+The client itself is implemented as a continuous loop. After being started, it polls the P2P pool for new txs, assembles a new block if any is found, and goes back to sleep. On every new block assembled, it modifies the world state database to reflect the txs processed, but these changes are only committed once the world state synchronizer sees the new block on L1.
+
+## Components
+
+_What components are used to build a sequencer client._
+
+- The **block builder** is responsible for assembling an L2 block out of a set of processed transactions (we say a tx has been _processed_ if all its function calls have been executed). This involves running the txs through the base, merge, and rollup circuits, updating the world state trees, and building the L2 block object.
+
+- The **prover** generates proofs for every circuit used. For the time being, no proofs are being actually generated, so the only implementation is an empty one.
+
+- The **publisher** deals with sending L1 transactions to the rollup and contract deployment emitter contracts. It is responsible for assembling the Ethereum tx, choosing reasonable gas settings, and monitoring the tx until it gets mined. Note that the current implementation does not handle unstable network conditions (gas price spikes, reorgs, etc).
+
+- The **public processor** executes any public function calls in the transactions. Unlike private function calls, which are resolved in the client, public functions require access to the latest data trees, so they are executed by the sequencer, much like in any non-private L2.
+
+- The **simulator** is an interface to the wasm implementations of the circuits used by the sequencer.
+
+- The **sequencer** pulls txs from the P2P pool, orchestrates all the components above to assemble and publish a block, and updates the world state database.
+
+## Circuits
+
+_What circuits does the sequencer depend on._
+
+- The **public circuit** is responsible for proving the execution of Brillig (public function bytecode). At the moment, we are using a fake version that actually runs ACIR (intermediate representation for private functions) and does not emit any proofs.
+
+- The **public kernel circuit** then validates the output of the public circuit, and outputs a set of changes to the world state in the same format as the private kernel circuit, meaning we get a standard representation for all txs, regardless of whether public or private functions (or both) were run. The kernel circuits are run iteratively for every recursive call in the transaction.
+
+- The **base rollup circuit** aggregates the changes from two txs (more precisely, the outputs from their kernel circuits once all call stacks are emptied) into a single output.
+
+- The **merge rollup circuit** aggregates two outputs from base rollup circuits into a single one. This circuit is executed recursively until only two outputs are left. This setup means that an L2 block needs to contain always a power-of-two number of txs; if there are not enough, then empty txs are added.
+
+- The **root rollup circuit** consumes two outputs from base or merge rollups and outputs the data to assemble an L2 block. The L1 rollup contract then verifies the proof from this circuit, which implies that all txs included in it were correct.
+
+## Development
+
+Start by running `bootstrap.sh` in the project root.
+
+To build the package, run `yarn build` in the root.
+
+To watch for changes, `yarn build:dev`.
+
+To run the tests, execute `yarn test`.

package/dest/client/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dest/client/index.js

@@ -0,0 +1 @@
+export * from './sequencer-client.js';

package/dest/client/sequencer-client.d.ts

@@ -0,0 +1,71 @@
+import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import { EpochCache } from '@aztec/epoch-cache';
+import { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { P2P } from '@aztec/p2p';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { TelemetryClient } from '@aztec/telemetry-client';
+import type { ValidatorClient } from '@aztec/validator-client';
+import type { SequencerClientConfig } from '../config.js';
+import { SequencerPublisher } from '../publisher/index.js';
+import { Sequencer, type SequencerConfig } from '../sequencer/index.js';
+import type { SlasherClient } from '../slasher/index.js';
+/**
+ * Encapsulates the full sequencer and publisher.
+ */
+export declare class SequencerClient {
+    protected sequencer: Sequencer;
+    constructor(sequencer: Sequencer);
+    /**
+     * Initializes and starts a new instance.
+     * @param config - Configuration for the sequencer, publisher, and L1 tx sender.
+     * @param p2pClient - P2P client that provides the txs to be sequenced.
+     * @param validatorClient - Validator client performs attestation duties when rotating proposers.
+     * @param worldStateSynchronizer - Provides access to world state.
+     * @param contractDataSource - Provides access to contract bytecode for public executions.
+     * @param l2BlockSource - Provides information about the previously published blocks.
+     * @param l1ToL2MessageSource - Provides access to L1 to L2 messages.
+     * @param prover - An instance of a block prover
+     * @param simulationProvider - An instance of a simulation provider
+     * @returns A new running instance.
+     */
+    static new(config: SequencerClientConfig, deps: {
+        validatorClient: ValidatorClient | undefined;
+        p2pClient: P2P;
+        worldStateSynchronizer: WorldStateSynchronizer;
+        slasherClient: SlasherClient;
+        contractDataSource: ContractDataSource;
+        l2BlockSource: L2BlockSource;
+        l1ToL2MessageSource: L1ToL2MessageSource;
+        telemetry: TelemetryClient;
+        publisher?: SequencerPublisher;
+        blobSinkClient?: BlobSinkClientInterface;
+        dateProvider: DateProvider;
+        epochCache?: EpochCache;
+        l1TxUtils?: L1TxUtilsWithBlobs;
+    }): Promise<SequencerClient>;
+    /**
+     * Updates sequencer config.
+     * @param config - New parameters.
+     */
+    updateSequencerConfig(config: SequencerConfig): Promise<void>;
+    /**
+     * Stops the sequencer from processing new txs.
+     */
+    stop(): Promise<void>;
+    /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */
+    flush(): void;
+    /**
+     * Restarts the sequencer after being stopped.
+     */
+    restart(): void;
+    get coinbase(): EthAddress;
+    get feeRecipient(): AztecAddress;
+    get forwarderAddress(): EthAddress;
+}
+//# sourceMappingURL=sequencer-client.d.ts.map

package/dest/client/sequencer-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencer-client.d.ts","sourceRoot":"","sources":["../../src/client/sequencer-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAUhD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAGtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;GAEG;AACH,qBAAa,eAAe;IACd,SAAS,CAAC,SAAS,EAAE,SAAS;gBAApB,SAAS,EAAE,SAAS;IAE1C;;;;;;;;;;;;OAYG;WACiB,GAAG,CACrB,MAAM,EAAE,qBAAqB,EAC7B,IAAI,EAAE;QACJ,eAAe,EAAE,eAAe,GAAG,SAAS,CAAC;QAC7C,SAAS,EAAE,GAAG,CAAC;QACf,sBAAsB,EAAE,sBAAsB,CAAC;QAC/C,aAAa,EAAE,aAAa,CAAC;QAC7B,kBAAkB,EAAE,kBAAkB,CAAC;QACvC,aAAa,EAAE,aAAa,CAAC;QAC7B,mBAAmB,EAAE,mBAAmB,CAAC;QACzC,SAAS,EAAE,eAAe,CAAC;QAC3B,SAAS,CAAC,EAAE,kBAAkB,CAAC;QAC/B,cAAc,CAAC,EAAE,uBAAuB,CAAC;QACzC,YAAY,EAAE,YAAY,CAAC;QAC3B,UAAU,CAAC,EAAE,UAAU,CAAC;QACxB,SAAS,CAAC,EAAE,kBAAkB,CAAC;KAChC;IAiHH;;;OAGG;IACI,qBAAqB,CAAC,MAAM,EAAE,eAAe;IAIpD;;OAEG;IACU,IAAI;IAIjB,uGAAuG;IAChG,KAAK;IAIZ;;OAEG;IACI,OAAO;IAId,IAAI,QAAQ,IAAI,UAAU,CAEzB;IAED,IAAI,YAAY,IAAI,YAAY,CAE/B;IAED,IAAI,gBAAgB,IAAI,UAAU,CAEjC;CACF"}

package/dest/client/sequencer-client.js

@@ -0,0 +1,117 @@
+import { EpochCache } from '@aztec/epoch-cache';
+import { ForwarderContract, GovernanceProposerContract, RollupContract, SlashingProposerContract, createEthereumChain, createL1Clients, isAnvilTestChain } from '@aztec/ethereum';
+import { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { LightweightBlockBuilderFactory } from '@aztec/prover-client/block-builder';
+import { PublicProcessorFactory } from '@aztec/simulator/server';
+import { GlobalVariableBuilder } from '../global_variable_builder/index.js';
+import { SequencerPublisher } from '../publisher/index.js';
+import { Sequencer } from '../sequencer/index.js';
+/**
+ * Encapsulates the full sequencer and publisher.
+ */ export class SequencerClient {
+    sequencer;
+    constructor(sequencer){
+        this.sequencer = sequencer;
+    }
+    /**
+   * Initializes and starts a new instance.
+   * @param config - Configuration for the sequencer, publisher, and L1 tx sender.
+   * @param p2pClient - P2P client that provides the txs to be sequenced.
+   * @param validatorClient - Validator client performs attestation duties when rotating proposers.
+   * @param worldStateSynchronizer - Provides access to world state.
+   * @param contractDataSource - Provides access to contract bytecode for public executions.
+   * @param l2BlockSource - Provides information about the previously published blocks.
+   * @param l1ToL2MessageSource - Provides access to L1 to L2 messages.
+   * @param prover - An instance of a block prover
+   * @param simulationProvider - An instance of a simulation provider
+   * @returns A new running instance.
+   */ static async new(config, deps) {
+        const { validatorClient, p2pClient, worldStateSynchronizer, slasherClient, contractDataSource, l2BlockSource, l1ToL2MessageSource, telemetry: telemetryClient } = deps;
+        const { l1RpcUrls: rpcUrls, l1ChainId: chainId, publisherPrivateKey } = config;
+        const chain = createEthereumChain(rpcUrls, chainId);
+        const log = createLogger('sequencer-client');
+        const { publicClient, walletClient } = createL1Clients(rpcUrls, publisherPrivateKey, chain.chainInfo);
+        const l1TxUtils = deps.l1TxUtils ?? new L1TxUtilsWithBlobs(publicClient, walletClient, log, config);
+        const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
+        const [l1GenesisTime, slotDuration] = await Promise.all([
+            rollupContract.getL1GenesisTime(),
+            rollupContract.getSlotDuration()
+        ]);
+        const forwarderContract = config.customForwarderContractAddress && config.customForwarderContractAddress !== EthAddress.ZERO ? new ForwarderContract(publicClient, config.customForwarderContractAddress.toString(), config.l1Contracts.rollupAddress.toString()) : await ForwarderContract.create(walletClient.account.address, walletClient, publicClient, log, config.l1Contracts.rollupAddress.toString());
+        const governanceProposerContract = new GovernanceProposerContract(publicClient, config.l1Contracts.governanceProposerAddress.toString());
+        const slashingProposerAddress = await rollupContract.getSlashingProposerAddress();
+        const slashingProposerContract = new SlashingProposerContract(publicClient, slashingProposerAddress.toString());
+        const epochCache = deps.epochCache ?? await EpochCache.create(config.l1Contracts.rollupAddress, {
+            l1RpcUrls: rpcUrls,
+            l1ChainId: chainId,
+            viemPollingIntervalMS: config.viemPollingIntervalMS,
+            aztecSlotDuration: config.aztecSlotDuration,
+            ethereumSlotDuration: config.ethereumSlotDuration,
+            aztecEpochDuration: config.aztecEpochDuration
+        }, {
+            dateProvider: deps.dateProvider
+        });
+        const publisher = deps.publisher ?? new SequencerPublisher(config, {
+            l1TxUtils,
+            telemetry: telemetryClient,
+            blobSinkClient: deps.blobSinkClient,
+            rollupContract,
+            epochCache,
+            forwarderContract,
+            governanceProposerContract,
+            slashingProposerContract
+        });
+        const globalsBuilder = new GlobalVariableBuilder(config);
+        const publicProcessorFactory = new PublicProcessorFactory(contractDataSource, deps.dateProvider, telemetryClient);
+        const ethereumSlotDuration = config.ethereumSlotDuration;
+        // When running in anvil, assume we can post a tx up until the very last second of an L1 slot.
+        // Otherwise, assume we must have broadcasted the tx before the slot started (we use a default
+        // maxL1TxInclusionTimeIntoSlot of zero) to get the tx into that L1 slot.
+        // In theory, the L1 slot has an initial 4s phase where the block is propagated, so we could
+        // make it with a propagation time into slot equal to 4s. However, we prefer being conservative.
+        // See https://www.blocknative.com/blog/anatomy-of-a-slot#7 for more info.
+        const maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot ?? isAnvilTestChain(config.l1ChainId) ? ethereumSlotDuration : 0;
+        const l1Constants = {
+            l1GenesisTime,
+            slotDuration: Number(slotDuration),
+            ethereumSlotDuration
+        };
+        const sequencer = new Sequencer(publisher, validatorClient, globalsBuilder, p2pClient, worldStateSynchronizer, slasherClient, new LightweightBlockBuilderFactory(telemetryClient), l2BlockSource, l1ToL2MessageSource, publicProcessorFactory, contractDataSource, l1Constants, deps.dateProvider, {
+            ...config,
+            maxL1TxInclusionTimeIntoSlot
+        }, telemetryClient);
+        await validatorClient?.start();
+        await sequencer.start();
+        return new SequencerClient(sequencer);
+    }
+    /**
+   * Updates sequencer config.
+   * @param config - New parameters.
+   */ updateSequencerConfig(config) {
+        return this.sequencer.updateConfig(config);
+    }
+    /**
+   * Stops the sequencer from processing new txs.
+   */ async stop() {
+        await this.sequencer.stop();
+    }
+    /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */ flush() {
+        this.sequencer.flush();
+    }
+    /**
+   * Restarts the sequencer after being stopped.
+   */ restart() {
+        this.sequencer.restart();
+    }
+    get coinbase() {
+        return this.sequencer.coinbase;
+    }
+    get feeRecipient() {
+        return this.sequencer.feeRecipient;
+    }
+    get forwarderAddress() {
+        return this.sequencer.getForwarderAddress();
+    }
+}

package/dest/config.d.ts

@@ -0,0 +1,29 @@
+import { type L1ContractsConfig, type L1ReaderConfig } from '@aztec/ethereum';
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+import { type AllowedElement, type ChainConfig, type SequencerConfig } from '@aztec/stdlib/config';
+import { type PublisherConfig, type TxSenderConfig } from './publisher/config.js';
+export * from './publisher/config.js';
+export type { SequencerConfig };
+/**
+ * Configuration settings for the SequencerClient.
+ */
+export type SequencerClientConfig = PublisherConfig & TxSenderConfig & SequencerConfig & L1ReaderConfig & ChainConfig & 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;
+/**
+ * Parses a string to a list of allowed elements.
+ * Each encoded is expected to be of one of the following formats
+ * `I:${address}`
+ * `I:${address}:${selector}`
+ * `C:${classId}`
+ * `C:${classId}:${selector}`
+ *
+ * @param value The string to parse
+ * @returns A list of allowed elements
+ */
+export declare function parseSequencerAllowList(value: string): AllowedElement[];
+//# sourceMappingURL=config.d.ts.map

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EAGpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAuB,MAAM,sBAAsB,CAAC;AAExH,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,cAAc,EAGpB,MAAM,uBAAuB,CAAC;AAE/B,cAAc,uBAAuB,CAAC;AACtC,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,eAAe,GACjD,cAAc,GACd,eAAe,GACf,cAAc,GACd,WAAW,GACX,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,GAAG,mBAAmB,GAAG,oBAAoB,CAAC,CAAC;AAE/F,eAAO,MAAM,uBAAuB,EAAE,kBAAkB,CAAC,eAAe,CAyEvE,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,kBAAkB,CAAC,qBAAqB,CAOnF,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAqCvE"}

package/dest/config.js

@@ -0,0 +1,143 @@
+import { l1ContractsConfigMappings, l1ReaderConfigMappings } from '@aztec/ethereum';
+import { booleanConfigHelper, getConfigFromMappings, numberConfigHelper, pickConfigMappings } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { chainConfigMappings } from '@aztec/stdlib/config';
+import { getPublisherConfigMappings, getTxSenderConfigMappings } from './publisher/config.js';
+export * from './publisher/config.js';
+export const sequencerConfigMappings = {
+    transactionPollingIntervalMS: {
+        env: 'SEQ_TX_POLLING_INTERVAL_MS',
+        description: 'The number of ms to wait between polling for pending txs.',
+        ...numberConfigHelper(500)
+    },
+    maxTxsPerBlock: {
+        env: 'SEQ_MAX_TX_PER_BLOCK',
+        description: 'The maximum number of txs to include in a block.',
+        ...numberConfigHelper(32)
+    },
+    minTxsPerBlock: {
+        env: 'SEQ_MIN_TX_PER_BLOCK',
+        description: 'The minimum number of txs to include in a block.',
+        ...numberConfigHelper(1)
+    },
+    maxL2BlockGas: {
+        env: 'SEQ_MAX_L2_BLOCK_GAS',
+        description: 'The maximum L2 block gas.',
+        ...numberConfigHelper(10e9)
+    },
+    maxDABlockGas: {
+        env: 'SEQ_MAX_DA_BLOCK_GAS',
+        description: 'The maximum DA block gas.',
+        ...numberConfigHelper(10e9)
+    },
+    coinbase: {
+        env: 'COINBASE',
+        parseEnv: (val)=>val ? EthAddress.fromString(val) : undefined,
+        description: 'Recipient of block reward.'
+    },
+    feeRecipient: {
+        env: 'FEE_RECIPIENT',
+        parseEnv: (val)=>AztecAddress.fromString(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'
+    },
+    allowedInSetup: {
+        env: 'SEQ_ALLOWED_SETUP_FN',
+        parseEnv: (val)=>parseSequencerAllowList(val),
+        description: 'The list of functions calls allowed to run in setup',
+        printDefault: ()=>'AuthRegistry, FeeJuice.increase_public_balance, Token.increase_public_balance, FPC.prepare_fee'
+    },
+    maxBlockSizeInBytes: {
+        env: 'SEQ_MAX_BLOCK_SIZE_IN_BYTES',
+        description: 'Max block size',
+        ...numberConfigHelper(1024 * 1024)
+    },
+    enforceTimeTable: {
+        env: 'SEQ_ENFORCE_TIME_TABLE',
+        description: 'Whether to enforce the time table when building blocks',
+        ...booleanConfigHelper(),
+        defaultValue: false
+    },
+    governanceProposerPayload: {
+        env: 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS',
+        description: 'The address of the payload for the governanceProposer',
+        parseEnv: (val)=>EthAddress.fromString(val),
+        defaultValue: EthAddress.ZERO
+    },
+    maxL1TxInclusionTimeIntoSlot: {
+        env: 'SEQ_MAX_L1_TX_INCLUSION_TIME_INTO_SLOT',
+        description: 'How many seconds into an L1 slot we can still send a tx and get it mined.',
+        parseEnv: (val)=>val ? parseInt(val, 10) : undefined
+    }
+};
+export const sequencerClientConfigMappings = {
+    ...sequencerConfigMappings,
+    ...l1ReaderConfigMappings,
+    ...getTxSenderConfigMappings('SEQ'),
+    ...getPublisherConfigMappings('SEQ'),
+    ...chainConfigMappings,
+    ...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);
+}
+/**
+ * Parses a string to a list of allowed elements.
+ * Each encoded is expected to be of one of the following formats
+ * `I:${address}`
+ * `I:${address}:${selector}`
+ * `C:${classId}`
+ * `C:${classId}:${selector}`
+ *
+ * @param value The string to parse
+ * @returns A list of allowed elements
+ */ export function parseSequencerAllowList(value) {
+    const entries = [];
+    if (!value) {
+        return entries;
+    }
+    for (const val of value.split(',')){
+        const [typeString, identifierString, selectorString] = val.split(':');
+        const selector = selectorString !== undefined ? FunctionSelector.fromString(selectorString) : undefined;
+        if (typeString === 'I') {
+            if (selector) {
+                entries.push({
+                    address: AztecAddress.fromString(identifierString),
+                    selector
+                });
+            } else {
+                entries.push({
+                    address: AztecAddress.fromString(identifierString)
+                });
+            }
+        } else if (typeString === 'C') {
+            if (selector) {
+                entries.push({
+                    classId: Fr.fromHexString(identifierString),
+                    selector
+                });
+            } else {
+                entries.push({
+                    classId: Fr.fromHexString(identifierString)
+                });
+            }
+        }
+    }
+    return entries;
+}

package/dest/global_variable_builder/global_builder.d.ts

@@ -0,0 +1,32 @@
+import { type L1ContractsConfig, type L1ReaderConfig } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import type { GlobalVariableBuilder as GlobalVariableBuilderInterface } from '@aztec/stdlib/tx';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+/**
+ * Simple global variables builder.
+ */
+export declare class GlobalVariableBuilder implements GlobalVariableBuilderInterface {
+    private log;
+    private rollupContract;
+    private publicClient;
+    private ethereumSlotDuration;
+    constructor(config: L1ReaderConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'>);
+    /**
+     * Computes the "current" base fees, e.g., the price that you currently should pay to get include in the next block
+     * @returns Base fees for the expected next block
+     */
+    getCurrentBaseFees(): Promise<GasFees>;
+    /**
+     * Simple builder of global variables that use the minimum time possible.
+     * @param blockNumber - The block number to build global variables for.
+     * @param coinbase - The address to receive block reward.
+     * @param feeRecipient - The address to receive fees.
+     * @param slotNumber - The slot number to use for the global variables, if undefined it will be calculated.
+     * @returns The global variables for the given block number.
+     */
+    buildGlobalVariables(blockNumber: Fr, coinbase: EthAddress, feeRecipient: AztecAddress, slotNumber?: bigint): Promise<GlobalVariables>;
+}
+//# sourceMappingURL=global_builder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"global_builder.d.ts","sourceRoot":"","sources":["../../src/global_variable_builder/global_builder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EAGpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,EAAE,qBAAqB,IAAI,8BAA8B,EAAE,MAAM,kBAAkB,CAAC;AAChG,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAInD;;GAEG;AACH,qBAAa,qBAAsB,YAAW,8BAA8B;IAC1E,OAAO,CAAC,GAAG,CAAqD;IAEhE,OAAO,CAAC,cAAc,CAA4D;IAClF,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,oBAAoB,CAAS;gBAEzB,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,CAAC;IAoBpF;;;OAGG;IACU,kBAAkB,IAAI,OAAO,CAAC,OAAO,CAAC;IAanD;;;;;;;OAOG;IACU,oBAAoB,CAC/B,WAAW,EAAE,EAAE,EACf,QAAQ,EAAE,UAAU,EACpB,YAAY,EAAE,YAAY,EAC1B,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC;CA8B5B"}

package/dest/global_variable_builder/global_builder.js

@@ -0,0 +1,79 @@
+import { createEthereumChain } from '@aztec/ethereum';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { GasFees } from '@aztec/stdlib/gas';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import { createPublicClient, fallback, getAddress, getContract, http } from 'viem';
+/**
+ * Simple global variables builder.
+ */ export class GlobalVariableBuilder {
+    log = createLogger('sequencer:global_variable_builder');
+    rollupContract;
+    publicClient;
+    ethereumSlotDuration;
+    constructor(config){
+        const { l1RpcUrls, l1ChainId: chainId, l1Contracts } = config;
+        const chain = createEthereumChain(l1RpcUrls, chainId);
+        this.ethereumSlotDuration = config.ethereumSlotDuration;
+        this.publicClient = createPublicClient({
+            chain: chain.chainInfo,
+            transport: fallback(chain.rpcUrls.map((url)=>http(url))),
+            pollingInterval: config.viemPollingIntervalMS
+        });
+        this.rollupContract = getContract({
+            address: getAddress(l1Contracts.rollupAddress.toString()),
+            abi: RollupAbi,
+            client: this.publicClient
+        });
+    }
+    /**
+   * Computes the "current" base fees, e.g., the price that you currently should pay to get include in the next block
+   * @returns Base fees for the expected next block
+   */ async getCurrentBaseFees() {
+        // 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 lastBlock = await this.rollupContract.read.getBlock([
+            await this.rollupContract.read.getPendingBlockNumber()
+        ]);
+        const earliestTimestamp = await this.rollupContract.read.getTimestampForSlot([
+            lastBlock.slotNumber + 1n
+        ]);
+        const nextEthTimestamp = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
+        const timestamp = earliestTimestamp > nextEthTimestamp ? earliestTimestamp : nextEthTimestamp;
+        return new GasFees(Fr.ZERO, new Fr(await this.rollupContract.read.getManaBaseFeeAt([
+            timestamp,
+            true
+        ])));
+    }
+    /**
+   * Simple builder of global variables that use the minimum time possible.
+   * @param blockNumber - The block number to build global variables for.
+   * @param coinbase - The address to receive block reward.
+   * @param feeRecipient - The address to receive fees.
+   * @param slotNumber - The slot number to use for the global variables, if undefined it will be calculated.
+   * @returns The global variables for the given block number.
+   */ async buildGlobalVariables(blockNumber, coinbase, feeRecipient, slotNumber) {
+        const version = new Fr(await this.rollupContract.read.getVersion());
+        const chainId = new Fr(this.publicClient.chain.id);
+        if (slotNumber === undefined) {
+            const ts = BigInt((await this.publicClient.getBlock()).timestamp + BigInt(this.ethereumSlotDuration));
+            slotNumber = await this.rollupContract.read.getSlotAt([
+                ts
+            ]);
+        }
+        const timestamp = await this.rollupContract.read.getTimestampForSlot([
+            slotNumber
+        ]);
+        const slotFr = new Fr(slotNumber);
+        const timestampFr = new Fr(timestamp);
+        // We can skip much of the logic in getCurrentBaseFees since it we already check that we are not within a slot elsewhere.
+        const gasFees = new GasFees(Fr.ZERO, new Fr(await this.rollupContract.read.getManaBaseFeeAt([
+            timestamp,
+            true
+        ])));
+        const globalVariables = new GlobalVariables(chainId, version, blockNumber, slotFr, timestampFr, coinbase, feeRecipient, gasFees);
+        return globalVariables;
+    }
+}

package/dest/global_variable_builder/index.d.ts

@@ -0,0 +1,2 @@
+export { GlobalVariableBuilder } from './global_builder.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/global_variable_builder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC"}

package/dest/global_variable_builder/index.js

@@ -0,0 +1 @@
+export { GlobalVariableBuilder } from './global_builder.js';

package/dest/index.d.ts

@@ -0,0 +1,8 @@
+export * from './client/index.js';
+export * from './config.js';
+export * from './publisher/index.js';
+export * from './tx_validator/tx_validator_factory.js';
+export * from './slasher/index.js';
+export { Sequencer, SequencerState, getDefaultAllowedSetupFunctions } from './sequencer/index.js';
+export * from './global_variable_builder/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,wCAAwC,CAAC;AACvD,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAIlG,cAAc,oCAAoC,CAAC"}

package/dest/index.js

@@ -0,0 +1,9 @@
+export * from './client/index.js';
+export * from './config.js';
+export * from './publisher/index.js';
+export * from './tx_validator/tx_validator_factory.js';
+export * from './slasher/index.js';
+export { Sequencer, SequencerState, getDefaultAllowedSetupFunctions } from './sequencer/index.js';
+// Used by the node to simulate public parts of transactions. Should these be moved to a shared library?
+// ISSUE(#9832)
+export * from './global_variable_builder/index.js';

package/dest/publisher/config.d.ts

@@ -0,0 +1,31 @@
+import { type BlobSinkConfig } from '@aztec/blob-sink/client';
+import { type L1ReaderConfig, type L1TxUtilsConfig } from '@aztec/ethereum';
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+/**
+ * The configuration of the rollup transaction publisher.
+ */
+export type TxSenderConfig = L1ReaderConfig & {
+    /**
+     * The private key to be used by the publisher.
+     */
+    publisherPrivateKey: `0x${string}`;
+    /**
+     * The address of the custom forwarder contract.
+     */
+    customForwarderContractAddress: EthAddress;
+};
+/**
+ * Configuration of the L1Publisher.
+ */
+export type PublisherConfig = L1TxUtilsConfig & BlobSinkConfig & {
+    /**
+     * The interval to wait between publish retries.
+     */
+    l1PublishRetryIntervalMS: number;
+};
+export declare const getTxSenderConfigMappings: (scope: 'PROVER' | 'SEQ') => ConfigMappingsType<Omit<TxSenderConfig, 'l1Contracts'>>;
+export declare function getTxSenderConfigFromEnv(scope: 'PROVER' | 'SEQ'): Omit<TxSenderConfig, 'l1Contracts'>;
+export declare const getPublisherConfigMappings: (scope: 'PROVER' | 'SEQ') => ConfigMappingsType<PublisherConfig & L1TxUtilsConfig>;
+export declare function getPublisherConfigFromEnv(scope: 'PROVER' | 'SEQ'): PublisherConfig;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/publisher/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAyB,MAAM,yBAAyB,CAAC;AACrF,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,eAAe,EAIrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,kBAAkB,EAAyB,MAAM,0BAA0B,CAAC;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG;IAC5C;;OAEG;IACH,mBAAmB,EAAE,KAAK,MAAM,EAAE,CAAC;IAEnC;;OAEG;IACH,8BAA8B,EAAE,UAAU,CAAC;CAC5C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,eAAe,GAC3C,cAAc,GAAG;IACf;;OAEG;IACH,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAEJ,eAAO,MAAM,yBAAyB,EAAE,CACtC,KAAK,EAAE,QAAQ,GAAG,KAAK,KACpB,kBAAkB,CAAC,IAAI,CAAC,cAAc,EAAE,aAAa,CAAC,CAczD,CAAC;AAEH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,aAAa,CAAC,CAErG;AAED,eAAO,MAAM,0BAA0B,EAAE,CACvC,KAAK,EAAE,QAAQ,GAAG,KAAK,KACpB,kBAAkB,CAAC,eAAe,GAAG,eAAe,CASvD,CAAC;AAEH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,GAAG,eAAe,CAElF"}