### Subscribe to Preprocessed Updates

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Starts a streaming subscription for preprocessed blockchain updates. This is an alternative to the standard subscribe method.

```rust
pub async fn subscribe_preprocessed(
    &mut self,
    request: impl IntoStreamingRequest<Message = SubscribePreprocessedRequest>,
) -> Result<Response<Streaming<SubscribePreprocessedUpdate>>, Status>
```

--------------------------------

### LaserstreamConfig with Replay Behavior

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/config.rs.html

Configures whether to enable replay on reconnects. When true, it uses slot tracking; when false, it starts from the current slot.

```rust
pub fn with_replay(mut self, replay: bool) -> Self {
        self.replay = replay;
        self
    }
```

--------------------------------

### Get Version

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Fetches the version information of the Helius service. This can be used for compatibility checks.

```rust
pub async fn get_version(&mut self, request: impl IntoRequest<GetVersionRequest>) -> Result<Response<GetVersionResponse>, Status>
```

--------------------------------

### Get Version

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/trait.Geyser.html

Retrieves the current version of the Geyser service.

```APIDOC
## get_version

### Description
Retrieves the current version of the Geyser service.

### Method
RPC (gRPC)

### Request
- **request** (GetVersionRequest) - The request object for getting the service version.

### Response
- **response** (GetVersionResponse) - The response containing the service version.
```

--------------------------------

### GetBlockHeightRequest Methods

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.GetBlockHeightRequest.html

Provides methods for interacting with the GetBlockHeightRequest, including getting and setting the commitment level.

```APIDOC
### impl GetBlockHeightRequest

#### pub fn commitment(&self) -> CommitmentLevel
Returns the enum value of `commitment`, or the default if the field is unset or set to an invalid enum value.

#### pub fn set_commitment(&mut self, value: CommitmentLevel)
Sets `commitment` to the provided enum value.
```

--------------------------------

### ready_oneshot

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Yields the service when it is ready to accept a request.

```APIDOC
## fn ready_oneshot(self) -> ReadyOneshot<Self, Request>
where Self: Sized,
Yields the service when it is ready to accept a request.
```

--------------------------------

### Get TypeId of StreamHandle

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/client/struct.StreamHandle.html

Gets the `TypeId` of the StreamHandle. This is useful for runtime type introspection.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### LaserstreamConfig Initialization

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/config.rs.html

Creates a new LaserstreamConfig with default channel options and replay enabled. Requires endpoint and API key.

```rust
pub fn new(endpoint: String, api_key: String) -> Self {
        Self {
            endpoint,
            api_key,
            max_reconnect_attempts: None, // Default to None
            channel_options: ChannelOptions::default(),
            replay: true, // Default to true
        }
    }
```

--------------------------------

### Get Type ID of SubscribeUpdateEntry

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateEntry.html

Gets the `TypeId` of the SubscribeUpdateEntry. This is part of the `Any` trait implementation, used for dynamic type checking.

```rust
fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.
```

--------------------------------

### ChannelOptions Implementations

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.ChannelOptions.html

This section covers methods available for configuring ChannelOptions, specifically for enabling compression.

```APIDOC
### impl ChannelOptions

#### pub fn with_zstd_compression(self) -> Self
Enable zstd compression for both sending and receiving

#### pub fn with_gzip_compression(self) -> Self
Enable gzip compression for both sending and receiving
```

--------------------------------

### Connect to gRPC Server and Create Client

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/client.rs.html

Establishes a gRPC connection and creates a GeyserClient. Handles connection errors by mapping them to an unavailable status.

```rust
let channel = endpoint
        .connect()
        .await
        .map_err(|e| Status::unavailable(format!("Connection failed: {}", e)))?;

    let mut geyser_client = GeyserClient::with_interceptor(channel, interceptor);
```

--------------------------------

### Get Slot

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/trait.Geyser.html

Retrieves the current slot number from the blockchain.

```APIDOC
## get_slot

### Description
Retrieves the current slot number from the blockchain.

### Method
RPC (gRPC)

### Request
- **request** (GetSlotRequest) - The request object for getting the current slot.

### Response
- **response** (GetSlotResponse) - The response containing the current slot number.
```

--------------------------------

### ready

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Yields a mutable reference to the service when it is ready to accept a request.

```APIDOC
## fn ready(&mut self) -> Ready<'_, Self, Request>
where Self: Sized,
Yields a mutable reference to the service when it is ready to accept a request.
```

--------------------------------

### Get Latest Blockhash

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/trait.Geyser.html

Retrieves the latest blockhash from the blockchain.

```APIDOC
## get_latest_blockhash

### Description
Retrieves the latest blockhash from the blockchain.

### Method
RPC (gRPC)

### Request
- **request** (GetLatestBlockhashRequest) - The request object for getting the latest blockhash.

### Response
- **response** (GetLatestBlockhashResponse) - The response containing the latest blockhash.
```

--------------------------------

### Get TypeId of LaserstreamConfig

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.LaserstreamConfig.html

Retrieves the TypeId of the LaserstreamConfig instance.

```rust
fn type_id(&self) -> TypeId>
```

--------------------------------

### GeyserServer::new

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Creates a new GeyserServer with the given inner service.

```APIDOC
## GeyserServer::new

### Description
Creates a new GeyserServer with the given inner service.

### Signature
```rust
pub fn new(inner: T) -> GeyserServer<T>
```
```

--------------------------------

### Establishing a Laserstream Subscription

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/client.rs.html

Establishes a gRPC connection for a bidirectional stream, handling subscription lifecycle and automatic reconnections. Returns a stream of updates and a handle to manage the subscription.

