feat: README and serialize proof data

Author: drewstone

Cargo.lock

@@ -35,3 +35,4 @@ reqwest = "0.12.15"
 tempfile = "3.13"
 
 pico-sdk = { git = "https://github.com/brevis-network/pico", features = ["coprocessor"] }
+pico-vm = { git = "https://github.com/brevis-network/pico" }

Cargo.toml

@@ -1,84 +1,65 @@
-# <h1 align="center">Hello World Tangle Blueprint 🌐</h1>
-
-## 📚 Overview
-
-This Tangle Blueprint provides a simple Hello World job.
-Blueprints are specifications for <abbr title="Actively Validated Services">AVS</abbr>s on the Tangle Network. An AVS is
-an off-chain service that runs arbitrary computations for a user-specified period of time.
-
-Blueprints provide a useful abstraction, allowing developers to create reusable service infrastructures as if they were
-smart contracts. This enables developers to monetize their work and align long-term incentives with the success of their
-creations, benefiting proportionally to their Blueprint's usage.
-
-For more details, please refer to the [project documentation](https://docs.tangle.tools/developers/blueprints/introduction).
-
-## 🚀 Features
-
-- Custom greeting messages
-- Default "Hello World!" messages
-- ...
-
-## 📋 Prerequisites
-
-Before you can run this project, you will need to have the following software installed on your machine:
-
-- [Rust](https://www.rust-lang.org/tools/install)
-- [Forge](https://getfoundry.sh)
-
-You will also need to install [cargo-tangle](https://crates.io/crates/cargo-tangle), our CLI tool for creating and
-deploying Tangle Blueprints:
-
-To install the Tangle CLI, run the following command:
-
-> Supported on Linux, MacOS, and Windows (WSL2)
-
-```bash
-cargo install cargo-tangle --git https://github.com/tangle-network/blueprint
-```
-
-## ⭐ Getting Started
-
-Once `cargo-tangle` is installed, you can create a new project with the following command:
-
-```sh
-cargo tangle blueprint create --name <project-name>
-```
-
-and follow the instructions to create a new project.
-
-## 🛠️ Development
-
-Once you have created a new project, you can run the following command to start the project:
-
-```sh
-cargo build
-```
-
-to build the project, and
-
-```sh
-cargo tangle blueprint deploy
-```
-
-to deploy the blueprint to the Tangle network.
-
-## 📜 License
-
-Licensed under either of
-
-* Apache License, Version 2.0
-  ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
-* MIT license
-  ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
-at your option.
-
-## 📬 Feedback and Contributions
-
-We welcome feedback and contributions to improve this blueprint.
-Please open an issue or submit a pull request on our GitHub repository.
-Please let us know if you fork this blueprint and extend it too!
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
-dual licensed as above, without any additional terms or conditions.
+# Pico Verifiable Computation Service - Tangle Blueprint
+
+This project implements a reusable Tangle Blueprint that provides Verifiable Computation as a Service, powered by the [Pico zkVM](https://github.com/brevis-network/pico).
+
+## Overview
+
+The service allows developers to submit arbitrary RISC-V programs (compiled for the Pico zkVM) along with their inputs and receive Zero-Knowledge Proofs (ZKPs) of the execution trace. This enables trustless verification of computations performed off-chain.
+
+Key Features:
+
+- **Generic Computation:** Supports proving arbitrary RISC-V programs compatible with Pico.
+- **On-Chain Program Registry:** Uses an EVM smart contract (`ProgramRegistry.sol`) to store program metadata (SHA256 hash and download location - e.g., IPFS, HTTPS), enabling program reuse and discovery.
+- **Flexible Proving:** Supports different proving modes via the Pico SDK:
+  - `Fast`: RISC-V execution proof only (for testing/debugging, **not secure**).
+  - `Full`: Complete recursive STARK proof generation.
+  - `FullWithEvm`: Generates a Groth16 proof verifiable on EVM chains using generated Solidity verifiers.
+- **Tangle Blueprint Integration:** Built using the [Tangle Blueprint SDK](https://github.com/TangleLabs/blueprint-sdk), allowing the service to run as a decentralized backend service within the Tangle network ecosystem. Jobs can be triggered via Tangle messages.
+- **Decentralized Storage:** Program binaries are intended to be stored off-chain (e.g., IPFS, Arweave, HTTPS), referenced by the on-chain registry.
+
+## Architecture
+
+1.  **Tangle Blueprint Runner (`bin/`):** The main service executable that runs the Blueprint. It listens for incoming job requests (e.g., from the Tangle network).
+2.  **Core Logic Library (`lib/`):** Contains the Rust implementation of the service:
+    - **Jobs:** Defines the available service functions (`say_hello` example, `generate_proof` core job).
+    - **Context:** Manages shared resources like HTTP clients and EVM provider configurations.
+    - **EVM Interaction:** Handles communication with the `ProgramRegistry` smart contract using `alloy`.
+    - **Program Handling:** Fetches program ELF binaries from specified locations (URL, local path) and verifies their integrity using SHA256 hashes.
+    - **Pico Integration:** Uses the `pico-sdk` to load ELFs, provide inputs, and execute the different proving flows (`prove_fast`, `prove`, `prove_evm`).
+    - **Types & Errors:** Defines data structures for requests, results, and custom errors.
+3.  **Program Registry Contract (`contracts/`):** A Solidity smart contract (`ProgramRegistry.sol`) deployed on an EVM-compatible chain. It stores `programHash -> {location, owner}` mappings.
+4.  **Program Storage (External):** A separate system (e.g., IPFS, web server) hosts the actual program ELF binaries.
+
+## Workflow
+
+1.  **Program Registration (Developer):**
+    - Compile RISC-V code to a Pico zkVM ELF binary.
+    - Calculate the SHA256 hash of the ELF file.
+    - Upload the ELF file to a persistent storage location (e.g., IPFS) and get its URI/URL.
+    - Call the `registerProgram` function on the `ProgramRegistry` smart contract with the program hash and location URI.
+2.  **Proof Request (User/Application):**
+    - Construct a `ProofRequest` containing:
+      - `program_hash`: The hash of the registered program to execute.
+      - `inputs`: Hex-encoded input data for the program.
+      - `proving_type`: `Fast`, `Full`, or `FullWithEvm`.
+      - Optional overrides for program location or EVM configuration.
+    - Submit the `ProofRequest` as a job call to the running Tangle Blueprint service (e.g., via a Tangle message targeting the service ID and `GENERATE_PROOF_JOB_ID`).
+3.  **Proof Generation (Service):**
+    - The Blueprint Runner receives the job call.
+    - The `generate_proof` job function executes:
+      - Retrieves the program location from the `ProgramRegistry` contract (unless overridden).
+      - Downloads the ELF binary from the location.
+      - Verifies the downloaded ELF hash against the requested `program_hash`.
+      - Initializes the Pico `DefaultProverClient` (KoalaBear).
+      - Executes the requested proving type (`prove_fast`, `prove`, or `prove_evm`).
+      - For `prove_evm`, runs external Docker commands via the SDK to generate the final Groth16 proof and EVM verifier inputs.
+      - Parses and collects the proof data and public values.
+    - Returns the `ProofResult` (containing proof data, public values, etc.) back through the Blueprint SDK (e.g., as a response Tangle message).
+
+## Setup & Usage
+
+_(TODO: Add instructions on how to build, configure (environment variables for RPC URL, registry address, etc.), deploy the contract, and run the blueprint service.)_
+
+## Development
+
+_(TODO: Add details on building the code, running tests, contributing guidelines.)_

README.md

@@ -21,9 +21,11 @@ url = { workspace = true }
 hex = { workspace = true }
 futures = { 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"
 
 [dev-dependencies]
 blueprint-sdk = { workspace = true, features = ["testing", "tangle"] }

pico-coprocessor-service-lib/Cargo.toml

@@ -17,7 +17,7 @@ use tempfile::TempDir; // To manage temporary directories
 
 // Wrapper struct to hold temporary resources and ensure cleanup
 struct ProofResources {
-    _elf_temp_dir: TempDir, // Holds the temp dir containing the ELF, cleans up on drop
+    elf_temp_dir: TempDir, // Holds the temp dir containing the ELF, cleans up on drop
     elf_path: PathBuf,
     output_temp_dir: TempDir, // Holds the temp dir for proof outputs, cleans up on drop
     output_path: PathBuf,
@@ -85,7 +85,7 @@ pub async fn generate_proof(
     // Wrap resources for automatic cleanup
     let _resources = ProofResources {
         // Variable binding ensures it lives long enough
-        _elf_temp_dir: elf_temp_dir,      // Transfer ownership
+        elf_temp_dir,                     // Transfer ownership
         elf_path: elf_path.clone(),       // Clone path for use
         output_temp_dir,                  // Transfer ownership
         output_path: output_path.clone(), // Clone path for use

pico-coprocessor-service-lib/src/jobs/generate_proof.rs

@@ -9,6 +9,9 @@ mod pico;
 mod program;
 mod types;
 
+#[cfg(test)]
+mod tests;
+
 // Publicly export key types, errors, context, and job functions
 pub use context::ServiceContext;
 pub use errors::ProofServiceError;