# TermRepoCollateralManager.sol

## TermRepoCollateralManager

This contract enforces margin maintenance rules for adding/withdrawing, repurchasing and liquidating collateral

*This contract belongs to the Term Servicer group of contracts and is specific to a Term Repo deployment*

### ADMIN\_ROLE

```solidity
bytes32 ADMIN_ROLE
```

### AUCTION\_LOCKER

```solidity
bytes32 AUCTION_LOCKER
```

### DEVOPS\_ROLE

```solidity
bytes32 DEVOPS_ROLE
```

### INITIALIZER\_ROLE

```solidity
bytes32 INITIALIZER_ROLE
```

### SERVICER\_ROLE

```solidity
bytes32 SERVICER_ROLE
```

### ROLLOVER\_MANAGER

```solidity
bytes32 ROLLOVER_MANAGER
```

### ROLLOVER\_TARGET\_AUCTIONEER\_ROLE

```solidity
bytes32 ROLLOVER_TARGET_AUCTIONEER_ROLE
```

### termRepoId

```solidity
bytes32 termRepoId
```

### liquidationsPaused

```solidity
bool liquidationsPaused
```

### termContractPaired

```solidity
bool termContractPaired
```

### numOfAcceptedCollateralTokens

```solidity
uint8 numOfAcceptedCollateralTokens
```

### deMinimisMarginThreshold

```solidity
uint256 deMinimisMarginThreshold
```

### liquidateDamangesDueToProtocol

```solidity
uint256 liquidateDamangesDueToProtocol
```

### netExposureCapOnLiquidation

```solidity
uint256 netExposureCapOnLiquidation
```

### termRepoServicer

```solidity
contract ITermRepoServicer termRepoServicer
```

### purchaseToken

```solidity
address purchaseToken
```

### termPriceOracle

```solidity
contract ITermPriceOracle termPriceOracle
```

### termRepoLocker

```solidity
contract ITermRepoLocker termRepoLocker
```

### termController

```solidity
contract ITermController termController
```

### emitter

```solidity
contract ITermEventEmitter emitter
```

### collateralTokens

```solidity
address[] collateralTokens
```

### encumberedCollateralBalances

```solidity
mapping(address => uint256) encumberedCollateralBalances
```

### maintenanceCollateralRatios

```solidity
mapping(address => uint256) maintenanceCollateralRatios
```

### initialCollateralRatios

```solidity
mapping(address => uint256) initialCollateralRatios
```

### liquidatedDamages

```solidity
mapping(address => uint256) liquidatedDamages
```

### lockedCollateralLedger

```solidity
mapping(address => mapping(address => uint256)) lockedCollateralLedger
```

### isCollateralTokenAccepted

```solidity
modifier isCollateralTokenAccepted(address token)
```

### whileLiquidationsNotPaused

```solidity
modifier whileLiquidationsNotPaused()
```

### notTermContractPaired

```solidity
modifier notTermContractPaired()
```

### constructor

```solidity
constructor() public
```

### initialize

```solidity
function initialize(string termRepoId_, uint256 liquidateDamangesDueToProtocol_, uint256 netExposureCapOnLiquidation_, uint256 deMinimisMarginThreshold_, address purchaseToken_, struct Collateral[] collateralTokens_, contract ITermEventEmitter emitter_, address termInitializer_) external
```

### pairTermContracts

```solidity
function pairTermContracts(address termRepoLocker_, address termRepoServicer_, address termAuctionBidLocker_, address termAuction_, address termController_, address termPriceOracle_, address termRepoRolloverManager_, address devopsMultisig_, address adminWallet_) external
```

### externalLockCollateral

```solidity
function externalLockCollateral(address collateralToken, uint256 amount) external
```

#### Parameters

| Name            | Type    | Description                                 |
| --------------- | ------- | ------------------------------------------- |
| collateralToken | address | The address of the collateral token to lock |
| amount          | uint256 | The amount of collateral token to lock      |

### externalUnlockCollateral

```solidity
function externalUnlockCollateral(address collateralToken, uint256 amount) external
```

#### Parameters

| Name            | Type    | Description                                   |
| --------------- | ------- | --------------------------------------------- |
| collateralToken | address | The address of the collateral token to unlock |
| amount          | uint256 | The amount of collateral token to unlock      |

### batchLiquidation

```solidity
function batchLiquidation(address borrower, uint256[] closureAmounts) external
```

#### Parameters

| Name           | Type       | Description                                                                                                                                                            |
| -------------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| borrower       | address    | The address of the borrower                                                                                                                                            |
| closureAmounts | uint256\[] | An array specifying the amounts of Term Repo exposure the liquidator proposes to cover in liquidation; an amount is required to be specified for each collateral token |

### batchLiquidationWithRepoToken

```solidity
function batchLiquidationWithRepoToken(address borrower, uint256[] closureRepoTokenAmounts) external
```

#### Parameters

