diff --git a/Makefile b/Makefile index 9379357f2..a1dc65e02 100644 --- a/Makefile +++ b/Makefile @@ -23,6 +23,49 @@ BLOCKDATA_CANCUN := blockdata/cancun BLOCKHASH := blockhash +BLS_CANCUN := $(wildcard blsdata/cancun/*.lisp) \ + $(wildcard blsdata/cancun/generalities/cancun_restriction.lisp) \ + $(wildcard blsdata/cancun/generalities/constancy_conditions.lisp) \ + $(wildcard blsdata/cancun/generalities/constraining_address_sum.lisp) \ + $(wildcard blsdata/cancun/generalities/constraining_flag_sum.lisp) \ + $(wildcard blsdata/cancun/generalities/constraints_for_bls_stamp.lisp) \ + $(wildcard blsdata/cancun/generalities/constraints_for_ct.lisp) \ + $(wildcard blsdata/cancun/generalities/id_increment_constraints.lisp) \ + $(wildcard blsdata/cancun/generalities/legal_transition_constraints.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_acc_inputs.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_ct_max.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_index_max.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_index.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_is_first_input_and_is_second_input.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_phase.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_total_size.lisp) \ + $(wildcard blsdata/cancun/generalities/shorthands.lisp) \ + $(wildcard blsdata/cancun/lookups/*.lisp) \ + $(wildcard blsdata/cancun/specialized_constraints/*.lisp) \ + $(wildcard blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/*.lisp) \ + $(wildcard blsdata/cancun/utilities/*.lisp) \ + +BLS_PRAGUE := $(wildcard blsdata/cancun/*.lisp) \ + $(wildcard blsdata/cancun/generalities/constancy_conditions.lisp) \ + $(wildcard blsdata/cancun/generalities/constraining_address_sum.lisp) \ + $(wildcard blsdata/cancun/generalities/constraining_flag_sum.lisp) \ + $(wildcard blsdata/cancun/generalities/constraints_for_bls_stamp.lisp) \ + $(wildcard blsdata/cancun/generalities/constraints_for_ct.lisp) \ + $(wildcard blsdata/cancun/generalities/id_increment_constraints.lisp) \ + $(wildcard blsdata/cancun/generalities/legal_transition_constraints.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_acc_inputs.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_ct_max.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_index_max.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_index.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_is_first_input_and_is_second_input.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_phase.lisp) \ + $(wildcard blsdata/cancun/generalities/setting_total_size.lisp) \ + $(wildcard blsdata/cancun/generalities/shorthands.lisp) \ + $(wildcard blsdata/cancun/lookups/*.lisp) \ + $(wildcard blsdata/cancun/specialized_constraints/*.lisp) \ + $(wildcard blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/*.lisp) \ + $(wildcard blsdata/cancun/utilities/*.lisp) \ + CONSTANTS := constants/constants.lisp CONSTANTS_LONDON := constants/london/constants.lisp @@ -67,7 +110,30 @@ OOB_LONDON := oob/london OOB_SHANGHAI := oob/shanghai -OOB_CANCUN := oob/cancun +OOB_CANCUN := $(wildcard oob/cancun/lookups/*.lisp) \ + $(wildcard oob/cancun/opcodes/*.lisp) \ + $(wildcard oob/cancun/precompiles/*.lisp) \ + $(wildcard oob/cancun/binarities.lisp) \ + $(wildcard oob/cancun/cancun_restriction.lisp) \ + $(wildcard oob/cancun/columns.lisp) \ + $(wildcard oob/cancun/constancies.lisp) \ + $(wildcard oob/cancun/constants.lisp) \ + $(wildcard oob/cancun/decoding.lisp) \ + $(wildcard oob/cancun/heartbeat.lisp) \ + $(wildcard oob/cancun/shorthands.lisp) \ + $(wildcard oob/cancun/specialized.lisp) \ + +OOB_PRAGUE := $(wildcard oob/cancun/lookups/*.lisp) \ + $(wildcard oob/cancun/opcodes/*.lisp) \ + $(wildcard oob/cancun/precompiles/*.lisp) \ + $(wildcard oob/cancun/binarities.lisp) \ + $(wildcard oob/cancun/columns.lisp) \ + $(wildcard oob/cancun/constancies.lisp) \ + $(wildcard oob/cancun/constants.lisp) \ + $(wildcard oob/cancun/decoding.lisp) \ + $(wildcard oob/cancun/heartbeat.lisp) \ + $(wildcard oob/cancun/shorthands.lisp) \ + $(wildcard oob/cancun/specialized.lisp) \ RLP_ADDR := rlpaddr @@ -93,9 +159,12 @@ TABLES_LONDON := reftables/*.lisp \ reftables/london/inst_decoder.lisp TABLES_CANCUN := reftables/*.lisp \ + reftables/cancun/bls_reftable.lisp \ reftables/cancun/inst_decoder.lisp \ reftables/cancun/power.lisp +# reftables/cancun/bls_reftable.lisp is only used in PRAGUE, but adding it in CANCUN already allows to do not duplicate OOB + TRM := trm TXN_DATA_LONDON := txndata/london @@ -174,6 +243,7 @@ ZKEVM_MODULES_CANCUN := ${ZKEVM_MODULES_COMMON} \ ${CONSTANTS_CANCUN} \ ${TABLES_CANCUN} \ ${BLOCKDATA_CANCUN} \ + ${BLS_CANCUN} \ ${HUB_CANCUN} \ ${LOG_INFO_CANCUN} \ ${MMIO_CANCUN} \ @@ -187,11 +257,12 @@ ZKEVM_MODULES_PRAGUE := ${ZKEVM_MODULES_COMMON} \ ${CONSTANTS_PRAGUE} \ ${TABLES_CANCUN} \ ${BLOCKDATA_CANCUN} \ + ${BLS_PRAGUE} \ ${HUB_CANCUN} \ ${LOG_INFO_CANCUN} \ ${MMIO_CANCUN} \ ${MXP_CANCUN} \ - ${OOB_CANCUN} \ + ${OOB_PRAGUE} \ ${RLP_TXN_CANCUN} \ ${RLP_UTILS_CANCUN} \ ${TXN_DATA_CANCUN} diff --git a/blsdata/cancun/circuit_selectors.lisp b/blsdata/cancun/circuit_selectors.lisp new file mode 100644 index 000000000..5aec3bba0 --- /dev/null +++ b/blsdata/cancun/circuit_selectors.lisp @@ -0,0 +1,67 @@ +(module blsdata) + +(defun (cs_G1MT_for_g1_msm) + (* DATA_BLS_G1_MSM_FLAG IS_FIRST_INPUT MEXT_BIT)) + +(defun (cs_G2MT_for_g2_msm) + (* DATA_BLS_G2_MSM_FLAG IS_FIRST_INPUT MEXT_BIT)) + +(defun (cs_G1MT_for_pairing_malformed) + (* DATA_BLS_PAIRING_CHECK_FLAG IS_FIRST_INPUT MEXT_BIT)) + +(defun (cs_G2MT_for_pairing_malformed) + (* DATA_BLS_PAIRING_CHECK_FLAG IS_SECOND_INPUT MEXT_BIT)) + +(defun (cs_G1MT_for_pairing_wellformed) + (* DATA_BLS_PAIRING_CHECK_FLAG IS_FIRST_INPUT (- 1 NONTRIVIAL_POP_BIT) (- 1 IS_INFINITY) (wellformed_data))) + +(defun (cs_G2MT_for_pairing_wellformed) + (* DATA_BLS_PAIRING_CHECK_FLAG IS_SECOND_INPUT (- 1 NONTRIVIAL_POP_BIT) (- 1 IS_INFINITY) (wellformed_data))) + +(defun (is_nontrivial_pairing_data_or_result) + (+ (* DATA_BLS_PAIRING_CHECK_FLAG NONTRIVIAL_POP_BIT) RSLT_BLS_PAIRING_CHECK_FLAG)) + +;; Circuit selector column definitions + +(defcomputedcolumn (CIRCUIT_SELECTOR_C1_MEMBERSHIP :binary@prove) + (* MEXT_BIT DATA_BLS_G1_ADD_FLAG)) + +(defcomputedcolumn (CIRCUIT_SELECTOR_C2_MEMBERSHIP :binary@prove) + (* MEXT_BIT DATA_BLS_G2_MSM_FLAG)) + +(defcomputedcolumn (CIRCUIT_SELECTOR_G1_MEMBERSHIP :binary@prove) + (+ (cs_G1MT_for_g1_msm) + (cs_G1MT_for_pairing_malformed) + (cs_G1MT_for_pairing_wellformed))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_G2_MEMBERSHIP :binary@prove) + (+ (cs_G2MT_for_g2_msm) + (cs_G2MT_for_pairing_malformed) + (cs_G2MT_for_pairing_wellformed))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_POINT_EVALUATION :binary@prove) + (* WNON (is_point_evaluation))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_POINT_EVALUATION_FAILURE :binary@prove) + (* MEXT (is_point_evaluation))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_BLS_G1_ADD :binary@prove) + (* WNON (is_g1_add))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_BLS_G1_MSM :binary@prove) + (* WNON (is_g1_msm))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_BLS_G2_ADD :binary@prove) + (* WNON (is_g2_add))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_BLS_G2_MSM :binary@prove) + (* WNON (is_g2_msm))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_BLS_PAIRING_CHECK :binary@prove) + (* WNON (is_nontrivial_pairing_data_or_result))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_BLS_MAP_FP_TO_G1 :binary@prove) + (* WNON (is_map_fp_to_g1))) + +(defcomputedcolumn (CIRCUIT_SELECTOR_BLS_MAP_FP2_TO_G2 :binary@prove) + (* WNON (is_map_fp2_to_g2))) \ No newline at end of file diff --git a/blsdata/cancun/columns.lisp b/blsdata/cancun/columns.lisp new file mode 100644 index 000000000..62b830682 --- /dev/null +++ b/blsdata/cancun/columns.lisp @@ -0,0 +1,90 @@ +(module blsdata) + +(defcolumns + (STAMP :i32) + (ID :i32) + (TOTAL_SIZE :i16) + (INDEX :i16) + (INDEX_MAX :i16) + (LIMB :i128) + (PHASE :i16) + (SUCCESS_BIT :binary@prove) + + (CT :i4) + (CT_MAX :i4) + + (DATA_POINT_EVALUATION_FLAG :binary@prove) + (DATA_BLS_G1_ADD_FLAG :binary@prove) + (DATA_BLS_G1_MSM_FLAG :binary@prove) + (DATA_BLS_G2_ADD_FLAG :binary@prove) + (DATA_BLS_G2_MSM_FLAG :binary@prove) + (DATA_BLS_PAIRING_CHECK_FLAG :binary@prove) + (DATA_BLS_MAP_FP_TO_G1_FLAG :binary@prove) + (DATA_BLS_MAP_FP2_TO_G2_FLAG :binary@prove) + + (RSLT_POINT_EVALUATION_FLAG :binary@prove) + (RSLT_BLS_G1_ADD_FLAG :binary@prove) + (RSLT_BLS_G1_MSM_FLAG :binary@prove) + (RSLT_BLS_G2_ADD_FLAG :binary@prove) + (RSLT_BLS_G2_MSM_FLAG :binary@prove) + (RSLT_BLS_PAIRING_CHECK_FLAG :binary@prove) + (RSLT_BLS_MAP_FP_TO_G1_FLAG :binary@prove) + (RSLT_BLS_MAP_FP2_TO_G2_FLAG :binary@prove) + + (ACC_INPUTS :i16) + (BYTE_DELTA :byte@prove) + + (MALFORMED_DATA_INTERNAL_BIT :binary@prove) + (MALFORMED_DATA_INTERNAL_ACC :binary@prove) + (MALFORMED_DATA_INTERNAL_ACC_TOT :binary@prove) + (MALFORMED_DATA_EXTERNAL_BIT :binary@prove) + (MALFORMED_DATA_EXTERNAL_ACC :binary@prove) + (MALFORMED_DATA_EXTERNAL_ACC_TOT :binary@prove) + (WELLFORMED_DATA_TRIVIAL :binary@prove) + (WELLFORMED_DATA_NONTRIVIAL :binary@prove) + + (IS_FIRST_INPUT :binary@prove) + (IS_SECOND_INPUT :binary@prove) + (IS_INFINITY :binary@prove) + (NONTRIVIAL_PAIR_OF_POINTS_BIT :binary@prove) + (NONTRIVIAL_PAIR_OF_POINTS_ACC :binary@prove) + + ;; Circuit selector columns are defined using defcomputedcolumn in circuit_selectors.lisp + + (WCP_FLAG :binary@prove) + (WCP_ARG1_HI :i128) + (WCP_ARG1_LO :i128) + (WCP_ARG2_HI :i128) + (WCP_ARG2_LO :i128) + (WCP_RES :binary) + (WCP_INST :byte :display :opcode) +) + +;; aliases +(defalias + MINT_BIT MALFORMED_DATA_INTERNAL_BIT + MINT_ACC MALFORMED_DATA_INTERNAL_ACC + MINT MALFORMED_DATA_INTERNAL_ACC_TOT + MEXT_BIT MALFORMED_DATA_EXTERNAL_BIT + MEXT_ACC MALFORMED_DATA_EXTERNAL_ACC + MEXT MALFORMED_DATA_EXTERNAL_ACC_TOT + WTRV WELLFORMED_DATA_TRIVIAL + WNON WELLFORMED_DATA_NONTRIVIAL + NONTRIVIAL_POP_BIT NONTRIVIAL_PAIR_OF_POINTS_BIT + NONTRIVIAL_POP_ACC NONTRIVIAL_PAIR_OF_POINTS_ACC + CS_POINT_EVALUATION CIRCUIT_SELECTOR_POINT_EVALUATION + CS_POINT_EVALUATION_FAILURE CIRCUIT_SELECTOR_POINT_EVALUATION_FAILURE + CS_C1_MEMBERSHIP CIRCUIT_SELECTOR_C1_MEMBERSHIP + CS_G1_MEMBERSHIP CIRCUIT_SELECTOR_G1_MEMBERSHIP + CS_C2_MEMBERSHIP CIRCUIT_SELECTOR_C2_MEMBERSHIP + CS_G2_MEMBERSHIP CIRCUIT_SELECTOR_G2_MEMBERSHIP + CS_BLS_PAIRING_CHECK CIRCUIT_SELECTOR_BLS_PAIRING_CHECK + CS_BLS_G1_ADD CIRCUIT_SELECTOR_BLS_G1_ADD + CS_BLS_G2_ADD CIRCUIT_SELECTOR_BLS_G2_ADD + CS_BLS_G1_MSM CIRCUIT_SELECTOR_BLS_G1_MSM + CS_BLS_G2_MSM CIRCUIT_SELECTOR_BLS_G2_MSM + CS_BLS_MAP_FP_TO_G1 CIRCUIT_SELECTOR_BLS_MAP_FP_TO_G1 + CS_BLS_MAP_FP2_TO_G2 CIRCUIT_SELECTOR_BLS_MAP_FP2_TO_G2 +) + + diff --git a/blsdata/cancun/constants.lisp b/blsdata/cancun/constants.lisp new file mode 100644 index 000000000..e82250277 --- /dev/null +++ b/blsdata/cancun/constants.lisp @@ -0,0 +1,36 @@ +(module blsdata) + +(defconst + POINT_EVALUATION_PRIME_HI 0x73eda753299d7d483339d80809a1d805 + POINT_EVALUATION_PRIME_LO 0x53BDA402FFFE5BFEFFFFFFFF00000001 + BLS_PRIME_3 0x00000000000000000000000000000000 + BLS_PRIME_2 0x1a0111ea397fe69a4b1ba7b6434bacd7 + BLS_PRIME_1 0x64774b84f38512bf6730d2a0f6b0f624 + BLS_PRIME_0 0x1eabfffeb153ffffb9feffffffffaaab + + INDEX_MAX_DATA_POINT_EVALUATION 11 + INDEX_MAX_RSLT_POINT_EVALUATION 3 + INDEX_MAX_DATA_G1_ADD 15 + INDEX_MAX_RSLT_G1_ADD 7 + INDEX_MAX_DATA_G1_MSM_MIN 9 + INDEX_MAX_RSLT_G1_MSM 7 + INDEX_MAX_DATA_G2_ADD 31 + INDEX_MAX_RSLT_G2_ADD 15 + INDEX_MAX_DATA_G2_MSM_MIN 17 + INDEX_MAX_RSLT_G2_MSM 15 + INDEX_MAX_DATA_PAIRING_CHECK_MIN 23 + INDEX_MAX_RSLT_PAIRING_CHECK 1 + INDEX_MAX_DATA_MAP_FP_TO_G1 3 + INDEX_MAX_RSLT_MAP_FP_TO_G1 7 + INDEX_MAX_DATA_MAP_FP2_TO_G2 7 + INDEX_MAX_RSLT_MAP_FP2_TO_G2 15 + + CT_MAX_POINT_EVALUATION 11 + CT_MAX_SMALL_POINT 7 + CT_MAX_LARGE_POINT 15 + CT_MAX_SCALAR 1 + CT_MAX_MAP_FP_TO_G1 3 + CT_MAX_MAP_FP2_TO_G2 7 +) + + diff --git a/blsdata/cancun/generalities/cancun_restriction.lisp b/blsdata/cancun/generalities/cancun_restriction.lisp new file mode 100644 index 000000000..0f1334ed9 --- /dev/null +++ b/blsdata/cancun/generalities/cancun_restriction.lisp @@ -0,0 +1,4 @@ +(module blsdata) + +(defconstraint cancun-restriction () + (eq! (flag_sum) (is_point_evaluation))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/constancy_conditions.lisp b/blsdata/cancun/generalities/constancy_conditions.lisp new file mode 100644 index 000000000..4963a9fbc --- /dev/null +++ b/blsdata/cancun/generalities/constancy_conditions.lisp @@ -0,0 +1,24 @@ +(module blsdata) + +(defconstraint stamp-constancy () + (begin (stamp-constancy STAMP ID) + (stamp-constancy STAMP SUCCESS_BIT) + (stamp-constancy STAMP MINT) + (stamp-constancy STAMP MEXT) + (stamp-constancy STAMP WTRV) + (stamp-constancy STAMP WNON))) + +(defconstraint counter-constancy () + (begin (counter-constancy INDEX PHASE) ;; NOTE: PHASE and INDEX_MAX are said to be index-constant + (counter-constancy INDEX INDEX_MAX) + (counter-constancy CT CT_MAX) + (counter-constancy CT IS_INFINITY) + (counter-constancy CT ACC_INPUTS) + (counter-constancy CT NONTRIVIAL_POP_ACC) + (counter-constancy CT MEXT_BIT) + (counter-constancy CT MEXT_ACC))) + +(defconstraint pair-of-inputs-constancy () + (if-not-zero ACC_INPUTS + (if (will-remain-constant! ACC_INPUTS) + (will-remain-constant! NONTRIVIAL_POP_BIT)))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/constraining_address_sum.lisp b/blsdata/cancun/generalities/constraining_address_sum.lisp new file mode 100644 index 000000000..0cbcc23e5 --- /dev/null +++ b/blsdata/cancun/generalities/constraining_address_sum.lisp @@ -0,0 +1,14 @@ +(module blsdata) + +(defun (address_sum) + (+ (* 10 (is_point_evaluation)) + (* 11 (is_g1_add)) + (* 12 (is_g1_msm)) + (* 13 (is_g2_add)) + (* 14 (is_g2_msm)) + (* 15 (is_pairing_check)) + (* 16 (is_map_fp_to_g1)) + (* 17 (is_map_fp2_to_g2)))) + +(defconstraint stamp-constancy () + (stamp-constancy STAMP (address_sum))) diff --git a/blsdata/cancun/generalities/constraining_flag_sum.lisp b/blsdata/cancun/generalities/constraining_flag_sum.lisp new file mode 100644 index 000000000..41725071f --- /dev/null +++ b/blsdata/cancun/generalities/constraining_flag_sum.lisp @@ -0,0 +1,47 @@ +(module blsdata) + +(defun (is_point_evaluation) + (+ DATA_POINT_EVALUATION_FLAG RSLT_POINT_EVALUATION_FLAG)) + +(defun (is_g1_add) + (+ DATA_BLS_G1_ADD_FLAG RSLT_BLS_G1_ADD_FLAG)) + +(defun (is_g1_msm) + (+ DATA_BLS_G1_MSM_FLAG RSLT_BLS_G1_MSM_FLAG)) + +(defun (is_g2_add) + (+ DATA_BLS_G2_ADD_FLAG RSLT_BLS_G2_ADD_FLAG)) + +(defun (is_g2_msm) + (+ DATA_BLS_G2_MSM_FLAG RSLT_BLS_G2_MSM_FLAG)) + +(defun (is_pairing_check) + (+ DATA_BLS_PAIRING_CHECK_FLAG RSLT_BLS_PAIRING_CHECK_FLAG)) + +(defun (is_map_fp_to_g1) + (+ DATA_BLS_MAP_FP_TO_G1_FLAG RSLT_BLS_MAP_FP_TO_G1_FLAG)) + +(defun (is_map_fp2_to_g2) + (+ DATA_BLS_MAP_FP2_TO_G2_FLAG RSLT_BLS_MAP_FP2_TO_G2_FLAG)) + +(defun (flag_sum) + (+ (is_point_evaluation) + (is_g1_add) + (is_g1_msm) + (is_g2_add) + (is_g2_msm) + (is_pairing_check) + (is_map_fp_to_g1) + (is_map_fp2_to_g2))) + +(defconstraint first-row-sanity-check (:domain {0}) + (debug (vanishes! (flag_sum)))) + +(defconstraint non-decreasing-sanity-check () + (debug (if-not-zero (flag_sum) (next (eq! (flag_sum) 1))))) + +(defconstraint flag-sum-when-stamp-is-zero () + (if-zero STAMP (vanishes! (flag_sum)))) + +(defconstraint flag-sum-when-stamp-is-not-zero () + (if-not-zero STAMP (eq! (flag_sum) 1))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/constraints_for_bls_stamp.lisp b/blsdata/cancun/generalities/constraints_for_bls_stamp.lisp new file mode 100644 index 000000000..064cccbf8 --- /dev/null +++ b/blsdata/cancun/generalities/constraints_for_bls_stamp.lisp @@ -0,0 +1,11 @@ +(module blsdata) + +(defconstraint first-row (:domain {0}) + (vanishes! STAMP)) + +(defconstraint stamp-increment-sanity-check () + (begin + (debug (or! (will-remain-constant! STAMP) (will-inc! STAMP 1))))) ;; implied by the constraint below + +(defconstraint stamp-increment () + (eq! (next STAMP) (+ STAMP (transition_to_data)))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/constraints_for_ct.lisp b/blsdata/cancun/generalities/constraints_for_ct.lisp new file mode 100644 index 000000000..140dfd096 --- /dev/null +++ b/blsdata/cancun/generalities/constraints_for_ct.lisp @@ -0,0 +1,12 @@ +(module blsdata) + +(defconstraint vanishing-values () + (if-zero (flag_sum) + (begin (vanishes! CT_MAX) + (vanishes! CT) + (debug (vanishes! (next CT)))))) + +(defconstraint ct-increment () + (if-eq-else CT CT_MAX + (vanishes! (next CT)) + (eq! (next CT) (+ 1 CT)))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/id_increment_constraints.lisp b/blsdata/cancun/generalities/id_increment_constraints.lisp new file mode 100644 index 000000000..ca8ce0ea7 --- /dev/null +++ b/blsdata/cancun/generalities/id_increment_constraints.lisp @@ -0,0 +1,11 @@ +(module blsdata) + +(defconstraint id-increment () + (if-not-zero (- (next STAMP) STAMP) + (eq! (next ID) + (+ ID + 1 + (+ (* 256 256 256 (next BYTE_DELTA)) + (* 256 256 (shift BYTE_DELTA 2)) + (* 256 (shift BYTE_DELTA 3)) + (shift BYTE_DELTA 4)))))) diff --git a/blsdata/cancun/generalities/legal_transition_constraints.lisp b/blsdata/cancun/generalities/legal_transition_constraints.lisp new file mode 100644 index 000000000..5fbc56787 --- /dev/null +++ b/blsdata/cancun/generalities/legal_transition_constraints.lisp @@ -0,0 +1,38 @@ +(module blsdata) + +(defun (same_data_to_data) + (+ (* DATA_POINT_EVALUATION_FLAG (next DATA_POINT_EVALUATION_FLAG)) + (* DATA_BLS_G1_ADD_FLAG (next DATA_BLS_G1_ADD_FLAG)) + (* DATA_BLS_G1_MSM_FLAG (next DATA_BLS_G1_MSM_FLAG)) + (* DATA_BLS_G2_ADD_FLAG (next DATA_BLS_G2_ADD_FLAG)) + (* DATA_BLS_G2_MSM_FLAG (next DATA_BLS_G2_MSM_FLAG)) + (* DATA_BLS_PAIRING_CHECK_FLAG (next DATA_BLS_PAIRING_CHECK_FLAG)) + (* DATA_BLS_MAP_FP_TO_G1_FLAG (next DATA_BLS_MAP_FP_TO_G1_FLAG)) + (* DATA_BLS_MAP_FP2_TO_G2_FLAG (next DATA_BLS_MAP_FP2_TO_G2_FLAG)))) + +(defun (same_data_to_result) + (+ (* DATA_POINT_EVALUATION_FLAG (next RSLT_POINT_EVALUATION_FLAG)) + (* DATA_BLS_G1_ADD_FLAG (next RSLT_BLS_G1_ADD_FLAG)) + (* DATA_BLS_G1_MSM_FLAG (next RSLT_BLS_G1_MSM_FLAG)) + (* DATA_BLS_G2_ADD_FLAG (next RSLT_BLS_G2_ADD_FLAG)) + (* DATA_BLS_G2_MSM_FLAG (next RSLT_BLS_G2_MSM_FLAG)) + (* DATA_BLS_PAIRING_CHECK_FLAG (next RSLT_BLS_PAIRING_CHECK_FLAG)) + (* DATA_BLS_MAP_FP_TO_G1_FLAG (next RSLT_BLS_MAP_FP_TO_G1_FLAG)) + (* DATA_BLS_MAP_FP2_TO_G2_FLAG (next RSLT_BLS_MAP_FP2_TO_G2_FLAG)))) + +(defun (same_result_to_result) + (+ (* RSLT_POINT_EVALUATION_FLAG (next RSLT_POINT_EVALUATION_FLAG)) + (* RSLT_BLS_G1_ADD_FLAG (next RSLT_BLS_G1_ADD_FLAG)) + (* RSLT_BLS_G1_MSM_FLAG (next RSLT_BLS_G1_MSM_FLAG)) + (* RSLT_BLS_G2_ADD_FLAG (next RSLT_BLS_G2_ADD_FLAG)) + (* RSLT_BLS_G2_MSM_FLAG (next RSLT_BLS_G2_MSM_FLAG)) + (* RSLT_BLS_PAIRING_CHECK_FLAG (next RSLT_BLS_PAIRING_CHECK_FLAG)) + (* RSLT_BLS_MAP_FP_TO_G1_FLAG (next RSLT_BLS_MAP_FP_TO_G1_FLAG)) + (* RSLT_BLS_MAP_FP2_TO_G2_FLAG (next RSLT_BLS_MAP_FP2_TO_G2_FLAG)))) + +(defconstraint legal-transitions () + (if-not-zero STAMP + (eq! (+ (same_data_to_data) + (same_data_to_result) + (same_result_to_result) + (transition_to_data)) 1))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/setting_acc_inputs.lisp b/blsdata/cancun/generalities/setting_acc_inputs.lisp new file mode 100644 index 000000000..cf7c284cf --- /dev/null +++ b/blsdata/cancun/generalities/setting_acc_inputs.lisp @@ -0,0 +1,20 @@ +(module blsdata) + +(defun (is_variable_size_data) + (+ DATA_BLS_G1_MSM_FLAG + DATA_BLS_G2_MSM_FLAG + DATA_BLS_PAIRING_CHECK_FLAG)) + +(defconstraint acc-inputs-init () + (if-zero (is_variable_size_data) + (begin (vanishes! ACC_INPUTS) + (eq! (next ACC_INPUTS) (next (is_variable_size_data)))))) + +(defconstraint acc-inputs-increment () + (if-not-zero (is_variable_size_data) + (if-eq-else (next (is_variable_size_data)) 0 + (vanishes! (next ACC_INPUTS)) + (eq! (next ACC_INPUTS) + (+ ACC_INPUTS + 1 + (will_switch_from_second_to_first)))))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/setting_ct_max.lisp b/blsdata/cancun/generalities/setting_ct_max.lisp new file mode 100644 index 000000000..f3c8427ca --- /dev/null +++ b/blsdata/cancun/generalities/setting_ct_max.lisp @@ -0,0 +1,24 @@ +(module blsdata) + +(defun (ct_max_first_input) + (+ (* CT_MAX_POINT_EVALUATION DATA_POINT_EVALUATION_FLAG) + (* CT_MAX_SMALL_POINT DATA_BLS_G1_ADD_FLAG) + (* CT_MAX_SMALL_POINT DATA_BLS_G1_MSM_FLAG) + (* CT_MAX_LARGE_POINT DATA_BLS_G2_ADD_FLAG) + (* CT_MAX_LARGE_POINT DATA_BLS_G2_MSM_FLAG) + (* CT_MAX_SMALL_POINT DATA_BLS_PAIRING_CHECK_FLAG) + (* CT_MAX_MAP_FP_TO_G1 DATA_BLS_MAP_FP_TO_G1_FLAG) + (* CT_MAX_MAP_FP2_TO_G2 DATA_BLS_MAP_FP2_TO_G2_FLAG))) + +(defun (ct_max_second_input) + (+ (* CT_MAX_SMALL_POINT RSLT_BLS_G1_ADD_FLAG) + (* CT_MAX_SCALAR RSLT_BLS_G1_MSM_FLAG) + (* CT_MAX_LARGE_POINT RSLT_BLS_G2_ADD_FLAG) + (* CT_MAX_SCALAR RSLT_BLS_G2_MSM_FLAG) + (* CT_MAX_LARGE_POINT RSLT_BLS_PAIRING_CHECK_FLAG))) + +(defconstraint set-ct-max () + (eq! CT_MAX + (+ (* (ct_max_first_input) IS_FIRST_INPUT) + (* (ct_max_second_input) IS_SECOND_INPUT) + (* INDEX_MAX (is_result))))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/setting_index.lisp b/blsdata/cancun/generalities/setting_index.lisp new file mode 100644 index 000000000..2ac5c6790 --- /dev/null +++ b/blsdata/cancun/generalities/setting_index.lisp @@ -0,0 +1,22 @@ +(module blsdata) + +(defconstraint vanishing-values () + (if-zero (flag_sum) + (begin (vanishes! INDEX_MAX) + (vanishes! INDEX) + (vanishes! ID)))) + +(defconstraint index-reset () + (if-not-zero (transition_bit) + (vanishes! (next INDEX)))) + +(defconstraint index-increment () + (if-not-zero (flag_sum) + (if-eq-else INDEX INDEX_MAX + (eq! (transition_bit) 1) + (eq! (next INDEX) (+ 1 INDEX))))) + +(defconstraint final-row (:domain {-1}) + (if-not-zero (flag_sum) + (begin (eq! (is_result) 1) + (eq! INDEX INDEX_MAX)))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/setting_index_max.lisp b/blsdata/cancun/generalities/setting_index_max.lisp new file mode 100644 index 000000000..d468edfc0 --- /dev/null +++ b/blsdata/cancun/generalities/setting_index_max.lisp @@ -0,0 +1,28 @@ +(module blsdata) + +(defun (index_max_sum) + (+ (* INDEX_MAX_DATA_POINT_EVALUATION DATA_POINT_EVALUATION_FLAG) + (* INDEX_MAX_DATA_G1_ADD DATA_BLS_G1_ADD_FLAG) + (* INDEX_MAX_DATA_G2_ADD DATA_BLS_G2_ADD_FLAG) + (* INDEX_MAX_DATA_MAP_FP_TO_G1 DATA_BLS_MAP_FP_TO_G1_FLAG) + (* INDEX_MAX_DATA_MAP_FP2_TO_G2 DATA_BLS_MAP_FP2_TO_G2_FLAG) + (* INDEX_MAX_RSLT_POINT_EVALUATION RSLT_POINT_EVALUATION_FLAG) + (* INDEX_MAX_RSLT_G1_ADD RSLT_BLS_G1_ADD_FLAG) + (* INDEX_MAX_RSLT_G1_MSM RSLT_BLS_G1_MSM_FLAG) + (* INDEX_MAX_RSLT_G2_ADD RSLT_BLS_G2_ADD_FLAG) + (* INDEX_MAX_RSLT_G2_MSM RSLT_BLS_G2_MSM_FLAG) + (* INDEX_MAX_RSLT_PAIRING_CHECK RSLT_BLS_PAIRING_CHECK_FLAG) + (* INDEX_MAX_RSLT_MAP_FP_TO_G1 RSLT_BLS_MAP_FP_TO_G1_FLAG) + (* INDEX_MAX_RSLT_MAP_FP2_TO_G2 RSLT_BLS_MAP_FP2_TO_G2_FLAG))) + +(defconstraint index-constancy () + (counter-constancy INDEX INDEX_MAX)) + +(defconstraint set-index-max () + (eq! (* 16 INDEX_MAX) + (+ (* 16 (index_max_sum)) + (* DATA_BLS_G1_MSM_FLAG (- TOTAL_SIZE 16)) + (* DATA_BLS_G2_MSM_FLAG (- TOTAL_SIZE 16)) + (* DATA_BLS_PAIRING_CHECK_FLAG (- TOTAL_SIZE 16))))) + + \ No newline at end of file diff --git a/blsdata/cancun/generalities/setting_is_first_input_and_is_second_input.lisp b/blsdata/cancun/generalities/setting_is_first_input_and_is_second_input.lisp new file mode 100644 index 000000000..f3c83f46d --- /dev/null +++ b/blsdata/cancun/generalities/setting_is_first_input_and_is_second_input.lisp @@ -0,0 +1,51 @@ +(module blsdata) + +(defun (two_input_type_prc_data) + (+ DATA_BLS_G1_ADD_FLAG + DATA_BLS_G1_MSM_FLAG + DATA_BLS_G2_ADD_FLAG + DATA_BLS_G2_MSM_FLAG + DATA_BLS_PAIRING_CHECK_FLAG)) + +(defun (one_input_type_prc_data) + (+ DATA_POINT_EVALUATION_FLAG + DATA_BLS_MAP_FP_TO_G1_FLAG + DATA_BLS_MAP_FP2_TO_G2_FLAG)) + +(defun (will_switch_from_first_to_second) + (* IS_FIRST_INPUT (next IS_SECOND_INPUT))) + +(defun (will_switch_from_second_to_first) + (* IS_SECOND_INPUT (next IS_FIRST_INPUT))) + +(defconstraint counter-constancy () + (begin (counter-constancy CT IS_FIRST_INPUT) + (counter-constancy CT IS_SECOND_INPUT))) ;; TODO: add to constancy conditions in both lisp and specs + +(defconstraint either-first-or-second () + (eq! (is_data) (+ IS_FIRST_INPUT IS_SECOND_INPUT))) + +(defconstraint data-start-with-first-input () + (if-zero (is_data) + (eq! (next IS_FIRST_INPUT) (next (is_data))))) + +(defconstraint one-input-is-first-input () + (if-not-zero (one_input_type_prc_data) + (eq! IS_FIRST_INPUT 1))) + +(defconstraint two-input-is-either-first-or-second () + (if-not-zero (two_input_type_prc_data) + (eq! (+ IS_FIRST_INPUT IS_SECOND_INPUT) 1))) + +(defconstraint two-input-transitions () + (if-not-zero (two_input_type_prc_data) + (if-eq-else CT CT_MAX + (eq! (+ (will_switch_from_first_to_second) + (will_switch_from_second_to_first)) + (next (two_input_type_prc_data))) + (vanishes! (+ (will_switch_from_first_to_second) + (will_switch_from_second_to_first)))))) + + + + diff --git a/blsdata/cancun/generalities/setting_phase.lisp b/blsdata/cancun/generalities/setting_phase.lisp new file mode 100644 index 000000000..63b7b0900 --- /dev/null +++ b/blsdata/cancun/generalities/setting_phase.lisp @@ -0,0 +1,30 @@ +(module blsdata) + +(defun (phase_sum) + (+ (* PHASE_POINT_EVALUATION_DATA DATA_POINT_EVALUATION_FLAG) + (* PHASE_POINT_EVALUATION_RESULT RSLT_POINT_EVALUATION_FLAG) + (* PHASE_BLS_G1_ADD_DATA DATA_BLS_G1_ADD_FLAG) + (* PHASE_BLS_G1_ADD_RESULT RSLT_BLS_G1_ADD_FLAG) + (* PHASE_BLS_G1_MSM_DATA DATA_BLS_G1_MSM_FLAG) + (* PHASE_BLS_G1_MSM_RESULT RSLT_BLS_G1_MSM_FLAG) + (* PHASE_BLS_G2_ADD_DATA DATA_BLS_G2_ADD_FLAG) + (* PHASE_BLS_G2_ADD_RESULT RSLT_BLS_G2_ADD_FLAG) + (* PHASE_BLS_G2_MSM_DATA DATA_BLS_G2_MSM_FLAG) + (* PHASE_BLS_G2_MSM_RESULT RSLT_BLS_G2_MSM_FLAG) + (* PHASE_BLS_PAIRING_CHECK_DATA DATA_BLS_PAIRING_CHECK_FLAG) + (* PHASE_BLS_PAIRING_CHECK_RESULT RSLT_BLS_PAIRING_CHECK_FLAG) + (* PHASE_BLS_MAP_FP_TO_G1_DATA DATA_BLS_MAP_FP_TO_G1_FLAG) + (* PHASE_BLS_MAP_FP_TO_G1_RESULT RSLT_BLS_MAP_FP_TO_G1_FLAG) + (* PHASE_BLS_MAP_FP2_TO_G2_DATA DATA_BLS_MAP_FP2_TO_G2_FLAG) + (* PHASE_BLS_MAP_FP2_TO_G2_RESULT RSLT_BLS_MAP_FP2_TO_G2_FLAG))) + +(defconstraint index-constancy () + (counter-constancy INDEX PHASE)) ;; NOTE: PHASE is said to be index-constant + +(defconstraint setting-phase () + (eq! PHASE (phase_sum))) + + + + + \ No newline at end of file diff --git a/blsdata/cancun/generalities/setting_total_size.lisp b/blsdata/cancun/generalities/setting_total_size.lisp new file mode 100644 index 000000000..6d3ef2cac --- /dev/null +++ b/blsdata/cancun/generalities/setting_total_size.lisp @@ -0,0 +1,10 @@ +(module blsdata) + +(defconstraint setting-total-size-data () + (if-not-zero (is_data) + (if-zero (is_variable_size_data) + (eq! TOTAL_SIZE (* (+ INDEX_MAX 1) 16))))) + +(defconstraint setting-total-size-result () + (if-not-zero (is_result) + (eq! TOTAL_SIZE (* (+ INDEX_MAX 1) 16 SUCCESS_BIT)))) \ No newline at end of file diff --git a/blsdata/cancun/generalities/shorthands.lisp b/blsdata/cancun/generalities/shorthands.lisp new file mode 100644 index 000000000..c4154e03a --- /dev/null +++ b/blsdata/cancun/generalities/shorthands.lisp @@ -0,0 +1,30 @@ +(module blsdata) + +(defun (is_data) + (+ DATA_POINT_EVALUATION_FLAG + DATA_BLS_G1_ADD_FLAG + DATA_BLS_G1_MSM_FLAG + DATA_BLS_G2_ADD_FLAG + DATA_BLS_G2_MSM_FLAG + DATA_BLS_PAIRING_CHECK_FLAG + DATA_BLS_MAP_FP_TO_G1_FLAG + DATA_BLS_MAP_FP2_TO_G2_FLAG)) + +(defun (is_result) + (+ RSLT_POINT_EVALUATION_FLAG + RSLT_BLS_G1_ADD_FLAG + RSLT_BLS_G1_MSM_FLAG + RSLT_BLS_G2_ADD_FLAG + RSLT_BLS_G2_MSM_FLAG + RSLT_BLS_PAIRING_CHECK_FLAG + RSLT_BLS_MAP_FP_TO_G1_FLAG + RSLT_BLS_MAP_FP2_TO_G2_FLAG)) + +(defun (transition_to_data) + (* (- 1 (is_data)) (next (is_data)))) + +(defun (transition_to_result) + (* (- 1 (is_result)) (next (is_result)))) + +(defun (transition_bit) + (+ (transition_to_data) (transition_to_result))) \ No newline at end of file diff --git a/blsdata/cancun/lookups/blsdata_into_wcp.lisp b/blsdata/cancun/lookups/blsdata_into_wcp.lisp new file mode 100644 index 000000000..7fb28b688 --- /dev/null +++ b/blsdata/cancun/lookups/blsdata_into_wcp.lisp @@ -0,0 +1,25 @@ +(defun (blsdata-into-wcp-activation-flag) + blsdata.WCP_FLAG) + +(deflookup + blsdata-into-wcp + ; target columns + ( + wcp.ARGUMENT_1_HI + wcp.ARGUMENT_1_LO + wcp.ARGUMENT_2_HI + wcp.ARGUMENT_2_LO + wcp.RESULT + wcp.INST + ) + ; source columns + ( + (* blsdata.WCP_ARG1_HI (blsdata-into-wcp-activation-flag)) + (* blsdata.WCP_ARG1_LO (blsdata-into-wcp-activation-flag)) + (* blsdata.WCP_ARG2_HI (blsdata-into-wcp-activation-flag)) + (* blsdata.WCP_ARG2_LO (blsdata-into-wcp-activation-flag)) + (* blsdata.WCP_RES (blsdata-into-wcp-activation-flag)) + (* blsdata.WCP_INST (blsdata-into-wcp-activation-flag)) + )) + + diff --git a/blsdata/cancun/specialized_constraints/g1_add.lisp b/blsdata/cancun/specialized_constraints/g1_add.lisp new file mode 100644 index 000000000..85cec0504 --- /dev/null +++ b/blsdata/cancun/specialized_constraints/g1_add.lisp @@ -0,0 +1,15 @@ +(module blsdata) + +(defun (g1-add-hypothesis) + (* DATA_BLS_G1_ADD_FLAG (first_row_of_new_input))) + +(defconstraint internal-checks-g1-add (:guard (g1-add-hypothesis)) + (let ((A_x_3 LIMB) + (A_x_2 (shift LIMB 1)) + (A_x_1 (shift LIMB 2)) + (A_x_0 (shift LIMB 3)) + (A_y_3 (shift LIMB 4)) + (A_y_2 (shift LIMB 5)) + (A_y_1 (shift LIMB 6)) + (A_y_0 (shift LIMB 7))) + (wellFormedFpCoordinatesAndInfinityCheck 0 A_x_3 A_x_2 A_x_1 A_x_0 A_y_3 A_y_2 A_y_1 A_y_0))) \ No newline at end of file diff --git a/blsdata/cancun/specialized_constraints/g1_msm.lisp b/blsdata/cancun/specialized_constraints/g1_msm.lisp new file mode 100644 index 000000000..3404c8e2e --- /dev/null +++ b/blsdata/cancun/specialized_constraints/g1_msm.lisp @@ -0,0 +1,15 @@ +(module blsdata) + +(defun (g1-msm-hypothesis) + (* DATA_BLS_G1_MSM_FLAG (first_row_of_new_first_input))) + +(defconstraint internal-checks-g1-msm (:guard (g1-msm-hypothesis)) + (let ((A_x_3 LIMB) + (A_x_2 (shift LIMB 1)) + (A_x_1 (shift LIMB 2)) + (A_x_0 (shift LIMB 3)) + (A_y_3 (shift LIMB 4)) + (A_y_2 (shift LIMB 5)) + (A_y_1 (shift LIMB 6)) + (A_y_0 (shift LIMB 7))) + (wellFormedFpCoordinatesAndInfinityCheck 0 A_x_3 A_x_2 A_x_1 A_x_0 A_y_3 A_y_2 A_y_1 A_y_0))) \ No newline at end of file diff --git a/blsdata/cancun/specialized_constraints/g2_add.lisp b/blsdata/cancun/specialized_constraints/g2_add.lisp new file mode 100644 index 000000000..f0e3b8c51 --- /dev/null +++ b/blsdata/cancun/specialized_constraints/g2_add.lisp @@ -0,0 +1,23 @@ +(module blsdata) + +(defun (g2-add-hypothesis) + (* DATA_BLS_G2_ADD_FLAG (first_row_of_new_input))) + +(defconstraint internal-checks-g2-add (:guard (g2-add-hypothesis)) + (let ((A_x_Im_3 LIMB) + (A_x_Im_2 (shift LIMB 1)) + (A_x_Im_1 (shift LIMB 2)) + (A_x_Im_0 (shift LIMB 3)) + (A_x_Re_3 (shift LIMB 4)) + (A_x_Re_2 (shift LIMB 5)) + (A_x_Re_1 (shift LIMB 6)) + (A_x_Re_0 (shift LIMB 7)) + (A_y_Im_3 (shift LIMB 8)) + (A_y_Im_2 (shift LIMB 9)) + (A_y_Im_1 (shift LIMB 10)) + (A_y_Im_0 (shift LIMB 11)) + (A_y_Re_3 (shift LIMB 12)) + (A_y_Re_2 (shift LIMB 13)) + (A_y_Re_1 (shift LIMB 14)) + (A_y_Re_0 (shift LIMB 15))) + (wellFormedFp2CoordinatesAndInfinityCheck 0 A_x_Im_3 A_x_Im_2 A_x_Im_1 A_x_Im_0 A_x_Re_3 A_x_Re_2 A_x_Re_1 A_x_Re_0 A_y_Im_3 A_y_Im_2 A_y_Im_1 A_y_Im_0 A_y_Re_3 A_y_Re_2 A_y_Re_1 A_y_Re_0))) \ No newline at end of file diff --git a/blsdata/cancun/specialized_constraints/g2_msm.lisp b/blsdata/cancun/specialized_constraints/g2_msm.lisp new file mode 100644 index 000000000..ae57ba8c0 --- /dev/null +++ b/blsdata/cancun/specialized_constraints/g2_msm.lisp @@ -0,0 +1,23 @@ +(module blsdata) + +(defun (g2-msm-hypothesis) + (* DATA_BLS_G2_MSM_FLAG (first_row_of_new_first_input))) + +(defconstraint internal-checks-g2-msm (:guard (g2-msm-hypothesis)) + (let ((A_x_Im_3 LIMB) + (A_x_Im_2 (shift LIMB 1)) + (A_x_Im_1 (shift LIMB 2)) + (A_x_Im_0 (shift LIMB 3)) + (A_x_Re_3 (shift LIMB 4)) + (A_x_Re_2 (shift LIMB 5)) + (A_x_Re_1 (shift LIMB 6)) + (A_x_Re_0 (shift LIMB 7)) + (A_y_Im_3 (shift LIMB 8)) + (A_y_Im_2 (shift LIMB 9)) + (A_y_Im_1 (shift LIMB 10)) + (A_y_Im_0 (shift LIMB 11)) + (A_y_Re_3 (shift LIMB 12)) + (A_y_Re_2 (shift LIMB 13)) + (A_y_Re_1 (shift LIMB 14)) + (A_y_Re_0 (shift LIMB 15))) + (wellFormedFp2CoordinatesAndInfinityCheck 0 A_x_Im_3 A_x_Im_2 A_x_Im_1 A_x_Im_0 A_x_Re_3 A_x_Re_2 A_x_Re_1 A_x_Re_0 A_y_Im_3 A_y_Im_2 A_y_Im_1 A_y_Im_0 A_y_Re_3 A_y_Re_2 A_y_Re_1 A_y_Re_0))) \ No newline at end of file diff --git a/blsdata/cancun/specialized_constraints/map_fp2_to_g3.lisp b/blsdata/cancun/specialized_constraints/map_fp2_to_g3.lisp new file mode 100644 index 000000000..a415a562d --- /dev/null +++ b/blsdata/cancun/specialized_constraints/map_fp2_to_g3.lisp @@ -0,0 +1,21 @@ +(module blsdata) + +(defun (map-fp2-to-g2-hypothesis) + (* DATA_BLS_MAP_FP2_TO_G2_FLAG (first_row_of_new_first_input))) + +(defconstraint internal-checks-map-fp2-to-g2 (:guard (map-fp2-to-g2-hypothesis)) + (let ((e_Im_3 LIMB) + (e_Im_2 (shift LIMB 1)) + (e_Im_1 (shift LIMB 2)) + (e_Im_0 (shift LIMB 3)) + (e_Re_3 (shift LIMB 4)) + (e_Re_2 (shift LIMB 5)) + (e_Re_1 (shift LIMB 6)) + (e_Re_0 (shift LIMB 7)) + (e_Im_is_in_range WCP_RES) + (e_Re_is_in_range (shift WCP_RES 4)) + (internal_checks_passed (- 1 MINT_BIT))) + (begin (wcpGeneralizedCallToLT 0 e_Im_3 e_Im_2 e_Im_1 e_Im_0 BLS_PRIME_3 BLS_PRIME_2 BLS_PRIME_1 BLS_PRIME_0) + (wcpGeneralizedCallToLT 4 e_Re_3 e_Re_2 e_Re_1 e_Re_0 BLS_PRIME_3 BLS_PRIME_2 BLS_PRIME_1 BLS_PRIME_0) + (eq! internal_checks_passed (* e_Im_is_in_range e_Re_is_in_range)) + ))) \ No newline at end of file diff --git a/blsdata/cancun/specialized_constraints/map_fp_to_g1.lisp b/blsdata/cancun/specialized_constraints/map_fp_to_g1.lisp new file mode 100644 index 000000000..4afb3d938 --- /dev/null +++ b/blsdata/cancun/specialized_constraints/map_fp_to_g1.lisp @@ -0,0 +1,15 @@ +(module blsdata) + +(defun (map-fp-to-g1-hypothesis) + (* DATA_BLS_MAP_FP_TO_G1_FLAG (first_row_of_new_first_input))) + +(defconstraint internal-checks-map-fp-to-g1 (:guard (map-fp-to-g1-hypothesis)) + (let ((e_3 LIMB) + (e_2 (shift LIMB 1)) + (e_1 (shift LIMB 2)) + (e_0 (shift LIMB 3)) + (e_is_in_range WCP_RES) + (internal_checks_passed (- 1 MINT_BIT))) + (begin (wcpGeneralizedCallToLT 0 e_3 e_2 e_1 e_0 BLS_PRIME_3 BLS_PRIME_2 BLS_PRIME_1 BLS_PRIME_0) + (eq! internal_checks_passed (* e_is_in_range)) + ))) diff --git a/blsdata/cancun/specialized_constraints/pairing_check_first_input.lisp b/blsdata/cancun/specialized_constraints/pairing_check_first_input.lisp new file mode 100644 index 000000000..4a464d43f --- /dev/null +++ b/blsdata/cancun/specialized_constraints/pairing_check_first_input.lisp @@ -0,0 +1,15 @@ +(module blsdata) + +(defun (pairing-check-first-input-hypothesis) + (* DATA_BLS_PAIRING_CHECK_FLAG (first_row_of_new_first_input))) + +(defconstraint internal-checks-pairing-check-first-input (:guard (pairing-check-first-input-hypothesis)) + (let ((A_x_3 LIMB) + (A_x_2 (shift LIMB 1)) + (A_x_1 (shift LIMB 2)) + (A_x_0 (shift LIMB 3)) + (A_y_3 (shift LIMB 4)) + (A_y_2 (shift LIMB 5)) + (A_y_1 (shift LIMB 6)) + (A_y_0 (shift LIMB 7))) + (wellFormedFpCoordinatesAndInfinityCheck 0 A_x_3 A_x_2 A_x_1 A_x_0 A_y_3 A_y_2 A_y_1 A_y_0))) \ No newline at end of file diff --git a/blsdata/cancun/specialized_constraints/pairing_check_second_input.lisp b/blsdata/cancun/specialized_constraints/pairing_check_second_input.lisp new file mode 100644 index 000000000..cc2bb7f78 --- /dev/null +++ b/blsdata/cancun/specialized_constraints/pairing_check_second_input.lisp @@ -0,0 +1,23 @@ +(module blsdata) + +(defun (pairing-check-second-input-hypothesis) + (* DATA_BLS_PAIRING_CHECK_FLAG (first_row_of_new_second_input))) + +(defconstraint internal-checks-pairing-check-second-input (:guard (pairing-check-second-input-hypothesis)) + (let ((B_x_Im_3 LIMB) + (B_x_Im_2 (shift LIMB 1)) + (B_x_Im_1 (shift LIMB 2)) + (B_x_Im_0 (shift LIMB 3)) + (B_x_Re_3 (shift LIMB 4)) + (B_x_Re_2 (shift LIMB 5)) + (B_x_Re_1 (shift LIMB 6)) + (B_x_Re_0 (shift LIMB 7)) + (B_y_Im_3 (shift LIMB 8)) + (B_y_Im_2 (shift LIMB 9)) + (B_y_Im_1 (shift LIMB 10)) + (B_y_Im_0 (shift LIMB 11)) + (B_y_Re_3 (shift LIMB 12)) + (B_y_Re_2 (shift LIMB 13)) + (B_y_Re_1 (shift LIMB 14)) + (B_y_Re_0 (shift LIMB 15))) + (wellFormedFp2CoordinatesAndInfinityCheck 0 B_x_Im_3 B_x_Im_2 B_x_Im_1 B_x_Im_0 B_x_Re_3 B_x_Re_2 B_x_Re_1 B_x_Re_0 B_y_Im_3 B_y_Im_2 B_y_Im_1 B_y_Im_0 B_y_Re_3 B_y_Re_2 B_y_Re_1 B_y_Re_0))) \ No newline at end of file diff --git a/blsdata/cancun/specialized_constraints/point_evaluation.lisp b/blsdata/cancun/specialized_constraints/point_evaluation.lisp new file mode 100644 index 000000000..a3dd7ee64 --- /dev/null +++ b/blsdata/cancun/specialized_constraints/point_evaluation.lisp @@ -0,0 +1,17 @@ +(module blsdata) + +(defun (point-evaluation-hypothesis) + (* DATA_POINT_EVALUATION_FLAG (first_row_of_new_input))) + +(defconstraint internal-checks-point-evaluation (:guard (point-evaluation-hypothesis)) + (let ((z_hi (shift LIMB 2)) + (z_lo (shift LIMB 3)) + (y_hi (shift LIMB 4)) + (y_lo (shift LIMB 5)) + (z_is_in_range WCP_RES) + (y_is_in_range (shift WCP_RES 1)) + (internal_checks_passed (- 1 MINT_BIT))) + (begin (wcpCallToLT 0 z_hi z_lo POINT_EVALUATION_PRIME_HI POINT_EVALUATION_PRIME_LO) + (wcpCallToLT 1 y_hi y_lo POINT_EVALUATION_PRIME_HI POINT_EVALUATION_PRIME_LO) + (eq! internal_checks_passed (* z_is_in_range y_is_in_range)) + ))) diff --git a/blsdata/cancun/specialized_constraints/shorthands.lisp b/blsdata/cancun/specialized_constraints/shorthands.lisp new file mode 100644 index 000000000..27b5ae5bf --- /dev/null +++ b/blsdata/cancun/specialized_constraints/shorthands.lisp @@ -0,0 +1,10 @@ +(module blsdata) + +(defun (first_row_of_new_first_input) + (* (- 1 (prev IS_FIRST_INPUT)) IS_FIRST_INPUT)) + +(defun (first_row_of_new_second_input) + (* (- 1 (prev IS_SECOND_INPUT)) IS_SECOND_INPUT)) + +(defun (first_row_of_new_input) + (+ (first_row_of_new_first_input) (first_row_of_new_second_input))) \ No newline at end of file diff --git a/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/generalities.lisp b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/generalities.lisp new file mode 100644 index 000000000..8f0b2acb5 --- /dev/null +++ b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/generalities.lisp @@ -0,0 +1,45 @@ +(module blsdata) + +(defun (malformed_data) + (+ MINT MEXT)) + +(defun (wellformed_data) + (+ WTRV WNON)) + +(defun (case_data_sum) + (+ (malformed_data) + (wellformed_data))) + +(defconstraint case-data-sum-equal-to-flag-sum () + (eq! (case_data_sum) (flag_sum))) + +(defconstraint map-fp-to-g1-cannot-fail-externally () + (if-not-zero (is_map_fp_to_g1) + (vanishes! MEXT))) + +(defconstraint map-fp2-to-g2-cannot-fail-externally () + (if-not-zero (is_map_fp2_to_g2) + (vanishes! MEXT))) + +(defconstraint only-pairing-check-can-be-trivial () + (if-zero (is_pairing_check) + (vanishes! WTRV))) + +(defconstraint pairing-check-setting-non-trivial () + (if-not-zero (is_pairing_check) + (if-not-zero (transition_to_result) + (begin + (debug (if-not-zero (malformed_data) + (vanishes! WNON))) + (if-not-zero (wellformed_data) + (eq! WNON NONTRIVIAL_POP_ACC)))))) + +(defconstraint setting-mint-bit-along-g1-msm-scalar () + (if-not-zero DATA_BLS_G1_MSM_FLAG + (if-not-zero IS_SECOND_INPUT + (vanishes! MINT_BIT)))) + +(defconstraint setting-mint-bit-along-g2-msm-scalar () + (if-not-zero DATA_BLS_G2_MSM_FLAG + (if-not-zero IS_SECOND_INPUT + (vanishes! MINT_BIT)))) \ No newline at end of file diff --git a/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_mext_bit_mext_acc_and_mext.lisp b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_mext_bit_mext_acc_and_mext.lisp new file mode 100644 index 000000000..58c5e087f --- /dev/null +++ b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_mext_bit_mext_acc_and_mext.lisp @@ -0,0 +1,36 @@ +(module blsdata) + +(defconstraint if-mint-is-one-then-mext-is-not-relevant () + (if-not-zero MINT + (begin + (vanishes! MEXT_BIT) + (debug (vanishes! MEXT_ACC)) + (debug (vanishes! MEXT))))) + +(defconstraint if-is-data-is-zero-then-mext-bit-and-mext-acc-vanish () + (if-zero (is_data) + (begin + (vanishes! MEXT_BIT) + (vanishes! MEXT_ACC)))) + +(defconstraint if-is-map-fp-to-g1-is-one-then-mext-bit-and-mext-acc-and-mext-vanish () + (if-not-zero (is_map_fp_to_g1) + (begin + (vanishes! MEXT_BIT) + (debug (vanishes! MEXT_ACC)) + (debug (vanishes! MEXT))))) + +(defconstraint if-is-map-fp2-to-g2-is-one-then-mext-bit-and-mext-acc-and-mext-vanish () + (if-not-zero (is_map_fp2_to_g2) + (begin + (vanishes! MEXT_BIT) + (debug (vanishes! MEXT_ACC)) + (debug (vanishes! MEXT))))) + +(defconstraint propagate-mext-bit-into-mext-acc () + (if-not-zero (+ (transition_to_data) (will_switch_from_first_to_second) (will_switch_from_second_to_first)) + (eq! (next MEXT_ACC) (+ MEXT_ACC (next MEXT_BIT))))) + +(defconstraint propagate-mext-acc-into-mext () + (if-not-zero (transition_to_result) + (eq! MEXT MEXT_ACC))) \ No newline at end of file diff --git a/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_mint_bit_mint_acc_and_mint.lisp b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_mint_bit_mint_acc_and_mint.lisp new file mode 100644 index 000000000..65421d0ec --- /dev/null +++ b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_mint_bit_mint_acc_and_mint.lisp @@ -0,0 +1,19 @@ +(module blsdata) + +(defconstraint set-mint-bit-and-mint-acc-when-is-data-is-zero () + (if-zero (is_data) + (begin + (vanishes! MINT_BIT) + (vanishes! MINT_ACC) + ))) + +(defconstraint propagate-mint-bit-into-mint-acc () + (if-not-zero (+ (transition_to_data) (will_switch_from_first_to_second) (will_switch_from_second_to_first)) + (begin (if-zero MINT_ACC + (eq! (next MINT_ACC) (next MINT_BIT))) + (if-not-zero MINT_ACC + (eq! (next MINT_ACC) 1))))) + +(defconstraint propagate-mint-acc-into-mint () + (if-not-zero (transition_to_result) + (eq! MINT MINT_ACC))) \ No newline at end of file diff --git a/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_non_trivial_pop_acc.lisp b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_non_trivial_pop_acc.lisp new file mode 100644 index 000000000..669a2d13d --- /dev/null +++ b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_non_trivial_pop_acc.lisp @@ -0,0 +1,11 @@ +(module blsdata) + +(defconstraint non-trivial-pop-acc-is-only-relevant-in-pairing-check () + (if-zero DATA_BLS_PAIRING_CHECK_FLAG + (vanishes! NONTRIVIAL_POP_ACC))) + +(defconstraint set-non-trivial-pop-acc () + (if-zero (prev DATA_BLS_PAIRING_CHECK_FLAG) + (if-not-zero DATA_BLS_PAIRING_CHECK_FLAG + (eq! NONTRIVIAL_POP_ACC NONTRIVIAL_POP_BIT)))) + \ No newline at end of file diff --git a/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_non_trivial_pop_bit.lisp b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_non_trivial_pop_bit.lisp new file mode 100644 index 000000000..926f9afc9 --- /dev/null +++ b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_non_trivial_pop_bit.lisp @@ -0,0 +1,17 @@ +(module blsdata) + +(defun (small_point_is_nontrivial) + (- 1 IS_INFINITY)) + +(defun (large_point_is_nontrivial) + (- 1 (next IS_INFINITY))) + +(defconstraint nontrivial-pop-bit-is-only-relevant-in-pairing-check () + (if-zero DATA_BLS_PAIRING_CHECK_FLAG + (vanishes! NONTRIVIAL_POP_BIT))) + +(defconstraint set-non-trivial-pop-bit () + (if-not-zero DATA_BLS_PAIRING_CHECK_FLAG + (if-not-zero (will_switch_from_first_to_second) + (eq! NONTRIVIAL_POP_BIT (* (small_point_is_nontrivial) (large_point_is_nontrivial)))))) + diff --git a/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_result_for_trivial_pairings.lisp b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_result_for_trivial_pairings.lisp new file mode 100644 index 000000000..0107117af --- /dev/null +++ b/blsdata/cancun/top_level_flags_mint_mext_wtrv_wnon/setting_result_for_trivial_pairings.lisp @@ -0,0 +1,10 @@ +(module blsdata) + +(defconstraint set-pairing-check-result-when-trivial-pairings () + (let ((pairing_result_hi (next LIMB)) + (pairing_result_lo (shift LIMB 2))) + (if-not-zero (is_pairing_check) + (if-not-zero (transition_to_result) + (if-not-zero WTRV + (begin (vanishes! pairing_result_hi) + (eq! pairing_result_lo 1))))))) \ No newline at end of file diff --git a/blsdata/cancun/utilities/definition_of_isInfinity.lisp b/blsdata/cancun/utilities/definition_of_isInfinity.lisp new file mode 100644 index 000000000..a4a7df723 --- /dev/null +++ b/blsdata/cancun/utilities/definition_of_isInfinity.lisp @@ -0,0 +1,9 @@ +(module blsdata) + +(defun (isInfinity k coordinate_sum) + (let ((P_is_point_at_infinity (shift IS_INFINITY k))) + (begin + (if-zero coordinate_sum + (eq! P_is_point_at_infinity 1)) + (if-not-zero coordinate_sum + (eq! P_is_point_at_infinity 0))))) \ No newline at end of file diff --git a/blsdata/cancun/utilities/definition_of_wcp_utilities.lisp b/blsdata/cancun/utilities/definition_of_wcp_utilities.lisp new file mode 100644 index 000000000..29c954e4b --- /dev/null +++ b/blsdata/cancun/utilities/definition_of_wcp_utilities.lisp @@ -0,0 +1,25 @@ +(module blsdata) + +(defun (wcpCallToLT k a b c d) + (begin (eq! (shift WCP_FLAG k) 1) + (eq! (shift WCP_INST k) EVM_INST_LT) + (eq! (shift WCP_ARG1_HI k) a) + (eq! (shift WCP_ARG1_LO k) b) + (eq! (shift WCP_ARG2_HI k) c) + (eq! (shift WCP_ARG2_LO k) d))) + +(defun (wcpCallToEQ k a b c d) + (begin (eq! (shift WCP_FLAG k) 1) + (eq! (shift WCP_INST k) EVM_INST_EQ) + (eq! (shift WCP_ARG1_HI k) a) + (eq! (shift WCP_ARG1_LO k) b) + (eq! (shift WCP_ARG2_HI k) c) + (eq! (shift WCP_ARG2_LO k) d))) + +(defun (wcpGeneralizedCallToLT k a b c d e f g h) + (begin (wcpCallToLT (+ k 1) a b e f) + (wcpCallToEQ (+ k 2) a b e f) + (wcpCallToLT (+ k 3) c d g h) + (eq! (shift WCP_RES k) + (+ (shift WCP_RES (+ k 1)) + (* (shift WCP_RES (+ k 2)) (shift WCP_RES (+ k 3))))))) \ No newline at end of file diff --git a/blsdata/cancun/utilities/definition_of_wellFormedFp2CoordinatesAndInfinityCheck.lisp b/blsdata/cancun/utilities/definition_of_wellFormedFp2CoordinatesAndInfinityCheck.lisp new file mode 100644 index 000000000..7132d7c5e --- /dev/null +++ b/blsdata/cancun/utilities/definition_of_wellFormedFp2CoordinatesAndInfinityCheck.lisp @@ -0,0 +1,21 @@ +(module blsdata) + +(defun (wellFormedFp2CoordinatesAndInfinityCheck k P_x_Im_3 P_x_Im_2 P_x_Im_1 P_x_Im_0 P_x_Re_3 P_x_Re_2 P_x_Re_1 P_x_Re_0 P_y_Im_3 P_y_Im_2 P_y_Im_1 P_y_Im_0 P_y_Re_3 P_y_Re_2 P_y_Re_1 P_y_Re_0) + (let ((P_x_Im_is_in_range (shift WCP_RES k)) + (P_x_Re_is_in_range (shift WCP_RES (+ k 4))) + (P_y_Im_is_in_range (shift WCP_RES (+ k 8))) + (P_y_Re_is_in_range (shift WCP_RES (+ k 12))) + (well_formed_coordinates (- 1 MINT_BIT))) + (let ((P_x_is_in_range (* P_x_Im_is_in_range P_x_Re_is_in_range)) + (P_y_is_in_range (* P_y_Im_is_in_range P_y_Re_is_in_range))) + (begin + (wcpGeneralizedCallToLT k P_x_Im_3 P_x_Im_2 P_x_Im_1 P_x_Im_0 BLS_PRIME_3 BLS_PRIME_2 BLS_PRIME_1 BLS_PRIME_0) + (wcpGeneralizedCallToLT (+ k 4) P_x_Re_3 P_x_Re_2 P_x_Re_1 P_x_Re_0 BLS_PRIME_3 BLS_PRIME_2 BLS_PRIME_1 BLS_PRIME_0) + (wcpGeneralizedCallToLT (+ k 8) P_y_Im_3 P_y_Im_2 P_y_Im_1 P_y_Im_0 BLS_PRIME_3 BLS_PRIME_2 BLS_PRIME_1 BLS_PRIME_0) + (wcpGeneralizedCallToLT (+ k 12) P_y_Re_3 P_y_Re_2 P_y_Re_1 P_y_Re_0 BLS_PRIME_3 BLS_PRIME_2 BLS_PRIME_1 BLS_PRIME_0) + (eq! well_formed_coordinates (* P_x_is_in_range P_y_is_in_range)) + (isInfinity k (+ P_x_Re_3 P_x_Re_2 P_x_Re_1 P_x_Re_0 + P_x_Im_3 P_x_Im_2 P_x_Im_1 P_x_Im_0 + P_y_Re_3 P_y_Re_2 P_y_Re_1 P_y_Re_0 + P_y_Im_3 P_y_Im_2 P_y_Im_1 P_y_Im_0)) + )))) diff --git a/blsdata/cancun/utilities/definition_of_wellFormedFpCoordinatesAndInfinityCheck.lisp b/blsdata/cancun/utilities/definition_of_wellFormedFpCoordinatesAndInfinityCheck.lisp new file mode 100644 index 000000000..b8aaae816 --- /dev/null +++ b/blsdata/cancun/utilities/definition_of_wellFormedFpCoordinatesAndInfinityCheck.lisp @@ -0,0 +1,12 @@ +(module blsdata) + +(defun (wellFormedFpCoordinatesAndInfinityCheck k P_x_3 P_x_2 P_x_1 P_x_0 P_y_3 P_y_2 P_y_1 P_y_0) + (let ((P_x_is_in_range (shift WCP_RES k)) + (P_y_is_in_range (shift WCP_RES (+ k 4))) + (well_formed_coordinates (- 1 MINT_BIT))) + (begin + (wcpGeneralizedCallToLT k P_x_3 P_x_2 P_x_1 P_x_0 BLS_PRIME_3 BLS_PRIME_2 BLS_PRIME_1 BLS_PRIME_0) + (wcpGeneralizedCallToLT (+ k 4) P_y_3 P_y_2 P_y_1 P_y_0 BLS_PRIME_3 BLS_PRIME_2 BLS_PRIME_1 BLS_PRIME_0) + (eq! well_formed_coordinates (* P_x_is_in_range P_y_is_in_range)) + (isInfinity k (+ P_x_3 P_x_2 P_x_1 P_x_0 P_y_3 P_y_2 P_y_1 P_y_0)) + ))) \ No newline at end of file diff --git a/constants/constants.lisp b/constants/constants.lisp index 72cfede11..36ed8bd3a 100644 --- a/constants/constants.lisp +++ b/constants/constants.lisp @@ -233,9 +233,16 @@ GAS_CONST_ECPAIRING_PAIR 34000 GAS_CONST_BLAKE2_PER_ROUND 1 GAS_CONST_INIT_CODE_WORD 2 ;; post Shanghai EIP-3860 - GAS_CONST_HASH_OPCODE_GAS 3 ;; gas cost of BLOBHASH, EIP-4844 in Cancun + GAS_CONST_HASH_OPCODE_GAS 3 ;; gas cost of BLOBHASH, EIP-4844 in Cancun STANDARD_TOKEN_COST 4 ;; payload pricing FLOOR_TOKEN_COST 10 ;; floor cost constant, from EIP-3860 (Prague) + GAS_CONST_POINT_EVALUATION 50000 + GAS_CONST_BLS_G1_ADD 375 + GAS_CONST_BLS_G2_ADD 600 + GAS_CONST_BLS_MAP_FP_TO_G1 5500 + GAS_CONST_BLS_MAP_FP2_TO_G2 23800 + GAS_CONST_BLS_PAIRING_CHECK 37700 + GAS_CONST_BLS_PAIRING_CHECK_PAIR 32600 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; EVM MISC ;; @@ -308,6 +315,16 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PRECOMPILES ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING 192 + PRECOMPILE_CALL_DATA_SIZE___POINT_EVALUATION 192 + PRECOMPILE_CALL_DATA_SIZE___G1_ADD 256 + PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_G1_MSM 160 + PRECOMPILE_CALL_DATA_SIZE___G2_ADD 512 + PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_G2_MSM 288 + PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK 384 + PRECOMPILE_CALL_DATA_SIZE___FP_TO_G1 64 + PRECOMPILE_CALL_DATA_SIZE___FP2_TO_G2 128 + PRC_ECPAIRING_SIZE (* 6 WORD_SIZE) PRECOMPILE_CALL_DATA_SIZE___BLAKE2F 213 PRECOMPILE_RETURN_DATA_SIZE___ECADD 64 @@ -321,6 +338,12 @@ PRECOMPILE_RETURN_DATA_SIZE___BLS_PAIRING_CHECK 32 PRECOMPILE_RETURN_DATA_SIZE___BLS_MAP_FP_TO_G1 128 PRECOMPILE_RETURN_DATA_SIZE___BLS_MAP_FP2_TO_G2 256 + + PRC_BLS_G1_MSM_MAX_DISCOUNT 519 + PRC_BLS_G2_MSM_MAX_DISCOUNT 524 + PRC_BLS_G1_MSM_MULTIPLICATION_COST 12000 + PRC_BLS_G2_MSM_MULTIPLICATION_COST 22500 + PRC_BLS_MULTIPLICATION_MULTIPLIER 1000 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; EXO SUM ;; diff --git a/ecdata/constraints.lisp b/ecdata/constraints.lisp index 3d4b5fe8d..f91e1eecb 100644 --- a/ecdata/constraints.lisp +++ b/ecdata/constraints.lisp @@ -264,7 +264,7 @@ (if-not-zero (transition_to_result) (will-remain-constant! TRIVIAL_PAIRING))) -(defconstraint set-pairing-result-when-trivial-pairngs () +(defconstraint set-pairing-result-when-trivial-pairings () (let ((pairing_result_hi (next LIMB)) (pairing_result_lo (shift LIMB 2))) (if-not-zero (transition_to_result) diff --git a/mmio/cancun/constraints.lisp b/mmio/cancun/constraints.lisp index 67ca92eaa..c02fdece9 100644 --- a/mmio/cancun/constraints.lisp +++ b/mmio/cancun/constraints.lisp @@ -57,7 +57,8 @@ (* EXO_SUM_WEIGHT_TXCD EXO_IS_TXCD) (* EXO_SUM_WEIGHT_ECDATA EXO_IS_ECDATA) (* EXO_SUM_WEIGHT_RIPSHA EXO_IS_RIPSHA) - (* EXO_SUM_WEIGHT_BLAKEMODEXP EXO_IS_BLAKEMODEXP))) + (* EXO_SUM_WEIGHT_BLAKEMODEXP EXO_IS_BLAKEMODEXP) + (* EXO_SUM_WEIGHT_BLSDATA EXO_IS_BLS))) (defconstraint exo-sum-decoding () (eq! (weighted-exo-sum) (* (instruction-may-provide-exo-sum) EXO_SUM))) diff --git a/mmio/cancun/lookups/mmio_into_blsdata.lisp b/mmio/cancun/lookups/mmio_into_blsdata.lisp new file mode 100644 index 000000000..7af580389 --- /dev/null +++ b/mmio/cancun/lookups/mmio_into_blsdata.lisp @@ -0,0 +1,24 @@ +(defclookup + (mmio-into-blsdata :unchecked) + ;; target columns + ( + blsdata.ID + blsdata.PHASE + blsdata.INDEX + blsdata.LIMB + blsdata.TOTAL_SIZE + blsdata.SUCCESS_BIT + ) + ;; source selector + mmio.EXO_IS_BLS + ;; source columns + ( + mmio.EXO_ID + mmio.PHASE + mmio.INDEX_X + mmio.LIMB + mmio.TOTAL_SIZE + mmio.SUCCESS_BIT + )) + + diff --git a/oob/cancun/cancun_restriction.lisp b/oob/cancun/cancun_restriction.lisp new file mode 100644 index 000000000..391d646b4 --- /dev/null +++ b/oob/cancun/cancun_restriction.lisp @@ -0,0 +1,4 @@ +(module oob) + +(defconstraint cancun-restriction () + (vanishes! (flag-sum-eip-bls12-precompiles))) \ No newline at end of file diff --git a/oob/cancun/columns.lisp b/oob/cancun/columns.lisp index e73a0f936..3baa4747e 100644 --- a/oob/cancun/columns.lisp +++ b/oob/cancun/columns.lisp @@ -30,9 +30,18 @@ (IS_MODEXP_LEAD :binary@prove) (IS_MODEXP_PRICING :binary@prove) (IS_MODEXP_EXTRACT :binary@prove) + (IS_POINT_EVALUATION :binary@prove) + (IS_BLS_G1_ADD :binary@prove) + (IS_BLS_G1_MSM :binary@prove) + (IS_BLS_G2_ADD :binary@prove) + (IS_BLS_G2_MSM :binary@prove) + (IS_BLS_PAIRING_CHECK :binary@prove) + (IS_BLS_MAP_FP_TO_G1 :binary@prove) + (IS_BLS_MAP_FP2_TO_G2 :binary@prove) (WCP_FLAG :binary@prove) (ADD_FLAG :binary@prove) (MOD_FLAG :binary@prove) + (BLS_REF_TABLE_FLAG :binary@prove) (OUTGOING_INST :byte :display :opcode) (OUTGOING_DATA :i128 :array [4]) (OUTGOING_RES_LO :i128)) diff --git a/oob/cancun/constants.lisp b/oob/cancun/constants.lisp index 1fbf78b93..7bc5cc7bc 100644 --- a/oob/cancun/constants.lisp +++ b/oob/cancun/constants.lisp @@ -1,30 +1,38 @@ (module oob) (defconst - CT_MAX_JUMP 0 - CT_MAX_JUMPI 1 - CT_MAX_RDC 2 - CT_MAX_CDL 0 - CT_MAX_XCALL 0 - CT_MAX_CALL 2 - CT_MAX_XCREATE 0 - CT_MAX_CREATE 4 - CT_MAX_SSTORE 0 - CT_MAX_DEPLOYMENT 0 - CT_MAX_ECRECOVER 2 - CT_MAX_SHA2 3 - CT_MAX_RIPEMD 3 - CT_MAX_IDENTITY 3 - CT_MAX_ECADD 2 - CT_MAX_ECMUL 2 - CT_MAX_ECPAIRING 4 - CT_MAX_BLAKE2F_CDS 1 - CT_MAX_BLAKE2F_PARAMS 1 - CT_MAX_MODEXP_CDS 2 - CT_MAX_MODEXP_XBS 2 - CT_MAX_MODEXP_LEAD 3 - CT_MAX_MODEXP_PRICING 5 - CT_MAX_MODEXP_EXTRACT 3 - G_QUADDIVISOR 3) + CT_MAX_JUMP 0 + CT_MAX_JUMPI 1 + CT_MAX_RDC 2 + CT_MAX_CDL 0 + CT_MAX_XCALL 0 + CT_MAX_CALL 2 + CT_MAX_XCREATE 0 + CT_MAX_CREATE 4 + CT_MAX_SSTORE 0 + CT_MAX_DEPLOYMENT 0 + CT_MAX_ECRECOVER 2 + CT_MAX_SHA2 3 + CT_MAX_RIPEMD 3 + CT_MAX_IDENTITY 3 + CT_MAX_ECADD 2 + CT_MAX_ECMUL 2 + CT_MAX_ECPAIRING 4 + CT_MAX_BLAKE2F_CDS 1 + CT_MAX_BLAKE2F_PARAMS 1 + CT_MAX_MODEXP_CDS 2 + CT_MAX_MODEXP_XBS 2 + CT_MAX_MODEXP_LEAD 3 + CT_MAX_MODEXP_PRICING 5 + CT_MAX_MODEXP_EXTRACT 3 + CT_MAX_POINT_EVALUATION 3 + CT_MAX_BLS_G1_ADD 3 + CT_MAX_BLS_G1_MSM 6 + CT_MAX_BLS_G2_ADD 3 + CT_MAX_BLS_G2_MSM 6 + CT_MAX_BLS_PAIRING_CHECK 4 + CT_MAX_BLS_MAP_FP_TO_G1 3 + CT_MAX_BLS_MAP_FP2_TO_G2 3 + G_QUADDIVISOR 3) diff --git a/oob/cancun/lookups/oob-into-blsreftable.lisp b/oob/cancun/lookups/oob-into-blsreftable.lisp new file mode 100644 index 000000000..20af8643a --- /dev/null +++ b/oob/cancun/lookups/oob-into-blsreftable.lisp @@ -0,0 +1,20 @@ +(defun (oob-into-bls-ref-table-activation-flag) + oob.BLS_REF_TABLE_FLAG) + +(defclookup + (oob-into-bls-ref-table :unchecked) + ;; target columns + ( + blsreftable.PRC_NAME + blsreftable.NUM_INPUTS + blsreftable.DISCOUNT + ) + ;; source selector + (oob-into-bls-ref-table-activation-flag) + ;; source columns + ( + oob.OUTGOING_INST + [oob.OUTGOING_DATA 1] + oob.OUTGOING_RES_LO + )) + diff --git a/oob/cancun/precompiles/common/bls/bls_msm.lisp b/oob/cancun/precompiles/common/bls/bls_msm.lisp new file mode 100644 index 000000000..2537de86d --- /dev/null +++ b/oob/cancun/precompiles/common/bls/bls_msm.lisp @@ -0,0 +1,89 @@ +(module oob) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; ;; +;; For BLS_G1_MSM and BLS_G2_MSM ;; +;; ;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defun (prc-g1msm-prc-g2msm---standard-precondition) + (+ IS_BLS_G1_MSM + IS_BLS_G2_MSM)) +(defun (msm-pair-size) + (+ (* PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_G1_MSM IS_BLS_G1_MSM) + (* PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_G2_MSM IS_BLS_G2_MSM))) +(defun (max-discount) + (+ (* PRC_BLS_G1_MSM_MAX_DISCOUNT IS_BLS_G1_MSM) + (* PRC_BLS_G2_MSM_MAX_DISCOUNT IS_BLS_G2_MSM))) +(defun (msm-multiplication-cost) + (+ (* PRC_BLS_G1_MSM_MULTIPLICATION_COST IS_BLS_G1_MSM) + (* PRC_BLS_G2_MSM_MULTIPLICATION_COST IS_BLS_G2_MSM))) +(defun (prc-g1msm-prc-g2msm---remainder) (shift OUTGOING_RES_LO 2)) +(defun (prc-g1msm-prc-g2msm---cds-is-multiple-of-msm-pair-size) (shift OUTGOING_RES_LO 3)) +(defun (prc-g1msm-prc-g2msm---num-inputs_msm-pair-size) (prc---cds)) +(defun (prc-g1msm-prc-g2msm---num-inputs-gt-128) (shift OUTGOING_RES_LO 4)) +(defun (prc-g1msm-prc-g2msm---num-inputs-leq-128) (- 1 (prc-g1msm-prc-g2msm---num-inputs-gt-128))) +(defun (prc-g1msm-prc-g2msm---discount) (shift OUTGOING_RES_LO 5)) +(defun (prc-g1msm-prc-g2msm---insufficient-gas) (shift OUTGOING_RES_LO 6)) +(defun (prc-g1msm-prc-g2msm---sufficient-gas) (- 1 (prc-g1msm-prc-g2msm---insufficient-gas))) +(defun (prc-g1msm-prc-g2msm---precompile-cost_msm-pair-size_PRC_BLS_MULTIPLICATION_MULTIPLIER) (* (prc-g1msm-prc-g2msm---num-inputs_msm-pair-size) (msm-multiplication-cost) (prc-g1msm-prc-g2msm---discount))) + + + +(defconstraint prc-g1msm-prc-g2msm---mod-cds-by-msm-pair-size (:guard (* (assumption---fresh-new-stamp) (prc-g1msm-prc-g2msm---standard-precondition))) + (call-to-MOD 2 0 (prc---cds) 0 (msm-pair-size))) + +(defconstraint prc-g1msm-prc-g2msm---check-remainder-is-zero (:guard (* (assumption---fresh-new-stamp) (prc-g1msm-prc-g2msm---standard-precondition))) + (call-to-ISZERO 3 0 (prc-g1msm-prc-g2msm---remainder))) + +(defconstraint prc-g1msm-prc-g2msm---compare-num-inputs-against-128 (:guard (* (assumption---fresh-new-stamp) (prc-g1msm-prc-g2msm---standard-precondition))) + (if-zero (prc-g1msm-prc-g2msm---cds-is-multiple-of-msm-pair-size) + (noCall 4) + (begin (vanishes! (shift ADD_FLAG 4)) + (vanishes! (shift MOD_FLAG 4)) + (eq! (shift WCP_FLAG 4) 1) + (vanishes! (shift BLS_REF_TABLE_FLAG 4)) + (eq! (shift OUTGOING_INST 4) EVM_INST_GT) + (vanishes! (shift [OUTGOING_DATA 1] 4)) + (eq! (* (shift [OUTGOING_DATA 2] 4) (msm-pair-size)) (prc-g1msm-prc-g2msm---num-inputs_msm-pair-size)) + (vanishes! (shift [OUTGOING_DATA 3] 4)) + (eq! (shift [OUTGOING_DATA 4] 4) 128)))) + +(defconstraint prc-g1-msm-prc-g2-msm---compute-discount (:guard (* (assumption---fresh-new-stamp) (prc-g1msm-prc-g2msm---standard-precondition))) + (if-zero (prc-g1msm-prc-g2msm---cds-is-multiple-of-msm-pair-size) + (noCall 5) + (if-not-zero (prc-g1msm-prc-g2msm---num-inputs-leq-128) + (begin (vanishes! (shift ADD_FLAG 5)) + (vanishes! (shift MOD_FLAG 5)) + (vanishes! (shift WCP_FLAG 5)) + (eq! (shift BLS_REF_TABLE_FLAG 5) 1) + (eq! (shift OUTGOING_INST 5) (wght-sum-prc-bls)) + (eq! (* (shift [OUTGOING_DATA 1] 5) (msm-pair-size)) (prc-g1msm-prc-g2msm---num-inputs_msm-pair-size)) + (vanishes! (shift [OUTGOING_DATA 2] 5)) + (vanishes! (shift [OUTGOING_DATA 3] 5)) + (vanishes! (shift [OUTGOING_DATA 4] 5))) + (begin (noCall 5) + (eq! (prc-g1msm-prc-g2msm---discount) (max-discount)))))) + +(defconstraint prc-g1msm-prc-g2msm---compare-call-gas-against-precompile-cost (:guard (* (assumption---fresh-new-stamp) (prc-g1msm-prc-g2msm---standard-precondition))) + (if-zero (prc-g1msm-prc-g2msm---cds-is-multiple-of-msm-pair-size) + (noCall 6) + (begin (vanishes! (shift ADD_FLAG 6)) + (vanishes! (shift MOD_FLAG 6)) + (eq! (shift WCP_FLAG 6) 1) + (vanishes! (shift BLS_REF_TABLE_FLAG 6)) + (eq! (shift OUTGOING_INST 6) EVM_INST_LT) + (vanishes! (shift [OUTGOING_DATA 1] 6)) + (eq! (shift [OUTGOING_DATA 2] 6) (prc---callee-gas)) + (vanishes! (shift [OUTGOING_DATA 3] 6)) + (eq! (* (shift [OUTGOING_DATA 4] 6) (msm-pair-size) PRC_BLS_MULTIPLICATION_MULTIPLIER) + (prc-g1msm-prc-g2msm---precompile-cost_msm-pair-size_PRC_BLS_MULTIPLICATION_MULTIPLIER))))) + +(defconstraint prc-g1msm-prc-g2msm---justify-hub-predictions (:guard (* (assumption---fresh-new-stamp) (prc-g1msm-prc-g2msm---standard-precondition))) + (begin (eq! (prc---hub-success) + (* (prc---cds-is-non-zero) (prc-g1msm-prc-g2msm---cds-is-multiple-of-msm-pair-size) (prc-g1msm-prc-g2msm---sufficient-gas))) + (if-zero (prc---hub-success) + (vanishes! (prc---return-gas)) + (eq! (* (prc---return-gas) (msm-pair-size) PRC_BLS_MULTIPLICATION_MULTIPLIER) + (- (* (prc---callee-gas) (msm-pair-size) PRC_BLS_MULTIPLICATION_MULTIPLIER) (prc-g1msm-prc-g2msm---precompile-cost_msm-pair-size_PRC_BLS_MULTIPLICATION_MULTIPLIER)))))) diff --git a/oob/cancun/precompiles/common/bls/bls_pairing_check.lisp b/oob/cancun/precompiles/common/bls/bls_pairing_check.lisp new file mode 100644 index 000000000..6726c251d --- /dev/null +++ b/oob/cancun/precompiles/common/bls/bls_pairing_check.lisp @@ -0,0 +1,44 @@ +(module oob) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; ;; +;; For BLS_PAIRING_CHECK ;; +;; ;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defun (prc-blspairingcheck---standard-precondition) IS_BLS_PAIRING_CHECK) +(defun (prc-blspairingcheck---remainder) (shift OUTGOING_RES_LO 2)) +(defun (prc-blspairingcheck---cds-is-multiple-of-bls-pairing-check-pair-size) (shift OUTGOING_RES_LO 3)) +(defun (prc-blspairingcheck---insufficient-gas) (shift OUTGOING_RES_LO 4)) +(defun (prc-blspairingcheck---sufficient-gas) (- 1 (prc-blspairingcheck---insufficient-gas))) +(defun (prc-blspairingcheck---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK) (* (prc-blspairingcheck---cds-is-multiple-of-bls-pairing-check-pair-size) + (+ (* GAS_CONST_BLS_PAIRING_CHECK PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK) (* GAS_CONST_BLS_PAIRING_CHECK_PAIR (prc---cds))))) + +(defconstraint prc-blspairingcheck---mod-cds-by-PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK (:guard (* (assumption---fresh-new-stamp) (prc-blspairingcheck---standard-precondition))) + (call-to-MOD 2 0 (prc---cds) 0 PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK)) + +(defconstraint prc-blspairingcheck---check-remainder-is-zero (:guard (* (assumption---fresh-new-stamp) (prc-blspairingcheck---standard-precondition))) + (call-to-ISZERO 3 0 (prc-blspairingcheck---remainder))) + +(defconstraint prc-blspairingcheck---compare-call-gas-against-precompile-cost (:guard (* (assumption---fresh-new-stamp) (prc-blspairingcheck---standard-precondition))) + (if-zero (prc-blspairingcheck---cds-is-multiple-of-bls-pairing-check-pair-size) + (noCall 4) + (begin (vanishes! (shift ADD_FLAG 4)) + (vanishes! (shift MOD_FLAG 4)) + (eq! (shift WCP_FLAG 4) 1) + (vanishes! (shift BLS_REF_TABLE_FLAG 4)) + (eq! (shift OUTGOING_INST 4) EVM_INST_LT) + (vanishes! (shift [OUTGOING_DATA 1] 4)) + (eq! (shift [OUTGOING_DATA 2] 4) (prc---callee-gas)) + (vanishes! (shift [OUTGOING_DATA 3] 4)) + (eq! (* (shift [OUTGOING_DATA 4] 4) PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK) + (prc-blspairingcheck---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK))))) + +(defconstraint prc-blspairingcheck---justify-hub-predictions (:guard (* (assumption---fresh-new-stamp) (prc-blspairingcheck---standard-precondition))) + (begin (eq! (prc---hub-success) + (* (prc---cds-is-non-zero) (prc-blspairingcheck---cds-is-multiple-of-bls-pairing-check-pair-size) (prc-blspairingcheck---sufficient-gas))) + (if-zero (prc---hub-success) + (vanishes! (prc---return-gas)) + (eq! (* (prc---return-gas) PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK) + (- (* (prc---callee-gas) PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK) (prc-blspairingcheck---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___BLS_PAIRING_CHECK)))))) diff --git a/oob/cancun/precompiles/common/bls/point_evaluation_bls_adds_bls_maps.lisp b/oob/cancun/precompiles/common/bls/point_evaluation_bls_adds_bls_maps.lisp new file mode 100644 index 000000000..0a4172672 --- /dev/null +++ b/oob/cancun/precompiles/common/bls/point_evaluation_bls_adds_bls_maps.lisp @@ -0,0 +1,43 @@ +(module oob) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; ;; +;; For POINT_EVALUATION, BLS_G1_ADD, BLS_G2_ADD, BLS_MAP_FP_TO_G1, BLS_MAP_FP2_TO_G2 ;; +;; ;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defun (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---standard-precondition) + (+ IS_POINT_EVALUATION + IS_BLS_G1_ADD + IS_BLS_G2_ADD + IS_BLS_MAP_FP_TO_G1 + IS_BLS_MAP_FP2_TO_G2)) +(defun (fixed-cds) + (+ (* PRECOMPILE_CALL_DATA_SIZE___POINT_EVALUATION IS_POINT_EVALUATION) + (* PRECOMPILE_CALL_DATA_SIZE___G1_ADD IS_BLS_G1_ADD) + (* PRECOMPILE_CALL_DATA_SIZE___G2_ADD IS_BLS_G2_ADD) + (* PRECOMPILE_CALL_DATA_SIZE___FP_TO_G1 IS_BLS_MAP_FP_TO_G1) + (* PRECOMPILE_CALL_DATA_SIZE___FP2_TO_G2 IS_BLS_MAP_FP2_TO_G2))) +(defun (fixed-gast-cost) + (+ (* GAS_CONST_POINT_EVALUATION IS_POINT_EVALUATION) + (* GAS_CONST_BLS_G1_ADD IS_BLS_G1_ADD) + (* GAS_CONST_BLS_G2_ADD IS_BLS_G2_ADD) + (* GAS_CONST_BLS_MAP_FP_TO_G1 IS_BLS_MAP_FP_TO_G1) + (* GAS_CONST_BLS_MAP_FP2_TO_G2 IS_BLS_MAP_FP2_TO_G2))) +(defun (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---precompile-cost) (fixed-gast-cost)) +(defun (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---valid-cds) (shift OUTGOING_RES_LO 2)) +(defun (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---sufficient-gas) (- 1 (shift OUTGOING_RES_LO 3))) + +(defconstraint prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---check-cds-validity (:guard (* (assumption---fresh-new-stamp) (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---standard-precondition))) + (call-to-EQ 2 0 (prc---cds) 0 (fixed-cds))) + +(defconstraint prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---compare-call-gas-against-precompile-cost (:guard (* (assumption---fresh-new-stamp) (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---standard-precondition))) + (call-to-LT 3 0 (prc---callee-gas) 0 (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---precompile-cost))) + +(defconstraint prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---justify-hub-predictions (:guard (* (assumption---fresh-new-stamp) (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---standard-precondition))) + (begin (eq! (prc---hub-success) (* (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---valid-cds) (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---sufficient-gas))) + (if-zero (prc---hub-success) + (vanishes! (prc---return-gas)) + (eq! (prc---return-gas) + (- (prc---callee-gas) (prc-pointevaluation-prc-blsg1add-prc-blsg2add-prc-blsmapfptog1-prc-blsmapfp2tog2---precompile-cost)))))) \ No newline at end of file diff --git a/oob/cancun/precompiles/common/common_constraints.lisp b/oob/cancun/precompiles/common/common_constraints.lisp index b778e0c9c..a043cb4e0 100644 --- a/oob/cancun/precompiles/common/common_constraints.lisp +++ b/oob/cancun/precompiles/common/common_constraints.lisp @@ -18,6 +18,7 @@ (defun (prc---empty-call-data) [DATA 7]) (defun (prc---r@c-nonzero) [DATA 8]) (defun (prc---cds-is-zero) OUTGOING_RES_LO) +(defun (prc---cds-is-non-zero) (- 1 (prc---cds-is-zero))) (defun (prc---r@c-is-zero) (next OUTGOING_RES_LO)) (defconstraint prc---check-cds-is-zero (:guard (* (assumption---fresh-new-stamp) (prc-common---standard-precondition))) diff --git a/oob/cancun/precompiles/common/ecpairing.lisp b/oob/cancun/precompiles/common/ecpairing.lisp index 56ea88a6f..9f15b0dcf 100644 --- a/oob/cancun/precompiles/common/ecpairing.lisp +++ b/oob/cancun/precompiles/common/ecpairing.lisp @@ -9,34 +9,35 @@ (defun (prc-ecpairing---standard-precondition) IS_ECPAIRING) (defun (prc-ecpairing---remainder) (shift OUTGOING_RES_LO 2)) -(defun (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) (shift OUTGOING_RES_LO 3)) +(defun (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (shift OUTGOING_RES_LO 3)) (defun (prc-ecpairing---insufficient-gas) (shift OUTGOING_RES_LO 4)) -(defun (prc-ecpairing---precompile-cost_PRC_ECPAIRING_SIZE) (* (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) - (+ (* GAS_CONST_ECPAIRING PRC_ECPAIRING_SIZE) (* GAS_CONST_ECPAIRING_PAIR (prc---cds))))) +(defun (prc-ecpairing---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (* (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) + (+ (* GAS_CONST_ECPAIRING PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (* GAS_CONST_ECPAIRING_PAIR (prc---cds))))) -(defconstraint prc-ecpairing---mod-cds-by-PRC_ECPAIRING_SIZE (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) - (call-to-MOD 2 0 (prc---cds) 0 PRC_ECPAIRING_SIZE)) +(defconstraint prc-ecpairing---mod-cds-by-PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) + (call-to-MOD 2 0 (prc---cds) 0 PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING)) (defconstraint prc-ecpairing---check-remainder-is-zero (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) (call-to-ISZERO 3 0 (prc-ecpairing---remainder))) (defconstraint prc-ecpairing---compare-call-gas-against-precompile-cost (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) - (if-zero (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) + (if-zero (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (noCall 4) (begin (vanishes! (shift ADD_FLAG 4)) (vanishes! (shift MOD_FLAG 4)) (eq! (shift WCP_FLAG 4) 1) + (vanishes! (shift BLS_REF_TABLE_FLAG 4)) (eq! (shift OUTGOING_INST 4) EVM_INST_LT) (vanishes! (shift [OUTGOING_DATA 1] 4)) (eq! (shift [OUTGOING_DATA 2] 4) (prc---callee-gas)) (vanishes! (shift [OUTGOING_DATA 3] 4)) - (eq! (* (shift [OUTGOING_DATA 4] 4) PRC_ECPAIRING_SIZE) - (prc-ecpairing---precompile-cost_PRC_ECPAIRING_SIZE))))) + (eq! (* (shift [OUTGOING_DATA 4] 4) PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) + (prc-ecpairing---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING))))) (defconstraint prc-ecpairing---justify-hub-predictions (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) (begin (eq! (prc---hub-success) - (* (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) (- 1 (prc-ecpairing---insufficient-gas)))) + (* (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (- 1 (prc-ecpairing---insufficient-gas)))) (if-zero (prc---hub-success) (vanishes! (prc---return-gas)) - (eq! (* (prc---return-gas) PRC_ECPAIRING_SIZE) - (- (* (prc---callee-gas) PRC_ECPAIRING_SIZE) (prc-ecpairing---precompile-cost_PRC_ECPAIRING_SIZE)))))) + (eq! (* (prc---return-gas) PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) + (- (* (prc---callee-gas) PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (prc-ecpairing---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING)))))) diff --git a/oob/cancun/shorthands.lisp b/oob/cancun/shorthands.lisp index 99fdecb38..fe5b3d10f 100644 --- a/oob/cancun/shorthands.lisp +++ b/oob/cancun/shorthands.lisp @@ -17,7 +17,8 @@ IS_IDENTITY IS_ECADD IS_ECMUL - IS_ECPAIRING)) + IS_ECPAIRING + (flag-sum-prc-bls))) (defun (flag-sum-prc-blake) (+ IS_BLAKE2F_CDS IS_BLAKE2F_PARAMS)) @@ -28,6 +29,19 @@ IS_MODEXP_PRICING IS_MODEXP_EXTRACT)) +(defun (flag-sum-eip-blob-transactions) IS_POINT_EVALUATION) + +(defun (flag-sum-eip-bls12-precompiles) (+ IS_BLS_G1_ADD + IS_BLS_G1_MSM + IS_BLS_G2_ADD + IS_BLS_G2_MSM + IS_BLS_PAIRING_CHECK + IS_BLS_MAP_FP_TO_G1 + IS_BLS_MAP_FP2_TO_G2)) + +(defun (flag-sum-prc-bls) (+ (flag-sum-eip-blob-transactions) + (flag-sum-eip-bls12-precompiles))) + (defun (flag-sum-prc) (+ (flag-sum-prc-common) (flag-sum-prc-blake) (flag-sum-prc-modexp))) @@ -52,7 +66,8 @@ (* OOB_INST_IDENTITY IS_IDENTITY) (* OOB_INST_ECADD IS_ECADD) (* OOB_INST_ECMUL IS_ECMUL) - (* OOB_INST_ECPAIRING IS_ECPAIRING))) + (* OOB_INST_ECPAIRING IS_ECPAIRING) + (wght-sum-prc-bls))) (defun (wght-sum-prc-blake) (+ (* OOB_INST_BLAKE_CDS IS_BLAKE2F_CDS) (* OOB_INST_BLAKE_PARAMS IS_BLAKE2F_PARAMS))) @@ -63,6 +78,19 @@ (* OOB_INST_MODEXP_PRICING IS_MODEXP_PRICING) (* OOB_INST_MODEXP_EXTRACT IS_MODEXP_EXTRACT))) +(defun (wght-sum-prc-eip-blob-transactions) (+ (* OOB_INST_POINT_EVALUATION IS_POINT_EVALUATION))) + +(defun (wght-sum-prc-eip-bls12-precompiles) (+ (* OOB_INST_BLS_G1_ADD IS_BLS_G1_ADD) + (* OOB_INST_BLS_G1_MSM IS_BLS_G1_MSM) + (* OOB_INST_BLS_G2_ADD IS_BLS_G2_ADD) + (* OOB_INST_BLS_G2_MSM IS_BLS_G2_MSM) + (* OOB_INST_BLS_PAIRING_CHECK IS_BLS_PAIRING_CHECK) + (* OOB_INST_BLS_MAP_FP_TO_G1 IS_BLS_MAP_FP_TO_G1) + (* OOB_INST_BLS_MAP_FP2_TO_G2 IS_BLS_MAP_FP2_TO_G2))) + +(defun (wght-sum-prc-bls) (+ (wght-sum-prc-eip-blob-transactions) + (wght-sum-prc-eip-bls12-precompiles))) + (defun (wght-sum-prc) (+ (wght-sum-prc-common) (wght-sum-prc-blake) (wght-sum-prc-modexp))) @@ -87,7 +115,8 @@ (* CT_MAX_IDENTITY IS_IDENTITY) (* CT_MAX_ECADD IS_ECADD) (* CT_MAX_ECMUL IS_ECMUL) - (* CT_MAX_ECPAIRING IS_ECPAIRING))) + (* CT_MAX_ECPAIRING IS_ECPAIRING) + (maxct-sum-prc-bls))) (defun (maxct-sum-prc-blake) (+ (* CT_MAX_BLAKE2F_CDS IS_BLAKE2F_CDS) (* CT_MAX_BLAKE2F_PARAMS IS_BLAKE2F_PARAMS))) @@ -98,6 +127,19 @@ (* CT_MAX_MODEXP_PRICING IS_MODEXP_PRICING) (* CT_MAX_MODEXP_EXTRACT IS_MODEXP_EXTRACT))) +(defun (maxct-sum-prc-eip-blob-transactions)(+ (* CT_MAX_POINT_EVALUATION IS_POINT_EVALUATION))) + +(defun (maxct-sum-prc-eip-bls12-precompiles)(+ (* CT_MAX_BLS_G1_ADD IS_BLS_G1_ADD) + (* CT_MAX_BLS_G1_MSM IS_BLS_G1_MSM) + (* CT_MAX_BLS_G2_ADD IS_BLS_G2_ADD) + (* CT_MAX_BLS_G2_MSM IS_BLS_G2_MSM) + (* CT_MAX_BLS_PAIRING_CHECK IS_BLS_PAIRING_CHECK) + (* CT_MAX_BLS_MAP_FP_TO_G1 IS_BLS_MAP_FP_TO_G1) + (* CT_MAX_BLS_MAP_FP2_TO_G2 IS_BLS_MAP_FP2_TO_G2))) + +(defun (maxct-sum-prc-bls) (+ (maxct-sum-prc-eip-blob-transactions) + (maxct-sum-prc-eip-bls12-precompiles))) + (defun (maxct-sum-prc) (+ (maxct-sum-prc-common) (maxct-sum-prc-blake) (maxct-sum-prc-modexp))) @@ -107,10 +149,14 @@ (defun (lookup-sum k) (+ (shift ADD_FLAG k) (shift MOD_FLAG k) - (shift WCP_FLAG k))) + (shift WCP_FLAG k) + (shift BLS_REF_TABLE_FLAG k))) (defun (wght-lookup-sum k) (+ (* 1 (shift ADD_FLAG k)) (* 2 (shift MOD_FLAG k)) - (* 3 (shift WCP_FLAG k)))) + (* 3 (shift WCP_FLAG k)) + (* 4 (shift BLS_REF_TABLE_FLAG k)))) (defun (assumption---fresh-new-stamp) (- STAMP (prev STAMP))) + +;; TODO: change maxct ot ct-max diff --git a/oob/cancun/specialized.lisp b/oob/cancun/specialized.lisp index c55ae5037..12fca7eff 100644 --- a/oob/cancun/specialized.lisp +++ b/oob/cancun/specialized.lisp @@ -52,5 +52,13 @@ (debug (vanishes! (shift [OUTGOING_DATA 3] k))) (debug (vanishes! (shift [OUTGOING_DATA 4] k))))) +(defun (call-to-bls-ref-table k prc_name num_inputs) + (begin (eq! (wght-lookup-sum k) 4) + (eq! (shift OUTGOING_INST k) prc_name) + (eq! (shift [OUTGOING_DATA 1] k) num_inputs) + (debug (eq! (shift [OUTGOING_DATA 2] k) 0)) + (debug (eq! (shift [OUTGOING_DATA 3] k) 0)) + (debug (eq! (shift [OUTGOING_DATA 4] k) 0)))) + (defun (noCall k) (begin (eq! (wght-lookup-sum k) 0))) diff --git a/oob/london/precompiles/common/ecpairing.lisp b/oob/london/precompiles/common/ecpairing.lisp index 56ea88a6f..82bc37fd3 100644 --- a/oob/london/precompiles/common/ecpairing.lisp +++ b/oob/london/precompiles/common/ecpairing.lisp @@ -9,19 +9,19 @@ (defun (prc-ecpairing---standard-precondition) IS_ECPAIRING) (defun (prc-ecpairing---remainder) (shift OUTGOING_RES_LO 2)) -(defun (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) (shift OUTGOING_RES_LO 3)) +(defun (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (shift OUTGOING_RES_LO 3)) (defun (prc-ecpairing---insufficient-gas) (shift OUTGOING_RES_LO 4)) -(defun (prc-ecpairing---precompile-cost_PRC_ECPAIRING_SIZE) (* (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) - (+ (* GAS_CONST_ECPAIRING PRC_ECPAIRING_SIZE) (* GAS_CONST_ECPAIRING_PAIR (prc---cds))))) +(defun (prc-ecpairing---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (* (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) + (+ (* GAS_CONST_ECPAIRING PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (* GAS_CONST_ECPAIRING_PAIR (prc---cds))))) -(defconstraint prc-ecpairing---mod-cds-by-PRC_ECPAIRING_SIZE (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) - (call-to-MOD 2 0 (prc---cds) 0 PRC_ECPAIRING_SIZE)) +(defconstraint prc-ecpairing---mod-cds-by-PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) + (call-to-MOD 2 0 (prc---cds) 0 PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING)) (defconstraint prc-ecpairing---check-remainder-is-zero (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) (call-to-ISZERO 3 0 (prc-ecpairing---remainder))) (defconstraint prc-ecpairing---compare-call-gas-against-precompile-cost (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) - (if-zero (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) + (if-zero (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (noCall 4) (begin (vanishes! (shift ADD_FLAG 4)) (vanishes! (shift MOD_FLAG 4)) @@ -30,13 +30,13 @@ (vanishes! (shift [OUTGOING_DATA 1] 4)) (eq! (shift [OUTGOING_DATA 2] 4) (prc---callee-gas)) (vanishes! (shift [OUTGOING_DATA 3] 4)) - (eq! (* (shift [OUTGOING_DATA 4] 4) PRC_ECPAIRING_SIZE) - (prc-ecpairing---precompile-cost_PRC_ECPAIRING_SIZE))))) + (eq! (* (shift [OUTGOING_DATA 4] 4) PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) + (prc-ecpairing---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING))))) (defconstraint prc-ecpairing---justify-hub-predictions (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) (begin (eq! (prc---hub-success) - (* (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) (- 1 (prc-ecpairing---insufficient-gas)))) + (* (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (- 1 (prc-ecpairing---insufficient-gas)))) (if-zero (prc---hub-success) (vanishes! (prc---return-gas)) - (eq! (* (prc---return-gas) PRC_ECPAIRING_SIZE) - (- (* (prc---callee-gas) PRC_ECPAIRING_SIZE) (prc-ecpairing---precompile-cost_PRC_ECPAIRING_SIZE)))))) + (eq! (* (prc---return-gas) PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) + (- (* (prc---callee-gas) PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (prc-ecpairing---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING)))))) diff --git a/oob/shanghai/precompiles/common/ecpairing.lisp b/oob/shanghai/precompiles/common/ecpairing.lisp index 56ea88a6f..82bc37fd3 100644 --- a/oob/shanghai/precompiles/common/ecpairing.lisp +++ b/oob/shanghai/precompiles/common/ecpairing.lisp @@ -9,19 +9,19 @@ (defun (prc-ecpairing---standard-precondition) IS_ECPAIRING) (defun (prc-ecpairing---remainder) (shift OUTGOING_RES_LO 2)) -(defun (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) (shift OUTGOING_RES_LO 3)) +(defun (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (shift OUTGOING_RES_LO 3)) (defun (prc-ecpairing---insufficient-gas) (shift OUTGOING_RES_LO 4)) -(defun (prc-ecpairing---precompile-cost_PRC_ECPAIRING_SIZE) (* (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) - (+ (* GAS_CONST_ECPAIRING PRC_ECPAIRING_SIZE) (* GAS_CONST_ECPAIRING_PAIR (prc---cds))))) +(defun (prc-ecpairing---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (* (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) + (+ (* GAS_CONST_ECPAIRING PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (* GAS_CONST_ECPAIRING_PAIR (prc---cds))))) -(defconstraint prc-ecpairing---mod-cds-by-PRC_ECPAIRING_SIZE (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) - (call-to-MOD 2 0 (prc---cds) 0 PRC_ECPAIRING_SIZE)) +(defconstraint prc-ecpairing---mod-cds-by-PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) + (call-to-MOD 2 0 (prc---cds) 0 PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING)) (defconstraint prc-ecpairing---check-remainder-is-zero (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) (call-to-ISZERO 3 0 (prc-ecpairing---remainder))) (defconstraint prc-ecpairing---compare-call-gas-against-precompile-cost (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) - (if-zero (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) + (if-zero (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (noCall 4) (begin (vanishes! (shift ADD_FLAG 4)) (vanishes! (shift MOD_FLAG 4)) @@ -30,13 +30,13 @@ (vanishes! (shift [OUTGOING_DATA 1] 4)) (eq! (shift [OUTGOING_DATA 2] 4) (prc---callee-gas)) (vanishes! (shift [OUTGOING_DATA 3] 4)) - (eq! (* (shift [OUTGOING_DATA 4] 4) PRC_ECPAIRING_SIZE) - (prc-ecpairing---precompile-cost_PRC_ECPAIRING_SIZE))))) + (eq! (* (shift [OUTGOING_DATA 4] 4) PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) + (prc-ecpairing---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING))))) (defconstraint prc-ecpairing---justify-hub-predictions (:guard (* (assumption---fresh-new-stamp) (prc-ecpairing---standard-precondition))) (begin (eq! (prc---hub-success) - (* (prc-ecpairing---is-multiple_PRC_ECPAIRING_SIZE) (- 1 (prc-ecpairing---insufficient-gas)))) + (* (prc-ecpairing---is-multiple_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (- 1 (prc-ecpairing---insufficient-gas)))) (if-zero (prc---hub-success) (vanishes! (prc---return-gas)) - (eq! (* (prc---return-gas) PRC_ECPAIRING_SIZE) - (- (* (prc---callee-gas) PRC_ECPAIRING_SIZE) (prc-ecpairing---precompile-cost_PRC_ECPAIRING_SIZE)))))) + (eq! (* (prc---return-gas) PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) + (- (* (prc---callee-gas) PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING) (prc-ecpairing---precompile-cost_PRECOMPILE_CALL_DATA_UNIT_SIZE___ECPAIRING)))))) diff --git a/reftables/cancun/bls_reftable.lisp b/reftables/cancun/bls_reftable.lisp new file mode 100644 index 000000000..1637700f5 --- /dev/null +++ b/reftables/cancun/bls_reftable.lisp @@ -0,0 +1,7 @@ +(module blsreftable) + +(defcolumns + (PRC_NAME :byte) + (NUM_INPUTS :i8) ;; greatest value is 128 + (DISCOUNT :i10) ;; greatest value is 1000 +)