precompiles: Add bls precompiles IDs

rodiazet · rodiazet · commit 239548363f85 · 2024-09-03T15:48:07.000+02:00
diff --git a/test/state/precompiles.cpp b/test/state/precompiles.cpp
@@ -40,6 +40,24 @@ inline constexpr int64_t cost_per_input_word(size_t input_size) noexcept
 {
     return BaseCost + WordCost * num_words(input_size);
 }
+
+int64_t bls_msm_cost(size_t k, int64_t multiplication_cost) noexcept
+{
+    assert(k > 0 && k < 128);
+
+    constexpr int64_t MULTIPLIER = 1000;
+    constexpr int16_t discount[128] = {1200, 888, 764, 641, 594, 547, 500, 453, 438, 423, 408, 394,
+        379, 364, 349, 334, 330, 326, 322, 318, 314, 310, 306, 302, 298, 294, 289, 285, 281, 277,
+        273, 269, 268, 266, 265, 263, 262, 260, 259, 257, 256, 254, 253, 251, 250, 248, 247, 245,
+        244, 242, 241, 239, 238, 236, 235, 233, 232, 231, 229, 228, 226, 225, 223, 222, 221, 220,
+        219, 219, 218, 217, 216, 216, 215, 214, 213, 213, 212, 211, 211, 210, 209, 208, 208, 207,
+        206, 205, 205, 204, 203, 202, 202, 201, 200, 199, 199, 198, 197, 196, 196, 195, 194, 193,
+        193, 192, 191, 191, 190, 189, 188, 188, 187, 186, 185, 185, 184, 183, 182, 182, 181, 180,
+        179, 179, 178, 177, 176, 176, 175, 174};
+
+    return (static_cast<int64_t>(k) * multiplication_cost * discount[k - 1]) / MULTIPLIER;
+}
+
 }  // namespace
 
 PrecompileAnalysis ecrecover_analyze(bytes_view /*input*/, evmc_revision /*rev*/) noexcept
@@ -153,6 +171,73 @@ PrecompileAnalysis point_evaluation_analyze(bytes_view, evmc_revision) noexcept
     return {POINT_EVALUATION_PRECOMPILE_GAS, 64};
 }
 
