@aztec/ethereum 0.0.1-commit.c7c42ec → 0.0.1-commit.d1f2d6c

package/src/deploy_aztec_l1_contracts.ts

@@ -10,7 +10,9 @@ import { fileURLToPath } from '@aztec/foundation/url';
 import { bn254 } from '@noble/curves/bn254';
 import type { Abi, Narrow } from 'abitype';
 import { spawn } from 'child_process';
-import { dirname, resolve } from 'path';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { dirname, join, resolve } from 'path';
 import readline from 'readline';
 import type { Hex } from 'viem';
 import { foundry, mainnet, sepolia } from 'viem/chains';
@@ -107,17 +109,77 @@ export interface ValidatorJson {
 }
 
 /**
- * Gets the path to the l1-contracts directory.
+ * Gets the path to the l1-contracts foundry artifacts directory.
+ * These are copied from l1-contracts to yarn-project/l1-artifacts/l1-contracts
+ * during build to make yarn-project self-contained.
  */
 export function getL1ContractsPath(): string {
-  // Try to find l1-contracts relative to this file
   const currentDir = dirname(fileURLToPath(import.meta.url));
-
-  // Go up from yarn-project/ethereum/src to yarn-project, then to repo root, then to l1-contracts
-  const l1ContractsPath = resolve(currentDir, '..', '..', '..', 'l1-contracts');
+  // Go up from yarn-project/ethereum/dest to yarn-project, then to l1-artifacts/l1-contracts
+  const l1ContractsPath = resolve(currentDir, '..', '..', 'l1-artifacts', 'l1-contracts');
   return l1ContractsPath;
 }
 
