OpenZeppelin Contracts

https://docs.openzeppelin.com/contracts/5.x/
Admin
A library for secure smart contract development providing implementations of standards like ERC20...
Tokens:455,498
Snippets:4,465
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Quick Start Guide for Dapp Development

Source: https://docs.openzeppelin.com/contracts/5.x/learn/building-a-dapp

Follow these steps to run a local blockchain, initialize an OpenZeppelin project, and start the React development server. This guide helps you get a preconfigured React dapp running quickly.

```bash
Run your local blockchain:
> ganache-cli --deterministic
Initialize the OpenZeppelin project:
> openzeppelin init app
Go to the client directory:
> cd client
Run the React app:
> npm run start
Continue in your browser!
More at https://github.com/OpenZeppelin/starter-kit/tree/stable
```

--------------------------------

### Start Client Development Server

Source: https://docs.openzeppelin.com/contracts/5.x/learn/webauthn-smart-accounts

Navigate to the client directory and start the development server using pnpm.

```shell
cd client
pnpm dev
```

--------------------------------

### Start Server Development Server

Source: https://docs.openzeppelin.com/contracts/5.x/learn/webauthn-smart-accounts

Navigate to the server directory, source the environment variables, and start the development server using pnpm.

```shell
cd server
source .env
pnpm dev
```

--------------------------------

### Install Module

Source: https://docs.openzeppelin.com/contracts/5.x/api/account

Installs a Module of a certain type on the smart account.

```APIDOC
## installModule installModule(uint256 moduleTypeId, address module, bytes initData)

### Description
Installs a Module of a certain type on the smart account.

### Method
`public`

### Parameters
- **moduleTypeId** (uint256) - The type ID of the module to install.
- **module** (address) - The address of the module contract.
- **initData** (bytes) - Initialization data for the module.
```

--------------------------------

### Example Usage of CircularBuffer

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils#SafeMath

Demonstrates how to declare, initialize, and use a CircularBuffer in a contract. Ensure to call `setup` during construction.

```Solidity
contract Example {
    // Add the library methods
    using CircularBuffer for CircularBuffer.Bytes32CircularBuffer;

    // Declare a buffer storage variable
    CircularBuffer.Bytes32CircularBuffer private myBuffer;

    constructor() {
        myBuffer.setup(16); // Initialize the buffer with a non-zero fixed size (e.g., 16)
    }

    function pushValue(bytes32 value) external {
        myBuffer.push(value); // Safe to push because the buffer was initialized in the constructor
    }
}
```

--------------------------------

### Setup and Push to Merkle Tree

Source: https://docs.openzeppelin.com/contracts/5.x/utilities

Demonstrates the basic setup and push operations for a Merkle Tree using default hashing. Functions are exposed without access control for demonstration.

```Solidity
using MerkleTree for MerkleTree.Bytes32PushTree;
MerkleTree.Bytes32PushTree private _tree;

function setup(uint8 _depth, bytes32 _zero) public /* onlyOwner */ {
    root = _tree.setup(_depth, _zero);
}

function push(bytes32 leaf) public /* onlyOwner */ {
    (uint256 leafIndex, bytes32 currentRoot) = _tree.push(leaf);
    // Store the new root.
}
```

--------------------------------

### Example Usage of SlotDerivation

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils#SafeMath

Demonstrates how to use the SlotDerivation library within a contract to set and get values in a namespaced mapping. This example utilizes `using for` to extend contract types with library functions.

```solidity
contract Example {
    // Add the library methods
    using StorageSlot for bytes32;
    using SlotDerivation for *;

    // Declare a namespace
    string private constant _NAMESPACE = "<namespace>"; // eg. OpenZeppelin.Slot

    function setValueInNamespace(uint256 key, address newValue) internal {
        _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value = newValue;
    }

    function getValueInNamespace(uint256 key) internal view returns (address) {
        return _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value;
    }
}
```

--------------------------------

### Install Upgradeable Contracts Package

Source: https://docs.openzeppelin.com/contracts/5.x/upgradeable

Install the upgradeable contracts package and the main contracts package as a peer dependency.

```bash
$ npm install @openzeppelin/contracts-upgradeable @openzeppelin/contracts
```

--------------------------------

### Install OpenZeppelin Contracts

Source: https://docs.openzeppelin.com/contracts/5.x/learn/webauthn-smart-accounts

Installs the specified version of the OpenZeppelin contracts library, which includes necessary components for WebAuthn accounts.

```shell
foundry install OpenZeppelin/openzeppelin-contracts@v5.5.0-rc.0
```

--------------------------------

### Install Project Dependencies

Source: https://docs.openzeppelin.com/contracts/5.x/learn/sending-gasless-transactions

Installs necessary packages for building a GSN-powered DApp, including OpenZeppelin network and GSN helper libraries, along with development tools like Ganache.

