Struct GeyserCompressedAccountFilterSet 

pub struct GeyserCompressedAccountFilterSet { /* private fields */ }

A HashMap-like wrapper around CuckooFilter for safe filter construction.

Maintains two parallel collections:

• A HashSet as the source of truth for exact membership
• A CuckooFilter as the compact wire representation

Writes go to both; reads (contains, len) answer from the HashSet; serialization reads from the CuckooFilter. This gives users exact local semantics while producing a compact probabilistic filter for the server.

When to Use

Use CompressedAccountFilterSet whenever you need to build a cuckoo filter to send in a subscribe request. It is strictly safer than constructing a CuckooFilter directly — the filter’s remove method has a footgun (it can silently remove the wrong item when fingerprints collide), and CompressedAccountFilterSet guards against it.

Example

use {
    solana_pubkey::Pubkey,
    yellowstone_grpc_proto::cuckoo::CompressedAccountFilterSet,
};

let mut map = CompressedAccountFilterSet::with_capacity(1000).unwrap();
map.insert(Pubkey::new_from_array([42u8; 32])).unwrap();
map.insert(Pubkey::new_from_array([100u8; 32])).unwrap();
assert!(map.contains(Pubkey::new_from_array([42u8; 32])));
assert_eq!(map.len(), 2);

map.remove(Pubkey::new_from_array([42u8; 32]));
assert!(!map.contains(Pubkey::new_from_array([42u8; 32])));

Implementations

impl CompressedAccountFilterSet

pub fn with_capacity( max_capacity: usize, ) -> Result<CompressedAccountFilterSet, CuckooBuildError>

Creates an empty map pre-sized for up to max_capacity items.

Both the internal HashSet and CuckooFilter are allocated up front to avoid rehashing or reallocation during inserts.

Errors

Returns CuckooBuildError::CapacityOverflow if max_capacity exceeds what the system can allocate, or if the underlying cuckoo filter cannot be built at the requested size.

Example

use yellowstone_grpc_proto::cuckoo::CompressedAccountFilterSet;

let map = CompressedAccountFilterSet::with_capacity(10_000).unwrap();
assert!(map.is_empty());

pub fn insert(&mut self, key: Address) -> Result<bool, TableFullError>

Inserts an item into the map.

Returns Ok(true) if the item was newly inserted, Ok(false) if it was already present (idempotent).

Errors

Returns TableFullError if the underlying cuckoo filter is saturated and cannot accommodate the item. This typically means the map was under-sized for the workload; rebuild with a larger max_capacity.

On error, the map’s state is unchanged — neither the HashSet nor the CuckooFilter is mutated.

pub fn remove(&mut self, key: Address) -> bool

Removes an item from the map.

Returns true if the item was present and removed, false if it was not in the map.

Safety over CuckooFilter::remove

The underlying CuckooFilter has a known footgun: removing an item that was never inserted can silently remove a different item that shares the same fingerprint. CompressedAccountFilterSet prevents this by checking its internal HashSet first and only touching the filter when the item is genuinely present.

pub fn contains(&self, key: Address) -> bool

Checks if an item is in the map.

Unlike CuckooFilter::contains, this returns an exact answer — the HashSet guarantees no false positives.

pub fn len(&self) -> usize

Returns the number of items in the map.

pub fn capacity(&self) -> usize

Returns the number of items the map can hold without reallocating.

Typically larger than the max_capacity passed to with_capacity, the underlying HashSet rounds allocation up to its own sizing policy. Use this to check remaining headroom before a batch of inserts or to report occupancy alongside len.

use yellowstone_grpc_proto::cuckoo::CompressedAccountFilterSet;

let map = CompressedAccountFilterSet::with_capacity(1000).unwrap();
assert!(map.capacity() >= 1000);

pub fn iter(&self) -> impl Iterator<Item = &[u8; 32]>

Returns an iterator over the items in the map in arbitrary order.

Reads from the internal HashSet, so iteration order matches HashSet semantics; no ordering guarantee, and two calls on the same map may yield items in different orders.

use {
    solana_pubkey::Pubkey,
    yellowstone_grpc_proto::cuckoo::CompressedAccountFilterSet,
};

let mut map = CompressedAccountFilterSet::with_capacity(100).unwrap();
map.insert(Pubkey::new_from_array([1u8; 32])).unwrap();
map.insert(Pubkey::new_from_array([2u8; 32])).unwrap();
map.insert(Pubkey::new_from_array([3u8; 32])).unwrap();

let count = map.iter().count();
assert_eq!(count, 3);

pub fn is_empty(&self) -> bool

Returns true if the map contains no items.

pub const fn is_dirty(&self) -> bool

Returns true if the map has been mutated since the last call to [take_dirty] (or since construction).

Use this to check whether the filter needs to be re-sent without clearing the flag.

pub const fn take_dirty(&mut self) -> bool

Returns the dirty flag and clears it.

Call this when transmitting the filter: if it returns true, rebuild and send; if false, skip the send. Clearing means subsequent mutations will flip the flag back to true for the next cycle.

Example

use {
    solana_pubkey::Pubkey,
    yellowstone_grpc_proto::cuckoo::CompressedAccountFilterSet,
};

let mut map = CompressedAccountFilterSet::with_capacity(100).unwrap();
assert!(!map.take_dirty());    // fresh map is clean

