# 'Interest Accrued' contract flow

{% hint style="info" %}
Prior advised reading and definitions: '[finance view](/developer-material/v1-developer-material/functions-and-methods/interestratecredit.sol/accrued-interest-calculation.md)' of how accrued interest is calculated in our contracts.

The term 'InterestAccrued' is the Interest owed by a Borrower but not yet repaid to the Line of Credit contract and made available for withdrawal by a Lender.
{% endhint %}

Steps 2 - 5 below deal with calculating calculating accrued interest in order to update`InterestAccrued`for a single credit position id as either a direct result of the external function request (step 1) or indirectly as a result of another action such as a change in the balance on a credit line id.

Step 1 is an external function that updates the accrued interest for **all** credit position ids in a Line of Credit facility

<details>

<summary>1) <code>accrueInterest()</code> in LineOfCredit.sol</summary>

This external function *loops over all credit position ids* and calls related internal functions during which InterestRateCredit.sol is called with the id data and then i`nterestAccrued` is updated.

```solidity
 function accrueInterest() external override returns(bool) {
        uint256 len = ids.length;
        bytes32 id;
        for (uint256 i; i < len; ++i) {
          id = ids[i];
          Credit memory credit = credits[id];
          credits[id] = _accrue(credit, id);
          
        }
        
        return true;
    }
```

</details>

<details>

<summary>2) <code>_accrue</code> in LineOfCredit.sol</summary>

This internal function runs within step 1 or otherwise at any time the balance on a credit line changes or the interest rates are changed by mutual consent between a Borrower and a Lender.

```solidity
    function _accrue(Credit memory credit, bytes32 id) internal returns (Credit memory) {
        if (!credit.isOpen) {
            return credit;
        }
        return CreditLib.accrue(credit, id, address(interestRate));
    }
```

</details>

<details>

<summary>3) <code>accrue()</code> in CreditLib.sol</summary>

Called by `_accrue()` in step 2 above any time the balance on a credit position changes or the interest rates are changed by mutual consent between a Borrower and a Lender.

It returns an updated token denominated `interestAccrued` for a single id.

It does so by adding the new amount of interest to accrue to the prior amount of `interestAccrued` recorded.

This new amount of interest to accrue is called `accruedToken` and is calculated in InterestRateCredit.sol (see steps 4 and 5 below).

```solidity
function accrue(
        ILineOfCredit.Credit memory credit,
        bytes32 id,
        address interest
    ) public returns (ILineOfCredit.Credit memory) {
        unchecked {
            // interest will almost always be less than deposit
            // low risk of overflow unless extremely high interest rate

            // get token demoninated interest accrued
            uint256 accruedToken = IInterestRateCredit(interest).accrueInterest(id, credit.principal, credit.deposit);

            // update credit line balance
            credit.interestAccrued += accruedToken;

            emit InterestAccrued(id, accruedToken);
            return credit;
        }
    }
}
```

</details>

<details>

<summary>4) <code>accrueInterest()</code> in InterestRateCredit.sol</summary>

This is the main function for calculating the amount by which `interestAccrued` should be updated for *a single credit position id*, callable indirectly by `_accrue()` in LineOfCredit.sol (step 2 above) and then subsequently directly by `accrue()` in CreditLib.sol (step 3)

```solidity
function accrueInterest(
        bytes32 id,
        uint256 drawnBalance,
        uint256 facilityBalance
    ) external override onlyLineContract returns (uint256) {
        return _accrueInterest(id, drawnBalance, facilityBalance);
    }
```

</details>

<details>

<summary>5) <code>_accrueInterest() and _calculateInterestOwed</code> in InterestRateCredit.sol</summary>

Finally, this is where the amount by which `interestAccrued should be updated` is calculated per credit position id.

[For a detailed explanation of the formula, please see here.](/developer-material/v1-developer-material/functions-and-methods/interestratecredit.sol/accrued-interest-calculation.md)

```solidity
 function _accrueInterest(bytes32 id, uint256 drawnBalance, uint256 facilityBalance) internal returns (uint256) {
        Rate memory rate = rates[id];
        uint256 timespan = block.timestamp - rate.lastAccrued;
        // update last timestamp in storage
        rates[id].lastAccrued = block.timestamp;

        return (_calculateInterestOwed(rate.dRate, drawnBalance, timespan) +
            _calculateInterestOwed(rate.fRate, (facilityBalance - drawnBalance), timespan));
    }
 
 function _calculateInterestOwed(
        uint256 bpsRate,
        uint256 balance,
        uint256 timespan
   ) internal pure returns (uint256) {
        return (bpsRate * balance * timespan) / INTEREST_DENOMINATOR;
   }
```

</details>

*last updated Dec 29 2022*


---

# 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.creditcoop.xyz/developer-material/v1-developer-material/functions-and-methods/interestratecredit.sol/interest-accrued-contract-flow.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.