# 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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.inceptionlrt.com/developers/modules/restaking-pools.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.