@aztec/sequencer-client 0.0.0-test.0

package/dest/tx_validator/nullifier_cache.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { NullifierSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+/**
+ * Implements a nullifier source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export declare class NullifierCache implements NullifierSource {
+    private db;
+    nullifiers: Set<string>;
+    constructor(db: MerkleTreeReadOperations);
+    nullifiersExist(nullifiers: Buffer[]): Promise<boolean[]>;
+    addNullifiers(nullifiers: Buffer[]): void;
+}
+//# sourceMappingURL=nullifier_cache.d.ts.map

package/dest/tx_validator/nullifier_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullifier_cache.d.ts","sourceRoot":"","sources":["../../src/tx_validator/nullifier_cache.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF;;;GAGG;AACH,qBAAa,cAAe,YAAW,eAAe;IAGxC,OAAO,CAAC,EAAE;IAFtB,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;gBAEJ,EAAE,EAAE,wBAAwB;IAInC,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAS/D,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE;CAK1C"}

package/dest/tx_validator/nullifier_cache.js

@@ -0,0 +1,24 @@
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+/**
+ * Implements a nullifier source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */ export class NullifierCache {
+    db;
+    nullifiers;
+    constructor(db){
+        this.db = db;
+        this.nullifiers = new Set();
+    }
+    async nullifiersExist(nullifiers) {
+        const cacheResults = nullifiers.map((n)=>this.nullifiers.has(n.toString()));
+        const toCheckDb = nullifiers.filter((_n, index)=>!cacheResults[index]);
+        const dbHits = await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, toCheckDb);
+        let dbIndex = 0;
+        return nullifiers.map((_n, index)=>cacheResults[index] || dbHits[dbIndex++] !== undefined);
+    }
+    addNullifiers(nullifiers) {
+        for (const nullifier of nullifiers){
+            this.nullifiers.add(nullifier.toString());
+        }
+    }
+}

package/dest/tx_validator/phases_validator.d.ts

