@aztec/sequencer-client 0.1.0-alpha48 → 0.1.0-alpha57

package/src/sequencer/public_processor.test.ts

@@ -4,6 +4,7 @@ import {
   AztecAddress,
   CallContext,
   CircuitsWasm,
+  CombinedAccumulatedData,
   EthAddress,
   Fr,
   FunctionData,
@@ -14,13 +15,14 @@ import {
   PUBLIC_DATA_TREE_HEIGHT,
   Proof,
   PublicCallRequest,
+  PublicKernelPublicInputs,
   makeEmptyProof,
   makeTuple,
 } from '@aztec/circuits.js';
 import { computeCallStackItemHash } from '@aztec/circuits.js/abis';
 import {
   makeAztecAddress,
-  makeKernelPublicInputs,
+  makePrivateKernelPublicInputsFinal,
   makePublicCallRequest,
   makeSelector,
 } from '@aztec/circuits.js/factories';
@@ -39,7 +41,6 @@ import {
 import { MerkleTreeOperations, TreeInfo } from '@aztec/world-state';
 
 import { MockProxy, mock } from 'jest-mock-extended';
-import pick from 'lodash.pick';
 import times from 'lodash.times';
 
 import { PublicProver } from '../prover/index.js';
@@ -101,13 +102,23 @@ describe('public_processor', () => {
       const [processed, failed] = await processor.process([tx]);
 
       expect(processed).toEqual([
-        { isEmpty: false, hash, ...pick(tx, 'data', 'proof', 'encryptedLogs', 'unencryptedLogs') },
+        {
+          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.execute.mockRejectedValue(new Error(`Failed`));
+      publicExecutor.simulate.mockRejectedValue(new Error(`Failed`));
 
       const tx = mockTx();
       const [processed, failed] = await processor.process([tx]);
@@ -151,7 +162,7 @@ describe('public_processor', () => {
       const callStackItems = await Promise.all(callRequests.map(call => call.toPublicCallStackItem()));
       const callStackHashes = callStackItems.map(call => computeCallStackItemHash(wasm, call));
 
-      const kernelOutput = makeKernelPublicInputs(0x10);
+      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);
 
@@ -159,7 +170,7 @@ describe('public_processor', () => {
         ExtendedContractData.random(),
       ]);
 
-      publicExecutor.execute.mockImplementation(execution => {
+      publicExecutor.simulate.mockImplementation(execution => {
         for (const request of callRequests) {
           if (execution.contractAddress.equals(request.contractAddress)) {
             return Promise.resolve(makePublicExecutionResultFromRequest(request));
@@ -173,7 +184,7 @@ describe('public_processor', () => {
       expect(processed).toHaveLength(1);
       expect(processed).toEqual([await expectedTxByHash(tx)]);
       expect(failed).toHaveLength(0);
-      expect(publicExecutor.execute).toHaveBeenCalledTimes(2);
+      expect(publicExecutor.simulate).toHaveBeenCalledTimes(2);
     });
 
     it('runs a tx with an enqueued public call with nested execution', async function () {
@@ -181,7 +192,7 @@ describe('public_processor', () => {
       const callStackItem = await callRequest.toPublicCallStackItem();
       const callStackHash = computeCallStackItemHash(wasm, callStackItem);
 
-      const kernelOutput = makeKernelPublicInputs(0x10);
+      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);
 
@@ -202,14 +213,14 @@ describe('public_processor', () => {
           args: new Array(ARGS_LENGTH).fill(Fr.ZERO),
         }),
       ];
-      publicExecutor.execute.mockResolvedValue(publicExecutionResult);
+      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.execute).toHaveBeenCalledTimes(1);
+      expect(publicExecutor.simulate).toHaveBeenCalledTimes(1);
     });
   });
 });

package/src/sequencer/public_processor.ts

@@ -9,6 +9,7 @@ import {
 import {
   AztecAddress,
   CircuitsWasm,
+  CombinedAccumulatedData,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   Fr,
@@ -108,7 +109,7 @@ export class PublicProcessor {
    */
   public async process(txs: Tx[]): Promise<[ProcessedTx[], FailedTx[]]> {
     // The processor modifies the tx objects in place, so we need to clone them.
-    txs = txs.map(tx => Tx.fromJSON(tx.toJSON()));
+    txs = txs.map(tx => Tx.clone(tx));
     const result: ProcessedTx[] = [];
     const failed: FailedTx[] = [];
 
@@ -153,7 +154,11 @@ export class PublicProcessor {
     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 = tx.data;
+    let kernelOutput = new KernelCircuitPublicInputs(
+      CombinedAccumulatedData.fromFinalAccumulatedData(tx.data.end),
+      tx.data.constants,
+      tx.data.isPrivate,
+    );
     let kernelProof = tx.proof;
     const newUnencryptedFunctionLogs: FunctionL2Logs[] = [];
 
@@ -172,7 +177,7 @@ export class PublicProcessor {
       while (executionStack.length) {
         const current = executionStack.pop()!;
         const isExecutionRequest = !isPublicExecutionResult(current);
-        const result = isExecutionRequest ? await this.publicExecutor.execute(current, this.globalVariables) : 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(