@rev-net/core-v6 0.0.1

package/src/interfaces/IREVDeployer.sol

@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJB721TiersHook} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHook.sol";
+import {IJB721TiersHookDeployer} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHookDeployer.sol";
+import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
+import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
+import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
+import {JBRulesetConfig} from "@bananapus/core-v6/src/structs/JBRulesetConfig.sol";
+import {JBTerminalConfig} from "@bananapus/core-v6/src/structs/JBTerminalConfig.sol";
+import {IJBSuckerRegistry} from "@bananapus/suckers-v6/src/interfaces/IJBSuckerRegistry.sol";
+import {CTPublisher} from "@croptop/core-v6/src/CTPublisher.sol";
+
+import {REVConfig} from "../structs/REVConfig.sol";
+import {REVCroptopAllowedPost} from "../structs/REVCroptopAllowedPost.sol";
+import {REVDeploy721TiersHookConfig} from "../structs/REVDeploy721TiersHookConfig.sol";
+import {REVSuckerDeploymentConfig} from "../structs/REVSuckerDeploymentConfig.sol";
+
+interface IREVDeployer {
+    event ReplaceSplitOperator(uint256 indexed revnetId, address indexed newSplitOperator, address caller);
+    event DeploySuckers(
+        uint256 indexed revnetId,
+        bytes32 encodedConfigurationHash,
+        REVSuckerDeploymentConfig suckerDeploymentConfiguration,
+        address caller
+    );
+
+    event DeployRevnet(
+        uint256 indexed revnetId,
+        REVConfig configuration,
+        JBTerminalConfig[] terminalConfigurations,
+        REVSuckerDeploymentConfig suckerDeploymentConfiguration,
+        JBRulesetConfig[] rulesetConfigurations,
+        bytes32 encodedConfigurationHash,
+        address caller
+    );
+
+    event SetCashOutDelay(uint256 indexed revnetId, uint256 cashOutDelay, address caller);
+
+    event AutoIssue(
+        uint256 indexed revnetId, uint256 indexed stageId, address indexed beneficiary, uint256 count, address caller
+    );
+
+    event StoreAutoIssuanceAmount(
+        uint256 indexed revnetId, uint256 indexed stageId, address indexed beneficiary, uint256 count, address caller
+    );
+
+    event SetAdditionalOperator(uint256 revnetId, address additionalOperator, uint256[] permissionIds, address caller);
+
+    event BurnHeldTokens(uint256 indexed revnetId, uint256 count, address caller);
+
+    /// @notice The number of seconds until a revnet's participants can cash out after deploying to a new network.
+    /// @return The cash out delay in seconds.
+    function CASH_OUT_DELAY() external view returns (uint256);
+
+    /// @notice The controller used to create and manage Juicebox projects for revnets.
+    /// @return The controller contract.
+    function CONTROLLER() external view returns (IJBController);
+
+    /// @notice The directory of terminals and controllers for Juicebox projects.
+    /// @return The directory contract.
+    function DIRECTORY() external view returns (IJBDirectory);
+
+    /// @notice The contract that mints ERC-721s representing project ownership.
+    /// @return The projects contract.
+    function PROJECTS() external view returns (IJBProjects);
+
+    /// @notice The contract that stores Juicebox project access permissions.
+    /// @return The permissions contract.
+    function PERMISSIONS() external view returns (IJBPermissions);
+
+    /// @notice The cash out fee as a fraction out of `JBConstants.MAX_FEE`.
+    /// @return The fee value.
+    function FEE() external view returns (uint256);
+
+    /// @notice The default Uniswap pool fee tier for auto-configured buyback pools.
+    /// @return The fee tier (10_000 = 1%).
+    function DEFAULT_BUYBACK_POOL_FEE() external view returns (uint24);
+
+    /// @notice The default TWAP window for auto-configured buyback pools.
+    /// @return The TWAP window in seconds.
+    function DEFAULT_BUYBACK_TWAP_WINDOW() external view returns (uint32);
+
+    /// @notice The registry that deploys and tracks suckers for revnets.
+    /// @return The sucker registry contract.
+    function SUCKER_REGISTRY() external view returns (IJBSuckerRegistry);
+
+    /// @notice The Juicebox project ID of the revnet that receives cash out fees.
+    /// @return The fee revnet ID.
+    function FEE_REVNET_ID() external view returns (uint256);
+
+    /// @notice The croptop publisher revnets can use to publish ERC-721 posts to their tiered ERC-721 hooks.
+    /// @return The publisher contract.
+    function PUBLISHER() external view returns (CTPublisher);
+
+    /// @notice The buyback hook used as a data hook to route payments through buyback pools.
+    /// @return The buyback hook contract.
+    function BUYBACK_HOOK() external view returns (IJBRulesetDataHook);
+
+    /// @notice The deployer used to create tiered ERC-721 hooks for revnets.
+    /// @return The hook deployer contract.
+    function HOOK_DEPLOYER() external view returns (IJB721TiersHookDeployer);
+
+    /// @notice The loan contract used by all revnets.
+    /// @return The loans contract address.
+    function LOANS() external view returns (address);
+
+    /// @notice The number of revnet tokens that can be auto-minted for a beneficiary during a stage.
+    /// @param revnetId The ID of the revnet.
+    /// @param stageId The ID of the stage.
+    /// @param beneficiary The beneficiary of the auto-mint.
+    /// @return The number of tokens available to auto-issue.
+    function amountToAutoIssue(uint256 revnetId, uint256 stageId, address beneficiary) external view returns (uint256);
+
+    /// @notice The timestamp when cash outs become available for a revnet's participants.
+    /// @param revnetId The ID of the revnet.
+    /// @return The cash out delay timestamp.
+    function cashOutDelayOf(uint256 revnetId) external view returns (uint256);
+
+    /// @notice Deploy new suckers for an existing revnet.
+    /// @param revnetId The ID of the revnet to deploy suckers for.
+    /// @param suckerDeploymentConfiguration The suckers to set up for the revnet.
+    /// @return suckers The addresses of the deployed suckers.
+    function deploySuckersFor(
+        uint256 revnetId,
+        REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration
+    )
+        external
+        returns (address[] memory suckers);
+
+    /// @notice The hashed encoded configuration of each revnet.
+    /// @param revnetId The ID of the revnet.
+    /// @return The hashed encoded configuration.
+    function hashedEncodedConfigurationOf(uint256 revnetId) external view returns (bytes32);
+
+    /// @notice Whether an address is a revnet's split operator.
+    /// @param revnetId The ID of the revnet.
+    /// @param addr The address to check.
+    /// @return A flag indicating whether the address is the revnet's split operator.
+    function isSplitOperatorOf(uint256 revnetId, address addr) external view returns (bool);
+
+    /// @notice Each revnet's tiered ERC-721 hook.
+    /// @param revnetId The ID of the revnet.
+    /// @return The tiered ERC-721 hook.
+    function tiered721HookOf(uint256 revnetId) external view returns (IJB721TiersHook);
+
+    /// @notice Auto-mint a revnet's tokens from a stage for a beneficiary.
+    /// @param revnetId The ID of the revnet to auto-mint tokens from.
+    /// @param stageId The ID of the stage auto-mint tokens are available from.
+    /// @param beneficiary The address to auto-mint tokens to.
+    function autoIssueFor(uint256 revnetId, uint256 stageId, address beneficiary) external;
+
+    /// @notice Deploy a revnet, or initialize an existing Juicebox project as a revnet.
+    /// @param revnetId The ID of the Juicebox project to initialize. Send 0 to deploy a new revnet.
+    /// @param configuration Core revnet configuration.
+    /// @param terminalConfigurations The terminals to set up for the revnet.
+    /// @param suckerDeploymentConfiguration The suckers to set up for cross-chain token transfers.
+    /// @return The ID of the newly created or initialized revnet.
+    function deployFor(
+        uint256 revnetId,
+        REVConfig memory configuration,
+        JBTerminalConfig[] memory terminalConfigurations,
+        REVSuckerDeploymentConfig memory suckerDeploymentConfiguration
+    )
+        external
+        returns (uint256);
+
+    /// @notice Deploy a revnet with tiered ERC-721s and optional croptop posting support.
+    /// @param revnetId The ID of the Juicebox project to initialize. Send 0 to deploy a new revnet.
+    /// @param configuration Core revnet configuration.
+    /// @param terminalConfigurations The terminals to set up for the revnet.
+    /// @param suckerDeploymentConfiguration The suckers to set up for cross-chain token transfers.
+    /// @param tiered721HookConfiguration How to set up the tiered ERC-721 hook.
+    /// @param allowedPosts Restrictions on which croptop posts are allowed on the revnet's ERC-721 tiers.
+    /// @return The ID of the newly created or initialized revnet.
+    /// @return hook The tiered ERC-721 hook that was deployed for the revnet.
+    function deployWith721sFor(
+        uint256 revnetId,
+        REVConfig calldata configuration,
+        JBTerminalConfig[] memory terminalConfigurations,
+        REVSuckerDeploymentConfig memory suckerDeploymentConfiguration,
+        REVDeploy721TiersHookConfig memory tiered721HookConfiguration,
+        REVCroptopAllowedPost[] memory allowedPosts
+    )
+        external
+        returns (uint256, IJB721TiersHook hook);
+
+    /// @notice Change a revnet's split operator. Only the current split operator can call this.
+    /// @param revnetId The ID of the revnet.
+    /// @param newSplitOperator The new split operator's address.
+    function setSplitOperatorOf(uint256 revnetId, address newSplitOperator) external;
+
+    /// @notice Burn any of a revnet's tokens held by this contract.
+    /// @param revnetId The ID of the revnet whose tokens should be burned.
+    function burnHeldTokensOf(uint256 revnetId) external;
+}

