hello world

Author: kar2905

AirDrop.sol

@@ -0,0 +1,76 @@
+pragma solidity ^0.4.19;
+
+/**
+ * @title Token
+ * @dev Simpler version of ERC20 interface
+ */
+contract Token {
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+
+  /**
+   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
+   * account.
+   */
+  function Ownable() {
+    owner = msg.sender;
+  }
+
+
+  /**
+   * @dev Throws if called by any account other than the owner.
+   */
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+
+  /**
+   * @dev Allows the current owner to transfer control of the contract to a newOwner.
+   * @param newOwner The address to transfer ownership to.
+   */
+  function transferOwnership(address newOwner) onlyOwner public {
+    require(newOwner != address(0));
+    OwnershipTransferred(owner, newOwner);
+    owner = newOwner;
+  }
+
+}
+
+contract AirDrop is Ownable {
+
+  // This declares a state variable that would store the contract address
+  Token public tokenInstance;
+
+  /*
+    constructor function to set token address
+   */
+  function AirDrop(address _tokenAddress){
+    tokenInstance = Token(_tokenAddress);
+  }
+  event AddressLog(address _from, uint256 _amount);
+
+  /*
+    Airdrop function which take up a array of address and amount and call the
+    transfer function to send the token
+   */
+  function doAirDrop(address[] addrs, uint256 _amount) onlyOwner public returns (bool success) {
+    uint256 count = addrs.length;
+    for (uint256 i = 0; i < count; i++)
+    {
+      /* calling transfer function from contract */
+      tokenInstance.transfer(addrs [i],_amount);
+      /* logging event */
+      AddressLog(addrs [i],_amount);
+    }
+  }
+}

PreMint.sol

@@ -0,0 +1,179 @@
+pragma solidity ^0.4.19;
+
+/**
+ * @title ERC20Basic
+ * @dev Simpler version of ERC20 interface
+ * @dev see https://github.com/ethereum/EIPs/issues/179
+ */
+contract ERC20Basic {
+  uint256 public totalSupply;
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}
+
+contract ERC20 is ERC20Basic {
+  function allowance(address owner, address spender) public view returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public returns (bool);
+  function approve(address spender, uint256 value) public returns (bool);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract StandardToken is ERC20 {
+    using SafeMath for uint256;
+
+    mapping (address => uint256) public balances;
+    mapping (address => mapping (address => uint256)) public allowed;
+
+    function transfer(address _to, uint256 _value) returns (bool success) {
+        require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
+        balances[msg.sender] = balances[msg.sender].sub(_value);
+        balances[_to] = balances[_to].add(_value);
+        Transfer(msg.sender, _to, _value);
+        return true;
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
+        require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]);
+        balances[_to] = balances[_to].add(_value);
+        balances[_from] = balances[_from].sub(_value);
+        allowed[_from][msg.sender] -= allowed[_from][msg.sender].sub(_value);
+        Transfer(_from, _to, _value);
+        return true;
+    }
+
+    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];
+    }
+}
+
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+
+  /**
+   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
+   * account.
+   */
+  function Ownable() {
+    owner = msg.sender;
+  }
+
+
+  /**
+   * @dev Throws if called by any account other than the owner.
+   */
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+
+  /**
+   * @dev Allows the current owner to transfer control of the contract to a newOwner.
+   * @param newOwner The address to transfer ownership to.
+   */
+  function transferOwnership(address newOwner) onlyOwner public {
+    require(newOwner != address(0));
+    OwnershipTransferred(owner, newOwner);
+    owner = newOwner;
+  }
+
+}
+
+library SafeMath {
+  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
+    uint256 c = a * b;
+    assert(a == 0 || c / a == b);
+    return c;
+  }
+
+  function div(uint256 a, uint256 b) internal constant returns (uint256) {
+    assert(b > 0); // Solidity automatically throws when dividing by 0
+    uint256 c = a / b;
+    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+    return c;
+  }
+
+  function sub(uint256 a, uint256 b) internal constant returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function add(uint256 a, uint256 b) internal constant returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+/* Contract class for adding removing whitelisted contracts */
+contract WhiteListedContracts is Ownable {
+  mapping (address => uint ) white_listed_contracts;
+
+  //modifer to check if the contract given is white listed or not
+  modifier whitelistedContractsOnly() {
+    require(white_listed_contracts[msg.sender] == 1);
+    _;
+  }
+
+  //add a contract to whitelist
+  function addWhiteListedContracts (address _address) onlyOwner public {
+    white_listed_contracts[_address] = 1;
+  }
+
+  //remove contract from whitelist
+  function removeWhiteListedContracts (address _address) onlyOwner public {
+    white_listed_contracts[_address] = 0;
+  }
+}
+
+/* Contract class to mint tokens and transfer */
+contract SRTToken is Ownable,StandardToken,WhiteListedContracts {
+  using SafeMath for uint256;
+
+  string constant public name = 'SpringRole Pre Mint Token';
+  string constant public symbol = 'SRT';
+  uint constant public decimals = 18;
+  uint256 public totalSupply;
+
+  /* Contructor function to set initial balance and assign to owner*/
+  function SRTToken(uint256 _totalSupply){
+    totalSupply = _totalSupply * 10**decimals;
+    balances[msg.sender] = balances[msg.sender].add(totalSupply);
+  }
+
+  /*
+    transfer eth recived to owner account if any
+  */
+  function() payable {
+	  owner.transfer(msg.value);
+	}
+
+  /*
+  do transfer function will allow transfer from a _to to _from provided if the call
+  comes from whitelisted contracts only
+  */
+  function doTransfer(address _from, address _to, uint256 _value) whitelistedContractsOnly public returns (bool){
+    require(balances[_from] >= _value && balances[_to] + _value > balances[_to]);
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    Transfer(_from, _to, _value);
+    return true;
+  }
+
+}