Struct ForkAware

pub struct ForkAware<Context, Value, Routine, Handler>(PhantomData<(Value, Context, Routine, Handler)>)
where
    Context: Config,
    Value: Portable,
    Routine: Routines<BlockNumberFor<Context>>,
    Handler: ForksHandler<Context, ForkLocalDepot>;

Marker type for fork-aware offchain storage, enabling re-org-sensitive, fork-scoped state with routine-defined error and logging semantics.

Intended for Substrate FRAME-based runtimes only.

Fork-aware offchain storage is re-org sensitive:

• Values are scoped to the current fork.
• Values are reverted if the fork is abandoned.
• Values are not shared across competing forks.

This marker is used to specialize KeyValueStore implementations backed by fork-aware offchain storage via [StorageValueRef::local].

Error policy requirement

When KeyValueStore is used for this type, the corresponding Routine must also implement OffchainStorageError for the same specialized Persistent<Context, Value, Routine> type.

This ensures that:

• storage-level failures are surfaced as caller-defined errors,
• errors are attributed to the routine’s domain rather than the storage layer,
• and each failure is logged exactly once.

Timestamp semantics

This storage backend is explicitly bound to block numbers as its timestamp source. It does not accept a generic timestamp parameter.

All logging and routine behavior associated with this backend uses [BlockNumberFor], reflecting its intended use inside FRAME-based runtimes.

Type parameters

• Context: The active runtime type (i.e. a type implementing [frame_system::Config]). This binds the storage to a specific runtime configuration.
• Value: The value type stored in fork-aware offchain storage.
• Routine: A routine type implementing Routines parameterized by [BlockNumberFor], ensuring logging, error handling, and behavior are specialized to block-based execution.
• Handler: A type implementing ForksHandler using ForkLocalDepot that manages the fork graph and scope tracking for this storage backend.

This type is a marker only and carries no runtime data.

Tuple Fields

0: PhantomData<(Value, Context, Routine, Handler)>

Trait Implementations

impl<Context, Value, Routine, Handler> Clone for ForkAware<Context, Value, Routine, Handler>

where Context: Config + Clone, Value: Portable + Clone, Routine: Routines<BlockNumberFor<Context>> + Clone, Handler: ForksHandler<Context, ForkLocalDepot> + Clone,

fn clone(&self) -> ForkAware<Context, Value, Routine, Handler>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Context, Value, Routine, Handler> Debug for ForkAware<Context, Value, Routine, Handler>

where Context: Config + Debug, Value: Portable + Debug, Routine: Routines<BlockNumberFor<Context>> + Debug, Handler: ForksHandler<Context, ForkLocalDepot> + Debug,

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

Formats the value using the given formatter.

impl<Context, Value, Routine, Handler> Default for ForkAware<Context, Value, Routine, Handler>

where Context: Config + Default, Value: Portable + Default, Routine: Routines<BlockNumberFor<Context>> + Default, Handler: ForksHandler<Context, ForkLocalDepot> + Default,

fn default() -> ForkAware<Context, Value, Routine, Handler>

Returns the “default value” for a type.

impl<T, Value, Routine, Handler> KeyValueStore<Value, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for ForkAware<T, Value, Routine, Handler>

where T: Config, Value: Portable, Routine: OffchainStorageError<Self> + Routines<BlockNumberFor<T>>, Handler: ForksHandler<T, ForkLocalDepot> + Logging<BlockNumberFor<T>, Level = LogLevel, Logger = DispatchError>,

Fork-Aware Offchain Storage Kind/Backend Default KeyValueStore Implementation.

Intended for Substrate FRAME-based runtimes only.

This implementation is backed by fork-aware offchain storage ([StorageValueRef::local]).

The timestamp type is the runtime’s block number ([BlockNumberFor]), ensuring that all logs are tagged with the block context in which the operation occurred.

type Key = [u8]

Keys are raw byte slices; allows flexible usage for any encoded identifier.

type Value = Value

Value type implementing [Encode] and [Decode]

fn insert( key: &Self::Key, value: &Value, target: Option<&str>, fmt: Option<LogFormatter<BlockNumberFor<T>, Self::Level>>, ) -> Result<(), Self::Logger>

Writes a value to fork-aware offchain storage.

For get-check-set use Self::mutate instead for concurrency safety.

Values written using this method are scoped to the current fork and will be reverted automatically if the fork is abandoned.

fn get( key: &Self::Key, target: Option<&str>, fmt: Option<LogFormatter<BlockNumberFor<T>, Self::Level>>, ) -> Result<Option<Value>, Self::Logger>

Reads a value from fork-aware offchain storage.

The returned value reflects only the state of the current fork and may differ across competing forks.

fn remove( key: &Self::Key, target: Option<&str>, fmt: Option<LogFormatter<BlockNumberFor<T>, Self::Level>>, ) -> Result<Option<Value>, Self::Logger>

Removes a value from fork-aware offchain storage.

Removals are scoped to the current fork and are reverted automatically if the fork is abandoned.

fn mutate<F>( key: &Self::Key, f: F, target: Option<&str>, fmt: Option<LogFormatter<BlockNumberFor<T>, Self::Level>>, ) -> Result<(), Self::Logger>

where F: FnOnce(Result<Option<Value>, Self::Logger>) -> Result<Value, Self::Logger>,

Performs an atomic read-modify-write operation on fork-aware offchain storage.

The closure is invoked with the current value, if any, and must return the new value to store. Removal is not supported by this method.

Mutations performed by this method:

• are visible only on the current fork,
• are reverted automatically on re-orgs,
• and are safe to use with speculative chain state.

impl<Context, Value, Routine, Handler> Copy for ForkAware<Context, Value, Routine, Handler>

where Context: Config + Copy, Value: Portable + Copy, Routine: Routines<BlockNumberFor<Context>> + Copy, Handler: ForksHandler<Context, ForkLocalDepot> + Copy,

impl<Context, Value, Routine, Handler> SubstrateOffchainStorage for ForkAware<Context, Value, Routine, Handler>

where Context: Config, Value: Portable, Routine: Routines<BlockNumberFor<Context>>, Handler: ForksHandler<Context, ForkLocalDepot>,

Default backend marker implementation for all valid ForkAware specializations.

This blanket implementation marks every well-formed ForkAware<Context, Value, Routine> type as a supported Substrate offchain storage backend.