Struct ValidatorRecord 

struct ValidatorRecord {
    public_key: B256,
    validator_address: Address,
    ingress: String,
    egress: String,
    fee_recipient: Address,
    index: u64,
    active_idx: u64,
    added_at_height: u64,
    deactivated_at_height: u64,
}

A single entry in the validators vector.

Lifecycle

A record is created in one of three ways:

• add_validator: active entry (deactivated_at_height = 0, active_idx != 0)
• migrate_validator: active or born-deactivated, depending on V1 state
• rotate_validator: appends a born-deactivated snapshot of the old identity and overwrites the original slot in-place with the new identity

A record is deactivated via deactivate_validator, which sets deactivated_at_height to the current block height and clears active_idx to 0. This transition is one-way — a deactivated record never becomes active again.

Fields

public_key: B256

Ed25519 communication public key (unique across all records, reserved forever).

validator_address: Address

Ethereum-style address of the validator (unique among active validators).

ingress: String

Inbound address for peer connections (<ip>:<port>).

egress: String

Outbound IP for firewall whitelisting (<ip>).

fee_recipient: Address

Address that receives execution-layer fees for this validator.

index: u64

Position in the validators array. Stable across rotations for the in-place slot; snapshots get the tail position at the time they were appended.

active_idx: u64

1-indexed position in active_indices (0 = not active). Used as a backpointer for O(1) swap-and-pop removal on deactivation.

added_at_height: u64

Block height at which this record was created (or overwritten during rotation).

deactivated_at_height: u64

Block height at which this record was deactivated (0 = still active).

Trait Implementations

impl Debug for ValidatorRecord

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

Formats the value using the given formatter.

impl Handler<ValidatorRecord> for ValidatorRecordHandler

fn t_read(&self) -> Result<ValidatorRecord>

Reads the struct from transient storage.

fn t_write(&mut self, value: ValidatorRecord) -> Result<()>

Writes the struct to transient storage.

fn t_delete(&mut self) -> Result<()>

Deletes the struct from transient storage.

fn read(&self) -> Result<ValidatorRecord>

Reads the value from storage.

fn write(&mut self, value: ValidatorRecord) -> Result<()>

Writes the value to storage.

fn delete(&mut self) -> Result<()>

Deletes the value from storage (sets to zero).

impl Storable for ValidatorRecord

fn load<S: StorageOps>( storage: &S, base_slot: U256, ctx: LayoutCtx, ) -> Result<Self>

Load this type from storage at the given slot.

fn store<S: StorageOps>( &self, storage: &mut S, base_slot: U256, ctx: LayoutCtx, ) -> Result<()>

Store this type to storage at the given slot.

fn delete<S: StorageOps>( storage: &mut S, base_slot: U256, ctx: LayoutCtx, ) -> Result<()>

Delete this type from storage (set to zero).

impl StorableType for ValidatorRecord

const LAYOUT: Layout

Describes how this type is laid out in storage.

const IS_DYNAMIC: bool

Whether this type stores it’s data in its base slot or not.

type Handler = ValidatorRecordHandler

The handler type that provides storage access for this type.

fn handle(slot: U256, _ctx: LayoutCtx, address: Address) -> Self::Handler

Creates a handler for this type at the given storage location.

const SLOTS: usize = _

Number of storage slots this type takes.

const BYTES: usize = _

Number of bytes this type takes.

const IS_PACKABLE: bool = _

Whether this type can be packed with adjacent fields.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 152 bytes