+// Cached deployment directory
+let preparedDeployDir: string | undefined;
+
+function cleanupDeployDir() {
+  if (preparedDeployDir) {
+    try {
+      rmSync(preparedDeployDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+    preparedDeployDir = undefined;
+  }
+}
+
+/**
+ * Prepares a temp directory for forge deployment.
+ * Copies all artifacts with preserved timestamps (required for forge cache validity).
+ * A fresh broadcast/ directory is created for deployment outputs.
+ */
+export function prepareL1ContractsForDeployment(): string {
+  if (preparedDeployDir && existsSync(preparedDeployDir)) {
+    logger.verbose(`Using cached deployment directory: ${preparedDeployDir}`);
+    return preparedDeployDir;
+  }
+
+  const basePath = getL1ContractsPath();
+  logger.verbose(`Preparing L1 contracts from: ${basePath}`);
+  const tempDir = mkdtempSync(join(tmpdir(), '.foundry-deploy-'));
+  logger.verbose(`Created temp directory for deployment: ${tempDir}`);
+  preparedDeployDir = tempDir;
+  process.on('exit', cleanupDeployDir);
+
+  // Copy all dirs with preserved timestamps (required for forge cache validity)
+  const copyOpts = { recursive: true, preserveTimestamps: true };
+  cpSync(join(basePath, 'out'), join(tempDir, 'out'), copyOpts);
+  cpSync(join(basePath, 'lib'), join(tempDir, 'lib'), copyOpts);
+  cpSync(join(basePath, 'cache'), join(tempDir, 'cache'), copyOpts);
+  cpSync(join(basePath, 'src'), join(tempDir, 'src'), copyOpts);
+  cpSync(join(basePath, 'script'), join(tempDir, 'script'), copyOpts);
+  cpSync(join(basePath, 'generated'), join(tempDir, 'generated'), copyOpts);
+  // Kludge: copy test/ to appease forge cache which references test/shouting.t.sol
+  cpSync(join(basePath, 'test'), join(tempDir, 'test'), copyOpts);
+  cpSync(join(basePath, 'foundry.lock'), join(tempDir, 'foundry.lock'));
+
+  // Update foundry.toml to use absolute path to solc binary (avoids copying to noexec tmpfs)
+  const foundryTomlPath = join(basePath, 'foundry.toml');
+  let foundryToml = readFileSync(foundryTomlPath, 'utf-8');
+  const solcPathMatch = foundryToml.match(/solc\s*=\s*"\.\/solc-([^"]+)"/);
+  if (solcPathMatch) {
+    const solcVersion = solcPathMatch[1];
+    const absoluteSolcPath = join(basePath, `solc-${solcVersion}`);
+    foundryToml = foundryToml.replace(/solc\s*=\s*"\.\/solc-[^"]+"/, `solc = "${absoluteSolcPath}"`);
+    logger.verbose(`Updated solc path in foundry.toml to: ${absoluteSolcPath}`);
+  }
+  writeFileSync(join(tempDir, 'foundry.toml'), foundryToml);
+
+  mkdirSync(join(tempDir, 'broadcast'));
+  return tempDir;
+}
+
 /**
  * Computes the validator data for passing to Solidity.
  * Only computes the G2 public key (which requires scalar multiplication on G2, not available in EVM).
@@ -211,7 +273,6 @@ export async function deployAztecL1Contracts(
         'Initial validator funding requires minting tokens, which is not possible with an external token.',
     );
   }
-  const currentDir = dirname(fileURLToPath(import.meta.url));
   const chain = createEthereumChain([rpcUrl], chainId);
 
   const l1Client = createExtendedL1Client([rpcUrl], privateKey, chain.chainInfo);
@@ -240,8 +301,8 @@ export async function deployAztecL1Contracts(
     }
   }
 
-  // Relative location of l1-contracts in monorepo or docker image.
-  const l1ContractsPath = resolve(currentDir, '..', '..', '..', 'l1-contracts');
+  // Use foundry-artifacts from l1-artifacts package
+  const l1ContractsPath = prepareL1ContractsForDeployment();
 
   const FORGE_SCRIPT = 'script/deploy/DeployAztecL1Contracts.s.sol';
   await maybeForgeForceProductionBuild(l1ContractsPath, FORGE_SCRIPT, chainId);
@@ -258,7 +319,7 @@ export async function deployAztecL1Contracts(
   }
 
   // From heuristic testing. More caused issues with anvil.
-  const MAGIC_ANVIL_BATCH_SIZE = 12;
+  const MAGIC_ANVIL_BATCH_SIZE = 8;
   // Anvil seems to stall with unbounded batch size. Otherwise no max batch size is desirable.
   const forgeArgs = [
     'script',
@@ -447,6 +508,7 @@ export function getDeployAztecL1ContractsEnvVars(args: DeployAztecL1ContractsArg
     AZTEC_EJECTION_THRESHOLD: args.ejectionThreshold?.toString(),
     AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: args.governanceProposerRoundSize?.toString(),
     AZTEC_GOVERNANCE_PROPOSER_QUORUM: args.governanceProposerQuorum?.toString(),
+    AZTEC_GOVERNANCE_VOTING_DURATION: args.governanceVotingDuration?.toString(),
     ZKPASSPORT_DOMAIN: args.zkPassportArgs?.zkPassportDomain,
     ZKPASSPORT_SCOPE: args.zkPassportArgs?.zkPassportScope,
   } as const;
@@ -481,11 +543,13 @@ export function getDeployRollupForUpgradeEnvVars(
     AZTEC_PROOF_SUBMISSION_EPOCHS: args.aztecProofSubmissionEpochs.toString(),
     AZTEC_LOCAL_EJECTION_THRESHOLD: args.localEjectionThreshold.toString(),
     AZTEC_SLASHING_LIFETIME_IN_ROUNDS: args.slashingLifetimeInRounds.toString(),
+    AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: args.slashingExecutionDelayInRounds.toString(),
     AZTEC_SLASHING_VETOER: args.slashingVetoer.toString(),
     AZTEC_SLASHING_DISABLE_DURATION: args.slashingDisableDuration.toString(),
     AZTEC_MANA_TARGET: args.manaTarget.toString(),
     AZTEC_EXIT_DELAY_SECONDS: args.exitDelaySeconds.toString(),
     AZTEC_PROVING_COST_PER_MANA: args.provingCostPerMana.toString(),
+    AZTEC_INITIAL_ETH_PER_FEE_ASSET: args.initialEthPerFeeAsset.toString(),
     AZTEC_SLASHER_FLAVOR: args.slasherFlavor,
     AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: args.slashingRoundSizeInEpochs.toString(),
     AZTEC_SLASHING_QUORUM: args.slashingQuorum?.toString(),
@@ -513,10 +577,8 @@ export const deployRollupForUpgrade = async (
     | 'zkPassportArgs'
   >,
 ) => {
-  const currentDir = dirname(fileURLToPath(import.meta.url));
-
-  // Relative location of l1-contracts in monorepo or docker image.
-  const l1ContractsPath = resolve(currentDir, '..', '..', '..', 'l1-contracts');
+  // Use foundry-artifacts from l1-artifacts package
+  const l1ContractsPath = prepareL1ContractsForDeployment();
 
   const FORGE_SCRIPT = 'script/deploy/DeployRollupForUpgrade.s.sol';
   await maybeForgeForceProductionBuild(l1ContractsPath, FORGE_SCRIPT, chainId);

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

@@ -0,0 +1,32 @@
+// Auto-generated from spartan/environments/network-defaults.yml
+// Do not edit manually - run yarn generate to regenerate
+
+/** Default L1 contracts configuration values from network-defaults.yml */
+export const l1ContractsDefaultEnv = {
+  ETHEREUM_SLOT_DURATION: 12,
+  AZTEC_SLOT_DURATION: 36,
+  AZTEC_EPOCH_DURATION: 32,
+  AZTEC_TARGET_COMMITTEE_SIZE: 48,
+  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
+  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
+  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
+  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
+  AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
+  AZTEC_EXIT_DELAY_SECONDS: 172800,
+  AZTEC_INBOX_LAG: 1,
+  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_MANA_TARGET: 100000000,
+  AZTEC_PROVING_COST_PER_MANA: 100,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
+  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
+  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+  AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
+  AZTEC_SLASHING_DISABLE_DURATION: 432000,
+  AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
+  AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
+  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300,
+} as const;

package/src/l1_tx_utils/fee-strategies/index.ts

@@ -4,13 +4,13 @@ import type { PriorityFeeStrategy } from './types.js';
 
 export {
   HISTORICAL_BLOCK_COUNT,
-  executeStrategy,
   type PriorityFeeStrategy,
   type PriorityFeeStrategyContext,
   type PriorityFeeStrategyResult,
 } from './types.js';
 
 export { P75AllTxsPriorityFeeStrategy } from './p75_competitive.js';
+export { P75BlobTxsOnlyPriorityFeeStrategy } from './p75_competitive_blob_txs_only.js';
 
 /**
  * Default list of priority fee strategies to analyze.

package/src/l1_tx_utils/fee-strategies/p75_competitive.ts

@@ -12,50 +12,54 @@ import {
   type PriorityFeeStrategyResult,
 } from './types.js';
 
-/**
- * Type for the promises required by the competitive strategy
- */
-type P75AllTxsStrategyPromises = {
-  networkEstimate: Promise<bigint>;
-  pendingBlock: Promise<Awaited<ReturnType<ViemClient['getBlock']>> | null>;
-  feeHistory: Promise<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>;
-};
-
 /**
  * Our current competitive priority fee strategy.
  * Analyzes p75 of pending transactions and 5-block fee history to determine a competitive priority fee.
  * Falls back to network estimate if data is unavailable.
  */
-export const P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStrategyPromises> = {
+export const P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy = {
   name: 'Competitive (P75 + History) - CURRENT',
   id: 'p75_pending_txs_and_history_all_txs',
 
-  getRequiredPromises(client: ViemClient): P75AllTxsStrategyPromises {
-    return {
-      networkEstimate: client.estimateMaxPriorityFeePerGas().catch(() => 0n),
-      pendingBlock: client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
-      feeHistory: client
-        .getFeeHistory({
-          blockCount: HISTORICAL_BLOCK_COUNT,
-          rewardPercentiles: [75],
-          blockTag: 'latest',
-        })
-        .catch(() => null),
-    };
-  },
-
-  calculate(
-    results: {
-      [K in keyof P75AllTxsStrategyPromises]: PromiseSettledResult<Awaited<P75AllTxsStrategyPromises[K]>>;
-    },
-    context: PriorityFeeStrategyContext,
-  ): PriorityFeeStrategyResult {
-    const { logger } = context;
+  async execute(client: ViemClient, context: PriorityFeeStrategyContext): Promise<PriorityFeeStrategyResult> {
+    const { isBlobTx, logger } = context;
+
+    // Fire all RPC calls in parallel
+    const [latestBlockResult, blobBaseFeeResult, networkEstimateResult, pendingBlockResult, feeHistoryResult] =
+      await Promise.allSettled([
+        client.getBlock({ blockTag: 'latest' }),
+        isBlobTx ? client.getBlobBaseFee() : Promise.resolve(undefined),
+        client.estimateMaxPriorityFeePerGas().catch(() => 0n),
+        client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
+        client
+          .getFeeHistory({
+            blockCount: HISTORICAL_BLOCK_COUNT,
+            rewardPercentiles: [75],
+            blockTag: 'latest',
+          })
+          .catch(() => null),
+      ]);
+
+    // Extract latest block
+    if (latestBlockResult.status === 'rejected') {
+      throw new Error(`Failed to get latest block: ${latestBlockResult.reason}`);
+    }
+    const latestBlock = latestBlockResult.value;
+
+    // Extract blob base fee (only for blob txs)
+    let blobBaseFee: bigint | undefined;
+    if (isBlobTx) {
+      if (blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
+        blobBaseFee = blobBaseFeeResult.value;
+      } else {
+        logger?.warn('Failed to get L1 blob base fee');
+      }
+    }
 
-    // Extract network estimate from settled result
+    // Extract network estimate
     const networkEstimate =
-      results.networkEstimate.status === 'fulfilled' && typeof results.networkEstimate.value === 'bigint'
-        ? results.networkEstimate.value
+      networkEstimateResult.status === 'fulfilled' && typeof networkEstimateResult.value === 'bigint'
+        ? networkEstimateResult.value
         : 0n;
 
     let competitiveFee = networkEstimate;
@@ -63,8 +67,8 @@ export const P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStrategy
       networkEstimateGwei: formatGwei(networkEstimate),
     };
 
-    // Extract pending block from settled result
-    const pendingBlock = results.pendingBlock.status === 'fulfilled' ? results.pendingBlock.value : null;
+    // Extract pending block
+    const pendingBlock = pendingBlockResult.status === 'fulfilled' ? pendingBlockResult.value : null;
 
     // Analyze pending block transactions
     if (pendingBlock?.transactions && pendingBlock.transactions.length > 0) {
@@ -73,9 +77,7 @@ export const P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStrategy
           if (typeof tx === 'string') {
             return 0n;
           }
-          const fee = tx.maxPriorityFeePerGas || 0n;
-
-          return fee;
+          return tx.maxPriorityFeePerGas || 0n;
         })
         .filter((fee: bigint) => fee > 0n);
 
@@ -97,8 +99,8 @@ export const P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStrategy
       }
     }
 
-    // Extract fee history from settled result
-    const feeHistory = results.feeHistory.status === 'fulfilled' ? results.feeHistory.value : null;
+    // Extract fee history
+    const feeHistory = feeHistoryResult.status === 'fulfilled' ? feeHistoryResult.value : null;
 
     // Analyze fee history
     if (feeHistory?.reward && feeHistory.reward.length > 0) {
@@ -153,6 +155,8 @@ export const P75AllTxsPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStrategy
 
     return {
       priorityFee: competitiveFee,
+      latestBlock,
+      blobBaseFee,
       debugInfo,
     };
   },

package/src/l1_tx_utils/fee-strategies/p75_competitive_blob_txs_only.ts

@@ -12,15 +12,6 @@ import {
   type PriorityFeeStrategyResult,
 } from './types.js';
 
-/**
- * Type for the promises required by the competitive strategy
- */
-type P75AllTxsStrategyPromises = {
-  networkEstimate: Promise<bigint>;
-  pendingBlock: Promise<Awaited<ReturnType<ViemClient['getBlock']>> | null>;
-  feeHistory: Promise<Awaited<ReturnType<ViemClient['getFeeHistory']>> | null>;
-};
-
 /**
  * Fetches historical blocks and calculates reward percentiles for blob transactions only.
  * Returns data in the same format as getFeeHistory for easy drop-in replacement.
@@ -114,38 +105,51 @@ export async function getBlobPriorityFeeHistory(
  * Analyzes p75 of pending transactions and 5-block fee history to determine a competitive priority fee.
  * Falls back to network estimate if data is unavailable.
  */
-export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStrategyPromises> = {
+export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy = {
   name: 'Competitive (P75 + History) - Blob Txs Only',
   id: 'p75_pending_txs_and_history_blob_txs_only',
 
-  getRequiredPromises(client: ViemClient, opts: PriorityFeeStrategyContext): P75AllTxsStrategyPromises {
-    return {
-      networkEstimate: client.estimateMaxPriorityFeePerGas().catch(() => 0n),
-      pendingBlock: client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
-      feeHistory: opts.isBlobTx
-        ? getBlobPriorityFeeHistory(client, HISTORICAL_BLOCK_COUNT, [75])
-        : client
-            .getFeeHistory({
-              blockCount: HISTORICAL_BLOCK_COUNT,
-              rewardPercentiles: [75],
-              blockTag: 'latest',
-            })
-            .catch(() => null),
-    };
-  },
-
-  calculate(
-    results: {
-      [K in keyof P75AllTxsStrategyPromises]: PromiseSettledResult<Awaited<P75AllTxsStrategyPromises[K]>>;
-    },
-    context: PriorityFeeStrategyContext,
-  ): PriorityFeeStrategyResult {
-    const { logger } = context;
+  async execute(client: ViemClient, context: PriorityFeeStrategyContext): Promise<PriorityFeeStrategyResult> {
+    const { isBlobTx, logger } = context;
+
+    // Fire all RPC calls in parallel
+    const [latestBlockResult, blobBaseFeeResult, networkEstimateResult, pendingBlockResult, feeHistoryResult] =
+      await Promise.allSettled([
+        client.getBlock({ blockTag: 'latest' }),
+        isBlobTx ? client.getBlobBaseFee() : Promise.resolve(undefined),
+        client.estimateMaxPriorityFeePerGas().catch(() => 0n),
+        client.getBlock({ blockTag: 'pending', includeTransactions: true }).catch(() => null),
+        isBlobTx
+          ? getBlobPriorityFeeHistory(client, HISTORICAL_BLOCK_COUNT, [75])
+          : client
+              .getFeeHistory({
+                blockCount: HISTORICAL_BLOCK_COUNT,
+                rewardPercentiles: [75],
+                blockTag: 'latest',
+              })
+              .catch(() => null),
+      ]);
+
+    // Extract latest block (required)
+    if (latestBlockResult.status === 'rejected') {
+      throw new Error(`Failed to get latest block: ${latestBlockResult.reason}`);
+    }
+    const latestBlock = latestBlockResult.value;
+
+    // Extract blob base fee (only for blob txs)
+    let blobBaseFee: bigint | undefined;
+    if (isBlobTx) {
+      if (blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
+        blobBaseFee = blobBaseFeeResult.value;
+      } else {
+        logger?.warn('Failed to get L1 blob base fee');
+      }
+    }
 
-    // Extract network estimate from settled result
+    // Extract network estimate
     const networkEstimate =
-      results.networkEstimate.status === 'fulfilled' && typeof results.networkEstimate.value === 'bigint'
-        ? results.networkEstimate.value
+      networkEstimateResult.status === 'fulfilled' && typeof networkEstimateResult.value === 'bigint'
+        ? networkEstimateResult.value
         : 0n;
 
     let competitiveFee = networkEstimate;
@@ -153,8 +157,8 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStr
       networkEstimateGwei: formatGwei(networkEstimate),
     };
 
-    // Extract pending block from settled result
-    const pendingBlock = results.pendingBlock.status === 'fulfilled' ? results.pendingBlock.value : null;
+    // Extract pending block
+    const pendingBlock = pendingBlockResult.status === 'fulfilled' ? pendingBlockResult.value : null;
 
     // Analyze pending block transactions
     if (pendingBlock?.transactions && pendingBlock.transactions.length > 0) {
@@ -163,14 +167,12 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStr
           if (typeof tx === 'string') {
             return 0n;
           }
-          if (context.isBlobTx) {
+          if (isBlobTx) {
             if (!isBlobTransaction(tx)) {
               return 0n;
             }
           }
-          const fee = tx.maxPriorityFeePerGas || 0n;
-
-          return fee;
+          return tx.maxPriorityFeePerGas || 0n;
         })
         .filter((fee: bigint) => fee > 0n);
 
@@ -191,8 +193,8 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStr
       }
     }
 
-    // Extract fee history from settled result
-    const feeHistory = results.feeHistory.status === 'fulfilled' ? results.feeHistory.value : null;
+    // Extract fee history
+    const feeHistory = feeHistoryResult.status === 'fulfilled' ? feeHistoryResult.value : null;
 
     // Analyze fee history
     if (feeHistory?.reward && feeHistory.reward.length > 0) {
@@ -235,6 +237,8 @@ export const P75BlobTxsOnlyPriorityFeeStrategy: PriorityFeeStrategy<P75AllTxsStr
 
     return {
       priorityFee: competitiveFee,
+      latestBlock,
+      blobBaseFee,
       debugInfo,
     };
   },

package/src/l1_tx_utils/fee-strategies/types.ts

@@ -1,5 +1,7 @@
 import type { Logger } from '@aztec/foundation/log';
 
+import type { Block } from 'viem';
+
 import type { ViemClient } from '../../types.js';
 import type { L1TxUtilsConfig } from '../config.js';
 
@@ -14,12 +16,16 @@ export const HISTORICAL_BLOCK_COUNT = 5;
 export interface PriorityFeeStrategyResult {
   /** The calculated priority fee in wei */
   priorityFee: bigint;
+  /** The latest block (fetched as part of the strategy) */
+  latestBlock: Block;
+  /** The blob base fee (only present for blob transactions) */
+  blobBaseFee?: bigint;
   /** Optional debug info about how the fee was calculated */
   debugInfo?: Record<string, string | number>;
 }
 
 /**
- * Context passed to the strategy calculation function (excluding promise results)
+ * Context passed to the strategy function
  */
 export interface PriorityFeeStrategyContext {
   /** Gas configuration */
@@ -32,57 +38,19 @@ export interface PriorityFeeStrategyContext {
 
 /**
  * A strategy for calculating the priority fee for L1 transactions.
- * Each strategy defines what promises it needs and how to calculate the fee from their results.
- * This design allows strategies to be plugged into both L1FeeAnalyzer and ReadOnlyL1TxUtils.
+ * The function handles all RPC calls and returns
+ * the priority fee, along with any block data needed by the caller.
  */
-export interface PriorityFeeStrategy<TPromises extends Record<string, Promise<any>> = Record<string, Promise<any>>> {
+export type PriorityFeeStrategy = {
   /** Human-readable name for logging */
   name: string;
   /** Unique identifier for metrics */
   id: string;
   /**
-   * Returns the promises that need to be executed for this strategy.
-   * These will be run in parallel with Promise.allSettled.
+   * Calculate the priority fee.
    * @param client - The viem client to use for RPC calls
-   * @returns An object of promises keyed by name
-   */
-  getRequiredPromises(client: ViemClient, opts: Partial<PriorityFeeStrategyContext>): TPromises;
-  /**
-   * Calculate the priority fee based on the settled promise results.
-   * @param results - The settled results of the promises from getRequiredPromises
    * @param context - Contains gas config, whether it's a blob tx, and logger
-   * @returns The calculated priority fee result
+   * @returns The calculated priority fee result including block data
    */
-  calculate(
-    results: { [K in keyof TPromises]: PromiseSettledResult<Awaited<TPromises[K]>> },
-    context: PriorityFeeStrategyContext,
-  ): PriorityFeeStrategyResult;
-}
-
-/**
- * Helper function to execute a strategy's promises and calculate the result.
- * This can be used by both L1FeeAnalyzer and ReadOnlyL1TxUtils.
- * @param strategy - The strategy to execute
- * @param client - The viem client to use for RPC calls
- * @param context - The context for calculation
- * @returns The strategy result
- */
-export async function executeStrategy<TPromises extends Record<string, Promise<any>>>(
-  strategy: PriorityFeeStrategy<TPromises>,
-  client: ViemClient,
-  context: PriorityFeeStrategyContext,
-): Promise<PriorityFeeStrategyResult> {
-  const promises = strategy.getRequiredPromises(client, { isBlobTx: context.isBlobTx });
-  const keys = Object.keys(promises) as Array<keyof TPromises>;
-  const promiseArray = keys.map(k => promises[k]);
-
-  const settledResults = await Promise.allSettled(promiseArray);
-
-  // Reconstruct the results object with the same keys, preserving the type mapping
-  const results = {} as { [K in keyof TPromises]: PromiseSettledResult<Awaited<TPromises[K]>> };
-  keys.forEach((key, index) => {
-    results[key] = settledResults[index] as PromiseSettledResult<Awaited<TPromises[typeof key]>>;
-  });
-
-  return strategy.calculate(results, context);
-}
+  execute: (client: ViemClient, context: PriorityFeeStrategyContext) => Promise<PriorityFeeStrategyResult>;
+};

package/src/l1_tx_utils/l1_fee_analyzer.ts

@@ -13,7 +13,6 @@ import {
   DEFAULT_PRIORITY_FEE_STRATEGIES,
   type PriorityFeeStrategy,
   type PriorityFeeStrategyContext,
-  executeStrategy,
 } from './fee-strategies/index.js';
 import type { L1BlobInputs, L1TxRequest } from './types.js';
 
@@ -262,7 +261,7 @@ export class L1FeeAnalyzer {
 
   /**
    * Executes all configured strategies and returns their results.
-   * Each strategy defines its own promises which are executed and passed to calculate.
+   * Each strategy handles its own RPC calls internally.
    * @param isBlobTx - Whether this is a blob transaction
    * @returns Array of strategy results
    */
@@ -276,7 +275,7 @@ export class L1FeeAnalyzer {
 
     for (const strategy of this.strategies) {
       try {
-        const result = await executeStrategy(strategy, this.client, context);
+        const result = await strategy.execute(this.client, context);
 
         results.push({
           strategyId: strategy.id,