or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

access-control.mdcrosschain.mdfinance.mdgovernance.mdindex.mdmetatx.mdproxy.mdsecurity.mdtokens.mdutilities.md
tile.json

tessl/npm-openzeppelin-solidity

Secure Smart Contract library providing battle-tested implementations of industry-standard Solidity contracts including ERC20, ERC721, ERC1155 tokens, access control mechanisms, proxy patterns, and governance systems for Ethereum and EVM-compatible blockchains.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/openzeppelin-solidity@4.8.x

To install, run

npx @tessl/cli install tessl/npm-openzeppelin-solidity@4.8.0

index.mddocs/

OpenZeppelin Contracts

OpenZeppelin Contracts is a comprehensive library of secure, battle-tested smart contract components for Solidity development on Ethereum and EVM-compatible blockchains. It provides standardized implementations of industry-standard token contracts (ERC20, ERC721, ERC1155, ERC777), flexible access control mechanisms, security patterns, proxy systems for upgradeability, governance frameworks, and essential utilities for cryptographic operations and mathematical calculations.

Package Information

  • Package Name: openzeppelin-solidity
  • Package Type: npm
  • Language: Solidity, JavaScript
  • Installation: npm install openzeppelin-solidity
  • Documentation: https://docs.openzeppelin.com/contracts
  • Version: 4.8.1

Core Imports

Import contracts using Solidity import statements:

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

For specific extensions:

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

Basic Usage

Simple ERC20 Token

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyToken is ERC20, Ownable {
    constructor() ERC20("MyToken", "MTK") {
        _mint(msg.sender, 1000000 * 10**decimals());
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

Simple NFT Collection

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract MyNFT is ERC721, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() ERC721("MyNFT", "MNFT") {}

    function mint(address recipient) public onlyOwner returns (uint256) {
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();
        _safeMint(recipient, newItemId);
        return newItemId;
    }
}

Architecture

OpenZeppelin Contracts follows several key design patterns:

  • Inheritance-Based Extensions: Core implementations extended through inheritance for additional functionality
  • Interface Compliance: All contracts implement standard interfaces (IERC20, IERC721, etc.)
  • Security First: Every contract follows security best practices and undergoes rigorous auditing
  • Gas Optimization: Implementations balance security with gas efficiency
  • Modular Design: Contracts can be combined and extended for custom use cases
  • Role-Based Access: Flexible access control through roles and ownership patterns

Capabilities

Token Standards

Complete implementations of major Ethereum token standards with extensive extensions and utilities. Includes fungible tokens (ERC20), non-fungible tokens (ERC721), multi-tokens (ERC1155), and advanced tokens (ERC777).

contract ERC20 is Context, IERC20, IERC20Metadata {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    function balanceOf(address owner) external view returns (uint256 balance);
    function ownerOf(uint256 tokenId) external view returns (address owner);
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function transferFrom(address from, address to, uint256 tokenId) external;
    function approve(address to, uint256 tokenId) external;
    function setApprovalForAll(address operator, bool approved) external;
    function getApproved(uint256 tokenId) external view returns (address operator);
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

Token Standards

Access Control

Role-based and ownership-based access control mechanisms for restricting function access and managing permissions in smart contracts.

abstract contract AccessControl is Context, IAccessControl, ERC165 {
    function hasRole(bytes32 role, address account) public view virtual returns (bool);
    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32);
    function grantRole(bytes32 role, address account) public virtual;
    function revokeRole(bytes32 role, address account) public virtual;
    function renounceRole(bytes32 role, address account) public virtual;
}

abstract contract Ownable is Context {
    function owner() public view virtual returns (address);
    function renounceOwnership() public virtual onlyOwner;
    function transferOwnership(address newOwner) public virtual onlyOwner;
}

Access Control

Security Patterns

Security mechanisms including reentrancy protection, pausable contracts, and pull payment patterns to prevent common smart contract vulnerabilities.

abstract contract ReentrancyGuard {
    modifier nonReentrant();
}

abstract contract Pausable is Context {
    function paused() public view virtual returns (bool);
    modifier whenNotPaused();
    modifier whenPaused();
}

Security Patterns

Proxy Patterns

Upgradeable contract patterns and proxy utilities for creating flexible, maintainable smart contract systems.

library Clones {
    function clone(address implementation) internal returns (address instance);
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance);
    function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted);
}

