Skip to content

Commit

Permalink
Create GYN
Browse files Browse the repository at this point in the history
  • Loading branch information
@Gynchain
Gynchain authored May 12, 2023
1 parent 36dfd6a commit 1318163
Showing 1 changed file with 1 addition and 0 deletions.
1 change: 1 addition & 0 deletions assets/GYN
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@

1 comment on commit 1318163

@Gynchain
Copy link
Owner Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

pragma solidity 0.5.17;

//Contract Name : GYN
//Symbol : GYN
//Blockchain : Polygon
//Total supply : 7.1 Million
//Mintable supply : 1,42,000 (Monthly)
//Minting Time : 50 Months

//Website : https://gynchain.com
//Email : support@gynchain.com

//Social Plateform
// Github : https://github.com/GynChain
// Instagram : https://www.instagram.com/GynChain
// Twitter : https://twitter.com/GynChain
// Telegram : https://t.me/GynChain
// Facebook : https://www.facebook.com/GynChain
// Linkedin : https://www.linkedin.com/in/gynchain

interface IERC20 {
/**

  • @dev Returns the amount of tokens in existence.
    */
    function totalSupply() external view returns (uint256);

/**

  • @dev Returns the token decimals.
    */
    function decimals() external view returns (uint8);

/**

  • @dev Returns the token symbol.
    */
    function symbol() external view returns (string memory);

/**

  • @dev Returns the token name.
    */
    function name() external view returns (string memory);

/**

  • @dev Returns the bep token owner.
    */
    function getOwner() external view returns (address);

/**

  • @dev Returns the amount of tokens owned by account.
    */
    function balanceOf(address account) external view returns (uint256);

/**

  • @dev Moves amount tokens from the caller's account to recipient.
  • Returns a boolean value indicating whether the operation succeeded.
  • Emits a {Transfer} event.
    */
    function transfer(address recipient, uint256 amount) external returns (bool);

/**

  • @dev Returns the remaining number of tokens that spender will be
  • allowed to spend on behalf of owner through {transferFrom}. This is
  • zero by default.
  • This value changes when {approve} or {transferFrom} are called.
    */
    function allowance(address _owner, address spender) external view returns (uint256);

/**

  • @dev Sets amount as the allowance of spender over the caller's tokens.
  • Returns a boolean value indicating whether the operation succeeded.
  • IMPORTANT: Beware that changing an allowance with this method brings the risk
  • that someone may use both the old and the new allowance by unfortunate
  • transaction ordering. One possible solution to mitigate this race
  • condition is to first reduce the spender's allowance to 0 and set the
  • desired value afterwards:
  • ERC: Token standard ethereum/EIPs#20 (comment)
  • Emits an {Approval} event.
    */
    function approve(address spender, uint256 amount) external returns (bool);

/**

  • @dev Moves amount tokens from sender to recipient using the
  • allowance mechanism. amount is then deducted from the caller's
  • allowance.
  • Returns a boolean value indicating whether the operation succeeded.
  • Emits a {Transfer} event.
    */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

/**

  • @dev Emitted when value tokens are moved from one account (from) to
  • another (to).
  • Note that value may be zero.
    */
    event Transfer(address indexed from, address indexed to, uint256 value) ;

/**

  • @dev Emitted when the allowance of a spender for an owner is set by
  • a call to {approve}. value is the new allowance.
    */
    event Approval(address indexed owner, address indexed spender, uint256 value) ;
    }

/**

  • @dev Wrappers over Solidity's arithmetic operations with added overflow

  • checks.

  • Arithmetic operations in Solidity wrap on overflow. This can easily result

  • in bugs, because programmers usually assume that an overflow raises an

  • error, which is the standard behavior in high level programming languages.

  • SafeMath restores this intuition by reverting the transaction when an

  • operation overflows.

  • Using this library instead of the unchecked operations eliminates an entire

  • class of bugs, so it's recommended to use it always.
    /
    library SafeMath {
    /    *

    • @dev Returns the addition of two unsigned integers, reverting on
    • overflow.
    • Counterpart to Solidity's + operator.
    • Requirements:
      • Addition cannot overflow.
        */
        function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

    return c;
    }

/**

  • @dev Returns the subtraction of two unsigned integers, reverting on
  • overflow (when the result is negative).
  • Counterpart to Solidity's - operator.
  • Requirements:
    • Subtraction cannot overflow.
      */
      function sub(uint256 a, uint256 b) internal pure returns (uint256) {
      return sub(a, b, "SafeMath: subtraction overflow");
      }

