// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.24; import "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; import "./Interfaces/IStabilityPool.sol"; import "./Interfaces/IAddressesRegistry.sol"; import "./Interfaces/IStabilityPoolEvents.sol"; import "./Interfaces/ITroveManager.sol"; import "./Interfaces/IBoldToken.sol"; import "./Dependencies/LiquityBase.sol"; /* * The Stability Pool holds Bold tokens deposited by Stability Pool depositors. * * When a trove is liquidated, then depending on system conditions, some of its Bold debt gets offset with * Bold in the Stability Pool: that is, the offset debt evaporates, and an equal amount of Bold tokens in the Stability Pool is burned. * * Thus, a liquidation causes each depositor to receive a Bold loss, in proportion to their deposit as a share of total deposits. * They also receive an Coll gain, as the collateral of the liquidated trove is distributed among Stability depositors, * in the same proportion. * * When a liquidation occurs, it depletes every deposit by the same fraction: for example, a liquidation that depletes 40% * of the total Bold in the Stability Pool, depletes 40% of each deposit. * * A deposit that has experienced a series of liquidations is termed a "compounded deposit": each liquidation depletes the deposit, * multiplying it by some factor in range ]0,1[ * * * --- IMPLEMENTATION --- * * We use a highly scalable method of tracking deposits and Coll gains that has O(1) complexity. * * When a liquidation occurs, rather than updating each depositor's deposit and Coll gain, we simply update two state variables: * a product P, and a sum S. * * A mathematical manipulation allows us to factor out the initial deposit, and accurately track all depositors' compounded deposits * and accumulated Coll gains over time, as liquidations occur, using just these two variables P and S. When depositors join the * Stability Pool, they get a snapshot of the latest P and S: P_t and S_t, respectively. * * The formula for a depositor's accumulated Coll gain is derived here: * https://github.com/liquity/dev/blob/main/papers/Scalable_Reward_Distribution_with_Compounding_Stakes.pdf * * For a given deposit d_t, the ratio P/P_t tells us the factor by which a deposit has decreased since it joined the Stability Pool, * and the term d_t * (S - S_t)/P_t gives us the deposit's total accumulated Coll gain. * * Each liquidation updates the product P and sum S. After a series of liquidations, a compounded deposit and corresponding Coll gain * can be calculated using the initial deposit, the depositor’s snapshots of P and S, and the latest values of P and S. * * Any time a depositor updates their deposit (withdrawal, top-up) their accumulated Coll gain is paid out, their new deposit is recorded * (based on their latest compounded deposit and modified by the withdrawal/top-up), and they receive new snapshots of the latest P and S. * Essentially, they make a fresh deposit that overwrites the old one. * * * --- SCALE FACTOR --- * * Since P is a running product in range ]0,1] that is always-decreasing, it should never reach 0 when multiplied by a number in range ]0,1[. * Unfortunately, Solidity floor division always reaches 0, sooner or later. * * A series of liquidations that nearly empty the Pool (and thus each multiply P by a very small number in range ]0,1[ ) may push P * to its 36 digit decimal limit, and round it to 0, when in fact the Pool hasn't been emptied: this would break deposit tracking. * * P is stored at 36-digit precision as a uint. That is, a value of "1" is represented by a value of 1e36 in the code. * * So, to track P accurately, we use a scale factor: if a liquidation would cause P to decrease below 1e27, * we first multiply P by 1e9, and increment a currentScale factor by 1. * * The added benefit of using 1e9 for the scale factor that it ensures negligible precision loss close to the * scale boundary: when P is at its minimum value of 1e27, the relative precision loss in P due to floor division is only on the * order of 1e-27. * * --- MIN BOLD IN SP --- * * Once totalBoldDeposits has become >= MIN_BOLD_IN_SP, a liquidation may never fully empty the Pool - a minimum of 1 BOLD remains in the SP at all times thereafter. * This is enforced for liquidations in TroveManager.batchLiquidateTroves, and for withdrawals in StabilityPool.withdrawFromSP. * As such, it is impossible to empty the Stability Pool via liquidations, and P can never become 0. * * --- TRACKING DEPOSIT OVER SCALE CHANGES --- * * When a deposit is made, it gets a snapshot of the currentScale. * * When calculating a compounded deposit, we compare the current scale to the deposit's scale snapshot. If they're equal, the compounded deposit is given by d_t * P/P_t. * If it spans one scale change, it is given by d_t * P/(P_t * 1e9). * * --- TRACKING DEPOSITOR'S COLL GAIN OVER SCALE CHANGES --- * * We calculate the depositor's accumulated Coll gain for the scale at which they made the deposit, using the Coll gain formula: * e_1 = d_t * (S - S_t) / P_t * * and also for the scale after, taking care to divide the latter by a factor of 1e9: * e_2 = d_t * S / (P_t * 1e9) * * The gain in the second scale will be full, as the starting point was in the previous scale, thus no need to subtract anything. * The deposit therefore was present for reward events from the beginning of that second scale. * * S_i-S_t + S_{i+1} * .<--------.------------> * . . * . S_i . S_{i+1} * <--.-------->.<-----------> * S_t. . * <->. . * t . * |---+---------|-------------|-----... * i i+1 * * The sum of (e_1 + e_2) captures the depositor's total accumulated Coll gain, handling the case where their * deposit spanned one scale change. * * --- UPDATING P WHEN A LIQUIDATION OCCURS --- * * Please see the implementation spec in the proof document, which closely follows on from the compounded deposit / Coll gain derivations: * https://github.com/liquity/liquity/blob/master/papers/Scalable_Reward_Distribution_with_Compounding_Stakes.pdf * * */ contract StabilityPool is LiquityBase, IStabilityPool, IStabilityPoolEvents { using SafeERC20 for IERC20; string public constant NAME = "StabilityPool"; IERC20 public immutable collToken; ITroveManager public immutable troveManager; IBoldToken public immutable boldToken; uint256 internal collBalance; // deposited coll tracker // Tracker for Bold held in the pool. Changes when users deposit/withdraw, and when Trove debt is offset. uint256 internal totalBoldDeposits; // Total remaining Bold yield gains (from Trove interest mints) held by SP, and not yet paid out to depositors // From the contract's perspective, this is a write-only variable. uint256 internal yieldGainsOwed; // Total remaining Bold yield gains (from Trove interest mints) held by SP, not yet paid out to depositors, // and not accounted for because they were received when the total deposits were too small uint256 internal yieldGainsPending; // --- Data structures --- struct Deposit { uint256 initialValue; } struct Snapshots { uint256 S; // Coll reward sum liqs uint256 P; uint256 B; // Bold reward sum from minted interest uint256 scale; } mapping(address => Deposit) public deposits; // depositor address -> Deposit struct mapping(address => Snapshots) public depositSnapshots; // depositor address -> snapshots struct mapping(address => uint256) public stashedColl; /* Product 'P': Running product by which to multiply an initial deposit, in order to find the current compounded deposit, * after a series of liquidations have occurred, each of which cancel some Bold debt with the deposit. * * During its lifetime, a deposit's value evolves from d_t to d_t * P / P_t , where P_t * is the snapshot of P taken at the instant the deposit was made. 18-digit decimal. */ uint256 public P = P_PRECISION; uint256 public constant P_PRECISION = 1e36; // A scale change will happen if P decreases by a factor of at least this much uint256 public constant SCALE_FACTOR = 1e9; // Highest power `SCALE_FACTOR` can be raised to without overflow uint256 public constant MAX_SCALE_FACTOR_EXPONENT = 8; // The number of scale changes after which an untouched deposit stops receiving yield / coll gains uint256 public constant SCALE_SPAN = 2; // Each time the scale of P shifts by SCALE_FACTOR, the scale is incremented by 1 uint256 public currentScale; /* Coll Gain sum 'S': During its lifetime, each deposit d_t earns an Coll gain of ( d_t * [S - S_t] )/P_t, where S_t * is the depositor's snapshot of S taken at the time t when the deposit was made. * * The 'S' sums are stored in a mapping (scale => sum). * - The mapping records the sum S at different scales. */ mapping(uint256 => uint256) public scaleToS; mapping(uint256 => uint256) public scaleToB; // --- Events --- event TroveManagerAddressChanged(address _newTroveManagerAddress); event BoldTokenAddressChanged(address _newBoldTokenAddress); constructor(IAddressesRegistry _addressesRegistry) LiquityBase(_addressesRegistry) { collToken = _addressesRegistry.collToken(); troveManager = _addressesRegistry.troveManager(); boldToken = _addressesRegistry.boldToken(); emit TroveManagerAddressChanged(address(troveManager)); emit BoldTokenAddressChanged(address(boldToken)); } // --- Getters for public variables. Required by IPool interface --- function getCollBalance() external view override returns (uint256) { return collBalance; } function getTotalBoldDeposits() external view override returns (uint256) { return totalBoldDeposits; } function getYieldGainsOwed() external view override returns (uint256) { return yieldGainsOwed; } function getYieldGainsPending() external view override returns (uint256) { return yieldGainsPending; } // --- External Depositor Functions --- /* provideToSP(): * - Calculates depositor's Coll gain * - Calculates the compounded deposit * - Increases deposit, and takes new snapshots of accumulators P and S * - Sends depositor's accumulated Coll gains to depositor */ function provideToSP(uint256 _topUp, bool _doClaim) external override { _requireNonZeroAmount(_topUp); activePool.mintAggInterest(); uint256 initialDeposit = deposits[msg.sender].initialValue; uint256 currentCollGain = getDepositorCollGain(msg.sender); uint256 currentYieldGain = getDepositorYieldGain(msg.sender); uint256 compoundedBoldDeposit = getCompoundedBoldDeposit(msg.sender); (uint256 keptYieldGain, uint256 yieldGainToSend) = _getYieldToKeepOrSend(currentYieldGain, _doClaim); uint256 newDeposit = compoundedBoldDeposit + _topUp + keptYieldGain; (uint256 newStashedColl, uint256 collToSend) = _getNewStashedCollAndCollToSend(msg.sender, currentCollGain, _doClaim); emit DepositOperation( msg.sender, Operation.provideToSP, initialDeposit - compoundedBoldDeposit, int256(_topUp), currentYieldGain, yieldGainToSend, currentCollGain, collToSend ); _updateDepositAndSnapshots(msg.sender, newDeposit, newStashedColl); boldToken.sendToPool(msg.sender, address(this), _topUp); _updateTotalBoldDeposits(_topUp + keptYieldGain, 0); _decreaseYieldGainsOwed(currentYieldGain); _sendBoldtoDepositor(msg.sender, yieldGainToSend); _sendCollGainToDepositor(collToSend); // If there were pending yields and with the new deposit we are reaching the threshold, let’s move the yield to owed _updateYieldRewardsSum(0); } function _getYieldToKeepOrSend(uint256 _currentYieldGain, bool _doClaim) internal pure returns (uint256, uint256) { uint256 yieldToKeep; uint256 yieldToSend; if (_doClaim) { yieldToKeep = 0; yieldToSend = _currentYieldGain; } else { yieldToKeep = _currentYieldGain; yieldToSend = 0; } return (yieldToKeep, yieldToSend); } /* withdrawFromSP(): * - Calculates depositor's Coll gain * - Calculates the compounded deposit * - Sends the requested BOLD withdrawal to depositor * - (If _amount > userDeposit, the user withdraws all of their compounded deposit) * - Decreases deposit by withdrawn amount and takes new snapshots of accumulators P and S */ function withdrawFromSP(uint256 _amount, bool _doClaim) external override { uint256 initialDeposit = deposits[msg.sender].initialValue; _requireUserHasDeposit(initialDeposit); activePool.mintAggInterest(); uint256 currentCollGain = getDepositorCollGain(msg.sender); uint256 currentYieldGain = getDepositorYieldGain(msg.sender); uint256 compoundedBoldDeposit = getCompoundedBoldDeposit(msg.sender); uint256 boldToWithdraw = LiquityMath._min(_amount, compoundedBoldDeposit); (uint256 keptYieldGain, uint256 yieldGainToSend) = _getYieldToKeepOrSend(currentYieldGain, _doClaim); uint256 newDeposit = compoundedBoldDeposit - boldToWithdraw + keptYieldGain; (uint256 newStashedColl, uint256 collToSend) = _getNewStashedCollAndCollToSend(msg.sender, currentCollGain, _doClaim); emit DepositOperation( msg.sender, Operation.withdrawFromSP, initialDeposit - compoundedBoldDeposit, -int256(boldToWithdraw), currentYieldGain, yieldGainToSend, currentCollGain, collToSend ); _updateDepositAndSnapshots(msg.sender, newDeposit, newStashedColl); _decreaseYieldGainsOwed(currentYieldGain); uint256 newTotalBoldDeposits = _updateTotalBoldDeposits(keptYieldGain, boldToWithdraw); _sendBoldtoDepositor(msg.sender, boldToWithdraw + yieldGainToSend); _sendCollGainToDepositor(collToSend); require(newTotalBoldDeposits >= MIN_BOLD_IN_SP, "Withdrawal must leave totalBoldDeposits >= MIN_BOLD_IN_SP"); } function _getNewStashedCollAndCollToSend(address _depositor, uint256 _currentCollGain, bool _doClaim) internal view returns (uint256 newStashedColl, uint256 collToSend) { if (_doClaim) { newStashedColl = 0; collToSend = stashedColl[_depositor] + _currentCollGain; } else { newStashedColl = stashedColl[_depositor] + _currentCollGain; collToSend = 0; } } // This function is only needed in the case a user has no deposit but still has remaining stashed Coll gains. function claimAllCollGains() external { _requireUserHasNoDeposit(msg.sender); activePool.mintAggInterest(); uint256 collToSend = stashedColl[msg.sender]; _requireNonZeroAmount(collToSend); stashedColl[msg.sender] = 0; emit DepositOperation(msg.sender, Operation.claimAllCollGains, 0, 0, 0, 0, 0, collToSend); emit DepositUpdated(msg.sender, 0, 0, 0, 0, 0, 0); _sendCollGainToDepositor(collToSend); } // --- BOLD reward functions --- function triggerBoldRewards(uint256 _boldYield) external { _requireCallerIsActivePool(); _updateYieldRewardsSum(_boldYield); } function _updateYieldRewardsSum(uint256 _newYield) internal { uint256 accumulatedYieldGains = yieldGainsPending + _newYield; if (accumulatedYieldGains == 0) return; // When total deposits is very small, B is not updated. In this case, the BOLD issued is held // until the total deposits reach 1 BOLD (remains in the balance of the SP). if (totalBoldDeposits < MIN_BOLD_IN_SP) { yieldGainsPending = accumulatedYieldGains; return; } yieldGainsOwed += accumulatedYieldGains; yieldGainsPending = 0; scaleToB[currentScale] += P * accumulatedYieldGains / totalBoldDeposits; emit B_Updated(scaleToB[currentScale], currentScale); } // --- Liquidation functions --- /* * Cancels out the specified debt against the Bold contained in the Stability Pool (as far as possible) * and transfers the Trove's Coll collateral from ActivePool to StabilityPool. * Only called by liquidation functions in the TroveManager. */ function offset(uint256 _debtToOffset, uint256 _collToAdd) external override { _requireCallerIsTroveManager(); scaleToS[currentScale] += P * _collToAdd / totalBoldDeposits; emit S_Updated(scaleToS[currentScale], currentScale); uint256 numerator = P * (totalBoldDeposits - _debtToOffset); uint256 newP = numerator / totalBoldDeposits; // For `P` to turn zero, `totalBoldDeposits` has to be greater than `P * (totalBoldDeposits - _debtToOffset)`. // - As the offset must leave at least 1 BOLD in the SP (MIN_BOLD_IN_SP), // the minimum value of `totalBoldDeposits - _debtToOffset` is `1e18` // - It can be shown that `P` is always in range [1e27, 1e36]. // Thus, to turn `P` zero, `totalBoldDeposits` has to be greater than `1e27 * 1e18`, // and the offset has to be (near) maximal. // In other words, there needs to be octillions of BOLD in the SP, which is unlikely to happen in practice. require(newP > 0, "P must never decrease to 0"); // Overflow analyisis of scaling up P: // We know that the resulting P is <= 1e36, and it's the result of dividing numerator by totalBoldDeposits. // Thus, numerator <= 1e36 * totalBoldDeposits, so unless totalBoldDeposits is septillions of BOLD, it won’t overflow. // That holds on every iteration as an upper bound. We multiply numerator by SCALE_FACTOR, // but numerator is by definition smaller than 1e36 * totalBoldDeposits / SCALE_FACTOR. while (newP < P_PRECISION / SCALE_FACTOR) { numerator *= SCALE_FACTOR; newP = numerator / totalBoldDeposits; currentScale += 1; emit ScaleUpdated(currentScale); } emit P_Updated(newP); P = newP; _moveOffsetCollAndDebt(_collToAdd, _debtToOffset); } function _moveOffsetCollAndDebt(uint256 _collToAdd, uint256 _debtToOffset) internal { // Cancel the liquidated Bold debt with the Bold in the stability pool _updateTotalBoldDeposits(0, _debtToOffset); // Burn the debt that was successfully offset boldToken.burn(address(this), _debtToOffset); // Update internal Coll balance tracker uint256 newCollBalance = collBalance + _collToAdd; collBalance = newCollBalance; // Pull Coll from Active Pool activePool.sendColl(address(this), _collToAdd); emit StabilityPoolCollBalanceUpdated(newCollBalance); } function _updateTotalBoldDeposits(uint256 _depositIncrease, uint256 _depositDecrease) internal returns (uint256) { if (_depositIncrease == 0 && _depositDecrease == 0) return totalBoldDeposits; uint256 newTotalBoldDeposits = totalBoldDeposits + _depositIncrease - _depositDecrease; totalBoldDeposits = newTotalBoldDeposits; emit StabilityPoolBoldBalanceUpdated(newTotalBoldDeposits); return newTotalBoldDeposits; } function _decreaseYieldGainsOwed(uint256 _amount) internal { if (_amount == 0) return; uint256 newYieldGainsOwed = yieldGainsOwed - _amount; yieldGainsOwed = newYieldGainsOwed; } // --- Reward calculator functions for depositor --- function getDepositorCollGain(address _depositor) public view override returns (uint256) { uint256 initialDeposit = deposits[_depositor].initialValue; if (initialDeposit == 0) return 0; Snapshots storage snapshots = depositSnapshots[_depositor]; // Coll gains from the same scale in which the deposit was made need no scaling uint256 normalizedGains = scaleToS[snapshots.scale] - snapshots.S; // Scale down further coll gains by a power of `SCALE_FACTOR` depending on how many scale changes they span for (uint256 i = 1; i <= SCALE_SPAN; ++i) { normalizedGains += scaleToS[snapshots.scale + i] / SCALE_FACTOR ** i; } return LiquityMath._min(initialDeposit * normalizedGains / snapshots.P, collBalance); } function getDepositorYieldGain(address _depositor) public view override returns (uint256) { uint256 initialDeposit = deposits[_depositor].initialValue; if (initialDeposit == 0) return 0; Snapshots storage snapshots = depositSnapshots[_depositor]; // Yield gains from the same scale in which the deposit was made need no scaling uint256 normalizedGains = scaleToB[snapshots.scale] - snapshots.B; // Scale down further yield gains by a power of `SCALE_FACTOR` depending on how many scale changes they span for (uint256 i = 1; i <= SCALE_SPAN; ++i) { normalizedGains += scaleToB[snapshots.scale + i] / SCALE_FACTOR ** i; } return LiquityMath._min(initialDeposit * normalizedGains / snapshots.P, yieldGainsOwed); } function getDepositorYieldGainWithPending(address _depositor) external view override returns (uint256) { if (totalBoldDeposits < MIN_BOLD_IN_SP) return 0; uint256 initialDeposit = deposits[_depositor].initialValue; if (initialDeposit == 0) return 0; Snapshots storage snapshots = depositSnapshots[_depositor]; uint256 newYieldGainsOwed = yieldGainsOwed; // Yield gains from the same scale in which the deposit was made need no scaling uint256 normalizedGains = scaleToB[snapshots.scale] - snapshots.B; // Scale down further yield gains by a power of `SCALE_FACTOR` depending on how many scale changes they span for (uint256 i = 1; i <= SCALE_SPAN; ++i) { normalizedGains += scaleToB[snapshots.scale + i] / SCALE_FACTOR ** i; } // Pending gains uint256 pendingSPYield = activePool.calcPendingSPYield(); newYieldGainsOwed += pendingSPYield; if (currentScale <= snapshots.scale + SCALE_SPAN) { normalizedGains += P * pendingSPYield / totalBoldDeposits / SCALE_FACTOR ** (currentScale - snapshots.scale); } return LiquityMath._min(initialDeposit * normalizedGains / snapshots.P, newYieldGainsOwed); } // --- Compounded deposit --- function getCompoundedBoldDeposit(address _depositor) public view override returns (uint256 compoundedDeposit) { uint256 initialDeposit = deposits[_depositor].initialValue; if (initialDeposit == 0) return 0; Snapshots storage snapshots = depositSnapshots[_depositor]; uint256 scaleDiff = currentScale - snapshots.scale; // Compute the compounded deposit. If one or more scale changes in `P` were made during the deposit's lifetime, // account for them. // If more than `MAX_SCALE_FACTOR_EXPONENT` scale changes were made, then the divisor is greater than 2^256 so // any deposit amount would be rounded down to zero. if (scaleDiff <= MAX_SCALE_FACTOR_EXPONENT) { compoundedDeposit = initialDeposit * P / snapshots.P / SCALE_FACTOR ** scaleDiff; } else { compoundedDeposit = 0; } } // --- Sender functions for Bold deposit and Coll gains --- function _sendCollGainToDepositor(uint256 _collAmount) internal { if (_collAmount == 0) return; uint256 newCollBalance = collBalance - _collAmount; collBalance = newCollBalance; emit StabilityPoolCollBalanceUpdated(newCollBalance); collToken.safeTransfer(msg.sender, _collAmount); } // Send Bold to user and decrease Bold in Pool function _sendBoldtoDepositor(address _depositor, uint256 _boldToSend) internal { if (_boldToSend == 0) return; boldToken.returnFromPool(address(this), _depositor, _boldToSend); } // --- Stability Pool Deposit Functionality --- function _updateDepositAndSnapshots(address _depositor, uint256 _newDeposit, uint256 _newStashedColl) internal { deposits[_depositor].initialValue = _newDeposit; stashedColl[_depositor] = _newStashedColl; if (_newDeposit == 0) { delete depositSnapshots[_depositor]; emit DepositUpdated(_depositor, 0, _newStashedColl, 0, 0, 0, 0); return; } uint256 currentScaleCached = currentScale; uint256 currentP = P; // Get S for the current scale uint256 currentS = scaleToS[currentScaleCached]; uint256 currentB = scaleToB[currentScaleCached]; // Record new snapshots of the latest running product P and sum S for the depositor depositSnapshots[_depositor].P = currentP; depositSnapshots[_depositor].S = currentS; depositSnapshots[_depositor].B = currentB; depositSnapshots[_depositor].scale = currentScaleCached; emit DepositUpdated(_depositor, _newDeposit, _newStashedColl, currentP, currentS, currentB, currentScaleCached); } // --- 'require' functions --- function _requireCallerIsActivePool() internal view { require(msg.sender == address(activePool), "StabilityPool: Caller is not ActivePool"); } function _requireCallerIsTroveManager() internal view { require(msg.sender == address(troveManager), "StabilityPool: Caller is not TroveManager"); } function _requireUserHasDeposit(uint256 _initialDeposit) internal pure { require(_initialDeposit > 0, "StabilityPool: User must have a non-zero deposit"); } function _requireUserHasNoDeposit(address _address) internal view { uint256 initialDeposit = deposits[_address].initialValue; require(initialDeposit == 0, "StabilityPool: User must have no deposit"); } function _requireNonZeroAmount(uint256 _amount) internal pure { require(_amount > 0, "StabilityPool: Amount must be non-zero"); } } //SPDX-License-Identifier: MIT pragma solidity 0.8.24; import "./SVG.sol"; library bauhaus { string constant GOLDEN = "#F5D93A"; string constant CORAL = "#FB7C59"; string constant GREEN = "#63D77D"; string constant CYAN = "#95CBF3"; string constant BLUE = "#405AE5"; string constant DARK_BLUE = "#121B44"; string constant BROWN = "#D99664"; enum colorCode { GOLDEN, CORAL, GREEN, CYAN, BLUE, DARK_BLUE, BROWN } function _bauhaus(string memory _collName, uint256 _troveId) internal pure returns (string memory) { bytes32 collSig = keccak256(bytes(_collName)); uint256 variant = _troveId % 4; if (collSig == keccak256("WETH")) { return _img1(variant); } else if (collSig == keccak256("wstETH")) { return _img2(variant); } else { // assume rETH return _img3(variant); } } function _colorCode2Hex(colorCode _color) private pure returns (string memory) { if (_color == colorCode.GOLDEN) { return GOLDEN; } else if (_color == colorCode.CORAL) { return CORAL; } else if (_color == colorCode.GREEN) { return GREEN; } else if (_color == colorCode.CYAN) { return CYAN; } else if (_color == colorCode.BLUE) { return BLUE; } else if (_color == colorCode.DARK_BLUE) { return DARK_BLUE; } else { return BROWN; } } struct COLORS { colorCode rect1; colorCode rect2; colorCode rect3; colorCode rect4; colorCode rect5; colorCode poly; colorCode circle1; colorCode circle2; colorCode circle3; } function _colors1(uint256 _variant) internal pure returns (COLORS memory) { if (_variant == 0) { return COLORS( colorCode.BLUE, // rect1 colorCode.GOLDEN, // rect2 colorCode.GOLDEN, // rect3 colorCode.BROWN, // rect4 colorCode.CORAL, // rect5 colorCode.CYAN, // poly colorCode.GREEN, // circle1 colorCode.DARK_BLUE, // circle2 colorCode.GOLDEN // circle3 ); } else if (_variant == 1) { return COLORS( colorCode.GREEN, // rect1 colorCode.BLUE, // rect2 colorCode.GOLDEN, // rect3 colorCode.BROWN, // rect4 colorCode.GOLDEN, // rect5 colorCode.CORAL, // poly colorCode.BLUE, // circle1 colorCode.DARK_BLUE, // circle2 colorCode.BLUE // circle3 ); } else if (_variant == 2) { return COLORS( colorCode.BLUE, // rect1 colorCode.GOLDEN, // rect2 colorCode.CYAN, // rect3 colorCode.GOLDEN, // rect4 colorCode.BROWN, // rect5 colorCode.GREEN, // poly colorCode.CORAL, // circle1 colorCode.DARK_BLUE, // circle2 colorCode.BROWN // circle3 ); } else { return COLORS( colorCode.CYAN, // rect1 colorCode.BLUE, // rect2 colorCode.BLUE, // rect3 colorCode.BROWN, // rect4 colorCode.BLUE, // rect5 colorCode.GREEN, // poly colorCode.GOLDEN, // circle1 colorCode.DARK_BLUE, // circle2 colorCode.BLUE // circle3 ); } } function _img1(uint256 _variant) internal pure returns (string memory) { COLORS memory colors = _colors1(_variant); return string.concat(_rects1(colors), _polygons1(colors), _circles1(colors)); } function _rects1(COLORS memory _colors) internal pure returns (string memory) { return string.concat( //background svg.rect( string.concat( svg.prop("x", "16"), svg.prop("y", "55"), svg.prop("width", "268"), svg.prop("height", "268"), svg.prop("fill", DARK_BLUE) ) ), // large right rect | rect1 svg.rect( string.concat( svg.prop("x", "128"), svg.prop("y", "55"), svg.prop("width", "156"), svg.prop("height", "268"), svg.prop("fill", _colorCode2Hex(_colors.rect1)) ) ), // small upper right rect | rect2 svg.rect( string.concat( svg.prop("x", "228"), svg.prop("y", "55"), svg.prop("width", "56"), svg.prop("height", "56"), svg.prop("fill", _colorCode2Hex(_colors.rect2)) ) ), // large central left rect | rect3 svg.rect( string.concat( svg.prop("x", "16"), svg.prop("y", "111"), svg.prop("width", "134"), svg.prop("height", "156"), svg.prop("fill", _colorCode2Hex(_colors.rect3)) ) ), // small lower left rect | rect4 svg.rect( string.concat( svg.prop("x", "16"), svg.prop("y", "267"), svg.prop("width", "112"), svg.prop("height", "56"), svg.prop("fill", _colorCode2Hex(_colors.rect4)) ) ), // small lower right rect | rect5 svg.rect( string.concat( svg.prop("x", "228"), svg.prop("y", "267"), svg.prop("width", "56"), svg.prop("height", "56"), svg.prop("fill", _colorCode2Hex(_colors.rect5)) ) ) ); } function _polygons1(COLORS memory _colors) internal pure returns (string memory) { return string.concat( // left triangle | poly1 svg.polygon( string.concat(svg.prop("points", "16,55 72,55 16,111"), svg.prop("fill", _colorCode2Hex(_colors.poly))) ), // right triangle | poly2 svg.polygon( string.concat(svg.prop("points", "72,55 128,55 72,111"), svg.prop("fill", _colorCode2Hex(_colors.poly))) ) ); } function _circles1(COLORS memory _colors) internal pure returns (string memory) { return string.concat( //large central circle | circle1 svg.circle( string.concat( svg.prop("cx", "150"), svg.prop("cy", "189"), svg.prop("r", "78"), svg.prop("fill", _colorCode2Hex(_colors.circle1)) ) ), //small right circle | circle2 svg.circle( string.concat( svg.prop("cx", "228"), svg.prop("cy", "295"), svg.prop("r", "28"), svg.prop("fill", _colorCode2Hex(_colors.circle2)) ) ), //small right half circle | circle3 svg.path( "M228 267C220.574 267 213.452 269.95 208.201 275.201C202.95 280.452 200 287.574 200 295C200 302.426 202.95 309.548 208.201 314.799C213.452 320.05 220.574 323 228 323L228 267Z", svg.prop("fill", _colorCode2Hex(_colors.circle3)) ) ); } function _colors2(uint256 _variant) internal pure returns (COLORS memory) { if (_variant == 0) { return COLORS( colorCode.BROWN, // rect1 colorCode.GOLDEN, // rect2 colorCode.BLUE, // rect3 colorCode.GREEN, // rect4 colorCode.CORAL, // rect5 colorCode.GOLDEN, // unused colorCode.GOLDEN, // circle1 colorCode.CYAN, // circle2 colorCode.GREEN // circle3 ); } else if (_variant == 1) { return COLORS( colorCode.GREEN, // rect1 colorCode.BROWN, // rect2 colorCode.GOLDEN, // rect3 colorCode.BLUE, // rect4 colorCode.CYAN, // rect5 colorCode.GOLDEN, // unused colorCode.GREEN, // circle1 colorCode.CORAL, // circle2 colorCode.BLUE // circle3 ); } else if (_variant == 2) { return COLORS( colorCode.BLUE, // rect1 colorCode.GOLDEN, // rect2 colorCode.GREEN, // rect3 colorCode.BLUE, // rect4 colorCode.CORAL, // rect5 colorCode.GOLDEN, // unused colorCode.CYAN, // circle1 colorCode.BROWN, // circle2 colorCode.BROWN // circle3 ); } else { return COLORS( colorCode.GOLDEN, // rect1 colorCode.GREEN, // rect2 colorCode.BLUE, // rect3 colorCode.GOLDEN, // rect4 colorCode.BROWN, // rect5 colorCode.GOLDEN, // unused colorCode.BROWN, // circle1 colorCode.CYAN, // circle2 colorCode.CORAL // circle3 ); } } function _img2(uint256 _variant) internal pure returns (string memory) { COLORS memory colors = _colors2(_variant); return string.concat(_rects2(colors), _circles2(colors)); } function _rects2(COLORS memory _colors) internal pure returns (string memory) { return string.concat( //background svg.rect( string.concat( svg.prop("x", "16"), svg.prop("y", "55"), svg.prop("width", "268"), svg.prop("height", "268"), svg.prop("fill", DARK_BLUE) ) ), // large upper right rect | rect1 svg.rect( string.concat( svg.prop("x", "128"), svg.prop("y", "55"), svg.prop("width", "156"), svg.prop("height", "156"), svg.prop("fill", _colorCode2Hex(_colors.rect1)) ) ), // large central left rect | rect2 svg.rect( string.concat( svg.prop("x", "16"), svg.prop("y", "111"), svg.prop("width", "134"), svg.prop("height", "100"), svg.prop("fill", _colorCode2Hex(_colors.rect2)) ) ), // large lower left rect | rect3 svg.rect( string.concat( svg.prop("x", "16"), svg.prop("y", "211"), svg.prop("width", "212"), svg.prop("height", "56"), svg.prop("fill", _colorCode2Hex(_colors.rect3)) ) ), // small lower central rect | rect4 svg.rect( string.concat( svg.prop("x", "72"), svg.prop("y", "267"), svg.prop("width", "78"), svg.prop("height", "56"), svg.prop("fill", _colorCode2Hex(_colors.rect4)) ) ), // small lower right rect | rect5 svg.rect( string.concat( svg.prop("x", "150"), svg.prop("y", "267"), svg.prop("width", "134"), svg.prop("height", "56"), svg.prop("fill", _colorCode2Hex(_colors.rect5)) ) ) ); } function _circles2(COLORS memory _colors) internal pure returns (string memory) { return string.concat( //lower left circle | circle1 svg.circle( string.concat( svg.prop("cx", "44"), svg.prop("cy", "295"), svg.prop("r", "28"), svg.prop("fill", _colorCode2Hex(_colors.circle1)) ) ), //upper left half circle | circle2 svg.path( "M16 55C16 62.4 17.4 69.6 20.3 76.4C23.1 83.2 27.2 89.4 32.4 94.6C37.6 99.8 43.8 103.9 50.6 106.7C57.4 109.6 64.6 111 72 111C79.4 111 86.6 109.6 93.4 106.7C100.2 103.9 106.4 99.8 111.6 94.6C116.8 89.4 120.9 83.2 123.7 76.4C126.6 69.6 128 62.4 128 55L16 55Z", svg.prop("fill", _colorCode2Hex(_colors.circle2)) ), //central right half circle | circle3 svg.path( "M284 211C284 190.3 275.8 170.5 261.2 155.8C246.5 141.2 226.7 133 206 133C185.3 133 165.5 141.2 150.9 155.86C136.2 170.5 128 190.3 128 211L284 211Z", svg.prop("fill", _colorCode2Hex(_colors.circle3)) ) ); } function _colors3(uint256 _variant) internal pure returns (COLORS memory) { if (_variant == 0) { return COLORS( colorCode.BLUE, // rect1 colorCode.CORAL, // rect2 colorCode.BLUE, // rect3 colorCode.GREEN, // rect4 colorCode.GOLDEN, // unused colorCode.GOLDEN, // unused colorCode.GOLDEN, // circle1 colorCode.CYAN, // circle2 colorCode.GOLDEN // circle3 ); } else if (_variant == 1) { return COLORS( colorCode.CORAL, // rect1 colorCode.GREEN, // rect2 colorCode.BROWN, // rect3 colorCode.GOLDEN, // rect4 colorCode.GOLDEN, // unused colorCode.GOLDEN, // unused colorCode.BLUE, // circle1 colorCode.BLUE, // circle2 colorCode.CYAN // circle3 ); } else if (_variant == 2) { return COLORS( colorCode.CORAL, // rect1 colorCode.CYAN, // rect2 colorCode.CORAL, // rect3 colorCode.GOLDEN, // rect4 colorCode.GOLDEN, // unused colorCode.GOLDEN, // unused colorCode.GREEN, // circle1 colorCode.BLUE, // circle2 colorCode.GREEN // circle3 ); } else { return COLORS( colorCode.GOLDEN, // rect1 colorCode.CORAL, // rect2 colorCode.GREEN, // rect3 colorCode.BLUE, // rect4 colorCode.GOLDEN, // unused colorCode.GOLDEN, // unused colorCode.BROWN, // circle1 colorCode.BLUE, // circle2 colorCode.GREEN // circle3 ); } } function _img3(uint256 _variant) internal pure returns (string memory) { COLORS memory colors = _colors3(_variant); return string.concat(_rects3(colors), _circles3(colors)); } function _rects3(COLORS memory _colors) internal pure returns (string memory) { return string.concat( //background svg.rect( string.concat( svg.prop("x", "16"), svg.prop("y", "55"), svg.prop("width", "268"), svg.prop("height", "268"), svg.prop("fill", DARK_BLUE) ) ), // lower left rect | rect1 svg.rect( string.concat( svg.prop("x", "16"), svg.prop("y", "205"), svg.prop("width", "75"), svg.prop("height", "118"), svg.prop("fill", _colorCode2Hex(_colors.rect1)) ) ), // central rect | rect2 svg.rect( string.concat( svg.prop("x", "91"), svg.prop("y", "205"), svg.prop("width", "136"), svg.prop("height", "59"), svg.prop("fill", _colorCode2Hex(_colors.rect2)) ) ), // central right rect | rect3 svg.rect( string.concat( svg.prop("x", "166"), svg.prop("y", "180"), svg.prop("width", "118"), svg.prop("height", "25"), svg.prop("fill", _colorCode2Hex(_colors.rect3)) ) ), // upper right rect | rect4 svg.rect( string.concat( svg.prop("x", "166"), svg.prop("y", "55"), svg.prop("width", "118"), svg.prop("height", "126"), svg.prop("fill", _colorCode2Hex(_colors.rect4)) ) ) ); } function _circles3(COLORS memory _colors) internal pure returns (string memory) { return string.concat( //upper left circle | circle1 svg.circle( string.concat( svg.prop("cx", "91"), svg.prop("cy", "130"), svg.prop("r", "75"), svg.prop("fill", _colorCode2Hex(_colors.circle1)) ) ), //upper right half circle | circle2 svg.path( "M284 264 166 264 166 263C166 232 193 206 225 205C258 206 284 232 284 264C284 264 284 264 284 264Z", svg.prop("fill", _colorCode2Hex(_colors.circle2)) ), //lower right half circle | circle3 svg.path( "M284 323 166 323 166 323C166 290 193 265 225 264C258 265 284 290 284 323C284 323 284 323 284 323Z", svg.prop("fill", _colorCode2Hex(_colors.circle3)) ) ); } } //SPDX-License-Identifier: MIT pragma solidity 0.8.24; import "Solady/utils/LibString.sol"; library numUtils { function toLocale(string memory _wholeNumber) internal pure returns (string memory) { bytes memory b = bytes(_wholeNumber); uint256 len = b.length; if (len < 4) return _wholeNumber; uint256 numCommas = (len - 1) / 3; bytes memory result = new bytes(len + numCommas); uint256 j = result.length - 1; uint256 k = len; for (uint256 i = 0; i < len; i++) { result[j] = b[k - 1]; j = j > 1 ? j - 1 : 0; k--; if (k > 0 && (len - k) % 3 == 0) { result[j] = ","; j = j > 1 ? j - 1 : 0; } } return string(result); } // returns a string representation of a number with commas, where result = _value / 10 ** _divisor function toLocaleString(uint256 _value, uint8 _divisor, uint8 _precision) internal pure returns (string memory) { uint256 whole; uint256 fraction; if (_divisor > 0) { whole = _value / 10 ** _divisor; // check if the divisor is less than the precision if (_divisor <= _precision) { fraction = (_value % 10 ** _divisor); // adjust fraction to be the same as the precision fraction = fraction * 10 ** (_precision - _divisor); // if whole is zero, then add another zero to the fraction, special case if the value is 1 fraction = (whole == 0 && _value != 1) ? fraction * 10 : fraction; } else { fraction = (_value % 10 ** _divisor) / 10 ** (_divisor - _precision - 1); } } else { whole = _value; } string memory wholeStr = toLocale(LibString.toString(whole)); if (fraction == 0) { if (whole > 0 && _precision > 0) wholeStr = string.concat(wholeStr, "."); for (uint8 i = 0; i < _precision; i++) { wholeStr = string.concat(wholeStr, "0"); } return wholeStr; } string memory fractionStr = LibString.slice(LibString.toString(fraction), 0, _precision); // pad with leading zeros if (_precision > bytes(fractionStr).length) { uint256 len = _precision - bytes(fractionStr).length; string memory zeroStr = ""; for (uint8 i = 0; i < len; i++) { zeroStr = string.concat(zeroStr, "0"); } fractionStr = string.concat(zeroStr, fractionStr); } return string.concat(wholeStr, _precision > 0 ? "." : "", fractionStr); } } /// @notice Core utils used extensively to format CSS and numbers. /// @author Modified from (https://github.com/w1nt3r-eth/hot-chain-svg/blob/main/contracts/Utils.sol) by w1nt3r-eth. library utils { // used to simulate empty strings string internal constant NULL = ""; // formats a CSS variable line. includes a semicolon for formatting. function setCssVar(string memory _key, string memory _val) internal pure returns (string memory) { return string.concat("--", _key, ":", _val, ";"); } // formats getting a css variable function getCssVar(string memory _key) internal pure returns (string memory) { return string.concat("var(--", _key, ")"); } // formats getting a def URL function getDefURL(string memory _id) internal pure returns (string memory) { return string.concat("url(#", _id, ")"); } // formats rgba white with a specified opacity / alpha function white_a(uint256 _a) internal pure returns (string memory) { return rgba(255, 255, 255, _a); } // formats rgba black with a specified opacity / alpha function black_a(uint256 _a) internal pure returns (string memory) { return rgba(0, 0, 0, _a); } // formats generic rgba color in css function rgba(uint256 _r, uint256 _g, uint256 _b, uint256 _a) internal pure returns (string memory) { string memory formattedA = _a < 100 ? string.concat("0.", LibString.toString(_a)) : "1"; return string.concat( "rgba(", LibString.toString(_r), ",", LibString.toString(_g), ",", LibString.toString(_b), ",", formattedA, ")" ); } function cssBraces(string memory _attribute, string memory _value) internal pure returns (string memory) { return string.concat(" {", _attribute, ": ", _value, "}"); } function cssBraces(string[] memory _attributes, string[] memory _values) internal pure returns (string memory) { require(_attributes.length == _values.length, "Utils: Unbalanced Arrays"); uint256 len = _attributes.length; string memory results = " {"; for (uint256 i = 0; i < len; i++) { results = string.concat(results, _attributes[i], ": ", _values[i], "; "); } return string.concat(results, "}"); } //deals with integers (i.e. no decimals) function points(uint256[2][] memory pointsArray) internal pure returns (string memory) { require(pointsArray.length >= 3, "Utils: Array too short"); uint256 len = pointsArray.length - 1; string memory results = 'points="'; for (uint256 i = 0; i < len; i++) { results = string.concat( results, LibString.toString(pointsArray[i][0]), ",", LibString.toString(pointsArray[i][1]), " " ); } return string.concat( results, LibString.toString(pointsArray[len][0]), ",", LibString.toString(pointsArray[len][1]), '"' ); } // allows for a uniform precision to be applied to all points function points(uint256[2][] memory pointsArray, uint256 decimalPrecision) internal pure returns (string memory) { require(pointsArray.length >= 3, "Utils: Array too short"); uint256 len = pointsArray.length - 1; string memory results = 'points="'; for (uint256 i = 0; i < len; i++) { results = string.concat( results, toString(pointsArray[i][0], decimalPrecision), ",", toString(pointsArray[i][1], decimalPrecision), " " ); } return string.concat( results, toString(pointsArray[len][0], decimalPrecision), ",", toString(pointsArray[len][1], decimalPrecision), '"' ); } // checks if two strings are equal function stringsEqual(string memory _a, string memory _b) internal pure returns (bool) { return keccak256(abi.encodePacked(_a)) == keccak256(abi.encodePacked(_b)); } // returns the length of a string in characters function utfStringLength(string memory _str) internal pure returns (uint256 length) { uint256 i = 0; bytes memory string_rep = bytes(_str); while (i < string_rep.length) { if (string_rep[i] >> 7 == 0) { i += 1; } else if (string_rep[i] >> 5 == bytes1(uint8(0x6))) { i += 2; } else if (string_rep[i] >> 4 == bytes1(uint8(0xE))) { i += 3; } else if (string_rep[i] >> 3 == bytes1(uint8(0x1E))) { i += 4; } //For safety else { i += 1; } length++; } } // allows the insertion of a decimal point in the returned string at precision function toString(uint256 value, uint256 precision) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } require(precision <= digits && precision > 0, "Utils: precision invalid"); precision == digits ? digits += 2 : digits++; //adds a space for the decimal point, 2 if it is the whole uint uint256 decimalPlacement = digits - precision - 1; bytes memory buffer = new bytes(digits); buffer[decimalPlacement] = 0x2E; // add the decimal point, ASCII 46/hex 2E if (decimalPlacement == 1) { buffer[0] = 0x30; } while (value != 0) { digits -= 1; if (digits != decimalPlacement) { buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } } return string(buffer); } } //SPDX-License-Identifier: MIT pragma solidity 0.8.24; import {svg} from "./SVG.sol"; import {utils, LibString, numUtils} from "./Utils.sol"; import "./FixedAssets.sol"; library baseSVG { string constant GEIST = 'style="font-family: Geist" '; string constant DARK_BLUE = "#121B44"; string constant STOIC_WHITE = "#DEE4FB"; function _svgProps() internal pure returns (string memory) { return string.concat( svg.prop("width", "300"), svg.prop("height", "484"), svg.prop("viewBox", "0 0 300 484"), svg.prop("style", "background:none") ); } function _baseElements(FixedAssetReader _assetReader) internal view returns (string memory) { return string.concat( svg.rect( string.concat( svg.prop("fill", DARK_BLUE), svg.prop("rx", "8"), svg.prop("width", "300"), svg.prop("height", "484") ) ), _styles(_assetReader), _leverageLogo(), _boldLogo(_assetReader), _staticTextEls() ); } function _styles(FixedAssetReader _assetReader) private view returns (string memory) { return svg.el( "style", utils.NULL, string.concat( '@font-face { font-family: "Geist"; src: url("data:font/woff2;utf-8;base64,', _assetReader.readAsset(bytes4(keccak256("geist"))), '"); }' ) ); } function _leverageLogo() internal pure returns (string memory) { return string.concat( svg.path( "M20.2 31.2C19.1 32.4 17.6 33 16 33L16 21C17.6 21 19.1 21.6 20.2 22.7C21.4 23.9 22 25.4 22 27C22 28.6 21.4 30.1 20.2 31.2Z", svg.prop("fill", STOIC_WHITE) ), svg.path( "M22 27C22 25.4 22.6 23.9 23.8 22.7C25 21.6 26.4 21 28 21V33C26.4 33 25 32.4 24 31.2C22.6 30.1 22 28.6 22 27Z", svg.prop("fill", STOIC_WHITE) ) ); } function _boldLogo(FixedAssetReader _assetReader) internal view returns (string memory) { return svg.el( "image", string.concat( svg.prop("x", "264"), svg.prop("y", "373.5"), svg.prop("width", "20"), svg.prop("height", "20"), svg.prop( "href", string.concat("data:image/svg+xml;base64,", _assetReader.readAsset(bytes4(keccak256("BOLD")))) ) ) ); } function _staticTextEls() internal pure returns (string memory) { return string.concat( svg.text( string.concat( GEIST, svg.prop("x", "16"), svg.prop("y", "358"), svg.prop("font-size", "14"), svg.prop("fill", "white") ), "Collateral" ), svg.text( string.concat( GEIST, svg.prop("x", "16"), svg.prop("y", "389"), svg.prop("font-size", "14"), svg.prop("fill", "white") ), "Debt" ), svg.text( string.concat( GEIST, svg.prop("x", "16"), svg.prop("y", "420"), svg.prop("font-size", "14"), svg.prop("fill", "white") ), "Interest Rate" ), svg.text( string.concat( GEIST, svg.prop("x", "265"), svg.prop("y", "422"), svg.prop("font-size", "20"), svg.prop("fill", "white") ), "%" ), svg.text( string.concat( GEIST, svg.prop("x", "16"), svg.prop("y", "462"), svg.prop("font-size", "14"), svg.prop("fill", "white") ), "Owner" ) ); } function _formattedDynamicEl(string memory _value, uint256 _x, uint256 _y) internal pure returns (string memory) { return svg.text( string.concat( GEIST, svg.prop("text-anchor", "end"), svg.prop("x", LibString.toString(_x)), svg.prop("y", LibString.toString(_y)), svg.prop("font-size", "20"), svg.prop("fill", "white") ), _value ); } function _formattedIdEl(string memory _id) internal pure returns (string memory) { return svg.text( string.concat( GEIST, svg.prop("text-anchor", "end"), svg.prop("x", "284"), svg.prop("y", "33"), svg.prop("font-size", "14"), svg.prop("fill", "white") ), _id ); } function _formattedAddressEl(address _address) internal pure returns (string memory) { return svg.text( string.concat( GEIST, svg.prop("text-anchor", "end"), svg.prop("x", "284"), svg.prop("y", "462"), svg.prop("font-size", "14"), svg.prop("fill", "white") ), string.concat( LibString.slice(LibString.toHexStringChecksummed(_address), 0, 6), "...", LibString.slice(LibString.toHexStringChecksummed(_address), 38, 42) ) ); } function _collLogo(string memory _collName, FixedAssetReader _assetReader) internal view returns (string memory) { return svg.el( "image", string.concat( svg.prop("x", "264"), svg.prop("y", "342.5"), svg.prop("width", "20"), svg.prop("height", "20"), svg.prop( "href", string.concat( "data:image/svg+xml;base64,", _assetReader.readAsset(bytes4(keccak256(bytes(_collName)))) ) ) ) ); } function _statusEl(string memory _status) internal pure returns (string memory) { return svg.text( string.concat( GEIST, svg.prop("x", "40"), svg.prop("y", "33"), svg.prop("font-size", "14"), svg.prop("fill", "white") ), _status ); } function _dynamicTextEls(uint256 _debt, uint256 _coll, uint256 _annualInterestRate) internal pure returns (string memory) { return string.concat( _formattedDynamicEl(numUtils.toLocaleString(_coll, 18, 4), 256, 360), _formattedDynamicEl(numUtils.toLocaleString(_debt, 18, 2), 256, 391), _formattedDynamicEl(numUtils.toLocaleString(_annualInterestRate, 16, 2), 256, 422) ); } } //SPDX-License-Identifier: MIT pragma solidity ^0.8.18; import {utils, LibString} from "./Utils.sol"; /// @notice Core SVG utility library which helps us construct onchain SVG's with a simple, web-like API. /// @author Modified from (https://github.com/w1nt3r-eth/hot-chain-svg/blob/main/contracts/SVG.sol) by w1nt3r-eth. library svg { /* GLOBAL CONSTANTS */ string internal constant _SVG = 'xmlns="http://www.w3.org/2000/svg"'; string internal constant _HTML = 'xmlns="http://www.w3.org/1999/xhtml"'; string internal constant _XMLNS = "http://www.w3.org/2000/xmlns/ "; string internal constant _XLINK = "http://www.w3.org/1999/xlink "; /* MAIN ELEMENTS */ function g(string memory _props, string memory _children) internal pure returns (string memory) { return el("g", _props, _children); } function _svg(string memory _props, string memory _children) internal pure returns (string memory) { return el("svg", string.concat(_SVG, " ", _props), _children); } function style(string memory _title, string memory _props) internal pure returns (string memory) { return el("style", string.concat(".", _title, " ", _props)); } function path(string memory _d) internal pure returns (string memory) { return el("path", prop("d", _d, true)); } function path(string memory _d, string memory _props) internal pure returns (string memory) { return el("path", string.concat(prop("d", _d), _props)); } function path(string memory _d, string memory _props, string memory _children) internal pure returns (string memory) { return el("path", string.concat(prop("d", _d), _props), _children); } function text(string memory _props, string memory _children) internal pure returns (string memory) { return el("text", _props, _children); } function line(string memory _props) internal pure returns (string memory) { return el("line", _props); } function line(string memory _props, string memory _children) internal pure returns (string memory) { return el("line", _props, _children); } function circle(string memory _props) internal pure returns (string memory) { return el("circle", _props); } function circle(string memory _props, string memory _children) internal pure returns (string memory) { return el("circle", _props, _children); } function circle(string memory cx, string memory cy, string memory r) internal pure returns (string memory) { return el("circle", string.concat(prop("cx", cx), prop("cy", cy), prop("r", r, true))); } function circle(string memory cx, string memory cy, string memory r, string memory _children) internal pure returns (string memory) { return el("circle", string.concat(prop("cx", cx), prop("cy", cy), prop("r", r, true)), _children); } function circle(string memory cx, string memory cy, string memory r, string memory _props, string memory _children) internal pure returns (string memory) { return el("circle", string.concat(prop("cx", cx), prop("cy", cy), prop("r", r), _props), _children); } function ellipse(string memory _props) internal pure returns (string memory) { return el("ellipse", _props); } function ellipse(string memory _props, string memory _children) internal pure returns (string memory) { return el("ellipse", _props, _children); } function polygon(string memory _props) internal pure returns (string memory) { return el("polygon", _props); } function polygon(string memory _props, string memory _children) internal pure returns (string memory) { return el("polygon", _props, _children); } function polyline(string memory _props) internal pure returns (string memory) { return el("polyline", _props); } function polyline(string memory _props, string memory _children) internal pure returns (string memory) { return el("polyline", _props, _children); } function rect(string memory _props) internal pure returns (string memory) { return el("rect", _props); } function rect(string memory _props, string memory _children) internal pure returns (string memory) { return el("rect", _props, _children); } function filter(string memory _props, string memory _children) internal pure returns (string memory) { return el("filter", _props, _children); } function cdata(string memory _content) internal pure returns (string memory) { return string.concat(""); } /* GRADIENTS */ function radialGradient(string memory _props, string memory _children) internal pure returns (string memory) { return el("radialGradient", _props, _children); } function linearGradient(string memory _props, string memory _children) internal pure returns (string memory) { return el("linearGradient", _props, _children); } function gradientStop(uint256 offset, string memory stopColor, string memory _props) internal pure returns (string memory) { return el( "stop", string.concat( prop("stop-color", stopColor), " ", prop("offset", string.concat(LibString.toString(offset), "%")), " ", _props ), utils.NULL ); } /* ANIMATION */ function animateTransform(string memory _props) internal pure returns (string memory) { return el("animateTransform", _props); } function animate(string memory _props) internal pure returns (string memory) { return el("animate", _props); } /* COMMON */ // A generic element, can be used to construct any SVG (or HTML) element function el(string memory _tag, string memory _props, string memory _children) internal pure returns (string memory) { return string.concat("<", _tag, " ", _props, ">", _children, ""); } // A generic element, can be used to construct SVG (or HTML) elements without children function el(string memory _tag, string memory _props) internal pure returns (string memory) { return string.concat("<", _tag, " ", _props, "/>"); } // an SVG attribute function prop(string memory _key, string memory _val) internal pure returns (string memory) { return string.concat(_key, "=", '"', _val, '" '); } function prop(string memory _key, string memory _val, bool last) internal pure returns (string memory) { if (last) { return string.concat(_key, "=", '"', _val, '"'); } else { return string.concat(_key, "=", '"', _val, '" '); } } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./ILiquityBase.sol"; import "./ITroveNFT.sol"; import "./IBorrowerOperations.sol"; import "./IStabilityPool.sol"; import "./IBoldToken.sol"; import "./ISortedTroves.sol"; import "../Types/LatestTroveData.sol"; import "../Types/LatestBatchData.sol"; // Common interface for the Trove Manager. interface ITroveManager is ILiquityBase { enum Status { nonExistent, active, closedByOwner, closedByLiquidation, zombie } function shutdownTime() external view returns (uint256); function troveNFT() external view returns (ITroveNFT); function stabilityPool() external view returns (IStabilityPool); //function boldToken() external view returns (IBoldToken); function sortedTroves() external view returns (ISortedTroves); function borrowerOperations() external view returns (IBorrowerOperations); function Troves(uint256 _id) external view returns ( uint256 debt, uint256 coll, uint256 stake, Status status, uint64 arrayIndex, uint64 lastDebtUpdateTime, uint64 lastInterestRateAdjTime, uint256 annualInterestRate, address interestBatchManager, uint256 batchDebtShares ); function rewardSnapshots(uint256 _id) external view returns (uint256 coll, uint256 boldDebt); function getTroveIdsCount() external view returns (uint256); function getTroveFromTroveIdsArray(uint256 _index) external view returns (uint256); function getCurrentICR(uint256 _troveId, uint256 _price) external view returns (uint256); function lastZombieTroveId() external view returns (uint256); function batchLiquidateTroves(uint256[] calldata _troveArray) external; function redeemCollateral( address _sender, uint256 _boldAmount, uint256 _price, uint256 _redemptionRate, uint256 _maxIterations ) external returns (uint256 _redemeedAmount); function shutdown() external; function urgentRedemption(uint256 _boldAmount, uint256[] calldata _troveIds, uint256 _minCollateral) external; function getUnbackedPortionPriceAndRedeemability() external returns (uint256, uint256, bool); function getLatestTroveData(uint256 _troveId) external view returns (LatestTroveData memory); function getTroveAnnualInterestRate(uint256 _troveId) external view returns (uint256); function getTroveStatus(uint256 _troveId) external view returns (Status); function getLatestBatchData(address _batchAddress) external view returns (LatestBatchData memory); // -- permissioned functions called by BorrowerOperations function onOpenTrove(address _owner, uint256 _troveId, TroveChange memory _troveChange, uint256 _annualInterestRate) external; function onOpenTroveAndJoinBatch( address _owner, uint256 _troveId, TroveChange memory _troveChange, address _batchAddress, uint256 _batchColl, uint256 _batchDebt ) external; // Called from `adjustZombieTrove()` function setTroveStatusToActive(uint256 _troveId) external; function onAdjustTroveInterestRate( uint256 _troveId, uint256 _newColl, uint256 _newDebt, uint256 _newAnnualInterestRate, TroveChange calldata _troveChange ) external; function onAdjustTrove(uint256 _troveId, uint256 _newColl, uint256 _newDebt, TroveChange calldata _troveChange) external; function onAdjustTroveInsideBatch( uint256 _troveId, uint256 _newTroveColl, uint256 _newTroveDebt, TroveChange memory _troveChange, address _batchAddress, uint256 _newBatchColl, uint256 _newBatchDebt ) external; function onApplyTroveInterest( uint256 _troveId, uint256 _newTroveColl, uint256 _newTroveDebt, address _batchAddress, uint256 _newBatchColl, uint256 _newBatchDebt, TroveChange calldata _troveChange ) external; function onCloseTrove( uint256 _troveId, TroveChange memory _troveChange, // decrease vars: entire, with interest, batch fee and redistribution address _batchAddress, uint256 _newBatchColl, uint256 _newBatchDebt // entire, with interest and batch fee ) external; // -- batches -- function onRegisterBatchManager(address _batchAddress, uint256 _annualInterestRate, uint256 _annualFee) external; function onLowerBatchManagerAnnualFee( address _batchAddress, uint256 _newColl, uint256 _newDebt, uint256 _newAnnualManagementFee ) external; function onSetBatchManagerAnnualInterestRate( address _batchAddress, uint256 _newColl, uint256 _newDebt, uint256 _newAnnualInterestRate, uint256 _upfrontFee // needed by BatchUpdated event ) external; struct OnSetInterestBatchManagerParams { uint256 troveId; uint256 troveColl; // entire, with redistribution uint256 troveDebt; // entire, with interest, batch fee and redistribution TroveChange troveChange; address newBatchAddress; uint256 newBatchColl; // updated collateral for new batch manager uint256 newBatchDebt; // updated debt for new batch manager } function onSetInterestBatchManager(OnSetInterestBatchManagerParams calldata _params) external; function onRemoveFromBatch( uint256 _troveId, uint256 _newTroveColl, // entire, with redistribution uint256 _newTroveDebt, // entire, with interest, batch fee and redistribution TroveChange memory _troveChange, address _batchAddress, uint256 _newBatchColl, uint256 _newBatchDebt, // entire, with interest and batch fee uint256 _newAnnualInterestRate ) external; // -- end of permissioned functions -- } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./ILiquityBase.sol"; import "./IAddRemoveManagers.sol"; import "./IBoldToken.sol"; import "./IPriceFeed.sol"; import "./ISortedTroves.sol"; import "./ITroveManager.sol"; import "./IWETH.sol"; // Common interface for the Borrower Operations. interface IBorrowerOperations is ILiquityBase, IAddRemoveManagers { function CCR() external view returns (uint256); function MCR() external view returns (uint256); function SCR() external view returns (uint256); function openTrove( address _owner, uint256 _ownerIndex, uint256 _ETHAmount, uint256 _boldAmount, uint256 _upperHint, uint256 _lowerHint, uint256 _annualInterestRate, uint256 _maxUpfrontFee, address _addManager, address _removeManager, address _receiver ) external returns (uint256); struct OpenTroveAndJoinInterestBatchManagerParams { address owner; uint256 ownerIndex; uint256 collAmount; uint256 boldAmount; uint256 upperHint; uint256 lowerHint; address interestBatchManager; uint256 maxUpfrontFee; address addManager; address removeManager; address receiver; } function openTroveAndJoinInterestBatchManager(OpenTroveAndJoinInterestBatchManagerParams calldata _params) external returns (uint256); function addColl(uint256 _troveId, uint256 _ETHAmount) external; function withdrawColl(uint256 _troveId, uint256 _amount) external; function withdrawBold(uint256 _troveId, uint256 _amount, uint256 _maxUpfrontFee) external; function repayBold(uint256 _troveId, uint256 _amount) external; function closeTrove(uint256 _troveId) external; function adjustTrove( uint256 _troveId, uint256 _collChange, bool _isCollIncrease, uint256 _debtChange, bool isDebtIncrease, uint256 _maxUpfrontFee ) external; function adjustZombieTrove( uint256 _troveId, uint256 _collChange, bool _isCollIncrease, uint256 _boldChange, bool _isDebtIncrease, uint256 _upperHint, uint256 _lowerHint, uint256 _maxUpfrontFee ) external; function adjustTroveInterestRate( uint256 _troveId, uint256 _newAnnualInterestRate, uint256 _upperHint, uint256 _lowerHint, uint256 _maxUpfrontFee ) external; function applyPendingDebt(uint256 _troveId, uint256 _lowerHint, uint256 _upperHint) external; function onLiquidateTrove(uint256 _troveId) external; function claimCollateral() external; function hasBeenShutDown() external view returns (bool); function shutdown() external; function shutdownFromOracleFailure() external; function checkBatchManagerExists(address _batchMananger) external view returns (bool); // -- individual delegation -- struct InterestIndividualDelegate { address account; uint128 minInterestRate; uint128 maxInterestRate; uint256 minInterestRateChangePeriod; } function getInterestIndividualDelegateOf(uint256 _troveId) external view returns (InterestIndividualDelegate memory); function setInterestIndividualDelegate( uint256 _troveId, address _delegate, uint128 _minInterestRate, uint128 _maxInterestRate, // only needed if trove was previously in a batch: uint256 _newAnnualInterestRate, uint256 _upperHint, uint256 _lowerHint, uint256 _maxUpfrontFee, uint256 _minInterestRateChangePeriod ) external; function removeInterestIndividualDelegate(uint256 _troveId) external; // -- batches -- struct InterestBatchManager { uint128 minInterestRate; uint128 maxInterestRate; uint256 minInterestRateChangePeriod; } function registerBatchManager( uint128 minInterestRate, uint128 maxInterestRate, uint128 currentInterestRate, uint128 fee, uint128 minInterestRateChangePeriod ) external; function lowerBatchManagementFee(uint256 _newAnnualFee) external; function setBatchManagerAnnualInterestRate( uint128 _newAnnualInterestRate, uint256 _upperHint, uint256 _lowerHint, uint256 _maxUpfrontFee ) external; function interestBatchManagerOf(uint256 _troveId) external view returns (address); function getInterestBatchManager(address _account) external view returns (InterestBatchManager memory); function setInterestBatchManager( uint256 _troveId, address _newBatchManager, uint256 _upperHint, uint256 _lowerHint, uint256 _maxUpfrontFee ) external; function kickFromBatch(uint256 _troveId, uint256 _upperHint, uint256 _lowerHint) external; function removeFromBatch( uint256 _troveId, uint256 _newAnnualInterestRate, uint256 _upperHint, uint256 _lowerHint, uint256 _maxUpfrontFee ) external; function switchBatchManager( uint256 _troveId, uint256 _removeUpperHint, uint256 _removeLowerHint, address _newBatchManager, uint256 _addUpperHint, uint256 _addLowerHint, uint256 _maxUpfrontFee ) external; } //SPDX-License-Identifier: MIT pragma solidity ^0.8.12; // JSON utilities for base64 encoded ERC721 JSON metadata scheme library json { ///////////////////////////////////////////////////////////////////////////////////////////////////////////// /// @dev JSON requires that double quotes be escaped or JSONs will not build correctly /// string.concat also requires an escape, use \\" or the constant DOUBLE_QUOTES to represent " in JSON ///////////////////////////////////////////////////////////////////////////////////////////////////////////// string constant DOUBLE_QUOTES = '\\"'; function formattedMetadata( string memory name, string memory description, string memory svgImg, string memory attributes ) internal pure returns (string memory) { return string.concat( "data:application/json;base64,", encode( bytes( string.concat( "{", _prop("name", name), _prop("description", description), _xmlImage(svgImg), ',"attributes":', attributes, "}" ) ) ) ); } function _xmlImage(string memory _svgImg) internal pure returns (string memory) { return _prop("image", string.concat("data:image/svg+xml;base64,", encode(bytes(_svgImg))), true); } function _prop(string memory _key, string memory _val) internal pure returns (string memory) { return string.concat('"', _key, '": ', '"', _val, '", '); } function _prop(string memory _key, string memory _val, bool last) internal pure returns (string memory) { if (last) { return string.concat('"', _key, '": ', '"', _val, '"'); } else { return string.concat('"', _key, '": ', '"', _val, '", '); } } function _object(string memory _key, string memory _val) internal pure returns (string memory) { return string.concat('"', _key, '": ', "{", _val, "}"); } /** * taken from Openzeppelin * @dev Base64 Encoding/Decoding Table */ string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; /** * @dev Converts a `bytes` to its Bytes64 `string` representation. */ function encode(bytes memory data) internal pure returns (string memory) { /** * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol */ if (data.length == 0) return ""; // Loads the table into memory string memory table = _TABLE; // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter // and split into 4 numbers of 6 bits. // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up // - `data.length + 2` -> Round up // - `/ 3` -> Number of 3-bytes chunks // - `4 *` -> 4 characters for each chunk string memory result = new string(4 * ((data.length + 2) / 3)); assembly { // Prepare the lookup table (skip the first "length" byte) let tablePtr := add(table, 1) // Prepare result pointer, jump over length let resultPtr := add(result, 32) // Run over the input, 3 bytes at a time for { let dataPtr := data let endPtr := add(data, mload(data)) } lt(dataPtr, endPtr) {} { // Advance 3 bytes dataPtr := add(dataPtr, 3) let input := mload(dataPtr) // To write each character, shift the 3 bytes (18 bits) chunk // 4 times in blocks of 6 bits for each character (18, 12, 6, 0) // and apply logical AND with 0x3F which is the number of // the previous character in the ASCII table prior to the Base64 Table // The result is then added to the table to get the character to write, // and finally write it in the result pointer but with a left shift // of 256 (1 byte) - 8 (1 ASCII char) = 248 bits mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F)))) resultPtr := add(resultPtr, 1) // Advance mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F)))) resultPtr := add(resultPtr, 1) // Advance mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F)))) resultPtr := add(resultPtr, 1) // Advance mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F)))) resultPtr := add(resultPtr, 1) // Advance } // When data `bytes` is not exactly 3 bytes long // it is padded with `=` characters at the end switch mod(mload(data), 3) case 1 { mstore8(sub(resultPtr, 1), 0x3d) mstore8(sub(resultPtr, 2), 0x3d) } case 2 { mstore8(sub(resultPtr, 1), 0x3d) } } return result; } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IActivePool.sol"; import "./ILiquityBase.sol"; import "./IBoldToken.sol"; import "./ITroveManager.sol"; import "./IBoldRewardsReceiver.sol"; /* * The Stability Pool holds Bold tokens deposited by Stability Pool depositors. * * When a trove is liquidated, then depending on system conditions, some of its Bold debt gets offset with * Bold in the Stability Pool: that is, the offset debt evaporates, and an equal amount of Bold tokens in the Stability Pool is burned. * * Thus, a liquidation causes each depositor to receive a Bold loss, in proportion to their deposit as a share of total deposits. * They also receive an Coll gain, as the collateral of the liquidated trove is distributed among Stability depositors, * in the same proportion. * * When a liquidation occurs, it depletes every deposit by the same fraction: for example, a liquidation that depletes 40% * of the total Bold in the Stability Pool, depletes 40% of each deposit. * * A deposit that has experienced a series of liquidations is termed a "compounded deposit": each liquidation depletes the deposit, * multiplying it by some factor in range ]0,1[ * * Please see the implementation spec in the proof document, which closely follows on from the compounded deposit / Coll gain derivations: * https://github.com/liquity/liquity/blob/master/papers/Scalable_Reward_Distribution_with_Compounding_Stakes.pdf * */ interface IStabilityPool is ILiquityBase, IBoldRewardsReceiver { function boldToken() external view returns (IBoldToken); function troveManager() external view returns (ITroveManager); /* provideToSP(): * - Calculates depositor's Coll gain * - Calculates the compounded deposit * - Increases deposit, and takes new snapshots of accumulators P and S * - Sends depositor's accumulated Coll gains to depositor */ function provideToSP(uint256 _amount, bool _doClaim) external; /* withdrawFromSP(): * - Calculates depositor's Coll gain * - Calculates the compounded deposit * - Sends the requested BOLD withdrawal to depositor * - (If _amount > userDeposit, the user withdraws all of their compounded deposit) * - Decreases deposit by withdrawn amount and takes new snapshots of accumulators P and S */ function withdrawFromSP(uint256 _amount, bool doClaim) external; function claimAllCollGains() external; /* * Initial checks: * - Caller is TroveManager * --- * Cancels out the specified debt against the Bold contained in the Stability Pool (as far as possible) * and transfers the Trove's collateral from ActivePool to StabilityPool. * Only called by liquidation functions in the TroveManager. */ function offset(uint256 _debt, uint256 _coll) external; function deposits(address _depositor) external view returns (uint256 initialValue); function stashedColl(address _depositor) external view returns (uint256); /* * Returns the total amount of Coll held by the pool, accounted in an internal variable instead of `balance`, * to exclude edge cases like Coll received from a self-destruct. */ function getCollBalance() external view returns (uint256); /* * Returns Bold held in the pool. Changes when users deposit/withdraw, and when Trove debt is offset. */ function getTotalBoldDeposits() external view returns (uint256); function getYieldGainsOwed() external view returns (uint256); function getYieldGainsPending() external view returns (uint256); /* * Calculates the Coll gain earned by the deposit since its last snapshots were taken. */ function getDepositorCollGain(address _depositor) external view returns (uint256); /* * Calculates the BOLD yield gain earned by the deposit since its last snapshots were taken. */ function getDepositorYieldGain(address _depositor) external view returns (uint256); /* * Calculates what `getDepositorYieldGain` will be if interest is minted now. */ function getDepositorYieldGainWithPending(address _depositor) external view returns (uint256); /* * Return the user's compounded deposit. */ function getCompoundedBoldDeposit(address _depositor) external view returns (uint256); function scaleToS(uint256 _scale) external view returns (uint256); function scaleToB(uint256 _scale) external view returns (uint256); function P() external view returns (uint256); function currentScale() external view returns (uint256); function P_PRECISION() external view returns (uint256); } //SPDX-License-Identifier: MIT pragma solidity 0.8.24; import "Solady/utils/SSTORE2.sol"; import "./utils/JSON.sol"; import "./utils/baseSVG.sol"; import "./utils/bauhaus.sol"; import "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import {ITroveManager} from "../Interfaces/ITroveManager.sol"; interface IMetadataNFT { struct TroveData { uint256 _tokenId; address _owner; address _collToken; address _boldToken; uint256 _collAmount; uint256 _debtAmount; uint256 _interestRate; ITroveManager.Status _status; } function uri(TroveData memory _troveData) external view returns (string memory); } contract MetadataNFT is IMetadataNFT { FixedAssetReader public immutable assetReader; constructor(FixedAssetReader _assetReader) { assetReader = _assetReader; } function uri(TroveData memory _troveData) public view returns (string memory) { string memory attr = attributes(_troveData); return json.formattedMetadata( string.concat("Liquity V2 - ", IERC20Metadata(_troveData._collToken).name()), string.concat( "Liquity V2 is a collateralized debt platform. Users can lock up ", IERC20Metadata(_troveData._collToken).symbol(), " to issue stablecoin tokens (BOLD) to their own Ethereum address. The individual collateralized debt positions are called Troves, and are represented as NFTs." ), renderSVGImage(_troveData), attr ); } function renderSVGImage(TroveData memory _troveData) internal view returns (string memory) { return svg._svg( baseSVG._svgProps(), string.concat( baseSVG._baseElements(assetReader), bauhaus._bauhaus(IERC20Metadata(_troveData._collToken).symbol(), _troveData._tokenId), dynamicTextComponents(_troveData) ) ); } function attributes(TroveData memory _troveData) public pure returns (string memory) { //include: collateral token address, collateral amount, debt token address, debt amount, interest rate, status return string.concat( '[{"trait_type": "Collateral Token", "value": "', LibString.toHexString(_troveData._collToken), '"}, {"trait_type": "Collateral Amount", "value": "', LibString.toString(_troveData._collAmount), '"}, {"trait_type": "Debt Token", "value": "', LibString.toHexString(_troveData._boldToken), '"}, {"trait_type": "Debt Amount", "value": "', LibString.toString(_troveData._debtAmount), '"}, {"trait_type": "Interest Rate", "value": "', LibString.toString(_troveData._interestRate), '"}, {"trait_type": "Status", "value": "', _status2Str(_troveData._status), '"} ]' ); } function dynamicTextComponents(TroveData memory _troveData) public view returns (string memory) { string memory id = LibString.toHexString(_troveData._tokenId); id = string.concat(LibString.slice(id, 0, 6), "...", LibString.slice(id, 38, 42)); return string.concat( baseSVG._formattedIdEl(id), baseSVG._formattedAddressEl(_troveData._owner), baseSVG._collLogo(IERC20Metadata(_troveData._collToken).symbol(), assetReader), baseSVG._statusEl(_status2Str(_troveData._status)), baseSVG._dynamicTextEls(_troveData._debtAmount, _troveData._collAmount, _troveData._interestRate) ); } function _status2Str(ITroveManager.Status status) internal pure returns (string memory) { if (status == ITroveManager.Status.active) return "Active"; if (status == ITroveManager.Status.closedByOwner) return "Closed"; if (status == ITroveManager.Status.closedByLiquidation) return "Liquidated"; if (status == ITroveManager.Status.zombie) return "Below Min Debt"; return ""; } } // SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.24; address constant ZERO_ADDRESS = address(0); uint256 constant MAX_UINT256 = type(uint256).max; uint256 constant DECIMAL_PRECISION = 1e18; uint256 constant _100pct = DECIMAL_PRECISION; uint256 constant _1pct = DECIMAL_PRECISION / 100; // Amount of ETH to be locked in gas pool on opening troves uint256 constant ETH_GAS_COMPENSATION = 0.0375 ether; // Liquidation uint256 constant MIN_LIQUIDATION_PENALTY_SP = 5e16; // 5% uint256 constant MAX_LIQUIDATION_PENALTY_REDISTRIBUTION = 20e16; // 20% // Collateral branch parameters (SETH = staked ETH, i.e. wstETH / rETH) uint256 constant CCR_WETH = 150 * _1pct; uint256 constant CCR_SETH = 160 * _1pct; uint256 constant MCR_WETH = 110 * _1pct; uint256 constant MCR_SETH = 120 * _1pct; uint256 constant SCR_WETH = 110 * _1pct; uint256 constant SCR_SETH = 120 * _1pct; // Batch CR buffer (same for all branches for now) // On top of MCR to join a batch, or adjust inside a batch uint256 constant BCR_ALL = 10 * _1pct; uint256 constant LIQUIDATION_PENALTY_SP_WETH = 5 * _1pct; uint256 constant LIQUIDATION_PENALTY_SP_SETH = 5 * _1pct; uint256 constant LIQUIDATION_PENALTY_REDISTRIBUTION_WETH = 10 * _1pct; uint256 constant LIQUIDATION_PENALTY_REDISTRIBUTION_SETH = 20 * _1pct; // Fraction of collateral awarded to liquidator uint256 constant COLL_GAS_COMPENSATION_DIVISOR = 200; // dividing by 200 yields 0.5% uint256 constant COLL_GAS_COMPENSATION_CAP = 2 ether; // Max coll gas compensation capped at 2 ETH // Minimum amount of net Bold debt a trove must have uint256 constant MIN_DEBT = 2000e18; uint256 constant MIN_ANNUAL_INTEREST_RATE = _1pct / 2; // 0.5% uint256 constant MAX_ANNUAL_INTEREST_RATE = 250 * _1pct; // Batch management params uint128 constant MAX_ANNUAL_BATCH_MANAGEMENT_FEE = uint128(_100pct / 10); // 10% uint128 constant MIN_INTEREST_RATE_CHANGE_PERIOD = 1 hours; // only applies to batch managers / batched Troves uint256 constant REDEMPTION_FEE_FLOOR = _1pct / 2; // 0.5% // For the debt / shares ratio to increase by a factor 1e9 // at a average annual debt increase (compounded interest + fees) of 10%, it would take more than 217 years (log(1e9)/log(1.1)) // at a average annual debt increase (compounded interest + fees) of 50%, it would take more than 51 years (log(1e9)/log(1.5)) // The increase pace could be forced to be higher through an inflation attack, // but precisely the fact that we have this max value now prevents the attack uint256 constant MAX_BATCH_SHARES_RATIO = 1e9; // Half-life of 6h. 6h = 360 min // (1/2) = d^360 => d = (1/2)^(1/360) uint256 constant REDEMPTION_MINUTE_DECAY_FACTOR = 998076443575628800; // BETA: 18 digit decimal. Parameter by which to divide the redeemed fraction, in order to calc the new base rate from a redemption. // Corresponds to (1 / ALPHA) in the white paper. uint256 constant REDEMPTION_BETA = 1; // To prevent redemptions unless Bold depegs below 0.95 and allow the system to take off uint256 constant INITIAL_BASE_RATE = _100pct; // 100% initial redemption rate // Discount to be used once the shutdown thas been triggered uint256 constant URGENT_REDEMPTION_BONUS = 2e16; // 2% uint256 constant ONE_MINUTE = 1 minutes; uint256 constant ONE_YEAR = 365 days; uint256 constant UPFRONT_INTEREST_PERIOD = 7 days; uint256 constant INTEREST_RATE_ADJ_COOLDOWN = 7 days; uint256 constant SP_YIELD_SPLIT = 75 * _1pct; // 75% uint256 constant MIN_BOLD_IN_SP = 1e18; // Dummy contract that lets legacy Hardhat tests query some of the constants contract Constants { uint256 public constant _ETH_GAS_COMPENSATION = ETH_GAS_COMPENSATION; uint256 public constant _MIN_DEBT = MIN_DEBT; } // SPDX-License-Identifier: MIT pragma solidity 0.8.24; import {DECIMAL_PRECISION} from "./Constants.sol"; library LiquityMath { function _min(uint256 _a, uint256 _b) internal pure returns (uint256) { return (_a < _b) ? _a : _b; } function _max(uint256 _a, uint256 _b) internal pure returns (uint256) { return (_a >= _b) ? _a : _b; } function _sub_min_0(uint256 _a, uint256 _b) internal pure returns (uint256) { return (_a > _b) ? _a - _b : 0; } /* * Multiply two decimal numbers and use normal rounding rules: * -round product up if 19'th mantissa digit >= 5 * -round product down if 19'th mantissa digit < 5 * * Used only inside the exponentiation, _decPow(). */ function decMul(uint256 x, uint256 y) internal pure returns (uint256 decProd) { uint256 prod_xy = x * y; decProd = (prod_xy + DECIMAL_PRECISION / 2) / DECIMAL_PRECISION; } /* * _decPow: Exponentiation function for 18-digit decimal base, and integer exponent n. * * Uses the efficient "exponentiation by squaring" algorithm. O(log(n)) complexity. * * Called by function CollateralRegistry._calcDecayedBaseRate, that represent time in units of minutes * * The exponent is capped to avoid reverting due to overflow. The cap 525600000 equals * "minutes in 1000 years": 60 * 24 * 365 * 1000 * * If a period of > 1000 years is ever used as an exponent in either of the above functions, the result will be * negligibly different from just passing the cap, since: * * In function 1), the decayed base rate will be 0 for 1000 years or > 1000 years * In function 2), the difference in tokens issued at 1000 years and any time > 1000 years, will be negligible */ function _decPow(uint256 _base, uint256 _minutes) internal pure returns (uint256) { if (_minutes > 525600000) _minutes = 525600000; // cap to avoid overflow if (_minutes == 0) return DECIMAL_PRECISION; uint256 y = DECIMAL_PRECISION; uint256 x = _base; uint256 n = _minutes; // Exponentiation-by-squaring while (n > 1) { if (n % 2 == 0) { x = decMul(x, x); n = n / 2; } else { // if (n % 2 != 0) y = decMul(x, y); x = decMul(x, x); n = (n - 1) / 2; } } return decMul(x, y); } function _getAbsoluteDifference(uint256 _a, uint256 _b) internal pure returns (uint256) { return (_a >= _b) ? _a - _b : _b - _a; } function _computeCR(uint256 _coll, uint256 _debt, uint256 _price) internal pure returns (uint256) { if (_debt > 0) { uint256 newCollRatio = _coll * _price / _debt; return newCollRatio; } // Return the maximal value for uint256 if the debt is 0. Represents "infinite" CR. else { // if (_debt == 0) return 2 ** 256 - 1; } } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IActivePool.sol"; import "./IBoldToken.sol"; import "./IBorrowerOperations.sol"; import "./ICollSurplusPool.sol"; import "./IDefaultPool.sol"; import "./IHintHelpers.sol"; import "./IMultiTroveGetter.sol"; import "./ISortedTroves.sol"; import "./IStabilityPool.sol"; import "./ITroveManager.sol"; import "./ITroveNFT.sol"; import {IMetadataNFT} from "../NFTMetadata/MetadataNFT.sol"; import "./ICollateralRegistry.sol"; import "./IInterestRouter.sol"; import "./IPriceFeed.sol"; interface IAddressesRegistry { struct AddressVars { IERC20Metadata collToken; IBorrowerOperations borrowerOperations; ITroveManager troveManager; ITroveNFT troveNFT; IMetadataNFT metadataNFT; IStabilityPool stabilityPool; IPriceFeed priceFeed; IActivePool activePool; IDefaultPool defaultPool; address gasPoolAddress; ICollSurplusPool collSurplusPool; ISortedTroves sortedTroves; IInterestRouter interestRouter; IHintHelpers hintHelpers; IMultiTroveGetter multiTroveGetter; ICollateralRegistry collateralRegistry; IBoldToken boldToken; IWETH WETH; } function CCR() external returns (uint256); function SCR() external returns (uint256); function MCR() external returns (uint256); function BCR() external returns (uint256); function LIQUIDATION_PENALTY_SP() external returns (uint256); function LIQUIDATION_PENALTY_REDISTRIBUTION() external returns (uint256); function collToken() external view returns (IERC20Metadata); function borrowerOperations() external view returns (IBorrowerOperations); function troveManager() external view returns (ITroveManager); function troveNFT() external view returns (ITroveNFT); function metadataNFT() external view returns (IMetadataNFT); function stabilityPool() external view returns (IStabilityPool); function priceFeed() external view returns (IPriceFeed); function activePool() external view returns (IActivePool); function defaultPool() external view returns (IDefaultPool); function gasPoolAddress() external view returns (address); function collSurplusPool() external view returns (ICollSurplusPool); function sortedTroves() external view returns (ISortedTroves); function interestRouter() external view returns (IInterestRouter); function hintHelpers() external view returns (IHintHelpers); function multiTroveGetter() external view returns (IMultiTroveGetter); function collateralRegistry() external view returns (ICollateralRegistry); function boldToken() external view returns (IBoldToken); function WETH() external returns (IWETH); function setAddresses(AddressVars memory _vars) external; } // SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.24; import "./Constants.sol"; import "./LiquityMath.sol"; import "../Interfaces/IAddressesRegistry.sol"; import "../Interfaces/IActivePool.sol"; import "../Interfaces/IDefaultPool.sol"; import "../Interfaces/IPriceFeed.sol"; import "../Interfaces/ILiquityBase.sol"; /* * Base contract for TroveManager, BorrowerOperations and StabilityPool. Contains global system constants and * common functions. */ contract LiquityBase is ILiquityBase { IActivePool public activePool; IDefaultPool internal defaultPool; IPriceFeed internal priceFeed; event ActivePoolAddressChanged(address _newActivePoolAddress); event DefaultPoolAddressChanged(address _newDefaultPoolAddress); event PriceFeedAddressChanged(address _newPriceFeedAddress); constructor(IAddressesRegistry _addressesRegistry) { activePool = _addressesRegistry.activePool(); defaultPool = _addressesRegistry.defaultPool(); priceFeed = _addressesRegistry.priceFeed(); emit ActivePoolAddressChanged(address(activePool)); emit DefaultPoolAddressChanged(address(defaultPool)); emit PriceFeedAddressChanged(address(priceFeed)); } // --- Gas compensation functions --- function getEntireBranchColl() public view returns (uint256 entireSystemColl) { uint256 activeColl = activePool.getCollBalance(); uint256 liquidatedColl = defaultPool.getCollBalance(); return activeColl + liquidatedColl; } function getEntireBranchDebt() public view returns (uint256 entireSystemDebt) { uint256 activeDebt = activePool.getBoldDebt(); uint256 closedDebt = defaultPool.getBoldDebt(); return activeDebt + closedDebt; } function _getTCR(uint256 _price) internal view returns (uint256 TCR) { uint256 entireSystemColl = getEntireBranchColl(); uint256 entireSystemDebt = getEntireBranchDebt(); TCR = LiquityMath._computeCR(entireSystemColl, entireSystemDebt, _price); return TCR; } function _checkBelowCriticalThreshold(uint256 _price, uint256 _CCR) internal view returns (bool) { uint256 TCR = _getTCR(_price); return TCR < _CCR; } function _calcInterest(uint256 _weightedDebt, uint256 _period) internal pure returns (uint256) { return _weightedDebt * _period / ONE_YEAR / DECIMAL_PRECISION; } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IInterestRouter.sol"; import "./IBoldRewardsReceiver.sol"; import "../Types/TroveChange.sol"; interface IActivePool { function defaultPoolAddress() external view returns (address); function borrowerOperationsAddress() external view returns (address); function troveManagerAddress() external view returns (address); function interestRouter() external view returns (IInterestRouter); // We avoid IStabilityPool here in order to prevent creating a dependency cycle that would break flattening function stabilityPool() external view returns (IBoldRewardsReceiver); function getCollBalance() external view returns (uint256); function getBoldDebt() external view returns (uint256); function lastAggUpdateTime() external view returns (uint256); function aggRecordedDebt() external view returns (uint256); function aggWeightedDebtSum() external view returns (uint256); function aggBatchManagementFees() external view returns (uint256); function aggWeightedBatchManagementFeeSum() external view returns (uint256); function calcPendingAggInterest() external view returns (uint256); function calcPendingSPYield() external view returns (uint256); function calcPendingAggBatchManagementFee() external view returns (uint256); function getNewApproxAvgInterestRateFromTroveChange(TroveChange calldata _troveChange) external view returns (uint256); function mintAggInterest() external; function mintAggInterestAndAccountForTroveChange(TroveChange calldata _troveChange, address _batchManager) external; function mintBatchManagementFeeAndAccountForChange(TroveChange calldata _troveChange, address _batchAddress) external; function setShutdownFlag() external; function hasBeenShutDown() external view returns (bool); function shutdownTime() external view returns (uint256); function sendColl(address _account, uint256 _amount) external; function sendCollToDefaultPool(uint256 _amount) external; function receiveColl(uint256 _amount) external; function accountForReceivedColl(uint256 _amount) external; } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./ITroveManager.sol"; import {BatchId, BATCH_ID_ZERO} from "../Types/BatchId.sol"; interface ISortedTroves { // -- Mutating functions (permissioned) -- function insert(uint256 _id, uint256 _annualInterestRate, uint256 _prevId, uint256 _nextId) external; function insertIntoBatch( uint256 _troveId, BatchId _batchId, uint256 _annualInterestRate, uint256 _prevId, uint256 _nextId ) external; function remove(uint256 _id) external; function removeFromBatch(uint256 _id) external; function reInsert(uint256 _id, uint256 _newAnnualInterestRate, uint256 _prevId, uint256 _nextId) external; function reInsertBatch(BatchId _id, uint256 _newAnnualInterestRate, uint256 _prevId, uint256 _nextId) external; // -- View functions -- function contains(uint256 _id) external view returns (bool); function isBatchedNode(uint256 _id) external view returns (bool); function isEmptyBatch(BatchId _id) external view returns (bool); function isEmpty() external view returns (bool); function getSize() external view returns (uint256); function getFirst() external view returns (uint256); function getLast() external view returns (uint256); function getNext(uint256 _id) external view returns (uint256); function getPrev(uint256 _id) external view returns (uint256); function validInsertPosition(uint256 _annualInterestRate, uint256 _prevId, uint256 _nextId) external view returns (bool); function findInsertPosition(uint256 _annualInterestRate, uint256 _prevId, uint256 _nextId) external view returns (uint256, uint256); // Public state variable getters function borrowerOperationsAddress() external view returns (address); function troveManager() external view returns (ITroveManager); function size() external view returns (uint256); function nodes(uint256 _id) external view returns (uint256 nextId, uint256 prevId, BatchId batchId, bool exists); function batches(BatchId _id) external view returns (uint256 head, uint256 tail); } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IHintHelpers { function getApproxHint(uint256 _collIndex, uint256 _interestRate, uint256 _numTrials, uint256 _inputRandomSeed) external view returns (uint256 hintId, uint256 diff, uint256 latestRandomSeed); function predictOpenTroveUpfrontFee(uint256 _collIndex, uint256 _borrowedAmount, uint256 _interestRate) external view returns (uint256); function predictAdjustInterestRateUpfrontFee(uint256 _collIndex, uint256 _troveId, uint256 _newInterestRate) external view returns (uint256); function forcePredictAdjustInterestRateUpfrontFee(uint256 _collIndex, uint256 _troveId, uint256 _newInterestRate) external view returns (uint256); function predictAdjustTroveUpfrontFee(uint256 _collIndex, uint256 _troveId, uint256 _debtIncrease) external view returns (uint256); function predictAdjustBatchInterestRateUpfrontFee( uint256 _collIndex, address _batchAddress, uint256 _newInterestRate ) external view returns (uint256); function predictJoinBatchInterestRateUpfrontFee(uint256 _collIndex, uint256 _troveId, address _batchAddress) external view returns (uint256); } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "./IBoldToken.sol"; import "./ITroveManager.sol"; interface ICollateralRegistry { function baseRate() external view returns (uint256); function lastFeeOperationTime() external view returns (uint256); function redeemCollateral(uint256 _boldamount, uint256 _maxIterations, uint256 _maxFeePercentage) external; // getters function totalCollaterals() external view returns (uint256); function getToken(uint256 _index) external view returns (IERC20Metadata); function getTroveManager(uint256 _index) external view returns (ITroveManager); function boldToken() external view returns (IBoldToken); function getRedemptionRate() external view returns (uint256); function getRedemptionRateWithDecay() external view returns (uint256); function getRedemptionRateForRedeemedAmount(uint256 _redeemAmount) external view returns (uint256); function getRedemptionFeeWithDecay(uint256 _ETHDrawn) external view returns (uint256); function getEffectiveRedemptionFeeInBold(uint256 _redeemAmount) external view returns (uint256); } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IMultiTroveGetter { struct CombinedTroveData { uint256 id; uint256 entireDebt; uint256 entireColl; uint256 redistBoldDebtGain; uint256 redistCollGain; uint256 accruedInterest; uint256 recordedDebt; uint256 annualInterestRate; uint256 accruedBatchManagementFee; uint256 lastInterestRateAdjTime; uint256 stake; uint256 lastDebtUpdateTime; address interestBatchManager; uint256 batchDebtShares; uint256 snapshotETH; uint256 snapshotBoldDebt; } struct DebtPerInterestRate { address interestBatchManager; uint256 interestRate; uint256 debt; } function getMultipleSortedTroves(uint256 _collIndex, int256 _startIdx, uint256 _count) external view returns (CombinedTroveData[] memory _troves); function getDebtPerInterestRateAscending(uint256 _collIndex, uint256 _startId, uint256 _maxIterations) external view returns (DebtPerInterestRate[] memory, uint256 currId); } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IStabilityPoolEvents { enum Operation { provideToSP, withdrawFromSP, claimAllCollGains } event StabilityPoolCollBalanceUpdated(uint256 _newBalance); event StabilityPoolBoldBalanceUpdated(uint256 _newBalance); event P_Updated(uint256 _P); event S_Updated(uint256 _S, uint256 _scale); event B_Updated(uint256 _B, uint256 _scale); event ScaleUpdated(uint256 _currentScale); event DepositUpdated( address indexed _depositor, uint256 _newDeposit, uint256 _stashedColl, uint256 _snapshotP, uint256 _snapshotS, uint256 _snapshotB, uint256 _snapshotScale ); event DepositOperation( address indexed _depositor, Operation _operation, uint256 _depositLossSinceLastOperation, int256 _topUpOrWithdrawal, uint256 _yieldGainSinceLastOperation, uint256 _yieldGainClaimed, uint256 _ethGainSinceLastOperation, uint256 _ethGainClaimed ); } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol"; import "openzeppelin-contracts/contracts/interfaces/IERC5267.sol"; interface IBoldToken is IERC20Metadata, IERC20Permit, IERC5267 { function setBranchAddresses( address _troveManagerAddress, address _stabilityPoolAddress, address _borrowerOperationsAddress, address _activePoolAddress ) external; function setCollateralRegistry(address _collateralRegistryAddress) external; function mint(address _account, uint256 _amount) external; function burn(address _account, uint256 _amount) external; function sendToPool(address _sender, address poolAddress, uint256 _amount) external; function returnFromPool(address poolAddress, address user, uint256 _amount) external; } //SPDX-License-Identifier: MIT pragma solidity 0.8.24; import "Solady/utils/SSTORE2.sol"; contract FixedAssetReader { struct Asset { uint128 start; uint128 end; } address public immutable pointer; mapping(bytes4 => Asset) public assets; function readAsset(bytes4 _sig) public view returns (string memory) { return string(SSTORE2.read(pointer, uint256(assets[_sig].start), uint256(assets[_sig].end))); } constructor(address _pointer, bytes4[] memory _sigs, Asset[] memory _assets) { pointer = _pointer; require(_sigs.length == _assets.length, "FixedAssetReader: Invalid input"); for (uint256 i = 0; i < _sigs.length; i++) { assets[_sigs[i]] = _assets[i]; } } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IDefaultPool { function troveManagerAddress() external view returns (address); function activePoolAddress() external view returns (address); // --- Functions --- function getCollBalance() external view returns (uint256); function getBoldDebt() external view returns (uint256); function sendCollToActivePool(uint256 _amount) external; function receiveColl(uint256 _amount) external; function increaseBoldDebt(uint256 _amount) external; function decreaseBoldDebt(uint256 _amount) external; } // SPDX-License-Identifier: MIT pragma solidity 0.8.24; type BatchId is address; using {equals as ==, notEquals as !=, isZero, isNotZero} for BatchId global; function equals(BatchId a, BatchId b) pure returns (bool) { return BatchId.unwrap(a) == BatchId.unwrap(b); } function notEquals(BatchId a, BatchId b) pure returns (bool) { return !(a == b); } function isZero(BatchId x) pure returns (bool) { return x == BATCH_ID_ZERO; } function isNotZero(BatchId x) pure returns (bool) { return !x.isZero(); } BatchId constant BATCH_ID_ZERO = BatchId.wrap(address(0)); // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IAddRemoveManagers { function setAddManager(uint256 _troveId, address _manager) external; function setRemoveManager(uint256 _troveId, address _manager) external; function setRemoveManagerWithReceiver(uint256 _troveId, address _manager, address _receiver) external; function addManagerOf(uint256 _troveId) external view returns (address); function removeManagerReceiverOf(uint256 _troveId) external view returns (address, address); } // SPDX-License-Identifier: MIT pragma solidity 0.8.24; struct LatestBatchData { uint256 totalDebtShares; uint256 entireDebtWithoutRedistribution; uint256 entireCollWithoutRedistribution; uint256 accruedInterest; uint256 recordedDebt; uint256 annualInterestRate; uint256 weightedRecordedDebt; uint256 annualManagementFee; uint256 accruedManagementFee; uint256 weightedRecordedBatchManagementFee; uint256 lastDebtUpdateTime; uint256 lastInterestRateAdjTime; } // SPDX-License-Identifier: MIT pragma solidity 0.8.24; struct TroveChange { uint256 appliedRedistBoldDebtGain; uint256 appliedRedistCollGain; uint256 collIncrease; uint256 collDecrease; uint256 debtIncrease; uint256 debtDecrease; uint256 newWeightedRecordedDebt; uint256 oldWeightedRecordedDebt; uint256 upfrontFee; uint256 batchAccruedManagementFee; uint256 newWeightedRecordedBatchManagementFee; uint256 oldWeightedRecordedBatchManagementFee; } // SPDX-License-Identifier: MIT pragma solidity 0.8.24; struct LatestTroveData { uint256 entireDebt; uint256 entireColl; uint256 redistBoldDebtGain; uint256 redistCollGain; uint256 accruedInterest; uint256 recordedDebt; uint256 annualInterestRate; uint256 weightedRecordedDebt; uint256 accruedBatchManagementFee; uint256 lastInterestRateAdjTime; } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IActivePool.sol"; import "./IDefaultPool.sol"; import "./IPriceFeed.sol"; interface ILiquityBase { function activePool() external view returns (IActivePool); function getEntireBranchDebt() external view returns (uint256); function getEntireBranchColl() external view returns (uint256); } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface ICollSurplusPool { function getCollBalance() external view returns (uint256); function getCollateral(address _account) external view returns (uint256); function accountSurplus(address _account, uint256 _amount) external; function claimColl(address _account) external; } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "openzeppelin-contracts/contracts/token/ERC721/extensions/IERC721Metadata.sol"; import "./ITroveManager.sol"; interface ITroveNFT is IERC721Metadata { function mint(address _owner, uint256 _troveId) external; function burn(uint256 _troveId) external; } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IPriceFeed { function fetchPrice() external returns (uint256, bool); function fetchRedemptionPrice() external returns (uint256, bool); function lastGoodPrice() external view returns (uint256); } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol"; interface IWETH is IERC20Metadata { function deposit() external payable; function withdraw(uint256 wad) external; } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IInterestRouter { // Currently the Interest Router doesn’t need any specific function } // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IBoldRewardsReceiver { function triggerBoldRewards(uint256 _boldYield) external; }

Visual Contract Explorer

Contract Activity

Top Callers

Related Contracts

Build smart contracts visually