Struct ConsensusApi 

pub struct ConsensusApi {

    pub cfg: ServerConfig,
    pub db: Database,
    pub modules: ServerModuleRegistry,
    pub client_cfg: ClientConfig,
    pub force_api_secret: Option<String>,
    pub submission_sender: Sender<ConsensusItem>,
    pub shutdown_receiver: Receiver<Option<ScheduledShutdown>>,
    pub shutdown_sender: Sender<Option<ScheduledShutdown>>,
    pub ord_latency_receiver: Receiver<Option<Duration>>,
    pub accepted_item_receiver: Receiver<()>,
    pub completed_session_receiver: Receiver<Option<Arc<CachedSessionOutcome>>>,
    pub p2p_status_receivers: P2PStatusReceivers,
    pub ci_status_receivers: BTreeMap<PeerId, Receiver<Option<u64>>>,
    pub bitcoin_rpc_connection: ServerBitcoinRpcMonitor,
    pub supported_api_versions: SupportedApiVersionsSummary,
    pub auth_ui: Option<ApiAuth>,
    pub auth_api: Option<ApiAuth>,
    pub code_version_str: String,
    pub code_version_hash: String,
    pub task_group: TaskGroup,
}

Fields

cfg: ServerConfig

Our server configuration

db: Database

Database for serving the API

modules: ServerModuleRegistry

Modules registered with the federation

client_cfg: ClientConfig

Cached client config

force_api_secret: Option<String>

submission_sender: Sender<ConsensusItem>

For sending API events to consensus such as transactions

shutdown_receiver: Receiver<Option<ScheduledShutdown>>

shutdown_sender: Sender<Option<ScheduledShutdown>>

ord_latency_receiver: Receiver<Option<Duration>>

accepted_item_receiver: Receiver<()>

Notified whenever consensus accepts an item.

completed_session_receiver: Receiver<Option<Arc<CachedSessionOutcome>>>

Notified whenever consensus completes a session.

p2p_status_receivers: P2PStatusReceivers

ci_status_receivers: BTreeMap<PeerId, Receiver<Option<u64>>>

bitcoin_rpc_connection: ServerBitcoinRpcMonitor

supported_api_versions: SupportedApiVersionsSummary

auth_ui: Option<ApiAuth>

auth_api: Option<ApiAuth>

code_version_str: String

code_version_hash: String

task_group: TaskGroup

Implementations

impl ConsensusApi

pub fn api_versions_summary(&self) -> &SupportedApiVersionsSummary

pub fn get_active_api_secret(&self) -> Option<String>

pub async fn submit_transaction( &self, transaction: Transaction, ) -> Result<TransactionId, TransactionError>

