@aztec/sequencer-client 0.16.4 → 0.16.6

package/src/publisher/l1-publisher.ts

@@ -1,291 +0,0 @@
-import { createDebugLogger } from '@aztec/foundation/log';
-import { InterruptibleSleep } from '@aztec/foundation/sleep';
-import { ExtendedContractData, L2Block } from '@aztec/types';
-import { L1PublishStats } from '@aztec/types/stats';
-
-import pick from 'lodash.pick';
-
-import { L2BlockReceiver } from '../receiver.js';
-import { PublisherConfig } from './config.js';
-
-/**
- * Stats for a sent transaction.
- */
-export type TransactionStats = {
-  /** Hash of the transaction. */
-  transactionHash: string;
-  /** Size in bytes of the tx calldata */
-  calldataSize: number;
-  /** Gas required to pay for the calldata inclusion (depends on size and number of zeros)  */
-  calldataGas: number;
-};
-
-/**
- * Minimal information from a tx receipt returned by an L1PublisherTxSender.
- */
-export type MinimalTransactionReceipt = {
-  /** True if the tx was successful, false if reverted. */
-  status: boolean;
-  /** Hash of the transaction. */
-  transactionHash: string;
-  /** Effective gas used by the tx */
-  gasUsed: bigint;
-  /** Effective gas price paid by the tx */
-  gasPrice: bigint;
-};
-
-/**
- * Pushes txs to the L1 chain and waits for their completion.
- */
-export interface L1PublisherTxSender {
-  /**
-   * Sends a tx to the L1 rollup contract with a new L2 block. Returns once the tx has been mined.
-   * @param encodedData - Serialized data for processing the new L2 block.
-   * @returns The hash of the mined tx.
-   */
-  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.
-   * @returns Undefined if the tx hasn't been mined yet, the receipt otherwise.
-   */
-  getTransactionReceipt(txHash: string): Promise<MinimalTransactionReceipt | undefined>;
-
-  /**
-   * Returns info on a tx by calling eth_getTransaction.
-   * @param txHash - Hash of the tx to look for.
-   */
-  getTransactionStats(txHash: string): Promise<TransactionStats | undefined>;
-}
-
-/**
- * Encoded block data and proof ready to be pushed to the L1 contract.
- */
-export type L1ProcessArgs = {
-  /**
-   * Root rollup proof for an L1 block.
-   */
-  proof: Buffer;
-  /**
-   * Serialized L2Block data.
-   */
-  inputs: 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.
- * - If sending (not mining) a tx fails, it retries indefinitely at 1-minute intervals.
- * - If the tx is not mined, keeps polling indefinitely at 1-second intervals.
- *
- * Adapted from https://github.com/AztecProtocol/aztec2-internal/blob/master/falafel/src/rollup_publisher.ts.
- */
-export class L1Publisher implements L2BlockReceiver {
-  private interruptibleSleep = new InterruptibleSleep();
-  private sleepTimeMs: number;
-  private interrupted = false;
-  private log = createDebugLogger('aztec:sequencer:publisher');
-
-  constructor(private txSender: L1PublisherTxSender, config?: PublisherConfig) {
-    this.sleepTimeMs = config?.l1BlockPublishRetryIntervalMS ?? 60_000;
-  }
-
-  /**
-   * Processes incoming L2 block data by publishing it to the L1 rollup contract.
-   * @param l2BlockData - L2 block data to publish.
-   * @returns True once the tx has been confirmed and is successful, false on revert or interrupt, blocks otherwise.
-   */
-  public async processL2Block(l2BlockData: L2Block): Promise<boolean> {
-    const proof = Buffer.alloc(0);
-    const txData = { proof, inputs: l2BlockData.toBufferWithLogs() };
-
-    while (!this.interrupted) {
-      if (!(await this.checkFeeDistributorBalance())) {
-        this.log(`Fee distributor ETH balance too low, awaiting top up...`);
-        await this.sleepOrInterrupted();
-        continue;
-      }
-
-      const txHash = await this.sendProcessTx(txData);
-      if (!txHash) {
-        break;
-      }
-
-      const receipt = await this.getTransactionReceipt(txHash);
-      if (!receipt) {
-        break;
-      }
-
-      // Tx was mined successfully
-      if (receipt.status) {
-        const tx = await this.txSender.getTransactionStats(txHash);
-        const stats: L1PublishStats = {
-          ...pick(receipt, 'gasPrice', 'gasUsed', 'transactionHash'),
-          ...pick(tx!, 'calldataGas', 'calldataSize'),
-          ...l2BlockData.getStats(),
-          eventName: 'rollup-published-to-l1',
-        };
-        this.log.info(`Published L2 block to L1 rollup contract`, stats);
-        return true;
-      }
-
-      // Check if someone else incremented the block number
-      if (!(await this.checkNextL2BlockNum(l2BlockData.number))) {
-        this.log('Publish failed. Contract changed underfoot.');
-        break;
-      }
-
-      this.log(`Transaction status failed: ${receipt.transactionHash}`);
-      await this.sleepOrInterrupted();
-    }
-
-    this.log('L2 block data syncing interrupted while processing blocks.');
-    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) {
-      if (!(await this.checkFeeDistributorBalance())) {
-        this.log(`Fee distributor ETH balance too low, awaiting top up...`);
-        await this.sleepOrInterrupted();
-        continue;
-      }
-
-      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.
-   * In practice this shouldn't matter, as we'll only ever be calling `interrupt` when we know it's going to fail.
-   * A call to `restart` is required before you can continue publishing.
-   */
-  public interrupt() {
-    this.interrupted = true;
-    this.interruptibleSleep.interrupt();
-  }
-
-  /** Restarts the publisher after calling `interrupt`. */
-  public restart() {
-    this.interrupted = false;
-  }
-
-  // TODO: Check fee distributor has at least 0.5 ETH.
-  // Related to https://github.com/AztecProtocol/aztec-packages/issues/1588
-  // eslint-disable-next-line require-await
-  private async checkFeeDistributorBalance(): Promise<boolean> {
-    return true;
-  }
-
-  // TODO: Fail if blockchainStatus.nextBlockNum > thisBlockNum.
-  // Related to https://github.com/AztecProtocol/aztec-packages/issues/1588
-  private checkNextL2BlockNum(_thisBlockNum: number): Promise<boolean> {
-    return Promise.resolve(true);
-  }
-
-  private async sendProcessTx(encodedData: L1ProcessArgs): Promise<string | undefined> {
-    while (!this.interrupted) {
-      try {
-        return await this.txSender.sendProcessTx(encodedData);
-      } catch (err) {
-        this.log.error(`Rollup publish failed`, err);
-        return undefined;
-      }
-    }
-  }
-
-  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 {
-        return await this.txSender.getTransactionReceipt(txHash);
-      } catch (err) {
-        //this.log.error(`Error getting tx receipt`, err);
-        await this.sleepOrInterrupted();
-      }
-    }
-  }
-
-  protected async sleepOrInterrupted() {
-    await this.interruptibleSleep.sleep(this.sleepTimeMs);
-  }
-}

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

