espresso_node/api/

endpoints.rs

//! Sequencer-specific API endpoint handlers.

use std::{
    collections::{BTreeSet, HashMap},
    env,
};

use alloy::primitives::utils::format_ether;
use anyhow::{Context, Result};
use committable::Committable;
use espresso_types::{
    FeeAccount, FeeMerkleTree, PubKey, Transaction,
    v0_3::RewardAccountV1,
    v0_4::{RewardAccountV2, RewardClaimError},
};

use crate::api::{
    RewardAmount, RewardMerkleTreeV2Data, data_source::TokenDataSource, unlock_schedule,
};
// re-exported here to avoid breaking changes in consumers
// "deprecated" does not work with "pub use": https://github.com/rust-lang/rust/issues/30827
#[deprecated(note = "use espresso_types::ADVZNamespaceProofQueryData")]
pub type ADVZNamespaceProofQueryData = espresso_types::ADVZNamespaceProofQueryData;
#[deprecated(note = "use espresso_types::NamespaceProofQueryData")]
pub type NamespaceProofQueryData = espresso_types::NamespaceProofQueryData;

use futures::FutureExt;
use hotshot_query_service::{
    Error,
    availability::AvailabilityDataSource,
    explorer::{self, ExplorerDataSource},
    merklized_state::{
        self, MerklizedState, MerklizedStateDataSource, MerklizedStateHeightPersistence, Snapshot,
    },
    node::{self, NodeDataSource},
};
use hotshot_types::{
    data::{EpochNumber, ViewNumber},
    traits::network::ConnectedNetwork,
};
use jf_merkle_tree_compat::MerkleTreeScheme;
use serde::de::Error as _;
use tagged_base64::TaggedBase64;
use tide_disco::{Api, Error as _, RequestParams, StatusCode, method::ReadState};
use vbs::version::{StaticVersion, StaticVersionType};

use super::data_source::{
    CatchupDataSource, DatabaseMetadataSource, HotShotConfigDataSource, NodeStateDataSource,
    PruningDataSource, StakeTableDataSource, StateSignatureDataSource, SubmitDataSource,
};
use crate::{
    SeqTypes, SequencerApiVersion, SequencerPersistence, api::RewardMerkleTreeDataSource,
    options::PublicNodeConfig,
};

pub(crate) mod availability;
pub(super) use availability::*;

pub(super) fn fee<State, Ver>(
    api_ver: semver::Version,
) -> Result<Api<State, merklized_state::Error, Ver>>
where
    State: 'static + Send + Sync + ReadState,
    Ver: 'static + StaticVersionType,
    <State as ReadState>::State: Send
        + Sync
        + MerklizedStateDataSource<SeqTypes, FeeMerkleTree, { FeeMerkleTree::ARITY }>
        + MerklizedStateHeightPersistence,
{
    let mut options = merklized_state::Options::default();
    let extension = toml::from_str(include_str!("../../api/fee.toml"))?;
    options.extensions.push(extension);

    let mut api =
        merklized_state::define_api::<State, SeqTypes, FeeMerkleTree, Ver, 256>(&options, api_ver)?;

    api.get("getfeebalance", move |req, state| {
        async move {
            let address = req.string_param("address")?;
            let height = state.get_last_state_height().await?;
            let snapshot = Snapshot::Index(height as u64);
            let key = address
                .parse()
                .map_err(|_| merklized_state::Error::Custom {
                    message: "failed to parse address".to_string(),
                    status: StatusCode::BAD_REQUEST,
                })?;
            let path = state.get_path(snapshot, key).await?;
            Ok(path.elem().copied())
        }
        .boxed()
    })?;
    Ok(api)
}

pub enum RewardMerkleTreeVersion {
    V1,
    V2,
}