package/src/interfaces/IREVLoans.sol

@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPermit2} from "@uniswap/permit2/src/interfaces/IPermit2.sol";
+import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBPayoutTerminal} from "@bananapus/core-v6/src/interfaces/IJBPayoutTerminal.sol";
+import {IJBPrices} from "@bananapus/core-v6/src/interfaces/IJBPrices.sol";
+import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
+import {IJBTokenUriResolver} from "@bananapus/core-v6/src/interfaces/IJBTokenUriResolver.sol";
+import {JBSingleAllowance} from "@bananapus/core-v6/src/structs/JBSingleAllowance.sol";
+
+import {REVLoan} from "./../structs/REVLoan.sol";
+import {REVLoanSource} from "./../structs/REVLoanSource.sol";
+
+interface IREVLoans {
+    event Borrow(
+        uint256 indexed loanId,
+        uint256 indexed revnetId,
+        REVLoan loan,
+        REVLoanSource source,
+        uint256 borrowAmount,
+        uint256 collateralCount,
+        uint256 sourceFeeAmount,
+        address payable beneficiary,
+        address caller
+    );
+    event Liquidate(uint256 indexed loanId, uint256 indexed revnetId, REVLoan loan, address caller);
+    event RepayLoan(
+        uint256 indexed loanId,
+        uint256 indexed revnetId,
+        uint256 indexed paidOffLoanId,
+        REVLoan loan,
+        REVLoan paidOffLoan,
+        uint256 repayBorrowAmount,
+        uint256 sourceFeeAmount,
+        uint256 collateralCountToReturn,
+        address payable beneficiary,
+        address caller
+    );
+    event ReallocateCollateral(
+        uint256 indexed loanId,
+        uint256 indexed revnetId,
+        uint256 indexed reallocatedLoanId,
+        REVLoan reallocatedLoan,
+        uint256 removedCollateralCount,
+        address caller
+    );
+    event SetTokenUriResolver(IJBTokenUriResolver indexed resolver, address caller);
+
+    /// @notice The duration after which a loan expires and its collateral is permanently lost.
+    /// @return The loan liquidation duration in seconds.
+    function LOAN_LIQUIDATION_DURATION() external view returns (uint256);
+
+    /// @notice The permit2 utility used for token transfers.
+    /// @return The permit2 contract.
+    function PERMIT2() external view returns (IPermit2);
+
+    /// @notice The controller that manages revnets using this loans contract.
+    /// @return The controller contract.
+    function CONTROLLER() external view returns (IJBController);
+
+    /// @notice The directory of terminals and controllers for revnets.
+    /// @return The directory contract.
+    function DIRECTORY() external view returns (IJBDirectory);
+
+    /// @notice The contract that stores prices for each revnet.
+    /// @return The prices contract.
+    function PRICES() external view returns (IJBPrices);
+
+    /// @notice The contract that mints ERC-721s representing project ownership.
+    /// @return The projects contract.
+    function PROJECTS() external view returns (IJBProjects);
+
+    /// @notice The ID of the REV revnet that receives protocol fees from loans.
+    /// @return The REV revnet ID.
+    function REV_ID() external view returns (uint256);
+
+    /// @notice The fee percent charged by the REV revnet on each loan, in terms of `JBConstants.MAX_FEE`.
+    /// @return The REV prepaid fee percent.
+    function REV_PREPAID_FEE_PERCENT() external view returns (uint256);
+
+    /// @notice The minimum fee percent that must be prepaid when borrowing, in terms of `JBConstants.MAX_FEE`.
+    /// @return The minimum prepaid fee percent.
+    function MIN_PREPAID_FEE_PERCENT() external view returns (uint256);
+
+    /// @notice The maximum fee percent that can be prepaid when borrowing, in terms of `JBConstants.MAX_FEE`.
+    /// @return The maximum prepaid fee percent.
+    function MAX_PREPAID_FEE_PERCENT() external view returns (uint256);
+
+    /// @notice The amount that can be borrowed from a revnet given a certain amount of collateral.
+    /// @param revnetId The ID of the revnet to check for borrowable assets from.
+    /// @param collateralCount The amount of collateral used to secure the loan.
+    /// @param decimals The decimals the resulting fixed point value will include.
+    /// @param currency The currency that the resulting amount should be in terms of.
+    /// @return The amount that can be borrowed from the revnet.
+    function borrowableAmountFrom(
+        uint256 revnetId,
+        uint256 collateralCount,
+        uint256 decimals,
+        uint256 currency
+    )
+        external
+        view
+        returns (uint256);
+
+    /// @notice Determines the source fee amount for a loan being paid off a certain amount.
+    /// @param loan The loan having its source fee amount determined.
+    /// @param amount The amount being paid off.
+    /// @return sourceFeeAmount The source fee amount for the loan.
+    function determineSourceFeeAmount(
+        REVLoan memory loan,
+        uint256 amount
+    )
+        external
+        view
+        returns (uint256 sourceFeeAmount);
+
+    /// @notice Whether a revnet currently has outstanding loans from the specified terminal in the specified token.
+    /// @param revnetId The ID of the revnet issuing the loan.
+    /// @param terminal The terminal that the loan is issued from.
+    /// @param token The token being loaned.
+    /// @return A flag indicating if the revnet has an active loan source.
+    function isLoanSourceOf(uint256 revnetId, IJBPayoutTerminal terminal, address token) external view returns (bool);
+
+    /// @notice Get a loan's details.
+    /// @param loanId The ID of the loan to retrieve.
+    /// @return The loan data.
+    function loanOf(uint256 loanId) external view returns (REVLoan memory);
+
+    /// @notice The sources of each revnet's loans.
+    /// @param revnetId The ID of the revnet to get the loan sources for.
+    /// @return The array of loan sources.
+    function loanSourcesOf(uint256 revnetId) external view returns (REVLoanSource[] memory);
+
+    /// @notice The number of loans that have been created for a revnet.
+    /// @param revnetId The ID of the revnet to get the loan count for.
+    /// @return The number of loans.
+    function numberOfLoansFor(uint256 revnetId) external view returns (uint256);
+
+    /// @notice The revnet ID for the loan with the provided loan ID.
+    /// @param loanId The loan ID to get the revnet ID of.
+    /// @return The ID of the revnet.
+    function revnetIdOfLoanWith(uint256 loanId) external view returns (uint256);
+
+    /// @notice The contract resolving each loan ID to its ERC-721 URI.
+    /// @return The token URI resolver.
+    function tokenUriResolver() external view returns (IJBTokenUriResolver);
+
+    /// @notice The total amount loaned out by a revnet from a specified terminal in a specified token.
+    /// @param revnetId The ID of the revnet issuing the loan.
+    /// @param terminal The terminal that the loan is issued from.
+    /// @param token The token being loaned.
+    /// @return The total amount borrowed.
+    function totalBorrowedFrom(
+        uint256 revnetId,
+        IJBPayoutTerminal terminal,
+        address token
+    )
+        external
+        view
+        returns (uint256);
+
+    /// @notice The total amount of collateral supporting a revnet's loans.
+    /// @param revnetId The ID of the revnet.
+    /// @return The total collateral count.
+    function totalCollateralOf(uint256 revnetId) external view returns (uint256);
+
+    /// @notice Open a loan by borrowing from a revnet. Collateral tokens are burned and only re-minted upon repayment.
+    /// @param revnetId The ID of the revnet being borrowed from.
+    /// @param source The source of the loan (terminal and token).
+    /// @param minBorrowAmount The minimum amount to borrow, denominated in the source's token.
+    /// @param collateralCount The amount of tokens to use as collateral for the loan.
+    /// @param beneficiary The address that will receive the borrowed funds and fee payment tokens.
+    /// @param prepaidFeePercent The fee percent to charge upfront, in terms of `JBConstants.MAX_FEE`.
+    /// @return loanId The ID of the loan created from borrowing.
+    /// @return The loan created from borrowing.
+    function borrowFrom(
+        uint256 revnetId,
+        REVLoanSource calldata source,
+        uint256 minBorrowAmount,
+        uint256 collateralCount,
+        address payable beneficiary,
+        uint256 prepaidFeePercent
+    )
+        external
+        returns (uint256 loanId, REVLoan memory);
+
+    /// @notice Liquidates loans that have exceeded the liquidation duration, permanently destroying their collateral.
+    /// @param revnetId The ID of the revnet to liquidate loans from.
+    /// @param startingLoanId The loan number to start iterating from.
+    /// @param count The number of loans to iterate over.
+    function liquidateExpiredLoansFrom(uint256 revnetId, uint256 startingLoanId, uint256 count) external;
+
+    /// @notice Repay a loan or return excess collateral no longer needed to support the loan.
+    /// @param loanId The ID of the loan being repaid.
+    /// @param maxRepayBorrowAmount The maximum amount to repay, denominated in the source's token.
+    /// @param collateralCountToReturn The amount of collateral to return from the loan.
+    /// @param beneficiary The address receiving the returned collateral and fee payment tokens.
+    /// @param allowance A permit2 allowance to facilitate the repayment transfer.
+    /// @return paidOffLoanId The ID of the loan after it has been paid off.
+    /// @return paidOffloan The loan after it has been paid off.
+    function repayLoan(
+        uint256 loanId,
+        uint256 maxRepayBorrowAmount,
+        uint256 collateralCountToReturn,
+        address payable beneficiary,
+        JBSingleAllowance calldata allowance
+    )
+        external
+        payable
+        returns (uint256 paidOffLoanId, REVLoan memory paidOffloan);
+
+    /// @notice Refinance a loan by transferring extra collateral from an existing loan to a new loan.
+    /// @param loanId The ID of the loan to reallocate collateral from.
+    /// @param collateralCountToTransfer The amount of collateral to transfer from the original loan.
+    /// @param source The source of the new loan (terminal and token). Must match the existing loan's source.
+    /// @param minBorrowAmount The minimum amount to borrow for the new loan.
+    /// @param collateralCountToAdd Additional collateral to add to the new loan from the caller's balance.
+    /// @param beneficiary The address that will receive the borrowed funds and fee payment tokens.
+    /// @param prepaidFeePercent The fee percent to charge upfront for the new loan.
+    /// @return reallocatedLoanId The ID of the reallocated (reduced) loan.
+    /// @return newLoanId The ID of the newly created loan.
+    /// @return reallocatedLoan The reallocated loan data.
+    /// @return newLoan The new loan data.
+    function reallocateCollateralFromLoan(
+        uint256 loanId,
+        uint256 collateralCountToTransfer,
+        REVLoanSource calldata source,
+        uint256 minBorrowAmount,
+        uint256 collateralCountToAdd,
+        address payable beneficiary,
+        uint256 prepaidFeePercent
+    )
+        external
+        returns (uint256 reallocatedLoanId, uint256 newLoanId, REVLoan memory reallocatedLoan, REVLoan memory newLoan);
+
+    /// @notice Sets the address of the resolver used to retrieve the token URI of loans.
+    /// @param resolver The new token URI resolver.
+    function setTokenUriResolver(IJBTokenUriResolver resolver) external;
+}

