Quantstamp reviewed Pheasant Network on 2 Aug 2023: 24 findings, 0 critical; 14 marked fixed, 10 acknowledged; 8 more marked mitigated.
Report hosted on certificate.quantstamp.com.
Trustblock does not review code.
Statuses are the security firm’s own, from its report.
| Severity | Open | Acknowledged | Fixed | Mitigated |
|---|---|---|---|---|
| Critical | 0 | 0 | 0 | 0 |
| High | 0 | 2 | 8 | 3 |
| Medium | 0 | 3 | 2 | 1 |
| Low | 0 | 5 | 4 | 4 |
Marked Informational or Undetermined by the firm. Not counted as findings.
Based on the current system, the Relayer can perform two actions: 1. It is possible for a malicious Relayer to front-run any detected valid slash attempt against him with the functions `slash()` and `slashUpwardTrade()`. As a result, he will recover half of the slashed amount. In the end, the Relayer will remain with the amount he got from the user and half the slashed amount. 2. Also, the Relayer can get back deposited funds from the Bond Manager by: * initiating a trade of `_amount` using a second address `a2`. * ignoring that trade request. * initiating a dispute with `a2` to get as rewards `>100%` of `_amount` from the Bond Manager (because half will be sent to him as a disputer, and half will be sent to him as a trade user).
A two-step update mechanism distinguishes the action to plan the update of a contract parameter and the action to execute that update. A minimum delay of `UPDATE_PERIOD` must pass before the second action can be executed. Integrity constraints are checked during the second step. It means that an invalid request can be recorded on-chain in the first step, even if it will fail during the second step. That mechanism can be found in the contracts: 1. PolygonChildCheckpointManager 2. CoreChildCheckpointManager 3. BondManager 4. PheasantNetworkBridgeChild
"Dead" code refers to code that is never executed and hence makes no impact on the final result of running a program. Dead code raises a concern since either the code is unnecessary or the necessary code's results were ignored. 1. `Types.sol` defines the `Trade` structure with a field named `disputeTimestamp`. In the codebase, this is set to `block.timestamp`, and it is not modified in any function providing the same data as `Trade.timestamp`. 2. `PheasantNetworkBridgeChild.withdraw()` contains two commented `require()` statements.
If the gas fees for submitting a block hash to L2 from L1 (e.g. ETH Mainnet) are higher than the potential disputer fee, no disputer will submit the block and the evidence validation will revert.
Currently, the relayer is a trusted entity in the protocol. As we pointed out in other issues, while there is the potential of slashing, the bonded assets are not tied to individually, slashable trades. Furthermore, pending updates overwriting most of the global variables of the `PheasantNetworkBridgeChild` can be activated after a three hours waiting period at any time, resulting in theoretically slashable trades becoming unslashable. Additionally, the pause mechanism theoretically enables the relayer to walk away with the funds of all pending trades. The developers also made clear that there will currently only be one active relayer controlled by the team, further resulting in the centralization of the system. While the project's roadmap contains a pathway to a more decentralized and trustless protocol, it is currently not fully implemented.
`payable` keyword in a function allows the caller to send funds to the smart contract when calling that function. However, if funds are not expected this can be confusing for users and can lead to loss of funds. The following functions are not expected to receive funds and are marked as `payable`: - `BondManager.finalizeWithdrawalBond()` - `BondManager.slash()`
Every Solidity file specifies in the header a version number of the format`pragma solidity (^)0.8.*`. The caret (`^`) before the version number implies an unlocked pragma, meaning that the compiler will use the specified version *and above*, hence the term "unlocked". Furthermore, some of the files are locked to a specific version (i.e. `PolygonPheasantNetworkBridgeChild.sol`), while others remain unlocked (i.e.`OptimismRootCheckpointManager.sol`).
The clone-and-own approach involves copying and adjusting open source code at one's own discretion. From the development perspective, it is initially beneficial as it reduces the amount of effort. However, from the security perspective, it involves some risks as the code may not follow the best practices, may contain a security vulnerability, or may include intentionally or unintentionally modified upstream libraries.
In `checkERC20TransferTx()`, the transaction is validated to match the signature of `transfer(address,uint256)` function. If a user transfers an ERC-20 token using `transferFrom()`, the evidence validation will fail.
The report names a repository or files. Open the report to see its scope.
Repository and files the report names (17)
240 projects reviewed · 338 reports · latest Nov 2026
See Quantstamp’s auditsSomething wrong on this page? A missing report, a wrong date, a finding that was fixed since. Tell us and we check it against its source.
Tell us