```bash
$ mkdir gsn-dapp && cd gsn-dapp
$ npm init -y
$ npm install @openzeppelin/network
$ npm install --save-dev @openzeppelin/gsn-helpers @openzeppelin/contracts-ethereum-package @openzeppelin/upgrades @openzeppelin/cli ganache-cli
```

--------------------------------

### Example Usage of Packing and Unpacking

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Demonstrates how to pack an address, bytes4 selector, and uint64 period into a custom bytes32 type and unpack it. This example showcases the utility of the Packing library for custom data structures.

```solidity
library MyPacker {
    type MyType is bytes32;

    function _pack(address account, bytes4 selector, uint64 period) external pure returns (MyType) {
        bytes12 subpack = Packing.pack_4_8(selector, bytes8(period));
        bytes32 pack = Packing.pack_20_12(bytes20(account), subpack);
        return MyType.wrap(pack);
    }

    function _unpack(MyType self) external pure returns (address, bytes4, uint64) {
        bytes32 pack = MyType.unwrap(self);
        return (
            address(Packing.extract_32_20(pack, 0)),
            Packing.extract_32_4(pack, 20),
            uint64(Packing.extract_32_8(pack, 24))
        );
    }
}
```

--------------------------------

### Install OpenZeppelin Contracts v3.1.0

Source: https://docs.openzeppelin.com/contracts/5.x/changelog

Use this command to install the specified version of OpenZeppelin Contracts as a development dependency.

```bash
npm install --save-dev @openzeppelin/contracts
```

--------------------------------

### Check Module Installation

Source: https://docs.openzeppelin.com/contracts/5.x/api/account

Returns whether a module is installed on the smart account.

```APIDOC
## isModuleInstalled isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) → bool

### Description
Returns whether a module is installed on the smart account.

### Method
`public`

### Parameters
- **moduleTypeId** (uint256) - The type ID of the module to check.
- **module** (address) - The address of the module contract.
- **additionalContext** (bytes) - Additional context for the check.
```

--------------------------------

### Permit Usage Example

Source: https://docs.openzeppelin.com/contracts/5.x/api/token/erc20

Example of how to use the permit function with try/catch for robustness against frontrunning. This pattern allows the permit call to fail gracefully while still attempting the main action.

```solidity
function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
    try token.permit(msg.sender, address(this), value, deadline, v, r, s) {}
    catch {}
    doThing(..., value);
}

function doThing(..., uint256 value) public {
    token.safeTransferFrom(msg.sender, address(this), value);
    ...
```

--------------------------------

### Install Module

Source: https://docs.openzeppelin.com/contracts/5.x/api/account

Installs a Module of a certain type on the smart account. The `initData` is expected to be the (packed) concatenation of a 4-byte selector and the rest of the data to be sent to the handler when calling `IERC7579Module.onInstall` for the fallback module type.

```solidity
function installModule(uint256 moduleTypeId, address module, bytes initData) public
```

```solidity
function _installModule(uint256 moduleTypeId, address module, bytes initData) internal
```

--------------------------------

### Install Latest OpenZeppelin Contracts

Source: https://docs.openzeppelin.com/contracts/5.x/changelog

Command to install the latest version of the OpenZeppelin Contracts library using npm.

```bash
$ npm install @openzeppelin/contracts@latest
```

--------------------------------

### Install OpenZeppelin Contracts (Foundry)

Source: https://docs.openzeppelin.com/contracts/5.x

Installs OpenZeppelin Contracts using forge for Foundry projects. Avoid using the master branch in favor of tagged releases.

```bash
$ forge install OpenZeppelin/openzeppelin-contracts
```

--------------------------------

### Permit Function Example

Source: https://docs.openzeppelin.com/contracts/5.x/api/token/ERC20

Example of how to use the permit function with try/catch for robustness against frontrunning. This pattern allows a permit call to fail gracefully while still attempting the main action.

```solidity
function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
    try token.permit(msg.sender, address(this), value, deadline, v, r, s) {}
    catch {}
    doThing(..., value);
}

function doThing(..., uint256 value) public {
    token.safeTransferFrom(msg.sender, address(this), value);
    ...
}
```

--------------------------------

### Install OpenZeppelin Contracts

Source: https://docs.openzeppelin.com/contracts/5.x/learn/developing-smart-contracts

Install the latest published release of the OpenZeppelin Contracts library using npm. Always use published releases to avoid security vulnerabilities.

```bash
npm install @openzeppelin/contracts
```

--------------------------------

### Check Node.js Installation

Source: https://docs.openzeppelin.com/contracts/5.x/learn/setting-up-a-node-project

Verify your Node.js installation by checking its version. Ensure you have an active or maintenance version compatible with most Ethereum software.

```bash
$ node --version
v20.17.0
```

--------------------------------

### votingPeriod

