# NablaBackstopPool

The backstop pool takes most of the risk of a set of swap pools backed by it. Whenever a swap pool is low on reserves and a LPer wants to withdraw some liquidity, they can conduct an insurance withdrawal (burn swap pool shares, reimbursed in backstop liquidity) to avoid paying a high slippage. The backstop pool owns all excess liquidity in its swap pools, but is also liable for potential liquidity gaps. In return, the backstop pool receives a cut of the swap fees.

***

### Withdrawal

```solidity
struct Withdrawal {
  uint128 startClaimPeriod;
  uint128 endClaimPeriod;
  uint256 sharesToBurn;
}
```

***

### SwapPoolConfig

```solidity
struct SwapPoolConfig {
  uint128 insuranceFeeBps;
  bool isCovered;
}
```

***

### router

```solidity
contract IRouter router
```

router instance for this backstop pool

***

### getBackedPool

```solidity
function getBackedPool(uint256 _index) external view returns (address swapPool_)
```

enumerate swap pools backed by this backstop pool

#### **Parameters**

| Name    | Type    | Description                                        |
| ------- | ------- | -------------------------------------------------- |
| \_index | uint256 | index of the swap pool in `coveredSwapPools` array |

#### **Return Values**

| Name       | Type    | Description       |
| ---------- | ------- | ----------------- |
| swapPool\_ | address | swap pool address |

***

### getBackedPoolCount

```solidity
function getBackedPoolCount() external view returns (uint256 count_)
```

get swap pool count backed by this backstop pool

#### **Return Values**

| Name    | Type    | Description          |
| ------- | ------- | -------------------- |
| count\_ | uint256 | number of swap pools |

***

### getInsuranceFee

```solidity
function getInsuranceFee(address _swapPool) external view returns (uint256 feeBps_)
```

get insurance withdrawal fee for a given swap pool

#### **Parameters**

| Name       | Type    | Description              |
| ---------- | ------- | ------------------------ |
| \_swapPool | address | address of the swap pool |

#### **Return Values**

| Name     | Type    | Description                                      |
| -------- | ------- | ------------------------------------------------ |
| feeBps\_ | uint256 | insurance witdrawal fee, in basis points (0.01%) |

***

### deposit

```solidity
function deposit(uint256 _depositAmount, uint256 _minLPAmountOut, uint256 _deadline, bytes[] _priceUpdateData) external payable returns (uint256 sharesToMint_)
```

Deposits amount of tokens into pool Will change cov ratio of pool, will increase delta to 0

*By calling this function the price feeds get updated (IPriceOracleAdapter.updatePriceFeeds)*

#### **Parameters**

| Name              | Type     | Description                                                                                                       |
| ----------------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
| \_depositAmount   | uint256  | The amount of backstop pool tokens to be deposited                                                                |
| \_minLPAmountOut  | uint256  | The minimum amount of backstop pool LP tokens to mint                                                             |
| \_deadline        | uint256  | Unix timestamp after which the transaction will revert                                                            |
| \_priceUpdateData | bytes\[] | Array of price update data of all assets involved (backstop pool and all swapPools as within coveredSwapPools\[]) |

#### **Return Values**

| Name           | Type    | Description                                    |
| -------------- | ------- | ---------------------------------------------- |
| sharesToMint\_ | uint256 | Total number of backstop pool LP tokens minted |

***

### initiateWithdraw

```solidity
function initiateWithdraw(uint256 _sharesToBurn) external returns (bool success_)
```

Starts the withdrawal process or overrides an existing one The user must finalize the withdrawal after the delay period has passed but before the claim period ends through `finalizeWithdrawBackstopLiquidity()` or `finalizeWithdrawExcessSwapLiquidity()`

#### **Parameters**

| Name           | Type    | Description                                                         |
| -------------- | ------- | ------------------------------------------------------------------- |
| \_sharesToBurn | uint256 | The liquidity to be withdrawn, an amount of backstop pool LP tokens |

#### **Return Values**

| Name      | Type | Description             |
| --------- | ---- | ----------------------- |
| success\_ | bool | Confirmation of success |

***

### cancelWithdraw

```solidity
function cancelWithdraw() external returns (bool success_)
```

Cancels an initiated withdrawal

#### **Return Values**

