Interaction

cyhole.helius.Helius

Helius(
    api_key: str,
    network: HeliusNetwork = HeliusNetwork.MAINNET,
    headers: Any | None = None,
)

Bases: Interaction

              flowchart TD
              cyhole.helius.Helius[Helius]
              cyhole.core.interaction.Interaction[Interaction]

                              cyhole.core.interaction.Interaction --> cyhole.helius.Helius
                


              click cyhole.helius.Helius href "" "cyhole.helius.Helius"
              click cyhole.core.interaction.Interaction href "" "cyhole.core.interaction.Interaction"
            

Class used to connect Helius API.

Helius provides enhanced Solana RPC infrastructure including the Digital Asset Standard (DAS) API — a unified interface for querying on-chain NFTs, compressed NFTs (cNFTs), fungible tokens, and inscriptions.

All DAS endpoints require an API key obtained from the Helius Dashboard. The key is appended as a URL query parameter on every request.

Example — sync

from cyhole.helius import Helius

helius = Helius(api_key="your-api-key")
response = helius.client.post_get_asset("4ZkS7zADmEFnkLPMHqJfPvHDN8oqfPjqDFGEQHiqPbEz")
print(response.result.id)

Example — async

import asyncio
from cyhole.helius import Helius

helius = Helius(api_key="your-api-key")

async def main():
    async with helius.async_client as client:
        response = await client.post_get_asset("4ZkS7zADmEFnkLPMHqJfPvHDN8oqfPjqDFGEQHiqPbEz")
    print(response.result.ownership.owner)

asyncio.run(main())

Source code in src/cyhole/helius/interaction.py

def __init__(
    self,
    api_key: str,
    network: HeliusNetwork = HeliusNetwork.MAINNET,
    headers: Any | None = None,
) -> None:
    super().__init__(headers)
    self.url_api = f"https://{network.value}.helius-rpc.com/?api-key={api_key}"
    self.client = HeliusClient(self)
    self.async_client = HeliusAsyncClient(self)

_post_get_asset

_post_get_asset(
    sync: Literal[True],
    asset_id: str,
    options: PostGetAssetOptions | None = None,
) -> PostGetAssetResponse

_post_get_asset(
    sync: Literal[False],
    asset_id: str,
    options: PostGetAssetOptions | None = None,
) -> Coroutine[None, None, PostGetAssetResponse]

_post_get_asset(
    sync: bool,
    asset_id: str,
    options: PostGetAssetOptions | None = None,
) -> (
    PostGetAssetResponse
    | Coroutine[None, None, PostGetAssetResponse]
)

This function refers to the getAsset DAS API endpoint.

Retrieves the full on-chain record for a single digital asset (NFT, cNFT, or fungible token) identified by its mint address. The response includes ownership, royalty, compression state, content metadata, and optional fungible or inscription data depending on the options provided.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
asset_id	str	the mint address of the asset to retrieve.	required
options	PostGetAssetOptions | None	optional display flags — use PostGetAssetOptions to enable showFungible, showInscription, showCollectionMetadata, or showUnverifiedCollections.	None

Returns:

Name	Type	Description
PostGetAssetResponse	PostGetAssetResponse | Coroutine[None, None, PostGetAssetResponse]	full asset record wrapped in a JSON-RPC 2.0 envelope. Access the asset data via response.result.

Source code in src/cyhole/helius/interaction.py

def _post_get_asset(self, sync: bool, asset_id: str, options: PostGetAssetOptions | None = None) -> PostGetAssetResponse | Coroutine[None, None, PostGetAssetResponse]:
    """
    This function refers to the **getAsset** DAS API endpoint.

    Retrieves the full on-chain record for a single digital asset (NFT, cNFT,
    or fungible token) identified by its mint address. The response includes
    ownership, royalty, compression state, content metadata, and optional
    fungible or inscription data depending on the `options` provided.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        asset_id: the mint address of the asset to retrieve.
        options: optional display flags — use [`PostGetAssetOptions`][cyhole.helius.schema.PostGetAssetOptions]
            to enable `showFungible`, `showInscription`, `showCollectionMetadata`, or
            `showUnverifiedCollections`.

    Returns:
        PostGetAssetResponse: full asset record wrapped in a JSON-RPC 2.0 envelope.
            Access the asset data via `response.result`.
    """
    params: dict = {"id": asset_id}
    if options:
        params["options"] = options.model_dump(by_alias = True, exclude_none = True)
    body = {"jsonrpc": "2.0", "id": "cyhole", "method": "getAsset", "params": params}
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetAssetResponse, json = body)

_post_get_asset_batch

_post_get_asset_batch(
    sync: Literal[True], ids: list[str]
) -> PostGetAssetBatchResponse

_post_get_asset_batch(
    sync: Literal[False], ids: list[str]
) -> Coroutine[None, None, PostGetAssetBatchResponse]

_post_get_asset_batch(
    sync: bool, ids: list[str]
) -> (
    PostGetAssetBatchResponse
    | Coroutine[None, None, PostGetAssetBatchResponse]
)

