@aztec/sequencer-client 0.0.1-commit.b655e406 → 0.0.1-commit.d1f2d6c

package/dest/test/mock_checkpoint_builder.js

@@ -0,0 +1,208 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Timer } from '@aztec/foundation/timer';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { Gas } from '@aztec/stdlib/gas';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeAppendOnlyTreeSnapshot } from '@aztec/stdlib/testing';
+/**
+ * A fake CheckpointBuilder for testing that implements the same interface as the real one.
+ * Can be seeded with blocks to return sequentially on each `buildBlock` call.
+ */ export class MockCheckpointBuilder {
+    constants;
+    checkpointNumber;
+    blocks;
+    builtBlocks;
+    usedTxsPerBlock;
+    blockIndex;
+    /** Optional function to dynamically provide the block (alternative to seedBlocks) */ blockProvider;
+    /** Track calls for assertions */ buildBlockCalls;
+    completeCheckpointCalled;
+    getCheckpointCalled;
+    /** Set to an error to make buildBlock throw on next call */ errorOnBuild;
+    constructor(constants, checkpointNumber){
+        this.constants = constants;
+        this.checkpointNumber = checkpointNumber;
+        this.blocks = [];
+        this.builtBlocks = [];
+        this.usedTxsPerBlock = [];
+        this.blockIndex = 0;
+        this.blockProvider = undefined;
+        this.buildBlockCalls = [];
+        this.completeCheckpointCalled = false;
+        this.getCheckpointCalled = false;
+        this.errorOnBuild = undefined;
+    }
+    /** Seed the builder with blocks to return on successive buildBlock calls */ seedBlocks(blocks, usedTxsPerBlock) {
+        this.blocks = blocks;
+        this.usedTxsPerBlock = usedTxsPerBlock ?? blocks.map(()=>[]);
+        this.blockIndex = 0;
+        this.blockProvider = undefined;
+        return this;
+    }
+    /**
+   * Set a function that provides blocks dynamically.
+   * Useful for tests where the block is determined at call time (e.g., sequencer tests).
+   */ setBlockProvider(provider) {
+        this.blockProvider = provider;
+        this.blocks = [];
+        return this;
+    }
+    getConstantData() {
+        return this.constants;
+    }
+    buildBlock(_pendingTxs, blockNumber, timestamp, opts) {
+        this.buildBlockCalls.push({
+            blockNumber,
+            timestamp,
+            opts
+        });
+        if (this.errorOnBuild) {
+            return Promise.reject(this.errorOnBuild);
+        }
+        let block;
+        let usedTxs;
+        if (this.blockProvider) {
+            // Dynamic mode: get block from provider
+            block = this.blockProvider();
+            usedTxs = [];
+            this.builtBlocks.push(block);
+        } else {
+            // Seeded mode: get block from pre-seeded list
+            block = this.blocks[this.blockIndex];
+            usedTxs = this.usedTxsPerBlock[this.blockIndex] ?? [];
+            this.blockIndex++;
+            this.builtBlocks.push(block);
+        }
+        return Promise.resolve({
+            block,
+            publicGas: Gas.empty(),
+            publicProcessorDuration: 0,
+            numTxs: block?.body?.txEffects?.length ?? usedTxs.length,
+            blockBuildingTimer: new Timer(),
+            usedTxs,
+            failedTxs: [],
+            usedTxBlobFields: block?.body?.txEffects?.reduce((sum, tx)=>sum + tx.getNumBlobFields(), 0) ?? 0
+        });
+    }
+    completeCheckpoint() {
+        this.completeCheckpointCalled = true;
+        const allBlocks = this.blockProvider ? this.builtBlocks : this.blocks;
+        const lastBlock = allBlocks[allBlocks.length - 1];
+        // Create a CheckpointHeader from the last block's header for testing
+        const checkpointHeader = this.createCheckpointHeader(lastBlock);
+        return Promise.resolve(new Checkpoint(makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1), checkpointHeader, allBlocks, this.checkpointNumber));
+    }
+    getCheckpoint() {
+        this.getCheckpointCalled = true;
+        const builtBlocks = this.blockProvider ? this.builtBlocks : this.blocks.slice(0, this.blockIndex);
+        const lastBlock = builtBlocks[builtBlocks.length - 1];
+        if (!lastBlock) {
+            throw new Error('No blocks built yet');
+        }
+        // Create a CheckpointHeader from the last block's header for testing
+        const checkpointHeader = this.createCheckpointHeader(lastBlock);
+        return Promise.resolve(new Checkpoint(makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1), checkpointHeader, builtBlocks, this.checkpointNumber));
+    }
+    /**
+   * Creates a CheckpointHeader from a block's header for testing.
+   * This is a simplified version that creates a minimal CheckpointHeader.
+   */ createCheckpointHeader(block) {
+        const header = block.header;
+        const gv = header.globalVariables;
+        return CheckpointHeader.empty({
+            lastArchiveRoot: header.lastArchive.root,
+            blockHeadersHash: Fr.random(),
+            slotNumber: gv.slotNumber,
+            timestamp: gv.timestamp,
+            coinbase: gv.coinbase,
+            feeRecipient: gv.feeRecipient,
+            gasFees: gv.gasFees,
+            totalManaUsed: header.totalManaUsed
+        });
+    }
+    /** Reset for reuse in another test */ reset() {
+        this.blocks = [];
+        this.builtBlocks = [];
+        this.usedTxsPerBlock = [];
+        this.blockIndex = 0;
+        this.buildBlockCalls = [];
+        this.completeCheckpointCalled = false;
+        this.getCheckpointCalled = false;
+        this.errorOnBuild = undefined;
+        this.blockProvider = undefined;
+    }
+}
+/**
+ * A fake CheckpointsBuilder (factory) for testing that implements the same interface
+ * as FullNodeCheckpointsBuilder. Returns MockCheckpointBuilder instances.
+ * Does NOT use jest mocks - this is a proper test double.
+ */ export class MockCheckpointsBuilder {
+    checkpointBuilder;
+    /** Track calls for assertions */ startCheckpointCalls = [];
+    openCheckpointCalls = [];
+    updateConfigCalls = [];
+    /**
+   * Set the MockCheckpointBuilder to return from startCheckpoint.
+   * Must be called before startCheckpoint is invoked.
+   */ setCheckpointBuilder(builder) {
+        this.checkpointBuilder = builder;
+        return this;
+    }
+    /**
+   * Creates a new MockCheckpointBuilder with the given constants.
+   * Convenience method that creates and sets the builder in one call.
+   */ createCheckpointBuilder(constants, checkpointNumber) {
+        this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+        return this.checkpointBuilder;
+    }
+    /** Get the current checkpoint builder (for assertions) */ getCheckpointBuilder() {
+        return this.checkpointBuilder;
+    }
+    getConfig() {
+        return {
+            l1GenesisTime: 0n,
+            slotDuration: 24,
+            l1ChainId: 1,
+            rollupVersion: 1
+        };
+    }
+    updateConfig(config) {
+        this.updateConfigCalls.push(config);
+    }
+    startCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, _fork) {
+        this.startCheckpointCalls.push({
+            checkpointNumber,
+            constants,
+            l1ToL2Messages,
+            previousCheckpointOutHashes
+        });
+        if (!this.checkpointBuilder) {
+            // Auto-create a builder if none was set
+            this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+        }
+        return Promise.resolve(this.checkpointBuilder);
+    }
+    openCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, _fork, existingBlocks = []) {
+        this.openCheckpointCalls.push({
+            checkpointNumber,
+            constants,
+            l1ToL2Messages,
+            previousCheckpointOutHashes,
+            existingBlocks
+        });
+        if (!this.checkpointBuilder) {
+            // Auto-create a builder if none was set
+            this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+        }
+        return Promise.resolve(this.checkpointBuilder);
+    }
+    getFork(_blockNumber) {
+        throw new Error('MockCheckpointsBuilder.getFork not implemented');
+    }
+    /** Reset for reuse in another test */ reset() {
+        this.checkpointBuilder = undefined;
+        this.startCheckpointCalls = [];
+        this.openCheckpointCalls = [];
+        this.updateConfigCalls = [];
+    }
+}