| Name      | Type | Description             |
| --------- | ---- | ----------------------- |
| success\_ | bool | Confirmation of success |

***

### finalizeWithdrawBackstopLiquidity

```solidity
function finalizeWithdrawBackstopLiquidity(uint256 _minimumAmount, uint256 _deadline, bytes[] _priceUpdateData) external payable returns (uint256 payoutAmount_)
```

Finalizes the withdrawal process after the delay period has passed but before the claim period ends Withdraws backstop liquidity amount of asset ensuring minimum amount required

*By calling this function the price feeds get updated (IPriceOracleAdapter.updatePriceFeeds)*

#### **Parameters**

| Name              | Type     | Description                                                                                                       |
| ----------------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
| \_minimumAmount   | uint256  | Reject withdrawal if resulting amount is below                                                                    |
| \_deadline        | uint256  | Unix timestamp after which the transaction will revert                                                            |
| \_priceUpdateData | bytes\[] | Array of price update data of all assets involved (backstop pool and all swapPools as within coveredSwapPools\[]) |

#### **Return Values**

| Name           | Type    | Description                          |
| -------------- | ------- | ------------------------------------ |
| payoutAmount\_ | uint256 | Amount of `asset()` tokens withdrawn |

***

### redeemSwapPoolShares

```solidity
function redeemSwapPoolShares(address _swapPool, uint256 _shares, uint256 _minAmountOut, uint256 _deadline, bytes[] _priceUpdateData) external payable returns (uint256 amountOut_)
```

Withdraw from a swap pool using backstop liquidity without slippage (backstop burn) only possible if swap pool's coverage ratio < 100%

*By calling this function the price feeds get updated (IPriceOracleAdapter.updatePriceFeeds)*

#### **Parameters**

| Name              | Type     | Description                                                                         |
| ----------------- | -------- | ----------------------------------------------------------------------------------- |
| \_swapPool        | address  | swap pool address                                                                   |
| \_shares          | uint256  | number of swap pool LP tokens to redeem, uses decimals of swap pool                 |
| \_minAmountOut    | uint256  | minimum amount of backstop liquidity to receive, uses decimals of backstop pool     |
| \_deadline        | uint256  | Unix timestamp after which the transaction will revert                              |
| \_priceUpdateData | bytes\[] | Array of price update data of all assets involved (backstop pool and this swapPool) |

#### **Return Values**

| Name        | Type    | Description                                                           |
| ----------- | ------- | --------------------------------------------------------------------- |
| amountOut\_ | uint256 | amount of backstop liquidity paid-out, uses decimals of backstop pool |

***

### finalizeWithdrawExcessSwapLiquidity

```solidity
function finalizeWithdrawExcessSwapLiquidity(address _swapPool, uint256 _minAmount, uint256 _deadline, bytes[] _priceUpdateData) external payable returns (uint256 swapAmount_)
```

Finalizes the withdrawal process after the delay period has passed but before the claim period ends Withdraw from backstop pool, but receive excess liquidity of a swap pool instead of backstop liquidity

*By calling this function the price feeds get updated (IPriceOracleAdapter.updatePriceFeeds)*

#### **Parameters**

| Name              | Type     | Description                                                                                                       |
| ----------------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
| \_swapPool        | address  | swap pool address, must have a coverage ratio > 100%                                                              |
| \_minAmount       | uint256  | minimum amount of swap pool liquidity to receive, uses decimals of swap pool                                      |
| \_deadline        | uint256  | Unix timestamp after which the transaction will revert                                                            |
| \_priceUpdateData | bytes\[] | Array of price update data of all assets involved (backstop pool and all swapPools as within coveredSwapPools\[]) |

#### **Return Values**

| Name         | Type    | Description                                                        |
| ------------ | ------- | ------------------------------------------------------------------ |
| swapAmount\_ | uint256 | amount of swap pool liquidity paid-out, uses decimals of swap pool |

***

### redeemCrossSwapPoolShares

```solidity
function redeemCrossSwapPoolShares(address _swapPool, address _targetSwapPool, uint256 _shares, uint256 _minAmount, uint256 _deadline, bytes[] _priceUpdateData) external payable returns (uint256 finalAmount_)
```

***

### getTotalPoolWorth

