Struct Verifier

pub struct Verifier<C: CitreaClientT> {
    pub citrea_client: C,
    /* private fields */
}

Fields

citrea_client: C

Implementations

impl<C> Verifier<C>

where C: CitreaClientT,

pub async fn create_watchtower_challenge( &self, transaction_data: TransactionRequestData, commit_data: &[u8], ) -> Result<(TransactionType, Transaction, RbfSigningInfo), BridgeError>

Creates and signs the watchtower challenge with the given commit data.

Arguments

• transaction_data - Data to identify the deposit and kickoff.
• commit_data - Commit data for the watchtower challenge.

Returns

A tuple of: 1. TransactionType: WatchtowerChallenge 2. Transaction: Signed watchtower challenge transaction 3. RbfSigningInfo: Rbf signing info for the watchtower challenge (for re-signing the transaction after a rbf input is added to the tx)

pub async fn create_and_sign_unspent_kickoff_connector_txs( &self, round_idx: RoundIndex, operator_xonly_pk: XOnlyPublicKey, ) -> Result<Vec<(TransactionType, Transaction)>, BridgeError>

Creates and signs all the unspent kickoff connector (using the previously saved signatures from operator during setup) transactions for a single round of an operator.

Arguments

• round_idx - Index of the round.
• operator_xonly_pk - Operator’s x-only public key.

Returns

A vector of tuples: 1. TransactionType: UnspentKickoff(idx) for idx’th kickoff in the round 2. Transaction: Signed unspent kickoff connector transaction

impl<C> Verifier<C>

where C: CitreaClientT,

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

pub async fn set_operator( &self, collateral_funding_outpoint: OutPoint, operator_xonly_pk: XOnlyPublicKey, wallet_reimburse_address: Address, operator_winternitz_public_keys: Vec<PublicKey>, unspent_kickoff_sigs: Vec<Signature>, ) -> Result<(), BridgeError>

pub async fn nonce_gen( &self, num_nonces: u32, ) -> Result<(u32, Vec<PublicNonce>), BridgeError>

pub async fn deposit_sign( &self, deposit_data: DepositData, session_id: u32, agg_nonce_rx: Receiver<AggregatedNonce>, ) -> Result<Receiver<PartialSignature>, BridgeError>

pub async fn deposit_finalize( &self, deposit_data: &mut DepositData, session_id: u32, sig_receiver: Receiver<Signature>, agg_nonce_receiver: Receiver<AggregatedNonce>, operator_sig_receiver: Receiver<Signature>, ) -> Result<(PartialSignature, PartialSignature), BridgeError>

TODO: This function should be split in to multiple functions

pub async fn sign_optimistic_payout( &self, nonce_session_id: u32, agg_nonce: AggregatedNonce, deposit_id: u32, input_signature: Signature, input_outpoint: OutPoint, output_script_pubkey: ScriptBuf, output_amount: Amount, ) -> Result<PartialSignature, BridgeError>

pub async fn set_operator_keys( &self, deposit_data: DepositData, keys: OperatorKeys, operator_xonly_pk: XOnlyPublicKey, ) -> Result<(), BridgeError>

pub async fn handle_kickoff<'a>( &'a self, dbtx: DatabaseTransaction<'a, '_>, kickoff_witness: Witness, deposit_data: DepositData, kickoff_data: KickoffData, challenged_before: bool, ) -> Result<bool, BridgeError>

Checks if the kickoff is malicious and sends the appropriate txs if it is. Returns true if the kickoff is malicious.

Trait Implementations

impl<C> BlockHandler for Verifier<C>

where C: CitreaClientT,

fn handle_new_block<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, dbtx: DatabaseTransaction<'life1, 'life2>, block_id: u32, block: Block, height: u32, ) -> Pin<Box<dyn Future<Output = Result<(), BridgeError>> + Send + 'async_trait>>

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

Handle a new finalized block

impl<C: Clone + CitreaClientT> Clone for Verifier<C>

fn clone(&self) -> Verifier<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug + CitreaClientT> Debug for Verifier<C>

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

Formats the value using the given formatter.

impl<C> NamedEntity for Verifier<C>

where C: CitreaClientT,

const ENTITY_NAME: &'static str = "verifier"

A string identifier for this owner type used to distinguish between state machines with different owners in the database.

impl<C> TryFrom<&Verifier<C>> for VerifierParams

where C: CitreaClientT,

type Error = Status

The type returned in the event of a conversion error.

fn try_from(verifier: &Verifier<C>) -> Result<Self, Self::Error>

Performs the conversion.