chore: update blueprint-sdk docs (#100)

* chore: update cli docs

* chore: update code links wip

* chore: fmt

* chore: update code links

* chore: prettier

---------

Co-authored-by: Drew Stone <drewstone329@gmail.com>

Author: Tjemmmic

pages/developers/blueprint-contexts/eigenlayer-context.mdx

@@ -35,6 +35,8 @@ The `EigenlayerContext` trait provides access to core Eigenlayer services and fu
 <GithubFileReaderDisplay
   url="https://github.com/tangle-network/gadget/blob/main/crates/contexts/src/eigenlayer.rs"
   title="EigenlayerContext Trait Definition"
+  fromLine={5}
+  toLine={9}
 />
 
 ## Using the Context
@@ -45,8 +47,8 @@ First, define your context struct that implements the `EigenlayerContext` trait:
 
 <GithubFileReaderDisplay
   url="https://github.com/tangle-network/gadget/blob/main/blueprints/incredible-squaring-eigenlayer/src/contexts/aggregator.rs"
-  fromLine={43}
-  toLine={56}
+  fromLine={39}
+  toLine={52}
   title="Aggregator Context Definition"
 />
 
@@ -68,6 +70,6 @@ Finally, instantiate your context in your main runner:
 <GithubFileReaderDisplay
   url="https://github.com/tangle-network/gadget/blob/main/blueprints/incredible-squaring-eigenlayer/src/main.rs"
   fromLine={27}
-  toLine={45}
+  toLine={53}
   title="Instantiating the Context"
 />

pages/developers/blueprint-contexts/keystore-context.mdx

@@ -21,7 +21,7 @@ The `KeystoreContext` trait provides access to a `Keystore` that implements the
 <GithubFileReaderDisplay
   url="https://github.com/tangle-network/gadget/blob/main/crates/contexts/src/keystore.rs"
   fromLine={4}
-  toLine={9}
+  toLine={8}
   title="KeystoreContext Trait Definition"
 />
 

pages/developers/blueprint-event-listeners/_meta.json

@@ -2,6 +2,6 @@
   "introduction": "Introduction to Event Listeners",
   "tangle-job-calls": "Tangle Job Call Listener",
   "evm-contracts": "EVM Contract Listeners",
-  "periodic-listeners": "Periodic Listeners",
+  "cron-job-listeners": "Cron Job Listeners",
   "custom-listeners": "Custom Listeners"
 }

pages/developers/blueprint-event-listeners/cron-job-listeners.mdx

