-
Notifications
You must be signed in to change notification settings - Fork 0
/
bitpointToken.sol
171 lines (134 loc) · 4.29 KB
/
bitpointToken.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
pragma solidity 0.4.11;
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender != owner) throw;
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract Bitpoint is owned,SafeMath
{
string public constant symbol = "BPT";
string public constant name = "Bitpoint Token";
uint256 public totalSupply;
//TODO wei to eur
uint256 eurval = 4;
uint256 profitForuser;
uint256 profitForContract;
uint256 ethertosend;
mapping (address => uint256) balances;
mapping (address => uint256) withdrawn;
event TokenMinted(address _for, uint256 _value);
event Withdraws(address from, uint256 _value);
event Transfer(address to,address from, uint256 _value);
event TokenBurned( uint256 _value);
function () payable {
uint amount = msg.value;
//TODO convert amount to EUR
amount = safeMul(amount,eurval);
balances[msg.sender] = balances[msg.sender] + amount;
totalSupply =totalSupply + amount;
TokenMinted(msg.sender,amount);
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function withdrawnFrom(address _owner) constant returns (uint256 balance) {
return withdrawn[_owner];
}
//return unix timestamp
// function creationTime(address _owner) constant returns (uint256 createdOn) {
// return balances[_owner].createdOn;
// }
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function getTotalSupply() constant returns (uint) // this doesn't have anything to do with the act of greeting
{
return totalSupply;
}
//AtM calls withdraw, to is address of customer to which ether to be send
function withdraw (uint256 value, address from, address to) onlyOwner {
// withdraw will
if (balances[from] < value){
return;
}
profitForuser = value * 4/100;
profitForContract = value * 1/100;
value = value - profitForuser;
value = value - profitForContract;
totalSupply = totalSupply + profitForContract;
balances[from] = balances[from] - value;
withdrawn[from] = withdrawn[from] + value;
Withdraws(from,value);
balances[from] = balances[from] + profitForuser;
//send ether to address
ethertosend = value/eurval;
to.transfer(ethertosend);
}
//ATM deposit ether back to contract
function deposit (uint256 value, address to)onlyOwner payable{
uint amount = value;
//TODO convert amount to EUR
amount = amount * eurval;
balances[to] = balances[to] + amount;
totalSupply = totalSupply+amount;
withdrawn[to] = withdrawn[to] - amount;
TokenMinted(to,amount);
}
function kill()
{
if (msg.sender == owner)
suicide(owner); // kills this contract and sends remaining funds back to creator
}
}