```rust
/// Establishes a gRPC connection, handles the subscription lifecycle,
/// and provides a stream of updates. Automatically reconnects on failure.
#[instrument(skip(config, request))]
pub fn subscribe(
    config: LaserstreamConfig,
    request: SubscribeRequest,
) -> (
    impl Stream<Item = Result<SubscribeUpdate, LaserstreamError>>,
    StreamHandle,
) {
    let (write_tx, mut write_rx) = mpsc::unbounded_channel::<SubscribeRequest>();
    let handle = StreamHandle { write_tx };
    let update_stream = stream! {
        let mut reconnect_attempts = 0;
        let mut tracked_slot: u64 = 0;

        // Determine the effective max reconnect attempts
        let effective_max_attempts = config
            .max_reconnect_attempts
            .unwrap_or(HARD_CAP_RECONNECT_ATTEMPTS) // Default to hard cap if not set
            .min(HARD_CAP_RECONNECT_ATTEMPTS); // Enforce hard cap

        // Keep original request for reconnection attempts
        let mut current_request = request.clone();
        let internal_slot_sub_id = format!("internal-{}", uuid::Uuid::new_v4().to_string().split('-').next().unwrap());
        
        // Get replay behavior from config
        let replay_enabled = config.replay;
        
        // Add internal slot subscription only when replay is enabled
        if replay_enabled {
            current_request.slots.insert(
                internal_slot_sub_id.clone(),
                SubscribeRequestFilterSlots {
                    filter_by_commitment: Some(true), // Use same commitment as user request
                    ..Default::default()
                }
            );
        }
        
        // Clear any user-provided from_slot if replay is disabled
        if !replay_enabled {
            current_request.from_slot = None;
        }

        let api_key_string = config.api_key.clone();

        loop {

```

--------------------------------

### Get Block Height

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/trait.Geyser.html

Retrieves the current block height of the blockchain.

```APIDOC
## get_block_height

### Description
Retrieves the current block height of the blockchain.

### Method
RPC (gRPC)

### Request
- **request** (GetBlockHeightRequest) - The request object for getting the block height.

### Response
- **response** (GetBlockHeightResponse) - The response containing the block height.
```

--------------------------------

### Get first_available Field

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeReplayInfoResponse.html

Returns the value of `first_available`, or the default value if `first_available` is unset.

```rust
pub fn first_available(&self) -> u64
```

--------------------------------

### Configure gRPC Endpoint Options

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/client.rs.html

Sets various connection and HTTP/2 options for a gRPC endpoint. Use this to fine-tune connection behavior like timeouts, keep-alive settings, and buffer sizes.

```rust
let mut endpoint = Endpoint::from_shared(config.endpoint.clone())
        .map_err(|e| Status::internal(format!("Failed to parse endpoint: {}", e)))?
        .connect_timeout(Duration::from_secs(options.connect_timeout_secs.unwrap_or(10)))
        .timeout(Duration::from_secs(options.timeout_secs.unwrap_or(30)))
        .http2_keep_alive_interval(Duration::from_secs(options.http2_keep_alive_interval_secs.unwrap_or(30)))
        .keep_alive_timeout(Duration::from_secs(options.keep_alive_timeout_secs.unwrap_or(5)))
        .keep_alive_while_idle(options.keep_alive_while_idle.unwrap_or(true))
        .initial_stream_window_size(options.initial_stream_window_size.or(Some(1024 * 1024 * 4)))
        .initial_connection_window_size(options.initial_connection_window_size.or(Some(1024 * 1024 * 8)))
        .http2_adaptive_window(options.http2_adaptive_window.unwrap_or(true))
        .tcp_nodelay(options.tcp_nodelay.unwrap_or(true))
        .buffer_size(options.buffer_size.or(Some(1024 * 64)));

    if let Some(tcp_keepalive_secs) = options.tcp_keepalive_secs {
        endpoint = endpoint.tcp_keepalive(Some(Duration::from_secs(tcp_keepalive_secs)));
    }
```

--------------------------------

### Create New LaserstreamConfig

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.LaserstreamConfig.html

Initializes a new LaserstreamConfig with the provided endpoint and API key.

```rust
pub fn new(endpoint: String, api_key: String) -> Self>
```

--------------------------------

### oneshot

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Consume this `Service`, calling with the providing request once it is ready.

```APIDOC
## fn oneshot(self, req: Request) -> Oneshot<Self, Request>
where Self: Sized,
Consume this `Service`, calling with the providing request once it is ready.
```

--------------------------------

### Get Slot

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Retrieves the current slot number on the blockchain. This is useful for time-sensitive operations.

```rust
pub async fn get_slot(&mut self, request: impl IntoRequest<GetSlotRequest>) -> Result<Response<GetSlotResponse>, Status>
```

--------------------------------

### Clone Implementation for UiTokenAmount

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.UiTokenAmount.html

Provides methods to duplicate UiTokenAmount instances. `clone` creates a new instance, while `clone_from` copies data from another instance.

```rust
fn clone(&self) -> UiTokenAmount
```

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

--------------------------------

### Get Latest Blockhash

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Retrieves the latest blockhash from the blockchain. This is a standard request-response operation.

```rust
pub async fn get_latest_blockhash(
    &mut self,
    request: impl IntoRequest<GetLatestBlockhashRequest>,
) -> Result<Response<GetLatestBlockhashResponse>, Status>
```

--------------------------------

### Create Bidirectional Stream and Subscribe

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/client.rs.html

