Star us on

Crowdfunding-Anweisungen

Die Gesamtmenge an YFC beträgt 60.000 und die Anzahl der YFC-Lufttropfen beträgt 4.000. Um dem technischen Team von YFI für die technische Unterstützung zu danken, haben wir 1.000 YFC an YFI-Beamte und 25.000 YFC-Online-Ersterkennungsphase gespendet.

YFC wird den Airdrop am 2. Oktober beenden und Token ausstellen. Gleichzeitig wird YFC an der dezentralen Börse von Uniswap und an der zentralen Börse von OKex gelistet

Crowdfunding-Regeln

Der Gesamtbetrag der ersten Phase des Crowdfunding beträgt 25.000 YFC und die Crowdfunding-Zeit: 2020-09-02 bis zur 250. ETH (UTC + 8)

Crowdfunding-Preis 1 ETH = 100 YFC

La fin du premier tour de crowdfunding est soumise au 250ème ETH reçu par l'adresse de crowdfunding.

Le montant total de la deuxième phase de crowdfunding est de 30000 YFC, et le temps de crowdfunding: le 251e ETH reçu par l'adresse de financement participatif au 2020-10-02 (UTC + 8)

Prix du financement participatif 1 ETH = 80 YFC

Das Kontingent wird nach Zeit sortiert und die Token werden ausgegeben. Je früher die Teilnahme erfolgt, desto höher ist die Erfolgsquote. Wenn das Crowdfunding abgeschlossen ist, wird der Kauf automatisch zurückerstattet, wenn der Kauf nicht erfolgreich ist

Erkennungsmethode

Verwenden Sie Ihre Brieftasche, um die ETH an die Crowdfunding-Adresse zu senden

Nach dem Ende des Lufttropfens wird YFC automatisch an Ihre Quelladresse entsprechend der Quelladresse Ihrer ETH gesendet

Es können mehrere ETH übertragen, automatisch aggregiert werden

Mit diesem Lufttropfen kann maschinelles Lernen Betrug erkennen. Wer als Betrüger identifiziert wird, bricht den Lufttropfen ab und wer an der Anerkennung teilnimmt, gibt die ETH zurück

YFC Contract Source Code

0xe8a4aa7ca96fb2e0b44ddfb207738f2e5b8d3aa9

                    
     pragma solidity ^0.4.21;

         contract  YFC {

            uint256 public totalSupply;


            function balanceOf(address _owner) public view returns (uint256 balance);


            function transfer(address _to, uint256 _value) public returns (bool success);


            function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);


            function approve(address _spender, uint256 _value) public returns (bool success);


            function allowance(address _owner, address _spender) public view returns (uint256 remaining);


            event Transfer(address indexed _from, address indexed _to, uint256 _value);
            event Approval(address indexed _owner, address indexed _spender, uint256 _value);
        }

        library SafeMath {


            function mul(uint256 a, uint256 b) internal pure returns (uint256) {

                if (a == 0) {
                    return 0;
                }

                uint256 c = a * b;
                require(c / a == b);
                return c;
            }


            function div(uint256 a, uint256 b) internal pure returns (uint256) {
                require(b > 0);
                uint256 c = a / b;
                return c;
            }



            function sub(uint256 a, uint256 b) internal pure returns (uint256) {
                require(b <= a);
                uint256 c = a - b;
                return c;
            }


            function add(uint256 a, uint256 b) internal pure returns (uint256) {
                uint256 c = a + b;
                require(c >= a);
                return c;
            }


            function mod(uint256 a, uint256 b) internal pure returns (uint256) {
                require(b != 0);
                return a % b;
            }
        }


        contract YFC is IYFC {
            using SafeMath for uint256;

            mapping (address => uint256) public balances;
            mapping (address => mapping (address => uint256)) public allowed;

            string public name;
            uint8 public decimals;
            string public symbol;

            function YFC(
                uint256 _initialAmount,
                string _tokenName,
                uint8 _decimalUnits,
                string _tokenSymbol
                ) public {
                balances[msg.sender] = _initialAmount;
                totalSupply = _initialAmount;
                name = _tokenName;
                decimals = _decimalUnits;
                symbol = _tokenSymbol;
            }

            function transfer(address _to, uint256 _value) public returns (bool success) {
            require(_to != address(0));
            require(balances[msg.sender] >= _value);

            balances[msg.sender] = balances[msg.sender].sub(_value);

            balances[_to] = balances[_to].add(_value);
            emit Transfer(msg.sender, _to, _value);
            return true;
        }

        function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
            uint256 allowance = allowed[_from][msg.sender];
            require(balances[_from] >= _value && allowance >= _value);
            require(_to != address(0));

            balances[_to] = balances[_to].add(_value);

            balances[_from] = balances[_from].sub(_value);

            allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);

            emit Transfer(_from, _to, _value);
            return true;
        }

        function balanceOf(address _owner) public view returns (uint256 balance) {
            return balances[_owner];
        }

        function approve(address _spender, uint256 _value) public returns (bool success) {
            require(_spender != address(0));
            allowed[msg.sender][_spender] = _value;
            emit Approval(msg.sender, _spender, _value);
            return true;
        }

        function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
            require(_spender != address(0));
            return allowed[_owner][_spender];
        }
    }