Is the safeMint function safer than the normal mint function?

Often developers use the safeMint function because it is safer than the normal mint function. But is this really true? Let’s check!

Introduction to ERC721:

Before diving into the intricacies of mint and safeMint, let's take a moment to understand ERC721. ERC721 is a standard for creating non-fungible tokens (NFTs). Unlike ERC20 tokens, which are fungible and can be exchanged on a one-to-one basis, ERC721 tokens are unique and cannot be exchanged like-for-like. This uniqueness has made ERC721 a go-to standard for digital collectibles, art, and other one-of-a-kind digital assets.

Mint vs SafeMint:

In the ERC721 standard, particularly in the OpenZeppelin implementation, there are two primary functions for creating new tokens: mint and safeMint.

Mint: The mint function is straightforward. It creates a new token and assigns it to an address. However, it doesn't perform any checks to ensure that the recipient address can handle ERC721 tokens. This is fine for most cases, but issues can arise if the token is sent to a contract that is not prepared to handle ERC721 tokens.

SafeMint: This function does everything that mint does but with an added layer of safety. It checks if the recipient address is a smart contract and, if so, whether it can handle ERC721 tokens. This is done using the ERC721 Receiver interface, which requires contracts to implement a specific function (onERC721Received) to be considered ERC721-compliant. The safeMint function ensures that the token doesn't get lost in a contract that can't handle it.

The Risk of Reentrancy in SafeMint:

Now, let's address the elephant in the room: the risk of reentrancy in safeMint. Reentrancy is a well-known vulnerability where a malicious contract can repeatedly call into another contract before the first execution is finished, potentially leading to unexpected behaviors or exploits. In the context of safeMint, the risk emerges when the function checks if the recipient is a smart contract and can handle ERC721 tokens. If the recipient contract is malicious and has implemented the onERC721Received function, it could potentially make recursive calls back to the safeMint function or other functions in the ERC721 contract. This could lead to a variety of issues, including unexpected state changes or, in the worst-case scenario, draining of funds. To mitigate this risk, reentrancy guards or checks-effects-interactions patterns should be incorporated to ensure that the state changes in the contract are finalized before calling external contracts.

While safeMint in ERC721 offers an additional layer of safety compared to mint, it is not immune to the risks inherent in smart contract interactions, such as reentrancy attacks. Understanding these risks and implementing mitigation strategies is crucial for developers working with ERC721 and other smart contract standards.

The following customMint function is vulnerable to such an attack, as the caller can mint multiple times while only one mint should be allowed.