EVMAuth Core

Overview

EVMAuth is an authorization state management system for APIs, MCP servers, and AI agents.

Purpose

EVMAuth was created to provide a simple, standardized way to manage persistent authorization without the overhead of developing and maintaining auth servers, databases, subscription management services, and payment systems.

Use Cases

• Token-Gated Access Control: Grant access to digital services, APIs, and AI agents based on token ownership.
• Subscription Management: Issue time-limited access tokens for subscription-based services.
• Metered Usage: Issue tokens that can be redeemed for usage credits, allowing for pay-as-you-go models.
• Licensing: Manage software licenses and entitlements through tokens.
• Access Revocation: Instantly revoke access by burning tokens or freezing accounts.
• Decentralized Identity: Leverage EVM networks for secure and verifiable identity management.

Features

Each EVMAuth token type can be configured for direct purchase, with any of the following:

• Native currencies like ETH
• Stablecoins like USDC and USDT
• Any other ERC-20 tokens

Each accepted payment method can be priced independently. If no prices are set (i.e. all prices are zero), direct purchases are disabled for that token type.

EVMAuth tokens can also be issued to users programmatically and redeemed by the issuer at any time. This works well for metered usage models, where tokens are used as credits.

Each EVMAuth token type can be configured with a time-to-live (TTL). If the TTL is set (i.e. greater than zero), tokens of that type will automatically expire. This is ideal for subscription models.

All EVMAuth tokens are transferable by default, but each token type can be made non-transferable. This is useful for non-transferable licenses, identity tokens, or other situations where transfers are undesirable.

Compatibility

EVMAuth comes in two flavors: ERC-1155 and ERC-6909. Each version is fully compliant with its token standard and, as such, is fully compatible with existing wallets, apps, marketplaces, and other tools that support those standards.

EVMAuth contracts are upgradable by default, using OpenZeppelin's UUPSUpgradeable and ERC-7201 namespaced storage layout, and can be deployed to any EVM-compatible network, including Ethereum, Base, Tron, Polygon, Monad, and Radius.

Deployment

EVMAuth can be deployed on any EVM-compatible network (e.g. Ethereum, Base, Radius) using the scripts provided in the scripts/ directory.

When deploying the contract, you will need to specify the following parameters:

• Initial transfer delay for the default admin role
• Initial default admin address, for role management
• Initial treasury address, for receiving revenue from direct purchases
• Role grants, to set up access control during initialization (optional, can be done later)
• Base token metadata URI (for ERC-1155) or contract URI (for ERC-6909) (optional, can be updated later)

Access Control

If you did not grant roles during initialization, only the default admin can assign roles after deployment, by calling:

• grantRole(TOKEN_MANAGER_ROLE, address) for accounts that can configure tokens and token metadata
• grantRole(ACCESS_MANAGER_ROLE, address) for accounts that can pause/unpause the contract and freeze accounts
• grantRole(TREASURER_ROLE, address) for accounts that can modify the treasury address where funds are collected
• grantRole(MINTER_ROLE, address)for accounts that can issue tokens to addresses
• grantRole(BURNER_ROLE, address)for accounts that can deduct tokens from addresses

Token Configuration

An account with the TOKEN_MANAGER_ROLE should then create one or more new tokens by calling createToken with the desired configuration:

• uint256 price: The cost to purchase one unit of the token; 0 means the token cannot be purchased directly; set to 0 to disable native currency purchases
• PaymentToken[] erc20Prices: Array of PaymentToken structs, each containing ERC-20 token address and price; pass an empty array to disable ERC-20 token purchases
• uint256 ttl: Time-to-live in seconds; 0 means the token never expires; set to 0 for non-expiring tokens
• bool transferable: Whether the token can be transferred between accounts

An account with the TOKEN_MANAGER_ROLE can modify an existing token by calling updateToken(id, EVMAuthTokenConfig).

Token Standards

ERC-1155 vs ERC-6909

When to Choose Which

Choose ERC-1155 when you:

• Need NFT marketplace compatibility
• Batch operations are important
• Want receiver hook notifications
• Prefer URI-based metadata

Choose ERC-6909 when you:

• Need ERC-20-like semantics per token
• Want granular approval control
• Need on-chain token metadata
• Prefer a simpler token transfer model
• Want to extend the contract with custom features

Both versions of EVMAuth are fairly large. EVMAuth1155 is right near the limit, while EVMAuth6909 has a bit more headroom for expansion.

╭------------------------------+------------------+-------------------+--------------------+---------------------╮
| Contract                     | Runtime Size (B) | Initcode Size (B) | Runtime Margin (B) | Initcode Margin (B) |
+================================================================================================================+
| EVMAuth1155                  | 24,516           | 24,575            | 60                 | 24,577              |
|------------------------------+------------------+-------------------+--------------------+---------------------|
| EVMAuth6909                  | 22,247           | 22,306            | 2,329              | 26,846              |
╰------------------------------+------------------+-------------------+--------------------+---------------------╯

EVMAuth Contract Architecture

Overview

The EVMAuth contract system is designed with a modular, composable architecture that separates concerns into focused base contracts. This approach provides flexibility while maintaining a clean inheritance structure.

The architecture consists of:

• Base Contracts: Modular components that handle specific functionality (e.g. access control, purchasing, token expiry)
• Base EVMAuth Contract: Combines all base contracts into a unified authorization state management system
• Token Standard Implementations: EVMAuth1155 and EVMAuth6909 extend EVMAuth with their respective token standards

Base Contracts Hierarchy

classDiagram
    class TokenAccessControl {
        <<abstract>>
        +DEFAULT_ADMIN_ROLE
        +UPGRADE_MANAGER_ROLE
        +ACCESS_MANAGER_ROLE
        +TOKEN_MANAGER_ROLE
        +MINTER_ROLE
        +BURNER_ROLE
        +TREASURER_ROLE
        +freezeAccount(account)
        +unfreezeAccount(account)
        +pause()
        +unpause()
        <<inherited from Pausable>>
        +paused()
        <<inherited from AccessControl>>
        +hasRole(role, account)
        +grantRole(role, account)
        +revokeRole(role, account)
        +renounceRole(role, account)
    }
    
    class AccountFreezable {
        <<abstract>>
        -frozenAccounts mapping
        +isFrozen(address)
        +frozenAccounts()
        #_freezeAccount(address)
        #_unfreezeAccount(address)
    }
    
    class TokenEnumerable {
        <<abstract>>
        -nextTokenId
        -tokenExists mapping
        +nextTokenID()
        +exists(id)
        #_claimNextTokenID()
    }
    
    class TokenTransferable {
        <<abstract>>
        -transferable mapping
        +isTransferable(id)
        #_setTransferable(id, bool)
    }
    
    class TokenEphemeral {
        <<abstract>>
        -ttl mapping
        -balanceRecords mapping
        +balanceOf(account, id)
        +balanceRecordsOf(account, id)
        +tokenTTL(id)
        +pruneBalanceRecords(account, id)
        #_setTTL(id, ttl)
        #_expiresAt(id)
        #_maxBalanceRecords()
        #_updateBalanceRecords(from, to, id, amount)
        #_addToBalanceRecords(account, id, amount, expiresAt)
        #_deductFromBalanceRecords(account, id, amount)
        #_transferBalanceRecords(from, to, id, amount)
    }
    
    class TokenPurchasable {
        <<abstract>>
        -treasury address
        -prices mapping
        -erc20Prices mapping
        +treasury()
        +tokenPrice(id)
        +tokenERC20Prices(id)
        +isAcceptedERC20PaymentToken(id, token)
        +purchase(id, amount)
        +purchaseFor(receiver, id, amount)
        +purchaseWithERC20(token, id, amount)
        +purchaseWithERC20For(receiver, token, id, amount)
        #_setPrice(id, price)
        #_setERC20Price(id, token, price)
        #_setERC20Prices(id, prices[])
        #_mintPurchasedTokens(to, id, amount)
    }
    
    class EVMAuth {
        <<abstract>>
        +EVMAuthTokenConfig struct
        +createToken(config)
        +updateToken(id, config)
        +tokenConfig(id)
        +setTreasury(address payable newTreasury)
        #_authorizeUpgrade(newImplementation)
    }
    
    AccessControlDefaultAdminRulesUpgradeable <|-- TokenAccessControl
    PausableUpgradeable <|-- TokenAccessControl
    AccountFreezable <|-- TokenAccessControl
    TokenAccessControl <|-- EVMAuth
    TokenEnumerable <|-- EVMAuth
    TokenTransferable <|-- EVMAuth
    TokenEphemeral <|-- EVMAuth
    TokenPurchasable <|-- EVMAuth
    UUPSUpgradeable <|-- EVMAuth

EVMAuth1155 Implementation

classDiagram
    class EVMAuth {
        <<abstract>>
        +DEFAULT_ADMIN_ROLE
        +UPGRADE_MANAGER_ROLE
        +ACCESS_MANAGER_ROLE
        +TOKEN_MANAGER_ROLE
        +MINTER_ROLE
        +BURNER_ROLE
        +TREASURER_ROLE
        +hasRole(role, account)
        +isFrozen(address)
        +frozenAccounts()
        +balanceOf(account, id)
        +balanceRecordsOf(account, id)
        +nextTokenID()
        +exists(id)
        +tokenConfig(id)
        +treasury()
        +tokenPrice(id)
        +tokenERC20Prices(id)
        +isAcceptedERC20PaymentToken(id, token)
        +tokenTTL(id)
        +isTransferable(id)
        +grantRole(role, account)
        +revokeRole(role, account)
        +renounceRole(role, account)
        +pause()
        +unpause()
        +freezeAccount(account)
        +unfreezeAccount(account)
        +createToken(config)
        +updateToken(id, config)
        +setTreasury(address payable newTreasury)
        +purchase(id, amount)
        +purchaseFor(receiver, id, amount)
        +purchaseWithERC20(token, id, amount)
        +purchaseWithERC20For(receiver, token, id, amount)
        +pruneBalanceRecords(account, id)
    }
    
    class ERC1155Upgradeable {
        +balanceOf(account, id)
        +balanceOfBatch(accounts[], ids[])
        +setApprovalForAll(operator, approved)
        +isApprovedForAll(account, operator)
        +safeTransferFrom(from, to, id, amount, data)
        +safeBatchTransferFrom(from, to, ids[], amounts[], data)
    }
    
    class ERC1155URIStorageUpgradeable {
        +uri(id)
        #_setURI(id, uri)
        #_setBaseURI(baseURI)
    }
    
    class EVMAuth1155 {
        +initialize(delay, admin, treasury, uri)
        +mint(to, id, amount, data)
        +mintBatch(to, ids[], amounts[], data)
        +burn(from, id, amount)
        +burnBatch(from, ids[], amounts[])
        +setBaseURI(uri)
        +setTokenURI(id, uri)
        +purchaseFor(recipient, id, amount)
        +purchaseWithERC20For(token, recipient, id, amount)
        +balanceRecordsOf(account, id)
        +pruneBalanceRecords(account, id)
        +exists(id)
        +supportsInterface(interfaceId)
        #_update(from, to, ids[], amounts[])
        #_mintPurchasedTokens(to, id, amount)
    }
    
    ERC1155Upgradeable <|-- ERC1155SupplyUpgradeable
    ERC1155Upgradeable <|-- ERC1155URIStorageUpgradeable
    ERC1155SupplyUpgradeable <|-- EVMAuth1155
    ERC1155URIStorageUpgradeable <|-- EVMAuth1155
    EVMAuth <|-- EVMAuth1155

EVMAuth6909 Implementation

classDiagram
     class EVMAuth {
        <<abstract>>
        +DEFAULT_ADMIN_ROLE
        +UPGRADE_MANAGER_ROLE
        +ACCESS_MANAGER_ROLE
        +TOKEN_MANAGER_ROLE
        +MINTER_ROLE
        +BURNER_ROLE
        +TREASURER_ROLE
        +hasRole(role, account)
        +isFrozen(address)
        +frozenAccounts()
        +balanceOf(account, id)
        +balanceRecordsOf(account, id)
        +nextTokenID()
        +exists(id)
        +tokenConfig(id)
        +treasury()
        +tokenPrice(id)
        +tokenERC20Prices(id)
        +isAcceptedERC20PaymentToken(id, token)
        +tokenTTL(id)
        +isTransferable(id)
        +grantRole(role, account)
        +revokeRole(role, account)
        +renounceRole(role, account)
        +pause()
        +unpause()
        +freezeAccount(account)
        +unfreezeAccount(account)
        +createToken(config)
        +updateToken(id, config)
        +setTreasury(address payable newTreasury)
        +purchase(id, amount)
        +purchaseFor(receiver, id, amount)
        +purchaseWithERC20(token, id, amount)
        +purchaseWithERC20For(receiver, token, id, amount)
        +pruneBalanceRecords(account, id)
    }
    
    class ERC6909Upgradeable {
        +balanceOf(account, id)
        +allowance(owner, spender, id)
        +isOperator(owner, spender)
        +transfer(to, id, amount)
        +transferFrom(from, to, id, amount)
        +approve(spender, id, amount)
        +setOperator(operator, approved)
    }
    
    class ERC6909MetadataUpgradeable {
        +name(id)
        +symbol(id)
        +decimals(id)
        #_setTokenMetadata(id, name, symbol, decimals)
    }
    
    class ERC6909ContentURIUpgradeable {
        +contractURI()
        +tokenURI(id)
        #_setContractURI(uri)
        #_setTokenURI(id, uri)
    }
    
    class EVMAuth6909 {
        +initialize(delay, admin, treasury, uri)
        +mint(to, id, amount)
        +burn(from, id, amount)
        +setContractURI(uri)
        +setTokenURI(id, uri)
        +setTokenMetadata(id, name, symbol, decimals)
        +purchaseFor(recipient, id, amount)
        +purchaseWithERC20For(token, recipient, id, amount)
        +balanceRecordsOf(account, id)
        +pruneBalanceRecords(account, id)
        +exists(id)
        +supportsInterface(interfaceId)
        #_update(from, to, id, amount)
        #_mintPurchasedTokens(to, id, amount)
    }
    
    ERC6909Upgradeable <|-- ERC6909MetadataUpgradeable
    ERC6909Upgradeable <|-- ERC6909ContentURIUpgradeable
    ERC6909MetadataUpgradeable <|-- EVMAuth6909
    ERC6909ContentURIUpgradeable <|-- EVMAuth6909
    EVMAuth <|-- EVMAuth6909

Base Contract Descriptions

TokenAccessControl

Provides role-based access control with six distinct roles, pausable functionality, and account freezing capabilities. Extends OpenZeppelin's AccessControlDefaultAdminRulesUpgradeable for secure admin transfer with time delays.

AccountFreezable

Enables freezing and unfreezing of individual accounts, preventing them from transferring or receiving tokens. Maintains a list of frozen accounts for transparency.

TokenEnumerable

Manages token ID generation and tracks which token IDs have been created. Provides a sequential ID system starting from 1.

TokenTransferable

Controls whether individual token types can be transferred between accounts. Each token ID can be configured as transferable or non-transferable.

TokenEphemeral

Implements time-to-live (TTL) functionality for tokens. Tokens with a TTL expire after the specified duration, with automatic pruning of expired balance records. Uses an efficient time-bucket system for gas optimization.

TokenPurchasable

Handles direct token purchases with both native currency and ERC-20 tokens. Supports per-token pricing in multiple currencies, with revenue sent to a configurable treasury address. Includes reentrancy protection for secure purchases.

EVMAuth

The main abstract contract that combines all base functionality and provides a unified interface for token configuration. Defines the EVMAuthTokenConfig structure that encapsulates price, ERC-20 prices, TTL, and transferability settings for each token type.

Key Architectural Decisions

1. Upgradability: All contracts use the Universal Upgradeable Proxy Standard (UUPS) pattern for future improvements

2. Security:

   • Role-based access control with time-delayed admin transfers
   • Pausable operations for emergency situations
   • Account freezing capabilities
   • Reentrancy protection on purchase functions

3. Gas Optimization:

   • TTL implementation uses bounded arrays and time buckets for balance records
   • Automatic pruning of expired records, with manual pruning methods available
   • Efficient storage patterns for token properties, as defined in ERC-7201

4. Flexibility:

   • Alternative purchase options (native and/or ERC-20 tokens)
   • Configurable token properties (price, TTL, transferability)
   • Support for both ERC-1155 and ERC-6909 token standards

SDKs & Libraries

EVMAuth provides the following SDKs and libraries for easy integration with applications and frameworks:

• TypeScript SDK
• Python SDK (coming soon)

To request additional SDKs or libraries, create a new issue with the question label.

You can also use Foundry's cast command line tool to interact with deployed EVMAuth contracts, and reference this Cast Command Cheat Sheet which illustrates how to call each EVMAuth function.

Contributing

To contribute to this open source project, please follow the guidelines in the Contributing Guide.

License

The EVMAuth contract is released under the MIT License. See the LICENSE file for details.

Contents

• src
• test

Contents

• interfaces
• CommonBase
• TestBase
• ScriptBase
• Script
• StdAssertions
• StdChains
• StdCheatsSafe
• StdCheats
• StdConstants
• stdError
• StdInvariant
• stdJson
• stdMath
• FindData
• StdStorage
• stdStorageSafe
• stdStorage
• StdStyle
• stdToml
• StdUtils
• Test
• VmSafe
• Vm
• console
• safeconsole

Contents

• IERC1155
• IERC165
• IERC20
• IERC4626
• IERC6909
• IERC6909Metadata
• IERC6909ContentURI
• IERC6909TokenSupply
• IERC721
• IERC721TokenReceiver
• IERC721Metadata
• IERC721Enumerable
• IERC7540Operator
• IERC7540Deposit
• IERC7540Redeem
• IERC7540
• IERC7575
• IERC7575Share
• IMulticall3

IERC1155

Inherits: IERC165

See https://eips.ethereum.org/EIPS/eip-1155 Note: The ERC-165 identifier for this interface is 0xd9b67a26.

Functions

safeTransferFrom

Transfers _value amount of an _id from the _from address to the _to address specified (with safety call).

*Caller must be approved to manage the tokens being transferred out of the _from account (see "Approval" section of the standard).

• MUST revert if _to is the zero address.
• MUST revert if balance of holder for token _id is lower than the _value sent.
• MUST revert on any other error.
• MUST emit the TransferSingle event to reflect the balance change (see "Safe Transfer Rules" section of the standard).
• After the above conditions are met, this function MUST check if _to is a smart contract (e.g. code size > 0). If so, it MUST call onERC1155Received on _to and act appropriately (see "Safe Transfer Rules" section of the standard).*

function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;

Parameters

safeBatchTransferFrom

Transfers _values amount(s) of _ids from the _from address to the _to address specified (with safety call).

*Caller must be approved to manage the tokens being transferred out of the _from account (see "Approval" section of the standard).

