Precompute authorities when importing blocks

[fab-10]

PR description

Like we do for senders, when can precompute the authorities for EIP-7702 transactions, to improve the performance during block import

Fixed Issue(s)

Thanks for sending a pull request! Have you done the following?

• Checked out our contribution guidelines?
• Considered documentation and added the doc-change-required label to this PR if updates are required.
• Considered the changelog and included an update if required.
• For database changes (e.g. KeyValueSegmentIdentifier) considered compatibility and performed forwards and backwards compatibility tests

Locally, you can run these tests to catch failures early:

• unit tests: ./gradlew build
• acceptance tests: ./gradlew acceptanceTest
• integration tests: ./gradlew integrationTest
• reference tests: ./gradlew ethereum:referenceTests:referenceTests

[ahamlat]

Precompute is asynchronous here, are we sure that the authorities are not accessed before it is finished or there is a fallback to calculate them if they don't exist yet ?

[ahamlat]

I wonder if it is not better to precalculate all the senders than precompute all the autorities of all the transactions. Currently, we calculate sender of txn, then precomupte autorities of txn, then calculate sender of txn+1, then precomupte autorities of txn+1

[fab-10]

about your first question, if this async computation does not finish before the processing, then like for the sender it will be computed on first usage

About the order, I do not know which is the best solution, because in serial mode, should be better to precompute the authorities to txn before the sender of txn+1, but in parallel mode not sure what is the best solution, what do you suggest?

[ahamlat]

I was thinking about this case, do we want to improve the time it takes to execute all the transaction by precalculating all the sender or improve a large one by precalculating all the authorizers.
I think it makes sens here to improve the worst case, so let's keep the current order.

[ahamlat]

I think it makes also sens here compute the recovery in parallel, even for small amount of delegations. I suggest to do it when the number of delegation is bigger or equals to the number of cores

Benchmark                                                     (delegationCount)  Mode  Cnt      Score      Error  Units
CodeDelegationProcessorBenchmark.parallelProcessing                          10  avgt    5    212.832 ±    9.387  us/op
CodeDelegationProcessorBenchmark.parallelProcessing                         100  avgt    5    827.758 ±   84.302  us/op
CodeDelegationProcessorBenchmark.parallelProcessing                        1000  avgt    5   8260.485 ± 3498.222  us/op
CodeDelegationProcessorBenchmark.sequentialProcessing                        10  avgt    5    509.073 ±    7.936  us/op
CodeDelegationProcessorBenchmark.sequentialProcessing                       100  avgt    5   4918.714 ±  488.391  us/op
CodeDelegationProcessorBenchmark.sequentialProcessing                      1000  avgt    5  49019.810 ±  876.575  us/op