Struct BaseRpcClient 

pub struct BaseRpcClient { /* private fields */ }

Client for communicating with the delta base layer through RPC

BaseRpcClient provides a high-level interface for interacting with delta base layers. It handles connection management, request formatting, and response parsing for all base layer operations.

Example

use delta_base_sdk::rpc::BaseRpcClient;

async fn connect() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to local base layer provider
    let client = BaseRpcClient::new("http://localhost:50051").await?;

    // Connect to a remote node with HTTPS
    let secure_client = BaseRpcClient::new("https://baselayer.example.com").await?;

    // Connect with just the host (HTTPS will be added automatically)
    let auto_scheme_client = BaseRpcClient::new("baselayer.example.com").await?;

    Ok(())
}

Implementations

impl BaseRpcClient

pub async fn new( url: impl TryInto<Uri, Error = InvalidUri> + Send, ) -> Result<Self, RpcError>

Creates a new client by connecting to the specified base layer provider URL

This method establishes a connection to delta base layer at the specified URL. If the URL does not include a scheme (http:// or https://), HTTPS will be used automatically.

Parameters

• url - URL of base layer provider to connect to, either as a string or a URI

Errors

Returns RpcError if:

• The URL cannot be parsed; or
• The connection cannot be established

pub async fn submit_transaction<T>( &self, tx: SignedTransaction<T>, ) -> Result<(), RpcError>

where T: TransactionType + Into<TypeData> + Send,

Submits a signed transaction to the base layer network

This method sends a transaction to base layer for processing. The transaction must be properly signed with a valid signature from the transaction signer’s private key.

Parameters

• tx - Signed transaction to submit

Errors

Returns RpcError if:

• The connection to the base layer provider fails;
• The base layer provider rejects the transaction; or
• There’s a protocol conversion error.

pub async fn get_base_vault( &self, owner: OwnerId, ) -> Result<BaseVault, RpcError>

Gets the base vault for an owner in the base layer shard

This is a convenience method that calls get_vault with the base layer shard (0).

Parameters

• owner - The ID of the vault owner

Errors

Returns RpcError if:

• The vault doesn’t exist;
• The connection to the base layer provider fails; or
• There’s a protocol conversion error.

pub async fn get_vault( &self, address: Address, ) -> Result<ShardedVault, RpcError>

Retrieves a domain vault data for a specific address

Parameters

• address - of the vault to fetch

Errors

Returns RpcError if:

• The vault under the given address doesn’t exist;
• The connection to the base layer provider fails; or
• There’s a protocol conversion error.

Example

use delta_base_sdk::{
    crypto::ed25519,
    rpc::BaseRpcClient,
    vaults::{Address, ReadableNativeBalance},
};

async fn get_vault_example(client: &BaseRpcClient) -> Result<(), Box<dyn std::error::Error>> {
    let address = Address::new(ed25519::PubKey::generate().owner(), 1);
    let vault = client.get_vault(address).await?;
    println!("Vault data: {:?}", vault);
    println!("Vault balance: {}", vault.balance());
    Ok(())
}

pub async fn get_vaults( &self, addresses: impl IntoIterator<Item = Address>, ) -> Result<HashMap<Address, ShardedVault>, RpcError>

Retrieves multiple sharded vaults by address

This method fetches multiple vaults in a single request, up to a maximum of 100.

Parameters

• addresses - An iterator of addresses to retrieve

Errors

Returns RpcError if:

• Any of the vaults don’t exist;
• The connection to the base layer provider fails; or
• There’s a protocol conversion error.

pub async fn get_domain_owner_ids( &self, shard: Shard, ) -> Result<Vec<OwnerId>, RpcError>

Returns all the OwnerId that have a vault registered for the given shard on the base layer

pub async fn get_domain_agreement( &self, shard: Shard, ) -> Result<DomainAgreement, RpcError>

Gets the Domain Agreement for the provided shard.

Parameters

• shard - the shard to query the agreement for

Errors

Returns RpcError if:

• There’s no active agreement;
• The connection to the base layer RPC fails; or
• There’s a protocol conversion error.

pub async fn get_transaction_status( &self, tx_id: TxId, ) -> Result<TransactionStatus, RpcError>

Retrieves the current status of a transaction by its signature

This method allows tracking the progress of a transaction through the delta network. After submitting a transaction, you can use this method to check if it has been processed, confirmed, or rejected.

Parameters

• tx_id - TxId of the transaction to query

Errors

Returns RpcError if:

• The connection to the base layer provider fails; or
• The signature is invalid or unknown to the network.

Note

Transaction signatures are unique identifiers generated when signing a transaction. Retain the signature after submitting a transaction if you want to check its status later.

pub async fn get_epoch(&self) -> Result<Epoch, RpcError>

Retrieves the current epoch in delta

This method returns the current epoch number. Epochs are protocol-defined periods in the delta protocol during which the base layer provider set remains constant.

Errors

Returns RpcError if:

• The connection to the base layer provider fails
• The base layer provider cannot provide epoch information

Example

use delta_base_sdk::rpc::BaseRpcClient;

async fn get_network_info() -> Result<(), Box<dyn std::error::Error>> {
    let client = BaseRpcClient::new("http://localhost:50051").await?;

    // Get information about the current epoch
    let epoch = client.get_epoch().await?;

    println!("Current epoch: {}", epoch);

    Ok(())
}

pub async fn get_sdl(&self, hash: HashDigest) -> Result<StateDiffList, RpcError>

Retrieves a State Diff List (SDL) by its hash identifier

A State Diff List (SDL) is a batch of state changes in the delta protocol. This method allows retrieving the complete contents of an SDL by its hash, enabling applications to inspect state changes or verify transaction results.

Parameters

• hash - Cryptographic hash that uniquely identifies the SDL

Errors

Returns RpcError if:

• The SDL with the specified hash doesn’t exist;
• The connection to the base layer provider fails; or
• There’s a protocol conversion error.

pub async fn get_sdl_status( &self, hash: HashDigest, ) -> Result<SdlStatus, RpcError>

Retrieves the status of a State Diff List (SDL).

Parameters

• hash - Cryptographic hash that uniquely identifies the SDL

Errors

Returns RpcError if:

• The SDL with the specified hash doesn’t exist;
• The connection to the base layer provider fails; or
• There’s a protocol conversion error.

pub async fn stream_base_layer_events( &self, shard: Shard, ) -> Result<impl Stream<Item = Result<BaseLayerEvent, RpcError>> + Send, RpcError>

Subscribes to a stream of real-time events from the delta network

This method establishes a streaming connection to receive events from the base layer as they occur. Events include epoch transitions, vault migrations, and other network state changes. The events are filtered by shard.

Parameters

• shard - Shard number to receive events for

Errors

Returns RpcError if:

• The connection to the base layer provider fails;
• The streaming request is rejected; or
• Individual stream items may contain errors if there are issues during streaming.

Example

use delta_base_sdk::{
    events::BaseLayerEvent,
    rpc::BaseRpcClient,
};
use tokio_stream::StreamExt;

async fn monitor_events() -> Result<(), Box<dyn std::error::Error>> {
    let client = BaseRpcClient::new("http://localhost:50051").await?;

    // Subscribe to base layer events for shard 0 (the base layer shard)
    let mut event_stream = client.stream_base_layer_events(0).await?;

    println!("Listening for events...");

    // Process events as they arrive
    while let Some(event_result) = event_stream.next().await {
        match event_result {
            Ok(event) => {
                match event {
                    BaseLayerEvent::NewEpoch(epoch) => {
                        println!("New epoch started: {}", epoch);
                    },
                    BaseLayerEvent::SdlUpdate(update) => {
                        println!("SDL update received: {:?}", update.hash);
                    },
                    BaseLayerEvent::VaultEmigrated(address) => {
                        println!("Vault emigrated: {address:?}");
                    },
                    BaseLayerEvent::VaultImmigrated(address) => {
                        println!("Vault immigrated: {address:?}");
                    },
                }
            },
            Err(e) => {
                eprintln!("Error in event stream: {e}");
                // Decide whether to break or continue based on the error
            }
        }
    }

    Ok(())
}

Note

The returned stream implements the Stream trait from the tokio_stream crate. You need to bring the StreamExt trait into scope to use methods like next().

This is a long-lived connection that will continue to deliver events until the stream is dropped or the connection is closed. It’s suitable for building reactive applications that need to respond to network events in real-time.

Trait Implementations

impl Clone for BaseRpcClient

fn clone(&self) -> BaseRpcClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BaseRpcClient

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

Formats the value using the given formatter.