Abracadabra.money

1contract sSpell is IERC20, Domain {
2    using BoringMath for uint256;
3    using BoringMath128 for uint128;
4    using BoringERC20 for IERC20;
5​
6    string public constant symbol = "sSPELL";
7    string public constant name = "Staked Spell Tokens";
8    uint8 public constant decimals = 18;
9    uint256 public override totalSupply;
10    uint256 private constant LOCK_TIME = 24 hours;
11​
12    IERC20 public immutable token;
13​
14    constructor(IERC20 _token) public {
15        token = _token;
16    }
17​
18    struct User {
19        uint128 balance;
20        uint128 lockedUntil;
21    }
22​
23    /// @notice owner > balance mapping.
24    mapping(address => User) public users;
25    /// @notice owner > spender > allowance mapping.
26    mapping(address => mapping(address => uint256)) public override allowance;
27    /// @notice owner > nonce mapping. Used in `permit`.
28    mapping(address => uint256) public nonces;
29​
30    event Transfer(address indexed _from, address indexed _to, uint256 _value);
31    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
32​
33    function balanceOf(address user) public view override returns (uint256 balance) {
34        return users[user].balance;
35    }
36​
37    function _transfer(
38        address from,
39        address to,
40        uint256 shares
41    ) internal {
42        User memory fromUser = users[from];
43        require(block.timestamp >= fromUser.lockedUntil, "Locked");
44        if (shares != 0) {
45            require(fromUser.balance >= shares, "Low balance");
46            if (from != to) {
47                require(to != address(0), "Zero address"); // Moved down so other failed calls safe some gas
48                User memory toUser = users[to];
49                users[from].balance = fromUser.balance - shares.to128(); // Underflow is checked
50                users[to].balance = toUser.balance + shares.to128(); // Can't overflow because totalSupply would be greater than 2^128-1;
51            }
52        }
53        emit Transfer(from, to, shares);
54    }
55​
56    function _useAllowance(address from, uint256 shares) internal {
57        if (msg.sender == from) {
58            return;
59        }
60        uint256 spenderAllowance = allowance[from][msg.sender];
61        // If allowance is infinite, don't decrease it to save on gas (breaks with EIP-20).
62        if (spenderAllowance != type(uint256).max) {
63            require(spenderAllowance >= shares, "Low allowance");
64            allowance[from][msg.sender] = spenderAllowance - shares; // Underflow is checked
65        }
66    }
67​
68    /// @notice Transfers `shares` tokens from `msg.sender` to `to`.
69    /// @param to The address to move the tokens.
70    /// @param shares of the tokens to move.
71    /// @return (bool) Returns True if succeeded.
72    function transfer(address to, uint256 shares) public returns (bool) {
73        _transfer(msg.sender, to, shares);
74        return true;
75    }
76​
77    /// @notice Transfers `shares` tokens from `from` to `to`. Caller needs approval for `from`.
78    /// @param from Address to draw tokens from.
79    /// @param to The address to move the tokens.
80    /// @param shares The token shares to move.
81    /// @return (bool) Returns True if succeeded.
82    function transferFrom(
83        address from,
84        address to,
85        uint256 shares
86    ) public returns (bool) {
87        _useAllowance(from, shares);
88        _transfer(from, to, shares);
89        return true;
90    }
91​
92    /// @notice Approves `amount` from sender to be spend by `spender`.
93    /// @param spender Address of the party that can draw from msg.sender's account.
94    /// @param amount The maximum collective amount that `spender` can draw.
95    /// @return (bool) Returns True if approved.
96    function approve(address spender, uint256 amount) public override returns (bool) {
97        allowance[msg.sender][spender] = amount;
98        emit Approval(msg.sender, spender, amount);
99        return true;
100    }
101​
102    // solhint-disable-next-line func-name-mixedcase
103    function DOMAIN_SEPARATOR() external view returns (bytes32) {
104        return _domainSeparator();
105    }
106​
107    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
108    bytes32 private constant PERMIT_SIGNATURE_HASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
109​
110    /// @notice Approves `value` from `owner_` to be spend by `spender`.
111    /// @param owner_ Address of the owner.
112    /// @param spender The address of the spender that gets approved to draw from `owner_`.
113    /// @param value The maximum collective amount that `spender` can draw.
114    /// @param deadline This permit must be redeemed before this deadline (UTC timestamp in seconds).
115    function permit(
116        address owner_,
117        address spender,
118        uint256 value,
119        uint256 deadline,
120        uint8 v,
121        bytes32 r,
122        bytes32 s
123    ) external override {
124        require(owner_ != address(0), "Zero owner");
125        require(block.timestamp < deadline, "Expired");
126        require(
127            ecrecover(_getDigest(keccak256(abi.encode(PERMIT_SIGNATURE_HASH, owner_, spender, value, nonces[owner_]++, deadline))), v, r, s) ==
128                owner_,
129            "Invalid Sig"
130        );
131        allowance[owner_][spender] = value;
132        emit Approval(owner_, spender, value);
133    }
134​
135    // math is ok, because amount, totalSupply and shares is always 0 <= amount <= 100.000.000 * 10^18
136    // theoretically you can grow the amount/share ratio, but it's not practical and useless
137    function mint(uint256 amount) public returns (bool) {
138        require(msg.sender != address(0), "Zero address");
139        User memory user = users[msg.sender];
140​
141        uint256 totalTokens = token.balanceOf(address(this));
142        uint256 shares = totalSupply == 0 ? amount : (amount * totalSupply) / totalTokens;
143        user.balance += shares.to128();
144        user.lockedUntil = (block.timestamp + LOCK_TIME).to128();
145        users[msg.sender] = user;
146        totalSupply += shares;
147​
148        token.safeTransferFrom(msg.sender, address(this), amount);
149​
150        emit Transfer(address(0), msg.sender, shares);
151        return true;
152    }
153​
154    function _burn(
155        address from,
156        address to,
157        uint256 shares
158    ) internal {
159        require(to != address(0), "Zero address");
160        User memory user = users[from];
161        require(block.timestamp >= user.lockedUntil, "Locked");
162        uint256 amount = (shares * token.balanceOf(address(this))) / totalSupply;
163        users[from].balance = user.balance.sub(shares.to128()); // Must check underflow
164        totalSupply -= shares;
165​
166        token.safeTransfer(to, amount);
167​
168        emit Transfer(from, address(0), shares);
169    }
170​
171    function burn(address to, uint256 shares) public returns (bool) {
172        _burn(msg.sender, to, shares);
173        return true;
174    }
175​
176    function burnFrom(
177        address from,
178        address to,
179        uint256 shares
180    ) public returns (bool) {
181        _useAllowance(from, shares);
182        _burn(from, to, shares);
183        return true;

Solidity Contracts

JavaScript Tests