Struct TxCache 

pub struct TxCache { /* private fields */ }

Signet’s Transaction Cache helper. Forwards GET and POST requests to a tx cache URL.

Implementations

impl TxCache

pub const fn new_with_client(url: Url, client: Client) -> Self

Create a new cache with the given URL and client.

pub fn new(url: Url) -> Self

Instantiate a new cache with the given URL and a new reqwest client.

pub fn new_from_string(url: &str) -> Result<Self>

Create a new cache given a string URL.

pub fn parmigiana() -> Self

Connect to the transaction cache with the Parmigiana URL.

pub fn parmigiana_with_client(client: Client) -> Self

Create a new cache with the Parmigiana URL and a specific reqwest::Client.

pub fn pecorino() -> Self

👎Deprecated:

Pecorino is being deprecated in favor of Parmigiana

Connect to the transaction cache with the Pecorino URL.

pub fn pecorino_with_client(client: Client) -> Self

👎Deprecated:

Pecorino is being deprecated in favor of Parmigiana

Connect to the transaction cache with the Pecorino URL and a specific reqwest::Client.

pub const fn client(&self) -> &Client

Get the client used to send requests

pub const fn url(&self) -> &Url

Get the URL of the transaction cache.

pub async fn forward_raw_transaction( &self, tx: TxEnvelope, ) -> Result<TransactionResponse>

Forward a raw transaction to the transaction cache.

This method submits a signed transaction envelope to the cache for inclusion in a future block. The transaction will be validated and stored, returning a response containing its cache identifier.

Arguments

• tx - A signed TxEnvelope containing the transaction to forward.

Returns

A TransactionResponse containing the transaction’s cache identifier on success.

Errors

Returns an error if the request fails or the transaction cache rejects the transaction.

pub async fn forward_bundle( &self, bundle: SignetEthBundle, ) -> Result<BundleResponse>

Forward a bundle to the transaction cache.

This method submits a signed bundle to the cache for inclusion in a future block. Bundles allow multiple transactions to be submitted atomically with ordering guarantees.

Arguments

• bundle - A SignetEthBundle containing the bundle to forward.

Returns

A BundleResponse containing the bundle’s cache identifier (UUID) on success.

Errors

Returns an error if the request fails or the transaction cache rejects the bundle.

pub async fn forward_order(&self, order: SignedOrder) -> Result<()>

Forward a signed order to the transaction cache.

This method submits a signed order to the cache. Orders represent user intents that can be filled by solvers or market makers.

Arguments

• order - A SignedOrder containing the order to forward.

Errors

Returns an error if the request fails or the transaction cache rejects the order.

pub async fn get_transactions( &self, query: Option<TxKey>, ) -> Result<CacheResponse<TransactionList>>

Get transactions from the transaction cache.

Retrieves transactions from the cache, optionally filtered by a query key for pagination. When no query is provided, returns the first page of transactions.

Arguments

• query - An optional TxKey for pagination. Use None to get the first page, or pass the key from a previous response to get subsequent pages.

Returns

A CacheResponse containing a TransactionList with the transactions and pagination information. If more transactions are available, the response will contain a key to fetch the next page.

Errors

Returns an error if the request fails or the response cannot be parsed.

pub async fn get_orders( &self, query: Option<OrderKey>, ) -> Result<CacheResponse<OrderList>>

Get signed orders from the transaction cache.

Retrieves signed orders from the cache, optionally filtered by a query key for pagination. When no query is provided, returns the first page of orders.

Arguments

• query - An optional OrderKey for pagination. Use None to get the first page, or pass the key from a previous response to get subsequent pages.

Returns

A CacheResponse containing an OrderList with the orders and pagination information. If more orders are available, the response will contain a key to fetch the next page.

Errors

Returns an error if the request fails or the response cannot be parsed.

pub async fn update_bundle( &self, bundle_id: &str, bundle: SignetEthBundle, ) -> Result<BundleResponse>

Update an existing bundle in the transaction cache.

This method sends a PUT request to update a bundle that already exists in the cache. The bundle is identified by its UUID and the entire bundle content is replaced with the provided data.

Arguments

• bundle_id - The UUID of the bundle to update.
• bundle - The updated SignetEthBundle to store.

Returns

A BundleResponse containing the bundle’s UUID on success.

Errors

Returns TxCacheError::NotFound if the bundle does not exist. Returns an error if the request fails or the response cannot be parsed.

Example

use signet_tx_cache::TxCache;
use signet_bundle::SignetEthBundle;

async fn example() -> Result<(), signet_tx_cache::TxCacheError> {
    let cache = TxCache::parmigiana();
    let bundle_id = "550e8400-e29b-41d4-a716-446655440000";
    // Create bundle from your transaction data
    let bundle: SignetEthBundle = todo!();

    let response = cache.update_bundle(bundle_id, bundle).await?;
    println!("Updated bundle: {}", response.id);
    Ok(())
}

pub fn stream_transactions( &self, ) -> impl Stream<Item = Result<TxEnvelope>> + Send + '_

Stream all transactions from the transaction cache, automatically paginating through all available pages.

Returns a Stream that yields each TxEnvelope individually, fetching subsequent pages as needed. The stream ends when no more pages are available or on the first error (which is yielded before terminating).

pub fn stream_orders( &self, ) -> impl Stream<Item = Result<SignedOrder>> + Send + '_

Stream all signed orders from the transaction cache, automatically paginating through all available pages.

Returns a Stream that yields each SignedOrder individually, fetching subsequent pages as needed. The stream ends when no more pages are available or on the first error (which is yielded before terminating).

pub async fn update_order( &self, order_id: &str, order: SignedOrder, ) -> Result<OrderResponse>

Update an existing order in the transaction cache.

This method sends a PUT request to update an order that already exists in the cache. The order is identified by its ID and the entire order content is replaced with the provided data.

Arguments

• order_id - The ID of the order to update (hex-encoded B256).
• order - The updated SignedOrder to store.

Returns

An OrderResponse containing the order’s ID on success.

Errors

Returns TxCacheError::NotFound if the order does not exist. Returns an error if the request fails or the response cannot be parsed.

Example

use signet_tx_cache::TxCache;
use signet_types::SignedOrder;

let cache = TxCache::parmigiana();
let order_id = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

let response = cache.update_order(order_id, order).await?;
println!("Updated order: {:?}", response.id);

Trait Implementations

impl Clone for TxCache

fn clone(&self) -> TxCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TxCache

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

Formats the value using the given formatter.