pub(super) fn reward<State, Ver, MT, const ARITY: usize>(
    api_ver: semver::Version,
    merkle_tree_version: RewardMerkleTreeVersion,
) -> Result<Api<State, merklized_state::Error, Ver>>
where
    State: 'static + Send + Sync + ReadState,
    Ver: 'static + StaticVersionType,
    MT: MerklizedState<SeqTypes, ARITY>,
    for<'a> <MT::Commit as TryFrom<&'a TaggedBase64>>::Error: std::fmt::Display,
    <MT as MerklizedState<SeqTypes, ARITY>>::Entry: std::marker::Copy,
    <State as ReadState>::State: Send
        + Sync
        + RewardMerkleTreeDataSource
        + MerklizedStateDataSource<SeqTypes, MT, ARITY>
        + MerklizedStateHeightPersistence,
{
    let mut options = merklized_state::Options::default();
    let extension = toml::from_str(include_str!("../../api/reward.toml"))?;
    options.extensions.push(extension);

    let mut api =
        merklized_state::define_api::<State, SeqTypes, MT, Ver, ARITY>(&options, api_ver)?;

    api.get("get_latest_reward_balance", move |req, state| {
        async move {
            let address = req.string_param("address")?;
            let account = address
                .parse()
                .map_err(|_| merklized_state::Error::Custom {
                    message: format!("invalid reward address: {address}"),
                    status: StatusCode::BAD_REQUEST,
                })?;

            state
                .load_latest_reward_account_proof_v2(account)
                .await
                .map_err(|err| merklized_state::Error::Custom {
                    message: format!(
                        "failed to load latest reward account proof from storage for account \
                         {account}: {err}"
                    ),
                    status: StatusCode::NOT_FOUND,
                })
                .map(|proof| RewardAmount(proof.balance))
        }
        .boxed()
    })?
    .get("get_latest_reward_account_proof", move |req, state| {
        async move {
            let address = req.string_param("address")?;
            let account = address
                .parse()
                .map_err(|_| merklized_state::Error::Custom {
                    message: format!("invalid reward address: {address}"),
                    status: StatusCode::BAD_REQUEST,
                })?;

            state
                .load_latest_reward_account_proof_v2(account)
                .await
                .map_err(|err| merklized_state::Error::Custom {
                    message: format!(
                        "failed to load latest reward account proof from storage for account \
                         {account}: {err}"
                    ),
                    status: StatusCode::NOT_FOUND,
                })
        }
        .boxed()
    })?
    .get("get_reward_balance", move |req, state| {
        async move {
            let address = req.string_param("address")?;
            let height = req.integer_param("height")?;
            let account = address
                .parse()
                .map_err(|_| merklized_state::Error::Custom {
                    message: format!("invalid reward address: {address}"),
                    status: StatusCode::BAD_REQUEST,
                })?;

            state
                .load_reward_account_proof_v2(height, account)
                .await
                .map_err(|err| merklized_state::Error::Custom {
                    message: format!(
                        "failed to load v2 reward account {address} at height {height}: {err}"
                    ),
                    status: StatusCode::NOT_FOUND,
                })
                .map(|proof| Some(RewardAmount(proof.balance)))
        }
        .boxed()
    })?
    .get("get_reward_amounts", move |req, state| {
        async move {
            let height = req.integer_param("height")?;
            let limit: usize = req.integer_param("limit")?;
            let offset = req.integer_param("offset")?;

            if limit > 10_000 {
                return Err(merklized_state::Error::Custom {
                    message: format!("limit {limit} exceeds maximum allowed 10000"),
                    status: StatusCode::BAD_REQUEST,
                });
            }

            let tree_bytes =
                state
                    .load_tree(height)
                    .await
                    .map_err(|err| merklized_state::Error::Custom {
                        message: format!(
                            "failed to load RewardMerkleTreeV2Data from storage at height \
                             {height}: {err}"
                        ),
                        status: StatusCode::NOT_FOUND,
                    })?;

            let tree_data = bincode::deserialize::<RewardMerkleTreeV2Data>(&tree_bytes)
                .context(
                    "Failed to deserialize RewardMerkleTreeV2 for height {height} from storage; \
                     this should never happen.",
                )
                .map_err(|err| merklized_state::Error::Custom {
                    message: format!(
                        "failed to load RewardMerkleTreeV2Data from storage at height {height}: \
                         {err}"
                    ),
                    status: StatusCode::NOT_FOUND,
                })?;

            let end = std::cmp::min(offset + limit, tree_data.balances.len());

            let result = tree_data
                .balances
                .get(offset..end)
                .ok_or(merklized_state::Error::Custom {
                    message: "Range out of bounds for balances".to_string(),
                    status: StatusCode::NOT_FOUND,
                })?
                .iter()
                .rev()
                .cloned()
                .collect::<Vec<_>>();

            Ok(result)
        }
        .boxed()
    })?
    .get("get_reward_merkle_tree_v2", move |req, state| {
        async move {
            let height = req.integer_param("height")?;

            state
                .load_tree(height)
                .await
                .map_err(|err| merklized_state::Error::Custom {
                    message: format!(
                        "failed to load RewardMerkleTreeV2Data from storage at height {height}: \
                         {err}"
                    ),
                    status: StatusCode::NOT_FOUND,
                })
        }
        .boxed()
    })?;

    match merkle_tree_version {
        RewardMerkleTreeVersion::V1 => {
            api.get("get_reward_account_proof", move |req, state| {
                async move {
                    let address = req.string_param("address")?;
                    let height = req.integer_param("height")?;
                    let account = address
                        .parse()
                        .map_err(|_| merklized_state::Error::Custom {
                            message: format!("invalid reward address: {address}"),
                            status: StatusCode::BAD_REQUEST,
                        })?;

                    state
                        .load_v1_reward_account_proof(height, account)
                        .await
                        .map_err(|err| merklized_state::Error::Custom {
                            message: format!(
                                "failed to load v1 reward account {address} at height {height}: \
                                 {err}"
                            ),
                            status: StatusCode::NOT_FOUND,
                        })
                }
                .boxed()
            })?;
        },
        RewardMerkleTreeVersion::V2 => {
            api.get("get_reward_account_proof", move |req, state| {
                async move {
                    let address = req.string_param("address")?;
                    let height = req.integer_param("height")?;
                    let account = address
                        .parse()
                        .map_err(|_| merklized_state::Error::Custom {
                            message: format!("invalid reward address: {address}"),
                            status: StatusCode::BAD_REQUEST,
                        })?;

                    state
                        .load_reward_account_proof_v2(height, account)
                        .await
                        .map_err(|err| merklized_state::Error::Custom {
                            message: format!(
                                "failed to load v2 reward account {address} at height {height}: \
                                 {err}"
                            ),
                            status: StatusCode::NOT_FOUND,
                        })
                }
                .boxed()
            })?;

            api.get("get_reward_claim_input", move |req, state| {
                async move {
                    let address = req.string_param("address")?;
                    let height = req.integer_param("height")?;
                    let account = address
                        .parse()
                        .map_err(|_| merklized_state::Error::Custom {
                            message: format!("invalid reward address: {address}"),
                            status: StatusCode::BAD_REQUEST,
                        })?;

                    let proof = state
                        .load_reward_account_proof_v2(height, account)
                        .await
                        .map_err(|err| merklized_state::Error::Custom {
                            message: format!(
                                "failed to load v2 reward account {address} at height {height}: \
                                 {err}"
                            ),
                            status: StatusCode::NOT_FOUND,
                        })?;

                    // Auth root inputs (other than the reward merkle tree root) are currently
                    // all zero placeholder values. This may be extended in the future.
                    let claim_input = match proof.to_reward_claim_input() {
                        Ok(input) => input,
                        Err(RewardClaimError::ZeroRewardError) => {
                            return Err(merklized_state::Error::Custom {
                                message: format!(
                                    "zero reward balance for {address} at height {height}"
                                ),
                                status: StatusCode::NOT_FOUND,
                            });
                        },
                        Err(RewardClaimError::ProofConversionError(err)) => {
                            let message = format!(
                                "failed to create solidity proof for {address} at height \
                                 {height}: {err}",
                            );
                            tracing::warn!("{message}");
                            // Normally we would not want to return the internal error via the
                            // API response but this is an error that should never occur. No
                            // secret data involved so it seems fine to return it.
                            return Err(merklized_state::Error::Custom {
                                message,
                                status: StatusCode::INTERNAL_SERVER_ERROR,
                            });
                        },
                    };

                    Ok(claim_input)
                }
                .boxed()
            })?;
        },
    }

    Ok(api)
}

