Borrowing

This page covers Borrow Lifecycle Using Order Books and Repay/Collateral Management using Strategy.

Core Contracts & Integration

(Borrowing + Repayment + Collateral Management + Examples)

Developers primarily interact with:

• Orderbook → for borrowing

• Strategies → for repayment, collateral, and ERC-4626 actions

This page merges conceptual flows, function, and real Solidity examples.

---

1. Borrowing Lifecycle

Borrowing in Avon:

• Uses global liquidity, aggregated from all strategies

• Opens isolated debt positions inside each strategy that participates

• Returns a single aggregated loan amount to the borrower

Borrow Steps

1. Borrower provides collateral

2. Calls matchMarketBorrowOrder on the orderbook

3. Orderbook selects best strategy quotes

4. Collateral gets routed into strategies

5. Strategies open debt positions

6. Borrower receives loan tokens

Only the orderbook initiates borrowing. Only strategies hold positions.

---

2. Borrow Flow Diagram

Borrower Contract
      │
      │ 1) Approve collateral
      ▼
Orderbook.matchMarketBorrowOrder()
      │
      ├──> Select best strategy quotes (rate → LTV → time)
      │
      ├──> Route collateral into multiple strategies
      │
      ├──> Each strategy: open isolated debt positions
      │
      └──> Return aggregated loan amount

---

3. Borrow (Orderbook)

Function

function matchMarketBorrowOrder(
    uint256 borrowAmount,
    uint256 minExpected,
    uint256 collateralBuffer,
    uint256 maxRate,
    uint256 maxLtv
) external;

Parameter Definitions

Parameter	Description
borrowAmount	Requested loan amount
minExpected	Minimum acceptable output (slippage check)
collateralBuffer	Required margin above strategy LTV
maxRate	Optional rate ceiling (0 disables)
maxLtv	Optional LTV ceiling (0 disables)

Execution Rules

• Matches up to 30 best strategy quotes

• Routes collateral into participating strategies

• Reverts if constraints violated

• Returns aggregated loan tokens

---

4. Repayment Lifecycle

Because strategies are isolated, repayment must happen per-strategy.

Repay Steps

1. Borrower approves strategy

2. Calls repay()

3. Strategy reduces debt

4. Strategy unlocks proportional collateral

5. If strategy debt becomes zero → all collateral withdrawable

---

5. Repayment (Strategy)

function repay(address borrower, uint256 amount) external;

Rules:

• Partial or full repayment

• If amount == type(uint256).max, strategy repays full debt

• Improves borrower health

• Unlocks collateral proportionally

---

6. Collateral Management (Strategy)

Deposit Collateral

function depositCollateral(address user, uint256 amount) external;

Withdraw Collateral

function withdrawCollateral(address user, uint256 amount) external;

Rules:

• Must maintain health ≥ LLTV

• Cannot withdraw collateral securing active debt

• Required collateral is computed per-strategy

---

7. Reading Position Data (Strategies)

strategy.debtOf(user);
strategy.collateralOf(user);
strategy.healthOf(user);

Borrowers must query each strategy independently.

---

8. Borrow + Repay (Solidity Example)

Borrow Function

function borrowExample(
    uint256 collateralAmt,
    uint256 borrowAmt
) external {
    // 1. Receive collateral
    collateral.transferFrom(msg.sender, address(this), collateralAmt);
    collateral.approve(address(orderbook), collateralAmt);

    // 2. Execute borrow
    orderbook.matchMarketBorrowOrder(
        borrowAmt,
        borrowAmt * 99 / 100, // accept 1% slippage
        0.01e18,               // 1% collateral buffer
        0,                     // no max rate
        0                      // no LTV ceiling
    );

    // 3. Transfer borrowed tokens to user
    loan.transfer(msg.sender, loan.balanceOf(address(this)));
}

---

Repay Function

function repayExample(address strategy, uint256 amount) external {
    loan.transferFrom(msg.sender, address(this), amount);
    loan.approve(strategy, amount);

    IStrategy(strategy).repay(msg.sender, amount);
}

---

9. Example: Leverage Loop

Borrow → swap → redeposit → borrow again:

borrow(...);
swap(...);
strategy.depositCollateral(...);
borrow(...);

Avon does not restrict leverage logic — strategies remain isolated and composable.

---

10. Example: Frontend Borrow Quote

Frontends may:

1. Read all strategies under an orderbook

2. Retrieve their tick quotes

3. Sort them

4. Estimate borrow results client-side

5. Call matchMarketBorrowOrder as final action

The onchain result will always follow the same deterministic logic.

---

This completes the strategy model. Next page covers data access, security, and full reference.