package/src/structs/REVAutoIssuance.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member chainId The ID of the chain on which the mint should be honored.
+/// @custom:member count The number of tokens that should be minted.
+/// @custom:member beneficiary The address that will receive the minted tokens.
+struct REVAutoIssuance {
+    uint32 chainId;
+    uint104 count;
+    address beneficiary;
+}

package/src/structs/REVConfig.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {REVDescription} from "./REVDescription.sol";
+import {REVStageConfig} from "./REVStageConfig.sol";
+
+/// @custom:member description The description of the revnet.
+/// @custom:member baseCurrency The currency that the issuance is based on.
+/// @custom:member splitOperator The address that will receive the token premint and initial production split,
+/// and who is allowed to change who the operator is. Only the operator can replace itself after deployment.
+/// @custom:member stageConfigurations The periods of changing constraints.
+struct REVConfig {
+    REVDescription description;
+    uint32 baseCurrency;
+    address splitOperator;
+    REVStageConfig[] stageConfigurations;
+}

package/src/structs/REVCroptopAllowedPost.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice Criteria for allowed posts.
+/// @custom:member category A category that should allow posts.
+/// @custom:member minimumPrice The minimum price that a post to the specified category should cost.
+/// @custom:member minimumTotalSupply The minimum total supply of NFTs that can be made available when minting.
+/// @custom:member maxTotalSupply The max total supply of NFTs that can be made available when minting. Leave as 0 for
+/// max.
+/// @custom:member maximumSplitPercent The maximum split percent (out of JBConstants.SPLITS_TOTAL_PERCENT) that a
+/// poster can set. 0 means splits are not allowed.
+/// @custom:member allowedAddresses A list of addresses that are allowed to post on the category through Croptop.
+struct REVCroptopAllowedPost {
+    uint24 category;
+    uint104 minimumPrice;
+    uint32 minimumTotalSupply;
+    uint32 maximumTotalSupply;
+    uint32 maximumSplitPercent;
+    address[] allowedAddresses;
+}

