chore: bump version to 0.4.0 and add Monad Mainnet deployment with streamlined documentation

- Bump workspace version from 0.3.1 to 0.4.0 in Cargo.toml
- Add Monad Mainnet deployment (chain 143, contract 0xE8c4FFb4A6F7B8040a7AE39F6651290E06A40725) to networks.rs
- Refactor Network enum to only include live deployments (remove placeholder networks)
- Update README with deployment table, condensed Quick Start showing full lifecycle, and removed Design Principles section
- Replace basic.rs example

Author: gitctrlx

.gitignore

@@ -21,4 +21,4 @@ target
 #.idea/
 
 /contracts
-/3rdparty
+# /3rdparty

Cargo.lock

@@ -4,14 +4,14 @@ default-members = ["erc8183"]
 resolver = "3"
 
 [workspace.package]
-version = "0.3.1"
+version = "0.4.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/qntx/erc8183"
 description = "The Commerce Layer for AI Agents."
 
 [workspace.dependencies]
-erc8183 = { version = "0.3", path = "erc8183" }
+erc8183 = { version = "0.4", path = "erc8183" }
 
 alloy = { version = "1", features = ["full"] }
 serde = { version = "1", features = ["derive"] }

Cargo.toml

@@ -26,7 +26,7 @@
 Type-safe Rust SDK for the [ERC-8183](https://eips.ethereum.org/EIPS/eip-8183) Agentic Commerce Protocol.
 On-chain job escrow with evaluator attestation for AI agent commerce.
 
-[Quick Start](#quick-start) | [Protocol Reference](#erc-8183-protocol) | [API docs][doc-url]
+[Quick Start](#quick-start) | [Protocol](#erc-8183-protocol) | [API docs][doc-url]
 
 </div>
 
@@ -37,37 +37,55 @@ ERC-8183 enables **trustless commerce between AI agents**: a client locks funds
 This SDK provides type-safe Rust bindings for the protocol, built on [alloy](https://github.com/alloy-rs/alloy).
 
 > [!NOTE]
-> ERC-8183 is currently a **Draft** EIP. See [SECURITY.md](SECURITY.md) before production use.
->
-> Reference implementation: **[qntx/market-contract](https://github.com/qntx/market-contract)**
+> Reference implementation: **[qntx/market-contract](https://github.com/qntx/market-contract)**, See [SECURITY.md](SECURITY.md) before production use.
 
-## Quick Start
-
-```rust
-use erc8183::{Erc8183, types::CreateJobParams};
+## Deployments
 
-// Connect to contract
-let job = Erc8183::new(provider).with_address(contract_addr).job()?;
+| Network | Chain ID | Contract | Payment Token | Explorer |
+| --- | --- | --- | --- | --- |
+| **Monad Mainnet** | 143 | [`0xE8c4FFb4A6F7B8040a7AE39F6651290E06A40725`](https://monad.socialscan.io/address/0xE8c4FFb4A6F7B8040a7AE39F6651290E06A40725) | USDC | [Socialscan](https://monad.socialscan.io/address/0xE8c4FFb4A6F7B8040a7AE39F6651290E06A40725) |
 
-// Create → Fund → Submit → Complete
-let id = job.create_job(&CreateJobParams::new(provider, evaluator, expires, "task")).await?;
-job.fund(id, budget, None).await?;
-job.submit(id, deliverable, None).await?;
-job.complete(id, reason, None).await?;
+## Quick Start
 
-// Query
-let data = job.get_job(id).await?;
+```rust
+use erc8183::{Erc8183, Network, types::CreateJobParams};
+use alloy::primitives::{Address, U256};
+
+// Connect to Monad Mainnet
+let sdk = Erc8183::new(provider).with_network(Network::MonadMainnet);
+let job = sdk.job()?;
+
+// Create a job (caller becomes client)
+let params = CreateJobParams::new(
+    provider_addr,                    // provider
+    evaluator_addr,                   // evaluator
+    U256::from(1_800_000_000u64),     // expiredAt (Unix timestamp)
+    "Analyze market data",            // description
+);
+let job_id = job.create_job(&params).await?;
+
+// Fund the escrow (requires ERC-20 approval first)
+job.set_budget(job_id, U256::from(1_000_000), None).await?;
+job.fund(job_id, U256::from(1_000_000), None).await?;
+
+// Provider submits work
+job.submit(job_id, deliverable_hash, None).await?;
+
+// Evaluator completes — releases payment to provider
+job.complete(job_id, FixedBytes::ZERO, None).await?;
+
+// Query job state
+let data = job.get_job(job_id).await?;
+println!("Status: {} (terminal: {})", data.status, data.status.is_terminal());
 ```
 
-The full API mirrors the on-chain functions: `set_provider`, `set_budget`, `reject`, `claim_refund`, plus view/admin methods like `total_jobs`, `payment_token`, `set_platform_fee`, etc.
-
 ### Three-Layer Bindings
 
 | Layer | Binding | Scope |
 | --- | --- | --- |
-| **Standard** | [`IERC8183`](erc8183/src/contracts.rs) | Spec-mandated lifecycle functions and events. Works with **any** ERC-8183 contract. |
-| **Implementation** | [`AgenticCommerce`](erc8183/src/contracts.rs) | Full QNTX ABI: `Job` struct, custom errors, admin functions, view getters, `Ownable2Step`. |
-| **Hook** | [`IACPHook`](erc8183/src/contracts.rs) | Normative hook interface. `beforeAction` / `afterAction` callbacks. |
+| **Standard** | `IERC8183` | Spec-mandated lifecycle functions and events. Works with **any** ERC-8183 contract. |
+| **Hook** | `IACPHook` | Normative hook interface. `beforeAction` / `afterAction` callbacks. |
+| **Implementation** | `AgenticCommerce` | Full QNTX ABI: `Job` struct, custom errors, admin functions, view getters, `Ownable2Step`. |
 
 Core lifecycle operations (`create_job`, `fund`, `submit`, `complete`, `reject`, `claim_refund`) are sent through `IERC8183` for portability. View and admin operations use `AgenticCommerce`.
 
@@ -129,16 +147,6 @@ use erc8183::hooks;
 assert_eq!(hooks::SEL_FUND, erc8183::contracts::IERC8183::fundCall::SELECTOR.into());
 ```
 
-## Design Principles
-
-| Principle | Detail |
-| --- | --- |
-| **Zero `async_trait`** | Pure RPITIT — no trait-object overhead, no heap allocation per call |
-| **Inline `sol!` bindings** | Preserves struct names and visibility; no JSON ABI files to manage |
-| **Provider-generic** | Works with any alloy transport (HTTP, WebSocket, IPC) and signer |
-| **Layered bindings** | `IERC8183` for portability, `AgenticCommerce` for full access |
-| **Strict linting** | `clippy::pedantic` + `nursery` + `correctness` (deny) |
-
 ## Related Standards
 
 | Standard | Relationship |

README.md

@@ -0,0 +1,97 @@
+//! Complete lifecycle on Monad Mainnet: `Open → Funded → Submitted → Completed`.
+//!
+//! ```sh
+//! export RPC_URL=https://rpc.monad.xyz
+//! export CLIENT_KEY=0xac0974...
+//! export PROVIDER_KEY=0x59c699...
+//! export EVALUATOR_KEY=0x5de411...
+//! cargo run --example lifecycle
+//! ```
+
+use std::env;
+
+use alloy::{
+    network::EthereumWallet,
+    primitives::{Address, FixedBytes, U256},
+    providers::{Provider, ProviderBuilder},
+    signers::local::PrivateKeySigner,
+};
+use erc8183::{Erc8183, Network, job::JobHandle, types::CreateJobParams};
+
+fn connect(
+    rpc: &str,
+    key_env: &str,
+) -> Result<(Erc8183<impl Provider>, Address), Box<dyn std::error::Error>> {
+    let signer: PrivateKeySigner = env::var(key_env)?.parse()?;
+    let addr = signer.address();
+    let sdk = Erc8183::new(
+        ProviderBuilder::new()
+            .wallet(EthereumWallet::from(signer))
+            .connect_http(rpc.parse()?),
+    )
+    .with_network(Network::MonadMainnet);
+    Ok((sdk, addr))
+}
+
+/// Client: create job → set budget → fund escrow.
+async fn client_create_and_fund<P: Provider>(
+    job: &JobHandle<P>,
+    provider: Address,
+    evaluator: Address,
+) -> erc8183::Result<U256> {
+    let params = CreateJobParams::new(
+        provider,
+        evaluator,
+        U256::from(u64::MAX),
+        "Analyze market data",
+    );
+    let id = job.create_job(&params).await?;
+    let budget = U256::from(1_000_000u64);
+    job.set_budget(id, budget, None).await?;
+    job.fund(id, budget, None).await?;
+    Ok(id)
+}
+
+/// Provider: submit work deliverable.
+async fn provider_submit<P: Provider>(job: &JobHandle<P>, id: U256) -> erc8183::Result<()> {
+    job.submit(id, FixedBytes::from([0xAB; 32]), None).await
+}
+
+/// Evaluator: attest completion → release escrow.
+async fn evaluator_complete<P: Provider>(job: &JobHandle<P>, id: U256) -> erc8183::Result<()> {
+    job.complete(id, FixedBytes::ZERO, None).await
+}
+
+#[allow(clippy::print_stdout)]
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let rpc = env::var("RPC_URL")?;
+
+    let (client_sdk, _) = connect(&rpc, "CLIENT_KEY")?;
+    let (provider_sdk, provider_addr) = connect(&rpc, "PROVIDER_KEY")?;
+    let (evaluator_sdk, evaluator_addr) = connect(&rpc, "EVALUATOR_KEY")?;
+
+    let client = client_sdk.job()?;
+    let provider = provider_sdk.job()?;
+    let evaluator = evaluator_sdk.job()?;
+
+    // Open → Funded → Submitted → Completed
+    let id = client_create_and_fund(&client, provider_addr, evaluator_addr).await?;
+    println!("[Client]    Created & funded job #{id}");
+
+    provider_submit(&provider, id).await?;
+    println!("[Provider]  Submitted deliverable");
+
+    evaluator_complete(&evaluator, id).await?;
+    println!("[Evaluator] Completed — payment released");
+
+    let job = client.get_job(id).await?;
+    println!(
+        "\nJob #{}: {} (terminal: {})",
+        job.id,
+        job.status,
+        job.status.is_terminal()
+    );
+
+    Ok(())
+}

erc8183/examples/basic.rs

@@ -5,13 +5,15 @@
 //! ```rust,no_run
 //! use alloy::primitives::U256;
 //! use alloy::providers::ProviderBuilder;
-//! use erc8183::Erc8183;
+//! use erc8183::{Erc8183, Network};
 //!
 //! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
 //! let provider = ProviderBuilder::new()
-//!     .connect_http("https://eth.llamarpc.com".parse()?);
+//!     .connect_http("https://monad-rpc.example.com".parse()?);
+//!
+//! // Built-in network (Monad Mainnet)
 //! let client = Erc8183::new(provider)
-//!     .with_address("0x1234...".parse()?);
+//!     .with_network(Network::MonadMainnet);
 //!
 //! let job = client.job()?.get_job(U256::from(1)).await?;
 //! # Ok(())
@@ -23,7 +25,7 @@ use alloy::{primitives::Address, providers::Provider};
 use crate::{
     error::{Error, Result},
     job::JobHandle,
-    networks::{Network, NetworkAddress},
+    networks::Network,
 };
 
 /// The main client for interacting with the ERC-8183 Agentic Commerce Protocol.
@@ -35,19 +37,34 @@ use crate::{
 ///
 /// # Examples
 ///
+/// Built-in network:
+///
 /// ```rust,no_run
-/// use alloy::primitives::U256;
 /// use alloy::providers::ProviderBuilder;
-/// use erc8183::Erc8183;
+/// use erc8183::{Erc8183, Network};
 ///
 /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
-/// let provider = ProviderBuilder::new()
-///     .connect_http("https://eth.llamarpc.com".parse()?);
+/// let client = Erc8183::new(
+///     ProviderBuilder::new()
+///         .connect_http("https://monad-rpc.example.com".parse()?),
+/// )
+/// .with_network(Network::MonadMainnet);
+/// # Ok(())
+/// # }
+/// ```
 ///
-/// let client = Erc8183::new(provider)
-///     .with_address("0x1234...".parse()?);
+/// Custom deployment:
+///
+/// ```rust,no_run
+/// use alloy::providers::ProviderBuilder;
+/// use erc8183::Erc8183;
 ///
-/// let job = client.job()?.get_job(U256::from(1)).await?;
+/// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+/// let client = Erc8183::new(
+///     ProviderBuilder::new()
+///         .connect_http("https://rpc.example.com".parse()?),
+/// )
+/// .with_address("0x1234...".parse()?);
 /// # Ok(())
 /// # }
 /// ```
@@ -74,19 +91,13 @@ impl<P: Provider> Erc8183<P> {
     /// Configure the contract address from a pre-defined [`Network`].
     #[must_use]
     pub const fn with_network(mut self, network: Network) -> Self {
-        let addr = network.address();
-        self.contract_address = Some(addr.agentic_commerce);
-        self
-    }
-
-    /// Configure the contract address from a [`NetworkAddress`] struct.
-    #[must_use]
-    pub const fn with_addresses(mut self, addr: NetworkAddress) -> Self {
-        self.contract_address = Some(addr.agentic_commerce);
+        self.contract_address = Some(network.address());
         self
     }
 
-    /// Set a custom Agentic Commerce contract address.
+    /// Set a custom `AgenticCommerce` contract address.
+    ///
+    /// Use this for deployments not yet listed in [`Network`].
     #[must_use]
     pub const fn with_address(mut self, address: Address) -> Self {
         self.contract_address = Some(address);