Source: https://docs.openzeppelin.com/contracts/5.x/api/governance

Gets the voting period, the time between vote start and vote end.

```APIDOC
## votingPeriod

### Description
Gets the voting period, the time between the vote start and vote end. The unit depends on the clock used by the contract.

### Method
external

### Response
#### Success Response
- **uint256** - The voting period.
```

--------------------------------

### Initialize Project Directory

Source: https://docs.openzeppelin.com/contracts/5.x/learn/webauthn-smart-accounts

Creates a new directory for the WebAuthn tutorial project and navigates into it. This sets up the base for the project structure.

```Shell
mkdir webauthn-tutorial
cd webauthn-tutorial

```

--------------------------------

### votingDelay

Source: https://docs.openzeppelin.com/contracts/5.x/api/governance

Gets the voting delay, the time between proposal creation and vote start.

```APIDOC
## votingDelay

### Description
Gets the voting delay, the time between the proposal is created and the vote starts. The unit depends on the clock used by the contract.

### Method
external

### Response
#### Success Response
- **uint256** - The voting delay.
```

--------------------------------

### Get Vesting Start Timestamp

Source: https://docs.openzeppelin.com/contracts/5.x/api/finance

Returns the timestamp when the vesting period begins.

```solidity
start() returns (uint256)
```

--------------------------------

### Get Fallback Handler

Source: https://docs.openzeppelin.com/contracts/5.x/api/account

Returns the fallback handler for the given selector. Returns `address(0)` if not installed.

```solidity
function _fallbackHandler(bytes4 selector) → address internal
```

--------------------------------

### Initialize WebAuthn and Viem for Smart Account Creation

Source: https://docs.openzeppelin.com/contracts/5.x/learn/webauthn-smart-accounts

Sets up the client-side application by initializing state variables, creating a Viem public client for interacting with the Sepolia network, and preparing for WebAuthn credential creation.

```typescript
import { useState } from "react";
import "./App.css";
import { WebAuthnP256 } from "ox";
import {
	encodeAbiParameters,
	createPublicClient,
	http,
	encodeFunctionData,
	encodePacked,
	type Hex,
} from "viem";
import { sepolia } from "viem/chains";
import {
	ENTRYPOINT_ADDRESS,
	NFT_ADDRESS,
	entryPointAbi,
	myNftAbi,
	accountWebAuthnAbi,
} from "../../shared";
import type { PackedUserOperation } from "viem/account-abstraction";
import { serializeBigInts } from "./utils";

const SERVER_URL = "http://localhost:8787";

const publicClient = createPublicClient({
	transport: http(),
	chain: sepolia,
});

function App() {
	const [isLoading, setIsLoading] = useState(false);
	const [statusMessage, setStatusMessage] = useState("");
	const [accountAddress, setAccountAddress] = useState<string | null>(null);
	const [mintTxHash, setMintTxHash] = useState<string | null>(null);

	aSync function createAccount() {
		try {
			setIsLoading(true);
			setStatusMessage("Creating WebAuthn credential...");

			// Create WebAuthn credential
			const credential = await WebAuthnP256.createCredential({
				name: "wallet-user",
			});

			// Convert BigInt values to hex strings for serialization (with proper padding)
			const publicKey = {
				prefix: credential.publicKey.prefix,
				x: `0x${credential.publicKey.x.toString(16).padStart(64, "0")}`,
				y: `0x${credential.publicKey.y.toString(16).padStart(64, "0")}`,
			};

			setStatusMessage("Deploying WebAuthn account...");

```

--------------------------------

### Initialize Foundry Project for Contracts

Source: https://docs.openzeppelin.com/contracts/5.x/learn/webauthn-smart-accounts

Sets up a new Foundry project and navigates into the contracts directory.

```shell
forge init contracts
cd contracts
```

--------------------------------

### Initialize AccountERC7579 with a Validator Module

Source: https://docs.openzeppelin.com/contracts/5.x/api/account

Example of how to initialize a custom account contract that inherits from AccountERC7579, installing a validator module during initialization.

```solidity
contract MyAccountERC7579 is AccountERC7579, Initializable {
  function initializeAccount(address validator, bytes calldata validatorData) public initializer {
    _installModule(MODULE_TYPE_VALIDATOR, validator, validatorData);
  }
}
```

--------------------------------

### Set up Environment Variables

Source: https://docs.openzeppelin.com/contracts/5.x/learn/webauthn-smart-accounts

Configure your environment by exporting RPC URL and private key. This allows Foundry to access necessary credentials for deployment.

```shell
export RPC_URL=https://sepolia.drpc.org\nexport PRIVATE_KEY=$(cast wallet private-key --account sepolia)
```

--------------------------------

### Initialize OpenZeppelin Project

Source: https://docs.openzeppelin.com/contracts/5.x/learn/sending-gasless-transactions

