chore: fhevm-listener, handle is bytes32

Author: rudy-6-4

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

@@ -3,7 +3,7 @@ use bigdecimal::num_bigint::BigInt;
 
 use fhevm_listener::contracts::TfheContract;
 use fhevm_listener::contracts::TfheContract::TfheContractEvents;
-use fhevm_listener::database::tfhe_event_propagate::{Database as ListenerDatabase, Handle, ToType};
+use fhevm_listener::database::tfhe_event_propagate::{ClearConst, Database as ListenerDatabase, Handle, ToType};
 
 
 use crate::tests::operators::{generate_binary_test_cases, generate_unary_test_cases};
@@ -26,9 +26,14 @@ fn tfhe_event(data: TfheContractEvents) -> Log<TfheContractEvents> {
     Log::<TfheContractEvents>{address, data}
 }
 
-fn as_scalar(big_int: &BigInt) -> Handle {
+fn as_scalar_handle(big_int: &BigInt) -> Handle {
     let (_, bytes) = big_int.to_bytes_be();
-    Handle::from_be_slice(&bytes)
+    Handle::right_padding_from(&bytes)
+}
+
+fn as_scalar_uint(big_int: &BigInt) -> ClearConst {
+    let (_, bytes) = big_int.to_bytes_be();
+    ClearConst::from_be_slice(&bytes)
 }
 
 fn to_bytes(big_int: &BigInt) -> Bytes {
@@ -53,7 +58,7 @@ fn binary_op_to_event(op: &BinaryOperatorTestCase, lhs: &Handle, rhs: &Handle, r
     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(r_scalar)
+        as_scalar_handle(r_scalar)
     } else {
         rhs.clone()
     };
@@ -95,7 +100,7 @@ fn next_handle() -> Handle {
     #[allow(non_upper_case_globals)]
     static count: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
     let v = count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-    Handle::from_limbs([1, 2, 3, v])
+    as_scalar_handle(&BigInt::from(v))
 }
 
 async fn listener_event_to_db(app: &TestInstance) -> ListenerDatabase {
@@ -160,7 +165,7 @@ async fn test_fhe_binary_operands_events() -> Result<(), Box<dyn std::error::Err
 
     wait_until_all_ciphertexts_computed(&app).await?;
     for (op, output_handle) in cases {
-        let decrypt_request = vec![output_handle.to_be_bytes_vec()];
+        let decrypt_request = vec![output_handle.to_vec()];
         let resp = decrypt_ciphertexts(&pool, 1, decrypt_request).await?;
         let decr_response = &resp[0];
         println!("Checking computation for binary test bits:{} op:{} is_scalar:{} lhs:{} rhs:{} output:{}",
@@ -243,7 +248,7 @@ async fn test_fhe_unary_operands_events() -> Result<(), Box<dyn std::error::Erro
         listener_event_to_db.notify_scheduler().await;
         wait_until_all_ciphertexts_computed(&app).await?;
 
-        let decrypt_request = vec![output_handle.to_be_bytes_vec()];
+        let decrypt_request = vec![output_handle.to_vec()];
         let resp = decrypt_ciphertexts(&pool, 1, decrypt_request).await?;
         let decr_response = &resp[0];
         println!(
@@ -350,7 +355,7 @@ async fn test_fhe_if_then_else_events() -> Result<(), Box<dyn std::error::Error>
             )).await?;
             listener_event_to_db.notify_scheduler().await;
             wait_until_all_ciphertexts_computed(&app).await?;
-            let decrypt_request = vec![output_handle.to_be_bytes_vec()];
+            let decrypt_request = vec![output_handle.to_vec()];
             let resp = decrypt_ciphertexts(&pool, 1, decrypt_request).await?;
             let decr_response = &resp[0];
             println!(
@@ -422,7 +427,7 @@ async fn test_fhe_cast_events() -> Result<(), Box<dyn std::error::Error>> {
 
             listener_event_to_db.notify_scheduler().await;
             wait_until_all_ciphertexts_computed(&app).await?;
-            let decrypt_request = vec![output_handle.to_be_bytes_vec()];
+            let decrypt_request = vec![output_handle.to_vec()];
             let resp = decrypt_ciphertexts(&pool, 1, decrypt_request).await?;
             let decr_response = &resp[0];
 
@@ -486,7 +491,7 @@ async fn test_fhe_rand_events() -> Result<(), Box<dyn std::error::Error>> {
         listener_event_to_db.insert_tfhe_event(&tfhe_event(
             TfheContractEvents::FheRandBounded(TfheContract::FheRandBounded {
                 caller,
-                upperBound: as_scalar(&BigInt::from(1)),
+                upperBound: as_scalar_uint(&BigInt::from(1)),
                 randType: to_ty(rand_type),
                 seed: FixedBytes::from([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]),
                     result: output3_handle.clone()
@@ -496,7 +501,7 @@ async fn test_fhe_rand_events() -> Result<(), Box<dyn std::error::Error>> {
         listener_event_to_db.notify_scheduler().await;
         wait_until_all_ciphertexts_computed(&app).await?;
 
-        let decrypt_request = vec![output1_handle.to_be_bytes_vec(), output2_handle.to_be_bytes_vec(), output3_handle.to_be_bytes_vec()];
+        let decrypt_request = vec![output1_handle.to_vec(), output2_handle.to_vec(), output3_handle.to_vec()];
         let resp = decrypt_ciphertexts(&pool, 1, decrypt_request).await?;
         assert_eq!(resp[0].output_type, rand_type as i16);
         assert_eq!(resp[1].output_type, rand_type as i16);