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

package/src/publisher/l1-publisher.ts

@@ -1,6 +1,6 @@
 import { createDebugLogger } from '@aztec/foundation/log';
 import { InterruptableSleep } from '@aztec/foundation/sleep';
-import { ContractDataAndBytecode, L2Block } from '@aztec/types';
+import { ExtendedContractData, L2Block } from '@aztec/types';
 
 import { L2BlockReceiver } from '../receiver.js';
 import { PublisherConfig } from './config.js';
@@ -31,16 +31,22 @@ export interface L1PublisherTxSender {
   sendProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined>;
 
   /**
-   * Sends a tx to the public contract data emitter contract with contract deployment data such as bytecode. Returns once the tx has been mined.
-   * @param l2BlockNum - Number of the L2 block that owns this public contract data.
+   * Sends a tx to the contract deployment emitter contract with contract deployment data such as bytecode. Returns once the tx has been mined.
+   * @param l2BlockNum - Number of the L2 block that owns this encrypted logs.
    * @param l2BlockHash - The hash of the block corresponding to this data.
-   * @param contractData - Data to publish.
+   * @param partialAddresses - The partial addresses of the deployed contract
+   * @param publicKeys - The public keys of the deployed contract
+   * @param newExtendedContractData - Data to publish.
    * @returns The hash of the mined tx.
+   * @remarks Partial addresses, public keys and contract data has to be in the same order.
+   * @remarks See the link bellow for more info on partial address and public key:
+   * https://github.com/AztecProtocol/aztec-packages/blob/master/docs/docs/concepts/foundation/accounts/keys.md#addresses-partial-addresses-and-public-keys
+   * TODO: replace the link above with the link to deployed docs
    */
   sendEmitContractDeploymentTx(
     l2BlockNum: number,
     l2BlockHash: Buffer,
-    contractData: ContractDataAndBytecode[],
+    newExtendedContractData: ExtendedContractData[],
   ): Promise<(string | undefined)[]>;
 
   /**
@@ -139,12 +145,8 @@ export class L1Publisher implements L2BlockReceiver {
    * @param contractData - The new contract data to publish.
    * @returns True once the tx has been confirmed and is successful, false on revert or interrupt, blocks otherwise.
    */
-  public async processNewContractData(
-    l2BlockNum: number,
-    l2BlockHash: Buffer,
-    contractData: ContractDataAndBytecode[],
-  ) {
-    let _contractData: ContractDataAndBytecode[] = [];
+  public async processNewContractData(l2BlockNum: number, l2BlockHash: Buffer, contractData: ExtendedContractData[]) {
+    let _contractData: ExtendedContractData[] = [];
     while (!this.interrupted) {
       if (!(await this.checkFeeDistributorBalance())) {
         this.log(`Fee distributor ETH balance too low, awaiting top up...`);
@@ -217,11 +219,11 @@ export class L1Publisher implements L2BlockReceiver {
   private async sendEmitNewContractDataTx(
     l2BlockNum: number,
     l2BlockHash: Buffer,
-    contractData: ContractDataAndBytecode[],
+    newExtendedContractData: ExtendedContractData[],
   ) {
     while (!this.interrupted) {
       try {
-        return await this.txSender.sendEmitContractDeploymentTx(l2BlockNum, l2BlockHash, contractData);
+        return await this.txSender.sendEmitContractDeploymentTx(l2BlockNum, l2BlockHash, newExtendedContractData);
       } catch (err) {
         this.log.error(`Error sending contract data to L1`, err);
         await this.sleepOrInterrupted();

package/src/publisher/viem-tx-sender.ts

@@ -1,7 +1,7 @@
 import { createEthereumChain } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { ContractDeploymentEmitterAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { ContractDataAndBytecode } from '@aztec/types';
+import { ExtendedContractData } from '@aztec/types';
 
 import {
   GetContractReturnType,
@@ -120,22 +120,25 @@ export class ViemTxSender implements L1PublisherTxSender {
    * Sends a tx to the contract deployment emitter contract with contract deployment data such as bytecode. Returns once the tx has been mined.
    * @param l2BlockNum - Number of the L2 block that owns this encrypted logs.
    * @param l2BlockHash - The hash of the block corresponding to this data.
-   * @param newContractDataAndBytecode - Data to publish.
+   * @param newExtendedContractData - Data to publish.
    * @returns The hash of the mined tx.
    */
   async sendEmitContractDeploymentTx(
     l2BlockNum: number,
     l2BlockHash: Buffer,
-    newContractDataAndBytecode: ContractDataAndBytecode[],
+    newExtendedContractData: ExtendedContractData[],
   ): Promise<(string | undefined)[]> {
     const hashes: string[] = [];
-    for (const contractDataAndBytecode of newContractDataAndBytecode) {
+    for (const extendedContractData of newExtendedContractData) {
       const args = [
         BigInt(l2BlockNum),
-        contractDataAndBytecode.contractData.contractAddress.toString() as Hex,
-        contractDataAndBytecode.contractData.portalContractAddress.toString() as Hex,
+        extendedContractData.contractData.contractAddress.toString() as Hex,
+        extendedContractData.contractData.portalContractAddress.toString() as Hex,
         `0x${l2BlockHash.toString('hex')}`,
-        `0x${contractDataAndBytecode.bytecode.toString('hex')}`,
+        extendedContractData.partialAddress.toString(true),
+        extendedContractData.publicKey.x.toString(true),
+        extendedContractData.publicKey.y.toString(true),
+        `0x${extendedContractData.bytecode.toString('hex')}`,
       ] as const;
 
       const gas = await this.contractDeploymentEmitterContract.estimateGas.emitContractDeployment(args, {

package/src/sequencer/processed_tx.ts

@@ -16,6 +16,20 @@ export type ProcessedTx = Pick<Tx, 'data' | 'proof' | 'encryptedLogs' | 'unencry
   isEmpty: boolean;
 };
 
+/**
+ * Represents a tx that failed to be processed by the sequencer public processor.
+ */
+export type FailedTx = {
+  /**
+   * The failing transaction.
+   */
+  tx: Tx;
+  /**
+   * The error that caused the tx to fail.
+   */
+  error: Error;
+};
+
 /**
  * Makes a processed tx out of a private only tx that has its proof already set.
  * @param tx - Source tx that doesn't need further processing.

package/src/sequencer/public_processor.test.ts

@@ -26,9 +26,9 @@ import {
 } from '@aztec/circuits.js/factories';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import {
-  ContractDataAndBytecode,
   ContractDataSource,
   EncodedContractFunction,
+  ExtendedContractData,
   FunctionCall,
   FunctionL2Logs,
   SiblingPath,
@@ -54,7 +54,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 +66,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 +74,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);
   });
 
@@ -113,7 +113,7 @@ describe('public_processor', () => {
       const [processed, failed] = await processor.process([tx]);
 
       expect(processed).toEqual([]);
-      expect(failed).toEqual([tx]);
+      expect(failed[0].tx).toEqual(tx);
     });
   });
 
@@ -155,7 +155,9 @@ describe('public_processor', () => {
       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) {
@@ -183,7 +185,14 @@ describe('public_processor', () => {
       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

@@ -46,10 +46,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 +106,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];
@@ -170,7 +174,7 @@ export class PublicProcessor {
         const isExecutionRequest = !isPublicExecutionResult(current);
         const result = isExecutionRequest ? await this.publicExecutor.execute(current, this.globalVariables) : current;
         newUnencryptedFunctionLogs.push(result.unencryptedLogs);
-        const functionSelector = result.execution.functionData.functionSelectorBuffer.toString('hex');
+        const functionSelector = result.execution.functionData.selector.toString();
         this.log(
           `Running public kernel circuit for ${functionSelector}@${result.execution.contractAddress.toString()}`,
         );

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.
  */

package/src/simulator/public_executor.ts

@@ -6,7 +6,7 @@ import {
   PublicExecutor,
   PublicStateDB,
 } from '@aztec/acir-simulator';
-import { AztecAddress, CircuitsWasm, EthAddress, Fr, HistoricBlockData } from '@aztec/circuits.js';
+import { AztecAddress, CircuitsWasm, EthAddress, Fr, FunctionSelector, HistoricBlockData } from '@aztec/circuits.js';
 import { siloCommitment } from '@aztec/circuits.js/abis';
 import { ContractDataSource, L1ToL2MessageSource, MerkleTreeId } from '@aztec/types';
 import { MerkleTreeOperations, computePublicDataTreeLeafIndex } from '@aztec/world-state';
@@ -36,11 +36,11 @@ export function getPublicExecutor(
  */
 class ContractsDataSourcePublicDB implements PublicContractsDB {
   constructor(private db: ContractDataSource) {}
-  async getBytecode(address: AztecAddress, functionSelector: Buffer): Promise<Buffer | undefined> {
-    return (await this.db.getPublicFunction(address, functionSelector))?.bytecode;
+  async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
+    return (await this.db.getPublicFunction(address, selector))?.bytecode;
   }
-  async getIsInternal(address: AztecAddress, functionSelector: Buffer): Promise<boolean | undefined> {
-    return (await this.db.getPublicFunction(address, functionSelector))?.isInternal;
+  async getIsInternal(address: AztecAddress, selector: FunctionSelector): Promise<boolean | undefined> {
+    return (await this.db.getPublicFunction(address, selector))?.isInternal;
   }
   async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
     return (await this.db.getContractData(address))?.portalContractAddress;