refactor: Remove data results from post result sudo msg

src/msgs/data_requests/query.rs

@@ -15,8 +15,6 @@ pub enum QueryMsg {
     GetDataRequestReveal { dr_id: String, public_key: String },
     #[cfg_attr(feature = "cosmwasm",  returns(HashMap<String, RevealBody>))]
     GetDataRequestReveals { dr_id: String },
-    #[cfg_attr(feature = "cosmwasm", returns(Option<DataResult>))]
-    GetDataResult { dr_id: String },
     #[cfg_attr(feature = "cosmwasm",  returns(Vec<DataRequest>))]
     GetDataRequestsByStatus {
         status: DataRequestStatus,

src/msgs/data_requests/query_tests.rs

@@ -92,23 +92,6 @@ fn json_get_data_request_reveals() {
     assert_json_deser(msg, expected_json);
 }
 
-#[test]
-fn json_get_data_result() {
-    let expected_json = json!({
-      "get_data_result": {
-        "dr_id": "dr_id",
-      }
-    });
-    let msg: QueryMsg = DrQueryMsg::GetDataResult {
-        dr_id: "dr_id".to_string(),
-    }
-    .into();
-    #[cfg(not(feature = "cosmwasm"))]
-    assert_json_ser(msg, expected_json);
-    #[cfg(feature = "cosmwasm")]
-    assert_json_deser(msg, expected_json);
-}
-
 #[test]
 fn json_get_data_requests_by_status() {
     let expected_json = json!({

src/msgs/data_requests/sudo/mod.rs

@@ -1,29 +1,25 @@
-use super::*;
-
 pub mod expire_data_requests;
-pub mod post_results;
+pub mod remove_requests;
 
-#[cfg_attr(feature = "cosmwasm", cw_serde)]
+#[cfg_attr(feature = "cosmwasm", cosmwasm_schema::cw_serde)]
 #[cfg_attr(not(feature = "cosmwasm"), derive(serde::Serialize, Debug, PartialEq))]
 #[cfg_attr(not(feature = "cosmwasm"), serde(rename_all = "snake_case"))]
-pub struct PostResult {
-    pub dr_id:     String,
-    pub result:    DataResult,
-    pub exit_code: u8,
+pub struct RemoveDataRequest {
+    pub dr_id: String,
 }
 
-impl From<PostResult> for crate::msgs::SudoMsg {
-    fn from(value: PostResult) -> Self {
-        SudoMsg::PostDataResult(value).into()
+impl From<RemoveDataRequest> for crate::msgs::SudoMsg {
+    fn from(value: RemoveDataRequest) -> Self {
+        SudoMsg::RemoveDataRequest(value).into()
     }
 }
 
-#[cfg_attr(feature = "cosmwasm", cw_serde)]
+#[cfg_attr(feature = "cosmwasm", cosmwasm_schema::cw_serde)]
 #[cfg_attr(not(feature = "cosmwasm"), derive(serde::Serialize, Debug, PartialEq))]
 #[cfg_attr(not(feature = "cosmwasm"), serde(rename_all = "snake_case"))]
 pub enum SudoMsg {
-    PostDataResult(PostResult),
-    PostDataResults(post_results::Sudo),
+    RemoveDataRequest(RemoveDataRequest),
+    RemoveDataRequests(remove_requests::Sudo),
     ExpireDataRequests(expire_data_requests::Sudo),
 }
 

src/msgs/data_requests/sudo/post_results.rs → src/msgs/data_requests/sudo/remove_requests.rs

@@ -1,14 +1,14 @@
 use super::*;
 
-#[cfg_attr(feature = "cosmwasm", cw_serde)]
+#[cfg_attr(feature = "cosmwasm", cosmwasm_schema::cw_serde)]
 #[cfg_attr(not(feature = "cosmwasm"), derive(serde::Serialize, Debug, PartialEq))]
 #[cfg_attr(not(feature = "cosmwasm"), serde(rename_all = "snake_case"))]
 pub struct Sudo {
-    pub results: Vec<PostResult>,
+    pub requests: Vec<RemoveDataRequest>,
 }
 
 impl From<Sudo> for crate::msgs::SudoMsg {
     fn from(value: Sudo) -> Self {
-        super::SudoMsg::PostDataResults(value).into()
+        super::SudoMsg::RemoveDataRequests(value).into()
     }
 }

src/msgs/data_requests/sudo_tests.rs

@@ -1,61 +1,17 @@
-use semver::Version;
 use serde_json::json;
 
-#[cfg(feature = "cosmwasm")]
-use super::Bytes;
-use super::{sudo::*, DataResult, SudoMsg};
+use super::{sudo::*, SudoMsg};
 use crate::msgs::*;
 
 #[test]
-fn json_post_result() {
-    #[cfg(not(feature = "cosmwasm"))]
-    let result_bytes = "result".to_string();
-    #[cfg(feature = "cosmwasm")]
-    let result_bytes: Bytes = "result".as_bytes().into();
-
-    let gas_used = 100;
-
-    #[cfg(not(feature = "cosmwasm"))]
-    let seda_payload = "seda_payload".to_string();
-    #[cfg(feature = "cosmwasm")]
-    let seda_payload: Bytes = "seda_payload".as_bytes().into();
-
-    #[cfg(not(feature = "cosmwasm"))]
-    let payback_address = "payback_address".to_string();
-    #[cfg(feature = "cosmwasm")]
-    let payback_address: Bytes = "payback_address".as_bytes().into();
-    let result = DataResult {
-        version: Version::new(1, 0, 0),
-        dr_id: "dr_id".to_string(),
-        block_height: 100,
-        exit_code: 0,
-        gas_used,
-        result: result_bytes.clone(),
-        payback_address: payback_address.clone(),
-        seda_payload: seda_payload.clone(),
-        consensus: false,
-    };
+fn json_remove_request() {
     let expected_json = json!({
-    "post_data_result": {
+    "remove_data_request": {
       "dr_id": "dr_id",
-      "result": {
-        "version": "1.0.0",
-        "dr_id": "dr_id",
-        "block_height": 100,
-        "exit_code": 0,
-        "gas_used": gas_used,
-        "result": result_bytes,
-        "payback_address": payback_address,
-        "seda_payload": seda_payload,
-        "consensus": false,
-      },
-      "exit_code": 0,
     }
     });
-    let msg: SudoMsg = PostResult {
+    let msg: SudoMsg = RemoveDataRequest {
         dr_id: "dr_id".to_string(),
-        result,
-        exit_code: 0,
     }
     .into();
     #[cfg(not(feature = "cosmwasm"))]

src/msgs/data_requests/types.rs

@@ -1,7 +1,5 @@
 #[cfg(not(feature = "cosmwasm"))]
 use base64::{prelude::BASE64_STANDARD, Engine};
-#[cfg(feature = "cosmwasm")]
-use cw_storage_plus::{Key, Prefixer, PrimaryKey};
 use semver::Version;
 use sha3::{Digest, Keccak256};
 
@@ -16,29 +14,6 @@ pub enum DataRequestStatus {
     Tallying,
 }
 
-#[cfg(feature = "cosmwasm")]
-impl<'a> PrimaryKey<'a> for DataRequestStatus {
-    type Prefix = ();
-    type SubPrefix = ();
-    type Suffix = &'static str;
-    type SuperSuffix = &'static str;
-
-    fn key(&self) -> Vec<Key> {
-        vec![Key::Val8(match self {
-            DataRequestStatus::Committing => [0],
-            DataRequestStatus::Revealing => [1],
-            DataRequestStatus::Tallying => [2],
-        })]
-    }
-}
-
-#[cfg(feature = "cosmwasm")]
-impl<'a> Prefixer<'a> for DataRequestStatus {
-    fn prefix(&self) -> Vec<Key> {
-        self.key()
-    }
-}
-
 /// Represents a data request at creation time
 #[cfg_attr(feature = "cosmwasm", cw_serde)]
 #[cfg_attr(not(feature = "cosmwasm"), derive(Serialize, Deserialize, Clone, Debug, PartialEq))]
@@ -109,86 +84,6 @@ impl DataRequest {
     }
 }
 
-/// Represents a resolved data result
-#[cfg_attr(feature = "cosmwasm", cw_serde)]
-#[cfg_attr(not(feature = "cosmwasm"), derive(Serialize, Deserialize, Debug, PartialEq))]
-#[cfg_attr(not(feature = "cosmwasm"), serde(rename_all = "snake_case"))]
-pub struct DataResult {
-    // DR Result
-    /// Semantic Version String
-    pub version: Version,
-
-    /// Data Request Identifier
-    pub dr_id:        String,
-    ///  Represents whether the result was in consensus or not (≥ 66%)
-    pub consensus:    bool,
-    /// Exit code of Tally WASM binary execution
-    pub exit_code:    u8,
-    /// Result from Tally WASM binary execution
-    pub result:       Bytes,
-    /// Block Height at which data request was finalized
-    pub block_height: u64,
-    /// Gas used by the complete data request execution
-    pub gas_used:     u64,
-
-    // Fields from Data Request Execution
-    /// Payback address set by the relayer
-    pub payback_address: Bytes,
-    /// Payload set by SEDA Protocol (e.g. OEV-enabled data requests)
-    pub seda_payload:    Bytes,
-}
-
-impl TryHashSelf for DataResult {
-    fn try_hash(&self) -> Result<Hash> {
-        let version = self.version.hash();
-        let dr_id = hex::decode(&self.dr_id)?;
-        let consensus: [u8; 1] = [self.consensus.into()];
-        let exit_code = self.exit_code.to_be_bytes();
-
-        let mut result_hasher = Keccak256::new();
-        #[cfg(feature = "cosmwasm")]
-        result_hasher.update(self.result.as_slice());
-        #[cfg(not(feature = "cosmwasm"))]
-        result_hasher.update(BASE64_STANDARD.decode(&self.result)?);
-        let result_hash = result_hasher.finalize();
-
-        let block_height = self.block_height.to_be_bytes();
-        #[cfg(feature = "cosmwasm")]
-        let gas_used = self.gas_used.to_be_bytes();
-        #[cfg(not(feature = "cosmwasm"))]
-        let gas_used = self.gas_used.to_be_bytes();
-
-        let mut payback_hasher = Keccak256::new();
-        #[cfg(feature = "cosmwasm")]
-        payback_hasher.update(self.payback_address.as_slice());
-        #[cfg(not(feature = "cosmwasm"))]
-        payback_hasher.update(BASE64_STANDARD.decode(&self.payback_address)?);
-        let seda_payback_hash = payback_hasher.finalize();
-
-        let mut seda_payload_hasher = Keccak256::new();
-        #[cfg(feature = "cosmwasm")]
-        seda_payload_hasher.update(self.seda_payload.as_slice());
-        #[cfg(not(feature = "cosmwasm"))]
-        seda_payload_hasher.update(BASE64_STANDARD.decode(&self.seda_payload)?);
-        let seda_payload_hash = seda_payload_hasher.finalize();
-
-        let bytes = [
-            version.as_slice(),
-            &dr_id,
-            &consensus,
-            &exit_code,
-            &result_hash,
-            &block_height,
-            &gas_used,
-            &seda_payback_hash,
-            &seda_payload_hash,
-        ]
-        .concat();
-
-        Ok(Keccak256::digest(bytes).into())
-    }
-}
-
 /// A revealed data request result that is hashed and signed by the executor
 #[cfg_attr(feature = "cosmwasm", cw_serde)]
 #[cfg_attr(not(feature = "cosmwasm"), derive(Serialize, Deserialize, Clone, Debug, PartialEq))]

src/msgs/data_requests/types_tests.rs

@@ -4,7 +4,7 @@ use serde_json::json;
 
 #[cfg(feature = "cosmwasm")]
 use super::Bytes;
-use super::{DataRequest, DataResult, HashSelf, PostDataRequestArgs, RevealBody, TimeoutConfig};
+use super::{DataRequest, HashSelf, PostDataRequestArgs, RevealBody, TimeoutConfig};
 use crate::msgs::*;
 
 #[test]
@@ -88,56 +88,6 @@ fn json_data_request() {
     assert_json_deser(msg, expected_json);
 }
 
-#[test]
-fn json_data_result() {
-    let version = "1.0.0".to_string();
-    let dr_id = "dr_id".to_string();
-    let consensus = true;
-    let exit_code = 0;
-    #[cfg(not(feature = "cosmwasm"))]
-    let result = "result".to_string();
-    #[cfg(feature = "cosmwasm")]
-    let result: Bytes = "result".as_bytes().into();
-    let block_height = 1;
-    let gas_used = 1;
-    #[cfg(not(feature = "cosmwasm"))]
-    let payback_address = "payback_address".to_string();
-    #[cfg(feature = "cosmwasm")]
-    let payback_address: Bytes = "payback_address".as_bytes().into();
-    #[cfg(not(feature = "cosmwasm"))]
-    let seda_payload = "seda_payload".to_string();
-    #[cfg(feature = "cosmwasm")]
-    let seda_payload: Bytes = "seda_payload".as_bytes().into();
-
-    let expected_json = json!({
-      "version": version,
-      "dr_id": dr_id,
-      "consensus": consensus,
-      "exit_code": exit_code,
-      "result": result,
-      "block_height": block_height,
-      "gas_used": gas_used,
-      "payback_address": payback_address,
-      "seda_payload": seda_payload,
-    });
-    let msg = DataResult {
-        version: version.parse().unwrap(),
-        dr_id,
-        consensus,
-        exit_code,
-        result,
-        block_height,
-        gas_used,
-        payback_address,
-        seda_payload,
-    };
-
-    #[cfg(not(feature = "cosmwasm"))]
-    assert_json_ser(msg, expected_json);
-    #[cfg(feature = "cosmwasm")]
-    assert_json_deser(msg, expected_json);
-}
-
 #[test]
 fn json_reveal_body() {
     let id = "id".to_string();