Struct ConfigGenApi

pub struct ConfigGenApi {
    state: Arc<Mutex<ConfigGenState>>,
    db: Database,
    config_generated_tx: Sender<ServerConfig>,
    task_group: TaskGroup,
    code_version_str: String,
    api_secret: Option<String>,
    p2p_bind_addr: SocketAddr,
    bitcoin_status_cache: Arc<RwLock<Option<(Instant, BitcoinRpcConnectionStatus)>>>,
    bitcoin_status_cache_duration: Duration,
}

Serves the config gen API endpoints

Fields

state: Arc<Mutex<ConfigGenState>>

In-memory state machine

db: Database

DB not really used

config_generated_tx: Sender<ServerConfig>

Tracks when the config is generated

task_group: TaskGroup

Task group for running DKG

code_version_str: String

Code version str that will get encoded in consensus hash

api_secret: Option<String>

Api secret to use

p2p_bind_addr: SocketAddr

bitcoin_status_cache: Arc<RwLock<Option<(Instant, BitcoinRpcConnectionStatus)>>>

bitcoin_status_cache_duration: Duration

Implementations

impl ConfigGenApi

pub fn new( p2p_bind_addr: SocketAddr, settings: ConfigGenSettings, db: Database, config_generated_tx: Sender<ServerConfig>, task_group: &TaskGroup, code_version_str: String, api_secret: Option<String>, ) -> Self

pub async fn set_password(&self, auth: ApiAuth) -> ApiResult<()>

async fn require_status( &self, status: ServerStatus, ) -> ApiResult<MutexGuard<'_, ConfigGenState>>

async fn require_any_status( &self, statuses: &[ServerStatus], ) -> ApiResult<MutexGuard<'_, ConfigGenState>>

pub async fn set_config_gen_connections( &self, request: ConfigGenConnectionsRequest, ) -> ApiResult<()>

Sets our connection info, possibly sending it to a leader

async fn update_leader(&self) -> ApiResult<()>

Sends our updated peer info to the leader (if we have one)

pub async fn add_config_gen_peer(&self, peer: PeerServerParams) -> ApiResult<()>

Called from set_config_gen_connections to add a peer’s connection info to the leader

pub async fn config_gen_peers(&self) -> ApiResult<Vec<PeerServerParams>>

Returns the peers that have called add_config_gen_peer on the leader

pub async fn default_config_gen_params( &self, ) -> ApiResult<ConfigGenParamsRequest>

Returns default config gen params that can be modified by the leader

pub async fn set_config_gen_params( &self, request: ConfigGenParamsRequest, ) -> ApiResult<()>

Sets and validates the config gen params

The leader passes consensus params, everyone passes local params

async fn get_requested_params(&self) -> ApiResult<ConfigGenParamsRequest>

pub async fn consensus_config_gen_params( &self, request: &ConfigGenParamsRequest, ) -> ApiResult<ConfigGenParamsResponse>

Gets the consensus config gen params

pub async fn run_dkg(&self) -> ApiResult<()>

Once configs are generated, updates status to ReadyForConfigGen and spawns a task to coordinate DKG, then returns. Coordinating DKG in a separate thread allows clients to poll the server status instead of blocking until completion, which can be fragile due to timeouts, poor network connections, etc.

Calling a second time will return an error.

pub async fn verify_config_hash(&self) -> ApiResult<BTreeMap<PeerId, Hash>>

Returns tagged hashes of consensus config to be shared with other peers. The hashes are tagged with the peer id such that they are unique to each peer and their manual verification by the guardians via the UI is more robust.

pub async fn verified_configs(&self) -> ApiResult<()>

We have verified all our peer configs

pub async fn start_consensus(&self) -> ApiResult<()>

pub async fn server_status(&self) -> ServerStatus

Returns the server status

fn bad_request<T>(msg: &str) -> ApiResult<T>

pub async fn restart_federation_setup(&self) -> ApiResult<()>

async fn await_leader_restart(&self, client: &DynGlobalApi) -> ApiResult<()>

async fn await_peer_restart(&self)

pub async fn check_bitcoin_status( &self, ) -> ApiResult<BitcoinRpcConnectionStatus>

async fn fetch_bitcoin_status() -> ApiResult<BitcoinRpcConnectionStatus>

Trait Implementations

impl Clone for ConfigGenApi

fn clone(&self) -> ConfigGenApi

Returns a copy of the value.

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

Performs copy-assignment from source.

impl HasApiContext<ConfigGenApi> for ConfigGenApi

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

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