@@ -0,0 +1,12 @@
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+import { type PublicExecutionRequest, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+export declare class PhasesTxValidator implements TxValidator<Tx> {
+    #private;
+    private setupAllowList;
+    private contractDataSource;
+    constructor(contracts: ContractDataSource, setupAllowList: AllowedElement[]);
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+    isOnAllowList(publicCall: PublicExecutionRequest, allowList: AllowedElement[]): Promise<boolean>;
+}
+//# sourceMappingURL=phases_validator.d.ts.map

package/dest/tx_validator/phases_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phases_validator.d.ts","sourceRoot":"","sources":["../../src/tx_validator/phases_validator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EACL,KAAK,sBAAsB,EAC3B,EAAE,EAEF,KAAK,kBAAkB,EACvB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,iBAAkB,YAAW,WAAW,CAAC,EAAE,CAAC;;IAIZ,OAAO,CAAC,cAAc;IAFjE,OAAO,CAAC,kBAAkB,CAA8B;gBAE5C,SAAS,EAAE,kBAAkB,EAAU,cAAc,EAAE,cAAc,EAAE;IAI7E,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAgC/C,aAAa,CAAC,UAAU,EAAE,sBAAsB,EAAE,SAAS,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CA6CvG"}

package/dest/tx_validator/phases_validator.js

@@ -0,0 +1,80 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ContractsDataSourcePublicDB, getExecutionRequestsByPhase } from '@aztec/simulator/server';
+import { Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+export class PhasesTxValidator {
+    setupAllowList;
+    #log;
+    contractDataSource;
+    constructor(contracts, setupAllowList){
+        this.setupAllowList = setupAllowList;
+        this.#log = createLogger('sequencer:tx_validator:tx_phases');
+        this.contractDataSource = new ContractsDataSourcePublicDB(contracts);
+    }
+    async validateTx(tx) {
+        try {
+            // TODO(@spalladino): We add this just to handle public authwit-check calls during setup
+            // which are needed for public FPC flows, but fail if the account contract hasnt been deployed yet,
+            // which is what we're trying to do as part of the current txs.
+            await this.contractDataSource.addNewContracts(tx);
+            if (!tx.data.forPublic) {
+                this.#log.debug(`Tx ${Tx.getHash(tx)} does not contain enqueued public functions. Skipping phases validation.`);
+                return {
+                    result: 'valid'
+                };
+            }
+            const setupFns = getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP);
+            for (const setupFn of setupFns){
+                if (!await this.isOnAllowList(setupFn, this.setupAllowList)) {
+                    this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because it calls setup function not on allow list: ${setupFn.callContext.contractAddress}:${setupFn.callContext.functionSelector}`, {
+                        allowList: this.setupAllowList
+                    });
+                    return {
+                        result: 'invalid',
+                        reason: [
+                            'Setup function not on allow list'
+                        ]
+                    };
+                }
+            }
+            return {
+                result: 'valid'
+            };
+        } finally{
+            this.contractDataSource.clearContractsForTx();
+        }
+    }
+    async isOnAllowList(publicCall, allowList) {
+        if (publicCall.isEmpty()) {
+            return true;
+        }
+        const { contractAddress, functionSelector } = publicCall.callContext;
+        // do these checks first since they don't require the contract class
+        for (const entry of allowList){
+            if ('address' in entry && !('selector' in entry)) {
+                if (contractAddress.equals(entry.address)) {
+                    return true;
+                }
+            }
+            if ('address' in entry && 'selector' in entry) {
+                if (contractAddress.equals(entry.address) && entry.selector.equals(functionSelector)) {
+                    return true;
+                }
+            }
+            const contractClass = await this.contractDataSource.getContractInstance(contractAddress);
+            if (!contractClass) {
+                throw new Error(`Contract not found: ${contractAddress}`);
+            }
+            if ('classId' in entry && !('selector' in entry)) {
+                if (contractClass.currentContractClassId.equals(entry.classId)) {
+                    return true;
+                }
+            }
+            if ('classId' in entry && 'selector' in entry) {
+                if (contractClass.currentContractClassId.equals(entry.classId) && (entry.selector === undefined || entry.selector.equals(functionSelector))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

package/dest/tx_validator/test_utils.d.ts

@@ -0,0 +1,23 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Tx } from '@aztec/stdlib/tx';
+export declare function patchNonRevertibleFn(tx: Tx, index: number, overrides: {
+    address?: AztecAddress;
+    selector: FunctionSelector;
+    args?: Fr[];
+    msgSender?: AztecAddress;
+}): Promise<{
+    address: AztecAddress;
+    selector: FunctionSelector;
+}>;
+export declare function patchRevertibleFn(tx: Tx, index: number, overrides: {
+    address?: AztecAddress;
+    selector: FunctionSelector;
+    args?: Fr[];
+    msgSender?: AztecAddress;
+}): Promise<{
+    address: AztecAddress;
+    selector: FunctionSelector;
+}>;
+//# sourceMappingURL=test_utils.d.ts.map

package/dest/tx_validator/test_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../src/tx_validator/test_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3C,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,OAAO,CAAC,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAC;IAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,YAAY,CAAA;CAAE,GACvG,OAAO,CAAC;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAEhE;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,EAAE,EACN,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,OAAO,CAAC,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAC;IAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,YAAY,CAAA;CAAE,GACvG,OAAO,CAAC;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAEhE"}

package/dest/tx_validator/test_utils.js

@@ -0,0 +1,26 @@
+import { computeVarArgsHash } from '@aztec/stdlib/hash';
+export function patchNonRevertibleFn(tx, index, overrides) {
+    return patchFn('nonRevertibleAccumulatedData', tx, index, overrides);
+}
+export function patchRevertibleFn(tx, index, overrides) {
+    return patchFn('revertibleAccumulatedData', tx, index, overrides);
+}
+async function patchFn(where, tx, index, overrides) {
+    const fn = tx.enqueuedPublicFunctionCalls.at(-1 * index - 1);
+    fn.callContext.contractAddress = overrides.address ?? fn.callContext.contractAddress;
+    fn.callContext.functionSelector = overrides.selector;
+    fn.args = overrides.args ?? fn.args;
+    fn.callContext.msgSender = overrides.msgSender ?? fn.callContext.msgSender;
+    tx.enqueuedPublicFunctionCalls[index] = fn;
+    const request = tx.data.forPublic[where].publicCallRequests[index];
+    request.contractAddress = fn.callContext.contractAddress;
+    request.msgSender = fn.callContext.msgSender;
+    request.functionSelector = fn.callContext.functionSelector;
+    request.isStaticCall = fn.callContext.isStaticCall;
+    request.argsHash = await computeVarArgsHash(fn.args);
+    tx.data.forPublic[where].publicCallRequests[index] = request;
+    return {
+        address: fn.callContext.contractAddress,
+        selector: fn.callContext.functionSelector
+    };
+}

package/dest/tx_validator/tx_validator_factory.d.ts

@@ -0,0 +1,18 @@
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { GasFees } from '@aztec/stdlib/gas';
+import type { AllowedElement, ClientProtocolCircuitVerifier, MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { GlobalVariables, type ProcessedTx, type Tx, type TxValidator } from '@aztec/stdlib/tx';
+import { NullifierCache } from './nullifier_cache.js';
+export declare function createValidatorForAcceptingTxs(db: MerkleTreeReadOperations, contractDataSource: ContractDataSource, verifier: ClientProtocolCircuitVerifier | undefined, { blockNumber, l1ChainId, setupAllowList, gasFees, skipFeeEnforcement, }: {
+    blockNumber: number;
+    l1ChainId: number;
+    setupAllowList: AllowedElement[];
+    gasFees: GasFees;
+    skipFeeEnforcement?: boolean;
+}): TxValidator<Tx>;
+export declare function createValidatorsForBlockBuilding(db: MerkleTreeReadOperations, contractDataSource: ContractDataSource, globalVariables: GlobalVariables, setupAllowList: AllowedElement[]): {
+    preprocessValidator: TxValidator<Tx>;
+    postprocessValidator: TxValidator<ProcessedTx>;
+    nullifierCache: NullifierCache;
+};
+//# sourceMappingURL=tx_validator_factory.d.ts.map

package/dest/tx_validator/tx_validator_factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_validator_factory.d.ts","sourceRoot":"","sources":["../../src/tx_validator/tx_validator_factory.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EACV,cAAc,EACd,6BAA6B,EAC7B,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,EAAE,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAIhG,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,wBAAgB,8BAA8B,CAC5C,EAAE,EAAE,wBAAwB,EAC5B,kBAAkB,EAAE,kBAAkB,EACtC,QAAQ,EAAE,6BAA6B,GAAG,SAAS,EACnD,EACE,WAAW,EACX,SAAS,EACT,cAAc,EACd,OAAO,EACP,kBAAkB,GACnB,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,cAAc,EAAE,CAAC;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,GACA,WAAW,CAAC,EAAE,CAAC,CAkBjB;AAED,wBAAgB,gCAAgC,CAC9C,EAAE,EAAE,wBAAwB,EAC5B,kBAAkB,EAAE,kBAAkB,EACtC,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,cAAc,EAAE,GAC/B;IACD,mBAAmB,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;IACrC,oBAAoB,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAC/C,cAAc,EAAE,cAAc,CAAC;CAChC,CAiBA"}

package/dest/tx_validator/tx_validator_factory.js

@@ -0,0 +1,50 @@
+import { Fr } from '@aztec/foundation/fields';
+import { AggregateTxValidator, BlockHeaderTxValidator, DataTxValidator, DoubleSpendTxValidator, MetadataTxValidator, TxProofValidator } from '@aztec/p2p';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { readPublicState } from '@aztec/simulator/server';
+import { ArchiveCache } from './archive_cache.js';
+import { GasTxValidator } from './gas_validator.js';
+import { NullifierCache } from './nullifier_cache.js';
+import { PhasesTxValidator } from './phases_validator.js';
+export function createValidatorForAcceptingTxs(db, contractDataSource, verifier, { blockNumber, l1ChainId, setupAllowList, gasFees, skipFeeEnforcement }) {
+    const validators = [
+        new DataTxValidator(),
+        new MetadataTxValidator(new Fr(l1ChainId), new Fr(blockNumber)),
+        new DoubleSpendTxValidator(new NullifierCache(db)),
+        new PhasesTxValidator(contractDataSource, setupAllowList),
+        new BlockHeaderTxValidator(new ArchiveCache(db))
+    ];
+    if (!skipFeeEnforcement) {
+        validators.push(new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, gasFees));
+    }
+    if (verifier) {
+        validators.push(new TxProofValidator(verifier));
+    }
+    return new AggregateTxValidator(...validators);
+}
+export function createValidatorsForBlockBuilding(db, contractDataSource, globalVariables, setupAllowList) {
+    const nullifierCache = new NullifierCache(db);
+    const archiveCache = new ArchiveCache(db);
+    const publicStateSource = new DatabasePublicStateSource(db);
+    return {
+        preprocessValidator: preprocessValidator(nullifierCache, archiveCache, publicStateSource, contractDataSource, globalVariables, setupAllowList),
+        postprocessValidator: postprocessValidator(nullifierCache),
+        nullifierCache
+    };
+}
+class DatabasePublicStateSource {
+    db;
+    constructor(db){
+        this.db = db;
+    }
+    storageRead(contractAddress, slot) {
+        return readPublicState(this.db, contractAddress, slot);
+    }
+}
+function preprocessValidator(nullifierCache, archiveCache, publicStateSource, contractDataSource, globalVariables, setupAllowList) {
+    // We don't include the TxProofValidator nor the DataTxValidator here because they are already checked by the time we get to block building.
+    return new AggregateTxValidator(new MetadataTxValidator(globalVariables.chainId, globalVariables.blockNumber), new DoubleSpendTxValidator(nullifierCache), new PhasesTxValidator(contractDataSource, setupAllowList), new GasTxValidator(publicStateSource, ProtocolContractAddress.FeeJuice, globalVariables.gasFees), new BlockHeaderTxValidator(archiveCache));
+}
+function postprocessValidator(nullifierCache) {
+    return new DoubleSpendTxValidator(nullifierCache);
+}

package/package.json

@@ -0,0 +1,121 @@
+{
+  "name": "@aztec/sequencer-client",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./config": "./dest/config.js",
+    "./test": "./dest/test/index.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Sequencer Client",
+    "tsconfig": "./tsconfig.json"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "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.0-test.0",
+    "@aztec/bb-prover": "0.0.0-test.0",
+    "@aztec/blob-lib": "0.0.0-test.0",
+    "@aztec/blob-sink": "0.0.0-test.0",
+    "@aztec/constants": "0.0.0-test.0",
+    "@aztec/epoch-cache": "0.0.0-test.0",
+    "@aztec/ethereum": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/l1-artifacts": "0.0.0-test.0",
+    "@aztec/merkle-tree": "0.0.0-test.0",
+    "@aztec/noir-contracts.js": "0.0.0-test.0",
+    "@aztec/noir-protocol-circuits-types": "0.0.0-test.0",
+    "@aztec/p2p": "0.0.0-test.0",
+    "@aztec/protocol-contracts": "0.0.0-test.0",
+    "@aztec/prover-client": "0.0.0-test.0",
+    "@aztec/simulator": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "@aztec/telemetry-client": "0.0.0-test.0",
+    "@aztec/validator-client": "0.0.0-test.0",
+    "@aztec/world-state": "0.0.0-test.0",
+    "lodash.chunk": "^4.2.0",
+    "lodash.pick": "^4.4.0",
+    "tslib": "^2.4.0",
+    "viem": "2.22.8",
+    "@aztec/noir-acvm_js": "0.0.0-test.0",
+    "@aztec/noir-types": "0.0.0-test.0"
+  },
+  "devDependencies": {
+    "@aztec/archiver": "0.0.0-test.0",
+    "@aztec/kv-store": "0.0.0-test.0",
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/levelup": "^5.1.2",
+    "@types/lodash.chunk": "^4.2.7",
+    "@types/lodash.pick": "^4.4.7",
+    "@types/memdown": "^3.0.0",
+    "@types/node": "^18.7.23",
+    "concurrently": "^7.6.0",
+    "eslint": "^8.37.0",
+    "express": "^4.21.1",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.3",
+    "levelup": "^5.1.1",
+    "memdown": "^6.1.1",
+    "prettier": "^2.8.7",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "jest": {
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  }
+}

package/src/client/index.ts

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

package/src/client/sequencer-client.ts

@@ -0,0 +1,219 @@
+import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+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 type { DateProvider } from '@aztec/foundation/timer';
+import type { P2P } from '@aztec/p2p';
+import { LightweightBlockBuilderFactory } from '@aztec/prover-client/block-builder';
+import { PublicProcessorFactory } from '@aztec/simulator/server';
+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 { GlobalVariableBuilder } from '../global_variable_builder/index.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 class SequencerClient {
+  constructor(protected 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.
+   */
+  public static async new(
+    config: SequencerClientConfig,
+    deps: {
+      validatorClient: ValidatorClient | undefined; // allowed to be undefined while we migrate
+      p2pClient: P2P;
+      worldStateSynchronizer: WorldStateSynchronizer;
+      slasherClient: SlasherClient;
+      contractDataSource: ContractDataSource;
+      l2BlockSource: L2BlockSource;
+      l1ToL2MessageSource: L1ToL2MessageSource;
+      telemetry: TelemetryClient;
+      publisher?: SequencerPublisher;
+      blobSinkClient?: BlobSinkClientInterface;
+      dateProvider: DateProvider;
+      epochCache?: EpochCache;
+      l1TxUtils?: L1TxUtilsWithBlobs;
+    },
+  ) {
+    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(),
+    ] as const);
+    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.
+   */
+  public updateSequencerConfig(config: SequencerConfig) {
+    return this.sequencer.updateConfig(config);
+  }
+
+  /**
+   * Stops the sequencer from processing new txs.
+   */
+  public async stop() {
+    await this.sequencer.stop();
+  }
+
+  /** Forces the sequencer to bypass all time and tx count checks for the next block and build anyway. */
+  public flush() {
+    this.sequencer.flush();
+  }
+
+  /**
+   * Restarts the sequencer after being stopped.
+   */
+  public restart() {
+    this.sequencer.restart();
+  }
+
+  get coinbase(): EthAddress {
+    return this.sequencer.coinbase;
+  }
+
+  get feeRecipient(): AztecAddress {
+    return this.sequencer.feeRecipient;
+  }
+
+  get forwarderAddress(): EthAddress {
+    return this.sequencer.getForwarderAddress();
+  }
+}