Following is the verified source code from 0x63091244180ae240c87d1f528f5f269134cb07b3:
|
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 |
pragma solidity ^0.4.6; contract Token { bytes32 public standard; bytes32 public name; bytes32 public symbol; uint256 public totalSupply; uint8 public decimals; bool public allowTransactions; mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; function transfer(address _to, uint256 _value) returns (bool success); function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success); function approve(address _spender, uint256 _value) returns (bool success); function transferFrom(address _from, address _to, uint256 _value) returns (bool success); } contract DVIP { function feeFor(address from, address to, uint256 amount) constant external returns (uint256 value); } contract Assertive { function assert(bool assertion) { if (!assertion) throw; } } contract Owned is Assertive { address internal owner; event SetOwner(address indexed previousOwner, address indexed newOwner); function Owned () { owner = msg.sender; } modifier onlyOwner { assert(msg.sender == owner); _; } function setOwner(address newOwner) onlyOwner { SetOwner(owner, newOwner); owner = newOwner; } function getOwner() returns (address out) { return owner; } } contract Math is Assertive { function safeMul(uint a, uint b) internal returns (uint) { uint c = a * b; assert(a == 0 || 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; } } contract ExchangeWhitelist is Math, Owned { mapping (address => mapping (address => uint256)) public tokens; //mapping of token addresses to mapping of account balances struct Account { bool authorized; uint256 tier; uint256 resetWithdrawal; uint256 withdrawn; } mapping (address => Account) public accounts; mapping (address => bool) public whitelistAdmins; mapping (address => bool) public admins; //ether balances are held in the token=0 account mapping (bytes32 => uint256) public orderFills; address public feeAccount; address public dvipAddress; address public feeMakeExporter; address public feeTakeExporter; event Order(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s); event Cancel(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s); event Trade(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, address get, address give, bytes32 hash); event Deposit(address token, address user, uint256 amount, uint256 balance); event Withdraw(address token, address user, uint256 amount, uint256 balance); function ExchangeWhitelist(address feeAccount_, address dvipAddress_) { feeAccount = feeAccount_; dvipAddress = dvipAddress_; feeMakeExporter = 0x00000000000000000000000000000000000000f7; feeTakeExporter = 0x00000000000000000000000000000000000000f8; } function setFeeAccount(address feeAccount_) onlyOwner { feeAccount = feeAccount_; } function setDVIP(address dvipAddress_) onlyOwner { dvipAddress = dvipAddress_; } function setAdmin(address admin, bool isAdmin) onlyOwner { admins[admin] = isAdmin; } function setWhitelister(address whitelister, bool isWhitelister) onlyOwner { whitelistAdmins[whitelister] = isWhitelister; } modifier onlyWhitelister { if (!whitelistAdmins[msg.sender]) throw; _; } modifier onlyAdmin { if (msg.sender != owner && !admins[msg.sender]) throw; _; } function setWhitelisted(address target, bool isWhitelisted) onlyWhitelister { accounts[target].authorized = isWhitelisted; } modifier onlyWhitelisted { if (!accounts[msg.sender].authorized) throw; _; } function() { throw; } function deposit(address token, uint256 amount) payable { if (token == address(0)) { tokens[address(0)][msg.sender] = safeAdd(tokens[address(0)][msg.sender], msg.value); } else { if (msg.value != 0) throw; tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount); if (!Token(token).transferFrom(msg.sender, this, amount)) throw; } Deposit(token, msg.sender, amount, tokens[token][msg.sender]); } function withdraw(address token, uint256 amount) { if (tokens[token][msg.sender] < amount) throw; tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount); if (token == address(0)) { if (!msg.sender.send(amount)) throw; } else { if (!Token(token).transfer(msg.sender, amount)) throw; } Withdraw(token, msg.sender, amount, tokens[token][msg.sender]); } function balanceOf(address token, address user) constant returns (uint256) { return tokens[token][user]; } uint256 internal feeTake; uint256 internal feeMake; uint256 internal feeTerm; function trade(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s, uint256 amount) onlyWhitelisted { //amount is in amountBuy terms bytes32 hash = sha3(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user); if (!( ecrecover(hash,v,r,s) == user && block.number <= expires && safeAdd(orderFills[hash], amount) <= amountBuy && tokens[tokenBuy][msg.sender] >= amount && tokens[tokenSell][user] >= safeMul(amountSell, amount) / amountBuy )) throw; feeMake = DVIP(dvipAddress).feeFor(feeMakeExporter, msg.sender, 1 ether); feeTake = DVIP(dvipAddress).feeFor(feeTakeExporter, user, 1 ether); tokens[tokenBuy][msg.sender] = safeSub(tokens[tokenBuy][msg.sender], amount); feeTerm = safeMul(amount, ((1 ether) - feeMake)) / (1 ether); tokens[tokenBuy][user] = safeAdd(tokens[tokenBuy][user], feeTerm); feeTerm = safeMul(amount, feeMake) / (1 ether); tokens[tokenBuy][feeAccount] = safeAdd(tokens[tokenBuy][feeAccount], feeTerm); feeTerm = safeMul(amountSell, amount) / amountBuy; tokens[tokenSell][user] = safeSub(tokens[tokenSell][user], feeTerm); feeTerm = safeMul(safeMul(((1 ether) - feeTake), amountSell), amount) / amountBuy / (1 ether); tokens[tokenSell][msg.sender] = safeAdd(tokens[tokenSell][msg.sender], feeTerm); feeTerm = safeMul(safeMul(feeTake, amountSell), amount) / amountBuy / (1 ether); tokens[tokenSell][feeAccount] = safeAdd(tokens[tokenSell][feeAccount], feeTerm); orderFills[hash] = safeAdd(orderFills[hash], amount); Trade(tokenBuy, amount, tokenSell, amountSell * amount / amountBuy, user, msg.sender, hash); } bytes32 internal testHash; uint256 internal amountSelln; function testTrade(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s, uint256 amount, address sender) constant returns (uint8 code) { testHash = sha3(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user); if (tokens[tokenBuy][sender] < amount) return 1; if (!accounts[sender].authorized) return 2; if (!accounts[user].authorized) return 3; if (ecrecover(testHash, v, r, s) != user) return 4; amountSelln = safeMul(amountSell, amount) / amountBuy; if (tokens[tokenSell][user] < amountSelln) return 5; if (block.number > expires) return 6; if (safeAdd(orderFills[testHash], amount) > amountBuy) return 7; return 0; } function cancelOrder(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, uint8 v, bytes32 r, bytes32 s, address user) { bytes32 hash = sha3(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user); if (ecrecover(hash,v,r,s) != msg.sender) throw; orderFills[hash] = amountBuy; Cancel(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, msg.sender, v, r, s); } } |