YFIN全称YFI.Name是DEFI治理型代币YFI的永久流动性与抵消无常损失的先行者,一种基于流动性,同时通过永久流动治理来抵消无常损失的通胀代币,下一代智能聚合器。支持多种DeFi协议的聚合理财平台,基于 YFII 分叉而来,简化用户门槛, 并提供更低的费率, 助长 DEFI 生态。YFIN将用户存入的不同代币汇集到不同的池中,然后根据策略调动某代币池的资金参与不同的流动性挖矿,从而实现更高的收益。

Star us on

YFNPOOL

YFNP全称YFNPOOL,是YFIN流动性挖矿产出的代币,YFNP总量6,000,000枚,头矿2倍奖励30天,1.2万/天,每150万进行减半,预计10年挖完。

YFNP为YFIN永久流动性与抵消无常损失的产物,通过YFIN金融系统挖矿产出.YFNP应用于NFT游戏,NFT卡牌,区块猫,YFIN借贷,YFIN交易所,YFIN治理等居多场景。YFNP是未来。

ETH 地址

空投说明 Crowdfunding-Anweisungen

YFIN总量60000枚,为感谢YFI技术团队的技术支持,我们向YFI官方捐赠1,000枚! 向YFIN发送ERC20地址即可参与本次空投活动。参加活动用户即可获得0.1枚YFIN,每邀请一位好友增加0.1枚,最多可获得4枚YFIN。空投赠送给YFIN参与者和推广者4000枚!社区众筹25000枚,DEFI流动性挖矿30000枚!

YFIN空投结束后,并发放代币,同时上线Uniswap等头部去中心化交易所,Binance huobi okex等头部中心化交易所;

众筹规则

众筹总量 55000 YFIN, 众筹时间:2020-10-12 至 2020-12-02(UTC+8)

众筹价格 1 ETH = 30 YFIN

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

众筹方式

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

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

可转账多笔ETH,自动汇总

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

YFIN智能合约源代码

0x2a7e79b5f3d8efb718943191a6daf19955a501f4

                    
     pragma solidity ^0.5.2;

         contract  IYFIN {

            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 YFIN is IYFIN {
            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 YFIN(
                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];
        }
    }