type ExplorerApi<N, P, D, ApiVer> = Api<AvailState<N, P, D>, explorer::Error, ApiVer>;

pub(super) fn explorer<N, P, D>(
    api_ver: semver::Version,
) -> Result<ExplorerApi<N, P, D, SequencerApiVersion>>
where
    N: ConnectedNetwork<PubKey>,
    D: ExplorerDataSource<SeqTypes> + Send + Sync + 'static,
    P: SequencerPersistence,
{
    let api = explorer::define_api::<AvailState<N, P, D>, SeqTypes, _>(
        SequencerApiVersion::instance(),
        api_ver,
    )?;
    Ok(api)
}

pub(super) fn token<S>(api_ver: semver::Version) -> Result<Api<S, node::Error, StaticVersion<0, 1>>>
where
    S: 'static + Send + Sync + ReadState,
    <S as ReadState>::State: Send
        + Sync
        + TokenDataSource<SeqTypes>
        + NodeDataSource<SeqTypes>
        + NodeStateDataSource
        + AvailabilityDataSource<SeqTypes>,
{
    // Extend the base API
    let mut options = node::Options::default();
    let extension = toml::from_str(include_str!("../../api/token.toml"))?;
    options.extensions.push(extension);

    // Create the base API with our extensions
    let mut api =
        node::define_api::<S, SeqTypes, _>(&options, SequencerApiVersion::instance(), api_ver)?;

    // Tack on the application logic
    api.at("get_total_minted_supply", |_, state| {
        async move {
            let value = state
                .read(|state| state.get_total_supply_l1().boxed())
                .await
                .map_err(|err| node::Error::Custom {
                    message: format!("failed to get total supply. err={err:#}"),
                    status: StatusCode::NOT_FOUND,
                })?;

            Ok(format_ether(value))
        }
        .boxed()
    })?;

    api.at("get_circulating_supply", |_, state| {
        async move {
            let calc = fetch_supply_inputs(state).await?;
            Ok(format_ether(calc.circulating_supply()))
        }
        .boxed()
    })?;

    api.at("get_circulating_supply_ethereum", |_, state| {
        async move {
            let calc = fetch_supply_inputs(state).await?;
            Ok(format_ether(calc.circulating_supply_ethereum()))
        }
        .boxed()
    })?;

    api.at("get_total_issued_supply", |_, state| {
        async move {
            let calc = fetch_supply_inputs(state).await?;
            Ok(format_ether(calc.total_issued_supply()))
        }
        .boxed()
    })?;

    // Reuses fetch_supply_inputs for uniformity; the extra Ethereum fetches are cached.
    api.at("get_total_reward_distributed", |_, state| {
        async move {
            let calc = fetch_supply_inputs(state).await?;
            Ok(format_ether(calc.total_reward_distributed()))
        }
        .boxed()
    })?;

    Ok(api)
}