This function refers to the getAssetBatch DAS API endpoint.

Retrieves up to 1,000 digital assets in a single request. Useful for bulk enrichment of mint address lists (e.g. wallet portfolio snapshots). Items in the result list follow the same schema as a single getAsset call.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
ids	list[str]	list of mint addresses to retrieve (max 1,000 items).	required

Returns:

Name	Type	Description
PostGetAssetBatchResponse	PostGetAssetBatchResponse | Coroutine[None, None, PostGetAssetBatchResponse]	list of asset records wrapped in a JSON-RPC 2.0 envelope. Access the list via response.result.

Source code in src/cyhole/helius/interaction.py

def _post_get_asset_batch(self, sync: bool, ids: list[str]) -> PostGetAssetBatchResponse | Coroutine[None, None, PostGetAssetBatchResponse]:
    """
    This function refers to the **getAssetBatch** DAS API endpoint.

    Retrieves up to 1,000 digital assets in a single request. Useful for
    bulk enrichment of mint address lists (e.g. wallet portfolio snapshots).
    Items in the result list follow the same schema as a single `getAsset` call.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        ids: list of mint addresses to retrieve (max 1,000 items).

    Returns:
        PostGetAssetBatchResponse: list of asset records wrapped in a JSON-RPC 2.0 envelope.
            Access the list via `response.result`.
    """
    body = {"jsonrpc": "2.0", "id": "cyhole", "method": "getAssetBatch", "params": {"ids": ids}}
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetAssetBatchResponse, json = body)

_post_get_asset_proof

_post_get_asset_proof(
    sync: Literal[True], asset_id: str
) -> PostGetAssetProofResponse

_post_get_asset_proof(
    sync: Literal[False], asset_id: str
) -> Coroutine[None, None, PostGetAssetProofResponse]

_post_get_asset_proof(
    sync: bool, asset_id: str
) -> (
    PostGetAssetProofResponse
    | Coroutine[None, None, PostGetAssetProofResponse]
)

This function refers to the getAssetProof DAS API endpoint.

Returns the Merkle proof required to execute on-chain operations (transfer, burn, delegate) on a compressed NFT (cNFT). The proof must be passed to the Bubblegum program alongside the instruction. Only applicable to cNFTs; regular NFTs do not require a proof.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
asset_id	str	the mint address of the compressed NFT.	required

Returns:

Name	Type	Description
PostGetAssetProofResponse	PostGetAssetProofResponse | Coroutine[None, None, PostGetAssetProofResponse]	Merkle proof data wrapped in a JSON-RPC 2.0 envelope. Access the proof via response.result.

Source code in src/cyhole/helius/interaction.py

def _post_get_asset_proof(self, sync: bool, asset_id: str) -> PostGetAssetProofResponse | Coroutine[None, None, PostGetAssetProofResponse]:
    """
    This function refers to the **getAssetProof** DAS API endpoint.

    Returns the Merkle proof required to execute on-chain operations (transfer,
    burn, delegate) on a **compressed NFT** (cNFT). The proof must be passed to
    the Bubblegum program alongside the instruction. Only applicable to cNFTs;
    regular NFTs do not require a proof.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        asset_id: the mint address of the compressed NFT.

    Returns:
        PostGetAssetProofResponse: Merkle proof data wrapped in a JSON-RPC 2.0 envelope.
            Access the proof via `response.result`.
    """
    body = {"jsonrpc": "2.0", "id": "cyhole", "method": "getAssetProof", "params": {"id": asset_id}}
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetAssetProofResponse, json = body)

_post_get_asset_proof_batch

_post_get_asset_proof_batch(
    sync: Literal[True], ids: list[str]
) -> PostGetAssetProofBatchResponse

_post_get_asset_proof_batch(
    sync: Literal[False], ids: list[str]
) -> Coroutine[None, None, PostGetAssetProofBatchResponse]

_post_get_asset_proof_batch(
    sync: bool, ids: list[str]
) -> (
    PostGetAssetProofBatchResponse
    | Coroutine[None, None, PostGetAssetProofBatchResponse]
)

This function refers to the getAssetProofBatch DAS API endpoint.

Fetches Merkle proofs for multiple compressed NFTs in a single round-trip. The response is a mapping of asset mint address → proof object, making it straightforward to look up the proof for each cNFT in a batch transfer.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
ids	list[str]	list of compressed NFT mint addresses.	required

Returns:

Name	Type	Description
PostGetAssetProofBatchResponse	PostGetAssetProofBatchResponse | Coroutine[None, None, PostGetAssetProofBatchResponse]	dict of proofs keyed by asset ID, wrapped in a JSON-RPC 2.0 envelope. Access via response.result["<mint>"].

Source code in src/cyhole/helius/interaction.py

