@aztec/sequencer-client 0.1.0-alpha11

package/dest/sequencer/public_processor.js

@@ -0,0 +1,195 @@
+import { isPublicExecutionResult } from '@aztec/acir-simulator';
+import { AztecAddress, CircuitsWasm, ContractStorageRead, ContractStorageUpdateRequest, Fr, KERNEL_PUBLIC_DATA_READS_LENGTH, KERNEL_PUBLIC_DATA_UPDATE_REQUESTS_LENGTH, MembershipWitness, NEW_COMMITMENTS_LENGTH, NEW_L2_TO_L1_MSGS_LENGTH, NEW_NULLIFIERS_LENGTH, PUBLIC_CALL_STACK_LENGTH, PreviousKernelData, PublicCallData, PublicCallStackItem, PublicCircuitPublicInputs, PublicKernelInputs, RETURN_VALUES_LENGTH, VK_TREE_HEIGHT, } from '@aztec/circuits.js';
+import { computeCallStackItemHash, computeVarArgsHash } from '@aztec/circuits.js/abis';
+import { isArrayEmpty, padArrayEnd, padArrayStart } from '@aztec/foundation/collection';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { mapTuple, to2Fields } from '@aztec/foundation/serialize';
+import { MerkleTreeId } from '@aztec/types';
+import { getVerificationKeys } from '../index.js';
+import { EmptyPublicProver } from '../prover/empty.js';
+import { getPublicExecutor } from '../simulator/public_executor.js';
+import { WasmPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
+import { makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
+import { getCombinedHistoricTreeRoots } from './utils.js';
+/**
+ * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
+ */
+export class PublicProcessorFactory {
+    constructor(merkleTree, contractDataSource, l1Tol2MessagesDataSource) {
+        this.merkleTree = merkleTree;
+        this.contractDataSource = contractDataSource;
+        this.l1Tol2MessagesDataSource = l1Tol2MessagesDataSource;
+    }
+    /**
+     * Creates a new instance of a PublicProcessor.
+     * @returns A new instance of a PublicProcessor.
+     */
+    create() {
+        return new PublicProcessor(this.merkleTree, getPublicExecutor(this.merkleTree, this.contractDataSource, this.l1Tol2MessagesDataSource), new WasmPublicKernelCircuitSimulator(), new EmptyPublicProver(), this.contractDataSource);
+    }
+}
+/**
+ * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
+ * any public function calls in them. Txs with private calls only are unaffected.
+ */
+export class PublicProcessor {
+    constructor(db, publicExecutor, publicKernel, publicProver, contractDataSource, log = createDebugLogger('aztec:sequencer:public-processor')) {
+        this.db = db;
+        this.publicExecutor = publicExecutor;
+        this.publicKernel = publicKernel;
+        this.publicProver = publicProver;
+        this.contractDataSource = contractDataSource;
+        this.log = log;
+    }
+    /**
+     * Run each tx through the public circuit and the public kernel circuit if needed.
+     * @param txs - Txs to process.
+     * @param globalVariables - The global variables for the block.
+     * @returns The list of processed txs with their circuit simulation outputs.
+     */
+    async process(txs, globalVariables) {
+        const result = [];
+        const failed = [];
+        for (const tx of txs) {
+            this.log(`Processing tx ${await tx.getTxHash()}`);
+            try {
+                result.push(await this.processTx(tx, globalVariables));
+            }
+            catch (err) {
+                this.log(`Error processing tx ${await tx.getTxHash()}: ${err}`);
+                failed.push(tx);
+            }
+        }
+        return [result, failed];
+    }
+    /**
+     * Makes an empty processed tx. Useful for padding a block to a power of two number of txs.
+     * @param chainId - The chain id of the rollup.
+     * @param version - The version of the rollup.
+     * @returns A processed tx with empty data.
+     */
+    async makeEmptyProcessedTx(chainId, version) {
+        const historicTreeRoots = await getCombinedHistoricTreeRoots(this.db);
+        return makeEmptyProcessedTx(historicTreeRoots, chainId, version);
+    }
+    async processTx(tx, globalVariables) {
+        if (!isArrayEmpty(tx.data.end.publicCallStack, item => item.isZero())) {
+            const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(tx, globalVariables);
+            tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+            return makeProcessedTx(tx, publicKernelOutput, publicKernelProof);
+        }
+        else {
+            return makeProcessedTx(tx);
+        }
+    }
+    async processEnqueuedPublicCalls(tx, globalVariables) {
+        this.log(`Executing enqueued public calls for tx ${await tx.getTxHash()}`);
+        if (!tx.enqueuedPublicFunctionCalls)
+            throw new Error(`Missing preimages for enqueued public calls`);
+        // We execute the requests in order, which means reversing the input as the stack pops from the end of the array
+        const executionStack = [...tx.enqueuedPublicFunctionCalls].reverse();
+        let kernelOutput = tx.data;
+        let kernelProof = tx.proof;
+        const newUnencryptedFunctionLogs = [];
+        while (executionStack.length) {
+            const current = executionStack.pop();
+            const isExecutionRequest = !isPublicExecutionResult(current);
+            const result = isExecutionRequest ? await this.publicExecutor.execute(current, globalVariables) : current;
+            newUnencryptedFunctionLogs.push(result.unencryptedLogs);
+            const functionSelector = result.execution.functionData.functionSelectorBuffer.toString('hex');
+            this.log(`Running public kernel circuit for ${functionSelector}@${result.execution.contractAddress.toString()}`);
+            executionStack.push(...result.nestedExecutions);
+            const preimages = await this.getPublicCallStackPreimages(result);
+            const callData = await this.getPublicCallData(result, preimages, isExecutionRequest);
+            [kernelOutput, kernelProof] = await this.runKernelCircuit(callData, kernelOutput, kernelProof);
+        }
+        return [kernelOutput, kernelProof, newUnencryptedFunctionLogs];
+    }
+    async runKernelCircuit(callData, previousOutput, previousProof) {
+        const output = await this.getKernelCircuitOutput(callData, previousOutput, previousProof);
+        const proof = await this.publicProver.getPublicKernelCircuitProof(output);
+        return [output, proof];
+    }
+    getKernelCircuitOutput(callData, previousOutput, previousProof) {
+        if (previousOutput?.isPrivate && previousProof) {
+            // Run the public kernel circuit with previous private kernel
+            const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+            const inputs = new PublicKernelInputs(previousKernel, callData);
+            return this.publicKernel.publicKernelCircuitPrivateInput(inputs);
+        }
+        else if (previousOutput && previousProof) {
+            // Run the public kernel circuit with previous public kernel
+            const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+            const inputs = new PublicKernelInputs(previousKernel, callData);
+            return this.publicKernel.publicKernelCircuitNonFirstIteration(inputs);
+        }
+        else {
+            throw new Error(`No public kernel circuit for inputs`);
+        }
+    }
+    getPreviousKernelData(previousOutput, previousProof) {
+        const vk = getVerificationKeys().publicKernelCircuit;
+        const vkIndex = 0;
+        const vkSiblingPath = MembershipWitness.random(VK_TREE_HEIGHT).siblingPath;
+        return new PreviousKernelData(previousOutput, previousProof, vk, vkIndex, vkSiblingPath);
+    }
+    async getPublicCircuitPublicInputs(result) {
+        const publicDataTreeInfo = await this.db.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE);
+        const historicPublicDataTreeRoot = Fr.fromBuffer(publicDataTreeInfo.root);
+        const callStackPreimages = await this.getPublicCallStackPreimages(result);
+        const wasm = await CircuitsWasm.get();
+        const publicCallStack = mapTuple(callStackPreimages, item => item.isEmpty() ? Fr.zero() : computeCallStackItemHash(wasm, item));
+        // TODO(#1347): Noir fails with too many unknowns error when public inputs struct contains too many members.
+        const unencryptedLogsHash = to2Fields(result.unencryptedLogs.hash());
+        const unencryptedLogPreimagesLength = new Fr(result.unencryptedLogs.getSerializedLength());
+        return PublicCircuitPublicInputs.from({
+            callContext: result.execution.callContext,
+            proverAddress: AztecAddress.random(),
+            argsHash: await computeVarArgsHash(wasm, result.execution.args),
+            newCommitments: padArrayEnd(result.newCommitments, Fr.ZERO, NEW_COMMITMENTS_LENGTH),
+            newNullifiers: padArrayEnd(result.newNullifiers, Fr.ZERO, NEW_NULLIFIERS_LENGTH),
+            newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, Fr.ZERO, NEW_L2_TO_L1_MSGS_LENGTH),
+            returnValues: padArrayEnd(result.returnValues, Fr.ZERO, RETURN_VALUES_LENGTH),
+            contractStorageReads: padArrayEnd(result.contractStorageReads, ContractStorageRead.empty(), KERNEL_PUBLIC_DATA_READS_LENGTH),
+            contractStorageUpdateRequests: padArrayEnd(result.contractStorageUpdateRequests, ContractStorageUpdateRequest.empty(), KERNEL_PUBLIC_DATA_UPDATE_REQUESTS_LENGTH),
+            publicCallStack,
+            unencryptedLogsHash,
+            unencryptedLogPreimagesLength,
+            historicPublicDataTreeRoot,
+        });
+    }
+    async getPublicCallStackItem(result, isExecutionRequest = false) {
+        return new PublicCallStackItem(result.execution.contractAddress, result.execution.functionData, await this.getPublicCircuitPublicInputs(result), isExecutionRequest);
+    }
+    async getPublicCallStackPreimages(result) {
+        const nested = result.nestedExecutions;
+        const preimages = await Promise.all(nested.map(n => this.getPublicCallStackItem(n)));
+        if (preimages.length > PUBLIC_CALL_STACK_LENGTH) {
+            throw new Error(`Public call stack size exceeded (max ${PUBLIC_CALL_STACK_LENGTH}, got ${preimages.length})`);
+        }
+        // Top of the stack is at the end of the array, so we padStart
+        return padArrayStart(preimages, PublicCallStackItem.empty(), PUBLIC_CALL_STACK_LENGTH);
+    }
+    getBytecodeHash(_result) {
+        // TODO: Determine how to calculate bytecode hash. Circuits just check it isn't zero for now.
+        // See https://github.com/AztecProtocol/aztec3-packages/issues/378
+        const bytecodeHash = new Fr(1n);
+        return Promise.resolve(bytecodeHash);
+    }
+    /**
+     * Calculates the PublicCircuitOutput for this execution result along with its proof,
+     * and assembles a PublicCallData object from it.
+     * @param result - The execution result.
+     * @param preimages - The preimages of the callstack items.
+     * @param isExecutionRequest - Whether the current callstack item should be considered a public fn execution request.
+     * @returns A corresponding PublicCallData object.
+     */
+    async getPublicCallData(result, preimages, isExecutionRequest = false) {
+        const bytecodeHash = await this.getBytecodeHash(result);
+        const callStackItem = await this.getPublicCallStackItem(result, isExecutionRequest);
+        const portalContractAddress = result.execution.callContext.portalContractAddress.toField();
+        const proof = await this.publicProver.getPublicCircuitProof(callStackItem.publicInputs);
+        return new PublicCallData(callStackItem, preimages, proof, portalContractAddress, bytecodeHash);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_processor.js","sourceRoot":"","sources":["../../src/sequencer/public_processor.ts"],"names":[],"mappings":"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"}

package/dest/sequencer/public_processor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=public_processor.test.d.ts.map

package/dest/sequencer/public_processor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_processor.test.d.ts","sourceRoot":"","sources":["../../src/sequencer/public_processor.test.ts"],"names":[],"mappings":""}

package/dest/sequencer/public_processor.test.js

@@ -0,0 +1,159 @@
+import { ARGS_LENGTH, CallContext, CircuitsWasm, EthAddress, Fr, FunctionData, GlobalVariables, KERNEL_PRIVATE_CALL_STACK_LENGTH, KERNEL_PUBLIC_CALL_STACK_LENGTH, PUBLIC_DATA_TREE_HEIGHT, makeEmptyProof, makeTuple, } from '@aztec/circuits.js';
+import { computeCallStackItemHash } from '@aztec/circuits.js/abis';
+import { makeAztecAddress, makeKernelPublicInputs, makePublicCallRequest, makeSelector, } from '@aztec/circuits.js/factories';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { SiblingPath } from '@aztec/merkle-tree';
+import { ContractPublicData, EncodedContractFunction, FunctionL2Logs, Tx, TxL2Logs, } from '@aztec/types';
+import { mock } from 'jest-mock-extended';
+import pick from 'lodash.pick';
+import times from 'lodash.times';
+import { makeTx } from '../index.js';
+import { WasmPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
+import { PublicProcessor } from './public_processor.js';
+describe('public_processor', () => {
+    let db;
+    let publicExecutor;
+    let publicProver;
+    let contractDataSource;
+    let publicFunction;
+    let contractData;
+    let proof;
+    let root;
+    let processor;
+    beforeEach(() => {
+        db = mock();
+        publicExecutor = mock();
+        publicProver = mock();
+        contractDataSource = mock();
+        contractData = ContractPublicData.random();
+        publicFunction = EncodedContractFunction.random();
+        proof = makeEmptyProof();
+        root = Buffer.alloc(32, 5);
+        publicProver.getPublicCircuitProof.mockResolvedValue(proof);
+        publicProver.getPublicKernelCircuitProof.mockResolvedValue(proof);
+        db.getTreeInfo.mockResolvedValue({ root });
+        contractDataSource.getL2ContractPublicData.mockResolvedValue(contractData);
+        contractDataSource.getPublicFunction.mockResolvedValue(publicFunction);
+    });
+    describe('with mock circuits', () => {
+        let publicKernel;
+        beforeEach(() => {
+            publicKernel = mock();
+            processor = new PublicProcessor(db, publicExecutor, publicKernel, publicProver, contractDataSource);
+        });
+        it('skips txs without public execution requests', async function () {
+            const tx = makeTx();
+            tx.data.end.publicCallStack = makeTuple(KERNEL_PUBLIC_CALL_STACK_LENGTH, Fr.zero);
+            const hash = await tx.getTxHash();
+            const [processed, failed] = await processor.process([tx], GlobalVariables.empty());
+            expect(processed).toEqual([
+                { isEmpty: false, hash, ...pick(tx, 'data', 'proof', 'encryptedLogs', 'unencryptedLogs') },
+            ]);
+            expect(failed).toEqual([]);
+        });
+        it('returns failed txs without aborting entire operation', async function () {
+            publicExecutor.execute.mockRejectedValue(new Error(`Failed`));
+            const tx = makeTx();
+            const [processed, failed] = await processor.process([tx], GlobalVariables.empty());
+            expect(processed).toEqual([]);
+            expect(failed).toEqual([tx]);
+        });
+    });
+    describe('with actual circuits', () => {
+        let publicKernel;
+        let wasm;
+        beforeAll(async () => {
+            wasm = await CircuitsWasm.get();
+        });
+        beforeEach(() => {
+            const path = times(PUBLIC_DATA_TREE_HEIGHT, i => Buffer.alloc(32, i));
+            db.getSiblingPath.mockResolvedValue(new SiblingPath(PUBLIC_DATA_TREE_HEIGHT, path));
+            publicKernel = new WasmPublicKernelCircuitSimulator();
+            processor = new PublicProcessor(db, publicExecutor, publicKernel, publicProver, contractDataSource);
+        });
+        const expectedTxByHash = async (tx) => expect.objectContaining({
+            hash: await tx.getTxHash(),
+            proof,
+        });
+        it('runs a tx with enqueued public calls', async function () {
+            const callRequests = [makePublicCallRequest(0x100), makePublicCallRequest(0x100)];
+            const callStackItems = await Promise.all(callRequests.map(call => call.toPublicCallStackItem()));
+            const callStackHashes = callStackItems.map(call => computeCallStackItemHash(wasm, call));
+            const kernelOutput = makeKernelPublicInputs(0x10);
+            kernelOutput.end.publicCallStack = padArrayEnd(callStackHashes, Fr.ZERO, KERNEL_PUBLIC_CALL_STACK_LENGTH);
+            kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, KERNEL_PRIVATE_CALL_STACK_LENGTH);
+            const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), [], callRequests);
+            publicExecutor.execute.mockImplementation(execution => {
+                for (const request of callRequests) {
+                    if (execution.contractAddress.equals(request.contractAddress)) {
+                        return Promise.resolve(makePublicExecutionResultFromRequest(request));
+                    }
+                }
+                throw new Error(`Unexpected execution request: ${execution}`);
+            });
+            const [processed, failed] = await processor.process([tx], GlobalVariables.empty());
+            expect(processed).toHaveLength(1);
+            expect(processed).toEqual([await expectedTxByHash(tx)]);
+            expect(failed).toHaveLength(0);
+            expect(publicExecutor.execute).toHaveBeenCalledTimes(2);
+        });
+        it('runs a tx with an enqueued public call with nested execution', async function () {
+            const callRequest = makePublicCallRequest(0x100);
+            const callStackItem = await callRequest.toPublicCallStackItem();
+            const callStackHash = computeCallStackItemHash(wasm, callStackItem);
+            const kernelOutput = makeKernelPublicInputs(0x10);
+            kernelOutput.end.publicCallStack = padArrayEnd([callStackHash], Fr.ZERO, KERNEL_PUBLIC_CALL_STACK_LENGTH);
+            kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, KERNEL_PRIVATE_CALL_STACK_LENGTH);
+            const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), [], [callRequest]);
+            const publicExecutionResult = makePublicExecutionResultFromRequest(callRequest);
+            publicExecutionResult.nestedExecutions = [
+                makePublicExecutionResult({
+                    from: publicExecutionResult.execution.contractAddress,
+                    to: makeAztecAddress(30),
+                    functionData: new FunctionData(makeSelector(5), false, false),
+                    args: new Array(ARGS_LENGTH).fill(Fr.ZERO),
+                }),
+            ];
+            publicExecutor.execute.mockResolvedValue(publicExecutionResult);
+            const [processed, failed] = await processor.process([tx], GlobalVariables.empty());
+            expect(processed).toHaveLength(1);
+            expect(processed).toEqual([await expectedTxByHash(tx)]);
+            expect(failed).toHaveLength(0);
+            expect(publicExecutor.execute).toHaveBeenCalledTimes(1);
+        });
+    });
+});
+function makePublicExecutionResultFromRequest(item) {
+    return {
+        execution: item,
+        nestedExecutions: [],
+        returnValues: [new Fr(1n)],
+        newCommitments: [],
+        newL2ToL1Messages: [],
+        newNullifiers: [],
+        contractStorageReads: [],
+        contractStorageUpdateRequests: [],
+        unencryptedLogs: new FunctionL2Logs([]),
+    };
+}
+function makePublicExecutionResult(tx, nestedExecutions = []) {
+    const callContext = new CallContext(tx.from, tx.to, EthAddress.ZERO, false, false, false);
+    const execution = {
+        callContext,
+        contractAddress: tx.to,
+        functionData: tx.functionData,
+        args: tx.args,
+    };
+    return {
+        execution,
+        nestedExecutions,
+        returnValues: [],
+        newCommitments: [],
+        newNullifiers: [],
+        newL2ToL1Messages: [],
+        contractStorageReads: [],
+        contractStorageUpdateRequests: [],
+        unencryptedLogs: new FunctionL2Logs([]),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_processor.test.js","sourceRoot":"","sources":["../../src/sequencer/public_processor.test.ts"],"names":[],"mappings":"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"}

package/dest/sequencer/sequencer.d.ts

@@ -0,0 +1,133 @@
+import { Fr } from '@aztec/foundation/fields';
+import { P2P } from '@aztec/p2p';
+import { L1ToL2MessageSource, L2Block, L2BlockSource, Tx } from '@aztec/types';
+import { WorldStateSynchroniser } from '@aztec/world-state';
+import { BlockBuilder } from '../block_builder/index.js';
+import { L1Publisher } from '../publisher/l1-publisher.js';
+import { SequencerConfig } from './config.js';
+import { ProcessedTx } from './processed_tx.js';
+import { PublicProcessorFactory } from './public_processor.js';
+import { GlobalVariables } from '@aztec/circuits.js';
+import { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
+/**
+ * Sequencer client
+ * - Wins a period of time to become the sequencer (depending on finalised protocol).
+ * - Chooses a set of txs from the tx pool to be in the rollup.
+ * - Simulate the rollup of txs.
+ * - Adds proof requests to the request pool (not for this milestone).
+ * - Receives results to those proofs from the network (repeats as necessary) (not for this milestone).
+ * - Publishes L1 tx(s) to the rollup contract via RollupPublisher.
+ */
+export declare class Sequencer {
+    private publisher;
+    private globalsBuilder;
+    private p2pClient;
+    private worldState;
+    private blockBuilder;
+    private l2BlockSource;
+    private l1ToL2MessageSource;
+    private publicProcessorFactory;
+    private log;
+    private runningPromise?;
+    private pollingIntervalMs;
+    private maxTxsPerBlock;
+    private minTxsPerBLock;
+    private lastPublishedBlock;
+    private state;
+    private chainId;
+    private version;
+    constructor(publisher: L1Publisher, globalsBuilder: GlobalVariableBuilder, p2pClient: P2P, worldState: WorldStateSynchroniser, blockBuilder: BlockBuilder, l2BlockSource: L2BlockSource, l1ToL2MessageSource: L1ToL2MessageSource, publicProcessorFactory: PublicProcessorFactory, config: SequencerConfig, log?: import("@aztec/foundation/log").DebugLogger);
+    /**
+     * Starts the sequencer and moves to IDLE state. Blocks until the initial sync is complete.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the sequencer from processing txs and moves to STOPPED state.
+     */
+    stop(): Promise<void>;
+    /**
+     * Starts a previously stopped sequencer.
+     */
+    restart(): void;
+    /**
+     * Returns the current state of the sequencer.
+     * @returns An object with a state entry with one of SequencerState.
+     */
+    status(): {
+        state: SequencerState;
+    };
+    protected initialSync(): Promise<void>;
+    /**
+     * Grabs up to maxTxsPerBlock from the p2p client, constructs a block, and pushes it to L1.
+     */
+    protected work(): Promise<void>;
+    /**
+     * Gets new contract public data from the txs and publishes it on chain.
+     * @param validTxs - The set of real transactions being published as part of the block.
+     * @param block - The L2Block to be published.
+     */
+    protected publishContractPublicData(validTxs: Tx[], block: L2Block): Promise<void>;
+    /**
+     * Publishes the L2Block to the rollup contract.
+     * @param block - The L2Block to be published.
+     */
+    protected publishL2Block(block: L2Block): Promise<void>;
+    protected takeValidTxs(txs: Tx[]): Promise<Tx[]>;
+    /**
+     * Returns whether the previous block sent has been mined, and all dependencies have caught up with it.
+     * @returns Boolean indicating if our dependencies are synced to the latest block.
+     */
+    protected isBlockSynced(): Promise<boolean>;
+    /**
+     * Pads the set of txs to a power of two and assembles a block by calling the block builder.
+     * @param txs - Processed txs to include in the next block.
+     * @param newL1ToL2Messages - L1 to L2 messages to be part of the block.
+     * @param emptyTx - Empty tx to repeat at the end of the block to pad to a power of two.
+     * @param globalVariables - Global variables to use in the block.
+     * @returns The new block.
+     */
+    protected buildBlock(txs: ProcessedTx[], newL1ToL2Messages: Fr[], emptyTx: ProcessedTx, globalVariables: GlobalVariables): Promise<L2Block>;
+    /**
+     * Calls the archiver to pull upto `NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP` message keys
+     * (archiver returns the top messages sorted by fees)
+     * @returns An array of L1 to L2 messages' messageKeys
+     */
+    protected getPendingL1ToL2Messages(): Promise<Fr[]>;
+    /**
+     * Returns true if one of the transaction nullifiers exist.
+     * Nullifiers prevent double spends in a private context.
+     * @param tx - The transaction.
+     * @returns Whether this is a problematic double spend that the L1 contract would reject.
+     */
+    protected isTxDoubleSpend(tx: Tx): Promise<boolean>;
+}
+/**
+ * State of the sequencer.
+ */
+export declare enum SequencerState {
+    /**
+     * Will move to WAITING_FOR_TXS after a configured amount of time.
+     */
+    IDLE = 0,
+    /**
+     * Polling the P2P module for txs to include in a block. Will move to CREATING_BLOCK if there are valid txs to include, or back to IDLE otherwise.
+     */
+    WAITING_FOR_TXS = 1,
+    /**
+     * Creating a new L2 block. Includes processing public function calls and running rollup circuits. Will move to PUBLISHING_CONTRACT_DATA.
+     */
+    CREATING_BLOCK = 2,
+    /**
+     * Sending the tx to L1 with encrypted logs and awaiting it to be mined. Will move back to PUBLISHING_BLOCK once finished.
+     */
+    PUBLISHING_CONTRACT_DATA = 3,
+    /**
+     * Sending the tx to L1 with the L2 block data and awaiting it to be mined. Will move to IDLE.
+     */
+    PUBLISHING_BLOCK = 4,
+    /**
+     * Sequencer is stopped and not processing any txs from the pool.
+     */
+    STOPPED = 5
+}
+//# sourceMappingURL=sequencer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sequencer.d.ts","sourceRoot":"","sources":["../../src/sequencer/sequencer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAGL,mBAAmB,EACnB,OAAO,EACP,aAAa,EAEb,EAAE,EACH,MAAM,cAAc,CAAC;AACtB,OAAO,EAAoB,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAE9E,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AAErF;;;;;;;;GAQG;AACH,qBAAa,SAAS;IAWlB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,sBAAsB;IAE9B,OAAO,CAAC,GAAG;IAnBb,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,cAAc,CAAM;IAC5B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,kBAAkB,CAAK;IAC/B,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAK;gBAGV,SAAS,EAAE,WAAW,EACtB,cAAc,EAAE,qBAAqB,EACrC,SAAS,EAAE,GAAG,EACd,UAAU,EAAE,sBAAsB,EAClC,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,aAAa,EAC5B,mBAAmB,EAAE,mBAAmB,EACxC,sBAAsB,EAAE,sBAAsB,EACtD,MAAM,EAAE,eAAe,EACf,GAAG,8CAAuC;IAapD;;OAEG;IACU,KAAK;IASlB;;OAEG;IACU,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAOlC;;OAEG;IACI,OAAO;IAMd;;;OAGG;IACI,MAAM;;;cAIG,WAAW;IAK3B;;OAEG;cACa,IAAI;IAkEpB;;;;OAIG;cACa,yBAAyB,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO;IA2BxE;;;OAGG;cACa,cAAc,CAAC,KAAK,EAAE,OAAO;cAa7B,YAAY,CAAC,GAAG,EAAE,EAAE,EAAE;IA4BtC;;;OAGG;cACa,aAAa;IAS7B;;;;;;;OAOG;cACa,UAAU,CACxB,GAAG,EAAE,WAAW,EAAE,EAClB,iBAAiB,EAAE,EAAE,EAAE,EACvB,OAAO,EAAE,WAAW,EACpB,eAAe,EAAE,eAAe;IAalC;;;;OAIG;cACa,wBAAwB,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;IAIzD;;;;;OAKG;cACa,eAAe,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CAgB1D;AAED;;GAEG;AACH,oBAAY,cAAc;IACxB;;OAEG;IACH,IAAI,IAAA;IACJ;;OAEG;IACH,eAAe,IAAA;IACf;;OAEG;IACH,cAAc,IAAA;IACd;;OAEG;IACH,wBAAwB,IAAA;IACxB;;OAEG;IACH,gBAAgB,IAAA;IAChB;;OAEG;IACH,OAAO,IAAA;CACR"}