/// Fetch state data and build a [`unlock_schedule::SupplyCalculator`].
async fn fetch_supply_inputs<S: ReadState>(
    state: &S,
) -> Result<unlock_schedule::SupplyCalculator, node::Error>
where
    S::State: Send + Sync + TokenDataSource<SeqTypes> + NodeStateDataSource,
{
    let node_state = state.read(|s| s.node_state().boxed()).await;
    let chain_id = node_state.chain_config.chain_id;

    let header = state.read(|s| s.get_decided_header().boxed()).await;
    let now_secs = header.timestamp_internal();
    let total_reward_distributed = header.total_reward_distributed();

    let initial_supply = state
        .read(|s| s.get_initial_supply_l1().boxed())
        .await
        .map_err(|err| node::Error::Custom {
            message: format!("failed to get initial supply: {err:#}"),
            status: StatusCode::INTERNAL_SERVER_ERROR,
        })?;

    let total_supply_l1 = state
        .read(|s| s.get_total_supply_l1().boxed())
        .await
        .map_err(|err| node::Error::Custom {
            message: format!("failed to get total supply: {err:#}"),
            status: StatusCode::INTERNAL_SERVER_ERROR,
        })?;

    Ok(unlock_schedule::SupplyCalculator::new(
        chain_id,
        now_secs,
        initial_supply,
        total_supply_l1,
        total_reward_distributed,
    ))
}

