Struct Backend &nbsp; Copy item path

impl<N: Network> Backend<N>

pub(super) async fn prepare_monad_fork_replay( &self, source_chain_id: u64, execution_chain_id: u64, timestamp: u64, parent_hash: B256, transactions: &[HistoricalReplayTransaction], ) -> Result<Option<ForkReplay>>

Available on crate feature monad only.

Prepares the Monad-specific inputs for replaying a historical transaction prefix.

pub(super) fn finalize_monad_fork_replay( &self, replay: &ForkReplay, evm_env: &mut EvmEnv, )

Available on crate feature monad only.

Applies the Monad execution rules selected for a completed fork replay.

Available on crate feature monad only.

pub(super) async fn monad_context_for_child_of_block_number( &self, block_number: u64, ) -> Result<MonadChainContext, BlockchainError>

Available on crate feature monad only.

Fetches the full blocks required to build context on top of block_number.

pub(super) async fn monad_context_for_child_of_block_hash( &self, block_hash: B256, ) -> Result<MonadChainContext, BlockchainError>

Available on crate feature monad only.

Available on crate feature monad only.

Builds the Monad [EvmEnv] (spec and gas params) from a base env.

pub(super) fn transact_monad_with_inspector_ref<'db, I, DB>( &self, db: &'db DB, evm_env: &EvmEnv, inspector: &mut I, tx_env: TxEnv, execution: PreparedExecution, ) -> Result<ResultAndState<HaltReason>, BlockchainError>
where DB: DatabaseRef + ?Sized, I: Inspector<MonadContext<WrapDatabaseRef<&'db DB>>>, WrapDatabaseRef<&'db DB>: Database<Error = DatabaseError>,

Available on crate feature monad only.

Monad path of Backend::transact_call_with_inspector_ref.

impl<N: Network> Backend<N>

pub(super) fn transact_op_with_inspector_ref<'db, I, DB>( &self, db: &'db DB, evm_env: &EvmEnv, inspector: &mut I, tx_env: OpTransaction<TxEnv>, ) -> Result<ResultAndState<HaltReason>, BlockchainError>
where DB: DatabaseRef + ?Sized, I: Inspector<OpEvmContext<WrapDatabaseRef<&'db DB>>>, WrapDatabaseRef<&'db DB>: Database<Error = DatabaseError>,

Available on crate feature optimism only.

Optimism path of Backend::transact_call_with_inspector_ref.

Creates an OP EVM, injects precompiles, transacts, and maps the OP-specific halt reason back to the shared [HaltReason].

pub fn monad_hardfork(&self) -> MonadHardfork

Available on crate feature monad only.

Returns the active Monad hardfork.

pub fn is_tempo_hardfork_active(&self, hardfork: TempoHardfork) -> bool

Returns whether a Tempo hardfork is active on this backend.

pub fn precompiles(&self) -> BTreeMap<String, Address>

Returns the precompiles for the current spec.

pub fn system_contracts(&self) -> BTreeMap<SystemContract, Address>

Returns the system contracts for the current spec.

pub fn blob_params(&self) -> BlobParams

Returns the active [BlobParams].

fn simulation_blob_params_at_timestamp(&self, timestamp: u64) -> BlobParams

fn is_optimism_jovian_at_header<H: BlockHeader>( &self, header: &H, decoded: Option<bool>, ) -> bool

Available on crate feature optimism only.

pub fn ensure_eip1559_active(&self) -> Result<(), BlockchainError>

Returns an error if EIP1559 is not active (pre Berlin)

pub fn ensure_eip2930_active(&self) -> Result<(), BlockchainError>

Returns an error if EIP1559 is not active (pre muirGlacier)

pub fn excess_blob_gas_and_price(&self) -> Option<BlobExcessGasAndPrice>

pub fn set_base_fee(&self, basefee: u64)

Sets the current basefee

pub fn set_gas_price(&self, price: u128)

Sets the gas price

fn tx_replay_evm_env(&self, block: &Block) -> (EvmEnv, FoundryHardfork)

Returns the environment for replaying transactions from a historical block.