map.insert(Pubkey::new_from_array([42u8; 32])).unwrap();
assert!(map.take_dirty());     // mutation flipped it
assert!(!map.take_dirty());    // and clearing it takes effect

pub fn to_proto(&self) -> CuckooFilter

Serializes the underlying cuckoo filter to its proto wire format.

The returned proto carries all parameters needed for deserialization on the server side or in cross-language clients: bucket count, entries per bucket, fingerprint bits, and the hash seed.

pub fn to_account_filter(&self) -> SubscribeRequestFilterAccounts

Returns a SubscribeRequestFilterAccounts that carries only this cuckoo filter in essence no explicit account list, no owner, no predicates.

Use this when you want to add the cuckoo filter to a subscribe request yourself, under a name of your choosing, alongside other account filters or other subscription types:

use {
    solana_pubkey::Pubkey,
    yellowstone_grpc_proto::{cuckoo::CompressedAccountFilterSet, geyser::SubscribeRequest},
};

let mut map = CompressedAccountFilterSet::with_capacity(1000).unwrap();
map.insert(Pubkey::new_from_array([1u8; 32])).unwrap();

let mut req = SubscribeRequest::default();
req.accounts.insert("my_cuckoo".to_string(), map.to_account_filter());

pub fn to_block_filter(&self) -> SubscribeRequestFilterBlocks

Returns a SubscribeRequestFilterBlocks that carries only this cuckoo filter, no explicit account include list, no transaction or entry options set.

Use this when you want to subscribe to full blocks but filter the transactions and accounts inside them by the cuckoo set:

use {
    solana_pubkey::Pubkey,
    yellowstone_grpc_proto::{cuckoo::CompressedAccountFilterSet, geyser::SubscribeRequest},
};

let mut map = CompressedAccountFilterSet::with_capacity(1000).unwrap();
map.insert(Pubkey::new_from_array([1u8; 32])).unwrap();

let mut req = SubscribeRequest::default();
req.blocks.insert("blocks".to_string(), map.to_block_filter());

pub fn to_transaction_filter(&self) -> SubscribeRequestFilterTransactions

Returns a SubscribeRequestFilterTransactions that carries only this cuckoo filter, no explicit account include list, no vote/failed/signature predicates, no token account expansion.

Use this when you want full transaction details for a large address set without sending every pubkey on the wire. The same filter works for transactions and transactions_status:

use {
    solana_pubkey::Pubkey,
    yellowstone_grpc_proto::{cuckoo::CompressedAccountFilterSet, geyser::SubscribeRequest},
};

let mut map = CompressedAccountFilterSet::with_capacity(1000).unwrap();
map.insert(Pubkey::new_from_array([1u8; 32])).unwrap();

let mut req = SubscribeRequest::default();
req.transactions.insert("txs".to_string(), map.to_transaction_filter());

pub fn insert_into_subscribe_request( &mut self, req: &mut SubscribeRequest, name: &str, )

Inserts this cuckoo filter into req.accounts under the given name.

Existing entries in req.accounts are preserved. If an entry already exists under name, it is replaced. Other fields of req (transactions, blocks, slots, etc.) are untouched.

Marks the map as clean — subsequent mutations will flip the dirty flag back to true for the next transmission cycle.

Example

use {
    solana_pubkey::Pubkey,
    yellowstone_grpc_proto::{cuckoo::CompressedAccountFilterSet, geyser::SubscribeRequest},
};

let mut map = CompressedAccountFilterSet::with_capacity(1000).unwrap();
map.insert(Pubkey::new_from_array([1u8; 32])).unwrap();

let mut req = SubscribeRequest::default();
map.insert_into_subscribe_request(&mut req, "tracked_accounts");
// req.accounts["tracked_accounts"] now carries the cuckoo filter

pub fn insert_into_block_subscribe_request( &mut self, req: &mut SubscribeRequest, name: &str, )

Inserts this cuckoo filter into req.blocks under the given name.

Existing entries in req.blocks are preserved. If an entry already exists under name, it is replaced. Other fields of req are untouched.

Marks the map as clean, subsequent mutations will flip the dirty flag back to true for the next transmission cycle.

Example

use {
    solana_pubkey::Pubkey,
    yellowstone_grpc_proto::{cuckoo::CompressedAccountFilterSet, geyser::SubscribeRequest},
};

let mut map = CompressedAccountFilterSet::with_capacity(1000).unwrap();
map.insert(Pubkey::new_from_array([1u8; 32])).unwrap();

let mut req = SubscribeRequest::default();
map.insert_into_block_subscribe_request(&mut req, "tracked_blocks");

pub fn insert_into_transaction_subscribe_request( &mut self, req: &mut SubscribeRequest, name: &str, )

Inserts this cuckoo filter into req.transactions under the given name.

Existing entries in req.transactions are preserved. If an entry already exists under name, it is replaced. Other fields of req are untouched.

Marks the map as clean, subsequent mutations will flip the dirty flag back to true for the next transmission cycle.

Example

use {
    solana_pubkey::Pubkey,
    yellowstone_grpc_proto::{cuckoo::CompressedAccountFilterSet, geyser::SubscribeRequest},
};

let mut map = CompressedAccountFilterSet::with_capacity(1000).unwrap();
map.insert(Pubkey::new_from_array([1u8; 32])).unwrap();

let mut req = SubscribeRequest::default();
map.insert_into_transaction_subscribe_request(&mut req, "tracked_txs");