@@ -1,195 +0,0 @@
-import { createEthereumChain } from '@aztec/ethereum';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { ContractDeploymentEmitterAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { BLOB_SIZE_IN_BYTES, ExtendedContractData } from '@aztec/types';
-
-import {
-  GetContractReturnType,
-  Hex,
-  HttpTransport,
-  PublicClient,
-  WalletClient,
-  createPublicClient,
-  createWalletClient,
-  getAddress,
-  getContract,
-  hexToBytes,
-  http,
-} from 'viem';
-import { PrivateKeyAccount, privateKeyToAccount } from 'viem/accounts';
-import * as chains from 'viem/chains';
-
-import { TxSenderConfig } from './config.js';
-import {
-  L1PublisherTxSender,
-  MinimalTransactionReceipt,
-  L1ProcessArgs as ProcessTxArgs,
-  TransactionStats,
-} from './l1-publisher.js';
-
-/**
- * Pushes transactions to the L1 rollup contract using viem.
- */
-export class ViemTxSender implements L1PublisherTxSender {
-  private rollupContract: GetContractReturnType<
-    typeof RollupAbi,
-    PublicClient<HttpTransport, chains.Chain>,
-    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
-  >;
-  private contractDeploymentEmitterContract: GetContractReturnType<
-    typeof ContractDeploymentEmitterAbi,
-    PublicClient<HttpTransport, chains.Chain>,
-    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
-  >;
-
-  private log = createDebugLogger('aztec:sequencer:viem-tx-sender');
-  private publicClient: PublicClient<HttpTransport, chains.Chain>;
-  private account: PrivateKeyAccount;
-
-  constructor(config: TxSenderConfig) {
-    const { rpcUrl, apiKey, publisherPrivateKey, l1Contracts } = config;
-    const chain = createEthereumChain(rpcUrl, apiKey);
-    this.account = privateKeyToAccount(publisherPrivateKey);
-    const walletClient = createWalletClient({
-      account: this.account,
-      chain: chain.chainInfo,
-      transport: http(chain.rpcUrl),
-    });
-
-    this.publicClient = createPublicClient({
-      chain: chain.chainInfo,
-      transport: http(chain.rpcUrl),
-    });
-
-    this.rollupContract = getContract({
-      address: getAddress(l1Contracts.rollupAddress.toString()),
-      abi: RollupAbi,
-      publicClient: this.publicClient,
-      walletClient,
-    });
-    this.contractDeploymentEmitterContract = getContract({
-      address: getAddress(l1Contracts.contractDeploymentEmitterAddress.toString()),
-      abi: ContractDeploymentEmitterAbi,
-      publicClient: this.publicClient,
-      walletClient,
-    });
-  }
-
-  async getTransactionStats(txHash: string): Promise<TransactionStats | undefined> {
-    const tx = await this.publicClient.getTransaction({ hash: txHash as Hex });
-    if (!tx) {
-      return undefined;
-    }
-    const calldata = hexToBytes(tx.input);
-    return {
-      transactionHash: tx.hash,
-      calldataSize: calldata.length,
-      calldataGas: getCalldataGasUsage(calldata),
-    };
-  }
-
-  /**
-   * Returns a tx receipt if the tx has been mined.
-   * @param txHash - Hash of the tx to look for.
-   * @returns Undefined if the tx hasn't been mined yet, the receipt otherwise.
-   */
-  async getTransactionReceipt(txHash: string): Promise<MinimalTransactionReceipt | undefined> {
-    const receipt = await this.publicClient.getTransactionReceipt({
-      hash: txHash as Hex,
-    });
-
-    if (receipt) {
-      return {
-        status: receipt.status === 'success',
-        transactionHash: txHash,
-        gasUsed: receipt.gasUsed,
-        gasPrice: receipt.effectiveGasPrice,
-      };
-    }
-
-    this.log(`Receipt not found for tx hash ${txHash}`);
-    return undefined;
-  }
-
-  /**
-   * Sends a tx to the L1 rollup contract with a new L2 block. Returns once the tx has been mined.
-   * @param encodedData - Serialized data for processing the new L2 block.
-   * @returns The hash of the mined tx.
-   */
-  async sendProcessTx(encodedData: ProcessTxArgs): Promise<string | undefined> {
-    const args = [`0x${encodedData.proof.toString('hex')}`, `0x${encodedData.inputs.toString('hex')}`] as const;
-
-    const gas = await this.rollupContract.estimateGas.process(args, {
-      account: this.account,
-    });
-    const hash = await this.rollupContract.write.process(args, {
-      gas,
-      account: this.account,
-    });
-    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.partialAddress.toString(),
-        extendedContractData.publicKey.x.toString(),
-        extendedContractData.publicKey.y.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.
-   * @returns Viem's chain object.
-   */
-  private getChain(chainId: number) {
-    for (const chain of Object.values(chains)) {
-      if ('id' in chain && chain.id === chainId) {
-        return chain;
-      }
-    }
-
-    throw new Error(`Chain with id ${chainId} not found`);
-  }
-}
-
-/**
- * Returns cost of calldata usage in Ethereum.
- * @param data - Calldata.
- * @returns 4 for each zero byte, 16 for each nonzero.
- */
-function getCalldataGasUsage(data: Uint8Array) {
-  return data.filter(byte => byte === 0).length * 4 + data.filter(byte => byte !== 0).length * 16;
-}

package/src/receiver.ts

@@ -1,13 +0,0 @@
-import { L2Block } from '@aztec/types';
-
-/**
- * Given the necessary rollup data, verifies it, and updates the underlying state accordingly to advance the state of the system.
- * See https://hackmd.io/ouVCnacHQRq2o1oRc5ksNA#RollupReceiver.
- */
-export interface L2BlockReceiver {
-  /**
-   * Receive and L2 block and process it, returns true if successful.
-   * @param l2BlockData - L2 block to process.
-   */
-  processL2Block(l2BlockData: L2Block): Promise<boolean>;
-}

package/src/sequencer/config.ts

@@ -1 +0,0 @@
-export { SequencerConfig } from '@aztec/types';

package/src/sequencer/index.ts

@@ -1,3 +0,0 @@
-export * from './sequencer.js';
-export * from './config.js';
-export * from './utils.js';

package/src/sequencer/processed_tx.ts

@@ -1,107 +0,0 @@
-import {
-  BlockHeader,
-  CombinedAccumulatedData,
-  Fr,
-  Proof,
-  PublicKernelPublicInputs,
-  makeEmptyProof,
-} from '@aztec/circuits.js';
-import { ExtendedContractData, Tx, TxHash, TxL2Logs } from '@aztec/types';
-
-/**
- * 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'> & {
-  /**
-   * Output of the public kernel circuit for this tx.
-   */
-  data: PublicKernelPublicInputs;
-  /**
-   * Hash of the transaction.
-   */
-  hash: TxHash;
-  /**
-   * Flag indicating the tx is 'empty' meaning it's a padding tx to take us to a power of 2.
-   */
-  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.
- */
-export async function makeProcessedTx(tx: Tx): Promise<ProcessedTx>;
-
-/**
- * Makes a processed tx out of a tx with a public component that needs processing.
- * @param tx - Source tx.
- * @param kernelOutput - Output of the public kernel circuit simulation for this tx.
- * @param proof - Proof of the public kernel circuit for this tx.
- */
-export async function makeProcessedTx(
-  tx: Tx,
-  kernelOutput: PublicKernelPublicInputs,
-  proof: Proof,
-): Promise<ProcessedTx>;
-
-/**
- * Makes a processed tx out of source tx.
- * @param tx - Source tx.
- * @param kernelOutput - Output of the kernel circuit simulation for this tx.
- * @param proof - Proof of the kernel circuit for this tx.
- */
-export async function makeProcessedTx(
-  tx: Tx,
-  kernelOutput?: PublicKernelPublicInputs,
-  proof?: Proof,
-): Promise<ProcessedTx> {
-  return {
-    hash: await tx.getTxHash(),
-    data:
-      kernelOutput ??
-      new PublicKernelPublicInputs(CombinedAccumulatedData.fromFinalAccumulatedData(tx.data.end), tx.data.constants),
-    proof: proof ?? tx.proof,
-    encryptedLogs: tx.encryptedLogs,
-    unencryptedLogs: tx.unencryptedLogs,
-    newContracts: tx.newContracts,
-    isEmpty: false,
-  };
-}
-
-/**
- * Makes an empty tx from an empty kernel circuit public inputs.
- * @returns A processed empty tx.
- */
-export function makeEmptyProcessedTx(historicalTreeRoots: BlockHeader, chainId: Fr, version: Fr): Promise<ProcessedTx> {
-  const emptyKernelOutput = PublicKernelPublicInputs.empty();
-  emptyKernelOutput.constants.blockHeader = historicalTreeRoots;
-  emptyKernelOutput.constants.txContext.chainId = chainId;
-  emptyKernelOutput.constants.txContext.version = version;
-  const emptyProof = makeEmptyProof();
-
-  const hash = new TxHash(Fr.ZERO.toBuffer());
-  return Promise.resolve({
-    hash,
-    encryptedLogs: new TxL2Logs([]),
-    unencryptedLogs: new TxL2Logs([]),
-    data: emptyKernelOutput,
-    proof: emptyProof,
-    newContracts: [ExtendedContractData.empty()],
-    isEmpty: true,
-  });
-}