pub(super) fn node<S>(api_ver: semver::Version) -> Result<Api<S, node::Error, StaticVersion<0, 1>>>
where
    S: 'static + Send + Sync + ReadState,
    <S as ReadState>::State: Send
        + Sync
        + StakeTableDataSource<SeqTypes>
        + NodeDataSource<SeqTypes>
        + AvailabilityDataSource<SeqTypes>
        + PruningDataSource,
{
    // Extend the base API
    let mut options = node::Options::default();
    let extension = toml::from_str(include_str!("../../api/node.toml"))?;
    options.extensions.push(extension);

    // Create the base API with our extensions
    let mut api =
        node::define_api::<S, SeqTypes, _>(&options, SequencerApiVersion::instance(), api_ver)?;

    // Tack on the application logic
    api.at("stake_table", |req, state| {
        async move {
            // Try to get the epoch from the request. If this fails, error
            // as it was probably a mistake
            let epoch = req
                .opt_integer_param("epoch_number")
                .map_err(|_| hotshot_query_service::node::Error::Custom {
                    message: "Epoch number is required".to_string(),
                    status: StatusCode::BAD_REQUEST,
                })?
                .map(EpochNumber::new);

            state
                .read(|state| state.get_stake_table(epoch).boxed())
                .await
                .map_err(|err| node::Error::Custom {
                    message: format!("failed to get stake table for epoch={epoch:?}. err={err:#}"),
                    status: StatusCode::NOT_FOUND,
                })
        }
        .boxed()
    })?
    .at("stake_table_current", |_, state| {
        async move {
            state
                .read(|state| state.get_stake_table_current().boxed())
                .await
                .map_err(|err| node::Error::Custom {
                    message: format!("failed to get current stake table. err={err:#}"),
                    status: StatusCode::NOT_FOUND,
                })
        }
        .boxed()
    })?
    .at("da_stake_table", |req, state| {
        async move {
            // Try to get the epoch from the request. If this fails, error
            // as it was probably a mistake
            let epoch = req
                .opt_integer_param("epoch_number")
                .map_err(|_| hotshot_query_service::node::Error::Custom {
                    message: "Epoch number is required".to_string(),
                    status: StatusCode::BAD_REQUEST,
                })?
                .map(EpochNumber::new);

            state
                .read(|state| state.get_da_stake_table(epoch).boxed())
                .await
                .map_err(|err| node::Error::Custom {
                    message: format!(
                        "failed to get DA stake table for epoch={epoch:?}. err={err:#}"
                    ),
                    status: StatusCode::NOT_FOUND,
                })
        }
        .boxed()
    })?
    .at("da_stake_table_current", |_, state| {
        async move {
            state
                .read(|state| state.get_da_stake_table_current().boxed())
                .await
                .map_err(|err| node::Error::Custom {
                    message: format!("failed to get current DA stake table. err={err:#}"),
                    status: StatusCode::NOT_FOUND,
                })
        }
        .boxed()
    })?
    .at("get_validators", |req, state| {
        async move {
            let epoch = req.integer_param::<_, u64>("epoch_number").map_err(|_| {
                hotshot_query_service::node::Error::Custom {
                    message: "Epoch number is required".to_string(),
                    status: StatusCode::BAD_REQUEST,
                }
            })?;

            state
                .read(|state| state.get_validators(EpochNumber::new(epoch)).boxed())
                .await
                .map_err(|err| hotshot_query_service::node::Error::Custom {
                    message: format!("failed to get validators mapping: err: {err}"),
                    status: StatusCode::NOT_FOUND,
                })
        }
        .boxed()
    })?
    .at("get_all_validators", |req, state| {
        async move {
            let epoch = req.integer_param::<_, u64>("epoch_number").map_err(|_| {
                hotshot_query_service::node::Error::Custom {
                    message: "Epoch number is required".to_string(),
                    status: StatusCode::BAD_REQUEST,
                }
            })?;

            let offset = req.integer_param::<_, u64>("offset")?;

            let limit = req.integer_param::<_, u64>("limit")?;
            if limit > 1000 {
                return Err(hotshot_query_service::node::Error::Custom {
                    message: "Limit cannot be greater than 1000".to_string(),
                    status: StatusCode::BAD_REQUEST,
                });
            }

            state
                .read(|state| {
                    state
                        .get_all_validators(EpochNumber::new(epoch), offset, limit)
                        .boxed()
                })
                .await
                .map_err(|err| hotshot_query_service::node::Error::Custom {
                    message: format!("failed to get all validators : err: {err}"),
                    status: StatusCode::INTERNAL_SERVER_ERROR,
                })
        }
        .boxed()
    })?
    .at("current_proposal_participation", |_, state| {
        async move {
            Ok(state
                .read(|state| state.current_proposal_participation().boxed())
                .await)
        }
        .boxed()
    })?
    .at("proposal_participation", |req, state| {
        async move {
            let epoch = req.integer_param::<_, u64>("epoch").map_err(|_| {
                hotshot_query_service::node::Error::Custom {
                    message: "Epoch number is required".to_string(),
                    status: StatusCode::BAD_REQUEST,
                }
            })?;

            Ok(state
                .read(|state| state.proposal_participation(epoch.into()).boxed())
                .await)
        }
        .boxed()
    })?
    .at("current_vote_participation", |_, state| {
        async move {
            Ok(state
                .read(|state| state.current_vote_participation().boxed())
                .await)
        }
        .boxed()
    })?
    .at("vote_participation", |req, state| {
        async move {
            let epoch = req.integer_param::<_, u64>("epoch").map_err(|_| {
                hotshot_query_service::node::Error::Custom {
                    message: "Epoch number is required".to_string(),
                    status: StatusCode::BAD_REQUEST,
                }
            })?;

            Ok(state
                .read(|state| state.vote_participation(epoch.into()).boxed())
                .await)
        }
        .boxed()
    })?
    .at("get_block_reward", |req, state| {
        async move {
            let epoch = req
                .opt_integer_param::<_, u64>("epoch_number")?
                .map(EpochNumber::new);

            state
                .read(|state| state.get_block_reward(epoch).boxed())
                .await
                .map_err(|err| node::Error::Custom {
                    message: format!("failed to get block reward. err={err:#}"),
                    status: StatusCode::NOT_FOUND,
                })
        }
        .boxed()
    })?
    .at("get_oldest_block", |_req, state| {
        async move {
            state
                .read(|state| state.get_oldest_block().boxed())
                .await
                .map_err(|err| node::Error::Custom {
                    message: format!("failed to get oldest block: {err:#}"),
                    status: StatusCode::INTERNAL_SERVER_ERROR,
                })
        }
        .boxed()
    })?
    .at("get_oldest_leaf", |_req, state| {
        async move {
            state
                .read(|state| state.get_oldest_leaf().boxed())
                .await
                .map_err(|err| node::Error::Custom {
                    message: format!("failed to get oldest leaf: {err:#}"),
                    status: StatusCode::INTERNAL_SERVER_ERROR,
                })
        }
        .boxed()
    })?;

    Ok(api)
}

