cyotee/resupply-lending

Resupply Lending System

The lending system is built around ResupplyPair contracts that enable users to deposit ERC4626 vault tokens as collateral and borrow reUSD stablecoins.

ResupplyPair Contract

Located at /src/protocol/ResupplyPair.sol with core logic in /src/protocol/pair/ResupplyPairCore.sol.

State Structure

// Collateral tracking
mapping(address => uint256) public userCollateralBalance;  // User → collateral amount
uint256 public totalCollateral;

// Borrow tracking (share-based for interest accrual)
mapping(address => uint256) public userBorrowShares;       // User → borrow shares
uint256 public totalBorrowShares;
uint256 public totalBorrowAmount;                          // Actual debt amount

// Configuration
address public collateralContract;    // ERC4626 vault token
address public asset;                 // reUSD stablecoin
uint256 public maxLTV;                // e.g., 95_000 (95% with LTV_PRECISION)
uint256 public liquidationFee;        // e.g., 5_000 (5%)
uint256 public borrowLimit;           // Maximum borrowable amount

Core Operations

Adding Collateral

Deposit ERC4626 vault tokens as collateral:

function addCollateralVault(uint256 _collateralAmount, address _borrower) external {
    // Transfer vault tokens from caller
    IERC20(collateralContract).safeTransferFrom(msg.sender, address(this), _collateralAmount);

    // Update balances
    userCollateralBalance[_borrower] += _collateralAmount;
    totalCollateral += _collateralAmount;
}

Removing Collateral

Withdraw collateral (must maintain health factor):

function removeCollateralVault(uint256 _collateralAmount, address _receiver) external {
    // Update balances
    userCollateralBalance[msg.sender] -= _collateralAmount;
    totalCollateral -= _collateralAmount;

    // Verify position remains healthy
    require(_isSolvent(msg.sender), "Position unhealthy");

    // Transfer vault tokens
    IERC20(collateralContract).safeTransfer(_receiver, _collateralAmount);
}

Borrowing

Mint reUSD against deposited collateral:

function borrow(
    uint256 _borrowAmount,
    uint256 _underlyingAmount,  // For minting to underlying protocols
    address _receiver
) external returns (uint256 shares) {
    // Accrue interest first
    _accrue();

    // Calculate borrow shares
    shares = totalBorrowShares == 0
        ? _borrowAmount
        : (_borrowAmount * totalBorrowShares) / totalBorrowAmount;

    // Update state
    userBorrowShares[msg.sender] += shares;
    totalBorrowShares += shares;
    totalBorrowAmount += _borrowAmount;

    // Verify solvency
    require(_isSolvent(msg.sender), "Position unhealthy");

    // Mint reUSD
    IStablecoin(asset).mint(_receiver, _borrowAmount);
}

Repaying

Burn reUSD to reduce debt:

function repay(uint256 _shares, address _borrower) external returns (uint256 amountRepaid) {
    _accrue();

    // Calculate amount from shares
    amountRepaid = (_shares * totalBorrowAmount) / totalBorrowShares;

    // Update state
    userBorrowShares[_borrower] -= _shares;
    totalBorrowShares -= _shares;
    totalBorrowAmount -= amountRepaid;

    // Burn reUSD from caller
    IStablecoin(asset).burn(msg.sender, amountRepaid);
}

Interest Rate Model

Interest accrues per-second based on utilization:

// InterestRateCalculator interface
function getNewRate(
    uint256 _currentRate,
    uint256 _utilization,    // totalBorrow / borrowLimit
    uint256 _deltaTime
) external view returns (uint256 newRate);

Utilization calculation:

uint256 utilization = (totalBorrowAmount * 1e18) / borrowLimit;

Interest accrual:

function _accrue() internal {
    uint256 deltaTime = block.timestamp - lastAccrueTime;
    uint256 interestEarned = (totalBorrowAmount * currentRate * deltaTime) / RATE_PRECISION;
    totalBorrowAmount += interestEarned;
    lastAccrueTime = block.timestamp;
}

Collateral Valuation

The oracle converts vault tokens to asset value:

// BasicVaultOracle
function getPrice(address collateral) external view returns (uint256) {
    // Get ERC4626 exchange rate
    uint256 assetsPerShare = IERC4626(collateral).convertToAssets(1e18);
    return assetsPerShare;
}

Solvency check:

function _isSolvent(address _borrower) internal view returns (bool) {
    uint256 collateralValue = (userCollateralBalance[_borrower] * oracle.getPrice(collateralContract)) / EXCHANGE_PRECISION;
    uint256 borrowValue = (userBorrowShares[_borrower] * totalBorrowAmount) / totalBorrowShares;

    // LTV check: borrowValue <= collateralValue * maxLTV / LTV_PRECISION
    return borrowValue * LTV_PRECISION <= collateralValue * maxLTV;
}

Advanced Operations

Leveraged Positions

Increase exposure in a single transaction:

function leveragedPosition(
    address _swapperAddress,
    uint256 _borrowAmount,
    uint256 _minCollateralReceived,
    bytes calldata _swapData
) external returns (uint256 collateralReceived);

Flow:

1. Borrow reUSD
2. Swap reUSD → collateral via swapper
3. Add swapped collateral to position

Repay with Collateral

Reduce debt using collateral:

function repayWithCollateral(
    address _swapperAddress,
    uint256 _collateralToSwap,
    uint256 _minAssetReceived,
    bytes calldata _swapData
) external returns (uint256 assetReceived);

Flow:

1. Remove collateral
2. Swap collateral → reUSD via swapper
3. Repay debt with swapped reUSD

Pair Configuration

Pairs are deployed with specific parameters:

struct ConfigData {
    address oracle;              // Price oracle
    address rateCalculator;      // Interest rate model
    uint256 maxLTV;              // e.g., 95_000 (95%)
    uint256 initialBorrowLimit;  // e.g., 1_000_000e18
    uint256 liquidationFee;      // e.g., 5_000 (5%)
    uint256 mintFee;             // Borrow fee
    uint256 protocolRedemptionFee;
}

Reward Distribution

Pairs distribute multiple reward tokens to borrowers:

// Claim rewards
function getReward(address _account, address _forwardTo) external;

// Reward tokens can include: RSUP, CRV, CVX

Additional Resources

For the complete IResupplyPair interface with all functions and events, see references/pair-interface.md.