@aztec/ethereum 0.0.1-commit.0c875d939 → 0.0.1-commit.10bd49492

package/src/contracts/fee_asset_price_oracle.ts

@@ -34,12 +34,25 @@ export class FeeAssetPriceOracle {
 
   @memoize
   async getUniswapOracle(): Promise<UniswapPriceOracle | undefined> {
-    if ((await this.client.getCode({ address: STATE_VIEW_ADDRESS.toString() })) === '0x') {
+    const code = await this.client.getCode({ address: STATE_VIEW_ADDRESS.toString() });
+    if (code === undefined || code === '0x') {
       this.log.warn('Uniswap V4 StateView contract not found, skipping fee asset price oracle');
       return undefined;
     }
     this.log.info('Uniswap V4 StateView contract found, initializing fee asset price oracle');
-    return new UniswapPriceOracle(this.client, this.log);
+    const oracle = new UniswapPriceOracle(this.client, this.log);
+
+    try {
+      if (!(await oracle.isPoolInitialized())) {
+        this.log.warn('Uniswap V4 pool not initialized, skipping fee asset price oracle');
+        return undefined;
+      }
+    } catch (err) {
+      this.log.warn(`Failed to check if Uniswap V4 pool is initialized: ${err}`);
+      return undefined;
+    }
+
+    return oracle;
   }
 
   /**
@@ -210,6 +223,11 @@ class UniswapPriceOracle {
     return keccak256(encoded);
   }
 
+  async isPoolInitialized(): Promise<boolean> {
+    const [sqrtPriceX96] = await this.stateView.read.getSlot0([this.poolId], undefined);
+    return sqrtPriceX96 !== 0n;
+  }
+
   /**
    * Gets the price as ETH per FeeAsset, scaled by 1e12.
    * This is the format expected by the rollup contract.

package/src/contracts/governance.ts

@@ -14,7 +14,7 @@ import {
 } from 'viem';
 
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
-import { createL1TxUtilsFromViemWallet } from '../l1_tx_utils/index.js';
+import { createL1TxUtils } from '../l1_tx_utils/index.js';
 import { type ExtendedViemWalletClient, type ViemClient, isExtendedClient } from '../types.js';
 
 export type L1GovernanceContractAddresses = Pick<
@@ -194,7 +194,7 @@ export class GovernanceContract extends ReadOnlyGovernanceContract {
     retries: number;
     logger: Logger;
   }) {
-    const l1TxUtils = createL1TxUtilsFromViemWallet(this.client, { logger });
+    const l1TxUtils = createL1TxUtils(this.client, { logger });
     const retryDelaySeconds = 12;
 
     voteAmount = voteAmount ?? (await this.getPowerForProposal(proposalId));
@@ -252,7 +252,7 @@ export class GovernanceContract extends ReadOnlyGovernanceContract {
     retries: number;
     logger: Logger;
   }) {
-    const l1TxUtils = createL1TxUtilsFromViemWallet(this.client, { logger });
+    const l1TxUtils = createL1TxUtils(this.client, { logger });
     const retryDelaySeconds = 12;
     let success = false;
     for (let i = 0; i < retries; i++) {

package/src/contracts/governance_proposer.ts

@@ -110,6 +110,12 @@ export class GovernanceProposerContract implements IEmpireBase {
     };
   }
 
+  /** Checks if a payload was ever submitted to governance via submitRoundWinner. */
+  public async hasPayloadBeenProposed(payload: Hex, fromBlock: bigint): Promise<boolean> {
+    const events = await this.proposer.getEvents.PayloadSubmitted({ payload }, { fromBlock, strict: true });
+    return events.length > 0;
+  }
+
   public async submitRoundWinner(
     round: bigint,
     l1TxUtils: L1TxUtils,

package/src/contracts/registry.ts

@@ -3,7 +3,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { RegistryAbi } from '@aztec/l1-artifacts/RegistryAbi';
 import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
 
-import { type GetContractReturnType, type Hex, getContract } from 'viem';
+import { type GetContractReturnType, type Hex, getAbiItem, getContract } from 'viem';
 
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
 import type { ViemClient } from '../types.js';
@@ -128,4 +128,34 @@ export class RegistryContract {
   public async getRewardDistributor(): Promise<EthAddress> {
     return EthAddress.fromString(await this.registry.read.getRewardDistributor());
   }
+
+  /** Returns the L1 timestamp at which the given rollup was registered via addRollup(). */
+  public async getCanonicalRollupRegistrationTimestamp(
+    rollupAddress: EthAddress,
+    fromBlock?: bigint,
+  ): Promise<bigint | undefined> {
+    const event = getAbiItem({ abi: RegistryAbi, name: 'CanonicalRollupUpdated' });
+    const start = fromBlock ?? 0n;
+    const latestBlock = await this.client.getBlockNumber();
+    const chunkSize = 1_000n;
+
+    for (let from = start; from <= latestBlock; from += chunkSize) {
+      const to = from + chunkSize - 1n > latestBlock ? latestBlock : from + chunkSize - 1n;
+      const logs = await this.client.getLogs({
+        address: this.address.toString(),
+        fromBlock: from,
+        toBlock: to,
+        strict: true,
+        event,
+        args: { instance: rollupAddress.toString() },
+      });
+
+      if (logs.length > 0) {
+        const block = await this.client.getBlock({ blockNumber: logs[0].blockNumber });
+        return block.timestamp;
+      }
+    }
+
+    return undefined;
+  }
 }

package/src/contracts/rollup.ts

@@ -193,10 +193,10 @@ export type CheckpointProposedArgs = {
   checkpointNumber: CheckpointNumber;
   archive: Fr;
   versionedBlobHashes: Buffer[];
-  /** Hash of attestations. Undefined for older events (backwards compatibility). */
-  attestationsHash?: Buffer32;
-  /** Digest of the payload. Undefined for older events (backwards compatibility). */
-  payloadDigest?: Buffer32;
+  /** Hash of attestations emitted in the CheckpointProposed event. */
+  attestationsHash: Buffer32;
+  /** Digest of the payload emitted in the CheckpointProposed event. */
+  payloadDigest: Buffer32;
 };
 
 /** Log type for CheckpointProposed events. */
@@ -392,16 +392,25 @@ export class RollupContract {
     epochDuration: number;
     proofSubmissionEpochs: number;
     targetCommitteeSize: number;
+    rollupManaLimit: number;
   }> {
-    const [l1StartBlock, l1GenesisTime, slotDuration, epochDuration, proofSubmissionEpochs, targetCommitteeSize] =
-      await Promise.all([
-        this.getL1StartBlock(),
-        this.getL1GenesisTime(),
-        this.getSlotDuration(),
-        this.getEpochDuration(),
-        this.getProofSubmissionEpochs(),
-        this.getTargetCommitteeSize(),
-      ]);
+    const [
+      l1StartBlock,
+      l1GenesisTime,
+      slotDuration,
+      epochDuration,
+      proofSubmissionEpochs,
+      targetCommitteeSize,
+      rollupManaLimit,
+    ] = await Promise.all([
+      this.getL1StartBlock(),
+      this.getL1GenesisTime(),
+      this.getSlotDuration(),
+      this.getEpochDuration(),
+      this.getProofSubmissionEpochs(),
+      this.getTargetCommitteeSize(),
+      this.getManaLimit(),
+    ]);
     return {
       l1StartBlock,
       l1GenesisTime,
@@ -409,6 +418,7 @@ export class RollupContract {
       epochDuration: Number(epochDuration),
       proofSubmissionEpochs: Number(proofSubmissionEpochs),
       targetCommitteeSize,
+      rollupManaLimit: Number(rollupManaLimit),
     };
   }
 
@@ -503,8 +513,9 @@ export class RollupContract {
     return CheckpointNumber.fromBigInt(await this.rollup.read.getPendingCheckpointNumber());
   }
 
-  async getProvenCheckpointNumber(): Promise<CheckpointNumber> {
-    return CheckpointNumber.fromBigInt(await this.rollup.read.getProvenCheckpointNumber());
+  async getProvenCheckpointNumber(options?: { blockNumber?: bigint }): Promise<CheckpointNumber> {
+    await checkBlockTag(options?.blockNumber, this.client);
+    return CheckpointNumber.fromBigInt(await this.rollup.read.getProvenCheckpointNumber(options));
   }
 
   async getSlotNumber(): Promise<SlotNumber> {
@@ -1060,8 +1071,22 @@ export class RollupContract {
           checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber!),
           archive: Fr.fromString(log.args.archive!),
           versionedBlobHashes: log.args.versionedBlobHashes!.map(h => Buffer.from(h.slice(2), 'hex')),
-          attestationsHash: log.args.attestationsHash ? Buffer32.fromString(log.args.attestationsHash) : undefined,
-          payloadDigest: log.args.payloadDigest ? Buffer32.fromString(log.args.payloadDigest) : undefined,
+          attestationsHash: (() => {
+            if (!log.args.attestationsHash) {
+              throw new Error(
+                `CheckpointProposed event missing attestationsHash for checkpoint ${log.args.checkpointNumber}`,
+              );
+            }
+            return Buffer32.fromString(log.args.attestationsHash);
+          })(),
+          payloadDigest: (() => {
+            if (!log.args.payloadDigest) {
+              throw new Error(
+                `CheckpointProposed event missing payloadDigest for checkpoint ${log.args.checkpointNumber}`,
+              );
+            }
+            return Buffer32.fromString(log.args.payloadDigest);
+          })(),
         },
       }));
   }

package/src/deploy_aztec_l1_contracts.ts

@@ -23,7 +23,6 @@ import type { L1ContractsConfig } from './config.js';
 import { deployMulticall3 } from './contracts/multicall.js';
 import { RollupContract } from './contracts/rollup.js';
 import type { L1ContractAddresses } from './l1_contract_addresses.js';
-import type { L1TxUtilsConfig } from './l1_tx_utils/config.js';
 import type { ExtendedViemWalletClient } from './types.js';
 
 const logger = createLogger('ethereum:deploy_aztec_l1_contracts');
@@ -491,7 +490,25 @@ export type VerificationRecord = {
   libraries: VerificationLibraryEntry[];
 };
 
-export interface DeployAztecL1ContractsArgs extends Omit<L1ContractsConfig, keyof L1TxUtilsConfig> {
+export interface DeployAztecL1ContractsArgs
+  extends Omit<
+    L1ContractsConfig,
+    | 'gasLimitBufferPercentage'
+    | 'maxGwei'
+    | 'maxBlobGwei'
+    | 'priorityFeeBumpPercentage'
+    | 'priorityFeeRetryBumpPercentage'
+    | 'minimumPriorityFeePerGas'
+    | 'maxSpeedUpAttempts'
+    | 'checkIntervalMs'
+    | 'stallTimeMs'
+    | 'txTimeoutMs'
+    | 'cancelTxOnTimeout'
+    | 'txCancellationFinalTimeoutMs'
+    | 'txUnseenConsideredDroppedMs'
+    | 'enableDelayer'
+    | 'txDelayerMaxInclusionTimeIntoSlot'
+  > {
   /** The vk tree root. */
   vkTreeRoot: Fr;
   /** The hash of the protocol contracts. */

package/src/deploy_l1_contract.ts

@@ -24,7 +24,7 @@ import {
 } from './deploy_aztec_l1_contracts.js';
 import { RegisterNewRollupVersionPayloadArtifact } from './l1_artifacts.js';
 import { type L1TxUtilsConfig, getL1TxUtilsConfigEnvVars } from './l1_tx_utils/config.js';
-import { createL1TxUtilsFromViemWallet } from './l1_tx_utils/factory.js';
+import { createL1TxUtils } from './l1_tx_utils/factory.js';
 import type { L1TxUtils } from './l1_tx_utils/l1_tx_utils.js';
 import type { GasPrice, L1TxConfig, L1TxRequest } from './l1_tx_utils/types.js';
 import type { ExtendedViemWalletClient } from './types.js';
@@ -46,7 +46,7 @@ export class L1Deployer {
     private createVerificationJson: boolean = false,
   ) {
     this.salt = maybeSalt ? padHex(numberToHex(maybeSalt), { size: 32 }) : undefined;
-    this.l1TxUtils = createL1TxUtilsFromViemWallet(
+    this.l1TxUtils = createL1TxUtils(
       this.client,
       { logger: this.logger, dateProvider },
       { ...this.txUtilsConfig, debugMaxGasLimit: acceleratedTestDeployments },
@@ -179,7 +179,7 @@ export async function deployL1Contract(
 
   if (!l1TxUtils) {
     const config = getL1TxUtilsConfigEnvVars();
-    l1TxUtils = createL1TxUtilsFromViemWallet(
+    l1TxUtils = createL1TxUtils(
       extendedClient,
       { logger },
       { ...config, debugMaxGasLimit: acceleratedTestDeployments },

package/src/generated/l1-contracts-defaults.ts

@@ -4,7 +4,7 @@
 /** Default L1 contracts configuration values from network-defaults.yml */
 export const l1ContractsDefaultEnv = {
   ETHEREUM_SLOT_DURATION: 12,
-  AZTEC_SLOT_DURATION: 36,
+  AZTEC_SLOT_DURATION: 72,
   AZTEC_EPOCH_DURATION: 32,
   AZTEC_TARGET_COMMITTEE_SIZE: 48,
   AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,

package/src/l1_tx_utils/config.ts

@@ -5,6 +5,7 @@ import {
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
+  optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
 
 export interface L1TxUtilsConfig {
@@ -60,6 +61,12 @@ export interface L1TxUtilsConfig {
    * How long a tx nonce can be unseen in the mempool before considering it dropped
    */
   txUnseenConsideredDroppedMs?: number;
+  /** Enable tx delayer. When true, wraps the viem client to intercept and delay txs. Test-only. */
+  enableDelayer?: boolean;
+  /** Max seconds into an L1 slot for tx inclusion. Txs sent later are deferred to next slot. Only used when enableDelayer is true. */
+  txDelayerMaxInclusionTimeIntoSlot?: number;
+  /** How many seconds an L1 slot lasts. */
+  ethereumSlotDuration?: number;
 }
 
 export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
@@ -142,6 +149,19 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
     env: 'L1_TX_MONITOR_TX_UNSEEN_CONSIDERED_DROPPED_MS',
     ...numberConfigHelper(6 * 12 * 1000), // 6 L1 blocks
   },
+  enableDelayer: {
+    description: 'Enable tx delayer for testing.',
+    ...booleanConfigHelper(false),
+  },
+  txDelayerMaxInclusionTimeIntoSlot: {
+    description: 'Max seconds into L1 slot for tx inclusion when delayer is enabled.',
+    ...optionalNumberConfigHelper(),
+  },
+  ethereumSlotDuration: {
+    env: 'ETHEREUM_SLOT_DURATION',
+    description: 'How many seconds an L1 slot lasts.',
+    ...numberConfigHelper(12),
+  },
 };
 
 // We abuse the fact that all mappings above have a non null default value and force-type this to Required

package/src/l1_tx_utils/factory.ts

@@ -1,64 +1,64 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 
-import type { TransactionSerializable } from 'viem';
-
 import type { EthSigner } from '../eth-signer/eth-signer.js';
 import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
 import type { L1TxUtilsConfig } from './config.js';
 import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
 import { L1TxUtils } from './l1_tx_utils.js';
 import { createViemSigner } from './signer.js';
+import { Delayer } from './tx_delayer.js';
 import type { SigningCallback } from './types.js';
 
-export function createL1TxUtilsFromViemWallet(
-  client: ExtendedViemWalletClient,
-  deps?: {
-    logger?: Logger;
-    dateProvider?: DateProvider;
-    store?: IL1TxStore;
-    metrics?: IL1TxMetrics;
-  },
-  config?: Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean },
-): L1TxUtils {
-  return new L1TxUtils(
+/** Source of signing capability: either a wallet client or a separate client + signer. */
+export type L1SignerSource = ExtendedViemWalletClient | { client: ViemClient; signer: EthSigner };
+
+export function resolveSignerSource(source: L1SignerSource): {
+  client: ViemClient;
+  address: EthAddress;
+  signingCallback: SigningCallback;
+} {
+  if ('account' in source && source.account) {
+    return {
+      client: source as ExtendedViemWalletClient,
+      address: EthAddress.fromString((source as ExtendedViemWalletClient).account.address),
+      signingCallback: createViemSigner(source as ExtendedViemWalletClient),
+    };
+  }
+  const { client, signer } = source as { client: ViemClient; signer: EthSigner };
+  return {
     client,
-    EthAddress.fromString(client.account.address),
-    createViemSigner(client),
-    deps?.logger,
-    deps?.dateProvider,
-    config,
-    config?.debugMaxGasLimit ?? false,
-    deps?.store,
-    deps?.metrics,
-  );
+    address: signer.address,
+    signingCallback: async (tx, _addr) => (await signer.signTransaction(tx)).toViemTransactionSignature(),
+  };
 }
 
-export function createL1TxUtilsFromEthSigner(
-  client: ViemClient,
-  signer: EthSigner,
+export function createL1TxUtils(
+  source: L1SignerSource,
   deps?: {
     logger?: Logger;
     dateProvider?: DateProvider;
     store?: IL1TxStore;
     metrics?: IL1TxMetrics;
+    kzg?: BlobKzgInstance;
+    delayer?: Delayer;
   },
   config?: Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean },
 ): L1TxUtils {
-  const callback: SigningCallback = async (transaction: TransactionSerializable, _signingAddress) => {
-    return (await signer.signTransaction(transaction)).toViemTransactionSignature();
-  };
-
+  const { client, address, signingCallback } = resolveSignerSource(source);
   return new L1TxUtils(
     client,
-    signer.address,
-    callback,
+    address,
+    signingCallback,
     deps?.logger,
     deps?.dateProvider,
     config,
     config?.debugMaxGasLimit ?? false,
     deps?.store,
     deps?.metrics,
+    deps?.kzg,
+    deps?.delayer,
   );
 }

package/src/l1_tx_utils/forwarder_l1_tx_utils.ts

@@ -1,25 +1,27 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
 
 import { type Hex, encodeFunctionData } from 'viem';
 
-import type { EthSigner } from '../eth-signer/eth-signer.js';
 import { FORWARDER_ABI } from '../forwarder_proxy.js';
-import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
+import type { ViemClient } from '../types.js';
 import type { L1TxUtilsConfig } from './config.js';
+import type { L1SignerSource } from './factory.js';
+import { resolveSignerSource } from './factory.js';
 import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
-import { L1TxUtilsWithBlobs } from './l1_tx_utils_with_blobs.js';
-import { createViemSigner } from './signer.js';
+import { L1TxUtils } from './l1_tx_utils.js';
+import { Delayer } from './tx_delayer.js';
 import type { L1BlobInputs, L1TxConfig, L1TxRequest, SigningCallback } from './types.js';
 
 /**
- * Extends L1TxUtilsWithBlobs to wrap all transactions through a forwarder contract.
+ * Extends L1TxUtils to wrap all transactions through a forwarder contract.
  * This is mainly used for testing the archiver's ability to decode transactions that go through proxies.
  */
-export class ForwarderL1TxUtils extends L1TxUtilsWithBlobs {
+export class ForwarderL1TxUtils extends L1TxUtils {
   constructor(
-    client: ViemClient | ExtendedViemWalletClient,
+    client: ViemClient,
     senderAddress: EthAddress,
     signingCallback: SigningCallback,
     logger: Logger | undefined,
@@ -28,9 +30,23 @@ export class ForwarderL1TxUtils extends L1TxUtilsWithBlobs {
     debugMaxGasLimit: boolean,
     store: IL1TxStore | undefined,
     metrics: IL1TxMetrics | undefined,
+    kzg: BlobKzgInstance | undefined,
+    delayer: Delayer | undefined,
     private readonly forwarderAddress: EthAddress,
   ) {
-    super(client, senderAddress, signingCallback, logger, dateProvider, config, debugMaxGasLimit, store, metrics);
+    super(
+      client,
+      senderAddress,
+      signingCallback,
+      logger,
+      dateProvider,
+      config,
+      debugMaxGasLimit,
+      store,
+      metrics,
+      kzg,
+      delayer,
+    );
   }
 
   /**
@@ -61,59 +77,32 @@ export class ForwarderL1TxUtils extends L1TxUtilsWithBlobs {
   }
 }
 
-export function createForwarderL1TxUtilsFromViemWallet(
-  client: ExtendedViemWalletClient,
+export function createForwarderL1TxUtils(
+  source: L1SignerSource,
   forwarderAddress: EthAddress,
-  deps: {
+  deps?: {
     logger?: Logger;
     dateProvider?: DateProvider;
     store?: IL1TxStore;
     metrics?: IL1TxMetrics;
-  } = {},
-  config: Partial<L1TxUtilsConfig> = {},
-  debugMaxGasLimit: boolean = false,
-) {
+    kzg?: BlobKzgInstance;
+    delayer?: Delayer;
+  },
+  config?: Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean },
+): ForwarderL1TxUtils {
+  const { client, address, signingCallback } = resolveSignerSource(source);
   return new ForwarderL1TxUtils(
     client,
-    EthAddress.fromString(client.account.address),
-    createViemSigner(client),
-    deps.logger,
-    deps.dateProvider,
-    config,
-    debugMaxGasLimit,
-    deps.store,
-    deps.metrics,
-    forwarderAddress,
-  );
-}
-
-export function createForwarderL1TxUtilsFromEthSigner(
-  client: ViemClient,
-  signer: EthSigner,
-  forwarderAddress: EthAddress,
-  deps: {
-    logger?: Logger;
-    dateProvider?: DateProvider;
-    store?: IL1TxStore;
-    metrics?: IL1TxMetrics;
-  } = {},
-  config: Partial<L1TxUtilsConfig> = {},
-  debugMaxGasLimit: boolean = false,
-) {
-  const callback: SigningCallback = async (transaction, _signingAddress) => {
-    return (await signer.signTransaction(transaction)).toViemTransactionSignature();
-  };
-
-  return new ForwarderL1TxUtils(
-    client,
-    signer.address,
-    callback,
-    deps.logger,
-    deps.dateProvider,
-    config,
-    debugMaxGasLimit,
-    deps.store,
-    deps.metrics,
+    address,
+    signingCallback,
+    deps?.logger,
+    deps?.dateProvider,
+    config ?? {},
+    config?.debugMaxGasLimit ?? false,
+    deps?.store,
+    deps?.metrics,
+    deps?.kzg,
+    deps?.delayer,
     forwarderAddress,
   );
 }

package/src/l1_tx_utils/index-blobs.ts

@@ -1,2 +1,2 @@
-export * from './forwarder_l1_tx_utils.js';
-export * from './l1_tx_utils_with_blobs.js';
+export { createForwarderL1TxUtils, ForwarderL1TxUtils } from './forwarder_l1_tx_utils.js';
+export { createL1TxUtils, type L1SignerSource, resolveSignerSource } from './factory.js';

package/src/l1_tx_utils/index.ts

@@ -8,6 +8,7 @@ export * from './l1_tx_utils.js';
 export * from './readonly_l1_tx_utils.js';
 export * from './signer.js';
 export * from './types.js';
+export * from './tx_delayer.js';
 export * from './utils.js';
 
 // Note: We intentionally do not export l1_tx_utils_with_blobs.js