@aztec/sequencer-client 0.23.0 → 0.24.0

package/src/publisher/l1-publisher.ts

@@ -0,0 +1,365 @@
+import { ExtendedContractData, L2Block } from '@aztec/circuit-types';
+import { L1PublishStats } from '@aztec/circuit-types/stats';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { InterruptibleSleep } from '@aztec/foundation/sleep';
+
+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;
+  /** Logs emitted in this tx. */
+  logs: any[];
+};
+
+/**
+ * Pushes txs to the L1 chain and waits for their completion.
+ */
+export interface L1PublisherTxSender {
+  /**
+   * Publishes tx effects to Availability Oracle.
+   * @param encodedBody - Encoded block body.
+   * @returns The hash of the mined tx.
+   */
+  sendPublishTx(encodedBody: Buffer): Promise<string | 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.
+   */
+  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>;
+
+  /**
+   * Returns the current archive root.
+   * @returns The current archive root of the rollup contract.
+   */
+  getCurrentArchive(): Promise<Buffer>;
+
+  /**
+   * Checks if the transaction effects of the given block are available.
+   * @param block - The block of which to check whether txs are available.
+   * @returns True if the txs are available, false otherwise.
+   */
+  checkIfTxsAreAvailable(block: L2Block): Promise<boolean>;
+}
+
+/**
+ * Encoded block and proof ready to be pushed to the L1 contract.
+ */
+export type L1ProcessArgs = {
+  /** The L2 block header. */
+  header: Buffer;
+  /** A root of the archive tree after the L2 block is applied. */
+  archive: Buffer;
+  /** Transactions hash. */
+  txsHash: Buffer;
+  /** L2 block body. */
+  body: Buffer;
+  /** Root rollup proof of the L2 block. */
+  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.
+ * - 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;
+  }
+
+  /**
+   * Publishes L2 block on L1.
+   * @param block - L2 block to publish.
+   * @returns True once the tx has been confirmed and is successful, false on revert or interrupt, blocks otherwise.
+   */
+  public async processL2Block(block: L2Block): Promise<boolean> {
+    // TODO(#4148) Remove this block number check, it's here because we don't currently have proper genesis state on the contract
+    const lastArchive = block.header.lastArchive.root.toBuffer();
+    if (block.number != 1 && !(await this.checkLastArchiveHash(lastArchive))) {
+      this.log(`Detected different last archive prior to publishing a block, aborting publish...`);
+      return false;
+    }
+
+    const encodedBody = block.bodyToBuffer();
+
+    // Publish block transaction effects
+    while (!this.interrupted) {
+      if (await this.txSender.checkIfTxsAreAvailable(block)) {
+        this.log(`Transaction effects of a block ${block.number} already published.`);
+        break;
+      }
+
+      const txHash = await this.sendPublishTx(encodedBody);
+      if (!txHash) {
+        return false;
+      }
+
+      const receipt = await this.getTransactionReceipt(txHash);
+      if (!receipt) {
+        return false;
+      }
+
+      if (receipt.status) {
+        let txsHash;
+        if (receipt.logs.length === 1) {
+          // txsHash from IAvailabilityOracle.TxsPublished event
+          txsHash = receipt.logs[0].data;
+        } else {
+          this.log(`Expected 1 log, got ${receipt.logs.length}`);
+        }
+
+        this.log.info(`Block txs effects published, txsHash: ${txsHash}`);
+        break;
+      }
+
+      this.log(`AvailabilityOracle.publish tx status failed: ${receipt.transactionHash}`);
+      await this.sleepOrInterrupted();
+    }
+
+    const processTxArgs = {
+      header: block.header.toBuffer(),
+      archive: block.archive.root.toBuffer(),
+      txsHash: block.getCalldataHash(),
+      body: encodedBody,
+      proof: Buffer.alloc(0),
+    };
+
+    // Process block
+    while (!this.interrupted) {
+      const txHash = await this.sendProcessTx(processTxArgs);
+      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'),
+          ...block.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.checkLastArchiveHash(lastArchive))) {
+        this.log('Publish failed. Detected different last archive hash.');
+        break;
+      }
+
+      this.log(`Rollup.process tx 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) {
+      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;
+  }
+
+  /**
+   * Verifies that the given value of last archive in a block header equals current archive of the rollup contract
+   * @param lastArchive - The last archive of the block we wish to publish.
+   * @returns Boolean indicating if the hashes are equal.
+   */
+  private async checkLastArchiveHash(lastArchive: Buffer): Promise<boolean> {
+    const fromChain = await this.txSender.getCurrentArchive();
+    const areSame = lastArchive.equals(fromChain);
+    if (!areSame) {
+      this.log(`CONTRACT ARCHIVE: ${fromChain.toString('hex')}`);
+      this.log(`NEW BLOCK LAST ARCHIVE: ${lastArchive.toString('hex')}`);
+    }
+    return areSame;
+  }
+
+  private async sendPublishTx(encodedBody: Buffer): Promise<string | undefined> {
+    while (!this.interrupted) {
+      try {
+        return await this.txSender.sendPublishTx(encodedBody);
+      } catch (err) {
+        this.log.error(`TxEffects publish failed`, err);
+        return undefined;
+      }
+    }
+  }
+
+  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

@@ -0,0 +1,241 @@
+import { BLOB_SIZE_IN_BYTES, ExtendedContractData, 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 {
+  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 availabilityOracleContract: GetContractReturnType<
+    typeof AvailabilityOracleAbi,
+    PublicClient<HttpTransport, chains.Chain>,
+    WalletClient<HttpTransport, chains.Chain, PrivateKeyAccount>
+  >;
+  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.availabilityOracleContract = getContract({
+      address: getAddress(l1Contracts.availabilityOracleAddress.toString()),
+      abi: AvailabilityOracleAbi,
+      publicClient: this.publicClient,
+      walletClient,
+    });
+    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 getCurrentArchive(): Promise<Buffer> {
+    const archive = await this.rollupContract.read.archive();
+    return Buffer.from(archive.replace('0x', ''), 'hex');
+  }
+
+  checkIfTxsAreAvailable(block: L2Block): Promise<boolean> {
+    const args = [`0x${block.getCalldataHash().toString('hex')}`] as const;
+    return this.availabilityOracleContract.read.isAvailable(args);
+  }
+
+  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,
+        logs: receipt.logs,
+      };
+    }
+
+    this.log(`Receipt not found for tx hash ${txHash}`);
+    return undefined;
+  }
+
+  /**
+   * Publishes tx effects to Availability Oracle.
+   * @param encodedBody - Encoded block body.
+   * @returns The hash of the mined tx.
+   */
+  async sendPublishTx(encodedBody: Buffer): Promise<string | undefined> {
+    const args = [`0x${encodedBody.toString('hex')}`] as const;
+
+    const gas = await this.availabilityOracleContract.estimateGas.publish(args, {
+      account: this.account,
+    });
+    const hash = await this.availabilityOracleContract.write.publish(args, {
+      gas,
+      account: this.account,
+    });
+    return hash;
+  }
+
+  /**
+   * 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.header.toString('hex')}`,
+      `0x${encodedData.archive.toString('hex')}`,
+      `0x${encodedData.txsHash.toString('hex')}`,
+      `0x${encodedData.body.toString('hex')}`,
+      `0x${encodedData.proof.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.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.
+   * @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

@@ -0,0 +1,13 @@
+import { L2Block } from '@aztec/circuit-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>;
+}