Struct AggregatorServer

pub struct AggregatorServer {
    pub aggregator: Aggregator,
    background_tasks: BackgroundTaskManager,
}

Aggregator server wrapper that manages background tasks.

Fields

aggregator: Aggregator

background_tasks: BackgroundTaskManager

Implementations

impl AggregatorServer

pub async fn new(config: BridgeConfig) -> Result<Self, BridgeError>

pub async fn start_background_tasks(&self) -> Result<(), BridgeError>

Starts the background tasks for the aggregator. If called multiple times, it will restart only the tasks that are not already running.

pub async fn shutdown(&mut self)

Methods from Deref<Target = Aggregator>

pub fn get_verifier_clients(&self) -> &[ClementineVerifierClient<Channel>]

async fn fetch_pubkeys_from_entities<T, C, F, Fut>( &self, clients: &[C], keys_storage: &RwLock<Vec<Option<T>>>, pubkey_fetcher: F, key_type_name: &str, ) -> Result<Vec<T>, BridgeError>

where T: Clone + Send + Sync, C: Clone + Send + Sync, F: Fn(C) -> Fut + Send + Sync, Fut: Future<Output = Result<T, BridgeError>> + Send,

Generic helper function to fetch keys from clients

pub async fn fetch_verifier_keys(&self) -> Result<Vec<PublicKey>, BridgeError>

If all verifier keys are already collected, returns them. Otherwise, it tries to collect them from the verifiers, saves them and returns them.

pub async fn fetch_operator_keys( &self, ) -> Result<Vec<XOnlyPublicKey>, BridgeError>

If all operator keys are already collected, returns them. Otherwise, it tries to collect them from the operators, saves them and returns them.

pub fn get_operator_clients(&self) -> &[ClementineOperatorClient<Channel>]

pub async fn collect_and_distribute_keys( &self, deposit_params: &DepositParams, ) -> Result<(), BridgeError>

Collects and distributes keys to verifiers from operators and watchtowers for the new deposit for operators: get bitvm assert winternitz public keys and watchtower challenge ack hashes for watchtowers: get winternitz public keys for watchtower challenges

async fn _aggregate_move_partial_sigs( &self, deposit_data: &mut DepositData, agg_nonce: &AggregatedNonce, partial_sigs: Vec<PartialSignature>, ) -> Result<Signature, BridgeError>

pub async fn get_participating_verifiers( &self, deposit_data: &DepositData, ) -> Result<ParticipatingVerifiers, BridgeError>

Returns a list of verifier clients that are participating in the deposit.

pub async fn get_participating_operators( &self, deposit_data: &DepositData, ) -> Result<ParticipatingOperators, BridgeError>

Returns a list of operator clients that are participating in the deposit.

pub async fn get_entity_statuses( &self, restart_tasks: bool, ) -> Result<Vec<EntityStatusWithId>, BridgeError>

Retrieves the status of all entities (operators and verifiers) and restarts background tasks if needed. Returns a vector of EntityStatusWithId. Only returns an error if restarting tasks fails when requested.

async fn create_movetx( &self, partial_sigs: Vec<Vec<u8>>, movetx_agg_nonce: AggregatedNonce, deposit_params: DepositParams, ) -> Result<TxHandler<Signed>, Status>

async fn verify_and_save_emergency_stop_sigs( &self, emergency_stop_sigs: Vec<Vec<u8>>, emergency_stop_agg_nonce: AggregatedNonce, deposit_params: DepositParams, ) -> Result<(), BridgeError>

pub async fn send_emergency_stop_tx( &self, tx: Transaction, ) -> Result<Transaction, Status>

Trait Implementations

impl ClementineAggregator for AggregatorServer

fn new_deposit<'life0, 'async_trait>( &'life0 self, request: Request<Deposit>, ) -> Pin<Box<dyn Future<Output = Result<Response<RawSignedTx>, Status>> + Send + 'async_trait>>

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

Handles a new deposit request from a user. This function coordinates the signing process between verifiers to create a valid move transaction. It ensures a covenant using pre-signed NofN transactions. It also collects signatures from operators to ensure that the operators can be slashed if they act maliciously.

Overview:

1. Receive and parse deposit parameters from user
2. Signs all NofN transactions with verifiers using MuSig2:
   • Creates nonce streams with verifiers (get pub nonces for each transaction)
   • Opens deposit signing streams with verifiers (sends aggnonces for each transaction, receives partial sigs)
   • Opens deposit finalization streams with verifiers (sends final signatures, receives movetx signatures)
3. Collects signatures from operators
4. Waits for all tasks to complete
5. Returns signed move transaction

The following pipelines are used to coordinate the signing process, these move the data between the verifiers and the aggregator:

• Nonce aggregation
• Nonce distribution
• Signature aggregation
• Signature distribution

fn vergen<'life0, 'async_trait>( &'life0 self, _request: Request<Empty>, ) -> Pin<Box<dyn Future<Output = Result<Response<VergenResponse>, Status>> + Send + 'async_trait>>

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

fn get_entity_statuses<'life0, 'async_trait>( &'life0 self, request: Request<GetEntityStatusesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<EntityStatuses>, Status>> + Send + 'async_trait>>

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

Returns the current status of tasks running on the operators/verifiers. If restart_tasks is true, it will restart the tasks on the entities if they are stopped.

fn optimistic_payout<'life0, 'async_trait>( &'life0 self, request: Request<OptimisticWithdrawParams>, ) -> Pin<Box<dyn Future<Output = Result<Response<RawSignedTx>, Status>> + Send + 'async_trait>>

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

Perform an optimistic payout to reimburse a peg-out from Citrea

fn internal_send_tx<'life0, 'async_trait>( &'life0 self, request: Request<SendTxRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

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

Send a pre-signed tx to the network

fn setup<'life0, 'async_trait>( &'life0 self, _request: Request<Empty>, ) -> Pin<Box<dyn Future<Output = Result<Response<VerifierPublicKeys>, Status>> + Send + 'async_trait>>

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

Sets up the system of verifiers, watchtowers and operators by:

fn withdraw<'life0, 'async_trait>( &'life0 self, request: Request<AggregatorWithdrawalInput>, ) -> Pin<Box<dyn Future<Output = Result<Response<AggregatorWithdrawResponse>, Status>> + Send + 'async_trait>>

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

Call’s withdraw on all operators Used by the clementine-backend service to initiate a withdrawal If the operator’s xonly public keys list is empty, the withdrawal will be sent to all operators. If not, only the operators in the list will be sent the withdrawal request.

fn get_nofn_aggregated_xonly_pk<'life0, 'async_trait>( &'life0 self, __arg1: Request<Empty>, ) -> Pin<Box<dyn Future<Output = Result<Response<NofnResponse>, Status>> + Send + 'async_trait>>

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

fn internal_get_emergency_stop_tx<'life0, 'async_trait>( &'life0 self, request: Request<GetEmergencyStopTxRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetEmergencyStopTxResponse>, Status>> + Send + 'async_trait>>

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

Creates an emergency stop tx that won’t be broadcasted. Tx will have around 3 sats/vbyte fee. Set add_anchor to true to add an anchor output for cpfp..

fn send_move_to_vault_tx<'life0, 'async_trait>( &'life0 self, request: Request<SendMoveTxRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Txid>, Status>> + Send + 'async_trait>>

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

impl Debug for AggregatorServer

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

Formats the value using the given formatter.

impl Deref for AggregatorServer

type Target = Aggregator

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.