Sets up a bidirectional stream for subscriptions, sending an initial request and receiving a response. Handles errors during request sending and subscription.

```rust
let (mut subscribe_tx, subscribe_rx) = futures_mpsc::unbounded();
    subscribe_tx
        .send(request)
        .await
        .map_err(|e| Status::internal(format!("Failed to send initial request: {}", e)))?;

    let response = geyser_client
        .subscribe(subscribe_rx)
        .await
        .map_err(|e| Status::internal(format!("Subscription failed: {}", e)))?;

    Ok((subscribe_tx, response.into_inner()))
```

--------------------------------

### GetLatestBlockhashRequest

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.GetLatestBlockhashRequest.html

Represents a request to get the latest blockhash. It includes an optional commitment level.

```APIDOC
## Struct GetLatestBlockhashRequest

### Summary
```rust
pub struct GetLatestBlockhashRequest {
    pub commitment: Option<i32>,
}
```

### Fields
- `commitment`: `Option<i32>` - The commitment level for the request. This is an optional field.
```

--------------------------------

### Get Nonempty Txn Signature Value

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeRequestFilterAccounts.html

Returns the value of `nonempty_txn_signature`, or the default value if it is unset.

```rust
pub fn nonempty_txn_signature(&self) -> bool
```

--------------------------------

### Clone Implementation for ChannelOptions

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.ChannelOptions.html

Standard implementation for cloning ChannelOptions, allowing a duplicate of the configuration to be created.

```rust
fn clone(&self) -> ChannelOptions
```

--------------------------------

### Default Implementation for SubscribeUpdateAccountInfo

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateAccountInfo.html

Provides a default instance of SubscribeUpdateAccountInfo. This is useful for initialization or when a default state is required.

```rust
fn default() -> SubscribeUpdateAccountInfo
```

--------------------------------

### IsBlockhashValidRequest Methods

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.IsBlockhashValidRequest.html

Provides methods for interacting with the IsBlockhashValidRequest struct, such as getting and setting the commitment level.

```APIDOC
## impl IsBlockhashValidRequest

### `fn commitment(&self) -> CommitmentLevel`
Returns the enum value of `commitment`, or the default if the field is unset or set to an invalid enum value.

### `fn set_commitment(&mut self, value: CommitmentLevel)`
Sets `commitment` to the provided enum value.
```

--------------------------------

### Get Cost Units

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.TransactionStatusMeta.html

Retrieves the total transaction cost. Returns the default value if `cost_units` is not set.

```rust
pub fn cost_units(&self) -> u64
```

--------------------------------

### Default Implementation for UiTokenAmount

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.UiTokenAmount.html

Allows creating a default UiTokenAmount instance. This is useful for initializing the struct when no specific values are provided.

```rust
fn default() -> UiTokenAmount
```

--------------------------------

### LayerExt<L> for L

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateTransaction.html

Applies a layer to a service and wraps it.

```APIDOC
## fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>

### Description
Applies the layer to a service and wraps it in `Layered`.

### Type Parameters
* S

### Type Constraints
* L: Layer<S>
```

--------------------------------

### Reward Type Methods

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.Reward.html

Methods for interacting with the `reward_type` field, including getting its enum value and setting it.

```APIDOC
### impl Reward

#### pub fn reward_type(&self) -> RewardType
Returns the enum value of `reward_type`, or the default if the field is set to an invalid enum value.

#### pub fn set_reward_type(&mut self, value: RewardType)
Sets `reward_type` to the provided enum value.
```

--------------------------------

### Enable Gzip Compression

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.ChannelOptions.html

A convenience method to enable gzip compression for both sending and receiving on a channel.

```rust
pub fn with_gzip_compression(self) -> Self
```

--------------------------------

### Get From Slot Value

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeRequest.html

Retrieves the value of the from_slot field. Returns the default value if the field is unset.

```rust
pub fn from_slot(&self) -> u64
```

--------------------------------

### try_from

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Performs the conversion from one type to another.

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### Parameters
* `value`: The value to convert.

### Type Constraints
* `U`: Must implement `Into<T>`.
```

--------------------------------

### Default Implementation

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeRequestFilterTransactions.html

Provides a default instance of SubscribeRequestFilterTransactions. Use this to get a struct with all fields set to their default values.

```rust
fn default() -> SubscribeRequestFilterTransactions
```

--------------------------------

### PartialEq Implementation for CompiledInstruction

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.CompiledInstruction.html

Enables equality comparison between CompiledInstruction instances using the `==` and `!=` operators.

```rust
fn eq(&self, other: &CompiledInstruction) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Get Commitment Level

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.GetLatestBlockhashRequest.html

Retrieves the enum value of the commitment field. Returns the default if the field is unset or invalid.

```rust
pub fn commitment(&self) -> CommitmentLevel
```

--------------------------------

### PartialEq Implementation for UiTokenAmount

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.UiTokenAmount.html

Enables comparison of UiTokenAmount instances for equality. The `eq` method checks if two instances have the same values, while `ne` checks for inequality.

```rust
fn eq(&self, other: &UiTokenAmount) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Get Dead Error String

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateSlot.html

Retrieves the dead error message. Returns an empty string if the dead_error field is not set.

```rust
pub fn dead_error(&self) -> &str
```

--------------------------------

### Get Block Height

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Fetches the current block height of the blockchain. This method is used for querying the chain's progress.

```rust
pub async fn get_block_height(
    &mut self,
    request: impl IntoRequest<GetBlockHeightRequest>,
) -> Result<Response<GetBlockHeightResponse>, Status>
```

--------------------------------

### CloneToUninit Trait Implementation (Experimental)

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeRequestFilterAccountsFilterMemcmp.html

An experimental nightly-only API for performing copy-assignment to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
where T: Clone,
```

