API tools faq
paste
Guest User

Oracle Smart contract

a guest
Mar 13th, 2020
198
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 31.18 KB | None | 0 0
raw download clone embed print report
  1. pragma solidity ^ 0.6.4;
  2. pragma experimental ABIEncoderV2;
  3.  
  4. contract Oracle{
  5. address payable ORACLE = address(0);
  6. address address0 = address(0);
  7.  
  8. struct Poll{
  9. uint8 dataType; // string, uint, bool, address
  10.  
  11. //commit
  12. mapping(address => bool) committed;
  13. mapping(address => bytes) commitHash;
  14.  
  15. //reveal
  16. mapping(address => bool) revealed;
  17. mapping(address => bool) rejected;
  18. mapping(address => bool) voted;
  19.  
  20. mapping(address => string) stringVotes;
  21. mapping(address => uint) uintVotes;
  22. mapping(address => bool) boolVotes;
  23. mapping(address => address) addressVotes;
  24. }
  25.  
  26. struct RequestTicket{
  27. uint ID;
  28. address sender;
  29. string query;
  30. uint timeRequested;
  31. bool finalized;
  32. Poll poll;
  33. uint txCoverageFee;
  34. uint serviceFee;
  35. bool needsResponse;
  36.  
  37. bool rejected;
  38. string resolvedString;
  39. uint resolvedUint;
  40. bool resolvedBool;
  41. address resolvedAddress;
  42.  
  43. mapping(address => bool) punished;
  44. }
  45.  
  46. //oracle configs
  47. uint constant ROUNDTABLE_SEATS = 0;
  48. uint constant COMMIT_TIME_WINDOW = 1;
  49. uint constant REVEAL_TIME_WINDOW = 2;
  50. uint constant DELEGATE_REWARDSHARE = 3;
  51. uint constant ELECTORATE_REWARDSHARE = 4;
  52. uint constant FREEZE_TIMEOUT = 5;
  53. uint constant TX_FEE_PER = 6;
  54. uint constant SERVICE_FEE = 7;
  55. uint constant CONFIGS = 8;
  56.  
  57. uint[] oracleConfigurations = new uint[](CONFIGS);
  58. mapping(uint/*configID*/ => mapping(uint => uint) ) public totalVotes_forEach_configOption;
  59. mapping(uint/*configID*/ => mapping(address => uint) ) public individualsSelectedOption;
  60.  
  61. mapping(address => uint) resolveWeight;
  62. mapping(address => uint) weightLocked;
  63.  
  64. RequestTicket[] requestTickets;
  65. //ROUND TABLE & Candidates
  66. mapping(uint => address) public chairsCandidate; // only looks at the first X indexes
  67. mapping(address => uint) candidatesChair;
  68. mapping(address => uint) timeSeated; // watchers aren't responsible for requestTickets that came in before them
  69. mapping(address => bool) frozen;
  70. mapping(address => uint) timeWhenThawedOut;
  71. mapping(address => bool) paused; // self pause
  72. mapping(address => bool) hasChair;
  73. uint chairs;
  74. uint public hotSeats;
  75.  
  76. uint256 constant scaleFactor = 0x10000000000000000;
  77. //PAYROLL
  78. mapping(address => uint) earnings;
  79. mapping(address => uint) totalShares;
  80. mapping(address => mapping(address => uint256)) public shares;
  81. mapping(address => mapping(address => uint256)) payouts;
  82. mapping(address => uint) earningsPerShare;
  83.  
  84. //Tx Coverage fee
  85. uint earningsPerWatcher;
  86. uint totalWatchers;
  87. mapping(address => uint256) watcherPayouts;
  88.  
  89.  
  90. //lazy UI data
  91. mapping(address => address[]) public yourBacking;
  92. mapping(address => mapping(address => bool)) public alreadyBacking;
  93.  
  94. ResolveToken resolveToken;
  95.  
  96. constructor(address _resolve) public{
  97. resolveToken = ResolveToken(_resolve);
  98. }
  99.  
  100. function addressPayable(address addr) public pure returns(address payable){
  101. return address(uint160(addr));
  102. }
  103.  
  104. function addShares(address pool, address account, uint amount) internal{
  105. update(pool, addressPayable(account));
  106. totalShares[pool] += amount;
  107. shares[pool][account] += amount;
  108.  
  109. if(pool == ORACLE){
  110. updateWatcherTxEarnings(addressPayable(account));
  111. totalWatchers += 1;
  112. }
  113. }
  114.  
  115. function removeShares(address pool, address account, uint amount) internal{
  116. update(pool, addressPayable(account));
  117. totalShares[pool] -= amount;
  118. shares[pool][account] -= amount;
  119.  
  120. if(pool == ORACLE){
  121. updateWatcherTxEarnings(addressPayable(account));
  122. totalWatchers -= 1;
  123. }
  124. }
  125.  
  126. event Cashout(address account, uint amount);
  127. event WatcherPayroll(address watcher, uint paidOut);
  128. function update(address pool, address payable account) internal {
  129. uint owedPerShare = earningsPerShare[pool] - payouts[pool][account];
  130. uint newMoney = shares[pool][account] * owedPerShare;
  131. payouts[pool][account] = earningsPerShare[pool];
  132.  
  133. if(pool == ORACLE){
  134. uint drs = oracleConfigurations[DELEGATE_REWARDSHARE];
  135. uint ers = oracleConfigurations[ELECTORATE_REWARDSHARE];
  136. uint eth4Watcher = newMoney *drs/(drs+ers);
  137. earnings[account] += eth4Watcher/scaleFactor;
  138. earningsPerShare[account] += (newMoney - eth4Watcher)/totalShares[account];
  139. emit Cashout(account, eth4Watcher/scaleFactor);
  140. emit WatcherPayroll(account, (newMoney - eth4Watcher)/totalShares[account]);
  141. }else{
  142. earnings[account] += newMoney/scaleFactor;
  143. emit Cashout(account, newMoney/scaleFactor);
  144. }
  145. }
  146.  
  147. event TxCashout(address watcher, uint amount);
  148. function updateWatcherTxEarnings(address payable watcher) internal {
  149. uint owed = earningsPerWatcher - watcherPayouts[watcher];
  150. watcherPayouts[watcher] = earningsPerWatcher;
  151. earnings[watcher] += owed;
  152. emit TxCashout(watcher, owed);
  153. }
  154.  
  155. event StakeResolves( address indexed addr, uint256 amountStaked, bytes _data );
  156. function tokenFallback(address from, uint value, bytes calldata _data) external{
  157. if(msg.sender == address(resolveToken) ){
  158. resolveWeight[from] += value;
  159. //update option totals
  160. uint option;
  161. for(uint8 config = 0;config<CONFIGS;config+=1){
  162. option = individualsSelectedOption[config][from];
  163. totalVotes_forEach_configOption[config][option] += value;
  164. assertOption(config, option);
  165. }
  166.  
  167. emit StakeResolves(from, value, _data);
  168. }else{
  169. revert();
  170. }
  171. }
  172.  
  173. event UnstakeResolves(address sender, uint amount);
  174. function unstakeResolves(uint amount) public{
  175. address sender = msg.sender;
  176. if( amount <= ( resolveWeight[sender] - weightLocked[sender] ) ){
  177. resolveWeight[sender] -= amount;
  178. for(uint config = 0; config<CONFIGS; config+=1){
  179. totalVotes_forEach_configOption[config][individualsSelectedOption[config][sender]] -= amount;
  180. }
  181. emit UnstakeResolves(sender, amount);
  182. resolveToken.transfer(sender, amount);
  183. }else{
  184. revert();
  185. }
  186. }
  187.  
  188. event BackCandidate(address sender,address candidate, uint amount);
  189. function backCandidate(address candidate, uint amount, bool _assert) public{
  190. address sender = msg.sender;
  191. require(candidate!=ORACLE);
  192. if( amount <= ( resolveWeight[sender] - weightLocked[sender] ) && !isWatcher(candidate) ){
  193. weightLocked[sender] += amount;
  194. addShares(candidate, sender, amount);
  195. //I guess candidates should be able to opt into pausing themselves instead of being cast as a delegate right away.
  196. //Idk where else to write this comment
  197. //If the candidate isn't seated, and freezing and pause isn't preventing them from being seated ... then assertCandidate()
  198. if( candidatesChair[candidate] >= hotSeats && !frausted(candidate) && _assert){
  199. assertCandidate(candidate);
  200. }
  201. emit BackCandidate(sender, candidate, amount);
  202. //LAZY U.I.
  203. if(!alreadyBacking[sender][candidate]){
  204. yourBacking[sender].push(candidate);
  205. alreadyBacking[sender][candidate] = true;
  206. }
  207. }else{
  208. revert();
  209. }
  210. }
  211.  
  212. event WithdrawBacking(address sender,address candidate, uint amount);
  213. function withdrawBacking(address candidate, uint amount) public{
  214. address sender = msg.sender;
  215. if( amount <= shares[candidate][sender] && !frozen[candidate] && ( !(candidatesChair[candidate]<hotSeats) || paused[candidate] ) ){
  216. weightLocked[sender] -= amount;
  217. removeShares(candidate, sender, amount);
  218. emit WithdrawBacking(sender, candidate, amount);
  219. }else{
  220. revert();
  221. }
  222. }
  223.  
  224. function frausted(address candidate) public view returns(bool){
  225. return paused[candidate] || frozen[candidate];
  226. }
  227.  
  228. event AssertCandidate(address candidate, bool asserted, address replacedWatcher, uint newSeat);
  229. function assertCandidate(address candidate) public returns(bool){
  230. if(candidatesChair[candidate] >= hotSeats && candidate != ORACLE && !frausted(candidate) ){
  231. address weakestLink = chairsCandidate[0];
  232. bool thereIsAFraustedDelegate;
  233. uint chairNumber;
  234. address comparedDelegate;
  235. for(uint i = 0; i<hotSeats; i+=1){
  236. comparedDelegate = chairsCandidate[i];
  237.  
  238. if(thereIsAFraustedDelegate && frausted(comparedDelegate) ){
  239. if( totalShares[comparedDelegate] < totalShares[weakestLink] ){
  240. weakestLink = comparedDelegate;
  241. chairNumber = i;
  242. }
  243. }else{
  244. if( frausted(comparedDelegate) ){
  245. thereIsAFraustedDelegate = true;
  246. weakestLink = comparedDelegate;
  247. chairNumber = i;
  248. }else if( totalShares[comparedDelegate] < totalShares[weakestLink] ){
  249. weakestLink = comparedDelegate;
  250. chairNumber = i;
  251. }
  252. }
  253. }
  254. //check if we can swap out seated watcher & then swap 'em
  255. if( totalShares[candidate] > totalShares[weakestLink] || thereIsAFraustedDelegate ){
  256. uint theChairForTheLoser;
  257.  
  258. if(hasChair[candidate]){
  259. theChairForTheLoser = candidatesChair[candidate];
  260. }else{
  261. hasChair[candidate] = true;
  262. theChairForTheLoser = chairs;
  263. chairs += 1;
  264. }
  265.  
  266. //###
  267. //old candidate getting bumped
  268. removeShares(ORACLE, weakestLink, totalShares[weakestLink]);
  269. candidatesChair[ weakestLink ] = theChairForTheLoser;
  270. chairsCandidate[theChairForTheLoser] = weakestLink;
  271.  
  272. //new candidate sitting at the round table
  273. addShares(ORACLE, candidate, totalShares[candidate]);
  274. chairsCandidate[chairNumber] = candidate;
  275. candidatesChair[candidate] = chairNumber;
  276. emit AssertCandidate(candidate, true, weakestLink, chairNumber);
  277. return true;
  278. }else{
  279. if(!hasChair[candidate]){
  280. hasChair[candidate] = true;
  281. candidatesChair[candidate] = chairs;
  282. chairsCandidate[chairs] = candidate;
  283. emit AssertCandidate(candidate, false, address0, chairs);
  284. chairs+=1;
  285. return false;
  286. }else{
  287. revert();
  288. }
  289. }
  290. }else{
  291. revert();
  292. }
  293. }
  294.  
  295. event OptionVote(address sender, uint8 config, uint option, uint weight);
  296. function optionVote(bool[] memory isModifying, uint[] memory modifiedOptions) public{
  297. address sender = msg.sender;
  298. for(uint8 config = 0; config<CONFIGS; config+=1){
  299. if(isModifying[config]){
  300. uint selectedOption = individualsSelectedOption[config][sender];
  301. totalVotes_forEach_configOption[config][ selectedOption ] -= resolveWeight[sender];
  302. individualsSelectedOption[config][sender] = modifiedOptions[config];
  303. totalVotes_forEach_configOption[config][ modifiedOptions[config] ] += resolveWeight[sender];
  304. emit OptionVote(sender, config, modifiedOptions[config], resolveWeight[sender]);
  305. assertOption( config, modifiedOptions[config] );
  306. }
  307. }
  308. }
  309.  
  310. event AssertOption(uint8 config, uint option);
  311. function assertOption(uint8 config, uint option) public{
  312. if( totalVotes_forEach_configOption[config][option] > totalVotes_forEach_configOption[config][ oracleConfigurations[config] ] ){
  313. oracleConfigurations[config] = option;
  314. emit AssertOption(config, option);
  315.  
  316. }
  317. }
  318.  
  319. function isWatcher(address candidate) public view returns(bool){
  320. return candidatesChair[candidate]<hotSeats && !frausted(candidate);
  321. }
  322.  
  323. function getFee() public view returns(uint txCoverageFee, uint serviceFee){
  324. uint activeWatchers;
  325. for(uint chair = 0; chair<hotSeats; chair+=1){
  326. if( !frausted(chairsCandidate[chair]) ){
  327. activeWatchers += 1;
  328. }
  329. }
  330. return ( TX_FEE_PER*activeWatchers, oracleConfigurations[SERVICE_FEE] );
  331. }
  332. //------------------------------ Request Ticket Life Cycle
  333. event FileRequestTicket(address sender, uint ticketID, string query, uint timeRequested, uint8 dataType, uint feePaid);
  334. function fileRequestTicket(string memory query, uint8 returnType, bool needsResponse) public payable returns(uint ticketID){
  335. uint ETH = msg.value;
  336. (uint txCoverageFee, uint serviceFee) = getFee();
  337. if(ETH == txCoverageFee + serviceFee ){
  338. RequestTicket memory ticket;
  339. ticket.query = query;
  340. ticket.timeRequested = now;
  341. ticket.ID = requestTickets.length;
  342. ticket.sender = msg.sender;
  343. ticket.needsResponse = needsResponse;
  344.  
  345. Poll memory poll;
  346. if(returnType>3)
  347. returnType = 3;
  348. poll.dataType = returnType;
  349.  
  350. ticket.poll = poll;
  351. requestTickets.push(ticket);
  352.  
  353. ticket.txCoverageFee = txCoverageFee;
  354. ticket.serviceFee = serviceFee;
  355. emit FileRequestTicket(msg.sender, ticketID, query, now, returnType, ETH);
  356. return ticket.ID;
  357. }else{
  358. revert();
  359. }
  360. }
  361.  
  362. event CommitVote(address sender, bytes hash);
  363. function commitVote(uint[] memory tickets, bytes[] memory voteHashes) public{
  364. address sender = msg.sender;
  365. //RequestTicket storage ticket;
  366. for(uint R; R<tickets.length; R+=1 ){
  367. //ticket = requestTickets[ tickets[R] ];
  368. if(now <= requestTickets[ tickets[R] ].timeRequested + oracleConfigurations[COMMIT_TIME_WINDOW] ){
  369. requestTickets[ tickets[R] ].poll.committed[sender] = true;
  370. requestTickets[ tickets[R] ].poll.commitHash[sender] = voteHashes[R];
  371. emit CommitVote(sender, voteHashes[R]);
  372. }
  373. }
  374. }
  375.  
  376. event RevealVote(address voter, uint ticketID, bool rejected, /*suba*/ string stringVote, uint uintVote, bool boolVote, address addressVote);
  377. function revealVote(uint[] memory tickets, bool[] memory rejected, string[] memory stringVotes, uint[] memory uintVotes, bool[] memory boolVotes, address[] memory addressVotes, string[] memory passwords) public{
  378. address sender = msg.sender;
  379. RequestTicket memory ticket;
  380. bytes memory abiEncodePacked;
  381. for(uint R; R<tickets.length; R+=1 ){
  382. ticket = requestTickets[ tickets[R] ];
  383. if(now > ticket.timeRequested + oracleConfigurations[COMMIT_TIME_WINDOW] && now <= ticket.timeRequested + oracleConfigurations[COMMIT_TIME_WINDOW] + oracleConfigurations[REVEAL_TIME_WINDOW] ){
  384. if(ticket.poll.dataType == 0){
  385. abiEncodePacked = abi.encodePacked( rejected[R], stringVotes[R], passwords[R] );
  386. }else if(ticket.poll.dataType == 1){
  387. abiEncodePacked = abi.encodePacked( rejected[R], uintVotes[R], passwords[R] );
  388. }else if(ticket.poll.dataType == 2){
  389. abiEncodePacked = abi.encodePacked( rejected[R], boolVotes[R], passwords[R] );
  390. }else if(ticket.poll.dataType == 3){
  391. abiEncodePacked = abi.encodePacked( rejected[R], addressVotes[R], passwords[R] );
  392. }
  393.  
  394. if( compareBytes( abiEncodePacked, requestTickets[ tickets[R] ].poll.commitHash[sender]) ){
  395. requestTickets[ tickets[R] ].poll.revealed[sender] = true;
  396. if(rejected[R]){
  397. requestTickets[ tickets[R] ].poll.rejected[sender] = true;
  398. }else{
  399. requestTickets[ tickets[R] ].poll.voted[sender] = true;
  400. if(ticket.poll.dataType == 0){
  401. requestTickets[ tickets[R] ].poll.stringVotes[sender] = stringVotes[R];
  402. }else if(ticket.poll.dataType == 1){
  403. requestTickets[ tickets[R] ].poll.uintVotes[sender] = uintVotes[R];
  404. }else if(ticket.poll.dataType == 2){
  405. requestTickets[ tickets[R] ].poll.boolVotes[sender] = boolVotes[R];
  406. }else if(ticket.poll.dataType == 3){
  407. requestTickets[ tickets[R] ].poll.addressVotes[sender] = addressVotes[R];
  408. }
  409. }
  410. emit RevealVote(sender, tickets[R], rejected[R], stringVotes[R], uintVotes[R], boolVotes[R], addressVotes[R]);
  411. }
  412. }
  413. }
  414. }
  415.  
  416. event FinalizedRequestOptions(string[] stringOptions, uint[] uintOptions, bool[] boolOptions, address[] addressOptions, address[] watchers);
  417. function finalizeRequest(uint ticketID) public{
  418. // if response time window is over or all delegates have voted,
  419. // anyone can finalize the request to trigger the event
  420. RequestTicket storage ticket = requestTickets[ticketID];
  421. if(!ticket.finalized){
  422. uint totalEligibleWeight;
  423. address watcher;
  424. //uint WEIGHTS[0];
  425. //uint WEIGHTS[1];
  426. uint[] memory WEIGHTS = new uint[](2);//0 weight of votes | 1 weight of rejections
  427.  
  428. string[] memory stringOptions = new string[](hotSeats);
  429. uint[] memory uintOptions = new uint[](hotSeats);
  430. bool[] memory boolOptions = new bool[](hotSeats);
  431. address[] memory addressOptions = new address[](hotSeats);
  432.  
  433. uint[] memory optionWeights = new uint[](hotSeats);
  434.  
  435. address[] memory watchers = new address[](hotSeats);// LAZY UI data
  436.  
  437. //uint options;
  438. uint[] memory OPT = new uint[](2);//0= number of options, 1=top Option
  439. //uint weight;
  440. //uint topOption;
  441. uint opt;
  442. for(uint chair = 0; chair < hotSeats; chair+=1){
  443. watcher = chairsCandidate[chair];
  444. watchers[chair] = watcher;
  445. //weight = totalShares[watcher];
  446. if( !frausted(watcher) && timeSeated[watcher] <= ticket.timeRequested ){
  447. totalEligibleWeight += totalShares[watcher];
  448. if(ticket.poll.voted[watcher]){
  449. WEIGHTS[0] += totalShares[watcher];
  450.  
  451. //check to see if chosen option already is accounted for, if so, add weight to it.
  452. for(opt = 0; opt<OPT[0]; opt+=1){
  453. if( (ticket.poll.dataType == 0 && compareStrings(stringOptions[opt],ticket.poll.stringVotes[watcher]) ) ||
  454. (ticket.poll.dataType == 1 && uintOptions[opt] == ticket.poll.uintVotes[watcher]) ||
  455. (ticket.poll.dataType == 2 && boolOptions[opt] == ticket.poll.boolVotes[watcher]) ||
  456. (ticket.poll.dataType == 3 && addressOptions[opt] == ticket.poll.addressVotes[watcher])
  457. ){
  458. optionWeights[opt] += totalShares[watcher];
  459. if(optionWeights[opt] > optionWeights[OPT[1]]){
  460. OPT[1] = opt;
  461. }
  462. break;
  463. }
  464. }
  465.  
  466. //add new unique option
  467. if(opt == OPT[0]){
  468. if(ticket.poll.dataType == 0){
  469. stringOptions[OPT[0]] = ticket.poll.stringVotes[watcher];
  470. }else if(ticket.poll.dataType == 1){
  471. uintOptions[OPT[0]] = ticket.poll.uintVotes[watcher];
  472. }else if(ticket.poll.dataType == 2){
  473. boolOptions[OPT[0]] = ticket.poll.boolVotes[watcher];
  474. }else if(ticket.poll.dataType == 3){
  475. addressOptions[OPT[0]] = ticket.poll.addressVotes[watcher];
  476. }
  477. optionWeights[OPT[0]] = totalShares[watcher];
  478. OPT[0]+=1;
  479. }
  480. }else if(ticket.poll.rejected[watcher]){
  481. WEIGHTS[1] += totalShares[watcher];
  482. }
  483. }
  484. }
  485.  
  486. if( totalEligibleWeight == (WEIGHTS[1] + WEIGHTS[0]) || now > ticket.timeRequested+oracleConfigurations[REVEAL_TIME_WINDOW]+oracleConfigurations[COMMIT_TIME_WINDOW] ){
  487. bool rejected;
  488. if( WEIGHTS[1] > optionWeights[OPT[1]] ){
  489. rejected = true;
  490. }
  491.  
  492. //dish out the rewards
  493. earningsPerShare[ORACLE] += ticket.serviceFee * scaleFactor / totalShares[ORACLE];
  494. earningsPerWatcher += ticket.txCoverageFee / totalWatchers;
  495.  
  496. //write results in stone
  497. if(rejected){
  498. ticket.rejected = true;
  499. }else{
  500. uint8 dataType = ticket.poll.dataType;
  501. if(dataType == 0){
  502. ticket.resolvedString = stringOptions[OPT[1]];
  503. }else if(dataType == 1){
  504. ticket.resolvedUint = uintOptions[OPT[1]];
  505. }else if(dataType == 2){
  506. ticket.resolvedBool = boolOptions[OPT[1]];
  507. }else if(dataType == 3){
  508. ticket.resolvedAddress = addressOptions[OPT[1]];
  509. }
  510. }
  511.  
  512. ticket.finalized = true;
  513. EMIT_FinalizeRequestData(ticket);
  514. emit FinalizedRequestOptions( stringOptions, uintOptions, boolOptions, addressOptions, watchers);
  515. //return results to requestor
  516. if( Common.isContract(ticket.sender) && ticket.needsResponse){
  517. sendOracleResponse(ticket);
  518. }
  519. }else{
  520. revert();
  521. }
  522. }
  523. }
  524.  
  525. event FinalizedRequestTicketData(uint ticketID, string query, uint8 dataType, bool rejected, string resolvedString, uint resolvedUint, bool resolvedBool, address resolvedAddress);
  526. function EMIT_FinalizeRequestData(RequestTicket storage ticket) internal{
  527. FinalizedRequestTicketData(ticket.ID, ticket.query, ticket.poll.dataType, ticket.rejected, ticket.resolvedString, ticket.resolvedUint, ticket.resolvedBool, ticket.resolvedAddress);
  528. }
  529.  
  530. function sendOracleResponse(RequestTicket memory ticket) internal{
  531. address(ticket.sender).call(abi.encodeWithSignature("receiveOracleResponse(bool,string,uint,bool,address)",ticket.rejected, ticket.resolvedString,ticket.resolvedUint,ticket.resolvedBool,ticket.resolvedAddress ) );
  532. }
  533.  
  534. function cashout(address[] memory pools) public{
  535. address payable sender = msg.sender;
  536. for(uint p; p < pools.length; p+=1){
  537. update(pools[p], sender);
  538. }
  539. uint ETH = earnings[sender];
  540. earnings[sender] = 0;
  541. sender.transfer( ETH );
  542. }
  543.  
  544. function runWatcherPayroll(address watcher) public{
  545. update(ORACLE, addressPayable(watcher) );
  546. updateWatcherTxEarnings(addressPayable(watcher) );
  547. }
  548.  
  549. function tryToPunish(uint[] memory tickets, address[] memory watchers) public{
  550. freezeNoncommits(tickets, watchers);
  551. freezeUnrevealedCommits(tickets, watchers);
  552. freezeWrongWatchers(tickets, watchers);
  553. }
  554.  
  555. event FreezeNoncommits(uint ticketID, address watcher);
  556. function freezeNoncommits(uint[] memory tickets, address[] memory watchers) public{
  557. // get them while they're still at the round table and we're in the reveal phase of a ticket
  558. for(uint i; i<watchers.length; i+=1){
  559. if( candidatesChair[watchers[i]] < hotSeats &&
  560. !requestTickets[ tickets[i] ].poll.committed[ watchers[i] ] &&
  561. now > requestTickets[ tickets[i] ].timeRequested + oracleConfigurations[COMMIT_TIME_WINDOW] &&
  562. now <= requestTickets[ tickets[i] ].timeRequested + oracleConfigurations[COMMIT_TIME_WINDOW] + oracleConfigurations[REVEAL_TIME_WINDOW]
  563. ){
  564. if(punish(tickets[i] , watchers[i]) ){
  565. emit FreezeNoncommits(tickets[i] , watchers[i]);
  566. }
  567. }
  568. }
  569. }
  570.  
  571. event FreezeUnrevealedCommits(uint ticketID, address watcher);
  572. function freezeUnrevealedCommits(uint[] memory tickets, address[] memory watchers) public{
  573. // get them if they made a commit, but did not reveal it after the reveal window is over
  574. for(uint i; i<watchers.length; i+=1){
  575. if( requestTickets[ tickets[i] ].poll.committed[ watchers[i] ] &&
  576. !requestTickets[ tickets[i] ].poll.revealed[ watchers[i] ] &&
  577. now > requestTickets[ tickets[i] ].timeRequested + oracleConfigurations[COMMIT_TIME_WINDOW] + oracleConfigurations[REVEAL_TIME_WINDOW]
  578. ){
  579. if(punish(tickets[i] , watchers[i]) ){
  580. emit FreezeUnrevealedCommits(tickets[i] , watchers[i]);
  581. }
  582. }
  583. }
  584. }
  585.  
  586. event FreezeWrongWatchers(uint ticketID, address watcher);
  587. function freezeWrongWatchers(uint[] memory tickets, address[] memory watchers) public{
  588. // get them if the ticket is finalized and their vote doesn't match the resolved answer
  589. uint ticket;
  590. address watcher;
  591. for(uint i; i<watchers.length; i+=1){
  592. ticket = tickets[i];
  593. watcher = watchers[i];
  594. if( requestTickets[ ticket ].finalized &&
  595. (
  596. (requestTickets[ ticket ].poll.dataType == 0 && !compareStrings(requestTickets[ ticket ].resolvedString, requestTickets[ ticket ].poll.stringVotes[ watcher ] ))||
  597. (requestTickets[ ticket ].poll.dataType == 1 && requestTickets[ ticket ].resolvedUint != requestTickets[ ticket ].poll.uintVotes[ watcher ] )||
  598. (requestTickets[ ticket ].poll.dataType == 2 && requestTickets[ ticket ].resolvedBool != requestTickets[ ticket ].poll.boolVotes[ watcher ] )||
  599. (requestTickets[ ticket ].poll.dataType == 3 && requestTickets[ ticket ].resolvedAddress != requestTickets[ ticket ].poll.addressVotes[ watcher ] )
  600. )
  601. ){
  602. if(punish(ticket , watcher)){
  603. emit FreezeWrongWatchers(ticket , watcher);
  604. }
  605. }
  606. }
  607. }
  608.  
  609. event Punish(uint thatOutTime, bool freshFreeze, bool knockOff);
  610. function punish(uint ticketID, address watcher) internal returns(bool punished){
  611. if(!requestTickets[ticketID].punished[watcher] && timeSeated[watcher] <= requestTickets[ ticketID ].timeRequested ){
  612. frozen[watcher] = true;
  613. bool freshFreeze;
  614. bool knockOff;
  615. if(timeWhenThawedOut[watcher] > now){
  616. timeWhenThawedOut[watcher] += oracleConfigurations[FREEZE_TIMEOUT];
  617. }else{
  618. timeWhenThawedOut[watcher] = now + oracleConfigurations[FREEZE_TIMEOUT];
  619. freshFreeze = true;
  620. if(isWatcher(watcher)){
  621. //###
  622. removeShares(ORACLE, watcher, totalShares[watcher]);
  623. knockOff = true;
  624. }
  625. }
  626. emit Punish(timeWhenThawedOut[watcher], freshFreeze, knockOff);
  627. return true;
  628. }
  629. return false;
  630. }
  631.  
  632. event Thaw(address candidate, bool seated);
  633. function thaw(address candidate, bool _assert) public{
  634. if( now >= timeWhenThawedOut[candidate] ){
  635. bool seated;
  636. frozen[candidate] = false;
  637. if( candidatesChair[candidate] < hotSeats && !paused[candidate]){
  638. //###
  639. addShares(ORACLE, candidate, totalShares[candidate]);
  640. seated = true;
  641. }else if( _assert ){
  642. seated = assertCandidate(candidate);
  643. }
  644. emit Thaw(candidate, seated);
  645. }else{
  646. revert();
  647. }
  648. }
  649.  
  650. event PauseOut(address sender, bool wasWatcher);
  651. function pauseOut() public{
  652. address sender = msg.sender;
  653. bool wasWatcher;
  654. if(isWatcher(sender)){
  655. wasWatcher = true;
  656. //###
  657. removeShares(ORACLE, sender, totalShares[sender]);
  658. }
  659. paused[sender] = true;
  660. emit PauseOut(sender, wasWatcher);
  661. }
  662.  
  663. event Unpause(address sender, bool seated);
  664. function unpause(bool _assert) public{
  665. address sender = msg.sender;
  666. paused[sender] = false;
  667. bool seated;
  668. if( candidatesChair[sender] < hotSeats && !frozen[sender]){
  669. //###
  670. addShares(ORACLE, sender, totalShares[sender]);
  671. seated = true;
  672. }else if( _assert ){
  673. seated = assertCandidate(sender);
  674. }
  675. emit Unpause(sender, seated);
  676.  
  677. }
  678.  
  679. event UpdateRoundTable(uint newTotalHotSeats);
  680. function updateRoundTable(uint seats) public{
  681. // update hotSeats up and down.
  682. address candidate;
  683. for(uint s; s<seats; s+=1){
  684. if( oracleConfigurations[ROUNDTABLE_SEATS] > hotSeats ){
  685. candidate = chairsCandidate[hotSeats];
  686. if(candidate == address0){
  687. break;
  688. }else{
  689. //###
  690. addShares(ORACLE, candidate, totalShares[candidate]);
  691. hotSeats += 1;
  692. }
  693. }
  694. if( oracleConfigurations[ROUNDTABLE_SEATS] < hotSeats ){
  695. candidate = chairsCandidate[hotSeats-1];
  696. //###
  697. removeShares(ORACLE, candidate, totalShares[candidate]);
  698. hotSeats -= 1;
  699. }
  700. if( oracleConfigurations[ROUNDTABLE_SEATS] == hotSeats ){break;}
  701. }
  702. emit UpdateRoundTable(hotSeats);
  703. }
  704.  
  705. function viewRequestTickets(uint[] memory ticketIDs) public view returns(
  706. address[] memory sender,
  707. string[] memory query,
  708. uint[] memory timeRequested,
  709. bool[] memory finalized,
  710. uint[] memory txCoverageFeePaid,
  711. uint[] memory serviceFeePaid,
  712. bool[] memory rejected,
  713. string[] memory resolvedString,
  714. uint[] memory resolvedUint,
  715. bool[] memory resolvedBool,
  716. address[] memory resolvedAddress,
  717. uint8[] memory dataType){
  718.  
  719. uint L = ticketIDs.length;
  720.  
  721. sender = new address[](L);
  722. query = new string[](L);
  723. timeRequested = new uint[](L);
  724. finalized = new bool[](L);
  725. txCoverageFeePaid = new uint[](L);
  726. serviceFeePaid = new uint[](L);
  727. rejected = new bool[](L);
  728. resolvedString = new string[](L);
  729. resolvedUint = new uint[](L);
  730. resolvedBool = new bool[](L);
  731. resolvedAddress = new address[](L);
  732. dataType = new uint8[](L);
  733. for(uint t; t<L;t+=1){
  734. sender[t] = requestTickets[t].sender;
  735. query[t] = requestTickets[t].query;
  736. timeRequested[t] = requestTickets[t].timeRequested;
  737. finalized[t] = requestTickets[t].finalized;
  738. txCoverageFeePaid[t] = requestTickets[t].txCoverageFee;
  739. serviceFeePaid[t] = requestTickets[t].serviceFee;
  740. rejected[t] = requestTickets[t].rejected;
  741. resolvedString[t] = requestTickets[t].resolvedString;
  742. resolvedUint[t] = requestTickets[t].resolvedUint;
  743. resolvedBool[t] = requestTickets[t].resolvedBool;
  744. resolvedAddress[t] = requestTickets[t].resolvedAddress;
  745. dataType[t] = requestTickets[t].poll.dataType;
  746. }
  747. //return (ticket.sender, ticket.query,ticket.timeRequested,ticket.finalized,ticket.ETH,ticket.rejected,ticket.resolvedString,ticket.resolvedUint,ticket.resolvedBool,ticket.resolvedAddress,ticket.poll.dataType);
  748. }
  749. function viewYourCandidates(address you)public view returns(uint[] memory dividends, uint[] memory seat, bool[] memory isFrozen, bool[] memory isPaused){
  750. uint L = yourBacking[you].length;
  751. dividends = new uint[](L);
  752. seat = new uint[](L);
  753. isFrozen = new bool[](L);
  754. isPaused = new bool[](L);
  755. uint owedPerShare;// = earningsPerShare[pool] - payouts[pool][account];
  756. uint newMoney;// = shares[pool][account] * owedPerShare;
  757.  
  758. address candidate;
  759. for(uint c;c<L;c+=1){
  760. candidate = yourBacking[you][c];
  761. owedPerShare = earningsPerShare[candidate] - payouts[candidate][you];
  762. newMoney = shares[candidate][you] * owedPerShare;
  763. dividends[c] = newMoney;
  764. seat[c] = candidatesChair[candidate];
  765. isFrozen[c] = frozen[candidate];
  766. isPaused[c] = paused[candidate];
  767. }
  768. }
  769.  
  770. function compareStrings(string memory a, string memory b) public pure returns (bool) {
  771. return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))) );
  772. }
  773. function compareBytes(bytes memory a, bytes memory b) public pure returns (bool) {
  774. return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))) );
  775. }
  776.  
  777. function accountData(address account) public view returns(
  778. uint _resolveWeight,
  779. uint _weightLocked,
  780. uint _candidatesChair,
  781. uint _timeSeated,
  782. bool _frozen,
  783. uint _timeWhenThawedOut,
  784. bool _paused,
  785. bool _hasChair,
  786. uint _earnings,
  787. uint _totalShares,
  788. uint _txCoverageFeeEarnings
  789. ){
  790. _resolveWeight = resolveWeight[account];
  791. _weightLocked = weightLocked[account];
  792. _candidatesChair = candidatesChair[account];
  793. _timeSeated = timeSeated[account];
  794. _frozen = frozen[account];
  795. _timeWhenThawedOut = timeWhenThawedOut[account];
  796. _paused = paused[account];
  797. _hasChair = hasChair[account];
  798. _earnings = earnings[account];
  799. _totalShares = totalShares[account];
  800. uint txCoverageFeeEarnings;
  801. if( !isWatcher(account) ){
  802. txCoverageFeeEarnings = earningsPerWatcher - watcherPayouts[account];
  803. }
  804. _txCoverageFeeEarnings = txCoverageFeeEarnings;
  805. }
  806. }
  807.  
  808. abstract contract OracleInterfacingContract{
  809. function receiveOracleResponse(bool rejected, string calldata STRING, uint UINT, bool BOOL, address ADDRESS) external virtual returns(bool);
  810. }
  811.  
  812. abstract contract ResolveToken{
  813. function transfer(address _to, uint256 _value) public virtual returns (bool);
  814. }
  815.  
  816. /**
  817. * @title Common
  818. * @dev Math operations with safety checks that throw on error
  819. */
  820. library Common {
  821. /**
  822. * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  823. */
  824. function subtract(uint256 a, uint256 b) internal pure returns (uint256) {
  825. assert(b <= a);
  826. return a - b;
  827. }
  828.  
  829. //assemble the given address bytecode. If bytecode exists then the _addr is a contract.
  830. function isContract(address _addr) public view returns (bool is_contract) {
  831. uint length;
  832. assembly {
  833. //retrieve the size of the code on target address, this needs assembly
  834. length := extcodesize(_addr)
  835. }
  836. if(length>0) {
  837. return true;
  838. }else {
  839. return false;
  840. }
  841. }
  842. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!