Contract Source Code:

// 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 './ISCRYPairTransferable.sol';

interface IStashETH is ISCRYPairTransferable {
    function deposit() external payable returns (uint256);
    function depositFor(address to) external payable returns (bool);
    function withdraw(uint amount) external returns (bool);
    function withdrawTo(address account, uint amount) external returns (bool);
}

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 './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;
    }
}

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

import './SLOWERC20.sol';
import './interfaces/IStashETH.sol';

contract StashETH is IStashETH, SLOWERC20 {
    address immutable private factory;

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

    constructor(address _factory) public SLOWERC20(5) {
        factory = _factory;
    }

    receive() payable external {
        deposit();
    }

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

    function symbol() external view override returns (string memory) {
        return 'stash-ETH';
    }

    function deposit() public payable override returns (uint256) {
        balanceOf[msg.sender] = balanceOf[msg.sender].add(msg.value);
        // emit Deposit(msg.sender, msg.value);
        return msg.value;
    }

    function depositFor(address to) external payable override returns (bool) {
        balanceOf[to] = balanceOf[to].add(msg.value);
        // emit DepositFor(msg.sender, to, msg.value);
        return true;
    }

    function withdraw(uint wad) external override returns (bool) {
        require(block.number.sub(lastReceivedBlock[msg.sender]) >= BLOCK_HOLDING_PERIOD, 'StashETH: BLOCKED');
        balanceOf[msg.sender] = balanceOf[msg.sender].sub(wad);
        payable(msg.sender).transfer(wad);
        // emit Withdrawal(msg.sender, wad);
        return true;
    }

    function withdrawTo(address account, uint wad) external override returns (bool) {
        require(block.number.sub(lastReceivedBlock[msg.sender]) >= BLOCK_HOLDING_PERIOD, 'StashETH: BLOCKED');
        balanceOf[msg.sender] = balanceOf[msg.sender].sub(wad);
        payable(account).transfer(wad);
        // emit WithdrawalTo(msg.sender, account, wad);
        return true;   
    }

    function totalSupply() external view override returns (uint) {
        return address(this).balance;
    }

    function transferFromPool(address to, uint256 value) external override returns (bool) {
        require(ISCRYFactory(factory).lpTokens(msg.sender), 'StashETH: FORBIDDEN');
        _transfer(msg.sender, to, value);
        if (!ISCRYFactory(factory).lpTokens(to) ) {
            lastReceivedBlock[to] = block.number;
        }
        return true;
    }
}