If you notice some outdated information please let us know!
PASS
The final review score is indicated as a percentage. The percentage is calculated as Achieved Points due to MAX Possible Points. For each element the answer can be either Yes/No or a percentage. For a detailed breakdown of the individual weights of each question, please consult this document.
Very simply, the audit looks for the following declarations from the developer's site. With these declarations, it is reasonable to trust the smart contracts.
This report is for informational purposes only and does not constitute investment advice of any kind, nor does it constitute an offer to provide investment advisory or other services. Nothing in this report shall be considered a solicitation or offer to buy or sell any security, token, future, option or other financial instrument or to offer or provide any investment advice or service to any person in any jurisdiction. Nothing contained in this report constitutes investment advice or offers any opinion with respect to the suitability of any security, and the views expressed in this report should not be taken as advice to buy, sell or hold any security. The information in this report should not be relied upon for the purpose of investing. In preparing the information contained in this report, we have not taken into account the investment needs, objectives and financial circumstances of any particular investor. This information has no regard to the specific investment objectives, financial situation and particular needs of any specific recipient of this information and investments discussed may not be suitable for all investors.
Any views expressed in this report by us were prepared based upon the information available to us at the time such views were written. The views expressed within this report are limited to DeFiSafety and the author and do not reflect those of any additional or third party and are strictly based upon DeFiSafety, its authors, interpretations and evaluation of relevant data. Changed or additional information could cause such views to change. All information is subject to possible correction. Information may quickly become unreliable for various reasons, including changes in market conditions or economic circumstances.
This completed report is copyright (c) DeFiSafety 2023. Permission is given to copy in whole, retaining this copyright label.
This section looks at the code deployed on the relevant chain that gets reviewed and its corresponding software repository. The document explaining these questions is here.
1. Are the smart contract addresses easy to find? (%)
Some of ShapeShift's smart contract addresses are clearly labeled in their docs.
2. How active is the primary contract? (%)
The protocol's Staking smart contract recorded more than 10 transactions a week, but less than 10 transactions a day within the last month (sitting at around 2.5 transactions a day in the last month), earning them a 70% score. A screenshot of the transaction history is available in the appendix.
3. Does the protocol have a public software repository? (Y/N)
ShapeShift's public software repository can be found on their GitHub.
4. Is there a development history visible? (%)
ShapeShift maintains their repositories thoroughly, logging in a total of 2,678 commits and 3 branches, using their fox-staking-3 as an example.
5. Is the team public (not anonymous)?
The team operating the protocol can be found publicly on their LinkedIn page. Supporting documentation can be found in the appendix.
This section looks at the software documentation. The document explaining these questions is here.
7. Is the protocol's software architecture documented? (Y/N)
ShapeShift clearly illustrates its software architecture through diagrams and written explanations.
8. Does the software documentation fully cover the deployed contracts' source code? (%)
While ShapeShift has some function documentation for their staking reward contracts in their contract code, the overall level is low.
9. Is it possible to trace the documented software to its implementation in the protocol's source code? (%)
ShapeShift has only basic comments in its code, therefore no traceability
10. Has the protocol tested their deployed code? (%)
Code examples are in the Appendix at the end of this report.. As per the SLOC, there is 464% testing to code (TtC). This score is guided by the Test to Code ratio (TtC). Generally a good test to code ratio is over 100%. However, the reviewer's best judgement is the final deciding factor.
11. How covered is the protocol's code? (%)
ShapeShift's Zonkyo audit shows a total code coverage of 99%.
12. Does the protocol provide scripts and instructions to run their tests? (Y/N)
The protocol provides scripts to run their tests in their GitHub Testing page.
13. Is there a detailed report of the protocol's test results?(%)
Test coverage results visible.
14. Has the protocol undergone Formal Verification? (Y/N)
ShapeShift has not undergone formal verification and no report is available.
15. Were the smart contracts deployed to a testnet? (Y/N)
ShapeShift's testnet addresses could not be found.
This section looks at the 3rd party software audits done. It is explained in this document.
16. Is the protocol sufficiently audited? (%)
17. Is the bounty value acceptably high (%)
No bounties are visible..
This section covers the documentation of special access controls for a DeFi protocol. The admin access controls are the contracts that allow updating contracts or coefficients in the protocol. Since these contracts can allow the protocol admins to "change the rules", complete disclosure of capabilities is vital for user's transparency. It is explained in this document.
18. Is the protocol's admin control information easy to find?
ShapeShift's smart contracts are immutable and no special access privileges are permitted; this information can be found on the README.md repo in the protocol's GitHub.
19. Are relevant contracts clearly labelled as upgradeable or immutable? (%)
The relevant contracts are clearly identified as immutable here.
20. Is the type of smart contract ownership clearly indicated? (%)
Because ShapeShift doesn't give special access privileges, there are no clear external entity that can be appointed as a contract owner based on the information found on their GitHub here.
21. Are the protocol's smart contract change capabilities described? (%)
ShapeShift's smart contracts are immutable therefore the change capabilities are clearly outlined here.
22. Is the protocol's admin control information easy to understand? (%)
The protocol clearly states the immutability of its smart contracts in plain english here.
23. Is there sufficient Pause Control documentation? (%)
While there are no pause control functions in ShapeShift's code, their smart contracts are immutable and the documentation explains why pause control functions are not a necessity here.
24. Is there sufficient Timelock documentation? (%)
Through the immutability of their contracts shown here, ShapeShift identifies why their protocol does not need a timelock, meaning that they earn a score of 100%.
25. Is the Timelock of an adequate length? (Y/N)
ShapeShift justifies why no Timelock is needed here.
This section goes over the documentation that a protocol may or may not supply about their Oracle usage. Oracles are a fundamental part of DeFi as they are responsible for relaying tons of price data information to thousands of protocols using blockchain technology. Not only are they important for price feeds, but they are also an essential component of transaction verification and security. These questions are explained in this document.
26. Is the protocol's Oracle sufficiently documented? (%)
ShapeShift does not document any Oracle contract on their repositories.
27. Is front running mitigated by this protocol? (Y/N)
ShapeShift does not document mitigation techniques for front running in their protocol.
28. Can flashloan attacks be applied to the protocol, and if so, are those flashloan attack risks mitigated? (Y/N)
ShapeShift does not document mitigation techniques for flashloan attacks.
1pragma solidity ^0.7.6;
2
3import "../openzeppelin-solidity-3.4.0/contracts/math/Math.sol";
4import "../openzeppelin-solidity-3.4.0/contracts/math/SafeMath.sol";
5import "../openzeppelin-solidity-3.4.0/contracts/token/ERC20/SafeERC20.sol";
6import "../openzeppelin-solidity-3.4.0/contracts/utils/ReentrancyGuard.sol";
7
8// Inheritance
9import "./interfaces/IStakingRewards.sol";
10import "./RewardsDistributionRecipient.sol";
11
12contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
13 using SafeMath for uint256;
14 using SafeERC20 for IERC20;
15
16 /* ========== STATE VARIABLES ========== */
17
18 /// The token staking rewards will be paid in.
19 IERC20 public rewardsToken;
20 /// The token which must be staked to earn rewards.
21 IERC20 public stakingToken;
22 /// The time at which reward distribution will be complete.
23 uint256 public periodFinish = 0;
24 /// The rate at which rewards will be distributed.
25 uint256 public rewardRate = 0;
26 /// How long rewards will be distributed after the staking period begins.
27 uint256 public rewardsDuration = 135 days;
28 /// The last time rewardPerTokenStored was updated.
29 uint256 public lastUpdateTime;
30 /// The lastest snapshot of the amount of reward allocated to each staked token.
31 uint256 public rewardPerTokenStored;
32
33 /// How much reward-per-token has been paid out to each user who has withdrawn their stake.
34 mapping(address => uint256) public userRewardPerTokenPaid;
35 /// How much reward each user has earned.
36 mapping(address => uint256) public rewards;
37
38 uint256 private _totalSupply;
39 mapping(address => uint256) private _balances;
40
41 /* ========== CONSTRUCTOR ========== */
42
43 /// Deploy a new StakingRewards contract with the specified parameters. (This should only be done by the StakingRewardsFactory.)
44 constructor(
45 address _rewardsDistribution,
46 address _rewardsToken,
47 address _stakingToken
48 ) {
49 rewardsToken = IERC20(_rewardsToken);
50 stakingToken = IERC20(_stakingToken);
51 rewardsDistribution = _rewardsDistribution;
52 }
53
54 /* ========== VIEWS ========== */
55
56 /// Returns the total number of LP tokens staked.
57 function totalSupply() external view override returns (uint256) {
58 return _totalSupply;
59 }
60
61 /// Returns the total number of LP tokens staked by a given address.
62 function balanceOf(address account) external view override returns (uint256) {
63 return _balances[account];
64 }
65
66 /// Returns the last time for which a rewards have already been earned.
67 function lastTimeRewardApplicable() public view override returns (uint256) {
68 return Math.min(block.timestamp, periodFinish);
69 }
70
71 /// Returns the current amount of reward allocated per staked LP token.
72 function rewardPerToken() public view override returns (uint256) {
73 if (_totalSupply == 0) {
74 return rewardPerTokenStored;
75 }
76 return
77 rewardPerTokenStored.add(
78 lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply)
79 );
80 }
81
82 /// Returns the total reward earnings associated with a given address.
83 function earned(address account) public view override returns (uint256) {
84 return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
85 }
86
87 /// Returns the total reward amount.
88 function getRewardForDuration() external view override returns (uint256) {
89 return rewardRate.mul(rewardsDuration);
90 }
91
92 /* ========== MUTATIVE FUNCTIONS ========== */
93
94 /// Stake a number of LP tokens to earn rewards, using a signed permit instead of a balance approval.
95 function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
96 require(amount > 0, "Cannot stake 0");
97 _totalSupply = _totalSupply.add(amount);
98 _balances[msg.sender] = _balances[msg.sender].add(amount);
99
100 // permit
101 IUniswapV2ERC20(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
102
103 stakingToken.safeTransferFrom(msg.sender, address(this), amount);
104 emit Staked(msg.sender, amount);
105 }
106
107 /// Stake a number of LP tokens to earn rewards.
108 function stake(uint256 amount) external override nonReentrant updateReward(msg.sender) {
109 require(amount > 0, "Cannot stake 0");
110 _totalSupply = _totalSupply.add(amount);
111 _balances[msg.sender] = _balances[msg.sender].add(amount);
112 stakingToken.safeTransferFrom(msg.sender, address(this), amount);
113 emit Staked(msg.sender, amount);
114 }
115
116 /// Withdraw a number of LP tokens.
117 function withdraw(uint256 amount) public override nonReentrant updateReward(msg.sender) {
118 require(amount > 0, "Cannot withdraw 0");
119 _totalSupply = _totalSupply.sub(amount);
120 _balances[msg.sender] = _balances[msg.sender].sub(amount);
121 stakingToken.safeTransfer(msg.sender, amount);
122 emit Withdrawn(msg.sender, amount);
123 }
124
125 /// Transfer the caller's earned rewards.
126 function getReward() public override nonReentrant updateReward(msg.sender) {
127 uint256 reward = rewards[msg.sender];
128 if (reward > 0) {
129 rewards[msg.sender] = 0;
130 rewardsToken.safeTransfer(msg.sender, reward);
131 emit RewardPaid(msg.sender, reward);
132 }
133 }
134
135 /// Withdraw all staked LP tokens and any pending rewards.
136 function exit() external override {
137 withdraw(_balances[msg.sender]);
138 getReward();
139 }
140
141 /* ========== RESTRICTED FUNCTIONS ========== */
142
143 /// Called by the StakingRewardsFactory to begin reward distribution.
144 function notifyRewardAmount(uint256 reward) external override onlyRewardsDistribution updateReward(address(0)) {
145 if (block.timestamp >= periodFinish) {
146 rewardRate = reward.div(rewardsDuration);
147 } else {
148 uint256 remaining = periodFinish.sub(block.timestamp);
149 uint256 leftover = remaining.mul(rewardRate);
150 rewardRate = reward.add(leftover).div(rewardsDuration);
151 }
152
153 // Ensure the provided reward amount is not more than the balance in the contract.
154 // This keeps the reward rate in the right range, preventing overflows due to
155 // very high values of rewardRate in the earned and rewardsPerToken functions;
156 // Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
157 uint balance = rewardsToken.balanceOf(address(this));
158 require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
159
160 lastUpdateTime = block.timestamp;
161 periodFinish = block.timestamp.add(rewardsDuration);
162 emit RewardAdded(reward);
163 }
164
165 /* ========== MODIFIERS ========== */
166
167 modifier updateReward(address account) {
168 rewardPerTokenStored = rewardPerToken();
169 lastUpdateTime = lastTimeRewardApplicable();
170 if (account != address(0)) {
171 rewards[account] = earned(account);
172 userRewardPerTokenPaid[account] = rewardPerTokenStored;
173 }
174 _;
175 }
176
177 /* ========== EVENTS ========== */
178
179 /// Emitted when the StakingRewardsFactory has allocated a reward balance to a StakingRewards contract, starting the staking period.
180 event RewardAdded(uint256 reward);
181 /// Emitted when a user stakes their LP tokens.
182 event Staked(address indexed user, uint256 amount);
183 /// Emitted when a user withdraws their LP tokens.
184 event Withdrawn(address indexed user, uint256 amount);
185 /// Emitted when a user has been paid a reward.
186 event RewardPaid(address indexed user, uint256 reward);
187}
188
189interface IUniswapV2ERC20 {
190 /// Allows a user to permit a contract to access their tokens by signing a permit.
191 function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
192}
Tests to Code: 4430 / 954 = 464 %