chore: add trading-volume-example for testing

Author: drewstone

Cargo.lock

@@ -33,6 +33,9 @@ futures = "0.3.31"
 serde_json = "1.0.140"
 reqwest = "0.12.15"
 tempfile = "3.13"
+rand = "0.8"
 
+parity-scale-codec = { version = "3", features = ["derive"] }
 pico-sdk = { git = "https://github.com/brevis-network/pico", features = ["coprocessor"] }
 pico-vm = { git = "https://github.com/brevis-network/pico" }
+coprocessor-sdk = { git = "https://github.com/brevis-network/Pico-zkCoprocessor" }

Cargo.toml

@@ -1,8 +1,8 @@
 use blueprint_sdk::build;
 use blueprint_sdk::tangle::blueprint;
+use pico_coprocessor_service_blueprint_lib::{generate_coprocessor_proof, generate_proof};
 use std::path::Path;
 use std::process;
-use pico_coprocessor_service_blueprint_lib::say_hello;
 
 fn main() {
     // Automatically update dependencies with `soldeer` (if available), and build the contracts.
@@ -22,7 +22,7 @@ fn main() {
         name: "experiment",
         master_manager_revision: "Latest",
         manager: { Evm = "HelloBlueprint" },
-        jobs: [say_hello]
+        jobs: [generate_proof, generate_coprocessor_proof]
     };
 
     match blueprint {
@@ -31,12 +31,12 @@ fn main() {
             let json = blueprint_sdk::tangle::metadata::macros::ext::serde_json::to_string_pretty(
                 &blueprint,
             )
-                .unwrap();
+            .unwrap();
             std::fs::write(
                 Path::new(env!("CARGO_WORKSPACE_DIR")).join("blueprint.json"),
                 json.as_bytes(),
             )
-                .unwrap();
+            .unwrap();
         }
         Err(e) => {
             println!("cargo::error={e:?}");

pico-coprocessor-service-bin/build.rs

@@ -1,98 +1,130 @@
-use blueprint_sdk::Job;
-use blueprint_sdk::Router;
-use blueprint_sdk::contexts::tangle::TangleClientContext;
-use blueprint_sdk::crypto::sp_core::SpSr25519;
-use blueprint_sdk::crypto::tangle_pair_signer::TanglePairSigner;
-use blueprint_sdk::keystore::backends::Backend;
-use blueprint_sdk::runner::BlueprintRunner;
-use blueprint_sdk::runner::config::BlueprintEnvironment;
-use blueprint_sdk::runner::tangle::config::TangleConfig;
-use blueprint_sdk::tangle::consumer::TangleConsumer;
-use blueprint_sdk::tangle::filters::MatchesServiceId;
-use blueprint_sdk::tangle::layers::TangleLayer;
-use blueprint_sdk::tangle::producer::TangleProducer;
-use pico_coprocessor_service_blueprint_lib::{MyContext, SAY_HELLO_JOB_ID, say_hello};
+// pico-coprocessor-service-bin/src/main.rs
+use blueprint_sdk::{
+    Job,
+    Router,                     // Ensure Job and Router are imported
+    alloy::primitives::Address, // Import Address
+    contexts::tangle::TangleClientContext,
+    crypto::{sp_core::SpSr25519, tangle_pair_signer::TanglePairSigner},
+    keystore::backends::Backend,
+    runner::{BlueprintRunner, config::BlueprintEnvironment, tangle::config::TangleConfig},
+    tangle::{
+        consumer::TangleConsumer, filters::MatchesServiceId, layers::TangleLayer,
+        producer::TangleProducer,
+    },
+};
+// Import new types and jobs from lib
+use pico_coprocessor_service_blueprint_lib::{
+    GENERATE_COPROCESSOR_PROOF_JOB_ID,
+    GENERATE_PROOF_JOB_ID,
+    ServiceContext,
+    generate_coprocessor_proof,
+    generate_proof,
+    say_hello, // Jobs
+};
+use std::{path::PathBuf, str::FromStr}; // For PathBuf and FromStr
 use tower::filter::FilterLayer;
 use tracing::error;
 use tracing::level_filters::LevelFilter;
+use url::Url; // For parsing RPC URL
 
 #[tokio::main]
-async fn main() -> Result<(), blueprint_sdk::Error> {
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Use Box<dyn Error> for broader error handling
     setup_log();
+    tracing::info!("Starting Pico Coprocessor Service Blueprint Runner...");
 
-    let env = BlueprintEnvironment::load()?;
+    // --- Load Configuration ---
+    let env = BlueprintEnvironment::load()
+        .map_err(|e| format!("Failed to load blueprint environment: {}", e))?;
+
+    // Tangle Signer Setup
     let sr25519_signer = env.keystore().first_local::<SpSr25519>()?;
     let sr25519_pair = env.keystore().get_secret::<SpSr25519>(&sr25519_signer)?;
-    let st25519_signer = TanglePairSigner::new(sr25519_pair.0);
+    let tangle_signer = TanglePairSigner::new(sr25519_pair.0);
+    tracing::info!("Tangle signer configured.");
 
+    // Tangle Client Setup
     let tangle_client = env.tangle_client().await?;
     let tangle_producer =
         TangleProducer::finalized_blocks(tangle_client.rpc_client.clone()).await?;
-    let tangle_consumer = TangleConsumer::new(tangle_client.rpc_client.clone(), st25519_signer);
-
-    let tangle_config = TangleConfig::default();
-
-    let service_id = env.protocol_settings.tangle()?.service_id.unwrap();
-    let result = BlueprintRunner::builder(tangle_config, env)
-        .router(
-            // A router
-            //
-            // Each "route" is a job ID and the job function. We can also support arbitrary `Service`s from `tower`,
-            // which may make it easier for people to port over existing services to a blueprint.
-            Router::new()
-                // The route defined here has a `TangleLayer`, which adds metadata to the
-                // produced `JobResult`s, making it visible to a `TangleConsumer`.
-                .route(SAY_HELLO_JOB_ID, say_hello.layer(TangleLayer))
-                // Add the `FilterLayer` to filter out job calls that don't match the service ID
-                //
-                // This layer is global to the router, and is applied to every job call.
-                .layer(FilterLayer::new(MatchesServiceId(service_id)))
-                // We can add a context to the router, which will be passed to all job functions
-                // that have the `Context` extractor.
-                //
-                // A context can be used for global state between job calls, such as a database.
-                //
-                // It is important to note that the context is **cloned** for each job call, so
-                // the context must be cheaply cloneable.
-                .with_context(MyContext::new()),
-        )
-        // Add potentially many producers
-        //
-        // A producer is simply a `Stream` that outputs `JobCall`s, which are passed down to the intended
-        // job functions.
+    let tangle_consumer = TangleConsumer::new(tangle_client.rpc_client.clone(), tangle_signer);
+    tracing::info!("Tangle producer and consumer configured.");
+
+    let tangle_config = env.protocol_settings.tangle()?.clone(); // Use loaded config
+    let service_id = tangle_config
+        .service_id
+        .ok_or("Tangle Service ID not configured")?;
+    tracing::info!(%service_id, "Using Tangle Service ID");
+
+    // --- Service Specific Configuration ---
+    // Get these from environment variables or a config file via BlueprintEnvironment extensions
+    // Example using environment variables (add error handling)
+    let eth_rpc_env =
+        std::env::var("ETH_RPC_URL").map_err(|_| "ETH_RPC_URL environment variable not set")?;
+    let eth_rpc_url =
+        Url::parse(&eth_rpc_env).map_err(|e| format!("Invalid ETH_RPC_URL: {}", e))?;
+
+    let registry_addr_env = std::env::var("REGISTRY_CONTRACT_ADDRESS")
+        .map_err(|_| "REGISTRY_CONTRACT_ADDRESS environment variable not set")?;
+    let registry_contract_address = Address::from_str(&registry_addr_env)
+        .map_err(|e| format!("Invalid REGISTRY_CONTRACT_ADDRESS: {}", e))?;
+
+    let temp_dir_base_env =
+        std::env::var("TEMP_DIR_BASE").unwrap_or_else(|_| "/tmp/pico-service".to_string());
+    let temp_dir_base = PathBuf::from(temp_dir_base_env);
+
+    tracing::info!(rpc_url = %eth_rpc_url, registry = %registry_contract_address, temp_dir = ?temp_dir_base, "Service configuration loaded");
+
+    // --- Create Service Context ---
+    let service_context =
+        ServiceContext::new(eth_rpc_url, registry_contract_address, temp_dir_base)
+            .map_err(|e| format!("Failed to create service context: {:?}", e))?;
+    tracing::info!("Service context created.");
+
+    // --- Build Router ---
+    let router = Router::new()
+        // Add routes for each job ID
+        .route(GENERATE_PROOF_JOB_ID, generate_proof.layer(TangleLayer))
+        .route(
+            GENERATE_COPROCESSOR_PROOF_JOB_ID,
+            generate_coprocessor_proof.layer(TangleLayer),
+        ) // Add new route
+        // Global filter layer
+        .layer(FilterLayer::new(MatchesServiceId(service_id)))
+        // Add the shared context
+        .with_context(service_context);
+    tracing::info!("Router configured with {} jobs.", 3); // Update count
+
+    // --- Build and Run Runner ---
+    let runner_result = BlueprintRunner::builder(tangle_config, env)
+        .router(router)
         .producer(tangle_producer)
-        // Add potentially many consumers
-        //
-        // A consumer is simply a `Sink` that consumes `JobResult`s, which are the output of the job functions.
-        // Every result will be passed to every consumer. It is the responsibility of the consumer
-        // to determine whether or not to process a result.
         .consumer(tangle_consumer)
-        // Custom shutdown handlers
-        //
-        // Now users can specify what to do when an error occurs and the runner is shutting down.
-        // That can be cleanup logic, finalizing database transactions, etc.
-        .with_shutdown_handler(async { println!("Shutting down!") })
+        .with_shutdown_handler(async { println!("Shutting down Pico Coprocessor Service!") })
         .run()
         .await;
 
-    if let Err(e) = result {
-        error!("Runner failed! {e:?}");
+    if let Err(e) = runner_result {
+        error!("Blueprint runner failed: {:?}", e);
+        // Convert specific blueprint errors if needed, otherwise return the boxed error
+        return Err(e.into());
     }
 
+    tracing::info!("Blueprint runner finished successfully.");
     Ok(())
 }
 
 pub fn setup_log() {
     use tracing_subscriber::util::SubscriberInitExt;
+    let filter = tracing_subscriber::EnvFilter::builder()
+        .with_default_directive(LevelFilter::INFO.into())
+        .from_env_lossy();
 
-    let _ = tracing_subscriber::fmt::SubscriberBuilder::default()
-        .without_time()
-        .with_span_events(tracing_subscriber::fmt::format::FmtSpan::NONE)
-        .with_env_filter(
-            tracing_subscriber::EnvFilter::builder()
-                .with_default_directive(LevelFilter::INFO.into())
-                .from_env_lossy(),
-        )
-        .finish()
-        .try_init();
+    let _ = tracing_subscriber::fmt() //.SubscriberBuilder::default()
+        // .without_time() // Keep time for debugging
+        .with_span_events(tracing_subscriber::fmt::format::FmtSpan::CLOSE) // Show span duration
+        .with_env_filter(filter)
+        // .finish() // finish called by init
+        .try_init(); // Use try_init to avoid panic if already initialized
+    tracing::info!("Logging initialized.");
 }

pico-coprocessor-service-bin/src/main.rs

@@ -20,12 +20,14 @@ serde = { workspace = true }
 url = { workspace = true }
 hex = { workspace = true }
 futures = { workspace = true }
+coprocessor-sdk = { workspace = true }
 pico-sdk = { workspace = true, features = ["coprocessor"] }
 pico-vm = { workspace = true }
 serde_json = { workspace = true }
 reqwest = { workspace = true, features = ["stream"] }
 tempfile.workspace = true
-rand = "0.8"
+rand = { workspace = true }
+parity-scale-codec = { workspace = true }
 
 [dev-dependencies]
 blueprint-sdk = { workspace = true, features = ["testing", "tangle"] }