UNIC aims to build a Turing complete decentralized financial ecological worker system, through a distributed open source agreement to establish a transparent, accessible and inclusive peer-to-peer financial system, minimize trust risks, and effectively supplement Uniswap V2 Shortcomings, forming a complete "closed loop", from multiple channels of lending, trading, futures, wallets, and insurance, holders can obtain multiple benefits from advertising and investment. This is the latest defi model.

Star us on

Crowdfunding

Use your wallet to send ETH to the crowdfunding address
• After the airdrop is over, the UNIC will be automatically sent to your source address according to the source address of your ETH
• You can transfer multiple ETHs, automatically aggregate
• This airdrop uses machine learning to identify cheating. Those who are identified as cheaters will cancel the airdrop, and those who participate in the recognition will return ETH to the original way

Airdrop instructions

• The total number of UNICs is only 210,000, and the number of airdrops is 30,000. In order to thank the UNI technical team for their technical support, we donated 1,500 UNICs to Uniswap official, and 126,000 UNICs were recognized online.

• UNIC will end the airdrop and pre-sale on  2021, and will also launch Uniswap decentralized exchange; COINTIGER, Biki, Binance and other exchanges.

Crowdfunding rules

• Total Pre-sale: 126,000 UNIC  Pre-sale time:  (UTC+8)

• Pre-sale price 1 ETH = 200 UNIC

• The quota is sorted by time, and the tokens are issued, the earlier the participation, the greater the success rate. If the pre-sale is completed, the original way will be refunded automatically if the purchase is not successful

UNIC Contract source code

0x5962DD33718C9CaeeDAE944577913Af9782e9Bab

        
* @dev Returns the addition of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint a, uint b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, "add: +");
        return c;
    }
    /**
     * @dev Returns the addition of two unsigned integers, reverting with custom message on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, errorMessage);
        return c;
    }
    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    function sub(uint a, uint b) internal pure returns (uint) {
        return sub(a, b, "sub: -");
    }
    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        require(b <= a, errorMessage);
        uint c = a - b;
        return c;
    }
    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint a, uint b) internal pure returns (uint) {
        // 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-contracts/pull/522
        if (a == 0) {
            return 0;
        }
        uint c = a * b;
        require(c / a == b, "mul: *");
        return c;
    }
    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        // 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-contracts/pull/522
        if (a == 0) {
            return 0;
        }
        uint c = a * b;
        require(c / a == b, errorMessage);
        return c;
    }