feat: ability to use file as action

Author: Ludo Galabru

components/chainhook-event-observer/src/chainhooks/mod.rs

@@ -19,6 +19,7 @@ use clarity_repl::clarity::util::hash::{hex_bytes, to_hex, Hash160};
 use clarity_repl::clarity::vm::types::{CharType, SequenceData, Value as ClarityValue};
 use reqwest::{Client, Method};
 use serde::Serialize;
+use serde_json::Value as JsonValue;
 use std::collections::HashMap;
 use std::io::Cursor;
 use std::iter::Map;
@@ -415,6 +416,7 @@ pub struct BitcoinChainhookOccurrencePayload {
 
 pub enum BitcoinChainhookOccurrence {
     Http(RequestBuilder),
+    File(String, Vec<u8>),
     Data(BitcoinChainhookOccurrencePayload),
 }
 
@@ -447,9 +449,37 @@ pub struct StacksChainhookOccurrencePayload {
 }
 pub enum StacksChainhookOccurrence {
     Http(RequestBuilder),
+    File(String, Vec<u8>),
     Data(StacksChainhookOccurrencePayload),
 }
 
+pub fn serialize_bitcoin_payload_to_json<'a>(
+    trigger: BitcoinTriggerChainhook<'a>,
+    proofs: &HashMap<&'a TransactionIdentifier, String>,
+) -> JsonValue {
+    json!({
+        "apply": trigger.apply.into_iter().map(|(transaction, block_identifier)| {
+            json!({
+                "transaction": transaction,
+                "block_identifier": block_identifier,
+                "confirmations": 1, // TODO(lgalabru)
+                "proof": proofs.get(&transaction.transaction_identifier),
+            })
+        }).collect::<Vec<_>>(),
+        "rollback": trigger.rollback.into_iter().map(|(transaction, block_identifier)| {
+            json!({
+                "transaction": transaction,
+                "block_identifier": block_identifier,
+                "confirmations": 1, // TODO(lgalabru)
+            })
+        }).collect::<Vec<_>>(),
+        "chainhook": {
+            "uuid": trigger.chainhook.uuid,
+            "predicate": trigger.chainhook.predicate,
+        }
+    })
+}
+
 pub fn handle_bitcoin_hook_action<'a>(
     trigger: BitcoinTriggerChainhook<'a>,
     proofs: &HashMap<&'a TransactionIdentifier, String>,
@@ -459,28 +489,8 @@ pub fn handle_bitcoin_hook_action<'a>(
             let client = Client::builder().build().unwrap();
             let host = format!("{}", http.url);
             let method = Method::from_bytes(http.method.as_bytes()).unwrap();
-            let payload = json!({
-                "apply": trigger.apply.into_iter().map(|(transaction, block_identifier)| {
-                    json!({
-                        "transaction": transaction,
-                        "block_identifier": block_identifier,
-                        "confirmations": 1, // TODO(lgalabru)
-                        "proof": proofs.get(&transaction.transaction_identifier),
-                    })
-                }).collect::<Vec<_>>(),
-                "rollback": trigger.rollback.into_iter().map(|(transaction, block_identifier)| {
-                    json!({
-                        "transaction": transaction,
-                        "block_identifier": block_identifier,
-                        "confirmations": 1, // TODO(lgalabru)
-                    })
-                }).collect::<Vec<_>>(),
-                "chainhook": {
-                    "uuid": trigger.chainhook.uuid,
-                    "predicate": trigger.chainhook.predicate,
-                }
-            });
-            let body = serde_json::to_vec(&payload).unwrap();
+            let body =
+                serde_json::to_vec(&serialize_bitcoin_payload_to_json(trigger, proofs)).unwrap();
             Some(BitcoinChainhookOccurrence::Http(
                 client
                     .request(method, &host)
@@ -489,6 +499,14 @@ pub fn handle_bitcoin_hook_action<'a>(
                     .body(body),
             ))
         }
