rollup-fee for spec=feynman

[roynalnaruto]

Fixes #42.

The PR implements the proposed updates to rollup-fee for ScrollSpecId::FEYNMAN.

rollup_fee(tx) = compression_factor(tx) * size(rlp(tx)) * (
	exec_scalar * l1_base_fee + 
	blob_scalar * l1_blob_base_fee
)

# compression_factor = 1.0 / compression_ratio
0.0 < compression_factor(tx) <= 1.0
exec_scalar = compression_scalar + commit_scalar + verification_scalar
blob_scalar = compression_scalar + blob_scalar

Assumption

compression_factor = 1 until further notice

[Thegaram]

lgtm, would be nice to add some tests

[frisitano]

Looks good, thanks for adding the documentation, that's super insightful and helpful. I added a question inline around the compression_ratio.

[frisitano]

From my understanding, we will assume the worst case in the prover, i.e. the compression ratio is 1. Is this the case, or will the prover also estimate compression? If the prover logic and execution node logic is different, how will we capture that here? Do we need to feature flag this here, depending on whether we are running as a prover or not?

[roynalnaruto]

The prover should not need to estimate compression ratio, specifically because zstd-encoding will add a lot of cycles to our batch prover (which we would like to avoid).

You are probably right, we will eventually need feature flag to either:

1. prover: fix upper bound for rollup fee (assuming compression ratio == 1)
2. node: calculating the actual rollup fee by estimating the compression_ratio with zstd-encoding

And we additionally must then constrain the rollup fee to be at the most the upper bound (in the prover).

Let's keep this PR unmerged until we resolve this conversation.

[frisitano]

I have some thoughts on how we can address the compression factor for the prover. We introduce a compression_factor: Option< U256 > field in the ScrollTransaction:

scroll-revm/src/transaction.rs

Lines 17 to 24 in 54e4e90

	/// A Scroll transaction. Wraps around a base transaction and provides the optional RLPed bytes for
	/// the l1 fee computation.
	#[derive(Clone, Debug, PartialEq, Eq)]
	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
	pub struct ScrollTransaction<T: Transaction> {
	pub base: T,
	pub rlp_bytes: Option<Bytes>,
	}

We provide a utility to compute the compression factors for all transactions in the host. These compression factors should be computed by the utility and then added to the witness. The witness is then provided to the guest. Inside the guest, we modify the EVM to enable access to the compression factor for each transaction. Inside of the rollup_fee function, we assert the compression factor is less than one and use it to compute the rollup_fee.

@roynalnaruto @Thegaram, I'm keen to hear your feedback on this approach.

[Thegaram]

Superseded by #50.