pub(super) fn database<S, ApiVer: StaticVersionType + 'static>(
    api_ver: semver::Version,
) -> Result<Api<S, Error, ApiVer>>
where
    S: 'static + Send + Sync + ReadState,
    <S as ReadState>::State: Send + Sync + DatabaseMetadataSource,
{
    let toml = toml::from_str::<toml::Value>(include_str!("../../api/database.toml"))?;
    let mut api = Api::<S, Error, ApiVer>::new(toml)?;

    api.with_version(api_ver)
        .at("get_table_sizes", |_req, state| {
            async move {
                state
                    .read(|state| state.get_table_sizes().boxed())
                    .await
                    .map_err(|err| Error::internal(format!("failed to get table sizes: {err:#}")))
            }
            .boxed()
        })?
        .at("get_migration_status", |_req, state| {
            async move {
                state
                    .read(|state| state.get_migration_status().boxed())
                    .await
                    .map_err(|err| {
                        Error::internal(format!("failed to get migration status: {err:#}"))
                    })
            }
            .boxed()
        })?;

    Ok(api)
}

pub(super) fn submit<N, P, S, ApiVer: StaticVersionType + 'static>(
    api_ver: semver::Version,
) -> Result<Api<S, Error, ApiVer>>
where
    N: ConnectedNetwork<PubKey>,
    S: 'static + Send + Sync + ReadState,
    P: SequencerPersistence,
    S::State: Send + Sync + SubmitDataSource<N, P>,
{
    let toml = toml::from_str::<toml::Value>(include_str!("../../api/submit.toml"))?;
    let mut api = Api::<S, Error, ApiVer>::new(toml)?;

    api.with_version(api_ver).at("submit", |req, state| {
        async move {
            let tx = req
                .body_auto::<Transaction, ApiVer>(ApiVer::instance())
                .map_err(Error::from_request_error)?;

            let hash = tx.commit();
            state
                .read(|state| state.submit(tx).boxed())
                .await
                .map_err(|err| Error::internal(err.to_string()))?;
            Ok(hash)
        }
        .boxed()
    })?;

    Ok(api)
}

pub(super) fn state_signature<N, S, ApiVer: StaticVersionType + 'static>(
    _: ApiVer,
    api_ver: semver::Version,
) -> Result<Api<S, Error, ApiVer>>
where
    N: ConnectedNetwork<PubKey>,
    S: 'static + Send + Sync + ReadState,
    S::State: Send + Sync + StateSignatureDataSource<N>,
{
    let toml = toml::from_str::<toml::Value>(include_str!("../../api/state_signature.toml"))?;
    let mut api = Api::<S, Error, ApiVer>::new(toml)?;
    api.with_version(api_ver);

    api.get("get_state_signature", |req, state| {
        async move {
            let height = req
                .integer_param("height")
                .map_err(Error::from_request_error)?;
            state
                .get_state_signature(height)
                .await
                .ok_or(tide_disco::Error::catch_all(
                    StatusCode::NOT_FOUND,
                    "Signature not found.".to_owned(),
                ))
        }
        .boxed()
    })?;

    Ok(api)
}

