refactor: move to CMC example (#32)

* remove weather example

* other migrations

* new eth-price-oracle example with CMC

* simplify

Author: reecepbcups

.env.example

@@ -1,7 +1,7 @@
 
 # == project ==
-# Get your key from: https://openweathermap.org/ for the example
-WAVS_ENV_OPEN_WEATHER_API_KEY="00000000000000000000000000000000"
+# TODO: make sure you set any project specific env vars in the service_config's host_envs on deploy
+WAVS_ENV_YOURKEYHERE="00000000000000000000000000000000"
 
 # WAVS
 WAVS_DATA=~/wavs/data

Cargo.lock

@@ -39,7 +39,7 @@ forge test
 ## Rust
 
 ```bash
-# Generate new bindings from your contract(s)
+# Generate new bindings from your contract(s) alias: `make build`
 make bindings
 
 # Run rust tests
@@ -55,7 +55,7 @@ make test
 # (cd lib/WAVS; cargo install --path ./packages/cli)
 # (cd lib/WAVS; just docker-build)
 
-docker cp $(docker create --name tc ghcr.io/lay3rlabs/wavs:0.3.0-alpha5-amd64):/usr/local/bin/wavs-cli ~/.cargo/bin/wavs-cli && docker rm tc
+docker cp $(docker create --name tc ghcr.io/lay3rlabs/wavs:0.3.0-alpha5):/usr/local/bin/wavs-cli ~/.cargo/bin/wavs-cli && docker rm tc
 ```
 
 ### Start Anvil, WAVS, and Deploy Eigenlayer
@@ -64,9 +64,6 @@ docker cp $(docker create --name tc ghcr.io/lay3rlabs/wavs:0.3.0-alpha5-amd64):/
 # copy over the .env file
 cp .env.example .env
 
-# [!] Get your key from: https://openweathermap.org/
-# Update the WAVS_ENV_OPEN_WEATHER_API_KEY in the .env file with your key`
-
 # MacOS Docker:
 # Docker Engine -> Settings -> Resources -> Network -> 'Enable Host Networking'
 # or
@@ -82,11 +79,11 @@ sudo chmod 0666 .docker/cli/deployments.json
 wavs-cli deploy-eigen-service-manager --data ./.docker/cli
 export SERVICE_MANAGER=`jq -r '.eigen_service_managers.local | .[-1]' .docker/cli/deployments.json`
 
-# Deploy
+# Deploy contracts
 export FOUNDRY_ANVIL_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
 forge script ./script/Deploy.s.sol ${SERVICE_MANAGER} --sig "run(string)" --rpc-url http://localhost:8545 --broadcast
 
-# Grab deployed service manager from script file output
+# Get deployed contracts
 export SERVICE_HANDLER_ADDR=`jq -r '.service_handler' "./.docker/cli/script_deploy.json"`
 echo "Service Handler Addr: $SERVICE_HANDLER_ADDR"
 
@@ -102,7 +99,7 @@ make wasi-build
 
 # TODO: currently broken upstream
 # Verify execution works as expected without deploying
-# wavs-cli exec --component $(pwd)/compiled/eth_trigger_weather.wasm --input Nashville,TN
+# wavs-cli exec --component $(pwd)/compiled/eth_price_oracle.wasm --input `cast format-bytes32-string 1`
 ```
 
 ## Deploy Service and Verify
@@ -111,18 +108,16 @@ make wasi-build
 # Contract trigger function signature to listen for
 trigger_event=$(cast sig-event "NewTrigger(bytes)"); echo "Trigger Event: $trigger_event"
 
-wavs-cli deploy-service --log-level=error --quiet-results=false --data ./.docker/cli --component $(pwd)/compiled/eth_trigger_weather.wasm \
+wavs-cli deploy-service --log-level=error --data ./.docker/cli --component $(pwd)/compiled/eth_price_oracle.wasm \
   --trigger-event-name ${trigger_event:2} \
   --trigger eth-contract-event \
   --trigger-address ${TRIGGER_ADDR} \
   --submit-address ${SERVICE_HANDLER_ADDR} \
-  --service-config '{"fuel_limit":100000000,"max_gas":5000000,"host_envs":["WAVS_ENV_OPEN_WEATHER_API_KEY"],"kv":[],"workflow_id":"default","component_id":"default"}'
-
+  --service-config '{"fuel_limit":100000000,"max_gas":5000000,"host_envs":[],"kv":[],"workflow_id":"default","component_id":"default"}'
 
 # Submit AVS request -> chain
-cast send ${TRIGGER_ADDR} "addTrigger(bytes)" `cast format-bytes32-string Nashville,TN` --rpc-url http://localhost:8545 --private-key $FOUNDRY_ANVIL_PRIVATE_KEY
+cast send ${TRIGGER_ADDR} "addTrigger(bytes)" `cast format-bytes32-string 1` --rpc-url http://localhost:8545 --private-key $FOUNDRY_ANVIL_PRIVATE_KEY
 
-# Grab data from the contract directly
-hex_bytes=$(cast decode-abi "getData(uint64)(bytes)" `cast call ${SERVICE_HANDLER_ADDR} "getData(uint64)" 1`)
-echo `cast --to-ascii $hex_bytes`
+ID=`cast call ${TRIGGER_ADDR} "nextTriggerId()" --rpc-url http://localhost:8545`; echo "ID: $ID"
+cast --to-ascii $(cast decode-abi "getData(uint64)(bytes)" `cast call ${SERVICE_HANDLER_ADDR} "getData(uint64)" $ID`)
 ```

README.md

@@ -26,10 +26,10 @@ async fn main() -> Result<()> {
     let resp = contract.getData(1).call().await?;
 
     let hex = resp.data;
-    println!("Weather Response Hex: {:?}\n", hex);
+    println!("Response Hex: {:?}\n", hex);
 
     let ascii = to_ascii(hex.to_string().as_str())?;
-    println!("Weather Response ASCII: {:?}", ascii);
+    println!("Response ASCII: {:?}", ascii);
 
     Ok(())
 }

app/src/main.rs

@@ -1,5 +1,5 @@
 [package]
-name = "eth-trigger-weather"
+name = "eth-price-oracle"
 edition.workspace = true
 version.workspace = true
 authors.workspace = true
@@ -32,5 +32,5 @@ strip = true
 lto = true
 
 [package.metadata.component]
-package = "component:eth-trigger-weather"
+package = "component:eth-price-oracle"
 target = "wavs:worker/layer-trigger-world@0.3.0-alpha2"

components/eth-trigger-weather/Cargo.toml components/eth-price-oracle/Cargo.tomlcomponents/eth-trigger-weather/Cargo.toml renamed to components/eth-price-oracle/Cargo.toml

@@ -0,0 +1,143 @@
+mod trigger;
+use trigger::{decode_trigger_event, encode_trigger_output};
+pub mod bindings;
+use crate::bindings::{export, Guest, TriggerAction};
+use serde::{Deserialize, Serialize};
+use wstd::{
+    http::{Client, Request},
+    io::{empty, AsyncRead},
+    runtime::block_on,
+};
+
+struct Component;
+export!(Component with_types_in bindings);
+
+impl Guest for Component {
+    fn run(trigger_action: TriggerAction) -> std::result::Result<Vec<u8>, String> {
+        let (trigger_id, req) =
+            decode_trigger_event(trigger_action.data).map_err(|e| e.to_string())?;
+
+        // Convert bytes to string and parse first char as u64
+        let input = std::str::from_utf8(&req).map_err(|e| e.to_string())?;
+        println!("input id: {}", input);
+
+        let id = input.chars().next().ok_or("Empty input")?;
+        let id = id.to_digit(16).ok_or("Invalid hex digit")? as u64;
+
+        let res = block_on(async move {
+            let resp_data = get_price_feed(id).await;
+            println!("resp_data: {:?}", resp_data);
+
+            match resp_data {
+                Ok(resp) => {
+                    let output: Vec<u8> = serde_json::to_vec(&resp).unwrap();
+                    Ok(output)
+                }
+                Err(e) => Err(e),
+            }
+        });
+
+        match res {
+            Ok(data) => Ok(encode_trigger_output(trigger_id, &data)),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+async fn get_price_feed(id: u64) -> Result<PriceFeedData, String> {
+    let url = format!(
+        "https://api.coinmarketcap.com/data-api/v3/cryptocurrency/detail?id={}&range=1h",
+        id
+    );
+
+    let current_time = std::time::SystemTime::now().elapsed().unwrap().as_secs();
+
+    let req = Request::get(url)
+        .header("Accept", "application/json")
+        .header("Content-Type", "application/json")
+        .header("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36")
+        .header("Cookie", format!("myrandom_cookie={}", current_time))
+        .body(empty())
+        .unwrap();
+
+    let response = Client::new().send(req).await;
+
+    // print out response
+    println!("response: {:?}", response);
+
+    match response {
+        Ok(mut response) => {
+            let mut body_buf = Vec::new();
+            response.body_mut().read_to_end(&mut body_buf).await.unwrap();
+
+            let resp = String::from_utf8_lossy(&body_buf);
+            let json: Root = serde_json::from_str(format!(r#"{}"#, resp).as_str()).unwrap();
+
+            return Ok(PriceFeedData {
+                symbol: json.data.symbol,
+                price: json.data.statistics.price,
+                timestamp: json.status.timestamp,
+            });
+        }
+        Err(e) => {
+            return Err(e.to_string());
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PriceFeedData {
+    symbol: String,
+    timestamp: String,
+    price: f64,
+}
+
+/// -----
+/// https://transform.tools/json-to-rust-serde
+/// Generated from https://api.coinmarketcap.com/data-api/v3/cryptocurrency/detail?id=1&range=1h
+/// -----
+///
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Root {
+    pub data: Data,
+    pub status: Status,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Data {
+    pub id: f64,
+    pub name: String,
+    pub symbol: String,
+    pub statistics: Statistics,
+    pub description: String,
+    pub category: String,
+    pub slug: String,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Statistics {
+    pub price: f64,
+    #[serde(rename = "totalSupply")]
+    pub total_supply: f64,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct CoinBitesVideo {
+    pub id: String,
+    pub category: String,
+    #[serde(rename = "videoUrl")]
+    pub video_url: String,
+    pub title: String,
+    pub description: String,
+    #[serde(rename = "previewImage")]
+    pub preview_image: String,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Status {
+    pub timestamp: String,
+    pub error_code: String,
+    pub error_message: String,
+    pub elapsed: String,
+    pub credit_count: f64,
+}