@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.001888fc

package/dest/l1_tx_utils_with_blobs.js

@@ -1,64 +0,0 @@
-import { Blob } from '@aztec/blob-lib';
-import { formatGwei } from 'viem';
-import { L1TxUtils } from './l1_tx_utils.js';
-export class L1TxUtilsWithBlobs extends L1TxUtils {
-    /**
-   * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
-   * @param nonce - The nonce of the transaction to cancel
-   * @param previousGasPrice - The gas price of the previous transaction
-   * @param attempts - The number of attempts to cancel the transaction
-   * @returns The hash of the cancellation transaction
-   */ async attemptTxCancellation(nonce, isBlobTx = false, previousGasPrice, attempts = 0) {
-        const account = this.walletClient.account;
-        // Get gas price with higher priority fee for cancellation
-        const cancelGasPrice = await this.getGasPrice({
-            ...this.config,
-            // Use high bump for cancellation to ensure it replaces the original tx
-            priorityFeeRetryBumpPercentage: 150
-        }, isBlobTx, attempts + 1, previousGasPrice);
-        this.logger?.debug(`Attempting to cancel transaction with nonce ${nonce}`, {
-            maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
-            maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas)
-        });
-        const request = {
-            to: account.address,
-            value: 0n
-        };
-        // Send 0-value tx to self with higher gas price
-        if (!isBlobTx) {
-            const cancelTxHash = await this.walletClient.sendTransaction({
-                ...request,
-                nonce,
-                gas: 21_000n,
-                maxFeePerGas: cancelGasPrice.maxFeePerGas,
-                maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas
-            });
-            const receipt = await this.monitorTransaction(request, cancelTxHash, {
-                gasLimit: 21_000n
-            }, undefined, undefined, true);
-            return receipt.transactionHash;
-        } else {
-            const blobData = new Uint8Array(131072).fill(0);
-            const kzg = Blob.getViemKzgInstance();
-            const blobInputs = {
-                blobs: [
-                    blobData
-                ],
-                kzg,
-                maxFeePerBlobGas: cancelGasPrice.maxFeePerBlobGas
-            };
-            const cancelTxHash = await this.walletClient.sendTransaction({
-                ...request,
-                ...blobInputs,
-                nonce,
-                gas: 21_000n,
-                maxFeePerGas: cancelGasPrice.maxFeePerGas,
-                maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas
-            });
-            const receipt = await this.monitorTransaction(request, cancelTxHash, {
-                gasLimit: 21_000n
-            }, undefined, blobInputs, true);
-            return receipt.transactionHash;
-        }
-    }
-}

package/dest/test/delayed_tx_utils.d.ts

@@ -1,8 +0,0 @@
-import { L1TxUtilsWithBlobs } from '../l1_tx_utils_with_blobs.js';
-import { type Delayer } from './tx_delayer.js';
-export declare class DelayedTxUtils extends L1TxUtilsWithBlobs {
-    delayer: Delayer | undefined;
-    static fromL1TxUtils(l1TxUtils: L1TxUtilsWithBlobs, ethereumSlotDuration: number): DelayedTxUtils;
-    enableDelayer(ethereumSlotDuration: number): void;
-}
-//# sourceMappingURL=delayed_tx_utils.d.ts.map

package/dest/test/delayed_tx_utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delayed_tx_utils.d.ts","sourceRoot":"","sources":["../../src/test/delayed_tx_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,KAAK,OAAO,EAAe,MAAM,iBAAiB,CAAC;AAE5D,qBAAa,cAAe,SAAQ,kBAAkB;IAC7C,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;WAEtB,aAAa,CAAC,SAAS,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM;IAUhF,aAAa,CAAC,oBAAoB,EAAE,MAAM;CAOlD"}

package/dest/test/delayed_tx_utils.js

@@ -1,21 +0,0 @@
-import { L1TxUtilsWithBlobs } from '../l1_tx_utils_with_blobs.js';
-import { withDelayer } from './tx_delayer.js';
-export class DelayedTxUtils extends L1TxUtilsWithBlobs {
-    delayer;
-    static fromL1TxUtils(l1TxUtils, ethereumSlotDuration) {
-        const { client, delayer } = withDelayer(l1TxUtils.walletClient, {
-            ethereumSlotDuration
-        });
-        const casted = l1TxUtils;
-        casted.delayer = delayer;
-        casted.walletClient = client;
-        return casted;
-    }
-    enableDelayer(ethereumSlotDuration) {
-        const { client, delayer } = withDelayer(this.walletClient, {
-            ethereumSlotDuration
-        });
-        this.delayer = delayer;
-        this.walletClient = client;
-    }
-}