• MUST revert if _to is the zero address.
• MUST revert if length of _ids is not the same as length of _values.
• MUST revert if any of the balance(s) of the holder(s) for token(s) in _ids is lower than the respective amount(s) in _values sent to the recipient.
• MUST revert on any other error.
• MUST emit TransferSingle or TransferBatch event(s) such that all the balance changes are reflected (see "Safe Transfer Rules" section of the standard).
• Balance changes and events MUST follow the ordering of the arrays (_ids[0]/_values[0] before _ids[1]/_values[1], etc).
• After the above conditions for the transfer(s) in the batch are met, this function MUST check if _to is a smart contract (e.g. code size > 0). If so, it MUST call the relevant ERC1155TokenReceiver hook(s) on _to and act appropriately (see "Safe Transfer Rules" section of the standard).*

function safeBatchTransferFrom(
    address _from,
    address _to,
    uint256[] calldata _ids,
    uint256[] calldata _values,
    bytes calldata _data
) external;

Parameters

balanceOf

Get the balance of an account's tokens.

function balanceOf(address _owner, uint256 _id) external view returns (uint256);

Parameters

Returns

balanceOfBatch

Get the balance of multiple account/token pairs

function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view returns (uint256[] memory);

Parameters

Returns

setApprovalForAll

Enable or disable approval for a third party ("operator") to manage all of the caller's tokens.

MUST emit the ApprovalForAll event on success.

function setApprovalForAll(address _operator, bool _approved) external;

Parameters

isApprovedForAll

Queries the approval status of an operator for a given owner.

function isApprovedForAll(address _owner, address _operator) external view returns (bool);

Parameters

Returns

Events

TransferSingle

• Either TransferSingle or TransferBatch MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
• The _operator argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender).
• The _from argument MUST be the address of the holder whose balance is decreased.
• The _to argument MUST be the address of the recipient whose balance is increased.
• The _id argument MUST be the token type being transferred.
• The _value argument MUST be the number of tokens the holder balance is decreased by and match what the recipient balance is increased by.
• When minting/creating tokens, the _from argument MUST be set to 0x0 (i.e. zero address).
• When burning/destroying tokens, the _to argument MUST be set to 0x0 (i.e. zero address).*

event TransferSingle(
    address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value
);

TransferBatch

• Either TransferSingle or TransferBatch MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
• The _operator argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender).
• The _from argument MUST be the address of the holder whose balance is decreased.
• The _to argument MUST be the address of the recipient whose balance is increased.
• The _ids argument MUST be the list of tokens being transferred.
• The _values argument MUST be the list of number of tokens (matching the list and order of tokens specified in _ids) the holder balance is decreased by and match what the recipient balance is increased by.
• When minting/creating tokens, the _from argument MUST be set to 0x0 (i.e. zero address).
• When burning/destroying tokens, the _to argument MUST be set to 0x0 (i.e. zero address).*

event TransferBatch(
    address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values
);

ApprovalForAll

MUST emit when approval for a second party/operator address to manage all tokens for an owner address is enabled or disabled (absence of an event assumes disabled).

event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

URI

MUST emit when the URI is updated for a token ID. URIs are defined in RFC 3986. The URI MUST point to a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema".

event URI(string _value, uint256 indexed _id);

IERC165

Functions

supportsInterface

Query if a contract implements an interface

Interface identification is specified in ERC-165. This function uses less than 30,000 gas.

function supportsInterface(bytes4 interfaceID) external view returns (bool);

Parameters

Returns

IERC20

Interface of the ERC20 standard as defined in the EIP.

This includes the optional name, symbol, and decimals metadata.

Functions

totalSupply

Returns the amount of tokens in existence.

function totalSupply() external view returns (uint256);

balanceOf

Returns the amount of tokens owned by account.

function balanceOf(address account) external view returns (uint256);

transfer

Moves amount tokens from the caller's account to to.

function transfer(address to, uint256 amount) external returns (bool);

allowance

Returns the remaining number of tokens that spender is allowed to spend on behalf of owner

function allowance(address owner, address spender) external view returns (uint256);

approve

Sets amount as the allowance of spender over the caller's tokens.

Be aware of front-running risks: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729

function approve(address spender, uint256 amount) external returns (bool);

transferFrom

Moves amount tokens from from to to using the allowance mechanism. amount is then deducted from the caller's allowance.

function transferFrom(address from, address to, uint256 amount) external returns (bool);

name

Returns the name of the token.

function name() external view returns (string memory);

symbol

Returns the symbol of the token.

function symbol() external view returns (string memory);

decimals

Returns the decimals places of the token.

function decimals() external view returns (uint8);

Events

Transfer

Emitted when value tokens are moved from one account (from) to another (to).

event Transfer(address indexed from, address indexed to, uint256 value);

Approval

Emitted when the allowance of a spender for an owner is set, where value is the new allowance.

event Approval(address indexed owner, address indexed spender, uint256 value);

IERC4626

Inherits: IERC20

Interface of the ERC4626 "Tokenized Vault Standard", as defined in https://eips.ethereum.org/EIPS/eip-4626

Functions

asset

Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.

• MUST be an ERC-20 token contract.
• MUST NOT revert.*

function asset() external view returns (address assetTokenAddress);

totalAssets

Returns the total amount of the underlying asset that is “managed” by Vault.

• SHOULD include any compounding that occurs from yield.
• MUST be inclusive of any fees that are charged against assets in the Vault.
• MUST NOT revert.*

function totalAssets() external view returns (uint256 totalManagedAssets);

convertToShares

Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal scenario where all the conditions are met.

• MUST NOT be inclusive of any fees that are charged against assets in the Vault.
• MUST NOT show any variations depending on the caller.
• MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
• MUST NOT revert. NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and from.*

function convertToShares(uint256 assets) external view returns (uint256 shares);

convertToAssets

Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal scenario where all the conditions are met.

• MUST NOT be inclusive of any fees that are charged against assets in the Vault.
• MUST NOT show any variations depending on the caller.
• MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
• MUST NOT revert. NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and from.*

function convertToAssets(uint256 shares) external view returns (uint256 assets);

maxDeposit

Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver, through a deposit call.

• MUST return a limited value if receiver is subject to some deposit limit.
• MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
• MUST NOT revert.*

function maxDeposit(address receiver) external view returns (uint256 maxAssets);

previewDeposit

Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given current on-chain conditions.

• MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called in the same transaction.
• MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the deposit would be accepted, regardless if the user has enough tokens approved, etc.
• MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
• MUST NOT revert. NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in share price or some other type of condition, meaning the depositor will lose assets by depositing.*

function previewDeposit(uint256 assets) external view returns (uint256 shares);

deposit

Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.

• MUST emit the Deposit event.
• MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the deposit execution, and are accounted for during deposit.
• MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not approving enough underlying tokens to the Vault contract, etc). NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.*

function deposit(uint256 assets, address receiver) external returns (uint256 shares);

maxMint

Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.

• MUST return a limited value if receiver is subject to some mint limit.
• MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
• MUST NOT revert.*

function maxMint(address receiver) external view returns (uint256 maxShares);

previewMint

Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given current on-chain conditions.

• MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the same transaction.
• MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint would be accepted, regardless if the user has enough tokens approved, etc.
• MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
• MUST NOT revert. NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in share price or some other type of condition, meaning the depositor will lose assets by minting.*

function previewMint(uint256 shares) external view returns (uint256 assets);

mint

Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.

• MUST emit the Deposit event.
• MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint execution, and are accounted for during mint.
• MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not approving enough underlying tokens to the Vault contract, etc). NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.*

function mint(uint256 shares, address receiver) external returns (uint256 assets);

maxWithdraw

Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the Vault, through a withdrawal call.

• MUST return a limited value if owner is subject to some withdrawal limit or timelock.
• MUST NOT revert.*

function maxWithdraw(address owner) external view returns (uint256 maxAssets);

previewWithdraw

Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, given current on-chain conditions.

• MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if called in the same transaction.
• MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though the withdrawal would be accepted, regardless if the user has enough shares, etc.
• MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
• MUST NOT revert. NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in share price or some other type of condition, meaning the depositor will lose assets by depositing.*

function previewWithdraw(uint256 assets) external view returns (uint256 shares);

withdraw

Burns shares from owner and sends exactly assets of underlying tokens to receiver.

• MUST emit the Withdraw event.
• MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the withdraw execution, and are accounted for during withdrawal.
• MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner not having enough shares, etc). Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed. Those methods should be performed separately.*

function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);

maxRedeem

Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault, through a redeem call.

• MUST return a limited value if owner is subject to some withdrawal limit or timelock.
• MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
• MUST NOT revert.*

function maxRedeem(address owner) external view returns (uint256 maxShares);

previewRedeem

Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, given current on-chain conditions.

• MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the same transaction.
• MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the redemption would be accepted, regardless if the user has enough shares, etc.
• MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
• MUST NOT revert. NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in share price or some other type of condition, meaning the depositor will lose assets by redeeming.*

function previewRedeem(uint256 shares) external view returns (uint256 assets);

redeem

Burns exactly shares from owner and sends assets of underlying tokens to receiver.

• MUST emit the Withdraw event.
• MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the redeem execution, and are accounted for during redeem.
• MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner not having enough shares, etc). NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed. Those methods should be performed separately.*

function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);

Events

Deposit

event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);

Withdraw

event Withdraw(address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares);

IERC6909

Inherits: IERC165

Required interface of an ERC-6909 compliant contract, as defined in https://eips.ethereum.org/EIPS/eip-6909

Functions

balanceOf

Returns the amount of tokens of type id owned by owner.

function balanceOf(address owner, uint256 id) external view returns (uint256);

allowance

Returns the amount of tokens of type id that spender is allowed to spend on behalf of owner. NOTE: Does not include operator allowances.

function allowance(address owner, address spender, uint256 id) external view returns (uint256);

isOperator

Returns true if spender is set as an operator for owner.

function isOperator(address owner, address spender) external view returns (bool);

approve

Sets an approval to spender for amount tokens of type id from the caller's tokens. Must return true.

function approve(address spender, uint256 id, uint256 amount) external returns (bool);

setOperator

Grants or revokes unlimited transfer permission of any token id to spender for the caller's tokens. Must return true.

function setOperator(address spender, bool approved) external returns (bool);

transfer

Transfers amount of token type id from the caller's account to receiver. Must return true.

function transfer(address receiver, uint256 id, uint256 amount) external returns (bool);

transferFrom

Transfers amount of token type id from sender to receiver. Must return true.

function transferFrom(address sender, address receiver, uint256 id, uint256 amount) external returns (bool);

Events

Approval

Emitted when the allowance of a spender for an owner is set for a token of type id.

event Approval(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount);

OperatorSet

Emitted when owner grants or revokes operator status for a spender.

event OperatorSet(address indexed owner, address indexed spender, bool approved);

Transfer

Emitted when amount tokens of type id are moved from sender to receiver initiated by caller.

event Transfer(address caller, address indexed sender, address indexed receiver, uint256 indexed id, uint256 amount);

IERC6909Metadata

Inherits: IERC6909

Optional extension of {IERC6909} that adds metadata functions.

Functions

name

Returns the name of the token of type id.

function name(uint256 id) external view returns (string memory);

symbol

Returns the ticker symbol of the token of type id.

function symbol(uint256 id) external view returns (string memory);

decimals

Returns the number of decimals for the token of type id.

function decimals(uint256 id) external view returns (uint8);

IERC6909ContentURI

Inherits: IERC6909

Optional extension of {IERC6909} that adds content URI functions.

Functions

contractURI

Returns URI for the contract.

function contractURI() external view returns (string memory);

tokenURI

Returns the URI for the token of type id.

function tokenURI(uint256 id) external view returns (string memory);

IERC6909TokenSupply

Inherits: IERC6909

Optional extension of {IERC6909} that adds a token supply function.

Functions

totalSupply

Returns the total supply of the token of type id.

function totalSupply(uint256 id) external view returns (uint256);

IERC721

Inherits: IERC165

See https://eips.ethereum.org/EIPS/eip-721 Note: the ERC-165 identifier for this interface is 0x80ac58cd.

Functions

balanceOf

Count all NFTs assigned to an owner

NFTs assigned to the zero address are considered invalid, and this function throws for queries about the zero address.

function balanceOf(address _owner) external view returns (uint256);

Parameters

Returns

ownerOf

Find the owner of an NFT

NFTs assigned to zero address are considered invalid, and queries about them do throw.

function ownerOf(uint256 _tokenId) external view returns (address);

Parameters

Returns

safeTransferFrom

Transfers the ownership of an NFT from one address to another address

Throws unless msg.sender is the current owner, an authorized operator, or the approved address for this NFT. Throws if _from is not the current owner. Throws if _to is the zero address. Throws if _tokenId is not a valid NFT. When transfer is complete, this function checks if _to is a smart contract (code size > 0). If so, it calls onERC721Received on _to and throws if the return value is not bytes4(keccak256("onERC721Received(address,address,uint256,bytes)")).

function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external payable;

Parameters

safeTransferFrom

Transfers the ownership of an NFT from one address to another address

This works identically to the other function with an extra data parameter, except this function just sets data to "".

function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;

Parameters

transferFrom

Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE TO CONFIRM THAT _to IS CAPABLE OF RECEIVING NFTS OR ELSE THEY MAY BE PERMANENTLY LOST

Throws unless msg.sender is the current owner, an authorized operator, or the approved address for this NFT. Throws if _from is not the current owner. Throws if _to is the zero address. Throws if _tokenId is not a valid NFT.

function transferFrom(address _from, address _to, uint256 _tokenId) external payable;

Parameters

approve

Change or reaffirm the approved address for an NFT

The zero address indicates there is no approved address. Throws unless msg.sender is the current NFT owner, or an authorized operator of the current owner.

function approve(address _approved, uint256 _tokenId) external payable;

Parameters

setApprovalForAll

Enable or disable approval for a third party ("operator") to manage all of msg.sender's assets

Emits the ApprovalForAll event. The contract MUST allow multiple operators per owner.

function setApprovalForAll(address _operator, bool _approved) external;

Parameters

getApproved

Get the approved address for a single NFT

Throws if _tokenId is not a valid NFT.

function getApproved(uint256 _tokenId) external view returns (address);

Parameters

Returns

isApprovedForAll

Query if an address is an authorized operator for another address

function isApprovedForAll(address _owner, address _operator) external view returns (bool);

Parameters

Returns

Events

Transfer

This emits when ownership of any NFT changes by any mechanism. This event emits when NFTs are created (from == 0) and destroyed (to == 0). Exception: during contract creation, any number of NFTs may be created and assigned without emitting Transfer. At the time of any transfer, the approved address for that NFT (if any) is reset to none.

event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);

Approval

This emits when the approved address for an NFT is changed or reaffirmed. The zero address indicates there is no approved address. When a Transfer event emits, this also indicates that the approved address for that NFT (if any) is reset to none.

event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);

ApprovalForAll

This emits when an operator is enabled or disabled for an owner. The operator can manage all NFTs of the owner.

event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

IERC721TokenReceiver

Note: the ERC-165 identifier for this interface is 0x150b7a02.

Functions

onERC721Received

Handle the receipt of an NFT

The ERC721 smart contract calls this function on the recipient after a transfer. This function MAY throw to revert and reject the transfer. Return of other than the magic value MUST result in the transaction being reverted. Note: the contract address is always the message sender.

function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data)
    external
    returns (bytes4);

Parameters

Returns

IERC721Metadata

Inherits: IERC721

See https://eips.ethereum.org/EIPS/eip-721 Note: the ERC-165 identifier for this interface is 0x5b5e139f.

Functions

name

A descriptive name for a collection of NFTs in this contract

function name() external view returns (string memory _name);

symbol

An abbreviated name for NFTs in this contract

function symbol() external view returns (string memory _symbol);

tokenURI

A distinct Uniform Resource Identifier (URI) for a given asset.

Throws if _tokenId is not a valid NFT. URIs are defined in RFC 3986. The URI may point to a JSON file that conforms to the "ERC721 Metadata JSON Schema".

function tokenURI(uint256 _tokenId) external view returns (string memory);

IERC721Enumerable

Inherits: IERC721

See https://eips.ethereum.org/EIPS/eip-721 Note: the ERC-165 identifier for this interface is 0x780e9d63.

Functions

totalSupply

Count NFTs tracked by this contract

function totalSupply() external view returns (uint256);

Returns

tokenByIndex

Enumerate valid NFTs

Throws if _index >= totalSupply().

function tokenByIndex(uint256 _index) external view returns (uint256);

Parameters

Returns

tokenOfOwnerByIndex

Enumerate NFTs assigned to an owner

Throws if _index >= balanceOf(_owner) or if _owner is the zero address, representing invalid NFTs.

function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);

Parameters

Returns

IERC7540Operator

Interface of the base operator logic of ERC7540, as defined in https://eips.ethereum.org/EIPS/eip-7540

Functions

setOperator

Sets or removes an operator for the caller.

function setOperator(address operator, bool approved) external returns (bool);

Parameters

Returns

isOperator

Returns true if the operator is approved as an operator for an controller.

function isOperator(address controller, address operator) external view returns (bool status);

Parameters

Returns

Events

OperatorSet

The event emitted when an operator is set.

event OperatorSet(address indexed controller, address indexed operator, bool approved);

Parameters

IERC7540Deposit

Inherits: IERC7540Operator

Interface of the asynchronous deposit Vault interface of ERC7540, as defined in https://eips.ethereum.org/EIPS/eip-7540

Functions

requestDeposit

*Transfers assets from sender into the Vault and submits a Request for asynchronous deposit.

• MUST support ERC-20 approve / transferFrom on asset as a deposit Request flow.
• MUST revert if all of assets cannot be requested for deposit.
• owner MUST be msg.sender unless some unspecified explicit approval is given by the caller, approval of ERC-20 tokens from owner to sender is NOT enough.*

function requestDeposit(uint256 assets, address controller, address owner) external returns (uint256 requestId);

Parameters

pendingDepositRequest

*Returns the amount of requested assets in Pending state.

• MUST NOT include any assets in Claimable state for deposit or mint.
• MUST NOT show any variations depending on the caller.
• MUST NOT revert unless due to integer overflow caused by an unreasonably large input.*

function pendingDepositRequest(uint256 requestId, address controller) external view returns (uint256 pendingAssets);

claimableDepositRequest

*Returns the amount of requested assets in Claimable state for the controller to deposit or mint.

• MUST NOT include any assets in Pending state.
• MUST NOT show any variations depending on the caller.
• MUST NOT revert unless due to integer overflow caused by an unreasonably large input.*

function claimableDepositRequest(uint256 requestId, address controller)
    external
    view
    returns (uint256 claimableAssets);

deposit

*Mints shares Vault shares to receiver by claiming the Request of the controller.

• MUST emit the Deposit event.
• controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.*

function deposit(uint256 assets, address receiver, address controller) external returns (uint256 shares);

mint

*Mints exactly shares Vault shares to receiver by claiming the Request of the controller.

• MUST emit the Deposit event.
• controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.*

