Token AI Chain

/**
 *Submitted for verification at Etherscan.io on 2021-07-29
*/

// SPDX-License-Identifier: Unlicensed

pragma solidity ^0.8.0;

library SafeMath {

  /**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
    if (a == 0) {
      return 0;
    }
    c = a * b;
    assert(c / a == b);
    return c;
  }

  /**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    // uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return a / b;
  }

  /**
  * @dev Subtracts 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;
  }

  /**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
    c = a + b;
    assert(c >= a);
    return c;
  }
}

library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


contract AIChain {
    using SafeMath for uint256;
    string  public name = "AI Chain";
    string  public symbol = "AI";
    uint8   public decimals = 18;
    uint256 public totalSupply = 21*10**18*10**18; 
    
    event Transfer(
        address indexed _from,
        address indexed _to,
        uint256 _value
    );

    event Approval(
        address indexed _owner,
        address indexed _spender,
        uint256 _value
    );

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor() {
        balanceOf[msg.sender] = totalSupply;
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_value <= balanceOf[_from]);
        require(_value <= allowance[_from][msg.sender]);
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        allowance[_from][msg.sender] -= _value;
        emit Transfer(_from, _to, _value);
        return true;
    }
    
    function approve(address _spender, uint256 _value) public returns (bool) {
    allowance[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
  }

  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param _owner address The address which owns the funds.
   * @param _spender address The address which will spend the funds.
   * @return A uint256 specifying the amount of tokens still available for the spender.
   */
  function allowed(address _owner,address _spender)public view returns (uint256)
  {
    return allowance[_owner][_spender];
  }

  /**
   * @dev Increase the amount of tokens that an owner allowed to a spender.
   *
   * approve should be called when allowed[_spender] == 0. To increment
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param _spender The address which will spend the funds.
   * @param _addedValue The amount of tokens to increase the allowance by.
   */
  function increaseApproval(
    address _spender,
    uint _addedValue
  )
    public
    returns (bool)
  {
    allowance[msg.sender][_spender] = (
      allowance[msg.sender][_spender] + _addedValue);
    emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
    return true;
  }

  /**
   * @dev Decrease the amount of tokens that an owner allowed to a spender.
   *
   * approve should be called when allowed[_spender] == 0. To decrement
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param _spender The address which will spend the funds.
   * @param _subtractedValue The amount of tokens to decrease the allowance by.
   */
  function decreaseApproval(
    address _spender,
    uint _subtractedValue
  )
    public
    returns (bool)
  {
    uint oldValue = allowance[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowance[msg.sender][_spender] = 0;
    } else {
      allowance[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
    return true;
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_owner","type":"address"},{"indexed":true,"internalType":"address","name":"_spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_from","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_spender","type":"address"}],"name":"allowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_subtractedValue","type":"uint256"}],"name":"decreaseApproval","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_addedValue","type":"uint256"}],"name":"increaseApproval","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

7219:3715:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7276:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8583:194;;;;;;:::i;:::-;;:::i;:::-;;;1445:14:1;;1438:22;1420:41;;1408:2;1393:18;8583:194:0;1375:92:1;7385:45:0;;;;;;;;;2226:25:1;;;2214:2;2199:18;7385:45:0;2181:76:1;8176:395:0;;;;;;:::i;:::-;;:::i;7350:28::-;;;;;;;;;;;;2434:4:1;2422:17;;;2404:36;;2392:2;2377:18;7350:28:0;2359:87:1;9104:129:0;;;;;;:::i;:::-;-1:-1:-1;;;;;9200:17:0;;;9174:7;9200:17;;;:9;:17;;;;;;;;:27;;;;;;;;;;;;;9104:129;10483:448;;;;;;:::i;:::-;;:::i;7684:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;7315:28;;;:::i;7884:284::-;;;;;;:::i;:::-;;:::i;9702:307::-;;;;;;:::i;:::-;;:::i;7735:64::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;7276:32;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;8583:194::-;8673:10;8650:4;8663:21;;;:9;:21;;;;;;;;-1:-1:-1;;;;;8663:31:0;;;;;;;;;;:40;;;8715:38;8650:4;;8663:31;;8715:38;;;;8697:6;2226:25:1;;2214:2;2199:18;;2181:76;8715:38:0;;;;;;;;-1:-1:-1;8767:4:0;8583:194;;;;:::o;8176:395::-;-1:-1:-1;;;;;8301:16:0;;8258:12;8301:16;;;:9;:16;;;;;;8291:26;;;8283:35;;;;;;-1:-1:-1;;;;;8347:16:0;;;;;;:9;:16;;;;;;;;8364:10;8347:28;;;;;;;;8337:38;;;8329:47;;;;;;-1:-1:-1;;;;;8387:16:0;;;;;;:9;:16;;;;;:26;;8407:6;;8387:16;:26;;8407:6;;8387:26;:::i;:::-;;;;-1:-1:-1;;;;;;;8424:14:0;;;;;;:9;:14;;;;;:24;;8442:6;;8424:14;:24;;8442:6;;8424:24;:::i;:::-;;;;-1:-1:-1;;;;;;;8459:16:0;;;;;;:9;:16;;;;;;;;8476:10;8459:28;;;;;;;:38;;8491:6;;8459:16;:38;;8491:6;;8459:38;:::i;:::-;;;;;;;;8529:3;-1:-1:-1;;;;;8513:28:0;8522:5;-1:-1:-1;;;;;8513:28:0;;8534:6;8513:28;;;;2226:25:1;;2214:2;2199:18;;2181:76;8513:28:0;;;;;;;;-1:-1:-1;8559:4:0;8176:395;;;;;:::o;10483:448::-;10633:10;10591:4;10623:21;;;:9;:21;;;;;;;;-1:-1:-1;;;;;10623:31:0;;;;;;;;;;10665:27;;;10661:172;;;10713:10;10737:1;10703:21;;;:9;:21;;;;;;;;-1:-1:-1;;;;;10703:31:0;;;;;;;;;:35;10661:172;;;10795:30;:8;10808:16;10795:12;:30::i;:::-;10771:10;10761:21;;;;:9;:21;;;;;;;;-1:-1:-1;;;;;10761:31:0;;;;;;;;;:64;10661:172;10853:10;10875:21;;;;:9;:21;;;;;;;;-1:-1:-1;;;;;10844:63:0;;10875:31;;;;;;;;;;;10844:63;;2226:25:1;;;10844:63:0;;10853:10;10844:63;;2199:18:1;10844:63:0;;;;;;;-1:-1:-1;10921:4:0;;10483:448;-1:-1:-1;;;10483:448:0:o;7315:28::-;;;;;;;:::i;7884:284::-;7990:10;7947:12;7980:21;;;:9;:21;;;;;;:31;-1:-1:-1;7980:31:0;7972:40;;;;;;8033:10;8023:21;;;;:9;:21;;;;;:31;;8048:6;;8023:21;:31;;8048:6;;8023:31;:::i;:::-;;;;-1:-1:-1;;;;;;;8065:14:0;;;;;;:9;:14;;;;;:24;;8083:6;;8065:14;:24;;8083:6;;8065:24;:::i;:::-;;;;-1:-1:-1;;8105:33:0;;2226:25:1;;;-1:-1:-1;;;;;8105:33:0;;;8114:10;;8105:33;;2214:2:1;2199:18;8105:33:0;2181:76:1;9702:307:0;9874:10;9805:4;9864:21;;;:9;:21;;;;;;;;-1:-1:-1;;;;;9864:31:0;;;;;;;;;;:45;;9898:11;;9864:45;:::i;:::-;9831:10;9821:21;;;;:9;:21;;;;;;;;-1:-1:-1;;;;;9821:31:0;;;;;;;;;;;;:89;;;9922:63;2226:25:1;;;9821:31:0;;9922:63;;2199:18:1;9922:63:0;2181:76:1;815:113:0;873:7;901:1;896;:6;;889:14;;-1:-1:-1;;;889:14:0;;;;;;;;;917:5;921:1;917;:5;:::i;:::-;910:12;815:113;-1:-1:-1;;;815:113:0:o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:196::-;251:6;304:2;292:9;283:7;279:23;275:32;272:2;;;325:6;317;310:22;272:2;353:29;372:9;353:29;:::i;393:270::-;461:6;469;522:2;510:9;501:7;497:23;493:32;490:2;;;543:6;535;528:22;490:2;571:29;590:9;571:29;:::i;:::-;561:39;;619:38;653:2;642:9;638:18;619:38;:::i;:::-;609:48;;480:183;;;;;:::o;668:338::-;745:6;753;761;814:2;802:9;793:7;789:23;785:32;782:2;;;835:6;827;820:22;782:2;863:29;882:9;863:29;:::i;:::-;853:39;;911:38;945:2;934:9;930:18;911:38;:::i;:::-;901:48;;996:2;985:9;981:18;968:32;958:42;;772:234;;;;;:::o;1011:264::-;1079:6;1087;1140:2;1128:9;1119:7;1115:23;1111:32;1108:2;;;1161:6;1153;1146:22;1108:2;1189:29;1208:9;1189:29;:::i;:::-;1179:39;1265:2;1250:18;;;;1237:32;;-1:-1:-1;;;1098:177:1:o;1472:603::-;1584:4;1613:2;1642;1631:9;1624:21;1674:6;1668:13;1717:6;1712:2;1701:9;1697:18;1690:34;1742:4;1755:140;1769:6;1766:1;1763:13;1755:140;;;1864:14;;;1860:23;;1854:30;1830:17;;;1849:2;1826:26;1819:66;1784:10;;1755:140;;;1913:6;1910:1;1907:13;1904:2;;;1983:4;1978:2;1969:6;1958:9;1954:22;1950:31;1943:45;1904:2;-1:-1:-1;2059:2:1;2038:15;-1:-1:-1;;2034:29:1;2019:45;;;;2066:2;2015:54;;1593:482;-1:-1:-1;;;1593:482:1:o;2451:128::-;2491:3;2522:1;2518:6;2515:1;2512:13;2509:2;;;2528:18;;:::i;:::-;-1:-1:-1;2564:9:1;;2499:80::o;2584:125::-;2624:4;2652:1;2649;2646:8;2643:2;;;2657:18;;:::i;:::-;-1:-1:-1;2694:9:1;;2633:76::o;2714:380::-;2793:1;2789:12;;;;2836;;;2857:2;;2911:4;2903:6;2899:17;2889:27;;2857:2;2964;2956:6;2953:14;2933:18;2930:38;2927:2;;;3010:10;3005:3;3001:20;2998:1;2991:31;3045:4;3042:1;3035:15;3073:4;3070:1;3063:15;2927:2;;2769:325;;;:::o;3099:127::-;3160:10;3155:3;3151:20;3148:1;3141:31;3191:4;3188:1;3181:15;3215:4;3212:1;3205:15

ipfs://44ee5ec2b1ddbe811f50c0db8535e2e5dc3dc731c1aeef4f78aa169e20e5b841