@bananapus/distributor-v6 0.0.28 → 0.0.30

package/src/JBTokenDistributor.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.28;
 
+import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
 import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
 import {IJBSplitHook} from "@bananapus/core-v6/src/interfaces/IJBSplitHook.sol";
 import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
@@ -10,6 +11,8 @@ import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {mulDiv} from "@prb/math/src/Common.sol";
+import {IREVLoans} from "@rev-net/core-v6/src/interfaces/IREVLoans.sol";
+import {IREVOwner} from "@rev-net/core-v6/src/interfaces/IREVOwner.sol";
 
 import {JBDistributor} from "./JBDistributor.sol";
 import {IJBDistributor} from "./interfaces/IJBDistributor.sol";
@@ -66,14 +69,22 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
     //*********************************************************************//
 
     /// @param directory The JB directory used to verify terminal/controller callers.
+    /// @param controller The JB controller used to burn expired or forfeited project-token rewards.
+    /// @param revLoans The Revnet loans contract used to borrow against vested revnet rewards.
+    /// @param revOwner The REVOwner contract that must own revnet reward token projects.
     /// @param initialRoundDuration The duration of each round, specified in seconds.
     /// @param initialVestingRounds The number of rounds until tokens are fully vested.
+    /// @param initialClaimDuration The number of seconds claimants have after each reward round becomes claimable.
     constructor(
         IJBDirectory directory,
+        IJBController controller,
+        IREVLoans revLoans,
+        IREVOwner revOwner,
         uint256 initialRoundDuration,
-        uint256 initialVestingRounds
+        uint256 initialVestingRounds,
+        uint48 initialClaimDuration
     )
-        JBDistributor(initialRoundDuration, initialVestingRounds)
+        JBDistributor(controller, revLoans, revOwner, initialRoundDuration, initialVestingRounds, initialClaimDuration)
     {
         DIRECTORY = directory;
     }
@@ -111,7 +122,7 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
 
             if (msg.value != 0) {
                 // Assign native split proceeds to the current reward round for this IVotes hook.
-                _recordRewardFunding({hook: hook, token: IERC20(context.token), amount: msg.value, claimDuration: 0});
+                _recordRewardFunding({hook: hook, token: IERC20(context.token), amount: msg.value});
             }
         } else {
             // Validate that native ETH is not cross-booked under an ERC-20 token.
@@ -129,7 +140,7 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
                 _acceptErc20FundsFrom({token: IERC20(context.token), from: msg.sender, amount: context.amount});
 
             // Assign only the amount actually received to this round's reward pot.
-            _recordRewardFunding({hook: hook, token: IERC20(context.token), amount: delta, claimDuration: 0});
+            _recordRewardFunding({hook: hook, token: IERC20(context.token), amount: delta});
         }
     }
 
@@ -206,14 +217,14 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
     /// @param hook The IVotes token whose stakers are claiming.
     /// @param tokenIds The encoded staker addresses to claim for.
     /// @param tokens The reward tokens to claim.