function mint(uint256 shares, address receiver, address controller) external returns (uint256 assets);

Events

DepositRequest

event DepositRequest(
    address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
);

IERC7540Redeem

Inherits: IERC7540Operator

Interface of the asynchronous deposit Vault interface of ERC7540, as defined in https://eips.ethereum.org/EIPS/eip-7540

Functions

requestRedeem

*Assumes control of shares from sender into the Vault and submits a Request for asynchronous redeem.

• MUST support a redeem Request flow where the control of shares is taken from sender directly where msg.sender has ERC-20 approval over the shares of owner.
• MUST revert if all of shares cannot be requested for redeem.*

function requestRedeem(uint256 shares, address controller, address owner) external returns (uint256 requestId);

Parameters

pendingRedeemRequest

*Returns the amount of requested shares in Pending state.

• MUST NOT include any shares in Claimable state for redeem or withdraw.
• MUST NOT show any variations depending on the caller.
• MUST NOT revert unless due to integer overflow caused by an unreasonably large input.*

function pendingRedeemRequest(uint256 requestId, address controller) external view returns (uint256 pendingShares);

claimableRedeemRequest

*Returns the amount of requested shares in Claimable state for the controller to redeem or withdraw.

• MUST NOT include any shares in Pending state for redeem or withdraw.
• MUST NOT show any variations depending on the caller.
• MUST NOT revert unless due to integer overflow caused by an unreasonably large input.*

function claimableRedeemRequest(uint256 requestId, address controller)
    external
    view
    returns (uint256 claimableShares);

Events

RedeemRequest

event RedeemRequest(
    address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
);

IERC7540

Inherits: IERC7540Deposit, IERC7540Redeem, IERC7575

Interface of the fully asynchronous Vault interface of ERC7540, as defined in https://eips.ethereum.org/EIPS/eip-7540

IERC7575

Inherits: IERC165

Interface of the ERC7575 "Multi-Asset ERC-4626 Vaults", as defined in https://eips.ethereum.org/EIPS/eip-7575

Functions

asset

*Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.

• MUST be an ERC-20 token contract.
• MUST NOT revert.*

function asset() external view returns (address assetTokenAddress);

share

*Returns the address of the share token

• MUST be an ERC-20 token contract.
• MUST NOT revert.*

function share() external view returns (address shareTokenAddress);

convertToShares

*Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal scenario where all the conditions are met.

• MUST NOT be inclusive of any fees that are charged against assets in the Vault.
• MUST NOT show any variations depending on the caller.
• MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
• MUST NOT revert. NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and from.*

function convertToShares(uint256 assets) external view returns (uint256 shares);

convertToAssets

*Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal scenario where all the conditions are met.

• MUST NOT be inclusive of any fees that are charged against assets in the Vault.
• MUST NOT show any variations depending on the caller.
• MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
• MUST NOT revert. NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and from.*

function convertToAssets(uint256 shares) external view returns (uint256 assets);

totalAssets

*Returns the total amount of the underlying asset that is “managed” by Vault.

• SHOULD include any compounding that occurs from yield.
• MUST be inclusive of any fees that are charged against assets in the Vault.
• MUST NOT revert.*

function totalAssets() external view returns (uint256 totalManagedAssets);

maxDeposit

*Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver, through a deposit call.

• MUST return a limited value if receiver is subject to some deposit limit.
• MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
• MUST NOT revert.*

function maxDeposit(address receiver) external view returns (uint256 maxAssets);

previewDeposit

*Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given current on-chain conditions.

• MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called in the same transaction.
• MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the deposit would be accepted, regardless if the user has enough tokens approved, etc.
• MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
• MUST NOT revert. NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in share price or some other type of condition, meaning the depositor will lose assets by depositing.*

function previewDeposit(uint256 assets) external view returns (uint256 shares);

deposit

*Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.

• MUST emit the Deposit event.
• MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the deposit execution, and are accounted for during deposit.
• MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not approving enough underlying tokens to the Vault contract, etc). NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.*

function deposit(uint256 assets, address receiver) external returns (uint256 shares);

maxMint

*Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.

• MUST return a limited value if receiver is subject to some mint limit.
• MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
• MUST NOT revert.*

function maxMint(address receiver) external view returns (uint256 maxShares);

previewMint

*Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given current on-chain conditions.

• MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the same transaction.
• MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint would be accepted, regardless if the user has enough tokens approved, etc.
• MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
• MUST NOT revert. NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in share price or some other type of condition, meaning the depositor will lose assets by minting.*

function previewMint(uint256 shares) external view returns (uint256 assets);

mint

*Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.

• MUST emit the Deposit event.
• MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint execution, and are accounted for during mint.
• MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not approving enough underlying tokens to the Vault contract, etc). NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.*

function mint(uint256 shares, address receiver) external returns (uint256 assets);

maxWithdraw

*Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the Vault, through a withdraw call.

• MUST return a limited value if owner is subject to some withdrawal limit or timelock.
• MUST NOT revert.*

function maxWithdraw(address owner) external view returns (uint256 maxAssets);

previewWithdraw

*Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, given current on-chain conditions.

• MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if called in the same transaction.
• MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though the withdrawal would be accepted, regardless if the user has enough shares, etc.
• MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
• MUST NOT revert. NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in share price or some other type of condition, meaning the depositor will lose assets by depositing.*

function previewWithdraw(uint256 assets) external view returns (uint256 shares);

withdraw

*Burns shares from owner and sends exactly assets of underlying tokens to receiver.

• MUST emit the Withdraw event.
• MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the withdraw execution, and are accounted for during withdraw.
• MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner not having enough shares, etc). Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed. Those methods should be performed separately.*

function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);

maxRedeem

*Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault, through a redeem call.

• MUST return a limited value if owner is subject to some withdrawal limit or timelock.
• MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
• MUST NOT revert.*

function maxRedeem(address owner) external view returns (uint256 maxShares);

previewRedeem

*Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, given current on-chain conditions.

• MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the same transaction.
• MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the redemption would be accepted, regardless if the user has enough shares, etc.
• MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
• MUST NOT revert. NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in share price or some other type of condition, meaning the depositor will lose assets by redeeming.*

function previewRedeem(uint256 shares) external view returns (uint256 assets);

redeem

*Burns exactly shares from owner and sends assets of underlying tokens to receiver.

• MUST emit the Withdraw event.
• MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the redeem execution, and are accounted for during redeem.
• MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner not having enough shares, etc). NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed. Those methods should be performed separately.*

function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);

Events

Deposit

event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);

Withdraw

event Withdraw(address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares);

IERC7575Share

Inherits: IERC165

Interface of the ERC20 share token, as defined in https://eips.ethereum.org/EIPS/eip-7575

Functions

vault

Returns the address of the Vault for the given asset.

function vault(address asset) external view returns (address);

Parameters

Events

VaultUpdate

event VaultUpdate(address indexed asset, address vault);

IMulticall3

Functions

aggregate

function aggregate(Call[] calldata calls) external payable returns (uint256 blockNumber, bytes[] memory returnData);

aggregate3

function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);

aggregate3Value

function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);

blockAndAggregate

function blockAndAggregate(Call[] calldata calls)
    external
    payable
    returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);

getBasefee

function getBasefee() external view returns (uint256 basefee);

getBlockHash

function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);

getBlockNumber

function getBlockNumber() external view returns (uint256 blockNumber);

getChainId

function getChainId() external view returns (uint256 chainid);

getCurrentBlockCoinbase

function getCurrentBlockCoinbase() external view returns (address coinbase);

getCurrentBlockDifficulty

function getCurrentBlockDifficulty() external view returns (uint256 difficulty);

getCurrentBlockGasLimit

function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);

getCurrentBlockTimestamp

function getCurrentBlockTimestamp() external view returns (uint256 timestamp);

getEthBalance

function getEthBalance(address addr) external view returns (uint256 balance);

getLastBlockHash

function getLastBlockHash() external view returns (bytes32 blockHash);

tryAggregate

function tryAggregate(bool requireSuccess, Call[] calldata calls)
    external
    payable
    returns (Result[] memory returnData);

tryBlockAndAggregate

function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)
    external
    payable
    returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);

Structs

Call

struct Call {
    address target;
    bytes callData;
}

Call3

struct Call3 {
    address target;
    bool allowFailure;
    bytes callData;
}

Call3Value

struct Call3Value {
    address target;
    bool allowFailure;
    uint256 value;
    bytes callData;
}

Result

struct Result {
    bool success;
    bytes returnData;
}

CommonBase

State Variables

VM_ADDRESS

Cheat code address. Calculated as address(uint160(uint256(keccak256("hevm cheat code")))).

address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;

CONSOLE

console.sol and console2.sol work by executing a staticcall to this address. Calculated as address(uint160(uint88(bytes11("console.log")))).

address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;

CREATE2_FACTORY

Used when deploying with create2. Taken from https://github.com/Arachnid/deterministic-deployment-proxy.

address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;

DEFAULT_SENDER

The default address for tx.origin and msg.sender. Calculated as address(uint160(uint256(keccak256("foundry default caller")))).

address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;

DEFAULT_TEST_CONTRACT

The address of the first contract CREATEd by a running test contract. When running tests, each test contract is CREATEd by DEFAULT_SENDER with nonce 1. Calculated as VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1).

address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;

MULTICALL3_ADDRESS

Deterministic deployment address of the Multicall3 contract. Taken from https://www.multicall3.com.

address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;

SECP256K1_ORDER

The order of the secp256k1 curve.

uint256 internal constant SECP256K1_ORDER =
    115792089237316195423570985008687907852837564279074904382605163141518161494337;

UINT256_MAX

uint256 internal constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;

vm

Vm internal constant vm = Vm(VM_ADDRESS);

stdstore

StdStorage internal stdstore;

TestBase

Inherits: CommonBase

ScriptBase

Inherits: CommonBase

State Variables

vmSafe

VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);

Script

Inherits: ScriptBase, StdChains, StdCheatsSafe, StdUtils

State Variables

IS_SCRIPT

bool public IS_SCRIPT = true;

StdAssertions

State Variables

vm

Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));

_failed

bool private _failed;

Functions

failed

function failed() public view returns (bool);

fail

function fail() internal virtual;

assertTrue

function assertTrue(bool data) internal pure virtual;

assertTrue

function assertTrue(bool data, string memory err) internal pure virtual;

assertFalse

function assertFalse(bool data) internal pure virtual;

assertFalse

function assertFalse(bool data, string memory err) internal pure virtual;

assertEq

function assertEq(bool left, bool right) internal pure virtual;

assertEq

function assertEq(bool left, bool right, string memory err) internal pure virtual;

assertEq

function assertEq(uint256 left, uint256 right) internal pure virtual;

assertEq

function assertEq(uint256 left, uint256 right, string memory err) internal pure virtual;

assertEqDecimal

function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual;

assertEqDecimal

function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual;

assertEq

function assertEq(int256 left, int256 right) internal pure virtual;

assertEq

function assertEq(int256 left, int256 right, string memory err) internal pure virtual;

assertEqDecimal

function assertEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual;

assertEqDecimal

function assertEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual;

assertEq

function assertEq(address left, address right) internal pure virtual;

assertEq

function assertEq(address left, address right, string memory err) internal pure virtual;

assertEq

function assertEq(bytes32 left, bytes32 right) internal pure virtual;

assertEq

function assertEq(bytes32 left, bytes32 right, string memory err) internal pure virtual;

assertEq32

function assertEq32(bytes32 left, bytes32 right) internal pure virtual;

assertEq32

function assertEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual;

assertEq

function assertEq(string memory left, string memory right) internal pure virtual;

assertEq

function assertEq(string memory left, string memory right, string memory err) internal pure virtual;

assertEq

function assertEq(bytes memory left, bytes memory right) internal pure virtual;

assertEq

function assertEq(bytes memory left, bytes memory right, string memory err) internal pure virtual;

assertEq

function assertEq(bool[] memory left, bool[] memory right) internal pure virtual;

assertEq

function assertEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual;

assertEq

function assertEq(uint256[] memory left, uint256[] memory right) internal pure virtual;

assertEq

function assertEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual;

assertEq

function assertEq(int256[] memory left, int256[] memory right) internal pure virtual;

assertEq

function assertEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual;

assertEq

function assertEq(address[] memory left, address[] memory right) internal pure virtual;

assertEq

function assertEq(address[] memory left, address[] memory right, string memory err) internal pure virtual;

assertEq

function assertEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual;

assertEq

function assertEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual;

assertEq

function assertEq(string[] memory left, string[] memory right) internal pure virtual;

assertEq

function assertEq(string[] memory left, string[] memory right, string memory err) internal pure virtual;

assertEq

function assertEq(bytes[] memory left, bytes[] memory right) internal pure virtual;

assertEq

function assertEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual;

assertEqUint

function assertEqUint(uint256 left, uint256 right) internal pure virtual;

assertNotEq

function assertNotEq(bool left, bool right) internal pure virtual;

assertNotEq

function assertNotEq(bool left, bool right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(uint256 left, uint256 right) internal pure virtual;

assertNotEq

function assertNotEq(uint256 left, uint256 right, string memory err) internal pure virtual;

assertNotEqDecimal

function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual;

assertNotEqDecimal

function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(int256 left, int256 right) internal pure virtual;

assertNotEq

function assertNotEq(int256 left, int256 right, string memory err) internal pure virtual;

assertNotEqDecimal

function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual;

assertNotEqDecimal

function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(address left, address right) internal pure virtual;

assertNotEq

function assertNotEq(address left, address right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(bytes32 left, bytes32 right) internal pure virtual;

assertNotEq

function assertNotEq(bytes32 left, bytes32 right, string memory err) internal pure virtual;

assertNotEq32

function assertNotEq32(bytes32 left, bytes32 right) internal pure virtual;

assertNotEq32

function assertNotEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(string memory left, string memory right) internal pure virtual;

assertNotEq

function assertNotEq(string memory left, string memory right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(bytes memory left, bytes memory right) internal pure virtual;

assertNotEq

function assertNotEq(bytes memory left, bytes memory right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(bool[] memory left, bool[] memory right) internal pure virtual;

assertNotEq

function assertNotEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(uint256[] memory left, uint256[] memory right) internal pure virtual;

assertNotEq

function assertNotEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(int256[] memory left, int256[] memory right) internal pure virtual;

assertNotEq

function assertNotEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(address[] memory left, address[] memory right) internal pure virtual;

assertNotEq

function assertNotEq(address[] memory left, address[] memory right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual;

assertNotEq

function assertNotEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(string[] memory left, string[] memory right) internal pure virtual;

assertNotEq

function assertNotEq(string[] memory left, string[] memory right, string memory err) internal pure virtual;

assertNotEq

function assertNotEq(bytes[] memory left, bytes[] memory right) internal pure virtual;

assertNotEq

function assertNotEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual;

assertLt

function assertLt(uint256 left, uint256 right) internal pure virtual;

assertLt

function assertLt(uint256 left, uint256 right, string memory err) internal pure virtual;

assertLtDecimal

function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual;

assertLtDecimal

function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual;

assertLt

function assertLt(int256 left, int256 right) internal pure virtual;

assertLt

function assertLt(int256 left, int256 right, string memory err) internal pure virtual;

assertLtDecimal

function assertLtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual;

assertLtDecimal

function assertLtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual;

assertGt

function assertGt(uint256 left, uint256 right) internal pure virtual;

assertGt

function assertGt(uint256 left, uint256 right, string memory err) internal pure virtual;

assertGtDecimal

function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual;

assertGtDecimal

function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual;

assertGt

function assertGt(int256 left, int256 right) internal pure virtual;

assertGt

function assertGt(int256 left, int256 right, string memory err) internal pure virtual;

assertGtDecimal

function assertGtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual;

assertGtDecimal

function assertGtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual;

assertLe

function assertLe(uint256 left, uint256 right) internal pure virtual;

assertLe

function assertLe(uint256 left, uint256 right, string memory err) internal pure virtual;

assertLeDecimal

function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual;

assertLeDecimal

function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual;

assertLe

function assertLe(int256 left, int256 right) internal pure virtual;

assertLe

function assertLe(int256 left, int256 right, string memory err) internal pure virtual;

assertLeDecimal

function assertLeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual;

assertLeDecimal

function assertLeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual;

assertGe

function assertGe(uint256 left, uint256 right) internal pure virtual;

assertGe

function assertGe(uint256 left, uint256 right, string memory err) internal pure virtual;

assertGeDecimal

function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual;

assertGeDecimal

function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual;

assertGe

function assertGe(int256 left, int256 right) internal pure virtual;

assertGe

function assertGe(int256 left, int256 right, string memory err) internal pure virtual;

assertGeDecimal

function assertGeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual;

assertGeDecimal

function assertGeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual;

assertApproxEqAbs

function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) internal pure virtual;

assertApproxEqAbs

function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string memory err) internal pure virtual;

assertApproxEqAbsDecimal

function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals)
    internal
    pure
    virtual;

assertApproxEqAbsDecimal

function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string memory err)
    internal
    pure
    virtual;

assertApproxEqAbs

function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) internal pure virtual;

assertApproxEqAbs

function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string memory err) internal pure virtual;

assertApproxEqAbsDecimal

function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals)
    internal
    pure
    virtual;

assertApproxEqAbsDecimal

function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string memory err)
    internal
    pure
    virtual;

assertApproxEqRel

function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) internal pure virtual;

assertApproxEqRel

function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string memory err)
    internal
    pure
    virtual;

assertApproxEqRelDecimal

function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)
    internal
    pure
    virtual;

assertApproxEqRelDecimal

function assertApproxEqRelDecimal(
    uint256 left,
    uint256 right,
    uint256 maxPercentDelta,
    uint256 decimals,
    string memory err
) internal pure virtual;

assertApproxEqRel

function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) internal pure virtual;

assertApproxEqRel

function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string memory err)
    internal
    pure
    virtual;

assertApproxEqRelDecimal

function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)
    internal
    pure
    virtual;

assertApproxEqRelDecimal

function assertApproxEqRelDecimal(
    int256 left,
    int256 right,
    uint256 maxPercentDelta,
    uint256 decimals,
    string memory err
) internal pure virtual;

checkEq0

function checkEq0(bytes memory left, bytes memory right) internal pure returns (bool);

assertEq0

function assertEq0(bytes memory left, bytes memory right) internal pure virtual;

assertEq0

function assertEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual;

assertNotEq0

function assertNotEq0(bytes memory left, bytes memory right) internal pure virtual;

assertNotEq0

function assertNotEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual;

assertEqCall

function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual;

assertEqCall

function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB)
    internal
    virtual;

assertEqCall

function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData)
    internal
    virtual;

assertEqCall

function assertEqCall(
    address targetA,
    bytes memory callDataA,
    address targetB,
    bytes memory callDataB,
    bool strictRevertData
) internal virtual;

Events

log

event log(string);