Initializes a new OpenZeppelin project, setting up the necessary configuration and directory structure for smart contract development and deployment.

```bash
$ npx oz init
```

--------------------------------

### Retrieve Accounts with ethers.js

Source: https://docs.openzeppelin.com/contracts/5.x/learn/deploying-and-interacting

Use `ethers.getSigners()` to get a list of available accounts from the local Hardhat node. This is useful for verifying your Hardhat setup.

```javascript
// Retrieve accounts from the local node
const accounts = (await ethers.getSigners()).map(signer => signer.address);
console.log(accounts);
```

--------------------------------

### Create React App

Source: https://docs.openzeppelin.com/contracts/5.x/learn/sending-gasless-transactions

Bootstrap a new React client-side application using create-react-app.

```bash
$ npx create-react-app client
```

--------------------------------

### Check Module Installation

Source: https://docs.openzeppelin.com/contracts/5.x/api/account

Returns whether a module is installed on the smart account. This internal function reverts if the module is not installed.

```solidity
function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) → bool public
```

```solidity
function _checkModule(uint256 moduleTypeId, address module, bytes additionalContext) internal
```

--------------------------------

### Upgrade ERC1967 Implementation with Setup Call

Source: https://docs.openzeppelin.com/contracts/5.x/api/proxy

Upgrade the implementation of an ERC-1967 proxy and optionally perform a setup call. This function is payable only if the setup call is performed.

```solidity
function upgradeToAndCall(address newImplementation, bytes memory data) internal {
    _upgradeTo(newImplementation);
    if (data.length > 0) {
        Address.functionDelegateCall(newImplementation, data);
    }
}
```

--------------------------------

### Unpack OpenZeppelin Starter Kit

Source: https://docs.openzeppelin.com/contracts/5.x/learn/building-a-dapp

Use the `oz unpack` command to download and extract a preconfigured dapp starter kit. This command sets up a project with OpenZeppelin libraries, Infura connections, and Rimble UI components.

```bash
$ oz unpack starter
✓ Kit downloaded and unpacked
The kit is ready to use.
```

--------------------------------

### Example Usage of SignerRSA with Account

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils/cryptography

Demonstrates how to integrate SignerRSA with an Account contract, including initialization of the RSA public key.

```solidity
contract MyAccountRSA is Account, SignerRSA, Initializable {
    function initialize(bytes memory e, bytes memory n) public initializer {
      _setSigner(e, n);
    }
}
```

--------------------------------

### Create Contract Instance with OpenZeppelin CLI

Source: https://docs.openzeppelin.com/contracts/5.x/learn/sending-gasless-transactions

Deploys a contract instance using the OpenZeppelin CLI, prompts for contract selection, network, and initialization function, and returns the instance address.

```bash
$ openzeppelin create
✓ Compiled contracts with solc 0.5.9 (commit.e560f70d)
? Pick a contract to instantiate Counter
? Pick a network development
All contracts are up to date
? Call a function to initialize the instance after creating it? Yes
? Select which function * initialize()
✓ Instance created at 0xCfEB869F69431e42cdB54A4F4f105C19C080A601
```

--------------------------------

### hook()

Source: https://docs.openzeppelin.com/contracts/5.x/api/account

Returns the address of the installed hook module, or the zero address if none is installed.

```APIDOC
## hook()

### Description
Returns the hook module address if installed, or `address(0)` otherwise.

### Function Signature
`hook() → address`

### Visibility
`public`
```

--------------------------------

### Initialize Hardhat Project

Source: https://docs.openzeppelin.com/contracts/5.x/learn/developing-smart-contracts

Run the Hardhat command-line tool to initialize a new Hardhat project, which includes creating a configuration file.

```bash
npx hardhat
# 888    888                      888 888               888
# 888    888                      888 888               888
# 888    888                      888 888               888
# 8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
# 888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
# 888    888 .d888888 888    888  888 888  888 .d888888 888
# 888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
# 888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888
#
# 👷 Welcome to Hardhat v2.22.12 👷‍
#
# ✔ What do you want to do? · Create an empty hardhat.config.js
# Config file created

```

--------------------------------

### splice(uint256[] array, uint256 start)

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Moves the content of `array`, from `start` (included) to the end of `array` to the start of that array, and shrinks the array length accordingly. This function modifies the provided array in place.

```APIDOC
## splice(uint256[] array, uint256 start)

### Description
Moves the content of `array`, from `start` (included) to the end of `array` to the start of that array, and shrinks the array length accordingly, effectively overwriting the array with array[start:].

### Method
Internal

### Parameters
- **array** (uint256[]) - The array to modify.
- **start** (uint256) - The starting index (inclusive).

### Notes
This function modifies the provided array in place. If you need to preserve the original array, use `Arrays.slice` instead.
```

--------------------------------

