> For the complete documentation index, see [llms.txt](https://docs.talus.network/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.talus.network/reference/sdk/crawler.md).

# Crawler Reads

**Audience:** Nexus SDK integrators (Rust).

**Area:** Crawler reads.

**Generated from:** Nexus SDK crawler API at tag `v2.1.1` commit `08bfe76e726922ce512d623fbc1d2e1bd786bcd4`; the generated inventory is preserved and 2.1.1 read helpers are source-verified.

Complete public Crawler types and methods for typed object, metadata, transaction, owned-object, dynamic-field, versioned-state, package, and table-vector reads.

### Transaction-consistent reads and recovery

`ObjectUpdateReference` identifies the exact object version, owner, type, digest, and previous transaction. `TransactionUpdate` reads the transaction effects and events for a digest. Use these helpers together: a notification or indexed activity record identifies work to inspect, while the configured Sui RPC establishes the exact object and transaction result.

`TransactionStateOutput<T>` carries the decoded `data` value together with the stable parent `object_id` and the `field_ref` written by that transaction. It does not contain a transaction view; correlate it with the caller's `ExecutedTransaction` or `TransactionUpdate` when transaction effects or events are needed. `transaction_output_object` and `get_transaction_output_object` select an object from a transaction's output; `transaction_shared_initial_version` extracts a shared object's initial version for a consistent follow-up read. Treat `ObjectNotFound` or an incomplete transaction result as evidence requiring classification, not proof that prior state never existed.

### Public types

#### `Crawler` methods

**`new`**

```rust
pub fn new(client: Arc<sui::grpc::Client>) -> Self
```

**`get_package`**

> Fetch a published Move package descriptor for ABI inspection.

```rust
pub async fn get_package(&self, package_id: sui::types::Address) -> anyhow::Result<sui::grpc::Package>
```

**`get_object`**

> Fetch an object by its ID and deserialize its Move struct contents from BCS.

```rust
pub async fn get_object<T>(&self, object_id: sui::types::Address) -> anyhow::Result<Response<T>>
where
    T: DeserializeOwned
```

**`get_optional_object`**

> Fetch an object when present.
>
> \# Errors
>
> Returns an error for transport and decoding failures. A missing object returns `Ok(None)`.

```rust
pub async fn get_optional_object<T>(&self, object_id: sui::types::Address) -> anyhow::Result<Option<Response<T>>>
where
    T: DeserializeOwned
```

**`get_objects`**

> Fetch many objects by their IDs in batch and deserialize Move struct contents from BCS.

```rust
pub async fn get_objects<T>(&self, object_ids: &[sui::types::Address]) -> anyhow::Result<Vec<Response<T>>>
where
    T: DeserializeOwned
```

**`get_optional_objects`**

> Fetches many objects that may no longer exist.
>
> Each result corresponds to the identifier at the same position in `object_ids`. A missing object produces \[`None`].
>
> \# Errors
>
> Returns an error when the RPC response is malformed, a present object has the wrong identity, or transport or decoding fails.

```rust
pub async fn get_optional_objects<T>(&self, object_ids: &[sui::types::Address]) -> anyhow::Result<Vec<Option<Response<T>>>>
where
    T: DeserializeOwned
```

**`get_chain_id`**

> Fetch the connected RPC's chain identifier in the 8-hex-char form Sui's Move builder uses for `[environments]` lookups (the same value `sui client chain-identifier` prints). The gRPC service-info call returns the genesis checkpoint digest base58-encoded; we decode it and hex-encode the first four bytes to derive the short identifier.

```rust
pub async fn get_chain_id(&self) -> anyhow::Result<String>
```

**`get_object_metadata`**

> Fetch an object's metadata only, omitting its content.

```rust
pub async fn get_object_metadata(&self, object_id: sui::types::Address) -> anyhow::Result<Response<()>>
```

**`get_object_update_reference`**

> Fetch the update reference for the latest or a historical object version. Unlike \[`Self::get_object_metadata`], this includes the transaction digest that produced the requested version.

```rust
pub async fn get_object_update_reference(&self, object_id: sui::types::Address, version: Option<sui::types::Version>) -> anyhow::Result<ObjectUpdateReference>
```

**`get_transaction_update`**

> Fetch and decode the effects and events for one transaction digest

```rust
pub async fn get_transaction_update(&self, digest: sui::types::Digest) -> anyhow::Result<TransactionUpdate>
```

**`get_objects_metadata`**

> Fetch many objects' metadata only in batch, omitting their content.

```rust
pub async fn get_objects_metadata(&self, object_ids: &[sui::types::Address]) -> anyhow::Result<Vec<Response<()>>>
```

**`fetch_coins_for_address_by_type`**

> Fetch every coin owned by `owner` with the exact requested Move struct tag.
>
> The state service applies owner and type filters. Returned objects are validated again so callers never receive a reference whose address owner or type differs from the request.

```rust
pub async fn fetch_coins_for_address_by_type(&self, owner: sui::types::Address, object_type: sui::types::StructTag) -> anyhow::Result<Vec<(sui::types::ObjectReference, u64)>>
```

**`get_owned_objects`**

> Fetch owned objects of a specific type for an owner and deserialize BCS contents.

```rust
pub async fn get_owned_objects<T>(&self, owner: sui::types::Address, object_type: sui::types::StructTag) -> anyhow::Result<Vec<Response<T>>>
where
    T: DeserializeOwned
```

**`get_object_owned_objects`**

> Fetch exact-type objects owned by another object and deserialize their BCS contents.

```rust
pub async fn get_object_owned_objects<T>(&self, parent_id: sui::types::Address, object_type: sui::types::StructTag) -> anyhow::Result<Vec<Response<T>>>
where
    T: DeserializeOwned
```

**`get_owned_object_page`**

> Fetch one RPC page of objects owned by an address with an exact type.
>
> The address owner and type of every returned object are validated after the state service applies the same filters.
>
> \# Errors
>
> Returns an error when `limit` is zero, the RPC request fails, the response violates its owner or type filter, or an object cannot be decoded.

```rust
pub async fn get_owned_object_page<T>(&self, owner: sui::types::Address, object_type: sui::types::StructTag, cursor: Option<Vec<u8>>, limit: usize) -> anyhow::Result<OwnedObjectPage<T>>
where
    T: DeserializeOwned
```

**`get_object_owned_object_page`**

> Fetch one RPC page of exact-type objects owned by another object.
>
> Unlike \[`Crawler::get_owned_object_page`], this requires every returned object to have the exact `Owner::Object(parent_id)` owner. Address and consensus-address ownership are rejected.

```rust
pub async fn get_object_owned_object_page<T>(&self, parent_id: sui::types::Address, object_type: sui::types::StructTag, cursor: Option<Vec<u8>>, limit: usize) -> anyhow::Result<OwnedObjectPage<T>>
where
    T: DeserializeOwned
```

**`get_dynamic_fields`**

> Fetch all dynamic fields for a given parent table object and parse them into a `HashMap<K, V>`.

```rust
pub async fn get_dynamic_fields<K, V>(&self, parent_id: sui::types::Address, expected_size: usize) -> anyhow::Result<HashMap<K, V>>
where
    K: Eq + Hash + DeserializeOwned,
    V: DeserializeOwned
```

**`get_dynamic_field_refs_matching_key`**

> Fetch dynamic field references whose BCS names decode as `K`.
>
> This is the right shape for heterogeneous dynamic field parents: inspect names first, then fetch the selected field object with the expected value type.

```rust
pub async fn get_dynamic_field_refs_matching_key<K>(&self, parent_id: sui::types::Address) -> anyhow::Result<Vec<DynamicFieldReference<K>>>
where
    K: Eq + Hash + DeserializeOwned
```

**`get_dynamic_field_value_by_id`**

> Fetch a dynamic field object by field ID and decode only its value.

```rust
pub async fn get_dynamic_field_value_by_id<K, V>(&self, field_id: sui::types::Address) -> anyhow::Result<V>
where
    K: DeserializeOwned,
    V: DeserializeOwned
```

**`get_dynamic_field_by_key`**

> Fetch the dynamic field selected by one typed key.
>
> The field object identifier is derived from `parent_id`, `key`, and `key_type`, so sibling fields are not enumerated. `key_type` must be the canonical Move \[`sui::types::TypeTag`] for `K`. An absent field returns \[`None`].
>
> \# Errors
>
> Returns an error when the key cannot be encoded, the object request fails, or the field identity, key, or value is invalid.

```rust
pub async fn get_dynamic_field_by_key<K, V>(&self, parent_id: sui::types::Address, key: K, key_type: &sui::types::TypeTag) -> anyhow::Result<Option<V>>
where
    K: Eq + Serialize + DeserializeOwned,
    V: DeserializeOwned
```

**`get_dynamic_fields_by_keys`**

> Fetch values for the distinct dynamic field keys requested from one parent.
>
> Field identities are derived from `parent_id`, `key_type`, and each BCS encoded key. Unlike \[`Crawler::get_dynamic_fields`], the amount of work is independent of unrelated fields stored under the parent.
>
> Missing fields are omitted from the returned \[`HashMap`]. Duplicate keys produce one object request.
>
> \# Errors
>
> Returns an error when a key cannot be encoded, an RPC response has an unexpected identity, or a present field cannot be decoded and validated.

```rust
pub async fn get_dynamic_fields_by_keys<K, V, I>(&self, parent_id: sui::types::Address, keys: I, key_type: &sui::types::TypeTag) -> anyhow::Result<HashMap<K, V>>
where
    K: Eq + Hash + Serialize + DeserializeOwned,
    V: DeserializeOwned,
    I: IntoIterator<Item = K>
```

**`get_dynamic_field_page_matching_types`**

> Fetch one RPC page of dynamic fields matching a key and value type.
>
> Fields from other namespaces are skipped. The returned cursor is the unmodified cursor supplied by Sui for the requested page.
>
> \# Errors
>
> Returns an error when `limit` is zero, the RPC request fails, or a matching field object cannot be decoded.

```rust
pub async fn get_dynamic_field_page_matching_types<K, V>(&self, parent_id: sui::types::Address, cursor: Option<Vec<u8>>, limit: usize, value_type_suffix: &str) -> anyhow::Result<DynamicFieldPage<K, V>>
where
    K: DeserializeOwned,
    V: DeserializeOwned
```

**`get_dynamic_field_object_values`**

> Fetch dynamic field values from their field objects without decoding key names. This is useful for singleton dynamic fields whose on-chain name encoding is package-version dependent.

```rust
pub async fn get_dynamic_field_object_values<K, V>(&self, parent_id: sui::types::Address) -> anyhow::Result<Vec<V>>
where
    K: DeserializeOwned,
    V: DeserializeOwned
```

**`get_dynamic_field_values`**

> Fetch all dynamic-field values for a parent object without attempting to decode keys.

```rust
pub async fn get_dynamic_field_values<V>(&self, parent_id: sui::types::Address) -> anyhow::Result<Vec<(Option<String>, V)>>
where
    V: DeserializeOwned
```

**`get_dynamic_object_fields`**

> Fetch all dynamic object fields for a parent object id without requiring a local dynamic-object-map wrapper.

```rust
pub async fn get_dynamic_object_fields<K, V>(&self, parent_id: sui::types::Address) -> anyhow::Result<HashMap<K, Response<V>>>
where
    K: Eq + Hash + DeserializeOwned,
    V: DeserializeOwned
```

**`get_dynamic_object_field_by_key`**

> Fetch the dynamic object field selected by one typed key.
>
> The method derives and reads the Sui wrapper field, then fetches only the child object named by that wrapper. `key_type` must be the canonical Move \[`sui::types::TypeTag`] for `K`. Unlike \[`Crawler::get_dynamic_object_fields`], it does not enumerate sibling fields. A missing wrapper returns `Ok(None)`.
>
> \# Errors
>
> Returns an error when the wrapper key cannot be encoded, either object request fails, the wrapper or child identity is invalid, the child is absent, or a returned value cannot be decoded and validated.

```rust
pub async fn get_dynamic_object_field_by_key<K, V>(&self, parent_id: sui::types::Address, key: K, key_type: &sui::types::TypeTag) -> anyhow::Result<Option<Response<V>>>
where
    K: Eq + Serialize + DeserializeOwned,
    V: DeserializeOwned
```

**`get_dynamic_object_field_refs_matching_key`**

> Fetch dynamic object fields for a parent and keep only entries whose key BCS decodes as `K`. Parents may legitimately contain several child namespaces with unrelated key types.

```rust
pub async fn get_dynamic_object_field_refs_matching_key<K>(&self, parent_id: sui::types::Address) -> anyhow::Result<Vec<DynamicObjectFieldReference<K>>>
where
    K: Eq + Hash + DeserializeOwned
```

**`get_dynamic_object_field_child_ids`**

> Fetch all dynamic object field child IDs for a parent object.

```rust
pub async fn get_dynamic_object_field_child_ids(&self, parent_id: sui::types::Address) -> anyhow::Result<Vec<sui::types::Address>>
```

**`get_table_vec`**

> Fetch every item in a \[`TableVec`] by its contiguous index key.
>
> The request derives the fields for `0..parent.size_u64()` directly and returns values in index order.
>
> \# Errors
>
> Returns an error when an index field cannot be fetched, validated, or decoded, or when any expected index is absent.

```rust
pub async fn get_table_vec<T>(&self, parent: &TableVec<T>) -> anyhow::Result<Vec<T>>
where
    T: DeserializeOwned
```

**`DynamicFieldPage` methods**

**`data`**

> Returns the decoded values in RPC order.

```rust
pub fn data(&self) -> &[(K, V)]
```

**`next_cursor`**

> Returns the opaque cursor for the next RPC page.

```rust
pub fn next_cursor(&self) -> Option<&[u8]>
```

**`into_parts`**

> Separates the decoded values from the opaque next page cursor.

```rust
pub fn into_parts(self) -> (Vec<(K, V)>, Option<Vec<u8>>)
```

**`OwnedObjectPage` methods**

**`data`**

> Returns the decoded objects in RPC order.

```rust
pub fn data(&self) -> &[Response<T>]
```

**`next_cursor`**

> Returns the opaque cursor for the next RPC page.

```rust
pub fn next_cursor(&self) -> Option<&[u8]>
```

**`into_parts`**

> Separates the decoded objects from the opaque next page cursor.

```rust
pub fn into_parts(self) -> (Vec<Response<T>>, Option<Vec<u8>>)
```

**`Response` methods**

**`is_shared`**

> Check if the object is shared.

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

**`is_immutable`**

> Check if the object is immutable.

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

**`get_initial_version`**

> Get initial version of the object if it's shared or current version otherwise.

```rust
pub fn get_initial_version(&self) -> sui::types::Version
```

**`object_ref`**

```rust
pub fn object_ref(&self) -> sui::types::ObjectReference
```

**`Set` methods**

**`new`**

```rust
pub fn new() -> Self
```

**`into_inner`**

```rust
pub fn into_inner(self) -> HashSet<T>
```

**`inner`**

```rust
pub fn inner(&self) -> &HashSet<T>
```

**`inner_mut`**

```rust
pub fn inner_mut(&mut self) -> &mut HashSet<T>
```

**`is_empty`**

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

**`Map` methods**

**`new`**

```rust
pub fn new() -> Self
```

**`from_map`**

```rust
pub fn from_map(contents: HashMap<K, V>) -> Self
```

**`into_inner`**

```rust
pub fn into_inner(self) -> HashMap<K, V>
```

**`into_map`**

```rust
pub fn into_map(self) -> HashMap<K, V>
```

**`inner`**

```rust
pub fn inner(&self) -> &HashMap<K, V>
```

**`inner_mut`**

```rust
pub fn inner_mut(&mut self) -> &mut HashMap<K, V>
```

### Preparation retries and finalized receipts

Use `sui::grpc::with_read_retry_until` to give concurrent crawler preparation one observation deadline. Failed transport reads can retry while completed sibling reads are retained. End the retry scope before external effects, or wrap those effects in `without_read_retry`. Dropping the preparation future cancels active reads and backoff. `set_retry_request_budget` bounds recovery admission across pooled clients for an endpoint; ordinary requests bypass that budget. `with_retry_budget` applies admission to a recovery attempt without replaying effects or changing transaction identity.

`transaction_output_object` decodes object bytes from a transaction receipt, and `transaction_shared_initial_version` obtains its initial shared version. The Workflow result decoder validates Execution and walk identity against this receipt, allowing consumption without waiting for a later object read. Keep the receipt and identity checks with the decoded result.

### Source-derived public API inventory

#### `Crawler`

```rust
pub struct Crawler {
    client: Arc<sui::grpc::Client>,
    state_catalog: Arc<sui::grpc::Client>,
}
```

#### `DynamicObjectFieldReference`

```rust
pub struct DynamicObjectFieldReference<K> {
    pub name: K,
    pub field_id: sui::types::Address,
    pub child_id: sui::types::Address,
}
```

#### `DynamicFieldReference`

```rust
pub struct DynamicFieldReference<K> {
    pub name: K,
    pub field_id: sui::types::Address,
}
```

#### `DynamicFieldMetadata`

```rust
pub struct DynamicFieldMetadata {
    /// Object ID of the dynamic field wrapper.
    pub field_id: sui::types::Address,
    /// Exact Move type of the field key.
    pub key_type: sui::types::TypeTag,
    /// Exact Move type of the field value.
    pub value_type: sui::types::TypeTag,
}
```

#### `ObjectMetadata`

```rust
pub struct ObjectMetadata {
    /// Stable Sui object ID.
    pub object_id: sui::types::Address,
    /// Current object owner.
    pub owner: sui::types::Owner,
    /// Exact Move type of the object anchor.
    pub object_type: sui::types::StructTag,
}
```

#### `DynamicFieldPage`

```rust
pub struct DynamicFieldPage<K, V> {
    data: Vec<(K, V)>,
    next_cursor: Option<Vec<u8>>,
}
```

#### `DynamicFieldPage::data`

```rust
pub fn data(&self) -> &[(K, V)] {
```

#### `DynamicFieldPage::next_cursor`

```rust
pub fn next_cursor(&self) -> Option<&[u8]> {
```

#### `DynamicFieldPage::into_parts`

```rust
pub fn into_parts(self) -> (Vec<(K, V)>, Option<Vec<u8>>) {
```

#### `OwnedObjectPage`

```rust
pub struct OwnedObjectPage<T> {
    data: Vec<Response<T>>,
    next_cursor: Option<Vec<u8>>,
}
```

#### `OwnedObjectPage::data`

```rust
pub fn data(&self) -> &[Response<T>] {
```

#### `OwnedObjectPage::next_cursor`

```rust
pub fn next_cursor(&self) -> Option<&[u8]> {
```

#### `OwnedObjectPage::into_parts`

```rust
pub fn into_parts(self) -> (Vec<Response<T>>, Option<Vec<u8>>) {
```

#### `ObjectUpdateReference`

```rust
pub struct ObjectUpdateReference {
    pub owner: sui::types::Owner,
    pub object_type: sui::types::StructTag,
    pub version: sui::types::Version,
    pub digest: sui::types::Digest,
    pub previous_transaction: sui::types::Digest,
}
```

#### `TransactionUpdate`

```rust
pub struct TransactionUpdate {
    pub digest: sui::types::Digest,
    pub checkpoint: u64,
    pub effects: sui::types::TransactionEffectsV2,
    pub events: Vec<sui::types::Event>,
}
```

#### `Crawler::new`

```rust
pub fn new(client: Arc<sui::grpc::Client>) -> Self {
```

#### `Crawler::with_state_catalog`

```rust
pub fn with_state_catalog(
        client: Arc<sui::grpc::Client>,
        state_catalog: Arc<sui::grpc::Client>,
    ) -> Self {
```

#### `Crawler::observe_object_metadata`

```rust
pub async fn observe_object_metadata(
        &self,
        object_id: sui::types::Address,
    ) -> anyhow::Result<ObjectMetadata> {
```

#### `Crawler::get_dynamic_field_metadata`

```rust
pub async fn get_dynamic_field_metadata(
        &self,
        parent_id: sui::types::Address,
    ) -> anyhow::Result<Vec<DynamicFieldMetadata>> {
```

#### `Crawler::get_package`

```rust
pub async fn get_package(
        &self,
        package_id: sui::types::Address,
    ) -> anyhow::Result<sui::grpc::Package> {
```

#### `Crawler::get_object`

```rust
pub async fn get_object<T>(&self, object_id: sui::types::Address) -> anyhow::Result<Response<T>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::get_optional_object`

```rust
pub async fn get_optional_object<T>(
        &self,
        object_id: sui::types::Address,
    ) -> anyhow::Result<Option<Response<T>>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::get_objects`

```rust
pub async fn get_objects<T>(
        &self,
        object_ids: &[sui::types::Address],
    ) -> anyhow::Result<Vec<Response<T>>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::get_optional_objects`

```rust
pub async fn get_optional_objects<T>(
        &self,
        object_ids: &[sui::types::Address],
    ) -> anyhow::Result<Vec<Option<Response<T>>>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::get_chain_id`

```rust
pub async fn get_chain_id(&self) -> anyhow::Result<String> {
```

#### `Crawler::get_chain_digest`

```rust
pub async fn get_chain_digest(&self) -> anyhow::Result<sui::types::Digest> {
```

#### `Crawler::get_object_metadata`

```rust
pub async fn get_object_metadata(
        &self,
        object_id: sui::types::Address,
    ) -> anyhow::Result<Response<()>> {
```

#### `Crawler::get_object_update_reference`

```rust
pub async fn get_object_update_reference(
        &self,
        object_id: sui::types::Address,
        version: Option<sui::types::Version>,
    ) -> anyhow::Result<ObjectUpdateReference> {
```

#### `Crawler::get_transaction_update`

```rust
pub async fn get_transaction_update(
        &self,
        digest: sui::types::Digest,
    ) -> anyhow::Result<TransactionUpdate> {
```

#### `Crawler::get_transaction_objects`

```rust
pub async fn get_transaction_objects(
        &self,
        transaction: sui::types::Digest,
    ) -> anyhow::Result<sui::grpc::ExecutedTransaction> {
```

#### `Crawler::transaction_output_object`

```rust
pub fn transaction_output_object<T>(
        &self,
        executed: &sui::grpc::ExecutedTransaction,
        transaction: sui::types::Digest,
        object_id: sui::types::Address,
    ) -> anyhow::Result<Response<T>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::transaction_shared_initial_version`

```rust
pub fn transaction_shared_initial_version(
        &self,
        executed: &sui::grpc::ExecutedTransaction,
        transaction: sui::types::Digest,
        object_id: sui::types::Address,
        expected_type: &sui::types::StructTag,
    ) -> anyhow::Result<sui::types::Version> {
```

#### `Crawler::get_transaction_output_object`

```rust
pub async fn get_transaction_output_object<T>(
        &self,
        transaction: sui::types::Digest,
        object_id: sui::types::Address,
    ) -> anyhow::Result<Response<T>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::get_objects_metadata`

```rust
pub async fn get_objects_metadata(
        &self,
        object_ids: &[sui::types::Address],
    ) -> anyhow::Result<Vec<Response<()>>> {
```

#### `Crawler::fetch_coins_for_address_by_type`

```rust
pub async fn fetch_coins_for_address_by_type(
        &self,
        owner: sui::types::Address,
        object_type: sui::types::StructTag,
    ) -> anyhow::Result<Vec<(sui::types::ObjectReference, u64)>> {
```

#### `Crawler::get_owned_objects`

```rust
pub async fn get_owned_objects<T>(
        &self,
        owner: sui::types::Address,
        object_type: sui::types::StructTag,
    ) -> anyhow::Result<Vec<Response<T>>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::get_object_owned_objects`

```rust
pub async fn get_object_owned_objects<T>(
        &self,
        parent_id: sui::types::Address,
        object_type: sui::types::StructTag,
    ) -> anyhow::Result<Vec<Response<T>>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::get_owned_object_page`

```rust
pub async fn get_owned_object_page<T>(
        &self,
        owner: sui::types::Address,
        object_type: sui::types::StructTag,
        cursor: Option<Vec<u8>>,
        limit: usize,
    ) -> anyhow::Result<OwnedObjectPage<T>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::get_object_owned_object_page`

```rust
pub async fn get_object_owned_object_page<T>(
        &self,
        parent_id: sui::types::Address,
        object_type: sui::types::StructTag,
        cursor: Option<Vec<u8>>,
        limit: usize,
    ) -> anyhow::Result<OwnedObjectPage<T>>
    where
        T: DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_fields`

```rust
pub async fn get_dynamic_fields<K, V>(
        &self,
        parent_id: sui::types::Address,
        expected_size: usize,
    ) -> anyhow::Result<HashMap<K, V>>
    where
        K: Eq + Hash + DeserializeOwned,
        V: DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_field_refs_matching_key`

```rust
pub async fn get_dynamic_field_refs_matching_key<K>(
        &self,
        parent_id: sui::types::Address,
    ) -> anyhow::Result<Vec<DynamicFieldReference<K>>>
    where
        K: Eq + Hash + DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_field_value_by_id`

```rust
pub async fn get_dynamic_field_value_by_id<K, V>(
        &self,
        field_id: sui::types::Address,
    ) -> anyhow::Result<V>
    where
        K: DeserializeOwned,
        V: DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_field_by_key`

```rust
pub async fn get_dynamic_field_by_key<K, V>(
        &self,
        parent_id: sui::types::Address,
        key: K,
        key_type: &sui::types::TypeTag,
    ) -> anyhow::Result<Option<V>>
    where
        K: Eq + Serialize + DeserializeOwned,
        V: DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_fields_by_keys`

```rust
pub async fn get_dynamic_fields_by_keys<K, V, I>(
        &self,
        parent_id: sui::types::Address,
        keys: I,
        key_type: &sui::types::TypeTag,
    ) -> anyhow::Result<HashMap<K, V>>
    where
        K: Eq + Hash + Serialize + DeserializeOwned,
        V: DeserializeOwned,
        I: IntoIterator<Item = K>,
    {
```

#### `Crawler::get_dynamic_field_page_matching_types`

```rust
pub async fn get_dynamic_field_page_matching_types<K, V>(
        &self,
        parent_id: sui::types::Address,
        cursor: Option<Vec<u8>>,
        limit: usize,
        value_type_suffix: &str,
    ) -> anyhow::Result<DynamicFieldPage<K, V>>
    where
        K: DeserializeOwned,
        V: DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_field_object_values`

```rust
pub async fn get_dynamic_field_object_values<K, V>(
        &self,
        parent_id: sui::types::Address,
    ) -> anyhow::Result<Vec<V>>
    where
        K: DeserializeOwned,
        V: DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_field_values`

```rust
pub async fn get_dynamic_field_values<V>(
        &self,
        parent_id: sui::types::Address,
    ) -> anyhow::Result<Vec<(Option<String>, V)>>
    where
        V: DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_object_fields`

```rust
pub async fn get_dynamic_object_fields<K, V>(
        &self,
        parent_id: sui::types::Address,
    ) -> anyhow::Result<HashMap<K, Response<V>>>
    where
        K: Eq + Hash + DeserializeOwned,
        V: DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_object_field_by_key`

```rust
pub async fn get_dynamic_object_field_by_key<K, V>(
        &self,
        parent_id: sui::types::Address,
        key: K,
        key_type: &sui::types::TypeTag,
    ) -> anyhow::Result<Option<Response<V>>>
    where
        K: Eq + Serialize + DeserializeOwned,
        V: DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_object_field_refs_matching_key`

```rust
pub async fn get_dynamic_object_field_refs_matching_key<K>(
        &self,
        parent_id: sui::types::Address,
    ) -> anyhow::Result<Vec<DynamicObjectFieldReference<K>>>
    where
        K: Eq + Hash + DeserializeOwned,
    {
```

#### `Crawler::get_dynamic_object_field_child_ids`

```rust
pub async fn get_dynamic_object_field_child_ids(
        &self,
        parent_id: sui::types::Address,
    ) -> anyhow::Result<Vec<sui::types::Address>> {
```

#### `Crawler::get_table_vec`

```rust
pub async fn get_table_vec<T>(&self, parent: &TableVec<T>) -> anyhow::Result<Vec<T>>
    where
        T: DeserializeOwned,
    {
```

#### `Response`

```rust
pub struct Response<T> {
    pub object_id: sui::types::Address,
    pub owner: sui::types::Owner,
    pub version: sui::types::Version,
    pub data: T,
    pub digest: sui::types::Digest,
    /// If the object is `0x2::coin::Coin`, contains the balance.
    pub balance: Option<u64>,
}
```

#### `TransactionStateOutput`

```rust
pub struct TransactionStateOutput<T> {
    pub object_id: sui::types::Address,
    pub field_ref: sui::types::ObjectReference,
    pub data: T,
}
```

#### `Response::is_shared`

```rust
pub fn is_shared(&self) -> bool {
```

#### `Response::is_immutable`

```rust
pub fn is_immutable(&self) -> bool {
```

#### `Response::get_initial_version`

```rust
pub fn get_initial_version(&self) -> sui::types::Version {
```

#### `Response::object_ref`

```rust
pub fn object_ref(&self) -> sui::types::ObjectReference {
```

#### `Set`

```rust
pub struct Set<T>
where
    T: Eq + Hash,
{
    contents: HashSet<T>,
}
```

#### `Set::new`

```rust
pub fn new() -> Self {
```

#### `Set::into_inner`

```rust
pub fn into_inner(self) -> HashSet<T> {
```

#### `Set::inner`

```rust
pub fn inner(&self) -> &HashSet<T> {
```

#### `Set::inner_mut`

```rust
pub fn inner_mut(&mut self) -> &mut HashSet<T> {
```

#### `Set::is_empty`

```rust
pub fn is_empty(&self) -> bool {
```

#### `Map`

```rust
pub struct Map<K, V>
where
    K: Eq + Hash,
{
    contents: HashMap<K, V>,
}
```

#### `Map::new`

```rust
pub fn new() -> Self {
```

#### `Map::from_map`

```rust
pub fn from_map(contents: HashMap<K, V>) -> Self {
```

#### `Map::into_inner`

```rust
pub fn into_inner(self) -> HashMap<K, V> {
```

#### `Map::into_map`

```rust
pub fn into_map(self) -> HashMap<K, V> {
```

#### `Map::inner`

```rust
pub fn inner(&self) -> &HashMap<K, V> {
```

#### `Map::inner_mut`

```rust
pub fn inner_mut(&mut self) -> &mut HashMap<K, V> {
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.talus.network/reference/sdk/crawler.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `build a script that syncs our docs to a CMS` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.