# Where to use SafeMath of OpenZeppelin in this code?

This is the simple code:

``````pragma solidity ^0.4.4;

contract Token {

function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}

}

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

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

return allowed[_owner][_spender];
}

uint256 public totalSupply;
}

contract TestCoin is StandardToken { // CHANGE THIS. Update the contract name.

string public name;                   // Token Name
uint8 public decimals;                // How many decimals to show. To be standard complicant keep it 18
string public symbol;                 // An identifier: eg SBX, XPR etc..
string public version = 'H1.0';
uint256 public unitsOneEthCanBuy;     // How many units of your coin can be bought by 1 ETH?
uint256 public totalEthInWei;         // WEI is the smallest unit of ETH (the equivalent of cent in USD or satoshi in BTC). We'll store the total ETH raised via our ICO here.
address public fundsWallet;           // Where should the raised ETH go?

function TestCoin() {
balances[msg.sender] = 1000000000000000000000;               // Give the creator all initial tokens. This is set to 1000 for example. If you want your initial tokens to be X and your decimal is 5, set this value to X * 100000. (CHANGE THIS)
totalSupply = 1000000000000000000000;                        // Update total supply (1000 for example) (CHANGE THIS)
name = "TestCoin";                                   // Set the name for display purposes (CHANGE THIS)
decimals = 18;                                               // Amount of decimals for display purposes (CHANGE THIS)
symbol = "TCN";                                             // Set the symbol for display purposes (CHANGE THIS)
unitsOneEthCanBuy = 10;                                      // Set the price of your token for the ICO (CHANGE THIS)
fundsWallet = msg.sender;                                    // The owner of the contract gets ETH
}

function() payable{
totalEthInWei = totalEthInWei + msg.value;
uint256 amount = msg.value * unitsOneEthCanBuy;
if (balances[fundsWallet] < amount) {
return;
}

balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;

Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain

//Transfer ether to fundsWallet
fundsWallet.transfer(msg.value);
}

/* Approves and then calls the receiving contract */
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);

return true;
}
}
``````

Do you use the SafeMath library for every mathematical function?

For example `balances[msg.sender] -= _value;` would be `balances[msg.sender]=sub(balances[msg.sender], _value)`?

Yup, because safeMath will make you code safer with their asserts,

``````sub = Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
``````

`balances[msg.sender] = balances[msg.sender].sub(_value);`

there is also

``````mul = Multiplies two numbers, throws on overflow.
div = Integer division of two numbers, truncating the quotient.