def _post_get_asset_proof_batch(self, sync: bool, ids: list[str]) -> PostGetAssetProofBatchResponse | Coroutine[None, None, PostGetAssetProofBatchResponse]:
    """
    This function refers to the **getAssetProofBatch** DAS API endpoint.

    Fetches Merkle proofs for multiple compressed NFTs in a single round-trip.
    The response is a mapping of asset mint address → proof object, making it
    straightforward to look up the proof for each cNFT in a batch transfer.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        ids: list of compressed NFT mint addresses.

    Returns:
        PostGetAssetProofBatchResponse: dict of proofs keyed by asset ID,
            wrapped in a JSON-RPC 2.0 envelope. Access via `response.result["<mint>"]`.
    """
    body = {"jsonrpc": "2.0", "id": "cyhole", "method": "getAssetProofBatch", "params": {"ids": ids}}
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetAssetProofBatchResponse, json = body)

_post_get_assets_by_owner

_post_get_assets_by_owner(
    sync: Literal[True], body: PostGetAssetsByOwnerBody
) -> PostGetAssetsByOwnerResponse

_post_get_assets_by_owner(
    sync: Literal[False], body: PostGetAssetsByOwnerBody
) -> Coroutine[None, None, PostGetAssetsByOwnerResponse]

_post_get_assets_by_owner(
    sync: bool, body: PostGetAssetsByOwnerBody
) -> (
    PostGetAssetsByOwnerResponse
    | Coroutine[None, None, PostGetAssetsByOwnerResponse]
)

This function refers to the getAssetsByOwner DAS API endpoint.

Returns all digital assets (NFTs, cNFTs, fungible tokens) held by a given wallet. Supports pagination, sorting, and display options such as native SOL balance and fungible token data. Useful for building wallet portfolio views.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostGetAssetsByOwnerBody	request body — see PostGetAssetsByOwnerBody. At minimum, set owner_address. Use display_options to include fungible balances or native SOL balance.	required

Returns:

Name	Type	Description
PostGetAssetsByOwnerResponse	PostGetAssetsByOwnerResponse | Coroutine[None, None, PostGetAssetsByOwnerResponse]	paginated asset list wrapped in a JSON-RPC 2.0 envelope. Access via response.result.items. Total count is in response.result.total.

Source code in src/cyhole/helius/interaction.py

def _post_get_assets_by_owner(self, sync: bool, body: PostGetAssetsByOwnerBody) -> PostGetAssetsByOwnerResponse | Coroutine[None, None, PostGetAssetsByOwnerResponse]:
    """
    This function refers to the **getAssetsByOwner** DAS API endpoint.

    Returns all digital assets (NFTs, cNFTs, fungible tokens) held by a given wallet.
    Supports pagination, sorting, and display options such as native SOL balance and
    fungible token data. Useful for building wallet portfolio views.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        body: request body — see [`PostGetAssetsByOwnerBody`][cyhole.helius.schema.PostGetAssetsByOwnerBody].
            At minimum, set `owner_address`. Use `display_options` to include
            fungible balances or native SOL balance.

    Returns:
        PostGetAssetsByOwnerResponse: paginated asset list wrapped in a JSON-RPC 2.0 envelope.
            Access via `response.result.items`. Total count is in `response.result.total`.
    """
    rpc_body = {
        "jsonrpc": "2.0",
        "id": "cyhole",
        "method": "getAssetsByOwner",
        "params": body.model_dump(by_alias = True, exclude_none = True),
    }
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetAssetsByOwnerResponse, json = rpc_body)

_post_get_assets_by_group

_post_get_assets_by_group(
    sync: Literal[True], body: PostGetAssetsByGroupBody
) -> PostGetAssetsByGroupResponse

_post_get_assets_by_group(
    sync: Literal[False], body: PostGetAssetsByGroupBody
) -> Coroutine[None, None, PostGetAssetsByGroupResponse]

_post_get_assets_by_group(
    sync: bool, body: PostGetAssetsByGroupBody
) -> (
    PostGetAssetsByGroupResponse
    | Coroutine[None, None, PostGetAssetsByGroupResponse]
)

This function refers to the getAssetsByGroup DAS API endpoint.

Returns all assets that belong to a specific collection (or other grouping key). The most common usage is to supply group_key = "collection" and group_value = "<collection_mint_address>" to enumerate every NFT in a collection.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostGetAssetsByGroupBody	request body — see PostGetAssetsByGroupBody. Must supply group_key and group_value.	required

Returns:

Name	Type	Description
PostGetAssetsByGroupResponse	PostGetAssetsByGroupResponse | Coroutine[None, None, PostGetAssetsByGroupResponse]	paginated asset list wrapped in a JSON-RPC 2.0 envelope. Access via response.result.items.

Source code in src/cyhole/helius/interaction.py

