compound-patterns

# Compound V3 (Comet) Integration ## Architecture Compound V3 (Comet) is a fundamentally different design from V2. Each Comet deployment is a single-asset market — one base asset (e.g., USDC) with multiple collateral assets. There are no cTokens; the Comet contract itself tracks balances. | Component | Description | |-----------|-------------| | `Comet` | Core market contract (one per base asset) | | `CometRewards` | Claims COMP rewards for suppliers/borrowers | | `Configurator` | Governance-controlled parameter updates | | `BulkerV2` | Batch operations including native ETH wrapping | ## Supply / Withdraw Base Asset ```solidity import {IComet} from "./interfaces/IComet.sol"; IComet comet = IComet(COMET_USDC); // Supply base asset (earn interest) IERC20(usdc).approve(address(comet), amount); comet.supply(usdc, amount); // Withdraw base asset comet.withdraw(usdc, amount); // Use type(uint256).max for full withdrawal ``` ## Collateral Management ```solidity // Supply collateral (does NOT earn interest) IERC20(weth).approve(address(comet), amount); comet.supply(weth, amount); // Withdraw collateral comet.withdraw(weth, amount); // Check collateral balance uint256 collateral = comet.collateralBalanceOf(account, weth); ``` ## Borrowing ```solidity // Borrow base asset against collateral // Simply withdraw more base than you supplied comet.withdraw(usdc, borrowAmount); // Repay borrow — supply base asset IERC20(usdc).approve(address(comet), repayAmount); comet.supply(usdc, repayAmount); ``` ## Account State ```solidity // Positive = supplying, negative = borrowing int256 balance = comet.balanceOf(account); // Check if account is liquidatable bool isLiquidatable = comet.isLiquidatable(account); // Get borrow balance (always positive) uint256 borrowBalance = comet.borrowBalanceOf(account); // Check if an action is allowed bool canBorrow = comet.isBorrowCollateralized(account); ``` ## Liquidation via Absorb ```solidity // Compound V3 uses "absorb" instead of traditional liquidation // Anyone can call absorb on an underwater account address[] memory accounts = new address[](1); accounts[0] = underwaterAccount; comet.absorb(msg.sender, accounts); // After absorb, protocol holds the collateral // Buy collateral at a discount through the Comet contract uint256 reserves = comet.getCollateralReserves(weth); comet.buyCollateral(weth, minAmount, baseAmount, recipient); ``` ## Interest Rate Model Compound V3 uses a kinked rate model: ``` if utilization <= kink: borrowRate = baseBorrowRate + (utilization * borrowRateSlopeLow) else: borrowRate = baseBorrowRate + (kink * borrowRateSlopeLow) + ((utilization - kink) * borrowRateSlopeHigh) ``` ```solidity uint256 utilization = comet.getUtilization(); uint256 supplyRate = comet.getSupplyRate(utilization); uint256 borrowRate = comet.getBorrowRate(utilization); // Rates are per-second, scaled by 1e18 // APR = rate * SECONDS_PER_YEAR ``` ## COMP Rewards ```solidity import {ICometRewards} from "./interfaces/ICometRewards.sol"; ICometRewards rewards = ICometRewards(COMET_REWARDS); // Claim COMP rewards rewards.claim(cometAddress, account, true); // true = accrue first // Check pending rewards ICometRewards.RewardOwed memory owed = rewards.getRewardOwed(cometAddress, account); // owed.token = COMP address, owed.owed = claimable amount ``` ## Safe Integration Pattern ```solidity contract CometIntegration { IComet public immutable comet; address public immutable baseToken; constructor(address _comet) { comet = IComet(_comet); baseToken = IComet(_comet).baseToken(); } function supplyBase(uint256 amount) external { IERC20(baseToken).transferFrom(msg.sender, address(this), amount); IERC20(baseToken).approve(address(comet), amount); comet.supply(baseToken, amount); } function supplyCollateral(address asset, uint256 amount) external { IERC20(asset).transferFrom(msg.sender, address(this), amount); IERC20(asset).approve(address(comet), amount); comet.supply(asset, amount); } function borrow(uint256 amount) external { comet.withdraw(baseToken, amount); IERC20(baseToken).transfer(msg.sender, amount); } function isHealthy() external view returns (bool) { return !comet.isLiquidatable(address(this)); } } ``` ## Checklist - [ ] Differentiate base asset operations (earn interest) from collateral (no interest) - [ ] Use `isLiquidatable()` to monitor health before withdrawals - [ ] Use `BulkerV2` for batching operations and native ETH support - [ ] Approve exact amounts to Comet before supply - [ ] Account for per-second interest accrual in balance checks - [ ] Test absorb + buyCollateral flow for liquidation bots - [ ] Check collateral factors and supply caps via `getAssetInfo()`