--------------------------------

### Connect and Subscribe to Laserstream

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/client.rs.html

Establishes a WebSocket connection and subscribes to the Laserstream service. Handles successful connections by setting up message processing loops and timers.

```rust
match connect_and_subscribe_once(&config, attempt_request, api_key_string.clone()).await {
                Ok((sender, stream)) => {
                    // Successful connection – reset attempt counter so we don't hit the cap
                    reconnect_attempts = 0;

                    // Box sender and stream here before processing
                    let mut sender: Pin<Box<dyn futures_util::Sink<SubscribeRequest, Error = futures_mpsc::SendError> + Send>> = Box::pin(sender);
                    // Ensure the boxed stream yields Result<_, Status>
                    let mut stream: Pin<Box<dyn Stream<Item = Result<SubscribeUpdate, Status>> + Send>> = Box::pin(stream);

                    // Ping interval timer
                    let mut ping_interval = tokio::time::interval(Duration::from_secs(30));
                    ping_interval.tick().await; // Skip first immediate tick
                    let mut ping_id = 0i32;

                    loop {
                        tokio::select! {
                            // Send periodic ping
                            _ = ping_interval.tick() => {
                                ping_id = ping_id.wrapping_add(1);
                                let ping_request = SubscribeRequest {
                                    ping: Some(SubscribeRequestPing { id: ping_id }),
                                    ..Default::default()
                                };
                                let _ = sender.send(ping_request).await;
                            },
                            // Handle incoming messages from the server
                            result = stream.next() => {
                                if let Some(result) = result {
                                    match result {
                                        Ok(update) => {
                                            
                                            // Handle ping/pong
                                            if matches!(&update.update_oneof, Some(UpdateOneof::Ping(_))) {
                                                let pong_req = SubscribeRequest { ping: Some(SubscribeRequestPing { id: 1 }), ..Default::default() };
                                                if let Err(e) = sender.send(pong_req).await {
                                                    warn!(error = %e, "Failed to send pong");
                                                    break;
                                                }
                                                continue;
                                            }
                                            
                                            // Do not forward server 'Pong' updates to consumers either
                                            if matches!(&update.update_oneof, Some(UpdateOneof::Pong(_))) {
                                                continue;
                                            }

                                // Track the latest slot from any slot update (including internal subscription)
                                if let Some(UpdateOneof::Slot(s)) = &update.update_oneof {
                                    if replay_enabled {
                                        tracked_slot = s.slot;
                                    }
                                    

```

--------------------------------

### subscribe_replay_info

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/trait.Geyser.html

Retrieves information related to subscribing to replay data. This method is used to get details about available replay data.

```APIDOC
## POST /subscribe_replay_info

### Description
Retrieves information about replay data subscriptions.

### Method
POST

### Endpoint
/subscribe_replay_info

### Request Body
- **request** (SubscribeReplayInfoRequest) - Required - The request object for replay info.

### Response
#### Success Response (200)
- **response** (SubscribeReplayInfoResponse) - The response containing replay information.
```

--------------------------------

### CommitmentLevel Methods

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/enum.CommitmentLevel.html

Provides methods for interacting with the CommitmentLevel enum, such as checking validity, converting from i32, and getting string names.

```APIDOC
## Implementations

### impl CommitmentLevel

#### pub fn is_valid(value: i32) -> bool
Returns `true` if `value` is a variant of `CommitmentLevel`.

#### pub fn from_i32(value: i32) -> Option<CommitmentLevel>
Deprecated: Use the TryFrom<i32> implementation instead
Converts an `i32` to a `CommitmentLevel`, or `None` if `value` is not a valid variant.

#### pub fn as_str_name(&self) -> &'static str
String value of the enum field names used in the ProtoBuf definition. The values are not transformed in any way and thus are considered stable (if the ProtoBuf definition does not change) and safe for programmatic use.

#### pub fn from_str_name(value: &str) -> Option<CommitmentLevel>
Creates an enum from field names used in the ProtoBuf definition.
```

--------------------------------

### Establish Preprocessed Subscription Stream with Reconnection

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/client.rs.html

Sets up a stream for preprocessed transactions that automatically attempts to reconnect on failure. It limits the number of reconnect attempts to prevent infinite loops.

```rust
let handle = PreprocessedStreamHandle;
    let update_stream = stream! {
        let mut reconnect_attempts = 0;

        let effective_max_attempts = config
            .max_reconnect_attempts
            .unwrap_or(HARD_CAP_RECONNECT_ATTEMPTS)
            .min(HARD_CAP_RECONNECT_ATTEMPTS);

        loop {
            let api_key = config.api_key.clone();
            let request_clone = request.clone();

            match connect_and_subscribe_preprocessed_once(&config, request_clone, api_key).await {
                Ok(mut stream) => {
                    reconnect_attempts = 0;

                    while let Some(result) = stream.next().await {
                        match result {
                            Ok(update) => yield Ok(update),
                            Err(e) => {

```

--------------------------------

### Get Encoded Length

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.Message.html

Returns the encoded length of the message in bytes, without including a length delimiter. This is useful for pre-allocating buffers.

```rust
fn encoded_len(&self) -> usize
Returns the encoded length of the message without a length delimiter.
```

--------------------------------

### PartialEq Implementation for GetVersionRequest

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.GetVersionRequest.html

Enables equality comparisons between GetVersionRequest instances. Includes methods for checking equality (`eq`) and inequality (`ne`).

