If you notice some outdated information please let us know!
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 2021. 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?(%)
Smart contracts are easily located.
2. How active is the primary contract? (%)
Primary contracts are very active, with some stable swaps being used 20 or 30 times a day.
3. Does the protocol have a public software repository? (Y/N)
Curve uses GitHub as a software repository.
4. Is there a development history visible? (%)
At 898 commits, this repo is almost as endless as Curve's logo.
5. Is the team public (not anonymous)? (Y/N)
Two team members are public and they self-report working for Curve. One of the founders, Michael Egorov, can also be found at https://www.linkedin.com/in/michael-egorov/.
The difference between this and the old link is solely the link. This section looks at the software documentation. The document explaining these questions is here.
6. Is there a whitepaper? (Y/N)
Curve has multiple whitepapers, though the most user accessible is their Gitbook.
7. Is the protocol's software architecture documented? (Y/N)
Curve's software architecture is well documented using specific references to contracts.
8. Does the software documentation fully cover the deployed contracts' source code? (%)
The software function documentation covers all contracts deployed.
9. Is it possible to trace the documented software to its implementation in the protocol's source code? (%)
There is strong association between code and documents, but there is no explicit traceability.
10. Has the protocol tested their deployed code? (%)
Due to our testing tool not being optimized for vyper files, we had to rely on other methods to get an accurate measure of the depth of Curve's testing. Thankfully, they have provided proof of extensive and all-encompassing testing through our Twitter thread with them.
11. How covered is the protocol's code? (%)
Although the protocol offers a code coverage report for users running their own tests, there are no results. . However, with clear in-depth testing practices, Curve gets a 60% for this question.
12. Does the protocol provide scripts and instructions to run their tests? (Y/N)
Curve provides scripts.
13. Is there a detailed report of the protocol's test results?(%)
No test report is evident.
14. Has the protocol undergone Formal Verification? (Y/N)
Curve has not undergone formal verification.
15. Were the smart contracts deployed to a testnet? (Y/N)
Curve uses testnets with their various deployments to new networks.
This section looks at the 3rd party software audits done. It is explained in this document.
16. Is the protocol sufficiently audited? (%)
Curve has been audited three times, two of which were pre-launch.
17. Is the bounty value acceptably high (%)
Curve offers $250K with a static program.
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?
Admin controls are easy to find. However, they need updating so that users can find them all in one location with sufficient detail yet still in straightforward language.
19. Are relevant contracts clearly labelled as upgradeable or immutable? (%)
Relevant contracts are clearly labelled as upgradeable or immutable in the various sections of their technical documentation.
20. Is the type of smart contract ownership clearly indicated? (%)
Ownership is in the hands of the DAO, as stated.
21. Are the protocol's smart contract change capabilities described? (%)
Contracts that are capable of change (or not) are identified.
22. Is the protocol's admin control information easy to understand? (%)
Information regarding admin control and its relation to user funds' safety is clearly described at https://resources.curve.fi/faq/security.
23. Is there sufficient Pause Control documentation? (%)
An in-depth mention of a their pause control is documented here.
24. Is there sufficient Timelock documentation? (%)
No timelock documentation is detailed. However, their DAO structure fundamentally operates like a timelock due to admin's giving up ownership to the DAO, and every vote on contract changes has to go through a lengthy voting process. In addition, Curve has clearly stated that the only contract that the DAO does not have full ownership of is the CRV DAO token. Regardless, the token contract restricts all admin access and external call possibilities. This renders the need for a timelock effectively useless for any Curve contract.
25. Is the Timelock of an adequate length? (Y/N)
The voting of the DAO acting as a timelock, its length is parallel to the overall voting process which takes 10 days.
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. This is explained in this document.
26. Is the protocol's Oracle sufficiently documented? (%)
Curve uses TWAP oracles.
27. Is front running mitigated by this protocol? (Y/N)
Curve details front-running mitigation in their docs.
28. Can flashloan attacks be applied to the protocol, and if so, are those flashloan attack risks mitigated? (Y/N)
Flashloan countermeasures are implemented.
1# Events 2event TokenExchange: 3 buyer: indexed(address) 4 sold_id: int128 5 tokens_sold: uint256 6 bought_id: int128 7 tokens_bought: uint256 8 9 10event AddLiquidity: 11 provider: indexed(address) 12 token_amounts: uint256[N_COINS] 13 fees: uint256[N_COINS] 14 invariant: uint256 15 token_supply: uint256 16 17event RemoveLiquidity: 18 provider: indexed(address) 19 token_amounts: uint256[N_COINS] 20 fees: uint256[N_COINS] 21 token_supply: uint256 22 23event RemoveLiquidityOne: 24 provider: indexed(address) 25 token_amount: uint256 26 coin_amount: uint256 27 28event RemoveLiquidityImbalance: 29 provider: indexed(address) 30 token_amounts: uint256[N_COINS] 31 fees: uint256[N_COINS] 32 invariant: uint256 33 token_supply: uint256 34 35event CommitNewAdmin: 36 deadline: indexed(uint256) 37 admin: indexed(address) 38 39event NewAdmin: 40 admin: indexed(address) 41 42 43event CommitNewFee: 44 deadline: indexed(uint256) 45 fee: uint256 46 admin_fee: uint256 47 48event NewFee: 49 fee: uint256 50 admin_fee: uint256 51 52event RampA: 53 old_A: uint256 54 new_A: uint256 55 initial_time: uint256 56 future_time: uint256 57 58event StopRampA: 59 A: uint256 60 t: uint256 61 62 63# This can (and needs to) be changed at compile time 64N_COINS: constant(int128) = 3 # <- change 65 66FEE_DENOMINATOR: constant(uint256) = 10 ** 10 67LENDING_PRECISION: constant(uint256) = 10 ** 18 68PRECISION: constant(uint256) = 10 ** 18 # The precision to convert to 69PRECISION_MUL: constant(uint256[N_COINS]) = [1, 1000000000000, 1000000000000] 70RATES: constant(uint256[N_COINS]) = [1000000000000000000, 1000000000000000000000000000000, 1000000000000000000000000000000] 71FEE_INDEX: constant(int128) = 2 # Which coin may potentially have fees (USDT) 72 73MAX_ADMIN_FEE: constant(uint256) = 10 * 10 ** 9 74MAX_FEE: constant(uint256) = 5 * 10 ** 9 75MAX_A: constant(uint256) = 10 ** 6 76MAX_A_CHANGE: constant(uint256) = 10 77 78ADMIN_ACTIONS_DELAY: constant(uint256) = 3 * 86400 79MIN_RAMP_TIME: constant(uint256) = 86400 80 81coins: public(address[N_COINS]) 82balances: public(uint256[N_COINS]) 83fee: public(uint256) # fee * 1e10 84admin_fee: public(uint256) # admin_fee * 1e10 85 86owner: public(address) 87token: CurveToken 88 89initial_A: public(uint256) 90future_A: public(uint256) 91initial_A_time: public(uint256) 92future_A_time: public(uint256) 93 94admin_actions_deadline: public(uint256) 95transfer_ownership_deadline: public(uint256) 96future_fee: public(uint256) 97future_admin_fee: public(uint256) 98future_owner: public(address) 99 100is_killed: bool 101kill_deadline: uint256 102KILL_DEADLINE_DT: constant(uint256) = 2 * 30 * 86400 103 104 105@external 106def __init__( 107 _owner: address, 108 _coins: address[N_COINS], 109 _pool_token: address, 110 _A: uint256, 111 _fee: uint256, 112 _admin_fee: uint256 113): 114 """ 115 @notice Contract constructor 116 @param _owner Contract owner address 117 @param _coins Addresses of ERC20 conracts of coins 118 @param _pool_token Address of the token representing LP share 119 @param _A Amplification coefficient multiplied by n * (n - 1) 120 @param _fee Fee to charge for exchanges 121 @param _admin_fee Admin fee 122 """ 123 for i in range(N_COINS): 124 assert _coins[i] != ZERO_ADDRESS 125 self.coins = _coins 126 self.initial_A = _A 127 self.future_A = _A 128 self.fee = _fee 129 self.admin_fee = _admin_fee 130 self.owner = _owner 131 self.kill_deadline = block.timestamp + KILL_DEADLINE_DT 132 self.token = CurveToken(_pool_token) 133 134 135@view 136@internal 137def _A() -> uint256: 138 """ 139 Handle ramping A up or down 140 """ 141 t1: uint256 = self.future_A_time 142 A1: uint256 = self.future_A 143 144 if block.timestamp < t1: 145 A0: uint256 = self.initial_A 146 t0: uint256 = self.initial_A_time 147 # Expressions in uint256 cannot have negative numbers, thus "if" 148 if A1 > A0: 149 return A0 + (A1 - A0) * (block.timestamp - t0) / (t1 - t0) 150 else: 151 return A0 - (A0 - A1) * (block.timestamp - t0) / (t1 - t0) 152 153 else: # when t1 == 0 or block.timestamp >= t1 154 return A1 155
Tests to Code: 3079 / 30196 = 10 %