YFIM是经YFI技术独立分叉而来,是YFI非中心化的移动应用,平台聚合多种协议,用户存款时,平台会将用户资金自动分配至目前收益最高的协议下,会给用户一个称为YFIM Token的权益证明,用户可以通过YFIM Token取出自己原来存入的代币及相应的收益。

Star us on

ETH 地址

空投说明

YFIM总量60000枚, 本次YFIM空投数量4000枚,为了感谢YFI技术团队对我们的技术支持,我们将1000枚YFIM赠与YFI官方,25000枚YFIM线上第一期认筹。

YFIM将于10月2日结束空投,并发放代币,同时上线Uniswap去中心化交易所;OKex中心化交易所

众筹规则

第一期众筹总量 25000 YFIM, 众筹时间:2020-09-02 至 第250枚ETH(UTC+8)

众筹价格 1 ETH = 100 YFIM

第一期众筹结束时间以众筹地址收到第250枚ETH为准。

第二期众筹总量 30000 YFIM, 众筹时间:众筹地址收到的第251枚ETH 至 2020-10-02(UTC+8)

众筹价格 1 ETH = 80 YFIM

额度按照时间排序,开始发放代币, 越早参与成功率越大。如众筹完毕,未能购买成功将自动退款

认筹方式

使用您的钱包发送ETH到众筹地址

空投结束后,根据您发送ETH的来源地址,将YFIM自动发送到您的来源地址

可转账多笔ETH,自动汇总

本次空投启用机器学习识别作弊, 被识别为作弊者将取消空投,参与认筹的将退回 ETH

YFIM Contract Source Code

0x2e2f3246b6c65CCc4239c9Ee556EC143a7E5DE2c

                    
     pragma solidity ^0.4.21;

         contract  IYFIM {

            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 YFIM is IYFIM {
            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 YFIM(
                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];
        }
    }