logs

event logs(bytes);

log_address

event log_address(address);

log_bytes32

event log_bytes32(bytes32);

log_int

event log_int(int256);

log_uint

event log_uint(uint256);

log_bytes

event log_bytes(bytes);

log_string

event log_string(string);

log_named_address

event log_named_address(string key, address val);

log_named_bytes32

event log_named_bytes32(string key, bytes32 val);

log_named_decimal_int

event log_named_decimal_int(string key, int256 val, uint256 decimals);

log_named_decimal_uint

event log_named_decimal_uint(string key, uint256 val, uint256 decimals);

log_named_int

event log_named_int(string key, int256 val);

log_named_uint

event log_named_uint(string key, uint256 val);

log_named_bytes

event log_named_bytes(string key, bytes val);

log_named_string

event log_named_string(string key, string val);

log_array

event log_array(uint256[] val);

log_array

event log_array(int256[] val);

log_array

event log_array(address[] val);

log_named_array

event log_named_array(string key, uint256[] val);

log_named_array

event log_named_array(string key, int256[] val);

log_named_array

event log_named_array(string key, address[] val);

StdChains

StdChains provides information about EVM compatible chains that can be used in scripts/tests. For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are identified by their alias, which is the same as the alias in the [rpc_endpoints] section of the foundry.toml file. For best UX, ensure the alias in the foundry.toml file match the alias used in this contract, which can be found as the first argument to the setChainWithDefaultRpcUrl call in the initializeStdChains function. There are two main ways to use this contract:

1. Set a chain with setChain(string memory chainAlias, ChainData memory chain) or setChain(string memory chainAlias, Chain memory chain)
2. Get a chain with getChain(string memory chainAlias) or getChain(uint256 chainId). The first time either of those are used, chains are initialized with the default set of RPC URLs. This is done in initializeStdChains, which uses setChainWithDefaultRpcUrl. Defaults are recorded in defaultRpcUrls. The setChain function is straightforward, and it simply saves off the given chain data. The getChain methods use getChainWithUpdatedRpcUrl to return a chain. For example, let's say we want to retrieve the RPC URL for mainnet:

• If you have specified data with setChain, it will return that.
• If you have configured a mainnet RPC URL in foundry.toml, it will return the URL, provided it is valid (e.g. a URL is specified, or an environment variable is given and exists).
• If neither of the above conditions is met, the default data is returned. Summarizing the above, the prioritization hierarchy is setChain -> foundry.toml -> environment variable -> defaults.

State Variables

vm

VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));

stdChainsInitialized

bool private stdChainsInitialized;

chains

mapping(string => Chain) private chains;

defaultRpcUrls

mapping(string => string) private defaultRpcUrls;

idToAlias

mapping(uint256 => string) private idToAlias;

fallbackToDefaultRpcUrls

bool private fallbackToDefaultRpcUrls = true;

Functions

getChain

function getChain(string memory chainAlias) internal virtual returns (Chain memory chain);

getChain

function getChain(uint256 chainId) internal virtual returns (Chain memory chain);

setChain

function setChain(string memory chainAlias, ChainData memory chain) internal virtual;

setChain

function setChain(string memory chainAlias, Chain memory chain) internal virtual;

_toUpper

function _toUpper(string memory str) private pure returns (string memory);

getChainWithUpdatedRpcUrl

function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain) private view returns (Chain memory);

setFallbackToDefaultRpcUrls

function setFallbackToDefaultRpcUrls(bool useDefault) internal;

initializeStdChains

function initializeStdChains() private;

setChainWithDefaultRpcUrl

function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private;

Structs

ChainData

struct ChainData {
    string name;
    uint256 chainId;
    string rpcUrl;
}

Chain

struct Chain {
    string name;
    uint256 chainId;
    string chainAlias;
    string rpcUrl;
}

StdCheatsSafe

State Variables

vm

Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));

UINT256_MAX

uint256 private constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;

gasMeteringOff

bool private gasMeteringOff;

Functions

assumeNotBlacklisted

function assumeNotBlacklisted(address token, address addr) internal view virtual;

assumeNoBlacklisted

function assumeNoBlacklisted(address token, address addr) internal view virtual;

assumeAddressIsNot

function assumeAddressIsNot(address addr, AddressType addressType) internal virtual;

assumeAddressIsNot

function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual;

assumeAddressIsNot

function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2, AddressType addressType3)
    internal
    virtual;

assumeAddressIsNot

function assumeAddressIsNot(
    address addr,
    AddressType addressType1,
    AddressType addressType2,
    AddressType addressType3,
    AddressType addressType4
) internal virtual;

_isPayable

function _isPayable(address addr) private returns (bool);

assumePayable

function assumePayable(address addr) internal virtual;

assumeNotPayable

function assumeNotPayable(address addr) internal virtual;

assumeNotZeroAddress

function assumeNotZeroAddress(address addr) internal pure virtual;

assumeNotPrecompile

function assumeNotPrecompile(address addr) internal pure virtual;

assumeNotPrecompile

function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual;

assumeNotForgeAddress

function assumeNotForgeAddress(address addr) internal pure virtual;

assumeUnusedAddress

function assumeUnusedAddress(address addr) internal view virtual;

readEIP1559ScriptArtifact

function readEIP1559ScriptArtifact(string memory path) internal view virtual returns (EIP1559ScriptArtifact memory);

rawToConvertedEIPTx1559s

function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory);

rawToConvertedEIPTx1559

function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory);

rawToConvertedEIP1559Detail

function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)
    internal
    pure
    virtual
    returns (Tx1559Detail memory);

readTx1559s

function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory);

readTx1559

function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory);

readReceipts

function readReceipts(string memory path) internal view virtual returns (Receipt[] memory);

readReceipt

function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory);

rawToConvertedReceipts

function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory);

rawToConvertedReceipt

function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory);

rawToConvertedReceiptLogs

function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)
    internal
    pure
    virtual
    returns (ReceiptLog[] memory);

deployCode

function deployCode(string memory what, bytes memory args) internal virtual returns (address addr);

deployCode

function deployCode(string memory what) internal virtual returns (address addr);

deployCode

deploy contract with value on construction

function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr);

deployCode

function deployCode(string memory what, uint256 val) internal virtual returns (address addr);

makeAddrAndKey

function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey);

makeAddr

function makeAddr(string memory name) internal virtual returns (address addr);

destroyAccount

function destroyAccount(address who, address beneficiary) internal virtual;

makeAccount

function makeAccount(string memory name) internal virtual returns (Account memory account);

deriveRememberKey

function deriveRememberKey(string memory mnemonic, uint32 index)
    internal
    virtual
    returns (address who, uint256 privateKey);

_bytesToUint

function _bytesToUint(bytes memory b) private pure returns (uint256);

isFork

function isFork() internal view virtual returns (bool status);

skipWhenForking

modifier skipWhenForking();

skipWhenNotForking

modifier skipWhenNotForking();

noGasMetering

modifier noGasMetering();

_viewChainId

function _viewChainId() private view returns (uint256 chainId);

_pureChainId

function _pureChainId() private pure returns (uint256 chainId);

Structs

RawTx1559

struct RawTx1559 {
    string[] arguments;
    address contractAddress;
    string contractName;
    string functionSig;
    bytes32 hash;
    RawTx1559Detail txDetail;
    string opcode;
}

RawTx1559Detail

struct RawTx1559Detail {
    AccessList[] accessList;
    bytes data;
    address from;
    bytes gas;
    bytes nonce;
    address to;
    bytes txType;
    bytes value;
}

Tx1559

struct Tx1559 {
    string[] arguments;
    address contractAddress;
    string contractName;
    string functionSig;
    bytes32 hash;
    Tx1559Detail txDetail;
    string opcode;
}

Tx1559Detail

struct Tx1559Detail {
    AccessList[] accessList;
    bytes data;
    address from;
    uint256 gas;
    uint256 nonce;
    address to;
    uint256 txType;
    uint256 value;
}

TxLegacy

struct TxLegacy {
    string[] arguments;
    address contractAddress;
    string contractName;
    string functionSig;
    string hash;
    string opcode;
    TxDetailLegacy transaction;
}

TxDetailLegacy

struct TxDetailLegacy {
    AccessList[] accessList;
    uint256 chainId;
    bytes data;
    address from;
    uint256 gas;
    uint256 gasPrice;
    bytes32 hash;
    uint256 nonce;
    bytes1 opcode;
    bytes32 r;
    bytes32 s;
    uint256 txType;
    address to;
    uint8 v;
    uint256 value;
}

AccessList

struct AccessList {
    address accessAddress;
    bytes32[] storageKeys;
}

RawReceipt

struct RawReceipt {
    bytes32 blockHash;
    bytes blockNumber;
    address contractAddress;
    bytes cumulativeGasUsed;
    bytes effectiveGasPrice;
    address from;
    bytes gasUsed;
    RawReceiptLog[] logs;
    bytes logsBloom;
    bytes status;
    address to;
    bytes32 transactionHash;
    bytes transactionIndex;
}

Receipt

struct Receipt {
    bytes32 blockHash;
    uint256 blockNumber;
    address contractAddress;
    uint256 cumulativeGasUsed;
    uint256 effectiveGasPrice;
    address from;
    uint256 gasUsed;
    ReceiptLog[] logs;
    bytes logsBloom;
    uint256 status;
    address to;
    bytes32 transactionHash;
    uint256 transactionIndex;
}

EIP1559ScriptArtifact

struct EIP1559ScriptArtifact {
    string[] libraries;
    string path;
    string[] pending;
    Receipt[] receipts;
    uint256 timestamp;
    Tx1559[] transactions;
    TxReturn[] txReturns;
}

RawEIP1559ScriptArtifact

struct RawEIP1559ScriptArtifact {
    string[] libraries;
    string path;
    string[] pending;
    RawReceipt[] receipts;
    TxReturn[] txReturns;
    uint256 timestamp;
    RawTx1559[] transactions;
}

RawReceiptLog

struct RawReceiptLog {
    address logAddress;
    bytes32 blockHash;
    bytes blockNumber;
    bytes data;
    bytes logIndex;
    bool removed;
    bytes32[] topics;
    bytes32 transactionHash;
    bytes transactionIndex;
    bytes transactionLogIndex;
}

ReceiptLog

struct ReceiptLog {
    address logAddress;
    bytes32 blockHash;
    uint256 blockNumber;
    bytes data;
    uint256 logIndex;
    bytes32[] topics;
    uint256 transactionIndex;
    uint256 transactionLogIndex;
    bool removed;
}

TxReturn

struct TxReturn {
    string internalType;
    string value;
}

Account

struct Account {
    address addr;
    uint256 key;
}

Enums

AddressType

enum AddressType {
    Payable,
    NonPayable,
    ZeroAddress,
    Precompile,
    ForgeAddress
}

StdCheats

Inherits: StdCheatsSafe

State Variables

stdstore

StdStorage private stdstore;

vm

Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));

CONSOLE2_ADDRESS

address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;

Functions

skip

function skip(uint256 time) internal virtual;

rewind

function rewind(uint256 time) internal virtual;

hoax

function hoax(address msgSender) internal virtual;

hoax

function hoax(address msgSender, uint256 give) internal virtual;

hoax

function hoax(address msgSender, address origin) internal virtual;

hoax

function hoax(address msgSender, address origin, uint256 give) internal virtual;

startHoax

function startHoax(address msgSender) internal virtual;

startHoax

function startHoax(address msgSender, uint256 give) internal virtual;

startHoax

function startHoax(address msgSender, address origin) internal virtual;

startHoax

function startHoax(address msgSender, address origin, uint256 give) internal virtual;

changePrank

function changePrank(address msgSender) internal virtual;

changePrank

function changePrank(address msgSender, address txOrigin) internal virtual;

deal

function deal(address to, uint256 give) internal virtual;

deal

function deal(address token, address to, uint256 give) internal virtual;

dealERC1155

function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual;

deal

function deal(address token, address to, uint256 give, bool adjust) internal virtual;

dealERC1155

function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual;

dealERC721

function dealERC721(address token, address to, uint256 id) internal virtual;

deployCodeTo

function deployCodeTo(string memory what, address where) internal virtual;

deployCodeTo

function deployCodeTo(string memory what, bytes memory args, address where) internal virtual;

deployCodeTo

function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual;

console2_log_StdCheats

function console2_log_StdCheats(string memory p0) private view;

StdConstants

State Variables

VM

Cheat code address. Calculated as address(uint160(uint256(keccak256("hevm cheat code")))).

Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

CONSOLE

console.sol and console2.sol work by executing a staticcall to this address. Calculated as address(uint160(uint88(bytes11("console.log")))).

address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;

CREATE2_FACTORY

Used when deploying with create2. Taken from https://github.com/Arachnid/deterministic-deployment-proxy.

address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;

DEFAULT_SENDER

The default address for tx.origin and msg.sender. Calculated as address(uint160(uint256(keccak256("foundry default caller")))).

address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;

DEFAULT_TEST_CONTRACT

The address of the first contract CREATEd by a running test contract. When running tests, each test contract is CREATEd by DEFAULT_SENDER with nonce 1. Calculated as VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1).

address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;

MULTICALL3_ADDRESS

Deterministic deployment address of the Multicall3 contract. Taken from https://www.multicall3.com.

IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);

SECP256K1_ORDER

The order of the secp256k1 curve.

uint256 internal constant SECP256K1_ORDER =
    115792089237316195423570985008687907852837564279074904382605163141518161494337;

stdError

State Variables

assertionError

bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01);

arithmeticError

bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11);

divisionError

bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12);

enumConversionError

bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21);

encodeStorageError

bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22);

popError

bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31);

indexOOBError

bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32);

memOverflowError

bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41);

zeroVarError

bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51);

StdInvariant

State Variables

_excludedContracts

address[] private _excludedContracts;

_excludedSenders

address[] private _excludedSenders;

_targetedContracts

address[] private _targetedContracts;

_targetedSenders

address[] private _targetedSenders;

_excludedArtifacts

string[] private _excludedArtifacts;

_targetedArtifacts

string[] private _targetedArtifacts;

_targetedArtifactSelectors

FuzzArtifactSelector[] private _targetedArtifactSelectors;

_excludedSelectors

FuzzSelector[] private _excludedSelectors;

_targetedSelectors

FuzzSelector[] private _targetedSelectors;

_targetedInterfaces

FuzzInterface[] private _targetedInterfaces;

Functions

excludeContract

function excludeContract(address newExcludedContract_) internal;

excludeSelector

function excludeSelector(FuzzSelector memory newExcludedSelector_) internal;

excludeSender

function excludeSender(address newExcludedSender_) internal;

excludeArtifact

function excludeArtifact(string memory newExcludedArtifact_) internal;

targetArtifact

function targetArtifact(string memory newTargetedArtifact_) internal;

targetArtifactSelector

function targetArtifactSelector(FuzzArtifactSelector memory newTargetedArtifactSelector_) internal;

targetContract

function targetContract(address newTargetedContract_) internal;

targetSelector

function targetSelector(FuzzSelector memory newTargetedSelector_) internal;

targetSender

function targetSender(address newTargetedSender_) internal;

targetInterface

function targetInterface(FuzzInterface memory newTargetedInterface_) internal;

excludeArtifacts

function excludeArtifacts() public view returns (string[] memory excludedArtifacts_);

excludeContracts

function excludeContracts() public view returns (address[] memory excludedContracts_);

excludeSelectors

function excludeSelectors() public view returns (FuzzSelector[] memory excludedSelectors_);

excludeSenders

function excludeSenders() public view returns (address[] memory excludedSenders_);

targetArtifacts

function targetArtifacts() public view returns (string[] memory targetedArtifacts_);

targetArtifactSelectors

function targetArtifactSelectors() public view returns (FuzzArtifactSelector[] memory targetedArtifactSelectors_);

targetContracts

function targetContracts() public view returns (address[] memory targetedContracts_);

targetSelectors

function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_);

targetSenders

function targetSenders() public view returns (address[] memory targetedSenders_);

targetInterfaces

function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_);

Structs

FuzzSelector

struct FuzzSelector {
    address addr;
    bytes4[] selectors;
}

FuzzArtifactSelector

struct FuzzArtifactSelector {
    string artifact;
    bytes4[] selectors;
}

FuzzInterface

struct FuzzInterface {
    address addr;
    string[] artifacts;
}

stdJson

State Variables

vm

VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));

Functions

keyExists

function keyExists(string memory json, string memory key) internal view returns (bool);

parseRaw

function parseRaw(string memory json, string memory key) internal pure returns (bytes memory);

readUint

function readUint(string memory json, string memory key) internal pure returns (uint256);

readUintArray

function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory);

readInt

function readInt(string memory json, string memory key) internal pure returns (int256);

readIntArray

function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory);

readBytes32

function readBytes32(string memory json, string memory key) internal pure returns (bytes32);

readBytes32Array

function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory);

readString

function readString(string memory json, string memory key) internal pure returns (string memory);

readStringArray

function readStringArray(string memory json, string memory key) internal pure returns (string[] memory);

readAddress

function readAddress(string memory json, string memory key) internal pure returns (address);

readAddressArray

function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory);

readBool

function readBool(string memory json, string memory key) internal pure returns (bool);

readBoolArray

function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory);

readBytes

function readBytes(string memory json, string memory key) internal pure returns (bytes memory);

readBytesArray

function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory);

readUintOr

function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256);

readUintArrayOr

function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)
    internal
    view
    returns (uint256[] memory);

readIntOr

function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256);

readIntArrayOr

function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)
    internal
    view
    returns (int256[] memory);

readBytes32Or

function readBytes32Or(string memory json, string memory key, bytes32 defaultValue) internal view returns (bytes32);

readBytes32ArrayOr

function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)
    internal
    view
    returns (bytes32[] memory);

readStringOr

function readStringOr(string memory json, string memory key, string memory defaultValue)
    internal
    view
    returns (string memory);

readStringArrayOr

function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)
    internal
    view
    returns (string[] memory);

readAddressOr

function readAddressOr(string memory json, string memory key, address defaultValue) internal view returns (address);

readAddressArrayOr

function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)
    internal
    view
    returns (address[] memory);

readBoolOr

function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool);

readBoolArrayOr

function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)
    internal
    view
    returns (bool[] memory);

readBytesOr

function readBytesOr(string memory json, string memory key, bytes memory defaultValue)
    internal
    view
    returns (bytes memory);

readBytesArrayOr

function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)
    internal
    view
    returns (bytes[] memory);

serialize

