Struct BlockExtras 

pub struct BlockExtras {

    pub total_fees: Sats,
    pub median_fee: FeeRate,
    pub fee_range: [FeeRate; 7],
    pub reward: Sats,
    pub pool: BlockPool,
    pub avg_fee: Sats,
    pub avg_fee_rate: FeeRate,
    pub coinbase_raw: String,
    pub coinbase_address: Option<String>,
    pub coinbase_addresses: Vec<String>,
    pub coinbase_signature: String,
    pub coinbase_signature_ascii: String,
    pub avg_tx_size: f64,
    pub total_inputs: u64,
    pub total_outputs: u64,
    pub total_output_amt: Sats,
    pub median_fee_amt: Sats,
    pub fee_percentiles: [Sats; 7],
    pub segwit_total_txs: u32,
    pub segwit_total_size: u64,
    pub segwit_total_weight: Weight,
    pub header: String,
    pub utxo_set_change: i64,
    pub utxo_set_size: u64,
    pub total_input_amt: Sats,
    pub virtual_size: f64,
    pub first_seen: Option<u64>,
    pub orphans: Vec<String>,
    pub price: Dollars,
}

Extended block data matching mempool.space /api/v1/blocks extras

Fields

total_fees: Sats

Total fees in satoshis

median_fee: FeeRate

Median fee rate in sat/vB

fee_range: [FeeRate; 7]

Fee rate range: [min, 10%, 25%, 50%, 75%, 90%, max]

reward: Sats

Total block reward (subsidy + fees) in satoshis

pool: BlockPool

Mining pool that mined this block

avg_fee: Sats

Average fee per transaction in satoshis

avg_fee_rate: FeeRate

Average fee rate in sat/vB

coinbase_raw: String

Raw coinbase transaction scriptsig as hex

coinbase_address: Option<String>

Primary coinbase output address

coinbase_addresses: Vec<String>

All coinbase output addresses

coinbase_signature: String

Coinbase output script in ASM format

coinbase_signature_ascii: String

Coinbase scriptsig decoded as ASCII

avg_tx_size: f64

Average transaction size in bytes

total_inputs: u64

Total number of inputs (excluding coinbase)

total_outputs: u64

Total number of outputs

total_output_amt: Sats

Total output amount in satoshis

median_fee_amt: Sats

Median fee amount in satoshis

fee_percentiles: [Sats; 7]

Fee amount percentiles in satoshis: [min, 10%, 25%, 50%, 75%, 90%, max]

segwit_total_txs: u32

Number of segwit transactions

segwit_total_size: u64

Total size of segwit transactions in bytes

segwit_total_weight: Weight

Total weight of segwit transactions

header: String

Raw 80-byte block header as hex

utxo_set_change: i64

UTXO set change (total outputs - total inputs, includes unspendable like OP_RETURN). Note: intentionally differs from utxo_set_size diff which excludes unspendable outputs. Matches mempool.space/bitcoin-cli behavior.

utxo_set_size: u64

Total spendable UTXO set size at this height (excludes OP_RETURN and other unspendable outputs)

total_input_amt: Sats

Total input amount in satoshis

virtual_size: f64

Virtual size in vbytes

first_seen: Option<u64>

Timestamp when the block was first seen (always null, not yet supported)

orphans: Vec<String>

Orphaned blocks (always empty)

price: Dollars

USD price at block height

Trait Implementations

impl Clone for BlockExtras

fn clone(&self) -> BlockExtras

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockExtras

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BlockExtras

fn deserialize<__D>( __deserializer: __D, ) -> Result<BlockExtras, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for BlockExtras

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for BlockExtras

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.