# How to write time based events in a contract? [duplicate]

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

contract ERC20 is ERC20Basic {
function approve(address spender, uint256 value) public returns (bool);
}

contract BasicToken is ERC20Basic {
using SafeMath for uint256;

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

// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_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 {

require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);

balances[_from] = balances[_from].sub(_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;
}

return allowed[_owner][_spender];
}

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 {

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

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

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

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.

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.