+PrecompileAnalysis bls12_g1add_analyze(bytes_view, evmc_revision) noexcept
+{
+    static constexpr auto BLS12_G1ADD_PRECOMPILE_GAS = 500;
+    return {BLS12_G1ADD_PRECOMPILE_GAS, 128};
+}
+
+PrecompileAnalysis bls12_g1mul_analyze(bytes_view, evmc_revision) noexcept
+{
+    static constexpr auto BLS12_G1MUL_PRECOMPILE_GAS = 12000;
+    return {BLS12_G1MUL_PRECOMPILE_GAS, 128};
+}
+
+PrecompileAnalysis bls12_g1msm_analyze(bytes_view input, evmc_revision) noexcept
+{
+    if (input.size() % 160 != 0)
+        return {GasCostMax, 0};
+
+    static constexpr auto BLS12_G1MUL_PRECOMPILE_GAS = 12000;
+    return {bls_msm_cost(input.size() / 160, BLS12_G1MUL_PRECOMPILE_GAS), 128};
+}
+
+PrecompileAnalysis bls12_g2add_analyze(bytes_view, evmc_revision) noexcept
+{
+    static constexpr auto BLS12_G2ADD_PRECOMPILE_GAS = 800;
+    return {BLS12_G2ADD_PRECOMPILE_GAS, 256};
+}
+
+PrecompileAnalysis bls12_g2mul_analyze(bytes_view, evmc_revision) noexcept
+{
+    static constexpr auto BLS12_G2MUL_PRECOMPILE_GAS = 45000;
+    return {BLS12_G2MUL_PRECOMPILE_GAS, 256};
+}
+
+PrecompileAnalysis bls12_g2msm_analyze(bytes_view input, evmc_revision) noexcept
+{
+    if (input.size() % 228 != 0)
+        return {GasCostMax, 0};
+
+    static constexpr auto BLS12_G2MUL_PRECOMPILE_GAS = 45000;
+    return {bls_msm_cost(input.size() / 228, BLS12_G2MUL_PRECOMPILE_GAS), 256};
+}
+
+PrecompileAnalysis bls12_pairing_check_analyze(bytes_view input, evmc_revision) noexcept
+{
+    if (input.size() % 384 != 0)
+        return {GasCostMax, 0};
+
+    static constexpr auto BLS12_PAIRING_CHECK_START_PRECOMPILE_GAS = 65000;
+    static constexpr auto BLS12_PAIRING_CHECK_PER_PAIR_PRECOMPILE_GAS = 43000;
+    return {
+        static_cast<int64_t>((input.size() / 384) * BLS12_PAIRING_CHECK_PER_PAIR_PRECOMPILE_GAS +
+                             BLS12_PAIRING_CHECK_START_PRECOMPILE_GAS),
+        32};
+}
+
+PrecompileAnalysis bls12_map_fp_to_g1_analyze(bytes_view, evmc_revision) noexcept
+{
+    static constexpr auto BLS12_FP_TO_G1_PRECOMPILE_GAS = 5500;
+    return {BLS12_FP_TO_G1_PRECOMPILE_GAS, 128};
+}
+
+PrecompileAnalysis bls12_map_fp2_to_g2_analyze(bytes_view, evmc_revision) noexcept
+{
+    static constexpr auto BLS12_FP2_TO_G2_PRECOMPILE_GAS = 75000;
+    return {BLS12_FP2_TO_G2_PRECOMPILE_GAS, 256};
+}
+
 ExecutionResult ecrecover_execute(const uint8_t* input, size_t input_size, uint8_t* output,
     [[maybe_unused]] size_t output_size) noexcept
 {
@@ -292,6 +377,51 @@ ExecutionResult blake2bf_execute(const uint8_t* input, [[maybe_unused]] size_t i
     return {EVMC_SUCCESS, sizeof(h)};
 }
 
+ExecutionResult bls12_g1add_execute(const uint8_t*, size_t, uint8_t*, size_t) noexcept
+{
+    return {EVMC_PRECOMPILE_FAILURE, 0};
+}
+
+ExecutionResult bls12_g1mul_execute(const uint8_t*, size_t, uint8_t*, size_t) noexcept
+{
+    return {EVMC_PRECOMPILE_FAILURE, 0};
+}
+
+ExecutionResult bls12_g1msm_execute(const uint8_t*, size_t, uint8_t*, size_t) noexcept
+{
+    return {EVMC_PRECOMPILE_FAILURE, 0};
+}
+
+ExecutionResult bls12_g2add_execute(const uint8_t*, size_t, uint8_t*, size_t) noexcept
+{
+    return {EVMC_PRECOMPILE_FAILURE, 0};
+}
+
+ExecutionResult bls12_g2mul_execute(const uint8_t*, size_t, uint8_t*, size_t) noexcept
+{
+    return {EVMC_PRECOMPILE_FAILURE, 0};
+}
+
+ExecutionResult bls12_g2msm_execute(const uint8_t*, size_t, uint8_t*, size_t) noexcept
+{
+    return {EVMC_PRECOMPILE_FAILURE, 0};
+}
+
+ExecutionResult bls12_pairing_check_execute(const uint8_t*, size_t, uint8_t*, size_t) noexcept
+{
+    return {EVMC_PRECOMPILE_FAILURE, 0};
+}
+
+ExecutionResult bls12_map_fp_to_g1_execute(const uint8_t*, size_t, uint8_t*, size_t) noexcept
+{
+    return {EVMC_PRECOMPILE_FAILURE, 0};
+}
+
+ExecutionResult bls12_map_fp2_to_g2_execute(const uint8_t*, size_t, uint8_t*, size_t) noexcept
+{
+    return {EVMC_PRECOMPILE_FAILURE, 0};
+}
+
 namespace
 {
 struct PrecompileTraits
@@ -301,19 +431,18 @@ struct PrecompileTraits
 };
 
 inline constexpr auto traits = []() noexcept {
-    std::array<PrecompileTraits, NumPrecompiles> tbl{{
-        {},  // undefined for 0
-        {ecrecover_analyze, ecrecover_execute},
-        {sha256_analyze, sha256_execute},
-        {ripemd160_analyze, ripemd160_execute},
-        {identity_analyze, identity_execute},
-        {expmod_analyze, expmod_stub},
-        {ecadd_analyze, ecadd_execute},
-        {ecmul_analyze, ecmul_execute},
-        {ecpairing_analyze, ecpairing_stub},
-        {blake2bf_analyze, blake2bf_execute},
-        {point_evaluation_analyze, point_evaluation_stub},
-    }};
+    std::array<PrecompileTraits, NumPrecompiles> tbl{{{},  // undefined for 0
+        {ecrecover_analyze, ecrecover_execute}, {sha256_analyze, sha256_execute},
+        {ripemd160_analyze, ripemd160_execute}, {identity_analyze, identity_execute},
+        {expmod_analyze, expmod_stub}, {ecadd_analyze, ecadd_execute},
+        {ecmul_analyze, ecmul_execute}, {ecpairing_analyze, ecpairing_stub},
+        {blake2bf_analyze, blake2bf_execute}, {point_evaluation_analyze, point_evaluation_stub},
+        {bls12_g1add_analyze, bls12_g1add_execute}, {bls12_g1mul_analyze, bls12_g1mul_execute},
+        {bls12_g1msm_analyze, bls12_g1msm_execute}, {bls12_g2add_analyze, bls12_g2add_execute},
+        {bls12_g2mul_analyze, bls12_g2mul_execute}, {bls12_g2msm_analyze, bls12_g2msm_execute},
+        {bls12_pairing_check_analyze, bls12_pairing_check_execute},
+        {bls12_map_fp_to_g1_analyze, bls12_map_fp_to_g1_execute},
+        {bls12_map_fp2_to_g2_analyze, bls12_map_fp2_to_g2_execute}}};
 #ifdef EVMONE_PRECOMPILES_SILKPRE
     // tbl[static_cast<size_t>(PrecompileId::ecrecover)].execute = silkpre_ecrecover_execute;
     // tbl[static_cast<size_t>(PrecompileId::sha256)].execute = silkpre_sha256_execute;
@@ -348,6 +477,9 @@ bool is_precompile(evmc_revision rev, const evmc::address& addr) noexcept
     if (rev < EVMC_CANCUN && id >= stdx::to_underlying(PrecompileId::since_cancun))
         return false;
 
+    if (rev < EVMC_PRAGUE && id >= stdx::to_underlying(PrecompileId::since_prague))
+        return false;
+
     return true;
 }
 
diff --git a/test/state/precompiles.hpp b/test/state/precompiles.hpp
@@ -22,11 +22,21 @@ enum class PrecompileId : uint8_t
     ecpairing = 0x08,
     blake2bf = 0x09,
     point_evaluation = 0x0a,
+    bls12_g1add = 0x0b,
+    bls12_g1mul = 0x0c,
+    bls12_g1msm = 0x0d,
+    bls12_g2add = 0x0e,
+    bls12_g2mul = 0x0f,
+    bls12_g2msm = 0x10,
+    bls12_pairing_check = 0x11,
+    bls12_map_fp_to_g1 = 0x12,
+    bls12_map_fp2_to_g2 = 0x13,
 
     since_byzantium = expmod,         ///< The first precompile introduced in Byzantium.
     since_istanbul = blake2bf,        ///< The first precompile introduced in Istanbul.
     since_cancun = point_evaluation,  ///< The first precompile introduced in Cancun.
-    latest = point_evaluation         ///< The latest introduced precompile (highest address).
+    since_prague = bls12_g1add,       ///< The first precompile introduced in Prague.
+    latest = bls12_map_fp2_to_g2      ///< The latest introduced precompile (highest address).
 };
 
 /// The total number of known precompiles ids, including 0.
