Struct validator_worker::SentryApi

pub struct SentryApi<C: Unlocked, P = ChainsValidators> {
    pub adapter: Adapter<C, UnlockedState>,
    pub client: Client,
    pub logger: Logger,
    pub config: Config,
    pub sentry_url: ApiUrl,
    pub whoami: HashMap<ChainId, Validator>,
    pub propagate_to: P,
}

Fields

adapter: Adapter<C, UnlockedState>

client: Client

logger: Logger

config: Config

sentry_url: ApiUrl

For all the calls that do not have information about the Chains

whoami: HashMap<ChainId, Validator>

Whilelisted chains for which this validator (Who Am I) can operate on.

Since the validator might have different urls for old vs new Campaigns, we can override the URL based on the campaign, see crate::Worker. Auth token for this validator is generated for each Chain on SentryApi::new

propagate_to: P

If set with Validators, propagate_to should contain the whoami Validator in each Chain! use SentryApi::init or SentryApi::with_propagate instead

Implementations

impl<C: Unlocked + 'static> SentryApi<C, ()>

pub fn new(
    adapter: Adapter<C, UnlockedState>,
    logger: Logger,
    config: Config,
    sentry_url: ApiUrl
) -> Result<SentryApi<C, ()>, Error>

sentry_url is the default URL to which the current Who am I validator should make requests. It is used to populate the config Chains with Authentication Token & [ApiUrl]. This value can be overwritten using propagate_to, if any of the passed validators has the same [ValidatorId].

pub fn init(
    adapter: Adapter<C, UnlockedState>,
    logger: Logger,
    config: Config,
    sentry_url: ApiUrl,
    propagate_to: ChainsValidators
) -> Result<SentryApi<C, ChainsValidators>, Error>

Initialize the SentryApi and makes sure that [Adapter::whoami()] is present in each chain Validators. Sets the Who am I [ApiUrl] and the Authentication Token for a specific Chain for calls that require authentication.

pub fn with_propagate(
    self,
    propagate_to: ChainsValidators
) -> Result<SentryApi<C, ChainsValidators>, Error>

If the Who am I Validator is not found in propagate_to it will be added. Propagation should happen to all validators Sentry instances including Who am I i.e. the current validator. If a Chain in propagate_to is not setup (SentryApi::whoami) for this instance, an error is returned.

impl<C: Unlocked + 'static, P> SentryApi<C, P>

pub async fn get_latest_msg(
    &self,
    channel: ChannelId,
    from: ValidatorId,
    message_types: &[MessageType]
) -> Result<Option<MessageTypes>, Error>

pub async fn get_our_latest_msg(
    &self,
    channel: ChannelId,
    message_types: &[MessageType]
) -> Result<Option<MessageTypes>, Error>

pub async fn get_last_approved(
    &self,
    channel: ChannelId
) -> Result<LastApprovedResponse<UncheckedState>, Error>

Get’s the last approved state and requesting a [primitives::validator::Heartbeat], see [LastApprovedResponse]

pub async fn get_spenders_page(
    &self,
    channel_context: &ChainOf<Channel>,
    page: u64
) -> Result<AllSpendersResponse, Error>

page always starts from 0

pub async fn get_all_spenders(
    &self,
    channel_context: &ChainOf<Channel>
) -> Result<HashMap<Address, Spender>, Error>

pub async fn get_accounting(
    &self,
    channel_context: &ChainOf<Channel>
) -> Result<AccountingResponse<CheckedState>, Error>

Get the accounting from Sentry Balances should always be in CheckedState

pub async fn collect_channels(
    &self
) -> Result<(HashSet<ChainOf<Channel>>, ChainsValidators), Error>

Fetches all Campaigns from the Who am I Sentry. It builds the Channels to be processed alongside all the Validators’ url & auth token.

impl<C: Unlocked + 'static> SentryApi<C>

pub async fn propagate(
    &self,
    channel_context: &ChainOf<Channel>,
    messages: &[MessageTypes]
) -> Result<Vec<PropagationResult>, Error>

Trait Implementations

impl<C: Unlocked, P: Clone> Clone for SentryApi<C, P>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug + Unlocked, P: Debug> Debug for SentryApi<C, P>

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

Formats the value using the given formatter.