# Restaking Pools

The `restaking-pool` module powers the aggregation and delegation of user assets into curated strategies. These pools act as intermediaries between users and shared security networks like EigenLayer or Symbiotic, enabling scalable and permissionless participation in restaking.

Each pool can be tailored to a specific strategy or validator set. The architecture supports off-chain coordination via a Go SDK and contract bindings, enhancing automation and interoperability with external systems.

## Key Components

#### 1. **Smart Contracts (`contracts/`)**

* Implement pool logic, user deposits, validator coordination, and restaking lifecycle.
* Likely includes access control (e.g., operator, curator), performance tracking, and rewards management.

#### 2. **Off-chain SDK (Go)**

* Located in `abigen/`, `generated/`, and `generation/` folders.
* Provides tools for interacting with smart contracts from Go-based services.
* Includes scripts like `compile_contracts.sh` and `fastgen.py` to build contract bindings and streamline integration.

#### 3. **Deployment & Governance**

* `deploy/` and `deployment/` folders handle deployment logic, potentially using Hardhat or custom scripts.
* `.openzeppelin/` includes metadata for upgradeable deployments.

## Flow Overview

1. **User deposits assets** into a restaking pool smart contract.
2. **Pool logic** routes assets to a target strategy (e.g., EigenLayer restaking).
3. **Rewards and performance data** are tracked.
4. **External validators** or service providers interact via off-chain bindings using the Go SDK.
5. **Withdrawals or reallocation** can be performed by users or orchestrators.

## Cross-Chain & Off-Chain Coordination

* Go modules enable validators or external AVS actors to read from/write to contracts efficiently.
* `abigen.go`, `utils.go`, and `generated.go` provide a bridge between the on-chain pool state and off-chain decision-making.

## Smart Contract Highlights

| Contract Area      | Role                                                   |
| ------------------ | ------------------------------------------------------ |
| Pool Core          | Manages user deposits, withdrawals, strategy routing   |
| Access Roles       | Defines operators/curators and their permissions       |
| Rewards Logic      | Tracks and distributes earned rewards from restaking   |
| Validator Registry | (If present) Registers approved restaking destinations |

## Extensibility

* Supports modular integration with new shared security networks.
* Can be extended with new off-chain agents using the Go SDK.
* Deployment scripts make pool creation repeatable and auditable.

## Notes

* Implements a blend of Solidity and Go for on-chain and off-chain interoperability.
* Ideal for use cases where external actors (e.g., Shared Security Networks, oracles) must participate in pool coordination.