// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;

interface ISCRYERC20 {
    // event Approval(address indexed owner, address indexed spender, uint value);
    // event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;

import './ISCRYERC20.sol';

interface ISCRYERC20Permit is ISCRYERC20 {
    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;

interface ISCRYFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);
    function lpTokens(address) external view returns (bool);

    function createPair(address tokenA, address tokenB) external returns (address pair, address stashTokenA, address stashTokenB);
    function oldMajor() external view returns (address);
    function tokenFactory() external view returns (address);
    function stashETH() external view returns (address);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;

interface ISCRYPairTransferable {
    function transferFromPool(address to, uint value) external returns (bool);
    // function balanceOf(address owner) external returns (uint);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0;

import './ISCRYERC20.sol';
import './ISCRYPairTransferable.sol';

interface IStashToken is ISCRYPairTransferable {
    // needs permit
    function underlying() external returns (ISCRYERC20);
    function depositFor(address to, uint256 amount) external returns (bool);
    function depositForWithPermit(address to, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
    function deposit() external returns (uint256);
    function depositTo(address to) external returns (uint256);
    function withdrawTo(address account, uint amount) external returns (bool);
    function withdrawFrom(address from, address to, uint amount) external returns (bool);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity =0.6.12;

import './interfaces/ISCRYERC20Permit.sol';
import './interfaces/ISCRYFactory.sol';
import './libraries/SafeMath.sol';

abstract contract SLOWERC20 is ISCRYERC20Permit {
    using SafeMath for uint;

    uint internal _totalSupply;
    mapping(address => uint) public override balanceOf;
    mapping(address => mapping(address => uint)) public override allowance;

    bytes32 public override immutable DOMAIN_SEPARATOR;
    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 public override constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
    mapping(address => uint) public override nonces;

    mapping (address => uint) internal lastReceivedBlock;
    uint internal immutable BLOCK_HOLDING_PERIOD;

    constructor(uint blockHoldingPeriod) public {
        uint chainId;
        assembly {
            chainId := chainid()
        }
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
                keccak256(bytes(name())),
                keccak256(bytes('1')),
                chainId,
                address(this)
            )  
        );
        BLOCK_HOLDING_PERIOD = blockHoldingPeriod;
    }

    function name() public view override virtual returns (string memory);

    function symbol() external view override virtual returns (string memory);

    function decimals() external view override virtual returns (uint8) {
        return 18;
    }

    function _mint(address to, uint value) internal virtual {
        _totalSupply = _totalSupply.add(value);
        balanceOf[to] = balanceOf[to].add(value);
        // emit Transfer(address(0), to, value);
    }

    function _burn(address from, uint value) internal {
        require(block.number.sub(lastReceivedBlock[from]) >= BLOCK_HOLDING_PERIOD, 'SLOWERC20: BLOCKED');

        balanceOf[from] = balanceOf[from].sub(value);
        _totalSupply = _totalSupply.sub(value);
        // emit Transfer(from, address(0), value);
    }

    function _approve(address owner, address spender, uint value) private {
        allowance[owner][spender] = value;
        // emit Approval(owner, spender, value);
    }

    function _transfer(address from, address to, uint value) internal {
        require(block.number.sub(lastReceivedBlock[from]) >= BLOCK_HOLDING_PERIOD, 'SLOWERC20: BLOCKED');
        balanceOf[from] = balanceOf[from].sub(value);
        balanceOf[to] = balanceOf[to].add(value);
        // emit Transfer(from, to, value);
    }

    function approve(address spender, uint value) external override returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    function transfer(address to, uint value) external override returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    function transferFrom(address from, address to, uint value) public override returns (bool) {
        if (allowance[from][msg.sender] != 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) {
            allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
        }
        _transfer(from, to, value);
        return true;
    }

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external override {
        require(deadline >= block.timestamp, 'SLOWERC20: EXPIRED');
        bytes32 digest = keccak256(
            abi.encodePacked(
                '\x19\x01',
                DOMAIN_SEPARATOR,
                keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
            )
        );
        address recoveredAddress = ecrecover(digest, v, r, s);
        require(recoveredAddress != address(0) && recoveredAddress == owner, 'SLOWERC20: INVALID_SIGNATURE');
        _approve(owner, spender, value);
    }

