[Core Protocol] Precompile 0x0100 (RIP-7212) returns empty returndata in real tx, works via eth_call on OP Sepolia

[craterface77]

Did you check the documentation and specs?

• Yes

Was there anything unclear or missing?

I'm experimenting with precompiling P-256 (0x0100, as introduced by RIP-7212) on OP Sepolia and have encountered what appears to be a gap in the implementation.

Did you check for duplicate questions?

• Yes

Similar Questions or Issues Found

No response

Please select the type of request

• Bug Report
• Feature Request

Steps to Reproduce

1. Create a contract that call: address(0x100).staticcall(abi.encode(h, r, s, qx, qy)); and hadrcode h, r, s, qx, qy inside this contract
2. Try to call the function from this contract directly (got success)
3. Try to call this function via entrypoint userOP (entrypoint -> account -> validator with address(0x100).staticcall) <- it will fail and 0x100 return success, "0x" in responce

Expected vs. Actual Behaviour

The precompilation of 0x0100 must return its result both in eth_call and in the actual tx execution - otherwise it is impossible to safely use RIP-7212 in AA wallets or validator modules.

It looks like 0x0100 may not be connected to the tx execution path on the current OP Sepolia (even if precompilation is recognized during a dry run).
Maybe the op-geth release deployed on Sepolia does not fully enable RIP-7212 at runtime?
Or any other ideas. Help would be greatly appreciated

Software Versions

No response

Operating System

mac-os

Hardware Resources

No response

Configuration Files, Startup Flags & Environment Variables

No response

Error Messages / Logs

Direct call some_contract.validate:

Arguments
h
0x92b4e9f68a01a06f4ca4feef9fafe9b74f717c1c46b9f8fdf6e60fd6f2e4fdb0
r
0x1a1fd8c4cbbd528e97416003a4e4b8b1e939f764057dac2254c0e0bf305da480
s
0x6113eaa2af96c17271c1163cbd52be4c8c8b928b839b8a6edb5bd0371940d6c8
qx
0x513ef4fc9c45e1617933b345cc8e39482e3e665723c5d8cce9c1a249e499f161
qy
0x71a8e80e182b188e7a65064164e71c68f1c6d363fda7273b2b27b31a7736ea66
Success
true
Returndata:
0x0000000000000000000000000000000000000000000000000000000000000001

Call through entry point:

Arguments
h
0x92b4e9f68a01a06f4ca4feef9fafe9b74f717c1c46b9f8fdf6e60fd6f2e4fdb0
r
0x1a1fd8c4cbbd528e97416003a4e4b8b1e939f764057dac2254c0e0bf305da480
s
0x6113eaa2af96c17271c1163cbd52be4c8c8b928b839b8a6edb5bd0371940d6c8
qx
0x513ef4fc9c45e1617933b345cc8e39482e3e665723c5d8cce9c1a249e499f161
qy
0x71a8e80e182b188e7a65064164e71c68f1c6d363fda7273b2b27b31a7736ea66
Success
true
Returndata:
0x

Feature Description

I'm experimenting with precompiling P-256 (0x0100, as introduced by RIP-7212) on OP Sepolia and have encountered what appears to be a gap in the implementation.

Observed behavior:
• When I call a contract using staticcall(0x0100, ...) via eth_call, it returns the correct result (32 bytes, 0x...01).
• But when the same logic is executed inside a real transaction (eth_sendTransaction), the precompilation returns empty data (0x), even though the call succeeds (success == true).

• OP Sepolia network
• The smart contract does the following inside the validator module:

(bool success, bytes memory returndata) = address(0x100).staticcall(
abi.encode(h, r, s, qx, qy)
);

• It works fine when called via regular eth_call.
• It fails (returns 0x) when called inside tx (e.g. via EntryPoint.handleOps(...) → account → validator with 0x100.staticcall).

Validation
• The exact same call (with the same h, r, s, qx, qy) works in eth_call.
• The signature is valid (verified using off-chain crypto libraries).

Purpose and Benefits

No response

Relevant Context or Examples

No response

[jsvisa]

Since I don't quite understand RIP-7212, could you please provide a reproduce test script, whether in node.js, or python or golang

[craterface77]

Hi, thanks for your answer! I already figured out how to work with this correctly, so I'm attaching the code for the guys who might also encounter difficulties:

1. I created the simple contract that will call 0x100:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