### Setup Weighted Multisig Account

Source: https://docs.openzeppelin.com/contracts/5.x/multisig

Demonstrates initializing a weighted multisig account with signers, their corresponding weights, and a threshold.

```Solidity
// Example setup for weighted multisig
function setupWeightedMultisigAccount() external {
    // Create array of signers (same as above)
    bytes[] memory signers = new bytes[](3);
    signers[0] = ecdsaSigner;
    signers[1] = p256Signer;
    signers[2] = rsaSigner;
    
    // Assign weights to signers (Alice:1, Bob:2, Charlie:3)
    uint256[] memory weights = new uint256[](3);
    weights[0] = 1;
    weights[1] = 2;
    weights[2] = 3;
    
    // Set threshold to 4 (requires at least Bob+Charlie or all three)
    uint256 threshold = 4;
    
    // Initialize the weighted account
    myWeightedMultisigAccount.initialize(signers, weights, threshold);
}
```

--------------------------------

### Install Hardhat Development Tool

Source: https://docs.openzeppelin.com/contracts/5.x/learn/developing-smart-contracts

Install Hardhat as a development dependency in your project using npm.

```bash
npm install --save-dev hardhat
```

--------------------------------

### Upgrade ERC1967 Beacon with Setup Call

Source: https://docs.openzeppelin.com/contracts/5.x/api/proxy

Change the beacon of an ERC-1967 proxy and optionally perform a setup call. This function is payable only if the setup call is performed. Note: Invoking this function has no effect on `BeaconProxy` instances since v5.

```solidity
function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {
    _upgradeBeacon(newBeacon);
    if (data.length > 0) {
        Address.functionDelegateCall(newBeacon, data);
    }
}
```

--------------------------------

### Install Hardhat Toolbox

Source: https://docs.openzeppelin.com/contracts/5.x/learn/writing-automated-tests

Install the Hardhat Toolbox to use Chai assertions for unit tests. This is a development dependency.

```bash
$ npm install --save-dev @nomicfoundation/hardhat-toolbox
```

--------------------------------

### Example Usage of Panic Utility

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Demonstrates how to use the Panic utility library to revert with standardized panic codes, either by using predefined constants or by providing a custom code.

```solidity
contract Example {
     using Panic for uint256;

     // Use any of the declared internal constants
     function foo() { Panic.GENERIC.panic(); }

     // Alternatively
     function foo() { Panic.panic(Panic.GENERIC); }
}
```

--------------------------------

### Install hardhat-verify Plugin

Source: https://docs.openzeppelin.com/contracts/5.x/learn/preparing-for-mainnet

Install the hardhat-verify plugin to automate contract verification. This is a prerequisite for using the verification task.

```bash
npm install --save-dev @nomicfoundation/hardhat-verify
```

--------------------------------

### Create a New Project Directory

Source: https://docs.openzeppelin.com/contracts/5.x/learn/setting-up-a-node-project

Start a new Node.js project by creating a dedicated directory for it. This is the first step in organizing your project files.

```bash
$ mkdir learn && cd learn
```

--------------------------------

### Setup Standard 2-of-3 Multisig Account

Source: https://docs.openzeppelin.com/contracts/5.x/multisig

Demonstrates initializing a standard multisig account with different types of signers (ECDSA, P256, RSA) and a threshold of 2.

```Solidity
// Example setup code
function setupMultisigAccount() external {
    // Create signers using different types of keys
    bytes memory ecdsaSigner = alice; // EOA address (20 bytes)
    
    // P256 signer with format: verifier || pubKey
    bytes memory p256Signer = abi.encodePacked(
        p256Verifier,
        bobP256PublicKeyX,
        bobP256PublicKeyY
    );
    
    // RSA signer with format: verifier || pubKey
    bytes memory rsaSigner = abi.encodePacked(
        rsaVerifier,
        abi.encode(charlieRSAPublicKeyE, charlieRSAPublicKeyN)
    );
    
    // Create array of signers
    bytes[] memory signers = new bytes[](3);
    signers[0] = ecdsaSigner;
    signers[1] = p255Signer;
    signers[2] = rsaSigner;
    
    // Set threshold to 2 (2-of-3 multisig)
    uint256 threshold = 2;
    
    // Initialize the account
    myMultisigAccount.initialize(signers, threshold);
}
```

--------------------------------

### Import Create2 Utility

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils#SafeMath

Import the Create2 library for easier and safer usage of the CREATE2 EVM opcode.

```Solidity
import "@openzeppelin/contracts/utils/Create2.sol";
```

--------------------------------

### Install Hardhat Ethers Plugin

Source: https://docs.openzeppelin.com/contracts/5.x/learn/deploying-and-interacting

Install the necessary npm packages for Hardhat to interact with ethers. This includes `@nomicfoundation/hardhat-ethers` and `ethers`.