fn prepare_block_replay<'a>( &self, block: &Block, parent_state: &'a StateDb, ) -> Result<(CacheDB<&'a StateDb>, EvmEnv, FoundryHardfork), BlockchainError>

Creates the database and environment for replaying a locally mined block.

pub(crate) fn mined_parity_trace_block( &self, block: u64, ) -> Option<Vec<LocalizedTransactionTrace>>

Returns the traces for the given block

pub(crate) fn mined_transaction( &self, hash: B256, ) -> Option<MinedTransaction<N>>

Returns the mined transaction for the given hash

pub async fn impersonate_signature( &self, signature: Bytes, address: Address, ) -> Result<(), BlockchainError>

Overrides the given signature to impersonate the specified address during ecrecover.

pub async fn debug_code_by_hash( &self, code_hash: B256, block_id: Option<BlockId>, ) -> Result<Option<Bytes>, BlockchainError>

Returns code by its hash

pub async fn debug_db_get( &self, key: String, ) -> Result<Option<Bytes>, BlockchainError>

Returns the value associated with a key from the database Currently only supports bytecode lookups.

Based on Reth implementation: https://github.com/paradigmxyz/reth/blob/66cfa9ed1a8c4bc2424aacf6fb2c1e67a78ee9a2/crates/rpc/rpc/src/debug.rs#L1146-L1178

Key should be: 0x63 (1-byte prefix) + 32 bytes (code_hash) Total key length must be 33 bytes.

fn mined_block_by_hash(&self, hash: B256) -> Option<AnyRpcBlock>

returns an error if the requested number is larger than the current height

fn inject_precompiles(&self, precompiles: &mut PrecompilesMap, evm_env: &EvmEnv)

Injects all configured precompiles into the given precompile map.

This applies five layers:

Network-specific precompiles (e.g. Tempo, OP)
Chain- and timestamp-specific precompiles
User-provided precompiles via PrecompileFactory
Cheatcode ecrecover overrides (if active)
Block-specific precompiles (e.g. ArbSys)

Replays a mined envelope through the active network’s canonical replay entry point.

§EVM settings

This modifies certain EVM settings to mirror geth’s SkipAccountChecks when transacting requests, see also: https://github.com/ethereum/go-ethereum/blob/380688c636a654becc8f114438c2a5d93d2db032/core/state_transition.go#L145-L148:

disable_eip3607 is set to true
disable_base_fee is set to true
tx_gas_limit_cap is set to Some(u64::MAX) indicating no gas limit cap
nonce check is skipped

pub async fn trace_filter( &self, filter: TraceFilter, ) -> Result<Vec<LocalizedTransactionTrace>, BlockchainError>

pub fn get_blobs_by_block_id( &self, id: impl Into<BlockId>, versioned_hashes: Vec<B256>, ) -> Result<Option<Vec<Blob>>>

pub fn get_blob_by_versioned_hash(&self, hash: B256) -> Result<Option<Blob>>

pub async fn with_genesis( db: Arc<AsyncRwLock<Box<dyn Db>>>, env: Arc<RwLock<EvmEnv>>, networks: NetworkConfigs, genesis: GenesisConfig, fees: FeeManager, fork: Arc<RwLock<Option<ClientFork>>>, enable_steps_tracing: bool, print_logs: bool, print_traces: bool, call_trace_decoder: Arc<CallTraceDecoder>, prune_state_history_config: PruneStateHistoryConfig, max_persisted_states: Option<usize>, transaction_block_keeper: Option<usize>, automine_block_time: Option<Duration>, cache_path: Option<PathBuf>, node_config: Arc<AsyncRwLock<NodeConfig>>, ) -> Result<Self>

Initialises the balance of the given accounts

async fn apply_genesis(&self) -> Result<(), DatabaseError>

Applies the configured genesis settings

fn mined_logs_for_block( &self, filter: Filter, block: Block, block_hash: B256, ) -> Vec<Log>

Returns all Logs mined by the node that were emitted in the block and match the Filter

fn removed_logs_since(&self, block_number: u64) -> Vec<Log>

Returns all logs of the blocks with a number greater than block_number, marked as removed.

This is used during a reorg to capture the logs of the blocks that are about to be unwound before their transactions and receipts are cleared from storage, so they can be re-delivered to log subscriptions and filters with removed: true.

async fn logs_for_block( &self, filter: Filter, hash: B256, ) -> Result<Vec<Log>, BlockchainError>

Returns the logs of the block that match the filter

pub async fn with_pending_block<F, T>( &self, pool_transactions: Vec<Arc<PoolTransaction<FoundryTxEnvelope>>>, f: F, ) -> T
where F: FnOnce(Box<dyn MaybeFullDatabase + '_>, BlockInfo<N>) -> T,

Creates the pending block

This will execute all transaction in the order they come but will not mine the block

pub async fn get_fee_token_balance( &self, token: Address, account: Address, ) -> Result<U256, BlockchainError>

Returns the ERC20/TIP20 token balance for an account.

Calls balanceOf(address) on the token contract. Returns U256::ZERO if the call fails (e.g. the token contract doesn’t exist).

pub async fn tempo_fee_payer(&self) -> Option<Address>

Returns the account used to sponsor Tempo fee-payer requests handled by this node.

Returns None on non-Tempo networks.

pub async fn tempo_user_fee_token( &self, account: Address, ) -> Result<Address, BlockchainError>

Returns the fee token an account pays with, as stored in the Tempo fee manager.

Falls back to PathUSD when the account has no stored preference or the lookup fails.

pub async fn call( &self, request: WithOtherFields<TransactionRequest>, fee_details: FeeDetails, block_request: Option<BlockRequest<FoundryTxEnvelope>>, overrides: EvmOverrides, ) -> Result<(InstructionResult, Option<Output>, u128, State), BlockchainError>

Executes the [TransactionRequest] without writing to the DB

§Errors

Returns an error if the block_number is greater than the current height

pub(crate) async fn with_database_at_and_context<F, T>( &self, block_request: Option<BlockRequest<FoundryTxEnvelope>>, f: F, ) -> Result<T, BlockchainError>
where F: FnOnce(Box<dyn MaybeFullDatabase + '_>, BlockEnv, Option<MonadChainContext>) -> Result<T, BlockchainError>,

Executes a closure with both state and network context at a specific block.

pub async fn storage_at( &self, address: Address, index: U256, block_request: Option<BlockRequest<FoundryTxEnvelope>>, ) -> Result<B256, BlockchainError>

pub async fn tempo_nonce( &self, caller: Address, nonce_key: U256, block_request: Option<BlockRequest<FoundryTxEnvelope>>, ) -> Result<u64, BlockchainError>

pub async fn get_nonce( &self, address: Address, block_request: BlockRequest<FoundryTxEnvelope>, ) -> Result<u64, BlockchainError>

Returns the nonce of the address

If the requested number predates the fork then this will fetch it from the endpoint

pub async fn trace_block_opcode_gas( &self, block_id: BlockId, ) -> Result<Option<BlockOpcodeGas>, BlockchainError>

Returns opcode gas usage for all transactions in the given block.

fn mined_block_opcode_gas( &self, block: &Block, block_hash: B256, ) -> Result<BlockOpcodeGas, BlockchainError>

pub async fn debug_execution_witness( &self, block: BlockNumber, ) -> Result<ExecutionWitness, BlockchainError>

Returns a best-effort execution witness for the given block, in the same format as reth’s debug_executionWitness.

Anvil does not track which state a block’s execution actually touched, so this returns a witness for the entire parent state instead: the RLP encoding of every node of the parent state trie (including all storage tries), all contract codes, and the preimages of all account addresses and storage slots. This is a strict superset of the minimal witness, so stateless re-execution of the block against it works, but the witness size grows with the total state instead of the state accessed by the block.

Limitations:

Not supported while forking: only remotely accessed accounts are known locally, and the locally computed state roots do not match the remote chain’s roots.
The parent block’s state must still be available in the state history, i.e. it must not have been discarded via --prune-history.
The genesis block has no witness since it has no parent state.
headers contains the ancestor headers within the 256 block BLOCKHASH window that are known locally, which may be fewer than 256.

pub async fn debug_account_info_at( &self, block_id: BlockId, tx_index: Index, address: Address, ) -> Result<Option<RpcAccountInfo>, BlockchainError>

Returns account information after replaying a block through the transaction at tx_index.

fn mined_debug_account_info_at( &self, block: &Block, tx_index: Index, address: Address, ) -> Result<RpcAccountInfo, BlockchainError>

pub async fn rollback(&self, common_block: Block) -> Result<(), BlockchainError>

Rollback the chain to a common height.

The state of the chain is rewound using rewind to the common block, including the db, storage, and env.

pub async fn debug_trace_transaction( &self, hash: B256, opts: GethDebugTracingOptions, ) -> Result<GethTrace, BlockchainError>

Returns the traces for the given transaction

pub async fn debug_trace_block( &self, rlp_block: Bytes, opts: GethDebugTracingOptions, ) -> Result<Vec<TraceResult>, BlockchainError>

Returns geth-style traces for all transactions in an RLP-encoded block.

pub async fn debug_trace_block_by_hash( &self, block_hash: B256, opts: GethDebugTracingOptions, ) -> Result<Vec<TraceResult>, BlockchainError>

Returns geth-style traces for all transactions in a block by hash.

pub async fn debug_trace_block_by_number( &self, block_number: BlockNumber, opts: GethDebugTracingOptions, ) -> Result<Vec<TraceResult>, BlockchainError>

Returns geth-style traces for all transactions in a block by number.

fn geth_trace( &self, tx: &MinedTransaction<N>, opts: GethDebugTracingOptions, ) -> Result<GethTrace, BlockchainError>

async fn mined_geth_trace_transaction( &self, hash: B256, opts: GethDebugTracingOptions, ) -> Option<Result<GethTrace, BlockchainError>>

pub async fn transaction_receipt( &self, hash: B256, ) -> Result<Option<FoundryTxReceipt>, BlockchainError>

pub fn mined_block_receipts( &self, id: impl Into<BlockId>, ) -> Option<Vec<FoundryTxReceipt>>

Returns all transaction receipts of the block

Write all chain data to serialized bytes buffer

pub async fn load_state( &self, state: SerializableState, ) -> Result<bool, BlockchainError>

Apply SerializableState data to the backend storage.

pub async fn load_state_bytes( &self, buf: Bytes, ) -> Result<bool, BlockchainError>

Deserialize and add all chain data to the backend storage

impl Backend<FoundryNetwork>

pub async fn call_bundle( &self, bundle: EthCallBundle, transactions: Vec<PendingTransaction<FoundryTxEnvelope>>, block_request: Option<BlockRequest<FoundryTxEnvelope>>, ) -> Result<EthCallBundleResponse, BlockchainError>

Simulates a bundle of signed transactions and returns Flashbots-compatible results.

pub async fn call_many( &self, bundles: Vec<Bundle<WithOtherFields<TransactionRequest>>>, block_request: Option<BlockRequest<FoundryTxEnvelope>>, state_override: Option<StateOverride>, ) -> Result<Vec<Vec<EthCallResponse>>, BlockchainError>

Executes bundles of call requests and returns each call output.

pub async fn simulate( &self, request: SimulatePayload, block_request: Option<BlockRequest<FoundryTxEnvelope>>, block_interval: u64, ) -> Result<Vec<SimulatedBlock<AnyRpcBlock>>, BlockchainError>

Simulates the payload by executing the calls in request.

pub(crate) async fn simulate_raw( &self, request: SimulatePayload<WithOtherFields<TransactionRequest>>, block_request: Option<BlockRequest<FoundryTxEnvelope>>, block_interval: u64, ) -> Result<Vec<SimulatedBlock<AnyRpcBlock>>, BlockchainError>

Simulates a payload while preserving transaction extension fields.

Runs f inside a Tempo storage context initialized from the current state (Tempo-only).

type Output = R

impl<T> Conv for T

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more

Attaches the current Context to this type, returning a WithContext wrapper. Read more

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Apply a runtime-determined style

impl<T> Paint for T
where T: ?Sized,

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 primary(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Primary].

§Example

println!("{}", value.primary());

fn fixed(&self, color: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Fixed].

§Example

println!("{}", value.fixed(color));

fn rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Rgb].

§Example

println!("{}", value.rgb(r, g, b));

fn black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Black].

§Example

println!("{}", value.black());

fn red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Red].

