<username>{{ maskedUsername }}</username><space /><text>just voted for</text><space /><projectButton />

<username>{{ maskedUsername }}</username><space /><text>just voted for</text><space /><projectLogo /><space /><projectName>{{ projectName }}</projectName>

Bug Bounty rewards are grouped by severity and the impact of the vulnerability. Examples and descriptions of the type of vulnerabilities that correspond to each severity level can be found below. The payout amount has a 5 tier structure with separate scalesfor website/apps and smart contracts.

Description of vulnerability and your proof of concept or validation steps

Name

Please input a title

Short description of the vulnerability and the affected asset.

The core team is situated in country(ies) that received low aggregated ratings in terms of international judicial cooperation, criminal justice system, anti-money laundering, and corruption. This contextual data suggests an increased difficulty and complexity in preventing and mitigating fraud.

The core team is situated in country(ies) that received medium aggregated ratings in terms of international judicial cooperation, criminal justice system, anti-money laundering, and corruption. This contextual data suggests a medium level of geographic accountability, thus reducing and mitigating the risk of fraud.

The core team is situated in country(ies) that received the best aggregated ratings in terms of international judicial cooperation, criminal justice system, anti-money laundering, and corruption. This contextual data suggests the highest level of geographic accountability, thus maximizing the risk reduction and mitigation.

Vulnerability Title

transfer

transferFrom

totalSupply

balanceOf

allowance

approve

Launchpad

One of the most dangerous behaviors in smart contracts is to perform an external call to an untrusted contract. An attacker can deploy a contract and implement the contract whatever they want. When the "Dividends" contract performs the external call, the attacker-defined code will be executed. 

Risk of Supporting Arbitrary Tokens

Performing integer division before multiplication truncates the low bits, losing the precision of calculation.

```solidity=185
      dividendAmountPerSecond_ = dividendsInfo_.pendingAmount.mul(dividendsInfo_.cycleDividendsPercent).div(100).div(
        _cycleDurationSeconds
      );
```

```solidity=191
    accDividendsPerShare = accDividendsPerShare.add(
      (_currentBlockTimestamp().sub(lastUpdateTime)).mul(dividendAmountPerSecond_).mul(1e16).div(totalAllocation)
    );
```


---
```solidity=102
                denominator := div(denominator, twos)
```

```solidity=117
            uint256 inverse = (3 * denominator) ^ 2;
```


---
```solidity=105
                prod0 := div(prod0, twos)
```

```solidity=132
            result = prod0 * inverse;
```


---
```solidity=102
                denominator := div(denominator, twos)
```

```solidity=117
            uint256 inverse = (3 * denominator) ^ 2;
```


---
```solidity=105
                prod0 := div(prod0, twos)
```

```solidity=132
            result = prod0 * inverse;
```


---
```solidity=102
                denominator := div(denominator, twos)
```

```solidity=117
            uint256 inverse = (3 * denominator) ^ 2;
```


---
```solidity=105
                prod0 := div(prod0, twos)
```

```solidity=132
            result = prod0 * inverse;
```


---
```solidity=102
                denominator := div(denominator, twos)
```

```solidity=117
            uint256 inverse = (3 * denominator) ^ 2;
```


---
```solidity=105
                prod0 := div(prod0, twos)
```

```solidity=132
            result = prod0 * inverse;
```



Divide Before Multiply

The contract is serving as the underlying entity to interact with one or more third party protocols. The scope of the audit treats third party entities as black boxes and assume their functional correctness. However, in the real world, third parties can be compromised and this may lead to lost or stolen assets. In addition, upgrades of third parties can possibly create severe impacts, such as increasing fees of third parties, migrating to new LP pools, etc.

```solidity=271
  function addDividendsToPending(address token, uint256 amount) external override nonReentrant {
```
- The function `Dividends.addDividendsToPending` interacts with third party contract with `IERC20` interface via `token`.


---
```solidity=34
  IERC20 public PROJECT_TOKEN; // Project token contract
```
- The contract `FairAuction` interacts with third party contract with `IERC20` interface via `PROJECT_TOKEN`.