def _post_get_assets_by_group(self, sync: bool, body: PostGetAssetsByGroupBody) -> PostGetAssetsByGroupResponse | Coroutine[None, None, PostGetAssetsByGroupResponse]:
    """
    This function refers to the **getAssetsByGroup** DAS API endpoint.

    Returns all assets that belong to a specific collection (or other grouping key).
    The most common usage is to supply `group_key = "collection"` and
    `group_value = "<collection_mint_address>"` to enumerate every NFT in a collection.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        body: request body — see [`PostGetAssetsByGroupBody`][cyhole.helius.schema.PostGetAssetsByGroupBody].
            Must supply `group_key` and `group_value`.

    Returns:
        PostGetAssetsByGroupResponse: paginated asset list wrapped in a JSON-RPC 2.0 envelope.
            Access via `response.result.items`.
    """
    rpc_body = {
        "jsonrpc": "2.0",
        "id": "cyhole",
        "method": "getAssetsByGroup",
        "params": body.model_dump(by_alias = True, exclude_none = True),
    }
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetAssetsByGroupResponse, json = rpc_body)

_post_get_assets_by_creator

_post_get_assets_by_creator(
    sync: Literal[True], body: PostGetAssetsByCreatorBody
) -> PostGetAssetsByCreatorResponse

_post_get_assets_by_creator(
    sync: Literal[False], body: PostGetAssetsByCreatorBody
) -> Coroutine[None, None, PostGetAssetsByCreatorResponse]

_post_get_assets_by_creator(
    sync: bool, body: PostGetAssetsByCreatorBody
) -> (
    PostGetAssetsByCreatorResponse
    | Coroutine[None, None, PostGetAssetsByCreatorResponse]
)

This function refers to the getAssetsByCreator DAS API endpoint.

Returns all digital assets created by a given wallet address. Optionally filter to only verified creator entries using only_verified = True, which excludes assets where the creator has not signed the metadata.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostGetAssetsByCreatorBody	request body — see PostGetAssetsByCreatorBody. Must supply creator_address.	required

Returns:

Name	Type	Description
PostGetAssetsByCreatorResponse	PostGetAssetsByCreatorResponse | Coroutine[None, None, PostGetAssetsByCreatorResponse]	paginated asset list wrapped in a JSON-RPC 2.0 envelope. Access via response.result.items.

Source code in src/cyhole/helius/interaction.py

def _post_get_assets_by_creator(self, sync: bool, body: PostGetAssetsByCreatorBody) -> PostGetAssetsByCreatorResponse | Coroutine[None, None, PostGetAssetsByCreatorResponse]:
    """
    This function refers to the **getAssetsByCreator** DAS API endpoint.

    Returns all digital assets created by a given wallet address. Optionally
    filter to only verified creator entries using `only_verified = True`, which
    excludes assets where the creator has not signed the metadata.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        body: request body — see [`PostGetAssetsByCreatorBody`][cyhole.helius.schema.PostGetAssetsByCreatorBody].
            Must supply `creator_address`.

    Returns:
        PostGetAssetsByCreatorResponse: paginated asset list wrapped in a JSON-RPC 2.0 envelope.
            Access via `response.result.items`.
    """
    rpc_body = {
        "jsonrpc": "2.0",
        "id": "cyhole",
        "method": "getAssetsByCreator",
        "params": body.model_dump(by_alias = True, exclude_none = True),
    }
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetAssetsByCreatorResponse, json = rpc_body)

_post_get_assets_by_authority

_post_get_assets_by_authority(
    sync: Literal[True], body: PostGetAssetsByAuthorityBody
) -> PostGetAssetsByAuthorityResponse

_post_get_assets_by_authority(
    sync: Literal[False], body: PostGetAssetsByAuthorityBody
) -> Coroutine[
    None, None, PostGetAssetsByAuthorityResponse
]

_post_get_assets_by_authority(
    sync: bool, body: PostGetAssetsByAuthorityBody
) -> (
    PostGetAssetsByAuthorityResponse
    | Coroutine[
        None, None, PostGetAssetsByAuthorityResponse
    ]
)

This function refers to the getAssetsByAuthority DAS API endpoint.

Returns all assets whose update authority matches the given address. Update authority controls the ability to modify on-chain metadata, so this endpoint is useful for discovering all assets managed by a specific program or wallet (e.g. all NFTs minted under a particular candy machine).

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostGetAssetsByAuthorityBody	request body — see PostGetAssetsByAuthorityBody. Must supply authority_address.	required

Returns:

Name	Type	Description
PostGetAssetsByAuthorityResponse	PostGetAssetsByAuthorityResponse | Coroutine[None, None, PostGetAssetsByAuthorityResponse]	paginated asset list wrapped in a JSON-RPC 2.0 envelope. Access via response.result.items.

Source code in src/cyhole/helius/interaction.py

def _post_get_assets_by_authority(self, sync: bool, body: PostGetAssetsByAuthorityBody) -> PostGetAssetsByAuthorityResponse | Coroutine[None, None, PostGetAssetsByAuthorityResponse]:
    """
    This function refers to the **getAssetsByAuthority** DAS API endpoint.

    Returns all assets whose **update authority** matches the given address.
    Update authority controls the ability to modify on-chain metadata, so this
    endpoint is useful for discovering all assets managed by a specific program
    or wallet (e.g. all NFTs minted under a particular candy machine).

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        body: request body — see [`PostGetAssetsByAuthorityBody`][cyhole.helius.schema.PostGetAssetsByAuthorityBody].
            Must supply `authority_address`.

    Returns:
        PostGetAssetsByAuthorityResponse: paginated asset list wrapped in a JSON-RPC 2.0 envelope.
            Access via `response.result.items`.
    """
    rpc_body = {
        "jsonrpc": "2.0",
        "id": "cyhole",
        "method": "getAssetsByAuthority",
        "params": body.model_dump(by_alias = True, exclude_none = True),
    }
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetAssetsByAuthorityResponse, json = rpc_body)