function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bool[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, uint256[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, int256[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, address[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bytes32[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bytes[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, string memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, string[] memory value) internal returns (string memory);

write

function write(string memory jsonKey, string memory path) internal;

write

function write(string memory jsonKey, string memory path, string memory valueKey) internal;

stdMath

State Variables

INT256_MIN

int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;

Functions

abs

function abs(int256 a) internal pure returns (uint256);

delta

function delta(uint256 a, uint256 b) internal pure returns (uint256);

delta

function delta(int256 a, int256 b) internal pure returns (uint256);

percentDelta

function percentDelta(uint256 a, uint256 b) internal pure returns (uint256);

percentDelta

function percentDelta(int256 a, int256 b) internal pure returns (uint256);

FindData

struct FindData {
    uint256 slot;
    uint256 offsetLeft;
    uint256 offsetRight;
    bool found;
}

StdStorage

struct StdStorage {
    mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;
    bytes32[] _keys;
    bytes4 _sig;
    uint256 _depth;
    address _target;
    bytes32 _set;
    bool _enable_packed_slots;
    bytes _calldata;
}

stdStorageSafe

State Variables

vm

Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));

UINT256_MAX

uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;

Functions

sigs

function sigs(string memory sigStr) internal pure returns (bytes4);

getCallParams

function getCallParams(StdStorage storage self) internal view returns (bytes memory);

callTarget

function callTarget(StdStorage storage self) internal view returns (bool, bytes32);

checkSlotMutatesCall

function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool);

findOffset

function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256);

findOffsets

function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256);

find

function find(StdStorage storage self) internal returns (FindData storage);

find

find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against

function find(StdStorage storage self, bool _clear) internal returns (FindData storage);

target

function target(StdStorage storage self, address _target) internal returns (StdStorage storage);

sig

function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage);

sig

function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage);

with_calldata

function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage);

with_key

function with_key(StdStorage storage self, address who) internal returns (StdStorage storage);

with_key

function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage);

with_key

function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage);

enable_packed_slots

function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage);

depth

function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage);

read

function read(StdStorage storage self) private returns (bytes memory);

read_bytes32

function read_bytes32(StdStorage storage self) internal returns (bytes32);

read_bool

function read_bool(StdStorage storage self) internal returns (bool);

read_address

function read_address(StdStorage storage self) internal returns (address);

read_uint

function read_uint(StdStorage storage self) internal returns (uint256);

read_int

function read_int(StdStorage storage self) internal returns (int256);

parent

function parent(StdStorage storage self) internal returns (uint256, bytes32);

root

function root(StdStorage storage self) internal returns (uint256);

bytesToBytes32

function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32);

flatten

function flatten(bytes32[] memory b) private pure returns (bytes memory);

clear

function clear(StdStorage storage self) internal;

getMaskByOffsets

function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask);

getUpdatedSlotValue

function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)
    internal
    pure
    returns (bytes32 newValue);

Events

SlotFound

event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);

WARNING_UninitedSlot

event WARNING_UninitedSlot(address who, uint256 slot);

stdStorage

State Variables

vm

Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));

Functions

sigs

function sigs(string memory sigStr) internal pure returns (bytes4);

find

function find(StdStorage storage self) internal returns (uint256);

find

function find(StdStorage storage self, bool _clear) internal returns (uint256);

target

function target(StdStorage storage self, address _target) internal returns (StdStorage storage);

sig

function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage);

sig

function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage);

with_key

function with_key(StdStorage storage self, address who) internal returns (StdStorage storage);

with_key

function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage);

with_key

function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage);

with_calldata

function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage);

enable_packed_slots

function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage);

depth

function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage);

clear

function clear(StdStorage storage self) internal;

checked_write

function checked_write(StdStorage storage self, address who) internal;

checked_write

function checked_write(StdStorage storage self, uint256 amt) internal;

checked_write_int

function checked_write_int(StdStorage storage self, int256 val) internal;

checked_write

function checked_write(StdStorage storage self, bool write) internal;

checked_write

function checked_write(StdStorage storage self, bytes32 set) internal;

read_bytes32

function read_bytes32(StdStorage storage self) internal returns (bytes32);

read_bool

function read_bool(StdStorage storage self) internal returns (bool);

read_address

function read_address(StdStorage storage self) internal returns (address);

read_uint

function read_uint(StdStorage storage self) internal returns (uint256);

read_int

function read_int(StdStorage storage self) internal returns (int256);

parent

function parent(StdStorage storage self) internal returns (uint256, bytes32);

root

function root(StdStorage storage self) internal returns (uint256);

StdStyle

State Variables

vm

VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));

RED

string constant RED = "\u001b[91m";

GREEN

string constant GREEN = "\u001b[92m";

YELLOW

string constant YELLOW = "\u001b[93m";

BLUE

string constant BLUE = "\u001b[94m";

MAGENTA

string constant MAGENTA = "\u001b[95m";

CYAN

string constant CYAN = "\u001b[96m";

BOLD

string constant BOLD = "\u001b[1m";

DIM

string constant DIM = "\u001b[2m";

ITALIC

string constant ITALIC = "\u001b[3m";

UNDERLINE

string constant UNDERLINE = "\u001b[4m";

INVERSE

string constant INVERSE = "\u001b[7m";

RESET

string constant RESET = "\u001b[0m";

Functions

styleConcat

function styleConcat(string memory style, string memory self) private pure returns (string memory);

red

function red(string memory self) internal pure returns (string memory);

red

function red(uint256 self) internal pure returns (string memory);

red

function red(int256 self) internal pure returns (string memory);

red

function red(address self) internal pure returns (string memory);

red

function red(bool self) internal pure returns (string memory);

redBytes

function redBytes(bytes memory self) internal pure returns (string memory);

redBytes32

function redBytes32(bytes32 self) internal pure returns (string memory);

green

function green(string memory self) internal pure returns (string memory);

green

function green(uint256 self) internal pure returns (string memory);

green

function green(int256 self) internal pure returns (string memory);

green

function green(address self) internal pure returns (string memory);

green

function green(bool self) internal pure returns (string memory);

greenBytes

function greenBytes(bytes memory self) internal pure returns (string memory);

greenBytes32

function greenBytes32(bytes32 self) internal pure returns (string memory);

yellow

function yellow(string memory self) internal pure returns (string memory);

yellow

function yellow(uint256 self) internal pure returns (string memory);

yellow

function yellow(int256 self) internal pure returns (string memory);

yellow

function yellow(address self) internal pure returns (string memory);

yellow

function yellow(bool self) internal pure returns (string memory);

yellowBytes

function yellowBytes(bytes memory self) internal pure returns (string memory);

yellowBytes32

function yellowBytes32(bytes32 self) internal pure returns (string memory);

blue

function blue(string memory self) internal pure returns (string memory);

blue

function blue(uint256 self) internal pure returns (string memory);

blue

function blue(int256 self) internal pure returns (string memory);

blue

function blue(address self) internal pure returns (string memory);

blue

function blue(bool self) internal pure returns (string memory);

blueBytes

function blueBytes(bytes memory self) internal pure returns (string memory);

blueBytes32

function blueBytes32(bytes32 self) internal pure returns (string memory);

magenta

function magenta(string memory self) internal pure returns (string memory);

magenta

function magenta(uint256 self) internal pure returns (string memory);

magenta

function magenta(int256 self) internal pure returns (string memory);

magenta

function magenta(address self) internal pure returns (string memory);

magenta

function magenta(bool self) internal pure returns (string memory);

magentaBytes

function magentaBytes(bytes memory self) internal pure returns (string memory);

magentaBytes32

function magentaBytes32(bytes32 self) internal pure returns (string memory);

cyan

function cyan(string memory self) internal pure returns (string memory);

cyan

function cyan(uint256 self) internal pure returns (string memory);

cyan

function cyan(int256 self) internal pure returns (string memory);

cyan

function cyan(address self) internal pure returns (string memory);

cyan

function cyan(bool self) internal pure returns (string memory);

cyanBytes

function cyanBytes(bytes memory self) internal pure returns (string memory);

cyanBytes32

function cyanBytes32(bytes32 self) internal pure returns (string memory);

bold

function bold(string memory self) internal pure returns (string memory);

bold

function bold(uint256 self) internal pure returns (string memory);

bold

function bold(int256 self) internal pure returns (string memory);

bold

function bold(address self) internal pure returns (string memory);

bold

function bold(bool self) internal pure returns (string memory);

boldBytes

function boldBytes(bytes memory self) internal pure returns (string memory);

boldBytes32

function boldBytes32(bytes32 self) internal pure returns (string memory);

dim

function dim(string memory self) internal pure returns (string memory);

dim

function dim(uint256 self) internal pure returns (string memory);

dim

function dim(int256 self) internal pure returns (string memory);

dim

function dim(address self) internal pure returns (string memory);

dim

function dim(bool self) internal pure returns (string memory);

dimBytes

function dimBytes(bytes memory self) internal pure returns (string memory);

dimBytes32

function dimBytes32(bytes32 self) internal pure returns (string memory);

italic

function italic(string memory self) internal pure returns (string memory);

italic

function italic(uint256 self) internal pure returns (string memory);

italic

function italic(int256 self) internal pure returns (string memory);

italic

function italic(address self) internal pure returns (string memory);

italic

function italic(bool self) internal pure returns (string memory);

italicBytes

function italicBytes(bytes memory self) internal pure returns (string memory);

italicBytes32

function italicBytes32(bytes32 self) internal pure returns (string memory);

underline

function underline(string memory self) internal pure returns (string memory);

underline

function underline(uint256 self) internal pure returns (string memory);

underline

function underline(int256 self) internal pure returns (string memory);

underline

function underline(address self) internal pure returns (string memory);

underline

function underline(bool self) internal pure returns (string memory);

underlineBytes

function underlineBytes(bytes memory self) internal pure returns (string memory);

underlineBytes32

function underlineBytes32(bytes32 self) internal pure returns (string memory);

inverse

function inverse(string memory self) internal pure returns (string memory);

inverse

function inverse(uint256 self) internal pure returns (string memory);

inverse

function inverse(int256 self) internal pure returns (string memory);

inverse

function inverse(address self) internal pure returns (string memory);

inverse

function inverse(bool self) internal pure returns (string memory);

inverseBytes

function inverseBytes(bytes memory self) internal pure returns (string memory);

inverseBytes32

function inverseBytes32(bytes32 self) internal pure returns (string memory);

stdToml

State Variables

vm

VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));

Functions

keyExists

function keyExists(string memory toml, string memory key) internal view returns (bool);

parseRaw

function parseRaw(string memory toml, string memory key) internal pure returns (bytes memory);

readUint

function readUint(string memory toml, string memory key) internal pure returns (uint256);

readUintArray

function readUintArray(string memory toml, string memory key) internal pure returns (uint256[] memory);

readInt

function readInt(string memory toml, string memory key) internal pure returns (int256);

readIntArray

function readIntArray(string memory toml, string memory key) internal pure returns (int256[] memory);

readBytes32

function readBytes32(string memory toml, string memory key) internal pure returns (bytes32);

readBytes32Array

function readBytes32Array(string memory toml, string memory key) internal pure returns (bytes32[] memory);

readString

function readString(string memory toml, string memory key) internal pure returns (string memory);

readStringArray

function readStringArray(string memory toml, string memory key) internal pure returns (string[] memory);

readAddress

function readAddress(string memory toml, string memory key) internal pure returns (address);

readAddressArray

function readAddressArray(string memory toml, string memory key) internal pure returns (address[] memory);

readBool

function readBool(string memory toml, string memory key) internal pure returns (bool);

readBoolArray

function readBoolArray(string memory toml, string memory key) internal pure returns (bool[] memory);

readBytes

function readBytes(string memory toml, string memory key) internal pure returns (bytes memory);

readBytesArray

function readBytesArray(string memory toml, string memory key) internal pure returns (bytes[] memory);

readUintOr

function readUintOr(string memory toml, string memory key, uint256 defaultValue) internal view returns (uint256);

readUintArrayOr

function readUintArrayOr(string memory toml, string memory key, uint256[] memory defaultValue)
    internal
    view
    returns (uint256[] memory);

readIntOr

function readIntOr(string memory toml, string memory key, int256 defaultValue) internal view returns (int256);

readIntArrayOr

function readIntArrayOr(string memory toml, string memory key, int256[] memory defaultValue)
    internal
    view
    returns (int256[] memory);

readBytes32Or

function readBytes32Or(string memory toml, string memory key, bytes32 defaultValue) internal view returns (bytes32);

readBytes32ArrayOr

function readBytes32ArrayOr(string memory toml, string memory key, bytes32[] memory defaultValue)
    internal
    view
    returns (bytes32[] memory);

readStringOr

function readStringOr(string memory toml, string memory key, string memory defaultValue)
    internal
    view
    returns (string memory);

readStringArrayOr

function readStringArrayOr(string memory toml, string memory key, string[] memory defaultValue)
    internal
    view
    returns (string[] memory);

readAddressOr

function readAddressOr(string memory toml, string memory key, address defaultValue) internal view returns (address);

readAddressArrayOr

function readAddressArrayOr(string memory toml, string memory key, address[] memory defaultValue)
    internal
    view
    returns (address[] memory);

readBoolOr

function readBoolOr(string memory toml, string memory key, bool defaultValue) internal view returns (bool);

readBoolArrayOr

function readBoolArrayOr(string memory toml, string memory key, bool[] memory defaultValue)
    internal
    view
    returns (bool[] memory);

readBytesOr

function readBytesOr(string memory toml, string memory key, bytes memory defaultValue)
    internal
    view
    returns (bytes memory);

readBytesArrayOr

function readBytesArrayOr(string memory toml, string memory key, bytes[] memory defaultValue)
    internal
    view
    returns (bytes[] memory);

serialize

function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bool[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, uint256[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, int256[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, address[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bytes32[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, bytes[] memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, string memory value) internal returns (string memory);

serialize

function serialize(string memory jsonKey, string memory key, string[] memory value) internal returns (string memory);

write

function write(string memory jsonKey, string memory path) internal;

write

function write(string memory jsonKey, string memory path, string memory valueKey) internal;

StdUtils

State Variables

multicall

IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);

vm

VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));

CONSOLE2_ADDRESS

address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;

INT256_MIN_ABS

uint256 private constant INT256_MIN_ABS = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

SECP256K1_ORDER

uint256 private constant SECP256K1_ORDER =
    115792089237316195423570985008687907852837564279074904382605163141518161494337;

UINT256_MAX

uint256 private constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;

CREATE2_FACTORY

address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;

Functions

_bound

function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result);

bound

function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result);

_bound

function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result);

bound

function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result);

boundPrivateKey

function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result);

bytesToUint

function bytesToUint(bytes memory b) internal pure virtual returns (uint256);

computeCreateAddress

adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)

Compute the address a contract will be deployed at for a given deployer address and nonce

function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address);

computeCreate2Address

function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)
    internal
    pure
    virtual
    returns (address);

computeCreate2Address

returns the address of a contract created with CREATE2 using the default CREATE2 deployer

function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address);

hashInitCode

returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments

function hashInitCode(bytes memory creationCode) internal pure returns (bytes32);

Parameters

hashInitCode

returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2

function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32);

Parameters

getTokenBalances

function getTokenBalances(address token, address[] memory addresses)
    internal
    virtual
    returns (uint256[] memory balances);

addressFromLast20Bytes

function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address);

_castLogPayloadViewToPure

function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)
    internal
    pure
    returns (function(bytes memory) internal pure fnOut);

_sendLogPayload

function _sendLogPayload(bytes memory payload) internal pure;

_sendLogPayloadView

function _sendLogPayloadView(bytes memory payload) private view;

console2_log_StdUtils

function console2_log_StdUtils(string memory p0) private pure;

console2_log_StdUtils

function console2_log_StdUtils(string memory p0, uint256 p1) private pure;

console2_log_StdUtils

function console2_log_StdUtils(string memory p0, string memory p1) private pure;

Test

Inherits: TestBase, StdAssertions, StdChains, StdCheats, StdInvariant, StdUtils

State Variables

IS_TEST

bool public IS_TEST = true;

VmSafe

The VmSafe interface does not allow manipulation of the EVM state or other actions that may result in Script simulations differing from on-chain execution. It is recommended to only use these cheats in scripts.

Functions

createWallet

Derives a private key from the name, labels the account with that name, and returns the wallet.

function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);

createWallet

Generates a wallet from the private key and returns the wallet.

function createWallet(uint256 privateKey) external returns (Wallet memory wallet);

createWallet

Generates a wallet from the private key, labels the account with that name, and returns the wallet.

function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);

deriveKey

Derive a private key from a provided mnenomic string (or mnenomic file path) at the derivation path m/44'/60'/0'/0/{index}.

function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);

deriveKey

Derive a private key from a provided mnenomic string (or mnenomic file path) at {derivationPath}{index}.

function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)
    external
    pure
    returns (uint256 privateKey);

deriveKey

Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language at the derivation path m/44'/60'/0'/0/{index}.

function deriveKey(string calldata mnemonic, uint32 index, string calldata language)
    external
    pure
    returns (uint256 privateKey);

deriveKey

Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language at {derivationPath}{index}.

function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)
    external
    pure
    returns (uint256 privateKey);

publicKeyP256

Derives secp256r1 public key from the provided privateKey.

function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);

rememberKey

Adds a private key to the local forge wallet and returns the address.

function rememberKey(uint256 privateKey) external returns (address keyAddr);

rememberKeys

Derive a set number of wallets from a mnemonic at the derivation path m/44'/60'/0'/0/{0..count}. The respective private keys are saved to the local forge wallet for later use and their addresses are returned.

function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)
    external
    returns (address[] memory keyAddrs);

rememberKeys

Derive a set number of wallets from a mnemonic in the specified language at the derivation path m/44'/60'/0'/0/{0..count}. The respective private keys are saved to the local forge wallet for later use and their addresses are returned.

function rememberKeys(string calldata mnemonic, string calldata derivationPath, string calldata language, uint32 count)
    external
    returns (address[] memory keyAddrs);

signCompact

Signs data with a Wallet. Returns a compact signature (r, vs) as per EIP-2098, where vs encodes both the signature's s value, and the recovery id v in a single bytes32. This format reduces the signature size from 65 to 64 bytes.

function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);

signCompact

Signs digest with privateKey using the secp256k1 curve. Returns a compact signature (r, vs) as per EIP-2098, where vs encodes both the signature's s value, and the recovery id v in a single bytes32. This format reduces the signature size from 65 to 64 bytes.

function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);

signCompact

Signs digest with signer provided to script using the secp256k1 curve. Returns a compact signature (r, vs) as per EIP-2098, where vs encodes both the signature's s value, and the recovery id v in a single bytes32. This format reduces the signature size from 65 to 64 bytes. If --sender is provided, the signer with provided address is used, otherwise, if exactly one signer is provided to the script, that signer is used. Raises error if signer passed through --sender does not match any unlocked signers or if --sender is not provided and not exactly one signer is passed to the script.

function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);

signCompact

Signs digest with signer provided to script using the secp256k1 curve. Returns a compact signature (r, vs) as per EIP-2098, where vs encodes both the signature's s value, and the recovery id v in a single bytes32. This format reduces the signature size from 65 to 64 bytes. Raises error if none of the signers passed into the script have provided address.

function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);

signP256

Signs digest with privateKey using the secp256r1 curve.