```rust
impl PartialEq for GetVersionRequest
Source§
#### fn eq(&self, other: &GetVersionRequest) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source§
#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source
```

--------------------------------

### GeyserServer::new Constructor

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Creates a new GeyserServer instance with the provided inner service implementation.

```rust
pub fn new(inner: T) -> GeyserServer<T>
```

--------------------------------

### Get Slot Status

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateSlot.html

Retrieves the slot status as a SlotStatus enum. Returns the default status if the stored i32 value is invalid.

```rust
pub fn status(&self) -> SlotStatus
```

--------------------------------

### Get Parent Slot Value

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateSlot.html

Retrieves the parent slot number. Returns the default value (0 for u64) if the parent is not set.

```rust
pub fn parent(&self) -> u64
```

--------------------------------

### Into Tonic Request

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.LaserstreamConfig.html

Wraps the LaserstreamConfig in a tonic::Request.

```rust
fn into_request(self) -> Request<T)>
```

--------------------------------

### boxed

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Convert the service into a `Service` + `Send` trait object.

```APIDOC
## fn boxed(self) -> BoxService<Request, Self::Response, Self::Error>
where Self: Sized + Send + 'static, Self::Future: Send + 'static,
Convert the service into a `Service` + `Send` trait object. Read more
```

--------------------------------

### SlotStatus Methods

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/enum.SlotStatus.html

Provides methods for interacting with the SlotStatus enum, including checking validity, converting from integers, and getting string representations.

```APIDOC
### impl SlotStatus

#### pub fn is_valid(value: i32) -> bool
Returns `true` if `value` is a variant of `SlotStatus`.

#### pub fn from_i32(value: i32) -> Option<SlotStatus>
Deprecated: Use the TryFrom<i32> implementation instead
Converts an `i32` to a `SlotStatus`, or `None` if `value` is not a valid variant.

#### pub fn as_str_name(&self) -> &'static str
String value of the enum field names used in the ProtoBuf definition. The values are not transformed in any way and thus are considered stable (if the ProtoBuf definition does not change) and safe for programmatic use.

#### pub fn from_str_name(value: &str) -> Option<SlotStatus>
Creates an enum from field names used in the ProtoBuf definition.
```

--------------------------------

### boxed

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Convert the service into a `Service` + `Send` trait object.

```APIDOC
## fn boxed(self) -> BoxService<Request, Self::Response, Self::Error>

### Description
Convert the service into a `Service` + `Send` trait object.

### Type Constraints
* `Self`: Must be `Sized`, `Send`, and `'static`.
* `Self::Future`: Must be `Send` and `'static`.
```

--------------------------------

### Get String Name of CommitmentLevel

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/enum.CommitmentLevel.html

Retrieves the string name of the enum variant, as used in the ProtoBuf definition. These names are considered stable.

```rust
pub fn as_str_name(&self) -> &'static str
```

--------------------------------

### Try converting i32 to CommitmentLevel

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/enum.CommitmentLevel.html

Safely attempts to convert an i32 into a CommitmentLevel variant. Returns a Result, with Ok(CommitmentLevel) on success and Err(UnknownEnumValue) if the i32 is not a valid variant.

```rust
type Error = UnknownEnumValue

fn try_from(value: i32) -> Result<CommitmentLevel, UnknownEnumValue>
```

--------------------------------

### Get Encoded Length of UpdateOneof Message

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/subscribe_preprocessed_update/enum.UpdateOneof.html

Returns the encoded length of the UpdateOneof message without a length delimiter. Useful for buffer allocation.

```rust
pub fn encoded_len(&self) -> usize
```

--------------------------------

### MessageHeader PartialEq Implementation

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.MessageHeader.html

Enables equality comparison between MessageHeader instances.

```rust
fn eq(&self, other: &MessageHeader) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Get Transaction Signature

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateAccountInfo.html

Retrieves the transaction signature associated with the account update. Returns a slice of bytes representing the signature, or an empty slice if not present.

```rust
pub fn txn_signature(&self) -> &[u8]
```

--------------------------------

### ChannelOptions with Gzip Compression

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/config.rs.html

Enables gzip compression for both sending and receiving data over the Laserstream channel. Also ensures zstd is accepted.

```rust
pub fn with_gzip_compression(mut self) -> Self {
        self.send_compression = Some(CompressionEncoding::Gzip);
        self.accept_compression = Some(vec![CompressionEncoding::Gzip, CompressionEncoding::Zstd]);
        self
    }
```

--------------------------------

### into_request

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/subscribe_request_filter_accounts_filter_lamports/enum.Cmp.html

Wraps the input message in a tonic::Request.

```APIDOC
## fn into_request(self) -> Request<T>

### Description
Wraps the input message `T` in a `tonic::Request`.

### Parameters
- **self** (T) - Required - The message to be wrapped.
```

--------------------------------

### Configure Replay Behavior

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.LaserstreamConfig.html

Determines whether to enable replay on reconnects. When true (default), it uses internal slot tracking. When false, it starts from the current slot.

```rust
pub fn with_replay(self, replay: bool) -> Self>
```

--------------------------------

### Clone Implementation for SubscribeUpdateBlockMeta

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateBlockMeta.html

Provides methods to duplicate SubscribeUpdateBlockMeta instances. `clone` creates a new instance, while `clone_from` performs copy-assignment.

```rust
fn clone(&self) -> SubscribeUpdateBlockMeta
```

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

--------------------------------

### Reward Type Enum Conversion

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.Reward.html

Provides methods to get the enum value of `reward_type` or set it to a provided enum value. Handles invalid enum values by returning the default.