pub async fn await_transaction( &self, txid: TransactionId, ) -> (Vec<ModuleInstanceId>, DatabaseTransaction<'_, Committable>)

pub async fn await_output_outcome( &self, outpoint: OutPoint, ) -> Result<SerdeModuleEncoding<DynOutputOutcome>>

pub async fn await_outputs_outcomes( &self, outpoint_range: OutPointRange, ) -> Result<Vec<Option<SerdeModuleEncoding<DynOutputOutcome>>>>

pub fn session_count(&self) -> u64

async fn await_session_outcome( &self, index: u64, format: OutcomeFormat, ) -> Arc<Value>

pub async fn session_status(&self, session_index: u64) -> SessionStatusV2

pub fn get_federation_status(&self) -> ApiResult<LegacyFederationStatus>

fn shutdown(&self, index: Option<u64>)

fn shutdown_after_current_session(&self)

Schedules a shutdown for the session that is running now. The consensus loop shuts down at the first session boundary at or after the scheduled session, so a session that completes while this request is handled defers the shutdown to the end of the next one instead of cancelling it. Repeating the request never moves a shutdown that is already due by then to a later session.

Unlike shutdown, the resulting stop is reported as ShutdownRequest::AfterCurrentSession, so the process running the server can tell it apart from a shutdown scheduled for a given session.

async fn get_federation_audit(&self) -> ApiResult<AuditSummary>

fn get_guardian_config_backup( &self, _auth: &GuardianAuthToken, ) -> GuardianConfigBackup

Uses the in-memory config to write a config backup tar archive that guardians can download. Private keys are stored as plaintext JSON. Operators should rely on disk encryption for at-rest protection.

async fn handle_backup_request( &self, dbtx: &mut DatabaseTransaction<'_>, request: SignedBackupRequest, ) -> Result<(), ApiError>

async fn handle_recover_request( &self, dbtx: &mut DatabaseTransaction<'_>, id: PublicKey, ) -> Option<ClientBackupSnapshot>

async fn api_announcements(&self) -> BTreeMap<PeerId, SignedApiAnnouncement>

List API URL announcements from all peers we have received them from (at least ourselves)

fn fedimintd_version(&self) -> String

Returns the tagged fedimintd version currently running

async fn submit_api_announcement( &self, peer_id: PeerId, announcement: SignedApiAnnouncement, ) -> Result<(), ApiError>

Add an API URL announcement from a peer to our database to be returned by ConsensusApi::api_announcements.

async fn sign_api_announcement(&self, new_url: SafeUrl) -> SignedApiAnnouncement

async fn guardian_metadata_list( &self, ) -> BTreeMap<PeerId, SignedGuardianMetadata>

async fn submit_guardian_metadata( &self, peer_id: PeerId, metadata: SignedGuardianMetadata, ) -> Result<(), ApiError>

async fn sign_guardian_metadata( &self, new_metadata: GuardianMetadata, ) -> SignedGuardianMetadata

async fn get_invite_code(&self, api_secret: Option<String>) -> InviteCode

Trait Implementations

impl Clone for ConsensusApi

fn clone(&self) -> ConsensusApi

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl HasApiContext<ConsensusApi> for ConsensusApi

fn context<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 ApiRequestErased, id: Option<ModuleInstanceId>, ) -> Pin<Box<dyn Future<Output = (&ConsensusApi, ApiEndpointContext)> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl HasApiContext<DynServerModule> for ConsensusApi

fn context<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 ApiRequestErased, id: Option<ModuleInstanceId>, ) -> Pin<Box<dyn Future<Output = (&DynServerModule, ApiEndpointContext)> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl IDashboardApi for ConsensusApi

fn auth_ui(&self) -> Option<ApiAuth>

Password protecting the dashboard UI login form. None means the UI is served without a login form.

fn guardian_id<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = PeerId> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the guardian ID

fn guardian_names<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = BTreeMap<PeerId, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get a map of peer IDs to guardian names

fn federation_name<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the federation name

fn session_count<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = u64> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the current active session count

fn get_session_status<'life0, 'async_trait>( &'life0 self, session_idx: u64, ) -> Pin<Box<dyn Future<Output = SessionStatusV2> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get items in a given session

fn consensus_ord_latency<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Option<Duration>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The time it took to order our last proposal in the current session

fn p2p_connection_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = BTreeMap<PeerId, Option<P2PConnectionStatus>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a map of peer ID to connection status (None = disconnected)

fn federation_invite_code<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the federation invite code to share with users

fn federation_audit<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = AuditSummary> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the federation audit summary

fn bitcoin_rpc_url<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = SafeUrl> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the url of the bitcoin rpc

fn bitcoin_rpc_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Option<ServerBitcoinRpcStatus>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the status of the bitcoin backend

fn download_guardian_config_backup<'life0, 'life1, 'async_trait>( &'life0 self, guardian_auth: &'life1 GuardianAuthToken, ) -> Pin<Box<dyn Future<Output = GuardianConfigBackup> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Download a backup of the guardian’s configuration

fn get_module_by_kind(&self, kind: ModuleKind) -> Option<&DynServerModule>

Get reference to a server module instance by module kind

fn fedimintd_version<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the fedimintd version

fn fedimintd_version_hash<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Option<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the git hash of the fedimintd binary, or None if it is not available (e.g. it was built outside a git checkout).

fn into_dyn(self) -> Arc<dyn IDashboardApi + Send + Sync>

where Self: Sized + Send + Sync + 'static,

Create a trait object