fix: update linting comment length

Author: LouisTsai-Csie

src/ethereum_test_benchmark/benchmark_code_generator.py

@@ -17,7 +17,9 @@ class JumpLoopGenerator(BenchmarkCodeGenerator):
     def deploy_contracts(self, pre: Alloc, fork: Fork) -> Address:
         """Deploy the looping contract."""
         # Benchmark Test Structure:
-        # setup + JUMPDEST + attack + attack + ... + cleanup + JUMP(setup_length)
+        # setup + JUMPDEST +
+        # attack + attack + ... + attack +
+        # cleanup + JUMP(setup_length)
         code = self.generate_repeated_code(self.attack_block, self.setup, self.cleanup, fork)
         self._contract_address = pre.deploy_contract(code=code)
         return self._contract_address

tests/benchmark/test_worst_blocks.py

@@ -205,7 +205,8 @@ def calldata_generator(
     # Token accounting:
     #   tokens_in_calldata = zero_bytes + 4 * non_zero_bytes
     #
-    # So we calculate how many bytes we can fit into calldata based on available gas.
+    # So we calculate how many bytes we can fit into calldata based on
+    # available gas.
     max_tokens_in_calldata = gas_amount // total_cost_floor_per_token
     num_of_bytes = max_tokens_in_calldata if zero_byte else max_tokens_in_calldata // 4
     byte_data = b"\x00" if zero_byte else b"\xff"
@@ -268,7 +269,10 @@ def test_block_full_access_list_and_data(
     gas_benchmark_value: int,
     tx_gas_limit_cap: int,
 ):
-    """Test a block with access lists (60% gas) and calldata (40% gas) using random mixed bytes."""
+    """
+    Test a block with access lists (60% gas) and calldata (40% gas) using
+    random mixed bytes.
+    """
     iteration_count = math.ceil(gas_benchmark_value / tx_gas_limit_cap)
 
     gas_remaining = gas_benchmark_value
@@ -305,8 +309,10 @@ def test_block_full_access_list_and_data(
             )
         ]
 
-        # Calculate calldata with 29% of gas for zero bytes and 71% for non-zero bytes
-        # Token accounting: tokens_in_calldata = zero_bytes + 4 * non_zero_bytes
+        # Calculate calldata with 29% of gas for zero bytes and 71% for
+        # non-zero bytes
+        # Token accounting: tokens_in_calldata = zero_bytes + 4 *
+        # non_zero_bytes
         # We want to split the gas budget:
         # - 29% of gas_for_calldata for zero bytes
         # - 71% of gas_for_calldata for non-zero bytes

tests/benchmark/test_worst_bytecode.py

@@ -35,10 +35,10 @@
 
 def deploy_initcode_template(pre: Alloc, fork: Fork) -> tuple[Address, Bytecode]:
     """Deploy the initcode template contract."""
