Nithyamickey
diff --git a/‎Dockerfile‎
Lines changed: 1 addition & 0 deletions b/‎Dockerfile‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎README.md‎
Lines changed: 1 addition & 1 deletion b/‎README.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎docs/agglayer/agglayer-go.md‎
Lines changed: 0 additions & 98 deletions b/‎docs/agglayer/agglayer-go.md‎
Lines changed: 0 additions & 98 deletions
diff --git a/‎docs/agglayer/agglayer-rs.md‎
Lines changed: 0 additions & 91 deletions b/‎docs/agglayer/agglayer-rs.md‎
Lines changed: 0 additions & 91 deletions
diff --git a/‎docs/agglayer/architecture/agglayer-node.md‎
Lines changed: 32 additions & 0 deletions b/‎docs/agglayer/architecture/agglayer-node.md‎
Lines changed: 32 additions & 0 deletions
diff --git a/‎docs/agglayer/architecture/overview.md‎
Lines changed: 37 additions & 0 deletions b/‎docs/agglayer/architecture/overview.md‎
Lines changed: 37 additions & 0 deletions
@@ -4,6 +4,7 @@ RUN apk update
 RUN apk add rsync
 RUN apk add git
 RUN apk add nodejs npm
+RUN apk add --no-cache bash
 COPY requirements.txt requirements.txt
 RUN pip install -r requirements.txt --no-cache-dir
 
 
@@ -1,6 +1,6 @@
 # Polygon Knowledge Layer
 