---
```solidity=35
  IERC20 public PROJECT_TOKEN_2; // Project token contract (eg. vested tokens)
```
- The contract `FairAuction` interacts with third party contract with `IERC20` interface via `PROJECT_TOKEN_2`.


---
```solidity=36
  IERC20 public SALE_TOKEN; // token used to participate
```
- The contract `FairAuction` interacts with third party contract with `IERC20` interface via `SALE_TOKEN`.


---
```solidity=37
  IERC20 public LP_TOKEN; // Project LP address
```
- The contract `FairAuction` interacts with third party contract with `IERC20` interface via `LP_TOKEN`.


---
```solidity=61
  address public weth = 0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91;
```
- The contract `FairAuction` interacts with third party contract with `IWETH` interface via `weth`.


---
```solidity=36
  IStMageToken public stMageToken; // stMageToken contract
```
- The contract `Launchpad` interacts with third party contract with `IStMageToken` interface via `stMageToken`.


---
```solidity=58
  IStMageToken public stMageToken; // stMageToken contract
```
- The contract `YieldBooster` interacts with third party contract with `IStMageToken` interface via `stMageToken`.


---
```solidity=226
    (address poolAddress, uint256 tokenId) = abi.decode(data, (address, uint256));
```
- The function `YieldBooster.allocate` interacts with third party contract with `INFTPool` interface via `poolAddress`.


---
```solidity=240
    (address poolAddress, uint256 tokenId) = abi.decode(data, (address, uint256));
```
- The function `YieldBooster.deallocate` interacts with third party contract with `INFTPool` interface via `poolAddress`.



Third Party Dependency

The `onERC721Received()` function is called to accept an NFT. In line 271 of the code, the contract authorizes the nft owner to transfer the NFT, but the `NFTPool` prohibits the transfer operation from the contract to others. Furthermore, authorizing the nft owner to transfer the NFT from the contract is a risky operation.

File CauldronPool.sol

```solidity=271
    nftPool.approve(from, tokenId);
```

File NFTPool.sol 
```solidity=1029
    function _beforeTokenTransfer(address from, address /*to*/, uint256 /*tokenId*/) internal view {
        require(!from.isContract() || msg.sender == from, "FORBIDDEN");
    }
```

Ineffective approve code

Addresses should be checked before assignment or external call to make sure they are not zero addresses.

```solidity=320
    stMageToken = _stmage;
```
- `_stmage` is not zero-checked before being used.



Missing Zero Address Validation

```solidity=253
      participationAmount = participationAmount.sub(refShareAmount);
```
- The variable `participationAmount` is never used after this assignment.


Unused Value

When transferring deflationary ERC20 tokens, the input amount may not be equal to the received amount due to the charged transaction fee. For example, if a user sends 100 deflationary tokens (with a 10% transaction fee), only 90 tokens actually arrived to the contract. However, a failure to discount such fees may allow the same user to withdraw 100 tokens from the contract, which causes the contract to lose 10 tokens in such a transaction.

Reference:
https://thoreum-finance.medium.com/what-exploit-happened-today-for-gocerberus-and-garuda-also-for-lokum-ybear-piggy-caramelswap-3943ee23a39f

```solidity=226
    SALE_TOKEN.safeTransferFrom(msg.sender, address(this), amount);
```
- Transferring tokens by `amount`.

```solidity=227
    _buy(amount, referralAddress);
```
- This function call executes the following operation.
- In `FairAuction._buy`,
    - `totalRaised = totalRaised.add(amount);`
- In `SafeMath.add`,
    - `return a + b;`
- The `amount` appears to be used for bookkeeping purposes without compensating the potential transfer fees.



Incompatibility with Deflationary Tokens

There are no unit tests for the program. Testing programs are a very important aspect of proving program correctness, preventing regressions, and release engineering. Without tests, there is no way to know if the program works as expected. 

Lack of Tests

