Skip to content
No description, website, or topics provided.
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
AITBotToken.sol
README.md

README.md

AITBotToken

/** *Submitted for verification at Etherscan.io on 2019-04-19 */

pragma solidity ^0.5.7;

interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256);

function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);

event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);

}

interface IERC223 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); function totalSupply() external view returns (uint256);

function balanceOf(address who) external view returns (uint);

function transfer(address to, uint value) external returns (bool);
function transfer(address to, uint value, bytes calldata data) external returns (bool);

event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);

}

contract ContractReceiver { function tokenFallback(address _from, uint _value, bytes memory _data) public {

}

}

/**

  • @title SafeMath

  • @dev Unsigned math operations with safety checks that revert on error. / library SafeMath { /*

    • @dev Multiplies two unsigned integers, reverts on overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; }

      uint256 c = a * b; require(c / a == b);

      return c; }

    /**

    • @dev Integer division of two unsigned integers truncating the quotient,

    • reverts on division by zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold

      return c; }

    /**

    • @dev Subtracts two unsigned integers, reverts on overflow

    • (i.e. if subtrahend is greater than minuend). */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b;

      return c; }

    /**

    • @dev Adds two unsigned integers, reverts on overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a);

      return c; }

    /**

    • @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
    • reverts when dividing by zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } }

contract StandardToken is IERC20, IERC223 { uint256 public totalSupply;

using SafeMath for uint;

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

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

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);
    emit Transfer(_from, _to, _value);
    return true;
}

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

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

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

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

// Function that is called when a user or another contract wants to transfer funds.
function transfer(address _to, uint _value, bytes memory _data) public returns (bool success) {
    if (isContract(_to)) {
        return transferToContract(_to, _value, _data);
    } else {
        return transferToAddress(_to, _value, _data);
    }
}

// Standard function transfer similar to ERC20 transfer with no _data.
// Added due to backwards compatibility reasons.
function transfer(address _to, uint _value) public returns (bool success) {
    bytes memory empty;
    if (isContract(_to)) {
        return transferToContract(_to, _value, empty);
    } else {
        return transferToAddress(_to, _value, empty);
    }
}

// Assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
    uint length;
    require(_addr != address(0));
    assembly {
        //retrieve the size of the code on target address, this needs assembly
        length := extcodesize(_addr)
    }
    return (length > 0);
}

// Function that is called when transaction target is an address.
function transferToAddress(address _to, uint _value, bytes memory _data) private returns (bool success) {
    require(balances[msg.sender] >= _value);
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    emit Transfer(msg.sender, _to, _value);
    emit Transfer(msg.sender, _to, _value, _data);
    return true;
}

// Function that is called when transaction target is a contract.
function transferToContract(address _to, uint _value, bytes memory _data) private returns (bool success) {
    require(balances[msg.sender] >= _value);
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    ContractReceiver receiver = ContractReceiver(_to);
    receiver.tokenFallback(msg.sender, _value, _data);
    emit Transfer(msg.sender, _to, _value);
    emit Transfer(msg.sender, _to, _value, _data);
    return true;
}

}

contract AITBotToken is StandardToken { string public constant name = "AITBot Token "; string public constant symbol = "AITBOT"; uint8 public constant decimals = 18; uint256 public constant initialSupply = 1000000000 * 10 ** uint256(decimals);

constructor () public {
    totalSupply = initialSupply;
    balances[msg.sender] = initialSupply;
}

}

You can’t perform that action at this time.