Bat crowdsale 智能合约

Basic attention token是Brave团队发行的用于新型区块链广告系统的流通货币,它是这个生态中关于广告主、发行商和用户之间交换价值的货币呈现。用户因自身的注意力而获得代币收益(Brave系统会通过一系列技术指标衡量);广告主可以购买bat,用于支付他们广告展示和优质注意力、交互反馈的获取;而发行商,将会获得广告主的支付,也会由于其优质的内容而获得用户的bat支付。

u=1976890326,3278379513&fm=23&gp=0.jpg

合约地址

https://github.com/brave-intl/basic-attention-token-crowdsale/tree/master/contracts

代码说明

BAToken.sol: Basic Attention Token and crowdsale functionality
SafeMath.sol: safe add/subtract/multiply
StandardToken.sol: standard ERC20 functionality
BATSafe.sol: Lockup contract, presently without final addresses

详细代码

StanddardToken.sol 标准ERC20货币代码

pragma solidity ^0.4.10;

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;    

}

SafeMath.sol 安全的数学计算合约

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;
}

}

BAToken.sol BAT发行合约

pragma solidity ^0.4.10;
import "./StandardToken.sol";
import "./SafeMath.sol";

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 = "0.91";

// contracts
address public ethFundDeposit;      // deposit address for ETH for Brave International
address public batFundDeposit;      // deposit address for Brave internal use and Brave 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 = 5500; // 5500 BAT tokens per 1 ETH: THIS MAY CHANGE AT DEPLOY TIME
uint256 public constant tokenCreationCap =  1500 * (10**6) * 10**decimals; 
uint256 public constant tokenCreationMin =  750 * (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);
  if(tokenCreationCap < checkedSupply) {    // odd fractions won't be found
    throw;                           // they need to get their money back if something goes wrong
  } else {
    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
}

}

BATSafe.sol 锁定合约

pragma solidity ^0.4.10;
import './StandardToken.sol';

contract BATSafe {

mapping (address => uint256) allocations;
uint256 public unlockDate;
address public BAT;
uint256 public constant exponent = 10**18;

function BATSafe(address _BAT) {                // sample allocations to testnet addresses
    BAT = _BAT;
    unlockDate = now + 6 months;
    allocations[0xB9bc094AC55d5696E888B942Ee879E55A2B2a586] = 100;
    allocations[0x1ff55E3F22585A61401396E8D5248e977E305BDf] = 10;
    allocations[0x990F1870e96ffa1427A6a72FA82040429B333812] = 15;
    allocations[0xeA0c9227d6B5B16F07FDc7807434AD21bBC40Fc5] = 75;
}

function unlock() external {
    if(now < unlockDate) throw;
    uint256 entitled = allocations[msg.sender];
    allocations[msg.sender] = 0;
    if(!StandardToken(BAT).transfer(msg.sender, entitled * exponent)) throw;
}

}

智能合约

赞 (0)

添加新评论