-    # The initcode will take its address as a starting point to the input to the keccak
-    # hash function.
-    # It will reuse the output of the hash function in a loop to create a large amount of
-    # seemingly random code, until it reaches the maximum contract size.
+    # The initcode will take its address as a starting point to the input to
+    # the keccak hash function.
+    # It will reuse the output of the hash function in a loop to create a
+    # large amount of random code, until it reaches the maximum code size.
     initcode = (
         Op.MSTORE(0, Op.ADDRESS)
         + While(
@@ -65,8 +65,8 @@ def deploy_initcode_template(pre: Alloc, fork: Fork) -> tuple[Address, Bytecode]
 
 def deploy_factory_contract(pre: Alloc, fork: Fork, initcode_address: Address) -> Address:
     """Deploy the factory contract."""
-    # The factory contract will simply use the initcode that is already deployed,
-    # and create a new contract and return its address if successful.
+    # The factory contract will use the initcode that is already
+    # deployed, and create a new contract and return its address if successful.
     factory_code = (
         Op.EXTCODECOPY(
             address=initcode_address,
@@ -91,8 +91,8 @@ def deploy_factory_contract(pre: Alloc, fork: Fork, initcode_address: Address) -
 
 def deploy_factory_caller_contract(pre: Alloc, fork: Fork, factory_address: Address) -> Address:
     """Deploy the factory caller contract."""
-    # The factory caller will call the factory contract N times, creating N new contracts.
-    # Calldata should contain the N value.
+    # The factory caller will call the factory contract N times, creating N
+    # new contracts. Calldata should contain the N value.
     factory_caller_code = Op.CALLDATALOAD(0) + While(
         body=Op.POP(Op.CALL(address=factory_address)),
         condition=Op.PUSH1(1) + Op.SWAP1 + Op.SUB + Op.DUP1 + Op.ISZERO + Op.ISZERO,
@@ -114,7 +114,10 @@ def deploy_attack_contract(
         + Op.MSTORE(64, initcode.keccak256())
     )
 
-    # setup_cost: G_VERY_LOW * 9 (PUSH) + G_VERY_LOW * 3 (MSTORE) + G_VERY_LOW (CALLDATACOPY)
+    # setup_cost:
+    # G_VERY_LOW * 9 (PUSH) +
+    # G_VERY_LOW * 3 (MSTORE) +
+    # G_VERY_LOW (CALLDATACOPY)
 
     # Attack call
     attack_call = Bytecode()
@@ -131,7 +134,7 @@ def deploy_attack_contract(
 
     # loop_cost = (
     #     gas_costs.G_KECCAK_256  KECCAK static cost
-    #     + math.ceil(85 / 32) * gas_costs.G_KECCAK_256_WORD  KECCAK dynamic cost for CREATE2
+    #     + math.ceil(85 / 32) * gas_costs.G_KECCAK_256_WORD
     #     + gas_costs.G_VERY_LOW * ~MSTOREs+ADDs
     #     + gas_costs.G_COLD_ACCOUNT_ACCESS Opcode cost
     #     + 30 ~Gluing opcodes
@@ -162,24 +165,28 @@ def test_worst_bytecode_single_opcode(
     tx_gas_limit_cap: int,
 ):
     """
-    Test a block execution where a single opcode execution maxes out the gas limit,
+    Test a block execution where a single opcode execution maxes out the
+    gas limit,
     and the opcodes access a huge amount of contract code.
 
-    We first use a single block to deploy a factory contract that will be used to deploy
+    We first use a single block to deploy a factory contract that will be
+    used to deploy
     a large number of contracts.
 
     This is done to avoid having a big pre-allocation size for the test.
 
-    The test is performed in the last block of the test, and the entire block gas limit is
+    The test is performed in the last block of the test, and the entire
+    block gas limit is
     consumed by repeated opcode executions.
     """
     iteration_count = gas_benchmark_value // tx_gas_limit_cap
 
     # The attack gas limit is the gas limit which the target tx will use
-    # The test will scale the block gas limit to setup the contracts accordingly to be
-    # able to pay for the contract deposit. This has to take into account the 200 gas per byte,
-    # but also the quadratic memory expansion costs which have to be paid each time the
-    # memory is being setup
+    # The test will scale the block gas limit to setup the contracts
+    # accordingly to be able to pay for the contract deposit.
+    # This has to take into account the 200 gas per byte,
+    # but also the quadratic memory expansion costs which have to be paid
+    # each time the memory is being setup
     max_contract_size = fork.max_code_size()
 
     gas_costs = fork.gas_costs()
@@ -200,7 +207,8 @@ def test_worst_bytecode_single_opcode(
     for _ in range(iteration_count):
         gas_available = min(tx_gas_limit_cap, gas_remaining)
         total_contracts += (
-            # Base available gas = GAS_LIMIT - intrinsic - (out of loop MSTOREs)
+            # Base available gas =
+            # GAS_LIMIT - intrinsic - (out of loop MSTOREs)
             gas_available - intrinsic_gas_cost_calc() - setup_cost
         ) // loop_cost
         gas_remaining -= gas_available
@@ -213,7 +221,8 @@ def test_worst_bytecode_single_opcode(
     # Deployment Phase - Deploy N contracts
 
     # Calculate the absolute minimum gas costs to deploy the contract
-    # This does not take into account setting up the actual memory (using KECCAK256 and XOR)
+    # This does not take into account setting up the actual memory
+    # (using KECCAK256 and XOR)
     # so the actual costs of deploying the contract is higher
     memory_expansion_gas_calculator = fork.memory_expansion_gas_calculator()
     memory_gas_minimum = memory_expansion_gas_calculator(new_bytes=len(bytes(max_contract_size)))

tests/benchmark/test_worst_compute.py

@@ -212,7 +212,10 @@ def test_worst_returndatasize_zero(
     benchmark_test: BenchmarkTestFiller,
     pre: Alloc,
 ):
-    """Test running a block with as many RETURNDATASIZE opcodes as possible with a zero buffer."""
+    """
+    Test running a block with as many RETURNDATASIZE opcodes as possible with
+    a zero buffer.
+    """
     benchmark_test(
         pre=pre,
         post={},
@@ -262,8 +265,10 @@ def test_worst_keccak(
     gsc = fork.gas_costs()
     mem_exp_gas_calculator = fork.memory_expansion_gas_calculator()
 
-    # Discover the optimal input size to maximize keccak-permutations, not keccak calls.
-    # The complication of the discovery arises from the non-linear gas cost of memory expansion.
+    # Discover the optimal input size to maximize keccak-permutations,
+    # not to maximize keccak calls.
+    # The complication of the discovery arises from
+    # the non-linear gas cost of memory expansion.
     max_keccak_perm_per_block = 0
     optimal_input_length = 0
     for i in range(1, 1_000_000, 32):
@@ -294,9 +299,11 @@ def test_worst_keccak(
     # The loop structure is: JUMPDEST + [attack iteration] + PUSH0 + JUMP
     #
     # Now calculate available gas for [attack iteration]:
-    #   Numerator = max_code_size-3. The -3 is for the JUMPDEST, PUSH0 and JUMP.
-    #   Denominator = (PUSHN + PUSH1 + KECCAK256 + POP) + PUSH1_DATA + PUSHN_DATA
-    # TODO: the testing framework uses PUSH1(0) instead of PUSH0 which is suboptimal for the
+    #   Numerator = max_code_size-3. (JUMPDEST, PUSH0 and JUMP)
+    #   Denominator = (PUSHN + PUSH1 + KECCAK256 + POP) + PUSH1_DATA +
+    #   PUSHN_DATA
+    # TODO: the testing framework uses PUSH1(0) instead of PUSH0 which is
+    # suboptimal for the
     # attack, whenever this is fixed adjust accordingly.
     benchmark_test(
         pre=pre,
@@ -1542,11 +1549,13 @@ def test_worst_tstore(
     init_key = 42
     setup = Op.PUSH1(init_key)
 
-    # If `dense_val_mut` is set, we use GAS as a cheap way of always storing a different value than
+    # If `dense_val_mut` is set, we use GAS as a cheap way of always
+    # storing a different value than
     # the previous one.
     attack_block = Op.TSTORE(Op.DUP2, Op.GAS if dense_val_mut else Op.DUP1)
 
-    # If `key_mut` is True, we mutate the key on every iteration of the big loop.
+    # If `key_mut` is True, we mutate the key on every iteration of the
+    # big loop.
     cleanup = Op.POP + Op.GAS if key_mut else Bytecode()
 
     benchmark_test(
@@ -1707,8 +1716,10 @@ def test_worst_mod(
     The order of accessing the numerators is selected in a way the mod value
     remains in the range as long as possible.
     """
-    # For SMOD we negate both numerator and modulus. The underlying computation is the same,
-    # just the SMOD implementation will have to additionally handle the sign bits.
+    # For SMOD we negate both numerator and modulus. The underlying
+    # computation is the same,
+    # just the SMOD implementation will have to additionally handle the
+    # sign bits.
     # The result stays negative.
     should_negate = op == Op.SMOD
 
@@ -1780,7 +1791,8 @@ def test_worst_mod(
         seed += 1
         print(f"{seed=}")
 
-    # TODO: Don't use fixed PUSH32. Let Bytecode helpers to select optimal push opcode.
+    # TODO: Don't use fixed PUSH32. Let Bytecode helpers to select optimal
+    # push opcode.
     setup = sum((Op.PUSH32[n] for n in numerators), Bytecode())
     attack_block = (
         Op.CALLDATALOAD(0) + sum(make_dup(len(numerators) - i) + op for i in indexes) + Op.POP
@@ -1812,7 +1824,10 @@ def test_worst_memory_access(
     offset_initialized: bool,
     big_memory_expansion: bool,
 ):
-    """Test running a block with as many memory access instructions as possible."""
+    """
+    Test running a block with as many memory access instructions as
+    possible.
+    """
     mem_exp_code = Op.MSTORE8(10 * 1024, 1) if big_memory_expansion else Bytecode()
     offset_set_code = Op.MSTORE(offset, 43) if offset_initialized else Bytecode()
     setup = mem_exp_code + offset_set_code + Op.PUSH1(42) + Op.PUSH1(offset)
@@ -2273,7 +2288,10 @@ def test_worst_clz_diff_input(
     gas_benchmark_value: int,
     env: Environment,
 ):
-    """Test running a block with as many CLZ with different input as possible."""
+    """
+    Test running a block with as many CLZ with different input as
+    possible.
+    """
     max_code_size = fork.max_code_size()
 
     code_prefix = Op.JUMPDEST

tests/benchmark/test_worst_memory.py

@@ -82,10 +82,13 @@ def test_worst_calldatacopy(
     if min_gas > gas_benchmark_value:
         pytest.skip("Minimum gas required for calldata ({min_gas}) is greater than the gas limit")
 
-    # We create the contract that will be doing the CALLDATACOPY multiple times.
+    # We create the contract that will be doing the CALLDATACOPY multiple
+    # times.
     #
-    # If `non_zero_data` is True, we leverage CALLDATASIZE for the copy length. Otherwise, since we
-    # don't send zero data explicitly via calldata, PUSH the target size and use DUP1 to copy it.
+    # If `non_zero_data` is True, we leverage CALLDATASIZE for the copy
+    # length. Otherwise, since we
+    # don't send zero data explicitly via calldata, PUSH the target size and
+    # use DUP1 to copy it.
     setup = Bytecode() if non_zero_data or size == 0 else Op.PUSH3(size)
     src_dst = 0 if fixed_src_dst else Op.MOD(Op.GAS, 7)
     attack_block = Op.CALLDATACOPY(
@@ -101,8 +104,8 @@ def test_worst_calldatacopy(
     # If the origin is CALL, we need to create a contract that will call the
     # target contract with the calldata.
     if origin == CallDataOrigin.CALL:
-        # If `non_zero_data` is False we leverage just using zeroed memory. Otherwise, we
-        # copy the calldata received from the transaction.
+        # If `non_zero_data` is False we leverage just using zeroed memory.
+        # Otherwise, we copy the calldata received from the transaction.
         setup = (
             Op.CALLDATACOPY(Op.PUSH0, Op.PUSH0, Op.CALLDATASIZE) if non_zero_data else Bytecode()
         ) + Op.JUMPDEST
@@ -166,8 +169,10 @@ def test_worst_codecopy(
         attack_block, Bytecode(), Bytecode(), fork
     )
 
-    # The code generated above is not guaranteed to be of max_code_size, so we pad it since
-    # a test parameter targets CODECOPYing a contract with max code size. Padded bytecode values
+    # The code generated above is not guaranteed to be of max_code_size, so
+    # we pad it since
+    # a test parameter targets CODECOPYing a contract with max code size.
+    # Padded bytecode values
     # are not relevant.
     code += Op.INVALID * (max_code_size - len(code))
     assert len(code) == max_code_size, (
@@ -209,8 +214,10 @@ def test_worst_returndatacopy(
     fixed_dst: bool,
 ):
     """Test running a block filled with RETURNDATACOPY executions."""
-    # Create the contract that will RETURN the data that will be used for RETURNDATACOPY.
-    # Random-ish data is injected at different points in memory to avoid making the content
+    # Create the contract that will RETURN the data that will be used for
+    # RETURNDATACOPY.
+    # Random-ish data is injected at different points in memory to avoid
+    # making the content
     # predictable. If `size` is 0, this helper contract won't be used.
     code = (
         Op.MSTORE8(0, Op.GAS)
@@ -223,7 +230,8 @@ def test_worst_returndatacopy(
     returndata_gen = Op.STATICCALL(address=helper_contract) if size > 0 else Bytecode()
     dst = 0 if fixed_dst else Op.MOD(Op.GAS, 7)
 
-    # We create the contract that will be doing the RETURNDATACOPY multiple times.
+    # We create the contract that will be doing the RETURNDATACOPY multiple
+    # times.
     returndata_gen = Op.STATICCALL(address=helper_contract) if size > 0 else Bytecode()
     attack_block = Op.RETURNDATACOPY(dst, Op.PUSH0, Op.RETURNDATASIZE)
 
@@ -236,7 +244,8 @@ def test_worst_returndatacopy(
     # STATICCALL(address=helper_contract)
     # JUMP(#)
     # ```
-    # The goal is that once per (big) loop iteration, the helper contract is called to
+    # The goal is that once per (big) loop iteration, the helper contract is
+    # called to
     # generate fresh returndata to continue calling RETURNDATACOPY.
 
     benchmark_test(

tests/benchmark/test_worst_stateful_opcodes.py

@@ -140,7 +140,10 @@ def test_worst_address_state_warm(
     opcode: Op,
     absent_target: bool,
 ):
-    """Test running a block with as many stateful opcodes doing warm access for an account."""
+    """
+    Test running a block with as many stateful opcodes doing warm access
+    for an account.
+    """
     # Setup
     target_addr = Address(100_000)
     post = {}
@@ -374,7 +377,10 @@ def test_worst_storage_access_warm(
     gas_benchmark_value: int,
     env: Environment,
 ):
-    """Test running a block with as many warm storage slot accesses as possible."""
+    """
+    Test running a block with as many warm storage slot accesses as
+    possible.
+    """
     blocks = []
 
     # The target storage slot for the warm access is storage slot 0.