fix(coprocessor): sync with contract fhe events

Author: rudy-6-4

.github/workflows/coprocessor-cargo-tests.yml

@@ -26,6 +26,7 @@ jobs:
               - .github/workflows/coprocessor-cargo-tests.yml
               - coprocessor/fhevm-engine/**
               - coprocessor/proto/**
+              - host-contracts/**
   cargo-tests:
     needs: check-changes
     if: ${{ needs.check-changes.outputs.changes-rust-files == 'true' }}

coprocessor/fhevm-engine/coprocessor/src/tests/operators_from_events.rs

@@ -74,8 +74,6 @@ fn binary_op_to_event(
     #[allow(non_snake_case)]
     let scalarByte = s_byte(op.is_scalar);
     let lhs = *lhs;
-    let use_bytes_when_avail = op.is_scalar && op.bits > 256;
-    let rhs_bytes = to_bytes(r_scalar);
     let rhs = if op.is_scalar && op.bits <= 256 {
         as_scalar_handle(r_scalar)
     } else {
@@ -209,44 +207,20 @@ fn binary_op_to_event(
             scalarByte,
             result,
         }),
-        S::FheEq => {
-            if use_bytes_when_avail {
-                E::FheEqBytes(C::FheEqBytes {
-                    caller,
-                    lhs,
-                    rhs: rhs_bytes,
-                    scalarByte,
-                    result,
-                })
-            } else {
-                E::FheEq(C::FheEq {
-                    caller,
-                    lhs,
-                    rhs,
-                    scalarByte,
-                    result,
-                })
-            }
-        }
-        S::FheNe => {
-            if use_bytes_when_avail {
-                E::FheNeBytes(C::FheNeBytes {
-                    caller,
-                    lhs,
-                    rhs: rhs_bytes,
-                    scalarByte,
-                    result,
-                })
-            } else {
-                E::FheNe(C::FheNe {
-                    caller,
-                    lhs,
-                    rhs,
-                    scalarByte,
-                    result,
-                })
-            }
-        }
+        S::FheEq => E::FheEq(C::FheEq {
+            caller,
+            lhs,
+            rhs,
+            scalarByte,
+            result,
+        }),
+        S::FheNe => E::FheNe(C::FheNe {
+            caller,
+            lhs,
+            rhs,
+            scalarByte,
+            result,
+        }),
         _ => panic!("unknown operation: {:?}", op.operator),
     }
 }
@@ -287,8 +261,8 @@ async fn test_fhe_binary_operands_events() -> Result<(), Box<dyn std::error::Err
         let rhs_handle = next_handle();
         let output_handle = next_handle();
 
-        let lhs_bytes = to_bytes(&op.lhs);
-        let rhs_bytes = to_bytes(&op.rhs);
+        let lhs_bytes = as_scalar_uint(&op.lhs);
+        let rhs_bytes = as_scalar_uint(&op.rhs);
 
         println!(
             "Operations for binary test bits:{} op:{} is_scalar:{} lhs:{} rhs:{}",
@@ -298,8 +272,8 @@ async fn test_fhe_binary_operands_events() -> Result<(), Box<dyn std::error::Err
             .parse()
             .unwrap();
         listener_event_to_db
-            .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncryptBytes(
-                TfheContract::TrivialEncryptBytes {
+            .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncrypt(
+                TfheContract::TrivialEncrypt {
                     caller,
                     pt: lhs_bytes,
                     toType: to_ty(op.input_types),
@@ -309,8 +283,8 @@ async fn test_fhe_binary_operands_events() -> Result<(), Box<dyn std::error::Err
             .await?;
         if !op.is_scalar {
             listener_event_to_db
-                .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncryptBytes(
-                    TfheContract::TrivialEncryptBytes {
+                .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncrypt(
+                    TfheContract::TrivialEncrypt {
                         caller,
                         pt: rhs_bytes,
                         toType: to_ty(op.input_types),
@@ -402,7 +376,7 @@ async fn test_fhe_unary_operands_events() -> Result<(), Box<dyn std::error::Erro
         let input_handle = next_handle();
         let output_handle = next_handle();
 
-        let inp_bytes = to_bytes(&op.inp);
+        let inp_bytes = as_scalar_uint(&op.inp);
 
         println!(
             "Operations for unary test bits:{} op:{} input:{}",
@@ -413,8 +387,8 @@ async fn test_fhe_unary_operands_events() -> Result<(), Box<dyn std::error::Erro
             .parse()
             .unwrap();
         listener_event_to_db
-            .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncryptBytes(
-                TfheContract::TrivialEncryptBytes {
+            .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncrypt(
+                TfheContract::TrivialEncrypt {
                     caller,
                     pt: inp_bytes,
                     toType: to_ty(op.operand_types),
@@ -472,21 +446,21 @@ async fn test_fhe_if_then_else_events() -> Result<(), Box<dyn std::error::Error>
         .unwrap();
 
     listener_event_to_db
-        .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncryptBytes(
-            TfheContract::TrivialEncryptBytes {
+        .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncrypt(
+            TfheContract::TrivialEncrypt {
                 caller,
-                pt: to_bytes(&BigInt::from(0)),
+                pt: as_scalar_uint(&BigInt::from(0)),
                 toType: to_ty(fhe_bool_type),
                 result: false_handle,
             },
         )))
         .await?;
 
     listener_event_to_db
-        .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncryptBytes(
-            TfheContract::TrivialEncryptBytes {
+        .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncrypt(
+            TfheContract::TrivialEncrypt {
                 caller,
-                pt: to_bytes(&BigInt::from(1)),
+                pt: as_scalar_uint(&BigInt::from(1)),
                 toType: to_ty(fhe_bool_type),
                 result: true_handle,
             },
@@ -504,21 +478,21 @@ async fn test_fhe_if_then_else_events() -> Result<(), Box<dyn std::error::Error>
         };
 
         listener_event_to_db
-            .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncryptBytes(
-                TfheContract::TrivialEncryptBytes {
+            .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncrypt(
+                TfheContract::TrivialEncrypt {
                     caller,
-                    pt: to_bytes(&left_input),
+                    pt: as_scalar_uint(&left_input),
                     toType: to_ty(*input_types),
                     result: left_handle,
                 },
             )))
             .await?;
 
         listener_event_to_db
-            .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncryptBytes(
-                TfheContract::TrivialEncryptBytes {
+            .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncrypt(
+                TfheContract::TrivialEncrypt {
                     caller,
-                    pt: to_bytes(&right_input),
+                    pt: as_scalar_uint(&right_input),
                     toType: to_ty(*input_types),
                     result: right_handle,
                 },
@@ -604,10 +578,10 @@ async fn test_fhe_cast_events() -> Result<(), Box<dyn std::error::Error>> {
             );
 
             listener_event_to_db
-                .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncryptBytes(
-                    TfheContract::TrivialEncryptBytes {
+                .insert_tfhe_event(&tfhe_event(TfheContractEvents::TrivialEncrypt(
+                    TfheContract::TrivialEncrypt {
                         caller,
-                        pt: to_bytes(&BigInt::from(input)),
+                        pt: as_scalar_uint(&BigInt::from(input)),
                         toType: to_ty(*type_from),
                         result: input_handle,
                     },

coprocessor/fhevm-engine/fhevm-listener/contracts/FHEVMExecutorTest.sol

@@ -57,18 +57,10 @@ contract FHEVMExecutorTest is FHEEvents {
         bytes32 result = bytes32(keccak256(abi.encodePacked("fheEq", lhs, rhs, scalarByte)));
         emit FheEq(msg.sender, lhs, rhs, scalarByte, result);
     }
-    function fheEq(bytes32 lhs, bytes memory rhs, bytes1 scalarByte) public {
-        bytes32 result = bytes32(keccak256(abi.encodePacked("fheEqBytes", lhs, rhs, scalarByte)));
-        emit FheEqBytes(msg.sender, lhs, rhs, scalarByte, result);
-    }
     function fheNe(bytes32 lhs, bytes32 rhs, bytes1 scalarByte) public {
         bytes32 result = bytes32(keccak256(abi.encodePacked("fheNe", lhs, rhs, scalarByte)));
         emit FheNe(msg.sender, lhs, rhs, scalarByte, result);
     }
-    function fheNe(bytes32 lhs, bytes memory rhs, bytes1 scalarByte) public {
-        bytes32 result = bytes32(keccak256(abi.encodePacked("fheNeBytes", lhs, rhs, scalarByte)));
-        emit FheNeBytes(msg.sender, lhs, rhs, scalarByte, result);
-    }
     function fheGe(bytes32 lhs, bytes32 rhs, bytes1 scalarByte) public {
         bytes32 result = bytes32(keccak256(abi.encodePacked("fheGe", lhs, rhs, scalarByte)));
         emit FheGe(msg.sender, lhs, rhs, scalarByte, result);
@@ -120,14 +112,9 @@ contract FHEVMExecutorTest is FHEEvents {
         emit Cast(msg.sender, ct, toType, result);
     }
 
-    function trivialEncrypt(uint256 pt, FheType toType) public {
-        bytes32 result = bytes32(keccak256(abi.encodePacked("trivialEncrypt", pt, toType)));
-        emit TrivialEncrypt(msg.sender, pt, toType, result);
-    }
-
-    function trivialEncrypt(bytes memory pt, FheType toType) public {
-        bytes32 result = bytes32(keccak256(abi.encodePacked("trivialEncryptBytes", pt, toType)));
-        emit TrivialEncryptBytes(msg.sender, pt, toType, result);
+    function trivialEncrypt(uint256 val, FheType toType) public {
+        bytes32 result = bytes32(keccak256(abi.encodePacked("trivialEncrypt", val, toType)));
+        emit TrivialEncrypt(msg.sender, val, toType, result);
     }
 
     function verifyCiphertext(

coprocessor/fhevm-engine/fhevm-listener/src/database/tfhe_event_propagate.rs

@@ -263,10 +263,6 @@ impl Database {
             | E::FheNot(C::FheNot {ct, result, ..})
             => self.insert_computation(tenant_id, result, &[ct], fhe_operation, &NO_SCALAR).await,
 
-            | E::FheEqBytes(C::FheEqBytes {lhs, rhs, scalarByte, result, ..})
-            | E::FheNeBytes(C::FheNeBytes {lhs, rhs, scalarByte, result, ..})
-            => self.insert_computation_bytes(tenant_id, result, &[lhs], &[rhs.to_vec()], fhe_operation, scalarByte).await,
-
             | E::FheRand(C::FheRand {randType, seed, result, ..})
             => self.insert_computation_bytes(tenant_id, result, &[], &[seed.to_vec(), ty(randType)], fhe_operation, &HAS_SCALAR).await,
 
@@ -276,9 +272,6 @@ impl Database {
             | E::TrivialEncrypt(C::TrivialEncrypt {pt, toType, result, ..})
             => self.insert_computation_bytes(tenant_id, result, &[], &[as_bytes(pt), ty(toType)], fhe_operation, &HAS_SCALAR).await,
 
-            | E::TrivialEncryptBytes(C::TrivialEncryptBytes {pt, toType, result, ..})
-            => self.insert_computation_bytes(tenant_id, result, &[], &[pt.to_vec(), ty(toType)], fhe_operation, &HAS_SCALAR).await,
-
             | E::Initialized(_)
             | E::OwnershipTransferStarted(_)
             | E::OwnershipTransferred(_)
@@ -528,8 +521,8 @@ fn event_to_op_int(op: &TfheContractEvents) -> FheOperation {
         E::FheShr(_) => O::FheShr as i32,
         E::FheRotl(_) => O::FheRotl as i32,
         E::FheRotr(_) => O::FheRotr as i32,
-        E::FheEq(_) | E::FheEqBytes(_) => O::FheEq as i32,
-        E::FheNe(_) | E::FheNeBytes(_) => O::FheNe as i32,
+        E::FheEq(_) => O::FheEq as i32,
+        E::FheNe(_) => O::FheNe as i32,
         E::FheGe(_) => O::FheGe as i32,
         E::FheGt(_) => O::FheGt as i32,
         E::FheLe(_) => O::FheLe as i32,
@@ -539,7 +532,7 @@ fn event_to_op_int(op: &TfheContractEvents) -> FheOperation {
         E::FheNeg(_) => O::FheNeg as i32,
         E::FheNot(_) => O::FheNot as i32,
         E::Cast(_) => O::FheCast as i32,
-        E::TrivialEncrypt(_) | E::TrivialEncryptBytes(_) => {
+        E::TrivialEncrypt(_) => {
             O::FheTrivialEncrypt as i32
         }
         E::FheIfThenElse(_) => O::FheIfThenElse as i32,
@@ -569,8 +562,8 @@ pub fn event_name(op: &TfheContractEvents) -> &'static str {
         E::FheShr(_) => "FheShr",
         E::FheRotl(_) => "FheRotl",
         E::FheRotr(_) => "FheRotr",
-        E::FheEq(_) | E::FheEqBytes(_) => "FheEq",
-        E::FheNe(_) | E::FheNeBytes(_) => "FheNe",
+        E::FheEq(_) => "FheEq",
+        E::FheNe(_) => "FheNe",
         E::FheGe(_) => "FheGe",
         E::FheGt(_) => "FheGt",
         E::FheLe(_) => "FheLe",
@@ -580,7 +573,7 @@ pub fn event_name(op: &TfheContractEvents) -> &'static str {
         E::FheNeg(_) => "FheNeg",
         E::FheNot(_) => "FheNot",
         E::Cast(_) => "FheCast",
-        E::TrivialEncrypt(_) | E::TrivialEncryptBytes(_) => "FheTrivialEncrypt",
+        E::TrivialEncrypt(_) => "FheTrivialEncrypt",
         E::FheIfThenElse(_) => "FheIfThenElse",
         E::FheRand(_) => "FheRand",
         E::FheRandBounded(_) => "FheRandBounded",