Struct Aggregator

pub struct Aggregator {
    pub(crate) rpc: ExtendedBitcoinRpc,
    pub(crate) db: Database,
    pub(crate) config: BridgeConfig,
    pub(crate) tx_sender: TxSenderClient,
    operator_clients: Vec<ClementineOperatorClient<Channel>>,
    verifier_clients: Vec<ClementineVerifierClient<Channel>>,
    verifier_keys: Arc<RwLock<Vec<Option<PublicKey>>>>,
    operator_keys: Arc<RwLock<Vec<Option<XOnlyPublicKey>>>>,
}

Aggregator struct. This struct is responsible for aggregating partial signatures from the verifiers. It will have in total 3 * num_operator + 1 aggregated nonces. [0] -> Aggregated nonce for the move transaction. [1..num_operator + 1] -> Aggregated nonces for the operator_takes transactions. [num_operator + 1..2 * num_operator + 1] -> Aggregated nonces for the slash_or_take transactions. [2 * num_operator + 1..3 * num_operator + 1] -> Aggregated nonces for the burn transactions. For now, we do not have the last bit.

Fields

rpc: ExtendedBitcoinRpc

db: Database

config: BridgeConfig

tx_sender: TxSenderClient

operator_clients: Vec<ClementineOperatorClient<Channel>>

verifier_clients: Vec<ClementineVerifierClient<Channel>>

verifier_keys: Arc<RwLock<Vec<Option<PublicKey>>>>

operator_keys: Arc<RwLock<Vec<Option<XOnlyPublicKey>>>>

Implementations

impl Aggregator

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

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 + Eq + StdHash + Debug, 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

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.

async fn fetch_all_entity_keys( &self, ) -> (Vec<Option<XOnlyPublicKey>>, Vec<Option<PublicKey>>)

Helper function to fetch keys for both operators and verifiers. Returns (operator_keys, verifier_keys) without failing if some entities are unreachable.

fn add_unreachable_entity_errors<T, F>( results: &mut Vec<T>, operator_keys: &[Option<XOnlyPublicKey>], verifier_keys: &[Option<PublicKey>], error_constructor: F, )

where F: Fn(EntityType, String, String) -> T,

Helper function to add error entries for entities where keys couldn’t be collected.

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.

pub async fn get_compatibility_data_from_entities( &self, ) -> Result<Vec<EntityDataWithId>, BridgeError>

pub async fn check_compatibility_with_actors( &self, verifiers_included: bool, operators_included: bool, ) -> Result<(), BridgeError>

Checks compatibility with other actors. Returns an error if aggregator is not compatible with any of the other actors, or any other actor returns an error.

impl Aggregator

fn extract_pub_nonce( response: Option<Response>, ) -> Result<PublicNonce, BridgeError>

async fn collect_operator_sigs( operator_clients: ParticipatingOperators, config: BridgeConfig, deposit_sign_session: DepositSignSession, ) -> Result<Vec<Vec<Signature>>, BridgeError>

For a specific deposit, collects needed signatures from all operators into a Vec<Vec<Signature>>.

async fn create_movetx( &self, partial_sigs: Vec<Vec<u8>>, movetx_agg_and_pub_nonces: (AggregatedNonce, Vec<PublicNonce>), 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_and_pub_nonces: (AggregatedNonce, Vec<PublicNonce>), deposit_params: DepositParams, ) -> Result<(), BridgeError>

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

Trait Implementations

impl ActorWithConfig for Aggregator

fn get_config(&self) -> &BridgeConfig

fn get_compatibility_params(&self) -> Result<CompatibilityParams, BridgeError>

fn is_compatible( &self, others: Vec<(String, CompatibilityParams)>, ) -> Result<(), BridgeError>

Returns an error with reason if not compatible, otherwise returns Ok(())

impl Clone for Aggregator

fn clone(&self) -> Aggregator

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Aggregator

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

Formats the value using the given formatter.