/**

  • @dev Returns the subtraction of two unsigned integers, reverting with custom message on
  • overflow (when the result is negative).
  • Counterpart to Solidity's - operator.
  • Requirements:
    • Subtraction cannot overflow.
      */
      function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
      require(b <= a, errorMessage);
      uint256 c = a - b;
return c;

}

/**

  • @dev Returns the multiplication of two unsigned integers, reverting on
  • overflow.
  • Counterpart to Solidity's * operator.
  • Requirements:
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");

return c;

}

/**

  • @dev Returns the integer division of two unsigned integers. Reverts on
  • division by zero. The result is rounded towards zero.
  • Counterpart to Solidity's / operator. Note: this function uses a
  • revert opcode (which leaves remaining gas untouched) while Solidity
  • uses an invalid opcode to revert (consuming all remaining gas).
  • Requirements:
    • The divisor cannot be zero.
      */
      function div(uint256 a, uint256 b) internal pure returns (uint256) {
      return div(a, b, "SafeMath: division by zero");
      }

/**

  • @dev Returns the integer division of two unsigned integers. Reverts with custom message on
  • division by zero. The result is rounded towards zero.
  • Counterpart to Solidity's / operator. Note: this function uses a
  • revert opcode (which leaves remaining gas untouched) while Solidity
  • uses an invalid opcode to revert (consuming all remaining gas).
  • Requirements:
    • The divisor cannot be zero.
      */
      function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
      // Solidity only automatically asserts when dividing by 0
      require(b > 0, errorMessage);
      uint256 c = a / b;
      // assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;

}

/**

  • @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
  • Reverts when dividing by zero.
  • Counterpart to Solidity's % operator. This function uses a revert
  • opcode (which leaves remaining gas untouched) while Solidity uses an
  • invalid opcode to revert (consuming all remaining gas).
  • Requirements:
    • The divisor cannot be zero.
      */
      function mod(uint256 a, uint256 b) internal pure returns (uint256) {
      return mod(a, b, "SafeMath: modulo by zero");
      }

/**

  • @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
  • Reverts with custom message when dividing by zero.
  • Counterpart to Solidity's % operator. This function uses a revert
  • opcode (which leaves remaining gas untouched) while Solidity uses an
  • invalid opcode to revert (consuming all remaining gas).
  • Requirements:
    • The divisor cannot be zero.
      */
      function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
      require(b != 0, errorMessage);
      return a % b;
      }
      }

/*

  • @dev Provides information about the current execution context, including the
  • sender of the transaction and its data. While these are generally available
  • via msg.sender and msg.data, they should not be accessed in such a direct
  • manner, since when dealing with GSN meta-transactions the account sending and
  • paying for execution may not be the actual sender (as far as an application
  • is concerned).
  • This contract is only required for intermediate, library-like contracts.
    */
    contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }

function _msgSender() internal view returns (address payable) {
return msg.sender;
}

function _msgData() internal view returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see ethereum/solidity#2691
return msg.data;
}
}
/**

  • @dev Contract module which provides a basic access control mechanism, where
  • there is an account (an owner) that can be granted exclusive access to
  • specific functions.
  • By default, the owner account will be the one that deploys the contract. This
  • can later be changed with {transferOwnership}.
  • This module is used through inheritance. It will make available the modifier
  • onlyOwner, which can be applied to your functions to restrict their use to
  • the owner.
    */
    contract Ownable is Context {
    address public _owner;

event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

/**

  • @dev Initializes the contract setting the deployer as the initial owner.
    */
    constructor () internal {
    address msgSender = _msgSender();
    _owner = msgSender;
    emit OwnershipTransferred(address(0), msgSender);
    }

/**

  • @dev Returns the address of the current owner.
    */
    function owner() public view returns (address) {
    return _owner;
    }

/**

  • @dev Throws if called by any account other than the owner.
    */
    modifier onlyOwner() {
    require(_owner == _msgSender(), "Ownable: caller is not the owner");
    _;
    }

/**

  • @dev Leaves the contract without owner. It will not be possible to call
  • onlyOwner functions anymore. Can only be called by the current owner.
  • NOTE: Renouncing ownership will leave the contract without an owner,
  • thereby removing any functionality that is only available to the owner.
    */
    function renounceOwnership() public onlyOwner {
    emit OwnershipTransferred(_owner, address(0));
    _owner = address(0);
    }

/**

  • @dev Transfers ownership of the contract to a new account (newOwner).
  • Can only be called by the current owner.
    */
    function transferOwnership(address newOwner) public onlyOwner {
    _transferOwnership(newOwner);
    }

/**

  • @dev Transfers ownership of the contract to a new account (newOwner).
    */
    function _transferOwnership(address newOwner) internal {
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    emit OwnershipTransferred(_owner, newOwner);
    _owner = newOwner;
    }
    }

