@aztec/sequencer-client 0.7.2 → 0.7.3

package/dest/sequencer/public_processor.d.ts

@@ -0,0 +1,75 @@
+import { PublicExecutionResult, PublicExecutor } from '@aztec/acir-simulator';
+import { Fr, GlobalVariables, HistoricBlockData, KernelCircuitPublicInputs, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, PreviousKernelData, Proof, PublicCallData, PublicCallStackItem, PublicCircuitPublicInputs, PublicKernelPublicInputs } from '@aztec/circuits.js';
+import { Tuple } from '@aztec/foundation/serialize';
+import { ContractDataSource, FunctionL2Logs, L1ToL2MessageSource, Tx } from '@aztec/types';
+import { MerkleTreeOperations } from '@aztec/world-state';
+import { PublicProver } from '../prover/index.js';
+import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { FailedTx, ProcessedTx } from './processed_tx.js';
+/**
+ * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
+ */
+export declare class PublicProcessorFactory {
+    private merkleTree;
+    private contractDataSource;
+    private l1Tol2MessagesDataSource;
+    constructor(merkleTree: MerkleTreeOperations, contractDataSource: ContractDataSource, l1Tol2MessagesDataSource: L1ToL2MessageSource);
+    /**
+     * Creates a new instance of a PublicProcessor.
+     * @param prevGlobalVariables - The global variables for the previous block, used to calculate the prev global variables hash.
+     * @param globalVariables - The global variables for the block being processed.
+     * @returns A new instance of a PublicProcessor.
+     */
+    create(prevGlobalVariables: GlobalVariables, globalVariables: GlobalVariables): Promise<PublicProcessor>;
+}
+/**
+ * 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 declare class PublicProcessor {
+    protected db: MerkleTreeOperations;
+    protected publicExecutor: PublicExecutor;
+    protected publicKernel: PublicKernelCircuitSimulator;
+    protected publicProver: PublicProver;
+    protected contractDataSource: ContractDataSource;
+    protected globalVariables: GlobalVariables;
+    protected blockData: HistoricBlockData;
+    private log;
+    constructor(db: MerkleTreeOperations, publicExecutor: PublicExecutor, publicKernel: PublicKernelCircuitSimulator, publicProver: PublicProver, contractDataSource: ContractDataSource, globalVariables: GlobalVariables, blockData: HistoricBlockData, log?: import("@aztec/foundation/log").DebugLogger);
+    /**
+     * Run each tx through the public circuit and the public kernel circuit if needed.
+     * @param txs - Txs to process.
+     * @returns The list of processed txs with their circuit simulation outputs.
+     */
+    process(txs: Tx[]): Promise<[ProcessedTx[], FailedTx[]]>;
+    /**
+     * Makes an empty processed tx. Useful for padding a block to a power of two number of txs.
+     * @returns A processed tx with empty data.
+     */
+    makeEmptyProcessedTx(): Promise<ProcessedTx>;
+    protected processTx(tx: Tx): Promise<ProcessedTx>;
+    protected processEnqueuedPublicCalls(tx: Tx): Promise<[PublicKernelPublicInputs, Proof, FunctionL2Logs[]]>;
+    protected runKernelCircuit(callData: PublicCallData, previousOutput: KernelCircuitPublicInputs, previousProof: Proof): Promise<[KernelCircuitPublicInputs, Proof]>;
+    protected getKernelCircuitOutput(callData: PublicCallData, previousOutput: KernelCircuitPublicInputs, previousProof: Proof): Promise<KernelCircuitPublicInputs>;
+    protected getPreviousKernelData(previousOutput: KernelCircuitPublicInputs, previousProof: Proof): PreviousKernelData;
+    protected getPublicCircuitPublicInputs(result: PublicExecutionResult): Promise<PublicCircuitPublicInputs>;
+    protected getPublicCallStackItem(result: PublicExecutionResult, isExecutionRequest?: boolean): Promise<PublicCallStackItem>;
+    protected getPublicCallStackPreimages(result: PublicExecutionResult): Promise<[PublicCallStackItem, PublicCallStackItem, PublicCallStackItem, PublicCallStackItem]>;
+    protected getBytecodeHash(_result: PublicExecutionResult): Promise<Fr>;
+    /**
+     * 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.
+     */
+    protected getPublicCallData(result: PublicExecutionResult, preimages: Tuple<PublicCallStackItem, typeof MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>, isExecutionRequest?: boolean): Promise<PublicCallData>;
+    /**
+     * Patch the ordering of storage actions output from the public kernel.
+     * @param publicInputs - to be patched here: public inputs to the kernel iteration up to this point
+     * @param execResult - result of the top/first execution for this enqueued public call
+     */
+    private patchPublicStorageActionOrdering;
+}
+//# sourceMappingURL=public_processor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"public_processor.d.ts","sourceRoot":"","sources":["../../src/sequencer/public_processor.ts"],"names":[],"mappings":"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"}