_post_search_assets

_post_search_assets(
    sync: Literal[True], body: PostSearchAssetsBody
) -> PostSearchAssetsResponse

_post_search_assets(
    sync: Literal[False], body: PostSearchAssetsBody
) -> Coroutine[None, None, PostSearchAssetsResponse]

_post_search_assets(
    sync: bool, body: PostSearchAssetsBody
) -> (
    PostSearchAssetsResponse
    | Coroutine[None, None, PostSearchAssetsResponse]
)

This function refers to the searchAssets DAS API endpoint.

Performs a flexible, multi-criteria search across all digital assets indexed by Helius. Filters can be combined freely: narrow by owner, creator, collection, token type, compression state, or burn status. All fields in the request body are optional — omitting a field means no constraint is applied for that dimension.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostSearchAssetsBody	search body — see PostSearchAssetsBody. All fields are optional; combine as needed.	required

Returns:

Name	Type	Description
PostSearchAssetsResponse	PostSearchAssetsResponse | Coroutine[None, None, PostSearchAssetsResponse]	paginated asset list wrapped in a JSON-RPC 2.0 envelope. Access via response.result.items.

Source code in src/cyhole/helius/interaction.py

def _post_search_assets(self, sync: bool, body: PostSearchAssetsBody) -> PostSearchAssetsResponse | Coroutine[None, None, PostSearchAssetsResponse]:
    """
    This function refers to the **searchAssets** DAS API endpoint.

    Performs a flexible, multi-criteria search across all digital assets indexed
    by Helius. Filters can be combined freely: narrow by owner, creator, collection,
    token type, compression state, or burn status. All fields in the request body
    are optional — omitting a field means no constraint is applied for that dimension.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        body: search body — see [`PostSearchAssetsBody`][cyhole.helius.schema.PostSearchAssetsBody].
            All fields are optional; combine as needed.

    Returns:
        PostSearchAssetsResponse: paginated asset list wrapped in a JSON-RPC 2.0 envelope.
            Access via `response.result.items`.
    """
    rpc_body = {
        "jsonrpc": "2.0",
        "id": "cyhole",
        "method": "searchAssets",
        "params": body.model_dump(by_alias = True, exclude_none = True),
    }
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostSearchAssetsResponse, json = rpc_body)

_post_get_signatures_for_asset

_post_get_signatures_for_asset(
    sync: Literal[True],
    asset_id: str,
    page: int | None = None,
    limit: int | None = None,
) -> PostGetSignaturesForAssetResponse

_post_get_signatures_for_asset(
    sync: Literal[False],
    asset_id: str,
    page: int | None = None,
    limit: int | None = None,
) -> Coroutine[
    None, None, PostGetSignaturesForAssetResponse
]

_post_get_signatures_for_asset(
    sync: bool,
    asset_id: str,
    page: int | None = None,
    limit: int | None = None,
) -> (
    PostGetSignaturesForAssetResponse
    | Coroutine[
        None, None, PostGetSignaturesForAssetResponse
    ]
)

This function refers to the getSignaturesForAsset DAS API endpoint.

Returns the transaction history for a digital asset, including both regular NFTs and compressed NFTs (cNFTs). Each item in the result is a two-element list of [signature, transaction_type] (e.g. ["5abc...", "Transfer"]). Useful for auditing provenance or tracking the ownership history of an asset.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
asset_id	str	the mint address of the asset.	required
page	int | None	page number for pagination (default 1).	None
limit	int | None	number of signatures per page, max 1,000 (default 1,000).	None

Returns:

Name	Type	Description
PostGetSignaturesForAssetResponse	PostGetSignaturesForAssetResponse | Coroutine[None, None, PostGetSignaturesForAssetResponse]	paginated signature list wrapped in a JSON-RPC 2.0 envelope. Access via response.result.items.

Source code in src/cyhole/helius/interaction.py

def _post_get_signatures_for_asset(self, sync: bool, asset_id: str, page: int | None = None, limit: int | None = None) -> PostGetSignaturesForAssetResponse | Coroutine[None, None, PostGetSignaturesForAssetResponse]:
    """
    This function refers to the **getSignaturesForAsset** DAS API endpoint.

    Returns the transaction history for a digital asset, including both regular
    NFTs and compressed NFTs (cNFTs). Each item in the result is a two-element
    list of `[signature, transaction_type]` (e.g. `["5abc...", "Transfer"]`).
    Useful for auditing provenance or tracking the ownership history of an asset.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        asset_id: the mint address of the asset.
        page: page number for pagination (default 1).
        limit: number of signatures per page, max 1,000 (default 1,000).

    Returns:
        PostGetSignaturesForAssetResponse: paginated signature list wrapped in a
            JSON-RPC 2.0 envelope. Access via `response.result.items`.
    """
    params: dict = {"id": asset_id}
    if page is not None:
        params["page"] = page
    if limit is not None:
        params["limit"] = limit
    body = {"jsonrpc": "2.0", "id": "cyhole", "method": "getSignaturesForAsset", "params": params}
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetSignaturesForAssetResponse, json = body)

_post_get_nft_editions

_post_get_nft_editions(
    sync: Literal[True],
    mint: str,
    page: int | None = None,
    limit: int | None = None,
) -> PostGetNftEditionsResponse

_post_get_nft_editions(
    sync: Literal[False],
    mint: str,
    page: int | None = None,
    limit: int | None = None,
) -> Coroutine[None, None, PostGetNftEditionsResponse]

_post_get_nft_editions(
    sync: bool,
    mint: str,
    page: int | None = None,
    limit: int | None = None,
) -> (
    PostGetNftEditionsResponse
    | Coroutine[None, None, PostGetNftEditionsResponse]
)

This function refers to the getNftEditions DAS API endpoint.

Returns all print editions derived from a given master edition NFT. Each item contains the edition mint address, edition address (PDA), and sequential edition number. The response also includes the master edition address, current supply, and optional max supply.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	the master edition mint address.	required
page	int | None	page number for pagination (default 1).	None
limit	int | None	number of editions per page, max 1,000 (default 1,000).	None

Returns:

Name	Type	Description
PostGetNftEditionsResponse	PostGetNftEditionsResponse | Coroutine[None, None, PostGetNftEditionsResponse]	paginated edition list wrapped in a JSON-RPC 2.0 envelope. Access via response.result.editions. Supply info is in response.result.supply.

Source code in src/cyhole/helius/interaction.py

def _post_get_nft_editions(self, sync: bool, mint: str, page: int | None = None, limit: int | None = None) -> PostGetNftEditionsResponse | Coroutine[None, None, PostGetNftEditionsResponse]:
    """
    This function refers to the **getNftEditions** DAS API endpoint.

    Returns all **print editions** derived from a given **master edition** NFT.
    Each item contains the edition mint address, edition address (PDA), and
    sequential edition number. The response also includes the master edition
    address, current supply, and optional max supply.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        mint: the master edition mint address.
        page: page number for pagination (default 1).
        limit: number of editions per page, max 1,000 (default 1,000).

    Returns:
        PostGetNftEditionsResponse: paginated edition list wrapped in a JSON-RPC 2.0 envelope.
            Access via `response.result.editions`. Supply info is in `response.result.supply`.
    """
    params: dict = {"mint": mint}
    if page is not None:
        params["page"] = page
    if limit is not None:
        params["limit"] = limit
    body = {"jsonrpc": "2.0", "id": "cyhole", "method": "getNftEditions", "params": params}
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetNftEditionsResponse, json = body)

_post_get_token_accounts

_post_get_token_accounts(
    sync: Literal[True], body: PostGetTokenAccountsBody
) -> PostGetTokenAccountsResponse

_post_get_token_accounts(
    sync: Literal[False], body: PostGetTokenAccountsBody
) -> Coroutine[None, None, PostGetTokenAccountsResponse]

_post_get_token_accounts(
    sync: bool, body: PostGetTokenAccountsBody
) -> (
    PostGetTokenAccountsResponse
    | Coroutine[None, None, PostGetTokenAccountsResponse]
)

This function refers to the getTokenAccounts DAS API endpoint.

Returns SPL token accounts filtered by mint address, owner wallet, or both. Each account record includes the token balance (amount), whether the account is frozen, and any delegated amount. Provide at least one of mint or owner to narrow the result set.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostGetTokenAccountsBody	query body — see PostGetTokenAccountsBody. Provide mint, owner, or both.	required

Returns:

Name	Type	Description
PostGetTokenAccountsResponse	PostGetTokenAccountsResponse | Coroutine[None, None, PostGetTokenAccountsResponse]	paginated token account list wrapped in a JSON-RPC 2.0 envelope. Access via response.result.token_accounts.

Source code in src/cyhole/helius/interaction.py

def _post_get_token_accounts(self, sync: bool, body: PostGetTokenAccountsBody) -> PostGetTokenAccountsResponse | Coroutine[None, None, PostGetTokenAccountsResponse]:
    """
    This function refers to the **getTokenAccounts** DAS API endpoint.

    Returns SPL token accounts filtered by mint address, owner wallet, or both.
    Each account record includes the token balance (`amount`), whether the account
    is frozen, and any delegated amount. Provide at least one of `mint` or `owner`
    to narrow the result set.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        body: query body — see [`PostGetTokenAccountsBody`][cyhole.helius.schema.PostGetTokenAccountsBody].
            Provide `mint`, `owner`, or both.

    Returns:
        PostGetTokenAccountsResponse: paginated token account list wrapped in a
            JSON-RPC 2.0 envelope. Access via `response.result.token_accounts`.
    """
    rpc_body = {
        "jsonrpc": "2.0",
        "id": "cyhole",
        "method": "getTokenAccounts",
        "params": body.model_dump(exclude_none = True),
    }
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetTokenAccountsResponse, json = rpc_body)