§Example

println!("{}", value.red());

fn green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Green].

§Example

println!("{}", value.green());

fn yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Yellow].

§Example

println!("{}", value.yellow());

fn blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Blue].

§Example

println!("{}", value.blue());

fn magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Magenta].

§Example

println!("{}", value.magenta());

fn cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Cyan].

§Example

println!("{}", value.cyan());

fn white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: White].

§Example

println!("{}", value.white());

fn bright_black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlack].

§Example

println!("{}", value.bright_black());

fn bright_red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightRed].

§Example

println!("{}", value.bright_red());

fn bright_green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightGreen].

§Example

println!("{}", value.bright_green());

fn bright_yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightYellow].

§Example

println!("{}", value.bright_yellow());

fn bright_blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlue].

§Example

println!("{}", value.bright_blue());

fn bright_magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightMagenta].

§Example

println!("{}", value.bright_magenta());

fn bright_cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightCyan].

§Example

println!("{}", value.bright_cyan());

fn bright_white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightWhite].

§Example

println!("{}", value.bright_white());

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>

Returns self with the bg() set to [Color :: Primary].

§Example

println!("{}", value.on_primary());

fn on_fixed(&self, color: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Fixed].

§Example

println!("{}", value.on_fixed(color));

fn on_rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Rgb].

