1  pragma solidity >=0.6.0;
  2  pragma experimental ABIEncoderV2;
  3  
  4  import "../deployment/Deployer.sol";
  5  import "../deployment/ManagedContract.sol";
  6  import "../interfaces/IProtocolSettings.sol";
  7  import "../interfaces/IOptionsExchange.sol";
  8  import "../interfaces/IERC20.sol";
  9  import "../interfaces/IGovernableLiquidityPool.sol";
 10  import "../interfaces/IProposalManager.sol";
 11  import "../interfaces/IProposalWrapper.sol";
 12  
 13  
 14  contract ProtocolReader is ManagedContract {
 15  
 16      IProtocolSettings private settings;
 17      IOptionsExchange private exchange;
 18      IProposalManager private proposalManager;
 19  
 20      struct poolData {
 21        string[] poolSymbols;
 22        address[] poolAddrs;
 23        uint[] poolApy;
 24        uint[] poolBalance;
 25        uint[] poolFreeBalance;
 26        uint[] userPoolBalance;
 27        uint[] userPoolUsdValue;
 28        uint[] poolMaturityDate;
 29        uint[] poolWithdrawalFee;
 30        string[] poolSymbolList;
 31      }
 32  
 33      struct poolPricesData {
 34        //address[] poolAddrs;
 35        uint[] poolBuyPrice;
 36        uint[] poolSellPrice;
 37        uint[] poolBuyPriceVolume;
 38        uint[] poolSellPriceVolume;
 39      }
 40  
 41      struct poolOptions {
 42        string[] poolSymbols;
 43        address[] poolAddrs;
 44        string[] poolOptionsRaw;
 45      }
 46  
 47      struct proposalData {
 48        address[] addr;
 49        address[] wrapperAddr;
 50        address[] govToken;
 51        IProposalWrapper.VoteType[] voteType;
 52        IProposalWrapper.Status[] status;
 53        bool[] isActive;
 54      }
 55  
 56      event IncentiveReward(address indexed from, uint value);
 57  
 58      function initialize(Deployer deployer) override internal {
 59          settings = IProtocolSettings(deployer.getContractAddress("ProtocolSettings"));
 60          exchange = IOptionsExchange(deployer.getContractAddress("OptionsExchange"));
 61          proposalManager = IProposalManager(deployer.getContractAddress("ProposalsManager"));
 62      }
 63  
 64      function listPoolsData(address account) external view returns (poolData memory){
 65        
 66        uint poolSymbolsMaxLen = exchange.totalPoolSymbols();
 67        poolData memory pd;
 68        pd.poolSymbols = new string[](poolSymbolsMaxLen);
 69        pd.poolAddrs = new address[](poolSymbolsMaxLen);
 70        pd.poolApy = new uint[](poolSymbolsMaxLen);
 71        pd.poolBalance = new uint[](poolSymbolsMaxLen);
 72        pd.poolFreeBalance = new uint[](poolSymbolsMaxLen);
 73        pd.userPoolBalance = new uint[](poolSymbolsMaxLen);
 74        pd.userPoolUsdValue = new uint[](poolSymbolsMaxLen);
 75        pd.poolMaturityDate = new uint[](poolSymbolsMaxLen);
 76        pd.poolWithdrawalFee = new uint[](poolSymbolsMaxLen);
 77        pd.poolSymbolList = new string[](poolSymbolsMaxLen);
 78  
 79  
 80        for (uint i=0; i < poolSymbolsMaxLen; i++) {
 81            string memory pSym = exchange.poolSymbols(i);
 82            pd.poolSymbols[i] = pSym;
 83            address poolAddr = exchange.getPoolAddress(pSym);
 84            pd.poolAddrs[i] = poolAddr;
 85            try IGovernableLiquidityPool(poolAddr).yield(365 * 24 * 60 * 60) returns (uint v) {
 86                pd.poolApy[i] = v;
 87            } catch (bytes memory /*lowLevelData*/) {
 88                pd.poolApy[i] = 0;
 89            }
 90            pd.poolBalance[i] = exchange.balanceOf(poolAddr);
 91            pd.userPoolBalance[i] = IERC20(poolAddr).balanceOf(account);
 92            try IGovernableLiquidityPool(poolAddr).valueOf(account) returns (uint v) {
 93                pd.userPoolUsdValue[i] = v;
 94            } catch (bytes memory /*lowLevelData*/) {
 95                pd.userPoolUsdValue[i] = 0;
 96            }
 97            pd.poolFreeBalance[i] = IGovernableLiquidityPool(poolAddr).calcFreeBalance();
 98            pd.poolMaturityDate[i] = IGovernableLiquidityPool(poolAddr).maturity();
 99            pd.poolWithdrawalFee[i] = IGovernableLiquidityPool(poolAddr).withdrawFee();
100            pd.poolSymbolList[i] = IGovernableLiquidityPool(poolAddr).listSymbols();
101        }
102  
103        return pd;
104      }
105  
106      function listPoolOptions() external view returns (poolOptions memory) {
107        uint poolSymbolsMaxLen = exchange.totalPoolSymbols();
108  
109        poolOptions memory po;
110        po.poolOptionsRaw = new string[](poolSymbolsMaxLen);
111        po.poolSymbols = new string[](poolSymbolsMaxLen);
112        po.poolAddrs = new address[](poolSymbolsMaxLen);
113  
114  
115        for(uint i=0; i< poolSymbolsMaxLen; i++) {
116          string memory pSym = exchange.poolSymbols(i);
117          po.poolSymbols[i] = pSym;
118          address poolAddr = exchange.getPoolAddress(pSym);
119          po.poolAddrs[i] = poolAddr;
120          po.poolOptionsRaw[i] = IGovernableLiquidityPool(poolAddr).listSymbols();
121  
122        }
123  
124        return po;
125      }
126  
127      function listPoolsPrices(string calldata optionSymbol, address[] calldata poolAddressList) external view returns (poolPricesData memory){
128        
129        poolPricesData memory ppd;
130        //ppd.poolAddrs = poolAddressList;
131        ppd.poolBuyPrice = new uint[](poolAddressList.length);
132        ppd.poolSellPrice = new uint[](poolAddressList.length);
133        ppd.poolBuyPriceVolume = new uint[](poolAddressList.length);
134        ppd.poolSellPriceVolume = new uint[](poolAddressList.length);
135  
136        for (uint i=0; i < poolAddressList.length; i++) {
137  
138            (ppd.poolBuyPrice[i], ppd.poolBuyPriceVolume[i]) = IGovernableLiquidityPool(poolAddressList[i]).queryBuy(optionSymbol, true);
139            (ppd.poolSellPrice[i], ppd.poolSellPriceVolume[i]) = IGovernableLiquidityPool(poolAddressList[i]).queryBuy(optionSymbol, false);
140        }
141  
142        return ppd;
143      }
144  
145      function listProposals() external view returns (proposalData memory) {
146        proposalData memory pd;
147        uint totalProposals = proposalManager.proposalCount();
148  
149        pd.addr = new address[](totalProposals);
150        pd.wrapperAddr = new address[](totalProposals);
151        pd.govToken = new address[](totalProposals);
152        pd.voteType = new IProposalWrapper.VoteType[](totalProposals);
153        pd.status = new IProposalWrapper.Status[](totalProposals);
154        pd.isActive = new bool[](totalProposals);
155  
156        for(uint i=1; i< totalProposals; i++){
157          pd.addr[i] = proposalManager.resolveProposal(i);
158          pd.wrapperAddr[i] = proposalManager.resolve(pd.addr[i]);
159          pd.govToken[i] = IProposalWrapper(pd.wrapperAddr[i]).getGovernanceToken();
160          pd.voteType[i] = IProposalWrapper(pd.wrapperAddr[i]).getVoteType();
161          pd.status[i] = IProposalWrapper(pd.wrapperAddr[i]).getStatus();
162          pd.isActive[i] = IProposalWrapper(pd.wrapperAddr[i]).isActive();
163        }
164        return pd;
165      }
166  }