pub(super) fn catchup<S, ApiVer: StaticVersionType + 'static>(
    _: ApiVer,
    api_ver: semver::Version,
) -> Result<Api<S, Error, ApiVer>>
where
    S: 'static + Send + Sync + ReadState,
    S::State: Send + Sync + NodeStateDataSource + CatchupDataSource,
{
    let toml = toml::from_str::<toml::Value>(include_str!("../../api/catchup.toml"))?;
    let mut api = Api::<S, Error, ApiVer>::new(toml)?;
    api.with_version(api_ver);

    let parse_height_view = |req: &RequestParams| -> Result<(u64, ViewNumber), Error> {
        let height = req
            .integer_param("height")
            .map_err(Error::from_request_error)?;
        let view = req
            .integer_param("view")
            .map_err(Error::from_request_error)?;
        Ok((height, ViewNumber::new(view)))
    };

    let parse_fee_account = |req: &RequestParams| -> Result<FeeAccount, Error> {
        let raw = req
            .string_param("address")
            .map_err(Error::from_request_error)?;
        raw.parse().map_err(|err| {
            Error::catch_all(
                StatusCode::BAD_REQUEST,
                format!("malformed fee account {raw}: {err}"),
            )
        })
    };

    let parse_reward_account = |req: &RequestParams| -> Result<RewardAccountV2, Error> {
        let raw = req
            .string_param("address")
            .map_err(Error::from_request_error)?;
        raw.parse().map_err(|err| {
            Error::catch_all(
                StatusCode::BAD_REQUEST,
                format!("malformed reward account {raw}: {err}"),
            )
        })
    };

    api.get("account", move |req, state| {
        async move {
            let (height, view) = parse_height_view(&req)?;
            let account = parse_fee_account(&req)?;
            state
                .get_account(&state.node_state().await, height, view, account)
                .await
                .map_err(|err| Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}")))
        }
        .boxed()
    })?
    .at("accounts", move |req, state| {
        async move {
            let (height, view) = parse_height_view(&req)?;
            let accounts = req
                .body_auto::<Vec<FeeAccount>, ApiVer>(ApiVer::instance())
                .map_err(Error::from_request_error)?;

            state
                .read(|state| {
                    async move {
                        state
                            .get_accounts(&state.node_state().await, height, view, &accounts)
                            .await
                            .map_err(|err| {
                                Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}"))
                            })
                    }
                    .boxed()
                })
                .await
        }
        .boxed()
    })?
    .get("reward_account", move |req, state| {
        async move {
            let (height, view) = parse_height_view(&req)?;
            let account = parse_reward_account(&req)?;
            state
                .get_reward_account_v1(&state.node_state().await, height, view, account.into())
                .await
                .map_err(|err| Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}")))
        }
        .boxed()
    })?
    .at("reward_accounts", move |req, state| {
        async move {
            let (height, view) = parse_height_view(&req)?;
            let accounts = req
                .body_auto::<Vec<RewardAccountV1>, ApiVer>(ApiVer::instance())
                .map_err(Error::from_request_error)?;

            state
                .read(|state| {
                    async move {
                        state
                            .get_reward_accounts_v1(
                                &state.node_state().await,
                                height,
                                view,
                                &accounts,
                            )
                            .await
                            .map_err(|err| {
                                Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}"))
                            })
                    }
                    .boxed()
                })
                .await
        }
        .boxed()
    })?
    .get("reward_account_v2", move |req, state| {
        async move {
            let (height, view) = parse_height_view(&req)?;
            let account = parse_reward_account(&req)?;

            state
                .get_reward_account_v2(&state.node_state().await, height, view, account)
                .await
                .map_err(|err| Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}")))
        }
        .boxed()
    })?
    .get("reward_amounts", move |_req, _state| {
        async move {
            Err::<u64, _>(Error::catch_all(
                StatusCode::NOT_FOUND,
                "catchup/reward-amounts is deprecated".to_string(),
            ))
        }
        .boxed()
    })?
    .at("reward_accounts_v2", move |_req, _state| {
        async move {
            Err::<u64, _>(Error::catch_all(
                StatusCode::NOT_FOUND,
                "catchup/reward-accounts-v2 is deprecated".to_string(),
            ))
        }
        .boxed()
    })?
    .get("blocks", |req, state| {
        async move {
            let height = req
                .integer_param("height")
                .map_err(Error::from_request_error)?;
            let view = req
                .integer_param("view")
                .map_err(Error::from_request_error)?;

            state
                .get_frontier(&state.node_state().await, height, ViewNumber::new(view))
                .await
                .map_err(|err| Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}")))
        }
        .boxed()
    })?
    .get("chainconfig", |req, state| {
        async move {
            let commitment = req
                .blob_param("commitment")
                .map_err(Error::from_request_error)?;

            state
                .get_chain_config(commitment)
                .await
                .map_err(|err| Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}")))
        }
        .boxed()
    })?
    .get("leafchain", |req, state| {
        async move {
            let height = req
                .integer_param("height")
                .map_err(Error::from_request_error)?;
            state
                .get_leaf_chain(height)
                .await
                .map_err(|err| Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}")))
        }
        .boxed()
    })?
    .get("cert2", |req, state| {
        async move {
            let height = req
                .integer_param("height")
                .map_err(Error::from_request_error)?;
            let response = state
                .get_cert2(height)
                .await
                .map_err(|err| Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}")))?;
            response.ok_or_else(|| {
                Error::catch_all(
                    StatusCode::NOT_FOUND,
                    format!("no cert2 available for height {height}"),
                )
            })
        }
        .boxed()
    })?
    .get("reward_merkle_tree_v2", move |req, state| {
        async move {
            let (height, view) = parse_height_view(&req)?;
            state
                .get_reward_merkle_tree_v2(height, view)
                .await
                .map_err(|err| Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}")))
        }
        .boxed()
    })?
    .get("state_cert", |req, state| {
        async move {
            let epoch = req
                .integer_param("epoch")
                .map_err(Error::from_request_error)?;
            state
                .get_state_cert(epoch)
                .await
                .map_err(|err| Error::catch_all(StatusCode::NOT_FOUND, format!("{err:#}")))
        }
        .boxed()
    })?;

    Ok(api)
}

