1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
pragma solidity ^0.4.11;
import "../Oracles/Oracle.sol";
import "../Tokens/Token.sol";
import "../Utils/Math.sol";
/// @title Ultimate oracle contract - Allows to swap oracle result for ultimate oracle result
/// @author Stefan George - <stefan@gnosis.pm>
contract UltimateOracle is Oracle {
using Math for *;
/*
* Events
*/
event ForwardedOracleOutcomeAssignment(int outcome);
event OutcomeChallenge(address indexed sender, int outcome);
event OutcomeVote(address indexed sender, int outcome, uint amount);
event Withdrawal(address indexed sender, uint amount);
/*
* Storage
*/
Oracle public forwardedOracle;
Token public collateralToken;
uint8 public spreadMultiplier;
uint public challengePeriod;
uint public challengeAmount;
uint public frontRunnerPeriod;
int public forwardedOutcome;
uint public forwardedOutcomeSetTimestamp;
int public frontRunner;
uint public frontRunnerSetTimestamp;
uint public totalAmount;
mapping (int => uint) public totalOutcomeAmounts;
mapping (address => mapping (int => uint)) public outcomeAmounts;
/*
* Public functions
*/
/// @dev Constructor sets ultimate oracle properties
/// @param _forwardedOracle Oracle address
/// @param _collateralToken Collateral token address
/// @param _spreadMultiplier Defines the spread as a multiple of the money bet on other outcomes
/// @param _challengePeriod Time to challenge oracle outcome
/// @param _challengeAmount Amount to challenge the outcome
/// @param _frontRunnerPeriod Time to overbid the front-runner
constructor(
Oracle _forwardedOracle,
Token _collateralToken,
uint8 _spreadMultiplier,
uint _challengePeriod,
uint _challengeAmount,
uint _frontRunnerPeriod
)
public
{
// Validate inputs
require( address(_forwardedOracle) != address(0)
&& address(_collateralToken) != address(0)
&& _spreadMultiplier >= 2
&& _challengePeriod > 0
&& _challengeAmount > 0
&& _frontRunnerPeriod > 0);
forwardedOracle = _forwardedOracle;
collateralToken = _collateralToken;
spreadMultiplier = _spreadMultiplier;
challengePeriod = _challengePeriod;
challengeAmount = _challengeAmount;
frontRunnerPeriod = _frontRunnerPeriod;
}
/// @dev Allows to set oracle outcome
function setForwardedOutcome()
public
{
// There was no challenge and the outcome was not set yet in the ultimate oracle but in the forwarded oracle
require( !isChallenged()
&& forwardedOutcomeSetTimestamp == 0
&& forwardedOracle.isOutcomeSet());
forwardedOutcome = forwardedOracle.getOutcome();
forwardedOutcomeSetTimestamp = now;
emit ForwardedOracleOutcomeAssignment(forwardedOutcome);
}
/// @dev Allows to challenge the oracle outcome
/// @param _outcome Outcome to bid on
function challengeOutcome(int _outcome)
public
{
// There was no challenge yet or the challenge period expired
require( !isChallenged()
&& !isChallengePeriodOver()
&& collateralToken.transferFrom(msg.sender, this, challengeAmount));
outcomeAmounts[msg.sender][_outcome] = challengeAmount;
totalOutcomeAmounts[_outcome] = challengeAmount;
totalAmount = challengeAmount;
frontRunner = _outcome;
frontRunnerSetTimestamp = now;
emit OutcomeChallenge(msg.sender, _outcome);
}
/// @dev Allows to challenge the oracle outcome
/// @param _outcome Outcome to bid on
/// @param amount Amount to bid
function voteForOutcome(int _outcome, uint amount)
public
{
uint maxAmount = (totalAmount - totalOutcomeAmounts[_outcome]).mul(spreadMultiplier);
if (amount > maxAmount)
amount = maxAmount;
// Outcome is challenged and front runner period is not over yet and tokens can be transferred
require( isChallenged()
&& !isFrontRunnerPeriodOver()
&& collateralToken.transferFrom(msg.sender, this, amount));
outcomeAmounts[msg.sender][_outcome] = outcomeAmounts[msg.sender][_outcome].add(amount);
totalOutcomeAmounts[_outcome] = totalOutcomeAmounts[_outcome].add(amount);
totalAmount = totalAmount.add(amount);
if (_outcome != frontRunner && totalOutcomeAmounts[_outcome] > totalOutcomeAmounts[frontRunner])
{
frontRunner = _outcome;
frontRunnerSetTimestamp = now;
}
emit OutcomeVote(msg.sender, _outcome, amount);
}
/// @dev Withdraws winnings for user
/// @return Winnings
function withdraw()
public
returns (uint amount)
{
// Outcome was challenged and ultimate outcome decided
require(isFrontRunnerPeriodOver());
amount = totalAmount.mul(outcomeAmounts[msg.sender][frontRunner]) / totalOutcomeAmounts[frontRunner];
outcomeAmounts[msg.sender][frontRunner] = 0;
// Transfer earnings to contributor
require(collateralToken.transfer(msg.sender, amount));
emit Withdrawal(msg.sender, amount);
}
/// @dev Checks if time to challenge the outcome is over
/// @return Is challenge period over?
function isChallengePeriodOver()
public
returns (bool)
{
return forwardedOutcomeSetTimestamp != 0 && now.sub(forwardedOutcomeSetTimestamp) > challengePeriod;
}
/// @dev Checks if time to overbid the front runner is over
/// @return Is front runner period over?
function isFrontRunnerPeriodOver()
public
returns (bool)
{
return frontRunnerSetTimestamp != 0 && now.sub(frontRunnerSetTimestamp) > frontRunnerPeriod;
}
/// @dev Checks if outcome was challenged
/// @return Is challenged?
function isChallenged()
public
returns (bool)
{
return frontRunnerSetTimestamp != 0;
}
/// @dev Returns if winning outcome is set
/// @return Is outcome set?
function isOutcomeSet()
public
constant
returns (bool)
{
return isChallengePeriodOver() && !isChallenged()
|| isFrontRunnerPeriodOver();
}
/// @dev Returns winning outcome
/// @return Outcome
function getOutcome()
public
constant
returns (int)
{
if (isFrontRunnerPeriodOver())
return frontRunner;
return forwardedOutcome;
}
}
|