The `splitPosition()` function is called by anyone to split the position into two, without checking that the new position's `splitAmount` is greater than 0.

The new position amount may be zero

The `allocate()` function is called by `stMageToken` to update the points of an NFT. The NFT contract address is passed in via the `data` parameter, and it is not possible to determine if it is a legitimate NFT contract address.

Lack of Input Validation

```solidity=282
        return address(uint160(uint256(_at(set._inner, index))));
```
- The type conversion `uint160(uint256(_at(set._inner,index)))` from larger type uint256 to smaller type uint160 may truncate data.


---
```solidity=282
        return address(uint160(uint256(_at(set._inner, index))));
```
- The type conversion `uint160(uint256(_at(set._inner,index)))` from larger type uint256 to smaller type uint160 may truncate data.


---
```solidity=282
        return address(uint160(uint256(_at(set._inner, index))));
```
- The type conversion `uint160(uint256(_at(set._inner,index)))` from larger type uint256 to smaller type uint160 may truncate data.


---
```solidity=282
        return address(uint160(uint256(_at(set._inner, index))));
```
- The type conversion `uint160(uint256(_at(set._inner,index)))` from larger type uint256 to smaller type uint160 may truncate data.


---
```solidity=282
        return address(uint160(uint256(_at(set._inner, index))));
```
- The type conversion `uint160(uint256(_at(set._inner,index)))` from larger type uint256 to smaller type uint160 may truncate data.



Unsafe Integer Cast

The linked variables assigned in the constructor can be declared as `immutable`. Immutable state variables can be assigned during contract creation but will remain constant throughout the lifetime of a deployed contract. A big advantage of immutable variables is that reading them is significantly cheaper than reading from regular state variables since they will not be stored in storage.

Variables That Could Be Declared as Immutable

State variables that never change should be declared as `constant` to save gas.

```solidity=61
  address public weth = 0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91;
```
- `weth` should be declared `constant`.



State Variable Should Be Declared Constant

Merlin DEX - audit 2

Address.sol

CauldronPool.sol

CauldronPoolFactory.sol

Context.sol

EnumerableSet.sol

ICauldronCustomReq.sol

ICauldronPoolFactory.sol

IERC165.sol

IERC20.sol

IERC721.sol

IERC721Receiver.sol

IMerlinStakeToken.sol

IMerlinToken.sol

INFTHandler.sol

INFTPool.sol

Ownable.sol

ReentrancyGuard.sol

SafeERC20.sol

SafeMath.sol

draft-IERC20Permit.sol

Dividends.sol

Math.sol

FairAuction.sol

IERC20Metadata.sol

Arrays.sol

Counters.sol

ERC20.sol

ERC20Snapshot.sol

LaunchPad.sol

StorageSlot.sol

IMerlinSwapMaster.sol

IYieldBooster.sol

MerlinSwapMaster.sol

ERC165.sol

ERC721.sol

ERC721Enumerable.sol

IERC721Enumerable.sol

IERC721Metadata.sol

NFTPool.sol

NFTPoolFactory.sol

Strings.sol

Initial Token Distribution

Function Calls User-Provided Addresses With No Access Control Modifier

Missing access control in function `allocateFromUsage()` and `deallocateFromUsage()`

MerlinSwapRouter Not Support `swapForExactToken`

Zksync Latency

Missing Error Messages

Logical issue of function `finalizeRedeem()`

Merlin DEX 

MerlinToken.sol

EmunerableSet.sol

IMerlinStakeTokenUsage.sol

MerlinStakeToken.sol

IMerlinSwapFactory.sol

IMerlinSwapPair.sol

IUniswapV2Callee.sol

IUniswapV2ERC20.sol

MerlinSwapFactory.sol

MerlinSwapPair.sol

UniswapV2ERC20.sol

IMerlinSwapRouter.sol

IUniswapV2Router01.sol

IWETH.sol

MerlinSwapRouter.sol

TransferHelper.sol

UniswapV2Library.sol

Leaderboards

Due Diligence Tools

Resources