package/src/structs/REVDeploy721TiersHookConfig.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBDeploy721TiersHookConfig} from "@bananapus/721-hook-v6/src/structs/JBDeploy721TiersHookConfig.sol";
+
+/// @custom:member baseline721HookConfiguration The baseline config.
+/// @custom:member salt The salt to base the collection's address on.
+/// @custom:member splitOperatorCanAdjustTiers A flag indicating if the revnet's split operator can add tiers and remove
+/// tiers if
+/// the tier is allowed to be removed
+/// @custom:member splitOperatorCanUpdateMetadata A flag indicating if the revnet's split operator can update the 721's
+/// metadata.
+/// @custom:member splitOperatorCanMint A flag indicating if the revnet's split operator can mint 721's from tiers that
+/// allow it.
+/// @custom:member splitOperatorCanIncreaseDiscountPercent A flag indicating if the revnet's split operator can increase
+/// the
+/// discount of a tier.
+struct REVDeploy721TiersHookConfig {
+    JBDeploy721TiersHookConfig baseline721HookConfiguration;
+    bytes32 salt;
+    bool splitOperatorCanAdjustTiers;
+    bool splitOperatorCanUpdateMetadata;
+    bool splitOperatorCanMint;
+    bool splitOperatorCanIncreaseDiscountPercent;
+}

