The OpenZeppelin Contracs provide a ton of useful utilities that you can use in your project. Here are some of the more popular ones.


Checking Signatures On-Chain

ECDSA provides functions for recovering and managing Ethereum account ECDSA signatures. These are often generated via web3.eth.sign, and are a 65 byte array (of type bytes in Solidity) arranged the follwing way: [[v (1)], [r (32)], [s (32)]].

The data signer can be recovered with ECDSA.recover, and its address compared to verify the signature. Most wallets will hash the data to sign and add the prefix '\x19Ethereum Signed Message:\n', so when attempting to recover the signer of an Ethereum signed message hash, you’ll want to use toEthSignedMessageHash.

using ECDSA for bytes32;

function _verify(bytes32 data, address account) pure returns (bool) {
    return keccack256(data)
        .recover(signature) == account;
Getting signature verification right is not trivial: make sure you fully read and understand ECDSA's documentation.

Verifying Merkle Proofs

MerkleProof provides verify, which can prove that some value is part of a Merkle tree.


In Solidity, it’s frequently helpful to know whether or not a contract supports an interface you’d like to use. ERC165 is a standard that helps do runtime interface detection. Contracts provides helpers both for implementing ERC165 in your contracts and querying other contracts:

contract MyContract {
    using ERC165Checker for address;

    bytes4 private InterfaceId_ERC721 = 0x80ac58cd;

     * @dev transfer an ERC721 token from this contract to someone else
    function transferERC721(
        address token,
        address to,
        uint256 tokenId
        require(token.supportsInterface(InterfaceId_ERC721), "IS_NOT_721_TOKEN");
        IERC721(token).transferFrom(address(this), to, tokenId);


The most popular math related library OpenZeppelin Contracts provides is SafeMath, which provides mathematical functions that protect your contract from overflows and underflows.

Include the contract with using SafeMath for uint256; and then call the functions:

  • myNumber.add(otherNumber)

  • myNumber.sub(otherNumber)

  • myNumber.div(otherNumber)

  • myNumber.mul(otherNumber)

  • myNumber.mod(otherNumber)



Want to split some payments between multiple people? Maybe you have an app that sends 30% of art purchases to the original creator and 70% of the profits to the current owner; you can build that with PaymentSplitter!

In Solidity, there are some security concerns with blindly sending money to accounts, since it allows them to execute arbitrary code. You can read up on these security concerns in the Ethereum Smart Contract Best Practices website. One of the ways to fix reentrancy and stalling problems is, instead of immediately sending Ether to accounts that need it, you can use PullPayment, which offers an _asyncTransfer function for sending money to something and requesting that they withdrawPayments() it later.

If you want to Escrow some funds, check out Escrow and ConditionalEscrow for governing the release of some escrowed Ether.


If you need support for more powerful collections than Solidity’s native arrays and mappings, take a look at EnumerableSet. It is similar to a mapping in that it stores and removes elements in constant time and doesn’t allow for repeated entries, but it also supports enumeration, which means you can easily query all elements of the set both on and off-chain.


Want to check if an address is a contract? Use Address and Address.isContract().

Want to keep track of some numbers that increment by 1 every time you want another one? Check out Counter. This is useful for lots of things, like creating incremental identifiers, as shown on the ERC721 guide.