    function totalSupply() external view override virtual returns (uint) {
        return _totalSupply;
    }
}

pragma solidity >=0.5.0;

// a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)

library SafeMath {
    function add(uint x, uint y) internal pure returns (uint z) {
        require((z = x + y) >= x, 'ds-math-add-overflow');
    }

    function sub(uint x, uint y) internal pure returns (uint z) {
        require((z = x - y) <= x, 'ds-math-sub-underflow');
    }

    function mul(uint x, uint y) internal pure returns (uint z) {
        require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity =0.6.12;

import './SLOWERC20.sol';
import './interfaces/IStashToken.sol';
import './interfaces/ISCRYERC20.sol';
import '../solidity-lib/libraries/TransferHelper.sol';

contract StashToken is IStashToken, SLOWERC20 {
    ISCRYERC20 public override immutable underlying;
    address private immutable factory;

    // event Deposit(address indexed dst, uint wad);
    // event DepositTo(address indexed src, address indexed dst, uint wad);
    // event DepositFor(address indexed src, address indexed dst, uint wad);
    // event WithdrawalTo(address indexed src, address indexed to, uint wad);    
    // event WithdrawalFrom(address indexed src, address indexed to, uint wad);    

    constructor(address _factory, address _underlying) public SLOWERC20(5) {
        underlying = ISCRYERC20(_underlying);
        factory = _factory;
    }

    function name() public view virtual override returns (string memory) {
        return 'ScurrySwap Stash Token';
    }

    function symbol() external view virtual override returns (string memory) {
        return string(abi.encodePacked('stash-', ISCRYERC20(underlying).symbol()));
    }

    function decimals() external view override returns (uint8) {
        return underlying.decimals();
    }

    function depositFor(address to, uint256 amount) external virtual override returns (bool) {
        // for fee-on-transfer, need to use balanceOf
        TransferHelper.safeTransferFrom(address(underlying), msg.sender, address(this), amount);
        _mint(to, underlying.balanceOf(address(this)).sub(_totalSupply));
        // emit DepositFor(msg.sender, to, amount);

        return true;
    }

    function depositForWithPermit(address to, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
        ISCRYERC20Permit(address(underlying))
          .permit(msg.sender, address(this), amount, deadline, v, r, s);
        TransferHelper.safeTransferFrom(address(underlying), msg.sender, address(this), amount);
        _mint(to, underlying.balanceOf(address(this)).sub(_totalSupply));
        // emit DepositFor(msg.sender, to, amount);

        return true;
    }

    function deposit() external virtual override returns (uint256) {
        uint256 value = underlying.balanceOf(address(this)).sub(_totalSupply);
        _mint(msg.sender, value);
        // emit Deposit(msg.sender, value);

        return value;
    }

    function depositTo(address to) external virtual override returns (uint256) {
        uint256 value = underlying.balanceOf(address(this)).sub(_totalSupply);
        _mint(to, value);
        // emit DepositTo(msg.sender, to, value);

        return value;
    }

    // adds hold time if transferring from pool unless `to` is another pair token
    function transferFromPool(address to, uint256 value) external override returns (bool) {
        require(ISCRYFactory(factory).lpTokens(msg.sender), 'StashToken: FORBIDDEN');
        _transfer(msg.sender, to, value);
        if (!ISCRYFactory(factory).lpTokens(to) ) {
            lastReceivedBlock[to] = block.number;
        }
        return true;
    }

    function withdrawTo(address account, uint amount) external virtual override returns (bool) {
        _burn(msg.sender, amount);
        TransferHelper.safeTransfer(address(underlying), account, amount);
        // emit WithdrawalTo(msg.sender, account, amount);
        return true;
    }

    function withdrawFrom(address from, address to, uint amount) external virtual override returns (bool) {
        address sender = msg.sender;
        if (allowance[from][sender] != 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) {
            allowance[from][sender] = allowance[from][sender].sub(amount);
        }
        _burn(from, amount);
        TransferHelper.safeTransfer(address(underlying), to, amount);
        // emit WithdrawalFrom(from, to, amount);

        return true;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity >=0.6.0;

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::safeApprove: approve failed'
        );
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::safeTransfer: transfer failed'
        );
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::transferFrom: transferFrom failed'
        );
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');
    }
}

{
  "compilationTarget": {
    "contracts/core/StashToken.sol": "StashToken"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 999999
  },
  "remappings": []
}