package/src/structs/REVDescription.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @custom:member name The name of the ERC-20 token being create for the revnet.
+/// @custom:member ticker The ticker of the ERC-20 token being created for the revnet.
+/// @custom:member uri The metadata URI containing revnet's info.
+/// @custom:member salt Revnets deployed across chains by the same address with the same salt will have the same
+/// address.
+struct REVDescription {
+    string name;
+    string ticker;
+    string uri;
+    bytes32 salt;
+}

package/src/structs/REVLoan.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {REVLoanSource} from "./REVLoanSource.sol";
+
+/// @custom:member borrowedAmount The amount that is being borrowed.
+/// @custom:member collateralTokenCount The number of collateral tokens currently accounted for.
+/// @custom:member createdAt The timestamp when the loan was created.
+/// @custom:member prepaidFeePercent The percentage of the loan's fees that were prepaid.
+/// @custom:member prepaidDuration The duration that the loan was prepaid for.
+/// @custom:member source The source of the loan.
+struct REVLoan {
+    uint112 amount;
+    uint112 collateral;
+    uint48 createdAt;
+    uint16 prepaidFeePercent;
+    uint32 prepaidDuration;
+    REVLoanSource source;
+}

package/src/structs/REVLoanSource.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBPayoutTerminal} from "@bananapus/core-v6/src/interfaces/IJBPayoutTerminal.sol";
+
+/// @custom:member token The token that is being loaned.
+/// @custom:member terminal The terminal that the loan is being made from.
+struct REVLoanSource {
+    address token;
+    IJBPayoutTerminal terminal;
+}