contract MockPrecompile {
    function tryVerifyNative() external view returns (bool, bytes memory) {
        bytes32 h = 0x92b4e9f68a01a06f4ca4feef9fafe9b74f717c1c46b9f8fdf6e60fd6f2e4fdb0;
        bytes32 r = 0x1a1fd8c4cbbd528e97416003a4e4b8b1e939f764057dac2254c0e0bf305da480;
        bytes32 s = 0x6113eaa2af96c17271c1163cbd52be4c8c8b928b839b8a6edb5bd0371940d6c8;
        bytes32 qx = 0x513ef4fc9c45e1617933b345cc8e39482e3e665723c5d8cce9c1a249e499f161;
        bytes32 qy = 0x71a8e80e182b188e7a65064164e71c68f1c6d363fda7273b2b27b31a7736ea66;

        (bool success, bytes memory returndata) = address(0x100).staticcall(abi.encode(h, r, s, qx, qy));
        return (success, returndata);
    }
}

2. I create the contract that will call the MockPrecompile create nested call (inside I explained what the right way to call):

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

interface IPrecompile {
    function tryVerifyNative() external view returns (bool, bytes memory);
}

contract MockCaller {
    address public precompileContractAddress;

    bool public precompileSuccessNotView;
    bytes public precompileReturndataNotView;

    bool public precompileSuccessStaticcall;
    bytes public precompileReturndataStaticcall;

    constructor(address _precompileAddress) {
        precompileContractAddress = _precompileAddress;
    }

    /*
        The issue is here! When you call the precompile like regular eth_call (transaction) with some update state
        it will revert empty precompile answer ("0x").
        And if you call it with view function (call) it will return the full answer (0x0..0 OR 0x0...1).
    */
    function callNotViewPrecompile() external returns (bool, bytes memory) {
        (bool success, bytes memory returndata) = IPrecompile(precompileContractAddress).tryVerifyNative();

        precompileSuccessNotView = success;
        precompileReturndataNotView = returndata;

        return (success, returndata);
    }

    /*
        This is the correct way to call the precompile. It will return the full answer (0x0..0 OR 0x0...1).
        The issue is that the precompile will revert with empty answer ("0x") if you call it with some update state.
        So you need to call it with view function (call) to get the full answer.
    */
    function callViewPrecompile() external view returns (bool, bytes memory) {
        (bool success, bytes memory returndata) = IPrecompile(precompileContractAddress).tryVerifyNative();
        return (success, returndata);
    }

    /*
        This is the correct way to call the precompile if you have no ability to make fully view function.
        It will return the full answer (0x0..0 OR 0x0...1).
    */
    function callStaticcallPrecompile() external returns (bool, bytes memory) {
        (bool ok, bytes memory full) =
            precompileContractAddress.staticcall(abi.encodeWithSelector(IPrecompile.tryVerifyNative.selector));
        require(ok, "staticcall failed");

        (bool success, bytes memory returndata) = abi.decode(full, (bool, bytes));

        precompileSuccessStaticcall = success;
        precompileReturndataStaticcall = returndata;

        return (success, returndata);
    }
}

The tests that I used:

import { ethers } from "hardhat";
import { expect } from "chai";

let mockPrecompile: any;
let mockCaller: any;
let mockPrecompileAddress: string;

describe("Mock Precompile Test", function () {
  before(async function () {
    const MockPrecompile = await ethers.getContractFactory("MockPrecompile");
    mockPrecompile = await MockPrecompile.deploy();
    await mockPrecompile.waitForDeployment();

    mockPrecompileAddress = await mockPrecompile.getAddress();

    const MockCaller = await ethers.getContractFactory("MockCaller");
    mockCaller = await MockCaller.deploy(mockPrecompileAddress);
    await mockCaller.waitForDeployment();
  });
  it("should return the 0x0..1 with direct call", async function () {
    const result = await mockPrecompile.tryVerifyNative();
    expect(result[0]).to.be.true;
    expect(result[1]).to.equal(
      "0x0000000000000000000000000000000000000000000000000000000000000001"
    );
  });

  it("should revert on invalid output (0x) when call through the not view function", async function () {
    const tx = await mockCaller.callNotViewPrecompile();
    await tx.wait();
    const success = await mockCaller.precompileSuccessNotView();
    const returndata = await mockCaller.precompileReturndataNotView();
    console.log("success", success);
    console.log("returndata", returndata);
  });

  // use callStaticcallPrecompile
  it("should return the 0x0..1 when call through the not view function but with Staticcall", async function () {
    const tx = await mockCaller.callStaticcallPrecompile();
    await tx.wait();
    const success = await mockCaller.precompileSuccessStaticcall();
    const returndata = await mockCaller.precompileReturndataStaticcall();
    console.log("success", success);
    console.log("returndata", returndata);
  });

  it("should return the 0x0..1 when call through the view function", async function () {
    const result = await mockCaller.callViewPrecompile();
    expect(result[0]).to.be.true;
    expect(result[1]).to.equal(
      "0x0000000000000000000000000000000000000000000000000000000000000001"
    );
  });
});

TLDR; You need use staticcall always when you try to iterate with 0x100 address, so the right methods would be
callViewPrecompile and callStaticcallPrecompile