package/dest/test/tx_delayer.d.ts

@@ -1,25 +0,0 @@
-import { type Logger } from '@aztec/foundation/log';
-import { type Client, type Hex } from 'viem';
-import type { ViemWalletClient } from '../types.js';
-export declare function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: Logger): Promise<boolean>;
-export declare function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: number | bigint, logger?: Logger): Promise<boolean>;
-export interface Delayer {
-    /** Returns the list of all txs (not just the delayed ones) sent through the attached client. */
-    getTxs(): Hex[];
-    /** Delays the next tx to be sent so it lands on the given L1 block number. */
-    pauseNextTxUntilBlock(l1BlockNumber: number | bigint | undefined): void;
-    /** Delays the next tx to be sent so it lands on the given timestamp. */
-    pauseNextTxUntilTimestamp(l1Timestamp: number | bigint | undefined): void;
-}
-/**
- * Returns a new client (without modifying the one passed in) with an injected tx delayer.
- * The delayer can be used to hold off the next tx to be sent until a given block number.
- * TODO(#10824): This doesn't play along well with blob txs for some reason.
- */
-export declare function withDelayer<T extends ViemWalletClient>(client: T, opts: {
-    ethereumSlotDuration: bigint | number;
-}): {
-    client: T;
-    delayer: Delayer;
-};
-//# sourceMappingURL=tx_delayer.d.ts.map

package/dest/test/tx_delayer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tx_delayer.d.ts","sourceRoot":"","sources":["../../src/test/tx_delayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,OAAO,EACL,KAAK,MAAM,EACX,KAAK,GAAG,EAMT,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,oBAgBxG;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,oBAuB5G;AAED,MAAM,WAAW,OAAO;IACtB,gGAAgG;IAChG,MAAM,IAAI,GAAG,EAAE,CAAC;IAChB,8EAA8E;IAC9E,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACxE,wEAAwE;IACxE,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;CAC3E;AAwBD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,gBAAgB,EACpD,MAAM,EAAE,CAAC,EACT,IAAI,EAAE;IAAE,oBAAoB,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAC9C;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA+DjC"}

package/dest/test/tx_delayer.js

