fix(extras)

- fix bug in resolve helper looking into the runtime twice
- fix decoding for types where module names don't match

core/src/decoder.rs

@@ -726,7 +726,6 @@ impl Decoder {
         match ty {
             "Data" => {
                 let data: pallet_identity::Data = Decode::decode(&mut &data[*cursor..])?;
-
                 // 1 byte for the enum
                 *cursor += 1;
                 match &data {
@@ -735,11 +734,6 @@ impl Decoder {
                     _ => *cursor += 32 
                 }
                 Ok(Some(SubstrateType::Data(data)))
-                // let len = Self::scale_length(&data[*cursor..])?;
-                // let data: Vec<u8> = Decode::decode(&mut &data[*cursor..])?;
-                // *cursor += len.0 + len.1;
-                // let data = data.into_iter().map(|d| SubstrateType::U8(d)).collect();
-                // Ok(Some(SubstrateType::Composite(data)))
             }
             "Call" | "GenericCall" => {
                 let types = self.decode_call(spec, data, cursor)?;

extras/src/resolver.rs

@@ -162,15 +162,13 @@ impl TypeResolver {
 
     /// Try to resolve a type pointer from the default definitions (definitions.json)
     fn resolve_helper(&self, module: &str, ty_pointer: &str) -> Option<&RustTypeMarker> {
-        log::trace!("Helper resolving {}, {}", module, ty_pointer);
-        if self.mods.get(module).is_none() {
-            log::debug!("Module None, Trying Runtime for type {}", ty_pointer);
-            self.mods.get_type("runtime", ty_pointer)
-        } else if let Some(t) = self.mods.get_type(module, ty_pointer) {
-            log::debug!("Trying module {}", module);
+        log::debug!("Helper resolving {}, {}", module, ty_pointer);
+
+        if let Some(t) = self.mods.get_type(module, ty_pointer) {
+            log::info!("Type {} found in module {}", ty_pointer, module);
             Some(t)
         } else if let Some(t) = self.mods.get_type("runtime", ty_pointer) {
-            log::debug!("Trying Runtime for type {}", ty_pointer);
+            log::debug!("Type not found in {}, trying `runtime` for type {}", module, ty_pointer);
             Some(t)
         } else if let Some(t) = self.check_other_modules(ty_pointer) {
             log::debug!("trying other modules");

integration_tests/tests/extrinsics.rs

@@ -347,3 +347,24 @@ fn should_decode_ext_779410_ksm() {
         println!("{}", serde_json::to_string(&decoded).unwrap());
     }
 }
+
+#[test]
+fn should_decode_ext_899638_ksm() {
+    init();
+    let types = extras::TypeResolver::default();
+    let mut decoder = Decoder::new(types, Chain::Kusama);
+
+    let (meta, ext) = test_suite::extrinsics_block899638();
+    let meta = Metadata::new(meta.as_slice());
+
+    decoder.register_version(1042, &meta);
+    for e in ext.iter() {
+        println!("{:?}", e);
+        println!("{:X?}", e);
+        let decoded = decoder
+            .decode_extrinsic(1042, e.as_slice())
+            .expect("should decode");
+        println!("{}", decoded);
+        println!("{}", serde_json::to_string(&decoded).unwrap());
+    }
+}

integration_tests/tests/test_suite.rs

@@ -101,6 +101,10 @@ pub fn extrinsics_block779410() -> (Vec<u8>, Vec<Vec<u8>>) {
     extrinsic_test("1042".to_string(), "779410".to_string(), 4)
 }
 
+pub fn extrinsics_block899638() -> (Vec<u8>, Vec<Vec<u8>>) {
+    extrinsic_test("1042".to_string(), "899638".to_string(), 4)
+}
+
 /// Get the runtime metadata from KusamaCC3 from block 3,901,874
 /// Block hash 0x1d65a4c67817c4f32f99f7247f070a2f3fd58baf81d4e533c9be9d1aa8c4e65a
 ///