package/dest/sequencer/public_processor.js

@@ -0,0 +1,269 @@
+import { collectPublicDataReads, collectPublicDataUpdateRequests, isPublicExecutionResult, } from '@aztec/acir-simulator';
+import { AztecAddress, CircuitsWasm, CombinedAccumulatedData, ContractStorageRead, ContractStorageUpdateRequest, Fr, KernelCircuitPublicInputs, MAX_NEW_COMMITMENTS_PER_CALL, MAX_NEW_L2_TO_L1_MSGS_PER_CALL, MAX_NEW_NULLIFIERS_PER_CALL, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, MAX_PUBLIC_DATA_READS_PER_CALL, MAX_PUBLIC_DATA_READS_PER_TX, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, MembershipWitness, PreviousKernelData, PublicCallData, PublicCallStackItem, PublicCircuitPublicInputs, PublicDataRead, PublicDataUpdateRequest, PublicKernelInputs, RETURN_VALUES_LENGTH, VK_TREE_HEIGHT, } from '@aztec/circuits.js';
+import { computeCallStackItemHash, computeVarArgsHash } from '@aztec/circuits.js/abis';
+import { arrayNonEmptyLength, isArrayEmpty, padArrayEnd, padArrayStart } from '@aztec/foundation/collection';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { mapTuple, to2Fields } from '@aztec/foundation/serialize';
+import { MerkleTreeId, Tx } from '@aztec/types';
+import { getVerificationKeys } from '../index.js';
+import { EmptyPublicProver } from '../prover/empty.js';
+import { getPublicExecutor } from '../simulator/index.js';
+import { WasmPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
+import { makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
+import { getHistoricBlockData } 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.
+     * @param prevGlobalVariables - The global variables for the previous block, used to calculate the prev global variables hash.
+     * @param globalVariables - The global variables for the block being processed.
+     * @returns A new instance of a PublicProcessor.
+     */
+    async create(prevGlobalVariables, globalVariables) {
+        const blockData = await getHistoricBlockData(this.merkleTree, prevGlobalVariables);
+        return new PublicProcessor(this.merkleTree, getPublicExecutor(this.merkleTree, this.contractDataSource, this.l1Tol2MessagesDataSource, blockData), new WasmPublicKernelCircuitSimulator(), new EmptyPublicProver(), this.contractDataSource, globalVariables, blockData);
+    }
+}
+/**
+ * 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, globalVariables, blockData, log = createDebugLogger('aztec:sequencer:public-processor')) {
+        this.db = db;
+        this.publicExecutor = publicExecutor;
+        this.publicKernel = publicKernel;
+        this.publicProver = publicProver;
+        this.contractDataSource = contractDataSource;
+        this.globalVariables = globalVariables;
+        this.blockData = blockData;
+        this.log = log;
+    }
+    /**
+     * Run each tx through the public circuit and the public kernel circuit if needed.
+     * @param txs - Txs to process.
+     * @returns The list of processed txs with their circuit simulation outputs.
+     */
+    async process(txs) {
+        // The processor modifies the tx objects in place, so we need to clone them.
+        txs = txs.map(tx => Tx.clone(tx));
+        const result = [];
+        const failed = [];
+        for (const tx of txs) {
+            this.log(`Processing tx ${await tx.getTxHash()}`);
+            try {
+                result.push(await this.processTx(tx));
+            }
+            catch (err) {
+                this.log.warn(`Error processing tx ${await tx.getTxHash()}: ${err}`);
+                failed.push({
+                    tx,
+                    error: err instanceof Error ? err : new Error('Unknown error'),
+                });
+            }
+        }
+        return [result, failed];
+    }
+    /**
+     * Makes an empty processed tx. Useful for padding a block to a power of two number of txs.
+     * @returns A processed tx with empty data.
+     */
+    makeEmptyProcessedTx() {
+        const { chainId, version } = this.globalVariables;
+        return makeEmptyProcessedTx(this.blockData, chainId, version);
+    }
+    async processTx(tx) {
+        if (!isArrayEmpty(tx.data.end.publicCallStack, item => item.isZero())) {
+            const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(tx);
+            tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+            return makeProcessedTx(tx, publicKernelOutput, publicKernelProof);
+        }
+        else {
+            return makeProcessedTx(tx);
+        }
+    }
+    async processEnqueuedPublicCalls(tx) {
+        this.log(`Executing enqueued public calls for tx ${await tx.getTxHash()}`);
+        if (!tx.enqueuedPublicFunctionCalls)
+            throw new Error(`Missing preimages for enqueued public calls`);
+        let kernelOutput = new KernelCircuitPublicInputs(CombinedAccumulatedData.fromFinalAccumulatedData(tx.data.end), tx.data.constants, tx.data.isPrivate);
+        let kernelProof = tx.proof;
+        const newUnencryptedFunctionLogs = [];
+        // TODO(#1684): Should multiple separately enqueued public calls be treated as
+        // separate public callstacks to be proven by separate public kernel sequences
+        // and submitted separately to the base rollup?
+        // TODO(dbanks12): why must these be reversed?
+        const enqueuedCallsReversed = tx.enqueuedPublicFunctionCalls.slice().reverse();
+        for (const enqueuedCall of enqueuedCallsReversed) {
+            const executionStack = [enqueuedCall];
+            // Keep track of which result is for the top/enqueued call
+            let enqueuedExecutionResult;
+            while (executionStack.length) {
+                const current = executionStack.pop();
+                const isExecutionRequest = !isPublicExecutionResult(current);
+                const result = isExecutionRequest ? await this.publicExecutor.simulate(current, this.globalVariables) : current;
+                newUnencryptedFunctionLogs.push(result.unencryptedLogs);
+                const functionSelector = result.execution.functionData.selector.toString();
+                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);
+                if (!enqueuedExecutionResult)
+                    enqueuedExecutionResult = result;
+            }
+            // HACK(#1622): Manually patches the ordering of public state actions
+            // TODO(#757): Enforce proper ordering of public state actions
+            await this.patchPublicStorageActionOrdering(kernelOutput, enqueuedExecutionResult);
+        }
+        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);
+        this.blockData.publicDataTreeRoot = 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(https://github.com/AztecProtocol/aztec-packages/issues/1165) --> set this in Noir
+        const unencryptedLogsHash = to2Fields(result.unencryptedLogs.hash());
+        const unencryptedLogPreimagesLength = new Fr(result.unencryptedLogs.getSerializedLength());
+        return PublicCircuitPublicInputs.from({
+            callContext: result.execution.callContext,
+            proverAddress: AztecAddress.ZERO,
+            argsHash: await computeVarArgsHash(wasm, result.execution.args),
+            newCommitments: padArrayEnd(result.newCommitments, Fr.ZERO, MAX_NEW_COMMITMENTS_PER_CALL),
+            newNullifiers: padArrayEnd(result.newNullifiers, Fr.ZERO, MAX_NEW_NULLIFIERS_PER_CALL),
+            newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, Fr.ZERO, MAX_NEW_L2_TO_L1_MSGS_PER_CALL),
+            returnValues: padArrayEnd(result.returnValues, Fr.ZERO, RETURN_VALUES_LENGTH),
+            contractStorageReads: padArrayEnd(result.contractStorageReads, ContractStorageRead.empty(), MAX_PUBLIC_DATA_READS_PER_CALL),
+            contractStorageUpdateRequests: padArrayEnd(result.contractStorageUpdateRequests, ContractStorageUpdateRequest.empty(), MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL),
+            publicCallStack,
+            unencryptedLogsHash,
+            unencryptedLogPreimagesLength,
+            historicBlockData: this.blockData,
+        });
+    }
+    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 > MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL) {
+            throw new Error(`Public call stack size exceeded (max ${MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL}, got ${preimages.length})`);
+        }
+        // Top of the stack is at the end of the array, so we padStart
+        return padArrayStart(preimages, PublicCallStackItem.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL);
+    }
+    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);
+    }
+    // HACK(#1622): this is a hack to fix ordering of public state in the call stack. Since the private kernel
+    // cannot keep track of side effects that happen after or before a nested call, we override the public
+    // state actions it emits with whatever we got from the simulator. As a sanity check, we at least verify
+    // that the elements are the same, so we are only tweaking their ordering.
+    // See yarn-project/end-to-end/src/e2e_ordering.test.ts
+    // See https://github.com/AztecProtocol/aztec-packages/issues/1616
+    // TODO(#757): Enforce proper ordering of public state actions
+    /**
+     * Patch the ordering of storage actions output from the public kernel.
+     * @param publicInputs - to be patched here: public inputs to the kernel iteration up to this point
+     * @param execResult - result of the top/first execution for this enqueued public call
+     */
+    async patchPublicStorageActionOrdering(publicInputs, execResult) {
+        // Convert ContractStorage* objects to PublicData* objects and sort them in execution order
+        const wasm = await CircuitsWasm.get();
+        const simPublicDataReads = collectPublicDataReads(wasm, execResult);
+        const simPublicDataUpdateRequests = collectPublicDataUpdateRequests(wasm, execResult);
+        const { publicDataReads, publicDataUpdateRequests } = publicInputs.end; // from kernel
+        // Validate all items in enqueued public calls are in the kernel emitted stack
+        const readsAreEqual = simPublicDataReads.reduce((accum, read) => accum && !!publicDataReads.find(item => item.leafIndex.equals(read.leafIndex) && item.value.equals(read.value)), true);
+        const updatesAreEqual = simPublicDataUpdateRequests.reduce((accum, update) => accum &&
+            !!publicDataUpdateRequests.find(item => item.leafIndex.equals(update.leafIndex) &&
+                item.oldValue.equals(update.oldValue) &&
+                item.newValue.equals(update.newValue)), true);
+        if (!readsAreEqual) {
+            throw new Error(`Public data reads from simulator do not match those from public kernel.\nFrom simulator: ${simPublicDataReads
+                .map(p => p.toFriendlyJSON())
+                .join(', ')}\nFrom public kernel: ${publicDataReads.map(i => i.toFriendlyJSON()).join(', ')}`);
+        }
+        if (!updatesAreEqual) {
+            throw new Error(`Public data update requests from simulator do not match those from public kernel.\nFrom simulator: ${simPublicDataUpdateRequests
+                .map(p => p.toFriendlyJSON())
+                .join(', ')}\nFrom public kernel: ${publicDataUpdateRequests.map(i => i.toFriendlyJSON()).join(', ')}`);
+        }
+        // Assume that kernel public inputs has the right number of items.
+        // We only want to reorder the items from the public inputs of the
+        // most recently processed top/enqueued call.
+        const numTotalReadsInKernel = arrayNonEmptyLength(publicInputs.end.publicDataReads, f => f.leafIndex.equals(Fr.ZERO) && f.value.equals(Fr.ZERO));
+        const numTotalUpdatesInKernel = arrayNonEmptyLength(publicInputs.end.publicDataUpdateRequests, f => f.leafIndex.equals(Fr.ZERO) && f.oldValue.equals(Fr.ZERO) && f.newValue.equals(Fr.ZERO));
+        const numReadsBeforeThisEnqueuedCall = numTotalReadsInKernel - simPublicDataReads.length;
+        const numUpdatesBeforeThisEnqueuedCall = numTotalUpdatesInKernel - simPublicDataUpdateRequests.length;
+        // Override kernel output
+        publicInputs.end.publicDataReads = padArrayEnd([
+            // do not mess with items from previous top/enqueued calls in kernel output
+            ...publicDataReads.slice(0, numReadsBeforeThisEnqueuedCall),
+            ...simPublicDataReads,
+        ], PublicDataRead.empty(), MAX_PUBLIC_DATA_READS_PER_TX);
+        // Override kernel output
+        publicInputs.end.publicDataUpdateRequests = padArrayEnd([
+            // do not mess with items from previous top/enqueued calls in kernel output
+            ...publicDataUpdateRequests.slice(0, numUpdatesBeforeThisEnqueuedCall),
+            ...simPublicDataUpdateRequests,
+        ], PublicDataUpdateRequest.empty(), MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX);
+    }
+}
+//# 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,164 @@
+import { ARGS_LENGTH, CallContext, CircuitsWasm, CombinedAccumulatedData, EthAddress, Fr, FunctionData, GlobalVariables, HistoricBlockData, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, PUBLIC_DATA_TREE_HEIGHT, PublicKernelPublicInputs, makeEmptyProof, makeTuple, } from '@aztec/circuits.js';
+import { computeCallStackItemHash } from '@aztec/circuits.js/abis';
+import { makeAztecAddress, makePrivateKernelPublicInputsFinal, makePublicCallRequest, makeSelector, } from '@aztec/circuits.js/factories';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { EncodedContractFunction, ExtendedContractData, FunctionL2Logs, SiblingPath, Tx, TxL2Logs, mockTx, } from '@aztec/types';
+import { mock } from 'jest-mock-extended';
+import times from 'lodash.times';
+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 = ExtendedContractData.random();
+        publicFunction = EncodedContractFunction.random();
+        proof = makeEmptyProof();
+        root = Buffer.alloc(32, 5);
+        publicProver.getPublicCircuitProof.mockResolvedValue(proof);
+        publicProver.getPublicKernelCircuitProof.mockResolvedValue(proof);
+        db.getTreeInfo.mockResolvedValue({ root });
+        contractDataSource.getExtendedContractData.mockResolvedValue(contractData);
+        contractDataSource.getPublicFunction.mockResolvedValue(publicFunction);
+    });
+    describe('with mock circuits', () => {
+        let publicKernel;
+        beforeEach(() => {
+            publicKernel = mock();
+            processor = new PublicProcessor(db, publicExecutor, publicKernel, publicProver, contractDataSource, GlobalVariables.empty(), HistoricBlockData.empty());
+        });
+        it('skips txs without public execution requests', async function () {
+            const tx = mockTx();
+            tx.data.end.publicCallStack = makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, Fr.zero);
+            const hash = await tx.getTxHash();
+            const [processed, failed] = await processor.process([tx]);
+            expect(processed).toEqual([
+                {
+                    isEmpty: false,
+                    hash,
+                    data: new PublicKernelPublicInputs(CombinedAccumulatedData.fromFinalAccumulatedData(tx.data.end), tx.data.constants),
+                    proof: tx.proof,
+                    encryptedLogs: tx.encryptedLogs,
+                    unencryptedLogs: tx.unencryptedLogs,
+                },
+            ]);
+            expect(failed).toEqual([]);
+        });
+        it('returns failed txs without aborting entire operation', async function () {
+            publicExecutor.simulate.mockRejectedValue(new Error(`Failed`));
+            const tx = mockTx();
+            const [processed, failed] = await processor.process([tx]);
+            expect(processed).toEqual([]);
+            expect(failed[0].tx).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, GlobalVariables.empty(), HistoricBlockData.empty());
+        });
+        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 = makePrivateKernelPublicInputsFinal(0x10);
+            kernelOutput.end.publicCallStack = padArrayEnd(callStackHashes, Fr.ZERO, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX);
+            kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX);
+            const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), callRequests, [
+                ExtendedContractData.random(),
+            ]);
+            publicExecutor.simulate.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]);
+            expect(processed).toHaveLength(1);
+            expect(processed).toEqual([await expectedTxByHash(tx)]);
+            expect(failed).toHaveLength(0);
+            expect(publicExecutor.simulate).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 = makePrivateKernelPublicInputsFinal(0x10);
+            kernelOutput.end.publicCallStack = padArrayEnd([callStackHash], Fr.ZERO, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX);
+            kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX);
+            const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), [callRequest], [ExtendedContractData.random()]);
+            const publicExecutionResult = makePublicExecutionResultFromRequest(callRequest);
+            publicExecutionResult.nestedExecutions = [
+                makePublicExecutionResult(publicExecutionResult.execution.contractAddress, {
+                    to: makeAztecAddress(30),
+                    functionData: new FunctionData(makeSelector(5), false, false, false),
+                    args: new Array(ARGS_LENGTH).fill(Fr.ZERO),
+                }),
+            ];
+            publicExecutor.simulate.mockResolvedValue(publicExecutionResult);
+            const [processed, failed] = await processor.process([tx]);
+            expect(processed).toHaveLength(1);
+            expect(processed).toEqual([await expectedTxByHash(tx)]);
+            expect(failed).toHaveLength(0);
+            expect(publicExecutor.simulate).toHaveBeenCalledTimes(1);
+        });
+    });
+});
+function makePublicExecutionResultFromRequest(item) {
+    return {
+        execution: item,
+        nestedExecutions: [],
+        returnValues: [new Fr(1n)],
+        newCommitments: [],
+        newL2ToL1Messages: [],
+        newNullifiers: [],
+        contractStorageReads: [],
+        contractStorageUpdateRequests: [],
+        unencryptedLogs: new FunctionL2Logs([]),
+    };
+}
+function makePublicExecutionResult(from, tx, nestedExecutions = []) {
+    const callContext = new CallContext(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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"}