-
Notifications
You must be signed in to change notification settings - Fork 0
/
PromiseToken.sol
253 lines (203 loc) · 7.27 KB
/
PromiseToken.sol
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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
pragma solidity ^0.4.18;
/**
* OpenZeppelin contracts (Mintable & Burnable + dependenices)
*/
import './Ownable.sol';
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
/**
* Promise (WORD) Token Code:
*/
contract PromiseToken is MintableToken, BurnableToken {
string public name = 'Promise';
string public symbol = 'WORD';
uint public decimals = 0;
uint public INITIAL_SUPPLY = 10000000;
address public coreAddress;
address public genieAddress;
uint public mintPercent = 50;
uint public burnPercent = 10;
function PromiseToken() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
coreAddress = msg.sender;
genieAddress = msg.sender;
}
function setCoreAddress(address newAddress) onlyOwner public returns(bool) {
coreAddress = newAddress;
}
function getCoreAddress() public view returns(address) {
return coreAddress;
}
function setGenieAddress(address newAddress) onlyOwner public returns(bool) {
genieAddress = newAddress;
}
function getGenieAddress() public view returns(address) {
return genieAddress;
}
function setMintPercent(uint newMintPercent) onlyOwner public returns(bool) {
mintPercent = newMintPercent;
}
function setBurnPercent(uint newBurnPercent) onlyOwner public returns(bool) {
burnPercent = newBurnPercent;
}
/**
* @dev Throws if called by any account other than the coreAddress (PromiseRegister)
*/
modifier onlyCore() {
require(msg.sender == coreAddress);
_;
}
function promiseProposed(address _from, uint _value) onlyCore public returns (bool) {
require(_value <= balances[_from]);
balances[_from] = balances[_from].sub(_value);
balances[genieAddress] = balances[genieAddress].add(_value);
return true;
}
function promiseRejected(address _from, uint _value) onlyCore public returns (bool) {
balances[_from] = balances[_from].add(_value);
balances[genieAddress] = balances[genieAddress].sub(_value);
return true;
}
function promiseBroken(address _to, uint _value) onlyCore public returns (bool) {
balances[_to] = balances[_to].add(_value/100*(100-burnPercent));
balances[genieAddress] = balances[genieAddress].sub(_value/100*(100-burnPercent));
totalSupply = totalSupply.sub(_value/100*burnPercent);
Burn(genieAddress, _value/100*burnPercent);
return true;
}
function promiseKept(address promiser, address promisee, uint _value) onlyCore public returns (bool) {
balances[promiser] = balances[promiser].add(_value);
balances[genieAddress] = balances[genieAddress].sub(_value);
promiseMint(promiser, _value/200*mintPercent);
promiseMint(promisee, _value/200*mintPercent);
return true;
}
function promiseMint(address _to, uint _amount) onlyCore public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function promiseBurned(uint _value) onlyCore public returns (bool) {
balances[genieAddress] = balances[genieAddress].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(genieAddress, _value);
}
}