@@ -1,116 +0,0 @@
-import { omit } from '@aztec/foundation/collection';
-import { createLogger } from '@aztec/foundation/log';
-import { retryUntil } from '@aztec/foundation/retry';
-import { inspect } from 'util';
-import { keccak256, parseTransaction, publicActions, walletActions } from 'viem';
-export function waitUntilBlock(client, blockNumber, logger) {
-    const publicClient = 'getBlockNumber' in client && typeof client.getBlockNumber === 'function' ? client : client.extend(publicActions);
-    return retryUntil(async ()=>{
-        const currentBlockNumber = await publicClient.getBlockNumber({
-            cacheTime: 0
-        });
-        logger?.debug(`Block number is ${currentBlockNumber} (waiting until ${blockNumber})`);
-        return currentBlockNumber >= BigInt(blockNumber);
-    }, `Wait until L1 block ${blockNumber}`, 120, 0.1);
-}
-export function waitUntilL1Timestamp(client, timestamp, logger) {
-    const publicClient = 'getBlockNumber' in client && typeof client.getBlockNumber === 'function' ? client : client.extend(publicActions);
-    let lastBlock = undefined;
-    return retryUntil(async ()=>{
-        const currentBlockNumber = await publicClient.getBlockNumber({
-            cacheTime: 0
-        });
-        if (currentBlockNumber === lastBlock) {
-            return false;
-        }
-        lastBlock = currentBlockNumber;
-        const currentBlock = await publicClient.getBlock({
-            includeTransactions: false,
-            blockNumber: currentBlockNumber
-        });
-        const currentTs = currentBlock.timestamp;
-        logger?.debug(`Block timstamp is ${currentTs} (waiting until ${timestamp})`);
-        return currentTs >= BigInt(timestamp);
-    }, `Wait until L1 timestamp ${timestamp}`, 120, 0.1);
-}
-class DelayerImpl {
-    constructor(opts){
-        this.ethereumSlotDuration = BigInt(opts.ethereumSlotDuration);
-    }
-    ethereumSlotDuration;
-    nextWait = undefined;
-    txs = [];
-    getTxs() {
-        return this.txs;
-    }
-    pauseNextTxUntilBlock(l1BlockNumber) {
-        this.nextWait = {
-            l1BlockNumber: BigInt(l1BlockNumber)
-        };
-    }
-    pauseNextTxUntilTimestamp(l1Timestamp) {
-        this.nextWait = {
-            l1Timestamp: BigInt(l1Timestamp)
-        };
-    }
-}
-/**
- * Returns a new client (without modifying the one passed in) with an injected tx delayer.
- * The delayer can be used to hold off the next tx to be sent until a given block number.
- * TODO(#10824): This doesn't play along well with blob txs for some reason.
- */ export function withDelayer(client, opts) {
-    const logger = createLogger('ethereum:tx_delayer');
-    const delayer = new DelayerImpl(opts);
-    const extended = client// Tweak sendRawTransaction so it uses the delay defined in the delayer.
-    // Note that this will only work with local accounts (ie accounts for which we have the private key).
-    // Transactions signed by the node will not be delayed since they use sendTransaction directly,
-    // but we do not use them in our codebase at all.
-    .extend((client)=>({
-            async sendRawTransaction (...args) {
-                if (delayer.nextWait !== undefined) {
-                    const waitUntil = delayer.nextWait;
-                    delayer.nextWait = undefined;
-                    const publicClient = client;
-                    const wait = 'l1BlockNumber' in waitUntil ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger) : waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger);
-                    // Compute the tx hash manually so we emulate sendRawTransaction response
-                    const { serializedTransaction } = args[0];
-                    const txHash = keccak256(serializedTransaction);
-                    logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
-                        argsLen: args.length,
-                        ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars')
-                    });
-                    // Do not await here so we can return the tx hash immediately as if it had been sent on the spot.
-                    // Instead, delay it so it lands on the desired block number or timestamp, assuming anvil will
-                    // mine it immediately.
-                    void wait.then(async ()=>{
-                        const clientTxHash = await client.sendRawTransaction(...args);
-                        if (clientTxHash !== txHash) {
-                            logger.error(`Tx hash returned by the client does not match computed one`, {
-                                clientTxHash,
-                                computedTxHash: txHash
-                            });
-                        }
-                        logger.info(`Sent previously delayed tx ${clientTxHash} to land on ${inspect(waitUntil)}`);
-                        delayer.txs.push(clientTxHash);
-                    }).catch((err)=>logger.error(`Error sending tx after delay`, err));
-                    return Promise.resolve(txHash);
-                } else {
-                    const txHash = await client.sendRawTransaction(...args);
-                    logger.verbose(`Sent tx immediately ${txHash}`);
-                    delayer.txs.push(txHash);
-                    return txHash;
-                }
-            }
-        }))// Re-extend with sendTransaction so it uses the modified sendRawTransaction.
-    .extend((client)=>({
-            sendTransaction: walletActions(client).sendTransaction
-        }))// And with the actions that depend on the modified sendTransaction
-    .extend((client)=>({
-            writeContract: walletActions(client).writeContract,
-            deployContract: walletActions(client).deployContract
-        }));
-    return {
-        client: extended,
-        delayer
-    };
-}

package/src/contracts/forwarder.ts