| Name                    | Type       | Description                                                                                                                                                                                 |
| ----------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| borrower                | address    | The address of the borrower                                                                                                                                                                 |
| closureRepoTokenAmounts | uint256\[] | An array specifying the amounts of Term Repo Tokens the liquidator proposes to cover borrower repo exposure in liquidation; an amount is required to be specified for each collateral token |

### batchDefault

```solidity
function batchDefault(address borrower, uint256[] closureAmounts) external
```

#### Parameters

| Name           | Type       | Description                                                                                                                                                            |
| -------------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| borrower       | address    | The address of the borrower                                                                                                                                            |
| closureAmounts | uint256\[] | An array specifying the amounts of Term Repo exposure the liquidator proposes to cover in liquidation; an amount is required to be specified for each collateral token |

### calculateMintableExposure

```solidity
function calculateMintableExposure(address collateralToken, uint256 amountToLock) external view returns (struct ExponentialNoError.Exp)
```

#### Parameters

| Name            | Type    | Description                                   |
| --------------- | ------- | --------------------------------------------- |
| collateralToken | address | The collateral token address of tokens locked |
| amountToLock    | uint256 | The amount of collateral tokens to lock       |

### getCollateralBalances

```solidity
function getCollateralBalances(address borrower) external view returns (address[], uint256[])
```

#### Parameters

| Name     | Type    | Description                 |
| -------- | ------- | --------------------------- |
| borrower | address | The address of the borrower |

#### Return Values

| Name | Type       | Description                                                     |
| ---- | ---------- | --------------------------------------------------------------- |
| \[0] | address\[] | An array of collateral token addresses                          |
| \[1] | uint256\[] | An array collateral token balances locked on behalf of borrower |

### getCollateralBalance

```solidity
function getCollateralBalance(address borrower, address collateralToken) external view returns (uint256)
```

#### Parameters

| Name            | Type    | Description                           |
| --------------- | ------- | ------------------------------------- |
| borrower        | address | The address of the borrower           |
| collateralToken | address | The collateral token address to query |

#### Return Values

| Name | Type    | Description                                                        |
| ---- | ------- | ------------------------------------------------------------------ |
| \[0] | uint256 | uint256 The amount of collateralToken locked on behalf of borrower |

### encumberedCollateralRemaining

```solidity
function encumberedCollateralRemaining() external view returns (bool)
```

#### Return Values

| Name | Type | Description                                                                |
| ---- | ---- | -------------------------------------------------------------------------- |
| \[0] | bool | bool A boolean that tests whether any encumbered collateral remains locked |

### auctionLockCollateral

```solidity
function auctionLockCollateral(address bidder, address collateralToken, uint256 amount) external
```

#### Parameters

| Name            | Type    | Description                                       |
| --------------- | ------- | ------------------------------------------------- |
| bidder          | address | The bidder's address                              |
| collateralToken | address | The address of the token to be used as collateral |
| amount          | uint256 | The amount of the token to lock                   |

### auctionUnlockCollateral

```solidity
function auctionUnlockCollateral(address bidder, address collateralToken, uint256 amount) external
```

#### Parameters

| Name            | Type    | Description                                 |
| --------------- | ------- | ------------------------------------------- |
| bidder          | address | The bidder's address                        |
| collateralToken | address | The address of the token used as collateral |
| amount          | uint256 | The amount of collateral tokens to unlock   |

### acceptRolloverCollateral

```solidity
function acceptRolloverCollateral(address borrower, address collateralToken, uint256 amount) external
```

#### Parameters

| Name            | Type    | Description                             |
| --------------- | ------- | --------------------------------------- |
| borrower        | address | The address of the borrower             |
| collateralToken | address | The address of a collateral token       |
| amount          | uint256 | The amount of collateral tokens to lock |

### transferRolloverCollateral

```solidity
function transferRolloverCollateral(address borrower, uint256 rolloverProportion, address rolloverTermRepoLocker) external returns (address[], uint256[])
```

#### Parameters

| Name                   | Type    | Description                                                                                       |
| ---------------------- | ------- | ------------------------------------------------------------------------------------------------- |
| borrower               | address | The borrower's address                                                                            |
| rolloverProportion     | uint256 | The proportion of the collateral to be unlocked, equal to the proportion of the collateral repaid |
| rolloverTermRepoLocker | address | The address of the new TermRepoLocker contract to roll into                                       |

#### Return Values

| Name | Type       | Description                                                                                                    |
| ---- | ---------- | -------------------------------------------------------------------------------------------------------------- |
| \[0] | address\[] | An array representing a list of accepted collateral token addresses                                            |
| \[1] | uint256\[] | An array containing the amount of collateral tokens to pairoff and transfer to new TermRepoLocker to roll into |

### approveRolloverAuction

```solidity
function approveRolloverAuction(address rolloverAuction) external
```

#### Parameters

| Name            | Type    | Description                         |
| --------------- | ------- | ----------------------------------- |
| rolloverAuction | address | The address of the rollover auction |

