Struct ForkLocalDepot

pub struct ForkLocalDepot {
    pub inherited_keys: BTreeSet<[u8; 32]>,
    pub local_keys: BTreeSet<[u8; 32]>,
}

Fork-local storage scope for ForksHandler implementing ForkScopes.

ForkLocalDepot is the branch-local scope container used by the fork-aware offchain execution system to track visibility of fork-scoped storage entries across branch lineage.

It does not store the actual values themselves.

Instead, it stores only deterministic 32-byte keys ([u8; 32]) representing items written into fork-aware storage systems such as:

• ForkAware
• Finalized

These keys act as stable scope references that allow the fork graph to answer:

"does this item exist on this branch or any reachable ancestor branch?"

without requiring repeated traversal of historical parent branches.

Why this exists

In fork-aware OCW execution, each branch must maintain isolated local state while still inheriting valid reachable state from its lineage.

Example:

A -> B -> C
        |-- D
        |-- D'

Here:

• D and D' must not overwrite each other
• both branches must still see inherited state from A -> B -> C

ForkLocalDepot provides that visibility layer by separating:

• current-generation writes
• inherited historical writes

instead of repeatedly walking parent branches during every lookup.

Fork inheritance model

When a new sibling branch is created:

Parent branch:
A -> B -> C

New sibling:
        |-- D'

the child branch receives:

inherited_keys(child)
= inherited_keys(parent) + local_keys(parent)

while starting with:

local_keys(child) = {}

This ensures:

• parent state remains reachable
• new writes stay isolated to the new fork
• existence checks remain O(log n)
• no ancestry walking is required for normal reads

Example

Original branch:

local_keys      = {k1, k2}
inherited_keys  = {}

After fork:

local_keys      = {}
inherited_keys  = {k1, k2}

New write:

local_keys      = {k3}
inherited_keys  = {k1, k2}

The child branch can see:

{k1, k2, k3}

while sibling branches remain isolated from k3.

Fields

inherited_keys: BTreeSet<[u8; 32]>

Keys inherited from previous generations through Accrete.

These represent all reachable historical entries inherited from ancestor branches.

They are not created in the current branch generation, but remain visible because they were promoted forward during fork creation.

This allows branch-local reads to access valid ancestor state without walking parent branches repeatedly.

local_keys: BTreeSet<[u8; 32]>

Keys created only in the current local generation.

These represent the newest writes belonging exclusively to the current branch path.

They are isolated to this branch until another fork occurs, at which point they are promoted into inherited_keys of the child branch through Accrete::accrete().

This ensures writes remain fork-local while still preserving deterministic lineage inheritance for future branches.

Trait Implementations

impl Accrete for ForkLocalDepot

type Item = Vec<u8>

The original payload used to derive deterministic keys.

Only the generated [u8; 32] key is stored internally.

fn accrete(&self) -> Self

Create the next generation.

All current local keys are promoted into inherited history, and the returned generation starts with a fresh empty local layer.

fn inherited(&self) -> Vec<[u8; 32]>

Returns inherited keys only.

fn local(&self) -> Vec<[u8; 32]>

Returns current local generation keys only.

fn add_to_local(&mut self, item: Self::Item) -> [u8; 32]

Insert an item’s deterministic key into the local generation.

The payload itself is not stored here, only its stable key hash.

Returns the deterministic key used for future lookups.

fn exists_in_local(&self, key: &[u8; 32]) -> bool

Checks existence only in local generation.

fn exists_in_inherited(&self, key: &[u8; 32]) -> bool

Checks existence only in inherited generations.

fn remove_from_local(&mut self, key: &[u8; 32])

Remove a key only from the local generation.

fn remove_from_inherited(&mut self, key: &[u8; 32])

Remove a key only from inherited generations.

fn make_key(item: &Self::Item) -> [u8; 32]

Creates a deterministic key for an item.

impl Clone for ForkLocalDepot

fn clone(&self) -> ForkLocalDepot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ForkLocalDepot

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

Formats the value using the given formatter.

impl Decode for ForkLocalDepot

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> 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 Default for ForkLocalDepot

fn default() -> ForkLocalDepot

Returns the “default value” for a type.

impl Encode for ForkLocalDepot

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 EncodeLike for ForkLocalDepot