Add base_meterBundle RPC for transaction bundle metering

[niran]

Implements JSON-RPC endpoint to simulate and meter Optimism transaction bundles, returning detailed gas usage, execution time, and bundle hash using Flashbots methodology.

Includes reusable meter_bundle() function for non-RPC contexts.

[danyalprout]

Looks good to me, left some comments on things that stood out but aren't blockers to merging.

Can we add a sanity check e2e test to this? Happy to do it in a follow up PR

[niran]

The biggest wart from moving to tips_core::Bundle is that specific block numbers now need to be provided in the request. The ability to specify "pending" or "latest" has been lost.

[wlawt]

@niran i think we could do BlockNumberOrTag::Latest.as_number()?

[niran]

Yep, that's what the code was doing before. But since the Bundle type has its own block number field, we can either just use Bundle's field, refactor the core types to make it easier to provide the block reference in the right way, or just avoid the core types altogether.

The types refactoring approach seems like the best option to me, but it's a little messy if we want to be able to maintain the main benefit that changes to bundle features are reflected in every crate that depends on tips-core. I think it'd be something like this in tips-core, which implements conversions between types to ensure they stay compatible. (Unfortunately, for other crates to inherit this, they'll have to remember to add similar conversion functions. Otherwise conversions will silently break.)

  // Core bundle data without timing/targeting
  pub struct BundleCore {
      pub txs: Vec<Bytes>,
      pub reverting_tx_hashes: Vec<TxHash>,
      pub replacement_uuid: Option<String>,
      pub dropping_tx_hashes: Vec<TxHash>,
  }

  // Timing/targeting metadata separate from core
  pub struct TimingMetadata {
      pub block_number: u64,
      pub flashblock_number_min: Option<u64>,
      pub flashblock_number_max: Option<u64>,
      pub min_timestamp: Option<u64>,
      pub max_timestamp: Option<u64>,
  }

  // Original Bundle type (unchanged for backward compatibility)
  pub struct Bundle {
      pub txs: Vec<Bytes>,
      pub block_number: u64,
      pub flashblock_number_min: Option<u64>,
      pub flashblock_number_max: Option<u64>,
      pub min_timestamp: Option<u64>,
      pub max_timestamp: Option<u64>,
      pub reverting_tx_hashes: Vec<TxHash>,
      pub replacement_uuid: Option<String>,
      pub dropping_tx_hashes: Vec<TxHash>,
  }

  // Decompose Bundle into parts
  impl Bundle {
      pub fn into_parts(self) -> (BundleCore, TimingMetadata) {
          let core = BundleCore {
              txs: self.txs,
              reverting_tx_hashes: self.reverting_tx_hashes,
              replacement_uuid: self.replacement_uuid,
              dropping_tx_hashes: self.dropping_tx_hashes,
          };

          let timing = TimingMetadata {
              block_number: self.block_number,
              flashblock_number_min: self.flashblock_number_min,
              flashblock_number_max: self.flashblock_number_max,
              min_timestamp: self.min_timestamp,
              max_timestamp: self.max_timestamp,
          };

          (core, timing)
      }

      pub fn from_parts(core: BundleCore, timing: TimingMetadata) -> Self {
          Bundle {
              txs: core.txs,
              block_number: timing.block_number,
              flashblock_number_min: timing.flashblock_number_min,
              flashblock_number_max: timing.flashblock_number_max,
              min_timestamp: timing.min_timestamp,
              max_timestamp: timing.max_timestamp,
              reverting_tx_hashes: core.reverting_tx_hashes,
              replacement_uuid: core.replacement_uuid,
              dropping_tx_hashes: core.dropping_tx_hashes,
          }
      }

      pub fn core(&self) -> &BundleCore {
          // For zero-copy access
      }
  }

  // Standard conversions
  impl From<Bundle> for BundleCore {
      fn from(bundle: Bundle) -> Self {
          bundle.into_parts().0
      }
  }

  impl From<&Bundle> for BundleCore {
      fn from(bundle: &Bundle) -> Self {
          BundleCore {
              txs: bundle.txs.clone(),
              reverting_tx_hashes: bundle.reverting_tx_hashes.clone(),
              replacement_uuid: bundle.replacement_uuid.clone(),
              dropping_tx_hashes: bundle.dropping_tx_hashes.clone(),
          }
      }
  }

Then the MeterBundleRequest would have its own handling for BlockNumberOrTag::Latest.as_number() with a method that extracts a TimingMetadata to maintain compatibility over time.

Whatever we decide here, I think we should do it as its own feature later.

[danyalprout]

The biggest wart from moving to tips_core::Bundle is that specific block numbers now need to be provided in the request. The ability to specify "pending" or "latest" has been lost.

Any reason to not always sim against latest (or ideally pending/flashblock state)?

[niran]

Once this is reviewed, I'm going to re-open this PR against main to merge it in now that there's a feature flag for it. (thanks @wlawt)

EDIT: turns out the merge base is editable! It's now based on main.