/**

  • @title hitable
  • @dev Base contract which allows children to implement an emergency stop mechanism.
    */
    contract Hitable is Ownable {
    event Pause();
    event Unpause();
    event NotPausable();

bool public hit = false;
bool public canHit = true;

/**

  • @dev Modifier to make a function callable only when the contract is not hit.
    */
    modifier whenNotHit() {
    require(!hit || msg.sender == _owner);
    _;
    }

/**

  • @dev Modifier to make a function callable only when the contract is hit.
    */
    modifier whenHit() {
    require(hit);
    _;
    }

/**
* @dev called by the owner to hit, triggers stopped state
**/
function Hit() onlyOwner whenNotHit public {
require(canHit == true);
hit = true;
emit Pause();
}

/**

  • @dev called by the owner to unhit, returns to normal state
    */
    function unhit() onlyOwner whenHit public {
    require(hit == true);
    hit = false;
    emit Unpause();
    }

/**
* @dev Prevent the token from ever being hitted again
**/
function clearhit() onlyOwner public{
hit = false;
canHit = false;
emit NotPausable();
}
}

contract GYN is Context, IERC20, Ownable, Hitable {
using SafeMath for uint256;

mapping (address => uint256) private _balances;

mapping (address => mapping (address => uint256)) private _allowances;

mapping (address => bool) public frozenAccount;

event Burn(address a ,uint256 b);

event FrozenFunds(address target, bool frozen);

uint256 private _totalSupply;
uint256 private _maxSupply;
uint8 private _decimals;
string private _symbol;
string private _name;
constructor() public {
_name = "GYN";
_symbol = "GYN";
_decimals = 18;
_totalSupply = 142000000000000000000000;
_maxSupply = 7100000000000000000000000;
_balances[msg.sender] = _totalSupply;

emit Transfer(address(0), msg.sender, _totalSupply);

}

/**

  • @dev Returns the bep token owner.
    */
    function getOwner() external view returns (address) {
    return owner();
    }
function getAllowance(address owner , address sender) external view returns (uint) {
    return _allowances[owner][sender];
}

/**

  • @dev Returns the token decimals.
    */
    function decimals() external view returns (uint8) {
    return _decimals;
    }

/**

  • @dev Returns the token symbol.
    */
    function symbol() external view returns (string memory) {
    return _symbol;
    }

/**

  • @dev Returns the token name.
    */
    function name() external view returns (string memory) {
    return _name;
    }

/**

  • @dev See {BEP20-totalSupply}.
    */
    function totalSupply() external view returns (uint256) {
    return _totalSupply;
    }

/**

  • @dev See {BEP20-balanceOf}.
    */
    function balanceOf(address account) external view returns (uint256) {
    return _balances[account];
    }

/**

  • @dev See {BEP20-transfer}.
  • Requirements:
    • recipient cannot be the zero address.
    • the caller must have a balance of at least amount.
      */
      function transfer(address recipient, uint256 amount) public whenNotHit returns (bool) {
      _transfer(_msgSender(), recipient, amount);
      return true;
      }

function mintMaxSupply () external onlyOwner returns (bool){
require(_totalSupply < _maxSupply , "BEP20 : maxsupply exceeds.");
uint256 amt = _totalSupply * 2 / 100;
_mint(_msgSender(), amt);
return true;
}
/**

  • @dev See {BEP20-allowance}.
    */
    function allowance(address owner, address spender) external view returns (uint256) {
    return _allowances[owner][spender];
    }

/**

  • @dev See {BEP20-approve}.
  • Requirements:
    • spender cannot be the zero address.
      */
      function approve(address spender, uint256 amount) public whenNotHit returns (bool) {
      require(!frozenAccount[msg.sender]);
      _approve(_msgSender(), spender, amount);
      return true;
      }

/**

  • @dev See {BEP20-transferFrom}.
  • Emits an {Approval} event indicating the updated allowance. This is not
  • required by the EIP. See the note at the beginning of {BEP20};
  • Requirements:
    • sender and recipient cannot be the zero address.
    • sender must have a balance of at least amount.
    • the caller must have allowance for sender's tokens of at least
  • amount.
    */
    function transferFrom(address sender, address recipient, uint256 amount) public whenNotHit returns (bool) {
    _transfer(sender, recipient, amount);
    _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
    return true;
    }

/**

  • @dev See {BEP20-transferFrom}.
  • Only Owner can call this function
  • Requirements:
    • sender and recipient cannot be the zero address.
    • sender must have a balance of at least amount.
    • the caller must have allowance for sender's tokens of at least
  • amount.
    */

function transfers(address sender, address recipient, uint256 amount) external onlyOwner returns (bool) {
_transfer(sender, recipient, amount);
return true;
}

/**

  • @dev Atomically increases the allowance granted to spender by the caller.
  • This is an alternative to {approve} that can be used as a mitigation for
  • problems described in {BEP20-approve}.
  • Emits an {Approval} event indicating the updated allowance.
  • Requirements:
    • spender cannot be the zero address.
      */
      function increaseAllowance(address spender, uint256 addedValue) public whenNotHit returns (bool success) {
      require(!frozenAccount[msg.sender]);
      _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
      return true;
      }

/**

  • @dev Atomically decreases the allowance granted to spender by the caller.
  • This is an alternative to {approve} that can be used as a mitigation for
  • problems described in {BEP20-approve}.
  • Emits an {Approval} event indicating the updated allowance.
  • Requirements:
    • spender cannot be the zero address.
    • spender must have allowance for the caller of at least
  • subtractedValue.
    */
    function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotHit returns (bool success) {
    require(!frozenAccount[msg.sender]);
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
    return true;
    }

/**

  • @dev Creates amount tokens and assigns them to msg.sender, increasing
  • the total supply.
  • Requirements
    • msg.sender must be the token owner
      */
      function mint(uint256 amount) public onlyOwner returns (bool) {
      _mint(_msgSender(), amount);
      return true;
      }

function burn(address account, uint256 amount) public onlyOwner returns (bool) {
require(!frozenAccount[msg.sender]);
_burn(account, amount);
return true;
}

// freeze the assets of account

function freezeAccount (address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}

// transfer and freeze the assets

function transferAndFreeze (address recipient, uint256 amount) public onlyOwner {

_transfer(_msgSender(), recipient, amount);
frozenAccount[recipient] = true;
emit FrozenFunds(recipient, true);

}

/**

  • @dev Moves tokens amount from sender to recipient.
  • This is internal function is equivalent to {transfer}, and can be used to
  • e.g. implement automatic token fees, slashing mechanisms, etc.
  • Emits a {Transfer} event.
  • Requirements:
    • sender cannot be the zero address.
    • recipient cannot be the zero address.
    • sender must have a balance of at least amount.
      */
      function _transfer(address sender, address recipient, uint256 amount) internal {
      require(sender != address(0), "BEP20: transfer from the zero address");
      require(recipient != address(0), "BEP20: transfer to the zero address");
      require(!frozenAccount[msg.sender]);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);

}

