feat(): Add docs to generating proofs for zkrust (#1063)

Co-authored-by: Urix <[email protected]>

Author: PatStiles

docs/3_guides/4_generating_proofs.md

@@ -284,3 +284,136 @@ aligned submit \
 ```
 
 For more instructions on how to submit proofs, check the [Submitting proofs guide](../3_guides/0_submitting_proofs.md).
+
+## ZkRust
+
+`zkRust` is a CLI tool maintained by Aligned that aims to simplify the developing applications in Rust using zkVM's such as SP1 or Risc0.
+
+zkRust can be installed directly by downloading the latest release binaries:
+
+```sh
+curl -L https://raw.githubusercontent.com/yetanotherco/zkRust/main/install_zkrust.sh | bash
+```
+
+Then, to get started you can create a workspace for your project in zkRust by running:
+
+```sh
+cargo new <PROGRAM_DIRECTORY>
+```
+
+It is that simple.
+
+## Usage
+
+To use zkRust, users specify a `fn main()` whose execution is proven within the zkVM. This function must be defined in a `main.rs` file in a directory with the following structure:
+
+```
+.
+└── <PROGRAM_DIRECTORY>
+    ├── Cargo.toml
+    └── src
+        └── main.rs
+```
+
+For using more complex programs you can import a separate lib/ crate into the `PROGRAM_DIRECTORY`
+
+```
+.
+└── <PROGRAM_DIRECTORY>
+    ├── Cargo.toml
+    ├── lib/
+    └── src
+        └── lib
+```
+
+### Inputs and Outputs
+
+The user may also define a `input()` and `output()` functions in addition to `main()`, that define code that runs outside of the zkVM, before and after the VM executes
+
+- The `input()` function executes before the zkVM code is executed and allows the user to define inputs passed to the vm such as a deserialized Tx or data fetched from an external source at runtime.
+- Within the `main()` (guest) function the user may write information from the computation performed in the zkVM to an output buffer to be used after proof generation.
+- The `output()` defines code that allows the user to read the information written to that buffer of the and perform post-processing of that data.
+
+The user may specify inputs into the VM (guest) code using `zk_rust_io::write()` as long on the type of rust object they are writing implements `Serializable`. 
+
+Within the `main()` function (guest) the user may read in the inputs by specifying `zk_rust_io::read()` and output data computed during the execution phase of the code within the VM (guest) program by specifying `zk_rust_io::commit()`.
+
+To read the output of the output of the VM (guest) program you declare `zk_rust_io::out()`. The `zk_rust_io` crate defines function headers that are not inlined and are purely used as compile time symbols to ensure a user can compile their rust code before running it within one of the zkVMs available in zkRust.
+
+To use the I/O imports import the `zk_rust_io` crate by adding the following to the `Cargo.toml` in your project directory.
+
+```sh
+zk_rust_io = { git = "https://github.com/yetanotherco/zkRust.git", version = "v0.1.0" }
+```
+
+## Example
+
+### input.rs
+
+```rust
+use zk_rust_io;
+
+pub fn input() {
+    let pattern = "a+".to_string();
+    let target_string = "an era of truth, not trust".to_string();
+
+    // Write in a simple regex pattern.
+    zk_rust_io::write(&pattern);
+    zk_rust_io::write(&target_string);
+}
+````
+
+### main.rs
+
+```rust
+use regex::Regex;
+use zk_rust_io;
+
+pub fn main() {
+    // Read two inputs from the prover: a regex pattern and a target string.
+    let pattern: String = zk_rust_io::read();
+    let target_string: String = zk_rust_io::read();
+
+    // Try to compile the regex pattern. If it fails, write `false` as output and return.
+    let regex = match Regex::new(&pattern) {
+        Ok(regex) => regex,
+        Err(_) => {
+            panic!("Invalid regex pattern");
+        }
+    };
+
+    // Perform the regex search on the target string.
+    let result = regex.is_match(&target_string);
+
+    // Write the result (true or false) to the output.
+    zk_rust_io::commit(&result);
+}
+```
+
+### output.rs
+
+```rust
+use zk_rust_io;
+
+pub fn output() {
+    // Read the output.
+    let res: bool = zk_rust_io::out();
+    println!("res: {}", res);
+}
+```
+
+To generate a proof of the execution of your code run the following:
+
+- **Sp1**:
+
+```sh
+  cargo run --release -- prove-sp1 <PROGRAM_DIRECTORY_PATH> .
+```
+
+- **Risc0**:
+  ```sh
+  cargo run --release -- prove-risc0  <PROGRAM_DIRECTORY_PATH> .
+  ```
+  Make sure to have [Risc0](https://dev.risczero.com/api/zkvm/quickstart#1-install-the-risc-zero-toolchain) installed with version `v1.0.1`
+
+For additional information on using zkRust and using it to submit proofs to Aligned see the [zkRust](https://github.com/yetanotherco/zkRust) Github Repository.