diff --git a/test/state/precompiles_internal.hpp b/test/state/precompiles_internal.hpp
@@ -29,6 +29,16 @@ PrecompileAnalysis ecmul_analyze(evmc::bytes_view input, evmc_revision rev) noex
 PrecompileAnalysis ecpairing_analyze(evmc::bytes_view input, evmc_revision rev) noexcept;
 PrecompileAnalysis blake2bf_analyze(evmc::bytes_view input, evmc_revision rev) noexcept;
 PrecompileAnalysis point_evaluation_analyze(evmc::bytes_view input, evmc_revision rev) noexcept;
+PrecompileAnalysis bls12_g1add_analyze(evmc::bytes_view input, evmc_revision rev) noexcept;
+PrecompileAnalysis bls12_g1add_analyze(evmc::bytes_view input, evmc_revision) noexcept;
+PrecompileAnalysis bls12_g1mul_analyze(evmc::bytes_view input, evmc_revision) noexcept;
+PrecompileAnalysis bls12_g1msm_analyze(evmc::bytes_view input, evmc_revision) noexcept;
+PrecompileAnalysis bls12_g2add_analyze(evmc::bytes_view input, evmc_revision) noexcept;
+PrecompileAnalysis bls12_g2mul_analyze(evmc::bytes_view input, evmc_revision) noexcept;
+PrecompileAnalysis bls12_g2msm_analyze(evmc::bytes_view input, evmc_revision) noexcept;
+PrecompileAnalysis bls12_pairing_check_analyze(evmc::bytes_view input, evmc_revision) noexcept;
+PrecompileAnalysis bls12_map_fp_to_g1_analyze(evmc::bytes_view input, evmc_revision) noexcept;
+PrecompileAnalysis bls12_map_fp2_to_g2_analyze(evmc::bytes_view input, evmc_revision) noexcept;
 
 ExecutionResult ecrecover_execute(
     const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
@@ -44,4 +54,24 @@ ExecutionResult ecmul_execute(
     const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
 ExecutionResult blake2bf_execute(
     const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_g1add_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_g1add_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_g1mul_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_g1msm_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_g2add_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_g2mul_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_g2msm_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_pairing_check_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_map_fp_to_g1_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult bls12_map_fp2_to_g2_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
 }  // namespace evmone::state
diff --git a/test/unittests/state_precompiles_test.cpp b/test/unittests/state_precompiles_test.cpp
@@ -34,11 +34,21 @@ TEST(state_precompiles, is_precompile)
         // Cancun:
         EXPECT_EQ(is_precompile(rev, 0x0a_address), rev >= EVMC_CANCUN);
 
+        // Prague:
+        EXPECT_EQ(is_precompile(rev, 0x0b_address), rev >= EVMC_PRAGUE);
+        EXPECT_EQ(is_precompile(rev, 0x0c_address), rev >= EVMC_PRAGUE);
+        EXPECT_EQ(is_precompile(rev, 0x0d_address), rev >= EVMC_PRAGUE);
+        EXPECT_EQ(is_precompile(rev, 0x0e_address), rev >= EVMC_PRAGUE);
+        EXPECT_EQ(is_precompile(rev, 0x0f_address), rev >= EVMC_PRAGUE);
+        EXPECT_EQ(is_precompile(rev, 0x10_address), rev >= EVMC_PRAGUE);
+        EXPECT_EQ(is_precompile(rev, 0x11_address), rev >= EVMC_PRAGUE);
+        EXPECT_EQ(is_precompile(rev, 0x12_address), rev >= EVMC_PRAGUE);
+        EXPECT_EQ(is_precompile(rev, 0x13_address), rev >= EVMC_PRAGUE);
+
         // Future?
-        EXPECT_FALSE(is_precompile(rev, 0x0b_address));
-        EXPECT_FALSE(is_precompile(rev, 0x0c_address));
-        EXPECT_FALSE(is_precompile(rev, 0x0d_address));
-        EXPECT_FALSE(is_precompile(rev, 0x0e_address));
-        EXPECT_FALSE(is_precompile(rev, 0x0f_address));
+        EXPECT_FALSE(is_precompile(rev, 0x14_address));
+        EXPECT_FALSE(is_precompile(rev, 0x15_address));
+        EXPECT_FALSE(is_precompile(rev, 0x16_address));
+        EXPECT_FALSE(is_precompile(rev, 0x17_address));
     }
 }