```solidity
function getTotalPoolWorth(uint256[] _allTokenPrices) public view returns (int256 value_, int256 totalExcessLiquidity_)
```

return worth of the whole backstop pool in `asset()`, incl. all swap pools' excess liquidity and the backstop pool's liabilities this is a fixed point number, using the backstop pool decimals

*ignoring if pools are paused or not, since liabilities still apply and we don't want the backstop pool worth to jump*

#### **Parameters**

| Name             | Type       | Description                                                                                                                                                         |
| ---------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| \_allTokenPrices | uint256\[] | array of all token prices (\[0] backstop pool token, \[1] swap pool token\_i, \[2] swap pool token\_i+1, ... \[n] swap pool token\_n) as within coveredSwapPools\[] |

#### **Return Values**

| Name                   | Type   | Description                                            |
| ---------------------- | ------ | ------------------------------------------------------ |
| value\_                | int256 | total value of all backstop pool shares, in `asset()`  |
| totalExcessLiquidity\_ | int256 | total excess liquidity of all swap pools, in `asset()` |

***

### sharesTargetWorth

```solidity
function sharesTargetWorth(uint256 _sharesToBurn, uint256[] _allTokenPrices) public view returns (uint256 amount_)
```

Returns the worth of an amount of pool shares (LP tokens) in underlying principle

#### **Parameters**

| Name             | Type       | Description                                                                                                                                                         |
| ---------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| \_sharesToBurn   | uint256    | The number of LP tokens to burn                                                                                                                                     |
| \_allTokenPrices | uint256\[] | array of all token prices (\[0] backstop pool token, \[1] swap pool token\_i, \[2] swap pool token\_i+1, ... \[n] swap pool token\_n) as within coveredSwapPools\[] |

#### **Return Values**

| Name     | Type    | Description                                              |
| -------- | ------- | -------------------------------------------------------- |
| amount\_ | uint256 | The amount of `asset()` tokens that the shares are worth |

***

### getPoolState

```solidity
function getPoolState(uint256[] _allTokenPrices) external view returns (uint256 reserves_, int256 totalPoolWorth_, uint256 totalSupply_)
```

returns the backstop pool state

#### **Parameters**

| Name             | Type       | Description                                                                                                                                                         |
| ---------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| \_allTokenPrices | uint256\[] | array of all token prices (\[0] backstop pool token, \[1] swap pool token\_i, \[2] swap pool token\_i+1, ... \[n] swap pool token\_n) as within coveredSwapPools\[] |

#### **Return Values**

| Name             | Type    | Description                            |
| ---------------- | ------- | -------------------------------------- |
| reserves\_       | uint256 | current amount of `asset` in this pool |
| totalPoolWorth\_ | int256  | total worth of the pool in `asset()`   |
| totalSupply\_    | uint256 | total amount of LP tokens minted       |

***

### getWithdrawal

```solidity
function getWithdrawal(address _sender) external view returns (uint128 startClaimPeriod_, uint128 endClaimPeriod_, uint256 sharesToBurn_)
```

Get information about a user's initiated withdrawal

#### **Parameters**

| Name     | Type    | Description                           |
| -------- | ------- | ------------------------------------- |
| \_sender | address | The user who initiated the withdrawal |

#### **Return Values**

| Name               | Type    | Description                                                               |
| ------------------ | ------- | ------------------------------------------------------------------------- |
| startClaimPeriod\_ | uint128 | The time when the withdrawal can be finalized, a unix timestamp           |
| endClaimPeriod\_   | uint128 | The time when the withdrawal can no longer be finalized, a unix timestamp |
| sharesToBurn\_     | uint256 | The amount of LP tokens to burn                                           |

***

### getWithdrawalDelayAndClaimPeriod

```solidity
function getWithdrawalDelayAndClaimPeriod() external view returns (uint128 delay_, uint128 claimPeriod_)
```

Get the delay and claim period for withdrawals

#### **Return Values**

| Name          | Type    | Description                                                              |
| ------------- | ------- | ------------------------------------------------------------------------ |
| delay\_       | uint128 | The delay before initiated withdrawals can be finalized, in seconds      |
| claimPeriod\_ | uint128 | The period within which initiated withdrawals can be claimed, in seconds |


---

# 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.nabla.fi/developers/contract-interfaces/nablabackstoppool.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.