+        HookAction::File(disk) => {
+            let bytes =
+                serde_json::to_vec(&serialize_bitcoin_payload_to_json(trigger, proofs)).unwrap();
+            Some(BitcoinChainhookOccurrence::File(
+                disk.path.to_string(),
+                bytes,
+            ))
+        }
         HookAction::Noop => Some(BitcoinChainhookOccurrence::Data(
             BitcoinChainhookOccurrencePayload {
                 apply: trigger
@@ -757,49 +775,64 @@ pub fn serialize_to_json(value: &ClarityValue) -> serde_json::Value {
     }
 }
 
+pub fn serialize_stacks_payload_to_json<'a>(
+    trigger: StacksTriggerChainhook<'a>,
+    proofs: &HashMap<&'a TransactionIdentifier, String>,
+) -> JsonValue {
+    let decode_clarity_values = trigger.should_decode_clarity_value();
+    json!({
+        "apply": trigger.apply.into_iter().map(|(transaction, block_identifier)| {
+            json!({
+                "transaction": if decode_clarity_values {
+                    encode_transaction_including_with_clarity_decoding(transaction)
+                } else {
+                    json!(transaction)
+                },
+                "block_identifier": block_identifier,
+                "confirmations": 1, // TODO(lgalabru)
+                "proof": proofs.get(&transaction.transaction_identifier),
+            })
+        }).collect::<Vec<_>>(),
+        "rollback": trigger.rollback.into_iter().map(|(transaction, block_identifier)| {
+            json!({
+                "transaction": transaction,
+                "block_identifier": block_identifier,
+                "confirmations": 1, // TODO(lgalabru)
+            })
+        }).collect::<Vec<_>>(),
+        "chainhook": {
+            "uuid": trigger.chainhook.uuid,
+            "predicate": trigger.chainhook.predicate,
+        }
+    })
+}
+
 pub fn handle_stacks_hook_action<'a>(
     trigger: StacksTriggerChainhook<'a>,
     proofs: &HashMap<&'a TransactionIdentifier, String>,
 ) -> Option<StacksChainhookOccurrence> {
-    let decode_clarity_values = trigger.should_decode_clarity_value();
     match &trigger.chainhook.action {
         HookAction::Http(http) => {
             let client = Client::builder().build().unwrap();
             let host = format!("{}", http.url);
             let method = Method::from_bytes(http.method.as_bytes()).unwrap();
-            let payload = json!({
-                "apply": trigger.apply.into_iter().map(|(transaction, block_identifier)| {
-                    json!({
-                        "transaction": if decode_clarity_values {
-                            encode_transaction_including_with_clarity_decoding(transaction)
-                        } else {
-                            json!(transaction)
-                        },
-                        "block_identifier": block_identifier,
-                        "confirmations": 1, // TODO(lgalabru)
-                        "proof": proofs.get(&transaction.transaction_identifier),
-                    })
-                }).collect::<Vec<_>>(),
-                "rollback": trigger.rollback.into_iter().map(|(transaction, block_identifier)| {
-                    json!({
-                        "transaction": transaction,
-                        "block_identifier": block_identifier,
-                        "confirmations": 1, // TODO(lgalabru)
-                    })
-                }).collect::<Vec<_>>(),
-                "chainhook": {
-                    "uuid": trigger.chainhook.uuid,
-                    "predicate": trigger.chainhook.predicate,
-                }
-            });
-            let body = serde_json::to_vec(&payload).unwrap();
+            let body =
+                serde_json::to_vec(&serialize_stacks_payload_to_json(trigger, proofs)).unwrap();
             Some(StacksChainhookOccurrence::Http(
                 client
                     .request(method, &host)
                     .header("Content-Type", "application/json")
                     .body(body),
             ))
         }
+        HookAction::File(disk) => {
+            let bytes =
+                serde_json::to_vec(&serialize_stacks_payload_to_json(trigger, proofs)).unwrap();
+            Some(StacksChainhookOccurrence::File(
+                disk.path.to_string(),
+                bytes,
+            ))
+        }
         HookAction::Noop => Some(StacksChainhookOccurrence::Data(
             StacksChainhookOccurrencePayload {
                 apply: trigger

components/chainhook-event-observer/src/chainhooks/types.rs

@@ -125,6 +125,7 @@ pub struct BitcoinChainhookSpecification {
 #[serde(rename_all = "snake_case")]
 pub enum HookAction {
     Http(HttpHook),
+    File(FileHook),
     Noop,
 }
 
@@ -136,6 +137,12 @@ pub struct HttpHook {
     pub authorization_header: String,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub struct FileHook {
+    pub path: String,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema)]
 pub struct ScriptTemplate {
     pub instructions: Vec<ScriptInstruction>,

components/chainhook-event-observer/src/observer/mod.rs

@@ -21,6 +21,8 @@ use rocket::request::{self, FromRequest, Outcome, Request};
 use rocket::serde::json::{json, Json, Value as JsonValue};
 use rocket::serde::Deserialize;
 use rocket::State;
+use rocket_okapi::{openapi, openapi_get_routes, request::OpenApiFromRequest};
+use schemars::JsonSchema;
 use serde_json::error;
 use stacks_rpc_client::{PoxInfo, StacksRpc};
 use std::collections::{HashMap, HashSet, VecDeque};
@@ -35,9 +37,6 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{Receiver, Sender};
 use std::sync::{Arc, Mutex, RwLock};
 
-use rocket_okapi::{openapi, openapi_get_routes, request::OpenApiFromRequest};
-use schemars::JsonSchema;
-
 pub const DEFAULT_INGESTION_PORT: u16 = 20445;
 pub const DEFAULT_CONTROL_PORT: u16 = 20446;
 
@@ -501,6 +500,9 @@ pub async fn start_observer_commands_handler(
                                         BitcoinChainhookOccurrence::Http(request) => {
                                             requests.push(request);
                                         }
+                                        BitcoinChainhookOccurrence::File(_path, _bytes) => {
+                                            info!("Writing to disk not supported in server mode")
+                                        }
                                         BitcoinChainhookOccurrence::Data(payload) => {
                                             if let Some(ref tx) = observer_events_tx {
                                                 let _ = tx.send(
@@ -617,6 +619,9 @@ pub async fn start_observer_commands_handler(
                                         StacksChainhookOccurrence::Http(request) => {
                                             requests.push(request);
                                         }
+                                        StacksChainhookOccurrence::File(_path, _bytes) => {
+                                            info!("Writing to disk not supported in server mode")
+                                        }
                                         StacksChainhookOccurrence::Data(payload) => {
                                             if let Some(ref tx) = observer_events_tx {
                                                 let _ = tx.send(
@@ -980,11 +985,18 @@ pub async fn handle_bitcoin_rpc_call(
         "{}:{}",
         bitcoin_config.username, bitcoin_config.password
     ));
+
+    let path = if method == "listunspent" {
+        "wallet/stacks-mining"
+    } else {
+        ""
+    };
+
     let client = Client::new();
     let builder = client
         .post(format!(
-            "{}:{}/",
-            bitcoin_config.rpc_host, bitcoin_config.rpc_port
+            "{}:{}/{}",
+            bitcoin_config.rpc_host, bitcoin_config.rpc_port, path
         ))
         .header("Content-Type", "application/json")
         .timeout(std::time::Duration::from_secs(5))

components/clarinet-cli/src/chainhooks/types.rs

@@ -74,6 +74,7 @@ pub struct StxEventPredicateFile {
 #[serde(rename_all = "kebab-case")]
 pub struct HookActionFile {
     http: Option<BTreeMap<String, String>>,
+    file: Option<BTreeMap<String, String>>,
 }
 
 impl ChainhookSpecificationFile {
@@ -200,14 +201,19 @@ impl HookActionFile {
                 Some(authorization_header) => Ok(authorization_header.to_string()),
                 None => Err(format!("authorization-header missing for http")),
             }?;
-
             Ok(HookAction::Http(HttpHook {
                 url,
                 method,
                 authorization_header,
             }))
+        } else if let Some(ref specs) = self.file {
+            let path = match specs.get("path") {
+                Some(path) => Ok(path.to_string()),
+                None => Err(format!("path missing for file")),
+            }?;
+            Ok(HookAction::File(FileHook { path }))
         } else {
-            Err(format!("action not supported (http)"))
+            Err(format!("action not supported (http, file)"))
         }
     }
 }

components/clarinet-cli/src/runner/api_v1.rs

@@ -47,6 +47,8 @@ use deno_core::{op, Extension};
 use deno_core::{ModuleSpecifier, OpState};
 use sha2::{Digest, Sha256};
 use std::collections::{BTreeMap, HashMap};
+use std::fs::OpenOptions;
+use std::io::Write;
 use std::sync::mpsc::{self, Sender};
 use std::thread::sleep;
 use std::time::Duration;
@@ -747,12 +749,38 @@ fn mine_block(state: &mut OpState, args: MineBlockArgs) -> Result<String, AnyErr
                         },
                         &HashMap::new(),
                     );
-                    if let Some(StacksChainhookOccurrence::Http(action)) = result {
-                        let chainhook_tx = match state.try_borrow::<Sender<ChainhookEvent>>() {
-                            Some(chainhook_tx) => chainhook_tx,
-                            None => panic!(),
-                        };
-                        let _ = chainhook_tx.send(ChainhookEvent::PerformRequest(action));
+                    match result {
+                        Some(StacksChainhookOccurrence::Http(action)) => {
+                            let chainhook_tx = match state.try_borrow::<Sender<ChainhookEvent>>() {
+                                Some(chainhook_tx) => chainhook_tx,
+                                None => panic!(),
+                            };
+                            let _ = chainhook_tx.send(ChainhookEvent::PerformRequest(action));
+                        }
+                        Some(StacksChainhookOccurrence::File(path, bytes)) => {
+                            let mut file_path = std::env::current_dir().unwrap();
+                            file_path.push(path);
+                            if !file_path.exists() {
+                                match std::fs::File::open(&file_path) {
+                                    Ok(ref mut file) => {
+                                        let _ = file.write_all(&bytes);
+                                    }
+                                    Err(e) => println!("unable to create file {:?}", e),
+                                }
+                            }
+                            let mut file = OpenOptions::new()
+                                .create(false)
+                                .write(true)
+                                .append(true)
+                                .open(file_path)
+                                .unwrap();
+
+                            if let Err(e) = writeln!(file, "{}", String::from_utf8(bytes).unwrap())
+                            {
+                                eprintln!("Couldn't write to file: {}", e);
+                            }
+                        }
+                        _ => {}
                     }
                 }
             }