# Rewarder Module

### Data Structures

#### RewarderManager

The main structure that manages all rewarders for a specific pair.

```rust
struct RewarderManager has store {
    rewarders: vector<Rewarder>,
    last_update_timestamp: u64,
}
```

**Fields:**

* `rewarders`: Vector containing up to 5 rewarder configurations
* `last_update_timestamp`: Timestamp of the last reward calculation update

#### Rewarder

Individual rewarder configuration for a specific token type.

```rust
struct Rewarder has copy, drop, store {
    emission_per_ms: u128,
    reward_coin: TypeName
}
```

**Fields:**

* `emission_per_ms`: Rate of token emission per millisecond
* `reward_coin`: Type name of the reward token

#### RewarderGlobalVault

Global storage for all reward token balances across the system.

```rust
struct RewarderGlobalVault has key, store {
    id: UID,
    balances: Bag,
}
```

**Fields:**

* `id`: Unique identifier for the vault
* `balances`: Bag containing balance objects for each token type

***

### Core Functions

#### Initialization

**`new()`**

Creates a new RewarderManager instance.

```rust
public(friend) fun new(): RewarderManager
```

**Returns:** Empty RewarderManager with no rewarders configured

**`add_rewarder<RewardCoin>()`**

Adds a new rewarder for a specific reward token type.

```rust
public(friend) fun add_rewarder<RewardCoin>(
    manager: &mut RewarderManager
)
```

**Parameters:**

* `manager`: Mutable reference to RewarderManager
* `RewardCoin`: Type parameter for the reward token

**Validations:**

* Maximum 5 rewarders per pair
* No duplicate rewarders for the same token type

#### Reward Calculation

**`calculate_reward_emission()`**

Calculates and updates reward emissions based on elapsed time.

```rust
public(friend) fun calculate_reward_emission(
    manager: &mut RewarderManager,
    clock: &Clock
): vector<u128>
```

**Parameters:**

* `manager`: Mutable reference to RewarderManager
* `clock`: Clock object for timestamp access

**Returns:** Vector of reward amounts for each rewarder

**Logic:**

```rust
reward_emission = emission_per_ms × (current_time - last_update_time)
```

**`simulate_reward_emission()`**

Simulates reward calculation without updating the manager state.

```rust
public fun simulate_reward_emission(
    manager: &RewarderManager,
    clock: &Clock
): vector<u128>
```

**Use Case:** Preview reward amounts before actual distribution

***

### Reward Management

#### Deposit Rewards

**`deposit_reward<RewardCoin>()`**

Deposits reward tokens into the global vault.

```rust
public fun deposit_reward<RewardCoin>(
    global_config: &GlobalConfig,
    vault: &mut RewarderGlobalVault,
    reward: Balance<RewardCoin>
)
```

**Parameters:**

* `global_config`: Global configuration for access control
* `vault`: Mutable reference to global vault
* `reward`: Balance object containing tokens to deposit

**Process:**

1. Validate package version
2. Create balance entry if doesn't exist
3. Join deposited balance with existing balance
4. Emit deposit event

#### Withdraw Rewards

**`withdraw_reward<RewardCoin>()`**

Withdraws reward tokens from the global vault.

```rust
public(friend) fun withdraw_reward<RewardCoin>(
    vault: &mut RewarderGlobalVault,
    amount: u64,
): Balance<RewardCoin>
```

**Parameters:**

* `vault`: Mutable reference to global vault
* `amount`: Amount to withdraw

**Validations:**

* Rewarder must exist for the token type
* Sufficient balance must be available

#### Emergency Withdrawal

**`emergent_withdraw<CoinType>()`**

Emergency withdrawal function for administrators.

```rust
public fun emergent_withdraw<CoinType>(
    global_config: &GlobalConfig,
    vault: &mut RewarderGlobalVault,
    amount: u64,
    ctx: &mut TxContext
)
```

**Access Control:**

* Only pool managers can execute
* Withdrawn funds sent to designated receiver

#### Error Codes

| Code | Constant                    | Description                        |
| ---- | --------------------------- | ---------------------------------- |
| 3000 | `E_TOO_MANY_REWARDERS`      | Exceeds maximum rewarders per pair |
| 3001 | `E_REWARDER_ALREADY_EXISTS` | Duplicate rewarder for token type  |
| 3003 | `E_INSUFFICIENT_BALANCE`    | Insufficient vault balance         |
| 3004 | `E_REWARDER_NOT_FOUND`      | Rewarder not found for token type  |

### Events

#### Key Events

**RewardEmissionUpdateEvent**

```rust
struct RewardEmissionUpdateEvent has copy, drop {
    pair: ID,
    reward_type: TypeName,
    old_emission: u128,
    new_emission: u128,
}
```

Emitted when emission rates are updated.

**DepositEvent**

```rust
struct DepositEvent has copy, drop {
    vault: ID,
    reward_type: TypeName,
    amount: u64,
    total_balance: u64,
}
```

Emitted when tokens are deposited into the vault.

**WithdrawEvent**

```rust
struct WithdrawEvent has copy, drop {
    vault: ID,
    reward_type: TypeName,
    amount: u64,
    remaining_balance: u64,
}
```

Emitted when tokens are withdrawn from the vault.


---

# 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.ferra.ag/integration/dlmm/smart-contract/rewarder-module.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.