// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;

library SafeMath {

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // 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;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

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

contract Ownable {
    address public owner;
    address public newowner;
    address public admin;
    address public dev;

    constructor() public {
        owner = msg.sender;
    }

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    
    modifier onlyNewOwner {
        require(msg.sender == newowner);
        _;
    }

    function transferOwnership(address _newOwner) public onlyOwner {
        newowner = _newOwner;
    }
    
    function takeOwnership() public onlyNewOwner {
        owner = newowner;
    }    
    
    function setAdmin(address _admin) public onlyOwner {
        admin = _admin;
    }

    function setDev(address _dev) public onlyOwner {
        dev = _dev;
    }
    
    modifier onlyAdmin {
        require(msg.sender == admin || msg.sender == owner);
        _;
    }
    
    modifier onlyDev {
        require(msg.sender == dev || msg.sender == admin || msg.sender == owner);
        _;
    }
}

abstract contract ContractConn{
    function transfer(address _to, uint _value) virtual public;
    function transferFrom(address _from, address _to, uint _value) virtual public;
    function balanceOf(address who) virtual public view returns (uint);
    function burn(uint256 _value) virtual public returns(bool);
}

contract Pledge is Ownable {

    using SafeMath for uint256;
    
    struct PledgeInfo {
        uint256 id;
        address pledgeor;
        string  coinType;
        uint256 amount;
        uint256 pledgeTime;
        uint256 pledgeBlock;
        uint256 ExpireBlock;
        bool    isValid;
    }
    
    ContractConn public zild;
    
    uint256 public pledgeBlock = 90000;
    uint256 public pledgeBlockChange = 0;
    uint256 public changePledgeTime;
    bool    public needChangeTime = false; 
	uint256 public burnCount = 0;
    uint256 public totalPledge;
    
    mapping(address => PledgeInfo[]) public zild_pledge;
    mapping(address => uint256) public user_pledge_amount;

    event SetPledgeBlock(uint256 pblock,address indexed who,uint256 time);
    event EffectPledgeBlock(uint256 pblock,address indexed who,uint256 time);
    event WithdrawZILD(address indexed to,uint256 pamount,uint256 time);
    event NeedBurnPledge(address indexed to,uint256 pleid,uint256 pamount);
    event BurnPledge(address  indexed from,uint256 pleid,uint256 pamount);
    event PledgeZILD(address indexed from,uint256 pleid,uint256 pamount,uint256 bblock,uint256 eblock,uint256 time);
    
    constructor(address _zild) public {
        zild = ContractConn(_zild);
    }

    function setpledgeblock(uint256 _block) public onlyAdmin {
        require(_block > 0,"Pledge: New pledge time must be greater than 0");
        pledgeBlockChange = _block;
        changePledgeTime = block.number;
        needChangeTime = true;
        emit SetPledgeBlock(_block,msg.sender,now);
    }

    function effectblockchange() public onlyAdmin {
        require(needChangeTime,"Pledge: No new deposit time are set");
        uint256 currentTime = block.number;
        uint256 effectTime = changePledgeTime.add(pledgeBlock);
        if (currentTime < effectTime) return;
        pledgeBlock = pledgeBlockChange;
        needChangeTime = false;
        emit EffectPledgeBlock(pledgeBlockChange,msg.sender,now);
    }
    

    function burn(uint256 _amount) public onlyAdmin returns(bool) {
        require(_amount > 0 || _amount < burnCount, "pledgeBurn：The amount exceeds the amount that should be burned");
        zild.burn(_amount);
        burnCount = burnCount.sub(_amount);
        emit BurnPledge(address(msg.sender),_amount,now);
        return true;
    }

    function pledgeZILD(uint256 _amount) public returns(uint256){
        zild.transferFrom(address(msg.sender), address(this), _amount);
        uint256 length = zild_pledge[msg.sender].length;
        zild_pledge[msg.sender].push(
            PledgeInfo({
                id: length,
                pledgeor: msg.sender,
                coinType: "zild",
                amount: _amount,
                pledgeTime: now,
                pledgeBlock: block.number,
                ExpireBlock: block.number.add(pledgeBlock),
                isValid: true
            })
        );
        user_pledge_amount[msg.sender] = user_pledge_amount[msg.sender].add(_amount); 
        totalPledge = totalPledge.add(_amount);
        emit PledgeZILD(msg.sender,length,_amount,block.number,block.number.add(pledgeBlock),now);
        return length;
    }

    function invalidPledge(address _user, uint256 _id) public onlyDev {
        require(zild_pledge[_user].length > _id);
        zild_pledge[_user][_id].isValid = false;
    }
    
    function validPledge(address _user, uint256 _id) public onlyAdmin{
        require(zild_pledge[_user].length > _id);
        zild_pledge[_user][_id].isValid = true;
    }
    
    function pledgeCount(address _user)  view public returns(uint256) {
        require(msg.sender == _user || msg.sender == owner, "Pledge: Only check your own pledge records");
        return zild_pledge[_user].length;
    }
 
     function pledgeAmount(address _user)  view public returns(uint256) {
        require(msg.sender == _user || msg.sender == owner, "Pledge: Only check your own pledge records");
        return user_pledge_amount[_user];
    }
    
    function clearInvalidOrder(address _user, uint256 _pledgeId) public onlyAdmin{
        PledgeInfo memory pledgeInfo = zild_pledge[address(_user)][_pledgeId];
        if(!pledgeInfo.isValid) {
            burnCount = burnCount.add(pledgeInfo.amount);
            user_pledge_amount[_user] = user_pledge_amount[_user].sub(pledgeInfo.amount); 
            totalPledge = totalPledge.sub(pledgeInfo.amount);
            zild_pledge[address(_user)][_pledgeId].amount = 0;
            emit NeedBurnPledge(_user,_pledgeId,pledgeInfo.amount);
        }
    }
 
    function withdrawZILD(uint256 _pledgeId) public returns(bool){
        PledgeInfo memory info = zild_pledge[msg.sender][_pledgeId]; 
        require(block.number > info.ExpireBlock, "The withdrawal block has not arrived!");
        require(info.isValid, "The withdrawal pledge has been breached!");
        zild.transfer(msg.sender,info.amount);
        user_pledge_amount[msg.sender] = user_pledge_amount[msg.sender].sub(info.amount); 
        totalPledge = totalPledge.sub(info.amount);
        zild_pledge[msg.sender][_pledgeId].amount = 0;
        emit WithdrawZILD(msg.sender,zild_pledge[msg.sender][_pledgeId].amount,now);
        return true;
    }
}

{"IERC20.sol":{"content":"pragma solidity 0.5.4;\r\n\r\ninterface IERC20 {\r\n\r\n    function balanceOf(address account) external view returns (uint256);\r\n    function transfer(address recipient, uint256 amount) external returns (bool);\r\n    function allowance(address owner, address spender) external view returns (uint256);\r\n    function approve(address spender, uint256 amount) external returns (bool);\r\n    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\r\n    event Transfer(address indexed from, address indexed to, uint256 value);\r\n    event Approval(address indexed owner, address indexed spender, uint256 value);\r\n\r\n}"},"Ownable.sol":{"content":"pragma solidity 0.5.4;\r\n\r\ncontract Ownable {\r\n\r\n    address private _owner;\r\n\r\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r\n\r\n    constructor() internal {\r\n        _owner = msg.sender;\r\n        emit OwnershipTransferred(address(0), _owner);\r\n    }\r\n\r\n    function owner() public view returns (address) {\r\n        return _owner;\r\n    }\r\n\r\n    function isOwner() public view returns (bool) {\r\n        return msg.sender == _owner;\r\n    }\r\n\r\n    modifier onlyOwner() {\r\n        require(msg.sender == _owner, \"Ownable: caller is not the owner\");\r\n        _;\r\n    }\r\n\r\n    function transferOwnership(address newOwner) public onlyOwner {\r\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\r\n        emit OwnershipTransferred(_owner, newOwner);\r\n        _owner = newOwner;\r\n    }\r\n\r\n}"},"SafeMath.sol":{"content":"pragma solidity ^0.5.0;\r\n\r\n/**\r\n * @dev Wrappers over Solidity\u0027s arithmetic operations with added overflow\r\n * checks.\r\n *\r\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\r\n * in bugs, because programmers usually assume that an overflow raises an\r\n * error, which is the standard behavior in high level programming languages.\r\n * `SafeMath` restores this intuition by reverting the transaction when an\r\n * operation overflows.\r\n *\r\n * Using this library instead of the unchecked operations eliminates an entire\r\n * class of bugs, so it\u0027s recommended to use it always.\r\n */\r\nlibrary SafeMath {\r\n    /**\r\n     * @dev Returns the addition of two unsigned integers, reverting on\r\n     * overflow.\r\n     *\r\n     * Counterpart to Solidity\u0027s `+` operator.\r\n     *\r\n     * Requirements:\r\n     * - Addition cannot overflow.\r\n     */\r\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        uint256 c = a + b;\r\n        require(c \u003e= a, \"SafeMath: addition overflow\");\r\n\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the subtraction of two unsigned integers, reverting on\r\n     * overflow (when the result is negative).\r\n     *\r\n     * Counterpart to Solidity\u0027s `-` operator.\r\n     *\r\n     * Requirements:\r\n     * - Subtraction cannot overflow.\r\n     */\r\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return sub(a, b, \"SafeMath: subtraction overflow\");\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\r\n     * overflow (when the result is negative).\r\n     *\r\n     * Counterpart to Solidity\u0027s `-` operator.\r\n     *\r\n     * Requirements:\r\n     * - Subtraction cannot overflow.\r\n     *\r\n     * _Available since v2.4.0._\r\n     */\r\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r\n        require(b \u003c= a, errorMessage);\r\n        uint256 c = a - b;\r\n\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the multiplication of two unsigned integers, reverting on\r\n     * overflow.\r\n     *\r\n     * Counterpart to Solidity\u0027s `*` operator.\r\n     *\r\n     * Requirements:\r\n     * - Multiplication cannot overflow.\r\n     */\r\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        // Gas optimization: this is cheaper than requiring \u0027a\u0027 not being zero, but the\r\n        // benefit is lost if \u0027b\u0027 is also tested.\r\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\r\n        if (a == 0) {\r\n            return 0;\r\n        }\r\n\r\n        uint256 c = a * b;\r\n        require(c / a == b, \"SafeMath: multiplication overflow\");\r\n\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the integer division of two unsigned integers. Reverts on\r\n     * division by zero. The result is rounded towards zero.\r\n     *\r\n     * Counterpart to Solidity\u0027s `/` operator. Note: this function uses a\r\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\r\n     * uses an invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return div(a, b, \"SafeMath: division by zero\");\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\r\n     * division by zero. The result is rounded towards zero.\r\n     *\r\n     * Counterpart to Solidity\u0027s `/` operator. Note: this function uses a\r\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\r\n     * uses an invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     * - The divisor cannot be zero.\r\n     *\r\n     * _Available since v2.4.0._\r\n     */\r\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r\n        // Solidity only automatically asserts when dividing by 0\r\n        require(b \u003e 0, errorMessage);\r\n        uint256 c = a / b;\r\n        // assert(a == b * c + a % b); // There is no case in which this doesn\u0027t hold\r\n\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\r\n     * Reverts when dividing by zero.\r\n     *\r\n     * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\r\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\r\n     * invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        return mod(a, b, \"SafeMath: modulo by zero\");\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\r\n     * Reverts with custom message when dividing by zero.\r\n     *\r\n     * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\r\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\r\n     * invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     * - The divisor cannot be zero.\r\n     *\r\n     * _Available since v2.4.0._\r\n     */\r\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r\n        require(b != 0, errorMessage);\r\n        return a % b;\r\n    }\r\n}"},"ZildFinance.sol":{"content":"pragma solidity 0.5.4;\r\n\r\nimport \u0027SafeMath.sol\u0027;\r\nimport \u0027Ownable.sol\u0027;\r\nimport \u0027IERC20.sol\u0027;\r\n\r\ncontract ZildFinanceCoin is Ownable, IERC20 {\r\n\r\n    using SafeMath for uint256;\r\n\r\n    string public constant name = \u0027Zild Finance Coin\u0027;\r\n    string public constant symbol = \u0027Zild\u0027;\r\n    uint8 public constant decimals = 18;\r\n    uint256 public totalSupply = 9980 * 10000 * 10 ** uint256(decimals);\r\n    uint256 public allowBurn = 2100 * 10000 * 10 ** uint256(decimals);\r\n    uint256 public tokenDestroyed;\r\n\t\r\n    uint256 public constant FounderAllocation = 1497 * 10000 * 10 ** uint256(decimals);\r\n    uint256 public constant FounderLockupAmount = 998 * 10000 * 10 ** uint256(decimals);\r\n    uint256 public constant FounderLockupCliff = 365 days;\r\n    uint256 public constant FounderReleaseInterval = 30 days;\r\n    uint256 public constant FounderReleaseAmount = 20.7916 * 10000 * 10 ** uint256(decimals);\r\n    uint256 public constant MarketingAllocation = 349 * 10000 * 10 ** uint256(decimals);\r\n    uint256 public constant FurnaceAllocation = 150 * 10000 * 10 ** uint256(decimals);\r\n\t\r\n    address public founder = address(0);\r\n    uint256 public founderLockupStartTime = 0;\r\n    uint256 public founderReleasedAmount = 0;\r\n\r\n    mapping (address =\u003e uint256) private _balances;\r\n    mapping (address =\u003e mapping (address =\u003e uint256)) private _allowances;    \r\n    mapping (address =\u003e bool) public frozenAccount;\r\n\r\n    event Transfer(address indexed from, address indexed to, uint256 value);\r\n    event Approval(address indexed from, address indexed to, uint256 value);\r\n    event ChangeFounder(address indexed previousFounder, address indexed newFounder);\r\n    event SetMinter(address indexed minter);\r\n    event SetMarketing(address indexed marketing);\r\n    event SetFurnace(address indexed furnace);\t\r\n    event Burn(address indexed _from, uint256 _tokenDestroyed, uint256 _timestamp);\r\n    event FrozenFunds(address target, bool frozen);\r\n\t\r\n    constructor(address _founder, address _marketing) public {\r\n        require(_founder != address(0), \"ZildFinanceCoin: founder is the zero address\");\r\n        require(_marketing != address(0), \"ZildFinanceCoin: operator is the zero address\");\r\n        founder = _founder;\r\n        founderLockupStartTime = block.timestamp;\r\n        _balances[address(this)] = totalSupply;\r\n        _transfer(address(this), _marketing, MarketingAllocation);\r\n    }\r\n\r\n    function release() public {\r\n        uint256 currentTime = block.timestamp;\r\n        uint256 cliffTime = founderLockupStartTime.add(FounderLockupCliff);\r\n        if (currentTime \u003c cliffTime) return;\r\n        if (founderReleasedAmount \u003e= FounderLockupAmount) return;\r\n        uint256 month = currentTime.sub(cliffTime).div(FounderReleaseInterval);\r\n        uint256 releaseAmount = month.mul(FounderReleaseAmount);\r\n        if (releaseAmount \u003e FounderLockupAmount) releaseAmount = FounderLockupAmount;\r\n        if (releaseAmount \u003c= founderReleasedAmount) return;\r\n        uint256 amount = releaseAmount.sub(founderReleasedAmount);\r\n        founderReleasedAmount = releaseAmount;\r\n        _transfer(address(this), founder, amount);\r\n    }\r\n\r\n    function balanceOf(address account) public view returns (uint256) {\r\n        return _balances[account];\r\n    }\r\n\r\n    function transfer(address to, uint256 amount) public returns (bool) {\r\n        require(to != address(0), \"ERC20: tranfer to the zero address\");\r\n        require(!frozenAccount[msg.sender]);\r\n        require(!frozenAccount[to]);\r\n        _transfer(msg.sender, to, amount);\r\n        return true;\r\n    }\r\n\t\r\n    function burn(uint256 _value) public returns (bool){\r\n        _burn(msg.sender, _value);\r\n        return true;\r\n    }\r\n\r\n    function _burn(address _who, uint256 _burntAmount) internal {\r\n        require (tokenDestroyed.add(_burntAmount) \u003c= allowBurn, \"ZildFinanceCoin: exceeded the maximum allowable burning amount\" );\r\n        require(_balances[msg.sender] \u003e= _burntAmount \u0026\u0026 _burntAmount \u003e 0);\r\n        _transfer(address(_who), address(0), _burntAmount);\r\n        totalSupply = totalSupply.sub(_burntAmount);\r\n        tokenDestroyed = tokenDestroyed.add(_burntAmount);\r\n        emit Burn(_who, _burntAmount, block.timestamp);\r\n    }\r\n\t\r\n\r\n    function allowance(address from, address to) public view returns (uint256) {\r\n        return _allowances[from][to];\r\n    }\r\n\r\n    function approve(address to, uint256 amount) public returns (bool) {\r\n        _approve(msg.sender, to, amount);\r\n        return true;\r\n    }\r\n\r\n    function transferFrom(address from, address to, uint256 amount) public returns (bool) {\r\n        uint256 remaining = _allowances[from][msg.sender].sub(amount, \"ERC20: transfer amount exceeds allowance\");\r\n        require(to != address(0), \"ERC20: tranfer to the zero address\");\r\n        require(!frozenAccount[from]);\r\n        require(!frozenAccount[to]);\r\n        require(!frozenAccount[msg.sender]);\r\n        _transfer(from, to, amount);\r\n        _approve(from, msg.sender, remaining);\r\n        return true;\r\n    }\r\n\r\n    function _transfer(address from, address to, uint256 amount) private {\r\n        require(from != address(0), \"ERC20: transfer from the zero address\");\r\n        _balances[from] = _balances[from].sub(amount, \"ERC20: transfer amount exceeds balance\");\r\n        _balances[to] = _balances[to].add(amount);\r\n        emit Transfer(from, to, amount);\r\n    }\r\n\r\n    function _approve(address from, address to, uint256 amount) private {\r\n        require(from != address(0), \"ERC20: approve from the zero address\");\r\n        require(to != address(0), \"ERC20: approve to the zero address\");\r\n        _allowances[from][to] = amount;\r\n        emit Approval(from, to, amount);\r\n    }\r\n\r\n    function changeFounder(address _founder) public onlyOwner {\r\n        require(_founder != address(0), \"ZildFinanceCoin: founder is the zero address\");\r\n        emit ChangeFounder(founder, _founder);\r\n        founder = _founder;\r\n    }\r\n\r\n    function setMinter(address minter) public onlyOwner {\r\n        require(minter != address(0), \"ZildFinanceCoin: minter is the zero address\");\r\n        require(_balances[minter] == 0, \"ZildFinanceCoin: minter has been initialized\");\r\n        _transfer(address(this), minter, totalSupply.sub(FounderAllocation));\r\n        emit SetMinter(minter);\r\n    }\r\n\r\n    function setFurnace(address furnace) public onlyOwner {\r\n        require(furnace != address(0), \"ZildFinanceCoin: furnace is the zero address\");\r\n        require(_balances[furnace] == 0, \"ZildFinanceCoin: furnace has been initialized\");\r\n        _transfer(address(this), furnace, FurnaceAllocation);\r\n        emit SetFurnace(furnace);\r\n    }\r\n\t\r\n    function freezeAccount(address _target, bool _bool) public onlyOwner {\r\n        if (_target != address(0)) {\r\n            frozenAccount[_target] = _bool;\r\n            emit FrozenFunds(_target,_bool);\r\n        }\r\n    }\r\n\r\n}"}}