Light Client refactoring

light-client/src/components/io.rs

@@ -53,12 +53,7 @@ impl Io for ProdIo {
         let validator_set = self.fetch_validator_set(peer, height)?;
         let next_validator_set = self.fetch_validator_set(peer, height + 1)?;
 
-        let light_block = LightBlock::new(
-            signed_header,
-            validator_set,
-            next_validator_set,
-            // peer
-        );
+        let light_block = LightBlock::new(signed_header, validator_set, next_validator_set, peer);
 
         Ok(light_block)
     }

light-client/src/tests.rs

@@ -6,16 +6,16 @@ use tendermint::block::Height as HeightStr;
 use tendermint::evidence::Duration as DurationStr;
 
 #[derive(Deserialize, Clone, Debug)]
-pub struct TestCases {
+pub struct TestCases<LB> {
     pub batch_name: String,
-    pub test_cases: Vec<TestCase>,
+    pub test_cases: Vec<TestCase<LB>>,
 }
 
 #[derive(Deserialize, Clone, Debug)]
-pub struct TestCase {
+pub struct TestCase<LB> {
     pub description: String,
     pub initial: Initial,
-    pub input: Vec<LightBlock>,
+    pub input: Vec<LB>,
     pub expected_output: Option<String>,
 }
 
@@ -28,20 +28,20 @@ pub struct Initial {
 }
 
 #[derive(Deserialize, Clone, Debug)]
-pub struct TestBisection {
+pub struct TestBisection<LB> {
     pub description: String,
     pub trust_options: TrustOptions,
-    pub primary: Provider,
+    pub primary: Provider<LB>,
     pub height_to_verify: HeightStr,
     pub now: Time,
     pub expected_output: Option<String>,
     pub expected_num_of_bisections: usize,
 }
 
 #[derive(Deserialize, Clone, Debug)]
-pub struct Provider {
+pub struct Provider<LB> {
     pub chain_id: String,
-    pub lite_blocks: Vec<LightBlock>,
+    pub lite_blocks: Vec<LB>,
 }
 
 #[derive(Deserialize, Clone, Debug)]
@@ -66,3 +66,77 @@ impl Trusted {
         }
     }
 }
+
+// -----------------------------------------------------------------------------
+// Everything below is a temporary workaround for the lack of `provider` field
+// in the light blocks serialized in the JSON fixtures.
+// -----------------------------------------------------------------------------
+
+#[derive(Clone, Debug, PartialEq, Deserialize)]
+pub struct AnonLightBlock {
+    pub signed_header: SignedHeader,
+    #[serde(rename = "validator_set")]
+    pub validators: ValidatorSet,
+    #[serde(rename = "next_validator_set")]
+    pub next_validators: ValidatorSet,
+    #[serde(default = "default_peer_id")]
+    pub provider: PeerId,
+}
+
+pub fn default_peer_id() -> PeerId {
+    "BADFADAD0BEFEEDC0C0ADEADBEEFC0FFEEFACADE".parse().unwrap()
+}
+
+impl From<AnonLightBlock> for LightBlock {
+    fn from(alb: AnonLightBlock) -> Self {
+        Self {
+            signed_header: alb.signed_header,
+            validators: alb.validators,
+            next_validators: alb.next_validators,
+            provider: alb.provider,
+        }
+    }
+}
+
+impl From<TestCase<AnonLightBlock>> for TestCase<LightBlock> {
+    fn from(tc: TestCase<AnonLightBlock>) -> Self {
+        Self {
+            description: tc.description,
+            initial: tc.initial,
+            input: tc.input.into_iter().map(Into::into).collect(),
+            expected_output: tc.expected_output,
+        }
+    }
+}
+
+impl From<TestCases<AnonLightBlock>> for TestCases<LightBlock> {
+    fn from(tc: TestCases<AnonLightBlock>) -> Self {
+        Self {
+            batch_name: tc.batch_name,
+            test_cases: tc.test_cases.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<Provider<AnonLightBlock>> for Provider<LightBlock> {
+    fn from(p: Provider<AnonLightBlock>) -> Self {
+        Self {
+            chain_id: p.chain_id,
+            lite_blocks: p.lite_blocks.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+impl From<TestBisection<AnonLightBlock>> for TestBisection<LightBlock> {
+    fn from(tb: TestBisection<AnonLightBlock>) -> Self {
+        Self {
+            description: tb.description,
+            trust_options: tb.trust_options,
+            primary: tb.primary.into(),
+            height_to_verify: tb.height_to_verify,
+            now: tb.now,
+            expected_output: tb.expected_output,
+            expected_num_of_bisections: tb.expected_num_of_bisections,
+        }
+    }
+}

light-client/src/types.rs

@@ -51,9 +51,8 @@ pub struct LightBlock {
     /// Validator set at the next block height
     #[serde(rename = "next_validator_set")]
     pub next_validators: ValidatorSet,
-    // FIXME: Uncomment when conformance tests are adapted to include provider
-    // /// The peer ID of the node that provided this block
-    // pub provider: PeerId,
+    /// The peer ID of the node that provided this block
+    pub provider: PeerId,
 }
 
 impl LightBlock {
@@ -62,13 +61,13 @@ impl LightBlock {
         signed_header: SignedHeader,
         validators: ValidatorSet,
         next_validators: ValidatorSet,
-        // provider: PeerId,
+        provider: PeerId,
     ) -> LightBlock {
         Self {
             signed_header,
             validators,
             next_validators,
-            // provider,
+            provider,
         }
     }
 

light-client/tests/light_client.rs

@@ -8,8 +8,6 @@ use std::path::{Path, PathBuf};
 
 use tendermint::rpc;
 
-const PEER_ID: &str = "BADFADAD0BEFEEDC0C0ADEADBEEFC0FFEEFACADE";
-
 // Link to the commit that generated below JSON test files:
 // https://github.com/Shivani912/tendermint/commit/e02f8fd54a278f0192353e54b84a027c8fe31c1e
 const TEST_FILES_PATH: &str = "./tests/support/";
@@ -36,7 +34,7 @@ fn verify_single(
         trusted_state.signed_header,
         trusted_state.next_validators.clone(),
         trusted_state.next_validators,
-        // PEER_ID.parse().unwrap(),
+        default_peer_id(),
     );
 
     let options = Options {
@@ -56,7 +54,7 @@ fn verify_single(
     }
 }
 
-fn run_test_case(tc: TestCase) {
+fn run_test_case(tc: TestCase<LightBlock>) {
     let mut latest_trusted = Trusted::new(
         tc.initial.signed_header.clone(),
         tc.initial.next_validator_set.clone(),
@@ -145,11 +143,10 @@ fn verify_bisection(
         .map(|_| light_client.get_trace(untrusted_height))
 }
 
-fn run_bisection_test(tc: TestBisection) {
+fn run_bisection_test(tc: TestBisection<LightBlock>) {
     println!("  - {}", tc.description);
 
-    let primary: PeerId = PEER_ID.parse().unwrap();
-
+    let primary = default_peer_id();
     let untrusted_height = tc.height_to_verify.try_into().unwrap();
     let trust_threshold = tc.trust_options.trust_level;
     let trusting_period = tc.trust_options.period;
@@ -275,12 +272,16 @@ fn run_bisection_tests(dir: &str) {
     }
 }
 
-fn read_test_case(file_path: &str) -> TestCase {
-    serde_json::from_str(read_json_fixture(file_path).as_str()).unwrap()
+fn read_test_case(file_path: &str) -> TestCase<LightBlock> {
+    let tc: TestCase<AnonLightBlock> =
+        serde_json::from_str(read_json_fixture(file_path).as_str()).unwrap();
+    tc.into()
 }
 
-fn read_bisection_test_case(file_path: &str) -> TestBisection {
-    serde_json::from_str(read_json_fixture(file_path).as_str()).unwrap()
+fn read_bisection_test_case(file_path: &str) -> TestBisection<LightBlock> {
+    let tc: TestBisection<AnonLightBlock> =
+        serde_json::from_str(read_json_fixture(file_path).as_str()).unwrap();
+    tc.into()
 }
 
 #[test]