Precompile tests where we run up agains the (63/64)-ths stuff

[OlivierBBB]

We need to write tests with very simple bytecode. The specifics of these tests are as follows:

• message call transaction to a very simple contract
• bytecode: some pushes followed by e.g. GAS followed by CALL / STATICCALL to a precompile
• provide the transaction with a very low amount of gas

The goal is to trigger the (63/64)-ths business. We want to do this so that the callee will not meet its gas requirements.

In other words we must extract several unit tests (for all precompiles) from the issue #1136. See the documentation.

This is more advanced version of the test described in #1730. In the present test, we cannot give enough gas to run the precompile, while in the simpler version we deliberately do not give enough gas.

[OlivierBBB]

Gas calculation

int gasPreCall = frame.getRemainingGas() // prior to the CALL-type instruction processing
int gasUpfront =
    (value == 0)
        ? 100 // precompiles are warm
        : (precompileExistsInState)
            ? 9_000 + 100
            : 25_000 + 9_000 + 100;

checkState(gasPreCall >= gasUpfront);

int x = gasPreCall - gasUpfront;
int k = x / 64;
int l = x - 64 * k;
// x = 64 * k + l with 0 ≤ l < 64 is the euclidean division
// this k and l is what we are after

int stipend = (value == 0) ? 0 : 2_300;

int calleeGas = 63 * k + l + stipend;

You also compute the precompile cost and the desired targetCalleeGas

int prcCost = precompileExecutionCost() // cost of precompile execution
int targetCalleeGas = switch (costParam) {
    case COST_MO -> prcCost - 1;
    case COST -> prcCost;
}

---

At this point the goal is to work backwards from the desired conclusion:

63 * k + l + stipend = targetCalleeGas
0 ≤ k
0 ≤ l < 64

You work backwards. The above gets you uniquely the right k and l. Then you deduce the x, and from x you deduce gasPreCall. At that point you add up all the previous costs (the pushes, the initial memory expansion so as to incur no memory expansion during the CALL-type instruction, the 21_000 for the transaction) and you get the transaction gas limit.

---

Actually the above does not determine k and l uniquely. So we may have more freedom than initially expected. See graph below of the $L$ function from the yellow paper ($L(n) = n - (n/64)$ with $x/64$ representing integer division.)

---

We can actually search for

63 * k + l + stipend = targetCalleeGas
0 ≤ k
0 ≤ l < 63 // not 64

instead, and still uniquely achieve every target value possible. The main point being that $g: n \mapsto 63 \cdot k + l$ has $g(64k - 1) = g(64k)$