type MerklizedStateApi<N, P, D, ApiVer> = Api<AvailState<N, P, D>, merklized_state::Error, ApiVer>;
pub(super) fn merklized_state<N, P, D, S, const ARITY: usize>(
    api_ver: semver::Version,
) -> Result<MerklizedStateApi<N, P, D, SequencerApiVersion>>
where
    N: ConnectedNetwork<PubKey>,
    D: MerklizedStateDataSource<SeqTypes, S, ARITY>
        + Send
        + Sync
        + MerklizedStateHeightPersistence
        + 'static,
    S: MerklizedState<SeqTypes, ARITY>,
    P: SequencerPersistence,
    for<'a> <S::Commit as TryFrom<&'a TaggedBase64>>::Error: std::fmt::Display,
{
    let api = merklized_state::define_api::<
        AvailState<N, P, D>,
        SeqTypes,
        S,
        SequencerApiVersion,
        ARITY,
    >(&Default::default(), api_ver)?;
    Ok(api)
}

pub(super) fn config<S, ApiVer: StaticVersionType + 'static>(
    _: ApiVer,
    api_ver: semver::Version,
    public_node_config: Option<PublicNodeConfig>,
) -> Result<Api<S, Error, ApiVer>>
where
    S: 'static + Send + Sync + ReadState,
    S::State: Send + Sync + HotShotConfigDataSource,
{
    let toml = toml::from_str::<toml::Value>(include_str!("../../api/config.toml"))?;
    let mut api = Api::<S, Error, ApiVer>::new(toml)?;
    api.with_version(api_ver);

    let env_variables = get_public_env_vars()
        .map_err(|err| Error::catch_all(StatusCode::INTERNAL_SERVER_ERROR, format!("{err:#}")))?;

    api.get("hotshot", |_, state| {
        async move { Ok(state.get_config().await) }.boxed()
    })?
    .get("env", move |_, _| {
        {
            let env_variables = env_variables.clone();
            async move { Ok(env_variables) }
        }
        .boxed()
    })?
    .get("runtime", move |_, _| {
        let public_node_config = public_node_config.clone();
        async move {
            public_node_config.ok_or_else(|| {
                Error::catch_all(
                    StatusCode::NOT_FOUND,
                    "runtime config not available".to_string(),
                )
            })
        }
        .boxed()
    })?;

    Ok(api)
}

pub(super) fn get_public_env_vars() -> Result<Vec<String>> {
    let toml: toml::Value = toml::from_str(include_str!("../../api/public-env-vars.toml"))?;

    let keys = toml
        .get("variables")
        .ok_or_else(|| toml::de::Error::custom("variables not found"))?
        .as_array()
        .ok_or_else(|| toml::de::Error::custom("variables is not an array"))?
        .clone()
        .into_iter()
        .map(|v| v.try_into())
        .collect::<Result<BTreeSet<String>, toml::de::Error>>()?;

    let hashmap: HashMap<String, String> = env::vars().collect();
    let mut public_env_vars: Vec<String> = Vec::new();
    for key in keys {
        let value = hashmap.get(&key).cloned().unwrap_or_default();
        public_env_vars.push(format!("{key}={value}"));
    }

    Ok(public_env_vars)
}