[DRAFT] Eigen Incredible Squaring Blueprint Integration Test

Cargo.toml

@@ -147,17 +147,17 @@ typed-builder = "0.19"
 url = { git = "https://github.com/domenukk/rust-url", branch = "no_std", default-features = false }
 w3f-bls = { version = "0.1.4", default-features = false }
 
-alloy-primitives = "0.7.7"
-alloy-json-abi = "0.7.7"
-alloy-sol-types = "0.7.7"
-alloy-rpc-types = { version = "0.2.1" }
-alloy-provider = { version = "0.2.1", default-features = false, features = ["reqwest", "ws"] }
-alloy-pubsub = { version = "0.2.1" }
-alloy-signer = { version = "0.2.1" }
-alloy-signer-local = { version = "0.2.1" }
-alloy-network = { version = "0.2.1" }
-alloy-contract = { version = "0.2.1" }
-alloy-transport = { version = "0.2.1" }
+alloy-primitives = "0.8.3"
+alloy-json-abi = "0.8.3"
+alloy-sol-types = "0.8.3"
+alloy-rpc-types = { version = "0.3.6" }
+alloy-provider = { version = "0.3.6", default-features = false, features = ["reqwest", "ws"] }
+alloy-pubsub = { version = "0.3.6" }
+alloy-signer = { version = "0.3.6" }
+alloy-signer-local = { version = "0.3.6" }
+alloy-network = { version = "0.3.6" }
+alloy-contract = { version = "0.3.6" }
+alloy-transport = { version = "0.3.6" }
 
 ark-bn254 = "0.4.0"
 ark-ec = "0.4.0"
@@ -176,7 +176,8 @@ secp256k1 = "0.29.1"
 
 # Eigenlayer
 # TODO: Remove this branch, point to main once https://github.com/webb-tools/eigensdk-rs/pull/20 is merged
-eigensdk-rs = { git = "https://github.com/webb-tools/eigensdk-rs.git", branch = "donovan/maintenance" }
+#eigensdk-rs = { git = "https://github.com/webb-tools/eigensdk-rs.git", branch = "donovan/maintenance" }
+eigensdk-rs = { path = "../eigensdk-rs" }
 
 [profile.dev.package.backtrace]
 opt-level = 3

blueprint-test-utils/Cargo.toml

@@ -70,6 +70,7 @@ uuid = { workspace = true, features = ["v4"] }
 schnorrkel = { workspace = true }
 subxt = { workspace = true, features = ["substrate-compat"] }
 color-eyre = { workspace = true }
+eigensdk-rs = { workspace = true }
 
 # Pallets
 pallet-timestamp = { workspace = true }

blueprint-test-utils/src/lib.rs