### unlockCollateralOnRepurchase

```solidity
function unlockCollateralOnRepurchase(address borrower) external
```

#### Parameters

| Name     | Type    | Description                 |
| -------- | ------- | --------------------------- |
| borrower | address | The address of the borrower |

### journalBidCollateralToCollateralManager

```solidity
function journalBidCollateralToCollateralManager(address borrower, address[] collateralTokenAddresses, uint256[] collateralTokenAmounts) external
```

#### Parameters

| Name                     | Type       | Description                 |
| ------------------------ | ---------- | --------------------------- |
| borrower                 | address    | The address of the borrower |
| collateralTokenAddresses | address\[] | Collateral token addresses  |
| collateralTokenAmounts   | uint256\[] | Collateral token amounts    |

### mintOpenExposureLockCollateral

```solidity
function mintOpenExposureLockCollateral(address borrower, address collateralToken, uint256 amount) external
```

#### Parameters

| Name            | Type    | Description                 |
| --------------- | ------- | --------------------------- |
| borrower        | address | The address of the borrower |
| collateralToken | address | Collateral token addresse   |
| amount          | uint256 | Collateral token amount     |

### reopenToNewAuction

```solidity
function reopenToNewAuction(struct TermAuctionGroup termAuctionGroup) external
```

#### Parameters

| Name             | Type                    | Description                   |
| ---------------- | ----------------------- | ----------------------------- |
| termAuctionGroup | struct TermAuctionGroup | A struct of auction contracts |

### pauseLiquidations

```solidity
function pauseLiquidations() external
```

### unpauseLiquidations

```solidity
function unpauseLiquidations() external
```

### isBorrowerInShortfall

```solidity
function isBorrowerInShortfall(address borrower) public view returns (bool)
```

#### Parameters

| Name     | Type    | Description                 |
| -------- | ------- | --------------------------- |
| borrower | address | The address of the borrower |

#### Return Values

| Name | Type | Description                                                                  |
| ---- | ---- | ---------------------------------------------------------------------------- |
| \[0] | bool | Boolean testing whether the given borrower is in shortfall or margin deficit |

### getCollateralMarketValue

```solidity
function getCollateralMarketValue(address borrower) public view returns (uint256)
```

#### Parameters

| Name     | Type    | Description                 |
| -------- | ------- | --------------------------- |
| borrower | address | The address of the borrower |

#### Return Values

| Name | Type    | Description                                                         |
| ---- | ------- | ------------------------------------------------------------------- |
| \[0] | uint256 | The market value of borrower's locked collateral denominated in USD |

### \_lockCollateral

```solidity
function _lockCollateral(address borrower, address collateralToken, uint256 amount) internal
```

### \_unlockCollateral

```solidity
function _unlockCollateral(address borrower, address collateralToken, uint256 amount, bool decrementEncumberedCollateral) internal
```

### \_partialUnlockCollateral

```solidity
function _partialUnlockCollateral(address borrower, uint256 unlockProportion, address destinationwallet) internal returns (uint256[])
```

### \_validateBatchLiquidationForFullLiquidation

```solidity
function _validateBatchLiquidationForFullLiquidation(address borrower, address liquidator, uint256[] closureTokenAmounts) internal returns (bool)
```

*A helper function to validate various conditions required to liquidate*

#### Return Values

| Name | Type | Description                                                           |
| ---- | ---- | --------------------------------------------------------------------- |
| \[0] | bool | A boolean for whether borrower position eligible for full liquidation |

### \_unencumberRemainingBorrowerCollateralOnZeroObligation

```solidity
function _unencumberRemainingBorrowerCollateralOnZeroObligation(address borrower) internal
```

### \_withinNetExposureCapOnLiquidation

```solidity
function _withinNetExposureCapOnLiquidation(address borrower) internal view returns (bool)
```

### \_collateralSeizureAmounts

```solidity
function _collateralSeizureAmounts(uint256 amountToCover_, address collateralToken) internal view returns (uint256, uint256)
```

*returns total amount of collateral seized in liquidation and the amount of that total going protocol*

### \_transferLiquidationCollateral

```solidity
function _transferLiquidationCollateral(address borrower, address liquidator, address collateralAddress, uint256 closureAmount, uint256 collateralSeizureAmount, uint256 collateralSeizureProtocolShare, bool isDefault) internal
```

*A helper function to transfer tokens and update relevant state variables and mappings*

### \_isAcceptedCollateralToken

```solidity
function _isAcceptedCollateralToken(address token_) internal view returns (bool)
```

### \_usdValueOfBalances

```solidity
function _usdValueOfBalances(mapping(address => uint256) _tokenBalances) internal view returns (uint256)
```

### \_authorizeUpgrade

```solidity
function _authorizeUpgrade(address impl) internal
```

*required override by the OpenZeppelin UUPS module*

#### Parameters

| Name | Type    | Description                        |
| ---- | ------- | ---------------------------------- |
| impl | address | new impl address for proxy upgrade |