package/src/structs/REVStageConfig.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+
+import {REVAutoIssuance} from "./REVAutoIssuance.sol";
+
+/// @custom:member startsAtOrAfter The timestamp to start a stage at the given rate at or after.
+/// @custom:member autoIssuances The configurations of mints during this stage.
+/// @custom:member splitPercent The percentage of newly issued tokens that should be split with the operator, out
+/// of 10_000 (JBConstants.MAX_RESERVED_PERCENT).
+/// @custom:member splits The splits for the revnet.
+/// @custom:member initialIssuance The number of revnet tokens that one unit of the revnet's base currency will buy, as
+/// a fixed point number
+/// with 18 decimals.
+/// @custom:member issuanceCutFrequency The number of seconds between applied issuance decreases. This
+/// should be at least 24 hours.
+/// @custom:member issuanceCutPercent The percent that issuance should decrease over time. This percentage is out
+/// of 1_000_000_000 (JBConstants.MAX_CUT_PERCENT). 0% corresponds to no issuance increase.
+/// @custom:member cashOutTaxRate The factor determining how much each token can cash out from the revnet once
+/// cashed out. This rate is out of 10_000 (JBConstants.MAX_CASH_OUT_TAX_RATE). 0% corresponds to no tax when cashing
+/// out.
+/// @custom:member extraMetadata Extra info to attach set into this stage that may affect hooks.
+struct REVStageConfig {
+    uint48 startsAtOrAfter;
+    REVAutoIssuance[] autoIssuances;
+    uint16 splitPercent;
+    JBSplit[] splits;
+    uint112 initialIssuance;
+    uint32 issuanceCutFrequency;
+    uint32 issuanceCutPercent;
+    uint16 cashOutTaxRate;
+    uint16 extraMetadata;
+}

package/src/structs/REVSuckerDeploymentConfig.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBSuckerDeployerConfig} from "@bananapus/suckers-v6/src/structs/JBSuckerDeployerConfig.sol";
+
+/// @custom:member deployerConfigurations The information for how to suck tokens to other chains.
+/// @custom:member salt The salt to use for creating suckers so that they use the same address across chains.
+struct REVSuckerDeploymentConfig {
+    JBSuckerDeployerConfig[] deployerConfigurations;
+    bytes32 salt;
+}