@aztec/sequencer-client 0.1.0-alpha47 → 0.1.0-alpha49

package/src/sequencer/public_processor.test.ts

@@ -4,11 +4,13 @@ import {
   AztecAddress,
   CallContext,
   CircuitsWasm,
+  CombinedAccumulatedData,
   EthAddress,
   Fr,
   FunctionData,
   GlobalVariables,
   HistoricBlockData,
+  KernelCircuitPublicInputs,
   MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   PUBLIC_DATA_TREE_HEIGHT,
@@ -20,15 +22,15 @@ import {
 import { computeCallStackItemHash } from '@aztec/circuits.js/abis';
 import {
   makeAztecAddress,
-  makeKernelPublicInputs,
+  makeKernelPublicInputsFinal,
   makePublicCallRequest,
   makeSelector,
 } from '@aztec/circuits.js/factories';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import {
-  ContractDataAndBytecode,
   ContractDataSource,
   EncodedContractFunction,
+  ExtendedContractData,
   FunctionCall,
   FunctionL2Logs,
   SiblingPath,
@@ -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';
@@ -54,7 +55,7 @@ describe('public_processor', () => {
   let contractDataSource: MockProxy<ContractDataSource>;
 
   let publicFunction: EncodedContractFunction;
-  let contractData: ContractDataAndBytecode;
+  let contractData: ExtendedContractData;
   let proof: Proof;
   let root: Buffer;
 
@@ -66,7 +67,7 @@ describe('public_processor', () => {
     publicProver = mock<PublicProver>();
     contractDataSource = mock<ContractDataSource>();
 
-    contractData = ContractDataAndBytecode.random();
+    contractData = ExtendedContractData.random();
     publicFunction = EncodedContractFunction.random();
     proof = makeEmptyProof();
     root = Buffer.alloc(32, 5);
@@ -74,7 +75,7 @@ describe('public_processor', () => {
     publicProver.getPublicCircuitProof.mockResolvedValue(proof);
     publicProver.getPublicKernelCircuitProof.mockResolvedValue(proof);
     db.getTreeInfo.mockResolvedValue({ root } as TreeInfo);
-    contractDataSource.getContractDataAndBytecode.mockResolvedValue(contractData);
+    contractDataSource.getExtendedContractData.mockResolvedValue(contractData);
     contractDataSource.getPublicFunction.mockResolvedValue(publicFunction);
   });
 
@@ -101,7 +102,18 @@ 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 KernelCircuitPublicInputs(
+            CombinedAccumulatedData.fromFinalAccumulatedData(tx.data.end),
+            tx.data.constants,
+            tx.data.isPrivate,
+          ),
+          proof: tx.proof,
+          encryptedLogs: tx.encryptedLogs,
+          unencryptedLogs: tx.unencryptedLogs,
+        },
       ]);
       expect(failed).toEqual([]);
     });
@@ -113,7 +125,7 @@ describe('public_processor', () => {
       const [processed, failed] = await processor.process([tx]);
 
       expect(processed).toEqual([]);
-      expect(failed).toEqual([tx]);
+      expect(failed[0].tx).toEqual(tx);
     });
   });
 