@@ -551,4 +551,99 @@ mod tests_standard {
             })
             .await
     }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_eigen_incredible_squaring_blueprint() {
+        let mut base_path = std::env::current_dir().expect("Failed to get current directory");
+
+        base_path.push("../blueprints/incredible-squaring");
+        base_path
+            .canonicalize()
+            .expect("File could not be normalized");
+
+        let manifest_path = base_path.join("Cargo.toml");
+        let blueprint_test_file = base_path.join("blueprint-test.json");
+        let blueprint_file = base_path.join("blueprint.json");
+
+        // cp the blueprint-test-file into the blueprint-file
+        tokio::fs::copy(&blueprint_test_file, &blueprint_file)
+            .await
+            .expect("Failed to copy blueprint-test.json to blueprint.json");
+
+        let opts = Opts {
+            pkg_name: Some("incredible-squaring-blueprint".to_string()),
+            rpc_url: "ws://127.0.0.1:9944".to_string(),
+            manifest_path,
+            signer: None,
+            signer_evm: None,
+        };
+        // --ws-external
+        const INPUT: u64 = 10;
+        const OUTPUT: u64 = INPUT.pow(2);
+
+        // Start Local Anvil Testnet in the background
+        let _ = eigensdk_rs::test_utils::anvil::testnet::incredible_squaring::run_incredible_squaring_testnet().await;
+
+        new_test_ext_blueprint_manager::<5, 1, (), _, _>((), opts, run_test_blueprint_manager)
+            .await
+            .execute_with_async(move |client, handles, logger| async move {
+                // At this point, blueprint has been deployed, every node has registered
+                // as an operator for the relevant services, and, all gadgets are running
+
+                // What's left: Submit a job, wait for the job to finish, then assert the job results
+                let keypair = handles[0].sr25519_id().clone();
+
+                // TODO: Important! The tests can only run serially, not in parallel, in order to not cause a race condition in IDs
+                let service_id = get_next_service_id(client)
+                    .await
+                    .expect("Failed to get next service id")
+                    .saturating_sub(1);
+                let call_id = get_next_call_id(client)
+                    .await
+                    .expect("Failed to get next job id")
+                    .saturating_sub(1);
+
+                logger.info(format!(
+                    "Submitting job with params service ID: {service_id}, call ID: {call_id}"
+                ));
+
+                // Pass the arguments
+                let mut job_args = Args::new();
+                let input =
+                    api::runtime_types::tangle_primitives::services::field::Field::Uint64(INPUT);
+                job_args.push(input);
+
+                // Next step: submit a job under that service/job id
+                if let Err(err) = submit_job(
+                    client,
+                    &keypair,
+                    service_id,
+                    Job::from(call_id as u8),
+                    job_args,
+                )
+                .await
+                {
+                    logger.error(format!("Failed to submit job: {err}"));
+                    panic!("Failed to submit job: {err}");
+                }
+
+                // Step 2: wait for the job to complete
+                let job_results = wait_for_completion_of_tangle_job(
+                    client,
+                    service_id,
+                    call_id,
+                    handles[0].logger(),
+                )
+                .await
+                .expect("Failed to wait for job completion");
+
+                // Step 3: Get the job results, compare to expected value(s)
+                let expected_result =
+                    api::runtime_types::tangle_primitives::services::field::Field::Uint64(OUTPUT);
+                assert_eq!(job_results.service_id, service_id);
+                assert_eq!(job_results.call_id, call_id);
+                assert_eq!(job_results.result[0], expected_result);
+            })
+            .await
+    }
 }

blueprints/incredible-squaring/src/eigenlayer.rs

@@ -4,31 +4,30 @@ use alloy_network::Ethereum;
 use alloy_network::EthereumWallet;
 use alloy_primitives::{Address, ChainId, FixedBytes};
 use alloy_primitives::{Bytes, U256};
-use alloy_provider::ProviderBuilder;
 use alloy_provider::Provider;
+use alloy_provider::ProviderBuilder;
 use alloy_signer::k256::ecdsa::SigningKey;
+use alloy_signer::k256::elliptic_curve::SecretKey;
 use alloy_signer_local::PrivateKeySigner;
 use alloy_sol_types::private::alloy_json_abi::JsonAbi;
 use alloy_sol_types::sol;
+use alloy_transport::Transport;
 use color_eyre::{eyre::eyre, eyre::OptionExt, Result};
 use gadget_sdk::job;
 use gadget_sdk::{
-    events_watcher::{
-        evm::{Config, EventWatcher},
-    },
+    events_watcher::evm::{Config, EventWatcher},
     keystore::Backend,
     network::setup::{start_p2p_network, NetworkConfig},
     run::GadgetRunner,
 };
 use std::convert::Infallible;
 use std::ops::Deref;
 use std::sync::OnceLock;
