pub struct Cheatcodes<FEN: FoundryEvmNetwork = EthEvmNetwork> {Show 75 fields
pub core: CheatcodesCore,
pub block: Option<BlockEnvFor<FEN>>,
pub fork_block_number_override: Option<u64>,
pub active_delegations: Vec<SignedAuthorization>,
pub active_blob_sidecar: Option<BlobTransactionSidecarVariant>,
pub gas_price: Option<u128>,
pub fee_token: Option<Address>,
pub origin_override: Option<Address>,
pending_origin_override: bool,
pending_gas_price: bool,
pending_emit_failure: Option<&'static str>,
pub state_epoch: u64,
pub fork_epoch: u64,
pub snapshot_restores: SnapshotRestores,
pub root_call_target: Option<Address>,
pub root_depth: usize,
pub tx_warm_addresses: Vec<Address>,
pub pranks: BTreeMap<usize, Prank>,
pub expected_revert: Option<ExpectedRevert>,
pub assume_no_revert: Option<AssumeNoRevert>,
pub fork_revert_diagnostic: Option<RevertDiagnostic>,
pub accesses: RecordAccess,
pub recording_accesses: bool,
pub recorded_account_diffs_stack: Option<Vec<Vec<AccountAccess>>>,
pending_account_diffs: Option<Arc<[AccountAccess]>>,
recorded_account_diffs_prefix: Option<Arc<[AccountAccess]>>,
created_accounts: Vec<Address>,
created_account_bindings: HashMap<(Option<LocalForkId>, Address), usize>,
created_account_changes: Vec<CreatedAccountChange>,
created_accounts_frames: Vec<CreatedAccountsFrame>,
created_accounts_snapshots: HashMap<U256, CreatedAccountsSnapshot>,
pub record_debug_steps_info: Option<RecordDebugStepInfo>,
pub expected_emits: VecDeque<(ExpectedEmit, AddressHashMap<LogCountMap>)>,
pub expected_creates: Vec<ExpectedCreate>,
pub allowed_mem_writes: HashMap<u64, Vec<Range<u64>>>,
pub broadcast: Option<Broadcast>,
pub broadcastable_transactions: BroadcastableTransactions<FEN::Network>,
pub extra_cheatcode_addresses: &'static [Address],
pub skip_payloads: Vec<Bytes>,
pub persistent_writes: Vec<(usize, usize, PersistentWrite)>,
pub frame_rollback: Option<(usize, usize)>,
pub persistent_write_snapshots: HashMap<U256, usize>,
pub failed_assertion: Option<String>,
pub failure_trace: Option<FailureTrace>,
pub failure_provenance: Option<FailureProvenance>,
pub gas_metering: GasMetering,
pub gas_snapshots: BTreeMap<String, BTreeMap<String, String>>,
pub pc: usize,
pub breakpoints: Breakpoints,
pub ignored_traces: IgnoredTraces,
storage_load_hooks: AddressHashMap<StorageHook>,
storage_store_hooks: AddressHashMap<StorageHook>,
mapping_storage_store_hooks: AddressHashMap<HashMap<B256, StorageHook>>,
storage_hook_mapping_slots: AddressHashMap<MappingSlots>,
pending_mapping_hash: Option<PendingMappingHash>,
storage_hooks_registered: bool,
pending_storage_hook: Option<PendingStorageHook>,
active_storage_hook: Option<ActiveStorageHook>,
pub deprecated: HashMap<&'static str, Option<&'static str>>,
pub script_address: Option<Address>,
signatures_identifier: OnceLock<Option<SignaturesIdentifier>>,
pub dynamic_gas_limit: bool,
pub execution_evm_version: Option<SpecFor<FEN>>,
pub env_overrides: EnvOverrideState,
pub fork_block_number_override_snapshots: HashMap<U256, Option<u64>>,
pub in_isolation_context: bool,
pub isolation_env: Option<EvmEnvFor<FEN>>,
pub in_replay: bool,
pub deploy_code_depth: Option<usize>,
pub deploy_code_create_state_gas: u64,
pub deploy_code_output: Option<(Bytes, bool)>,
pub applied_access_list: Option<AccessList>,
pub unrun_create_depth: Option<usize>,
pub env_handoff_creator: Option<Address>,
pub pending_create2_redirects: Vec<(u16, Option<Address>, bool)>,
}Expand description
An EVM inspector that handles calls to various cheatcodes, each with their own behavior.
Cheatcodes can be called by contracts during execution to modify the VM environment, such as mocking addresses, signatures and altering call reverts.
Executing cheatcodes can be very powerful. Most cheatcodes are limited to evm internals, but
there are also cheatcodes like ffi which can execute arbitrary commands or writeFile and
readFile which can manipulate files of the filesystem. Therefore, several restrictions are
implemented for these cheatcodes:
ffi, and file cheatcodes are always opt-in (via foundry config) and never enabled by default: all respective cheatcode handlers implement the appropriate checks- File cheatcodes require explicit permissions which paths are allowed for which operation, see
Config.fs_permission - Only permitted accounts are allowed to execute cheatcodes in forking mode, this ensures no contract deployed on the live network is able to execute cheatcodes by simply calling the cheatcode address: by default, the caller, test contract and newly deployed contracts are allowed to execute cheatcodes
Fields§
§core: CheatcodesCoreEngine-independent cheatcode state.
block: Option<BlockEnvFor<FEN>>The block environment
Used in the cheatcode handler to overwrite the block environment separately from the execution block environment.
fork_block_number_override: Option<u64>The active fork block override updated by a fork-switching cheatcode.
This persists fork changes made through a copy-on-write backend between invariant calls.
active_delegations: Vec<SignedAuthorization>Currently active EIP-7702 delegations that will be consumed when building the next
transaction. Set by vm.attachDelegation() and consumed via .take() during
transaction construction.
active_blob_sidecar: Option<BlobTransactionSidecarVariant>The active EIP-4844 blob that will be attached to the next call.
gas_price: Option<u128>The gas price.
Executions run fee-less, so the GASPRICE opcode reads this value instead, unless
vm.txGasPrice overrides it.
fee_token: Option<Address>The fee token of the executed transactions, recorded in broadcast requests.
origin_override: Option<Address>The tx.origin set by a prank or broadcast, which the ORIGIN opcode reads instead of
the transaction’s origin.
evm2 borrows the transaction environment for the whole transaction, so origin changes are applied at the opcode level.
pending_origin_override: boolWhether the executing ORIGIN opcode reads Self::origin_override.
pending_gas_price: boolWhether the executing GASPRICE opcode reads Self::gas_price.
pending_emit_failure: Option<&'static str>An expectEmit mismatch observed by the log hook, which reverts the emitting frame once
its LOG instruction finishes.
state_epoch: u64Incremented whenever a cheatcode replaces the running state outside of a snapshot restoration, such as a fork switch, so nested executions know to adopt the replaced state.
fork_epoch: u64Incremented whenever a cheatcode switches or rolls forks, bumped together with
state_epoch.
snapshot_restores: SnapshotRestoresRunning states replaced by snapshot restorations in the open frames of the running transaction, reinstated when a frame that was open at the restoration fails.
root_call_target: Option<Address>Target of the root call of the running transaction, if it is a call.
While an isolated call or create runs as a nested transaction, this is the target of that transaction instead.
root_depth: usizeCall depth of the running transaction’s top-level calls, set by the inspector stack when each one starts.
This is the EVM’s initial call depth, which is zero unless the transaction handler runs the calls below the transaction, such as Tempo’s for the calls of an AA transaction. Nested transactions, such as isolated calls and replays, keep the running transaction’s.
tx_warm_addresses: Vec<Address>The EIP-3651 coinbase and access-list addresses the running transaction warmed when it
started, which vm.cool keeps warm.
While an isolated call or create runs as a nested transaction, these are that transaction’s instead.
pranks: BTreeMap<usize, Prank>Prank information, mapped to the call depth where pranks were added.
expected_revert: Option<ExpectedRevert>Expected revert information
assume_no_revert: Option<AssumeNoRevert>Assume next call can revert and discard fuzz run if it does.
fork_revert_diagnostic: Option<RevertDiagnostic>Additional diagnostic for reverts
accesses: RecordAccessRecorded storage reads and writes
recording_accesses: boolWhether storage access recording is currently active
recorded_account_diffs_stack: Option<Vec<Vec<AccountAccess>>>Recorded account accesses (calls, creates) organized by relative call depth, where the topmost vector corresponds to accesses at the depth at which account access recording began. Each vector in the matrix represents a list of accesses at a specific call depth. Once that call context has ended, the last vector is removed from the matrix and merged into the previous vector.
pending_account_diffs: Option<Arc<[AccountAccess]>>Account accesses performed by the test runner before user code can start recording.
recorded_account_diffs_prefix: Option<Arc<[AccountAccess]>>Completed account accesses prepended to the active user recording session.
created_accounts: Vec<Address>Successfully created accounts in execution order.
created_account_bindings: HashMap<(Option<LocalForkId>, Address), usize>The creation currently represented by each address on each fork.
created_account_changes: Vec<CreatedAccountChange>Revertible changes to creation bindings made by EVM create frames.
created_accounts_frames: Vec<CreatedAccountsFrame>Creation-list and recorded-log checkpoints for frames observed by this inspector.
created_accounts_snapshots: HashMap<U256, CreatedAccountsSnapshot>Creation lists captured by state snapshots.
record_debug_steps_info: Option<RecordDebugStepInfo>The information of the debug step recording.
expected_emits: VecDeque<(ExpectedEmit, AddressHashMap<LogCountMap>)>Expected emits
expected_creates: Vec<ExpectedCreate>Expected creates
allowed_mem_writes: HashMap<u64, Vec<Range<u64>>>Map of context depths to memory offset ranges that may be written to within the call depth.
broadcast: Option<Broadcast>Current broadcasting information
broadcastable_transactions: BroadcastableTransactions<FEN::Network>Scripting based transactions
extra_cheatcode_addresses: &'static [Address]Additional addresses recognized as cheatcode contracts by this executor.
skip_payloads: Vec<Bytes>Revert payloads minted by the skip cheatcode during the current test call.
A top-level revert is only classified as a skip when its data byte-equals one of these
payloads, so user-crafted FOUNDRY::SKIP revert data never skips a test on its own.
persistent_writes: Vec<(usize, usize, PersistentWrite)>Writes that survive reverts of the enclosing calls, with the depth of the frame that made
them and the journal length right after them, replayed when that frame or an enclosing one
reverts and its rollback undid them. Writes accepted outside the journal have length zero,
see Self::record_accepted.
frame_rollback: Option<(usize, usize)>The depth of the frame that ended last and the journal length of its checkpoint, which a failure rolls the frame back to, recorded by the inspector stack.
persistent_write_snapshots: HashMap<U256, usize>The number of persistent writes recorded when each snapshot of the running transaction was taken, capped by the restorations that dropped some of them since.
failed_assertion: Option<String>Message of the first vm.assert* cheatcode that failed during the current call.
Unlike the global failure slot, this survives reverts, so callers still see the failure when the asserting call reverts afterwards.
failure_trace: Option<FailureTrace>Records failures by call site while set, so minimizers can tell failures apart.
failure_provenance: Option<FailureProvenance>Records where each call failed while set, so a replay can check it failed the same way.
gas_metering: GasMeteringGas metering state.
gas_snapshots: BTreeMap<String, BTreeMap<String, String>>Contains gas snapshots made over the course of a test suite.
pc: usizeThe current program counter.
breakpoints: BreakpointsBreakpoints supplied by the breakpoint cheatcode.
char -> (address, pc)
ignored_traces: IgnoredTracesIgnored traces.
storage_load_hooks: AddressHashMap<StorageHook>SLOAD callbacks keyed by effective storage address.
storage_store_hooks: AddressHashMap<StorageHook>SSTORE callbacks keyed by effective storage address.
mapping_storage_store_hooks: AddressHashMap<HashMap<B256, StorageHook>>Mapping SSTORE callbacks keyed by effective storage address and root slot.
storage_hook_mapping_slots: AddressHashMap<MappingSlots>Execution-local provenance used only by mapping storage hooks.
pending_mapping_hash: Option<PendingMappingHash>A 64-byte Keccak operation awaiting successful completion.
storage_hooks_registered: boolWhether any storage hook map contains a callback.
pending_storage_hook: Option<PendingStorageHook>Matching storage access captured before the opcode executes.
active_storage_hook: Option<ActiveStorageHook>Synthetic callback frame currently executing.
deprecated: HashMap<&'static str, Option<&'static str>>Deprecated cheatcodes mapped to the reason. Used to report warnings on test results.
script_address: Option<Address>Main script contract, when script execution protection is enabled.
signatures_identifier: OnceLock<Option<SignaturesIdentifier>>Signatures identifier for decoding events and functions
dynamic_gas_limit: boolUsed to determine whether the broadcasted call has dynamic gas limit.
execution_evm_version: Option<SpecFor<FEN>>§env_overrides: EnvOverrideStatePer-fork opcode environment overrides and their state-snapshot copies.
fork_block_number_override_snapshots: HashMap<U256, Option<u64>>Per-state-snapshot copies of Self::fork_block_number_override.
in_isolation_context: boolWhether we are currently executing inside an isolation context, i.e. the nested
transaction an isolated call (--isolate, --gas-report) executes as.
Cheatcodes that mutate the tx/block env consult this flag and route the change through
EnvOverrides instead of the actual env when true, so they don’t fight with the
fee-accounting zeroing.
isolation_env: Option<EvmEnvFor<FEN>>Environment of the transaction an isolated call runs in, while it runs.
The isolated call’s own nested transaction pays no fees; transactions that cheatcodes execute inside it start from this environment instead.
in_replay: boolWhether a replay is running whose fork-context changes cannot be merged into its parent.
deploy_code_depth: Option<usize>Depth of the in-flight deployCode call, whose create frame runs one level deeper.
deploy_code_create_state_gas: u64Account-creation state gas the in-flight deployCode call already charged its caller for
its create frame.
deploy_code_output: Option<(Bytes, bool)>Output the in-flight deployCode call’s constructor returned, which the EVM drops if
depositing it fails, and whether the constructor ran in an isolated call.
applied_access_list: Option<AccessList>The vm.accessList the running transaction last applied to a call or create. It replaces
the transaction’s access list when computing its stipend.
unrun_create_depth: Option<usize>Depth of a create that a hook ended with a revert without running its frame.
env_handoff_creator: Option<Address>Code that issued the CREATE being handed off to a new frame EVM.
pending_create2_redirects: Vec<(u16, Option<Address>, bool)>Automatic CREATE2 redirects: factory call depth, original issuing code, and whether the original create grants cheatcode access. The grant is resolved after caller overrides.
Implementations§
Source§impl<FEN: FoundryEvmNetwork> Cheatcodes<FEN>
impl<FEN: FoundryEvmNetwork> Cheatcodes<FEN>
Sourcepub fn new(config: Arc<CheatsConfig>) -> Self
pub fn new(config: Arc<CheatsConfig>) -> Self
Creates a new Cheatcodes with the given settings.
Sourcepub const fn set_extra_cheatcode_addresses(
&mut self,
addresses: &'static [Address],
)
pub const fn set_extra_cheatcode_addresses( &mut self, addresses: &'static [Address], )
Sets additional addresses recognized as cheatcode contracts.
Sourcepub fn start_internal_state_diff_recording(&mut self) -> bool
pub fn start_internal_state_diff_recording(&mut self) -> bool
Starts an internal account diff recording session for test runner setup.
Sourcepub fn stop_internal_state_diff_recording(&mut self) -> Vec<AccountAccess>
pub fn stop_internal_state_diff_recording(&mut self) -> Vec<AccountAccess>
Stops an internal account diff recording session without leaving recording enabled.
Sourcepub fn set_pending_account_diffs(&mut self, accesses: Vec<AccountAccess>)
pub fn set_pending_account_diffs(&mut self, accesses: Vec<AccountAccess>)
Makes account accesses captured by the test runner available to the next recording session.
Sourcepub fn start_state_diff_recording(&mut self)
pub fn start_state_diff_recording(&mut self)
Starts a user account diff recording session, including pending test runner accesses.
Sourcepub fn recorded_account_diffs(&self) -> impl Iterator<Item = &AccountAccess>
pub fn recorded_account_diffs(&self) -> impl Iterator<Item = &AccountAccess>
Returns completed and active account accesses in execution order.
Sourcepub(crate) fn recorded_account_diffs_with_boundaries(
&self,
) -> impl Iterator<Item = Option<&AccountAccess>>
pub(crate) fn recorded_account_diffs_with_boundaries( &self, ) -> impl Iterator<Item = Option<&AccountAccess>>
Returns account accesses with a None boundary between completed runner accesses and the
active recording. Call frames must not be inherited across this boundary.
Sourcepub fn take_recorded_account_diffs_prefix(&mut self) -> Vec<AccountAccess>
pub fn take_recorded_account_diffs_prefix(&mut self) -> Vec<AccountAccess>
Takes completed account accesses from the active user recording session.
Sourcepub(crate) fn created_account_bindings(
&self,
fork_id: Option<LocalForkId>,
) -> AddressHashMap<usize>
pub(crate) fn created_account_bindings( &self, fork_id: Option<LocalForkId>, ) -> AddressHashMap<usize>
Returns the current creation bound to each address on the given fork.
Sourcepub(crate) fn created_accounts(
&self,
fork_id: Option<LocalForkId>,
) -> Vec<Address>
pub(crate) fn created_accounts( &self, fork_id: Option<LocalForkId>, ) -> Vec<Address>
Returns successfully created accounts bound to the given fork in creation order.
Sourcepub(crate) fn record_created_account(
&mut self,
fork_id: Option<LocalForkId>,
address: Address,
)
pub(crate) fn record_created_account( &mut self, fork_id: Option<LocalForkId>, address: Address, )
Records a successfully created account.
Sourcepub(crate) fn commit_created_account_changes(
&mut self,
fork_id: Option<LocalForkId>,
)
pub(crate) fn commit_created_account_changes( &mut self, fork_id: Option<LocalForkId>, )
Keeps creation bindings saved with an outgoing fork across later frame reverts.
Sourcepub(crate) fn record_initial_created_accounts(
&mut self,
fork_id: Option<LocalForkId>,
accounts: impl IntoIterator<Item = (Address, usize)>,
)
pub(crate) fn record_initial_created_accounts( &mut self, fork_id: Option<LocalForkId>, accounts: impl IntoIterator<Item = (Address, usize)>, )
Records shared pre-fork creations on a newly selected fork without replacing local ones.
Sourcepub(crate) fn record_propagated_accounts(
&mut self,
fork_id: Option<LocalForkId>,
accounts: impl IntoIterator<Item = (Address, usize)>,
)
pub(crate) fn record_propagated_accounts( &mut self, fork_id: Option<LocalForkId>, accounts: impl IntoIterator<Item = (Address, usize)>, )
Records creations propagated to a fork with persistent account state.
Sourcepub(crate) fn snapshot_created_accounts(
&mut self,
snapshot_id: U256,
fork_id: Option<LocalForkId>,
)
pub(crate) fn snapshot_created_accounts( &mut self, snapshot_id: U256, fork_id: Option<LocalForkId>, )
Captures creation ordering alongside a state snapshot.
Sourcepub(crate) fn revert_created_accounts(
&mut self,
snapshot_id: U256,
remove: bool,
)
pub(crate) fn revert_created_accounts( &mut self, snapshot_id: U256, remove: bool, )
Restores creation ordering from a state snapshot.
Sourcepub(crate) fn delete_created_accounts_snapshot(&mut self, snapshot_id: U256)
pub(crate) fn delete_created_accounts_snapshot(&mut self, snapshot_id: U256)
Deletes one captured creation-order snapshot.
Sourcepub(crate) fn clear_created_accounts_snapshots(&mut self)
pub(crate) fn clear_created_accounts_snapshots(&mut self)
Deletes all captured creation-order snapshots.
fn start_created_accounts_frame( &mut self, reset: bool, kind: CreatedAccountsFrameKind, depth: usize, )
fn finish_created_accounts_frame( &mut self, success: bool, kind: CreatedAccountsFrameKind, depth: usize, )
Sourcepub fn get_prank(&self, depth: usize) -> Option<&Prank>
pub fn get_prank(&self, depth: usize) -> Option<&Prank>
Returns the configured prank at given depth or the first prank configured at a lower depth. For example, if pranks configured for depth 1, 3 and 5, the prank for depth 4 is the one configured at depth 3.
Sourcepub fn add_delegation(&mut self, authorization: SignedAuthorization)
pub fn add_delegation(&mut self, authorization: SignedAuthorization)
Adds a delegation to the active delegations list.
Sourcepub fn signatures_identifier(&self) -> Option<&SignaturesIdentifier>
pub fn signatures_identifier(&self) -> Option<&SignaturesIdentifier>
Returns the signatures identifier.
Sourcefn apply_cheatcode(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
message: &MessageFor<FEN>,
backend: &mut dyn CheatcodesBackend<FEN>,
gas: &mut GasTracker,
executor: &mut dyn CheatcodesExecutor<FEN>,
) -> Result
fn apply_cheatcode( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, message: &MessageFor<FEN>, backend: &mut dyn CheatcodesBackend<FEN>, gas: &mut GasTracker, executor: &mut dyn CheatcodesExecutor<FEN>, ) -> Result
Decodes the input data and applies the cheatcode.
Sourcefn apply_monad_cheatcode(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
message: &MessageFor<FEN>,
backend: &mut dyn CheatcodesBackend<FEN>,
gas: &mut GasTracker,
) -> Result
Available on crate feature monad only.
fn apply_monad_cheatcode( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, message: &MessageFor<FEN>, backend: &mut dyn CheatcodesBackend<FEN>, gas: &mut GasTracker, ) -> Result
monad only.Decodes the input data and applies Monad-specific cheatcodes.
Sourcefn allow_cheatcodes_on_create(
&self,
backend: &mut dyn CheatcodesBackend<FEN>,
depth: usize,
caller: Address,
created_address: Address,
creator: Option<Address>,
)
fn allow_cheatcodes_on_create( &self, backend: &mut dyn CheatcodesBackend<FEN>, depth: usize, caller: Address, created_address: Address, creator: Option<Address>, )
Grants cheatcode access for top-level deployments or authorized callers, provided the code issuing the CREATE also has access while forked.
Constructors need access before the new contract’s runtime code has been deployed.
Sourcefn deploy_code_caller_depth(&self, depth: usize) -> usize
fn deploy_code_caller_depth(&self, depth: usize) -> usize
Maps the depth of the synthetic deployCode create frame, which runs in a nested EVM one
level deeper, to the depth of the cheatcode call, where a native create would run.
Sourcepub(crate) fn set_origin(&mut self, tx_origin: Address, origin: Address)
pub(crate) fn set_origin(&mut self, tx_origin: Address, origin: Address)
Sets the tx.origin the ORIGIN opcode reads, given the transaction’s own origin.
Sourcefn apply_access_list(&mut self, interp: &mut InterpreterFor<'_, '_, FEN>)
fn apply_access_list(&mut self, interp: &mut InterpreterFor<'_, '_, FEN>)
Applies the configured vm.accessList to the running transaction on every call and
create. Access lists do not exist before Berlin, and nested transactions, such as
isolated calls, keep their own.
Sourcepub fn call_with_executor(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
call: &mut MessageFor<FEN>,
backend: &mut dyn CheatcodesBackend<FEN>,
executor: &mut dyn CheatcodesExecutor<FEN>,
isolate_call: bool,
) -> Option<MessageResultFor<FEN>>
pub fn call_with_executor( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, call: &mut MessageFor<FEN>, backend: &mut dyn CheatcodesBackend<FEN>, executor: &mut dyn CheatcodesExecutor<FEN>, isolate_call: bool, ) -> Option<MessageResultFor<FEN>>
Handles a call, accounting for whether the executor will isolate it as a transaction.
If isolate_call is true, the executor owns the transaction nonce increment when the call
proceeds to execution.
Sourcepub fn arbitrary_storage_targets(&self) -> impl Iterator<Item = Address> + '_
pub fn arbitrary_storage_targets(&self) -> impl Iterator<Item = Address> + '_
Returns addresses explicitly marked with arbitrary storage.
Sourcepub fn arbitrary_storage_target_overwrite_modes(
&self,
) -> impl Iterator<Item = (Address, bool)> + '_
pub fn arbitrary_storage_target_overwrite_modes( &self, ) -> impl Iterator<Item = (Address, bool)> + '_
Returns addresses explicitly marked with arbitrary storage and whether nonzero slots are overwritten.
Sourcepub fn arbitrary_storage_copied_targets(
&self,
) -> impl Iterator<Item = Address> + '_
pub fn arbitrary_storage_copied_targets( &self, ) -> impl Iterator<Item = Address> + '_
Returns addresses that copy storage from arbitrary-storage targets.
Sourcepub fn arbitrary_storage_copied_target_sources(
&self,
) -> impl Iterator<Item = (Address, Address)> + '_
pub fn arbitrary_storage_copied_target_sources( &self, ) -> impl Iterator<Item = (Address, Address)> + '_
Returns copied arbitrary-storage targets and their source address.
Sourcepub fn set_arbitrary_storage_replay_value(
&mut self,
address: Address,
slot: U256,
value: U256,
)
pub fn set_arbitrary_storage_replay_value( &mut self, address: Address, slot: U256, value: U256, )
Sets the value that arbitrary storage draws for a slot instead of a random one, so a replay reproduces a symbolic counterexample. Slots that are never drawn keep their value.
Sourcepub(crate) fn draw_arbitrary_storage_value(
&mut self,
address: Address,
slot: U256,
) -> U256
pub(crate) fn draw_arbitrary_storage_value( &mut self, address: Address, slot: U256, ) -> U256
Draws a value for a slot of an arbitrary-storage address or copied target: its replay value, or a random one.
Sourcepub fn mark_arbitrary_storage_slot_explicit(
&mut self,
address: Address,
slot: U256,
)
pub fn mark_arbitrary_storage_slot_explicit( &mut self, address: Address, slot: U256, )
Marks a slot as explicitly written with vm.store.
Sourcepub fn is_arbitrary_storage_slot_explicit(
&self,
address: Address,
slot: U256,
) -> bool
pub fn is_arbitrary_storage_slot_explicit( &self, address: Address, slot: U256, ) -> bool
Returns whether a slot was explicitly written with vm.store.
Sourcepub fn cached_arbitrary_storage_value(
&self,
address: Address,
slot: U256,
) -> Option<U256>
pub fn cached_arbitrary_storage_value( &self, address: Address, slot: U256, ) -> Option<U256>
Returns the value arbitrary storage generated for a slot of an arbitrary-storage address.
Sourcepub fn has_arbitrary_storage(&self, address: &Address) -> bool
pub fn has_arbitrary_storage(&self, address: &Address) -> bool
Whether the given address has arbitrary storage.
Sourcepub fn should_overwrite_arbitrary_storage(
&self,
address: &Address,
storage_slot: U256,
) -> bool
pub fn should_overwrite_arbitrary_storage( &self, address: &Address, storage_slot: U256, ) -> bool
Whether the given slot of address with arbitrary storage should be overwritten. True if address is marked as and overwrite and if no value was previously generated for given slot.
Sourcepub fn is_arbitrary_storage_copy(&self, address: &Address) -> bool
pub fn is_arbitrary_storage_copy(&self, address: &Address) -> bool
Whether the given address is a copy of an address with arbitrary storage.
Sourcepub fn register_storage_load_hook(
&mut self,
target: Address,
callback_target: Address,
callback_selector: [u8; 4],
)
pub fn register_storage_load_hook( &mut self, target: Address, callback_target: Address, callback_selector: [u8; 4], )
Registers an SLOAD callback, replacing the existing callback for target.
Sourcepub fn register_storage_store_hook(
&mut self,
target: Address,
callback_target: Address,
callback_selector: [u8; 4],
)
pub fn register_storage_store_hook( &mut self, target: Address, callback_target: Address, callback_selector: [u8; 4], )
Registers an SSTORE callback, replacing the existing callback for target.
Sourcepub fn register_mapping_storage_store_hook(
&mut self,
target: Address,
root_slot: B256,
callback_target: Address,
callback_selector: [u8; 4],
) -> bool
pub fn register_mapping_storage_store_hook( &mut self, target: Address, root_slot: B256, callback_target: Address, callback_selector: [u8; 4], ) -> bool
Registers a mapping SSTORE callback. Returns false when a raw hook conflicts.
Sourcepub fn mapping_storage_store_hooks(
&self,
) -> impl Iterator<Item = (Address, B256, StorageHook)> + '_
pub fn mapping_storage_store_hooks( &self, ) -> impl Iterator<Item = (Address, B256, StorageHook)> + '_
Returns registered mapping SSTORE callbacks.
Sourcepub fn has_mapping_storage_store_hooks(&self, target: Address) -> bool
pub fn has_mapping_storage_store_hooks(&self, target: Address) -> bool
Returns whether mapping hooks conflict with a raw store hook.
Sourcepub fn storage_load_hooks(
&self,
) -> impl Iterator<Item = (Address, StorageHook)> + '_
pub fn storage_load_hooks( &self, ) -> impl Iterator<Item = (Address, StorageHook)> + '_
Returns registered SLOAD callbacks.
Sourcepub fn storage_store_hooks(
&self,
) -> impl Iterator<Item = (Address, StorageHook)> + '_
pub fn storage_store_hooks( &self, ) -> impl Iterator<Item = (Address, StorageHook)> + '_
Returns registered SSTORE callbacks.
Sourcepub const fn has_storage_hooks(&self) -> bool
pub const fn has_storage_hooks(&self) -> bool
Returns whether any storage callback is registered.
Sourcepub fn clear_storage_hook_mapping_slots(&mut self)
pub fn clear_storage_hook_mapping_slots(&mut self)
Clears execution-local mapping provenance while preserving hook registrations.
Sourcepub const fn is_storage_hook_active(&self) -> bool
pub const fn is_storage_hook_active(&self) -> bool
Returns whether a synthetic storage-hook callback or one of its child calls is executing.
Sourcepub fn is_storage_hook_callback(&self, call: &MessageFor<FEN>) -> bool
pub fn is_storage_hook_callback(&self, call: &MessageFor<FEN>) -> bool
Returns whether call is the synthetic callback for the active storage hook.
Sourcepub fn steps(&self) -> OpcodeSet
pub fn steps(&self) -> OpcodeSet
Returns the opcodes the cheatcodes step: those of Self::hook_steps, and JUMPI while
failure provenance is collected.
This is the only place that decides which instructions the cheatcodes step: the inspector asks the EVM for these opcodes, and skips the hooks for every other instruction.
Sourcepub fn hook_steps(&self) -> OpcodeSet
pub fn hook_steps(&self) -> OpcodeSet
Returns the opcodes at which Self::step_hook and Self::step_end_hook must run. The
other opcodes of Self::steps only need Self::record_branch.
Sourcepub fn record_branch(&mut self, interp: &InterpreterFor<'_, '_, FEN>)
pub fn record_branch(&mut self, interp: &InterpreterFor<'_, '_, FEN>)
Records the JUMPI about to execute for the failure provenance, as Self::step_hook
does. Fuzz campaigns step every JUMPI only for this, so it skips the other hooks.
pub fn has_log_hooks(&self) -> bool
const fn has_active_env_overrides(&self) -> bool
Sourcepub fn initialize_interp_hook(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
)
pub fn initialize_interp_hook( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, )
Called after a frame interpreter has been initialized.
Sourcepub fn step_hook(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
backend: &mut dyn CheatcodesBackend<FEN>,
)
pub fn step_hook( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, backend: &mut dyn CheatcodesBackend<FEN>, )
Called before each instruction in Self::steps executes.
Kept out of line: it runs only while a cheatcode needs per-instruction work, and inlining it into the inspector’s per-instruction hook enlarges that hook’s frame for every opcode.
Sourcepub fn step_end_hook(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
backend: &mut dyn CheatcodesBackend<FEN>,
executor: &mut dyn CheatcodesExecutor<FEN>,
)
pub fn step_end_hook( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, backend: &mut dyn CheatcodesBackend<FEN>, executor: &mut dyn CheatcodesExecutor<FEN>, )
Called after each instruction in Self::steps executes.
Kept out of line for the same reason as Self::step_hook.
Sourcepub fn record_persistent(
&mut self,
depth: usize,
state: &State<'_>,
writes: impl IntoIterator<Item = PersistentWrite>,
)
pub fn record_persistent( &mut self, depth: usize, state: &State<'_>, writes: impl IntoIterator<Item = PersistentWrite>, )
Records writes the frame at depth just made to state, see
Self::persistent_writes.
Sourcepub fn record_accepted(
&mut self,
depth: usize,
writes: impl IntoIterator<Item = PersistentWrite>,
)
pub fn record_accepted( &mut self, depth: usize, writes: impl IntoIterator<Item = PersistentWrite>, )
Records writes the frame at depth just accepted into the running state outside the
journal, at journal length zero: no rollback undoes them, so only a failing frame that
reinstates the state a snapshot restoration replaced replays them.
Sourcepub(crate) fn restore_persistent_writes(
&mut self,
snapshot_id: U256,
replaced: StateSnapshot,
remove: bool,
switched: bool,
)
pub(crate) fn restore_persistent_writes( &mut self, snapshot_id: U256, replaced: StateSnapshot, remove: bool, switched: bool, )
Retains replaced, the running state a revert to snapshot_id replaced, and drops the
persistent writes recorded since the snapshot, which the restored state does not hold.
switched is whether the revert switched to another fork.
Sourcefn replay_persistent_writes(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
depth: usize,
success: bool,
)
fn replay_persistent_writes( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, depth: usize, success: bool, )
Replays the persistent writes made in the frame at depth or deeper after the frame
failed and the writes were rolled back, as writes of the enclosing frame. A transaction’s
writes are dropped when its root frame ends, and a failed root frame does not replay the
writes its rollback undid; a nested one merges its changes itself.
Sourcepub fn call_end_hook(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
call: &MessageFor<FEN>,
outcome: &mut MessageResultFor<FEN>,
backend: &mut dyn CheatcodesBackend<FEN>,
)
pub fn call_end_hook( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, call: &MessageFor<FEN>, outcome: &mut MessageResultFor<FEN>, backend: &mut dyn CheatcodesBackend<FEN>, )
Called after a call message executes.
Sourcepub fn create_hook(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
input: &mut MessageFor<FEN>,
backend: &mut dyn CheatcodesBackend<FEN>,
) -> Option<MessageResultFor<FEN>>
pub fn create_hook( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, input: &mut MessageFor<FEN>, backend: &mut dyn CheatcodesBackend<FEN>, ) -> Option<MessageResultFor<FEN>>
Called before a create message executes.
Sourcepub fn create_end_hook(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
call: &MessageFor<FEN>,
outcome: &mut MessageResultFor<FEN>,
_backend: &mut dyn CheatcodesBackend<FEN>,
)
pub fn create_end_hook( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, call: &MessageFor<FEN>, outcome: &mut MessageResultFor<FEN>, _backend: &mut dyn CheatcodesBackend<FEN>, )
Called after a create message executes.
Sourcepub fn should_use_create2_factory(
&mut self,
depth: usize,
message: &MessageFor<FEN>,
) -> bool
pub fn should_use_create2_factory( &mut self, depth: usize, message: &MessageFor<FEN>, ) -> bool
Determines whether the DEFAULT_CREATE2_DEPLOYER should be used for a CREATE message at
depth.
Sourcepub fn create2_deployer(&self) -> Address
pub fn create2_deployer(&self) -> Address
Returns the CREATE2 deployer address.
Sourcepub fn start_create2_redirect(
&mut self,
interp: &InterpreterFor<'_, '_, FEN>,
message: &MessageFor<FEN>,
)
pub fn start_create2_redirect( &mut self, interp: &InterpreterFor<'_, '_, FEN>, message: &MessageFor<FEN>, )
Preserves the original CREATE authorization before redirecting it to the factory.
fn take_create_creator( &mut self, interp: &InterpreterFor<'_, '_, FEN>, input: &MessageFor<FEN>, ) -> Option<Address>
fn can_grant_cheatcodes_on_create( backend: &dyn CheatcodesBackend<FEN>, depth: usize, caller: Address, creator: Option<Address>, ) -> bool
fn meter_gas(&mut self, interp: &mut InterpreterFor<'_, '_, FEN>)
fn meter_gas_record( &mut self, interp: &InterpreterFor<'_, '_, FEN>, curr_depth: usize, )
fn meter_gas_end(&mut self, interp: &InterpreterFor<'_, '_, FEN>)
const fn meter_gas_reset(&mut self, interp: &mut InterpreterFor<'_, '_, FEN>)
fn meter_gas_check(&mut self, interp: &mut InterpreterFor<'_, '_, FEN>)
Sourcefn apply_env_overrides(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
fork_id: Option<U256>,
)
fn apply_env_overrides( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, fork_id: Option<U256>, )
Applies opcode-level overrides for BASEFEE, GASPRICE, BLOBHASH and CHAINID.
Called from step_end after the opcode has executed and only when the
opcode succeeded. The opcode pushed its result onto the stack; we replace the top
of stack with the cheatcode-set override. evm2 borrows the transaction environment for
the whole transaction, so vm.txGasPrice, vm.blobhashes and vm.chainId become visible
to the running transaction this way; inside isolated calls vm.fee is applied this way
as well, since their nested transactions zero the real fee fields.
We can’t read the just-executed opcode from the interpreter here because the PC has already
advanced; instead step stashes it in env_overrides.pending_opcode for us.
Sourcefn replace_top_of_stack(interp: &mut InterpreterFor<'_, '_, FEN>, value: U256)
fn replace_top_of_stack(interp: &mut InterpreterFor<'_, '_, FEN>, value: U256)
Replaces the top of the interpreter stack with value.
The caller must only invoke this after a successful opcode that pushed
a value onto the stack; the pop() is therefore expected to succeed.
If it does not (e.g. because of a bug in the caller’s success gating)
we bail out instead of pushing on top of an unexpected stack, which
would silently grow the stack and corrupt the frame.
Sourcefn arbitrary_storage_end(&mut self, interp: &mut InterpreterFor<'_, '_, FEN>)
fn arbitrary_storage_end(&mut self, interp: &mut InterpreterFor<'_, '_, FEN>)
Generates or copies arbitrary values for storage slots.
Invoked in inspector step_end (when the current opcode is not executed), if current opcode
to execute is SLOAD and storage slot is cold.
Ensures that in next step (when SLOAD opcode is executed) an arbitrary value is returned:
- copies the existing arbitrary storage value (or the new generated one if no value in cache) from mapped source address to the target address.
- generates arbitrary value and saves it in target address storage.
fn take_storage_hook_inspector_state(&mut self) -> StorageHookInspectorState
fn restore_storage_hook_inspector_state( &mut self, state: StorageHookInspectorState, )
fn capture_storage_hook(&mut self, interp: &mut InterpreterFor<'_, '_, FEN>)
Sourcefn invoke_pending_storage_hook(
&mut self,
interp: &mut InterpreterFor<'_, '_, FEN>,
backend: &mut dyn CheatcodesBackend<FEN>,
executor: &mut dyn CheatcodesExecutor<FEN>,
)
fn invoke_pending_storage_hook( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, backend: &mut dyn CheatcodesBackend<FEN>, executor: &mut dyn CheatcodesExecutor<FEN>, )
Calls the storage hook captured for the instruction that just executed, as a nested frame whose gas, return data and access warmth do not affect the hooked frame.
Sourcefn record_accesses(&mut self, interp: &InterpreterFor<'_, '_, FEN>)
fn record_accesses(&mut self, interp: &InterpreterFor<'_, '_, FEN>)
Records storage slots reads and writes.
fn record_state_diffs( &mut self, interp: &mut InterpreterFor<'_, '_, FEN>, backend: &mut dyn CheatcodesBackend<FEN>, curr_depth: usize, )
Sourcefn check_mem_opcodes(
&self,
interpreter: &mut InterpreterFor<'_, '_, FEN>,
depth: u64,
)
fn check_mem_opcodes( &self, interpreter: &mut InterpreterFor<'_, '_, FEN>, depth: u64, )
Checks to see if the current opcode can either mutate directly or expand memory.
If the opcode at the current program counter is a match, check if the modified memory lies within the allowed ranges. If not, revert and fail the test.
fn set_gas_limit_type(&mut self, interpreter: &InterpreterFor<'_, '_, FEN>)
Trait Implementations§
Source§impl<FEN: Clone + FoundryEvmNetwork> Clone for Cheatcodes<FEN>
impl<FEN: Clone + FoundryEvmNetwork> Clone for Cheatcodes<FEN>
Source§impl<FEN: Debug + FoundryEvmNetwork> Debug for Cheatcodes<FEN>
impl<FEN: Debug + FoundryEvmNetwork> Debug for Cheatcodes<FEN>
Auto Trait Implementations§
impl<FEN = EthEvmNetwork> !Freeze for Cheatcodes<FEN>
impl<FEN = EthEvmNetwork> !RefUnwindSafe for Cheatcodes<FEN>
impl<FEN = EthEvmNetwork> !UnwindSafe for Cheatcodes<FEN>
impl<FEN> Send for Cheatcodes<FEN>where
Option<BlockEnvExt<<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types as EvmTypesHost>::BlockEnvExt>>: Send,
VecDeque<BroadcastableTransaction<<FEN as FoundryEvmNetwork>::Network>>: Send,
Option<<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types as EvmTypesHost>::SpecId>: Send,
Option<EvmEnv<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types>>: Send,
impl<FEN> Sync for Cheatcodes<FEN>where
Option<BlockEnvExt<<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types as EvmTypesHost>::BlockEnvExt>>: Sync,
VecDeque<BroadcastableTransaction<<FEN as FoundryEvmNetwork>::Network>>: Sync,
Option<<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types as EvmTypesHost>::SpecId>: Sync,
Option<EvmEnv<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types>>: Sync,
impl<FEN> Unpin for Cheatcodes<FEN>where
Option<BlockEnvExt<<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types as EvmTypesHost>::BlockEnvExt>>: Unpin,
VecDeque<BroadcastableTransaction<<FEN as FoundryEvmNetwork>::Network>>: Unpin,
Option<<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types as EvmTypesHost>::SpecId>: Unpin,
Option<EvmEnv<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types>>: Unpin,
impl<FEN> UnsafeUnpin for Cheatcodes<FEN>where
Option<BlockEnvExt<<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types as EvmTypesHost>::BlockEnvExt>>: UnsafeUnpin,
VecDeque<BroadcastableTransaction<<FEN as FoundryEvmNetwork>::Network>>: UnsafeUnpin,
Option<<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types as EvmTypesHost>::SpecId>: UnsafeUnpin,
Option<EvmEnv<<<FEN as FoundryEvmNetwork>::EvmFactory as FoundryEvmFactory>::Types>>: UnsafeUnpin,
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
§impl<T> Conv for T
impl<T> Conv for T
impl<T> ErasedDestructor for Twhere
T: 'static,
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self to use its Binary implementation when Debug-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self to use its Display implementation when
Debug-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self to use its LowerExp implementation when
Debug-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self to use its LowerHex implementation when
Debug-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self to use its Octal implementation when Debug-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self to use its Pointer implementation when
Debug-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self to use its UpperExp implementation when
Debug-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self to use its UpperHex implementation when
Debug-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<TxEnv, T> FromRecoveredTx<&T> for TxEnvwhere
TxEnv: FromRecoveredTx<T>,
impl<TxEnv, T> FromRecoveredTx<&T> for TxEnvwhere
TxEnv: FromRecoveredTx<T>,
§fn from_recovered_tx(tx: &&T, sender: Address) -> TxEnv
fn from_recovered_tx(tx: &&T, sender: Address) -> TxEnv
TxEnv] from a transaction and a sender address.§impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnvwhere
TxEnv: FromTxWithEncoded<T>,
impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnvwhere
TxEnv: FromTxWithEncoded<T>,
§fn from_encoded_tx(tx: &&T, sender: Address, encoded: Bytes) -> TxEnv
fn from_encoded_tx(tx: &&T, sender: Address, encoded: Bytes) -> TxEnv
TxEnv] from a transaction, its sender, and encoded transaction bytes.§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T in a tonic::Request§impl<L> LayerExt<L> for L
impl<L> LayerExt<L> for L
§fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>where
L: Layer<S>,
fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>where
L: Layer<S>,
Layered].impl<T> MaybeCompact for T
§impl<T> Paint for Twhere
T: ?Sized,
impl<T> Paint for Twhere
T: ?Sized,
§fn fg(&self, value: Color) -> Painted<&T>
fn fg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self with the foreground set to
value.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like red() and
green(), which have the same functionality but are
pithier.
§Example
Set foreground color to white using fg():
use yansi::{Paint, Color};
painted.fg(Color::White);Set foreground color to white using white().
use yansi::Paint;
painted.white();§fn bright_black(&self) -> Painted<&T>
fn bright_black(&self) -> Painted<&T>
§fn bright_red(&self) -> Painted<&T>
fn bright_red(&self) -> Painted<&T>
§fn bright_green(&self) -> Painted<&T>
fn bright_green(&self) -> Painted<&T>
§fn bright_yellow(&self) -> Painted<&T>
fn bright_yellow(&self) -> Painted<&T>
§fn bright_blue(&self) -> Painted<&T>
fn bright_blue(&self) -> Painted<&T>
§fn bright_magenta(&self) -> Painted<&T>
fn bright_magenta(&self) -> Painted<&T>
§fn bright_cyan(&self) -> Painted<&T>
fn bright_cyan(&self) -> Painted<&T>
§fn bright_white(&self) -> Painted<&T>
fn bright_white(&self) -> Painted<&T>
§fn bg(&self, value: Color) -> Painted<&T>
fn bg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self with the background set to
value.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like on_red() and
on_green(), which have the same functionality but
are pithier.
§Example
Set background color to red using fg():
use yansi::{Paint, Color};
painted.bg(Color::Red);Set background color to red using on_red().
use yansi::Paint;
painted.on_red();§fn on_primary(&self) -> Painted<&T>
fn on_primary(&self) -> Painted<&T>
§fn on_magenta(&self) -> Painted<&T>
fn on_magenta(&self) -> Painted<&T>
§fn on_bright_black(&self) -> Painted<&T>
fn on_bright_black(&self) -> Painted<&T>
§fn on_bright_red(&self) -> Painted<&T>
fn on_bright_red(&self) -> Painted<&T>
§fn on_bright_green(&self) -> Painted<&T>
fn on_bright_green(&self) -> Painted<&T>
§fn on_bright_yellow(&self) -> Painted<&T>
fn on_bright_yellow(&self) -> Painted<&T>
§fn on_bright_blue(&self) -> Painted<&T>
fn on_bright_blue(&self) -> Painted<&T>
§fn on_bright_magenta(&self) -> Painted<&T>
fn on_bright_magenta(&self) -> Painted<&T>
§fn on_bright_cyan(&self) -> Painted<&T>
fn on_bright_cyan(&self) -> Painted<&T>
§fn on_bright_white(&self) -> Painted<&T>
fn on_bright_white(&self) -> Painted<&T>
§fn attr(&self, value: Attribute) -> Painted<&T>
fn attr(&self, value: Attribute) -> Painted<&T>
Enables the styling [Attribute] value.
This method should be used rarely. Instead, prefer to use
attribute-specific builder methods like bold() and
underline(), which have the same functionality
but are pithier.
§Example
Make text bold using attr():
use yansi::{Paint, Attribute};
painted.attr(Attribute::Bold);Make text bold using using bold().
use yansi::Paint;
painted.bold();§fn rapid_blink(&self) -> Painted<&T>
fn rapid_blink(&self) -> Painted<&T>
§fn quirk(&self, value: Quirk) -> Painted<&T>
fn quirk(&self, value: Quirk) -> Painted<&T>
Enables the yansi [Quirk] value.
This method should be used rarely. Instead, prefer to use quirk-specific
builder methods like mask() and
wrap(), which have the same functionality but are
pithier.
§Example
Enable wrapping using .quirk():
use yansi::{Paint, Quirk};
painted.quirk(Quirk::Wrap);Enable wrapping using wrap().
use yansi::Paint;
painted.wrap();§fn clear(&self) -> Painted<&T>
👎Deprecated since 1.0.1: renamed to resetting() due to conflicts with Vec::clear().
The clear() method will be removed in a future release.
fn clear(&self) -> Painted<&T>
renamed to resetting() due to conflicts with Vec::clear().
The clear() method will be removed in a future release.
§fn whenever(&self, value: Condition) -> Painted<&T>
fn whenever(&self, value: Condition) -> Painted<&T>
Conditionally enable styling based on whether the [Condition] value
applies. Replaces any previous condition.
See the crate level docs for more details.
§Example
Enable styling painted only when both stdout and stderr are TTYs:
use yansi::{Paint, Condition};
painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self, then passes self.as_ref() into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self, then passes self.as_mut() into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self, then passes self.deref() into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B> of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B> of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R> view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R> view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap() only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut() only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow() only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut() only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref() only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut() only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref() only in debug builds, and is erased in release
builds.§impl<T> Threaded<T> for T
impl<T> Threaded<T> for T
§impl<T> TryConv for T
impl<T> TryConv for T
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ
Layout§
Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.