bond minter ineteface

aalavandhan · aalavandhan · commit c757fa79522b · 2022-02-13T21:07:08.000-08:00
diff --git a/contracts/ACash.sol b/contracts/ACash.sol
@@ -1,91 +1,163 @@
 //SPDX-License-Identifier: Unlicense
 pragma solidity ^0.8.0;
 
-import "hardhat/console.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
-import "./interfaces/IBondController.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {AddressQueue} from "./utils/AddressQueue.sol";
+import {BondMinterHelpers} from "./utils/BondMinterHelpers.sol";
 
-import "./utils/AddressQueue.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ITranche} from "./interfaces/ITranche.sol";
+import {IBondMinter} from "./interfaces/IBondMinter.sol";
+import {IBondController} from "./interfaces/IBondController.sol";
 
 // TODO:
 // 1) Factor fee params and math into external strategy pattern to enable more complex logic in future
 // 2) Implement replaceable fee strategies
-contract ACash is ERC20 {
+// 3) log events
+contract ACash is ERC20, Ownable {
     using AddressQueue for AddressQueue.Queue;
-
-    // todo: add setter
-    address public feeToken;
+    using BondMinterHelpers for IBondMinter;
+    using SafeERC20 for IERC20;
 
     // Used for fee and yield values
     uint256 public constant PCT_DECIMALS = 6;
 
+    //--- fee strategy parameters
+    // todo: add setter
+    // todo: rethink AMPL fee token, it can rebase up and down, alternatively SPOT as fee?
+    address public feeToken;
     // Special note: If mint or burn fee is negative, the other must overcompensate in the positive direction.
     // Otherwise, user could extract from fee reserve by constant mint/burn transactions.
     int256 public mintFeePct;
     int256 public burnFeePct;
     int256 public rolloverRewardPct;
 
-    address public bondFactory;
-    // bondFactory -> ordered array of tranche yields for SPOT
-    mapping (address => uint256[]) trancheYields;
+    //---- bond minter parameters
+    IBondMinter public bondMinter;
+    uint256 public bondMinterConfigIDX;
+    mapping (IBondMinter => uint256[]) trancheYields;
 
-    uint8 private immutable _decimals;
 
+    //---- bond queue parameters
     // bondQueue is a queue of Bonds, which have an associated number of seniority-based tranches.
     AddressQueue.Queue public bondQueue;
 
-    // bondIcebox is a holding area for tranches that are underwater.
-    // These are skipped in the general burn/redeem case, but may be manually burned redeemed by address
-    mapping(address => bool) bondIcebox;
-    
-    constructor(string memory name, string memory symbol, uint8 decimals_) ERC20(name, symbol) {
+    // system only keeps bonds which further than the `tolarableBondMaturiy` in the queue
+    uint256 private _tolarableBondMaturiy;
+
+    //---- ERC-20 parameters
+    uint8 private immutable _decimals;
+
+
+    // trancheIcebox is a holding area for tranches that are underwater or tranches which are about to mature.
+    // They can only be rolled over and not burnt
+    mapping(ITranche => bool) trancheIcebox;
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint8 decimals_,
+        IBondMinter bondMinter_,
+        uint256 bondMinterConfigIDX_,
+        uint256[] memory bondTrancheYields) ERC20(name, symbol) {
         _decimals = decimals_;
+        setBondMinter(bondMinter_, bondMinterConfigIDX_, bondTrancheYields);
+
         bondQueue.init();
-        console.log("Deploying ACash");
     }
 
+
     function decimals() public view override returns (uint8) {
         return _decimals;
     }
 
     function mint(uint256[] calldata trancheAmts) external returns (uint256, int256) {
-        require(bondFactory != address(0), "Error: No bond factory set.");
-        
-        address mintingBond = bondQueue.tail();
-        require (mintingBond != address(0), "Error: No active minting bond");
-        
-        uint256 trancheCount = IBondController(mintingBond).trancheCount();
+        // assert(bondMinter != address(0));
 
-        require(trancheAmts.length == trancheCount, "Must specify amounts for every Bond Tranche.");
+        IBondController mintingBond = IBondController(bondQueue.tail());
+        require (address(mintingBond) != address(0), "No active minting bond");
 
-        uint256[] storage yields = trancheYields[bondFactory];
+        uint256 trancheCount = mintingBond.trancheCount();
+
+        require(trancheAmts.length == trancheCount, "Must specify amounts for every bond tranche");
+
+        uint256[] storage yields = trancheYields[bondMinter];
         // "System Error: trancheYields size doesn't match bond tranche count."
         assert(yields.length == trancheCount);
 
         uint256 mintAmt = 0;
         for (uint256 i = 0; i < trancheCount; i++) {
             mintAmt += yields[i] * trancheAmts[i] / (10 ** PCT_DECIMALS);
-            (ITranche t, ) = IBondController(mintingBond).tranches(i);
-            IERC20(t).transferFrom(msg.sender, address(this), trancheAmts[i]); // assert or use safe transfer
+            (ITranche t, ) = mintingBond.tranches(i);
+            IERC20(address(t)).safeTransferFrom(msg.sender, address(this), trancheAmts[i]); // assert or use safe transfer
         }
 
         // transfer in fee
         int256 fee = mintFeePct * int256(mintAmt) / int256(10 ** PCT_DECIMALS);
         if (fee >= 0) {
-            IERC20(feeToken).transferFrom(msg.sender, address(this), uint256(fee));// todo: safe versions
+            IERC20(feeToken).safeTransferFrom(msg.sender, address(this), uint256(fee)); // todo: safe versions
         } else {
             // This is very scary!
-            IERC20(feeToken).transfer(msg.sender, uint256(-fee));
+            IERC20(feeToken).safeTransfer(msg.sender, uint256(-fee));
         }
-        
+
         // mint spot for user
         _mint(msg.sender, mintAmt);
 
         return (mintAmt, fee);
     }
 
+
+    // push new bond into the queue
+    function advanceMintBond(IBondController newBond) public onlyOwner {
+        // checks
+        require(bondMinter.isConfigMatch(bondMinterConfigIDX, newBond), "Expect new bond config to match minter config");
+        require(newBond.maturityDate() > tolarableBondMaturiyDate(), "New bond matures too soon");
+
+        // enqueue empty bond, now minters can use this bond to mint!
+        bondQueue.enqueue(address(newBond));
+    }
+
+    // todo: make this iterative to continue dequeue till the tail of the queue
+    // has a bond which expires sufficiently out into the future
+    function advanceBurnBond() public onlyOwner {
+        IBondController latestBond = IBondController(bondQueue.tail());
+        if(address(latestBond) != address(0) && latestBond.maturityDate() <= tolarableBondMaturiyDate()) {
+            // pop from queue
+            bondQueue.dequeue();
+
+            // push individual tranches into icebox
+            for(uint256 i = 0; i < latestBond.trancheCount(); i++){
+                (ITranche t,) = latestBond.tranches(i);
+                trancheIcebox[t] = true;
+            }
+        }
+    }
+
+    function setBondMinter(IBondMinter bondMinter_, uint256 bondMinterConfigIDX_, uint256[] memory bondTrancheYields) public onlyOwner {
+        // TODO: consider using custom minter rather than button's
+        // the current version does not have a instance check function
+        require(address(bondMinter_) != address(0), "Expected bond minter to be set");
+
+        require(bondMinter_.numConfigs() > bondMinterConfigIDX_, "Expected bond minter to be configured");
+
+        bondMinter = bondMinter_;
+        bondMinterConfigIDX = bondMinterConfigIDX_;
+
+        require(bondTrancheYields.length == bondMinter_.trancheCount(bondMinterConfigIDX_), "Must specify yields for every bond tranche");
+        trancheYields[bondMinter_] = bondTrancheYields;
+    }
+
+    function tolarableBondMaturiyDate() public view returns (uint256) {
+        return block.timestamp + _tolarableBondMaturiy;
+    }
+
     /*
+
+
     function calcMintFee(uint256[] calldata trancheAmts) view returns (uint256) {
 
     }
@@ -103,9 +175,7 @@ contract ACash is ERC20 {
 
     }
 
-    function advanceBond(address bond) public onlyOwner {
-        // enqueue empty bond
-    }
+
     */
     
 }
diff --git a/contracts/interfaces/IBondController.sol b/contracts/interfaces/IBondController.sol
@@ -17,6 +17,8 @@ interface IBondController {
     event Redeem(address user, uint256[] amounts);
     event FeeUpdate(uint256 newFee);
 
+    function maturityDate() external view returns (uint256);
+
     function collateralToken() external view returns (address);
 
     function tranches(uint256 i) external view returns (ITranche token, uint256 ratio);
diff --git a/contracts/interfaces/IBondMinter.sol b/contracts/interfaces/IBondMinter.sol
@@ -0,0 +1,80 @@
+/**
+ * @title BondMinter Interface
+ * @notice Interface for canonically minting bonds according to a stored vaults of configurations
+ */
+interface IBondMinter{
+    struct BondConfig {
+        address collateralToken;
+        uint256[] trancheRatios;
+        uint256 duration;
+    }
+
+    /**
+     * @notice Event emitted when a new BondConfig is added
+     * @param collateralToken address of the contract for the collateral
+     * @param trancheRatios Tranching ratios for the bonds. Must sum up to 1000.
+     * @param duration Duration of the bond in seconds
+     */
+    event BondConfigAdded(address collateralToken, uint256[] trancheRatios, uint256 duration);
+
+    /**
+     * @notice Event emitted when a BondConfig is removed
+     * @param collateralToken address of the contract for the collateral
+     * @param trancheRatios Tranching ratios for the bonds. Must sum up to 1000.
+     * @param duration Duration of the bond in seconds
+     */
+    event BondConfigRemoved(address collateralToken, uint256[] trancheRatios, uint256 duration);
+
+    /**
+     * @notice Adds new bond configuration to internal list. Emits BondConfigAdded on successful add
+     * @param collateralToken address of the contract for the collateral
+     * @param trancheRatios Tranching ratios for the bonds. Must sum up to 1000.
+     * @param duration Duration of the bond in seconds
+     * @return true if the bondConfig was added, that is if it wasn't already present.
+     */
+    function addBondConfig(
+        address collateralToken,
+        uint256[] memory trancheRatios,
+        uint256 duration
+    ) external returns (bool);
+
+    /**
+     * @notice Removes bond configuration to internal list
+     * @param collateralToken address of the contract for the collateral
+     * @param trancheRatios Tranching ratios for the bonds. Must sum up to 1000.
+     * @param duration Duration of the bond in seconds
+     * @return true if the bondConfig was removed, that is if it was present.
+     */
+    function removeBondConfig(
+        address collateralToken,
+        uint256[] memory trancheRatios,
+        uint256 duration
+    ) external returns (bool);
+
+    /**
+     * @notice The number of configs stored in the vault
+     */
+    function numConfigs() external view returns (uint256);
+
+    /**
+     * @notice Returns the bondConfig stored at `index`
+     */
+    function bondConfigAt(uint256 index) external view returns (BondConfig memory);
+
+    /**
+     * @notice Sets the bondFactory
+     * @param _bondFactory The bondFactory that will be used mint the bonds
+     */
+    function setBondFactory(address _bondFactory) external;
+
+    /**
+     * @notice Sets the waitingPeriod required between minting periods
+     * @param _waitingPeriod The minimum waiting period (in seconds) between mints
+     */
+    function setWaitingPeriod(uint256 _waitingPeriod) external;
+
+    /**
+     * @notice Iterates over configurations and mints bonds for each using the bondFactory
+     */
+    function mintBonds() external;
+}
diff --git a/contracts/utils/AddressQueue.sol b/contracts/utils/AddressQueue.sol
@@ -28,11 +28,11 @@ library AddressQueue {
         return a;
     }
 
-    function head(Queue storage q) public view returns (address) {
+    function head(Queue storage q) internal view returns (address) {
         return q.queue[q.first];
     }
 
-    function tail(Queue storage q) public view returns (address) {
+    function tail(Queue storage q) internal view returns (address) {
         return q.queue[q.last];
     }
 
diff --git a/contracts/utils/BondMinterHelpers.sol b/contracts/utils/BondMinterHelpers.sol
@@ -0,0 +1,37 @@
+pragma solidity ^0.8.0;
+
+import {IBondMinter} from "../interfaces/IBondMinter.sol";
+import {IBondController} from "../interfaces/IBondController.sol";
+
+library BondMinterHelpers {
+  // checks if bond as the same config as the minter config
+  function isConfigMatch(IBondMinter minter, uint256 configIDX, IBondController bond) internal returns (bool) {
+
+    IBondMinter.BondConfig memory config = minter.bondConfigAt(configIDX);
+
+    // collateral token mismatch
+    if(bond.collateralToken() != config.collateralToken){
+      return false;
+    }
+
+    // tranche ratios mismatch
+    uint256 trancheCount = bond.trancheCount();
+    if(trancheCount != config.trancheRatios.length) {
+      return false;
+    }
+
+    for(uint256 i = 0; i < trancheCount; i++) {
+      (, uint256 ratio) = bond.tranches(i);
+      if(ratio != config.trancheRatios[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  function trancheCount(IBondMinter minter, uint256 configIDX) internal returns(uint256){
+    IBondMinter.BondConfig memory config = minter.bondConfigAt(configIDX);
+    return config.trancheRatios.length;
+  }
+}
diff --git a/test/ACash.ts b/test/ACash.ts
@@ -3,9 +3,9 @@ import { ethers } from "hardhat";
 
 describe("ACash", function () {
   it("Should construct with name and symbol", async function () {
-    const ACash = await ethers.getContractFactory("ACash");
+      const ACash = await ethers.getContractFactory("ACash");
       const acash = await ACash.deploy("Spot Cash", "SPOT", "9");
-    await acash.deployed();
+      await acash.deployed();
 
       expect(await acash.name()).to.equal("Spot Cash");
       expect(await acash.symbol()).to.equal("SPOT");

Original file line number	Diff line number	Diff line change
`@@ -28,11 +28,11 @@ library AddressQueue {`
`28`	`28`	`return a;`
`29`	`29`	`}`
`30`	`30`
`31`		`- function head(Queue storage q) public view returns (address) {`
	`31`	`+ function head(Queue storage q) internal view returns (address) {`
`32`	`32`	`return q.queue[q.first];`
`33`	`33`	`}`
`34`	`34`
`35`		`- function tail(Queue storage q) public view returns (address) {`
	`35`	`+ function tail(Queue storage q) internal view returns (address) {`
`36`	`36`	`return q.queue[q.last];`
`37`	`37`	`}`
`38`	`38`