```bash
npm install --save-dev @nomicfoundation/hardhat-ethers ethers
```

--------------------------------

### Querying Role Members and Target Functions

Source: https://docs.openzeppelin.com/contracts/5.x/access-control

Examples demonstrating how to query the number of members in a role, list all members, count target functions for a role on a specific target, and list all target functions.

```JavaScript
const minterCount = await accessManager.getRoleMemberCount(MINTER_ROLE);

const members = [];
for (let i = 0; i < minterCount; ++i) {
    members.push(await accessManager.getRoleMember(MINTER_ROLE, i));
}

const allMembers = await accessManager.getRoleMembers(MINTER_ROLE, 0, ethers.MaxUint256);

const target = await myToken.getAddress();
const functionCount = await accessManager.getRoleTargetFunctionCount(MINTER_ROLE, target);

const functions = [];
for (let i = 0; i < functionCount; ++i) {
    functions.push(await accessManager.getRoleTargetFunction(MINTER_ROLE, target, i));
}

const allFunctions = await accessManager.getRoleTargetFunctions(MINTER_ROLE, target, 0, ethers.MaxUint256);
```

--------------------------------

### splice(uint256[] array, uint256 start, uint256 end)

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Moves the content of `array`, from `start` (included) to `end` (excluded) to the start of that array, and shrinks the array length accordingly. The `end` argument is truncated to the length of the `array`. This function modifies the provided array in place.

```APIDOC
## splice(uint256[] array, uint256 start, uint256 end)

### Description
Moves the content of `array`, from `start` (included) to `end` (excluded) to the start of that array, and shrinks the array length accordingly, effectively overwriting the array with array[start:end]. The `end` argument is truncated to the length of the `array`.

### Method
Internal

### Parameters
- **array** (uint256[]) - The array to modify.
- **start** (uint256) - The starting index (inclusive).
- **end** (uint256) - The ending index (exclusive).

### Notes
This function modifies the provided array in place. If you need to preserve the original array, use `Arrays.slice` instead.
```

--------------------------------

### splice(bytes32[] array, uint256 start, uint256 end)

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Moves the content of `array`, from `start` (included) to `end` (excluded) to the start of that array, and shrinks the array length accordingly. The `end` argument is truncated to the length of the `array`. This function modifies the provided array in place.

```APIDOC
## splice(bytes32[] array, uint256 start, uint256 end)

### Description
Moves the content of `array`, from `start` (included) to `end` (excluded) to the start of that array, and shrinks the array length accordingly, effectively overwriting the array with array[start:end]. The `end` argument is truncated to the length of the `array`.

### Method
Internal

### Parameters
- **array** (bytes32[]) - The array to modify.
- **start** (uint256) - The starting index (inclusive).
- **end** (uint256) - The ending index (exclusive).

### Notes
This function modifies the provided array in place. If you need to preserve the original array, use `Arrays.slice` instead.
```

--------------------------------

### Import Math Utilities

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Import the Math contract for standard math utilities that are missing in the Solidity language.

```Solidity
import "@openzeppelin/contracts/utils/math/Math.sol";
```

--------------------------------

### Install Hardhat Upgrades Plugin

Source: https://docs.openzeppelin.com/contracts/5.x/learn/upgrading-smart-contracts

Install the OpenZeppelin Hardhat Upgrades plugin using npm. This is a required step before configuring Hardhat.

```bash
npm install --save-dev @openzeppelin/hardhat-upgrades
```

--------------------------------

### Initialize a Node.js Project

Source: https://docs.openzeppelin.com/contracts/5.x/learn/setting-up-a-node-project

Initialize a new Node.js project with a `package.json` file using `npm init -y`. This command creates a default configuration for your project.

```bash
$ npm init -y
```

--------------------------------

### Install Latest Unaudited Release (Hardhat)

Source: https://docs.openzeppelin.com/contracts/5.x

Installs the latest unaudited release of OpenZeppelin Contracts using npm for Hardhat projects.

```bash
$ npm install @openzeppelin/contracts@dev
```

--------------------------------

### Install Latest Audited Release (Hardhat)

Source: https://docs.openzeppelin.com/contracts/5.x

Installs the latest audited release of OpenZeppelin Contracts using npm for Hardhat projects.

```bash
$ npm install @openzeppelin/contracts
```

--------------------------------

### Deploy Upgradeable Proxy with Hardhat

Source: https://docs.openzeppelin.com/contracts/5.x/upgradeable

Example deployment script using Hardhat's upgrades plugin to deploy an upgradeable proxy contract.

```javascript
const { ethers, upgrades } = require("hardhat");

async function main() {
  const MyCollectible = await ethers.getContractFactory("MyCollectible");

    const mc = await upgrades.deployProxy(MyCollectible);

    await mc.waitForDeployment();
    console.log("MyCollectible deployed to:", await mc.getAddress());
}

main();
```

