feat(sol) add CastExpr to Solidity and EVMCastExpr to evm_proof_plan

Author: iajoiner

Diff for: crates/proof-of-sql/src/sql/evm_proof_plan/exprs.rs

@@ -4,7 +4,7 @@ use crate::{
         database::{ColumnRef, LiteralValue},
         map::IndexSet,
     },
-    sql::proof_exprs::{AddExpr, ColumnExpr, DynProofExpr, EqualsExpr, LiteralExpr, SubtractExpr},
+    sql::proof_exprs::{AddExpr, CastExpr, ColumnExpr, DynProofExpr, EqualsExpr, LiteralExpr, SubtractExpr},
 };
 use alloc::boxed::Box;
 use serde::{Deserialize, Serialize};
@@ -17,6 +17,7 @@ pub(crate) enum EVMDynProofExpr {
     Equals(EVMEqualsExpr),
     Add(EVMAddExpr),
     Subtract(EVMSubtractExpr),
+    Cast(EVMCastExpr),
 }
 impl EVMDynProofExpr {
     /// Try to create an `EVMDynProofExpr` from a `DynProofExpr`.
@@ -64,6 +65,9 @@ impl EVMDynProofExpr {
             EVMDynProofExpr::Subtract(subtract_expr) => Ok(DynProofExpr::Subtract(
                 subtract_expr.try_into_proof_expr(column_refs)?,
             )),
+            EVMDynProofExpr::Cast(cast_expr) => Ok(DynProofExpr::Cast(
+                cast_expr.try_into_proof_expr(column_refs)?,
+            )),
         }
     }
 }
@@ -263,6 +267,44 @@ impl EVMSubtractExpr {
     }
 }
 
