@aztec/ethereum 0.0.1-commit.b655e406 → 0.0.1-commit.d3ec352c

package/src/contracts/rollup.ts

@@ -1,3 +1,4 @@
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
@@ -61,6 +62,7 @@ export type EpochProofPublicInputArgs = {
 
 export type ViemHeader = {
   lastArchiveRoot: `0x${string}`;
+  blockHeadersHash: `0x${string}`;
   contentCommitment: ViemContentCommitment;
   slotNumber: bigint;
   timestamp: bigint;
@@ -81,22 +83,6 @@ export type ViemGasFees = {
   feePerL2Gas: bigint;
 };
 
-export type ViemStateReference = {
-  l1ToL2MessageTree: ViemAppendOnlyTreeSnapshot;
-  partialStateReference: ViemPartialStateReference;
-};
-
-export type ViemPartialStateReference = {
-  noteHashTree: ViemAppendOnlyTreeSnapshot;
-  nullifierTree: ViemAppendOnlyTreeSnapshot;
-  publicDataTree: ViemAppendOnlyTreeSnapshot;
-};
-
-export type ViemAppendOnlyTreeSnapshot = {
-  root: `0x${string}`;
-  nextAvailableLeafIndex: number;
-};
-
 export enum SlashingProposerType {
   None = 0,
   Tally = 1,
@@ -207,8 +193,8 @@ export class RollupContract {
   }
 
   @memoize
-  getSlotDuration() {
-    return this.rollup.read.getSlotDuration();
+  async getSlotDuration(): Promise<number> {
+    return Number(await this.rollup.read.getSlotDuration());
   }
 
   @memoize
@@ -227,8 +213,13 @@ export class RollupContract {
   }
 
   @memoize
-  getLagInEpochs() {
-    return this.rollup.read.getLagInEpochs();
+  getLagInEpochsForValidatorSet() {
+    return this.rollup.read.getLagInEpochsForValidatorSet();
+  }
+
+  @memoize
+  getLagInEpochsForRandao() {
+    return this.rollup.read.getLagInEpochsForRandao();
   }
 
   @memoize
@@ -294,7 +285,7 @@ export class RollupContract {
     return {
       l1StartBlock,
       l1GenesisTime,
-      slotDuration: Number(slotDuration),
+      slotDuration,
       epochDuration: Number(epochDuration),
       proofSubmissionEpochs: Number(proofSubmissionEpochs),
     };
@@ -331,20 +322,20 @@ export class RollupContract {
     return await slasher.getProposer();
   }
 
-  getBlockReward() {
-    return this.rollup.read.getBlockReward();
+  getCheckpointReward() {
+    return this.rollup.read.getCheckpointReward();
   }
 
-  getBlockNumber() {
-    return this.rollup.read.getPendingBlockNumber();
+  async getCheckpointNumber(): Promise<CheckpointNumber> {
+    return CheckpointNumber.fromBigInt(await this.rollup.read.getPendingCheckpointNumber());
   }
 
-  getProvenBlockNumber() {
-    return this.rollup.read.getProvenBlockNumber();
+  async getProvenCheckpointNumber(): Promise<CheckpointNumber> {
+    return CheckpointNumber.fromBigInt(await this.rollup.read.getProvenCheckpointNumber());
   }
 
-  getSlotNumber() {
-    return this.rollup.read.getCurrentSlot();
+  async getSlotNumber(): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
   }
 
   getL1FeesAt(timestamp: bigint) {
@@ -381,8 +372,8 @@ export class RollupContract {
     return this.rollup.read.getCurrentSampleSeed();
   }
 
-  getCurrentEpoch() {
-    return this.rollup.read.getCurrentEpoch();
+  async getCurrentEpoch(): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
   }
 
   async getCurrentEpochCommittee(): Promise<readonly `0x${string}`[] | undefined> {
@@ -425,16 +416,20 @@ export class RollupContract {
     return result;
   }
 
-  getBlock(blockNumber: bigint | number) {
-    return this.rollup.read.getBlock([BigInt(blockNumber)]);
+  getCheckpoint(checkpointNumber: CheckpointNumber) {
+    return this.rollup.read.getCheckpoint([BigInt(checkpointNumber)]);
   }
 
-  getTips() {
-    return this.rollup.read.getTips();
+  async getTips(): Promise<{ pending: CheckpointNumber; proven: CheckpointNumber }> {
+    const { pending, proven } = await this.rollup.read.getTips();
+    return {
+      pending: CheckpointNumber.fromBigInt(pending),
+      proven: CheckpointNumber.fromBigInt(proven),
+    };
   }
 
-  getTimestampForSlot(slot: bigint) {
-    return this.rollup.read.getTimestampForSlot([slot]);
+  getTimestampForSlot(slot: SlotNumber) {
+    return this.rollup.read.getTimestampForSlot([BigInt(slot)]);
   }
 
   getEntryQueueLength() {
@@ -445,16 +440,16 @@ export class RollupContract {
     return this.rollup.read.getAvailableValidatorFlushes();
   }
 
-  getNextFlushableEpoch() {
-    return this.rollup.read.getNextFlushableEpoch();
+  async getNextFlushableEpoch(): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getNextFlushableEpoch());
   }
 
-  getCurrentEpochNumber(): Promise<bigint> {
-    return this.rollup.read.getCurrentEpoch();
+  async getCurrentEpochNumber(): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getCurrentEpoch());
   }
 
-  getEpochNumberForBlock(blockNumber: bigint) {
-    return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
+  async getEpochNumberForCheckpoint(checkpointNumber: CheckpointNumber): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getEpochForCheckpoint([BigInt(checkpointNumber)]));
   }
 
   async getRollupAddresses(): Promise<L1RollupContractAddresses> {
@@ -494,8 +489,8 @@ export class RollupContract {
     return EthAddress.fromString(await this.rollup.read.getFeeAssetPortal());
   }
 
-  public async getEpochNumberForSlotNumber(slotNumber: bigint): Promise<bigint> {
-    return await this.rollup.read.getEpochAtSlot([slotNumber]);
+  public async getEpochNumberForSlotNumber(slotNumber: SlotNumber): Promise<EpochNumber> {
+    return EpochNumber.fromBigInt(await this.rollup.read.getEpochAtSlot([BigInt(slotNumber)]));
   }
 
   getEpochProofPublicInputs(
@@ -538,53 +533,57 @@ export class RollupContract {
    * @dev     Throws if unable to propose
    *
    * @param archive - The archive that we expect to be current state
-   * @return [slot, blockNumber] - If you can propose, the L2 slot number and L2 block number of the next Ethereum block,
+   * @return [slot, checkpointNumber, timeOfNextL1Slot] - If you can propose, the L2 slot number, checkpoint number and
+   * timestamp of the next L1 block
    * @throws otherwise
    */
   public async canProposeAtNextEthBlock(
     archive: Buffer,
     account: `0x${string}` | Account,
-    slotDuration: bigint | number,
-    opts: { forcePendingBlockNumber?: number } = {},
-  ): Promise<{ slot: bigint; blockNumber: bigint; timeOfNextL1Slot: bigint }> {
-    if (typeof slotDuration === 'number') {
-      slotDuration = BigInt(slotDuration);
-    }
+    slotDuration: number,
+    opts: { forcePendingCheckpointNumber?: CheckpointNumber } = {},
+  ): Promise<{ slot: SlotNumber; checkpointNumber: CheckpointNumber; timeOfNextL1Slot: bigint }> {
     const latestBlock = await this.client.getBlock();
-    const timeOfNextL1Slot = latestBlock.timestamp + slotDuration;
+    const timeOfNextL1Slot = latestBlock.timestamp + BigInt(slotDuration);
     const who = typeof account === 'string' ? account : account.address;
 
     try {
       const {
-        result: [slot, blockNumber],
+        result: [slot, checkpointNumber],
       } = await this.client.simulateContract({
         address: this.address,
         abi: RollupAbi,
         functionName: 'canProposeAtTime',
         args: [timeOfNextL1Slot, `0x${archive.toString('hex')}`, who],
         account,
-        stateOverride: await this.makePendingBlockNumberOverride(opts.forcePendingBlockNumber),
+        stateOverride: await this.makePendingCheckpointNumberOverride(opts.forcePendingCheckpointNumber),
       });
 
-      return { slot, blockNumber, timeOfNextL1Slot };
+      return {
+        slot: SlotNumber.fromBigInt(slot),
+        checkpointNumber: CheckpointNumber.fromBigInt(checkpointNumber),
+        timeOfNextL1Slot,
+      };
     } catch (err: unknown) {
       throw formatViemError(err);
     }
   }
 
   /**
-   * Returns a state override that sets the pending block number to the specified value. Useful for simulations.
-   * Requires querying the current state of the contract to get the current proven block number, as they are both
+   * Returns a state override that sets the pending checkpoint number to the specified value. Useful for simulations.
+   * Requires querying the current state of the contract to get the current proven checkpoint number, as they are both
    * stored in the same slot. If the argument is undefined, it returns an empty override.
    */
-  public async makePendingBlockNumberOverride(forcePendingBlockNumber: number | undefined): Promise<StateOverride> {
-    if (forcePendingBlockNumber === undefined) {
+  public async makePendingCheckpointNumberOverride(
+    forcePendingCheckpointNumber: CheckpointNumber | undefined,
+  ): Promise<StateOverride> {
+    if (forcePendingCheckpointNumber === undefined) {
       return [];
     }
     const slot = RollupContract.stfStorageSlot;
     const currentValue = await this.client.getStorageAt({ address: this.address, slot });
-    const currentProvenBlockNumber = currentValue ? hexToBigInt(currentValue) & ((1n << 128n) - 1n) : 0n;
-    const newValue = (BigInt(forcePendingBlockNumber) << 128n) | currentProvenBlockNumber;
+    const currentProvenCheckpointNumber = currentValue ? hexToBigInt(currentValue) & ((1n << 128n) - 1n) : 0n;
+    const newValue = (BigInt(forcePendingCheckpointNumber) << 128n) | currentProvenCheckpointNumber;
     return [
       {
         address: this.address,
@@ -595,7 +594,7 @@ export class RollupContract {
 
   /** Creates a request to Rollup#invalidateBadAttestation to be simulated or sent */
   public buildInvalidateBadAttestationRequest(
-    blockNumber: number,
+    checkpointNumber: CheckpointNumber,
     attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
     invalidIndex: number,
@@ -606,7 +605,7 @@ export class RollupContract {
         abi: RollupAbi,
         functionName: 'invalidateBadAttestation',
         args: [
-          BigInt(blockNumber),
+          BigInt(checkpointNumber),
           attestationsAndSigners,
           committee.map(addr => addr.toString()),
           BigInt(invalidIndex),
@@ -617,7 +616,7 @@ export class RollupContract {
 
   /** Creates a request to Rollup#invalidateInsufficientAttestations to be simulated or sent */
   public buildInvalidateInsufficientAttestationsRequest(
-    blockNumber: number,
+    checkpointNumber: CheckpointNumber,
     attestationsAndSigners: ViemCommitteeAttestations,
     committee: EthAddress[],
   ): L1TxRequest {
@@ -626,30 +625,30 @@ export class RollupContract {
       data: encodeFunctionData({
         abi: RollupAbi,
         functionName: 'invalidateInsufficientAttestations',
-        args: [BigInt(blockNumber), attestationsAndSigners, committee.map(addr => addr.toString())],
+        args: [BigInt(checkpointNumber), attestationsAndSigners, committee.map(addr => addr.toString())],
       }),
     };
   }
 
   /** Calls getHasSubmitted directly. Returns whether the given prover has submitted a proof with the given length for the given epoch. */
-  public getHasSubmittedProof(epochNumber: number, numberOfBlocksInEpoch: number, prover: Hex | EthAddress) {
+  public getHasSubmittedProof(epochNumber: EpochNumber, numberOfCheckpointsInEpoch: number, prover: Hex | EthAddress) {
     if (prover instanceof EthAddress) {
       prover = prover.toString();
     }
-    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfBlocksInEpoch), prover]);
+    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfCheckpointsInEpoch), prover]);
   }
 
   getManaBaseFeeAt(timestamp: bigint, inFeeAsset: boolean) {
     return this.rollup.read.getManaBaseFeeAt([timestamp, inFeeAsset]);
   }
 
-  getSlotAt(timestamp: bigint) {
-    return this.rollup.read.getSlotAt([timestamp]);
+  async getSlotAt(timestamp: bigint): Promise<SlotNumber> {
+    return SlotNumber.fromBigInt(await this.rollup.read.getSlotAt([timestamp]));
   }
 
-  async status(blockNumber: bigint, options?: { blockNumber?: bigint }) {
+  async status(checkpointNumber: CheckpointNumber, options?: { blockNumber?: bigint }) {
     await checkBlockTag(options?.blockNumber, this.client);
-    return this.rollup.read.status([blockNumber], options);
+    return this.rollup.read.status([BigInt(checkpointNumber)], options);
   }
 
   async canPruneAtTime(timestamp: bigint, options?: { blockNumber?: bigint }) {
@@ -661,8 +660,8 @@ export class RollupContract {
     return this.rollup.read.archive();
   }
 
-  archiveAt(blockNumber: bigint) {
-    return this.rollup.read.archiveAt([blockNumber]);
+  archiveAt(checkpointNumber: CheckpointNumber) {
+    return this.rollup.read.archiveAt([BigInt(checkpointNumber)]);
   }
 
   getSequencerRewards(address: Hex | EthAddress) {
@@ -704,8 +703,8 @@ export class RollupContract {
     return this.rollup.read.getStatus([address]);
   }
 
-  getBlobCommitmentsHash(blockNumber: bigint) {
-    return this.rollup.read.getBlobCommitmentsHash([blockNumber]);
+  getBlobCommitmentsHash(checkpointNumber: CheckpointNumber) {
+    return this.rollup.read.getBlobCommitmentsHash([BigInt(checkpointNumber)]);
   }
 
   getCurrentBlobCommitmentsHash() {
@@ -760,15 +759,17 @@ export class RollupContract {
     );
   }
 
-  public listenToBlockInvalidated(callback: (args: { blockNumber: bigint }) => unknown): WatchContractEventReturnType {
-    return this.rollup.watchEvent.BlockInvalidated(
+  public listenToCheckpointInvalidated(
+    callback: (args: { checkpointNumber: CheckpointNumber }) => unknown,
+  ): WatchContractEventReturnType {
+    return this.rollup.watchEvent.CheckpointInvalidated(
       {},
       {
         onLogs: logs => {
           for (const log of logs) {
             const args = log.args;
-            if (args.blockNumber !== undefined) {
-              callback({ blockNumber: args.blockNumber });
+            if (args.checkpointNumber !== undefined) {
+              callback({ checkpointNumber: CheckpointNumber.fromBigInt(args.checkpointNumber) });
             }
           }
         },

package/src/contracts/tally_slashing_proposer.ts

@@ -1,4 +1,5 @@
 import { type L1TxRequest, type ViemClient, tryExtractEvent } from '@aztec/ethereum';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
@@ -97,8 +98,8 @@ export class TallySlashingProposerContract {
    * @param slot - The slot number to check at
    * @returns Whether the round is ready to execute
    */
-  public async isRoundReadyToExecute(round: bigint, slot: bigint): Promise<boolean> {
-    return await this.contract.read.isRoundReadyToExecute([round, slot]);
+  public async isRoundReadyToExecute(round: bigint, slot: SlotNumber): Promise<boolean> {
+    return await this.contract.read.isRoundReadyToExecute([round, BigInt(slot)]);
   }
 
   /** Returns the slash actions and payload address for a given round (zero if no slash actions) */
@@ -149,7 +150,7 @@ export class TallySlashingProposerContract {
    */
   public async buildVoteRequestFromSigner(
     votes: Hex,
-    slot: bigint,
+    slot: SlotNumber,
     signer: (msg: TypedDataDefinition) => Promise<Hex>,
   ): Promise<L1TxRequest> {
     const typedData = this.buildVoteTypedData(votes, slot);
@@ -166,7 +167,7 @@ export class TallySlashingProposerContract {
   }
 
   /** Returns the typed data definition to EIP712-sign for voting */
-  public buildVoteTypedData(votes: Hex, slot: bigint): TypedDataDefinition {
+  public buildVoteTypedData(votes: Hex, slot: SlotNumber): TypedDataDefinition {
     const domain = {
       name: 'TallySlashingProposer',
       version: '1',
@@ -187,12 +188,12 @@ export class TallySlashingProposerContract {
       ],
     };
 
-    return { domain, types, primaryType: 'Vote', message: { votes, slot } };
+    return { domain, types, primaryType: 'Vote', message: { votes, slot: BigInt(slot) } };
   }
 
   /** Gets the digest to sign for voting directly from the contract */
-  public async getVoteDataDigest(votes: Hex, slot: bigint): Promise<Buffer32> {
-    return Buffer32.fromString(await this.contract.read.getVoteSignatureDigest([votes, slot]));
+  public async getVoteDataDigest(votes: Hex, slot: SlotNumber): Promise<Buffer32> {
+    return Buffer32.fromString(await this.contract.read.getVoteSignatureDigest([votes, BigInt(slot)]));
   }
 
   /**

package/src/deploy_l1_contracts.ts

@@ -1,4 +1,5 @@
 import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { SecretValue, getActiveNetworkName } from '@aztec/foundation/config';
 import { keccak256String } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -277,14 +278,22 @@ export const deploySharedContracts = async (
     logger.verbose(`Deployed Fee Asset at ${feeAssetAddress}`);
 
     // Mint a tiny bit of tokens to satisfy coin-issuer constraints
-    const { txHash } = await deployer.sendTransaction({
-      to: feeAssetAddress.toString(),
-      data: encodeFunctionData({
-        abi: FeeAssetArtifact.contractAbi,
-        functionName: 'mint',
-        args: [l1Client.account.address, 1n * 10n ** 18n],
-      }),
-    });
+    const { txHash } = await deployer.sendTransaction(
+      {
+        to: feeAssetAddress.toString(),
+        data: encodeFunctionData({
+          abi: FeeAssetArtifact.contractAbi,
+          functionName: 'mint',
+          args: [l1Client.account.address, 1n * 10n ** 18n],
+        }),
+      },
+      {
+        // contract may not have been deployed yet (CREATE2 returns address before mining),
+        // which causes gas estimation to fail. Hardcode to 100k which is plenty for ERC20 mint.
+        gasLimit: 100_000n,
+      },
+    );
+    await l1Client.waitForTransactionReceipt({ hash: txHash });
     logger.verbose(`Minted tiny bit of tokens to satisfy coin-issuer constraints in ${txHash}`);
 
     const deployedStaking = await deployer.deploy(StakingAssetArtifact, ['Staking', 'STK', l1Client.account.address]);
@@ -362,12 +371,19 @@ export const deploySharedContracts = async (
     txHashes.push(txHash);
   }
 
+  logger.verbose(`Waiting for deployments to complete`);
+  await deployer.waitForDeployments();
+
   const coinIssuerAddress = (
-    await deployer.deploy(CoinIssuerArtifact, [
-      feeAssetAddress.toString(),
-      2n * 10n ** 17n, // hard cap of 20% per year
-      l1Client.account.address,
-    ])
+    await deployer.deploy(
+      CoinIssuerArtifact,
+      [
+        feeAssetAddress.toString(),
+        2n * 10n ** 17n, // hard cap of 20% per year
+        l1Client.account.address,
+      ],
+      { gasLimit: 1_000_000n, noSimulation: true },
+    )
   ).address;
   logger.verbose(`Deployed CoinIssuer at ${coinIssuerAddress}`);
 
@@ -386,17 +402,16 @@ export const deploySharedContracts = async (
     /*                          CHEAT CODES START HERE                            */
     /* -------------------------------------------------------------------------- */
 
-    feeAssetHandlerAddress = (
-      await deployer.deploy(FeeAssetHandlerArtifact, [
-        l1Client.account.address,
-        feeAssetAddress.toString(),
-        BigInt(1000n * 10n ** 18n),
-      ])
-    ).address;
+    const deployedFeeAssetHandler = await deployer.deploy(FeeAssetHandlerArtifact, [
+      l1Client.account.address,
+      feeAssetAddress.toString(),
+      BigInt(1000n * 10n ** 18n),
+    ]);
+    feeAssetHandlerAddress = deployedFeeAssetHandler.address;
     logger.verbose(`Deployed FeeAssetHandler at ${feeAssetHandlerAddress}`);
 
-    // Only if we are "fresh" will we be adding as a minter, otherwise above will simply get same address
-    if (needToSetGovernance) {
+    // Only add as minter if this is a new deployment (not reusing existing handler from failed previous run)
+    if (!deployedFeeAssetHandler.existed) {
       const { txHash } = await deployer.sendTransaction({
         to: feeAssetAddress.toString(),
         data: encodeFunctionData({
@@ -473,9 +488,9 @@ export const deploySharedContracts = async (
   const rewardDistributorAddress = await registry.getRewardDistributor();
 
   if (!args.existingTokenAddress) {
-    const blockReward = getRewardConfig(networkName).blockReward;
+    const checkpointReward = getRewardConfig(networkName).checkpointReward;
 
-    const funding = blockReward * 200000n;
+    const funding = checkpointReward * 200000n;
     const { txHash: fundRewardDistributorTxHash } = await deployer.sendTransaction({
       to: feeAssetAddress.toString(),
       data: encodeFunctionData({
@@ -849,7 +864,8 @@ export const deployRollup = async (
     aztecSlotDuration: BigInt(args.aztecSlotDuration),
     aztecEpochDuration: BigInt(args.aztecEpochDuration),
     targetCommitteeSize: BigInt(args.aztecTargetCommitteeSize),
-    lagInEpochs: BigInt(args.lagInEpochs),
+    lagInEpochsForValidatorSet: BigInt(args.lagInEpochsForValidatorSet),
+    lagInEpochsForRandao: BigInt(args.lagInEpochsForRandao),
     aztecProofSubmissionEpochs: BigInt(args.aztecProofSubmissionEpochs),
     slashingQuorum: BigInt(args.slashingQuorum ?? (args.slashingRoundSizeInEpochs * args.aztecEpochDuration) / 2 + 1),
     slashingRoundSize: BigInt(args.slashingRoundSizeInEpochs * args.aztecEpochDuration),
@@ -1504,13 +1520,13 @@ export const deployL1Contracts = async (
       // Need to get the time
       const currentSlot = await rollup.getSlotNumber();
 
-      if (BigInt(currentSlot) === 0n) {
-        const ts = Number(await rollup.getTimestampForSlot(1n));
+      if (currentSlot === 0) {
+        const ts = Number(await rollup.getTimestampForSlot(SlotNumber(1)));
         await rpcCall('evm_setNextBlockTimestamp', [ts]);
         await rpcCall('hardhat_mine', [1]);
         const currentSlot = await rollup.getSlotNumber();
 
-        if (BigInt(currentSlot) !== 1n) {
+        if (currentSlot !== 1) {
           throw new Error(`Error jumping time: current slot is ${currentSlot}`);
         }
         logger.info(`Jumped to slot 1`);
@@ -1561,7 +1577,7 @@ export class L1Deployer {
   async deploy<const TAbi extends Abi>(
     params: ContractArtifacts<TAbi>,
     args?: ContractConstructorArgs<TAbi>,
-    opts: { gasLimit?: bigint } = {},
+    opts: { gasLimit?: bigint; noSimulation?: boolean } = {},
   ): Promise<{ address: EthAddress; existed: boolean }> {
     this.logger.debug(`Deploying ${params.name} contract`, { args });
     try {
@@ -1577,6 +1593,7 @@ export class L1Deployer {
           l1TxUtils: this.l1TxUtils,
           acceleratedTestDeployments: this.acceleratedTestDeployments,
           gasLimit: opts.gasLimit,
+          noSimulation: opts.noSimulation,
         },
       );
       if (txHash) {
@@ -1666,6 +1683,7 @@ export async function deployL1Contract(
     l1TxUtils?: L1TxUtils;
     gasLimit?: bigint;
     acceleratedTestDeployments?: boolean;
+    noSimulation?: boolean;
   } = {},
 ): Promise<{
   address: EthAddress;
@@ -1677,7 +1695,7 @@ export async function deployL1Contract(
   let resultingAddress: Hex | null | undefined = undefined;
   const deployedLibraries: VerificationLibraryEntry[] = [];
 
-  const { salt: saltFromOpts, libraries, logger, gasLimit, acceleratedTestDeployments } = opts;
+  const { salt: saltFromOpts, libraries, logger, gasLimit, acceleratedTestDeployments, noSimulation } = opts;
   let { l1TxUtils } = opts;
 
   if (!l1TxUtils) {
@@ -1786,11 +1804,13 @@ export async function deployL1Contract(
     resultingAddress = address;
     const existing = await extendedClient.getCode({ address: resultingAddress });
     if (existing === undefined || existing === '0x') {
-      try {
-        await l1TxUtils.simulate({ to: DEPLOYER_ADDRESS, data: concatHex([salt, calldata]), gas: gasLimit });
-      } catch (err) {
-        logger?.error(`Failed to simulate deployment tx using universal deployer`, err);
-        await l1TxUtils.simulate({ to: null, data: encodeDeployData({ abi, bytecode, args }), gas: gasLimit });
+      if (!noSimulation) {
+        try {
+          await l1TxUtils.simulate({ to: DEPLOYER_ADDRESS, data: concatHex([salt, calldata]), gas: gasLimit });
+        } catch (err) {
+          logger?.error(`Failed to simulate deployment tx using universal deployer`, err);
+          await l1TxUtils.simulate({ to: null, data: encodeDeployData({ abi, bytecode, args }), gas: gasLimit });
+        }
       }
       const res = await l1TxUtils.sendTransaction(
         { to: DEPLOYER_ADDRESS, data: concatHex([salt, calldata]) },

package/src/l1_tx_utils/config.ts

@@ -1,7 +1,7 @@
 import {
   type ConfigMappingsType,
-  bigintConfigHelper,
   booleanConfigHelper,
+  floatConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
@@ -15,11 +15,11 @@ export interface L1TxUtilsConfig {
   /**
    * Maximum gas price in gwei
    */
-  maxGwei?: bigint;
+  maxGwei?: number;
   /**
    * Maximum blob fee per gas in gwei
    */
-  maxBlobGwei?: bigint;
+  maxBlobGwei?: number;
   /**
    * Priority fee bump percentage
    */
@@ -71,12 +71,14 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   maxGwei: {
     description: 'Maximum gas price in gwei to be used for transactions.',
     env: 'L1_GAS_PRICE_MAX',
-    ...bigintConfigHelper(2000n),
+    fallback: ['L1_FEE_PER_GAS_GWEI_MAX'],
+    ...floatConfigHelper(2000),
   },
   maxBlobGwei: {
     description: 'Maximum blob fee per gas in gwei',
     env: 'L1_BLOB_FEE_PER_GAS_MAX',
-    ...bigintConfigHelper(3000n),
+    fallback: ['L1_BLOB_FEE_PER_GAS_GWEI_MAX'],
+    ...floatConfigHelper(3000),
   },
   priorityFeeBumpPercentage: {
     description: 'How much to increase priority fee by each attempt (percentage)',
@@ -91,7 +93,8 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   fixedPriorityFeePerGas: {
     description: 'Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage',
     env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
-    ...numberConfigHelper(0),
+    fallback: ['L1_FIXED_PRIORITY_FEE_PER_GAS_GWEI'],
+    ...floatConfigHelper(0),
   },
   maxSpeedUpAttempts: {
     description: 'Maximum number of speed-up attempts',

package/src/l1_tx_utils/readonly_l1_tx_utils.ts

@@ -248,8 +248,7 @@ export class ReadOnlyL1TxUtils {
       this.logger?.debug('Using fixed priority fee per L1 gas', {
         fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas,
       });
-      // try to maintain precision up to 1000000 wei
-      priorityFee = BigInt(gasConfig.fixedPriorityFeePerGas * 1_000_000) * (WEI_CONST / 1_000_000n);
+      priorityFee = BigInt(Math.trunc(gasConfig.fixedPriorityFeePerGas * Number(WEI_CONST)));
     } else {
       // Get competitive priority fee (includes network estimate + analysis)
       priorityFee = this.getCompetitivePriorityFee(networkEstimateResult, pendingBlockResult, feeHistoryResult);
@@ -321,8 +320,8 @@ export class ReadOnlyL1TxUtils {
     }
 
     // maxGwei and maxBlobGwei are hard limits
-    const effectiveMaxGwei = gasConfig.maxGwei! * WEI_CONST;
-    const effectiveMaxBlobGwei = gasConfig.maxBlobGwei! * WEI_CONST;
+    const effectiveMaxGwei = BigInt(Math.trunc(gasConfig.maxGwei! * Number(WEI_CONST)));
+    const effectiveMaxBlobGwei = BigInt(Math.trunc(gasConfig.maxBlobGwei! * Number(WEI_CONST)));
 
     // Ensure we don't exceed maxGwei
     if (effectiveMaxGwei > 0n) {