```rust
pub fn reward_type(&self) -> RewardType
```

```rust
pub fn set_reward_type(&mut self, value: RewardType)
```

--------------------------------

### Get Compute Units Consumed

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.TransactionStatusMeta.html

Retrieves the sum of compute units consumed by all instructions for a transaction. Returns the default value if `compute_units_consumed` is not set, which may occur for transactions executed on Solana versions prior to v1.10.35 / v1.11.6.

```rust
pub fn compute_units_consumed(&self) -> u64
```

--------------------------------

### clone_to_uninit

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateSlot.html

Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

```APIDOC
## clone_to_uninit

### Description
Performs copy-assignment from `self` to `dest`.

### Method Signature
`unsafe fn clone_to_uninit(&self, dest: *mut u8)`

### Notes
This is a nightly-only experimental API.
```

--------------------------------

### PartialEq Implementation for SubscribeUpdateTransactionInfo

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateTransactionInfo.html

Enables comparison for equality between SubscribeUpdateTransactionInfo instances.

```rust
fn eq(&self, other: &SubscribeUpdateTransactionInfo) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### GeyserClient::new

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Creates a new GeyserClient with the provided inner service.

```APIDOC
## GeyserClient::new

### Description
Creates a new GeyserClient with the provided inner service.

### Signature
```rust
pub fn new(inner: T) -> GeyserClient<T>
```
```

--------------------------------

### LayerExt<L>

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdate.html

Applies a layer to a service and wraps it.

```APIDOC
## fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>

### Description
Applies the layer to a service and wraps it in `Layered`.

### Parameters
#### Path Parameters
- **service** (S) - Required - The service to apply the layer to.
```

--------------------------------

### Into Implementation for ChannelOptions

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.ChannelOptions.html

Allows converting ChannelOptions into another type that implements From<ChannelOptions>.

```rust
impl<T, U> Into<U> for T
where U: From<T>,
```

--------------------------------

### Default Implementation for SubscribeUpdateTransactionInfo

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateTransactionInfo.html

Provides a default value for SubscribeUpdateTransactionInfo, useful for initialization.

```rust
fn default() -> SubscribeUpdateTransactionInfo
```

--------------------------------

### PartialEq Implementation for SubscribeReplayInfoRequest

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeReplayInfoRequest.html

Enables comparison for equality between SubscribeReplayInfoRequest instances.

```rust
fn eq(&self, other: &SubscribeReplayInfoRequest) -> bool
```

--------------------------------

### try_into

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Performs the conversion from one type to another.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

### Type Constraints
* `U`: Must implement `TryFrom<T>`.
```

--------------------------------

### Convert i32 to SlotStatus using TryFrom

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/enum.SlotStatus.html

Safely converts an i32 to a SlotStatus. Returns a Result containing the SlotStatus on success or an UnknownEnumValue error if the value is invalid.

```rust
fn try_from(value: i32) -> Result<SlotStatus, UnknownEnumValue>
```

--------------------------------

### impl<T> FromRef<T> for T

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdatePing.html

Provides a way to create a new instance from a reference to an existing instance.

```APIDOC
## fn from_ref(input: &T) -> T

### Description
Converts to this type from a reference to the input type.

### Method
`from_ref`

### Parameters
#### Path Parameters
- **input** (*&T*) - Required - A reference to the input type.

### Response
#### Success Response
- **T** - The newly created instance of the type.
```

--------------------------------

### PartialEq Implementation for SubscribePreprocessedTransactionInfo

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribePreprocessedTransactionInfo.html

Enables comparison of SubscribePreprocessedTransactionInfo instances for equality.

```rust
fn eq(&self, other: &SubscribePreprocessedTransactionInfo) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Default Implementation for SubscribeUpdateBlockMeta

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateBlockMeta.html

Provides a default value for SubscribeUpdateBlockMeta, allowing instances to be created with default settings.

```rust
fn default() -> SubscribeUpdateBlockMeta
```

--------------------------------

### Default Implementation for SubscribePreprocessedTransactionInfo

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribePreprocessedTransactionInfo.html

Provides a default value for SubscribePreprocessedTransactionInfo, useful for initialization.

```rust
fn default() -> SubscribePreprocessedTransactionInfo
```

--------------------------------

### Create a new GeyserClient

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Constructs a new GeyserClient instance with the provided gRPC service. This is a basic constructor.

```rust
pub fn new(inner: T) -> GeyserClient<T>
```

--------------------------------

### Nightly-Only: Clone to Uninit

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.LaserstreamConfig.html

Nightly-only experimental API. Performs copy-assignment from LaserstreamConfig to an uninitialized memory location.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)>
```

--------------------------------

### Clone Implementation for CompiledInstruction

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.CompiledInstruction.html

Provides methods for cloning CompiledInstruction instances, allowing for duplicate creation or copying from another instance.

```rust
fn clone(&self) -> CompiledInstruction
```

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

--------------------------------

### Same for T

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribePreprocessedUpdate.html

Defines an associated type `Output` that should always be `Self`.

```APIDOC
## impl<T> Same for T

### Description
Defines an associated type `Output` which is always `Self`.

### Associated Type
- `Output` (T) - Should always be `Self`.
```

--------------------------------

### SubscribeReplayInfoResponse

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeReplayInfoResponse.html

Represents the response containing information about the first available replay data.

```APIDOC
## Struct SubscribeReplayInfoResponse

### Summary
```rust
pub struct SubscribeReplayInfoResponse {
    pub first_available: Option<u64>,
}
```

### Fields
* `first_available`: `Option<u64>` - The timestamp of the first available replay data. This field is optional.
```