abstract contract Proxy {
    function _delegate(address implementation) internal virtual;
    function _implementation() internal view virtual returns (address);
    function _fallback() internal virtual;
}

Proxy Patterns

Governance

On-chain governance systems with voting mechanisms, proposal management, and timelock controllers for decentralized decision making.

abstract contract Governor is Context, ERC165, EIP712, IGovernor {
    function name() public view virtual returns (string memory);
    function version() public view virtual returns (string memory);
    function hashProposal(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash) public pure virtual returns (uint256);
    function state(uint256 proposalId) public view virtual returns (ProposalState);
    function propose(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, string memory description) public virtual returns (uint256);
    function execute(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash) public payable virtual returns (uint256);
    function castVote(uint256 proposalId, uint8 support) public virtual returns (uint256);
}

contract TimelockController is AccessControl {
    function isOperation(bytes32 id) public view virtual returns (bool registered);
    function isOperationPending(bytes32 id) public view virtual returns (bool pending);
    function isOperationReady(bytes32 id) public view virtual returns (bool ready);
    function isOperationDone(bytes32 id) public view virtual returns (bool done);
    function getTimestamp(bytes32 id) public view virtual returns (uint256 timestamp);
    function getMinDelay() public view virtual returns (uint256 duration);
    function schedule(address target, uint256 value, bytes calldata data, bytes32 predecessor, bytes32 salt, uint256 delay) public virtual;
    function execute(address target, uint256 value, bytes calldata data, bytes32 predecessor, bytes32 salt) public payable virtual;
}

Governance

Utility Functions

Common utility functions including mathematical operations, cryptographic utilities, data structures, and helper functions for smart contract development.

library Math {
    function max(uint256 a, uint256 b) internal pure returns (uint256);
    function min(uint256 a, uint256 b) internal pure returns (uint256);
    function average(uint256 a, uint256 b) internal pure returns (uint256);
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256);
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result);
    function sqrt(uint256 a) internal pure returns (uint256);
}

library ECDSA {
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address);
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32);
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32);
}

library Address {
    function isContract(address account) internal view returns (bool);
    function sendValue(address payable recipient, uint256 amount) internal;
    function functionCall(address target, bytes memory data) internal returns (bytes memory);
}

Utilities

Financial Primitives

Payment splitting, vesting schedules, and other financial mechanisms for handling cryptocurrency payments and distributions.

contract PaymentSplitter is Context {
    function totalShares() public view returns (uint256);
    function totalReleased() public view returns (uint256);
    function shares(address account) public view returns (uint256);
    function released(address account) public view returns (uint256);
    function payee(uint256 index) public view returns (address);
    function release(address payable account) public virtual;
}

contract VestingWallet is Context {
    function beneficiary() public view virtual returns (address);
    function start() public view virtual returns (uint256);
    function duration() public view virtual returns (uint256);
    function released() public view virtual returns (uint256);
    function releasable() public view virtual returns (uint256);
    function release() public virtual;
}

Financial Primitives

Meta-Transactions

ERC2771 meta-transaction support for gasless transactions and improved user experience in decentralized applications.

abstract contract ERC2771Context is Context {
    function isTrustedForwarder(address forwarder) public view virtual returns (bool);
    function _msgSender() internal view virtual override returns (address sender);
    function _msgData() internal view virtual override returns (bytes calldata);
}

contract MinimalForwarder is EIP712 {
    struct ForwardRequest {
        address from;
        address to;
        uint256 value;
        uint256 gas;
        uint256 nonce;
        bytes data;
    }
    
    function getNonce(address from) public view returns (uint256);
    function verify(ForwardRequest calldata req, bytes calldata signature) public view returns (bool);
    function execute(ForwardRequest calldata req, bytes calldata signature) public payable returns (bool, bytes memory);
}

Meta-Transactions

Cross-Chain Integration

Cross-chain messaging utilities for communicating across different blockchain networks, supporting Layer 2 solutions and bridge protocols.

abstract contract CrossChainEnabled {
    function _isCrossChain() internal view virtual returns (bool);
    function _crossChainSender() internal view virtual returns (address);
}

abstract contract CrossChainEnabledOptimism is CrossChainEnabled {
    constructor(address crossChainMessenger);
    function crossChainMessenger() public view virtual returns (address);
}

abstract contract CrossChainEnabledArbitrumL1 is CrossChainEnabled {
    constructor(address bridge);
    function bridge() public view virtual returns (address);
}

Cross-Chain Integration