scaffold remaining chains

Author: scarmuega

src/filters/into_json.rs

@@ -27,7 +27,7 @@ impl From<&Stage> for Worker {
 
 gasket::impl_mapper!(|_worker: Worker, stage: Stage, unit: ChainEvent| => {
     let out = unit.clone().map_record(|r| match r {
-        Record::Cardano(record) => Record::Cardano(cardano::Record::GenericJson(JsonValue::from(record))),
+        Record::Cardano(record) => Record::GenericJson(JsonValue::from(record)),
         x => x,
     });
 

src/filters/select/eval/mod.rs

@@ -609,11 +609,14 @@ pub fn eval(record: &Record, predicate: &Predicate) -> MatchOutcome {
             cardano::Record::ParsedTx(x) => eval_tx(x, predicate),
             cardano::Record::ParsedBlock(x) => eval_block(x, predicate),
             _ => {
-                warn!("The select filter is valid only with ParsedTx & ParsedBlock records");
+                warn!("The select filter is valid only for ParsedTx / ParsedBlock records");
                 MatchOutcome::Uncertain
             }
         },
-        Record::Ethereum(_record) => todo!(),
+        _ => {
+            warn!("The select filter is valid only for Cardano ParsedTx / ParsedBlock records");
+            MatchOutcome::Uncertain
+        }
     }
 }
 

src/filters/wasm_plugin.rs

@@ -5,6 +5,8 @@ use serde::Deserialize;
 
 use crate::framework::*;
 
+pub type CardanoRecord = cardano::Record;
+
 #[derive(Stage)]
 #[stage(name = "filter-wasm", unit = "ChainEvent", worker = "Worker")]
 pub struct Stage {
@@ -18,23 +20,20 @@ pub struct Stage {
 }
 
 impl Stage {
-    fn map_record(&mut self, r: Record) -> Result<Vec<Record>, Error> {
+    fn map_cardano_record(&mut self, r: CardanoRecord) -> Result<Vec<Record>, Error> {
         let extism::convert::Json::<serde_json::Value>(output) = match r {
-            Record::CborBlock(x) => self.plugin.call("map_cbor_block", x).unwrap(),
-            Record::CborTx(x) => self.plugin.call("map_cbor_tx", x).unwrap(),
-            Record::ParsedTx(x) => self
+            CardanoRecord::CborBlock(x) => self.plugin.call("map_cbor_block", x).unwrap(),
+            CardanoRecord::CborTx(x) => self.plugin.call("map_cbor_tx", x).unwrap(),
+            CardanoRecord::ParsedTx(x) => self
                 .plugin
                 .call("map_u5c_tx", extism::convert::Json(x))
                 .unwrap(),
-            Record::ParsedBlock(x) => self
+            CardanoRecord::ParsedBlock(x) => self
                 .plugin
                 .call("map_u5c_block", extism::convert::Json(x))
                 .unwrap(),
-            Record::GenericJson(x) => self
-                .plugin
-                .call("map_json", extism::convert::Json(x))
-                .unwrap(),
-            Record::OuraV1Event(x) => self
+
+            CardanoRecord::OuraV1Event(x) => self
                 .plugin
                 .call("map_json", extism::convert::Json(x))
                 .unwrap(),
@@ -48,6 +47,13 @@ impl Stage {
 
         Ok(output)
     }
+
+    fn map_record(&mut self, r: Record) -> Result<Vec<Record>, Error> {
+        match r {
+            Record::Cardano(x) => self.map_cardano_record(x),
+            x => Ok(vec![x]),
+        }
+    }
 }
 
 #[derive(Default)]

src/framework/bitcoin/mod.rs

@@ -0,0 +1,17 @@
+use serde_json::{json, Value as JsonValue};
+
+#[derive(Debug, Clone)]
+pub enum Record {
+    // Scaffold placeholder for now
+    ParsedBlock(()),
+    RawBlock(Vec<u8>),
+}
+
+impl From<Record> for JsonValue {
+    fn from(value: Record) -> Self {
+        match value {
+            Record::ParsedBlock(x) => json!(x),
+            Record::RawBlock(x) => json!({ "hex": hex::encode(x) }),
+        }
+    }
+}

src/framework/cardano/mod.rs

@@ -42,7 +42,6 @@ impl From<ChainConfig> for GenesisValues {
 pub enum Record {
     CborBlock(Vec<u8>),
     CborTx(Vec<u8>),
-    GenericJson(JsonValue),
     OuraV1Event(legacy_v1::Event),
     ParsedTx(ParsedTx),
     ParsedBlock(ParsedBlock),
@@ -56,7 +55,6 @@ impl From<Record> for JsonValue {
             Record::ParsedBlock(x) => json!(x),
             Record::ParsedTx(x) => json!(x),
             Record::OuraV1Event(x) => json!(x),
-            Record::GenericJson(x) => x,
         }
     }
 }

src/framework/ethereum/mod.rs

@@ -4,12 +4,14 @@ use serde_json::{json, Value as JsonValue};
 #[derive(Debug, Clone)]
 pub enum Record {
     ParsedBlock(Block),
+    RawBlock(Vec<u8>),
 }
 
 impl From<Record> for JsonValue {
     fn from(value: Record) -> Self {
         match value {
             Record::ParsedBlock(x) => json!(x),
+            Record::RawBlock(x) => json!({ "hex": hex::encode(x) }),
         }
     }
 }

src/framework/mod.rs

@@ -16,8 +16,10 @@ pub use pallas::interop::utxorpc::spec::cardano::Tx as ParsedTx;
 // we use GenesisValues from Pallas as our ChainConfig
 pub use pallas::ledger::traverse::wellknown::GenesisValues;
 
+pub mod bitcoin;
 pub mod cardano;
 pub mod ethereum;
+pub mod substrate;
 
 pub mod errors;
 
@@ -79,14 +81,20 @@ impl Default for Chain {
 
 #[derive(Debug, Clone)]
 pub enum Record {
+    GenericJson(JsonValue),
     Cardano(cardano::Record),
     Ethereum(ethereum::Record),
+    Bitcoin(bitcoin::Record),
+    Substrate(substrate::Record),
 }
 impl From<Record> for JsonValue {
     fn from(value: Record) -> Self {
         match value {
+            Record::GenericJson(x) => x,
             Record::Cardano(record) => record.into(),
             Record::Ethereum(record) => record.into(),
+            Record::Bitcoin(record) => record.into(),
+            Record::Substrate(record) => record.into(),
         }
     }
 }

src/framework/substrate/mod.rs

@@ -0,0 +1,17 @@
+use alloy::rpc::types::Block;
+use serde_json::{json, Value as JsonValue};
+
+#[derive(Debug, Clone)]
+pub enum Record {
+    ParsedBlock(Block),
+    RawBlock(Vec<u8>),
+}
+
+impl From<Record> for JsonValue {
+    fn from(value: Record) -> Self {
+        match value {
+            Record::ParsedBlock(x) => json!(x),
+            Record::RawBlock(x) => json!({ "hex": hex::encode(x) }),
+        }
+    }
+}

src/sinks/aws_s3.rs

@@ -41,7 +41,7 @@ impl gasket::framework::Worker<Stage> for Worker {
         }
 
         let cbor = match record.unwrap() {
-            Record::CborBlock(cbor) => Ok(cbor),
+            Record::Cardano(cardano::Record::CborBlock(cbor)) => Ok(cbor),
             _ => Err(Error::config(String::from("Invalid configuration daemon"))),
         }
         .or_panic()?;

src/sinks/terminal/format.rs

@@ -95,11 +95,13 @@ impl LogLine {
 
                     log
                 }
-                cardano::Record::GenericJson(_json) => {
-                    todo!("GenericJson not implemented yet")
-                }
             },
             Record::Ethereum(_record) => todo!(),
+            Record::Bitcoin(record) => todo!(),
+            Record::Substrate(record) => todo!(),
+            Record::GenericJson(_json) => {
+                todo!("GenericJson not implemented yet")
+            }
         }
     }