_post_get_transfers_by_address

_post_get_transfers_by_address(
    sync: Literal[True],
    address: str,
    body: PostGetTransfersByAddressBody | None = None,
) -> PostGetTransfersByAddressResponse

_post_get_transfers_by_address(
    sync: Literal[False],
    address: str,
    body: PostGetTransfersByAddressBody | None = None,
) -> Coroutine[
    None, None, PostGetTransfersByAddressResponse
]

_post_get_transfers_by_address(
    sync: bool,
    address: str,
    body: PostGetTransfersByAddressBody | None = None,
) -> (
    PostGetTransfersByAddressResponse
    | Coroutine[
        None, None, PostGetTransfersByAddressResponse
    ]
)

This function refers to the getTransfersByAddress Helius RPC endpoint.

Returns parsed, human-readable token and native SOL transfer records for a wallet owner address, suitable for ledgers, payment tracking, and balance reconciliation. Results can be narrowed by counterparty, direction, mint, amount/time/slot ranges and paginated via pagination_token.

The endpoint is a Helius-exclusive feature (not part of standard Solana RPC), requires a Developer plan or higher, costs 10 credits per request, and returns at most the most recent 1 year of transfer history. Failed transactions and hidden SOL balance-change movements are not included.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
address	str	base58-encoded wallet owner address to query. Must be the owner wallet, not an associated token account (ATA).	required
body	PostGetTransfersByAddressBody | None	optional configuration object — see PostGetTransfersByAddressBody. All fields are optional. Use it to filter by counterparty, direction (HeliusTransferDirection), mint, SOL/WSOL mode (HeliusSolMode), numeric ranges, commitment (HeliusCommitment), ordering (HeliusSortOrder), and pagination (limit, pagination_token).	None

Returns:

Name	Type	Description
PostGetTransfersByAddressResponse	PostGetTransfersByAddressResponse | Coroutine[None, None, PostGetTransfersByAddressResponse]	paginated transfer rows wrapped in a JSON-RPC 2.0 envelope. Access the rows via response.result.data and the next-page cursor via response.result.pagination_token (None when there are no more pages).

Source code in src/cyhole/helius/interaction.py

def _post_get_transfers_by_address(self, sync: bool, address: str, body: PostGetTransfersByAddressBody | None = None) -> PostGetTransfersByAddressResponse | Coroutine[None, None, PostGetTransfersByAddressResponse]:
    """
    This function refers to the **getTransfersByAddress** Helius RPC endpoint.

    Returns parsed, human-readable token and native SOL transfer records for a
    wallet owner address, suitable for ledgers, payment tracking, and balance
    reconciliation. Results can be narrowed by counterparty, direction, mint,
    amount/time/slot ranges and paginated via `pagination_token`.

    The endpoint is a Helius-exclusive feature (not part of standard Solana RPC),
    requires a Developer plan or higher, costs 10 credits per request, and
    returns at most the most recent 1 year of transfer history. Failed
    transactions and hidden SOL balance-change movements are not included.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        address: base58-encoded wallet **owner** address to query. Must be the
            owner wallet, not an associated token account (ATA).
        body: optional configuration object — see
            [`PostGetTransfersByAddressBody`][cyhole.helius.schema.PostGetTransfersByAddressBody].
            All fields are optional. Use it to filter by counterparty, direction
            ([`HeliusTransferDirection`][cyhole.helius.param.HeliusTransferDirection]),
            mint, SOL/WSOL mode ([`HeliusSolMode`][cyhole.helius.param.HeliusSolMode]),
            numeric ranges, commitment ([`HeliusCommitment`][cyhole.helius.param.HeliusCommitment]),
            ordering ([`HeliusSortOrder`][cyhole.helius.param.HeliusSortOrder]),
            and pagination (`limit`, `pagination_token`).

    Returns:
        PostGetTransfersByAddressResponse: paginated transfer rows wrapped in a
            JSON-RPC 2.0 envelope. Access the rows via `response.result.data`
            and the next-page cursor via `response.result.pagination_token`
            (`None` when there are no more pages).
    """
    params: list = [address]
    if body is not None:
        params.append(body.model_dump(by_alias = True, exclude_none = True))
    rpc_body = {"jsonrpc": "2.0", "id": "cyhole", "method": "getTransfersByAddress", "params": params}
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetTransfersByAddressResponse, json = rpc_body)

_post_get_transactions_for_address

_post_get_transactions_for_address(
    sync: Literal[True],
    address: str,
    body: PostGetTransactionsForAddressBody | None = None,
) -> PostGetTransactionsForAddressResponse

