Struct DomainBuilder 

pub struct DomainBuilder<S, P> { /* private fields */ }

Builder to configure and create new domains

Obtain an instance via Domain::builder or Domain::from_config, then configure the domain with, for example:

• with_rpc to connect to a base layer RPC
• with_proving_client to set the proving client

Finally, call build to create the Domain.

Implementations

impl<S, P> DomainBuilder<S, P>

pub fn with_rocksdb(self, db_options: DbOptions) -> DomainBuilder<DbOptions, P>

Use RocksDb with the given configuration as storage

impl<P> DomainBuilder<DbOptions, P>

where P: Proving,

pub async fn build(self) -> Result<Domain<P, Storage>, Error>

Build the domain to get its handles.

impl<S, P> DomainBuilder<S, P>

pub fn with_proving_client<P2>(self, proving: P2) -> DomainBuilder<S, P2>

where P2: Proving,

Use the given proving client to generate proofs.

This can be a custom implementation of Proving or a provided one, for example SP1 (the sp1 feature needs to be active for that):

use delta_domain_sdk::{proving, Domain};

builder.with_proving_client(
    proving::sp1::Client::global_laws_cpu()
        .with_local_laws_cpu(local_laws_elf)
);

pub fn with_storage<S2>(self, storage: S2) -> DomainBuilder<S2, P>

where S2: KeyValueStorageWithColumnFamilies<ColumnFamilyIdentifier = ColumnFamilies, Error = StorageError> + Send + Sync + 'static,

Use a custom KeyValueStorageWithColumnFamilies implementation

Note

The SDK assumes that iteration order for [ColumnFamilies::PendingVerifiables] (i.e. the column family) is in lexicographical order of the keys/indices.

pub fn with_rpc(self, url: impl TryInto<Uri, Error = InvalidUri> + Send) -> Self

Use an RPC to connect to the base layer network.

Parameters

• url - of the base layer RPC

pub fn with_mock_rpc(self, mock_vaults: HashMap<Address, Vault>) -> Self

Override any previously configured RPC (even rpc_url from config file) and use a mock RPC as base layer network that can return the given mock_vaults when requested.

Note that only sharded vaults are supported.

impl<S> DomainBuilder<S, Client>

pub fn with_mock_local_laws<L: LocalLaws>(self) -> Self

This method sets a local laws implementation to allow testing of local laws logic. The local laws will be incorporated into the mock proving process.

impl<P, S> DomainBuilder<S, P>

where P: Proving, S: KeyValueStorageWithColumnFamilies<ColumnFamilyIdentifier = ColumnFamilies, Error = StorageError> + Send + Sync + 'static,

pub async fn build(self) -> Result<Domain<P, S>, Error>

Build the domain to get its handles.

Trait Implementations

impl<S: Debug, P: Debug> Debug for DomainBuilder<S, P>

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

Formats the value using the given formatter.