# SinglePool

 This contract is a single pool contract, where liquidity providers deposit/withdraw assets, and Plus Pool users bring or return utilized assets from a single pool.

## Code

Github Link: (Will be updated after official launch)

## Address

Contract adress after production is deployed (scope link) 

## Events, Read-Only Functions, and State-Changing Functions

{% tabs %}
{% tab title="Events" %}

## Events

**GiveReward**

```solidity
event GiveReward(address user, uint amount, uint lastIndex, uint rewardSum);
```

* Event log of when mined KSP is claimed and distributed

**Deposit**

```solidity
event Deposit(address user, uint depositAmount, uint depositTokens, uint totalAmount, uint totalSupply);
```

* Event log of single pool liquidity additions
* Parameters
  * `user` : user address
  * `depositAmount` : amount of tokens deposited by the user
  * `depositTokens` : amount of single pool tokens deposited 
  * `totalAmount` : total amount of tokens deposited 
  * `totalSupply` : total amount of single pool tokens deposited 

**Withdraw**

```solidity
event Withdraw(address user, uint withdrawAmount, uint withdrawTokens, uint totalAmount, uint totalSupply);
```

* Event log of single pool liquidity removals
* Parameters
  * `user` : User address 
  * `withdrawAmount` : The amount of tokens removed by the user
  * `withdrawTokens` : The amount of single pool tokens removed by the user
  * `totalAmount` : Total amount of tokens deposited 
  * `totalSupply` : Total amount of single pool tokens deposited 

**Borrow**

```solidity
event Borrow(address user, address plusPoolAddress, uint borrowAmount, uint accountBorrows, uint totalBorrows);
```

* Event log of using assets utilized during plus deposit
* Parameters
  * `user` : user address
  * `plusPoolAddress` : Plus Pool address
  * `borrowAmount` : The amount of tokens utilized 
  * `accountBorrows` : Total amount of assets utilized by users
  * `totalBorrows` : Total amount of single pool utilized 

**Repay**

```solidity
event Repay(address user, address plusPoolAddress, uint repayAmount, uint accountBorrows, uint totalBorrows);
```

* Event log of used assets are returned
* Parameters
  * `user` : User address 
  * `plusPoolAddress` : PlusPool address
  * `repayAmount` : The amount of returned asset tokens
  * `accountBorrows` : Total amount of assets utilized by users
  * `totalBorrows` : Total amount of single pool utilized
    {% endtab %}

{% tab title="Read-Only Functions" %}

## Read-Only Functions

#### name

* "I" + token name

#### symbol

* "i" + token symbol

**decimals**

* 18

**token**

* KIP7 token address 

#### totalSupply

* mint/burn depending on liquidity addition/removal

#### balanceOf

* Number of LP tokens held by each address

#### allowance

* Status of approval to spender for each address

#### getCash

* Number of tokens held by contract

#### reserveFactor

* KSP buyback & burn allocation ratio among utilization fees 
* It is a value between 0 and 10^18, in units of 0.000000000000000001%
* Default - 200000000000000000

#### totalBorrow

* Total Assets Utilized

#### mining

* The ratio of KSPs distributed to a single pool mined by that pool
* It is a value between 0 and 10000, in units of 0.0001%

#### lastMined

* SinglePoolFactory.mined() value at the last time the pair updated the index

#### withdrawActive

```solidity
function withdrawActive() public view returns (bool)
```

* Whether single pool withdrawal is possible

#### depositActive

```solidity
function depositActive() public view returns (bool)
```

* Whether single pool deposit is possible
  {% endtab %}

{% tab title="State-Changing Functions" %}

## State-Changing Functions

#### transfer

```solidity
function transfer(address _to, uint _value) public returns (bool)
```

* KIP7 Standard
* Method to transfer tokens 

#### transferFrom

```solidity
function transferFrom(address _from, address _to, uint _value) public returns (bool)
```

* KIP7 Standard
* Method to transfer tokens on behalf of the approved wallet

#### approve

```solidity
function approve(address _spender, uint _value) public returns (bool)
```

* KIP7 Standard
* Method to approve a transfer as much as value to spender

#### depositKlay

```solidity
function depositKlay() public payable
```

* Method used to provide liquidity when token is KLAY
* Liquidity of the KLAY `msg.value` 

#### depositKct

```solidity
function depositKct(uint depositAmount) public
```

* Method used to provide liquidity when token is KIP7 standard token
* Liquidity of the number of deposit amount is provided

#### withdraw

```solidity
function withdraw(uint withdrawAmount)
```

* Method to withdraw tokens to `msg.sender` wallet.
* `withdrawAmount` : Number of token amount to withdraw

#### withdrawByAmount

```solidity
function withdrawByAmount(uint withdrawTokens)
```

* Method to withdraw tokens to `msg.sender` wallet. 
* `withdrawTokens` : Number of SinglePool liquidity token amount to withdraw 

#### addReserves

```solidity
function addReserves(uint addAmount) external payable
```

* Method to transfer tokens to using buyback KSP
* `addAmount` : Number of token 

#### claimReward

```solidity
function claimReward() public
```

* Method that a user calls to claim the claimable KSP and airdrop that has accumulated for the pair
* When called, KSP is claimed from the Factory and paid to `msg.sende`
* Even if the method is not called directly, it is automatically called when the SinglePool token balance of the user’s wallet changes.
  * When liquidity is added
  * When liquidity is removed
    {% endtab %}
    {% endtabs %}