@@ -0,0 +1,70 @@
+---
+title: Cron Job Listeners
+---
+
+import GithubFileReaderDisplay from "/components/GithubFileReaderDisplay";
+
+# Cron Job Listeners
+
+Cron Job listeners are event listeners that trigger at specific time intervals. They are useful for tasks that need to be executed regularly, such as quality of service metrics/uptime checkers, data updates, and subscription style services.
+
+## Overview
+
+Cron Job Listeners enable your blueprint to:
+
+1. Schedule tasks to run at specific intervals
+2. Execute background jobs periodically
+3. Perform regular checks or updates without manual intervention
+
+Cron Job Listeners are particularly useful for tasks such as:
+
+- Regular data synchronization
+- Scheduled maintenance operations
+- Periodic health checks
+- Automated reporting at set intervals
+
+# CronJob
+
+Some programs may only be interested in checking for events at regular intervals. In this case, the `CronJob` can be used to simplify the process.
+
+A `CronJob` executes a job periodically, using a context that provides interval information in cron notation (e.g., "1/2 \* \* \* \* \*"):
+
+<GithubFileReaderDisplay 
+  url="https://github.com/tangle-network/gadget/blob/main/crates/event-listeners/cronjob/src/lib.rs"
+  fromLine={13}
+  toLine={27}
+  title="CronJob Event Listener Definition"
+/>
+
+--TODO: Update the section below once the Example Blueprints are updated in Gadget
+
+We can make a `PeriodicEventListener` that ticks every 6000ms to check the status of a web server using [reqwest](https://crates.io/crates/reqwest).
+
+Start by defining our inner event listener (`T` = `WebPoller`, in this case), and implement the `EventListener` trait.
+
+<GithubFileReaderDisplay
+  url="https://github.com/tangle-network/gadget/blob/main/blueprints/examples/src/periodic_web_poller.rs"
+  fromLine={79}
+  toLine={116}
+  title="Example WebPoller `EventListener` Implementation"
+/>
+
+## Using it in a Blueprint
+
+Implement the pre-processor and post-processors, as needed for the event listener:
+
+<GithubFileReaderDisplay
+  url="https://github.com/tangle-network/gadget/blob/main/blueprints/examples/src/periodic_web_poller.rs"
+  fromLine={68}
+  toLine={77}
+  title="Example WebPoller Post-Processor"
+/>
+
+Integrate the event listener inside the `job`:
+
+<GithubFileReaderDisplay
+  url="https://github.com/tangle-network/gadget/blob/main/blueprints/examples/src/periodic_web_poller.rs"
+  fromLine={36}
+  toLine={65}
+  title="Example Job with Periodic Web Poller Listener"
+/>

pages/developers/blueprint-event-listeners/custom-listeners.mdx

@@ -5,7 +5,7 @@ title: Custom Event Listeners
 To create an event listener, begin by defining a struct or enum which will listen to events:
 
 ```rust
-use gadget_sdk::event_listener::EventListener;
+use blueprint_sdk::event_listeners::core::EventListener;
 use async_trait::async_trait;
 
 /// Define a simple event listener that ticks every MS milliseconds.
@@ -65,7 +65,6 @@ Finally, register the event listener inside the `job` macro using `event_listene
 #[job(
     id = 0,
     params(x),
-    result(_),
     event_listener(listener = Ticker::<6000>), // <-- Register the event listener here
 )]
 pub fn hello_event_listener(

pages/developers/blueprint-event-listeners/introduction.mdx

@@ -12,8 +12,8 @@ In general, when defining your job, you must register an event listeners and pro
 
 <GithubFileReaderDisplay
   url="https://github.com/tangle-network/blueprint-template/blob/main/src/lib.rs"
-  fromLine={11}
-  toLine={32}
+  fromLine={12}
+  toLine={36}
   title="Example Blueprint Job with Tangle JobCalled Event Listener"
 />
 
@@ -25,7 +25,7 @@ Event listeners in the SDK are designed to be flexible and allow developers to c
 
 <GithubFileReaderDisplay
   url="https://github.com/tangle-network/gadget/blob/main/crates/event-listeners/core/src/lib.rs"
-  fromLine={15}
+  fromLine={14}
   toLine={25}
   title="Event Listener Trait Definition"
 />
@@ -36,8 +36,8 @@ When a blueprint instance runs, the event listeners are constructed and executed
 
 <GithubFileReaderDisplay
   url="https://github.com/tangle-network/gadget/blob/main/blueprints/incredible-squaring/src/main.rs"
-  fromLine={8}
-  toLine={26}
+  fromLine={7}
+  toLine={30}
   title="Example Blueprint Runner execution"
 />
 

pages/developers/blueprint-event-listeners/tangle-job-calls.mdx

@@ -34,8 +34,8 @@ will automatically work with the Tangle network.
 
 <GithubFileReaderDisplay
   url="https://github.com/tangle-network/blueprint-template/blob/main/src/lib.rs"
-  fromLine={11}
-  toLine={32}
+  fromLine={20}
+  toLine={36}
   title="Example Blueprint Job with Tangle JobCalled Event Listener"
 />
 
@@ -53,7 +53,7 @@ The pre-processor for Tangle job calls handles the following tasks:
 
 <GithubFileReaderDisplay
   url="https://github.com/tangle-network/gadget/blob/main/crates/event-listeners/tangle/src/services.rs"
-  fromLine={7}
+  fromLine={8}
   toLine={56}
   title="Tangle Job Call Pre-processor Implementation"
 />

pages/developers/blueprint-macros/context.mdx

@@ -118,9 +118,9 @@ These extensions can be easily added to your Context using derive macros, as sho
 Here's an example of how to use the built-in `KeystoreContext` extension:
 
 ```rust
-use std::convert::Infallible;
-use gadget_sdk::ctx::KeystoreContext;
-use gadget_sdk::config::StdGadgetConfiguration;
+use blueprint_sdk::std::convert::Infallible;
+use blueprint_sdk::contexts::keystore::KeystoreContext;
+use blueprint_sdk::config::StdGadgetConfiguration;
 
 #[derive(Debug, Clone, KeystoreContext)] // Derive the KeystoreContext extension
 struct Context {
@@ -129,7 +129,7 @@ struct Context {
     sdk_config: StdGadgetConfiguration,
 }
 
-#[job(id = 2, params(x), result(_))]
+#[job(id = 2, params(x))]
 pub fn x_squared(ctx: &Context, x: u64) -> Result<u64, Infallible> {
     let keystore = ctx.keystore(); // Access the keystore using the extension method
     // Use the keystore here ...
@@ -177,7 +177,7 @@ impl HttpClientContext for Context {
 }
 
 // Example job using the custom extension
-#[job(id = 3, params(url), result(_))]
+#[job(id = 3, params(url))]
 pub async fn fetch_url(ctx: &Context, url: String) -> Result<String, reqwest::Error> {
     let client = ctx.http_client();
     let response = client.get(&url).send().await?;

pages/developers/blueprint-macros/event-listeners.mdx

@@ -42,7 +42,7 @@ import TableOfContentCards from "../../../components/TableOfContentCards";
     },
     {
       title: "Periodic Listeners",
-      href: "/developers/blueprint-event-listeners/periodic-listeners",
+      href: "/developers/blueprint-event-listeners/cron-job-listeners",
       subItems: [
         {
           title: "Time-based Operations",

pages/developers/blueprint-macros/jobs.mdx

@@ -20,8 +20,8 @@ The `#[job]` macro is used to define individual tasks or jobs within a blueprint
 
 <GithubFileReaderDisplay 
   url="https://github.com/tangle-network/blueprint-template/blob/main/src/lib.rs"
-  fromLine={16}
-  toLine={32}
+  fromLine={20}
+  toLine={36}
   title="Example Job Macro Usage"
 />
 
@@ -69,8 +69,8 @@ The basic Incredible Squaring blueprint includes a `simple_squaring` job that sq
 
 <GithubFileReaderDisplay 
   url="https://github.com/tangle-network/gadget/blob/main/blueprints/incredible-squaring/src/lib.rs"
-  fromLine={9}
-  toLine={21}
+  fromLine={19}
+  toLine={31}
   title="Example Simple Squaring Job"
 />
 
@@ -82,8 +82,8 @@ The Eigenlayer Incredible Squaring blueprint includes a `compute_x_square` job t
 
 <GithubFileReaderDisplay 
   url="https://github.com/tangle-network/gadget/blob/main/blueprints/incredible-squaring-eigenlayer/src/jobs/compute_x_square.rs"
-  fromLine={18}
-  toLine={77}
+  fromLine={22}
+  toLine={86}
   title="Example Eigenlayer Squaring Job"
 />
 
@@ -105,7 +105,7 @@ This example demonstrates how to use the FROST keygen job to generate a new keyp
 <GithubFileReaderDisplay 
   url="https://github.com/tangle-network/frost-blueprint/blob/main/src/keygen.rs"
   fromLine={59}
-  toLine={127}
+  toLine={128}
   title="Example FROST Keygen Job"
 />
 
@@ -115,7 +115,7 @@ This example demonstrates how to use the FROST signing job to sign a message usi
 
 <GithubFileReaderDisplay 
   url="https://github.com/tangle-network/frost-blueprint/blob/main/src/sign.rs"
-  fromLine={70}
-  toLine={158}
+  fromLine={69}
+  toLine={164}
   title="Example FROST Signing Job"
 />

pages/developers/blueprint-macros/reports.mdx

@@ -78,7 +78,6 @@ use my_special_web_polling_context::Context;
 #[report(
     id = 1,
     params(value),
-    result(_),
     event_listener(
         listener = PeriodicEventListener<2000, WebPoller, serde_json::Value, reqwest::Client>
     ),

pages/developers/blueprints/introduction.mdx

@@ -1,6 +1,4 @@
-import { Callout } from 'nextra/components'
 import CardGrid from "../../../components/CardGrid.tsx"
-import ExpandableImage from "../../../components/ExpandableImage.tsx"
 
 # Blueprints
 
@@ -26,13 +24,13 @@ import ExpandableImage from "../../../components/ExpandableImage.tsx"
   ]}
 />
 
