Struct DomainClient 

pub struct DomainClient { /* private fields */ }

Client to perform actions on a running domain.

The client is cloneable and can be shared across tasks. It provides methods to apply verifiable messages, submit state diffs to the base layer, and generate and submit proofs.

Without running the domain first, actions performed by the client cannot be executed.

Implementations

impl DomainClient

pub async fn apply( &self, messages: Vec<VerifiableWithDiffs>, ) -> Result<(), Error>

Apply state diffs to the vaults

Changes to the vaults are visible immediately locally. The resulting state diff is buffered until a call to Self::submit.

Parameters

• messages - The verifiable messages with diffs to be applied

Returns

Ok(()) if application succeeded, or an Error if it failed

pub async fn submit(&self) -> Result<Option<HashDigest>, Error>

Submit all diffs that were applied since the last call to the base layer and return the hash of the resulting SDL.

Returns

• Ok(Some(hash)) - If diffs were successfully submitted, returns the SDL hash
• Ok(None) - If there were no pending diffs to submit
• Err(error) - If the submission failed

pub async fn prove(&self, sdl: HashDigest) -> Result<(), Error>

Prove the SDL specified by the hash.

Generates a proof for the SDL with the given hash and only returns once the proof is finished (or fails).

Use Self::prove_with_local_laws_input if you need to provide additional inputs for the local laws.

Parameters

• sdl - The hash of the SDL to generate a proof for

Returns

Ok(()) if proving succeeded, Error otherwise

pub async fn prove_with_local_laws_input( &self, sdl: HashDigest, local_laws_input: Vec<u8>, ) -> Result<(), Error>

Prove the SDL specified by the hash with additional inputs.

Generates a proof for the SDL with the given hash and only returns once the proof is finished (or fails).

Parameters

• sdl - The hash of the SDL to generate a proof for
• local_laws_input - Additional inputs to the configured local laws

Returns

Ok(()) if proving succeeded, Error otherwise

pub async fn submit_proof(&self, sdl: HashDigest) -> Result<(), Error>

Submit the proof of the SDL specified by the hash to the base layer.

Parameters

• sdl - The hash of the SDL whose proof should be submitted

Returns

Ok(()) if the proof was successfully submitted, or an Error if it failed

pub fn updates(&self) -> Receiver<SdlUpdate>

Subscribes to a stream of events from the running domain.

pub async fn apply_prove_submit( &self, messages: Vec<VerifiableWithDiffs>, ) -> Result<Option<HashDigest>, Error>

Shorthand to apply verifiables, submit an SDL, generate and submit a proof

This method combines the following:

1. apply to apply verifiables to the vaults
2. submit to batch the changes in an SDL and submit it to the base layer
3. proving to start proving the SDL
4. submit_proof to submit the proof to the base layer

This method does not allow setting additional inputs for the local laws.

Parameters

• messages - The verifiable messages to be applied

Returns

• Ok(Some(hash)) - Success, an SDL with this hash was created & proven
• Ok(None) - Success but there were no state changes to submit
• Err(error) - Any step in the process failed.

pub async fn submit_domain_agreement( &self, new_shard_fee: Planck, ) -> Result<(), Error>

Submit a Domain Agreement for this domain.

Having an active domain agreement is a prerequisite to submit transactions to the base layer. You can check whether a domain agreement is already active with Self::check_valid_domain_agreement.

Note that after submitting the domain agreement, it still has to be applied on the base layer, before the domain is allowed to send transactions.

Parameters

• new_shard_fee - amount of native token that will be charged to the domain operator keys’s base layer vault for creation of the new shard

Returns

• Ok(()) - if the domain agreement was successfully submitted
• Err(_) - see crate::domain_agreement::Error for error interpretation

pub async fn check_valid_domain_agreement(&self) -> Result<(), Error>

Check that there is an active Domain Agreement for this domain.

This method can typically be used as a safe-guard before calling Self::submit or other methods that require an active domain agreement for transactions to be accepted.

Returns

• Ok(()) - if there is an active domain agreement for this domain
• Err(_) - see crate::domain_agreement::Error for interpretation

pub async fn ensure_domain_agreement( &self, new_shard_fee: Planck, interval: Duration, timeout: Duration, ) -> Result<(), Error>

Ensure that the domain has a valid Domain Agreement.

If no valid Domain Agreement is found, a new one will be submitted and awaited up to timeout.

Parameters

• new_shard_fee - amount of native token that will be charged to the domain operator keys’s base layer vault for creation of the new shard
• interval - duration between polling for the the domain agreement
• timeout - maximal duration to await the new domain agreement

Trait Implementations

impl Clone for DomainClient

fn clone(&self) -> DomainClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DomainClient

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

Formats the value using the given formatter.