@@ -151,11 +163,13 @@ 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 = makeKernelPublicInputsFinal(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);
+      const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), callRequests, [
+        ExtendedContractData.random(),
+      ]);
 
       publicExecutor.execute.mockImplementation(execution => {
         for (const request of callRequests) {
@@ -179,11 +193,18 @@ describe('public_processor', () => {
       const callStackItem = await callRequest.toPublicCallStackItem();
       const callStackHash = computeCallStackItemHash(wasm, callStackItem);
 
-      const kernelOutput = makeKernelPublicInputs(0x10);
+      const kernelOutput = makeKernelPublicInputsFinal(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]);
+      const tx = new Tx(
+        kernelOutput,
+        proof,
+        TxL2Logs.random(2, 3),
+        TxL2Logs.random(3, 2),
+        [callRequest],
+        [ExtendedContractData.random()],
+      );
 
       const publicExecutionResult = makePublicExecutionResultFromRequest(callRequest);
       publicExecutionResult.nestedExecutions = [

package/src/sequencer/public_processor.ts

@@ -9,6 +9,7 @@ import {
 import {
   AztecAddress,
   CircuitsWasm,
+  CombinedAccumulatedData,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   Fr,
@@ -46,10 +47,9 @@ import { MerkleTreeOperations } from '@aztec/world-state';
 import { getVerificationKeys } from '../index.js';
 import { EmptyPublicProver } from '../prover/empty.js';
 import { PublicProver } from '../prover/index.js';
-import { PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { getPublicExecutor } from '../simulator/public_executor.js';
+import { PublicKernelCircuitSimulator, getPublicExecutor } from '../simulator/index.js';
 import { WasmPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
-import { ProcessedTx, makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
+import { FailedTx, ProcessedTx, makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
 import { getHistoricBlockData } from './utils.js';
 
 /**
@@ -107,17 +107,22 @@ export class PublicProcessor {
    * @param txs - Txs to process.
    * @returns The list of processed txs with their circuit simulation outputs.
    */
-  public async process(txs: Tx[]): Promise<[ProcessedTx[], Tx[]]> {
+  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()));
     const result: ProcessedTx[] = [];
-    const failed: Tx[] = [];
+    const failed: FailedTx[] = [];
 
     for (const tx of txs) {
       this.log(`Processing tx ${await tx.getTxHash()}`);
       try {
         result.push(await this.processTx(tx));
       } catch (err) {
-        this.log.error(`Error processing tx ${await tx.getTxHash()}: ${err}`);
-        failed.push(tx);
+        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];
@@ -149,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[] = [];
 

package/src/sequencer/sequencer.ts

@@ -3,15 +3,7 @@ import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { P2P } from '@aztec/p2p';
-import {
-  ContractData,
-  ContractDataAndBytecode,
-  L1ToL2MessageSource,
-  L2Block,
-  L2BlockSource,
-  MerkleTreeId,
-  Tx,
-} from '@aztec/types';
+import { L1ToL2MessageSource, L2Block, L2BlockSource, MerkleTreeId, Tx } from '@aztec/types';
 import { WorldStateStatus, WorldStateSynchroniser } from '@aztec/world-state';
 
 import times from 'lodash.times';
@@ -149,8 +141,9 @@ export class Sequencer {
       const processor = await this.publicProcessorFactory.create(prevGlobalVariables, newGlobalVariables);
       const [processedTxs, failedTxs] = await processor.process(validTxs);
       if (failedTxs.length > 0) {
-        this.log(`Dropping failed txs ${(await Tx.getHashes(failedTxs)).join(', ')}`);
-        await this.p2pClient.deleteTxs(await Tx.getHashes(failedTxs));
+        const failedTxData = failedTxs.map(fail => fail.tx);
+        this.log(`Dropping failed txs ${(await Tx.getHashes(failedTxData)).join(', ')}`);
+        await this.p2pClient.deleteTxs(await Tx.getHashes(failedTxData));
       }
 
       if (processedTxs.length === 0) {
@@ -170,7 +163,7 @@ export class Sequencer {
       const block = await this.buildBlock(processedTxs, l1ToL2Messages, emptyTx, newGlobalVariables);
       this.log(`Assembled block ${block.number}`);
 
-      await this.publishContractDataAndBytecode(validTxs, block);
+      await this.publishExtendedContractData(validTxs, block);
 
       await this.publishL2Block(block);
       this.log.info(`Submitted rollup block ${block.number} with ${processedTxs.length} transactions`);
@@ -182,28 +175,25 @@ export class Sequencer {
   }
 
   /**
-   * Gets new contract data and bytecode from the txs and publishes it on chain.
+   * Gets new extended contract 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 async publishContractDataAndBytecode(validTxs: Tx[], block: L2Block) {
+  protected async publishExtendedContractData(validTxs: Tx[], block: L2Block) {
     // Publishes contract data for txs to the network and awaits the tx to be mined
     this.state = SequencerState.PUBLISHING_CONTRACT_DATA;
     const newContractData = validTxs
       .map(tx => {
         // Currently can only have 1 new contract per tx
         const newContract = tx.data?.end.newContracts[0];
-        if (newContract && tx.newContractPublicFunctions?.length) {
-          return new ContractDataAndBytecode(
-            new ContractData(newContract.contractAddress, newContract.portalContractAddress),
-            tx.newContractPublicFunctions,
-          );
+        if (newContract) {
+          return tx.newContracts[0];
         }
       })
       .filter((cd): cd is Exclude<typeof cd, undefined> => cd !== undefined);
 
     const blockHash = block.getCalldataHash();
-    this.log(`Publishing contract data and bytecode with block hash ${blockHash.toString('hex')}`);
+    this.log(`Publishing extended contract data with block hash ${blockHash.toString('hex')}`);
 
     const publishedContractData = await this.publisher.processNewContractData(block.number, blockHash, newContractData);
     if (publishedContractData) {

package/src/simulator/index.ts

@@ -8,6 +8,8 @@ import {
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
 
+export { getPublicExecutor } from './public_executor.js';
+
 /**
  * Circuit simulator for the rollup circuits.
  */