package/dest/test/utils.d.ts

@@ -0,0 +1,53 @@
+import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import type { P2P } from '@aztec/p2p';
+import { CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
+import { BlockProposal, CheckpointAttestation, CheckpointProposal } from '@aztec/stdlib/p2p';
+import { GlobalVariables, type Tx } from '@aztec/stdlib/tx';
+import type { MockProxy } from 'jest-mock-extended';
+export { MockCheckpointBuilder, MockCheckpointsBuilder } from './mock_checkpoint_builder.js';
+/**
+ * Creates a mock transaction with a specific seed for deterministic testing
+ */
+export declare function makeTx(seed?: number, chainId?: Fr): Promise<Tx>;
+/**
+ * Creates an L2Block from transactions and global variables
+ */
+export declare function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Promise<L2Block>;
+/**
+ * Mocks the P2P client to return specific pending transactions
+ */
+export declare function mockPendingTxs(p2p: MockProxy<P2P>, txs: Tx[]): void;
+/**
+ * Creates an async iterator for transactions
+ */
+export declare function mockTxIterator(txs: Promise<Tx[]>): AsyncIterableIterator<Tx>;
+/**
+ * Creates mock committee attestations from a signer
+ */
+export declare function createMockSignatures(signer: Secp256k1Signer): CommitteeAttestation[];
+/**
+ * Creates a block proposal from a block and signature
+ */
+export declare function createBlockProposal(block: L2Block, signature: Signature): BlockProposal;
+/**
+ * Creates a checkpoint proposal from a block and signature
+ */
+export declare function createCheckpointProposal(block: L2Block, checkpointSignature: Signature, blockSignature?: Signature): CheckpointProposal;
+/**
+ * Creates a checkpoint attestation from a block and signature.
+ * Note: We manually set the sender since we use random signatures in tests.
+ * In production, the sender is recovered from the signature.
+ */
+export declare function createCheckpointAttestation(block: L2Block, signature: Signature, sender: EthAddress): CheckpointAttestation;
+/**
+ * Creates transactions and a block, and mocks P2P to return them.
+ * Helper for tests that need to set up a block with transactions.
+ */
+export declare function setupTxsAndBlock(p2p: MockProxy<P2P>, globalVariables: GlobalVariables, txCount: number, chainId: Fr): Promise<{
+    txs: Tx[];
+    block: L2Block;
+}>;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/test/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,kBAAkB,EAAoB,MAAM,mBAAmB,CAAC;AAG/G,OAAO,EAAe,eAAe,EAAE,KAAK,EAAE,EAAoC,MAAM,kBAAkB,CAAC;AAE3G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAE7F;;GAEG;AACH,wBAAsB,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAMrE;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAgB7F;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,IAAI,CAGnE;AAED;;GAEG;AACH,wBAAuB,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,GAAG,qBAAqB,CAAC,EAAE,CAAC,CAInF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,eAAe,GAAG,oBAAoB,EAAE,CAGpF;AAuBD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,aAAa,CAUvF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,mBAAmB,EAAE,SAAS,EAC9B,cAAc,CAAC,EAAE,SAAS,GACzB,kBAAkB,CASpB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,UAAU,GACjB,qBAAqB,CAOvB;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,EACnB,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,EAAE,GACV,OAAO,CAAC;IAAE,GAAG,EAAE,EAAE,EAAE,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,CAKxC"}

package/dest/test/utils.js

@@ -0,0 +1,103 @@
+import { Body } from '@aztec/aztec.js/block';
+import { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+import { times } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
+import { BlockProposal, CheckpointAttestation, CheckpointProposal, ConsensusPayload } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeAppendOnlyTreeSnapshot, mockTxForRollup } from '@aztec/stdlib/testing';
+import { BlockHeader, makeProcessedTxFromPrivateOnlyTx } from '@aztec/stdlib/tx';
+// Re-export mock classes from their dedicated file
+export { MockCheckpointBuilder, MockCheckpointsBuilder } from './mock_checkpoint_builder.js';
+/**
+ * Creates a mock transaction with a specific seed for deterministic testing
+ */ export async function makeTx(seed, chainId) {
+    const tx = await mockTxForRollup(seed);
+    if (chainId) {
+        tx.data.constants.txContext.chainId = chainId;
+    }
+    return tx;
+}
+/**
+ * Creates an L2Block from transactions and global variables
+ */ export async function makeBlock(txs, globalVariables) {
+    const processedTxs = await Promise.all(txs.map((tx)=>makeProcessedTxFromPrivateOnlyTx(tx, Fr.ZERO, new PublicDataWrite(Fr.random(), Fr.random()), globalVariables)));
+    const body = new Body(processedTxs.map((tx)=>tx.txEffect));
+    const header = BlockHeader.empty({
+        globalVariables
+    });
+    const archive = makeAppendOnlyTreeSnapshot(globalVariables.blockNumber + 1);
+    return new L2Block(archive, header, body, CheckpointNumber.fromBlockNumber(globalVariables.blockNumber), IndexWithinCheckpoint(0));
+}
+/**
+ * Mocks the P2P client to return specific pending transactions
+ */ export function mockPendingTxs(p2p, txs) {
+    p2p.getPendingTxCount.mockResolvedValue(txs.length);
+    p2p.iteratePendingTxs.mockImplementation(()=>mockTxIterator(Promise.resolve(txs)));
+}
+/**
+ * Creates an async iterator for transactions
+ */ export async function* mockTxIterator(txs) {
+    for (const tx of (await txs)){
+        yield tx;
+    }
+}
+/**
+ * Creates mock committee attestations from a signer
+ */ export function createMockSignatures(signer) {
+    const mockedSig = Signature.random();
+    return [
+        new CommitteeAttestation(signer.address, mockedSig)
+    ];
+}
+/**
+ * Creates a CheckpointHeader from an L2Block for testing purposes.
+ * Uses mock values for blockHeadersHash, blobsHash and inHash since L2Block doesn't have these fields.
+ */ function createCheckpointHeaderFromBlock(block) {
+    const gv = block.header.globalVariables;
+    return new CheckpointHeader(block.header.lastArchive.root, Fr.random(), Fr.random(), Fr.random(), Fr.random(), gv.slotNumber, gv.timestamp, gv.coinbase, gv.feeRecipient, gv.gasFees, block.header.totalManaUsed);
+}
+/**
+ * Creates a block proposal from a block and signature
+ */ export function createBlockProposal(block, signature) {
+    const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
+    return new BlockProposal(block.header, block.indexWithinCheckpoint, Fr.ZERO, block.archive.root, txHashes, signature);
+}
+/**
+ * Creates a checkpoint proposal from a block and signature
+ */ export function createCheckpointProposal(block, checkpointSignature, blockSignature) {
+    const txHashes = block.body.txEffects.map((tx)=>tx.txHash);
+    const checkpointHeader = createCheckpointHeaderFromBlock(block);
+    return new CheckpointProposal(checkpointHeader, block.archive.root, checkpointSignature, {
+        blockHeader: block.header,
+        indexWithinCheckpoint: block.indexWithinCheckpoint,
+        txHashes,
+        signature: blockSignature ?? checkpointSignature
+    });
+}
+/**
+ * Creates a checkpoint attestation from a block and signature.
+ * Note: We manually set the sender since we use random signatures in tests.
+ * In production, the sender is recovered from the signature.
+ */ export function createCheckpointAttestation(block, signature, sender) {
+    const checkpointHeader = createCheckpointHeaderFromBlock(block);
+    const payload = new ConsensusPayload(checkpointHeader, block.archive.root);
+    const attestation = new CheckpointAttestation(payload, signature, signature);
+    // Set sender directly for testing (bypasses signature recovery)
+    attestation.sender = sender;
+    return attestation;
+}
+/**
+ * Creates transactions and a block, and mocks P2P to return them.
+ * Helper for tests that need to set up a block with transactions.
+ */ export async function setupTxsAndBlock(p2p, globalVariables, txCount, chainId) {
+    const txs = await Promise.all(times(txCount, (i)=>makeTx(i + 1, chainId)));
+    const block = await makeBlock(txs, globalVariables);
+    mockPendingTxs(p2p, txs);
+    return {
+        txs,
+        block
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/sequencer-client",
-  "version": "0.0.1-commit.b655e406",
+  "version": "0.0.1-commit.d1f2d6c",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -18,50 +18,53 @@
     "../package.common.json"
   ],
   "scripts": {
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
     "test:integration": "concurrently -k -s first -c reset,dim -n test,anvil \"yarn test:integration:run\" \"anvil\"",
     "test:integration:run": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --no-cache --config jest.integration.config.json"
   },
   "dependencies": {
-    "@aztec/aztec.js": "0.0.1-commit.b655e406",
-    "@aztec/bb-prover": "0.0.1-commit.b655e406",
-    "@aztec/blob-lib": "0.0.1-commit.b655e406",
-    "@aztec/blob-sink": "0.0.1-commit.b655e406",
-    "@aztec/constants": "0.0.1-commit.b655e406",
-    "@aztec/epoch-cache": "0.0.1-commit.b655e406",
-    "@aztec/ethereum": "0.0.1-commit.b655e406",
-    "@aztec/foundation": "0.0.1-commit.b655e406",
-    "@aztec/l1-artifacts": "0.0.1-commit.b655e406",
-    "@aztec/merkle-tree": "0.0.1-commit.b655e406",
-    "@aztec/node-keystore": "0.0.1-commit.b655e406",
-    "@aztec/noir-acvm_js": "0.0.1-commit.b655e406",
-    "@aztec/noir-contracts.js": "0.0.1-commit.b655e406",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.b655e406",
-    "@aztec/noir-types": "0.0.1-commit.b655e406",
-    "@aztec/p2p": "0.0.1-commit.b655e406",
-    "@aztec/protocol-contracts": "0.0.1-commit.b655e406",
-    "@aztec/prover-client": "0.0.1-commit.b655e406",
-    "@aztec/simulator": "0.0.1-commit.b655e406",
-    "@aztec/slasher": "0.0.1-commit.b655e406",
-    "@aztec/stdlib": "0.0.1-commit.b655e406",
-    "@aztec/telemetry-client": "0.0.1-commit.b655e406",
-    "@aztec/validator-client": "0.0.1-commit.b655e406",
-    "@aztec/world-state": "0.0.1-commit.b655e406",
+    "@aztec/aztec.js": "0.0.1-commit.d1f2d6c",
+    "@aztec/bb-prover": "0.0.1-commit.d1f2d6c",
+    "@aztec/blob-client": "0.0.1-commit.d1f2d6c",
+    "@aztec/blob-lib": "0.0.1-commit.d1f2d6c",
+    "@aztec/constants": "0.0.1-commit.d1f2d6c",
+    "@aztec/epoch-cache": "0.0.1-commit.d1f2d6c",
+    "@aztec/ethereum": "0.0.1-commit.d1f2d6c",
+    "@aztec/foundation": "0.0.1-commit.d1f2d6c",
+    "@aztec/l1-artifacts": "0.0.1-commit.d1f2d6c",
+    "@aztec/merkle-tree": "0.0.1-commit.d1f2d6c",
+    "@aztec/node-keystore": "0.0.1-commit.d1f2d6c",
+    "@aztec/noir-acvm_js": "0.0.1-commit.d1f2d6c",
+    "@aztec/noir-contracts.js": "0.0.1-commit.d1f2d6c",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.d1f2d6c",
+    "@aztec/noir-types": "0.0.1-commit.d1f2d6c",
+    "@aztec/p2p": "0.0.1-commit.d1f2d6c",
+    "@aztec/protocol-contracts": "0.0.1-commit.d1f2d6c",
+    "@aztec/prover-client": "0.0.1-commit.d1f2d6c",
+    "@aztec/simulator": "0.0.1-commit.d1f2d6c",
+    "@aztec/slasher": "0.0.1-commit.d1f2d6c",
+    "@aztec/stdlib": "0.0.1-commit.d1f2d6c",
+    "@aztec/telemetry-client": "0.0.1-commit.d1f2d6c",
+    "@aztec/validator-client": "0.0.1-commit.d1f2d6c",
+    "@aztec/validator-ha-signer": "0.0.1-commit.d1f2d6c",
+    "@aztec/world-state": "0.0.1-commit.d1f2d6c",
     "lodash.chunk": "^4.2.0",
     "tslib": "^2.4.0",
-    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0"
+    "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.0.1-commit.b655e406",
-    "@aztec/kv-store": "0.0.1-commit.b655e406",
+    "@aztec/archiver": "0.0.1-commit.d1f2d6c",
+    "@aztec/kv-store": "0.0.1-commit.d1f2d6c",
+    "@electric-sql/pglite": "^0.3.14",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.chunk": "^4.2.7",
     "@types/lodash.pick": "^4.4.7",
     "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "concurrently": "^7.6.0",
     "eslint": "^9.26.0",
     "express": "^4.21.2",

package/src/client/sequencer-client.ts

@@ -1,29 +1,22 @@
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
 import { EpochCache } from '@aztec/epoch-cache';
-import {
-  GovernanceProposerContract,
-  PublisherManager,
-  RollupContract,
-  getPublicClient,
-  isAnvilTestChain,
-} from '@aztec/ethereum';
+import { isAnvilTestChain } from '@aztec/ethereum/chain';
+import { getPublicClient } from '@aztec/ethereum/client';
+import { GovernanceProposerContract, RollupContract } from '@aztec/ethereum/contracts';
 import { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import { PublisherManager } from '@aztec/ethereum/publisher-manager';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { KeystoreManager } from '@aztec/node-keystore';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-import type {
-  IFullNodeBlockBuilder,
-  ValidatorClientFullConfig,
-  WorldStateSynchronizer,
-} from '@aztec/stdlib/interfaces/server';
+import type { L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { L1Metrics, type TelemetryClient } from '@aztec/telemetry-client';
-import { NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
+import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
 
 import type { SequencerClientConfig } from '../config.js';
 import { GlobalVariableBuilder } from '../global_variable_builder/index.js';
@@ -37,7 +30,7 @@ export class SequencerClient {
   constructor(
     protected publisherManager: PublisherManager<L1TxUtilsWithBlobs>,
     protected sequencer: Sequencer,
-    protected blockBuilder: IFullNodeBlockBuilder,
+    protected checkpointsBuilder: FullNodeCheckpointsBuilder,
     protected validatorClient?: ValidatorClient,
     private l1Metrics?: L1Metrics,
   ) {}
@@ -57,16 +50,16 @@ export class SequencerClient {
   public static async new(
     config: SequencerClientConfig,
     deps: {
-      validatorClient: ValidatorClient | undefined; // allowed to be undefined while we migrate
+      validatorClient: ValidatorClient;
       p2pClient: P2P;
       worldStateSynchronizer: WorldStateSynchronizer;
       slasherClient: SlasherClientInterface | undefined;
-      blockBuilder: IFullNodeBlockBuilder;
-      l2BlockSource: L2BlockSource;
+      checkpointsBuilder: FullNodeCheckpointsBuilder;
+      l2BlockSource: L2BlockSource & L2BlockSink;
       l1ToL2MessageSource: L1ToL2MessageSource;
       telemetry: TelemetryClient;
       publisherFactory?: SequencerPublisherFactory;
-      blobSinkClient?: BlobSinkClientInterface;
+      blobClient: BlobClientInterface;
       dateProvider: DateProvider;
       epochCache?: EpochCache;
       l1TxUtils: L1TxUtilsWithBlobs[];
@@ -78,7 +71,7 @@ export class SequencerClient {
       p2pClient,
       worldStateSynchronizer,
       slasherClient,
-      blockBuilder,
+      checkpointsBuilder,
       l2BlockSource,
       l1ToL2MessageSource,
       telemetry: telemetryClient,
@@ -94,9 +87,11 @@ export class SequencerClient {
     );
     const publisherManager = new PublisherManager(l1TxUtils, config);
     const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
-    const [l1GenesisTime, slotDuration] = await Promise.all([
+    const [l1GenesisTime, slotDuration, rollupVersion, rollupManaLimit] = await Promise.all([
       rollupContract.getL1GenesisTime(),
       rollupContract.getSlotDuration(),
+      rollupContract.getVersion(),
+      rollupContract.getManaLimit().then(Number),
     ] as const);
 
     const governanceProposerContract = new GovernanceProposerContract(
@@ -125,7 +120,7 @@ export class SequencerClient {
       deps.publisherFactory ??
       new SequencerPublisherFactory(config, {
         telemetry: telemetryClient,
-        blobSinkClient: deps.blobSinkClient,
+        blobClient: deps.blobClient,
         epochCache,
         governanceProposerContract,
         slashFactoryContract,
@@ -135,33 +130,27 @@ export class SequencerClient {
         nodeKeyStore: NodeKeystoreAdapter.fromKeyStoreManager(deps.nodeKeyStore),
         logger: log,
       });
-    const globalsBuilder = new GlobalVariableBuilder(config);
 
     const ethereumSlotDuration = config.ethereumSlotDuration;
+    const l1Constants = { l1GenesisTime, slotDuration: Number(slotDuration), ethereumSlotDuration };
+
+    const globalsBuilder = new GlobalVariableBuilder({ ...config, ...l1Constants, rollupVersion });
 
-    const rollupManaLimit = Number(await rollupContract.getManaLimit());
     let sequencerManaLimit = config.maxL2BlockGas ?? rollupManaLimit;
     if (sequencerManaLimit > rollupManaLimit) {
       log.warn(
-        `Provided maxL2BlockGas of ${sequencerManaLimit} is greater than the maximum allowed by the L1 (${rollupManaLimit}), setting limit to ${rollupManaLimit}`,
+        `Provided maxL2BlockGas ${sequencerManaLimit} is greater than the max allowed by L1. Setting limit to ${rollupManaLimit}.`,
       );
       sequencerManaLimit = rollupManaLimit;
     }
 
     // When running in anvil, assume we can post a tx up until one second before the end 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.
+    // Otherwise, we need the full L1 slot duration for publishing to ensure inclusion.
     // 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.
+    // reduce the publishing time allowance. 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 - 1 : 0;
-
-    const l1Constants = {
-      l1GenesisTime,
-      slotDuration: Number(slotDuration),
-      ethereumSlotDuration,
-    };
+    const l1PublishingTimeBasedOnChain = isAnvilTestChain(config.l1ChainId) ? 1 : ethereumSlotDuration;
+    const l1PublishingTime = config.l1PublishingTime ?? l1PublishingTimeBasedOnChain;
 
     const sequencer = new Sequencer(
       publisherFactory,
@@ -172,19 +161,19 @@ export class SequencerClient {
       slasherClient,
       l2BlockSource,
       l1ToL2MessageSource,
-      blockBuilder,
+      checkpointsBuilder,
       l1Constants,
       deps.dateProvider,
       epochCache,
       rollupContract,
-      { ...config, maxL1TxInclusionTimeIntoSlot, maxL2BlockGas: sequencerManaLimit },
+      { ...config, l1PublishingTime, maxL2BlockGas: sequencerManaLimit },
       telemetryClient,
       log,
     );
 
     await sequencer.init();
 
-    return new SequencerClient(publisherManager, sequencer, blockBuilder, validatorClient, l1Metrics);
+    return new SequencerClient(publisherManager, sequencer, checkpointsBuilder, validatorClient, l1Metrics);
   }
 
   /**
@@ -193,7 +182,7 @@ export class SequencerClient {
    */
   public updateConfig(config: SequencerConfig & Partial<ValidatorClientFullConfig>) {
     this.sequencer.updateConfig(config);
-    this.blockBuilder.updateConfig(config);
+    this.checkpointsBuilder.updateConfig(config);
     this.validatorClient?.updateConfig(config);
   }