@aztec/sequencer-client 0.26.6 → 0.27.0

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/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?