-    function _claimPastRewards(address hook, uint256[] calldata tokenIds, IERC20[] calldata tokens) internal {
+    function _claimPastRewards(address hook, uint256[] calldata tokenIds, IERC20[] calldata tokens) internal override {
         // Round 0 has no completed reward rounds behind it, so nothing can be claimed yet.
         uint256 round = currentRound();
         if (round == 0) return;
 
         // Current-round funding is excluded. It becomes claimable only after a later round starts.
         JBClaimContext memory ctx =
-            JBClaimContext({hook: hook, lastClaimableRound: round - 1, vestingReleaseRound: round + vestingRounds});
+            JBClaimContext({hook: hook, lastClaimableRound: round - 1, vestingReleaseRound: round + VESTING_ROUNDS});
 
         // Process each reward token independently because each token has its own round funding and claim cursor.
         for (uint256 i; i < tokens.length;) {
@@ -398,7 +409,7 @@ contract JBTokenDistributor is JBDistributor, IJBTokenDistributor {
     /// @notice Revert unless the caller is authorized to claim each token ID.
     /// @param hook The IVotes token whose stakers are claiming.
     /// @param tokenIds The encoded staker addresses to check.
-    function _requireCanClaimTokenIds(address hook, uint256[] calldata tokenIds) internal view {
+    function _requireCanClaimTokenIds(address hook, uint256[] calldata tokenIds) internal view override {
         // Each tokenId is an encoded address, so every requested claim must belong to msg.sender.
         for (uint256 i; i < tokenIds.length;) {
             if (!_canClaim({hook: hook, tokenId: tokenIds[i], account: msg.sender})) {

package/src/interfaces/IJBDistributor.sol

@@ -1,9 +1,13 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
+import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IREVLoans} from "@rev-net/core-v6/src/interfaces/IREVLoans.sol";
+import {IREVOwner} from "@rev-net/core-v6/src/interfaces/IREVOwner.sol";
 
 import {JBTokenSnapshotData} from "../structs/JBTokenSnapshotData.sol";
+import {JBVestingLoan} from "../structs/JBVestingLoan.sol";
 
 /// @notice Interface for round-based reward distributors with linear vesting. Stakers claim their share of funded
 /// reward rounds, and claimed amounts vest linearly over a configurable number of rounds.
@@ -13,6 +17,32 @@ interface IJBDistributor {
     // -------------------------------- events --------------------------- //
     //*********************************************************************//
 
+    /// @notice Emitted when vesting revnet rewards are used as Revnet loan collateral.
+    /// @param hook The hook whose token ID owns the vesting rewards.
+    /// @param tokenId The token ID whose vesting rewards are collateralized.
+    /// @param token The revnet reward token used as collateral.
+    /// @param loanId The Revnet loan NFT ID held by this distributor.
+    /// @param revnetId The revnet whose project token is collateralized.
+    /// @param collateralCount The amount of vesting rewards used as collateral.
+    /// @param sourceToken The token borrowed from the revnet.
+    /// @param minBorrowAmount The minimum amount to borrow.
+    /// @param prepaidFeePercent The prepaid fee percent used by the loan.
+    /// @param beneficiary The recipient of the borrowed funds.
+    /// @param caller The address that opened the loan.
+    event BorrowAgainstVesting(
+        address indexed hook,
+        uint256 indexed tokenId,
+        IERC20 indexed token,
+        uint256 loanId,
+        uint256 revnetId,
+        uint256 collateralCount,
+        address sourceToken,
+        uint256 minBorrowAmount,
+        uint256 prepaidFeePercent,
+        address beneficiary,
+        address caller
+    );
+
     /// @notice Emitted when a staker begins vesting tokens.
     /// @param hook The hook whose stakers are vesting.
     /// @param tokenId The ID of the staked token that is claiming.
@@ -61,6 +91,38 @@ interface IJBDistributor {
         address indexed hook, uint256 indexed round, IERC20 indexed token, uint256 amount, address caller
     );
 
+    /// @notice Emitted when a liquidated distributor-held Revnet loan is written off.
+    /// @param hook The hook whose vesting rewards were collateralized.
+    /// @param tokenId The token ID whose vesting rewards were collateralized.
+    /// @param token The revnet reward token whose collateral was liquidated.
+    /// @param loanId The liquidated Revnet loan NFT ID.
+    /// @param collateralCount The amount of vesting rewards forfeited by liquidation.
+    /// @param caller The address that triggered the write-off.
+    event LiquidatedVestingLoanWrittenOff(
+        address indexed hook,
+        uint256 indexed tokenId,
+        IERC20 indexed token,
+        uint256 loanId,
+        uint256 collateralCount,
+        address caller
+    );
+
+    /// @notice Emitted when a distributor-held Revnet loan is repaid and its collateral resumes vesting.
+    /// @param loanId The Revnet loan NFT ID that was repaid.
+    /// @param paidOffLoanId The paid-off loan ID returned by Revnet loans.
+    /// @param token The revnet reward token restored to vesting.
+    /// @param collateralCount The amount of vesting rewards restored.
+    /// @param repayBorrowAmount The amount repaid, denominated in the loan source token.
+    /// @param caller The address that repaid the loan.
+    event RepayVestingLoan(
+        uint256 indexed loanId,
+        uint256 indexed paidOffLoanId,
+        IERC20 indexed token,
+        uint256 collateralCount,
+        uint256 repayBorrowAmount,
+        address caller
+    );
+
     /// @notice Emitted when a snapshot is created for a round.
     /// @param hook The hook the snapshot is for.
     /// @param round The round the snapshot was created for.
@@ -81,11 +143,39 @@ interface IJBDistributor {
     // ----------------------------- views ------------------------------- //
     //*********************************************************************//
 
+    /// @notice The number of seconds after a reward round becomes claimable before unclaimed rewards expire.
+    /// @dev A zero duration means reward rounds do not expire.
+    function CLAIM_DURATION() external view returns (uint48);
+
+    /// @notice The JB controller used to burn expired or forfeited project-token rewards.
+    function CONTROLLER() external view returns (IJBController);
+
+    /// @notice The duration of each round, specified in seconds.
+    function ROUND_DURATION() external view returns (uint256);
+
+    /// @notice The Revnet loans contract used to borrow against vesting revnet rewards.
+    function REV_LOANS() external view returns (IREVLoans);
+
+    /// @notice The REVOwner contract that must own a reward token's project to enable loan-backed collection.
+    function REV_OWNER() external view returns (IREVOwner);
+
+    /// @notice The starting timestamp of the distributor.
+    function STARTING_TIMESTAMP() external view returns (uint256);
+
+    /// @notice The number of rounds until tokens are fully vested.
+    function VESTING_ROUNDS() external view returns (uint256);
+
     /// @notice The balance of a token held for a specific hook's stakers.
     /// @param hook The hook whose balance to check.
     /// @param token The token to check the balance of.
     function balanceOf(address hook, IERC20 token) external view returns (uint256);
 
+    /// @notice The active Revnet loan using one token ID's vesting rewards as collateral.
+    /// @param hook The hook the token ID belongs to.
+    /// @param tokenId The token ID whose vesting rewards are collateralized.
+    /// @param token The reward token used as loan collateral.
+    function activeVestingLoanIdOf(address hook, uint256 tokenId, IERC20 token) external view returns (uint256);
+
     /// @notice Calculate how much of the token has been claimed for the given tokenId.
     /// @param hook The hook the tokenId belongs to.
     /// @param tokenId The ID of the token to calculate the token amount for.
@@ -101,9 +191,6 @@ interface IJBDistributor {
     /// @notice The number of the current round.
     function currentRound() external view returns (uint256);
 
-    /// @notice The duration of each round, specified in seconds.
-    function roundDuration() external view returns (uint256);
-
     /// @notice The block number recorded as the snapshot point for a round.
     /// @dev Returns 0 if no snapshot block has been recorded yet for this round.
     /// @param round The round to get the snapshot block of.
@@ -131,8 +218,14 @@ interface IJBDistributor {
     /// @param token The address of the token that is vesting.
     function totalVestingAmountOf(address hook, IERC20 token) external view returns (uint256);
 
-    /// @notice The number of rounds until tokens are fully vested.
-    function vestingRounds() external view returns (uint256);
+    /// @notice The amount of vesting inventory currently collateralized in Revnet loans.
+    /// @param hook The hook whose loaned vesting amount to check.
+    /// @param token The reward token used as collateral.
+    function totalLoanedVestingAmountOf(address hook, IERC20 token) external view returns (uint256);
+
+    /// @notice The vesting position collateralized by a Revnet loan.
+    /// @param loanId The Revnet loan NFT ID.
+    function vestingLoanOf(uint256 loanId) external view returns (JBVestingLoan memory);
 
     //*********************************************************************//
     // ---------------------------- transactions ------------------------- //
@@ -144,6 +237,28 @@ interface IJBDistributor {
     /// @param tokens The tokens to claim.
     function beginVesting(address hook, uint256[] calldata tokenIds, IERC20[] calldata tokens) external;
 
+    /// @notice Borrow from a revnet using one token ID's uncollected vesting rewards as collateral.
+    /// @param hook The hook whose staker is borrowing against vesting rewards.
+    /// @param tokenIds The single token ID to borrow against.
+    /// @param tokens The single revnet reward token to collateralize.
+    /// @param sourceToken The token to borrow from the revnet.
+    /// @param minBorrowAmount The minimum amount to borrow, denominated in `sourceToken`.
+    /// @param prepaidFeePercent The fee percent to charge upfront.
+    /// @param beneficiary The recipient of the borrowed funds.
+    /// @return loanId The Revnet loan NFT ID held by this distributor.
+    /// @return collateralCount The amount of vesting rewards used as collateral.
+    function borrowAgainstVesting(
+        address hook,
+        uint256[] calldata tokenIds,
+        IERC20[] calldata tokens,
+        address sourceToken,
+        uint256 minBorrowAmount,
+        uint256 prepaidFeePercent,
+        address payable beneficiary
+    )
+        external
+        returns (uint256 loanId, uint256 collateralCount);
+
     /// @notice Collect vested tokens.
     /// @param hook The hook whose stakers are collecting.
     /// @param tokenIds The IDs of the tokens to collect for.
@@ -164,15 +279,6 @@ interface IJBDistributor {
     /// @param amount The amount to fund.
     function fund(address hook, IERC20 token, uint256 amount) external payable;
 
-    /// @notice Fund the distributor for a specific hook with expiring rewards.
-    /// @dev `claimDuration` is measured from the first timestamp at which the funded round can be claimed.
-    /// @dev A zero duration means the reward round does not expire.
-    /// @param hook The hook to fund.
-    /// @param token The token to fund with.
-    /// @param amount The amount to fund.
-    /// @param claimDuration The number of seconds claimants have after the round becomes claimable.
-    function fundWithClaimDuration(address hook, IERC20 token, uint256 amount, uint48 claimDuration) external payable;
-
     /// @notice Burn unclaimed rewards from expired reward rounds.
     /// @param hook The hook whose expired reward rounds should be burned.
     /// @param token The reward token to burn.
@@ -183,11 +289,23 @@ interface IJBDistributor {
     /// @notice Record the snapshot block for the current round. Callable by anyone (keepers, frontends).
     function poke() external;
 
-    /// @notice Release vested rewards for burned tokens.
+    /// @notice Repay a distributor-held Revnet loan and restore its collateral to the original vesting schedule.
+    /// @param loanId The Revnet loan NFT ID to repay.
+    /// @param maxRepayBorrowAmount The maximum amount of source token the caller is willing to repay.
+    /// @return paidOffLoanId The paid-off loan ID returned by Revnet loans.
+    function repayVestingLoan(
+        uint256 loanId,
+        uint256 maxRepayBorrowAmount
+    )
+        external
+        payable
+        returns (uint256 paidOffLoanId);
+
+    /// @notice Burn unlocked rewards for burned tokens.
     /// @param hook The hook whose tokens were burned.
     /// @param tokenIds The IDs of the burned tokens.
-    /// @param tokens The addresses of the tokens to release.
-    /// @param beneficiary The recipient of the released tokens.
+    /// @param tokens The addresses of the tokens to burn.
+    /// @param beneficiary Unused for forfeiture.
     function releaseForfeitedRewards(
         address hook,
         uint256[] calldata tokenIds,
@@ -195,4 +313,9 @@ interface IJBDistributor {
         address beneficiary
     )
         external;
+
+    /// @notice Write off a distributor-held Revnet loan after Revnet liquidation permanently destroys its collateral.
+    /// @param loanId The liquidated Revnet loan NFT ID.
+    /// @return collateralCount The amount of vesting rewards forfeited by liquidation.
+    function writeOffLiquidatedVestingLoan(uint256 loanId) external returns (uint256 collateralCount);
 }

package/src/structs/JBBorrowContext.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/// @notice Parameters used while opening a distributor-owned Revnet loan.
+/// @custom:member hook The hook whose token ID owns the vesting rewards.
+/// @custom:member tokenId The token ID whose vesting rewards are collateralized.
+/// @custom:member token The revnet reward token used as loan collateral.
+/// @custom:member sourceToken The token borrowed from the revnet.
+/// @custom:member minBorrowAmount The minimum amount to borrow.
+/// @custom:member prepaidFeePercent The prepaid fee percent used by the loan.
+/// @custom:member beneficiary The recipient of the borrowed funds.
+/// @custom:member revnetId The revnet whose project token is collateralized.
+struct JBBorrowContext {
+    address hook;
+    uint256 tokenId;
+    IERC20 token;
+    address sourceToken;
+    uint256 minBorrowAmount;
+    uint256 prepaidFeePercent;
+    address payable beneficiary;
+    uint256 revnetId;
+}

package/src/structs/JBVestingLoan.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/// @notice Tracks a Revnet loan collateralized by one token ID's vesting rewards.
+/// @custom:member hook The hook the token ID belongs to.
+/// @custom:member tokenId The token ID whose vesting rewards are collateralized.
+/// @custom:member token The revnet reward token used as loan collateral.
+/// @custom:member vestingDataCount The vesting-entry boundary collateralized by the loan.
+/// @custom:member collateralCount The amount of vesting rewards collateralized.
+struct JBVestingLoan {
+    address hook;
+    uint256 tokenId;
+    IERC20 token;
+    uint48 vestingDataCount;
+    uint256 collateralCount;
+}