diff --git a/contracts/governance/ZrxTreasury.json b/contracts/governance/ZrxTreasury.json new file mode 100644 index 0000000000..6f5aaef980 --- /dev/null +++ b/contracts/governance/ZrxTreasury.json @@ -0,0 +1,12781 @@ +{ + "abi": [ + { + "inputs": [ + { + "internalType": "contract IStaking", + "name": "stakingProxy_", + "type": "address" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "votingPeriod", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "proposalThreshold", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "quorumThreshold", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "defaultPoolId", + "type": "bytes32" + } + ], + "internalType": "struct IZrxTreasury.TreasuryParameters", + "name": "params", + "type": "tuple" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "proposer", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "address", + "name": "target", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "indexed": false, + "internalType": "struct IZrxTreasury.ProposedAction[]", + "name": "actions", + "type": "tuple[]" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "executionEpoch", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "string", + "name": "description", + "type": "string" + } + ], + "name": "ProposalCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + } + ], + "name": "ProposalExecuted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "voter", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "support", + "type": "bool" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "votingPower", + "type": "uint256" + } + ], + "name": "VoteCast", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "support", + "type": "bool" + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + } + ], + "name": "castVote", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "support", + "type": "bool" + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + }, + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "name": "castVoteBySignature", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "defaultPoolId", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "defaultPoolOperator", + "outputs": [ + { + "internalType": "contract DefaultPoolOperator", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "address", + "name": "target", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "internalType": "struct IZrxTreasury.ProposedAction[]", + "name": "actions", + "type": "tuple[]" + } + ], + "name": "execute", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + } + ], + "name": "getVotingPower", + "outputs": [ + { + "internalType": "uint256", + "name": "votingPower", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "hasVoted", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "proposalCount", + "outputs": [ + { + "internalType": "uint256", + "name": "count", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "proposalThreshold", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "proposals", + "outputs": [ + { + "internalType": "bytes32", + "name": "actionsHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "executionEpoch", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "voteEpoch", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "votesFor", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "votesAgainst", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "executed", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "target", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "internalType": "struct IZrxTreasury.ProposedAction[]", + "name": "actions", + "type": "tuple[]" + }, + { + "internalType": "uint256", + "name": "executionEpoch", + "type": "uint256" + }, + { + "internalType": "string", + "name": "description", + "type": "string" + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + } + ], + "name": "propose", + "outputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "quorumThreshold", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "stakingProxy", + "outputs": [ + { + "internalType": "contract IStaking", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "newProposalThreshold", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "newQuorumThreshold", + "type": "uint256" + } + ], + "name": "updateThresholds", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "votingPeriod", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "stateMutability": "payable", + "type": "receive" + } + ], + "bytecode": { + "object": "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", + "sourceMap": "993:14117:16:-:0;;;2409:870;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2526:13;-1:-1:-1;;;;;2526:36:16;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2504:19;;:60;2496:95;;;;-1:-1:-1;;;2496:95:16;;;;;;;:::i;:::-;;;;;;;;;2601:28;;;;-1:-1:-1;;;;;;2601:28:16;;;2654:19;;2639:34;;2703:24;;;;2654:19;2683:44;2755:22;;;;2737:15;:40;2803:20;;;2787:36;;2833:32;;:::i;:::-;2897:20;;;;2868:50;;-1:-1:-1;;;2868:50:16;;-1:-1:-1;;;;;2868:28:16;;;;;:50;;2897:20;2868:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2970:20;;2928:63;;-1:-1:-1;;;;;;2928:63:16;;;3119:13;;;;;;;;;;;;-1:-1:-1;;;3119:13:16;;;;;2970:20;-1:-1:-1;1417:95:16;3103:31;3152:13;:11;:13::i;:::-;3199:16;;;;;;;;;;;-1:-1:-1;;;3199:16:16;;;;;3042:220;;;;;;;3183:34;;3243:4;;3042:220;;:::i;:::-;;;;-1:-1:-1;;3042:220:16;;;;;;;;;3019:253;;3042:220;3019:253;;;;3001:271;;-1:-1:-1;993:14117:16;;-1:-1:-1;;993:14117:16;14936:172;15059:9;14936:172;:::o;993:14117::-;;;;;;;;;;-1:-1:-1;993:14117:16;;;;;;;;:::o;2199:506:-1:-;;;2372:9;2363:7;2359:23;2384:3;2359:23;2355:33;2352:2;;;-1:-1;;2391:12;2352:2;388:6;382:13;400:50;444:5;400:50;:::i;:::-;2443:91;-1:-1;1186:4;-1:-1;;1165:19;;1161:30;1158:2;;;-1:-1;;1194:12;1158:2;;1222:20;1186:4;1222:20;:::i;:::-;2571:2;2661:9;2657:22;1997:13;1314:16;1307:86;1532:22;2661:9;1532:22;1997:13;2571:2;1486:5;1482:16;1475:86;1698:22;2661:9;1698:22;1997:13;1532:22;1652:5;1648:16;1641:86;1186:4;2661:9;1862:22;224:13;1698:22;1816:5;1812:16;1805:86;2579:110;;;;2346:359;;;;;:::o;2712:307::-;;2849:2;2837:9;2828:7;2824:23;2820:32;2817:2;;;-1:-1;;2855:12;2817:2;647:20;2849:2;647:20;:::i;:::-;89:6;83:13;101:33;128:5;101:33;:::i;:::-;728:86;;884:2;948:22;;2137:13;6482:10;6471:22;;7093:34;;7083:2;;-1:-1;;7131:12;7083:2;884;899:16;;892:85;903:5;2811:208;-1:-1;;;2811:208::o;3026:263::-;;3141:2;3129:9;3120:7;3116:23;3112:32;3109:2;;;-1:-1;;3147:12;3109:2;-1:-1;1997:13;;3103:186;-1:-1;3103:186::o;4011:222::-;3511:37;;;4138:2;4123:18;;4109:124::o;4240:700::-;3511:37;;;4660:2;4645:18;;3511:37;;;;4743:2;4728:18;;3511:37;;;;4826:2;4811:18;;3511:37;-1:-1;;;;;6265:54;4925:3;4910:19;;3383:45;4495:3;4480:19;;4466:474::o;4947:416::-;5147:2;5161:47;;;3785:2;5132:18;;;5737:19;3821:24;5777:14;;;3801:45;3865:12;;;5118:245::o;5370:256::-;5432:2;5426:9;5458:17;;;-1:-1;;;;;5518:34;;5554:22;;;5515:62;5512:2;;;5590:1;;5580:12;5512:2;5432;5599:22;5410:216;;-1:-1;5410:216::o;6505:117::-;-1:-1;;;;;6265:54;;6564:35;;6554:2;;6613:1;;6603:12;6554:2;6548:74;:::o;:::-;993:14117:16;;;;;;;;;;;;;;;;;;;;;;;;;", + "linkReferences": {} + }, + "deployedBytecode": { + "object": "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", + "sourceMap": "993:14117:16:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2103:27;;;;;;;;;;-1:-1:-1;2103:27:16;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;1903:46;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;1726:47::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;2136:60::-;;;;;;;;;;-1:-1:-1;2136:60:16;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;8372:689::-;;;;;;:::i;:::-;;:::i;:::-;;2042:39;;;;;;;;;;;;;:::i;9863:1560::-;;;;;;;;;;-1:-1:-1;9863:1560:16;;;;;:::i;:::-;;:::i;1779:65::-;;;;;;;;;;;;;:::i;1850:47::-;;;;;;;;;;;;;:::i;1995:41::-;;;;;;;;;;;;;:::i;3787:281::-;;;;;;;;;;-1:-1:-1;3787:281:16;;;;;:::i;:::-;;:::i;7554:588::-;;;;;;;;;;-1:-1:-1;7554:588:16;;;;;:::i;:::-;;:::i;5188:936::-;;;;;;;;;;-1:-1:-1;5188:936:16;;;;;:::i;:::-;;:::i;9166:110::-;;;;;;;;;;;;;:::i;6671:185::-;;;;;;;;;;-1:-1:-1;6671:185:16;;;;;:::i;:::-;;:::i;2103:27::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2103:27:16;;;;;;;:::o;1903:46::-;;;:::o;1726:47::-;;;:::o;2136:60::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;8372:689::-;8494:15;:13;:15::i;:::-;8480:10;:29;8476:97;;8525:37;;;;;;;;;;:::i;:::-;;;;;;;;8476:97;8582:24;;:::i;:::-;8609:9;8619:10;8609:21;;;;;;;;;;;;;;;;;8582:48;;;;;;;;8609:21;;;;;;;8582:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8640:44:16;8582:48;8676:7;8640:25;:44::i;:::-;8728:4;8695:9;8705:10;8695:21;;;;;;;;;;;;;;;;;;;;;:30;;:37;;;;;;;;;;;;;;8743:268;8768:7;:14;8763:1;:19;8743:268;;8803:28;;:::i;:::-;8834:7;8842:1;8834:10;;;;;;;;;;;;;;8803:41;;8859:15;8880:6;:13;;;:18;;8906:6;:12;;;8920:6;:11;;;8880:52;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8858:74;;;8954:10;8946:54;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;8784:3:16;;8743:268;;;;9026:28;9043:10;9026:28;;;;;;:::i;:::-;;;;;;;;8372:689;;;:::o;2042:39::-;;;;:::o;9863:1560::-;9990:19;10021:24;10048:12;:47;;;10096:7;10105:30;10048:88;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:121;;;10021:148;;;;10179:37;10219:12;:56;;;10276:7;10285:13;10219:80;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:113;;;10179:153;;;-1:-1:-1;10540:66:16;10604:1;10540:55;:16;10179:153;10540:24;:55::i;:::-;:63;;:66::i;:::-;10526:80;;10678:9;10673:715;10698:15;:22;10693:1;:27;10673:715;;10746:9;10741:151;10766:1;10761;:6;10741:151;;10822:15;10838:1;10822:18;;;;;;;;;;;;;;10800:15;10816:1;10800:18;;;;;;;;;;;;;;:40;;10792:85;;;;;;;;;;;;:::i;:::-;10769:3;;10741:151;;;;10905:25;;:::i;:::-;10933:12;:27;;;10961:15;10977:1;10961:18;;;;;;;;;;;;;;10933:47;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10905:75;;11019:7;11002:24;;:4;:13;;;:24;;;10994:80;;;;;;;;;;;;:::i;:::-;11088:27;11118:12;:58;;;11177:15;11193:1;11177:18;;;;;;;;;;;;;;11118:78;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:115;;;;-1:-1:-1;11247:23:16;11273:40;:29;;;11311:1;11273:37;:40::i;:::-;11247:66;-1:-1:-1;11341:36:16;:11;11247:66;11341:19;:36::i;:::-;11327:50;-1:-1:-1;;10722:3:16;;;;;-1:-1:-1;10673:715:16;;-1:-1:-1;10673:715:16;;;11398:18;;9863:1560;;;;;:::o;1779:65::-;;;:::o;1850:47::-;;;:::o;1995:41::-;;;;:::o;3787:281::-;3907:10;3929:4;3907:27;3899:66;;;;;;;;;;;;:::i;:::-;3975:17;:40;;;;4025:15;:36;3787:281::o;7554:588::-;7762:18;1617:84;7832:10;7844:7;7880:15;7863:33;;;;;;;;:::i;:::-;;;;;;;;;;;;;7853:44;;;;;;7806:92;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;7783:125;;;;;;7762:146;;7918:14;7974:15;7991:10;7945:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;7935:68;;;;;;7918:85;;8013:17;8033:26;8043:6;8051:1;8054;8057;8033:26;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8013:46;;8077:58;8087:9;8098:10;8110:7;8119:15;8077:9;:58::i;:::-;8070:65;;;7554:588;;;;;;:::o;5188:936::-;5386:18;5471:17;;5424:43;5439:10;5451:15;5424:14;:43::i;:::-;:64;;5416:110;;;;;;;;;;;;:::i;:::-;5561:1;5544:7;:14;:18;5536:58;;;;;;;;;;;;:::i;:::-;5604:20;5627:12;:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5604:50;;5690:12;5705:1;5690:16;5672:14;:34;;5664:78;;;;;;;;;;;;:::i;:::-;5766:15;:13;:15::i;:::-;5822:9;:16;;;;;;;5791:28;5822:16;;;;5884:19;;5753:28;;-1:-1:-1;5822:16:16;;;;;5884:19;;5895:7;;5822:16;5884:19;;:::i;:::-;;;;;;;;;;;;;;;5874:30;;5884:19;5874:30;;;;5848:56;;5914:26;;;:43;;;6006:1;5991:16;;;5967:21;;;:40;6023:94;;;;6039:10;;6051:15;;6068:10;;6080:7;;5943:14;;6105:11;;6023:94;:::i;:::-;;;;;;;;5188:936;;;;;;;;:::o;9166:110::-;9253:9;:16;9166:110;:::o;6671:185::-;6790:59;6800:10;6812;6824:7;6833:15;6790:9;:59::i;:::-;6671:185;;;:::o;11567:586::-;11726:20;;11702:19;;;;11713:7;;11702:19;;;:::i;:::-;;;;;;;;;;;;;11692:30;;;;;;:54;11684:108;;;;;;;;;;;;:::i;:::-;11810:28;11829:8;11810:18;:28::i;:::-;11802:90;;;;;;;;;;;;:::i;:::-;11911:8;:17;;;11910:18;11902:82;;;;;;;;;;;;:::i;:::-;12046:8;:23;;;12015:12;:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:54;11994:152;;;;;;;;;;;;:::i;:::-;11567:586;;:::o;2056:410:2:-;2118:7;2149:5;;;2168;;;2164:278;;;2189:242;2231:186;2295:58;2375:1;2398;2231:42;:186::i;:::-;2189:24;:242::i;:::-;2458:1;2056:410;-1:-1:-1;;;2056:410:2:o;1243:::-;1305:7;1328:6;1324:278;;1350:241;1392:185;1456:57;1535:1;1558;1392:42;:185::i;1350:241::-;1611:9;1627:1;1623;:5;;;;;;;1243:410;-1:-1:-1;;;;1243:410:2:o;13801:1089:16:-;13939:15;:13;:15::i;:::-;13925:10;:29;13921:99;;13970:39;;;;;;;;;;:::i;13921:99::-;14033:20;;;;:8;:20;;;;;;;;:27;;;;;;;;;;;;;14029:91;;;14076:33;;;;;;;;;;:::i;14029:91::-;14130:24;;:::i;:::-;14157:9;14167:10;14157:21;;;;;;;;;;;;;;;;;14130:48;;;;;;;;14157:21;;;;;;;14130:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14214:27;;;;;;;14130:48;;-1:-1:-1;14214:25:16;:12;:25;;;;:27;;;;14157:21;;14214:27;;;;;;;:25;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14192:8;:18;;;:49;;:86;;;;14245:33;14259:8;:18;;;14245:13;:33::i;:::-;14188:153;;;14294:36;;;;;;;;;;:::i;14188:153::-;14351:19;14373:38;14388:5;14395:15;14373:14;:38::i;:::-;14351:60;-1:-1:-1;14425:16:16;14421:82;;14457:35;;;;;;;;;;:::i;14421:82::-;14517:7;14513:245;;;14573:51;14612:11;14573:9;14583:10;14573:21;;;;;;;;;;;;;;;;;;:30;;;:38;;:51;;;;:::i;:::-;14540:9;14550:10;14540:21;;;;;;;;;;;;;;;;;;:30;;:84;;;;14513:245;;;14692:55;14735:11;14692:9;14702:10;14692:21;;;;;;;;;;;;;;;;;;:34;;;:42;;:55;;;;:::i;:::-;14655:9;14665:10;14655:21;;;;;;;;;;;;;;;;;;:34;;:92;;;;14513:245;14767:20;;;;:8;:20;;;;;;;;:27;;;;;;;;;;;;:34;;;;14797:4;14767:34;;;14817:66;;;;;14788:5;;14833:15;;14776:10;;14862:7;;14871:11;;14817:66;:::i;:::-;;;;;;;;13801:1089;;;;;;:::o;12331:520::-;12407:14;12496:33;12510:8;:18;;;12496:13;:33::i;:::-;12491:77;;-1:-1:-1;12552:5:16;12545:12;;12491:77;12637:8;:21;;;12616:8;:17;;;:42;12612:85;;-1:-1:-1;12681:5:16;12674:12;;12612:85;12770:15;;12750:8;:17;;;:35;12746:78;;;-1:-1:-1;12808:5:16;12801:12;;12746:78;-1:-1:-1;12840:4:16;12331:520;;;;:::o;1340:206:5:-;1439:12;808:10;1493:28;;1523:9;1534:1;1537;1470:69;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1340:206:5;;;;;:::o;1382:150:4:-;1505:9;1499:16;1492:4;1481:9;1477:20;1470:46;13066:540:16;13130:13;13155:20;13178:12;:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13155:50;;13234:9;13219:12;:24;13215:67;;;13266:5;13259:12;;;;;13215:67;13310:9;13295:12;:24;13291:66;;;13342:4;13335:11;;;;;13291:66;13464:19;13486:67;13540:12;13486;:43;;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;:67::i;:::-;13570:15;:29;;13066:540;-1:-1:-1;;;;13066:540:16:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;5:130::-;72:20;;97:33;72:20;97:33;:::i;301:707::-;;418:3;411:4;403:6;399:17;395:27;385:2;;-1:-1;;426:12;385:2;473:6;460:20;495:80;510:64;567:6;510:64;:::i;:::-;495:80;:::i;:::-;603:21;;;486:89;-1:-1;647:4;660:14;;;;635:17;;;749;;;740:27;;;;737:36;-1:-1;734:2;;;786:1;;776:12;734:2;811:1;796:206;821:6;818:1;815:13;796:206;;;2041:20;;889:50;;953:14;;;;981;;;;843:1;836:9;796:206;;;800:14;;;;;378:630;;;;:::o;1061:774::-;;1210:3;1203:4;1195:6;1191:17;1187:27;1177:2;;-1:-1;;1218:12;1177:2;1265:6;1252:20;1287:112;1302:96;1391:6;1302:96;:::i;1287:112::-;1427:21;;;1278:121;-1:-1;1471:4;1484:14;;;;1459:17;;;1579:1;1564:265;1589:6;1586:1;1583:13;1564:265;;;1672:3;1659:17;1463:6;1647:30;3716:4;;3695:19;1647:30;3699:3;3695:19;;3691:30;3688:2;;;1579:1;;3724:12;3688:2;3752:20;3716:4;3752:20;:::i;:::-;3856:49;3901:3;1471:4;1647:30;;3856:49;:::i;:::-;3838:16;3831:75;3980:18;;1647:30;3980:18;3967:32;4019:18;4011:6;4008:30;4005:2;;;1579:1;;4041:12;4005:2;4086:58;4140:3;1471:4;4131:6;1647:30;4116:22;;4086:58;:::i;:::-;4068:16;;;4061:84;-1:-1;4261:22;;;;5121:20;4222:16;;;4215:75;1684:82;;1780:14;;;;1808;;;;1611:1;1604:9;1564:265;;2112:440;;2213:3;2206:4;2198:6;2194:17;2190:27;2180:2;;-1:-1;;2221:12;2180:2;2268:6;2255:20;40991:18;40983:6;40980:30;40977:2;;;-1:-1;;41013:12;40977:2;2290:64;41154:4;41086:9;2206:4;41071:6;41067:17;41063:33;41144:15;2290:64;:::i;:::-;2281:73;;2374:6;2367:5;2360:21;2478:3;41154:4;2469:6;2402;2460:16;;2457:25;2454:2;;;2495:1;;2485:12;2454:2;46458:6;41154:4;2402:6;2398:17;41154:4;2436:5;2432:16;46435:30;46514:1;46496:16;;;41154:4;46496:16;46489:27;2436:5;2173:379;-1:-1;;2173:379::o;5743:132::-;5820:13;;45039:26;45028:38;;48137:34;;48127:2;;48185:1;;48175:12;5882:502;;;6028:2;6016:9;6007:7;6003:23;5999:32;5996:2;;;-1:-1;;6034:12;5996:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;6086:63;-1:-1;6214:2;6199:18;;6186:32;6238:18;6227:30;;6224:2;;;-1:-1;;6260:12;6224:2;6290:78;6360:7;6351:6;6340:9;6336:22;6290:78;:::i;:::-;6280:88;;;5990:394;;;;;:::o;6391:1059::-;;;;;6638:3;6626:9;6617:7;6613:23;6609:33;6606:2;;;-1:-1;;6645:12;6606:2;6703:17;6690:31;6741:18;;6733:6;6730:30;6727:2;;;-1:-1;;6763:12;6727:2;6793:110;6895:7;6886:6;6875:9;6871:22;6793:110;:::i;:::-;6783:120;;6940:2;6983:9;6979:22;5121:20;6948:63;;7076:2;7065:9;7061:18;7048:32;7034:46;;6741:18;7092:6;7089:30;7086:2;;;-1:-1;;7122:12;7086:2;7152:63;7207:7;7198:6;7187:9;7183:22;7152:63;:::i;:::-;7142:73;;7280:2;7269:9;7265:18;7252:32;7238:46;;6741:18;7296:6;7293:30;7290:2;;;-1:-1;;7326:12;7290:2;;7356:78;7426:7;7417:6;7406:9;7402:22;7356:78;:::i;:::-;7346:88;;;6600:850;;;;;;;:::o;7457:307::-;;7594:2;7582:9;7573:7;7569:23;7565:32;7562:2;;;-1:-1;;7600:12;7562:2;3196:20;7594:2;3196:20;:::i;:::-;226:6;220:13;238:33;265:5;238:33;:::i;:::-;3277:86;;3433:2;3497:22;;5409:13;44753:10;44742:22;;47773:34;;47763:2;;-1:-1;;47811:12;47763:2;3433;3448:16;;3441:85;3452:5;7556:208;-1:-1;;;7556:208::o;7771:325::-;;7917:2;7905:9;7896:7;7892:23;7888:32;7885:2;;;-1:-1;;7923:12;7885:2;4521:20;7917:2;4521:20;:::i;:::-;5554:6;5548:13;44848:18;47922:5;44837:30;47898:5;47895:34;47885:2;;-1:-1;;47933:12;47885:2;4606:85;;4800:59;4855:3;4767:2;4831:22;;4800:59;:::i;:::-;4767:2;4786:5;4782:16;4775:85;4966:59;5021:3;4933:2;5001:9;4997:22;4966:59;:::i;:::-;4933:2;4948:16;;4941:85;4952:5;7879:217;-1:-1;;;7879:217::o;8103:241::-;;8207:2;8195:9;8186:7;8182:23;8178:32;8175:2;;;-1:-1;;8213:12;8175:2;-1:-1;5121:20;;8169:175;-1:-1;8169:175::o;8351:263::-;;8466:2;8454:9;8445:7;8441:23;8437:32;8434:2;;;-1:-1;;8472:12;8434:2;-1:-1;5269:13;;8428:186;-1:-1;8428:186::o;8621:366::-;;;8742:2;8730:9;8721:7;8717:23;8713:32;8710:2;;;-1:-1;;8748:12;8710:2;5134:6;5121:20;8800:63;;8900:2;8943:9;8939:22;72:20;97:33;124:5;97:33;:::i;:::-;8908:63;;;;8704:283;;;;;:::o;8994:566::-;;;9172:2;9160:9;9151:7;9147:23;9143:32;9140:2;;;-1:-1;;9178:12;9140:2;5134:6;5121:20;9230:63;;9358:2;9347:9;9343:18;9330:32;9382:18;9374:6;9371:30;9368:2;;;-1:-1;;9404:12;9368:2;9434:110;9536:7;9527:6;9516:9;9512:22;9434:110;:::i;9567:621::-;;;;9727:2;9715:9;9706:7;9702:23;9698:32;9695:2;;;-1:-1;;9733:12;9695:2;5134:6;5121:20;9785:63;;9885:2;9925:9;9921:22;1907:20;1932:30;1956:5;1932:30;:::i;:::-;9893:60;-1:-1;10018:2;10003:18;;9990:32;10042:18;10031:30;;10028:2;;;-1:-1;;10064:12;10028:2;10094:78;10164:7;10155:6;10144:9;10140:22;10094:78;:::i;:::-;10084:88;;;9689:499;;;;;:::o;10195:995::-;;;;;;;10404:3;10392:9;10383:7;10379:23;10375:33;10372:2;;;-1:-1;;10411:12;10372:2;5134:6;5121:20;10463:63;;10563:2;10603:9;10599:22;1907:20;1932:30;1956:5;1932:30;:::i;:::-;10571:60;-1:-1;10696:2;10681:18;;10668:32;10720:18;10709:30;;10706:2;;;-1:-1;;10742:12;10706:2;10772:78;10842:7;10833:6;10822:9;10818:22;10772:78;:::i;:::-;10762:88;;;10887:2;10928:9;10924:22;5675:20;44950:4;48042:5;44939:16;48019:5;48016:33;48006:2;;-1:-1;;48053:12;48006:2;10366:824;;;;-1:-1;10366:824;;10993:3;11033:22;;2041:20;;11102:3;11142:22;;;2041:20;;-1:-1;10366:824;-1:-1;;10366:824::o;11197:366::-;;;11318:2;11306:9;11297:7;11293:23;11289:32;11286:2;;;-1:-1;;11324:12;11286:2;-1:-1;;5121:20;;;11476:2;11515:22;;;5121:20;;-1:-1;11280:283::o;12650:690::-;;12843:5;41956:12;42823:6;42818:3;42811:19;42860:4;;42855:3;42851:14;12855:93;;42860:4;13019:5;41620:14;-1:-1;13058:260;13083:6;13080:1;13077:13;13058:260;;;13144:13;;15490:37;;11724:14;;;;42519;;;;13105:1;13098:9;13058:260;;;-1:-1;13324:10;;12774:566;-1:-1;;;;;12774:566::o;14206:1104::-;;14495:5;41956:12;42823:6;42818:3;42811:19;42860:4;;42855:3;42851:14;14507:125;;;;42860:4;14689:6;14685:17;14680:3;14676:27;14664:39;;42860:4;14806:5;41620:14;-1:-1;14845:426;14870:6;14867:1;14864:13;14845:426;;;14932:9;14926:4;14922:20;14917:3;14910:33;14977:6;14971:13;24021:4;44547:42;24095:16;24089:23;44536:54;12457:3;12450:37;42860:4;24253:5;24249:16;24243:23;24021:4;42860;24290:3;24286:14;24279:38;24332:71;24021:4;24016:3;24012:14;24384:12;24332:71;:::i;:::-;24489:4;24478:16;;;24472:23;24549:14;;;;15490:37;;;;-1:-1;15250:14;;;;24324:79;-1:-1;42519:14;;;;14892:1;14885:9;14845:426;;;-1:-1;15294:10;;14394:916;-1:-1;;;;;;;14394:916::o;15936:323::-;;16068:5;41956:12;42823:6;42818:3;42811:19;16151:52;16196:6;42860:4;42855:3;42851:14;42860:4;16177:5;16173:16;16151:52;:::i;:::-;46976:2;46956:14;46972:7;46952:28;16215:39;;;;42860:4;16215:39;;16016:243;-1:-1;;16016:243::o;24947:335::-;41956:12;;24947:335;;25132:125;;41629:4;41620:14;;;24947:335;13823:268;13848:6;13845:1;13842:13;13823:268;;;13909:13;;15490:37;;11724:14;;;;42519;;;;13870:1;13863:9;13823:268;;;-1:-1;25267:10;;25113:169;-1:-1;;;;;;25113:169::o;25289:271::-;;16426:5;41956:12;16537:52;16582:6;16577:3;16570:4;16563:5;16559:16;16537:52;:::i;:::-;16601:16;;;;;25423:137;-1:-1;;25423:137::o;25567:659::-;19373:66;19353:87;;19338:1;19459:11;;15490:37;;;;26078:12;;;15490:37;26189:12;;;25812:414::o;26233:1308::-;;44547:42;43987:5;44536:54;12326:3;12319:58;26692:3;26819:2;26808:9;26804:18;26797:48;26859:108;26692:3;26681:9;26677:19;26953:6;26859:108;:::i;:::-;15520:5;27046:2;27035:9;27031:18;15490:37;27098:9;27092:4;27088:20;27083:2;27072:9;27068:18;27061:48;27123:172;27290:4;27281:6;27123:172;:::i;:::-;27115:180;;15520:5;27374:3;27363:9;27359:19;15490:37;27428:9;27422:4;27418:20;27412:3;27401:9;27397:19;27390:49;27453:78;27526:4;27517:6;27453:78;:::i;:::-;27445:86;26663:878;-1:-1;;;;;;;;;26663:878::o;27548:804::-;;44547:42;12480:5;44536:54;12457:3;12450:37;27831:3;27950:2;27939:9;27935:18;27928:48;27990:108;27831:3;27820:9;27816:19;28084:6;27990:108;:::i;:::-;28177:2;28162:18;;15490:37;;;;-1:-1;44071:13;;44064:21;28254:2;28239:18;;15383:34;28337:3;28322:19;;;15490:37;27982:116;27802:550;-1:-1;;27802:550::o;28359:333::-;44547:42;44536:54;;;;12450:37;;28678:2;28663:18;;15490:37;28514:2;28499:18;;28485:207::o;28699:361::-;44547:42;44536:54;;12450:37;;28868:2;28853:18;;47196:1;47186:12;;47176:2;;47202:9;47176:2;46081:40;29046:2;29035:9;29031:18;17239:64;28839:221;;;;;:::o;29067:498::-;;29308:2;29329:17;29322:47;29383:172;29308:2;29297:9;29293:18;29541:6;29383:172;:::i;29572:210::-;44071:13;;44064:21;15383:34;;29693:2;29678:18;;29664:118::o;29789:222::-;15490:37;;;29916:2;29901:18;;29887:124::o;30018:544::-;15490:37;;;30388:2;30373:18;;15490:37;;;;44071:13;44064:21;30465:2;30450:18;;15383:34;30548:2;30533:18;;15490:37;30223:3;30208:19;;30194:368::o;30569:768::-;15490:37;;;30995:2;30980:18;;15490:37;;;;31078:2;31063:18;;15490:37;;;;31161:2;31146:18;;15490:37;31244:3;31229:19;;15490:37;44071:13;44064:21;31322:3;31307:19;;15383:34;30830:3;30815:19;;30801:536::o;31344:548::-;15490:37;;;44950:4;44939:16;;;;31712:2;31697:18;;24900:35;31795:2;31780:18;;15490:37;31878:2;31863:18;;15490:37;31551:3;31536:19;;31522:370::o;31899:278::-;44547:42;44536:54;;;;16728:78;;32054:2;32039:18;;32025:152::o;32447:480::-;32648:2;32633:18;;47082:1;47072:12;;47062:2;;47088:9;47062:2;17074:68;;;32830:2;32815:18;;15490:37;;;;32913:2;32898:18;;;15490:37;32619:308;:::o;32934:416::-;33134:2;33148:47;;;17894:2;33119:18;;;42811:19;17930:33;42851:14;;;17910:54;17983:12;;;33105:245::o;33357:416::-;33557:2;33571:47;;;18234:2;33542:18;;;42811:19;18270:29;42851:14;;;18250:50;18319:12;;;33528:245::o;33780:416::-;33980:2;33994:47;;;18570:2;33965:18;;;42811:19;18606:34;42851:14;;;18586:55;18675:21;18661:12;;;18654:43;18716:12;;;33951:245::o;34203:416::-;34403:2;34417:47;;;18967:2;34388:18;;;42811:19;19003:28;42851:14;;;18983:49;19051:12;;;34374:245::o;34626:416::-;34826:2;34840:47;;;19709:2;34811:18;;;42811:19;19745:25;42851:14;;;19725:46;19790:12;;;34797:245::o;35049:416::-;35249:2;35263:47;;;20041:2;35234:18;;;42811:19;20077:29;42851:14;;;20057:50;20126:12;;;35220:245::o;35472:416::-;35672:2;35686:47;;;35657:18;;;42811:19;20413:34;42851:14;;;20393:55;20467:12;;;35643:245::o;35895:416::-;36095:2;36109:47;;;20718:2;36080:18;;;42811:19;20754:34;42851:14;;;20734:55;20823:19;20809:12;;;20802:41;20862:12;;;36066:245::o;36318:416::-;36518:2;36532:47;;;21113:2;36503:18;;;42811:19;21149:27;42851:14;;;21129:48;21196:12;;;36489:245::o;36741:416::-;36941:2;36955:47;;;21447:2;36926:18;;;42811:19;21483:33;42851:14;;;21463:54;21536:12;;;36912:245::o;37164:416::-;37364:2;37378:47;;;21787:2;37349:18;;;42811:19;21823:34;42851:14;;;21803:55;21892:13;21878:12;;;21871:35;21925:12;;;37335:245::o;37587:416::-;37787:2;37801:47;;;22176:2;37772:18;;;42811:19;22212:34;42851:14;;;22192:55;22281:11;22267:12;;;22260:33;22312:12;;;37758:245::o;38010:416::-;38210:2;38224:47;;;22563:2;38195:18;;;42811:19;22599:28;42851:14;;;22579:49;22647:12;;;38181:245::o;38433:416::-;38633:2;38647:47;;;22898:2;38618:18;;;42811:19;22934:34;42851:14;;;22914:55;23003:21;22989:12;;;22982:43;23044:12;;;38604:245::o;38856:416::-;39056:2;39070:47;;;23295:2;39041:18;;;42811:19;23331:34;42851:14;;;23311:55;23400:3;23386:12;;;23379:25;23423:12;;;39027:245::o;39279:416::-;39479:2;39493:47;;;23674:2;39464:18;;;42811:19;23710:31;42851:14;;;23690:52;23761:12;;;39450:245::o;39931:256::-;39993:2;39987:9;40019:17;;;40094:18;40079:34;;40115:22;;;40076:62;40073:2;;;40151:1;;40141:12;40073:2;39993;40160:22;39971:216;;-1:-1;39971:216::o;40194:304::-;;40353:18;40345:6;40342:30;40339:2;;;-1:-1;;40375:12;40339:2;-1:-1;40420:4;40408:17;;;40473:15;;40276:222::o;46531:268::-;46596:1;46603:101;46617:6;46614:1;46611:13;46603:101;;;46684:11;;;46678:18;46665:11;;;46658:39;46639:2;46632:10;46603:101;;;46719:6;46716:1;46713:13;46710:2;;;46596:1;46775:6;46770:3;46766:16;46759:27;46710:2;;46580:219;;;:::o;47225:117::-;44547:42;47312:5;44536:54;47287:5;47284:35;47274:2;;47333:1;;47323:12;47274:2;47268:74;:::o;47349:111::-;47430:5;44071:13;44064:21;47408:5;47405:32;47395:2;;47451:1;;47441:12", + "linkReferences": {}, + "immutableReferences": { + "1906": [ + { + "start": 814, + "length": 32 + }, + { + "start": 1454, + "length": 32 + }, + { + "start": 1648, + "length": 32 + }, + { + "start": 2028, + "length": 32 + }, + { + "start": 2324, + "length": 32 + }, + { + "start": 3163, + "length": 32 + }, + { + "start": 3859, + "length": 32 + }, + { + "start": 4500, + "length": 32 + }, + { + "start": 5370, + "length": 32 + }, + { + "start": 5604, + "length": 32 + } + ], + "1909": [ + { + "start": 2584, + "length": 32 + } + ], + "1912": [ + { + "start": 1709, + "length": 32 + }, + { + "start": 2620, + "length": 32 + } + ], + "1915": [ + { + "start": 778, + "length": 32 + }, + { + "start": 5571, + "length": 32 + } + ], + "1917": [ + { + "start": 2851, + "length": 32 + } + ] + } + }, + "methodIdentifiers": { + "castVote(uint256,bool,bytes32[])": "dfe1e6b2", + "castVoteBySignature(uint256,bool,bytes32[],uint8,bytes32,bytes32)": "d438a3ce", + "defaultPoolId()": "a0edbcbb", + "defaultPoolOperator()": "9de38af2", + "execute(uint256,(address,bytes,uint256)[])": "662bede3", + "getVotingPower(address,bytes32[])": "7c29cb1a", + "hasVoted(uint256,address)": "43859632", + "proposalCount()": "da35c664", + "proposalThreshold()": "b58131b0", + "proposals(uint256)": "013cf08b", + "propose((address,bytes,uint256)[],uint256,string,bytes32[])": "d73ceb3a", + "quorumThreshold()": "7b7a91dd", + "stakingProxy()": "22f80d11", + "updateThresholds(uint256,uint256)": "c14b8e9c", + "votingPeriod()": "02a251a3" + }, + "rawMetadata": "{\"compiler\":{\"version\":\"0.6.12+commit.27d51765\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract IStaking\",\"name\":\"stakingProxy_\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"votingPeriod\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"proposalThreshold\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"quorumThreshold\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"defaultPoolId\",\"type\":\"bytes32\"}],\"internalType\":\"struct IZrxTreasury.TreasuryParameters\",\"name\":\"params\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"proposer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32[]\",\"name\":\"operatedPoolIds\",\"type\":\"bytes32[]\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"proposalId\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"struct IZrxTreasury.ProposedAction[]\",\"name\":\"actions\",\"type\":\"tuple[]\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"executionEpoch\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"}],\"name\":\"ProposalCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"proposalId\",\"type\":\"uint256\"}],\"name\":\"ProposalExecuted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"voter\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32[]\",\"name\":\"operatedPoolIds\",\"type\":\"bytes32[]\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"proposalId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"support\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"votingPower\",\"type\":\"uint256\"}],\"name\":\"VoteCast\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"proposalId\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"support\",\"type\":\"bool\"},{\"internalType\":\"bytes32[]\",\"name\":\"operatedPoolIds\",\"type\":\"bytes32[]\"}],\"name\":\"castVote\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"proposalId\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"support\",\"type\":\"bool\"},{\"internalType\":\"bytes32[]\",\"name\":\"operatedPoolIds\",\"type\":\"bytes32[]\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"castVoteBySignature\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"defaultPoolId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"defaultPoolOperator\",\"outputs\":[{\"internalType\":\"contract DefaultPoolOperator\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"proposalId\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct IZrxTreasury.ProposedAction[]\",\"name\":\"actions\",\"type\":\"tuple[]\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"operatedPoolIds\",\"type\":\"bytes32[]\"}],\"name\":\"getVotingPower\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"votingPower\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"hasVoted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proposalCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"count\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proposalThreshold\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"proposals\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"actionsHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"executionEpoch\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"voteEpoch\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"votesFor\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"votesAgainst\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"executed\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct IZrxTreasury.ProposedAction[]\",\"name\":\"actions\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"executionEpoch\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"},{\"internalType\":\"bytes32[]\",\"name\":\"operatedPoolIds\",\"type\":\"bytes32[]\"}],\"name\":\"propose\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"proposalId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"quorumThreshold\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stakingProxy\",\"outputs\":[{\"internalType\":\"contract IStaking\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newProposalThreshold\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"newQuorumThreshold\",\"type\":\"uint256\"}],\"name\":\"updateThresholds\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"votingPeriod\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"castVote(uint256,bool,bytes32[])\":{\"details\":\"Casts a vote for the given proposal. Only callable during the voting period for that proposal. One address can only vote once. See `getVotingPower` for how voting power is computed.\",\"params\":{\"operatedPoolIds\":\"The pools operated by `msg.sender`. The ZRX currently delegated to those pools will be accounted for in the voting power.\",\"proposalId\":\"The ID of the proposal to vote on.\",\"support\":\"Whether to support the proposal or not.\"}},\"castVoteBySignature(uint256,bool,bytes32[],uint8,bytes32,bytes32)\":{\"details\":\"Casts a vote for the given proposal, by signature. Only callable during the voting period for that proposal. One address/voter can only vote once. See `getVotingPower` for how voting power is computed.\",\"params\":{\"operatedPoolIds\":\"The pools operated by voter. The ZRX currently delegated to those pools will be accounted for in the voting power.\",\"proposalId\":\"The ID of the proposal to vote on.\",\"r\":\"the r field of the signature\",\"s\":\"the s field of the signature\",\"support\":\"Whether to support the proposal or not.\",\"v\":\"the v field of the signature\"}},\"constructor\":{\"details\":\"Initializes the ZRX treasury and creates the default staking pool.\",\"params\":{\"params\":\"Immutable treasury parameters.\",\"stakingProxy_\":\"The 0x staking proxy contract.\"}},\"execute(uint256,(address,bytes,uint256)[])\":{\"details\":\"Executes a proposal that has passed and is currently executable.\",\"params\":{\"actions\":\"Actions associated with the proposal to execute.\",\"proposalId\":\"The ID of the proposal to execute.\"}},\"getVotingPower(address,bytes32[])\":{\"details\":\"Computes the current voting power of the given account. Voting power is equal to: (ZRX delegated to the default pool) + 0.5 * (ZRX delegated to other pools) + 0.5 * (ZRX delegated to pools operated by account)\",\"params\":{\"account\":\"The address of the account.\",\"operatedPoolIds\":\"The pools operated by `account`. The ZRX currently delegated to those pools will be accounted for in the voting power.\"},\"returns\":{\"votingPower\":\"The current voting power of the given account.\"}},\"proposalCount()\":{\"details\":\"Returns the total number of proposals.\",\"returns\":{\"count\":\"The number of proposals.\"}},\"propose((address,bytes,uint256)[],uint256,string,bytes32[])\":{\"details\":\"Creates a proposal to send ZRX from this treasury on the the given actions. Must have at least `proposalThreshold` of voting power to call this function. See `getVotingPower` for how voting power is computed. If a proposal is successfully created, voting starts at the epoch after next (currentEpoch + 2). If the vote passes, the proposal is executable during the `executionEpoch`. See `hasProposalPassed` for the passing criteria.\",\"params\":{\"actions\":\"The proposed ZRX actions. An action specifies a contract call.\",\"description\":\"A text description for the proposal.\",\"executionEpoch\":\"The epoch during which the proposal is to be executed if it passes. Must be at least two epochs from the current epoch.\",\"operatedPoolIds\":\"The pools operated by the signer. The ZRX currently delegated to those pools will be accounted for in the voting power.\"},\"returns\":{\"proposalId\":\"The ID of the newly created proposal.\"}},\"updateThresholds(uint256,uint256)\":{\"details\":\"Updates the proposal and quorum thresholds to the given values. Note that this function is only callable by the treasury contract itself, so the threshold can only be updated via a successful treasury proposal.\",\"params\":{\"newProposalThreshold\":\"The new value for the proposal threshold.\",\"newQuorumThreshold\":\"The new value for the quorum threshold.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/src/ZrxTreasury.sol\":\"ZrxTreasury\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[\":@0x/contracts-erc20/=../erc20/\",\":@0x/contracts-utils/=../utils/\",\":@0x/contracts-zero-ex/=../zero-ex/\",\":ds-test/=/Users/Elena/Source/protocol/contracts/erc20/lib/forge-std/lib/ds-test/src/\",\":erc20/=/Users/Elena/Source/protocol/contracts/erc20/src/\",\":forge-std/=/Users/Elena/Source/protocol/contracts/erc20/lib/forge-std/src/\",\":interfaces/=/Users/Elena/Source/protocol/contracts/zero-ex/../utils/contracts/src/interfaces/\",\":samplers/=/Users/Elena/Source/protocol/contracts/zero-ex/contracts/test/samplers/\",\":src/=/Users/Elena/Source/protocol/contracts/zero-ex/./contracts/src/\",\":test/=../erc20/test/\",\":tests/=../zero-ex/tests/\",\":utils/=/Users/Elena/Source/protocol/contracts/zero-ex/./tests/utils/\",\":v06/=/Users/Elena/Source/protocol/contracts/zero-ex/../utils/contracts/src/v06/\",\":v08/=/Users/Elena/Source/protocol/contracts/zero-ex/../utils/contracts/src/v08/\",\":zero-ex/=/Users/Elena/Source/protocol/contracts/zero-ex/contracts/src/\"]},\"sources\":{\"../erc20/src/IERC20Token.sol\":{\"keccak256\":\"0x5ad0b042d6efa7e267fd5cb2e267eb0fdb4b66654b5d09360d9b01fb9a2b52e2\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://e1466234b6582f936c48c877e5c19010ef8080b25e69d88068122ee046df06c3\",\"dweb:/ipfs/QmRmjsiNNbzGP5iNQg49myPxtf7Jz5jr8qPtyK8EzFTaiG\"]},\"../utils/contracts/src/v06/LibBytesV06.sol\":{\"keccak256\":\"0x4627b090ebd8db251e6cea36597c906bd4f82c219059395eaf7263067666b856\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://b003ca5062e373a0d9956f519f44ce58b3388f1161d11bf75122fd0c53ac690c\",\"dweb:/ipfs/QmRATPXeyFQDMGrmBmZKebCrGf36uUQCSczkZfbhLFJ8U5\"]},\"../utils/contracts/src/v06/LibSafeMathV06.sol\":{\"keccak256\":\"0xf41503c5323320d0d4a8de4afddbc41c9e0fa205b8b0ee317bd4d98b411bb3ea\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://168c15f7009ae049478e8be800ef7b627373691878388659bd30b8be049b0c7f\",\"dweb:/ipfs/QmP1R2YzmnbgQhaK5N6QyscgAhWvHAd1sos8f44EV3E5Md\"]},\"../utils/contracts/src/v06/errors/LibBytesRichErrorsV06.sol\":{\"keccak256\":\"0x53f172b5aaf453b6372471ab3918bb0c1611ff38c8ad30f1a955f2453fa499c3\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://1e62e069b8daf7b57ae8c943523388907e479dcaf408a115cd5d51b68cbcc972\",\"dweb:/ipfs/QmbmhaNpPbPouw7ve7kQo52G6dps4hvFuq36iUiEgMLQBi\"]},\"../utils/contracts/src/v06/errors/LibRichErrorsV06.sol\":{\"keccak256\":\"0x94011e576f60b0c5490c9424503a7ef0c9ebb57d1d9573372c87da0ede38f674\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://f7499e74e13cd04b40eb54fdc892f3055e3f982c965d4a8d42b09d4575a570a0\",\"dweb:/ipfs/QmSv3DG4yUWStJujCybqHfWSv5KcPmWVPnoz5FArnMcq7f\"]},\"../utils/contracts/src/v06/errors/LibSafeMathRichErrorsV06.sol\":{\"keccak256\":\"0xfb01cc2d90995a03f1f72b00226e089d1bf2acf36fe2c115b08ccf048e26cf6b\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://e420abd75dcdeec59750b3909da937c2fe2f02dcd8fc3b38d54ec79035f73b0c\",\"dweb:/ipfs/QmVo5F1pzsVfdQRmumYc2vMTMsC8EPEs5CYa1wn5XcCFKZ\"]},\"../zero-ex/contracts/src/errors/LibSignatureRichErrors.sol\":{\"keccak256\":\"0x37068d2a3e0128011f5e84bfebea451c74295279b8c60776dba37770eeae4a50\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://0c6554d5d1aa836bc2c47e8b046ed51e9b207df4756be012c0d29f4d80e26a45\",\"dweb:/ipfs/QmQEL7psQnUHTfeG16May1cLuvjBfFYHpnHGjDyMqqJouW\"]},\"../zero-ex/contracts/src/features/libs/LibSignature.sol\":{\"keccak256\":\"0xfa6a46013652e4365a5948c221f655a41b029dbf5cf733c71e662f76d26013d6\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://73332e4838e1a607ababaaa58ad936bbeeed1aedc82db4d74dd7e09ee1994cde\",\"dweb:/ipfs/QmaaF8a1Q6SB1VzZGBx8HYD9jpe3fiyLefrHstXFvvCqqP\"]},\"contracts/src/DefaultPoolOperator.sol\":{\"keccak256\":\"0x60f6966ee0336ad706793c7cb4fd21060e302bbf06ea4894991ee342f1f70ba8\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://7c33280a9517aa80cbf9017b9e10100b72a0d9c7dee149564578072dd50bde2b\",\"dweb:/ipfs/QmY3ktL2jRRPP8gouWPEAu9r8kAYhNSaxEFXfgeseDwtDE\"]},\"contracts/src/IStaking.sol\":{\"keccak256\":\"0xb0b7d2c8b1663232787298e82ba46eabc939c43ead76e0ddfb9b14948044ed60\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://5a84fde559e5892a41cc231bf84364cd02481c3261b7dc7058e86047a65da547\",\"dweb:/ipfs/Qme81X4ARzqeKusRsXZtp9jUmATPrqqoyUQA6c9aC7Qrrr\"]},\"contracts/src/IZrxTreasury.sol\":{\"keccak256\":\"0xdfcb293e422511faf8f7c92c196924c6bd0de2e944a3bb8e1181e32fb8831a57\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://7d78c7cc8ba778072599baed0da74657998470477ebd3544e9cd03f94f27fa54\",\"dweb:/ipfs/QmXPJjramvrVSNghAuSivPUUJ57QGEFqbRGzv7LgpdARoW\"]},\"contracts/src/ZrxTreasury.sol\":{\"keccak256\":\"0x8c647757bc4f0dee461d3e327db7f706223d8f720f244d9791334d0669839a3b\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://4772884ef913e3b3935114fbdfc2cebc56ce09956bb441125e361ba22b0a625d\",\"dweb:/ipfs/QmbhP7GbgRB8c47dDqivuQPzPZ1JAzKRFay8kMN3EQkM9N\"]}},\"version\":1}", + "metadata": { + "compiler": { + "version": "0.6.12+commit.27d51765" + }, + "language": "Solidity", + "output": { + "abi": [ + { + "inputs": [ + { + "internalType": "contract IStaking", + "name": "stakingProxy_", + "type": "address" + }, + { + "internalType": "struct IZrxTreasury.TreasuryParameters", + "name": "params", + "type": "tuple", + "components": [ + { + "internalType": "uint256", + "name": "votingPeriod", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "proposalThreshold", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "quorumThreshold", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "defaultPoolId", + "type": "bytes32" + } + ] + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "proposer", + "type": "address", + "indexed": false + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]", + "indexed": false + }, + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256", + "indexed": false + }, + { + "internalType": "struct IZrxTreasury.ProposedAction[]", + "name": "actions", + "type": "tuple[]", + "components": [ + { + "internalType": "address", + "name": "target", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "indexed": false + }, + { + "internalType": "uint256", + "name": "executionEpoch", + "type": "uint256", + "indexed": false + }, + { + "internalType": "string", + "name": "description", + "type": "string", + "indexed": false + } + ], + "type": "event", + "name": "ProposalCreated", + "anonymous": false + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256", + "indexed": false + } + ], + "type": "event", + "name": "ProposalExecuted", + "anonymous": false + }, + { + "inputs": [ + { + "internalType": "address", + "name": "voter", + "type": "address", + "indexed": false + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]", + "indexed": false + }, + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256", + "indexed": false + }, + { + "internalType": "bool", + "name": "support", + "type": "bool", + "indexed": false + }, + { + "internalType": "uint256", + "name": "votingPower", + "type": "uint256", + "indexed": false + } + ], + "type": "event", + "name": "VoteCast", + "anonymous": false + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "support", + "type": "bool" + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + } + ], + "stateMutability": "nonpayable", + "type": "function", + "name": "castVote" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "support", + "type": "bool" + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + }, + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "r", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "s", + "type": "bytes32" + } + ], + "stateMutability": "nonpayable", + "type": "function", + "name": "castVoteBySignature" + }, + { + "inputs": [], + "stateMutability": "view", + "type": "function", + "name": "defaultPoolId", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ] + }, + { + "inputs": [], + "stateMutability": "view", + "type": "function", + "name": "defaultPoolOperator", + "outputs": [ + { + "internalType": "contract DefaultPoolOperator", + "name": "", + "type": "address" + } + ] + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + }, + { + "internalType": "struct IZrxTreasury.ProposedAction[]", + "name": "actions", + "type": "tuple[]", + "components": [ + { + "internalType": "address", + "name": "target", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ] + } + ], + "stateMutability": "payable", + "type": "function", + "name": "execute" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + } + ], + "stateMutability": "view", + "type": "function", + "name": "getVotingPower", + "outputs": [ + { + "internalType": "uint256", + "name": "votingPower", + "type": "uint256" + } + ] + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function", + "name": "hasVoted", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ] + }, + { + "inputs": [], + "stateMutability": "view", + "type": "function", + "name": "proposalCount", + "outputs": [ + { + "internalType": "uint256", + "name": "count", + "type": "uint256" + } + ] + }, + { + "inputs": [], + "stateMutability": "view", + "type": "function", + "name": "proposalThreshold", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ] + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function", + "name": "proposals", + "outputs": [ + { + "internalType": "bytes32", + "name": "actionsHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "executionEpoch", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "voteEpoch", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "votesFor", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "votesAgainst", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "executed", + "type": "bool" + } + ] + }, + { + "inputs": [ + { + "internalType": "struct IZrxTreasury.ProposedAction[]", + "name": "actions", + "type": "tuple[]", + "components": [ + { + "internalType": "address", + "name": "target", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ] + }, + { + "internalType": "uint256", + "name": "executionEpoch", + "type": "uint256" + }, + { + "internalType": "string", + "name": "description", + "type": "string" + }, + { + "internalType": "bytes32[]", + "name": "operatedPoolIds", + "type": "bytes32[]" + } + ], + "stateMutability": "nonpayable", + "type": "function", + "name": "propose", + "outputs": [ + { + "internalType": "uint256", + "name": "proposalId", + "type": "uint256" + } + ] + }, + { + "inputs": [], + "stateMutability": "view", + "type": "function", + "name": "quorumThreshold", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ] + }, + { + "inputs": [], + "stateMutability": "view", + "type": "function", + "name": "stakingProxy", + "outputs": [ + { + "internalType": "contract IStaking", + "name": "", + "type": "address" + } + ] + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "newProposalThreshold", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "newQuorumThreshold", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function", + "name": "updateThresholds" + }, + { + "inputs": [], + "stateMutability": "view", + "type": "function", + "name": "votingPeriod", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ] + }, + { + "inputs": [], + "stateMutability": "payable", + "type": "receive" + } + ], + "devdoc": { + "kind": "dev", + "methods": { + "castVote(uint256,bool,bytes32[])": { + "details": "Casts a vote for the given proposal. Only callable during the voting period for that proposal. One address can only vote once. See `getVotingPower` for how voting power is computed.", + "params": { + "operatedPoolIds": "The pools operated by `msg.sender`. The ZRX currently delegated to those pools will be accounted for in the voting power.", + "proposalId": "The ID of the proposal to vote on.", + "support": "Whether to support the proposal or not." + } + }, + "castVoteBySignature(uint256,bool,bytes32[],uint8,bytes32,bytes32)": { + "details": "Casts a vote for the given proposal, by signature. Only callable during the voting period for that proposal. One address/voter can only vote once. See `getVotingPower` for how voting power is computed.", + "params": { + "operatedPoolIds": "The pools operated by voter. The ZRX currently delegated to those pools will be accounted for in the voting power.", + "proposalId": "The ID of the proposal to vote on.", + "r": "the r field of the signature", + "s": "the s field of the signature", + "support": "Whether to support the proposal or not.", + "v": "the v field of the signature" + } + }, + "constructor": { + "details": "Initializes the ZRX treasury and creates the default staking pool.", + "params": { + "params": "Immutable treasury parameters.", + "stakingProxy_": "The 0x staking proxy contract." + } + }, + "execute(uint256,(address,bytes,uint256)[])": { + "details": "Executes a proposal that has passed and is currently executable.", + "params": { + "actions": "Actions associated with the proposal to execute.", + "proposalId": "The ID of the proposal to execute." + } + }, + "getVotingPower(address,bytes32[])": { + "details": "Computes the current voting power of the given account. Voting power is equal to: (ZRX delegated to the default pool) + 0.5 * (ZRX delegated to other pools) + 0.5 * (ZRX delegated to pools operated by account)", + "params": { + "account": "The address of the account.", + "operatedPoolIds": "The pools operated by `account`. The ZRX currently delegated to those pools will be accounted for in the voting power." + }, + "returns": { + "votingPower": "The current voting power of the given account." + } + }, + "proposalCount()": { + "details": "Returns the total number of proposals.", + "returns": { + "count": "The number of proposals." + } + }, + "propose((address,bytes,uint256)[],uint256,string,bytes32[])": { + "details": "Creates a proposal to send ZRX from this treasury on the the given actions. Must have at least `proposalThreshold` of voting power to call this function. See `getVotingPower` for how voting power is computed. If a proposal is successfully created, voting starts at the epoch after next (currentEpoch + 2). If the vote passes, the proposal is executable during the `executionEpoch`. See `hasProposalPassed` for the passing criteria.", + "params": { + "actions": "The proposed ZRX actions. An action specifies a contract call.", + "description": "A text description for the proposal.", + "executionEpoch": "The epoch during which the proposal is to be executed if it passes. Must be at least two epochs from the current epoch.", + "operatedPoolIds": "The pools operated by the signer. The ZRX currently delegated to those pools will be accounted for in the voting power." + }, + "returns": { + "proposalId": "The ID of the newly created proposal." + } + }, + "updateThresholds(uint256,uint256)": { + "details": "Updates the proposal and quorum thresholds to the given values. Note that this function is only callable by the treasury contract itself, so the threshold can only be updated via a successful treasury proposal.", + "params": { + "newProposalThreshold": "The new value for the proposal threshold.", + "newQuorumThreshold": "The new value for the quorum threshold." + } + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + } + }, + "settings": { + "remappings": [ + ":@0x/contracts-erc20/=../erc20/", + ":@0x/contracts-utils/=../utils/", + ":@0x/contracts-zero-ex/=../zero-ex/", + ":ds-test/=/Users/Elena/Source/protocol/contracts/erc20/lib/forge-std/lib/ds-test/src/", + ":erc20/=/Users/Elena/Source/protocol/contracts/erc20/src/", + ":forge-std/=/Users/Elena/Source/protocol/contracts/erc20/lib/forge-std/src/", + ":interfaces/=/Users/Elena/Source/protocol/contracts/zero-ex/../utils/contracts/src/interfaces/", + ":samplers/=/Users/Elena/Source/protocol/contracts/zero-ex/contracts/test/samplers/", + ":src/=/Users/Elena/Source/protocol/contracts/zero-ex/./contracts/src/", + ":test/=../erc20/test/", + ":tests/=../zero-ex/tests/", + ":utils/=/Users/Elena/Source/protocol/contracts/zero-ex/./tests/utils/", + ":v06/=/Users/Elena/Source/protocol/contracts/zero-ex/../utils/contracts/src/v06/", + ":v08/=/Users/Elena/Source/protocol/contracts/zero-ex/../utils/contracts/src/v08/", + ":zero-ex/=/Users/Elena/Source/protocol/contracts/zero-ex/contracts/src/" + ], + "optimizer": { + "enabled": true, + "runs": 1000000 + }, + "metadata": { + "bytecodeHash": "ipfs" + }, + "compilationTarget": { + "contracts/src/ZrxTreasury.sol": "ZrxTreasury" + }, + "libraries": {} + }, + "sources": { + "../erc20/src/IERC20Token.sol": { + "keccak256": "0x5ad0b042d6efa7e267fd5cb2e267eb0fdb4b66654b5d09360d9b01fb9a2b52e2", + "urls": [ + "bzz-raw://e1466234b6582f936c48c877e5c19010ef8080b25e69d88068122ee046df06c3", + "dweb:/ipfs/QmRmjsiNNbzGP5iNQg49myPxtf7Jz5jr8qPtyK8EzFTaiG" + ], + "license": "Apache-2.0" + }, + "../utils/contracts/src/v06/LibBytesV06.sol": { + "keccak256": "0x4627b090ebd8db251e6cea36597c906bd4f82c219059395eaf7263067666b856", + "urls": [ + "bzz-raw://b003ca5062e373a0d9956f519f44ce58b3388f1161d11bf75122fd0c53ac690c", + "dweb:/ipfs/QmRATPXeyFQDMGrmBmZKebCrGf36uUQCSczkZfbhLFJ8U5" + ], + "license": "Apache-2.0" + }, + "../utils/contracts/src/v06/LibSafeMathV06.sol": { + "keccak256": "0xf41503c5323320d0d4a8de4afddbc41c9e0fa205b8b0ee317bd4d98b411bb3ea", + "urls": [ + "bzz-raw://168c15f7009ae049478e8be800ef7b627373691878388659bd30b8be049b0c7f", + "dweb:/ipfs/QmP1R2YzmnbgQhaK5N6QyscgAhWvHAd1sos8f44EV3E5Md" + ], + "license": "Apache-2.0" + }, + "../utils/contracts/src/v06/errors/LibBytesRichErrorsV06.sol": { + "keccak256": "0x53f172b5aaf453b6372471ab3918bb0c1611ff38c8ad30f1a955f2453fa499c3", + "urls": [ + "bzz-raw://1e62e069b8daf7b57ae8c943523388907e479dcaf408a115cd5d51b68cbcc972", + "dweb:/ipfs/QmbmhaNpPbPouw7ve7kQo52G6dps4hvFuq36iUiEgMLQBi" + ], + "license": "Apache-2.0" + }, + "../utils/contracts/src/v06/errors/LibRichErrorsV06.sol": { + "keccak256": "0x94011e576f60b0c5490c9424503a7ef0c9ebb57d1d9573372c87da0ede38f674", + "urls": [ + "bzz-raw://f7499e74e13cd04b40eb54fdc892f3055e3f982c965d4a8d42b09d4575a570a0", + "dweb:/ipfs/QmSv3DG4yUWStJujCybqHfWSv5KcPmWVPnoz5FArnMcq7f" + ], + "license": "Apache-2.0" + }, + "../utils/contracts/src/v06/errors/LibSafeMathRichErrorsV06.sol": { + "keccak256": "0xfb01cc2d90995a03f1f72b00226e089d1bf2acf36fe2c115b08ccf048e26cf6b", + "urls": [ + "bzz-raw://e420abd75dcdeec59750b3909da937c2fe2f02dcd8fc3b38d54ec79035f73b0c", + "dweb:/ipfs/QmVo5F1pzsVfdQRmumYc2vMTMsC8EPEs5CYa1wn5XcCFKZ" + ], + "license": "Apache-2.0" + }, + "../zero-ex/contracts/src/errors/LibSignatureRichErrors.sol": { + "keccak256": "0x37068d2a3e0128011f5e84bfebea451c74295279b8c60776dba37770eeae4a50", + "urls": [ + "bzz-raw://0c6554d5d1aa836bc2c47e8b046ed51e9b207df4756be012c0d29f4d80e26a45", + "dweb:/ipfs/QmQEL7psQnUHTfeG16May1cLuvjBfFYHpnHGjDyMqqJouW" + ], + "license": "Apache-2.0" + }, + "../zero-ex/contracts/src/features/libs/LibSignature.sol": { + "keccak256": "0xfa6a46013652e4365a5948c221f655a41b029dbf5cf733c71e662f76d26013d6", + "urls": [ + "bzz-raw://73332e4838e1a607ababaaa58ad936bbeeed1aedc82db4d74dd7e09ee1994cde", + "dweb:/ipfs/QmaaF8a1Q6SB1VzZGBx8HYD9jpe3fiyLefrHstXFvvCqqP" + ], + "license": "Apache-2.0" + }, + "contracts/src/DefaultPoolOperator.sol": { + "keccak256": "0x60f6966ee0336ad706793c7cb4fd21060e302bbf06ea4894991ee342f1f70ba8", + "urls": [ + "bzz-raw://7c33280a9517aa80cbf9017b9e10100b72a0d9c7dee149564578072dd50bde2b", + "dweb:/ipfs/QmY3ktL2jRRPP8gouWPEAu9r8kAYhNSaxEFXfgeseDwtDE" + ], + "license": "Apache-2.0" + }, + "contracts/src/IStaking.sol": { + "keccak256": "0xb0b7d2c8b1663232787298e82ba46eabc939c43ead76e0ddfb9b14948044ed60", + "urls": [ + "bzz-raw://5a84fde559e5892a41cc231bf84364cd02481c3261b7dc7058e86047a65da547", + "dweb:/ipfs/Qme81X4ARzqeKusRsXZtp9jUmATPrqqoyUQA6c9aC7Qrrr" + ], + "license": "Apache-2.0" + }, + "contracts/src/IZrxTreasury.sol": { + "keccak256": "0xdfcb293e422511faf8f7c92c196924c6bd0de2e944a3bb8e1181e32fb8831a57", + "urls": [ + "bzz-raw://7d78c7cc8ba778072599baed0da74657998470477ebd3544e9cd03f94f27fa54", + "dweb:/ipfs/QmXPJjramvrVSNghAuSivPUUJ57QGEFqbRGzv7LgpdARoW" + ], + "license": "Apache-2.0" + }, + "contracts/src/ZrxTreasury.sol": { + "keccak256": "0x8c647757bc4f0dee461d3e327db7f706223d8f720f244d9791334d0669839a3b", + "urls": [ + "bzz-raw://4772884ef913e3b3935114fbdfc2cebc56ce09956bb441125e361ba22b0a625d", + "dweb:/ipfs/QmbhP7GbgRB8c47dDqivuQPzPZ1JAzKRFay8kMN3EQkM9N" + ], + "license": "Apache-2.0" + } + }, + "version": 1 + }, + "ast": { + "absolutePath": "contracts/src/ZrxTreasury.sol", + "id": 2714, + "exportedSymbols": { + "ZrxTreasury": [2713] + }, + "nodeType": "SourceUnit", + "src": "619:14492:16", + "nodes": [ + { + "id": 1866, + "nodeType": "PragmaDirective", + "src": "619:24:16", + "nodes": [], + "literals": ["solidity", "^", "0.6", ".12"] + }, + { + "id": 1867, + "nodeType": "PragmaDirective", + "src": "644:33:16", + "nodes": [], + "literals": ["experimental", "ABIEncoderV2"] + }, + { + "id": 1868, + "nodeType": "ImportDirective", + "src": "679:63:16", + "nodes": [], + "absolutePath": "../utils/contracts/src/v06/LibBytesV06.sol", + "file": "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol", + "scope": 2714, + "sourceUnit": 599, + "symbolAliases": [], + "unitAlias": "" + }, + { + "id": 1869, + "nodeType": "ImportDirective", + "src": "743:66:16", + "nodes": [], + "absolutePath": "../utils/contracts/src/v06/LibSafeMathV06.sol", + "file": "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol", + "scope": 2714, + "sourceUnit": 1004, + "symbolAliases": [], + "unitAlias": "" + }, + { + "id": 1870, + "nodeType": "ImportDirective", + "src": "810:75:16", + "nodes": [], + "absolutePath": "../utils/contracts/src/v06/errors/LibRichErrorsV06.sol", + "file": "@0x/contracts-utils/contracts/src/v06/errors/LibRichErrorsV06.sol", + "scope": 2714, + "sourceUnit": 1036, + "symbolAliases": [], + "unitAlias": "" + }, + { + "id": 1871, + "nodeType": "ImportDirective", + "src": "886:76:16", + "nodes": [], + "absolutePath": "../zero-ex/contracts/src/features/libs/LibSignature.sol", + "file": "@0x/contracts-zero-ex/contracts/src/features/libs/LibSignature.sol", + "scope": 2714, + "sourceUnit": 1247, + "symbolAliases": [], + "unitAlias": "" + }, + { + "id": 1872, + "nodeType": "ImportDirective", + "src": "963:28:16", + "nodes": [], + "absolutePath": "contracts/src/IZrxTreasury.sol", + "file": "./IZrxTreasury.sol", + "scope": 2714, + "sourceUnit": 1865, + "symbolAliases": [], + "unitAlias": "" + }, + { + "id": 2713, + "nodeType": "ContractDefinition", + "src": "993:14117:16", + "nodes": [ + { + "id": 1877, + "nodeType": "UsingForDirective", + "src": "1036:33:16", + "nodes": [], + "libraryName": { + "contractScope": null, + "id": 1875, + "name": "LibSafeMathV06", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1003, + "src": "1042:14:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_LibSafeMathV06_$1003", + "typeString": "library LibSafeMathV06" + } + }, + "typeName": { + "id": 1876, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1061:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + }, + { + "id": 1880, + "nodeType": "UsingForDirective", + "src": "1074:33:16", + "nodes": [], + "libraryName": { + "contractScope": null, + "id": 1878, + "name": "LibRichErrorsV06", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1035, + "src": "1080:16:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_LibRichErrorsV06_$1035", + "typeString": "library LibRichErrorsV06" + } + }, + "typeName": { + "id": 1879, + "name": "bytes", + "nodeType": "ElementaryTypeName", + "src": "1101:5:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes_storage_ptr", + "typeString": "bytes" + } + } + }, + { + "id": 1883, + "nodeType": "UsingForDirective", + "src": "1112:28:16", + "nodes": [], + "libraryName": { + "contractScope": null, + "id": 1881, + "name": "LibBytesV06", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 598, + "src": "1118:11:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_LibBytesV06_$598", + "typeString": "library LibBytesV06" + } + }, + "typeName": { + "id": 1882, + "name": "bytes", + "nodeType": "ElementaryTypeName", + "src": "1134:5:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes_storage_ptr", + "typeString": "bytes" + } + } + }, + { + "id": 1887, + "nodeType": "VariableDeclaration", + "src": "1168:54:16", + "nodes": [], + "constant": true, + "documentation": { + "id": 1884, + "nodeType": "StructuredDocumentation", + "src": "1146:17:16", + "text": "Contract name" + }, + "mutability": "constant", + "name": "CONTRACT_NAME", + "overrides": null, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string" + }, + "typeName": { + "id": 1885, + "name": "string", + "nodeType": "ElementaryTypeName", + "src": "1168:6:16", + "typeDescriptions": { + "typeIdentifier": "t_string_storage_ptr", + "typeString": "string" + } + }, + "value": { + "argumentTypes": null, + "hexValue": "5a7278205472656173757279", + "id": 1886, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1208:14:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_87d04f8a70a96e82e2eff0013aa6d23b3d03d655fecd921b5c27439303237317", + "typeString": "literal_string \"Zrx Treasury\"" + }, + "value": "Zrx Treasury" + }, + "visibility": "private" + }, + { + "id": 1891, + "nodeType": "VariableDeclaration", + "src": "1254:50:16", + "nodes": [], + "constant": true, + "documentation": { + "id": 1888, + "nodeType": "StructuredDocumentation", + "src": "1229:20:16", + "text": "Contract version" + }, + "mutability": "constant", + "name": "CONTRACT_VERSION", + "overrides": null, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string" + }, + "typeName": { + "id": 1889, + "name": "string", + "nodeType": "ElementaryTypeName", + "src": "1254:6:16", + "typeDescriptions": { + "typeIdentifier": "t_string_storage_ptr", + "typeString": "string" + } + }, + "value": { + "argumentTypes": null, + "hexValue": "312e302e30", + "id": 1890, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1297:7:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_06c015bd22b4c69690933c1058878ebdfef31f9aaae40bbe86d8a09fe1b2972c", + "typeString": "literal_string \"1.0.0\"" + }, + "value": "1.0.0" + }, + "visibility": "private" + }, + { + "id": 1897, + "nodeType": "VariableDeclaration", + "src": "1366:146:16", + "nodes": [], + "constant": true, + "documentation": { + "id": 1892, + "nodeType": "StructuredDocumentation", + "src": "1311:50:16", + "text": "The EIP-712 typehash for the contract's domain" + }, + "mutability": "constant", + "name": "DOMAIN_TYPEHASH", + "overrides": null, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "typeName": { + "id": 1893, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "1366:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "value": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "454950373132446f6d61696e28737472696e67206e616d652c737472696e672076657273696f6e2c75696e7432353620636861696e49642c6164647265737320766572696679696e67436f6e747261637429", + "id": 1895, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1427:84:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f", + "typeString": "literal_string \"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"" + }, + "value": "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_stringliteral_8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f", + "typeString": "literal_string \"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"" + } + ], + "id": 1894, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "1417:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 1896, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "1417:95:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "visibility": "private" + }, + { + "id": 1903, + "nodeType": "VariableDeclaration", + "src": "1568:133:16", + "nodes": [], + "constant": true, + "documentation": { + "id": 1898, + "nodeType": "StructuredDocumentation", + "src": "1519:44:16", + "text": "The EIP-712 typehash for the vote struct" + }, + "mutability": "constant", + "name": "VOTE_TYPEHASH", + "overrides": null, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "typeName": { + "id": 1899, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "1568:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "value": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "5472656173757279566f74652875696e743235362070726f706f73616c49642c626f6f6c20737570706f72742c627974657333325b5d206f70657261746564506f6f6c49647329", + "id": 1901, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1627:73:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_1e5642e3d26f0a340fb17e122193a3cd21b85477a8a2fb82e99ef31fa9927bd5", + "typeString": "literal_string \"TreasuryVote(uint256 proposalId,bool support,bytes32[] operatedPoolIds)\"" + }, + "value": "TreasuryVote(uint256 proposalId,bool support,bytes32[] operatedPoolIds)" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_stringliteral_1e5642e3d26f0a340fb17e122193a3cd21b85477a8a2fb82e99ef31fa9927bd5", + "typeString": "literal_string \"TreasuryVote(uint256 proposalId,bool support,bytes32[] operatedPoolIds)\"" + } + ], + "id": 1900, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "1617:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 1902, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "1617:84:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "visibility": "private" + }, + { + "id": 1906, + "nodeType": "VariableDeclaration", + "src": "1726:47:16", + "nodes": [], + "baseFunctions": [1760], + "constant": false, + "functionSelector": "22f80d11", + "mutability": "immutable", + "name": "stakingProxy", + "overrides": { + "id": 1905, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "1752:8:16" + }, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + }, + "typeName": { + "contractScope": null, + "id": 1904, + "name": "IStaking", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1688, + "src": "1726:8:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "value": null, + "visibility": "public" + }, + { + "id": 1909, + "nodeType": "VariableDeclaration", + "src": "1779:65:16", + "nodes": [], + "baseFunctions": [1765], + "constant": false, + "functionSelector": "9de38af2", + "mutability": "immutable", + "name": "defaultPoolOperator", + "overrides": { + "id": 1908, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "1816:8:16" + }, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_contract$_DefaultPoolOperator_$1597", + "typeString": "contract DefaultPoolOperator" + }, + "typeName": { + "contractScope": null, + "id": 1907, + "name": "DefaultPoolOperator", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1597, + "src": "1779:19:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_DefaultPoolOperator_$1597", + "typeString": "contract DefaultPoolOperator" + } + }, + "value": null, + "visibility": "public" + }, + { + "id": 1912, + "nodeType": "VariableDeclaration", + "src": "1850:47:16", + "nodes": [], + "baseFunctions": [1770], + "constant": false, + "functionSelector": "a0edbcbb", + "mutability": "immutable", + "name": "defaultPoolId", + "overrides": { + "id": 1911, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "1875:8:16" + }, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "typeName": { + "id": 1910, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "1850:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "value": null, + "visibility": "public" + }, + { + "id": 1915, + "nodeType": "VariableDeclaration", + "src": "1903:46:16", + "nodes": [], + "baseFunctions": [1775], + "constant": false, + "functionSelector": "02a251a3", + "mutability": "immutable", + "name": "votingPeriod", + "overrides": { + "id": 1914, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "1928:8:16" + }, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 1913, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1903:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "public" + }, + { + "id": 1917, + "nodeType": "VariableDeclaration", + "src": "1955:33:16", + "nodes": [], + "constant": false, + "mutability": "immutable", + "name": "domainSeparator", + "overrides": null, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "typeName": { + "id": 1916, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "1955:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "value": null, + "visibility": "internal" + }, + { + "id": 1920, + "nodeType": "VariableDeclaration", + "src": "1995:41:16", + "nodes": [], + "baseFunctions": [1780], + "constant": false, + "functionSelector": "b58131b0", + "mutability": "mutable", + "name": "proposalThreshold", + "overrides": { + "id": 1919, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "2010:8:16" + }, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 1918, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1995:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "public" + }, + { + "id": 1923, + "nodeType": "VariableDeclaration", + "src": "2042:39:16", + "nodes": [], + "baseFunctions": [1785], + "constant": false, + "functionSelector": "7b7a91dd", + "mutability": "mutable", + "name": "quorumThreshold", + "overrides": { + "id": 1922, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "2057:8:16" + }, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 1921, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2042:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "public" + }, + { + "id": 1926, + "nodeType": "VariableDeclaration", + "src": "2103:27:16", + "nodes": [], + "constant": false, + "functionSelector": "013cf08b", + "mutability": "mutable", + "name": "proposals", + "overrides": null, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal[]" + }, + "typeName": { + "baseType": { + "contractScope": null, + "id": 1924, + "name": "Proposal", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1722, + "src": "2103:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal" + } + }, + "id": 1925, + "length": null, + "nodeType": "ArrayTypeName", + "src": "2103:10:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal[]" + } + }, + "value": null, + "visibility": "public" + }, + { + "id": 1932, + "nodeType": "VariableDeclaration", + "src": "2136:60:16", + "nodes": [], + "constant": false, + "functionSelector": "43859632", + "mutability": "mutable", + "name": "hasVoted", + "overrides": null, + "scope": 2713, + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_mapping$_t_uint256_$_t_mapping$_t_address_$_t_bool_$_$", + "typeString": "mapping(uint256 => mapping(address => bool))" + }, + "typeName": { + "id": 1931, + "keyType": { + "id": 1927, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2144:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Mapping", + "src": "2136:44:16", + "typeDescriptions": { + "typeIdentifier": "t_mapping$_t_uint256_$_t_mapping$_t_address_$_t_bool_$_$", + "typeString": "mapping(uint256 => mapping(address => bool))" + }, + "valueType": { + "id": 1930, + "keyType": { + "id": 1928, + "name": "address", + "nodeType": "ElementaryTypeName", + "src": "2163:7:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "nodeType": "Mapping", + "src": "2155:24:16", + "typeDescriptions": { + "typeIdentifier": "t_mapping$_t_address_$_t_bool_$", + "typeString": "mapping(address => bool)" + }, + "valueType": { + "id": 1929, + "name": "bool", + "nodeType": "ElementaryTypeName", + "src": "2174:4:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + } + } + }, + "value": null, + "visibility": "public" + }, + { + "id": 2019, + "nodeType": "FunctionDefinition", + "src": "2409:870:16", + "nodes": [], + "body": { + "id": 2018, + "nodeType": "Block", + "src": "2486:793:16", + "nodes": [], + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 1946, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 1941, + "name": "params", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1937, + "src": "2504:6:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_TreasuryParameters_$1702_memory_ptr", + "typeString": "struct IZrxTreasury.TreasuryParameters memory" + } + }, + "id": 1942, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "votingPeriod", + "nodeType": "MemberAccess", + "referencedDeclaration": 1695, + "src": "2504:19:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "<", + "rightExpression": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "expression": { + "argumentTypes": null, + "id": 1943, + "name": "stakingProxy_", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1935, + "src": "2526:13:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 1944, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "epochDurationInSeconds", + "nodeType": "MemberAccess", + "referencedDeclaration": 1643, + "src": "2526:36:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$", + "typeString": "function () view external returns (uint256)" + } + }, + "id": 1945, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "2526:38:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "2504:60:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "564f54494e475f504552494f445f544f4f5f4c4f4e47", + "id": 1947, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2566:24:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_8131b60ba61849608d2ca55ee4cdfe8a0cb0e6ba1d1d03830d84678bbeb11114", + "typeString": "literal_string \"VOTING_PERIOD_TOO_LONG\"" + }, + "value": "VOTING_PERIOD_TOO_LONG" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_8131b60ba61849608d2ca55ee4cdfe8a0cb0e6ba1d1d03830d84678bbeb11114", + "typeString": "literal_string \"VOTING_PERIOD_TOO_LONG\"" + } + ], + "id": 1940, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "2496:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 1948, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "2496:95:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 1949, + "nodeType": "ExpressionStatement", + "src": "2496:95:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 1952, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 1950, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "2601:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "id": 1951, + "name": "stakingProxy_", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1935, + "src": "2616:13:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "src": "2601:28:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 1953, + "nodeType": "ExpressionStatement", + "src": "2601:28:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 1957, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 1954, + "name": "votingPeriod", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1915, + "src": "2639:12:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 1955, + "name": "params", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1937, + "src": "2654:6:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_TreasuryParameters_$1702_memory_ptr", + "typeString": "struct IZrxTreasury.TreasuryParameters memory" + } + }, + "id": 1956, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "votingPeriod", + "nodeType": "MemberAccess", + "referencedDeclaration": 1695, + "src": "2654:19:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "2639:34:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 1958, + "nodeType": "ExpressionStatement", + "src": "2639:34:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 1962, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 1959, + "name": "proposalThreshold", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1920, + "src": "2683:17:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 1960, + "name": "params", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1937, + "src": "2703:6:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_TreasuryParameters_$1702_memory_ptr", + "typeString": "struct IZrxTreasury.TreasuryParameters memory" + } + }, + "id": 1961, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "proposalThreshold", + "nodeType": "MemberAccess", + "referencedDeclaration": 1697, + "src": "2703:24:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "2683:44:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 1963, + "nodeType": "ExpressionStatement", + "src": "2683:44:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 1967, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 1964, + "name": "quorumThreshold", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1923, + "src": "2737:15:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 1965, + "name": "params", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1937, + "src": "2755:6:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_TreasuryParameters_$1702_memory_ptr", + "typeString": "struct IZrxTreasury.TreasuryParameters memory" + } + }, + "id": 1966, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "quorumThreshold", + "nodeType": "MemberAccess", + "referencedDeclaration": 1699, + "src": "2755:22:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "2737:40:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 1968, + "nodeType": "ExpressionStatement", + "src": "2737:40:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 1972, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 1969, + "name": "defaultPoolId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1912, + "src": "2787:13:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 1970, + "name": "params", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1937, + "src": "2803:6:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_TreasuryParameters_$1702_memory_ptr", + "typeString": "struct IZrxTreasury.TreasuryParameters memory" + } + }, + "id": 1971, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "defaultPoolId", + "nodeType": "MemberAccess", + "referencedDeclaration": 1701, + "src": "2803:20:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "src": "2787:36:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "id": 1973, + "nodeType": "ExpressionStatement", + "src": "2787:36:16" + }, + { + "assignments": [1977], + "declarations": [ + { + "constant": false, + "id": 1977, + "mutability": "mutable", + "name": "defaultPool", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2018, + "src": "2833:32:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Pool_$1615_memory_ptr", + "typeString": "struct IStaking.Pool" + }, + "typeName": { + "contractScope": null, + "id": 1976, + "name": "IStaking.Pool", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1615, + "src": "2833:13:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Pool_$1615_storage_ptr", + "typeString": "struct IStaking.Pool" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 1983, + "initialValue": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 1980, + "name": "params", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1937, + "src": "2897:6:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_TreasuryParameters_$1702_memory_ptr", + "typeString": "struct IZrxTreasury.TreasuryParameters memory" + } + }, + "id": 1981, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "defaultPoolId", + "nodeType": "MemberAccess", + "referencedDeclaration": 1701, + "src": "2897:20:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + ], + "expression": { + "argumentTypes": null, + "id": 1978, + "name": "stakingProxy_", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1935, + "src": "2868:13:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 1979, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "getStakingPool", + "nodeType": "MemberAccess", + "referencedDeclaration": 1651, + "src": "2868:28:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$_t_bytes32_$returns$_t_struct$_Pool_$1615_memory_ptr_$", + "typeString": "function (bytes32) view external returns (struct IStaking.Pool memory)" + } + }, + "id": 1982, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "2868:50:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_struct$_Pool_$1615_memory_ptr", + "typeString": "struct IStaking.Pool memory" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "2833:85:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 1989, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 1984, + "name": "defaultPoolOperator", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1909, + "src": "2928:19:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_DefaultPoolOperator_$1597", + "typeString": "contract DefaultPoolOperator" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 1986, + "name": "defaultPool", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1977, + "src": "2970:11:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Pool_$1615_memory_ptr", + "typeString": "struct IStaking.Pool memory" + } + }, + "id": 1987, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "operator", + "nodeType": "MemberAccess", + "referencedDeclaration": 1612, + "src": "2970:20:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + } + ], + "id": 1985, + "name": "DefaultPoolOperator", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1597, + "src": "2950:19:16", + "typeDescriptions": { + "typeIdentifier": "t_type$_t_contract$_DefaultPoolOperator_$1597_$", + "typeString": "type(contract DefaultPoolOperator)" + } + }, + "id": 1988, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "typeConversion", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "2950:41:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_contract$_DefaultPoolOperator_$1597", + "typeString": "contract DefaultPoolOperator" + } + }, + "src": "2928:63:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_DefaultPoolOperator_$1597", + "typeString": "contract DefaultPoolOperator" + } + }, + "id": 1990, + "nodeType": "ExpressionStatement", + "src": "2928:63:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2016, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 1991, + "name": "domainSeparator", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1917, + "src": "3001:15:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 1995, + "name": "DOMAIN_TYPEHASH", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1897, + "src": "3070:15:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 1999, + "name": "CONTRACT_NAME", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1887, + "src": "3119:13:16", + "typeDescriptions": { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "id": 1998, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "nodeType": "ElementaryTypeNameExpression", + "src": "3113:5:16", + "typeDescriptions": { + "typeIdentifier": "t_type$_t_bytes_storage_ptr_$", + "typeString": "type(bytes storage pointer)" + }, + "typeName": { + "id": 1997, + "name": "bytes", + "nodeType": "ElementaryTypeName", + "src": "3113:5:16", + "typeDescriptions": { + "typeIdentifier": null, + "typeString": null + } + } + }, + "id": 2000, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "typeConversion", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3113:20:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "id": 1996, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "3103:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 2001, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3103:31:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "id": 2002, + "name": "_getChainId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2712, + "src": "3152:11:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_pure$__$returns$_t_uint256_$", + "typeString": "function () pure returns (uint256)" + } + }, + "id": 2003, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3152:13:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2007, + "name": "CONTRACT_VERSION", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1891, + "src": "3199:16:16", + "typeDescriptions": { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "id": 2006, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "nodeType": "ElementaryTypeNameExpression", + "src": "3193:5:16", + "typeDescriptions": { + "typeIdentifier": "t_type$_t_bytes_storage_ptr_$", + "typeString": "type(bytes storage pointer)" + }, + "typeName": { + "id": 2005, + "name": "bytes", + "nodeType": "ElementaryTypeName", + "src": "3193:5:16", + "typeDescriptions": { + "typeIdentifier": null, + "typeString": null + } + } + }, + "id": 2008, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "typeConversion", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3193:23:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "id": 2004, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "3183:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 2009, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3183:34:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2012, + "name": "this", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -28, + "src": "3243:4:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_ZrxTreasury_$2713", + "typeString": "contract ZrxTreasury" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_contract$_ZrxTreasury_$2713", + "typeString": "contract ZrxTreasury" + } + ], + "id": 2011, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "nodeType": "ElementaryTypeNameExpression", + "src": "3235:7:16", + "typeDescriptions": { + "typeIdentifier": "t_type$_t_address_$", + "typeString": "type(address)" + }, + "typeName": { + "id": 2010, + "name": "address", + "nodeType": "ElementaryTypeName", + "src": "3235:7:16", + "typeDescriptions": { + "typeIdentifier": null, + "typeString": null + } + } + }, + "id": 2013, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "typeConversion", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3235:13:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + } + ], + "expression": { + "argumentTypes": null, + "id": 1993, + "name": "abi", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -1, + "src": "3042:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_abi", + "typeString": "abi" + } + }, + "id": 1994, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "memberName": "encode", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "3042:10:16", + "typeDescriptions": { + "typeIdentifier": "t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$", + "typeString": "function () pure returns (bytes memory)" + } + }, + "id": 2014, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3042:220:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "id": 1992, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "3019:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 2015, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3019:253:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "src": "3001:271:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "id": 2017, + "nodeType": "ExpressionStatement", + "src": "3001:271:16" + } + ] + }, + "documentation": { + "id": 1933, + "nodeType": "StructuredDocumentation", + "src": "2203:201:16", + "text": "@dev Initializes the ZRX treasury and creates the default\n staking pool.\n @param stakingProxy_ The 0x staking proxy contract.\n @param params Immutable treasury parameters." + }, + "implemented": true, + "kind": "constructor", + "modifiers": [], + "name": "", + "overrides": null, + "parameters": { + "id": 1938, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 1935, + "mutability": "mutable", + "name": "stakingProxy_", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2019, + "src": "2421:22:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + }, + "typeName": { + "contractScope": null, + "id": 1934, + "name": "IStaking", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1688, + "src": "2421:8:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 1937, + "mutability": "mutable", + "name": "params", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2019, + "src": "2445:32:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_struct$_TreasuryParameters_$1702_memory_ptr", + "typeString": "struct IZrxTreasury.TreasuryParameters" + }, + "typeName": { + "contractScope": null, + "id": 1936, + "name": "TreasuryParameters", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1702, + "src": "2445:18:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_TreasuryParameters_$1702_storage_ptr", + "typeString": "struct IZrxTreasury.TreasuryParameters" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "2420:58:16" + }, + "returnParameters": { + "id": 1939, + "nodeType": "ParameterList", + "parameters": [], + "src": "2486:0:16" + }, + "scope": 2713, + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "public" + }, + { + "id": 2024, + "nodeType": "FunctionDefinition", + "src": "3337:29:16", + "nodes": [], + "body": { + "id": 2023, + "nodeType": "Block", + "src": "3364:2:16", + "nodes": [], + "statements": [] + }, + "documentation": { + "id": 2020, + "nodeType": "StructuredDocumentation", + "src": "3285:47:16", + "text": "@dev Allows this contract to receive ether." + }, + "implemented": true, + "kind": "receive", + "modifiers": [], + "name": "", + "overrides": null, + "parameters": { + "id": 2021, + "nodeType": "ParameterList", + "parameters": [], + "src": "3344:2:16" + }, + "returnParameters": { + "id": 2022, + "nodeType": "ParameterList", + "parameters": [], + "src": "3364:0:16" + }, + "scope": 2713, + "stateMutability": "payable", + "virtual": false, + "visibility": "external" + }, + { + "id": 2053, + "nodeType": "FunctionDefinition", + "src": "3787:281:16", + "nodes": [], + "body": { + "id": 2052, + "nodeType": "Block", + "src": "3889:179:16", + "nodes": [], + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + }, + "id": 2040, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2034, + "name": "msg", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -15, + "src": "3907:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_message", + "typeString": "msg" + } + }, + "id": 2035, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "sender", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "3907:10:16", + "typeDescriptions": { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + } + }, + "nodeType": "BinaryOperation", + "operator": "==", + "rightExpression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2038, + "name": "this", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -28, + "src": "3929:4:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_ZrxTreasury_$2713", + "typeString": "contract ZrxTreasury" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_contract$_ZrxTreasury_$2713", + "typeString": "contract ZrxTreasury" + } + ], + "id": 2037, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "nodeType": "ElementaryTypeNameExpression", + "src": "3921:7:16", + "typeDescriptions": { + "typeIdentifier": "t_type$_t_address_$", + "typeString": "type(address)" + }, + "typeName": { + "id": 2036, + "name": "address", + "nodeType": "ElementaryTypeName", + "src": "3921:7:16", + "typeDescriptions": { + "typeIdentifier": null, + "typeString": null + } + } + }, + "id": 2039, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "typeConversion", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3921:13:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + } + }, + "src": "3907:27:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "7570646174655468726573686f6c64732f4f4e4c595f53454c46", + "id": 2041, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "3936:28:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_2428dc1780903199765122e4a6ce9d002b074213a33665da01c9e4ff7f6be62b", + "typeString": "literal_string \"updateThresholds/ONLY_SELF\"" + }, + "value": "updateThresholds/ONLY_SELF" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_2428dc1780903199765122e4a6ce9d002b074213a33665da01c9e4ff7f6be62b", + "typeString": "literal_string \"updateThresholds/ONLY_SELF\"" + } + ], + "id": 2033, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "3899:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2042, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "3899:66:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2043, + "nodeType": "ExpressionStatement", + "src": "3899:66:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2046, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 2044, + "name": "proposalThreshold", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1920, + "src": "3975:17:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "id": 2045, + "name": "newProposalThreshold", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2027, + "src": "3995:20:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "3975:40:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2047, + "nodeType": "ExpressionStatement", + "src": "3975:40:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2050, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 2048, + "name": "quorumThreshold", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1923, + "src": "4025:15:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "id": 2049, + "name": "newQuorumThreshold", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2029, + "src": "4043:18:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "4025:36:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2051, + "nodeType": "ExpressionStatement", + "src": "4025:36:16" + } + ] + }, + "baseFunctions": [1793], + "documentation": { + "id": 2025, + "nodeType": "StructuredDocumentation", + "src": "3372:410:16", + "text": "@dev Updates the proposal and quorum thresholds to the given\n values. Note that this function is only callable by the\n treasury contract itself, so the threshold can only be\n updated via a successful treasury proposal.\n @param newProposalThreshold The new value for the proposal threshold.\n @param newQuorumThreshold The new value for the quorum threshold." + }, + "functionSelector": "c14b8e9c", + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "updateThresholds", + "overrides": { + "id": 2031, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "3880:8:16" + }, + "parameters": { + "id": 2030, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2027, + "mutability": "mutable", + "name": "newProposalThreshold", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2053, + "src": "3813:28:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2026, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "3813:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2029, + "mutability": "mutable", + "name": "newQuorumThreshold", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2053, + "src": "3843:26:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2028, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "3843:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "3812:58:16" + }, + "returnParameters": { + "id": 2032, + "nodeType": "ParameterList", + "parameters": [], + "src": "3889:0:16" + }, + "scope": 2713, + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "external" + }, + { + "id": 2151, + "nodeType": "FunctionDefinition", + "src": "5188:936:16", + "nodes": [], + "body": { + "id": 2150, + "nodeType": "Block", + "src": "5406:718:16", + "nodes": [], + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2077, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2072, + "name": "msg", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -15, + "src": "5439:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_message", + "typeString": "msg" + } + }, + "id": 2073, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "sender", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "5439:10:16", + "typeDescriptions": { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + } + }, + { + "argumentTypes": null, + "id": 2074, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2064, + "src": "5451:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + }, + { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + ], + "id": 2071, + "name": "getVotingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2452, + "src": "5424:14:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_view$_t_address_$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$_t_uint256_$", + "typeString": "function (address,bytes32[] memory) view returns (uint256)" + } + }, + "id": 2075, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "5424:43:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": ">=", + "rightExpression": { + "argumentTypes": null, + "id": 2076, + "name": "proposalThreshold", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1920, + "src": "5471:17:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "5424:64:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "70726f706f73652f494e53554646494349454e545f564f54494e475f504f574552", + "id": 2078, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "5490:35:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_dbd213301c39dffffc55b6eb35d4aa34db5778034d20a6714a68ce19986c5fb4", + "typeString": "literal_string \"propose/INSUFFICIENT_VOTING_POWER\"" + }, + "value": "propose/INSUFFICIENT_VOTING_POWER" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_dbd213301c39dffffc55b6eb35d4aa34db5778034d20a6714a68ce19986c5fb4", + "typeString": "literal_string \"propose/INSUFFICIENT_VOTING_POWER\"" + } + ], + "id": 2070, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "5416:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2079, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "5416:110:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2080, + "nodeType": "ExpressionStatement", + "src": "5416:110:16" + }, + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2085, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2082, + "name": "actions", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2057, + "src": "5544:7:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + }, + "id": 2083, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "length", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "5544:14:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": ">", + "rightExpression": { + "argumentTypes": null, + "hexValue": "30", + "id": 2084, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "5561:1:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_rational_0_by_1", + "typeString": "int_const 0" + }, + "value": "0" + }, + "src": "5544:18:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "70726f706f73652f4e4f5f414354494f4e535f50524f504f534544", + "id": 2086, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "5564:29:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_066fd83e31c0c1271d045b772abf366dbaa6335e37725c4487624d49eca6fe3c", + "typeString": "literal_string \"propose/NO_ACTIONS_PROPOSED\"" + }, + "value": "propose/NO_ACTIONS_PROPOSED" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_066fd83e31c0c1271d045b772abf366dbaa6335e37725c4487624d49eca6fe3c", + "typeString": "literal_string \"propose/NO_ACTIONS_PROPOSED\"" + } + ], + "id": 2081, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "5536:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2087, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "5536:58:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2088, + "nodeType": "ExpressionStatement", + "src": "5536:58:16" + }, + { + "assignments": [2090], + "declarations": [ + { + "constant": false, + "id": 2090, + "mutability": "mutable", + "name": "currentEpoch", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2150, + "src": "5604:20:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2089, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "5604:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2094, + "initialValue": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "expression": { + "argumentTypes": null, + "id": 2091, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "5627:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 2092, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "currentEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1631, + "src": "5627:25:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$", + "typeString": "function () view external returns (uint256)" + } + }, + "id": 2093, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "5627:27:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "5604:50:16" + }, + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2100, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2096, + "name": "executionEpoch", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2059, + "src": "5672:14:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": ">=", + "rightExpression": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2099, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2097, + "name": "currentEpoch", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2090, + "src": "5690:12:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "+", + "rightExpression": { + "argumentTypes": null, + "hexValue": "32", + "id": 2098, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "5705:1:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_rational_2_by_1", + "typeString": "int_const 2" + }, + "value": "2" + }, + "src": "5690:16:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "5672:34:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "70726f706f73652f494e56414c49445f455845435554494f4e5f45504f4348", + "id": 2101, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "5708:33:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_948e33521e2cfdb3c937203c33d9340697e18c9d74f530635dc10a270e80d77b", + "typeString": "literal_string \"propose/INVALID_EXECUTION_EPOCH\"" + }, + "value": "propose/INVALID_EXECUTION_EPOCH" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_948e33521e2cfdb3c937203c33d9340697e18c9d74f530635dc10a270e80d77b", + "typeString": "literal_string \"propose/INVALID_EXECUTION_EPOCH\"" + } + ], + "id": 2095, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "5664:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2102, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "5664:78:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2103, + "nodeType": "ExpressionStatement", + "src": "5664:78:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2107, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 2104, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2068, + "src": "5753:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "id": 2105, + "name": "proposalCount", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2325, + "src": "5766:13:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$", + "typeString": "function () view returns (uint256)" + } + }, + "id": 2106, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "5766:15:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "5753:28:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2108, + "nodeType": "ExpressionStatement", + "src": "5753:28:16" + }, + { + "assignments": [2110], + "declarations": [ + { + "constant": false, + "id": 2110, + "mutability": "mutable", + "name": "newProposal", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2150, + "src": "5791:28:16", + "stateVariable": false, + "storageLocation": "storage", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal" + }, + "typeName": { + "contractScope": null, + "id": 2109, + "name": "Proposal", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1722, + "src": "5791:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2114, + "initialValue": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "expression": { + "argumentTypes": null, + "id": 2111, + "name": "proposals", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1926, + "src": "5822:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref[] storage ref" + } + }, + "id": 2112, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "push", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "5822:14:16", + "typeDescriptions": { + "typeIdentifier": "t_function_arraypush_nonpayable$__$returns$_t_struct$_Proposal_$1722_storage_$", + "typeString": "function () returns (struct IZrxTreasury.Proposal storage ref)" + } + }, + "id": 2113, + "isConstant": false, + "isLValue": true, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "5822:16:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "5791:47:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2124, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2115, + "name": "newProposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2110, + "src": "5848:11:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal storage pointer" + } + }, + "id": 2117, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "memberName": "actionsHash", + "nodeType": "MemberAccess", + "referencedDeclaration": 1711, + "src": "5848:23:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2121, + "name": "actions", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2057, + "src": "5895:7:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + ], + "expression": { + "argumentTypes": null, + "id": 2119, + "name": "abi", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -1, + "src": "5884:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_abi", + "typeString": "abi" + } + }, + "id": 2120, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "memberName": "encode", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "5884:10:16", + "typeDescriptions": { + "typeIdentifier": "t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$", + "typeString": "function () pure returns (bytes memory)" + } + }, + "id": 2122, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "5884:19:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "id": 2118, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "5874:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 2123, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "5874:30:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "src": "5848:56:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "id": 2125, + "nodeType": "ExpressionStatement", + "src": "5848:56:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2130, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2126, + "name": "newProposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2110, + "src": "5914:11:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal storage pointer" + } + }, + "id": 2128, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "memberName": "executionEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1713, + "src": "5914:26:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "id": 2129, + "name": "executionEpoch", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2059, + "src": "5943:14:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "5914:43:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2131, + "nodeType": "ExpressionStatement", + "src": "5914:43:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2138, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2132, + "name": "newProposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2110, + "src": "5967:11:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal storage pointer" + } + }, + "id": 2134, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "memberName": "voteEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1715, + "src": "5967:21:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2137, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2135, + "name": "currentEpoch", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2090, + "src": "5991:12:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "+", + "rightExpression": { + "argumentTypes": null, + "hexValue": "32", + "id": 2136, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "6006:1:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_rational_2_by_1", + "typeString": "int_const 2" + }, + "value": "2" + }, + "src": "5991:16:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "5967:40:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2139, + "nodeType": "ExpressionStatement", + "src": "5967:40:16" + }, + { + "eventCall": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2141, + "name": "msg", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -15, + "src": "6039:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_message", + "typeString": "msg" + } + }, + "id": 2142, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "sender", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "6039:10:16", + "typeDescriptions": { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + } + }, + { + "argumentTypes": null, + "id": 2143, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2064, + "src": "6051:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + }, + { + "argumentTypes": null, + "id": 2144, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2068, + "src": "6068:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + { + "argumentTypes": null, + "id": 2145, + "name": "actions", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2057, + "src": "6080:7:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + }, + { + "argumentTypes": null, + "id": 2146, + "name": "executionEpoch", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2059, + "src": "6089:14:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + { + "argumentTypes": null, + "id": 2147, + "name": "description", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2061, + "src": "6105:11:16", + "typeDescriptions": { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + }, + { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "id": 2140, + "name": "ProposalCreated", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1738, + "src": "6023:15:16", + "typeDescriptions": { + "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_array$_t_bytes32_$dyn_memory_ptr_$_t_uint256_$_t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr_$_t_uint256_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (address,bytes32[] memory,uint256,struct IZrxTreasury.ProposedAction memory[] memory,uint256,string memory)" + } + }, + "id": 2148, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "6023:94:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2149, + "nodeType": "EmitStatement", + "src": "6018:99:16" + } + ] + }, + "baseFunctions": [1809], + "documentation": { + "id": 2054, + "nodeType": "StructuredDocumentation", + "src": "4074:1109:16", + "text": "@dev Creates a proposal to send ZRX from this treasury on the\n the given actions. Must have at least `proposalThreshold`\n of voting power to call this function. See `getVotingPower`\n for how voting power is computed. If a proposal is successfully\n created, voting starts at the epoch after next (currentEpoch + 2).\n If the vote passes, the proposal is executable during the\n `executionEpoch`. See `hasProposalPassed` for the passing criteria.\n @param actions The proposed ZRX actions. An action specifies a\n contract call.\n @param executionEpoch The epoch during which the proposal is to\n be executed if it passes. Must be at least two epochs\n from the current epoch.\n @param description A text description for the proposal.\n @param operatedPoolIds The pools operated by the signer. The\n ZRX currently delegated to those pools will be accounted\n for in the voting power.\n @return proposalId The ID of the newly created proposal." + }, + "functionSelector": "d73ceb3a", + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "propose", + "overrides": { + "id": 2066, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "5368:8:16" + }, + "parameters": { + "id": 2065, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2057, + "mutability": "mutable", + "name": "actions", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2151, + "src": "5214:31:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction[]" + }, + "typeName": { + "baseType": { + "contractScope": null, + "id": 2055, + "name": "ProposedAction", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1709, + "src": "5214:14:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_ProposedAction_$1709_storage_ptr", + "typeString": "struct IZrxTreasury.ProposedAction" + } + }, + "id": 2056, + "length": null, + "nodeType": "ArrayTypeName", + "src": "5214:16:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_storage_$dyn_storage_ptr", + "typeString": "struct IZrxTreasury.ProposedAction[]" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2059, + "mutability": "mutable", + "name": "executionEpoch", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2151, + "src": "5255:22:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2058, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "5255:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2061, + "mutability": "mutable", + "name": "description", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2151, + "src": "5287:25:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string" + }, + "typeName": { + "id": 2060, + "name": "string", + "nodeType": "ElementaryTypeName", + "src": "5287:6:16", + "typeDescriptions": { + "typeIdentifier": "t_string_storage_ptr", + "typeString": "string" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2064, + "mutability": "mutable", + "name": "operatedPoolIds", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2151, + "src": "5322:32:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[]" + }, + "typeName": { + "baseType": { + "id": 2062, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "5322:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "id": 2063, + "length": null, + "nodeType": "ArrayTypeName", + "src": "5322:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr", + "typeString": "bytes32[]" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "5204:156:16" + }, + "returnParameters": { + "id": 2069, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2068, + "mutability": "mutable", + "name": "proposalId", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2151, + "src": "5386:18:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2067, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "5386:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "5385:20:16" + }, + "scope": 2713, + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "public" + }, + { + "id": 2172, + "nodeType": "FunctionDefinition", + "src": "6671:185:16", + "nodes": [], + "body": { + "id": 2171, + "nodeType": "Block", + "src": "6773:83:16", + "nodes": [], + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2164, + "name": "msg", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -15, + "src": "6800:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_message", + "typeString": "msg" + } + }, + "id": 2165, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "sender", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "6800:10:16", + "typeDescriptions": { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + } + }, + { + "argumentTypes": null, + "id": 2166, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2154, + "src": "6812:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + { + "argumentTypes": null, + "id": 2167, + "name": "support", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2156, + "src": "6824:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "id": 2168, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2159, + "src": "6833:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address_payable", + "typeString": "address payable" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + ], + "id": 2163, + "name": "_castVote", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2699, + "src": "6790:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_uint256_$_t_bool_$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$__$", + "typeString": "function (address,uint256,bool,bytes32[] memory)" + } + }, + "id": 2169, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "6790:59:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "functionReturnParameters": 2162, + "id": 2170, + "nodeType": "Return", + "src": "6783:66:16" + } + ] + }, + "baseFunctions": [1820], + "documentation": { + "id": 2152, + "nodeType": "StructuredDocumentation", + "src": "6130:536:16", + "text": "@dev Casts a vote for the given proposal. Only callable\n during the voting period for that proposal.\n One address can only vote once.\n See `getVotingPower` for how voting power is computed.\n @param proposalId The ID of the proposal to vote on.\n @param support Whether to support the proposal or not.\n @param operatedPoolIds The pools operated by `msg.sender`. The\n ZRX currently delegated to those pools will be accounted\n for in the voting power." + }, + "functionSelector": "dfe1e6b2", + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "castVote", + "overrides": { + "id": 2161, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "6764:8:16" + }, + "parameters": { + "id": 2160, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2154, + "mutability": "mutable", + "name": "proposalId", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2172, + "src": "6689:18:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2153, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "6689:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2156, + "mutability": "mutable", + "name": "support", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2172, + "src": "6709:12:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "typeName": { + "id": 2155, + "name": "bool", + "nodeType": "ElementaryTypeName", + "src": "6709:4:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2159, + "mutability": "mutable", + "name": "operatedPoolIds", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2172, + "src": "6723:32:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[]" + }, + "typeName": { + "baseType": { + "id": 2157, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "6723:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "id": 2158, + "length": null, + "nodeType": "ArrayTypeName", + "src": "6723:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr", + "typeString": "bytes32[]" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "6688:68:16" + }, + "returnParameters": { + "id": 2162, + "nodeType": "ParameterList", + "parameters": [], + "src": "6773:0:16" + }, + "scope": 2713, + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "public" + }, + { + "id": 2235, + "nodeType": "FunctionDefinition", + "src": "7554:588:16", + "nodes": [], + "body": { + "id": 2234, + "nodeType": "Block", + "src": "7752:390:16", + "nodes": [], + "statements": [ + { + "assignments": [2191], + "declarations": [ + { + "constant": false, + "id": 2191, + "mutability": "mutable", + "name": "structHash", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2234, + "src": "7762:18:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "typeName": { + "id": 2190, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "7762:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2206, + "initialValue": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2195, + "name": "VOTE_TYPEHASH", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1903, + "src": "7817:13:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + { + "argumentTypes": null, + "id": 2196, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2175, + "src": "7832:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + { + "argumentTypes": null, + "id": 2197, + "name": "support", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2177, + "src": "7844:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2201, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2180, + "src": "7880:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + ], + "expression": { + "argumentTypes": null, + "id": 2199, + "name": "abi", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -1, + "src": "7863:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_abi", + "typeString": "abi" + } + }, + "id": 2200, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "memberName": "encodePacked", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "7863:16:16", + "typeDescriptions": { + "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$", + "typeString": "function () pure returns (bytes memory)" + } + }, + "id": 2202, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "7863:33:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "id": 2198, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "7853:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 2203, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "7853:44:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + ], + "expression": { + "argumentTypes": null, + "id": 2193, + "name": "abi", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -1, + "src": "7806:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_abi", + "typeString": "abi" + } + }, + "id": 2194, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "memberName": "encode", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "7806:10:16", + "typeDescriptions": { + "typeIdentifier": "t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$", + "typeString": "function () pure returns (bytes memory)" + } + }, + "id": 2204, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "7806:92:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "id": 2192, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "7783:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 2205, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "7783:125:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "7762:146:16" + }, + { + "assignments": [2208], + "declarations": [ + { + "constant": false, + "id": 2208, + "mutability": "mutable", + "name": "digest", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2234, + "src": "7918:14:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "typeName": { + "id": 2207, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "7918:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2217, + "initialValue": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "1901", + "id": 2212, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "7962:10:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_301a50b291d33ce1e8e9064e3f6a6c51d902ec22892b50d58abf6357c6a45541", + "typeString": "literal_string \"\u0019\u0001\"" + }, + "value": "\u0019\u0001" + }, + { + "argumentTypes": null, + "id": 2213, + "name": "domainSeparator", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1917, + "src": "7974:15:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + { + "argumentTypes": null, + "id": 2214, + "name": "structHash", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2191, + "src": "7991:10:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_stringliteral_301a50b291d33ce1e8e9064e3f6a6c51d902ec22892b50d58abf6357c6a45541", + "typeString": "literal_string \"\u0019\u0001\"" + }, + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + ], + "expression": { + "argumentTypes": null, + "id": 2210, + "name": "abi", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -1, + "src": "7945:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_abi", + "typeString": "abi" + } + }, + "id": 2211, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "memberName": "encodePacked", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "7945:16:16", + "typeDescriptions": { + "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$", + "typeString": "function () pure returns (bytes memory)" + } + }, + "id": 2215, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "7945:57:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "id": 2209, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "7935:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 2216, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "7935:68:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "7918:85:16" + }, + { + "assignments": [2219], + "declarations": [ + { + "constant": false, + "id": 2219, + "mutability": "mutable", + "name": "signatory", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2234, + "src": "8013:17:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "typeName": { + "id": 2218, + "name": "address", + "nodeType": "ElementaryTypeName", + "src": "8013:7:16", + "stateMutability": "nonpayable", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2226, + "initialValue": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2221, + "name": "digest", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2208, + "src": "8043:6:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + { + "argumentTypes": null, + "id": 2222, + "name": "v", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2182, + "src": "8051:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint8", + "typeString": "uint8" + } + }, + { + "argumentTypes": null, + "id": 2223, + "name": "r", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2184, + "src": "8054:1:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + { + "argumentTypes": null, + "id": 2224, + "name": "s", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2186, + "src": "8057:1:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_uint8", + "typeString": "uint8" + }, + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + ], + "id": 2220, + "name": "ecrecover", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -6, + "src": "8033:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_ecrecover_pure$_t_bytes32_$_t_uint8_$_t_bytes32_$_t_bytes32_$returns$_t_address_$", + "typeString": "function (bytes32,uint8,bytes32,bytes32) pure returns (address)" + } + }, + "id": 2225, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "8033:26:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "8013:46:16" + }, + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2228, + "name": "signatory", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2219, + "src": "8087:9:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + { + "argumentTypes": null, + "id": 2229, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2175, + "src": "8098:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + { + "argumentTypes": null, + "id": 2230, + "name": "support", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2177, + "src": "8110:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "id": 2231, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2180, + "src": "8119:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + ], + "id": 2227, + "name": "_castVote", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2699, + "src": "8077:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_uint256_$_t_bool_$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$__$", + "typeString": "function (address,uint256,bool,bytes32[] memory)" + } + }, + "id": 2232, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "8077:58:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "functionReturnParameters": 2189, + "id": 2233, + "nodeType": "Return", + "src": "8070:65:16" + } + ] + }, + "baseFunctions": [1837], + "documentation": { + "id": 2173, + "nodeType": "StructuredDocumentation", + "src": "6862:687:16", + "text": "@dev Casts a vote for the given proposal, by signature.\n Only callable during the voting period for that proposal.\n One address/voter can only vote once.\n See `getVotingPower` for how voting power is computed.\n @param proposalId The ID of the proposal to vote on.\n @param support Whether to support the proposal or not.\n @param operatedPoolIds The pools operated by voter. The\n ZRX currently delegated to those pools will be accounted\n for in the voting power.\n @param v the v field of the signature\n @param r the r field of the signature\n @param s the s field of the signature" + }, + "functionSelector": "d438a3ce", + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "castVoteBySignature", + "overrides": { + "id": 2188, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "7743:8:16" + }, + "parameters": { + "id": 2187, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2175, + "mutability": "mutable", + "name": "proposalId", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2235, + "src": "7592:18:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2174, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "7592:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2177, + "mutability": "mutable", + "name": "support", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2235, + "src": "7620:12:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "typeName": { + "id": 2176, + "name": "bool", + "nodeType": "ElementaryTypeName", + "src": "7620:4:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2180, + "mutability": "mutable", + "name": "operatedPoolIds", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2235, + "src": "7642:32:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[]" + }, + "typeName": { + "baseType": { + "id": 2178, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "7642:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "id": 2179, + "length": null, + "nodeType": "ArrayTypeName", + "src": "7642:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr", + "typeString": "bytes32[]" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2182, + "mutability": "mutable", + "name": "v", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2235, + "src": "7684:7:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint8", + "typeString": "uint8" + }, + "typeName": { + "id": 2181, + "name": "uint8", + "nodeType": "ElementaryTypeName", + "src": "7684:5:16", + "typeDescriptions": { + "typeIdentifier": "t_uint8", + "typeString": "uint8" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2184, + "mutability": "mutable", + "name": "r", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2235, + "src": "7701:9:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "typeName": { + "id": 2183, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "7701:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2186, + "mutability": "mutable", + "name": "s", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2235, + "src": "7720:9:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "typeName": { + "id": 2185, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "7720:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "7582:153:16" + }, + "returnParameters": { + "id": 2189, + "nodeType": "ParameterList", + "parameters": [], + "src": "7752:0:16" + }, + "scope": 2713, + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "public" + }, + { + "id": 2314, + "nodeType": "FunctionDefinition", + "src": "8372:689:16", + "nodes": [], + "body": { + "id": 2313, + "nodeType": "Block", + "src": "8466:595:16", + "nodes": [], + "statements": [ + { + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2248, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2245, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2238, + "src": "8480:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": ">=", + "rightExpression": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "id": 2246, + "name": "proposalCount", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2325, + "src": "8494:13:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$", + "typeString": "function () view returns (uint256)" + } + }, + "id": 2247, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "8494:15:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "8480:29:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2254, + "nodeType": "IfStatement", + "src": "8476:97:16", + "trueBody": { + "id": 2253, + "nodeType": "Block", + "src": "8511:62:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "657865637574652f494e56414c49445f50524f504f53414c5f4944", + "id": 2250, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "8532:29:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_72c9d1dd3a58618357745a4d14a321a786f79cd4b9389174083499bb5ff0d18d", + "typeString": "literal_string \"execute/INVALID_PROPOSAL_ID\"" + }, + "value": "execute/INVALID_PROPOSAL_ID" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_stringliteral_72c9d1dd3a58618357745a4d14a321a786f79cd4b9389174083499bb5ff0d18d", + "typeString": "literal_string \"execute/INVALID_PROPOSAL_ID\"" + } + ], + "id": 2249, + "name": "revert", + "nodeType": "Identifier", + "overloadedDeclarations": [-19, -19], + "referencedDeclaration": -19, + "src": "8525:6:16", + "typeDescriptions": { + "typeIdentifier": "t_function_revert_pure$_t_string_memory_ptr_$returns$__$", + "typeString": "function (string memory) pure" + } + }, + "id": 2251, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "8525:37:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2252, + "nodeType": "ExpressionStatement", + "src": "8525:37:16" + } + ] + } + }, + { + "assignments": [2256], + "declarations": [ + { + "constant": false, + "id": 2256, + "mutability": "mutable", + "name": "proposal", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2313, + "src": "8582:24:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal" + }, + "typeName": { + "contractScope": null, + "id": 2255, + "name": "Proposal", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1722, + "src": "8582:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2260, + "initialValue": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2257, + "name": "proposals", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1926, + "src": "8609:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref[] storage ref" + } + }, + "id": 2259, + "indexExpression": { + "argumentTypes": null, + "id": 2258, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2238, + "src": "8619:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "8609:21:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "8582:48:16" + }, + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2262, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2256, + "src": "8666:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + { + "argumentTypes": null, + "id": 2263, + "name": "actions", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2241, + "src": "8676:7:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + }, + { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + ], + "id": 2261, + "name": "_assertProposalExecutable", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2499, + "src": "8640:25:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_view$_t_struct$_Proposal_$1722_memory_ptr_$_t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr_$returns$__$", + "typeString": "function (struct IZrxTreasury.Proposal memory,struct IZrxTreasury.ProposedAction memory[] memory) view" + } + }, + "id": 2264, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "8640:44:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2265, + "nodeType": "ExpressionStatement", + "src": "8640:44:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2271, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2266, + "name": "proposals", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1926, + "src": "8695:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref[] storage ref" + } + }, + "id": 2268, + "indexExpression": { + "argumentTypes": null, + "id": 2267, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2238, + "src": "8705:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "8695:21:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref" + } + }, + "id": 2269, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "memberName": "executed", + "nodeType": "MemberAccess", + "referencedDeclaration": 1721, + "src": "8695:30:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "hexValue": "74727565", + "id": 2270, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "bool", + "lValueRequested": false, + "nodeType": "Literal", + "src": "8728:4:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "value": "true" + }, + "src": "8695:37:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "id": 2272, + "nodeType": "ExpressionStatement", + "src": "8695:37:16" + }, + { + "body": { + "id": 2307, + "nodeType": "Block", + "src": "8789:222:16", + "statements": [ + { + "assignments": [2285], + "declarations": [ + { + "constant": false, + "id": 2285, + "mutability": "mutable", + "name": "action", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2307, + "src": "8803:28:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_struct$_ProposedAction_$1709_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction" + }, + "typeName": { + "contractScope": null, + "id": 2284, + "name": "ProposedAction", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1709, + "src": "8803:14:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_ProposedAction_$1709_storage_ptr", + "typeString": "struct IZrxTreasury.ProposedAction" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2289, + "initialValue": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2286, + "name": "actions", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2241, + "src": "8834:7:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + }, + "id": 2288, + "indexExpression": { + "argumentTypes": null, + "id": 2287, + "name": "i", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2274, + "src": "8842:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "8834:10:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_ProposedAction_$1709_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "8803:41:16" + }, + { + "assignments": [2291, null], + "declarations": [ + { + "constant": false, + "id": 2291, + "mutability": "mutable", + "name": "didSucceed", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2307, + "src": "8859:15:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "typeName": { + "id": 2290, + "name": "bool", + "nodeType": "ElementaryTypeName", + "src": "8859:4:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "value": null, + "visibility": "internal" + }, + null + ], + "id": 2301, + "initialValue": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2298, + "name": "action", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2285, + "src": "8920:6:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_ProposedAction_$1709_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory" + } + }, + "id": 2299, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "data", + "nodeType": "MemberAccess", + "referencedDeclaration": 1706, + "src": "8920:11:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "expression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2292, + "name": "action", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2285, + "src": "8880:6:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_ProposedAction_$1709_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory" + } + }, + "id": 2293, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "target", + "nodeType": "MemberAccess", + "referencedDeclaration": 1704, + "src": "8880:13:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "id": 2294, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "call", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "8880:18:16", + "typeDescriptions": { + "typeIdentifier": "t_function_barecall_payable$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$", + "typeString": "function (bytes memory) payable returns (bool,bytes memory)" + } + }, + "id": 2297, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "names": ["value"], + "nodeType": "FunctionCallOptions", + "options": [ + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2295, + "name": "action", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2285, + "src": "8906:6:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_ProposedAction_$1709_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory" + } + }, + "id": 2296, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "value", + "nodeType": "MemberAccess", + "referencedDeclaration": 1708, + "src": "8906:12:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "src": "8880:39:16", + "typeDescriptions": { + "typeIdentifier": "t_function_barecall_payable$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$value", + "typeString": "function (bytes memory) payable returns (bool,bytes memory)" + } + }, + "id": 2300, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "8880:52:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$", + "typeString": "tuple(bool,bytes memory)" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "8858:74:16" + }, + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2303, + "name": "didSucceed", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2291, + "src": "8954:10:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "657865637574652f414354494f4e5f455845435554494f4e5f4641494c4544", + "id": 2304, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "8966:33:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_0458e4d5cfbdcc280e0160625b014595375f42d5e20225829c59a79d332d3c67", + "typeString": "literal_string \"execute/ACTION_EXECUTION_FAILED\"" + }, + "value": "execute/ACTION_EXECUTION_FAILED" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_0458e4d5cfbdcc280e0160625b014595375f42d5e20225829c59a79d332d3c67", + "typeString": "literal_string \"execute/ACTION_EXECUTION_FAILED\"" + } + ], + "id": 2302, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "8946:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2305, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "8946:54:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2306, + "nodeType": "ExpressionStatement", + "src": "8946:54:16" + } + ] + }, + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2280, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2277, + "name": "i", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2274, + "src": "8763:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "!=", + "rightExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2278, + "name": "actions", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2241, + "src": "8768:7:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + }, + "id": 2279, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "length", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "8768:14:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "8763:19:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "id": 2308, + "initializationExpression": { + "assignments": [2274], + "declarations": [ + { + "constant": false, + "id": 2274, + "mutability": "mutable", + "name": "i", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2308, + "src": "8748:9:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2273, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "8748:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2276, + "initialValue": { + "argumentTypes": null, + "hexValue": "30", + "id": 2275, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "8760:1:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_rational_0_by_1", + "typeString": "int_const 0" + }, + "value": "0" + }, + "nodeType": "VariableDeclarationStatement", + "src": "8748:13:16" + }, + "loopExpression": { + "expression": { + "argumentTypes": null, + "id": 2282, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "nodeType": "UnaryOperation", + "operator": "++", + "prefix": false, + "src": "8784:3:16", + "subExpression": { + "argumentTypes": null, + "id": 2281, + "name": "i", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2274, + "src": "8784:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2283, + "nodeType": "ExpressionStatement", + "src": "8784:3:16" + }, + "nodeType": "ForStatement", + "src": "8743:268:16" + }, + { + "eventCall": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2310, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2238, + "src": "9043:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "id": 2309, + "name": "ProposalExecuted", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1755, + "src": "9026:16:16", + "typeDescriptions": { + "typeIdentifier": "t_function_event_nonpayable$_t_uint256_$returns$__$", + "typeString": "function (uint256)" + } + }, + "id": 2311, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "9026:28:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2312, + "nodeType": "EmitStatement", + "src": "9021:33:16" + } + ] + }, + "baseFunctions": [1846], + "documentation": { + "id": 2236, + "nodeType": "StructuredDocumentation", + "src": "8148:219:16", + "text": "@dev Executes a proposal that has passed and is\n currently executable.\n @param proposalId The ID of the proposal to execute.\n @param actions Actions associated with the proposal to execute." + }, + "functionSelector": "662bede3", + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "execute", + "overrides": { + "id": 2243, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "8457:8:16" + }, + "parameters": { + "id": 2242, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2238, + "mutability": "mutable", + "name": "proposalId", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2314, + "src": "8389:18:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2237, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "8389:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2241, + "mutability": "mutable", + "name": "actions", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2314, + "src": "8409:31:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction[]" + }, + "typeName": { + "baseType": { + "contractScope": null, + "id": 2239, + "name": "ProposedAction", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1709, + "src": "8409:14:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_ProposedAction_$1709_storage_ptr", + "typeString": "struct IZrxTreasury.ProposedAction" + } + }, + "id": 2240, + "length": null, + "nodeType": "ArrayTypeName", + "src": "8409:16:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_storage_$dyn_storage_ptr", + "typeString": "struct IZrxTreasury.ProposedAction[]" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "8388:53:16" + }, + "returnParameters": { + "id": 2244, + "nodeType": "ParameterList", + "parameters": [], + "src": "8466:0:16" + }, + "scope": 2713, + "stateMutability": "payable", + "virtual": false, + "visibility": "public" + }, + { + "id": 2325, + "nodeType": "FunctionDefinition", + "src": "9166:110:16", + "nodes": [], + "body": { + "id": 2324, + "nodeType": "Block", + "src": "9236:40:16", + "nodes": [], + "statements": [ + { + "expression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2321, + "name": "proposals", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1926, + "src": "9253:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref[] storage ref" + } + }, + "id": 2322, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "length", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "9253:16:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "functionReturnParameters": 2320, + "id": 2323, + "nodeType": "Return", + "src": "9246:23:16" + } + ] + }, + "baseFunctions": [1852], + "documentation": { + "id": 2315, + "nodeType": "StructuredDocumentation", + "src": "9067:94:16", + "text": "@dev Returns the total number of proposals.\n @return count The number of proposals." + }, + "functionSelector": "da35c664", + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "proposalCount", + "overrides": { + "id": 2317, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "9203:8:16" + }, + "parameters": { + "id": 2316, + "nodeType": "ParameterList", + "parameters": [], + "src": "9188:2:16" + }, + "returnParameters": { + "id": 2320, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2319, + "mutability": "mutable", + "name": "count", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2325, + "src": "9221:13:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2318, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "9221:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "9220:15:16" + }, + "scope": 2713, + "stateMutability": "view", + "virtual": false, + "visibility": "public" + }, + { + "id": 2452, + "nodeType": "FunctionDefinition", + "src": "9863:1560:16", + "nodes": [], + "body": { + "id": 2451, + "nodeType": "Block", + "src": "10011:1412:16", + "nodes": [], + "statements": [ + { + "assignments": [2338], + "declarations": [ + { + "constant": false, + "id": 2338, + "mutability": "mutable", + "name": "delegatedBalance", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2451, + "src": "10021:24:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2337, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "10021:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2347, + "initialValue": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2341, + "name": "account", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2328, + "src": "10096:7:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2342, + "name": "IStaking", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1688, + "src": "10105:8:16", + "typeDescriptions": { + "typeIdentifier": "t_type$_t_contract$_IStaking_$1688_$", + "typeString": "type(contract IStaking)" + } + }, + "id": 2343, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "StakeStatus", + "nodeType": "MemberAccess", + "referencedDeclaration": 1603, + "src": "10105:20:16", + "typeDescriptions": { + "typeIdentifier": "t_type$_t_enum$_StakeStatus_$1603_$", + "typeString": "type(enum IStaking.StakeStatus)" + } + }, + "id": 2344, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "memberName": "DELEGATED", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "10105:30:16", + "typeDescriptions": { + "typeIdentifier": "t_enum$_StakeStatus_$1603", + "typeString": "enum IStaking.StakeStatus" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_enum$_StakeStatus_$1603", + "typeString": "enum IStaking.StakeStatus" + } + ], + "expression": { + "argumentTypes": null, + "id": 2339, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "10048:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 2340, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "getOwnerStakeByStatus", + "nodeType": "MemberAccess", + "referencedDeclaration": 1669, + "src": "10048:47:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$_t_address_$_t_enum$_StakeStatus_$1603_$returns$_t_struct$_StoredBalance_$1610_memory_ptr_$", + "typeString": "function (address,enum IStaking.StakeStatus) view external returns (struct IStaking.StoredBalance memory)" + } + }, + "id": 2345, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "10048:88:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_struct$_StoredBalance_$1610_memory_ptr", + "typeString": "struct IStaking.StoredBalance memory" + } + }, + "id": 2346, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "currentEpochBalance", + "nodeType": "MemberAccess", + "referencedDeclaration": 1607, + "src": "10048:121:16", + "typeDescriptions": { + "typeIdentifier": "t_uint96", + "typeString": "uint96" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "10021:148:16" + }, + { + "assignments": [2349], + "declarations": [ + { + "constant": false, + "id": 2349, + "mutability": "mutable", + "name": "balanceDelegatedToDefaultPool", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2451, + "src": "10179:37:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2348, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "10179:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2356, + "initialValue": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2352, + "name": "account", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2328, + "src": "10276:7:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + { + "argumentTypes": null, + "id": 2353, + "name": "defaultPoolId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1912, + "src": "10285:13:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + ], + "expression": { + "argumentTypes": null, + "id": 2350, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "10219:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 2351, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "getStakeDelegatedToPoolByOwner", + "nodeType": "MemberAccess", + "referencedDeclaration": 1687, + "src": "10219:56:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$_t_address_$_t_bytes32_$returns$_t_struct$_StoredBalance_$1610_memory_ptr_$", + "typeString": "function (address,bytes32) view external returns (struct IStaking.StoredBalance memory)" + } + }, + "id": 2354, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "10219:80:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_struct$_StoredBalance_$1610_memory_ptr", + "typeString": "struct IStaking.StoredBalance memory" + } + }, + "id": 2355, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "currentEpochBalance", + "nodeType": "MemberAccess", + "referencedDeclaration": 1607, + "src": "10219:113:16", + "typeDescriptions": { + "typeIdentifier": "t_uint96", + "typeString": "uint96" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "10179:153:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2365, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 2357, + "name": "votingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2335, + "src": "10526:11:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "32", + "id": 2363, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "10604:1:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_rational_2_by_1", + "typeString": "int_const 2" + }, + "value": "2" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_rational_2_by_1", + "typeString": "int_const 2" + } + ], + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2360, + "name": "balanceDelegatedToDefaultPool", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2349, + "src": "10565:29:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "expression": { + "argumentTypes": null, + "id": 2358, + "name": "delegatedBalance", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2338, + "src": "10540:16:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2359, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "safeAdd", + "nodeType": "MemberAccess", + "referencedDeclaration": 751, + "src": "10540:24:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$", + "typeString": "function (uint256,uint256) pure returns (uint256)" + } + }, + "id": 2361, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "10540:55:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2362, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "safeDiv", + "nodeType": "MemberAccess", + "referencedDeclaration": 683, + "src": "10540:63:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$", + "typeString": "function (uint256,uint256) pure returns (uint256)" + } + }, + "id": 2364, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "10540:66:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "10526:80:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2366, + "nodeType": "ExpressionStatement", + "src": "10526:80:16" + }, + { + "body": { + "id": 2447, + "nodeType": "Block", + "src": "10727:661:16", + "statements": [ + { + "body": { + "id": 2399, + "nodeType": "Block", + "src": "10774:118:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "id": 2395, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2389, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2331, + "src": "10800:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + }, + "id": 2391, + "indexExpression": { + "argumentTypes": null, + "id": 2390, + "name": "i", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2368, + "src": "10816:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "10800:18:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "nodeType": "BinaryOperation", + "operator": "!=", + "rightExpression": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2392, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2331, + "src": "10822:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + }, + "id": 2394, + "indexExpression": { + "argumentTypes": null, + "id": 2393, + "name": "j", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2379, + "src": "10838:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "10822:18:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "src": "10800:40:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "676574566f74696e67506f7765722f4455504c49434154455f504f4f4c5f4944", + "id": 2396, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "10842:34:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_7a214ee945fcb3941da17a9690341c19f08aedb27088a0cab95e3ffe2c207388", + "typeString": "literal_string \"getVotingPower/DUPLICATE_POOL_ID\"" + }, + "value": "getVotingPower/DUPLICATE_POOL_ID" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_7a214ee945fcb3941da17a9690341c19f08aedb27088a0cab95e3ffe2c207388", + "typeString": "literal_string \"getVotingPower/DUPLICATE_POOL_ID\"" + } + ], + "id": 2388, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "10792:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2397, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "10792:85:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2398, + "nodeType": "ExpressionStatement", + "src": "10792:85:16" + } + ] + }, + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2384, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2382, + "name": "j", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2379, + "src": "10761:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "!=", + "rightExpression": { + "argumentTypes": null, + "id": 2383, + "name": "i", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2368, + "src": "10766:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "10761:6:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "id": 2400, + "initializationExpression": { + "assignments": [2379], + "declarations": [ + { + "constant": false, + "id": 2379, + "mutability": "mutable", + "name": "j", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2400, + "src": "10746:9:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2378, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "10746:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2381, + "initialValue": { + "argumentTypes": null, + "hexValue": "30", + "id": 2380, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "10758:1:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_rational_0_by_1", + "typeString": "int_const 0" + }, + "value": "0" + }, + "nodeType": "VariableDeclarationStatement", + "src": "10746:13:16" + }, + "loopExpression": { + "expression": { + "argumentTypes": null, + "id": 2386, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "nodeType": "UnaryOperation", + "operator": "++", + "prefix": false, + "src": "10769:3:16", + "subExpression": { + "argumentTypes": null, + "id": 2385, + "name": "j", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2379, + "src": "10769:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2387, + "nodeType": "ExpressionStatement", + "src": "10769:3:16" + }, + "nodeType": "ForStatement", + "src": "10741:151:16" + }, + { + "assignments": [2404], + "declarations": [ + { + "constant": false, + "id": 2404, + "mutability": "mutable", + "name": "pool", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2447, + "src": "10905:25:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Pool_$1615_memory_ptr", + "typeString": "struct IStaking.Pool" + }, + "typeName": { + "contractScope": null, + "id": 2403, + "name": "IStaking.Pool", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1615, + "src": "10905:13:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Pool_$1615_storage_ptr", + "typeString": "struct IStaking.Pool" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2411, + "initialValue": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2407, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2331, + "src": "10961:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + }, + "id": 2409, + "indexExpression": { + "argumentTypes": null, + "id": 2408, + "name": "i", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2368, + "src": "10977:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "10961:18:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + ], + "expression": { + "argumentTypes": null, + "id": 2405, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "10933:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 2406, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "getStakingPool", + "nodeType": "MemberAccess", + "referencedDeclaration": 1651, + "src": "10933:27:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$_t_bytes32_$returns$_t_struct$_Pool_$1615_memory_ptr_$", + "typeString": "function (bytes32) view external returns (struct IStaking.Pool memory)" + } + }, + "id": 2410, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "10933:47:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_struct$_Pool_$1615_memory_ptr", + "typeString": "struct IStaking.Pool memory" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "10905:75:16" + }, + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "id": 2416, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2413, + "name": "pool", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2404, + "src": "11002:4:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Pool_$1615_memory_ptr", + "typeString": "struct IStaking.Pool memory" + } + }, + "id": 2414, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "operator", + "nodeType": "MemberAccess", + "referencedDeclaration": 1612, + "src": "11002:13:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "nodeType": "BinaryOperation", + "operator": "==", + "rightExpression": { + "argumentTypes": null, + "id": 2415, + "name": "account", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2328, + "src": "11019:7:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "src": "11002:24:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "676574566f74696e67506f7765722f504f4f4c5f4e4f545f4f504552415445445f42595f4143434f554e54", + "id": 2417, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "11028:45:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_98b054323bcd79d7b33ab99104d9b656a30613a8a5f989a2dc15cda17154d6b9", + "typeString": "literal_string \"getVotingPower/POOL_NOT_OPERATED_BY_ACCOUNT\"" + }, + "value": "getVotingPower/POOL_NOT_OPERATED_BY_ACCOUNT" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_98b054323bcd79d7b33ab99104d9b656a30613a8a5f989a2dc15cda17154d6b9", + "typeString": "literal_string \"getVotingPower/POOL_NOT_OPERATED_BY_ACCOUNT\"" + } + ], + "id": 2412, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "10994:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2418, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "10994:80:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2419, + "nodeType": "ExpressionStatement", + "src": "10994:80:16" + }, + { + "assignments": [2421], + "declarations": [ + { + "constant": false, + "id": 2421, + "mutability": "mutable", + "name": "stakeDelegatedToPool", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2447, + "src": "11088:27:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint96", + "typeString": "uint96" + }, + "typeName": { + "id": 2420, + "name": "uint96", + "nodeType": "ElementaryTypeName", + "src": "11088:6:16", + "typeDescriptions": { + "typeIdentifier": "t_uint96", + "typeString": "uint96" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2429, + "initialValue": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2424, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2331, + "src": "11177:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + }, + "id": 2426, + "indexExpression": { + "argumentTypes": null, + "id": 2425, + "name": "i", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2368, + "src": "11193:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "11177:18:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + ], + "expression": { + "argumentTypes": null, + "id": 2422, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "11118:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 2423, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "getTotalStakeDelegatedToPool", + "nodeType": "MemberAccess", + "referencedDeclaration": 1677, + "src": "11118:58:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$_t_bytes32_$returns$_t_struct$_StoredBalance_$1610_memory_ptr_$", + "typeString": "function (bytes32) view external returns (struct IStaking.StoredBalance memory)" + } + }, + "id": 2427, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11118:78:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_struct$_StoredBalance_$1610_memory_ptr", + "typeString": "struct IStaking.StoredBalance memory" + } + }, + "id": 2428, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "currentEpochBalance", + "nodeType": "MemberAccess", + "referencedDeclaration": 1607, + "src": "11118:115:16", + "typeDescriptions": { + "typeIdentifier": "t_uint96", + "typeString": "uint96" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "11088:145:16" + }, + { + "assignments": [2431], + "declarations": [ + { + "constant": false, + "id": 2431, + "mutability": "mutable", + "name": "poolVotingPower", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2447, + "src": "11247:23:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2430, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "11247:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2439, + "initialValue": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "32", + "id": 2437, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "11311:1:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_rational_2_by_1", + "typeString": "int_const 2" + }, + "value": "2" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_rational_2_by_1", + "typeString": "int_const 2" + } + ], + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2434, + "name": "stakeDelegatedToPool", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2421, + "src": "11281:20:16", + "typeDescriptions": { + "typeIdentifier": "t_uint96", + "typeString": "uint96" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint96", + "typeString": "uint96" + } + ], + "id": 2433, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "nodeType": "ElementaryTypeNameExpression", + "src": "11273:7:16", + "typeDescriptions": { + "typeIdentifier": "t_type$_t_uint256_$", + "typeString": "type(uint256)" + }, + "typeName": { + "id": 2432, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "11273:7:16", + "typeDescriptions": { + "typeIdentifier": null, + "typeString": null + } + } + }, + "id": 2435, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "typeConversion", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11273:29:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2436, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "safeDiv", + "nodeType": "MemberAccess", + "referencedDeclaration": 683, + "src": "11273:37:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$", + "typeString": "function (uint256,uint256) pure returns (uint256)" + } + }, + "id": 2438, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11273:40:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "11247:66:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2445, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "id": 2440, + "name": "votingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2335, + "src": "11327:11:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2443, + "name": "poolVotingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2431, + "src": "11361:15:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "expression": { + "argumentTypes": null, + "id": 2441, + "name": "votingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2335, + "src": "11341:11:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2442, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "safeAdd", + "nodeType": "MemberAccess", + "referencedDeclaration": 751, + "src": "11341:19:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$", + "typeString": "function (uint256,uint256) pure returns (uint256)" + } + }, + "id": 2444, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11341:36:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "11327:50:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2446, + "nodeType": "ExpressionStatement", + "src": "11327:50:16" + } + ] + }, + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2374, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2371, + "name": "i", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2368, + "src": "10693:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "!=", + "rightExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2372, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2331, + "src": "10698:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + }, + "id": 2373, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "length", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "10698:22:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "10693:27:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "id": 2448, + "initializationExpression": { + "assignments": [2368], + "declarations": [ + { + "constant": false, + "id": 2368, + "mutability": "mutable", + "name": "i", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2448, + "src": "10678:9:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2367, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "10678:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2370, + "initialValue": { + "argumentTypes": null, + "hexValue": "30", + "id": 2369, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "10690:1:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_rational_0_by_1", + "typeString": "int_const 0" + }, + "value": "0" + }, + "nodeType": "VariableDeclarationStatement", + "src": "10678:13:16" + }, + "loopExpression": { + "expression": { + "argumentTypes": null, + "id": 2376, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "nodeType": "UnaryOperation", + "operator": "++", + "prefix": false, + "src": "10722:3:16", + "subExpression": { + "argumentTypes": null, + "id": 2375, + "name": "i", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2368, + "src": "10722:1:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2377, + "nodeType": "ExpressionStatement", + "src": "10722:3:16" + }, + "nodeType": "ForStatement", + "src": "10673:715:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2449, + "name": "votingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2335, + "src": "11405:11:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "functionReturnParameters": 2336, + "id": 2450, + "nodeType": "Return", + "src": "11398:18:16" + } + ] + }, + "baseFunctions": [1863], + "documentation": { + "id": 2326, + "nodeType": "StructuredDocumentation", + "src": "9282:576:16", + "text": "@dev Computes the current voting power of the given account.\n Voting power is equal to:\n (ZRX delegated to the default pool) +\n 0.5 * (ZRX delegated to other pools) +\n 0.5 * (ZRX delegated to pools operated by account)\n @param account The address of the account.\n @param operatedPoolIds The pools operated by `account`. The\n ZRX currently delegated to those pools will be accounted\n for in the voting power.\n @return votingPower The current voting power of the given account." + }, + "functionSelector": "7c29cb1a", + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "getVotingPower", + "overrides": { + "id": 2333, + "nodeType": "OverrideSpecifier", + "overrides": [], + "src": "9972:8:16" + }, + "parameters": { + "id": 2332, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2328, + "mutability": "mutable", + "name": "account", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2452, + "src": "9896:15:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "typeName": { + "id": 2327, + "name": "address", + "nodeType": "ElementaryTypeName", + "src": "9896:7:16", + "stateMutability": "nonpayable", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2331, + "mutability": "mutable", + "name": "operatedPoolIds", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2452, + "src": "9921:32:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[]" + }, + "typeName": { + "baseType": { + "id": 2329, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "9921:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "id": 2330, + "length": null, + "nodeType": "ArrayTypeName", + "src": "9921:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr", + "typeString": "bytes32[]" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "9886:73:16" + }, + "returnParameters": { + "id": 2336, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2335, + "mutability": "mutable", + "name": "votingPower", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2452, + "src": "9990:19:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2334, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "9990:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "9989:21:16" + }, + "scope": 2713, + "stateMutability": "view", + "virtual": false, + "visibility": "public" + }, + { + "id": 2499, + "nodeType": "FunctionDefinition", + "src": "11567:586:16", + "nodes": [], + "body": { + "id": 2498, + "nodeType": "Block", + "src": "11674:479:16", + "nodes": [], + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + "id": 2470, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2465, + "name": "actions", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2458, + "src": "11713:7:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction memory[] memory" + } + ], + "expression": { + "argumentTypes": null, + "id": 2463, + "name": "abi", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -1, + "src": "11702:3:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_abi", + "typeString": "abi" + } + }, + "id": 2464, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "memberName": "encode", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "11702:10:16", + "typeDescriptions": { + "typeIdentifier": "t_function_abiencode_pure$__$returns$_t_bytes_memory_ptr_$", + "typeString": "function () pure returns (bytes memory)" + } + }, + "id": 2466, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11702:19:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "id": 2462, + "name": "keccak256", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -8, + "src": "11692:9:16", + "typeDescriptions": { + "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", + "typeString": "function (bytes memory) pure returns (bytes32)" + } + }, + "id": 2467, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11692:30:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "nodeType": "BinaryOperation", + "operator": "==", + "rightExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2468, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2455, + "src": "11726:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + "id": 2469, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "actionsHash", + "nodeType": "MemberAccess", + "referencedDeclaration": 1711, + "src": "11726:20:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "src": "11692:54:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "5f61737365727450726f706f73616c45786563757461626c652f494e56414c49445f414354494f4e53", + "id": 2471, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "11748:43:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_bb2d39095900fa0f1afe076ba7fd785e01c76b7ef4df4066c23a6ca23c4f54ea", + "typeString": "literal_string \"_assertProposalExecutable/INVALID_ACTIONS\"" + }, + "value": "_assertProposalExecutable/INVALID_ACTIONS" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_bb2d39095900fa0f1afe076ba7fd785e01c76b7ef4df4066c23a6ca23c4f54ea", + "typeString": "literal_string \"_assertProposalExecutable/INVALID_ACTIONS\"" + } + ], + "id": 2461, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "11684:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2472, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11684:108:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2473, + "nodeType": "ExpressionStatement", + "src": "11684:108:16" + }, + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2476, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2455, + "src": "11829:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + ], + "id": 2475, + "name": "_hasProposalPassed", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2536, + "src": "11810:18:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_view$_t_struct$_Proposal_$1722_memory_ptr_$returns$_t_bool_$", + "typeString": "function (struct IZrxTreasury.Proposal memory) view returns (bool)" + } + }, + "id": 2477, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11810:28:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "5f61737365727450726f706f73616c45786563757461626c652f50524f504f53414c5f4841535f4e4f545f504153534544", + "id": 2478, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "11840:51:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_7d210fb98e6003d0e0a1e160ce97b23f173705f9b69828f83485169c213a24df", + "typeString": "literal_string \"_assertProposalExecutable/PROPOSAL_HAS_NOT_PASSED\"" + }, + "value": "_assertProposalExecutable/PROPOSAL_HAS_NOT_PASSED" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_7d210fb98e6003d0e0a1e160ce97b23f173705f9b69828f83485169c213a24df", + "typeString": "literal_string \"_assertProposalExecutable/PROPOSAL_HAS_NOT_PASSED\"" + } + ], + "id": 2474, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "11802:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2479, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11802:90:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2480, + "nodeType": "ExpressionStatement", + "src": "11802:90:16" + }, + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2484, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "nodeType": "UnaryOperation", + "operator": "!", + "prefix": true, + "src": "11910:18:16", + "subExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2482, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2455, + "src": "11911:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + "id": 2483, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "executed", + "nodeType": "MemberAccess", + "referencedDeclaration": 1721, + "src": "11911:17:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "5f61737365727450726f706f73616c45786563757461626c652f50524f504f53414c5f414c52454144595f4558454355544544", + "id": 2485, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "11930:53:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_09466294efa267b6dec773829e7e051c7a82209512cb297450b50213ea126fb6", + "typeString": "literal_string \"_assertProposalExecutable/PROPOSAL_ALREADY_EXECUTED\"" + }, + "value": "_assertProposalExecutable/PROPOSAL_ALREADY_EXECUTED" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_09466294efa267b6dec773829e7e051c7a82209512cb297450b50213ea126fb6", + "typeString": "literal_string \"_assertProposalExecutable/PROPOSAL_ALREADY_EXECUTED\"" + } + ], + "id": 2481, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "11902:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2486, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11902:82:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2487, + "nodeType": "ExpressionStatement", + "src": "11902:82:16" + }, + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2494, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "expression": { + "argumentTypes": null, + "id": 2489, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "12015:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 2490, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "currentEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1631, + "src": "12015:25:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$", + "typeString": "function () view external returns (uint256)" + } + }, + "id": 2491, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "12015:27:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "==", + "rightExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2492, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2455, + "src": "12046:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + "id": 2493, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "executionEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1713, + "src": "12046:23:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "12015:54:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "hexValue": "5f61737365727450726f706f73616c45786563757461626c652f43414e4e4f545f455845435554455f544849535f45504f4348", + "id": 2495, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "12083:53:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_bec62ec1b786cb90488e4419cf7e24f7b2f2b34acd3cb17cf8ba0030505c05fb", + "typeString": "literal_string \"_assertProposalExecutable/CANNOT_EXECUTE_THIS_EPOCH\"" + }, + "value": "_assertProposalExecutable/CANNOT_EXECUTE_THIS_EPOCH" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_stringliteral_bec62ec1b786cb90488e4419cf7e24f7b2f2b34acd3cb17cf8ba0030505c05fb", + "typeString": "literal_string \"_assertProposalExecutable/CANNOT_EXECUTE_THIS_EPOCH\"" + } + ], + "id": 2488, + "name": "require", + "nodeType": "Identifier", + "overloadedDeclarations": [-18, -18], + "referencedDeclaration": -18, + "src": "11994:7:16", + "typeDescriptions": { + "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", + "typeString": "function (bool,string memory) pure" + } + }, + "id": 2496, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "11994:152:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2497, + "nodeType": "ExpressionStatement", + "src": "11994:152:16" + } + ] + }, + "documentation": { + "id": 2453, + "nodeType": "StructuredDocumentation", + "src": "11429:133:16", + "text": "@dev Checks whether the given proposal is executable.\n Reverts if not.\n @param proposal The proposal to check." + }, + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "_assertProposalExecutable", + "overrides": null, + "parameters": { + "id": 2459, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2455, + "mutability": "mutable", + "name": "proposal", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2499, + "src": "11602:24:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal" + }, + "typeName": { + "contractScope": null, + "id": 2454, + "name": "Proposal", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1722, + "src": "11602:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2458, + "mutability": "mutable", + "name": "actions", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2499, + "src": "11628:31:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_memory_ptr_$dyn_memory_ptr", + "typeString": "struct IZrxTreasury.ProposedAction[]" + }, + "typeName": { + "baseType": { + "contractScope": null, + "id": 2456, + "name": "ProposedAction", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1709, + "src": "11628:14:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_ProposedAction_$1709_storage_ptr", + "typeString": "struct IZrxTreasury.ProposedAction" + } + }, + "id": 2457, + "length": null, + "nodeType": "ArrayTypeName", + "src": "11628:16:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_ProposedAction_$1709_storage_$dyn_storage_ptr", + "typeString": "struct IZrxTreasury.ProposedAction[]" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "11601:59:16" + }, + "returnParameters": { + "id": 2460, + "nodeType": "ParameterList", + "parameters": [], + "src": "11674:0:16" + }, + "scope": 2713, + "stateMutability": "view", + "virtual": false, + "visibility": "private" + }, + { + "id": 2536, + "nodeType": "FunctionDefinition", + "src": "12331:520:16", + "nodes": [], + "body": { + "id": 2535, + "nodeType": "Block", + "src": "12423:428:16", + "nodes": [], + "statements": [ + { + "condition": { + "argumentTypes": null, + "id": 2511, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "nodeType": "UnaryOperation", + "operator": "!", + "prefix": true, + "src": "12495:34:16", + "subExpression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2508, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2502, + "src": "12510:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + "id": 2509, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "voteEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1715, + "src": "12510:18:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "id": 2507, + "name": "_hasVoteEnded", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2579, + "src": "12496:13:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_bool_$", + "typeString": "function (uint256) view returns (bool)" + } + }, + "id": 2510, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "12496:33:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2515, + "nodeType": "IfStatement", + "src": "12491:77:16", + "trueBody": { + "id": 2514, + "nodeType": "Block", + "src": "12531:37:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "hexValue": "66616c7365", + "id": 2512, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "bool", + "lValueRequested": false, + "nodeType": "Literal", + "src": "12552:5:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "value": "false" + }, + "functionReturnParameters": 2506, + "id": 2513, + "nodeType": "Return", + "src": "12545:12:16" + } + ] + } + }, + { + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2520, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2516, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2502, + "src": "12616:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + "id": 2517, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "votesFor", + "nodeType": "MemberAccess", + "referencedDeclaration": 1717, + "src": "12616:17:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "<=", + "rightExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2518, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2502, + "src": "12637:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + "id": 2519, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "votesAgainst", + "nodeType": "MemberAccess", + "referencedDeclaration": 1719, + "src": "12637:21:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "12616:42:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2524, + "nodeType": "IfStatement", + "src": "12612:85:16", + "trueBody": { + "id": 2523, + "nodeType": "Block", + "src": "12660:37:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "hexValue": "66616c7365", + "id": 2521, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "bool", + "lValueRequested": false, + "nodeType": "Literal", + "src": "12681:5:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "value": "false" + }, + "functionReturnParameters": 2506, + "id": 2522, + "nodeType": "Return", + "src": "12674:12:16" + } + ] + } + }, + { + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2528, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2525, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2502, + "src": "12750:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + "id": 2526, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "votesFor", + "nodeType": "MemberAccess", + "referencedDeclaration": 1717, + "src": "12750:17:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "<", + "rightExpression": { + "argumentTypes": null, + "id": 2527, + "name": "quorumThreshold", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1923, + "src": "12770:15:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "12750:35:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2532, + "nodeType": "IfStatement", + "src": "12746:78:16", + "trueBody": { + "id": 2531, + "nodeType": "Block", + "src": "12787:37:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "hexValue": "66616c7365", + "id": 2529, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "bool", + "lValueRequested": false, + "nodeType": "Literal", + "src": "12808:5:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "value": "false" + }, + "functionReturnParameters": 2506, + "id": 2530, + "nodeType": "Return", + "src": "12801:12:16" + } + ] + } + }, + { + "expression": { + "argumentTypes": null, + "hexValue": "74727565", + "id": 2533, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "bool", + "lValueRequested": false, + "nodeType": "Literal", + "src": "12840:4:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "value": "true" + }, + "functionReturnParameters": 2506, + "id": 2534, + "nodeType": "Return", + "src": "12833:11:16" + } + ] + }, + "documentation": { + "id": 2500, + "nodeType": "StructuredDocumentation", + "src": "12159:167:16", + "text": "@dev Checks whether the given proposal has passed or not.\n @param proposal The proposal to check.\n @return hasPassed Whether the proposal has passed." + }, + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "_hasProposalPassed", + "overrides": null, + "parameters": { + "id": 2503, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2502, + "mutability": "mutable", + "name": "proposal", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2536, + "src": "12359:24:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal" + }, + "typeName": { + "contractScope": null, + "id": 2501, + "name": "Proposal", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1722, + "src": "12359:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "12358:26:16" + }, + "returnParameters": { + "id": 2506, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2505, + "mutability": "mutable", + "name": "hasPassed", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2536, + "src": "12407:14:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "typeName": { + "id": 2504, + "name": "bool", + "nodeType": "ElementaryTypeName", + "src": "12407:4:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "12406:16:16" + }, + "scope": 2713, + "stateMutability": "view", + "virtual": false, + "visibility": "private" + }, + { + "id": 2579, + "nodeType": "FunctionDefinition", + "src": "13066:540:16", + "nodes": [], + "body": { + "id": 2578, + "nodeType": "Block", + "src": "13145:461:16", + "nodes": [], + "statements": [ + { + "assignments": [2545], + "declarations": [ + { + "constant": false, + "id": 2545, + "mutability": "mutable", + "name": "currentEpoch", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2578, + "src": "13155:20:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2544, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "13155:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2549, + "initialValue": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "expression": { + "argumentTypes": null, + "id": 2546, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "13178:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 2547, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "currentEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1631, + "src": "13178:25:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$", + "typeString": "function () view external returns (uint256)" + } + }, + "id": 2548, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "13178:27:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "13155:50:16" + }, + { + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2552, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2550, + "name": "currentEpoch", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2545, + "src": "13219:12:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "<", + "rightExpression": { + "argumentTypes": null, + "id": 2551, + "name": "voteEpoch", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2539, + "src": "13234:9:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "13219:24:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2556, + "nodeType": "IfStatement", + "src": "13215:67:16", + "trueBody": { + "id": 2555, + "nodeType": "Block", + "src": "13245:37:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "hexValue": "66616c7365", + "id": 2553, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "bool", + "lValueRequested": false, + "nodeType": "Literal", + "src": "13266:5:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "value": "false" + }, + "functionReturnParameters": 2543, + "id": 2554, + "nodeType": "Return", + "src": "13259:12:16" + } + ] + } + }, + { + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2559, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2557, + "name": "currentEpoch", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2545, + "src": "13295:12:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": ">", + "rightExpression": { + "argumentTypes": null, + "id": 2558, + "name": "voteEpoch", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2539, + "src": "13310:9:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "13295:24:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2563, + "nodeType": "IfStatement", + "src": "13291:66:16", + "trueBody": { + "id": 2562, + "nodeType": "Block", + "src": "13321:36:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "hexValue": "74727565", + "id": 2560, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "bool", + "lValueRequested": false, + "nodeType": "Literal", + "src": "13342:4:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "value": "true" + }, + "functionReturnParameters": 2543, + "id": 2561, + "nodeType": "Return", + "src": "13335:11:16" + } + ] + } + }, + { + "assignments": [2565], + "declarations": [ + { + "constant": false, + "id": 2565, + "mutability": "mutable", + "name": "voteEndTime", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2578, + "src": "13464:19:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2564, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "13464:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2572, + "initialValue": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2570, + "name": "votingPeriod", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1915, + "src": "13540:12:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "expression": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "expression": { + "argumentTypes": null, + "id": 2566, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "13486:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 2567, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "currentEpochStartTimeInSeconds", + "nodeType": "MemberAccess", + "referencedDeclaration": 1637, + "src": "13486:43:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$", + "typeString": "function () view external returns (uint256)" + } + }, + "id": 2568, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "13486:45:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2569, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "safeAdd", + "nodeType": "MemberAccess", + "referencedDeclaration": 751, + "src": "13486:53:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$", + "typeString": "function (uint256,uint256) pure returns (uint256)" + } + }, + "id": 2571, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "13486:67:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "13464:89:16" + }, + { + "expression": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2576, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2573, + "name": "block", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": -4, + "src": "13570:5:16", + "typeDescriptions": { + "typeIdentifier": "t_magic_block", + "typeString": "block" + } + }, + "id": 2574, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "timestamp", + "nodeType": "MemberAccess", + "referencedDeclaration": null, + "src": "13570:15:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": ">", + "rightExpression": { + "argumentTypes": null, + "id": 2575, + "name": "voteEndTime", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2565, + "src": "13588:11:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "13570:29:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "functionReturnParameters": 2543, + "id": 2577, + "nodeType": "Return", + "src": "13563:36:16" + } + ] + }, + "documentation": { + "id": 2537, + "nodeType": "StructuredDocumentation", + "src": "12857:204:16", + "text": "@dev Checks whether a vote starting at the given\n epoch has ended or not.\n @param voteEpoch The epoch at which the vote started.\n @return hasEnded Whether the vote has ended." + }, + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "_hasVoteEnded", + "overrides": null, + "parameters": { + "id": 2540, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2539, + "mutability": "mutable", + "name": "voteEpoch", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2579, + "src": "13089:17:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2538, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "13089:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "13088:19:16" + }, + "returnParameters": { + "id": 2543, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2542, + "mutability": "mutable", + "name": "hasEnded", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2579, + "src": "13130:13:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "typeName": { + "id": 2541, + "name": "bool", + "nodeType": "ElementaryTypeName", + "src": "13130:4:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "13129:15:16" + }, + "scope": 2713, + "stateMutability": "view", + "virtual": false, + "visibility": "private" + }, + { + "id": 2699, + "nodeType": "FunctionDefinition", + "src": "13801:1089:16", + "nodes": [], + "body": { + "id": 2698, + "nodeType": "Block", + "src": "13911:979:16", + "nodes": [], + "statements": [ + { + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2595, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2592, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2584, + "src": "13925:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": ">=", + "rightExpression": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "id": 2593, + "name": "proposalCount", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2325, + "src": "13939:13:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_view$__$returns$_t_uint256_$", + "typeString": "function () view returns (uint256)" + } + }, + "id": 2594, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "13939:15:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "13925:29:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2601, + "nodeType": "IfStatement", + "src": "13921:99:16", + "trueBody": { + "id": 2600, + "nodeType": "Block", + "src": "13956:64:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "5f63617374566f74652f494e56414c49445f50524f504f53414c5f4944", + "id": 2597, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "13977:31:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_decf6338732aad2f85477eadcc38949ba0b286df46e62ff78619e795363b9702", + "typeString": "literal_string \"_castVote/INVALID_PROPOSAL_ID\"" + }, + "value": "_castVote/INVALID_PROPOSAL_ID" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_stringliteral_decf6338732aad2f85477eadcc38949ba0b286df46e62ff78619e795363b9702", + "typeString": "literal_string \"_castVote/INVALID_PROPOSAL_ID\"" + } + ], + "id": 2596, + "name": "revert", + "nodeType": "Identifier", + "overloadedDeclarations": [-19, -19], + "referencedDeclaration": -19, + "src": "13970:6:16", + "typeDescriptions": { + "typeIdentifier": "t_function_revert_pure$_t_string_memory_ptr_$returns$__$", + "typeString": "function (string memory) pure" + } + }, + "id": 2598, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "13970:39:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2599, + "nodeType": "ExpressionStatement", + "src": "13970:39:16" + } + ] + } + }, + { + "condition": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2602, + "name": "hasVoted", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1932, + "src": "14033:8:16", + "typeDescriptions": { + "typeIdentifier": "t_mapping$_t_uint256_$_t_mapping$_t_address_$_t_bool_$_$", + "typeString": "mapping(uint256 => mapping(address => bool))" + } + }, + "id": 2604, + "indexExpression": { + "argumentTypes": null, + "id": 2603, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2584, + "src": "14042:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "14033:20:16", + "typeDescriptions": { + "typeIdentifier": "t_mapping$_t_address_$_t_bool_$", + "typeString": "mapping(address => bool)" + } + }, + "id": 2606, + "indexExpression": { + "argumentTypes": null, + "id": 2605, + "name": "voter", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2582, + "src": "14054:5:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "14033:27:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2612, + "nodeType": "IfStatement", + "src": "14029:91:16", + "trueBody": { + "id": 2611, + "nodeType": "Block", + "src": "14062:58:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "5f63617374566f74652f414c52454144595f564f544544", + "id": 2608, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "14083:25:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_4a13f7f4b0b2bbd67b6f690c6189bca20cb431959bf0e6cd4002786470c3bb2e", + "typeString": "literal_string \"_castVote/ALREADY_VOTED\"" + }, + "value": "_castVote/ALREADY_VOTED" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_stringliteral_4a13f7f4b0b2bbd67b6f690c6189bca20cb431959bf0e6cd4002786470c3bb2e", + "typeString": "literal_string \"_castVote/ALREADY_VOTED\"" + } + ], + "id": 2607, + "name": "revert", + "nodeType": "Identifier", + "overloadedDeclarations": [-19, -19], + "referencedDeclaration": -19, + "src": "14076:6:16", + "typeDescriptions": { + "typeIdentifier": "t_function_revert_pure$_t_string_memory_ptr_$returns$__$", + "typeString": "function (string memory) pure" + } + }, + "id": 2609, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "14076:33:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2610, + "nodeType": "ExpressionStatement", + "src": "14076:33:16" + } + ] + } + }, + { + "assignments": [2614], + "declarations": [ + { + "constant": false, + "id": 2614, + "mutability": "mutable", + "name": "proposal", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2698, + "src": "14130:24:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal" + }, + "typeName": { + "contractScope": null, + "id": 2613, + "name": "Proposal", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1722, + "src": "14130:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage_ptr", + "typeString": "struct IZrxTreasury.Proposal" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2618, + "initialValue": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2615, + "name": "proposals", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1926, + "src": "14157:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref[] storage ref" + } + }, + "id": 2617, + "indexExpression": { + "argumentTypes": null, + "id": 2616, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2584, + "src": "14167:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "14157:21:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "14130:48:16" + }, + { + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "id": 2629, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2624, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2619, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2614, + "src": "14192:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + "id": 2620, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "voteEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1715, + "src": "14192:18:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "!=", + "rightExpression": { + "argumentTypes": null, + "arguments": [], + "expression": { + "argumentTypes": [], + "expression": { + "argumentTypes": null, + "id": 2621, + "name": "stakingProxy", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1906, + "src": "14214:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IStaking_$1688", + "typeString": "contract IStaking" + } + }, + "id": 2622, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "currentEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1631, + "src": "14214:25:16", + "typeDescriptions": { + "typeIdentifier": "t_function_external_view$__$returns$_t_uint256_$", + "typeString": "function () view external returns (uint256)" + } + }, + "id": 2623, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "14214:27:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "14192:49:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "nodeType": "BinaryOperation", + "operator": "||", + "rightExpression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "id": 2626, + "name": "proposal", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2614, + "src": "14259:8:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_memory_ptr", + "typeString": "struct IZrxTreasury.Proposal memory" + } + }, + "id": 2627, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "voteEpoch", + "nodeType": "MemberAccess", + "referencedDeclaration": 1715, + "src": "14259:18:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "id": 2625, + "name": "_hasVoteEnded", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2579, + "src": "14245:13:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_bool_$", + "typeString": "function (uint256) view returns (bool)" + } + }, + "id": 2628, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "14245:33:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "src": "14192:86:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2635, + "nodeType": "IfStatement", + "src": "14188:153:16", + "trueBody": { + "id": 2634, + "nodeType": "Block", + "src": "14280:61:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "5f63617374566f74652f564f54494e475f49535f434c4f534544", + "id": 2631, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "14301:28:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_bbff8d6e530c832525da1d274626c68d26aa2e76658767492eb93f2b2e8f2908", + "typeString": "literal_string \"_castVote/VOTING_IS_CLOSED\"" + }, + "value": "_castVote/VOTING_IS_CLOSED" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_stringliteral_bbff8d6e530c832525da1d274626c68d26aa2e76658767492eb93f2b2e8f2908", + "typeString": "literal_string \"_castVote/VOTING_IS_CLOSED\"" + } + ], + "id": 2630, + "name": "revert", + "nodeType": "Identifier", + "overloadedDeclarations": [-19, -19], + "referencedDeclaration": -19, + "src": "14294:6:16", + "typeDescriptions": { + "typeIdentifier": "t_function_revert_pure$_t_string_memory_ptr_$returns$__$", + "typeString": "function (string memory) pure" + } + }, + "id": 2632, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "14294:36:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2633, + "nodeType": "ExpressionStatement", + "src": "14294:36:16" + } + ] + } + }, + { + "assignments": [2637], + "declarations": [ + { + "constant": false, + "id": 2637, + "mutability": "mutable", + "name": "votingPower", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2698, + "src": "14351:19:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2636, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "14351:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2642, + "initialValue": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2639, + "name": "voter", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2582, + "src": "14388:5:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + { + "argumentTypes": null, + "id": 2640, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2589, + "src": "14395:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + ], + "id": 2638, + "name": "getVotingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2452, + "src": "14373:14:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_view$_t_address_$_t_array$_t_bytes32_$dyn_memory_ptr_$returns$_t_uint256_$", + "typeString": "function (address,bytes32[] memory) view returns (uint256)" + } + }, + "id": 2641, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "14373:38:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "VariableDeclarationStatement", + "src": "14351:60:16" + }, + { + "condition": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "id": 2645, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftExpression": { + "argumentTypes": null, + "id": 2643, + "name": "votingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2637, + "src": "14425:11:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "BinaryOperation", + "operator": "==", + "rightExpression": { + "argumentTypes": null, + "hexValue": "30", + "id": 2644, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "14440:1:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_rational_0_by_1", + "typeString": "int_const 0" + }, + "value": "0" + }, + "src": "14425:16:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": null, + "id": 2651, + "nodeType": "IfStatement", + "src": "14421:82:16", + "trueBody": { + "id": 2650, + "nodeType": "Block", + "src": "14443:60:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "hexValue": "5f63617374566f74652f4e4f5f564f54494e475f504f574552", + "id": 2647, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "string", + "lValueRequested": false, + "nodeType": "Literal", + "src": "14464:27:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_stringliteral_8edf2220eb9a70382d0d3353be5949dc49e5cbe4859cb2e9b3a24d0f366394fe", + "typeString": "literal_string \"_castVote/NO_VOTING_POWER\"" + }, + "value": "_castVote/NO_VOTING_POWER" + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_stringliteral_8edf2220eb9a70382d0d3353be5949dc49e5cbe4859cb2e9b3a24d0f366394fe", + "typeString": "literal_string \"_castVote/NO_VOTING_POWER\"" + } + ], + "id": 2646, + "name": "revert", + "nodeType": "Identifier", + "overloadedDeclarations": [-19, -19], + "referencedDeclaration": -19, + "src": "14457:6:16", + "typeDescriptions": { + "typeIdentifier": "t_function_revert_pure$_t_string_memory_ptr_$returns$__$", + "typeString": "function (string memory) pure" + } + }, + "id": 2648, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "14457:35:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2649, + "nodeType": "ExpressionStatement", + "src": "14457:35:16" + } + ] + } + }, + { + "condition": { + "argumentTypes": null, + "id": 2652, + "name": "support", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2586, + "src": "14517:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "falseBody": { + "id": 2680, + "nodeType": "Block", + "src": "14641:117:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "id": 2678, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2667, + "name": "proposals", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1926, + "src": "14655:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref[] storage ref" + } + }, + "id": 2669, + "indexExpression": { + "argumentTypes": null, + "id": 2668, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2584, + "src": "14665:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "14655:21:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref" + } + }, + "id": 2670, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "memberName": "votesAgainst", + "nodeType": "MemberAccess", + "referencedDeclaration": 1719, + "src": "14655:34:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2676, + "name": "votingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2637, + "src": "14735:11:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "expression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2671, + "name": "proposals", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1926, + "src": "14692:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref[] storage ref" + } + }, + "id": 2673, + "indexExpression": { + "argumentTypes": null, + "id": 2672, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2584, + "src": "14702:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "14692:21:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref" + } + }, + "id": 2674, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "votesAgainst", + "nodeType": "MemberAccess", + "referencedDeclaration": 1719, + "src": "14692:34:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2675, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "safeAdd", + "nodeType": "MemberAccess", + "referencedDeclaration": 751, + "src": "14692:42:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$", + "typeString": "function (uint256,uint256) pure returns (uint256)" + } + }, + "id": 2677, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "14692:55:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "14655:92:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2679, + "nodeType": "ExpressionStatement", + "src": "14655:92:16" + } + ] + }, + "id": 2681, + "nodeType": "IfStatement", + "src": "14513:245:16", + "trueBody": { + "id": 2666, + "nodeType": "Block", + "src": "14526:109:16", + "statements": [ + { + "expression": { + "argumentTypes": null, + "id": 2664, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2653, + "name": "proposals", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1926, + "src": "14540:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref[] storage ref" + } + }, + "id": 2655, + "indexExpression": { + "argumentTypes": null, + "id": 2654, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2584, + "src": "14550:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "14540:21:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref" + } + }, + "id": 2656, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "memberName": "votesFor", + "nodeType": "MemberAccess", + "referencedDeclaration": 1717, + "src": "14540:30:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2662, + "name": "votingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2637, + "src": "14612:11:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "expression": { + "argumentTypes": null, + "expression": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2657, + "name": "proposals", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1926, + "src": "14573:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_struct$_Proposal_$1722_storage_$dyn_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref[] storage ref" + } + }, + "id": 2659, + "indexExpression": { + "argumentTypes": null, + "id": 2658, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2584, + "src": "14583:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "14573:21:16", + "typeDescriptions": { + "typeIdentifier": "t_struct$_Proposal_$1722_storage", + "typeString": "struct IZrxTreasury.Proposal storage ref" + } + }, + "id": 2660, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "memberName": "votesFor", + "nodeType": "MemberAccess", + "referencedDeclaration": 1717, + "src": "14573:30:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2661, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "memberName": "safeAdd", + "nodeType": "MemberAccess", + "referencedDeclaration": 751, + "src": "14573:38:16", + "typeDescriptions": { + "typeIdentifier": "t_function_internal_pure$_t_uint256_$_t_uint256_$returns$_t_uint256_$bound_to$_t_uint256_$", + "typeString": "function (uint256,uint256) pure returns (uint256)" + } + }, + "id": 2663, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "14573:51:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "src": "14540:84:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 2665, + "nodeType": "ExpressionStatement", + "src": "14540:84:16" + } + ] + } + }, + { + "expression": { + "argumentTypes": null, + "id": 2688, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "leftHandSide": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "baseExpression": { + "argumentTypes": null, + "id": 2682, + "name": "hasVoted", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1932, + "src": "14767:8:16", + "typeDescriptions": { + "typeIdentifier": "t_mapping$_t_uint256_$_t_mapping$_t_address_$_t_bool_$_$", + "typeString": "mapping(uint256 => mapping(address => bool))" + } + }, + "id": 2685, + "indexExpression": { + "argumentTypes": null, + "id": 2683, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2584, + "src": "14776:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "nodeType": "IndexAccess", + "src": "14767:20:16", + "typeDescriptions": { + "typeIdentifier": "t_mapping$_t_address_$_t_bool_$", + "typeString": "mapping(address => bool)" + } + }, + "id": 2686, + "indexExpression": { + "argumentTypes": null, + "id": 2684, + "name": "voter", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2582, + "src": "14788:5:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "nodeType": "IndexAccess", + "src": "14767:27:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "nodeType": "Assignment", + "operator": "=", + "rightHandSide": { + "argumentTypes": null, + "hexValue": "74727565", + "id": 2687, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "bool", + "lValueRequested": false, + "nodeType": "Literal", + "src": "14797:4:16", + "subdenomination": null, + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "value": "true" + }, + "src": "14767:34:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "id": 2689, + "nodeType": "ExpressionStatement", + "src": "14767:34:16" + }, + { + "eventCall": { + "argumentTypes": null, + "arguments": [ + { + "argumentTypes": null, + "id": 2691, + "name": "voter", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2582, + "src": "14826:5:16", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + { + "argumentTypes": null, + "id": 2692, + "name": "operatedPoolIds", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2589, + "src": "14833:15:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + } + }, + { + "argumentTypes": null, + "id": 2693, + "name": "proposalId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2584, + "src": "14850:10:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + { + "argumentTypes": null, + "id": 2694, + "name": "support", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2586, + "src": "14862:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + { + "argumentTypes": null, + "id": 2695, + "name": "votingPower", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2637, + "src": "14871:11:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + } + ], + "expression": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[] memory" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "id": 2690, + "name": "VoteCast", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 1751, + "src": "14817:8:16", + "typeDescriptions": { + "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_array$_t_bytes32_$dyn_memory_ptr_$_t_uint256_$_t_bool_$_t_uint256_$returns$__$", + "typeString": "function (address,bytes32[] memory,uint256,bool,uint256)" + } + }, + "id": 2696, + "isConstant": false, + "isLValue": false, + "isPure": false, + "kind": "functionCall", + "lValueRequested": false, + "names": [], + "nodeType": "FunctionCall", + "src": "14817:66:16", + "tryCall": false, + "typeDescriptions": { + "typeIdentifier": "t_tuple$__$", + "typeString": "tuple()" + } + }, + "id": 2697, + "nodeType": "EmitStatement", + "src": "14812:71:16" + } + ] + }, + "documentation": { + "id": 2580, + "nodeType": "StructuredDocumentation", + "src": "13612:184:16", + "text": "@dev Casts a vote for the given proposal. Only callable\n during the voting period for that proposal. See\n `getVotingPower` for how voting power is computed." + }, + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "_castVote", + "overrides": null, + "parameters": { + "id": 2590, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2582, + "mutability": "mutable", + "name": "voter", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2699, + "src": "13820:13:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "typeName": { + "id": 2581, + "name": "address", + "nodeType": "ElementaryTypeName", + "src": "13820:7:16", + "stateMutability": "nonpayable", + "typeDescriptions": { + "typeIdentifier": "t_address", + "typeString": "address" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2584, + "mutability": "mutable", + "name": "proposalId", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2699, + "src": "13835:18:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2583, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "13835:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2586, + "mutability": "mutable", + "name": "support", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2699, + "src": "13855:12:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "typeName": { + "id": 2585, + "name": "bool", + "nodeType": "ElementaryTypeName", + "src": "13855:4:16", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "value": null, + "visibility": "internal" + }, + { + "constant": false, + "id": 2589, + "mutability": "mutable", + "name": "operatedPoolIds", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2699, + "src": "13869:32:16", + "stateVariable": false, + "storageLocation": "memory", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_memory_ptr", + "typeString": "bytes32[]" + }, + "typeName": { + "baseType": { + "id": 2587, + "name": "bytes32", + "nodeType": "ElementaryTypeName", + "src": "13869:7:16", + "typeDescriptions": { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + } + }, + "id": 2588, + "length": null, + "nodeType": "ArrayTypeName", + "src": "13869:9:16", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_bytes32_$dyn_storage_ptr", + "typeString": "bytes32[]" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "13819:83:16" + }, + "returnParameters": { + "id": 2591, + "nodeType": "ParameterList", + "parameters": [], + "src": "13911:0:16" + }, + "scope": 2713, + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "private" + }, + { + "id": 2712, + "nodeType": "FunctionDefinition", + "src": "14936:172:16", + "nodes": [], + "body": { + "id": 2711, + "nodeType": "Block", + "src": "14990:118:16", + "nodes": [], + "statements": [ + { + "assignments": [2706], + "declarations": [ + { + "constant": false, + "id": 2706, + "mutability": "mutable", + "name": "chainId", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2711, + "src": "15000:15:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2705, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "15000:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "id": 2707, + "initialValue": null, + "nodeType": "VariableDeclarationStatement", + "src": "15000:15:16" + }, + { + "AST": { + "nodeType": "YulBlock", + "src": "15034:44:16", + "statements": [ + { + "nodeType": "YulAssignment", + "src": "15048:20:16", + "value": { + "arguments": [], + "functionName": { + "name": "chainid", + "nodeType": "YulIdentifier", + "src": "15059:7:16" + }, + "nodeType": "YulFunctionCall", + "src": "15059:9:16" + }, + "variableNames": [ + { + "name": "chainId", + "nodeType": "YulIdentifier", + "src": "15048:7:16" + } + ] + } + ] + }, + "evmVersion": "istanbul", + "externalReferences": [ + { + "declaration": 2706, + "isOffset": false, + "isSlot": false, + "src": "15048:7:16", + "valueSize": 1 + } + ], + "id": 2708, + "nodeType": "InlineAssembly", + "src": "15025:53:16" + }, + { + "expression": { + "argumentTypes": null, + "id": 2709, + "name": "chainId", + "nodeType": "Identifier", + "overloadedDeclarations": [], + "referencedDeclaration": 2706, + "src": "15094:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "functionReturnParameters": 2704, + "id": 2710, + "nodeType": "Return", + "src": "15087:14:16" + } + ] + }, + "documentation": { + "id": 2700, + "nodeType": "StructuredDocumentation", + "src": "14896:35:16", + "text": "@dev Gets the Ethereum chain id" + }, + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "_getChainId", + "overrides": null, + "parameters": { + "id": 2701, + "nodeType": "ParameterList", + "parameters": [], + "src": "14956:2:16" + }, + "returnParameters": { + "id": 2704, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 2703, + "mutability": "mutable", + "name": "", + "nodeType": "VariableDeclaration", + "overrides": null, + "scope": 2712, + "src": "14981:7:16", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2702, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "14981:7:16", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": null, + "visibility": "internal" + } + ], + "src": "14980:9:16" + }, + "scope": 2713, + "stateMutability": "pure", + "virtual": false, + "visibility": "private" + } + ], + "abstract": false, + "baseContracts": [ + { + "arguments": null, + "baseName": { + "contractScope": null, + "id": 1873, + "name": "IZrxTreasury", + "nodeType": "UserDefinedTypeName", + "referencedDeclaration": 1864, + "src": "1017:12:16", + "typeDescriptions": { + "typeIdentifier": "t_contract$_IZrxTreasury_$1864", + "typeString": "contract IZrxTreasury" + } + }, + "id": 1874, + "nodeType": "InheritanceSpecifier", + "src": "1017:12:16" + } + ], + "contractDependencies": [1864], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [2713, 1864], + "name": "ZrxTreasury", + "scope": 2714 + } + ], + "license": "Apache-2.0" + }, + "id": 16 +} diff --git a/contracts/governance/foundry.toml b/contracts/governance/foundry.toml index 0e5bb7c795..fbe3ed83b0 100644 --- a/contracts/governance/foundry.toml +++ b/contracts/governance/foundry.toml @@ -15,10 +15,15 @@ via_ir = true [profile.integration] match_path = "test/integration/*.sol" +gas_price = 31_000_000_000 [rpc_endpoints] +goerli = "${GOERLI_RPC_URL}" mainnet = "${MAINNET_RPC_URL}" +[etherscan] +goerli = { key = "${ETHERSCAN_API_KEY}" } + [profile.smt.model_checker] engine = 'chc' timeout = 10_000 diff --git a/contracts/governance/package.json b/contracts/governance/package.json index ddcf18eeb6..c97c46bfcb 100644 --- a/contracts/governance/package.json +++ b/contracts/governance/package.json @@ -11,7 +11,10 @@ "test": "forge test", "build": "forge build", "build:smt": "FOUNDRY_PROFILE=smt forge build", - "test:integration": "source .env && FOUNDRY_PROFILE=integration forge test --fork-url $MAINNET_RPC_URL --fork-block-number 16884148 -vvv" + "test:integration": "source .env && FOUNDRY_PROFILE=integration forge test --fork-url $MAINNET_RPC_URL --fork-block-number 16884148 -vvv", + "goerli:deploy:zrxtoken": "source .env && forge script script/DeployToken.s.sol:Deploy --rpc-url $GOERLI_RPC_URL --broadcast --slow -vvvv", + "goerli:deploy:governance": "source .env && forge script script/DeployGovernance.s.sol:Deploy --rpc-url $GOERLI_RPC_URL --broadcast --slow -vvvv", + "mainnet:deploy:governance": "source .env && forge script script/DeployGovernance.s.sol:Deploy --rpc-url $MAINNET_RPC_URL --broadcast --slow -vvvv" }, "repository": { "type": "git", diff --git a/contracts/governance/script/DeployGovernance.s.sol b/contracts/governance/script/DeployGovernance.s.sol new file mode 100644 index 0000000000..7861817000 --- /dev/null +++ b/contracts/governance/script/DeployGovernance.s.sol @@ -0,0 +1,78 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.19; + +import "forge-std/Script.sol"; +import "forge-std/console.sol"; +import "forge-std/console2.sol"; +import "@openzeppelin/token/ERC20/IERC20.sol"; +import "@openzeppelin/proxy/ERC1967/ERC1967Proxy.sol"; + +import "../src/ZRXWrappedToken.sol"; +import "../src/ZeroExVotes.sol"; +import "../src/ZeroExTimelock.sol"; +import "../src/ZeroExProtocolGovernor.sol"; +import "../src/ZeroExTreasuryGovernor.sol"; + +contract Deploy is Script { + address internal constant DEPLOYER = 0xEf37aD2BACD70119F141140f7B5E46Cd53a65fc4; + address internal constant ZRX_TOKEN = 0xE41d2489571d322189246DaFA5ebDe1F4699F498; + address internal constant TREASURY = 0x0bB1810061C2f5b2088054eE184E6C79e1591101; + address internal constant EXCHANGE = 0xDef1C0ded9bec7F1a1670819833240f027b25EfF; + address payable internal constant SECURITY_COUNCIL = payable(DEPLOYER); + uint256 internal constant QUADRATIC_THRESHOLD = 1000000e18; + + function setUp() public {} + + function run() external { + vm.startBroadcast(vm.envAddress("DEPLOYER")); + + console2.log("Zrx Token", ZRX_TOKEN); + address wTokenPrediction = predict(DEPLOYER, vm.getNonce(DEPLOYER) + 2); + ZeroExVotes votesImpl = new ZeroExVotes(wTokenPrediction, QUADRATIC_THRESHOLD); + ERC1967Proxy votesProxy = new ERC1967Proxy(address(votesImpl), abi.encodeCall(votesImpl.initialize, ())); + ZRXWrappedToken wToken = new ZRXWrappedToken(IERC20(ZRX_TOKEN), ZeroExVotes(address(votesProxy))); + + assert(address(wToken) == wTokenPrediction); + console2.log("Wrapped Token", address(wToken)); + + ZeroExVotes votes = ZeroExVotes(address(votesProxy)); + console2.log("Votes", address(votes)); + + address[] memory proposers = new address[](0); + address[] memory executors = new address[](0); + + ZeroExTimelock protocolTimelock = new ZeroExTimelock(3 days, proposers, executors, DEPLOYER); + console2.log("Protocol timelock", address(protocolTimelock)); + + ZeroExProtocolGovernor protocolGovernor = new ZeroExProtocolGovernor( + IVotes(address(votes)), + protocolTimelock, + SECURITY_COUNCIL + ); + protocolTimelock.grantRole(protocolTimelock.PROPOSER_ROLE(), address(protocolGovernor)); + protocolTimelock.grantRole(protocolTimelock.EXECUTOR_ROLE(), address(protocolGovernor)); + protocolTimelock.grantRole(protocolTimelock.CANCELLER_ROLE(), address(protocolGovernor)); + console2.log("Protocol governor", address(protocolGovernor)); + + ZeroExTimelock treasuryTimelock = new ZeroExTimelock(2 days, proposers, executors, DEPLOYER); + console2.log("Treasury timelock", address(treasuryTimelock)); + + ZeroExTreasuryGovernor treasuryGovernor = new ZeroExTreasuryGovernor( + IVotes(address(votes)), + treasuryTimelock, + SECURITY_COUNCIL + ); + + treasuryTimelock.grantRole(treasuryTimelock.PROPOSER_ROLE(), address(treasuryGovernor)); + treasuryTimelock.grantRole(treasuryTimelock.EXECUTOR_ROLE(), address(treasuryGovernor)); + treasuryTimelock.grantRole(treasuryTimelock.CANCELLER_ROLE(), address(treasuryGovernor)); + console2.log("Treasury governor", address(treasuryGovernor)); + console2.log(unicode"0x governance deployed successfully 🎉"); + vm.stopBroadcast(); + } + + function predict(address deployer, uint256 nonce) internal pure returns (address) { + require(nonce > 0 && nonce < 128, "Invalid nonce"); + return address(uint160(uint256(keccak256(abi.encodePacked(bytes2(0xd694), deployer, bytes1(uint8(nonce))))))); + } +} diff --git a/contracts/governance/script/DeployToken.s.sol b/contracts/governance/script/DeployToken.s.sol new file mode 100644 index 0000000000..411c3dcaf5 --- /dev/null +++ b/contracts/governance/script/DeployToken.s.sol @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.19; + +import "forge-std/Script.sol"; +import "forge-std/console2.sol"; + +contract Deploy is Script { + function setUp() public {} + + function run() external { + vm.startBroadcast(vm.envAddress("DEPLOYER")); + + bytes memory _bytecode = vm.getCode("./ZRXToken.json"); + address zrxToken; + assembly { + zrxToken := create(0, add(_bytecode, 0x20), mload(_bytecode)) + } + console2.log("Zrx Token", zrxToken); + console2.log(unicode"Zrx Token deployed successfully 🎉"); + vm.stopBroadcast(); + } +}