Struct adapter::Adapter

pub struct Adapter<C, S = LockedState> {
    pub client: Arc<C>,
    /* private fields */
}

The Adapter struct and it’s states.

Used for communication with the underlying client implementation.

Available adapters

2 Adapters are available in this crate:

• Ethereum
  • crate::ethereum::LockedAdapter and crate::ethereum::UnlockedAdapter
  • Client implementation crate::Ethereum for chains compatible with EVM.
• Dummy
  • crate::dummy::Adapter and it’s client implementation crate::Dummy for testing.

Fields

client: Arc<C>

client in a specific state - Locked or Unlocked

Implementations

impl<C: Locked> Adapter<C>

pub fn new(client: C) -> Adapter<C, LockedState>

Create a new Adapter in Locked state using a Locked.

impl<C: Unlocked> Adapter<C, LockedState>

pub fn with_unlocked(client: C) -> Adapter<C, UnlockedState>

Create a new Adapter in state::UnlockedState state using an Unlocked client.

impl<C> Adapter<C, LockedState>where
    C: Locked + Unlockable,
    <C::Unlocked as Locked>::Error: Into<Error>,
    C::Error: Into<Error>,

pub fn unlock(self) -> Result<Adapter<C::Unlocked, UnlockedState>, Error>

Trait Implementations

impl<C, S: Clone> Clone for Adapter<C, S>

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, S: Debug> Debug for Adapter<C, S>

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

Formats the value using the given formatter.

impl<C, S> Locked for Adapter<C, S>where
    C: Locked + Sync + Send,
    C::Error: Into<Error>,
    S: Sync + Send,

fn whoami(&self) -> ValidatorId

Get Adapter whoami

fn verify(
    &self,
    signer: ValidatorId,
    state_root: &str,
    signature: &str
) -> Result<bool, Error>

Verify, based on the signature & state_root, that the signer is the same

fn session_from_token<'life0, 'life1, 'async_trait>(
    &'life0 self,
    token: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Session, Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Creates a Session from a provided Token by calling the Contract. Does not cache the (Token, Session) pair.

type Error = Error

fn get_deposit<'life0, 'life1, 'async_trait>(
    &'life0 self,
    channel_context: &'life1 ChainOf<Channel>,
    depositor_address: Address
) -> Pin<Box<dyn Future<Output = Result<Deposit, Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

impl<C> Unlocked for Adapter<C, UnlockedState>where
    C: Unlocked + Sync + Send,
    C::Error: Into<Error>,

fn sign(&self, state_root: &str) -> Result<String, Error>

fn get_auth(
    &self,
    for_chain: ChainId,
    intended_for: ValidatorId
) -> Result<String, Error>