refactor: weather example (#2)

* wip

* working -> chain

* use bindings in weather + decode

* cleanup of docs + fmt

* readme slim down

* from scratch findings, good to go!

Author: reecepbcups

.docker/cli/.gitkeep

@@ -0,0 +1,21 @@
+
+# == project ==
+# Get your key from: https://openweathermap.org/ for the example
+WAVS_ENV_OPEN_WEATHER_API_KEY="00000000000000000000000000000000"
+
+# == ./packages/aggregator/.env ==
+WAVS_AGGREGATOR_MNEMONIC="test test test test test test test test test test test junk"
+WAVS_AGGREGATOR_DATA=~/wavs/aggregator
+
+# == ./packages/cli/.env ==
+WAVS_CLI_ETH_MNEMONIC="test test test test test test test test test test test junk"
+WAVS_CLI_DATA=~/wavs/cli
+WAVS_CLI_LOG_LEVEL="info, wavs_cli=debug"
+
+# == ./packages/wavs/.env ==
+WAVS_DATA=~/wavs/data
+WAVS_LOG_LEVEL="info, wavs[{subsys=TriggerManager}]=debug"
+WAVS_SUBMISSION_MNEMONIC="test test test test test test test test test test test junk"
+WAVS_COSMOS_SUBMISSION_MNEMONIC="cosmos mnemonic here"
+WAVS_E2E_COSMOS_MNEMONIC="e2e test cosmos mnemonic here"
+WAVS_E2E_COSMOS_TASK_QUEUE_ADDRESS="e2e test cosmos task queue address here"

.env.example

@@ -47,4 +47,4 @@ jobs:
         run: forge build --sizes
 
       - name: Check bindings are correct
-        run: forge bind --bindings-path ./crates/bindings --root ./contracts --crate-name bindings --skip-cargo-toml --alloy
+        run: forge bind --bindings-path ./crates/bindings --crate-name bindings --skip-cargo-toml --alloy

.github/workflows/contracts.yml

@@ -4,5 +4,5 @@ cache/
 Cargo.lock
 broadcast/
 compiled/*.wasm
-.docker
-wavs-cli.toml
+.docker/cli/*.json
+.env

.gitignore

@@ -4,6 +4,7 @@ members = [
     "crates/bindings",
     "components/*",
 ]
+resolver = "2"
 
 [workspace.package]
 edition = "2021"
@@ -16,6 +17,9 @@ rust-version = "1.80.0"
 
 [workspace.dependencies]
 bindings = { path = "crates/bindings" }
-# must match the bindings Cargo
+# alloy must match the bindings Cargo.toml version, git, and features
 alloy = { git = "https://github.com/alloy-rs/alloy", rev = "v0.9.2", features = ["sol-types", "contract"] }
 wit-bindgen-rt = { version = "0.32.0", features = ["bitflags"] }
+serde = { version = "1.0.211", features = ["derive"] }
+serde_json = "1.0.127"
+layer-wasi = { git = "https://github.com/Lay3rLabs/avs-toolkit", tag = "v0.2.1" }

Cargo.toml

@@ -16,6 +16,15 @@ bindings:
 build: bindings
 	@$(CARGO) build
 
+## wasi-build: building the WAVS wasi component(s)
+wasi-build:
+	@for component in $(shell ls ./components); do \
+		echo "Building component: $$component"; \
+		(cd components/$$component; cargo component build --release); \
+	done
+	@mkdir -p ./compiled
+	@cp ./target/wasm32-wasip1/release/*.wasm ./compiled/
+
 ## build-release: building the project in release mode
 build-release: bindings
 	@$(CARGO) build --release

Makefile

@@ -10,24 +10,11 @@
 
 **Template for quickly getting started with developing WAVS Rust applications**
 
-Continuous Integration is already set up to test both your Rust and Solidity
-code, as well as ensure formatting and that your Rust bindings match the
-Solidity build artifacts.
+A comprehensive template for developing WAVS (WebAssembly AVS) applications using Rust and Solidity. This template provides a pre-configured development environment with integrated testing frameworks for both Rust and Solidity components.
 
-<!-- ## Directory Structure
+## Installation
 
-The project is structured as a mixed Rust workspace with a Foundry project under
-`contracts/` and typesafe auto-generated bindings to the contracts under
-`crates/bindings/`.
-
-```
-├── Cargo.toml
-├── app // <-- Your Rust application logic
-├── crates
-    └── bindings // <-- Generated bindings to the smart contracts' abis (like Typechain)
-``` -->
-
-## Install
+Create a new project using this template:
 
 ```bash
 forge init --template https://github.com/Lay3rLabs/wavs-foundry-template my-wavs
@@ -38,19 +25,21 @@ forge init --template https://github.com/Lay3rLabs/wavs-foundry-template my-wavs
 Given the repository contains both Solidity and Rust code, there's 2 different
 workflows.
 
-### Solidity
-
-Forge is using submodules to manage dependencies. Initialize the dependencies:
+### Setting up the Environment
 
-If you are in the root directory of the project, run:
+Initialize the submodule dependencies:
 
 ```bash
 forge install
 ```
 
-Then, run the tests:
+Build the contracts:
+
+```bash
+forge build
+```
 
-If you are in the root directory of the project, run:
+Run the tests:
 
 ```bash
 forge test
@@ -61,12 +50,7 @@ forge test
 Rust bindings to the contracts can be generated via `forge bind`, which requires
 first building your contracts:
 
-<!-- Any follow-on calls to `forge bind` will check that the generated bindings match
-the ones under the build files. If you want to re-generate your bindings, pass
-the `--overwrite` flag to your `forge bind` command. -->
-
 ```bash
-forge build
 make bindings
 ```
 
@@ -76,77 +60,65 @@ Then, you can run the tests:
 cargo test
 ```
 
-## WAVS Operations
+## WAVS
+
+Build the latest solidity:
 
 ```bash
 forge build
 ```
 
-Run the following in the WAVS repo (separate terminal)
+Install the WAVS CLI:
+
 ```bash
-# this is based on ebf8cf6bc001d8292696ef6883d55d749c41bdd9 in the WAVS repo
-docker compose up # <- in the WAVS repository
+(cd lib/WAVS; cargo install --path ./packages/cli)
 ```
 
-Upload ServiceManager from this repo
-
 ```bash
-export CLI_EIGEN_CORE_DELEGATION_MANAGER=`docker exec -it wavs bash -c 'jq -r .eigen_core.local.delegation_manager ~/wavs/cli/deployments.json' | tr -d '\r'`
-export CLI_EIGEN_CORE_REWARDS_COORDINATOR=`docker exec -it wavs bash -c 'jq -r .eigen_core.local.rewards_coordinator ~/wavs/cli/deployments.json' | tr -d '\r'`
-export CLI_EIGEN_CORE_AVS_DIRECTORY=`docker exec -it wavs bash -c 'jq -r .eigen_core.local.avs_directory ~/wavs/cli/deployments.json' | tr -d '\r'`
-export FOUNDRY_ANVIL_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+cp .env.example .env
 
-forge script ./script/WavsServiceManager.s.sol --rpc-url http://localhost:8545 --broadcast
-```
-
-Build WAVS WASI component
+# [!] Get your key from: https://openweathermap.org/
+# Update the WAVS_ENV_OPEN_WEATHER_API_KEY in the .env file with your key`
 
-```bash
-(cd components/eth-trigger-echo; cargo component build --release)
+cp ./lib/WAVS/packages/wavs/wavs.toml .
+cp ./lib/WAVS/packages/cli/wavs-cli.toml .
 
-mkdir -p ./compiled && cp ./target/wasm32-wasip1/release/*.wasm ./compiled/
+# start the WAVS network
+docker compose up
 ```
 
-Verify
+Deploy Eigenlayer and upload your WAVS Service contract
 
 ```bash
-# install wavs-cli
-# https://github.com/Lay3rLabs/WAVS/issues/277
-# - right now `E0308` is super annoying @ packages/wavs/src/submission/core.rs:426:13 ^ have to do a `result: result.into(),` for now.
-(cd lib/WAVS; cargo install --path ./packages/cli)
-
-cp ./lib/WAVS/packages/cli/wavs-cli.toml .
+docker_cmd="docker exec -it wavs bash -c"
+export CLI_EIGEN_CORE_DELEGATION_MANAGER=`${docker_cmd} 'jq -r .eigen_core.local.delegation_manager ~/wavs/cli/deployments.json' | tr -d '\r'`
+export CLI_EIGEN_CORE_REWARDS_COORDINATOR=`${docker_cmd}  'jq -r .eigen_core.local.rewards_coordinator ~/wavs/cli/deployments.json' | tr -d '\r'`
+export CLI_EIGEN_CORE_AVS_DIRECTORY=`${docker_cmd}  'jq -r .eigen_core.local.avs_directory ~/wavs/cli/deployments.json' | tr -d '\r'`
+export FOUNDRY_ANVIL_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
 
-# Local Exec
-# ./compiled/eth_trigger_echo.wasm does not work because it's relative in `read_component(path: impl AsRef<Path>) -> Vec<u8> ...  Path::new("../../")`
-wavs-cli exec --component $(pwd)/compiled/eth_trigger_echo.wasm --input testing
+forge script ./script/WavsServiceManager.s.sol --rpc-url http://localhost:8545 --broadcast
+```
 
-# use the Eigenlayer deployed contracts
-mkdir -p .docker; docker cp wavs:/root/wavs/cli/deployments.json .docker/deployments.json
+Build WAVS WASI component(s)
 
-# Actual deploy
-# - Service manager is from the script/WavsServiceManager.s.sol broadcast logs
-export WAVS_CLI_ETH_MNEMONIC="test test test test test test test test test test test junk"
-wavs-cli deploy-service --component $(pwd)/compiled/eth_trigger_echo.wasm  --service-manager 0x851356ae760d987E095750cCeb3bC6014560891C --data ./.docker
+```bash
+# build all components/*
+make wasi-build
 
-wavs-cli add-task --input "hello testing!" --data ./.docker --service-id <Service-ID>
+# Verify execution works as expected without deploying
+wavs-cli exec --component $(pwd)/compiled/eth_trigger_weather.wasm --input Nashville,TN
 ```
 
+Deploy service and verify with adding a task
 
-## Installing Foundry
-
-First run the command below to get `foundryup`, the Foundry toolchain installer:
+```bash
+source .env
 
-```sh
-curl -L https://foundry.paradigm.xyz | bash
-```
+sudo chmod 0666 .docker/cli/deployments.json
 
-Then, in a new terminal session or after reloading your `PATH`, run it to get
-the latest `forge` and `cast` binaries:
+wavs-cli deploy-service --data ./.docker/cli --component $(pwd)/compiled/eth_trigger_weather.wasm \
+  --service-manager 0x851356ae760d987E095750cCeb3bC6014560891C \
+  --service-config '{"fuelLimit":100000000,"maxGas":5000000,"hostEnvs":["WAVS_ENV_OPEN_WEATHER_API_KEY"],"kv":[]}'
 
-```sh
-foundryup
+wavs-cli add-task --input "Nashville,TN" --data ./.docker/cli --service-id <Service-ID>
 ```
-
-For more, see the official
-[docs](https://github.com/gakonst/foundry#installation).

README.md

@@ -1,19 +1,38 @@
 use alloy::{
-    primitives::Address,
-    providers::{Provider, ProviderBuilder},
+    hex, primitives::Address, providers::{Provider, ProviderBuilder}
 };
 use bindings::wavsservicemanager::WavsServiceManager;
 use eyre::Result;
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let provider = ProviderBuilder::new().on_builtin("http://127.0.0.1:8545").await?;
+    let url = "http://127.0.0.1:8545";
+    let provider = ProviderBuilder::new().on_builtin(url).await?;
 
-    let address = "0x0000000000000000000000000000000000000000".parse::<Address>()?;
+    if provider.get_block_number().await? == 0 {
+        println!("No blocks / interactions on {url} yet.");
+        return Ok(());
+    }
 
-    let _contract = WavsServiceManager::new(address, provider.clone());
+    // update me before running
+    let contract_address = "0x851356ae760d987e095750cceb3bc6014560891c".parse::<Address>()?;
+    let contract = WavsServiceManager::new(contract_address, provider.clone());
+
+    let resp = contract.signedDataByTriggerId(1).call().await?;
+
+    let hex = resp.data;
+    println!("Weather Response Hex: {:?}\n", hex);
+
+    let ascii = to_ascii(hex.to_string().as_str())?;
+    println!("Weather Response ASCII: {:?}", ascii);
 
-    let blk = provider.get_block_number().await?;
-    println!("Hello, world! {}", blk);
     Ok(())
 }
+
+pub fn to_ascii(hex: &str) -> Result<String> {
+    let bytes = hex::decode(hex)?;
+    if !bytes.iter().all(u8::is_ascii) {
+        return Err(eyre::eyre!("Invalid ASCII bytes"));
+    }
+    Ok(String::from_utf8(bytes).unwrap())
+}

app/src/main.rs

@@ -1,5 +1,5 @@
 [package]
-name = "eth-trigger-echo"
+name = "eth-trigger-weather"
 edition.workspace = true
 version.workspace = true
 authors.workspace = true
@@ -8,6 +8,10 @@ repository.workspace = true
 
 [dependencies]
 wit-bindgen-rt = { workspace = true }
+layer-wasi = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = {workspace = true}
+reqwest = {version = "0.12.12"}
 
 [lib]
 crate-type = ["cdylib"]
@@ -20,7 +24,7 @@ strip = true
 lto = true
 
 [package.metadata.component]
-package = "component:eth-trigger-echo"
+package = "component:eth-trigger-weather"
 
 [package.metadata.component.target]
 path = "../../lib/WAVS/wit"