# Staking

Staking in Züs Network involves **locking tokens** into a **stake pool** to support various network participants. 

The **primary objectives** of staking are:

* **Security**: Ensures only reliable and well-funded providers operate in the network.
* **Incentives**: Rewards participants for providing services.
* **Decentralization**: Enables users to participate in governance and network operation.

There are **five main types** of **staking providers** in Züs:

1. **Blobbers** - Storage providers who store and maintain user data.
2. **Validators** - Verify storage challenges and ensure data integrity.
3. **Miners** - Participate in transaction validation and block production.
4. **Sharders** - Store blockchain metadata and help retrieve historical data.
5. **Authorizers** - Manage token bridging between blockchains.

Each provider type has **unique staking requirements** and rewards based on network contribution.

### **Staking Mechanism**

Users can **stake tokens** into **stake pools** of different providers, where tokens are **locked** and used to determine rewards and penalties.

#### **Stake Pools**

Each provider has a **stake pool** where staked tokens accumulate. The total stake affects:

* The **weight** of the provider in earning rewards.
* Their **ability to participate** in network operations.
* The **penalty mechanism** for failing to meet obligations.

#### **Stake Delegation**

Users who do not run a provider node can still **delegate their tokens** to existing providers and earn a **share of the rewards**.

* **Higher stake → More rewards.**
* **Stake remains locked** for a defined period.
* **Providers take a commission** before distributing rewards.

### Staking Process

The Züs Network allows **staking** to different service providers, including **blobbers, validators, miners, sharders, and authorizers**. 

Users can lock their tokens in **stake pools** to earn rewards based on the provider’s performance and stake weight. Here are key Stake-Related Functions in Go SDK

1. **`StakePoolLock`** - Locks tokens into a stake pool.
2. **`StakePoolUnlock`** - Unlocks staked tokens when eligible.
3. **`WritePoolLock`** - Locks tokens in a **write pool** for storage payments.
4. **`WritePoolUnlock`** - Unlocks tokens from the **write pool**.

#### **1. Locking Tokens in a Stake Pool**

The **`StakePoolLock`** function locks tokens into a stake pool, allowing users to delegate their stake to providers and earn rewards.

```go
func StakePoolLock(providerType ProviderType, providerID string, value, fee uint64) (hash string, nonce int64, err error)
```

Here is how it works:

1. The function **validates** that the SDK is initialized.
2. Ensures a **valid provider type and ID**.
3. Constructs a **stake pool request** and identifies the correct **smart contract**:
   * **Blobber/Validator:** `STORAGESC_STAKE_POOL_LOCK`
   * **Miner/Sharder:** `MINERSC_LOCK`
   * **Authorizer:** `ZCNSC_LOCK`
4. Calls `transaction.SmartContractTxnValueFeeWithRetry` to **execute the staking transaction**.

#### **Example Usage**

```go
hash, nonce, err := StakePoolLock(ProviderBlobber, "blobber-123", 1000, 10)
if err != nil {
    fmt.Println("Error staking:", err)
} else {
    fmt.Println("Stake transaction successful! Hash:", hash)
}
```

#### **Unlocking Tokens from a Stake Pool**

The **`StakePoolUnlock`** function allows users to withdraw their staked tokens when eligible.

```go
func StakePoolUnlock(providerType ProviderType, providerID, clientID string, fee uint64) (unstake int64, nonce int64, err error)
```

Here is how it works:

1. The function **validates** that the SDK is initialized.
2. Ensures the **provider type and ID** are valid.
3. Calls the correct **smart contract method**:
   * **Blobber/Validator:** `STORAGESC_STAKE_POOL_UNLOCK`
   * **Miner/Sharder:** `MINERSC_UNLOCK`
   * **Authorizer:** `ZCNSC_UNLOCK`
4. Executes the **transaction** and returns the amount unstaked.

#### **Example Usage**

```go
goCopyEditunstake, nonce, err := StakePoolUnlock(ProviderBlobber, "blobber-123", "client-id", 10)
if err != nil {
    fmt.Println("Error unlocking stake:", err)
} else {
    fmt.Println("Stake unlocked:", unstake)
}
```

#### **Locking Tokens in the Write Pool**

The **`WritePoolLock`** function allows users to lock tokens into a **write pool**, which is used for **storage payments**.

```go
func WritePoolLock(allocID string, tokens, fee uint64) (hash string, nonce int64, err error)
```

Here is how it works:

1. Ensures the SDK is initialized.
2. Locks tokens for a **specific allocation** (`allocID`).
3. Calls the **`STORAGESC_WRITE_POOL_LOCK`** smart contract.

#### **Example Usage**

```go
hash, nonce, err := WritePoolLock("allocation-456", 500, 5)
if err != nil {
    fmt.Println("Error locking write pool:", err)
} else {
    fmt.Println("Write pool locked successfully! Hash:", hash)
}
```

### **4. Unlocking Tokens from the Write Pool**

The **`WritePoolUnlock`** function allows users to unlock **all tokens** from the write pool.

```go
func WritePoolUnlock(allocID string, fee uint64) (hash string, nonce int64, err error)
```

Here is how it works:

1. Ensures SDK is initialized.
2. Unlocks all **unused tokens** from the **write pool** for a given **allocation** (`allocID`).
3. Calls the **`STORAGESC_WRITE_POOL_UNLOCK`** smart contract.

#### **Example Usage**

```go
hash, nonce, err := WritePoolUnlock("allocation-456", 5)
if err != nil {
    fmt.Println("Error unlocking write pool:", err)
} else {
    fmt.Println("Write pool unlocked successfully! Hash:", hash)
}
```


---

# 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.zus.network/zus-docs/tokenomics/staking.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.