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_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.