{"Context.sol":{"content":"pragma solidity 0.5.16;\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with GSN meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\ncontract Context {\n // Empty internal constructor, to prevent people from mistakenly deploying\n // an instance of this contract, which should be used via inheritance.\n constructor () internal { }\n\n function _msgSender() internal view returns (address payable) {\n return msg.sender;\n }\n\n function _msgData() internal view returns (bytes memory) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n}\n"},"IBEP20.sol":{"content":"pragma solidity 0.5.16;\n\ninterface IBEP20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the token decimals.\n */\n function decimals() external view returns (uint8);\n\n /**\n * @dev Returns the token symbol.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the token name.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the bep token owner.\n */\n function getOwner() external view returns (address);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller\u0027s account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address _owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller\u0027s tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender\u0027s allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller\u0027s\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"},"LGEWhitelisted.sol":{"content":"pragma solidity 0.5.16;\n\nimport { Context } from \"./Context.sol\";\nimport { SafeMath } from \"./SafeMath.sol\";\n\ncontract LGEWhitelisted is Context { \n using SafeMath for uint256;\n\n struct WhitelistRound {\n uint256 duration;\n uint256 amountMax;\n mapping(address =\u003e bool) addresses;\n mapping(address =\u003e uint256) purchased;\n }\n\n WhitelistRound[] public _lgeWhitelistRounds;\n\n uint256 public _lgeTimestamp;\n address public _lgePairAddress;\n\n address public _whitelister;\n\n event WhitelisterTransferred(address indexed previousWhitelister, address indexed newWhitelister);\n\n constructor () internal {\n _whitelister = _msgSender();\n }\n\n modifier onlyWhitelister() {\n require(_whitelister == _msgSender(), \"Caller is not the whitelister\");\n _;\n }\n\n function renounceWhitelister() external onlyWhitelister {\n emit WhitelisterTransferred(_whitelister, address(0));\n _whitelister = address(0);\n }\n\n function transferWhitelister(address newWhitelister) external onlyWhitelister {\n _transferWhitelister(newWhitelister);\n }\n\n function _transferWhitelister(address newWhitelister) internal {\n require(newWhitelister != address(0), \"New whitelister is the zero address\");\n emit WhitelisterTransferred(_whitelister, newWhitelister);\n _whitelister = newWhitelister;\n }\n\n /*\n * createLGEWhitelist - Call this after initial Token Generation Event (TGE) \n * \n * pairAddress - address generated from createPair() event on DEX\n * durations - array of durations (seconds) for each whitelist rounds\n * amountsMax - array of max amounts (TOKEN decimals) for each whitelist round\n * \n */\n function createLGEWhitelist(address pairAddress, uint256[] calldata durations, uint256[] calldata amountsMax) external onlyWhitelister() {\n require(durations.length == amountsMax.length, \"Invalid whitelist(s)\");\n \n _lgePairAddress = pairAddress;\n \n if(durations.length \u003e 0) { \n delete _lgeWhitelistRounds;\n \n for (uint256 i = 0; i \u003c durations.length; i ) {\n _lgeWhitelistRounds.push(WhitelistRound(durations[i], amountsMax[i]));\n } \n }\n }\n \n /*\n * modifyLGEWhitelistAddresses - Define what addresses are included/excluded from a whitelist round\n * \n * index - 0-based index of round to modify whitelist\n * duration - period in seconds from LGE event or previous whitelist round\n * amountMax - max amount (TOKEN decimals) for each whitelist round\n * \n */\n function modifyLGEWhitelist(uint256 index, uint256 duration, uint256 amountMax, address[] calldata addresses, bool enabled) external onlyWhitelister() {\n require(index \u003c _lgeWhitelistRounds.length, \"Invalid index\");\n require(amountMax \u003e 0, \"Invalid amountMax\");\n\n if(duration != _lgeWhitelistRounds[index].duration)\n _lgeWhitelistRounds[index].duration = duration;\n \n if(amountMax != _lgeWhitelistRounds[index].amountMax) \n _lgeWhitelistRounds[index].amountMax = amountMax;\n \n for (uint256 i = 0; i \u003c addresses.length; i ) {\n _lgeWhitelistRounds[index].addresses[addresses[i]] = enabled;\n }\n }\n \n /*\n * getLGEWhitelistRound\n *\n * returns:\n *\n * 1. whitelist round number ( 0 = no active round now )\n * 2. duration, in seconds, current whitelist round is active for\n * 3. timestamp current whitelist round closes at\n * 4. maximum amount a whitelister can purchase in this round\n * 5. is caller whitelisted\n * 6. how much caller has purchased in current whitelist round\n *\n */\n function getLGEWhitelistRound() public view returns (uint256, uint256, uint256, uint256, bool, uint256) {\n if(_lgeTimestamp \u003e 0) { \n uint256 wlCloseTimestampLast = _lgeTimestamp;\n \n for (uint256 i = 0; i \u003c _lgeWhitelistRounds.length; i ) { \n WhitelistRound storage wlRound = _lgeWhitelistRounds[i];\n wlCloseTimestampLast = wlCloseTimestampLast.add(wlRound.duration);\n\n if(now \u003c= wlCloseTimestampLast)\n return (i.add(1), wlRound.duration, wlCloseTimestampLast, wlRound.amountMax, wlRound.addresses[_msgSender()], wlRound.purchased[_msgSender()]);\n }\n }\n \n return (0, 0, 0, 0, false, 0);\n }\n \n /*\n * _applyLGEWhitelist - internal function to be called initially before any transfers\n * \n */ \n function _applyLGEWhitelist(address sender, address recipient, uint256 amount) internal {\n if(_lgePairAddress == address(0) || _lgeWhitelistRounds.length == 0)\n return;\n \n if(_lgeTimestamp == 0 \u0026\u0026 sender != _lgePairAddress \u0026\u0026 recipient == _lgePairAddress \u0026\u0026 amount \u003e 0)\n _lgeTimestamp = now;\n \n if(sender == _lgePairAddress \u0026\u0026 recipient != _lgePairAddress) {\n //buying\n\n (uint256 wlRoundNumber,,,,,) = getLGEWhitelistRound();\n \n if(wlRoundNumber \u003e 0) { \n WhitelistRound storage wlRound = _lgeWhitelistRounds[wlRoundNumber.sub(1)];\n \n require(wlRound.addresses[recipient], \"LGE - Buyer is not whitelisted\");\n \n uint256 amountRemaining = 0;\n \n if(wlRound.purchased[recipient] \u003c wlRound.amountMax)\n amountRemaining = wlRound.amountMax.sub(wlRound.purchased[recipient]);\n \n require(amount \u003c= amountRemaining, \"LGE - Amount exceeds whitelist maximum\");\n wlRound.purchased[recipient] = wlRound.purchased[recipient].add(amount); \n } \n }\n }\n}\n"},"Ownable.sol":{"content":"pragma solidity 0.5.16;\n\nimport { Context } from \"./Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\ncontract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor () internal {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(_owner == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() external onlyOwner {\n emit OwnershipTransferred(_owner, address(0));\n _owner = address(0);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) external onlyOwner {\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n */\n function _transferOwnership(address newOwner) internal {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n}\n"},"SafeMath.sol":{"content":"pragma solidity 0.5.16;\n\n/**\n * @dev Wrappers over Solidity\u0027s arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it\u0027s recommended to use it always.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity\u0027s ` ` operator.\n *\n * Requirements:\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 c = a b;\n require(c \u003e= a, \"SafeMath: addition overflow\");\n\n return c;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity\u0027s `-` operator.\n *\n * Requirements:\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return sub(a, b, \"SafeMath: subtraction overflow\");\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity\u0027s `-` operator.\n *\n * Requirements:\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n require(b \u003c= a, errorMessage);\n uint256 c = a - b;\n\n return c;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity\u0027s `*` operator.\n *\n * Requirements:\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n // Gas optimization: this is cheaper than requiring \u0027a\u0027 not being zero, but the\n // benefit is lost if \u0027b\u0027 is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) {\n return 0;\n }\n\n uint256 c = a * b;\n require(c / a == b, \"SafeMath: multiplication overflow\");\n\n return c;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers. Reverts on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity\u0027s `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return div(a, b, \"SafeMath: division by zero\");\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity\u0027s `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n // Solidity only automatically asserts when dividing by 0\n require(b \u003e 0, errorMessage);\n uint256 c = a / b;\n // assert(a == b * c a % b); // There is no case in which this doesn\u0027t hold\n\n return c;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * Reverts when dividing by zero.\n *\n * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return mod(a, b, \"SafeMath: modulo by zero\");\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * Reverts with custom message when dividing by zero.\n *\n * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n require(b != 0, errorMessage);\n return a % b;\n }\n}\n"},"TeraBlockToken.sol":{"content":"pragma solidity 0.5.16;\n\nimport { IBEP20 } from \"./IBEP20.sol\";\nimport { Context } from \"./Context.sol\";\nimport { SafeMath } from \"./SafeMath.sol\";\nimport { Ownable } from \"./Ownable.sol\";\nimport { LGEWhitelisted } from \"./LGEWhitelisted.sol\";\n\ncontract TeraBlockToken is Context, IBEP20, Ownable, LGEWhitelisted {\n using SafeMath for uint256;\n\n mapping (address =\u003e uint256) private _balances;\n mapping (address =\u003e mapping (address =\u003e uint256)) private _allowances;\n\n uint256 private _totalSupply;\n uint8 private _decimals;\n string private _symbol;\n string private _name;\n\n constructor() public {\n _name = \"TeraBlock Token\";\n _symbol = \"TBC\";\n _decimals = 18;\n _totalSupply = 400000000 * 10 ** 18;\n _balances[_msgSender()] = _totalSupply;\n\n emit Transfer(address(0), _msgSender(), _totalSupply);\n }\n\n /**\n * @dev Returns the bep token owner.\n */\n function getOwner() external view returns (address) {\n return owner();\n }\n\n /**\n * @dev Returns the token decimals.\n */\n function decimals() external view returns (uint8) {\n return _decimals;\n }\n\n /**\n * @dev Returns the token symbol.\n */\n function symbol() external view returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the token name.\n */\n function name() external view returns (string memory) {\n return _name;\n }\n\n /**\n * @dev See {BEP20-totalSupply}.\n */\n function totalSupply() external view returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {BEP20-balanceOf}.\n */\n function balanceOf(address account) external view returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {BEP20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) external returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {BEP20-allowance}.\n */\n function allowance(address owner, address spender) external view returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {BEP20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) external returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {BEP20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {BEP20};\n *\n * Requirements:\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for `sender`\u0027s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {\n _transfer(sender, recipient, amount);\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \"BEP20: transfer amount exceeds allowance\"));\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {BEP20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {BEP20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \"BEP20: decreased allowance below zero\"));\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal {\n require(sender != address(0), \"BEP20: transfer from the zero address\");\n require(recipient != address(0), \"BEP20: transfer to the zero address\");\n\n _applyLGEWhitelist(sender, recipient, amount);\n\n _balances[sender] = _balances[sender].sub(amount, \"BEP20: transfer amount exceeds balance\");\n _balances[recipient] = _balances[recipient].add(amount);\n emit Transfer(sender, recipient, amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.\n *\n * This is internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal {\n require(owner != address(0), \"BEP20: approve from the zero address\");\n require(spender != address(0), \"BEP20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n}\n"}}