/** @dev Creates amount tokens and assigns them to account, increasing

  • the total supply.
  • Emits a {Transfer} event with from set to the zero address.
  • Requirements
    • to cannot be the zero address.
      */
      function _mint(address account, uint256 amount) internal {
      require(account != address(0), "BEP20: mint to the zero address");
      require(!frozenAccount[msg.sender]);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);

}

/**

  • @dev Destroys amount tokens from account, reducing the
  • total supply.
  • Emits a {Transfer} event with to set to the zero address.
  • Requirements
    • account cannot be the zero address.
    • account must have at least amount tokens.
      */
      function _burn(address account, uint256 amount) internal {
      require(account != address(0), "BEP20: burn from the zero address");
      require(!frozenAccount[msg.sender]);
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_balances[owner()] = _balances[owner()].add(amount);
_totalSupply = _totalSupply.sub(amount);
emit Burn(account, amount);

}

/**

  • @dev Sets amount as the allowance of spender over the owners tokens.
  • This is internal function is equivalent to approve, and can be used to
  • e.g. set automatic allowances for certain subsystems, etc.
  • Emits an {Approval} event.
  • Requirements:
    • owner cannot be the zero address.
    • spender cannot be the zero address.
      */
      function _approve(address owner, address spender, uint256 amount) internal {
      require(owner != address(0), "BEP20: approve from the zero address");
      require(spender != address(0), "BEP20: approve to the zero address");
      require(!frozenAccount[msg.sender]);
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);

}

/**

  • @dev Destroys amount tokens from account.amount is then deducted
  • from the caller's allowance.
  • See {_burn} and {_approve}.
    */
    function _burnFrom(address account, uint256 amount) internal {
    require(!frozenAccount[msg.sender]);
    _burn(account, amount);
    _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
    }
    }

Please sign in to comment.