--------------------------------

### Create and Deploy WebAuthn Smart Account

Source: https://docs.openzeppelin.com/contracts/5.x/learn/webauthn-smart-accounts

This snippet demonstrates the backend logic for creating a new WebAuthn smart account. It predicts the account address, deploys the account using a factory, and funds it with ETH. Requires RPC_URL and PRIVATE_KEY environment variables.

```typescript
import { Hono } from "hono";
import { cors } from "hono/cors";
import { logger } from "hono/logger";
import {
	type Hex,
	encodeFunctionData,
	createPublicClient,
	createWalletClient,
	http,
	encodeAbiParameters,
} from "viem";
import {
	accountWebAuthnAbi,
	FACTORY_ADDRESS,
	accountFactoryAbi,
	ENTRYPOINT_ADDRESS,
	entryPointAbi,
} from "../../shared";
import { privateKeyToAccount } from "viem/accounts";
import { sepolia } from "viem/chains";

type Bindings = {
	RPC_URL: string;
	PRIVATE_KEY: string;
};

const app = new Hono<{ Bindings: Bindings }>();

app.use(cors());
app.use(logger());

app.get("/", (c) => {
	return c.text("Hello Hono!");
});

app.post("/account/create", async (c) => {
	try {
		const publicClient = createPublicClient({
			chain: sepolia,
			transport: http(c.env.RPC_URL),
		});

		const account = privateKeyToAccount(c.env.PRIVATE_KEY as `0x${string}`);

		const walletClient = createWalletClient({
			chain: sepolia,
			transport: http(c.env.RPC_URL),
			account,
		});

		const {
			credentialId, // Can be used to store accounts for future logins
			publicKey,
		} = await c.req.json();

		// Extract qx and qy from the public key (ensure proper padding)
		const qx = publicKey.x as Hex;
		const qy = publicKey.y as Hex;

		// Encode the initialization call
		const initCallData = encodeFunctionData({
			abi: accountWebAuthnAbi,
			functionName: "initializeWebAuthn",
			args: [qx, qy],
		});

		// Predict account address
		const [predictedAddress] = await publicClient.readContract({
			address: FACTORY_ADDRESS,
			abi: accountFactoryAbi,
			functionName: "predictAddress",
			args: [initCallData],
		});

		// Deploy the account
		const hash = await walletClient.writeContract({
			address: FACTORY_ADDRESS,
			abi: accountFactoryAbi,
			functionName: "cloneAndInitialize",
			args: [initCallData],
		});

		// Wait for transaction
		await publicClient.waitForTransactionReceipt({ hash });

		// Fund the account with 0.005 ETH from deployer wallet
		const fundHash = await walletClient.sendTransaction({
			to: predictedAddress,
			value: 5000000000000000n, // 0.005 ETH in wei
		});

		// Wait for funding transaction
		await publicClient.waitForTransactionReceipt({ hash: fundHash });

		return c.json({
			success: true,
			accountAddress: predictedAddress,
			ransactionHash: hash,
			fundingTransactionHash: fundHash,
			publicKey: { qx, qy },
		});
	} catch (error) {
		return c.json({ error: ` Failed to create account: ${error} ` }, 500);
	}
});

app.post("/account/mint", async (c) => {
	const publicClient = createPublicClient({
		chain: sepolia,
		transport: http(c.env.RPC_URL),
	});

	const account = privateKeyToAccount(c.env.PRIVATE_KEY as `0x${string}`);

	const walletClient = createWalletClient({
		chain: sepolia,
		transport: http(c.env.RPC_URL),
		account,
	});

	try {
		const {
			metadata,
			rHex,
			sHex,
			userOp,
			nonce: serializedNonce,
		} = await c.req.json();

		const challengeIndex = BigInt(metadata.challengeIndex);
		const typeIndex = BigInt(metadata.typeIndex);
		const authenticatorDataHex = metadata.authenticatorData;
		const clientDataJSON = metadata.clientDataJSON;
		const nonce = BigInt(serializedNonce);

		const encodedSignature = encodeAbiParameters(
			[
				{ name: "r", type: "bytes32" },
				{ name: "s", type: "bytes32" },
				{ name: "challengeIndex", type: "uint256" },
				{ name: "typeIndex", type: "uint256" },
				{ name: "authenticatorData", type: "bytes" },
				{ name: "clientDataJSON", type: "string" },
			],
			[
				rHex,
				sHex,
				challengeIndex,
				typeIndex,
				authenticatorDataHex,
				clientDataJSON,
			],
		);

		const fullUserOp = {
			...userOp,
			nonce,
			preVerificationGas: BigInt(userOp.preVerificationGas),
			signature: encodedSignature,
		};

		const { request } = await publicClient.simulateContract({
			address: ENTRYPOINT_ADDRESS,
			abi: entryPointAbi,
			functionName: "handleOps",
			args: [[fullUserOp], walletClient.account.address],
			account: walletClient.account,
		});

		const hash = await walletClient.writeContract(request);

		const receipt = await publicClient.waitForTransactionReceipt({
			hash: hash,
		});

		if (receipt.status === "reverted") {
			return c.json({ error: ` Failed to Mint: Reverted ` }, 500);
		}

		return c.json({
			status: "success",
			hash,
		});
	} catch (error) {
		return c.json({ error: ` Failed to Mint: ${error} ` }, 500);
	}
});

export default app;

```

