Merge pull request #97 from Relayz-io/kyrylo/adding-api-response

kyrylo/adding-api-response

common-api/src/api.rs

     pub account_id: AccountId,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "response", content = "body")]
+#[serde(rename_all = "snake_case")]
+enum ApiResponse<T> {
+    Success(T),
+    Timeout,
+}
+
 #[cfg(test)]
 mod tests {
 
 
         assert_eq!(s1, s2);
     }
+
+    #[test]
+    fn api_response_parsing() {
+        let test_data = serde_json::to_value(&ApiResponse::Success(NodeInfo {
+            account_id: AccountId::from_str("account.testnet").unwrap(),
+            bandwidth: Bandwidth {
+                speed: 100,
+                units: "mbps".to_owned(),
+            },
+            region: "us".to_owned(),
+        }))
+        .unwrap();
+
+        let test_data_match = serde_json::json!({
+            "response": "success",
+            "body": {
+                "account_id": "account.testnet",
+                "region": "us",
+                "bandwidth": {
+                    "speed": 100,
+                    "units": "mbps"
+                }
+            }
+        });
+        assert_eq!(test_data, test_data_match);
+
+        let test_data = serde_json::to_value(&ApiResponse::<()>::Timeout).unwrap();
+        let test_data_match = serde_json::json!({
+            "response": "timeout",
+        });
+        assert_eq!(test_data, test_data_match);
+    }
 }

common-api/src/crypto/ed25519.rs

 
 // This `Hash` implementation is safe since it retains the property
 // `k1 == k2 ⇒ hash(k1) == hash(k2)`.
-#[allow(clippy::derive_hash_xor_eq)]
+#[allow(clippy::derived_hash_with_manual_eq)]
 impl Hash for Ed25519PublicKey {
     fn hash<H: Hasher>(&self, state: &mut H) {
         state.write_u8(0u8);
     }
 }
 
-#[allow(clippy::derive_hash_xor_eq)]
+#[allow(clippy::derived_hash_with_manual_eq)]
 impl Hash for Ed25519Signature {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.to_bytes().hash(state);

near-primitives-light/src/transaction.rs

 }
 
 /// The status of execution for a transaction or a receipt.
-#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone)]
+#[derive(Default, BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone)]
 pub enum ExecutionStatus {
     /// The execution is pending or unknown.
+    #[default]
     Unknown,
     /// The execution has failed with the given execution error.
     Failure(Box<TxExecutionError>),
     }
 }
 
-impl Default for ExecutionStatus {
-    fn default() -> Self {
-        ExecutionStatus::Unknown
-    }
-}
-
 /// ExecutionOutcome for proof. Excludes logs and metadata
 #[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone)]
 pub struct PartialExecutionOutcome {
     }
 }
 
-#[derive(BorshSerialize, BorshDeserialize, PartialEq, Clone, Eq, Debug)]
+#[derive(Default, BorshSerialize, BorshDeserialize, PartialEq, Clone, Eq, Debug)]
 pub enum ExecutionMetadata {
     // V1: Empty Metadata
+    #[default]
     V1,
 
     // V2: With ProfileData
     V2(ProfileData),
 }
 
-impl Default for ExecutionMetadata {
-    fn default() -> Self {
-        ExecutionMetadata::V1
-    }
-}
-
 impl fmt::Debug for ExecutionOutcome {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ExecutionOutcome")

near-primitives-light/src/types.rs

 pub type StateRoot = CryptoHash;
 
 /// Different types of finality.
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+#[derive(Default, Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub enum Finality {
     #[serde(rename = "optimistic")]
     None,
     #[serde(rename = "near-final")]
     DoomSlug,
+    #[default]
     #[serde(rename = "final")]
     Final,
 }
 
-impl Default for Finality {
-    fn default() -> Self {
-        Finality::Final
-    }
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct AccountWithPublicKey {
     pub account_id: AccountId,

near-primitives-light/src/views.rs

 }
 
 #[allow(clippy::large_enum_variant)]
-#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone)]
+#[derive(
+    Default, BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Clone,
+)]
 pub enum FinalExecutionStatus {
     /// The execution has not yet started.
+    #[default]
     NotStarted,
     /// The execution has started and still going.
     Started,
     }
 }
 
-impl Default for FinalExecutionStatus {
-    fn default() -> Self {
-        FinalExecutionStatus::NotStarted
-    }
-}
-
 #[allow(clippy::large_enum_variant)]
 #[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
 pub enum ServerError {