thirdweb A-4

In TokenERC20, TokenERC721 and TokenERC115, mintWithSignature() allows the MintRequest’s to address to be zero:

function mintWithSignature(MintRequest calldata _req, bytes calldata _signature) external payable nonReentrant {
    // ...
    address receiver = _req.to == address(0) ? _msgSender() : _req.to;
    // ...
}

This behavior allows a minter to construct a mint signature such that the sender will receive the tokens, instead of needing to specify the recipient’s address.

However, because the recipient is the sender, an attacker can frontrun a mintWithSignature() transaction, receiving the tokens and leaving the victim with nothing.

If there is no price, the attacker gets the tokens for free. This is particularly bad when the token has a market price on an AMM, and the contract owner wanted to grant someone new tokens.

If a price is present, the attacker does have to pay it. But the situation is still problematic if the price was a discount, or if the use case is minting for a fixed amount of investment.

Note that this behavior also exists in SignatureDrop.sol.

Consider forcing MintRequest’s to address to always be defined.

In TokenERC20’s mintWithSignature function, when mint request is defined with quantity=0, nothing is minted to the specified to address but:

• The price is still charged
• The mint request is recorded as a success (via the minted mapping).

Although an account with a minter role would need to create this mint request, it’s not uncommon for such logic to have bugs, especially in an off-chain context.

Consider adding a check in the verifyRequest function to revert when quantity is 0.

require(_req.quantity > 0, "quantity is zero");

Also consider to add the above require statement to TokenERC1155. Although this contract doesn’t charge the price as quantity is considered in calculation, it still records the mint request as a success.

In TokenERC20, TokenERC721 and TokenERC115 mint requests can include a price and a currency which can be either NATIVE_TOKEN (e.g. ETH) or some other ERC20 token.

Suppose the currency specified in the request is some ERC20 token and the sender - by mistake - nevertheless sends ether with the call. The function call will not revert, causing the received “native tokens” to be locked inside the contract without recovery.

Consider adding a check to the collectPrice function which prevents ether being sent to the contract when currency is not set to NATIVE_TOKEN.

if (_currency == CurrencyTransferLib.NATIVE_TOKEN) {
            require(msg.value == _price, "must send total price.");
} else {
            require(msg.value == 0, "dont accept ether");
}

TokenERC721 and TokenERC1155 use _mint instead of _safeMint to mint the actual tokens:

_mint(_to, tokenIdToMint);

This can lead to tokens being locked in those contracts with no recovery.

Consider using _safeMint instead of _mint to check if a contract recipient can receive (or is at least aware of receiving) ERC721 tokens.

In TokenERC20, TokenERC721 and TokenERC115, the initialize functions don’t have a boundary check for platformFeeBps.

Also in the setPlatformFeeInfo function, the only restriction to platformFeeBps is ≤ MAX_BPS (10_000). If set to MAX_BPS or any value close to it (depending on fees), the minting would fail because of underflow in case ThirdWeb fee is applied. See following line:

CurrencyTransferLib.transferCurrency(
    _currency,
    _msgSender(),
    _primarySaleRecipient,
    _price - platformFees - twFee // underflow
);

Consider setting a reasonable upper limit for platformFeeBps.

In the initialize(), setPrimarySaleRecipient(), and setPlatformFeeInfo(), in all three token contracts, there is no check for primarySaleRecipient and platformFeeRecipient to not have address 0x0.

As a consequence, when using NATIVE_TOKEN (e.g. ETH), ether could be burned to the zero address.

In the case of an ERC20 transfer, the transaction would be reverted (for OpenZeppelin ERC20 tokens).

Consider adding checks to not allow address 0x0 for primarySaleRecipient and platformFeeRecipient.

Thirdweb’s signatureMint documentation defines one of the mint request parameters as pricePerToken.

However, in TokenERC20.sol, the price specified in the mint request is considered the total price instead.

This also creates an inconsistency with TokenERC1155.sol, which uses pricePerToken as documented.

Consider:

1. Updating TokenERC20 to use pricePerToken instead of total price and adapting collectPrice function accordingly to include a quantity parameter, or
2. Document the differing behavior of TokenERC20

In TokenERC20 there is the possibility to pause/unpause token transfers. In contrast, TokenERC721 and TokenERC1155 don’t provide this functionality.

Consider to add pause/unpause capability for token transfers in TokenERC721 and TokenERC1155.

In TokenERC1155's _mintTo function the minting reverts when the uri parameter in MintRequest is empty.

if (bytes(_tokenURI[_tokenId]).length == 0) {
    require(bytes(_uri).length > 0, "empty uri.");
    _tokenURI[_tokenId] = _uri;
}

In contrast, TokenERC721 doesn’t check for empty uri parameter.

Consider adding this check to TokenERC721 as well.

• TokenERC721 and TokenERC1155 define their own NATIVE_TOKEN constant:

  address private constant
  NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
  

  However, TokenERC20 uses CurrencyTransferLib.NATIVE_TOKEN.

• The collectPrice() function is written differently in TokenERC20 from TokenERC721 and TokenERC1155. Instead of passing in a reference to the whole _req request, it pulls out specific parameters. In addition, TokenERC20’s version has the logic to determine saleRecipient within mintWithSignature() instead of collectPrice().

  Consider updating TokenERC20’s collectPrice() to be consistent with TokenERC721 and TokenERC1155.

• _afterTokenTransfer() is only overridden in TokenERC20 without any changed behavior.

• MAX_BPS is declared as:

  • uint128 internal constant in TokenERC20.
  • uint256 private constant in TokenERC721 and in TokenERC1155.

• platformFeeBps is declared as:

  • uint128 internal in TokenERC20.
  • uint128 public in TokenERC721 and in TokenERC1155.

• TokenERC721 and TokenERC1155 both inherit from OpenZeppelin’s ReentrancyGuardUpgradeable and call its __ReentrancyGuard_init(). However, TokenERC20 does call this initializer, even though it inherits the same contract.

In TokenERC721 and TokenERC1155 function collectPrice uses memory keyword for the MintRequest parameter. Consider using calldata allocation instead to save gas costs. In TokenERC721 and TokenERC1155 function collectPrice uses memory keyword for the MintRequest parameter. Consider using calldata allocation instead to save on gas cost.

See OZ’s statement regarding draft status here: https://docs.openzeppelin.com/contracts/3.x/api/drafts