single class minter

Author: aalavandhan

contracts/BondMinter.sol

@@ -3,113 +3,63 @@ pragma solidity ^0.8.0;
 import {IBondFactory} from "./interfaces/button-wood/IBondFactory.sol";
 import {IBondMinter} from "./interfaces/IBondMinter.sol";
 
-import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
-import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
-
-// A class of bonds are uniquely identified by collateralToken, trancheRatios and duration,
-// which are hashed to create the bond's config hash
-// Based on the provided frequency minter instantiates new bonds for each config when poked
+// A minter periodically mints a specified class of bonds or config
+// a config is uniquely identified by {collateralToken, trancheRatios and duration}
+// Based on the provided frequency minter instantiates new bonds with the given config when poked
 //
-// Minor Modification to button wood's version keep track of the bond <-> config reference
+// Minor Modification to button wood's version
 // https://github.com/buttonwood-protocol/tranche/blob/main/contracts/bondMinter/
-// we want to know given a bond, was it minted by this minter and what is it's config hash
-contract BondMinter is IBondMinter, Ownable {
-    using EnumerableSet for EnumerableSet.Bytes32Set;
-
+// in ours configs are immutable and we limit one config per minter
+contract BondMinter is IBondMinter {
     // bond factory
     IBondFactory public immutable bondFactory;
 
     // mint frequency parameters
     uint256 public immutable waitingPeriod;
     uint256 public lastMintTimestamp;
 
+    // minter bond config
+    IBondMinter.BondConfig public config;
+    bytes32 public immutable override configHash;
+
     // mapping of minted bonds
     mapping(address => bool) mintedBonds;
 
-    // mapping to get the full bond config from config hash
-    mapping(bytes32 => IBondMinter.BondConfig) private configHashesToConfigs;
-
-    // mapping to get bond config hash from bond address
-    mapping(address => bytes32) private bondToConfigHashes;
-
-    // list of config hashes
-    EnumerableSet.Bytes32Set private configHashes;
 
-    constructor(IBondFactory bondFactory_,  uint256 waitingPeriod_) {
+    constructor(IBondFactory bondFactory_,  uint256 waitingPeriod_, IBondMinter.BondConfig memory config_) {
         bondFactory = bondFactory_;
         waitingPeriod = waitingPeriod_;
+        config = config_;
+        configHash = computeHash(config_);
         lastMintTimestamp = 0;
+
+        emit BondConfigAdded(config);
     }
 
     // checks if bond has been minted using this minter
     function isInstance(address bond) external view override returns (bool) {
         return mintedBonds[bond];
     }
 
-    // gets the bond's config hash
-    function getConfigHash(address bond) external view override returns (bytes32) {
-        return bondToConfigHashes[bond];
-    }
-
-    // get the bond's config
-    function getConfig(address bond) external view override returns (IBondMinter.BondConfig memory) {
-        return configHashesToConfigs[bondToConfigHashes[bond]];
-    }
-
-    // counts all configs
-    function numConfigs() public view override returns (uint256) {
-        return configHashes.length();
-    }
-
-    // gets configs
-    function bondConfigAt(uint256 index) public view override returns (IBondMinter.BondConfig memory) {
-        return configHashesToConfigs[configHashes.at(index)];
-    }
-
     function mintBonds() external override {
         require(
             block.timestamp - lastMintTimestamp >= waitingPeriod,
             "BondMinter: Not enough time has passed since last mint timestamp"
         );
         lastMintTimestamp = block.timestamp;
 
-        for (uint256 i = 0; i < numConfigs(); i++) {
-            BondConfig memory bondConfig = bondConfigAt(i);
-            bytes32 configHash = computeHash(bondConfig);
-            address bond = bondFactory.createBond(
-                bondConfig.collateralToken,
-                bondConfig.trancheRatios,
-                lastMintTimestamp + bondConfig.duration
-            );
-
-            mintedBonds[bond] = true;
-            bondToConfigHashes[bond] = configHash;
-
-            emit BondMinted(bond, configHash);
-        }
-    }
+        address bond = bondFactory.createBond(
+            config.collateralToken,
+            config.trancheRatios,
+            lastMintTimestamp + config.duration
+        );
 
-    function addBondConfig(IBondMinter.BondConfig memory config) external onlyOwner returns (bool) {
-        bytes32 hash = computeHash(config);
-        if (configHashes.add(hash)) {
-            configHashesToConfigs[hash] = config;
-            emit BondConfigAdded(config);
-            return true;
-        }
-        return false;
-    }
+        mintedBonds[bond] = true;
 
-    function removeBondConfig(IBondMinter.BondConfig memory config) external onlyOwner returns (bool) {
-        bytes32 hash = computeHash(config);
-        if (configHashes.remove(hash)) {
-            delete configHashesToConfigs[hash];
-            emit BondConfigRemoved(config);
-            return true;
-        }
-        return false;
+        emit BondMinted(bond);
     }
 
-    function computeHash(IBondMinter.BondConfig memory config) private pure returns (bytes32) {
-        return keccak256(abi.encode(config.collateralToken, config.trancheRatios, config.duration));
+    function computeHash(IBondMinter.BondConfig memory config_) private pure returns (bytes32) {
+        return keccak256(abi.encode(config_.collateralToken, config_.trancheRatios, config_.duration));
     }
 }

contracts/YieldStrategy.sol

@@ -11,20 +11,21 @@ contract YieldStrategy is Ownable, IYieldStrategy {
 
 	// todo: add setters
 
-	// tranche yield is specific to each unique bond config
-	// config => {collateralToken, trancheRatios, duration}
-	mapping(bytes32 => uint256[]) private _trancheYields;
+	// tranche yield is specific to a bond minter (which mints a specific class of bonds)
+	// a bond class is uniquely identified by {collateralToken, trancheRatios, duration}
+	mapping(IBondMinter => uint256[]) private _trancheYields;
 
 	function computeTrancheYield(IBondMinter minter, IBondController bond, uint256 seniorityIDX, uint256 trancheAmt) external view override returns (uint256) {
 		return trancheAmt * computeTrancheYieldPerc(minter, bond, seniorityIDX) / (10 ** PCT_DECIMALS);
 	}
 
 	function computeTrancheYieldPerc(IBondMinter minter, IBondController bond, uint256 seniorityIDX) public view returns (uint256) {
+		// assert(minter.isInstance(bond));
 		return trancheYields(minter, bond, seniorityIDX) * computeTranchePrice(bond, seniorityIDX) / (10 ** PRICE_DECIMALS);
 	}
 
 	function trancheYields(IBondMinter minter, IBondController bond, uint256 seniorityIDX) public view returns (uint256) {
-		return _trancheYields[minter.getConfigHash(address(bond))][seniorityIDX];
+		return _trancheYields[minter][seniorityIDX];
 	}
 
 	// Tranche pricing function goes here:

contracts/interfaces/IBondMinter.sol

@@ -7,19 +7,11 @@ interface IBondMinter {
 
     event BondConfigAdded(BondConfig config);
 
-    event BondConfigRemoved(BondConfig config);
-
-    event BondMinted(address bond, bytes32 configHash);
+    event BondMinted(address bond);
 
     function mintBonds() external;
 
     function isInstance(address bond) external view returns (bool);
 
-    function getConfigHash(address bond) external view returns (bytes32);
-
-    function getConfig(address bond) external view returns (BondConfig memory);
-
-    function numConfigs() external view returns (uint256);
-
-    function bondConfigAt(uint256 index) external view returns (BondConfig memory);
+    function configHash() external view returns (bytes32);
 }