function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);

sign

Signs data with a Wallet.

function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);

sign

Signs digest with privateKey using the secp256k1 curve.

function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);

sign

Signs digest with signer provided to script using the secp256k1 curve. If --sender is provided, the signer with provided address is used, otherwise, if exactly one signer is provided to the script, that signer is used. Raises error if signer passed through --sender does not match any unlocked signers or if --sender is not provided and not exactly one signer is passed to the script.

function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);

sign

Signs digest with signer provided to script using the secp256k1 curve. Raises error if none of the signers passed into the script have provided address.

function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);

envAddress

Gets the environment variable name and parses it as address. Reverts if the variable was not found or could not be parsed.

function envAddress(string calldata name) external view returns (address value);

envAddress

Gets the environment variable name and parses it as an array of address, delimited by delim. Reverts if the variable was not found or could not be parsed.

function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);

envBool

Gets the environment variable name and parses it as bool. Reverts if the variable was not found or could not be parsed.

function envBool(string calldata name) external view returns (bool value);

envBool

Gets the environment variable name and parses it as an array of bool, delimited by delim. Reverts if the variable was not found or could not be parsed.

function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);

envBytes32

Gets the environment variable name and parses it as bytes32. Reverts if the variable was not found or could not be parsed.

function envBytes32(string calldata name) external view returns (bytes32 value);

envBytes32

Gets the environment variable name and parses it as an array of bytes32, delimited by delim. Reverts if the variable was not found or could not be parsed.

function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);

envBytes

Gets the environment variable name and parses it as bytes. Reverts if the variable was not found or could not be parsed.

function envBytes(string calldata name) external view returns (bytes memory value);

envBytes

Gets the environment variable name and parses it as an array of bytes, delimited by delim. Reverts if the variable was not found or could not be parsed.

function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);

envExists

Gets the environment variable name and returns true if it exists, else returns false.

function envExists(string calldata name) external view returns (bool result);

envInt

Gets the environment variable name and parses it as int256. Reverts if the variable was not found or could not be parsed.

function envInt(string calldata name) external view returns (int256 value);

envInt

Gets the environment variable name and parses it as an array of int256, delimited by delim. Reverts if the variable was not found or could not be parsed.

function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);

envOr

Gets the environment variable name and parses it as bool. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, bool defaultValue) external view returns (bool value);

envOr

Gets the environment variable name and parses it as uint256. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);

envOr

Gets the environment variable name and parses it as an array of address, delimited by delim. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)
    external
    view
    returns (address[] memory value);

envOr

Gets the environment variable name and parses it as an array of bytes32, delimited by delim. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)
    external
    view
    returns (bytes32[] memory value);

envOr

Gets the environment variable name and parses it as an array of string, delimited by delim. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)
    external
    view
    returns (string[] memory value);

envOr

Gets the environment variable name and parses it as an array of bytes, delimited by delim. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)
    external
    view
    returns (bytes[] memory value);

envOr

Gets the environment variable name and parses it as int256. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);

envOr

Gets the environment variable name and parses it as address. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, address defaultValue) external view returns (address value);

envOr

Gets the environment variable name and parses it as bytes32. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);

envOr

Gets the environment variable name and parses it as string. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);

envOr

Gets the environment variable name and parses it as bytes. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);

envOr

Gets the environment variable name and parses it as an array of bool, delimited by delim. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)
    external
    view
    returns (bool[] memory value);

envOr

Gets the environment variable name and parses it as an array of uint256, delimited by delim. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)
    external
    view
    returns (uint256[] memory value);

envOr

Gets the environment variable name and parses it as an array of int256, delimited by delim. Reverts if the variable could not be parsed. Returns defaultValue if the variable was not found.

function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)
    external
    view
    returns (int256[] memory value);

envString

Gets the environment variable name and parses it as string. Reverts if the variable was not found or could not be parsed.

function envString(string calldata name) external view returns (string memory value);

envString

Gets the environment variable name and parses it as an array of string, delimited by delim. Reverts if the variable was not found or could not be parsed.

function envString(string calldata name, string calldata delim) external view returns (string[] memory value);

envUint

Gets the environment variable name and parses it as uint256. Reverts if the variable was not found or could not be parsed.

function envUint(string calldata name) external view returns (uint256 value);

envUint

Gets the environment variable name and parses it as an array of uint256, delimited by delim. Reverts if the variable was not found or could not be parsed.

function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);

isContext

Returns true if forge command was executed in given context.

function isContext(ForgeContext context) external view returns (bool result);

setEnv

Sets environment variables.

function setEnv(string calldata name, string calldata value) external;

accesses

Gets all accessed reads and write slot from a vm.record session, for a given address.

function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);

addr

Gets the address for a given private key.

function addr(uint256 privateKey) external pure returns (address keyAddr);

eth_getLogs

Gets all the logs according to specified filter.

function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)
    external
    returns (EthGetLogs[] memory logs);

getBlobBaseFee

Gets the current block.blobbasefee. You should use this instead of block.blobbasefee if you use vm.blobBaseFee, as block.blobbasefee is assumed to be constant across a transaction, and as a result will get optimized out by the compiler. See https://github.com/foundry-rs/foundry/issues/6180

function getBlobBaseFee() external view returns (uint256 blobBaseFee);

getBlockNumber

Gets the current block.number. You should use this instead of block.number if you use vm.roll, as block.number is assumed to be constant across a transaction, and as a result will get optimized out by the compiler. See https://github.com/foundry-rs/foundry/issues/6180

function getBlockNumber() external view returns (uint256 height);

getBlockTimestamp

Gets the current block.timestamp. You should use this instead of block.timestamp if you use vm.warp, as block.timestamp is assumed to be constant across a transaction, and as a result will get optimized out by the compiler. See https://github.com/foundry-rs/foundry/issues/6180

function getBlockTimestamp() external view returns (uint256 timestamp);

getMappingKeyAndParentOf

Gets the map key and parent of a mapping at a given slot, for a given address.

function getMappingKeyAndParentOf(address target, bytes32 elementSlot)
    external
    returns (bool found, bytes32 key, bytes32 parent);

getMappingLength

Gets the number of elements in the mapping at the given slot, for a given address.

function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);

getMappingSlotAt

Gets the elements at index idx of the mapping at the given slot, for a given address. The index must be less than the length of the mapping (i.e. the number of keys in the mapping).

function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);

getNonce

Gets the nonce of an account.

function getNonce(address account) external view returns (uint64 nonce);

getNonce

Get the nonce of a Wallet.

function getNonce(Wallet calldata wallet) external returns (uint64 nonce);

getRecordedLogs

Gets all the recorded logs.

function getRecordedLogs() external returns (Log[] memory logs);

getStateDiff

Returns state diffs from current vm.startStateDiffRecording session.

function getStateDiff() external view returns (string memory diff);

getStateDiffJson

Returns state diffs from current vm.startStateDiffRecording session, in json format.

function getStateDiffJson() external view returns (string memory diff);

lastCallGas

Gets the gas used in the last call from the callee perspective.

function lastCallGas() external view returns (Gas memory gas);

load

Loads a storage slot from an address.

function load(address target, bytes32 slot) external view returns (bytes32 data);

pauseGasMetering

Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.

function pauseGasMetering() external;

record

Records all storage reads and writes.

function record() external;

recordLogs

Record all the transaction logs.

function recordLogs() external;

resetGasMetering

Reset gas metering (i.e. gas usage is set to gas limit).

function resetGasMetering() external;

resumeGasMetering

Resumes gas metering (i.e. gas usage is counted again). Noop if already on.

function resumeGasMetering() external;

rpc

Performs an Ethereum JSON-RPC request to the current fork URL.

function rpc(string calldata method, string calldata params) external returns (bytes memory data);

rpc

Performs an Ethereum JSON-RPC request to the given endpoint.

function rpc(string calldata urlOrAlias, string calldata method, string calldata params)
    external
    returns (bytes memory data);

startDebugTraceRecording

Records the debug trace during the run.

function startDebugTraceRecording() external;

startMappingRecording

Starts recording all map SSTOREs for later retrieval.

function startMappingRecording() external;

startStateDiffRecording

Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order, along with the context of the calls

function startStateDiffRecording() external;

stopAndReturnDebugTraceRecording

Stop debug trace recording and returns the recorded debug trace.

function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);

stopAndReturnStateDiff

Returns an ordered array of all account accesses from a vm.startStateDiffRecording session.

function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);

stopMappingRecording

Stops recording all map SSTOREs for later retrieval and clears the recorded data.

function stopMappingRecording() external;

closeFile

Closes file for reading, resetting the offset and allowing to read it from beginning with readLine. path is relative to the project root.

function closeFile(string calldata path) external;

copyFile

Copies the contents of one file to another. This function will overwrite the contents of to. On success, the total number of bytes copied is returned and it is equal to the length of the to file as reported by metadata. Both from and to are relative to the project root.

function copyFile(string calldata from, string calldata to) external returns (uint64 copied);

createDir

Creates a new, empty directory at the provided path. This cheatcode will revert in the following situations, but is not limited to just these cases:

• User lacks permissions to modify path.
• A parent of the given path doesn't exist and recursive is false.
• path already exists and recursive is false. path is relative to the project root.

function createDir(string calldata path, bool recursive) external;

deployCode

Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional.

function deployCode(string calldata artifactPath) external returns (address deployedAddress);

deployCode

Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional. Additionally accepts abi-encoded constructor arguments.

function deployCode(string calldata artifactPath, bytes calldata constructorArgs)
    external
    returns (address deployedAddress);

deployCode

Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional. Additionally accepts msg.value.

function deployCode(string calldata artifactPath, uint256 value) external returns (address deployedAddress);

deployCode

Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional. Additionally accepts abi-encoded constructor arguments and msg.value.

function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value)
    external
    returns (address deployedAddress);

deployCode

Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional.

function deployCode(string calldata artifactPath, bytes32 salt) external returns (address deployedAddress);

deployCode

Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional. Additionally accepts abi-encoded constructor arguments.

function deployCode(string calldata artifactPath, bytes calldata constructorArgs, bytes32 salt)
    external
    returns (address deployedAddress);

deployCode

Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional. Additionally accepts msg.value.

function deployCode(string calldata artifactPath, uint256 value, bytes32 salt)
    external
    returns (address deployedAddress);

deployCode

Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional. Additionally accepts abi-encoded constructor arguments and msg.value.

function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value, bytes32 salt)
    external
    returns (address deployedAddress);

exists

Returns true if the given path points to an existing entity, else returns false.

function exists(string calldata path) external view returns (bool result);

ffi

Performs a foreign function call via the terminal.

function ffi(string[] calldata commandInput) external returns (bytes memory result);

fsMetadata

Given a path, query the file system to get information about a file, directory, etc.

function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);

getArtifactPathByCode

Gets the artifact path from code (aka. creation code).

function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);

getArtifactPathByDeployedCode

Gets the artifact path from deployed code (aka. runtime code).

function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);

getBroadcast

Returns the most recent broadcast for the given contract on chainId matching txType. For example: The most recent deployment can be fetched by passing txType as CREATE or CREATE2. The most recent call can be fetched by passing txType as CALL.

function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)
    external
    view
    returns (BroadcastTxSummary memory);

getBroadcasts

Returns all broadcasts for the given contract on chainId with the specified txType. Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.

function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)
    external
    view
    returns (BroadcastTxSummary[] memory);

getBroadcasts

Returns all broadcasts for the given contract on chainId. Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.

function getBroadcasts(string calldata contractName, uint64 chainId)
    external
    view
    returns (BroadcastTxSummary[] memory);

getCode

Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional.

function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);

getDeployedCode

Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the artifact in the form of :: where and parts are optional.

function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);

getDeployment

Returns the most recent deployment for the current chainId.

function getDeployment(string calldata contractName) external view returns (address deployedAddress);

getDeployment

Returns the most recent deployment for the given contract on chainId

function getDeployment(string calldata contractName, uint64 chainId) external view returns (address deployedAddress);

getDeployments

Returns all deployments for the given contract on chainId Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber. The most recent deployment is the first element, and the oldest is the last.

function getDeployments(string calldata contractName, uint64 chainId)
    external
    view
    returns (address[] memory deployedAddresses);

isDir

Returns true if the path exists on disk and is pointing at a directory, else returns false.

function isDir(string calldata path) external view returns (bool result);

isFile

Returns true if the path exists on disk and is pointing at a regular file, else returns false.

function isFile(string calldata path) external view returns (bool result);

projectRoot

Get the path of the current project root.

function projectRoot() external view returns (string memory path);

prompt

Prompts the user for a string value in the terminal.

function prompt(string calldata promptText) external returns (string memory input);

promptAddress

Prompts the user for an address in the terminal.

function promptAddress(string calldata promptText) external returns (address);

promptSecret

Prompts the user for a hidden string value in the terminal.

function promptSecret(string calldata promptText) external returns (string memory input);

promptSecretUint

Prompts the user for hidden uint256 in the terminal (usually pk).

function promptSecretUint(string calldata promptText) external returns (uint256);

promptUint

Prompts the user for uint256 in the terminal.

function promptUint(string calldata promptText) external returns (uint256);

readDir

Reads the directory at the given path recursively, up to maxDepth. maxDepth defaults to 1, meaning only the direct children of the given directory will be returned. Follows symbolic links if followLinks is true.

function readDir(string calldata path) external view returns (DirEntry[] memory entries);

readDir

See readDir(string).

function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);

readDir

See readDir(string).

function readDir(string calldata path, uint64 maxDepth, bool followLinks)
    external
    view
    returns (DirEntry[] memory entries);

readFile

Reads the entire content of file to string. path is relative to the project root.

function readFile(string calldata path) external view returns (string memory data);

readFileBinary

Reads the entire content of file as binary. path is relative to the project root.

function readFileBinary(string calldata path) external view returns (bytes memory data);

readLine

Reads next line of file to string.

function readLine(string calldata path) external view returns (string memory line);

readLink

Reads a symbolic link, returning the path that the link points to. This cheatcode will revert in the following situations, but is not limited to just these cases:

• path is not a symbolic link.
• path does not exist.

function readLink(string calldata linkPath) external view returns (string memory targetPath);

removeDir

Removes a directory at the provided path. This cheatcode will revert in the following situations, but is not limited to just these cases:

• path doesn't exist.
• path isn't a directory.
• User lacks permissions to modify path.
• The directory is not empty and recursive is false. path is relative to the project root.

function removeDir(string calldata path, bool recursive) external;

removeFile

Removes a file from the filesystem. This cheatcode will revert in the following situations, but is not limited to just these cases:

• path points to a directory.
• The file doesn't exist.
• The user lacks permissions to remove the file. path is relative to the project root.

function removeFile(string calldata path) external;

tryFfi

Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.

function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);

unixTime

Returns the time since unix epoch in milliseconds.

function unixTime() external view returns (uint256 milliseconds);

writeFile

Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does. path is relative to the project root.

function writeFile(string calldata path, string calldata data) external;

writeFileBinary

Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does. path is relative to the project root.

function writeFileBinary(string calldata path, bytes calldata data) external;

writeLine

Writes line to file, creating a file if it does not exist. path is relative to the project root.

function writeLine(string calldata path, string calldata data) external;

keyExistsJson

Checks if key exists in a JSON object.

function keyExistsJson(string calldata json, string calldata key) external view returns (bool);

parseJsonAddress

Parses a string of JSON data at key and coerces it to address.

function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);

parseJsonAddressArray

Parses a string of JSON data at key and coerces it to address[].

function parseJsonAddressArray(string calldata json, string calldata key) external pure returns (address[] memory);

parseJsonBool

Parses a string of JSON data at key and coerces it to bool.

function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);

parseJsonBoolArray

Parses a string of JSON data at key and coerces it to bool[].

function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);

parseJsonBytes

Parses a string of JSON data at key and coerces it to bytes.

function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);

parseJsonBytes32

Parses a string of JSON data at key and coerces it to bytes32.

function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);

parseJsonBytes32Array

Parses a string of JSON data at key and coerces it to bytes32[].

function parseJsonBytes32Array(string calldata json, string calldata key) external pure returns (bytes32[] memory);

parseJsonBytesArray

Parses a string of JSON data at key and coerces it to bytes[].

function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);

parseJsonInt

Parses a string of JSON data at key and coerces it to int256.

function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);

parseJsonIntArray

Parses a string of JSON data at key and coerces it to int256[].

function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);

parseJsonKeys

Returns an array of all the keys in a JSON object.

function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);

parseJsonString

Parses a string of JSON data at key and coerces it to string.

function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);

parseJsonStringArray

Parses a string of JSON data at key and coerces it to string[].

function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);

parseJsonTypeArray

Parses a string of JSON data at key and coerces it to type array corresponding to typeDescription.

function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)
    external
    pure
    returns (bytes memory);

parseJsonType

Parses a string of JSON data and coerces it to type corresponding to typeDescription.

function parseJsonType(string calldata json, string calldata typeDescription) external pure returns (bytes memory);

parseJsonType

Parses a string of JSON data at key and coerces it to type corresponding to typeDescription.

function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)
    external
    pure
    returns (bytes memory);

parseJsonUint

Parses a string of JSON data at key and coerces it to uint256.

function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);

parseJsonUintArray

Parses a string of JSON data at key and coerces it to uint256[].

function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);

parseJson

ABI-encodes a JSON object.

function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);

parseJson

ABI-encodes a JSON object at key.

function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);

serializeAddress

See serializeJson.

function serializeAddress(string calldata objectKey, string calldata valueKey, address value)
    external
    returns (string memory json);

serializeAddress

See serializeJson.

function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)
    external
    returns (string memory json);

serializeBool

See serializeJson.

function serializeBool(string calldata objectKey, string calldata valueKey, bool value)
    external
    returns (string memory json);

serializeBool

See serializeJson.

function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)
    external
    returns (string memory json);

serializeBytes32

See serializeJson.

function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)
    external
    returns (string memory json);

serializeBytes32

See serializeJson.

function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)
    external
    returns (string memory json);

serializeBytes

See serializeJson.

function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)
    external
    returns (string memory json);

serializeBytes

See serializeJson.

function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)
    external
    returns (string memory json);

serializeInt

See serializeJson.

function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)
    external
    returns (string memory json);

serializeInt

See serializeJson.

function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)
    external
    returns (string memory json);

serializeJson

Serializes a key and value to a JSON object stored in-memory that can be later written to a file. Returns the stringified version of the specific JSON file up to that moment.

function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);

serializeJsonType

See serializeJson.

function serializeJsonType(string calldata typeDescription, bytes calldata value)
    external
    pure
    returns (string memory json);

serializeJsonType

See serializeJson.

function serializeJsonType(
    string calldata objectKey,
    string calldata valueKey,
    string calldata typeDescription,
    bytes calldata value
) external returns (string memory json);

serializeString

See serializeJson.

function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)
    external
    returns (string memory json);

serializeString

See serializeJson.

function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)
    external
    returns (string memory json);