-use alloy_signer::k256::elliptic_curve::SecretKey;
-use alloy_transport::Transport;
-use IncredibleSquaringTaskManager::{
-    respondToTaskCall, G1Point, G2Point,
-    NonSignerStakesAndSignature, Task, TaskResponse,
-};
+use IBLSSignatureChecker::NonSignerStakesAndSignature;
+use IIncredibleSquaringTaskManager::{Task, TaskResponse};
+use IncredibleSquaringTaskManager::respondToTaskCall;
+use BN254::{G1Point, G2Point};
+
 use gadget_sdk::{
     tangle_subxt::tangle_testnet_runtime::api::{
         runtime_types::{sp_core::ecdsa, tangle_primitives::services},
@@ -40,9 +39,7 @@ use eigensdk_rs::eigen_utils::*;
 use eigensdk_rs::incredible_squaring_avs::operator::*;
 use sp_core::Pair;
 use subxt_signer::ecdsa::SecretKeyBytes;
-use gadget_sdk::config::{
-    GadgetConfiguration, StdGadgetConfiguration,
-};
+use gadget_sdk::config::GadgetConfiguration;
 use gadget_sdk::network::gossip::GossipHandle;
 use gadget_sdk::tangle_subxt::tangle_testnet_runtime::api;
 use gadget_sdk::tangle_subxt::tangle_testnet_runtime::api::runtime_types::tangle_primitives::services::PriceTargets;
@@ -77,8 +74,6 @@ pub async fn xsquare_eigen(
     quorum_threshold_percentage: u32,
 ) -> Result<respondToTaskCall, Infallible> {
     // TODO: Send our task response to Aggregator RPC server
-    // TODO: OR we use the gossip protocol to send the response to peers
-    // TODO: Where is by BLS key?
 
     // // 1. Calculate the squared number and save the response
     // let my_msg = MyMessage {
@@ -166,7 +161,7 @@ pub fn convert_event_to_inputs(
 impl GadgetRunner for EigenlayerGadgetRunner<parking_lot::RawRwLock> {
     type Error = color_eyre::eyre::Report;
 
-    fn config(&self) -> &StdGadgetConfiguration {
+    fn config(&self) -> &GadgetConfiguration<parking_lot::RawRwLock> {
         todo!()
     }
 
@@ -252,15 +247,15 @@ impl GadgetRunner for EigenlayerGadgetRunner<parking_lot::RawRwLock> {
             .clone()
             .boxed();
 
-        let _ws_provider = ProviderBuilder::new()
+        let ws_provider = ProviderBuilder::new()
             .with_recommended_fillers()
             .wallet(wallet)
             .on_http(self.env.rpc_endpoint.parse()?)
             .root()
             .clone()
             .boxed();
 
-        let _operator_info_service = OperatorInfoService::new(
+        let operator_info_service = OperatorInfoService::new(
             types::OperatorInfo {
                 socket: "0.0.0.0:0".to_string(),
                 pubkeys: OperatorPubkeys {
@@ -278,27 +273,27 @@ impl GadgetRunner for EigenlayerGadgetRunner<parking_lot::RawRwLock> {
             .await
             .map_err(|e| OperatorError::HttpEthClientError(e.to_string()))?;
 
-        let _signer = EigenGadgetSigner::new(
+        let signer = EigenGadgetSigner::new(
             PrivateKeySigner::from_signing_key(ecdsa_signing_key),
             Some(ChainId::from(chain_id)),
         );
 
         // This creates and registers an operator with the given configuration
-        // let operator = Operator::<NodeConfig, OperatorInfoService>::new_from_config(
-        //     node_config.clone(),
-        //     EigenGadgetProvider {
-        //         provider: http_provider,
-        //     },
-        //     EigenGadgetProvider {
-        //         provider: ws_provider,
-        //     },
-        //     operator_info_service,
-        //     signer,
-        // )
-        // .await
-        // .map_err(|e| eyre!(e))?;
+        let operator = Operator::<NodeConfig, OperatorInfoService>::new_from_config(
+            node_config.clone(),
+            EigenGadgetProvider {
+                provider: http_provider.clone(),
+            },
+            EigenGadgetProvider {
+                provider: ws_provider.clone(),
+            },
+            operator_info_service.clone(),
+            signer.clone(),
+        )
+        .await
+        .map_err(|e| eyre!(e))?;
 
-        // self.set_operator(operator);
+        self.set_operator(operator);
 
         tracing::info!("Registered operator for Eigenlayer");
         Ok(())
@@ -308,7 +303,7 @@ impl GadgetRunner for EigenlayerGadgetRunner<parking_lot::RawRwLock> {
         todo!()
     }
 
-    async fn run(&self) -> Result<()> {
+    async fn run(&mut self) -> Result<()> {
         // Tangle Portion of Run
         let _client = self.env.client().await.map_err(|e| eyre!(e))?;
         let signer = self.env.first_signer().map_err(|e| eyre!(e))?;
@@ -376,19 +371,45 @@ impl GadgetRunner for EigenlayerGadgetRunner<parking_lot::RawRwLock> {
 
         let _network: GossipHandle =
             start_p2p_network(network_config).map_err(|e| eyre!(e.to_string()))?;
+
         // let x_square_eigen = blueprint::XsquareEigenEventHandler {
         //     ctx: blueprint::MyContext { network, keystore },
         // };
-        //
-        // let contract: IncredibleSquaringTaskManager::IncredibleSquaringTaskManagerInstance = IncredibleSquaringTaskManager::IncredibleSquaringTaskManagerInstance::new(contract_address, provider);
+
         //
         // EventWatcher::run(
         //     &EigenlayerEventWatcher,
         //     contract,
         //     // Add more handler here if we have more functions.
         //     vec![Box::new(x_square_eigen)],
         // )
-        // .await?;
+        // .await?;'
+
+        let operator = self.operator.ok_or(eyre!("Run Error - No Operator Found"))?;
+
+        let instance = IncredibleSquaringTaskManagerInstanceWrapper::new(
+            IncredibleSquaringTaskManager::new(
+                operator.incredible_squaring_contract_manager.task_manager_addr.clone(),
+                operator.incredible_squaring_contract_manager.eth_client_http.clone(),
+            ),
+        );
+
+        let event_watcher: EigenlayerEventWatcher<NodeConfig> = EigenlayerEventWatcher::new();
+        event_watcher
+            .run(
+                instance,
+                vec![
+                // Box::new(x_square_eigen)
+                ],
+            )
+            .await?;
+
+        // self.operator.unwrap().start().await?;
+        // if let Some(operator) = &self.operator {
+        //     operator.start().await?;
+        // } else {
+        //     return Err(eyre!("Run Error - No Operator Found"));
+        // }
 
         Ok(())
     }

blueprints/incredible-squaring/src/main.rs

@@ -15,12 +15,6 @@ use structopt::StructOpt;
 use gadget_sdk::run::GadgetRunner;
 use gadget_sdk::tangle_subxt::tangle_testnet_runtime::api::runtime_types::tangle_primitives::services::PriceTargets;
 
-// #[async_trait::async_trait]
-// trait GadgetRunner {
-//     async fn register(&self) -> Result<()>;
-//     async fn run(&self) -> Result<()>;
-// }
-
 struct TangleGadgetRunner {
     env: GadgetConfiguration<parking_lot::RawRwLock>,
 }
@@ -73,7 +67,7 @@ impl GadgetRunner for TangleGadgetRunner {
         todo!()
     }
 
-    async fn run(&self) -> Result<()> {
+    async fn run(&mut self) -> Result<()> {
         let client = self.env.client().await.map_err(|e| eyre!(e))?;
         let signer = self.env.first_signer().map_err(|e| eyre!(e))?;
         let logger = self.env.logger.clone();
@@ -124,7 +118,7 @@ async fn create_gadget_runner(
 async fn main() -> Result<()> {
     // Load the environment and create the gadget runner
     // TODO: Place protocol in the config
-    let protocol = Protocol::Tangle;
+    let protocol = Protocol::Eigenlayer;
     let config = ContextConfig::from_args();
 
     let (env, mut runner) = create_gadget_runner(protocol, config.clone()).await;