@@ -1,132 +0,0 @@
-import { toHex } from '@aztec/foundation/bigint-buffer';
-import type { Logger } from '@aztec/foundation/log';
-import { ForwarderAbi, ForwarderBytecode } from '@aztec/l1-artifacts';
-
-import {
-  type EncodeFunctionDataParameters,
-  type GetContractReturnType,
-  type Hex,
-  encodeFunctionData,
-  getContract,
-} from 'viem';
-
-import { deployL1Contract } from '../deploy_l1_contracts.js';
-import type { L1BlobInputs, L1GasConfig, L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
-import type { L1Clients, ViemPublicClient, ViemWalletClient } from '../types.js';
-import { RollupContract } from './rollup.js';
-
-export class ForwarderContract {
-  private readonly forwarder: GetContractReturnType<typeof ForwarderAbi, ViemPublicClient>;
-
-  constructor(public readonly client: L1Clients['publicClient'], address: Hex, public readonly rollupAddress: Hex) {
-    this.forwarder = getContract({ address, abi: ForwarderAbi, client });
-  }
-
-  static async create(
-    owner: Hex,
-    walletClient: ViemWalletClient,
-    publicClient: ViemPublicClient,
-    logger: Logger,
-    rollupAddress: Hex,
-  ) {
-    logger.info('Deploying forwarder contract');
-
-    const { address, txHash } = await deployL1Contract(
-      walletClient,
-      publicClient,
-      ForwarderAbi,
-      ForwarderBytecode,
-      [owner],
-      owner,
-      undefined,
-      logger,
-    );
-
-    if (txHash) {
-      await publicClient.waitForTransactionReceipt({ hash: txHash });
-    }
-
-    logger.info(`Forwarder contract deployed at ${address} with owner ${owner}`);
-
-    return new ForwarderContract(publicClient, address.toString(), rollupAddress);
-  }
-
-  public getAddress() {
-    return this.forwarder.address;
-  }
-
-  public async forward(
-    requests: L1TxRequest[],
-    l1TxUtils: L1TxUtils,
-    gasConfig: L1GasConfig | undefined,
-    blobConfig: L1BlobInputs | undefined,
-    logger: Logger,
-  ) {
-    requests = requests.filter(request => request.to !== null);
-    const toArgs = requests.map(request => request.to!);
-    const dataArgs = requests.map(request => request.data!);
-    const forwarderFunctionData: EncodeFunctionDataParameters<typeof ForwarderAbi, 'forward'> = {
-      abi: ForwarderAbi,
-      functionName: 'forward',
-      args: [toArgs, dataArgs],
-    };
-    const encodedForwarderData = encodeFunctionData(forwarderFunctionData);
-
-    const { receipt, gasPrice } = await l1TxUtils.sendAndMonitorTransaction(
-      {
-        to: this.forwarder.address,
-        data: encodedForwarderData,
-      },
-      gasConfig,
-      blobConfig,
-    );
-
-    if (receipt.status === 'success') {
-      const stats = await l1TxUtils.getTransactionStats(receipt.transactionHash);
-      return { receipt, gasPrice, stats };
-    } else {
-      logger.error('Forwarder transaction failed', undefined, { receipt });
-
-      const args = {
-        ...forwarderFunctionData,
-        address: this.forwarder.address,
-      };
-
-      let errorMsg: string | undefined;
-
-      if (blobConfig) {
-        const maxFeePerBlobGas = blobConfig.maxFeePerBlobGas ?? gasPrice.maxFeePerBlobGas;
-        if (maxFeePerBlobGas === undefined) {
-          errorMsg = 'maxFeePerBlobGas is required to get the error message';
-        } else {
-          logger.debug('Trying to get error from reverted tx with blob config');
-          errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(
-            encodedForwarderData,
-            args,
-            {
-              blobs: blobConfig.blobs,
-              kzg: blobConfig.kzg,
-              maxFeePerBlobGas,
-            },
-            [
-              {
-                address: this.rollupAddress,
-                stateDiff: [
-                  {
-                    slot: toHex(RollupContract.checkBlobStorageSlot, true),
-                    value: toHex(0n, true),
-                  },
-                ],
-              },
-            ],
-          );
-        }
-      } else {
-        logger.debug('Trying to get error from reverted tx without blob config');
-        errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedForwarderData, args, undefined, []);
-      }
-
-      return { receipt, gasPrice, errorMsg };
-    }
-  }
-}

package/src/contracts/slashing_proposer.ts

@@ -1,51 +0,0 @@
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { SlashingProposerAbi } from '@aztec/l1-artifacts';
-
-import { type GetContractReturnType, type Hex, getContract } from 'viem';
-
-import type { L1TxRequest } from '../l1_tx_utils.js';
-import type { ViemPublicClient } from '../types.js';
-import { type IEmpireBase, encodeVote } from './empire_base.js';
-
-export class SlashingProposerContract implements IEmpireBase {
-  private readonly proposer: GetContractReturnType<typeof SlashingProposerAbi, ViemPublicClient>;
-
-  constructor(public readonly client: ViemPublicClient, address: Hex) {
-    this.proposer = getContract({ address, abi: SlashingProposerAbi, client });
-  }
-
-  public get address() {
-    return EthAddress.fromString(this.proposer.address);
-  }
-
-  public getQuorumSize() {
-    return this.proposer.read.N();
-  }
-
-  public getRoundSize() {
-    return this.proposer.read.M();
-  }
-
-  public computeRound(slot: bigint): Promise<bigint> {
-    return this.proposer.read.computeRound([slot]);
-  }
-
-  public async getRoundInfo(
-    rollupAddress: Hex,
-    round: bigint,
-  ): Promise<{ lastVote: bigint; leader: Hex; executed: boolean }> {
-    const roundInfo = await this.proposer.read.rounds([rollupAddress, round]);
-    return {
-      lastVote: roundInfo[0],
-      leader: roundInfo[1],
-      executed: roundInfo[2],
-    };
-  }
-
-  public createVoteRequest(payload: Hex): L1TxRequest {
-    return {
-      to: this.address.toString(),
-      data: encodeVote(payload),
-    };
-  }
-}