<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

### Marketplace

#### _owner
In the contract `Marketplace` the role `_owner` has authority over the functions shown in the diagram and list below.
* emergencyPause() - Set pause flag that pauses order executions and cancellations when turned on
* setReserveAddress() - Set `reserveAddress` address that collects commission fees.
* setRoyaltiesStorageAddress() - Set the `royaltiesStorage` address for royalty fees, which is used by the contract to calculate the amount of royalties to be paid. 
* setCommissionFee() - Set `commissionFee` amount.
* withdrawLockedFunds() - Withdraw ETH stored in the contract.

The following functions are also inherited from the `Ownable` contract.
* transferOwnership() - Transfer contract ownership
* renounceOwnership() - Give up contract ownership

Any compromise to the `_owner` account may allow the hacker to take advantage of this authority to set important parameters, pause contracts and withdraw funds from the contract.
![](https://accelerator-tasks-prod.s3.amazonaws.com/a001c3c3fa33478086131715b705f08c/diagrams/centralization_Marketplace-Marketplace-_owner.svg)

### RoyaltiesStorage

#### _owner
In the contract `RoyaltiesStorage` the role `_owner` has authority over the functions shown in the diagram and list below.
* setSignerAddress() - Sets the address of the signer that is authorized to set royalties.

The following functions are also inherited from the `Ownable` contract.
* transferOwnership() - Transfer contract ownership
* renounceOwnership() - Give up contract ownership

Any compromise to the `_owner` account may allow the hacker to take advantage of this authority to set the signer address.
![](https://accelerator-tasks-prod.s3.amazonaws.com/a001c3c3fa33478086131715b705f08c/diagrams/centralization_RoyaltiesStorage-RoyaltiesStorage-_owner.svg)

#### signerAddress
In the contract `RoyaltiesStorage` the role `signerAddress` has authority over the functions shown in the list below.
* setRoyalties() - Set royalty amounts and royalty recipients

Any compromise to the `signerAddress` account may allow the hacker to take advantage of this authority to set royalty fees and royalty recipients.

Centralization Related Risks

There are no upper boundaries for `setCommissionFee()` which is used to set the `commissionFee` variable. It is possible to set the total fee rate up to any arbitrary amount. 

```solidity=223
    /// @dev Update commissions fee in base 100
    /// @param commissionFee_ commission fee in base 100 to update
    function setCommissionFee(uint256 commissionFee_) external onlyOwner {
        commissionFee = commissionFee_;

        emit CommissionFeeUpdated(commissionFee_);
    }
```

Similarly, the cumulative royalties for an NFT can exceed 100%. If this occurs, then the recipients at the end of the `royaltyRecipient` array will never acquire royalties.

```solidity=123
                nftCollectionAddressToRoyaltyFee[royaltyData.tokenAddress] =
                    royaltyData.royaltyFee;
                nftCollectionAddressToRoyaltyRecipient[royaltyData.tokenAddress]
                = royaltyData.royaltyRecipient;
            }
            // If not a generative collection.
            else {
                delete nftAddressToNftIdToRoyaltyFee[royaltyData.tokenAddress][
                    royaltyData.tokenId
                ];
                delete nftAddressToNftIdToRoyaltyRecipient[
                    royaltyData.tokenAddress
                ][royaltyData.tokenId];
                nftAddressToNftIdToRoyaltyFee[royaltyData.tokenAddress][royaltyData
                    .tokenId] = royaltyData.royaltyFee;
```

No Upper Limit on fees

Signed messages are not properly verified with the current chain ID, thus allowing attackers to perform replay attacks across chains. Hardcoded or cached chain ID values are also vulnerable since a hard fork may occur and change the chain ID in the future. 

### RoyaltiesStorageVerifier.sol

```solidity=85
    abi.encodePacked(
        EIP191_HEADER,
        DOMAIN_SEPARATOR,
        keccak256(
            abi.encode(
                ROYALTIES_DATA_TYPEHASH,
                keccak256(bytes(royaltyData.uuid)),
                royaltyData.tokenAddress,
                royaltyData.tokenId,
                keccak256(
                    abi.encodePacked(royaltyData.royaltyRecipient)
                ),
                keccak256(abi.encodePacked(royaltyData.royaltyFee)),
                royaltyData.isCollection,
                royaltyData.isReset
            )
        )
    )
```
- Reading a state variable `DOMAIN_SEPARATOR`, which seems to use a cached chain ID value.
- Encoding the cached chain ID value `DOMAIN_SEPARATOR`.

### RoyaltiesStorage.sol

```solidity=83
        bytes32 hash_ = hashRoyaltyData(royaltyData);
```
- `hashRoyaltyData(royaltyData)` returns the cached chain ID.

### ECDSA.sol

```solidity=152
        address signer = ecrecover(hash, v, r, s);
```
- Calling `ecrecover` with a hash that does not properly include the chain ID.


---

### SmartOrder.sol

```solidity=104
    abi.encodePacked(
        EIP191_HEADER,
        DOMAIN_SEPARATOR,
        keccak256(
            abi.encode(
                ORDER_TYPEHASH,
                orderData.sellerAddress,
                orderData.sellTokenAddress,
                orderData.sellTokenId,
                orderData.sellTokenAmount,
                orderData.askTokenAddress,
                orderData.askTokenId,
                orderData.askTokenAmount,
                orderData.startTime,
                orderData.expirationTime,
                orderData.salt,
                orderData.sellAssetClass,
                orderData.askAssetClass
            )
        )
    )
```
- Reading a state variable `DOMAIN_SEPARATOR`, which seems to use a cached chain ID value.
- Encoding the cached chain ID value `DOMAIN_SEPARATOR`.

### Marketplace.sol

```solidity=288
        bytes32 hash_ = hashOrder(orderData);
```
- `hashOrder(orderData)` returns the cached chain ID.

### ECDSA.sol

```solidity=152
        address signer = ecrecover(hash, v, r, s);
```
- Calling `ecrecover` with a hash that does not properly include the chain ID.

The audit team would like to confirm how the team plans to manage the risk of replay attacks.

Potential Replay Attack

In the function `batchExecuteOrders()`, the function only ensures that the value of `msg.value` is greater than the `accumulatedPayments` of the batch orders.  The only way that these overpayments are handled is through `withdrawLockedFunds()`, but all the overpayments are sent to the owner address.  There is no refund mechanism for users to claim their overpaid funds.

No refund mechanism for overpayments

Orders can be made to trade the same type of token, for example ERC20-ERC20 orders.  In this case there is no check that the two tokens being exchanged are different token contracts.  The current design allows orders to be created with both `sellTokenAddress` and `askTokenAddress` set as the same address.

Lack of check for trading the same ERC20 token

Addresses are not validated before assignment or external calls, potentially allowing the use of zero addresses and leading to unexpected behavior or vulnerabilities. For example, transferring tokens to a zero address can result in a permanent loss of those tokens.

```solidity=149
        royaltiesStorage = royaltiesStorage_;
```
- `royaltiesStorage_` is not zero-checked before being used.


---
```solidity=234
        reserveAddress = reserveAddress_;
```
- `reserveAddress_` is not zero-checked before being used.


---
```solidity=245
        royaltiesStorage = royaltiesStorage_;
```
- `royaltiesStorage_` is not zero-checked before being used.

Missing Zero Address Validation

There should always be events emitted in the sensitive functions that are controlled by centralization roles.

Missing Emit Events

In the case that the `sellSideAssetClass` and `buySideAssetClass` are the same, the function `getFeeSide` will always return `FeeSide.SELL`.

Determination of fee payment

The **require** can be used to check for conditions and throw an exception if the condition is not met. It is better to provide a string message containing details about the error that will be passed back to the caller.

Missing Error Messages

erable°- Audit

RoyaltiesStorage.sol

RoyaltiesStorageVerifier.sol

IMarketplaceErrors.sol

LibBp.sol

Marketplace.sol

SmartOrder.sol

TransferProxy.sol

Erable employs NFTs as a means to combat plastic pollution, enabling users to simultaneously combat plastic pollution while generating real-yield from these NFTs.

Leaderboards

Due Diligence Tools

Resources

KYC Status

Bug Bounty Program