--------------------------------

### PartialEq Implementation for InnerInstructions

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.InnerInstructions.html

Enables comparison for equality between InnerInstructions instances.

```rust
fn eq(&self, other: &InnerInstructions) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Default ChannelOptions

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.ChannelOptions.html

Provides the default configuration for a channel when no specific options are set.

```rust
fn default() -> ChannelOptions
```

--------------------------------

### subscribe

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/client.rs.html

Establishes a gRPC connection for real-time data subscriptions. This function handles the subscription lifecycle, including automatic reconnection on failure, and provides a stream of updates along with a handle to manage the subscription.

```APIDOC
## subscribe

### Description
Establishes a gRPC connection, handles the subscription lifecycle, and provides a stream of updates. Automatically reconnects on failure.

### Signature
```rust
pub fn subscribe(
    config: LaserstreamConfig,
    request: SubscribeRequest,
) -> (
    impl Stream<Item = Result<SubscribeUpdate, LaserstreamError>>,
    StreamHandle,
)
```

### Parameters

- `config` (LaserstreamConfig): Configuration for the subscription, including API key, replay settings, and reconnection attempts.
- `request` (SubscribeRequest): The initial subscription request, defining the data filters and slots to subscribe to.
```

--------------------------------

### Default Implementation for GetVersionRequest

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.GetVersionRequest.html

Provides a default value for GetVersionRequest, allowing it to be created without explicit parameters.

```rust
impl Default for GetVersionRequest
Source§
#### fn default() -> GetVersionRequest
Returns the “default value” for a type. Read more
Source
```

--------------------------------

### GeyserClient::with_origin

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Creates a new GeyserClient with the provided inner service and origin URI.

```APIDOC
## GeyserClient::with_origin

### Description
Creates a new GeyserClient with the provided inner service and origin URI.

### Signature
```rust
pub fn with_origin(inner: T, origin: Uri) -> GeyserClient<T>
```
```

--------------------------------

### LaserstreamConfig with Custom Channel Options

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/config.rs.html

Allows setting custom channel options for the Laserstream connection, overriding defaults.

```rust
pub fn with_channel_options(mut self, options: ChannelOptions) -> Self {
        self.channel_options = options;
        self
    }
```

--------------------------------

### PartialEq Implementation for SubscribeUpdateBlockMeta

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateBlockMeta.html

Enables equality comparisons between SubscribeUpdateBlockMeta instances using `eq` and `ne` methods.

```rust
fn eq(&self, other: &SubscribeUpdateBlockMeta) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### GeyserServer::with_interceptor

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Creates a GeyserServer with a custom interceptor.

```APIDOC
## GeyserServer::with_interceptor

### Description
Creates a GeyserServer with a custom interceptor.

### Signature
```rust
pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<GeyserServer<T>, F>
where
    F: Interceptor,
```
```

--------------------------------

### clone_from

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/client/struct.PreprocessedStreamHandle.html

Performs copy-assignment from a source PreprocessedStreamHandle.

```APIDOC
#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`. Read more
```

--------------------------------

### connect_and_subscribe_preprocessed_once

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/client.rs.html

Establishes a connection to the Helius Laserstream service and subscribes to a preprocessed data stream. It handles connection options, TLS configuration, and applies compression if specified.

```APIDOC
## connect_and_subscribe_preprocessed_once

### Description
Connects to the Helius Laserstream service and subscribes to a preprocessed data stream. This function configures connection parameters, applies TLS, and optionally enables compression for the stream.

### Function Signature
```rust
async fn connect_and_subscribe_preprocessed_once(
    config: &LaserstreamConfig,
    request: SubscribePreprocessedRequest,
    api_key: String,
) -> Result<impl Stream<Item = Result<SubscribePreprocessedUpdate, laserstream_core_proto::tonic::Status>> + Send, Status>
```

### Parameters
- `config` (*LaserstreamConfig): Configuration for the Laserstream connection, including endpoint and channel options.
- `request` (*SubscribePreprocessedRequest): The initial subscription request for preprocessed data.
- `api_key` (String): The API key for authentication.

### Returns
A `Result` containing a stream of `SubscribePreprocessedUpdate` or a `Status` error if the connection or subscription fails.
```

--------------------------------

### StructuralPartialEq Implementation for BlockHeight

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.BlockHeight.html

Provides structural equality comparison for BlockHeight.

```rust
impl StructuralPartialEq for BlockHeight
```

--------------------------------

### Clone To Uninit SubscribeUpdateEntry (Experimental)

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateEntry.html

Performs copy-assignment from SubscribeUpdateEntry to an uninitialized memory location. This is an experimental, nightly-only API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.
```

--------------------------------

### Borrow LaserstreamConfig

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.LaserstreamConfig.html

Immutably borrows the LaserstreamConfig.

```rust
fn borrow(&self) -> &T>
```

--------------------------------

### Set Custom Channel Options

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.LaserstreamConfig.html

Allows setting custom gRPC channel options for the Laserstream connection.

```rust
pub fn with_channel_options(self, options: ChannelOptions) -> Self>
```

--------------------------------

### impl<L> LayerExt<L> for L

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Applies a layer to a service and wraps the result in a Layered struct.

```APIDOC
#### fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,
Applies the layer to a service and wraps it in `Layered`.
```

--------------------------------

### boxed_clone

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Convert the service into a `Service` + `Clone` + `Send` trait object.