§Example

println!("{}", value.on_rgb(r, g, b));

fn on_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Black].

§Example

println!("{}", value.on_black());

fn on_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Red].

§Example

println!("{}", value.on_red());

fn on_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Green].

§Example

println!("{}", value.on_green());

fn on_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Yellow].

§Example

println!("{}", value.on_yellow());

fn on_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Blue].

§Example

println!("{}", value.on_blue());

fn on_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Magenta].

§Example

println!("{}", value.on_magenta());

fn on_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Cyan].

§Example

println!("{}", value.on_cyan());

fn on_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: White].

§Example

println!("{}", value.on_white());

fn on_bright_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlack].

§Example

println!("{}", value.on_bright_black());

fn on_bright_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightRed].

§Example

println!("{}", value.on_bright_red());

fn on_bright_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightGreen].

§Example

println!("{}", value.on_bright_green());

fn on_bright_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightYellow].

§Example

println!("{}", value.on_bright_yellow());

fn on_bright_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlue].

§Example

println!("{}", value.on_bright_blue());

fn on_bright_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightMagenta].

§Example

println!("{}", value.on_bright_magenta());

fn on_bright_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightCyan].

§Example

println!("{}", value.on_bright_cyan());

fn on_bright_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightWhite].

§Example

