fixed panicing env checks, added debug logs

Author: erhant

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "dkn-oracle"
 description = "Dria Knowledge Network: Oracle Node"
-version = "0.1.4"
+version = "0.1.5"
 edition = "2021"
 license = "Apache-2.0"
 readme = "README.md"
@@ -24,7 +24,6 @@ lazy_static = "1.5.0"
 ollama-workflows = { git = "https://github.com/andthattoo/ollama-workflows" }
 
 # errors & logging & env
-color-eyre = { version = "0.6.3", default-features = false }
 env_logger = "0.11.5"
 eyre = "0.6.12"
 log = "0.4.22"

Cargo.toml

@@ -49,7 +49,7 @@ The CLI provides several methods to interact with the oracle contracts.
 
 ### Registration
 
-To serve oracle requests, you must first register as your desired oracle type, i.e. `generator` or `validator`. These are handled by the registration commands `register` and `unregister` which accepts multiple arguments to register at once. You can then see your registrations with `registrations` command.
+To serve oracle requests, you **MUST** first register as your desired oracle type, i.e. `generator` or `validator`. These are handled by the registration commands `register` and `unregister` which accepts multiple arguments to register at once. You can then see your registrations with `registrations` command.
 
 Here is an example:
 

README.md

@@ -22,7 +22,6 @@ pub async fn display_rewards(node: &DriaOracle) -> Result<()> {
 
     log::info!("Claimable rewards:");
     log::info!("{} ", allowance);
-
     if allowance.amount.is_zero() {
         log::warn!("You have no claimable rewards!");
     }

src/commands/token.rs

@@ -23,35 +23,45 @@ pub async fn handle_generation(
     task_id: U256,
     protocol: FixedBytes<32>,
 ) -> Result<Option<TransactionReceipt>> {
+    log::info!("Handling generation task {}", task_id);
+
+    // check if we have validated anyways
+    log::debug!("Checking existing generation esponses");
     let responses = node.get_task_responses(task_id).await?;
     if responses.iter().any(|r| r.responder == node.address()) {
         log::debug!("Already responded to {} with generation", task_id);
         return Ok(None);
     }
 
+    // fetch the request from contract
+    log::debug!("Fetching the task request");
     let request = node
         .get_task_request(task_id)
         .await
         .wrap_err("could not get task")?;
 
     // choose model based on the request
+    log::debug!("Choosing model to use");
     let models_string = bytes_to_string(&request.models)?;
     let (_, model) = models.get_any_matching_model_from_csv(&models_string)?;
     log::debug!("Using model: {} from {}", model, models_string);
 
     // execute task
+    log::debug!("Executing the workflow");
     let protocol_string = bytes32_to_string(&protocol)?;
     let executor = Executor::new(model);
     let (output, metadata) = executor
         .execute_raw(&request.input, &protocol_string)
         .await?;
 
     // do the Arweave trick for large inputs
-    let arweave = Arweave::new_from_env()?;
+    log::debug!("Uploading to Arweave if required");
+    let arweave = Arweave::new_from_env().wrap_err("could not create Arweave instance")?;
     let output = arweave.put_if_large(output).await?;
     let metadata = arweave.put_if_large(metadata).await?;
 
     // mine nonce
+    log::debug!("Mining nonce for task");
     let nonce = mine_nonce(
         request.parameters.difficulty,
         &request.requester,
@@ -62,8 +72,9 @@ pub async fn handle_generation(
     .nonce;
 
     // respond
-    let tx_hash = node
+    log::debug!("Responding with generation");
+    let tx_receipt = node
         .respond_generation(task_id, output, metadata, nonce)
         .await?;
-    Ok(Some(tx_hash))
+    Ok(Some(tx_receipt))
 }

src/compute/handlers/generation.rs

@@ -4,7 +4,7 @@ use alloy::{
     primitives::{utils::parse_ether, Bytes, U256},
     rpc::types::TransactionReceipt,
 };
-use eyre::{eyre, Result};
+use eyre::{eyre, Context, Result};
 
 /// Handles a validation request.
 #[allow(unused)]
@@ -13,7 +13,10 @@ pub async fn handle_validation(
     models: &ModelConfig,
     task_id: U256,
 ) -> Result<Option<TransactionReceipt>> {
+    log::info!("Handling validation task {}", task_id);
+
     // check if already responded as generator, because we cant validate our own answer
+    log::debug!("Checking if we are a generator for this task");
     let responses = node.get_task_responses(task_id).await?;
     if responses.iter().any(|r| r.responder == node.address()) {
         log::debug!(
@@ -24,23 +27,29 @@ pub async fn handle_validation(
     }
 
     // check if we have validated anyways
+    log::debug!("Checking if we have validated already");
     let validations = node.get_task_validations(task_id).await?;
     if validations.iter().any(|v| v.validator == node.address()) {
         return Err(eyre!("Already validated {}", task_id));
     }
 
-    let request = node.get_task_request(task_id).await?;
+    log::debug!("Fetching the task request");
+    let request = node
+        .get_task_request(task_id)
+        .await
+        .wrap_err("could not get task")?;
 
     // FIXME: will add validation prompt here
+    log::debug!("Validating the task");
     let scores = (0..request.parameters.numGenerations)
         .map(|_| parse_ether("1.0").unwrap())
         .collect::<Vec<_>>();
-
     // FIXME: metadata is empty for now, as dummy data
     // FIXME: can add Arweave trick for metadata here
     let metadata = Bytes::default();
 
     // mine nonce
+    log::debug!("Mining nonce for task");
     let nonce = mine_nonce(
         request.parameters.difficulty,
         &request.requester,
@@ -50,8 +59,10 @@ pub async fn handle_validation(
     )
     .nonce;
 
-    let tx_hash = node
+    // respond
+    log::debug!("Responding with validation");
+    let tx_receipt = node
         .respond_validation(task_id, scores, metadata, nonce)
         .await?;
-    Ok(Some(tx_hash))
+    Ok(Some(tx_receipt))
 }

src/compute/handlers/validation.rs

@@ -23,7 +23,6 @@ pub fn mine_nonce(
     // target is (2^256-1) / 2^difficulty
     let target = U256::MAX >> difficulty;
 
-    log::debug!("Mining nonce for task {}", task_id);
     loop {
         // encode packed
         let mut message = Vec::new();

src/compute/nonce.rs

@@ -3,7 +3,6 @@ use alloy::{
     transports::http::reqwest::Url,
 };
 
-use color_eyre::Section;
 use eyre::{Context, Result};
 use std::env;
 
@@ -18,10 +17,7 @@ pub struct DriaOracleConfig {
 
 impl Default for DriaOracleConfig {
     fn default() -> Self {
-        Self::new_from_env()
-            .and_then(Self::enable_color_eyre)
-            .unwrap()
-            .enable_logs()
+        Self::new_from_env().unwrap().enable_logs()
     }
 }
 
@@ -40,14 +36,10 @@ impl DriaOracleConfig {
     /// - `SECRET_KEY`
     /// - `RPC_URL`
     pub fn new_from_env() -> Result<Self> {
-        dotenvy::dotenv()?;
         // parse private key
-        let private_key_hex = env::var("SECRET_KEY")
-            .wrap_err("SECRET_KEY is not set")
-            .suggestion("SECRET_KEY must be within .env.")?;
-        let secret_key = B256::from_hex(private_key_hex)
-            .wrap_err("could not hex-decode secret key")
-            .suggestion("SECRET_KEY must be within .env and be hexadecimals.")?;
+        let private_key_hex = env::var("SECRET_KEY").wrap_err("SECRET_KEY is not set")?;
+        let secret_key =
+            B256::from_hex(private_key_hex).wrap_err("could not hex-decode secret key")?;
 
         // parse rpc url
         let rpc_url_env = env::var("RPC_URL").wrap_err("RPC_URL is not set")?;
@@ -89,14 +81,6 @@ impl DriaOracleConfig {
         self
     }
 
-    /// Enables colored `eyre` error reports.
-    pub fn enable_color_eyre(self) -> Result<Self> {
-        if let Err(e) = color_eyre::install() {
-            log::error!("Error during color_eyre::install: {}", e);
-        }
-        Ok(self)
-    }
-
     /// Change the signer with a new one with the given secret key.
     pub fn with_secret_key(&mut self, secret_key: &B256) -> Result<&mut Self> {
         let signer =

src/configurations/mod.rs

@@ -50,7 +50,7 @@ pub struct Arweave {
     /// - https://gateway.irys.xyz
     /// - https://node1.bundlr.network
     base_url: Url,
-    /// Reqwest client
+    /// Reqwest client.
     client: Client,
     /// Byte limit for the data to be considered for Arweave.
     ///
@@ -64,7 +64,7 @@ impl Arweave {
     pub fn new(base_url: &str, wallet: &str, byte_limit: usize) -> Result<Self> {
         Ok(Self {
             wallet: PathBuf::from(wallet),
-            base_url: Url::parse(base_url)?,
+            base_url: Url::parse(base_url).wrap_err("could not parse base URL")?,
             client: Client::new(),
             byte_limit,
         })
@@ -73,18 +73,19 @@ impl Arweave {
     /// Creates a new Arweave instance from the environment variables.
     ///
     /// Required environment variables:
+    ///
     /// - `ARWEAVE_WALLET_PATH`
     /// - `ARWEAVE_BASE_URL`
     /// - `ARWEAVE_BYTE_LIMIT`
     ///
     /// All these variables have defaults if they are missing.
     pub fn new_from_env() -> Result<Self> {
-        dotenvy::dotenv()?;
         let wallet = env::var("ARWEAVE_WALLET_PATH").unwrap_or(DEFAULT_WALLET_PATH.to_string());
         let base_url = env::var("ARWEAVE_BASE_URL").unwrap_or(DEFAULT_BASE_URL.to_string());
         let byte_limit = env::var("ARWEAVE_BYTE_LIMIT")
             .unwrap_or(DEFAULT_BYTE_LIMIT.to_string())
-            .parse::<usize>()?;
+            .parse::<usize>()
+            .wrap_err("could not parse ARWEAVE_BYTE_LIMIT")?;
 
         Self::new(&base_url, &wallet, byte_limit)
     }
@@ -95,7 +96,9 @@ impl Arweave {
     /// we want to use hexadecimals to read them easily on-chain.
     #[inline(always)]
     pub fn base64_to_hex(key: &str) -> Result<String> {
-        let decoded_key = BASE64_URL_SAFE_NO_PAD.decode(key.as_bytes())?;
+        let decoded_key = BASE64_URL_SAFE_NO_PAD
+            .decode(key.as_bytes())
+            .wrap_err("could not decode base64 url")?;
         Ok(hex::encode(decoded_key))
     }
 
@@ -105,7 +108,7 @@ impl Arweave {
     /// we want to use hexadecimals to read them easily on-chain.
     #[inline(always)]
     pub fn hex_to_base64(key: &str) -> Result<String> {
-        let decoded_key = hex::decode(key)?;
+        let decoded_key = hex::decode(key).wrap_err("could not decode hexadecimals")?;
         Ok(BASE64_URL_SAFE_NO_PAD.encode(&decoded_key))
     }
 

src/data/arweave.rs

@@ -4,7 +4,6 @@ use eyre::{Context, Result};
 async fn main() -> Result<()> {
     let dotenv_result = dotenvy::dotenv();
     env_logger::try_init().wrap_err("could not initialize env_logger")?;
-    color_eyre::install().wrap_err("could not install color_eyre")?;
     if let Err(err) = dotenv_result {
         log::warn!("Could not load .env file: {}", err);
     }

src/main.rs

@@ -8,6 +8,8 @@ use ollama_workflows::Model;
 
 #[tokio::test]
 async fn test_oracle() -> Result<()> {
+    dotenvy::dotenv().unwrap();
+
     // task setup
     let difficulty = 1;
     let models = string_to_bytes(Model::GPT4Turbo.to_string());

tests/oracle_test.rs

@@ -11,6 +11,8 @@ use ollama_workflows::Model;
 
 #[tokio::test]
 async fn test_request() -> Result<()> {
+    dotenvy::dotenv().unwrap();
+
     // task setup
     let difficulty = 1;
     let num_gens = 1;

tests/request_test.rs

@@ -14,6 +14,8 @@ use ollama_workflows::Model;
 
 #[tokio::test]
 async fn test_swan() -> Result<()> {
+    dotenvy::dotenv().unwrap();
+
     // task setup
     let difficulty = 1;
     let models = string_to_bytes(Model::GPT4Turbo.to_string());

tests/swan_test.rs

@@ -10,6 +10,8 @@ use eyre::Result;
 
 #[tokio::test]
 async fn test_weth_transfer() -> Result<()> {
+    dotenvy::dotenv().unwrap();
+
     // amount of WETH that will be transferred
     let amount = parse_ether("100")?;