0

This question already has an answer here:

I have created a token creation contract. Now, I have to write time-based events in the same contract like after every 6 months some 'x' number of tokens should send to 3 ether addresses. How to write that time based contract in the below contract? Please explain

pragma solidity ^0.4.4;

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 ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public constant 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 constant 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 BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  function transfer(address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[msg.sender]);

    // SafeMath.sub will throw if there is not enough balance.
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  function balanceOf(address _owner) public constant returns (uint256 balance) {
    return balances[_owner];
  }

}

contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address => uint256)) internal allowed;

  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }

  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
    return allowed[_owner][_spender];
  }

  function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

  function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

}

contract Ownable {
  address public owner;

  function Ownable() {
    owner = msg.sender;
  }

  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  function transferOwnership(address newOwner) onlyOwner {
    require(newOwner != address(0)); 
    owner = newOwner;
  }
}

contract SimpleERC20Token is StandardToken, Ownable
{
    string public name = 'Hello Token';
    string public symbol = "HNC";

    uint public decimals = 18;

    uint private constant initialSupply = 2000000000000;
    uint private constant _totalSupply = 1000000000000;

    function SimpleERC20Token()
    {
        owner = msg.sender;
        totalSupply = _totalSupply;
        balances[owner] = initialSupply;
    }
}

marked as duplicate by Richard Horrocks, ivicaa, Achala Dissanayake, eth Mar 8 '18 at 9:49

This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.

0

It can be achieved by modifying how the tokens are used. For example, while retrieving the balance of an account, change the balanceOf function.

  1. In the balanceOf function, write code, which checks how much time has passed and on that basis returns the incremented balance of team members. Other balances will be returned as it is.

    uint256 constant deployementTime = now; uint256 constant dividendDuration = 182 days; // 6 months uint256 constant dividendAmount = 4e18; //number of tokens to be given // customize how balance is shown function balanceOf(address account) public constant returns (uint256 balance){ if(account==0x131... || account== 0x123123... || ...){ //these are address of team members uint256 epochsPassed = (now-deployementTime)/dividendDuration; return balances[account]+epochsPassed*dividendAmount; } return balances[account]; }

  2. Do the similar modification while retrieving totalSupply. The change where totalSupply is returned after counting epochs and adding new tokens. Total supply indicates how many tokens are in circulation. So, instead of a constant variable, you can use a function.

  3. Do the similar modifications while using the tokens.

You can make the contract such that all the things are managed as per your wishes. While there may not be any data that shows on first look that tokens are actually given, contract can be made to behave such that the tokens are given.

0

The execution of smart contracts needs to be triggered by a third party (including other contracts). Also, contracts do not receive event notifications. Therefore, what you want to do requires a service that triggers your contract when the desired time has passed.

There is a service called Ethereum Alarm Clock, that does exactly what you want. Also oracles have these services, one that seems to be popular is Oraclize. You can schedule calls with this service.

These services are paid, so every time you request you need to pay the transaction fee plus the service fee. In your case, may be worth to pay a few cents every six months.

In the documentation of these projects you can find ready-to-go examples of how to use the service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.