-Welcome to the Polygon Knowledge Layer .
+Welcome to the Polygon Knowledge Layer!
 
 These docs use [the Material theme for MkDocs](https://squidfunk.github.io/mkdocs-material/). Our goal is to establish a high-quality, curated, and comprehensive "source of truth" for Polygon's technology. 
 
 
@@ -0,0 +1,32 @@
+# Agglayer Node
+
+## Overview
+
+**The Agglayer node** is the Rust-based service designed to receive zero-knowledge proofs from Agglayer-connected chains, verify their validity, and send them to the L1 for final settlement. 
+
+> **Note:** Instructions on how to clone and build the Agglayer locally, including running the pessimistic proof test suite and generating a verifiable proof using Succinct’s Prover Network, can be found [here](#).
+
+## Crate directory
+
+The crates and their functions within the Agglayer repo are as follows:
+
+| Crate                                                                          | Description                                                                                                                                                                                                                                                                                                                                                        |
+| ---                                                                            | ---                                                                                                                                                                                                                                                                                                                                                                |
+| [agglayer-aggregator-notifier](/crates/agglayer-aggregator-notifier)           | Contains implementations for [Certifier](crates/agglayer-certificate-orchestrator/src/certifier.rs#L29) which applies new [Certificate](crates/agglayer-types/src/lib.rs#245) on top of an existing state and computes the proof, as well as [EpochPacker](crates/agglayer-certificate-orchestrator/src/epoch_packer.rs#14), which handles the packing of an epoch |
+| [agglayer-certificate-orchestrator](/crates/agglayer-certificate-orchestrator) | Manages the orchestration and handling of certificates; also handles `current_epoch`, which allows non-orchestrators to push a proven certificate                                                                                                                                                                                                                  |
+| [agglayer-clock](/crates/agglayer-clock)                                       | Defines the pace of the Agglayer in terms of epoch with support for two clocks: time (for testing) and block (for listening for L1 blocks)                                                                                                                                                                                                                         |
+| [agglayer-config](/crates/agglayer-config)                                     | Manages configuration settings and parameters for Agglayer components                                                                                                                                                                                                                                                                                              |
+| [agglayer-contracts](/crates/agglayer-contracts)                               | Contains smart contracts and related logic                                                                                                                                                                                                                                                                                                                         |
+| [agglayer-gcp-kms](/crates/agglayer-gcp-kms)                                   | Provides integration with GCP's Key Management Service for secure key handling                                                                                                                                                                                                                                                                                     |
+| [agglayer-node](/crates/agglayer-node)                                         | Responsible for spawning and running the different components of the node                                                                                                                                                                                                                                                                                          |
+| [agglayer-prover-types](/crates/agglayer-prover-types)                         | Defines data structures and types used by the prover                                                                                                                                                                                                                                                                                                               |
+| [agglayer-prover](/crates/agglayer-prover)                                     | Responsible for running everything related to the prover                                                                                                                                                                                                                                                                                                           |
+| [agglayer-signer](/crates/agglayer-signer)                                     | Manages signing operations                                                                                                                                                                                                                                                                                                                                         |
+| [agglayer-storage](/crates/agglayer-storage)                                   | Contains two layers: a physical layer for abstracting RocksDB and a logic layer for exposing the interface to other crates so that they may interact with the storage                                                                                                                                                                                              |
+| [agglayer-telemetry](/crates/agglayer-telemetry)                               | Handles telemetry and monitoring functionalities                                                                                                                                                                                                                                                                                                                   |
+| [agglayer-types](/crates/agglayer-types)                                       | Defines common data types and structures                                                                                                                                                                                                                                                                                                                           |
+| [agglayer](/crates/agglayer)                                                   | The CLI for interacting with the Agglayer                                                                                                                                                                                                                                                                                                                          |
+| [pessimistic-proof-program](/crates/pessimistic-proof-program)                 | Implements the pessimistic proof program                                                                                                                                                                                                                                                                                                                           |
+| [pessimistic-proof-test-suite](/crates/pessimistic-proof-test-suite)           | Provides a suite of tests for validating the functionality of the pessimistic proof program                                                                                                                                                                                                                                                                        |
+| [pessimistic-proof](/crates/pessimistic-proof)                                 | Contains the core logic and implementation of the pessimistic proof mechanism                                                                                                                                                                                                                                                                                      |
+
@@ -0,0 +1,37 @@
+---
+hide:
+  - toc
+---
+
+# Agglayer Architecture
+
+## Overview
+
+**The Agglayer** is designed to provide an interoperability framework for cross-chain communication and state verification that robust, scalable, and flexible enough to support these features between unalike blockchain networks. The key components of the Agglayer include the **Agglayer node**, the **pessimistic proof**, and the **unified bridge**. They are designed to enable lightweight, secure, and verifiable cross-chain transactions.
+
+## Agglayer node
+
+The **Agglayer Node** is a Rust-based service responsible for processing and verifying zero-knowledge (ZK) proofs from chains connected to the Agglayer. 
+
+### Key functions:
+- **Zero-knowledge proof verification**: The node receives and verifies cryptographic proofs from connected chains before sending them to L1.
+- **Certificate management**: Handles certificates that attest to the state transitions of connected chains.
+- **Orchestration of epochs**: Manages state updates in a structured manner through epochs.
+
+## Pessimistic proof
+
+The **pessimistic proof** mechanism ensures that any withdrawal claims made to the Agglayer are backed by legitimate deposits in the **Unified Bridge**. It uses a novel zero-knowledge proof system implemented in Rust, leveraging the **SP1 zkVM** and the **Plonky3 proving system**.
+
+### Key functions:
+- **Security validation**: Ensures that each chain connected to the Agglayer remains as secure as if it were operating independently.
+- **State consistency**: Provides a complete view of all token and message transfers occurring across the Agglayer.
+- **Fraud prevention**: Prevents chains from withdrawing more assets than they have legitimately received.
+
+## Unified bridge
+
+The **unified bridge** is responsible for maintaining the data structures related to chain states, cross-chain transactions, and the Agglayer’s Global Exit Root, ensuring cross-chain transactions are indeed finalized on the L1 before they can be claimed.  
+
+### Key functions:
+- **Cross-chain asset transfers**: Allows users to bridge assets between different chains.
+- **Message passing**: Enables contract-to-contract interactions across chains.
+- **State management and accounting**: Maintains Merkle proofs that ensure transactions are finalized before being processed on the destination chain.