@aztec/sequencer-client 0.26.6 → 0.27.1

package/src/block_builder/solo_block_builder.ts

@@ -5,8 +5,6 @@ import {
   AppendOnlyTreeSnapshot,
   BaseOrMergeRollupPublicInputs,
   BaseRollupInputs,
-  CONTRACT_SUBTREE_HEIGHT,
-  CONTRACT_SUBTREE_SIBLING_PATH_LENGTH,
   ConstantRollupData,
   GlobalVariables,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
@@ -137,9 +135,6 @@ export class SoloBlockBuilder implements BlockBuilder {
       if (txHeader.state.partial.nullifierTree.isZero()) {
         throw new Error(`Empty nullifier tree in tx: ${toFriendlyJSON(tx)}`);
       }
-      if (txHeader.state.partial.contractTree.isZero()) {
-        throw new Error(`Empty contract tree in tx: ${toFriendlyJSON(tx)}`);
-      }
       if (txHeader.state.partial.publicDataTree.isZero()) {
         throw new Error(`Empty public data tree in tx: ${toFriendlyJSON(tx)}`);
       }
@@ -171,14 +166,11 @@ export class SoloBlockBuilder implements BlockBuilder {
     for (const tx of txs) {
       const input = await this.buildBaseRollupInput(tx, globalVariables);
       baseRollupInputs.push(input);
-      const promises = [
-        MerkleTreeId.NOTE_HASH_TREE,
-        MerkleTreeId.CONTRACT_TREE,
-        MerkleTreeId.NULLIFIER_TREE,
-        MerkleTreeId.PUBLIC_DATA_TREE,
-      ].map(async (id: MerkleTreeId) => {
-        return { key: id, value: await this.getTreeSnapshot(id) };
-      });
+      const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(
+        async (id: MerkleTreeId) => {
+          return { key: id, value: await this.getTreeSnapshot(id) };
+        },
+      );
       const snapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot> = new Map(
         (await Promise.all(promises)).map(obj => [obj.key, obj.value]),
       );
@@ -316,11 +308,6 @@ export class SoloBlockBuilder implements BlockBuilder {
       partialState.nullifierTree,
       'NullifierTree',
     );
-    this.validateSimulatedTree(
-      treeSnapshots.get(MerkleTreeId.CONTRACT_TREE)!,
-      partialState.contractTree,
-      'ContractTree',
-    );
     this.validateSimulatedTree(
       treeSnapshots.get(MerkleTreeId.PUBLIC_DATA_TREE)!,
       partialState.publicDataTree,
@@ -329,14 +316,11 @@ export class SoloBlockBuilder implements BlockBuilder {
   }
 
   protected async validateState(state: StateReference) {
-    const promises = [
-      MerkleTreeId.NOTE_HASH_TREE,
-      MerkleTreeId.CONTRACT_TREE,
-      MerkleTreeId.NULLIFIER_TREE,
-      MerkleTreeId.PUBLIC_DATA_TREE,
-    ].map(async (id: MerkleTreeId) => {
-      return { key: id, value: await this.getTreeSnapshot(id) };
-    });
+    const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(
+      async (id: MerkleTreeId) => {
+        return { key: id, value: await this.getTreeSnapshot(id) };
+      },
+    );
     const snapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot> = new Map(
       (await Promise.all(promises)).map(obj => [obj.key, obj.value]),
     );
@@ -636,7 +620,6 @@ export class SoloBlockBuilder implements BlockBuilder {
     const start = new PartialStateReference(
       await this.getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE),
       await this.getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE),
-      await this.getTreeSnapshot(MerkleTreeId.CONTRACT_TREE),
       await this.getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE),
     );
 
@@ -650,25 +633,9 @@ export class SoloBlockBuilder implements BlockBuilder {
       i < noteHashSubtreeSiblingPathArray.length ? noteHashSubtreeSiblingPathArray[i] : Fr.ZERO,
     );
 
-    const contractSubtreeSiblingPathArray = await this.getSubtreeSiblingPath(
-      MerkleTreeId.CONTRACT_TREE,
-      CONTRACT_SUBTREE_HEIGHT,
-    );
-
-    const contractSubtreeSiblingPath = makeTuple(CONTRACT_SUBTREE_SIBLING_PATH_LENGTH, i =>
-      i < contractSubtreeSiblingPathArray.length ? contractSubtreeSiblingPathArray[i] : Fr.ZERO,
-    );
-
-    // Update the contract and note hash trees with the new items being inserted to get the new roots
+    // Update the note hash trees with the new items being inserted to get the new roots
     // that will be used by the next iteration of the base rollup circuit, skipping the empty ones
-    const newContracts = tx.data.combinedData.newContracts.map(cd => cd.hash());
     const newNoteHashes = tx.data.combinedData.newNoteHashes.map(x => x.value.toBuffer());
-
-    await this.db.appendLeaves(
-      MerkleTreeId.CONTRACT_TREE,
-      newContracts.map(x => x.toBuffer()),
-    );
-
     await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, newNoteHashes);
 
     // The read witnesses for a given TX should be generated before the writes of the same TX are applied.
@@ -720,7 +687,6 @@ export class SoloBlockBuilder implements BlockBuilder {
       sortedNullifierIndexes: makeTuple(MAX_NEW_NULLIFIERS_PER_TX, i => sortedNewLeavesIndexes[i]),
       noteHashSubtreeSiblingPath,
       nullifierSubtreeSiblingPath,
-      contractSubtreeSiblingPath,
       publicDataSiblingPath,
     });
 

package/src/config.ts

@@ -44,7 +44,6 @@ export function getConfigEnvVars(): SequencerClientConfig {
     ROLLUP_CONTRACT_ADDRESS,
     REGISTRY_CONTRACT_ADDRESS,
     INBOX_CONTRACT_ADDRESS,
-    CONTRACT_DEPLOYMENT_EMITTER_ADDRESS,
     OUTBOX_CONTRACT_ADDRESS,
     COINBASE,
     FEE_RECIPIENT,
@@ -64,9 +63,6 @@ export function getConfigEnvVars(): SequencerClientConfig {
     registryAddress: REGISTRY_CONTRACT_ADDRESS ? EthAddress.fromString(REGISTRY_CONTRACT_ADDRESS) : EthAddress.ZERO,
     inboxAddress: INBOX_CONTRACT_ADDRESS ? EthAddress.fromString(INBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
     outboxAddress: OUTBOX_CONTRACT_ADDRESS ? EthAddress.fromString(OUTBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
-    contractDeploymentEmitterAddress: CONTRACT_DEPLOYMENT_EMITTER_ADDRESS
-      ? EthAddress.fromString(CONTRACT_DEPLOYMENT_EMITTER_ADDRESS)
-      : EthAddress.ZERO,
   };
 
   return {

package/src/publisher/l1-publisher.ts

@@ -1,4 +1,4 @@
-import { ExtendedContractData, L2Block } from '@aztec/circuit-types';
+import { L2Block } from '@aztec/circuit-types';
 import { L1PublishStats } from '@aztec/circuit-types/stats';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { InterruptibleSleep } from '@aztec/foundation/sleep';
@@ -54,22 +54,6 @@ export interface L1PublisherTxSender {
    */
   sendProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined>;
 
-  /**
-   * 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 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. Read more {@link https://docs.aztec.network/concepts/foundation/accounts/keys#addresses-partial-addresses-and-public-keys | here}.
-   */
-  sendEmitContractDeploymentTx(
-    l2BlockNum: number,
-    l2BlockHash: Buffer,
-    newExtendedContractData: ExtendedContractData[],
-  ): Promise<(string | undefined)[]>;
-
   /**
    * Returns a tx receipt if the tx has been mined.
    * @param txHash - Hash of the tx to look for.
@@ -111,16 +95,6 @@ export type L1ProcessArgs = {
   proof: Buffer;
 };
 
-/**
- * Helper function to filter out undefined items from an array.
- * Also asserts the resulting array is of type <T>.
- * @param item - An item from an array to check if undefined or not.
- * @returns True if the item is not undefined.
- */
-function isNotUndefined<T>(item: T | undefined): item is T {
-  return item !== undefined;
-}
-
 /**
  * Publishes L2 blocks to L1. This implementation does *not* retry a transaction in
  * the event of network congestion, but should work for local development.
@@ -234,49 +208,6 @@ export class L1Publisher implements L2BlockReceiver {
     return false;
   }
 
-  /**
-   * Publishes new contract data to L1.
-   * @param l2BlockNum - The L2 block number that the new contracts were deployed on.
-   * @param l2BlockHash - The hash of the block corresponding to this data.
-   * @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: ExtendedContractData[]) {
-    let _contractData: ExtendedContractData[] = [];
-    while (!this.interrupted) {
-      const arr = _contractData.length ? _contractData : contractData;
-      const txHashes = await this.sendEmitNewContractDataTx(l2BlockNum, l2BlockHash, arr);
-      if (!txHashes) {
-        break;
-      }
-      // filter successful txs
-      _contractData = arr.filter((_, i) => !!txHashes[i]);
-
-      const receipts = await Promise.all(
-        txHashes.filter(isNotUndefined).map(txHash => this.getTransactionReceipt(txHash)),
-      );
-      if (!receipts?.length) {
-        break;
-      }
-
-      // ALL Txs were mined successfully
-      if (receipts.length === contractData.length && receipts.every(r => r?.status)) {
-        return true;
-      }
-
-      this.log(
-        `Transaction status failed: ${receipts
-          .filter(r => !r?.status)
-          .map(r => r?.transactionHash)
-          .join(',')}`,
-      );
-      await this.sleepOrInterrupted();
-    }
-
-    this.log('L2 block data syncing interrupted while processing contract data.');
-    return false;
-  }
-
   /**
    * Calling `interrupt` will cause any in progress call to `publishRollup` to return `false` asap.
    * Be warned, the call may return false even if the tx subsequently gets successfully mined.
@@ -330,21 +261,6 @@ export class L1Publisher implements L2BlockReceiver {
     }
   }
 
-  private async sendEmitNewContractDataTx(
-    l2BlockNum: number,
-    l2BlockHash: Buffer,
-    newExtendedContractData: ExtendedContractData[],
-  ) {
-    while (!this.interrupted) {
-      try {
-        return await this.txSender.sendEmitContractDeploymentTx(l2BlockNum, l2BlockHash, newExtendedContractData);
-      } catch (err) {
-        this.log.error(`Error sending contract data to L1`, err);
-        await this.sleepOrInterrupted();
-      }
-    }
-  }
-
   private async getTransactionReceipt(txHash: string): Promise<MinimalTransactionReceipt | undefined> {
     while (!this.interrupted) {
       try {

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

@@ -1,8 +1,7 @@
-import { ExtendedContractData, L2Block } from '@aztec/circuit-types';
-import { BLOB_SIZE_IN_BYTES } from '@aztec/circuits.js/constants';
+import { L2Block } from '@aztec/circuit-types';
 import { createEthereumChain } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { AvailabilityOracleAbi, ContractDeploymentEmitterAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { AvailabilityOracleAbi, RollupAbi } from '@aztec/l1-artifacts';
 
 import {
   GetContractReturnType,
@@ -40,10 +39,6 @@ export class ViemTxSender implements L1PublisherTxSender {
     typeof RollupAbi,
     WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
   >;
-  private contractDeploymentEmitterContract: GetContractReturnType<
-    typeof ContractDeploymentEmitterAbi,
-    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
-  >;
 
   private log = createDebugLogger('aztec:sequencer:viem-tx-sender');
   private publicClient: PublicClient<HttpTransport, chains.Chain>;
@@ -74,11 +69,6 @@ export class ViemTxSender implements L1PublisherTxSender {
       abi: RollupAbi,
       client: walletClient,
     });
-    this.contractDeploymentEmitterContract = getContract({
-      address: getAddress(l1Contracts.contractDeploymentEmitterAddress.toString()),
-      abi: ContractDeploymentEmitterAbi,
-      client: walletClient,
-    });
   }
 
   async getCurrentArchive(): Promise<Buffer> {
@@ -169,46 +159,6 @@ export class ViemTxSender implements L1PublisherTxSender {
     return hash;
   }
 
-  /**
-   * 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 newExtendedContractData - Data to publish.
-   * @returns The hash of the mined tx.
-   */
-  async sendEmitContractDeploymentTx(
-    l2BlockNum: number,
-    l2BlockHash: Buffer,
-    newExtendedContractData: ExtendedContractData[],
-  ): Promise<(string | undefined)[]> {
-    const hashes: string[] = [];
-    for (const extendedContractData of newExtendedContractData) {
-      const args = [
-        BigInt(l2BlockNum),
-        extendedContractData.contractData.contractAddress.toString() as Hex,
-        extendedContractData.contractData.portalContractAddress.toString() as Hex,
-        `0x${l2BlockHash.toString('hex')}`,
-        extendedContractData.contractClassId.toString(),
-        extendedContractData.saltedInitializationHash.toString(),
-        extendedContractData.publicKeyHash.toString(),
-        `0x${extendedContractData.bytecode.toString('hex')}`,
-      ] as const;
-
-      const codeSize = extendedContractData.bytecode.length;
-      this.log(`Bytecode is ${codeSize} bytes and require ${codeSize / BLOB_SIZE_IN_BYTES} blobs`);
-
-      const gas = await this.contractDeploymentEmitterContract.estimateGas.emitContractDeployment(args, {
-        account: this.account,
-      });
-      const hash = await this.contractDeploymentEmitterContract.write.emitContractDeployment(args, {
-        gas,
-        account: this.account,
-      });
-      hashes.push(hash);
-    }
-    return hashes;
-  }
-
   /**
    * Gets the chain object for the given chain id.
    * @param chainId - Chain id of the target EVM chain.

package/src/sequencer/abstract_phase_manager.ts

@@ -13,6 +13,7 @@ import {
   MAX_NEW_NULLIFIERS_PER_CALL,
   MAX_NON_REVERTIBLE_PUBLIC_DATA_READS_PER_TX,
   MAX_NON_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
   MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
   MAX_PUBLIC_DATA_READS_PER_CALL,
@@ -264,13 +265,22 @@ export abstract class AbstractPhaseManager {
 
     if (this.phase === PublicKernelPhase.TAIL) {
       const { endNonRevertibleData, end } = previousOutput;
-      const nullifierReadRequestResetHints = await this.hintsBuilder.getNullifierReadRequestResetHints(
+      const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
         endNonRevertibleData.nullifierReadRequests,
         end.nullifierReadRequests,
         endNonRevertibleData.newNullifiers,
         end.newNullifiers,
       );
-      const inputs = new PublicKernelTailCircuitPrivateInputs(previousKernel, nullifierReadRequestResetHints);
+      const nullifierNonExistentReadRequestHints = await this.hintsBuilder.getNullifierNonExistentReadRequestHints(
+        endNonRevertibleData.nullifierNonExistentReadRequests,
+        endNonRevertibleData.newNullifiers,
+        end.newNullifiers,
+      );
+      const inputs = new PublicKernelTailCircuitPrivateInputs(
+        previousKernel,
+        nullifierReadRequestHints,
+        nullifierNonExistentReadRequestHints,
+      );
       return this.publicKernel.publicKernelCircuitTail(inputs);
     }
 
@@ -329,6 +339,11 @@ export abstract class AbstractPhaseManager {
         ReadRequest.empty(),
         MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
       ),
+      nullifierNonExistentReadRequests: padArrayEnd(
+        result.nullifierNonExistentReadRequests,
+        ReadRequest.empty(),
+        MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
+      ),
       contractStorageReads: padArrayEnd(
         result.contractStorageReads,
         ContractStorageRead.empty(),

package/src/sequencer/hints_builder.ts

@@ -3,14 +3,15 @@ import {
   Fr,
   MAX_NEW_NULLIFIERS_PER_TX,
   MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX,
+  MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
   MAX_REVERTIBLE_NULLIFIERS_PER_TX,
   MembershipWitness,
   NULLIFIER_TREE_HEIGHT,
-  NullifierLeafPreimage,
   ReadRequestContext,
   SideEffectLinkedToNoteHash,
-  buildNullifierReadRequestResetHints,
+  buildNullifierNonExistentReadRequestHints,
+  buildNullifierReadRequestHints,
   concatAccumulatedData,
   mergeAccumulatedData,
 } from '@aztec/circuits.js';
@@ -20,13 +21,13 @@ import { MerkleTreeOperations } from '@aztec/world-state';
 export class HintsBuilder {
   constructor(private db: MerkleTreeOperations) {}
 
-  getNullifierReadRequestResetHints(
+  getNullifierReadRequestHints(
     nullifierReadRequestsNonRevertible: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     nullifierReadRequestsRevertible: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX>,
     nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_REVERTIBLE_NULLIFIERS_PER_TX>,
   ) {
-    return buildNullifierReadRequestResetHints(
+    return buildNullifierReadRequestHints(
       this,
       mergeAccumulatedData(
         MAX_NULLIFIER_READ_REQUESTS_PER_TX,
@@ -37,19 +38,54 @@ export class HintsBuilder {
     );
   }
 
+  getNullifierNonExistentReadRequestHints(
+    nullifierNonExistentReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
+    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX>,
+    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_REVERTIBLE_NULLIFIERS_PER_TX>,
+  ) {
+    const pendingNullifiers = concatAccumulatedData(
+      MAX_NEW_NULLIFIERS_PER_TX,
+      nullifiersNonRevertible,
+      nullifiersRevertible,
+    );
+    return buildNullifierNonExistentReadRequestHints(this, nullifierNonExistentReadRequests, pendingNullifiers);
+  }
+
   async getNullifierMembershipWitness(nullifier: Fr) {
     const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
     if (index === undefined) {
       return;
     }
 
-    const siblingPath = await this.db.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, index);
+    return this.getNullifierMembershipWitnessWithPreimage(index);
+  }
+
+  async getLowNullifierMembershipWitness(nullifier: Fr) {
+    const res = await this.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
+    if (res === undefined) {
+      throw new Error(`Cannot find the low leaf for nullifier ${nullifier.toBigInt()}.`);
+    }
+
+    const { index, alreadyPresent } = res;
+    if (alreadyPresent) {
+      throw new Error(`Nullifier ${nullifier.toBigInt()} already exists in the tree.`);
+    }
+
+    return this.getNullifierMembershipWitnessWithPreimage(index);
+  }
+
+  private async getNullifierMembershipWitnessWithPreimage(index: bigint) {
+    const siblingPath = await this.db.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(MerkleTreeId.NULLIFIER_TREE, index);
     const membershipWitness = new MembershipWitness(
       NULLIFIER_TREE_HEIGHT,
       index,
       siblingPath.toTuple<typeof NULLIFIER_TREE_HEIGHT>(),
     );
-    const leafPreimage = (await this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index))! as NullifierLeafPreimage;
+
+    const leafPreimage = await this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
+    if (!leafPreimage) {
+      throw new Error(`Cannot find the leaf preimage at index ${index}.`);
+    }
 
     return { membershipWitness, leafPreimage };
   }

package/src/sequencer/processed_tx.ts

@@ -1,17 +1,7 @@
-import {
-  ContractData,
-  ExtendedContractData,
-  PublicDataWrite,
-  SimulationError,
-  Tx,
-  TxEffect,
-  TxHash,
-  TxL2Logs,
-} from '@aztec/circuit-types';
+import { PublicDataWrite, SimulationError, Tx, TxEffect, TxHash, TxL2Logs } from '@aztec/circuit-types';
 import {
   Fr,
   Header,
-  MAX_NEW_CONTRACTS_PER_TX,
   MAX_NEW_NOTE_HASHES_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
@@ -29,7 +19,7 @@ import { Tuple, fromFieldsTuple } from '@aztec/foundation/serialize';
  * Represents a tx that has been processed by the sequencer public processor,
  * so its kernel circuit public inputs are filled in.
  */
-export type ProcessedTx = Pick<Tx, 'proof' | 'encryptedLogs' | 'unencryptedLogs' | 'newContracts'> & {
+export type ProcessedTx = Pick<Tx, 'proof' | 'encryptedLogs' | 'unencryptedLogs'> & {
   /**
    * Output of the public kernel circuit for this tx.
    */
@@ -153,7 +143,6 @@ export function makeProcessedTx(
     proof: previousProof,
     encryptedLogs: revertReason ? new TxL2Logs([]) : tx.encryptedLogs,
     unencryptedLogs: revertReason ? new TxL2Logs([]) : tx.unencryptedLogs,
-    newContracts: revertReason ? [ExtendedContractData.empty()] : tx.newContracts,
     isEmpty: false,
     revertReason,
   };
@@ -177,7 +166,6 @@ export function makeEmptyProcessedTx(header: Header, chainId: Fr, version: Fr):
     unencryptedLogs: new TxL2Logs([]),
     data: emptyKernelOutput,
     proof: emptyProof,
-    newContracts: [ExtendedContractData.empty()],
     isEmpty: true,
     revertReason: undefined,
   };
@@ -195,10 +183,6 @@ export function toTxEffect(tx: ProcessedTx): TxEffect {
       PublicDataWrite,
       typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
     >,
-    tx.data.combinedData.newContracts.map(cd => cd.hash()) as Tuple<Fr, typeof MAX_NEW_CONTRACTS_PER_TX>,
-    tx.data.combinedData.newContracts.map(
-      cd => new ContractData(cd.contractAddress, cd.portalContractAddress),
-    ) as Tuple<ContractData, typeof MAX_NEW_CONTRACTS_PER_TX>,
     tx.encryptedLogs || new TxL2Logs([]),
     tx.unencryptedLogs || new TxL2Logs([]),
   );

package/src/sequencer/sequencer.ts

@@ -227,10 +227,6 @@ export class Sequencer {
 
       await assertBlockHeight();
 
-      await this.publishExtendedContractData(processedValidTxs, block);
-
-      await assertBlockHeight();
-
       await this.publishL2Block(block);
       this.log.info(`Submitted rollup block ${block.number} with ${processedValidTxs.length} transactions`);
     } catch (err) {
@@ -239,37 +235,6 @@ export class Sequencer {
     }
   }
 
-  /**
-   * 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 publishExtendedContractData(validTxs: ProcessedTx[], block: L2Block) {
-    // Publishes contract data for txs to the network and awaits the tx to be mined
-    this.state = SequencerState.PUBLISHING_CONTRACT_DATA;
-    const newContracts = validTxs.flatMap(tx => tx.newContracts).filter(cd => !cd.isEmpty());
-
-    if (newContracts.length === 0) {
-      this.log.debug(`No new contracts to publish in block ${block.number}`);
-      return;
-    }
-
-    const txsEffectsHash = block.body.getTxsEffectsHash();
-    this.log.info(`Publishing ${newContracts.length} contracts in block ${block.number}`);
-
-    const publishedContractData = await this.publisher.processNewContractData(
-      block.number,
-      txsEffectsHash,
-      newContracts,
-    );
-
-    if (publishedContractData) {
-      this.log(`Successfully published new contract data for block ${block.number}`);
-    } else if (!publishedContractData && newContracts.length) {
-      this.log(`Failed to publish new contract data for block ${block.number}`);
-    }
-  }
-
   /**
    * Publishes the L2Block to the rollup contract.
    * @param block - The L2Block to be published.

package/src/simulator/public_executor.ts

@@ -45,16 +45,6 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    * @param tx - The transaction to add contracts from.
    */
   public addNewContracts(tx: Tx): Promise<void> {
-    for (const contract of tx.newContracts) {
-      const contractAddress = contract.contractData.contractAddress;
-
-      if (contractAddress.isZero()) {
-        continue;
-      }
-
-      this.cache.set(contractAddress.toString(), contract);
-    }
-
     // Extract contract class and instance data from logs and add to cache for this block
     const logs = tx.unencryptedLogs.unrollLogs().map(UnencryptedL2Log.fromBuffer);
     ContractClassRegisteredEvent.fromLogs(logs, ClassRegistererAddress).forEach(e => {
@@ -76,16 +66,6 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    * @param tx - The tx's contracts to be removed
    */
   public removeNewContracts(tx: Tx): Promise<void> {
-    for (const contract of tx.newContracts) {
-      const contractAddress = contract.contractData.contractAddress;
-
-      if (contractAddress.isZero()) {
-        continue;
-      }
-
-      this.cache.delete(contractAddress.toString());
-    }
-
     // TODO(@spalladino): Can this inadvertently delete a valid contract added by another tx?
     // Let's say we have two txs adding the same contract on the same block. If the 2nd one reverts,
     // wouldn't that accidentally remove the contract added on the first one?