_post_get_transactions_for_address(
    sync: Literal[False],
    address: str,
    body: PostGetTransactionsForAddressBody | None = None,
) -> Coroutine[
    None, None, PostGetTransactionsForAddressResponse
]

_post_get_transactions_for_address(
    sync: bool,
    address: str,
    body: PostGetTransactionsForAddressBody | None = None,
) -> (
    PostGetTransactionsForAddressResponse
    | Coroutine[
        None, None, PostGetTransactionsForAddressResponse
    ]
)

This function refers to the getTransactionsForAddress Helius RPC endpoint.

Returns the transaction history for any Solana account with advanced filtering (time, slot, signature, success/failure status, token-account inclusion), bidirectional sorting (asc / desc), and cursor-based pagination. Unlike getSignaturesForAddress, this endpoint can optionally return the full transaction payload in a single call and can include activity on token accounts owned by the queried wallet via filters.token_accounts.

The endpoint is a Helius-exclusive feature (not part of standard Solana RPC), requires a Developer plan or higher, costs 50 credits per request and returns up to 100 full transactions or 1,000 signatures per page. The token_accounts filter does not see transactions prior to December 2022; devnet retention is limited to 2 weeks while mainnet retention is unlimited.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
address	str	base58-encoded account address to query (wallet, program, mint, pool, or token account).	required
body	PostGetTransactionsForAddressBody | None	optional configuration object — see PostGetTransactionsForAddressBody. All fields are optional. Use it to choose detail level (HeliusTransactionDetails), sort order (HeliusSortOrder), commitment (HeliusCommitment), encoding (HeliusEncoding), and filters such as status (HeliusTransactionStatus) and token-account inclusion (HeliusTokenAccountFilter).	None

Returns:

Name	Type	Description
PostGetTransactionsForAddressResponse	PostGetTransactionsForAddressResponse | Coroutine[None, None, PostGetTransactionsForAddressResponse]	paginated transaction list wrapped in a JSON-RPC 2.0 envelope. Access the rows via response.result.data and the next-page cursor via response.result.pagination_token (None when there are no more pages). Each TransactionForAddressItem exposes signature-mode or full-mode fields depending on the transaction_details parameter.

Source code in src/cyhole/helius/interaction.py

def _post_get_transactions_for_address(self, sync: bool, address: str, body: PostGetTransactionsForAddressBody | None = None) -> PostGetTransactionsForAddressResponse | Coroutine[None, None, PostGetTransactionsForAddressResponse]:
    """
    This function refers to the **getTransactionsForAddress** Helius RPC endpoint.

    Returns the transaction history for any Solana account with advanced
    filtering (time, slot, signature, success/failure status, token-account
    inclusion), bidirectional sorting (`asc` / `desc`), and cursor-based
    pagination. Unlike `getSignaturesForAddress`, this endpoint can optionally
    return the **full transaction payload** in a single call and can include
    activity on token accounts owned by the queried wallet via
    `filters.token_accounts`.

    The endpoint is a Helius-exclusive feature (not part of standard Solana RPC),
    requires a Developer plan or higher, costs 50 credits per request and
    returns up to 100 full transactions or 1,000 signatures per page. The
    `token_accounts` filter does not see transactions prior to December 2022;
    devnet retention is limited to 2 weeks while mainnet retention is unlimited.

    Parameters:
        sync: if `True` run synchronously, else return a coroutine.
        address: base58-encoded account address to query (wallet, program, mint,
            pool, or token account).
        body: optional configuration object — see
            [`PostGetTransactionsForAddressBody`][cyhole.helius.schema.PostGetTransactionsForAddressBody].
            All fields are optional. Use it to choose detail level
            ([`HeliusTransactionDetails`][cyhole.helius.param.HeliusTransactionDetails]),
            sort order ([`HeliusSortOrder`][cyhole.helius.param.HeliusSortOrder]),
            commitment ([`HeliusCommitment`][cyhole.helius.param.HeliusCommitment]),
            encoding ([`HeliusEncoding`][cyhole.helius.param.HeliusEncoding]),
            and filters such as status
            ([`HeliusTransactionStatus`][cyhole.helius.param.HeliusTransactionStatus])
            and token-account inclusion
            ([`HeliusTokenAccountFilter`][cyhole.helius.param.HeliusTokenAccountFilter]).

    Returns:
        PostGetTransactionsForAddressResponse: paginated transaction list wrapped
            in a JSON-RPC 2.0 envelope. Access the rows via `response.result.data`
            and the next-page cursor via `response.result.pagination_token`
            (`None` when there are no more pages). Each
            [`TransactionForAddressItem`][cyhole.helius.schema.TransactionForAddressItem]
            exposes signature-mode or full-mode fields depending on the
            `transaction_details` parameter.
    """
    params: list = [address]
    if body is not None:
        params.append(body.model_dump(by_alias = True, exclude_none = True))
    rpc_body = {"jsonrpc": "2.0", "id": "cyhole", "method": "getTransactionsForAddress", "params": params}
    return self.api_return_model(sync, RequestType.POST.value, self.url_api, PostGetTransactionsForAddressResponse, json = rpc_body)