Test Point Evaluation Precompile

Documentation for test cases from tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py.

Generate fixtures for these test cases for Cancun with:

Cancun only:

fill -v tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py --fork=Cancun --evm-bin=/path/to/evm-tool-dev-version

For all forks up to and including Cancun:

fill -v tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py --until=Cancun --evm-bin=/path/to/evm-tool-dev-version

Tests point evaluation precompile for EIP-4844: Shard Blob Transactions

Test point evaluation precompile for EIP-4844: Shard Blob Transactions.

Adding a new test

Add a function that is named test_<test_name> and takes at least the following arguments:

• blockchain_test
• pre
• tx
• post

The following arguments need to be parametrized or the test will not be generated:

• versioned_hash
• kzg_commitment
• z
• y
• kzg_proof
• success

These values correspond to a single call of the precompile, and success refers to whether the call should succeed or fail.

All other pytest.fixture fixtures can be parametrized to generate new combinations and test cases.

test_valid_precompile_calls(blockchain_test, pre, tx, post)

Test valid sanity precompile calls that are expected to succeed.

• kzg_commitment and kzg_proof are set to values such that p(z)==0 for all values of z, hence y is tested to be zero, and call to be succesful.

Source code in tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py

@pytest.mark.parametrize(
    "z,y,kzg_commitment,kzg_proof,versioned_hash",
    [
        pytest.param(BLS_MODULUS - 1, 0, INF_POINT, INF_POINT, auto, id="in_bounds_z"),
    ],
)
@pytest.mark.parametrize("success", [True])
@pytest.mark.valid_from("Cancun")
def test_valid_precompile_calls(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Test valid sanity precompile calls that are expected to succeed.

    - `kzg_commitment` and `kzg_proof` are set to values such that `p(z)==0` for all values of `z`,
    hence `y` is tested to be zero, and call to be succesful.
    """
    blockchain_test(
        pre=pre,
        post=post,
        blocks=[Block(txs=[tx])],
    )

test_invalid_precompile_calls(blockchain_test, pre, tx, post)

Test invalid precompile calls:

• Out of bounds inputs z and y
• Correct proof, commitment, z and y, but incorrect lengths
• Null inputs
• Zero inputs
• Correct proof, commitment, z and y, but incorrect version versioned hash

Source code in tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py

@pytest.mark.parametrize(
    "z,y,kzg_commitment,kzg_proof,versioned_hash",
    [
        (BLS_MODULUS, 0, INF_POINT, INF_POINT, auto),
        (0, BLS_MODULUS, INF_POINT, INF_POINT, auto),
        (Z, 0, INF_POINT, INF_POINT[:-1], auto),
        (Z, 0, INF_POINT, INF_POINT[0:1], auto),
        (Z, 0, INF_POINT, INF_POINT + bytes([0]), auto),
        (Z, 0, INF_POINT, INF_POINT + bytes([0] * 1023), auto),
        (bytes(), bytes(), bytes(), bytes(), bytes()),
        (0, 0, 0, 0, 0),
        (0, 0, 0, 0, auto),
        (Z, 0, INF_POINT, INF_POINT, kzg_to_versioned_hash(0xC0 << 376, 0x00)),
        (Z, 0, INF_POINT, INF_POINT, kzg_to_versioned_hash(0xC0 << 376, 0x02)),
        (Z, 0, INF_POINT, INF_POINT, kzg_to_versioned_hash(0xC0 << 376, 0xFF)),
    ],
    ids=[
        "out_of_bounds_z",
        "out_of_bounds_y",
        "correct_proof_1_input_too_short",
        "correct_proof_1_input_too_short_2",
        "correct_proof_1_input_too_long",
        "correct_proof_1_input_extra_long",
        "null_inputs",
        "zeros_inputs",
        "zeros_inputs_correct_versioned_hash",
        "correct_proof_1_incorrect_versioned_hash_version_0x00",
        "correct_proof_1_incorrect_versioned_hash_version_0x02",
        "correct_proof_1_incorrect_versioned_hash_version_0xff",
    ],
)
@pytest.mark.parametrize("success", [False])
@pytest.mark.valid_from("Cancun")
def test_invalid_precompile_calls(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Test invalid precompile calls:

    - Out of bounds inputs `z` and `y`
    - Correct proof, commitment, z and y, but incorrect lengths
    - Null inputs
    - Zero inputs
    - Correct proof, commitment, z and y, but incorrect version versioned hash
    """
    blockchain_test(
        pre=pre,
        post=post,
        blocks=[Block(txs=[tx])],
    )

test_point_evaluation_precompile_external_vectors(blockchain_test, pre, tx, post)

Test precompile calls using external test vectors compiled from different sources:

• go_kzg_4844_verify_kzg_proof.json: test vectors from the go-kzg-4844 repository.

Source code in tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py

@pytest.mark.parametrize(
    "z,y,kzg_commitment,kzg_proof,success",
    all_external_vectors(),
)
@pytest.mark.parametrize("versioned_hash", [auto])
@pytest.mark.valid_from("Cancun")
def test_point_evaluation_precompile_external_vectors(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Test precompile calls using external test vectors compiled from different sources:

    - `go_kzg_4844_verify_kzg_proof.json`: test vectors from the
    [go-kzg-4844](https://github.com/crate-crypto/go-kzg-4844) repository.
    """
    blockchain_test(
        pre=pre,
        post=post,
        blocks=[Block(txs=[tx])],
    )

test_point_evaluation_precompile_calls(blockchain_test, pre, tx, post)

Test calling the Point Evaluation Precompile with different call types, gas and parameter configuration:

• Using CALL, DELEGATECALL, CALLCODE and STATICCALL.
• Using correct and incorrect proofs
• Using barely insufficient gas

Source code in tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py

@pytest.mark.parametrize(
    "call_gas,y,success",
    [
        (POINT_EVALUATION_PRECOMPILE_GAS, 0, True),
        (POINT_EVALUATION_PRECOMPILE_GAS, 1, False),
        (POINT_EVALUATION_PRECOMPILE_GAS - 1, 0, False),
    ],
    ids=["correct", "incorrect", "insufficient_gas"],
)
@pytest.mark.parametrize(
    "call_type",
    [
        Op.CALL,
        Op.DELEGATECALL,
        Op.CALLCODE,
        Op.STATICCALL,
    ],
)
@pytest.mark.parametrize(
    "z,kzg_commitment,kzg_proof,versioned_hash",
    [[Z, INF_POINT, INF_POINT, auto]],
    ids=[""],
)
@pytest.mark.valid_from("Cancun")
def test_point_evaluation_precompile_calls(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    tx: Transaction,
    post: Dict,
):
    """
    Test calling the Point Evaluation Precompile with different call types, gas
    and parameter configuration:

    - Using CALL, DELEGATECALL, CALLCODE and STATICCALL.
    - Using correct and incorrect proofs
    - Using barely insufficient gas
    """
    blockchain_test(
        pre=pre,
        post=post,
        blocks=[Block(txs=[tx])],
    )

test_point_evaluation_precompile_gas_tx_to(blockchain_test, precompile_input, call_gas, proof_correct)

Test calling the Point Evaluation Precompile directly as transaction entry point, and measure the gas consumption.

• Using gas_limit with exact necessary gas, insufficient gas and extra gas.
• Using correct and incorrect proofs

Source code in tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py

@pytest.mark.parametrize(
    "call_gas",
    [
        (POINT_EVALUATION_PRECOMPILE_GAS),
        (POINT_EVALUATION_PRECOMPILE_GAS + 1),
        (POINT_EVALUATION_PRECOMPILE_GAS - 1),
    ],
    ids=["exact_gas", "extra_gas", "insufficient_gas"],
)
@pytest.mark.parametrize(
    "z,y,kzg_commitment,kzg_proof,versioned_hash,proof_correct",
    [
        [Z, 0, INF_POINT, INF_POINT, auto, True],
        [Z, 1, INF_POINT, INF_POINT, auto, False],
    ],
    ids=["correct_proof", "incorrect_proof"],
)
@pytest.mark.valid_from("Cancun")
def test_point_evaluation_precompile_gas_tx_to(
    blockchain_test: BlockchainTestFiller,
    precompile_input: bytes,
    call_gas: int,
    proof_correct: bool,
):
    """
    Test calling the Point Evaluation Precompile directly as
    transaction entry point, and measure the gas consumption.

    - Using `gas_limit` with exact necessary gas, insufficient gas and extra gas.
    - Using correct and incorrect proofs
    """
    start_balance = 10**18
    pre = {
        TestAddress: Account(
            nonce=0,
            balance=start_balance,
        )
    }

    # Gas is appended the intrinsic gas cost of the transaction
    intrinsic_gas_cost = 21_000 + eip_2028_transaction_data_cost(precompile_input)

    # Consumed gas will only be the precompile gas if the proof is correct and
    # the call gas is sufficient.
    # Otherwise, the call gas will be consumed in full.
    consumed_gas = (
        POINT_EVALUATION_PRECOMPILE_GAS
        if call_gas >= POINT_EVALUATION_PRECOMPILE_GAS and proof_correct
        else call_gas
    ) + intrinsic_gas_cost

    fee_per_gas = 7

    tx = Transaction(
        ty=2,
        nonce=0,
        data=precompile_input,
        to=to_address(POINT_EVALUATION_PRECOMPILE_ADDRESS),
        value=0,
        gas_limit=call_gas + intrinsic_gas_cost,
        max_fee_per_gas=7,
        max_priority_fee_per_gas=0,
    )

    post = {
        TestAddress: Account(
            nonce=1,
            balance=start_balance - (consumed_gas * fee_per_gas),
        )
    }

    blockchain_test(
        pre=pre,
        post=post,
        blocks=[Block(txs=[tx])],
    )

test_point_evaluation_precompile_before_fork(blockchain_test, pre, tx)

Test calling the Point Evaluation Precompile before the appropriate fork.

Source code in tests/cancun/eip4844_blobs/test_point_evaluation_precompile.py

@pytest.mark.parametrize(
    "z,y,kzg_commitment,kzg_proof,versioned_hash",
    [[Z, 0, INF_POINT, INF_POINT, auto]],
    ids=["correct_proof"],
)
@pytest.mark.valid_at_transition_to("Cancun")
def test_point_evaluation_precompile_before_fork(
    blockchain_test: BlockchainTestFiller,
    pre: Dict,
    tx: Transaction,
):
    """
    Test calling the Point Evaluation Precompile before the appropriate fork.
    """
    precompile_caller_code = Op.SSTORE(
        Op.NUMBER,
        Op.CALL(
            Op.GAS,
            POINT_EVALUATION_PRECOMPILE_ADDRESS,
            1,  # Value
            0,  # Zero-length calldata
            0,
            0,  # Zero-length return
            0,
        ),
    )
    precompile_caller_address = to_address(0x100)

    pre = {
        TestAddress: Account(
            nonce=0,
            balance=0x10**18,
        ),
        precompile_caller_address: Account(
            nonce=0,
            code=precompile_caller_code,
            balance=0x10**18,
        ),
    }

    def tx_generator() -> Iterator[Transaction]:
        nonce = 0  # Initial value
        while True:
            yield tx.with_nonce(nonce)
            nonce = nonce + 1

    iter_tx = tx_generator()

    FORK_TIMESTAMP = 15_000
    PRE_FORK_BLOCK_RANGE = range(999, FORK_TIMESTAMP, 1_000)

    # Blocks before fork
    blocks = [Block(timestamp=t, txs=[next(iter_tx)]) for t in PRE_FORK_BLOCK_RANGE]
    # Block after fork
    blocks += [Block(timestamp=FORK_TIMESTAMP, txs=[next(iter_tx)])]

    post = {
        precompile_caller_address: Account(
            storage={b: 1 for b in range(1, len(PRE_FORK_BLOCK_RANGE) + 1)},
            # The tx in last block succeeds; storage 0 by default.
        ),
        to_address(POINT_EVALUATION_PRECOMPILE_ADDRESS): Account(
            balance=len(PRE_FORK_BLOCK_RANGE),
        ),
    }

    blockchain_test(
        tag="point_evaluation_precompile_before_fork",
        pre=pre,
        post=post,
        blocks=blocks,
    )