serializeUintToHex

See serializeJson.

function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)
    external
    returns (string memory json);

serializeUint

See serializeJson.

function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)
    external
    returns (string memory json);

serializeUint

See serializeJson.

function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)
    external
    returns (string memory json);

writeJson

Write a serialized JSON object to a file. If the file exists, it will be overwritten.

function writeJson(string calldata json, string calldata path) external;

writeJson

Write a serialized JSON object to an existing JSON file, replacing a value with key = <value_key.> This is useful to replace a specific value of a JSON file, without having to parse the entire thing.

function writeJson(string calldata json, string calldata path, string calldata valueKey) external;

keyExists

Checks if key exists in a JSON object keyExists is being deprecated in favor of keyExistsJson. It will be removed in future versions.

function keyExists(string calldata json, string calldata key) external view returns (bool);

attachBlob

Attach an EIP-4844 blob to the next call

function attachBlob(bytes calldata blob) external;

attachDelegation

Designate the next call as an EIP-7702 transaction

function attachDelegation(SignedDelegation calldata signedDelegation) external;

broadcastRawTransaction

Takes a signed transaction and broadcasts it to the network.

function broadcastRawTransaction(bytes calldata data) external;

broadcast

Has the next call (at this call depth only) create transactions that can later be signed and sent onchain. Broadcasting address is determined by checking the following in order:

1. If --sender argument was provided, that address is used.
2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when forge broadcast is invoked, that signer is used.
3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.

function broadcast() external;

broadcast

Has the next call (at this call depth only) create a transaction with the address provided as the sender that can later be signed and sent onchain.

function broadcast(address signer) external;

broadcast

Has the next call (at this call depth only) create a transaction with the private key provided as the sender that can later be signed and sent onchain.

function broadcast(uint256 privateKey) external;

getWallets

Returns addresses of available unlocked wallets in the script environment.

function getWallets() external returns (address[] memory wallets);

signAndAttachDelegation

Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction

function signAndAttachDelegation(address implementation, uint256 privateKey)
    external
    returns (SignedDelegation memory signedDelegation);

signAndAttachDelegation

Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction for specific nonce

function signAndAttachDelegation(address implementation, uint256 privateKey, uint64 nonce)
    external
    returns (SignedDelegation memory signedDelegation);

signDelegation

Sign an EIP-7702 authorization for delegation

function signDelegation(address implementation, uint256 privateKey)
    external
    returns (SignedDelegation memory signedDelegation);

signDelegation

Sign an EIP-7702 authorization for delegation for specific nonce

function signDelegation(address implementation, uint256 privateKey, uint64 nonce)
    external
    returns (SignedDelegation memory signedDelegation);

startBroadcast

Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain. Broadcasting address is determined by checking the following in order:

1. If --sender argument was provided, that address is used.
2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when forge broadcast is invoked, that signer is used.
3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.

function startBroadcast() external;

startBroadcast

Has all subsequent calls (at this call depth only) create transactions with the address provided that can later be signed and sent onchain.

function startBroadcast(address signer) external;

startBroadcast

Has all subsequent calls (at this call depth only) create transactions with the private key provided that can later be signed and sent onchain.

function startBroadcast(uint256 privateKey) external;

stopBroadcast

Stops collecting onchain transactions.

function stopBroadcast() external;

contains

Returns true if search is found in subject, false otherwise.

function contains(string calldata subject, string calldata search) external returns (bool result);

indexOf

Returns the index of the first occurrence of a key in an input string. Returns NOT_FOUND (i.e. type(uint256).max) if the key is not found. Returns 0 in case of an empty key.

function indexOf(string calldata input, string calldata key) external pure returns (uint256);

parseAddress

Parses the given string into an address.

function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);

parseBool

Parses the given string into a bool.

function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);

parseBytes

Parses the given string into bytes.

function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);

parseBytes32

Parses the given string into a bytes32.

function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);

parseInt

Parses the given string into a int256.

function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);

parseUint

Parses the given string into a uint256.

function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);

replace

Replaces occurrences of from in the given string with to.

function replace(string calldata input, string calldata from, string calldata to)
    external
    pure
    returns (string memory output);

split

Splits the given string into an array of strings divided by the delimiter.

function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);

toLowercase

Converts the given string value to Lowercase.

function toLowercase(string calldata input) external pure returns (string memory output);

toString

Converts the given value to a string.

function toString(address value) external pure returns (string memory stringifiedValue);

toString

Converts the given value to a string.

function toString(bytes calldata value) external pure returns (string memory stringifiedValue);

toString

Converts the given value to a string.

function toString(bytes32 value) external pure returns (string memory stringifiedValue);

toString

Converts the given value to a string.

function toString(bool value) external pure returns (string memory stringifiedValue);

toString

Converts the given value to a string.

function toString(uint256 value) external pure returns (string memory stringifiedValue);

toString

Converts the given value to a string.

function toString(int256 value) external pure returns (string memory stringifiedValue);

toUppercase

Converts the given string value to Uppercase.

function toUppercase(string calldata input) external pure returns (string memory output);

trim

Trims leading and trailing whitespace from the given string value.

function trim(string calldata input) external pure returns (string memory output);

assertApproxEqAbsDecimal

Compares two uint256 values. Expects difference to be less than or equal to maxDelta. Formats values with decimals in failure message.

function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;

assertApproxEqAbsDecimal

Compares two uint256 values. Expects difference to be less than or equal to maxDelta. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertApproxEqAbsDecimal(
    uint256 left,
    uint256 right,
    uint256 maxDelta,
    uint256 decimals,
    string calldata error
) external pure;

assertApproxEqAbsDecimal

Compares two int256 values. Expects difference to be less than or equal to maxDelta. Formats values with decimals in failure message.

function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;

assertApproxEqAbsDecimal

Compares two int256 values. Expects difference to be less than or equal to maxDelta. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string calldata error)
    external
    pure;

assertApproxEqAbs

Compares two uint256 values. Expects difference to be less than or equal to maxDelta.

function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;

assertApproxEqAbs

Compares two uint256 values. Expects difference to be less than or equal to maxDelta. Includes error message into revert string on failure.

function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;

assertApproxEqAbs

Compares two int256 values. Expects difference to be less than or equal to maxDelta.

function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;

assertApproxEqAbs

Compares two int256 values. Expects difference to be less than or equal to maxDelta. Includes error message into revert string on failure.

function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;

assertApproxEqRelDecimal

Compares two uint256 values. Expects relative difference in percents to be less than or equal to maxPercentDelta. maxPercentDelta is an 18 decimal fixed point number, where 1e18 == 100% Formats values with decimals in failure message.

function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)
    external
    pure;

assertApproxEqRelDecimal

Compares two uint256 values. Expects relative difference in percents to be less than or equal to maxPercentDelta. maxPercentDelta is an 18 decimal fixed point number, where 1e18 == 100% Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertApproxEqRelDecimal(
    uint256 left,
    uint256 right,
    uint256 maxPercentDelta,
    uint256 decimals,
    string calldata error
) external pure;

assertApproxEqRelDecimal

Compares two int256 values. Expects relative difference in percents to be less than or equal to maxPercentDelta. maxPercentDelta is an 18 decimal fixed point number, where 1e18 == 100% Formats values with decimals in failure message.

function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) external pure;

assertApproxEqRelDecimal

Compares two int256 values. Expects relative difference in percents to be less than or equal to maxPercentDelta. maxPercentDelta is an 18 decimal fixed point number, where 1e18 == 100% Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertApproxEqRelDecimal(
    int256 left,
    int256 right,
    uint256 maxPercentDelta,
    uint256 decimals,
    string calldata error
) external pure;

assertApproxEqRel

Compares two uint256 values. Expects relative difference in percents to be less than or equal to maxPercentDelta. maxPercentDelta is an 18 decimal fixed point number, where 1e18 == 100%

function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;

assertApproxEqRel

Compares two uint256 values. Expects relative difference in percents to be less than or equal to maxPercentDelta. maxPercentDelta is an 18 decimal fixed point number, where 1e18 == 100% Includes error message into revert string on failure.

function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error) external pure;

assertApproxEqRel

Compares two int256 values. Expects relative difference in percents to be less than or equal to maxPercentDelta. maxPercentDelta is an 18 decimal fixed point number, where 1e18 == 100%

function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;

assertApproxEqRel

Compares two int256 values. Expects relative difference in percents to be less than or equal to maxPercentDelta. maxPercentDelta is an 18 decimal fixed point number, where 1e18 == 100% Includes error message into revert string on failure.

function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error) external pure;

assertEqDecimal

Asserts that two uint256 values are equal, formatting them with decimals in failure message.

function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

assertEqDecimal

Asserts that two uint256 values are equal, formatting them with decimals in failure message. Includes error message into revert string on failure.

function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

assertEqDecimal

Asserts that two int256 values are equal, formatting them with decimals in failure message.

function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;

assertEqDecimal

Asserts that two int256 values are equal, formatting them with decimals in failure message. Includes error message into revert string on failure.

function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

assertEq

Asserts that two bool values are equal.

function assertEq(bool left, bool right) external pure;

assertEq

Asserts that two bool values are equal and includes error message into revert string on failure.

function assertEq(bool left, bool right, string calldata error) external pure;

assertEq

Asserts that two string values are equal.

function assertEq(string calldata left, string calldata right) external pure;

assertEq

Asserts that two string values are equal and includes error message into revert string on failure.

function assertEq(string calldata left, string calldata right, string calldata error) external pure;

assertEq

Asserts that two bytes values are equal.

function assertEq(bytes calldata left, bytes calldata right) external pure;

assertEq

Asserts that two bytes values are equal and includes error message into revert string on failure.

function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;

assertEq

Asserts that two arrays of bool values are equal.

function assertEq(bool[] calldata left, bool[] calldata right) external pure;

assertEq

Asserts that two arrays of bool values are equal and includes error message into revert string on failure.

function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;

assertEq

