The first transaction 0x64438300… was submitted in block 3798640 at May-31-2017 02:24:35 PM +UTC.
From batICOData.tsv, 99.9995827118343% of the 156250 ETH was contributed in the first 3 blocks to 3798642 at Wed, 31 May 2017 14:25:29 UTC.
The last non-zero transaction 0x62901c72… was executed in block 3798720 at Wed, 31 May 2017 14:42:47 UTC.
The ICO was mainly over in less than a minute, and raised 156,250 ethers (~USD 35,957,812.50 @ $230.13/ETH). A total of 1,500,000,000 tokens were created.
366,350,000 tokens were allocated to the BATFund at 0x88e2efac3d2ef957fcd82ec201a506871ad06204 before the ICO commenced. This is after 133,650,00 tokens have already been moved from the BATFund to 0x67fa2c06c9c6d4332f330e14a66bdf1873ef3d2b – the total tokens reserved for the BATFund is 500,000,000 (33.33% of total supply), as can be seen in the smart contract code below. None of these BATFund tokens are frozen for any period of time.
And the 156,250 ethers have been moved to the ETHFundDeposit at 0xac2fa512db158f44f5ee2fa5766ea7c282763cdb in transaction 0x9c15ab19….
From the token smart contract source code, each 1 ETH will purchase 6,400 BAT tokens. 1 ETH = 6,400 BAT. So 1 BAT = 0.00015625 ETH.
At an ETH/USD rate of 230.13, 6,400 BAT = 230.13 . So 1 BAT = 0.0359578125 USD.
At the current ETH/BTC rate of 0.10027100, 6,400 BAT = 0.10027100 BTC. So 1 BAT = 0.00001566734375 BTC.
Following are a few of the complaints in the forums about the Basic Attention Token ICO:
- BAT token crowdsale over in seconds… what went wrong
- BAT ICO-don’t even bother
- Why BAT is a Terrible Long-Term Investment
- The Top 100 holders collectively own 99.07% (1,486,103,341.00 Tokens) of BAT
- BAT ICO Whale-Sale – Completely Against the Ethos of Ethereum and Cryptocurrency
And from 0x0D8775F648430679A709E98d2b0Cb6250d2887EF:
From https://etherscan.io/token/tokenholderchart/BAT, the top 100 holders collectively own 99.00% (1,484,982,091.00 Tokens) of BAT, out of 201 token holders:
And from https://etherscan.io/token/BAT#balances, the top token holder is the BATFund that owns 366,350,000 tokens (24.42333%), followed by the next token holder holding 133,650,000 tokens (8.91%), but this is part of the BATFund. The 3rd largest token holder holds 131,343,494.4 tokens (8.75623%) funded by 20,522.421 ETH (~USD 4,646,070.89) in transaction 0x06e61f46… :
The source code for the smart contract at 0x0D8775F648430679A709E98d2b0Cb6250d2887EF follows:
|
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 |
pragma solidity ^0.4.10; /* taking ideas from FirstBlood token */ contract SafeMath { /* function assert(bool assertion) internal { */ /* if (!assertion) { */ /* throw; */ /* } */ /* } // assert no longer needed once solidity is on 0.4.10 */ function safeAdd(uint256 x, uint256 y) internal returns(uint256) { uint256 z = x + y; assert((z >= x) && (z >= y)); return z; } function safeSubtract(uint256 x, uint256 y) internal returns(uint256) { assert(x >= y); uint256 z = x - y; return z; } function safeMult(uint256 x, uint256 y) internal returns(uint256) { uint256 z = x * y; assert((x == 0)||(z/x == y)); return z; } } contract Token { uint256 public totalSupply; function balanceOf(address _owner) constant returns (uint256 balance); function transfer(address _to, uint256 _value) returns (bool success); function transferFrom(address _from, address _to, uint256 _value) returns (bool success); function approve(address _spender, uint256 _value) returns (bool success); function allowance(address _owner, address _spender) constant returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } /* ERC 20 token */ contract StandardToken is Token { 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 transferFrom(address _from, address _to, uint256 _value) returns (bool success) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; } contract BAToken is StandardToken, SafeMath { // metadata string public constant name = "Basic Attention Token"; string public constant symbol = "BAT"; uint256 public constant decimals = 18; string public version = "1.0"; // contracts address public ethFundDeposit; // deposit address for ETH for Brave International address public batFundDeposit; // deposit address for Brave International use and BAT User Fund // crowdsale parameters bool public isFinalized; // switched to true in operational state uint256 public fundingStartBlock; uint256 public fundingEndBlock; uint256 public constant batFund = 500 * (10**6) * 10**decimals; // 500m BAT reserved for Brave Intl use uint256 public constant tokenExchangeRate = 6400; // 6400 BAT tokens per 1 ETH uint256 public constant tokenCreationCap = 1500 * (10**6) * 10**decimals; uint256 public constant tokenCreationMin = 675 * (10**6) * 10**decimals; // events event LogRefund(address indexed _to, uint256 _value); event CreateBAT(address indexed _to, uint256 _value); // constructor function BAToken( address _ethFundDeposit, address _batFundDeposit, uint256 _fundingStartBlock, uint256 _fundingEndBlock) { isFinalized = false; //controls pre through crowdsale state ethFundDeposit = _ethFundDeposit; batFundDeposit = _batFundDeposit; fundingStartBlock = _fundingStartBlock; fundingEndBlock = _fundingEndBlock; totalSupply = batFund; balances[batFundDeposit] = batFund; // Deposit Brave Intl share CreateBAT(batFundDeposit, batFund); // logs Brave Intl fund } /// @dev Accepts ether and creates new BAT tokens. function createTokens() payable external { if (isFinalized) throw; if (block.number < fundingStartBlock) throw; if (block.number > fundingEndBlock) throw; if (msg.value == 0) throw; uint256 tokens = safeMult(msg.value, tokenExchangeRate); // check that we're not over totals uint256 checkedSupply = safeAdd(totalSupply, tokens); // return money if something goes wrong if (tokenCreationCap < checkedSupply) throw; // odd fractions won't be found totalSupply = checkedSupply; balances[msg.sender] += tokens; // safeAdd not needed; bad semantics to use here CreateBAT(msg.sender, tokens); // logs token creation } /// @dev Ends the funding period and sends the ETH home function finalize() external { if (isFinalized) throw; if (msg.sender != ethFundDeposit) throw; // locks finalize to the ultimate ETH owner if(totalSupply < tokenCreationMin) throw; // have to sell minimum to move to operational if(block.number <= fundingEndBlock && totalSupply != tokenCreationCap) throw; // move to operational isFinalized = true; if(!ethFundDeposit.send(this.balance)) throw; // send the eth to Brave International } /// @dev Allows contributors to recover their ether in the case of a failed funding campaign. function refund() external { if(isFinalized) throw; // prevents refund if operational if (block.number <= fundingEndBlock) throw; // prevents refund until sale period is over if(totalSupply >= tokenCreationMin) throw; // no refunds if we sold enough if(msg.sender == batFundDeposit) throw; // Brave Intl not entitled to a refund uint256 batVal = balances[msg.sender]; if (batVal == 0) throw; balances[msg.sender] = 0; totalSupply = safeSubtract(totalSupply, batVal); // extra safe uint256 ethVal = batVal / tokenExchangeRate; // should be safe; previous throws covers edges LogRefund(msg.sender, ethVal); // log it if (!msg.sender.send(ethVal)) throw; // if you're using a contract; make sure it works with .send gas limits } } |