println!("{}", value.on_bright_white());

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 bold(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Bold].

§Example

println!("{}", value.bold());

fn dim(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Dim].

§Example

println!("{}", value.dim());

fn italic(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Italic].

§Example

println!("{}", value.italic());

fn underline(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Underline].

§Example

println!("{}", value.underline());

fn blink(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Blink].

§Example

println!("{}", value.blink());

fn rapid_blink(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: RapidBlink].

§Example

println!("{}", value.rapid_blink());

fn invert(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Invert].

§Example

println!("{}", value.invert());

fn conceal(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Conceal].

§Example

println!("{}", value.conceal());

fn strike(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Strike].

§Example

println!("{}", value.strike());

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 mask(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Mask].

§Example

println!("{}", value.mask());

fn wrap(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Wrap].

§Example

println!("{}", value.wrap());

fn linger(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Linger].

§Example

println!("{}", value.linger());

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.

Returns self with the quirk() set to [Quirk :: Clear].

§Example

println!("{}", value.clear());

fn resetting(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Resetting].

§Example

println!("{}", value.resetting());

fn bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Bright].

§Example

println!("{}", value.bright());

fn on_bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: OnBright].

§Example

println!("{}", value.on_bright());

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);

fn new(self) -> Painted<Self>
where Self: Sized,

Create a new [Painted] with a default [Style]. Read more

fn paint<S>(&self, style: S) -> Painted<&Self>
where S: Into<Style>,

Apply a style wholesale to self. Any previous style is replaced. Read more

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more