--------------------------------

### slice (uint256[], uint256 start)

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Copies elements from a uint256 array starting at a specified index to the end into a new array in memory.

```APIDOC
## slice(uint256[] array, uint256 start)

### Description
Copies the content of `array`, from `start` (included) to the end of `array` into a new uint256 array in memory. Replicates the behavior of Javascript's `Array.slice`.

### Method
internal

### Parameters
#### Path Parameters
- **array** (uint256[]) - The array to slice.
- **start** (uint256) - The starting index (inclusive).

### Returns
- **uint256[]** - A new array containing the sliced elements.
```

--------------------------------

### Example Usage of AccessControlDefaultAdminRules

Source: https://docs.openzeppelin.com/contracts/5.x/api/access

Demonstrates how to inherit and initialize AccessControlDefaultAdminRules in a custom contract, setting an initial delay and the default admin.

```solidity
contract MyToken is AccessControlDefaultAdminRules {
  constructor() AccessControlDefaultAdminRules(
    3 days,
    msg.sender // Explicit initial `DEFAULT_ADMIN_ROLE` holder
   ) {}
}
```

--------------------------------

### slice (bytes32[], uint256 start)

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Copies elements from a bytes32 array starting at a specified index to the end into a new array in memory.

```APIDOC
## slice(bytes32[] array, uint256 start)

### Description
Copies the content of `array`, from `start` (included) to the end of `array` into a new bytes32 array in memory. Replicates the behavior of Javascript's `Array.slice`.

### Method
internal

### Parameters
#### Path Parameters
- **array** (bytes32[]) - The array to slice.
- **start** (uint256) - The starting index (inclusive).

### Returns
- **bytes32[]** - A new array containing the sliced elements.
```

--------------------------------

### slice (address[], uint256 start)

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Copies elements from an address array starting at a specified index to the end into a new array in memory.

```APIDOC
## slice(address[] array, uint256 start)

### Description
Copies the content of `array`, from `start` (included) to the end of `array` into a new address array in memory. Replicates the behavior of Javascript's `Array.slice`.

### Method
internal

### Parameters
#### Path Parameters
- **array** (address[]) - The array to slice.
- **start** (uint256) - The starting index (inclusive).

### Returns
- **address[]** - A new array containing the sliced elements.
```

--------------------------------

### Initialize smart accounts

Source: https://docs.openzeppelin.com/contracts/5.x/accounts

Implements the Initializable pattern to configure account signers immediately after deployment. Always ensure accounts are initialized to avoid them remaining unusable.

```solidity
import {Account} from "@openzeppelin/community-contracts/account/Account.sol";
import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import {SignerECDSA} from "@openzeppelin/contracts/utils/cryptography/signers/SignerECDSA.sol";

contract MyAccount is Initializable, Account, SignerECDSA, ... {
    // ...

    function initializeECDSA(address signer) public initializer {
        _setSigner(signer);
    }
}
```

--------------------------------

### SignerERC7913 Contract Example

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils/cryptography

Example of using SignerERC7913 within an ERC-7913 account contract. Ensure _setSigner is called during initialization or construction.

```solidity
contract MyAccountERC7913 is Account, SignerERC7913, Initializable {
    function initialize(bytes memory signer_) public initializer {
      _setSigner(signer_);
    }

    function setSigner(bytes memory signer_) public onlyEntryPointOrSelf {
      _setSigner(signer_);
    }
}
```

--------------------------------

### Example Usage of SignerP256 with Account

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils/cryptography

Demonstrates how to integrate SignerP256 into an Account contract using an initializer. Ensure _setSigner is called during construction or initialization.

```solidity
contract MyAccountP256 is Account, SignerP256, Initializable {
    function initialize(bytes32 qx, bytes32 qy) public initializer {
      _setSigner(qx, qy);
    }
}
```

--------------------------------

### Get Supported Interfaces for an Account

Source: https://docs.openzeppelin.com/contracts/5.x/api/utils

Use ERC165Checker.getSupportedInterfaces to get a boolean array indicating support for multiple interface IDs. This function is internal.

```solidity
function getSupportedInterfaces(address account, bytes4[] interfaceIds) → bool[]
internal
```
Tokens:
Raw