Struct DryRunConfig 

pub struct DryRunConfig<Moment> {
    pub timestamp_override: Option<Moment>,
    pub perform_balance_checks: Option<bool>,
    pub state_overrides: Option<StateOverrideSet>,
}

Configuration specific to a dry-run execution.

Passed as an argument to the eth_transact_with_config runtime API method. Contains optional overrides that control how the dry-run is executed, such as timestamp simulation and state injection.

Backwards Compatibility

This type is SCALE-encoded when passed across the runtime API boundary via state_call. SCALE is a non-self-describing format: fields are encoded sequentially with no field names, delimiters, or end-of-message markers. This has important implications when the struct evolves over time.

Adding new trailing fields

New fields may be appended to the end of this struct without requiring a new runtime API method, provided that:

1. New RPC, old runtime (trailing bytes are ignored): The sp_api runtime API argument decoding machinery uses Decode::decode (not decode_all) for parameterized calls. This means bytes remaining after decoding all known fields are silently ignored. An old runtime that does not know about a newly appended field will decode the fields it recognizes and discard the rest. This is intentional behavior in sp_api — see the generated code in substrate/primitives/api/proc-macro/src/impl_runtime_apis.rs.

2. Old RPC, new runtime (missing bytes are defaulted): A new runtime expecting more fields than an old RPC provides would hit EOF during decoding and fail. To guard against this, this type uses a custom Decode implementation that falls back to Default for any trailing fields that are absent from the input. This ensures that an old RPC sending a shorter encoding is handled gracefully.

Constraints on fields

• New fields must be appended to the end. Inserting or reordering fields changes the byte layout of all subsequent fields, breaking both directions.
• New fields must implement Default so that the custom Decode fallback can produce a sensible value when the field is absent from the input. This is the only requirement on the field’s type — it does not need to be Option.
• This pattern relies on sp_api continuing to use Decode::decode rather than decode_all. If that ever changes, a new runtime API method would be needed instead.

Constraints on runtime API placement

The trailing-bytes trick described in point 1 above only works because sp_api discards unconsumed bytes at the end of the entire argument buffer. This means DryRunConfig must be the last argument of any runtime API method that uses it (which is currently the case for both eth_transact_with_config and eth_estimate_gas). If it were placed before another argument, the extra bytes from newly appended fields would shift the decoding offset and corrupt the subsequent argument.

Fields

timestamp_override: Option<Moment>

Optional timestamp override for dry-run in pending block.

perform_balance_checks: Option<bool>

Used to control if the dry run logic should perform the balance checks or not.

state_overrides: Option<StateOverrideSet>

Optional state overrides to apply before executing the call. Each entry maps an account address to a set of fields (balance, nonce, code, storage) that should be temporarily replaced for the duration of the dry-run.

Implementations

impl<Moment> DryRunConfig<Moment>

pub fn new() -> Self

Create a new DryRunConfig with default values.

Balance checks are enabled by default. Use the builder methods to customize.

pub fn with_timestamp_override( self, timestamp_override: impl Into<Option<Moment>>, ) -> Self

A builder method which consumes the object and modifies the timestamp_override field.

pub fn with_perform_balance_checks( self, perform_balance_checks: impl Into<Option<bool>>, ) -> Self

A builder method which consumes the object and modifies the perform_balance_checks field.

pub fn with_state_overrides( self, state_overrides: impl Into<Option<StateOverrideSet>>, ) -> Self

A builder method which consumes the object and sets the state overrides.

Trait Implementations

impl<Moment: Clone> Clone for DryRunConfig<Moment>

fn clone(&self) -> DryRunConfig<Moment>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Moment: Debug> Debug for DryRunConfig<Moment>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Moment: Decode> Decode for DryRunConfig<Moment>

A custom implementation of [Decode] to ensure forward and backward compatibility of the DryRunConfig type.

Backwards Compatibility

Please review the documentation on the DryRunConfig for more information about how we manage and handle compatibility for this type and instructions on what you should do when adding a new field to this type.

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<Moment> Default for DryRunConfig<Moment>

fn default() -> Self

Returns the “default value” for a type.

impl<Moment> Encode for DryRunConfig<Moment>

where Option<Moment>: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<Moment> TypeInfo for DryRunConfig<Moment>

where Option<Moment>: TypeInfo + 'static, Moment: TypeInfo + 'static,

type Identity = DryRunConfig<Moment>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<Moment> EncodeLike for DryRunConfig<Moment>

where Option<Moment>: Encode,