+/// Represents a cast expression.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub(crate) struct EVMCastExpr {
+    from_expr: Box<EVMDynProofExpr>,
+}
+
+impl EVMCastExpr {
+    #[cfg_attr(not(test), expect(dead_code))]
+    pub(crate) fn new(from_expr: EVMDynProofExpr) -> Self {
+        Self {
+            from_expr: Box::new(from_expr),
+        }
+    }
+
+    /// Try to create an `EVMCastExpr` from a `CastExpr`.
+    pub(crate) fn try_from_proof_expr(
+        expr: &CastExpr,
+        column_refs: &IndexSet<ColumnRef>,
+    ) -> EVMProofPlanResult<Self> {
+        Ok(EVMCastExpr {
+            from_expr: Box::new(EVMDynProofExpr::try_from_proof_expr(
+                &expr.from_expr,
+                column_refs,
+            )?),
+        })
+    }
+
+    pub(crate) fn try_into_proof_expr(
+        &self,
+        column_refs: &IndexSet<ColumnRef>,
+    ) -> EVMProofPlanResult<CastExpr> {
+        Ok(CastExpr {
+            from_expr: Box::new(self.from_expr.try_into_proof_expr(column_refs)?),
+        })
+    }
+}
+
+
 #[cfg(test)]
 mod tests {
     use super::*;

Diff for: solidity/src/proof_exprs/AddExpr.pre.sol

@@ -77,6 +77,10 @@ library AddExpr {
             function subtract_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
                 revert(0, 0)
             }
+            // IMPORT-YUL CastExpr.pre.sol
+            function cast_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
             // IMPORT-YUL ../builder/VerificationBuilder.pre.sol
             function builder_consume_final_round_mle(builder_ptr) -> value {
                 revert(0, 0)

Diff for: solidity/src/proof_exprs/CastExpr.pre.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: UNLICENSED
+// This is licensed under the Cryptographic Open Software License 1.0
+pragma solidity ^0.8.28;
+
+import "../base/Constants.sol";
+import "../base/Errors.sol";
+import {VerificationBuilder} from "../builder/VerificationBuilder.pre.sol";
+
+/// @title CastExpr
+/// @dev Library for handling casting a proof expression
+library CastExpr {
+    /// @notice Evaluates an cast expression by casting a sub-expression
+    /// @custom:as-yul-wrapper
+    /// #### Wrapped Yul Function
+    /// ##### Signature
+    /// ```yul
+    /// cast_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval
+    /// ```
+    /// ##### Parameters
+    /// * `expr_ptr` - calldata pointer to the expression data
+    /// * `builder_ptr` - memory pointer to the verification builder
+    /// * `chi_eval` - the chi value for evaluation
+    /// ##### Return Values
+    /// * `expr_ptr_out` - pointer to the remaining expression after consuming the sub-expression
+    /// * `eval` - the evaluation result from the builder's final round MLE
+    /// @notice Evaluates a sub-expression and casts it
+    /// ##### Proof Plan Encoding
+    /// The cast expression is encoded as follows:
+    /// 1. The input expression
+    /// @param __expr The cast expression data
+    /// @param __builder The verification builder
+    /// @param __chiEval The chi value for evaluation
+    /// @return __exprOut The remaining expression after processing
+    /// @return __builderOut The verification builder result
+    /// @return __eval The evaluated result
+    function __CastExprEvaluate( // solhint-disable-line gas-calldata-parameters
+    bytes calldata __expr, VerificationBuilder.Builder memory __builder, uint256 __chiEval)
+        external
+        pure
+        returns (bytes calldata __exprOut, VerificationBuilder.Builder memory __builderOut, uint256 __eval)
+    {
+        assembly {
+            // IMPORT-YUL ../base/Errors.sol
+            function err(code) {
+                revert(0, 0)
+            }
+            // IMPORT-YUL ../base/Queue.pre.sol
+            function dequeue(queue_ptr) -> value {
+                revert(0, 0)
+            }
+            // IMPORT-YUL ../base/SwitchUtil.pre.sol
+            function case_const(lhs, rhs) {
+                revert(0, 0)
+            }
+            // IMPORT-YUL ../builder/VerificationBuilder.pre.sol
+            function builder_get_column_evaluation(builder_ptr, column_num) -> eval {
+                revert(0, 0)
+            }
+            // IMPORT-YUL ../base/Array.pre.sol
+            function get_array_element(arr_ptr, index) -> value {
+                revert(0, 0)
+            }
+            // IMPORT-YUL ColumnExpr.pre.sol
+            function column_expr_evaluate(expr_ptr, builder_ptr) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
+            // IMPORT-YUL LiteralExpr.pre.sol
+            function literal_expr_evaluate(expr_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
+            // IMPORT-YUL EqualsExpr.pre.sol
+            function equals_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
+            // IMPORT-YUL AddExpr.pre.sol
+            function add_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
+            // IMPORT-YUL SubtractExpr.pre.sol
+            function subtract_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
+            // IMPORT-YUL ../builder/VerificationBuilder.pre.sol
+            function builder_consume_final_round_mle(builder_ptr) -> value {
+                revert(0, 0)
+            }
+            // IMPORT-YUL ../builder/VerificationBuilder.pre.sol
+            function builder_produce_identity_constraint(builder_ptr, evaluation, degree) {
+                revert(0, 0)
+            }
+            // IMPORT-YUL ProofExpr.pre.sol
+            function proof_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
+
+            function cast_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, result_eval {
+                let input_eval
+                expr_ptr, input_eval := proof_expr_evaluate(expr_ptr, builder_ptr, chi_eval)
+
+                result_eval := input_eval
+                expr_ptr_out := expr_ptr
+            }
+
+            let __exprOutOffset
+            __exprOutOffset, __eval := cast_expr_evaluate(__expr.offset, __builder, __chiEval)
+            __exprOut.offset := __exprOutOffset
+            // slither-disable-next-line write-after-write
+            __exprOut.length := sub(__expr.length, sub(__exprOutOffset, __expr.offset))
+        }
+        __builderOut = __builder;
+    }
+}

Diff for: solidity/src/proof_exprs/EqualsExpr.pre.sol

@@ -103,6 +103,10 @@ library EqualsExpr {
             function subtract_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
                 revert(0, 0)
             }
+            // IMPORT-YUL CastExpr.pre.sol
+            function cast_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
             // IMPORT-YUL ../builder/VerificationBuilder.pre.sol
             function builder_consume_final_round_mle(builder_ptr) -> value {
                 revert(0, 0)

Diff for: solidity/src/proof_exprs/SubtractExpr.pre.sol

@@ -77,6 +77,10 @@ library SubtractExpr {
             function add_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
                 revert(0, 0)
             }
+            // IMPORT-YUL CastExpr.pre.sol
+            function cast_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
             // IMPORT-YUL ../builder/VerificationBuilder.pre.sol
             function builder_consume_final_round_mle(builder_ptr) -> value {
                 revert(0, 0)

Diff for: solidity/src/proof_plans/FilterExec.pre.sol

@@ -140,6 +140,10 @@ library FilterExec {
             function subtract_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
                 revert(0, 0)
             }
+            // IMPORT-YUL ../proof_exprs/CastExpr.pre.sol
+            function cast_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
             // IMPORT-YUL ../proof_exprs/ProofExpr.pre.sol
             function proof_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
                 revert(0, 0)

Diff for: solidity/src/proof_plans/ProofPlan.pre.sol

@@ -103,6 +103,10 @@ library ProofPlan {
             function subtract_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, result_eval {
                 revert(0, 0)
             }
+            // IMPORT-YUL ../proof_exprs/CastExpr.pre.sol
+            function cast_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
             // IMPORT-YUL ../proof_exprs/ProofExpr.pre.sol
             function proof_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
                 revert(0, 0)

Diff for: solidity/src/verifier/Verifier.pre.sol

@@ -278,6 +278,10 @@ library Verifier {
             function subtract_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, result_eval {
                 revert(0, 0)
             }
+            // IMPORT-YUL ../proof_exprs/CastExpr.pre.sol
+            function cast_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
+                revert(0, 0)
+            }
             // IMPORT-YUL ../proof_exprs/ProofExpr.pre.sol
             function proof_expr_evaluate(expr_ptr, builder_ptr, chi_eval) -> expr_ptr_out, eval {
                 revert(0, 0)

Diff for: solidity/test/proof_exprs/CastExpr.t.pre.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: UNLICENSED
+// This is licensed under the Cryptographic Open Software License 1.0
+pragma solidity ^0.8.28;
+
+import {Test} from "forge-std/Test.sol";
+import "../../src/base/Constants.sol";
+import {VerificationBuilder} from "../../src/builder/VerificationBuilder.pre.sol";
+import {CastExpr} from "../../src/proof_exprs/CastExpr.pre.sol";
+import {F} from "../base/FieldUtil.sol";
+
+contract CastExprTest is Test {
+    function testSimpleCastExpr() public pure {
+        bytes memory expr = abi.encodePacked(
+            abi.encodePacked(LITERAL_EXPR_VARIANT, LITERAL_BIGINT_VARIANT, int64(7)),
+            hex"abcdef"
+        );
+        VerificationBuilder.Builder memory builder;
+
+        uint256 eval;
+        (expr, builder, eval) = CastExpr.__CastExprEvaluate(expr, builder, 10);
+
+        assert(eval == 70);
+        bytes memory expectedExprOut = hex"abcdef";
+        assert(expr.length == expectedExprOut.length);
+        uint256 exprOutLength = expr.length;
+        for (uint256 i = 0; i < exprOutLength; ++i) {
+            assert(expr[i] == expectedExprOut[i]);
+        }
+    }
+
+    function testFuzzCastExpr(
+        VerificationBuilder.Builder memory builder,
+        uint256 chiEvaluation,
+        int64 inputValue,
+        bytes memory trailingExpr
+    ) public pure {
+        bytes memory expr = abi.encodePacked(
+            abi.encodePacked(LITERAL_EXPR_VARIANT, LITERAL_BIGINT_VARIANT, inputValue),
+            trailingExpr
+        );
+
+        uint256 eval;
+        (expr, builder, eval) = CastExpr.__CastExprEvaluate(expr, builder, chiEvaluation);
+
+        assert(eval == (F.from(inputValue) * F.from(chiEvaluation)).into());
+        assert(expr.length == trailingExpr.length);
+        uint256 exprOutLength = expr.length;
+        for (uint256 i = 0; i < exprOutLength; ++i) {
+            assert(expr[i] == trailingExpr[i]);
+        }
+    }
+}