-**Blueprints** are specifications for Actively Validated Services (AVS) or **Instances** on the Tangle Network. Developers build blueprints using our [Gadget SDK](https://github.com/tangle-network/gadget) and deploy them to the Tangle Network. Once deployed, users can create Instances of the Blueprint, which are run by Tangle Operators. The Tangle Network incentivizes operators to run these instances by rewarding them with TNT tokens and fees from instancing and instance exeuction. Developers incentivize operators to run instances by specifying additional rewards for operators in the Blueprint.
+**Blueprints** are specifications for Actively Validated Services (AVS) or **Instances** on the Tangle Network. Developers build blueprints using our [Gadget SDK](https://github.com/tangle-network/gadget) and deploy them to the Tangle Network. Once deployed, users can create Instances of the Blueprint, which are run by Tangle Operators. The Tangle Network incentivizes operators to run these instances by rewarding them with TNT tokens and fees from instancing and instance execution. Developers incentivize operators to run instances by specifying additional rewards for operators in the Blueprint.
 
-An Actively Validated Service or Blueprint Instance is a computational service that runs a specified period of time, potentially user-specified or on-demand or forever. Instances allow Blueprints to be reused multiple times, so that useful services can be leveraged by many customers. A key benefit of instancing Blueprints is that each instance can have different operators and diffierent restaked assets securing them.
+An Actively Validated Service or Blueprint Instance is a computational service that runs a specified period of time, potentially user-specified or on-demand or forever. Instances allow Blueprints to be reused multiple times, so that useful services can be leveraged by many customers. A key benefit of instancing Blueprints is that each instance can have different operators and different restaked assets securing them.
 
 A Tangle Blueprint is defined by:
 
-- An program binary.
+- A program binary.
 - A set of smart contracts that provide programmability over the service's output verification and handling of malicious failures
 
 Tangle Blueprints specify their target environment for program execution. The Blueprint's binary can run natively on the operator's machine, in a virtual machine, or in a containerized environment. We are constantly working to provide the right environments for developers to build Blueprints so that operators are satisfied executing Blueprint Instances. Our Gadget SDK supports building AVS and Blueprint Instances directly on Eigenlayer without the same instancing as exists on Tangle, allowing developers nonetheless to leverage the features of our SDK to build and test their services on Eigenlayer. Future integrations with other restaking infrastructures are planned.
@@ -46,10 +44,10 @@ Developers interact with Tangle Blueprints by deploying them to the blockchain.
 The Blueprint includes one main smart contract responsible with all aspects of customizing a Blueprint's behavior and features. Developers have the flexibility to extend this contract, create child contracts, and anything that adheres to the function signatures expected by the runtime when executing logic. The Blueprint smart contract handles:
 
 1. **Registration**: Specifies how Operators register for the Blueprint, allowing the developer to add additional fees, access control, KYC, and any other EVM-deployable functionality to the registration process.
-2. **Request**: Defines how customer of Blueprints initiate Service Instances, providing the same customizability as the EVM for the initialization process of Service Instances.
+2. **Request**: Defines how customer of Blueprints initiates Service Instances, providing the same customizability as the EVM for the initialization process of Service Instances.
 3. **On Job Hooks**: Allows developers to specify custom logic to be executed when a job is created.
 4. **On Job Result Hooks**: Allows developers to specify custom logic to be executed when a job is completed, such as verifying a job's output.
-5. **Custom slashing conditions**: Allows developers to specify custom slashing conditions for Operators, such as failing to provide a service or providing a malicious service. These would be callable by anyone or priveledged callers but is entirely up to the developer to design.
+5. **Custom slashing conditions**: Allows developers to specify custom slashing conditions for Operators, such as failing to provide a service or providing a malicious service. These would be callable by anyone or privileged callers but is entirely up to the developer to design.
 
 Blueprint upgrades are handled differently than runtime upgrades and should eventually be supported through an additional Blueprint smart contract for governance. Upgrades should not overwrite previous versions to protect against malicious updates to active and future services. Instead, upgrades allow for a form of Operator lock-in, enabling developers to quickly benefit from the success of existing services and pass liquidity, as users can request "new versions" of the Blueprint while accessing the already restaked capital from the success of previous versions.
 

pages/developers/blueprints/use-cases.mdx

@@ -1,5 +1,3 @@
-import ExpandableImage from "../../../components/ExpandableImage";
-import TableOfContentCards from "../../../components/TableOfContentCards";
 import NonuniformTableOfContentCards from "../../../components/NonuniformTableOfContentCards";
 import GithubRepoCard, { GithubRepoList } from "../../../components/GithubRepoCard";
 
@@ -114,7 +112,7 @@ Signatures are pervasive in the design of blockchain bridges, oracles, and custo
     displayStyle="row"
 />
 
-The FROST Blueprint demonstrates how to implement threshold signatures using the FROST protocol on Tangle Network. [FROST](https://eprint.iacr.org/2020/852.pdf) is a protocol for generating threshold Shnorr signatures. This example showcases:
+The FROST Blueprint demonstrates how to implement threshold signatures using the FROST protocol on Tangle Network. [FROST](https://eprint.iacr.org/2020/852.pdf) is a protocol for generating threshold Schnorr signatures. This example showcases:
 
 - Distributed key generation between operators
 - Threshold signature creation

pages/developers/cli/installation.mdx

@@ -11,7 +11,7 @@ There are multiple sources to install the CLI from:
 > The script supports Linux, MacOS, and Windows (WSL2)
 
 ```shell
-$ curl --proto '=https' --tlsv1.2 -LsSf https://github.com/tangle-network/gadget/releases/download/cargo-tangle/v0.1.1-beta.7/cargo-tangle-installer.sh | sh
+$ curl --proto '=https' --tlsv1.2 -LsSf https://github.com/tangle-network/gadget/releases/download/cargo-tangle-v0.3.3/cargo-tangle-installer.sh | sh
 ```
 
 2. From [crates.io](https://crates.io) (stable)

pages/developers/cli/quickstart.mdx

@@ -11,15 +11,16 @@ title: Quickstart
 
 ## Creating a New Project
 
-1. Open your terminal and run:
+1. For an in-depth guide to commands, see the [CLI Reference](./reference.mdx). To get started
+   right away with creating a Tangle Blueprint, open your terminal and run:
 
 ```shell
 $ cargo tangle blueprint create --name <blueprint-name>
 ```
 
-2. Follow the prompts to set up your project.
+2. Follow the prompts to set up your project. The following image shows the prompt flow with example input and defaults selected.
 
-{/* TODO: Add a GIF */}
+![CLI Blueprint Creation](/images/cli-blueprint-create.png)
 
 ### Project Structure
 

pages/developers/cli/reference.mdx

@@ -30,6 +30,7 @@ Creates a new blueprint
   - `--name` (**required**): The name of the blueprint
   - `--repo`: The repo to pull the template from, by default this uses the hello world [blueprint template](https://github.com/tangle-network/blueprint-template)
   - `--path`: The path to copy a template from, no default value
+  - `--eigenlayer`: Uses an Eigenlayer template for creating an AVS, defaulting to the BLS version as seen below
 
 Usage:
 
@@ -45,6 +46,17 @@ Create a blueprint using another template from git
 $ cargo tangle blueprint create --name <name> --repo <git-repo-url>
 ```
 
+Create an EigenLayer AVS:
+
+```shell
+$ cargo tangle blueprint create --name <project-name> --eigenlayer <type>
+```
+
+where the following are the possible types (defaulting to bls if the type is omitted):
+
+- `bls`: Generates from our [BLS template](https://github.com/tangle-network/eigenlayer-bls-template), with contracts for BLS interaction
+- `ecdsa`: Generates from our [ECDSA template](https://github.com/tangle-network/eigenlayer-ecdsa-template), with ECDSA-oriented contracts
+
 #### Deploy
 
 Deploy a blueprint to Tangle