Asserts that two arrays of `uint256 values are equal.

function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;

assertEq

Asserts that two arrays of uint256 values are equal and includes error message into revert string on failure.

function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;

assertEq

Asserts that two arrays of int256 values are equal.

function assertEq(int256[] calldata left, int256[] calldata right) external pure;

assertEq

Asserts that two arrays of int256 values are equal and includes error message into revert string on failure.

function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;

assertEq

Asserts that two uint256 values are equal.

function assertEq(uint256 left, uint256 right) external pure;

assertEq

Asserts that two arrays of address values are equal.

function assertEq(address[] calldata left, address[] calldata right) external pure;

assertEq

Asserts that two arrays of address values are equal and includes error message into revert string on failure.

function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;

assertEq

Asserts that two arrays of bytes32 values are equal.

function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;

assertEq

Asserts that two arrays of bytes32 values are equal and includes error message into revert string on failure.

function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;

assertEq

Asserts that two arrays of string values are equal.

function assertEq(string[] calldata left, string[] calldata right) external pure;

assertEq

Asserts that two arrays of string values are equal and includes error message into revert string on failure.

function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;

assertEq

Asserts that two arrays of bytes values are equal.

function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;

assertEq

Asserts that two arrays of bytes values are equal and includes error message into revert string on failure.

function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;

assertEq

Asserts that two uint256 values are equal and includes error message into revert string on failure.

function assertEq(uint256 left, uint256 right, string calldata error) external pure;

assertEq

Asserts that two int256 values are equal.

function assertEq(int256 left, int256 right) external pure;

assertEq

Asserts that two int256 values are equal and includes error message into revert string on failure.

function assertEq(int256 left, int256 right, string calldata error) external pure;

assertEq

Asserts that two address values are equal.

function assertEq(address left, address right) external pure;

assertEq

Asserts that two address values are equal and includes error message into revert string on failure.

function assertEq(address left, address right, string calldata error) external pure;

assertEq

Asserts that two bytes32 values are equal.

function assertEq(bytes32 left, bytes32 right) external pure;

assertEq

Asserts that two bytes32 values are equal and includes error message into revert string on failure.

function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;

assertFalse

Asserts that the given condition is false.

function assertFalse(bool condition) external pure;

assertFalse

Asserts that the given condition is false and includes error message into revert string on failure.

function assertFalse(bool condition, string calldata error) external pure;

assertGeDecimal

Compares two uint256 values. Expects first value to be greater than or equal to second. Formats values with decimals in failure message.

function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

assertGeDecimal

Compares two uint256 values. Expects first value to be greater than or equal to second. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

assertGeDecimal

Compares two int256 values. Expects first value to be greater than or equal to second. Formats values with decimals in failure message.

function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;

assertGeDecimal

Compares two int256 values. Expects first value to be greater than or equal to second. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

assertGe

Compares two uint256 values. Expects first value to be greater than or equal to second.

function assertGe(uint256 left, uint256 right) external pure;

assertGe

Compares two uint256 values. Expects first value to be greater than or equal to second. Includes error message into revert string on failure.

function assertGe(uint256 left, uint256 right, string calldata error) external pure;

assertGe

Compares two int256 values. Expects first value to be greater than or equal to second.

function assertGe(int256 left, int256 right) external pure;

assertGe

Compares two int256 values. Expects first value to be greater than or equal to second. Includes error message into revert string on failure.

function assertGe(int256 left, int256 right, string calldata error) external pure;

assertGtDecimal

Compares two uint256 values. Expects first value to be greater than second. Formats values with decimals in failure message.

function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

assertGtDecimal

Compares two uint256 values. Expects first value to be greater than second. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

assertGtDecimal

Compares two int256 values. Expects first value to be greater than second. Formats values with decimals in failure message.

function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;

assertGtDecimal

Compares two int256 values. Expects first value to be greater than second. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

assertGt

Compares two uint256 values. Expects first value to be greater than second.

function assertGt(uint256 left, uint256 right) external pure;

assertGt

Compares two uint256 values. Expects first value to be greater than second. Includes error message into revert string on failure.

function assertGt(uint256 left, uint256 right, string calldata error) external pure;

assertGt

Compares two int256 values. Expects first value to be greater than second.

function assertGt(int256 left, int256 right) external pure;

assertGt

Compares two int256 values. Expects first value to be greater than second. Includes error message into revert string on failure.

function assertGt(int256 left, int256 right, string calldata error) external pure;

assertLeDecimal

Compares two uint256 values. Expects first value to be less than or equal to second. Formats values with decimals in failure message.

function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

assertLeDecimal

Compares two uint256 values. Expects first value to be less than or equal to second. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

assertLeDecimal

Compares two int256 values. Expects first value to be less than or equal to second. Formats values with decimals in failure message.

function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;

assertLeDecimal

Compares two int256 values. Expects first value to be less than or equal to second. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

assertLe

Compares two uint256 values. Expects first value to be less than or equal to second.

function assertLe(uint256 left, uint256 right) external pure;

assertLe

Compares two uint256 values. Expects first value to be less than or equal to second. Includes error message into revert string on failure.

function assertLe(uint256 left, uint256 right, string calldata error) external pure;

assertLe

Compares two int256 values. Expects first value to be less than or equal to second.

function assertLe(int256 left, int256 right) external pure;

assertLe

Compares two int256 values. Expects first value to be less than or equal to second. Includes error message into revert string on failure.

function assertLe(int256 left, int256 right, string calldata error) external pure;

assertLtDecimal

Compares two uint256 values. Expects first value to be less than second. Formats values with decimals in failure message.

function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

assertLtDecimal

Compares two uint256 values. Expects first value to be less than second. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

assertLtDecimal

Compares two int256 values. Expects first value to be less than second. Formats values with decimals in failure message.

function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;

assertLtDecimal

Compares two int256 values. Expects first value to be less than second. Formats values with decimals in failure message. Includes error message into revert string on failure.

function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

assertLt

Compares two uint256 values. Expects first value to be less than second.

function assertLt(uint256 left, uint256 right) external pure;

assertLt

Compares two uint256 values. Expects first value to be less than second. Includes error message into revert string on failure.

function assertLt(uint256 left, uint256 right, string calldata error) external pure;

assertLt

Compares two int256 values. Expects first value to be less than second.

function assertLt(int256 left, int256 right) external pure;

assertLt

Compares two int256 values. Expects first value to be less than second. Includes error message into revert string on failure.

function assertLt(int256 left, int256 right, string calldata error) external pure;

assertNotEqDecimal

Asserts that two uint256 values are not equal, formatting them with decimals in failure message.

function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

assertNotEqDecimal

Asserts that two uint256 values are not equal, formatting them with decimals in failure message. Includes error message into revert string on failure.

function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

assertNotEqDecimal

Asserts that two int256 values are not equal, formatting them with decimals in failure message.

function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;

assertNotEqDecimal

Asserts that two int256 values are not equal, formatting them with decimals in failure message. Includes error message into revert string on failure.

function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

assertNotEq

Asserts that two bool values are not equal.

function assertNotEq(bool left, bool right) external pure;

assertNotEq

Asserts that two bool values are not equal and includes error message into revert string on failure.

function assertNotEq(bool left, bool right, string calldata error) external pure;

assertNotEq

Asserts that two string values are not equal.

function assertNotEq(string calldata left, string calldata right) external pure;

assertNotEq

Asserts that two string values are not equal and includes error message into revert string on failure.

function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;

assertNotEq

Asserts that two bytes values are not equal.

function assertNotEq(bytes calldata left, bytes calldata right) external pure;

assertNotEq

Asserts that two bytes values are not equal and includes error message into revert string on failure.

function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;

assertNotEq

Asserts that two arrays of bool values are not equal.

function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;

assertNotEq

Asserts that two arrays of bool values are not equal and includes error message into revert string on failure.

function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;

assertNotEq

Asserts that two arrays of uint256 values are not equal.

function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;

assertNotEq

Asserts that two arrays of uint256 values are not equal and includes error message into revert string on failure.

function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;

assertNotEq

Asserts that two arrays of int256 values are not equal.

function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;

assertNotEq

Asserts that two arrays of int256 values are not equal and includes error message into revert string on failure.

function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;

assertNotEq

Asserts that two uint256 values are not equal.

function assertNotEq(uint256 left, uint256 right) external pure;

assertNotEq

Asserts that two arrays of address values are not equal.

function assertNotEq(address[] calldata left, address[] calldata right) external pure;

assertNotEq

Asserts that two arrays of address values are not equal and includes error message into revert string on failure.

function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;

assertNotEq

Asserts that two arrays of bytes32 values are not equal.

function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;

assertNotEq

Asserts that two arrays of bytes32 values are not equal and includes error message into revert string on failure.

function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;

assertNotEq

Asserts that two arrays of string values are not equal.

function assertNotEq(string[] calldata left, string[] calldata right) external pure;

assertNotEq

Asserts that two arrays of string values are not equal and includes error message into revert string on failure.

function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;

assertNotEq

Asserts that two arrays of bytes values are not equal.

function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;

assertNotEq

Asserts that two arrays of bytes values are not equal and includes error message into revert string on failure.

function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;

assertNotEq

Asserts that two uint256 values are not equal and includes error message into revert string on failure.

function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;

assertNotEq

Asserts that two int256 values are not equal.

function assertNotEq(int256 left, int256 right) external pure;

assertNotEq

Asserts that two int256 values are not equal and includes error message into revert string on failure.

function assertNotEq(int256 left, int256 right, string calldata error) external pure;

assertNotEq

Asserts that two address values are not equal.

function assertNotEq(address left, address right) external pure;

assertNotEq

Asserts that two address values are not equal and includes error message into revert string on failure.

function assertNotEq(address left, address right, string calldata error) external pure;

assertNotEq

Asserts that two bytes32 values are not equal.

function assertNotEq(bytes32 left, bytes32 right) external pure;

assertNotEq

Asserts that two bytes32 values are not equal and includes error message into revert string on failure.

function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;

assertTrue

Asserts that the given condition is true.

function assertTrue(bool condition) external pure;

assertTrue

Asserts that the given condition is true and includes error message into revert string on failure.

function assertTrue(bool condition, string calldata error) external pure;

assume

If the condition is false, discard this run's fuzz inputs and generate new ones.

function assume(bool condition) external pure;

assumeNoRevert

Discard this run's fuzz inputs and generate new ones if next call reverted.

function assumeNoRevert() external pure;

assumeNoRevert

Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.

function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;

assumeNoRevert

Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.

function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;

breakpoint

Writes a breakpoint to jump to in the debugger.

function breakpoint(string calldata char) external pure;

breakpoint

Writes a conditional breakpoint to jump to in the debugger.

function breakpoint(string calldata char, bool value) external pure;

foundryVersionAtLeast

Returns true if the current Foundry version is greater than or equal to the given version. The given version string must be in the format major.minor.patch. This is equivalent to foundryVersionCmp(version) >= 0.

function foundryVersionAtLeast(string calldata version) external view returns (bool);

foundryVersionCmp

Compares the current Foundry version with the given version string. The given version string must be in the format major.minor.patch. Returns: -1 if current Foundry version is less than the given version 0 if current Foundry version equals the given version 1 if current Foundry version is greater than the given version This result can then be used with a comparison operator against 0. For example, to check if the current Foundry version is greater than or equal to 1.0.0: if (foundryVersionCmp("1.0.0") >= 0) { ... }

function foundryVersionCmp(string calldata version) external view returns (int256);

getChain

Returns a Chain struct for specific alias

function getChain(string calldata chainAlias) external view returns (Chain memory chain);

getChain

Returns a Chain struct for specific chainId

function getChain(uint256 chainId) external view returns (Chain memory chain);

getFoundryVersion

Returns the Foundry version. Format: <cargo_version>-+<git_sha_short>.<unix_build_timestamp>. Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug Note: Build timestamps may vary slightly across platforms due to separate CI jobs. For reliable version comparisons, use UNIX format (e.g., >= 1700000000) to compare timestamps while ignoring minor time differences.

function getFoundryVersion() external view returns (string memory version);

rpcUrl

Returns the RPC url for the given alias.

function rpcUrl(string calldata rpcAlias) external view returns (string memory json);

rpcUrlStructs

Returns all rpc urls and their aliases as structs.

function rpcUrlStructs() external view returns (Rpc[] memory urls);

rpcUrls

Returns all rpc urls and their aliases [alias, url][].

function rpcUrls() external view returns (string[2][] memory urls);

sleep

Suspends execution of the main thread for duration milliseconds.

function sleep(uint256 duration) external;

keyExistsToml

Checks if key exists in a TOML table.

function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);

parseTomlAddress

Parses a string of TOML data at key and coerces it to address.

function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);

parseTomlAddressArray

Parses a string of TOML data at key and coerces it to address[].

function parseTomlAddressArray(string calldata toml, string calldata key) external pure returns (address[] memory);

parseTomlBool

Parses a string of TOML data at key and coerces it to bool.

function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);

parseTomlBoolArray

Parses a string of TOML data at key and coerces it to bool[].

function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);

parseTomlBytes

Parses a string of TOML data at key and coerces it to bytes.

function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);

parseTomlBytes32

Parses a string of TOML data at key and coerces it to bytes32.

function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);

parseTomlBytes32Array

Parses a string of TOML data at key and coerces it to bytes32[].

function parseTomlBytes32Array(string calldata toml, string calldata key) external pure returns (bytes32[] memory);

parseTomlBytesArray

Parses a string of TOML data at key and coerces it to bytes[].

function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);

parseTomlInt

Parses a string of TOML data at key and coerces it to int256.

function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);

parseTomlIntArray

Parses a string of TOML data at key and coerces it to int256[].

function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);

parseTomlKeys

Returns an array of all the keys in a TOML table.

function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);

parseTomlString

Parses a string of TOML data at key and coerces it to string.

function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);

parseTomlStringArray

Parses a string of TOML data at key and coerces it to string[].

function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);

parseTomlTypeArray

Parses a string of TOML data at key and coerces it to type array corresponding to typeDescription.

function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)
    external
    pure
    returns (bytes memory);

parseTomlType

Parses a string of TOML data and coerces it to type corresponding to typeDescription.

function parseTomlType(string calldata toml, string calldata typeDescription) external pure returns (bytes memory);

parseTomlType

Parses a string of TOML data at key and coerces it to type corresponding to typeDescription.

function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)
    external
    pure
    returns (bytes memory);

parseTomlUint

Parses a string of TOML data at key and coerces it to uint256.

function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);

parseTomlUintArray

Parses a string of TOML data at key and coerces it to uint256[].

function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);

parseToml

ABI-encodes a TOML table.

function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);

parseToml

ABI-encodes a TOML table at key.

function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);

writeToml

Takes serialized JSON, converts to TOML and write a serialized TOML to a file.

function writeToml(string calldata json, string calldata path) external;

writeToml

Takes serialized JSON, converts to TOML and write a serialized TOML table to an existing TOML file, replacing a value with key = <value_key.> This is useful to replace a specific value of a TOML file, without having to parse the entire thing.

function writeToml(string calldata json, string calldata path, string calldata valueKey) external;

computeCreate2Address

Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.

function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) external pure returns (address);

computeCreate2Address

Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.

function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);

computeCreateAddress

Compute the address a contract will be deployed at for a given deployer address and nonce.

function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);

copyStorage

Utility cheatcode to copy storage of from contract to another to contract.

function copyStorage(address from, address to) external;

ensNamehash

Returns ENS namehash for provided string.

function ensNamehash(string calldata name) external pure returns (bytes32);

getLabel

Gets the label for the specified address.

function getLabel(address account) external view returns (string memory currentLabel);

label

Labels an address in call traces.

function label(address account, string calldata newLabel) external;

pauseTracing

Pauses collection of call traces. Useful in cases when you want to skip tracing of complex calls which are not useful for debugging.

function pauseTracing() external view;

randomAddress

Returns a random address.

function randomAddress() external returns (address);

randomBool

Returns a random bool.

function randomBool() external view returns (bool);

randomBytes

Returns a random byte array value of the given length.

function randomBytes(uint256 len) external view returns (bytes memory);

randomBytes4

Returns a random fixed-size byte array of length 4.

function randomBytes4() external view returns (bytes4);

randomBytes8

Returns a random fixed-size byte array of length 8.

function randomBytes8() external view returns (bytes8);

randomInt

Returns a random int256 value.

function randomInt() external view returns (int256);

randomInt

Returns a random int256 value of given bits.

function randomInt(uint256 bits) external view returns (int256);

randomUint

Returns a random uint256 value.

function randomUint() external returns (uint256);

randomUint

Returns random uint256 value between the provided range (=min..=max).

function randomUint(uint256 min, uint256 max) external returns (uint256);

randomUint

Returns a random uint256 value of given bits.

function randomUint(uint256 bits) external view returns (uint256);

resumeTracing

Unpauses collection of call traces.

function resumeTracing() external view;

setArbitraryStorage

Utility cheatcode to set arbitrary storage for given target address.

function setArbitraryStorage(address target) external;

setArbitraryStorage

Utility cheatcode to set arbitrary storage for given target address and overwrite any storage slots that have been previously set.

function setArbitraryStorage(address target, bool overwrite) external;

shuffle

Randomly shuffles an array.

function shuffle(uint256[] calldata array) external returns (uint256[] memory);

sort

Sorts an array in ascending order.

function sort(uint256[] calldata array) external returns (uint256[] memory);

toBase64URL

Encodes a bytes value to a base64url string.

function toBase64URL(bytes calldata data) external pure returns (string memory);

toBase64URL

Encodes a string value to a base64url string.

function toBase64URL(string calldata data) external pure returns (string memory);

toBase64

Encodes a bytes value to a base64 string.

function toBase64(bytes calldata data) external pure returns (string memory);

toBase64

Encodes a string value to a base64 string.

function toBase64(string calldata data) external pure returns (string memory);

Structs

Log

An Ethereum log. Returned by getRecordedLogs.

struct Log {
    bytes32[] topics;
    bytes data;
    address emitter;
}

Rpc

An RPC URL and its alias. Returned by rpcUrlStructs.

struct Rpc {
    string key;
    string url;
}

EthGetLogs

An RPC log object. Returned by eth_getLogs.

struct EthGetLogs {
    address emitter;
    bytes32[] topics;
    bytes data;
    bytes32 blockHash;
    uint64 blockNumber;
    bytes32 transactionHash;
    uint64 transactionIndex;
    uint256 logIndex;
    bool removed;
}

DirEntry

A single entry in a directory listing. Returned by readDir.

struct DirEntry {
    string errorMessage;
    string path;
    uint64 depth;
    bool isDir;
    bool isSymlink;
}

FsMetadata

Metadata information about a file. This structure is returned from the fsMetadata function and represents known metadata about a file such as its permissions, size, modification times, etc.

struct FsMetadata {
    bool isDir;
    bool isSymlink;
    uint256 length;
    bool readOnly;
    uint256 modified;
    uint256 accessed;
    uint256 created;
}

Wallet

A wallet with a public and private key.

struct Wallet {
    address addr;
    uint256 publicKeyX;
    uint256 publicKeyY;
    uint256 privateKey;
}

FfiResult

The result of a tryFfi call.

struct FfiResult {
    int32 exitCode;
    bytes stdout;
    bytes stderr;
}

ChainInfo

Information on the chain and fork.

struct ChainInfo {
    uint256 forkId;
    uint256 chainId;
}

Chain

Information about a blockchain.

struct Chain {
    string name;
    uint256 chainId;
    string chainAlias;
    string rpcUrl;
}

AccountAccess

The result of a stopAndReturnStateDiff call.

struct AccountAccess {
    ChainInfo chainInfo;
    AccountAccessKind kind;
    address account;
    address accessor;
    bool initialized;
    uint256 oldBalance;
    uint256 newBalance;
    bytes deployedCode;
    uint256 value;
    bytes data;
    bool reverted;
    StorageAccess[] storageAccesses;
    uint64 depth;
}

StorageAccess

The storage accessed during an AccountAccess.

struct StorageAccess {
    address account;
    bytes32 slot;
    bool isWrite;
    bytes32 previousValue;
    bytes32 newValue;
    bool reverted;
}

Gas

Gas used. Returned by lastCallGas.

struct Gas {
    uint64 gasLimit;
    uint64 gasTotalUsed;
    uint64 gasMemoryUsed;
    int64 gasRefunded;
    uint64 gasRemaining;
}

DebugStep

The result of the stopDebugTraceRecording call

struct DebugStep {
    uint256[] stack;
    bytes memoryInput;
    uint8 opcode;
    uint64 depth;
    bool isOutOfGas;
    address contractAddr;
}

BroadcastTxSummary

Represents a transaction's broadcast details.

struct BroadcastTxSummary {
    bytes32 txHash;
    BroadcastTxType txType;
    address contractAddress;
    uint64 blockNumber;
    bool success;
}

SignedDelegation

Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.

struct SignedDelegation {
    uint8 v;
    bytes32 r;
    bytes32 s;
    uint64 nonce;
    address implementation;
}

PotentialRevert

Represents a "potential" revert reason from a single subsequent call when using vm.assumeNoReverts. Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced as normal.

struct PotentialRevert {
    address reverter;
    bool partialMatch;
    bytes revertData;
}

AccessListItem

An EIP-2930 access list item.

struct AccessListItem {
    address target;
    bytes32[] storageKeys;
}

Enums

CallerMode

A modification applied to either msg.sender or tx.origin. Returned by readCallers.

enum CallerMode {
    None,
    Broadcast,
    RecurrentBroadcast,
    Prank,
    RecurrentPrank
}

AccountAccessKind

The kind of account access that occurred.

enum AccountAccessKind {
    Call,
    DelegateCall,
    CallCode,
    StaticCall,
    Create,
    SelfDestruct,
    Resume,
    Balance,
    Extcodesize,
    Extcodehash,
    Extcodecopy
}

ForgeContext

Forge execution contexts.

enum ForgeContext {
    TestGroup,
    Test,
    Coverage,
    Snapshot,
    ScriptGroup,
    ScriptDryRun,
    ScriptBroadcast,
    ScriptResume,
    Unknown
}

BroadcastTxType

The transaction type (txType) of the broadcast.

enum BroadcastTxType {
    Call,
    Create,
    Create2
}

Vm

Inherits: VmSafe

The Vm interface does allow manipulation of the EVM state. These are all intended to be used in tests, but it is not recommended to use these cheats in scripts.

Functions

accessList

Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.

function accessList(AccessListItem[] calldata access) external;

activeFork

Returns the identifier of the currently active fork. Reverts if no fork is currently active.

function activeFork() external view returns (uint256 forkId);

allowCheatcodes

In forking mode, explicitly grant the given address cheatcode access.

function allowCheatcodes(address account) external;

blobBaseFee

Sets block.blobbasefee

function blobBaseFee(uint256 newBlobBaseFee) external;

blobhashes

Sets the blobhashes in the transaction. Not available on EVM versions before Cancun. If used on unsupported EVM versions it will revert.

function blobhashes(bytes32[] calldata hashes) external;

chainId

Sets block.chainid.

function chainId(uint256 newChainId) external;

clearMockedCalls

Clears all mocked calls.

function clearMockedCalls() external;

cloneAccount

Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.

function cloneAccount(address source, address target) external;

coinbase

Sets block.coinbase.

function coinbase(address newCoinbase) external;

cool

Marks the slots of an account and the account address as cold.

function cool(address target) external;

coolSlot

Utility cheatcode to mark specific storage slot as cold, simulating no prior read.

function coolSlot(address target, bytes32 slot) external;

createFork

Creates a new fork with the given endpoint and the latest block and returns the identifier of the fork.

function createFork(string calldata urlOrAlias) external returns (uint256 forkId);

createFork

Creates a new fork with the given endpoint and block and returns the identifier of the fork.

function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);

createFork

Creates a new fork with the given endpoint and at the block the given transaction was mined in, replays all transaction mined in the block before the transaction, and returns the identifier of the fork.

function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);

createSelectFork

Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.

function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);

createSelectFork

Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.

function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);

createSelectFork

Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in, replays all transaction mined in the block before the transaction, returns the identifier of the fork.

function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);

deal

Sets an address' balance.

function deal(address account, uint256 newBalance) external;

deleteStateSnapshot

Removes the snapshot with the given ID created by snapshot. Takes the snapshot ID to delete. Returns true if the snapshot was successfully deleted. Returns false if the snapshot does not exist.

function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);

deleteStateSnapshots

Removes all snapshots previously created by snapshot.

function deleteStateSnapshots() external;

difficulty

Sets block.difficulty. Not available on EVM versions from Paris onwards. Use prevrandao instead. Reverts if used on unsupported EVM versions.

function difficulty(uint256 newDifficulty) external;

dumpState

Dump a genesis JSON file's allocs to disk.

function dumpState(string calldata pathToStateJson) external;

etch

Sets an address' code.

function etch(address target, bytes calldata newRuntimeBytecode) external;

fee

Sets block.basefee.

function fee(uint256 newBasefee) external;

getBlobhashes

Gets the blockhashes from the current transaction. Not available on EVM versions before Cancun. If used on unsupported EVM versions it will revert.

function getBlobhashes() external view returns (bytes32[] memory hashes);

isPersistent

Returns true if the account is marked as persistent.

function isPersistent(address account) external view returns (bool persistent);

loadAllocs

Load a genesis JSON file's allocs into the in-memory EVM state.

function loadAllocs(string calldata pathToAllocsJson) external;

makePersistent

Marks that the account(s) should use persistent storage across fork swaps in a multifork setup Meaning, changes made to the state of this account will be kept when switching forks.

function makePersistent(address account) external;

makePersistent

See makePersistent(address).

function makePersistent(address account0, address account1) external;

makePersistent

See makePersistent(address).

function makePersistent(address account0, address account1, address account2) external;

makePersistent

See makePersistent(address).

function makePersistent(address[] calldata accounts) external;

mockCallRevert

Reverts a call to an address with specified revert data.

function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;

mockCallRevert

Reverts a call to an address with a specific msg.value, with specified revert data.

function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData) external;

mockCallRevert

Reverts a call to an address with specified revert data. Overload to pass the function selector directly token.approve.selector instead of abi.encodeWithSelector(token.approve.selector).

function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;

mockCallRevert

Reverts a call to an address with a specific msg.value, with specified revert data. Overload to pass the function selector directly token.approve.selector instead of abi.encodeWithSelector(token.approve.selector).

function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;

mockCall

Mocks a call to an address, returning specified data. Calldata can either be strict or a partial match, e.g. if you only pass a Solidity selector to the expected calldata, then the entire Solidity function will be mocked.

function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;

mockCall

Mocks a call to an address with a specific msg.value, returning specified data. Calldata match takes precedence over msg.value in case of ambiguity.

function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;

mockCall

Mocks a call to an address, returning specified data. Calldata can either be strict or a partial match, e.g. if you only pass a Solidity selector to the expected calldata, then the entire Solidity function will be mocked. Overload to pass the function selector directly token.approve.selector instead of abi.encodeWithSelector(token.approve.selector).

function mockCall(address callee, bytes4 data, bytes calldata returnData) external;

mockCall

Mocks a call to an address with a specific msg.value, returning specified data. Calldata match takes precedence over msg.value in case of ambiguity. Overload to pass the function selector directly token.approve.selector instead of abi.encodeWithSelector(token.approve.selector).

function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;

mockCalls

Mocks multiple calls to an address, returning specified data for each call.

function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;

mockCalls

Mocks multiple calls to an address with a specific msg.value, returning specified data for each call.

function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;

mockFunction

Whenever a call is made to callee with calldata data, this cheatcode instead calls target with the same calldata. This functionality is similar to a delegate call made to target contract from callee. Can be used to substitute a call to a function with another implementation that captures the primary logic of the original function but is easier to reason about. If calldata is not a strict match then partial match by selector is attempted.

function mockFunction(address callee, address target, bytes calldata data) external;

noAccessList

Utility cheatcode to remove any EIP-2930 access list set by accessList cheatcode.