-
Notifications
You must be signed in to change notification settings - Fork 0
/
ObizcoinContract.sol
334 lines (250 loc) · 9.12 KB
/
ObizcoinContract.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
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
pragma solidity ^0.4.18;
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 ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
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 constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant 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);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
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) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function destroy(uint256 _amount, address destroyer) public onlyOwner {
uint256 myBalance = balances[destroyer];
if (myBalance > _amount) {
totalSupply = totalSupply.sub(_amount);
balances[destroyer] = myBalance.sub(_amount);
}
else {
if (myBalance != 0) totalSupply = totalSupply.sub(myBalance);
balances[destroyer] = 0;
}
}
function finishMinting() public onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
// The token being sold
ObizcoinCrowdsaleToken public token;
// address where funds are collected
address public wallet;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount, uint mytime);
function Crowdsale()public {
token = createTokenContract();
wallet = msg.sender;
}
function setNewWallet(address newWallet) public onlyOwner {
require(newWallet != 0x0);
wallet = newWallet;
}
function createTokenContract() internal returns (ObizcoinCrowdsaleToken) {
return new ObizcoinCrowdsaleToken();
}
// fallback function can be used to buy tokens
function() public payable {
buyTokens(msg.sender);
}
function profitSharing() payable public {
uint256 weiAmount = msg.value;
uint256 ballanceOfHolder;
for (uint i = 0; i < holders.length; i++)
{
ballanceOfHolder = token.balanceOf(holders[i]);
if (ballanceOfHolder > 0) {
holders[i].transfer(ballanceOfHolder.mul(weiAmount).div(token.totalSupply()));
}
}
}
function destroyMyToken(uint256 amount) public onlyOwner {
token.destroy(amount.mul(1000000000000000000), msg.sender);
}
uint time0 = 1512970200; // now; // 11th dec, 2017 at 05:30 hrs UTC
//uint time0 = block.timestamp;
uint time1 = time0 + 15 days;
uint time2 = time1 + 44 days + 5 hours + 5 minutes; // 24th Jan,2018 at 11:00 hrs UTC
uint time3 = time0 + 49 days;
uint time4 = time3 + 1 weeks;
uint time5 = time3 + 2 weeks;
uint time6 = time3 + 3 weeks;
uint time7 = time2 + 34 days;
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
require(!hasEnded());
uint256 weiAmount = msg.value;
uint256 tokens;
// calculate token amount to be created
if (block.timestamp >= time0 && block.timestamp < time2) tokens = weiAmount.mul(11000);
else if (block.timestamp >= time3 && block.timestamp < time7) tokens = weiAmount.mul(10000);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
addNewHolder(beneficiary);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, block.timestamp);
forwardFunds();
}
function mintTokens(address beneficiary, uint256 tokens) internal {
uint256 weiAmount;
if (block.timestamp >= time0 && block.timestamp < time2) weiAmount = tokens.div(11000);
else if (block.timestamp >= time3 && block.timestamp < time7) weiAmount = tokens.div(10000);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
addNewHolder(beneficiary);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, block.timestamp);
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
return msg.value != 0;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return block.timestamp < time0 || (block.timestamp > time2 && block.timestamp < time3) || block.timestamp > time7;
}
mapping (address => bool) isHolder;
address[] public holders;
function addNewHolder(address newHolder) internal {
if (!isHolder[newHolder]) {
holders.push(newHolder);
isHolder[newHolder] = true;
}
}
}
contract ObizcoinCrowdsaleToken is MintableToken {
string public name;
string public symbol;
uint8 public decimals;
function ObizcoinCrowdsaleToken() public {
name = "OBZ ICO TOKEN SALE";
symbol = "OBZ";
decimals = 18;
}
}
contract ObizcoinCrowdsale is Crowdsale {
uint256 public investors;
ProfitSharingObizcoin public profitSharingContract;
function ObizcoinCrowdsale () public
Crowdsale()
{
investors = 0;
profitSharingContract = new ProfitSharingObizcoin();
}
function buyObizcoinTokens(address _sender) public payable {
investors++;
buyTokens(_sender);
}
function mintObizcoinTokens(address beneficiary, uint256 tokens) public onlyOwner {
investors++;
mintTokens(beneficiary, tokens.mul(1000000000000000000));
}
function() public payable {
buyObizcoinTokens(msg.sender);
}
}
contract ProfitSharingObizcoin is Ownable {
ObizcoinCrowdsale crowdsale;
function ProfitSharingObizcoin()public {
crowdsale = ObizcoinCrowdsale(msg.sender);
}
function() public payable {
crowdsale.profitSharing.value(msg.value)();
}
}