forked from FLASHMONILTD/OZT
-
Notifications
You must be signed in to change notification settings - Fork 0
/
OZTToken.sol
191 lines (151 loc) · 6.16 KB
/
OZTToken.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
pragma solidity 0.4.23;
import "./StandardToken.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
contract OZTToken is StandardToken, Ownable {
/* Overriding some ERC20 variables */
string public constant name = "OZTToken";
string public constant symbol = "OZT";
uint256 public constant decimals = 18;
uint256 public constant MAX_NUM_OZT_TOKENS = 730000000 * 10 ** decimals;
// Freeze duration for Advisors accounts
uint256 public constant START_ICO_TIMESTAMP = 1526565600; // ICO starts at 17.05.2018 @ 2PM UTC
int public constant DEFROST_MONTH_IN_MINUTES = 43200; // month in minutes
int public constant DEFROST_MONTHS = 3;
/*
modalités de sorties des advisors investisseurs ou des earlybirds j’opte pour
- un Freeze à 6 mois puis au bout du 6ème mois
- possible de sortir du capital de 50% du montant investi
- puis par la suite 5% tous les mois ce qui nous donnera une sortie effective au bout de 10 mois et au total ça fera donc 16 mois
*/
uint public constant DEFROST_FACTOR = 20;
// Fields that can be changed by functions
address[] public vIcedBalances;
mapping (address => uint256) public icedBalances_frosted;
mapping (address => uint256) public icedBalances_defrosted;
// Variable usefull for verifying that the assignedSupply matches that totalSupply
uint256 public assignedSupply;
//Boolean to allow or not the initial assignement of token (batch)
bool public batchAssignStopped = false;
bool public stopDefrost = false;
uint oneTokenWeiPrice;
address defroster;
function OZTToken() {
owner = msg.sender;
assignedSupply = 0;
// mint all tokens
totalSupply = MAX_NUM_OZT_TOKENS;
balances[msg.sender] = MAX_NUM_OZT_TOKENS;
Transfer(address(0x0), msg.sender, MAX_NUM_OZT_TOKENS);
}
function setDefroster(address addr) onlyOwner {
defroster = addr;
}
modifier onlyDefrosterOrOwner() {
require(msg.sender == defroster || msg.sender == owner);
_;
}
/**
* @dev Transfer tokens in batches (of adresses)
* @param _vaddr address The address which you want to send tokens from
* @param _vamounts address The address which you want to transfer to
*/
function batchAssignTokens(address[] _vaddr, uint[] _vamounts, uint[] _vDefrostClass ) onlyOwner {
require ( batchAssignStopped == false );
require ( _vaddr.length == _vamounts.length && _vaddr.length == _vDefrostClass.length);
//Looping into input arrays to assign target amount to each given address
for (uint index=0; index<_vaddr.length; index++) {
address toAddress = _vaddr[index];
uint amount = SafeMath.mul(_vamounts[index], 10 ** decimals);
uint defrostClass = _vDefrostClass[index]; // 0=ico investor, 1=reserveandteam/advisors
if ( defrostClass == 0 ) {
// investor account
transfer(toAddress, amount);
assignedSupply = SafeMath.add(assignedSupply, amount);
}
else if(defrostClass == 1){
// Iced account. The balance is not affected here
vIcedBalances.push(toAddress);
icedBalances_frosted[toAddress] = amount;
icedBalances_defrosted[toAddress] = 0;
assignedSupply = SafeMath.add(assignedSupply, amount);
}
}
}
function getBlockTimestamp() constant returns (uint256){
return now;
}
function getAssignedSupply() constant returns (uint256){
return assignedSupply;
}
function elapsedMonthsFromICOStart() constant returns (int elapsed) {
elapsed = (int(now-START_ICO_TIMESTAMP)/60)/DEFROST_MONTH_IN_MINUTES;
}
function getDefrostFactor()constant returns (uint){
return DEFROST_FACTOR;
}
function lagDefrost()constant returns (int){
return DEFROST_MONTHS;
}
function canDefrost() constant returns (bool){
int numMonths = elapsedMonthsFromICOStart();
return numMonths > DEFROST_MONTHS &&
uint(numMonths) <= SafeMath.add(uint(DEFROST_MONTHS), DEFROST_FACTOR/2+1);
}
function defrostTokens(uint fromIdx, uint toIdx) onlyDefrosterOrOwner {
require(now>START_ICO_TIMESTAMP);
require(stopDefrost == false);
require(fromIdx>=0 && toIdx<=vIcedBalances.length);
if(fromIdx==0 && toIdx==0){
fromIdx = 0;
toIdx = vIcedBalances.length;
}
int monthsElapsedFromFirstDefrost = elapsedMonthsFromICOStart() - DEFROST_MONTHS;
require(monthsElapsedFromFirstDefrost>0);
uint monthsIndex = uint(monthsElapsedFromFirstDefrost);
//require(monthsIndex<=DEFROST_FACTOR);
require(canDefrost() == true);
/*
if monthsIndex == 1 => defrost 50%
else if monthsIndex <= 10 defrost 5%
*/
// Looping into the iced accounts
for (uint index = fromIdx; index < toIdx; index++) {
address currentAddress = vIcedBalances[index];
uint256 amountTotal = SafeMath.add(icedBalances_frosted[currentAddress], icedBalances_defrosted[currentAddress]);
uint256 targetDeFrosted = 0;
uint256 fivePercAmount = SafeMath.div(amountTotal, DEFROST_FACTOR);
if(monthsIndex==1){
targetDeFrosted = SafeMath.mul(fivePercAmount, 10); // 10 times 5% = 50%
}else{
targetDeFrosted = SafeMath.mul(fivePercAmount, 10) + SafeMath.div(SafeMath.mul(monthsIndex-1, amountTotal), DEFROST_FACTOR);
}
uint256 amountToRelease = SafeMath.sub(targetDeFrosted, icedBalances_defrosted[currentAddress]);
if (amountToRelease > 0 && targetDeFrosted > 0) {
icedBalances_frosted[currentAddress] = SafeMath.sub(icedBalances_frosted[currentAddress], amountToRelease);
icedBalances_defrosted[currentAddress] = SafeMath.add(icedBalances_defrosted[currentAddress], amountToRelease);
transfer(currentAddress, amountToRelease);
}
}
}
function getStartIcoTimestamp() constant returns (uint) {
return START_ICO_TIMESTAMP;
}
function stopBatchAssign() onlyOwner {
require ( batchAssignStopped == false);
batchAssignStopped = true;
}
function getAddressBalance(address addr) constant returns (uint256 balance) {
balance = balances[addr];
}
function getAddressAndBalance(address addr) constant returns (address _address, uint256 _amount) {
_address = addr;
_amount = balances[addr];
}
function setStopDefrost() onlyOwner {
stopDefrost = true;
}
function killContract() onlyOwner {
selfdestruct(owner);
}
}