O3 Swap

1contract O3 is Context, ERC20, Ownable, IO3, ReentrancyGuard {
2    using SafeMath for uint256;
3    using SafeERC20 for IERC20;
4​
5    struct LpStakeInfo {
6        uint256 amountStaked;
7        uint256 blockNumber;
8    }
9​
10    event LOG_UNLOCK_TRANSFER (
11        address indexed from,
12        address indexed to,
13        uint256 amount
14    );
15​
16    event LOG_STAKE (
17        address indexed staker,
18        address indexed token,
19        uint256 stakeAmount
20    );
21​
22    event LOG_UNSTAKE (
23        address indexed staker,
24        address indexed token,
25        uint256 unstakeAmount
26    );
27​
28    event LOG_CLAIM_UNLOCKED (
29        address indexed staker,
30        uint256 claimedAmount
31    );
32​
33    event LOG_SET_UNLOCK_FACTOR (
34        address indexed token,
35        uint256 factor
36    );
37​
38    event LOG_SET_UNLOCK_BLOCK_GAP (
39        address indexed token,
40        uint256 blockGap
41    );
42​
43    uint256 public constant FACTOR_DENOMINATOR = 10 ** 8;
44​
45    mapping (address => uint256) private _unlocks;
46    mapping (address => mapping(address => LpStakeInfo)) private _stakingRecords;
47    mapping (address => uint256) private _unlockFactor;
48    mapping (address => uint256) private _unlockBlockGap;
49    mapping (address => bool) private _authorizedMintCaller;
50​
51    uint256 private _totalUnlocked;
52​
53    modifier onlyAuthorizedMintCaller() {
54        require(_msgSender() == owner() || _authorizedMintCaller[_msgSender()],"O3: MINT_CALLER_NOT_AUTHORIZED");
55        _;
56    }
57​
58    constructor () public ERC20("O3 Swap Token", "O3") {}
59​
60    function getUnlockFactor(address token) external view override returns (uint256) {
61        return _unlockFactor[token];
62    }
63​
64    function getUnlockBlockGap(address token) external view override returns (uint256) {
65        return _unlockBlockGap[token];
66    }
67​
68    function totalUnlocked() external view override returns (uint256) {
69        return _totalUnlocked;
70    }
71​
72    function unlockedOf(address account) external view override returns (uint256) {
73        return _unlocks[account];
74    }
75​
76    function lockedOf(address account) public view override returns (uint256) {
77        return balanceOf(account).sub(_unlocks[account]);
78    }
79​
80    function getStaked(address token) external view override returns (uint256) {
81        return _stakingRecords[_msgSender()][token].amountStaked;
82    }
83​
84    function getUnlockSpeed(address staker, address token) external view override returns (uint256) {
85        LpStakeInfo storage info = _stakingRecords[staker][token];
86        return _getUnlockSpeed(token, staker, info.amountStaked);
87    }
88​
89    function claimableUnlocked(address token) external view override returns (uint256) {
90        LpStakeInfo storage info = _stakingRecords[_msgSender()][token];
91        return _settleUnlockAmount(_msgSender(), token, info.amountStaked, info.blockNumber);
92    }
93​
94    function transfer(address recipient, uint256 amount) public override(ERC20, IERC20) returns (bool) {
95        _transfer(_msgSender(), recipient, amount);
96        _unlockTransfer(_msgSender(), recipient, amount);
97        return true;
98    }
99​
100    function transferFrom(address sender, address recipient, uint256 amount) public override(ERC20, IERC20) returns (bool) {
101        _transfer(sender, recipient, amount);
102        _unlockTransfer(sender, recipient, amount);
103        uint256 allowance = allowance(sender, _msgSender());
104        _approve(sender, _msgSender(), allowance.sub(amount, "O3: TRANSFER_AMOUNT_EXCEEDED"));
105        return true;
106    }
107​
108    function setUnlockFactor(address token, uint256 _factor) external override onlyOwner {
109        _unlockFactor[token] = _factor;
110        emit LOG_SET_UNLOCK_FACTOR(token, _factor);
111    }
112​
113    function setUnlockBlockGap(address token, uint256 _blockGap) external override onlyOwner {
114        _unlockBlockGap[token] = _blockGap;
115        emit LOG_SET_UNLOCK_BLOCK_GAP(token, _blockGap);
116    }
117​
118    function stake(address token, uint256 amount) external override nonReentrant returns (bool) {
119        require(_unlockFactor[token] > 0, "O3: FACTOR_NOT_SET");
120        require(_unlockBlockGap[token] > 0, "O3: BLOCK_GAP_NOT_SET");
121        _pullToken(token, _msgSender(), amount);
122        LpStakeInfo storage info = _stakingRecords[_msgSender()][token];
123        uint256 unlockedAmount = _settleUnlockAmount(_msgSender(), token, info.amountStaked, info.blockNumber);
124        _updateStakeRecord(_msgSender(), token, info.amountStaked.add(amount));
125        _mintUnlocked(_msgSender(), unlockedAmount);
126        emit LOG_STAKE(_msgSender(), token, amount);
127        return true;
128    }
129​
130    function unstake(address token, uint256 amount) external override nonReentrant returns (bool) {
131        require(amount > 0, "O3: ZERO_UNSTAKE_AMOUNT");
132        LpStakeInfo storage info = _stakingRecords[_msgSender()][token];
133        require(amount <= info.amountStaked, "O3: UNSTAKE_AMOUNT_EXCEEDED");
134        uint256 unlockedAmount = _settleUnlockAmount(_msgSender(), token, info.amountStaked, info.blockNumber);
135        _updateStakeRecord(_msgSender(), token, info.amountStaked.sub(amount));
136        _mintUnlocked(_msgSender(), unlockedAmount);
137        _pushToken(token, _msgSender(), amount);
138        emit LOG_UNSTAKE(_msgSender(), token, amount);
139        return true;
140    }
141​
142    function claimUnlocked(address token) external override nonReentrant returns (bool) {
143        LpStakeInfo storage info = _stakingRecords[_msgSender()][token];
144        uint256 unlockedAmount = _settleUnlockAmount(_msgSender(), token, info.amountStaked, info.blockNumber);
145        _updateStakeRecord(_msgSender(), token, info.amountStaked);
146        _mintUnlocked(_msgSender(), unlockedAmount);
147        emit LOG_CLAIM_UNLOCKED(_msgSender(), unlockedAmount);
148        return true;
149    }
150​
151    function _updateStakeRecord(address staker, address token, uint256 _amountStaked) internal {
152        _stakingRecords[staker][token].amountStaked = _amountStaked;
153        _stakingRecords[staker][token].blockNumber = block.number;
154    }
155​
156    function mintUnlockedToken(address to, uint256 amount) onlyAuthorizedMintCaller external override {
157        _mint(to, amount);
158        _mintUnlocked(to, amount);
159        require(totalSupply() <= 10**26, "O3: TOTAL_SUPPLY_EXCEEDED");
160    }
161​
162    function mintLockedToken(address to, uint256 amount) onlyAuthorizedMintCaller external override {
163        _mint(to, amount);
164        require(totalSupply() <= 10**26, "O3: TOTAL_SUPPLY_EXCEEDED");
165    }
166​
167    function setAuthorizedMintCaller(address caller) onlyOwner external override {
168        _authorizedMintCaller[caller] = true;
169    }
170​
171    function removeAuthorizedMintCaller(address caller) onlyOwner external override {
172        _authorizedMintCaller[caller] = false;
173    }
174​
175    function _settleUnlockAmount(address staker, address token, uint256 lpStaked, uint256 upToBlockNumber) internal view returns (uint256) {
176        uint256 unlockSpeed = _getUnlockSpeed(token, staker, lpStaked);
177        uint256 blocks = block.number.sub(upToBlockNumber);
178        uint256 unlockedAmount = unlockSpeed.mul(blocks).div(FACTOR_DENOMINATOR);
179        uint256 lockedAmount = lockedOf(staker);
180        if (unlockedAmount > lockedAmount) {
181            unlockedAmount = lockedAmount;
182        }
183        return unlockedAmount;
184    }
185​
186    function _mintUnlocked(address recipient, uint256 amount) internal {
187        _unlocks[recipient] = _unlocks[recipient].add(amount);
188        _totalUnlocked = _totalUnlocked.add(amount);
189        emit LOG_UNLOCK_TRANSFER(address(0), recipient, amount);
190    }
191​
192    function _getUnlockSpeed(address token, address staker, uint256 lpStaked) internal view returns (uint256) {
193        uint256 toBeUnlocked = lockedOf(staker);
194        uint256 unlockSpeed = _unlockFactor[token].mul(lpStaked);
195        uint256 maxUnlockSpeed = toBeUnlocked.mul(FACTOR_DENOMINATOR).div(_unlockBlockGap[token]);
196        if(unlockSpeed > maxUnlockSpeed) {
197            unlockSpeed = maxUnlockSpeed
198        }
199        return unlockSpeed

Solidity Contracts

JavaScript Tests