```APIDOC
## fn boxed_clone(self) -> BoxCloneService<Request, Self::Response, Self::Error>
where Self: Sized + Clone + Send + 'static, Self::Future: Send + 'static,
Convert the service into a `Service` + `Clone` + `Send` trait object. Read more
```

--------------------------------

### boxed_clone

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Convert the service into a `Service` + `Clone` + `Send` trait object.

```APIDOC
## fn boxed_clone(self) -> BoxCloneService<Request, Self::Response, Self::Error>

### Description
Convert the service into a `Service` + `Clone` + `Send` trait object.

### Type Constraints
* `Self`: Must be `Sized`, `Clone`, `Send`, and `'static`.
* `Self::Future`: Must be `Send` and `'static`.
```

--------------------------------

### Convert From Reference

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/config/struct.LaserstreamConfig.html

Converts from a reference to the LaserstreamConfig type.

```rust
fn from_ref(input: &T) -> T>
```

--------------------------------

### Clone Implementation for GetVersionRequest

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.GetVersionRequest.html

Provides methods for cloning GetVersionRequest instances. `clone` creates a duplicate, and `clone_from` performs copy-assignment.

```rust
impl Clone for GetVersionRequest
Source§
#### fn clone(&self) -> GetVersionRequest
Returns a duplicate of the value. Read more
1.0.0 · Source§
#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`. Read more
Source
```

--------------------------------

### GeyserClient::subscribe_preprocessed

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_client/struct.GeyserClient.html

Initiates a streaming subscription for preprocessed blockchain data.

```APIDOC
## GeyserClient::subscribe_preprocessed

### Description
Initiates a streaming subscription for preprocessed blockchain data.

### Signature
```rust
pub async fn subscribe_preprocessed(
    &mut self,
    request: impl IntoStreamingRequest<Message = SubscribePreprocessedRequest>,
) -> Result<Response<Streaming<SubscribePreprocessedUpdate>>, Status>
```
```

--------------------------------

### ChannelOptions with Zstd Compression

Source: https://docs.rs/helius-laserstream/latest/src/helius_laserstream/config.rs.html

Enables zstd compression for both sending and receiving data over the Laserstream channel. Also ensures gzip is accepted.

```rust
pub fn with_zstd_compression(mut self) -> Self {
        self.send_compression = Some(CompressionEncoding::Zstd);
        self.accept_compression = Some(vec![CompressionEncoding::Zstd, CompressionEncoding::Gzip]);
        self
    }
```

--------------------------------

### Implement Default for NumPartitions

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.NumPartitions.html

Provides a default value for NumPartitions, typically representing zero partitions.

```rust
fn default() -> NumPartitions
```

--------------------------------

### PingRequest PartialEq Implementation

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.PingRequest.html

Enables comparison of PingRequest instances for equality.

```rust
fn eq(&self, other: &PingRequest) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### PartialEq Implementation for SubscribeUpdate

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdate.html

Provides methods for comparing SubscribeUpdate values for equality.

```rust
fn eq(&self, other: &SubscribeUpdate) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Implement Message for SubscribeUpdatePong

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdatePong.html

Implements core Protobuf message functionalities for SubscribeUpdatePong, including encoding, decoding, and clearing the message. This is essential for gRPC communication.

```rust
impl Message for SubscribeUpdatePong
Source§
#### fn encoded_len(&self) -> usize
Returns the encoded length of the message without a length delimiter.
Source§
#### fn clear(&mut self)
Clears the message, resetting all fields to their default.
Source§
#### fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>
where Self: Sized,
Encodes the message to a buffer. Read more
Source§
#### fn encode_to_vec(&self) -> Vec<u8>
where Self: Sized,
Encodes the message to a newly allocated buffer.
Source§
#### fn encode_length_delimited(&self,
buf: &mut impl BufMut,
) -> Result<(), EncodeError>
where Self: Sized,
Encodes the message with a length-delimiter to a buffer. Read more
Source§
#### fn encode_length_delimited_to_vec(&self) -> Vec<u8>
where Self: Sized,
Encodes the message with a length-delimiter to a newly allocated buffer.
Source§
#### fn decode(buf: impl Buf) -> Result<Self, DecodeError>
where Self: Default,
Decodes an instance of the message from a buffer. Read more
Source§
#### fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>
where Self: Default,
Decodes a length-delimited instance of the message from the buffer.
Source§
#### fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>
where Self: Sized,
Decodes an instance of the message from a buffer, and merges it into `self`. Read more
Source§
#### fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>
where Self: Sized,
Decodes a length-delimited instance of the message from buffer, and merges it into `self`.
Source
```

--------------------------------

### LayerExt<L> for L

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateTransactionInfo.html

Applies a layer to a service and wraps it in a Layered struct.

```APIDOC
### impl<L> LayerExt<L> for L

#### fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in `Layered`.
```

--------------------------------

### PartialEq Implementation for SubscribeUpdateBatch

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/struct.SubscribeUpdateBatch.html

Provides methods for comparing SubscribeUpdateBatch instances for equality.

```rust
fn eq(&self, other: &SubscribeUpdateBatch) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### GeyserServer::accept_compressed Configuration

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/grpc/geyser_server/struct.GeyserServer.html

Enables decompressing incoming requests with the specified compression encoding.

```rust
pub fn accept_compressed(self, encoding: CompressionEncoding) -> GeyserServer<T>
```

--------------------------------

### Clone Implementation for Rewards

Source: https://docs.rs/helius-laserstream/latest/helius_laserstream/solana/storage/confirmed_block/struct.Rewards.html

Provides methods to duplicate Rewards instances.

```rust
fn clone(&self) -> Rewards
```

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