> For the complete documentation index, see [llms.txt](https://scall-io.gitbook.io/scall.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://scall-io.gitbook.io/scall.io/developers/contracts/collateralpool.md).

# CollateralPool

## 🏦 `CollateralPool.sol`

The `CollateralPool` contract is a key component of the Scall.io protocol. It handles the **collateral management system**, which powers all perpetual option contracts.

This contract manages:

* User deposits and withdrawals of collateral tokens (e.g., USDC)
* Real-time rent deduction from traders
* Liquidation logic based on collateral balances
* Reward distribution for liquidity providers (LPs)

***

### 🧩 What It Does

* Accepts and stores **collateral deposits** from traders
* Tracks **user rent balance** and updates it per block
* Enables **safe withdrawals** based on collateral/rent levels
* Handles **liquidation** if rent coverage becomes insufficient
* Distributes **protocol rewards** to LPs and other participants

***

### 🛠️ Public & External Functions

#### `depositCollateral(uint256 amount)`

* Allows a trader to deposit collateral.
* Emits: `CollateralDeposited`

```solidity
/// @notice Allows a user to deposit collateral into their account.
/// @param _amount The amount of collateral to deposit.
function depositCollateral(uint256 _amount) external
```

#### `withdrawCollateral(uint256 amount)`

* Lets a trader withdraw unused collateral, assuming rent requirements are still met.
* Emits: `CollateralWithdrawn`

```solidity
/// @notice Allows a user to withdraw collateral if they have sufficient balance.
/// @param _amount The amount of collateral to withdraw.
function withdrawCollateral(uint256 _amount) external
```

#### `liquidateContract(address user, address market, uint256 contractId)`

* Called by any liquidator when a user’s collateral balance drops below the minimum threshold (e.g., one week of rent).
* Automatically closes the user’s contracts and redistributes a penalty to the liquidator.
* Emits: `ContractLiquidated`

```solidity
/// @notice Liquidates a user's contract if they meet the liquidation criteria.
/// @param _user The address of the user.
/// @param _index The market index.
/// @param _id The ID of the user's position.
/// @return The penalty amount awarded to the liquidator (18 decimals).
function liquidateContract(address _user, uint256 _index, uint256 _id) external returns(uint256)
```

#### `claimRewards(uint256 index, uint256 id, uint256 substractCount)`

* Allows LPs or users with eligible NFTs to claim rent rewards based on usage and time.
* Emits: `RewardsClaimed`

```solidity
/// @notice Allows a user to claim rewards for a position they own.
/// @param _index The market index.
/// @param _id The ID of the user's position.
/// @param _substractCount If the user want to claim until a specific period.
/// @return claimedRewards The reward amount received by the LP (token decimals).
function claimRewards(uint256 _index, uint256 _id) external returns(uint256)
```

***

### 👀 View Functions

These read-only functions help frontends or users query internal state:

#### `getUserInfos(address user) → uint256`

* Returns user information for a specific user.

```solidity
struct UserInfos {
    uint256 collateral;
    uint256 rent;
    uint256 lastUpdate;
}
/// @notice Returns user information for a specific user.
/// @param _user The address of the user.
/// @return UserInfos structure containing collateral, rent, and last update timestamp.
function getUserInfos(address _user) external view returns(UserInfos memory)
```

#### `getUserFees(address user) → uint256`

* Returns the current fees per second for a given user.

```solidity
/// @notice Calculates the accumulated fees for a user.
/// @param _user The address of the user.
/// @return The total fees accumulated for the user (18 decimals).
function getUserFees(address _user) external view returns(uint256)
```

#### `balanceOf(address user) → uint256`

* Returns the current balance for a given user.

```solidity
/// @notice Returns the balance of collateral for a user after deducting rent fees.
/// @param _user The address of the user.
/// @return The net balance of the user (18 decimals).
function balanceOf(address _user) public view returns(uint256)
```

#### `getRewardsForLP(uint256 index, uint256 id) → uint256`

* Returns the rewards for a given LP.

```solidity
/// @notice Calculates the rewards for a liquidity provider after deducting fees.
/// @param _index The market index.
/// @param _id The ID of the user's position in the market.
/// @return The net rewards after fees (18 decimals).
function getRewardsForLp(uint256 _index, uint256 _id) external view returns(uint256)
```

#### `canOpenContract(address user, uint256 rent) → bool`

* Determines if a user can open a contract based on their collateral and rent.

```solidity
/// @notice Determines if a user can open a contract based on their collateral and rent.
/// @param _user The address of the user.
/// @param _rent The rent amount for the new contract.
/// @return True if the user has sufficient collateral, otherwise false.
function canOpenContract(address _user, uint256 _rent) external view returns(bool)
```

#### `needLiquidation(address user) → bool`

* Checks if a user needs to be liquidated.

```solidity
/// @notice Checks if a user needs to be liquidated.
/// @param _user The address of the user.
/// @return True if liquidation is required, otherwise false.
function needLiquidation(address _user) external view returns(bool)
```

#### `getCollateralToken() → address`

* Returns the address of the collateral token used.

```solidity
/// @notice Returns the address of the collateral Token.
/// @return Address of the collateral Token.
function getCollateralToken() external view returns(address)
```

#### `getMain() → address`

* Returns the address of the main contract that oversees protocol governance.

```solidity
/// @notice Returns the address of the main contract.
/// @return Address of the main contract.
function getMain() external view returns(address)
```

***

### 🧠 How It Works

The contract stores user collateral in a mapping and tracks **rent accrual per second**. If a user’s collateral drops below one week of required rent, their positions are eligible for liquidation.

When rent is collected, the protocol distributes it across:

* Liquidity providers
* The DAO (if enabled)
* Potential rewards for liquidators

***

### 📌 Summary

| Feature          | Purpose                                         |
| ---------------- | ----------------------------------------------- |
| Deposit/Withdraw | Manage user collateral balances                 |
| Rent Tracking    | Ensure options remain funded in real-time       |
| Liquidation      | Protect LPs by auto-closing underfunded trades  |
| Rewards Claiming | Enable LPs to receive protocol-generated income |