rebalancer

Author: aalavandhan

spot-contracts/contracts/Rebalancer.sol

@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.19;
+
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { IERC20MetadataUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
+import { ITranche } from "./_interfaces/buttonwood/ITranche.sol";
+import { IBondController } from "./_interfaces/buttonwood/IBondController.sol";
+import { IPerpetualTranche } from "./_interfaces/IPerpetualTranche.sol";
+import { TokenAmount } from "./_interfaces/ReturnData.sol";
+import { IRolloverVault } from "./_interfaces/IRolloverVault.sol";
+import { IFeePolicy } from "./_interfaces/IFeePolicy.sol";
+
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { MathUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol";
+import { BondTranches, BondTranchesHelpers } from "./_utils/BondTranchesHelpers.sol";
+import { BondHelpers } from "./_utils/BondHelpers.sol";
+
+/**
+ *  @title Rebalancer
+ *
+ *  @notice A router contract to interact with both perp and rollover vault tokens in unison.
+ *
+ *          Perp tokens act as low volatility derivative of the underlying collateral.
+ *          The vault notes act as a higher volatility derivative of the underlying collateral.
+ *
+ *          When a user holds both tokens in the right ratio (aka magic ratio)
+ *          his exposure is neutral (same as holding the underlying collateral).
+ *
+ *          When the user mints/burns both perps and vault notes together in the magic ratio,
+ *          the system charges no fees. This operation does not alter the system's `deviationRatio`.
+ *
+ *          Additionally, when the user burn perps and mints vault notes the system charges no fees.
+ *          This operation strictly increases the `deviationRatio` and leave the system in a healthier state.
+ *
+ *
+ */
+contract Rebalancer {
+    // math
+    using MathUpgradeable for uint256;
+
+    // data handling
+    using BondHelpers for IBondController;
+    using BondTranchesHelpers for BondTranches;
+
+    // ERC20 operations
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+    using SafeERC20Upgradeable for ITranche;
+    using SafeERC20Upgradeable for IPerpetualTranche;
+    using SafeERC20Upgradeable for IRolloverVault;
+
+    // Constants & Immutables
+
+    /// @dev Using the same granularity as the underlying buttonwood tranche contracts.
+    ///      https://github.com/buttonwood-protocol/tranche/blob/main/contracts/BondController.sol
+    uint256 private constant TRANCHE_RATIO_GRANULARITY = 1000;
+
+    /// @dev Immature redemption may result in some dust tranches when balances are not perfectly divisible by the tranche ratio.
+    ///      Based on current the implementation of `computeRedeemableTrancheAmounts`,
+    ///      the dust balances which remain after immature redemption will be at most {TRANCHE_RATIO_GRANULARITY} or 1000.
+    ///      We exclude dust tranche balances from recurrent immature redemption.
+    uint256 public constant TRANCHE_DUST_AMT = 1000;
+
+    uint8 public constant FEE_POLICY_DECIMALS = 8;
+    uint256 public constant FEE_ONE_PERC = (10**FEE_POLICY_DECIMALS);
+
+    uint256 public constant ONE = FEE_ONE_PERC; // 1.0 or 100%
+
+    /// @notice TODO
+    function deposit2(
+        IPerpetualTranche perp,
+        uint256 underlyingAmtIn
+    ) public returns (uint256, uint256) {
+        IRolloverVault vault = perp.vault();
+        IERC20Upgradeable underlying = perp.underlying();
+
+        // Transfer underlying tokens from user
+        underlying.safeTransferFrom(msg.sender, address(this), underlyingAmtIn);
+
+        // approve underlying to be spent
+        _checkAndApproveMax(underlying, address(vault), underlyingAmtIn);
+
+        // Figure out the accepted perp/vault collateral split
+        (, uint256 vaultPerc) = _computeNeutralSplit(perp, perp.getDepositTrancheRatio());
+
+        // mint notes based on the vault ratio
+        uint256 underlyingAmtIntoVault = underlyingAmtIn.mulDiv(vaultPerc, ONE, MathUpgradeable.Rounding.Up);
+        vault.deposit(underlyingAmtIntoVault);
+
+        // use the remaining collateral create perps
+        vault.swapUnderlyingForPerps(underlyingAmtIn - underlyingAmtIntoVault);
+
+        // Transfer perps and notes back to user
+        return (_transferAll(perp, msg.sender), _transferAll(vault, msg.sender));
+    }
+
+    /// @notice TODO
+    function redeem2(
+        IPerpetualTranche perp,
+        uint256 perpAmtAvailable,
+        uint256 noteAmtAvailable
+    )
+        public
+        returns (
+            uint256,
+            uint256,
+            TokenAmount[] memory
+        )
+    {
+        IRolloverVault vault = perp.vault();
+
+        // Compute the user's available balances
+        perpAmtAvailable = MathUpgradeable.min(perpAmtAvailable, perp.balanceOf(msg.sender));
+        noteAmtAvailable = MathUpgradeable.min(noteAmtAvailable, vault.balanceOf(msg.sender));
+
+        // Compute redemption amounts
+        (uint256 perpAmtBurnt, uint256 noteAmtBurnt) = _computeNeutralBurnAmts(
+            perp,
+            vault,
+            perpAmtAvailable,
+            noteAmtAvailable
+        );
+
+        // Transfer perps and vault notes from the user
+        perp.safeTransferFrom(msg.sender, address(this), perpAmtBurnt);
+        vault.safeTransferFrom(msg.sender, address(this), noteAmtBurnt);
+
+        // Redeem both perps and vault notes for tranches and underlying
+        TokenAmount[] memory perpTokensRedeemed = perp.redeem(perpAmtBurnt);
+        TokenAmount[] memory vaultTokensRedeemed = vault.redeem(noteAmtBurnt);
+
+        // Meld perp tranches with vault tranches if possible if not transfer out
+        TokenAmount[] memory tokensRedeemed = new TokenAmount[](
+            perpTokensRedeemed.length + vaultTokensRedeemed.length - 1
+        );
+        uint8 k = 0;
+        for (uint8 i = 1; i < perpTokensRedeemed.length; i++) {
+            IERC20Upgradeable tokenRedeemed = perpTokensRedeemed[i].token;
+            _redeemImmatureTranche(ITranche(address(tokenRedeemed)));
+            tokensRedeemed[k++] = TokenAmount({
+                token: tokenRedeemed,
+                amount: _transferAll(tokenRedeemed, msg.sender)
+            });
+        }
+        for (uint8 i = 1; i < vaultTokensRedeemed.length; i++) {
+            IERC20Upgradeable tokenRedeemed = vaultTokensRedeemed[i].token;
+            tokensRedeemed[k++] = TokenAmount({
+                token: tokenRedeemed,
+                amount: _transferAll(tokenRedeemed, msg.sender)
+            });
+        }
+
+        // transfer out remaining underlying
+        IERC20Upgradeable underlying = perpTokensRedeemed[0].token;
+        tokensRedeemed[k] = TokenAmount({ token: underlying, amount: _transferAll(underlying, msg.sender) });
+
+        return (perpAmtBurnt, noteAmtBurnt, tokensRedeemed);
+    }
+
+    /// @notice TODO
+    function redeemPerpsAndMintVaultNotes(
+        IPerpetualTranche perp,
+        uint256 perpAmtIn
+    ) external returns (uint256) {
+        IRolloverVault vault = perp.vault();
+        IERC20Upgradeable underlying = perp.underlying();
+
+        // Transfer perps from user
+        perp.safeTransferFrom(msg.sender, address(this), perpAmtIn);
+
+        // Swap perps for underlying
+        _checkAndApproveMax(perp, address(vault), perpAmtIn);
+        uint256 underlyingAmt = vault.swapPerpsForUnderlying(perpAmtIn);
+
+        // Deposit underlying into vault
+        _checkAndApproveMax(underlying, address(vault), underlyingAmt);
+        vault.deposit(underlyingAmt);
+
+        // Transfer minted notes back to user
+        return _transferAll(vault, msg.sender);
+    }
+
+    /// @dev Transfers the entire balance of a given token to the provided recipient.
+    function _transferAll(IERC20Upgradeable token, address to) private returns (uint256) {
+        uint256 bal = token.balanceOf(address(this));
+        if (bal > 0) {
+            token.safeTransfer(to, bal);
+        }
+        return bal;
+    }
+
+    /// @dev Checks if the spender has sufficient allowance. If not, approves the maximum possible amount.
+    function _checkAndApproveMax(
+        IERC20Upgradeable token,
+        address spender,
+        uint256 amount
+    ) private {
+        uint256 allowance = token.allowance(address(this), spender);
+        if (allowance < amount) {
+            token.safeApprove(spender, 0);
+            token.safeApprove(spender, type(uint256).max);
+        }
+    }
+
+    /// @dev Redeems tranche tokens held by this contract, for underlying.
+    function _redeemImmatureTranche(ITranche tranche) private {
+        uint256 trancheBalance = tranche.balanceOf(address(this));
+        if (trancheBalance < TRANCHE_DUST_AMT) {
+            return;
+        }
+
+        IBondController bond = IBondController(tranche.bond());
+        uint256[] memory trancheAmts = (bond.getTranches()).computeRedeemableTrancheAmounts(address(this));
+        if (trancheAmts[0] > 0) {
+            bond.redeem(trancheAmts);
+        }
+    }
+
+    struct SystemState {
+        uint256 perpTVL;
+        uint256 perpSupply;
+        uint256 vaultTVL;
+        uint256 noteSupply;
+    }
+
+    /// @dev Calculates the amount of perps and vault notes to burn based on the magic ratio.
+    function _computeNeutralBurnAmts(
+        IPerpetualTranche perp,
+        IRolloverVault vault,
+        uint256 perpAmtAvailable,
+        uint256 noteAmtAvailable
+    ) private returns (uint256, uint256) {
+        // Compute current system state
+        SystemState memory s = SystemState({
+            perpTVL: perp.getTVL(),
+            perpSupply: perp.totalSupply(),
+            vaultTVL: vault.getTVL(),
+            noteSupply: vault.totalSupply()
+        });
+
+        // Figure out the accepted perp/vault collateral split
+        (uint256 perpPerc, uint256 vaultPerc) = _computeNeutralSplit(perp, perp.getDepositTrancheRatio());
+
+        // We calculate `noteAmtIn` based on `perpAmtAvailable`
+        uint256 perpAmtToBurn = perpAmtAvailable;
+        uint256 noteAmtToBurn = perpAmtToBurn
+            .mulDiv(s.perpTVL, s.perpSupply, MathUpgradeable.Rounding.Up)
+            .mulDiv(s.noteSupply, s.vaultTVL, MathUpgradeable.Rounding.Up)
+            .mulDiv(vaultPerc, perpPerc, MathUpgradeable.Rounding.Up);
+
+        // if more notes are required than available, we recalculate `perpAmtToBurn` based on `noteAmtAvailable`
+        if (noteAmtToBurn > noteAmtAvailable) {
+            noteAmtToBurn = noteAmtAvailable;
+            perpAmtToBurn = noteAmtToBurn
+                .mulDiv(s.vaultTVL, s.noteSupply, MathUpgradeable.Rounding.Up)
+                .mulDiv(s.perpSupply, s.perpTVL, MathUpgradeable.Rounding.Up)
+                .mulDiv(perpPerc, vaultPerc, MathUpgradeable.Rounding.Up);
+        }
+
+        return (perpAmtToBurn, noteAmtToBurn);
+    }
+
+    /// @dev Calculates the magic ratio split.
+    function _computeNeutralSplit(IPerpetualTranche perp, uint256 perpRatio) public view returns (uint256, uint256) {
+        uint256 vaultRatio = (TRANCHE_RATIO_GRANULARITY - perpRatio).mulDiv(
+            perp.feePolicy().targetSubscriptionRatio(),
+            FEE_ONE_PERC,
+            MathUpgradeable.Rounding.Up
+        );
+        uint256 vaultPerc = ONE.mulDiv(vaultRatio, (perpRatio + vaultRatio), MathUpgradeable.Rounding.Up);
+        uint256 perpPerc = ONE - vaultPerc;
+        return (perpPerc, vaultPerc);
+    }
+}