From 82769998c69b7fb88abbe93e55f046122a17c627 Mon Sep 17 00:00:00 2001
From: Sander Bosma <sanderbosma@gmail.com>
Date: Tue, 4 Jan 2022 16:17:49 +0100
Subject: [PATCH] fix: use index override when decoding enums in events

---
 src/events.rs         | 46 ++++++++++++++++++++++++++++++++++++-------
 test-runtime/build.rs |  5 +++--
 2 files changed, 42 insertions(+), 9 deletions(-)

diff --git a/src/events.rs b/src/events.rs
index 15b74dca6f2..65afb063b26 100644
--- a/src/events.rs
+++ b/src/events.rs
@@ -187,13 +187,13 @@ where
             TypeDef::Variant(variant) => {
                 let variant_index = u8::decode(input)?;
                 variant_index.encode_to(output);
-                let variant =
-                    variant
-                        .variants()
-                        .get(variant_index as usize)
-                        .ok_or_else(|| {
-                            Error::Other(format!("Variant {} not found", variant_index))
-                        })?;
+                let variant = variant
+                    .variants()
+                    .iter()
+                    .find(|v| v.index() == variant_index)
+                    .ok_or_else(|| {
+                        Error::Other(format!("Variant {} not found", variant_index))
+                    })?;
                 for field in variant.fields() {
                     self.decode_type(field.ty().id(), input, output)?;
                 }
@@ -522,4 +522,36 @@ mod tests {
         assert_eq!(events[0].1.variant_index, encoded_event[0]);
         assert_eq!(events[0].1.data.0, encoded_event[1..]);
     }
+
+    #[test]
+    fn event_containing_explicit_index() {
+        #[derive(Clone, Encode, TypeInfo)]
+        #[repr(u8)]
+        #[allow(trivial_numeric_casts)] // required because the Encode derive produces a warning otherwise
+        pub enum MyType {
+            B = 10,
+        }
+
+        #[derive(Clone, Encode, TypeInfo)]
+        enum Event {
+            A(MyType),
+        }
+
+        let pallet_index = 0;
+        let pallet = pallet_metadata::<Event>(pallet_index);
+        let decoder = init_decoder(vec![pallet]);
+
+        let event = Event::A(MyType::B);
+        let encoded_event = event.encode();
+        let event_records = vec![event_record(pallet_index, event)];
+
+        let mut input = Vec::new();
+        event_records.encode_to(&mut input);
+
+        // this would panic if the explicit enum item index were not correctly used
+        let events = decoder.decode_events(&mut &input[..]).unwrap();
+
+        assert_eq!(events[0].1.variant_index, encoded_event[0]);
+        assert_eq!(events[0].1.data.0, encoded_event[1..]);
+    }
 }
diff --git a/test-runtime/build.rs b/test-runtime/build.rs
index a994365a119..9557a2c7515 100644
--- a/test-runtime/build.rs
+++ b/test-runtime/build.rs
@@ -41,8 +41,9 @@ async fn main() {
 
 async fn run() {
     // Select substrate binary to run based on env var.
-    let substrate_bin =
-        env::var(SUBSTRATE_BIN_ENV_VAR).unwrap_or_else(|_| "substrate".to_owned());
+    let substrate_bin = env::var(SUBSTRATE_BIN_ENV_VAR).unwrap_or_else(|_| {
+        "/home/sander/workspace/interlay/substrate-subxt/substrate".to_owned()
+    });
 
     // Run binary.
     let port = next_open_port()