Interaction

cyhole.rugcheck.Rugcheck

Rugcheck(
    api_key: str | None = None, headers: Any | None = None
)

Bases: Interaction

              flowchart TD
              cyhole.rugcheck.Rugcheck[Rugcheck]
              cyhole.core.interaction.Interaction[Interaction]

                              cyhole.core.interaction.Interaction --> cyhole.rugcheck.Rugcheck
                


              click cyhole.rugcheck.Rugcheck href "" "cyhole.rugcheck.Rugcheck"
              click cyhole.core.interaction.Interaction href "" "cyhole.core.interaction.Interaction"
            

Class used to connect Rugcheck API.

Rugcheck provides rug-pull risk analysis for Solana tokens, including liquidity analysis, insider detection, and community voting.

Public endpoints require no API key. Authenticated endpoints require a Bearer token passed as api_key.

Example

from cyhole.rugcheck import Rugcheck

rugcheck = Rugcheck()
report = rugcheck.client.get_token_report("DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263")

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

def __init__(self, api_key: str | None = None, headers: Any | None = None) -> None:
    super().__init__(headers)
    if api_key:
        auth_header = {"Authorization": f"Bearer {api_key}"}
        self.headers = {**(self.headers or {}), **auth_header}
    self.client = RugcheckClient(self)
    self.async_client = RugcheckAsyncClient(self)
    self.url_api = "https://api.rugcheck.xyz"

_get_ping

_get_ping(sync: Literal[True]) -> GetPingResponse

_get_ping(
    sync: Literal[False],
) -> Coroutine[None, None, GetPingResponse]

_get_ping(
    sync: bool,
) -> (
    GetPingResponse | Coroutine[None, None, GetPingResponse]
)

This function refers to the Ping API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required

Returns:

Name	Type	Description
GetPingResponse	GetPingResponse | Coroutine[None, None, GetPingResponse]	ping response with a message field.

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

def _get_ping(self, sync: bool) -> GetPingResponse | Coroutine[None, None, GetPingResponse]:
    """
    This function refers to the **Ping** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.

    Returns:
        GetPingResponse: ping response with a `message` field.
    """
    url = self.url_api + "/ping"
    return self.api_return_model(sync, RequestType.GET.value, url, GetPingResponse)

_get_maintenance

_get_maintenance(
    sync: Literal[True],
) -> GetMaintenanceResponse

_get_maintenance(
    sync: Literal[False],
) -> Coroutine[None, None, GetMaintenanceResponse]

_get_maintenance(
    sync: bool,
) -> (
    GetMaintenanceResponse
    | Coroutine[None, None, GetMaintenanceResponse]
)

This function refers to the Maintenance API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required

Returns:

Name	Type	Description
GetMaintenanceResponse	GetMaintenanceResponse | Coroutine[None, None, GetMaintenanceResponse]	maintenance status message.

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

def _get_maintenance(self, sync: bool) -> GetMaintenanceResponse | Coroutine[None, None, GetMaintenanceResponse]:
    """
    This function refers to the **Maintenance** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.

    Returns:
        GetMaintenanceResponse: maintenance status message.
    """
    url = self.url_api + "/v1/maintenance"
    return self.api_return_model(sync, RequestType.GET.value, url, GetMaintenanceResponse)

_get_leaderboard

_get_leaderboard(
    sync: Literal[True], page: int = 0, limit: int = 50
) -> GetLeaderboardResponse

_get_leaderboard(
    sync: Literal[False], page: int = 0, limit: int = 50
) -> Coroutine[None, None, GetLeaderboardResponse]

_get_leaderboard(
    sync: bool, page: int = 0, limit: int = 50
) -> (
    GetLeaderboardResponse
    | Coroutine[None, None, GetLeaderboardResponse]
)

This function refers to the Leaderboard API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
page	int	page number (default 0).	0
limit	int	number of entries per page, max 100 (default 50).	50

Returns:

Name	Type	Description
GetLeaderboardResponse	GetLeaderboardResponse | Coroutine[None, None, GetLeaderboardResponse]	ordered list of top voters.

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

def _get_leaderboard(self, sync: bool, page: int = 0, limit: int = 50) -> GetLeaderboardResponse | Coroutine[None, None, GetLeaderboardResponse]:
    """
    This function refers to the **Leaderboard** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        page: page number (default 0).
        limit: number of entries per page, max 100 (default 50).

    Returns:
        GetLeaderboardResponse: ordered list of top voters.
    """
    url = self.url_api + "/v1/leaderboard"
    params = {"page": page, "limit": limit}
    return self.api_return_model(sync, RequestType.GET.value, url, GetLeaderboardResponse, params=params)

_get_token_report

_get_token_report(
    sync: Literal[True],
    mint: str,
    refresh: bool | None = None,
) -> GetTokenReportResponse

_get_token_report(
    sync: Literal[False],
    mint: str,
    refresh: bool | None = None,
) -> Coroutine[None, None, GetTokenReportResponse]

_get_token_report(
    sync: bool, mint: str, refresh: bool | None = None
) -> (
    GetTokenReportResponse
    | Coroutine[None, None, GetTokenReportResponse]
)

This function refers to the Get Token Report API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	token mint address.	required
refresh	bool | None	if True, force a fresh report generation.	None

Returns:

Name	Type	Description
GetTokenReportResponse	GetTokenReportResponse | Coroutine[None, None, GetTokenReportResponse]	full rug-check report for the token.

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

def _get_token_report(self, sync: bool, mint: str, refresh: bool | None = None) -> GetTokenReportResponse | Coroutine[None, None, GetTokenReportResponse]:
    """
    This function refers to the **Get Token Report** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        mint: token mint address.
        refresh: if True, force a fresh report generation.

    Returns:
        GetTokenReportResponse: full rug-check report for the token.
    """
    url = self.url_api + f"/v1/tokens/{mint}/report"
    params = {"refresh": refresh}
    return self.api_return_model(sync, RequestType.GET.value, url, GetTokenReportResponse, params=params)

_get_token_report_summary

_get_token_report_summary(
    sync: Literal[True],
    mint: str,
    cache_only: str | None = None,
    refresh: bool | None = None,
) -> GetTokenReportSummaryResponse

_get_token_report_summary(
    sync: Literal[False],
    mint: str,
    cache_only: str | None = None,
    refresh: bool | None = None,
) -> Coroutine[None, None, GetTokenReportSummaryResponse]

_get_token_report_summary(
    sync: bool,
    mint: str,
    cache_only: str | None = None,
    refresh: bool | None = None,
) -> (
    GetTokenReportSummaryResponse
    | Coroutine[None, None, GetTokenReportSummaryResponse]
)

This function refers to the Get Token Report Summary API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	token mint address.	required
cache_only	str | None	if set, only return cached results.	None
refresh	bool | None	if True, force a fresh report generation.	None

Returns:

Name	Type	Description
GetTokenReportSummaryResponse	GetTokenReportSummaryResponse | Coroutine[None, None, GetTokenReportSummaryResponse]	lightweight summary of the token report.

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

def _get_token_report_summary(self, sync: bool, mint: str, cache_only: str | None = None, refresh: bool | None = None) -> GetTokenReportSummaryResponse | Coroutine[None, None, GetTokenReportSummaryResponse]:
    """
    This function refers to the **Get Token Report Summary** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        mint: token mint address.
        cache_only: if set, only return cached results.
        refresh: if True, force a fresh report generation.

    Returns:
        GetTokenReportSummaryResponse: lightweight summary of the token report.
    """
    url = self.url_api + f"/v1/tokens/{mint}/report/summary"
    params = {"cacheOnly": cache_only, "refresh": refresh}
    return self.api_return_model(sync, RequestType.GET.value, url, GetTokenReportSummaryResponse, params=params)

_get_token_metadata

_get_token_metadata(
    sync: Literal[True], mint: str
) -> GetTokenMetadataResponse

_get_token_metadata(
    sync: Literal[False], mint: str
) -> Coroutine[None, None, GetTokenMetadataResponse]

_get_token_metadata(
    sync: bool, mint: str
) -> (
    GetTokenMetadataResponse
    | Coroutine[None, None, GetTokenMetadataResponse]
)

This function refers to the Get Token Metadata API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	token mint address.	required

Returns:

Name	Type	Description
GetTokenMetadataResponse	GetTokenMetadataResponse | Coroutine[None, None, GetTokenMetadataResponse]	token metadata including image URI.

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

def _get_token_metadata(self, sync: bool, mint: str) -> GetTokenMetadataResponse | Coroutine[None, None, GetTokenMetadataResponse]:
    """
    This function refers to the **Get Token Metadata** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        mint: token mint address.

    Returns:
        GetTokenMetadataResponse: token metadata including image URI.
    """
    url = self.url_api + f"/v1/tokens/{mint}/metadata"
    return self.api_return_model(sync, RequestType.GET.value, url, GetTokenMetadataResponse)

_get_token_votes

_get_token_votes(
    sync: Literal[True], mint: str
) -> GetTokenVotesResponse

_get_token_votes(
    sync: Literal[False], mint: str
) -> Coroutine[None, None, GetTokenVotesResponse]

_get_token_votes(
    sync: bool, mint: str
) -> (
    GetTokenVotesResponse
    | Coroutine[None, None, GetTokenVotesResponse]
)

This function refers to the Get Token Votes API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	token mint address.	required

Returns:

Name	Type	Description
GetTokenVotesResponse	GetTokenVotesResponse | Coroutine[None, None, GetTokenVotesResponse]	up/down vote counts for the token.

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

def _get_token_votes(self, sync: bool, mint: str) -> GetTokenVotesResponse | Coroutine[None, None, GetTokenVotesResponse]:
    """
    This function refers to the **Get Token Votes** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        mint: token mint address.

    Returns:
        GetTokenVotesResponse: up/down vote counts for the token.
    """
    url = self.url_api + f"/v1/tokens/{mint}/votes"
    return self.api_return_model(sync, RequestType.GET.value, url, GetTokenVotesResponse)

_get_token_insiders_graph

_get_token_insiders_graph(
    sync: Literal[True], mint: str
) -> GetTokenInsidersGraphResponse

_get_token_insiders_graph(
    sync: Literal[False], mint: str
) -> Coroutine[None, None, GetTokenInsidersGraphResponse]

_get_token_insiders_graph(
    sync: bool, mint: str
) -> (
    GetTokenInsidersGraphResponse
    | Coroutine[None, None, GetTokenInsidersGraphResponse]
)

This function refers to the Get Token Insiders Graph API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	token mint address.	required

Returns:

Name	Type	Description
GetTokenInsidersGraphResponse	GetTokenInsidersGraphResponse | Coroutine[None, None, GetTokenInsidersGraphResponse]	list of insider networks with full node graphs.

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

def _get_token_insiders_graph(self, sync: bool, mint: str) -> GetTokenInsidersGraphResponse | Coroutine[None, None, GetTokenInsidersGraphResponse]:
    """
    This function refers to the **Get Token Insiders Graph** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        mint: token mint address.

    Returns:
        GetTokenInsidersGraphResponse: list of insider networks with full node graphs.
    """
    url = self.url_api + f"/v1/tokens/{mint}/insiders/graph"
    return self.api_return_model(sync, RequestType.GET.value, url, GetTokenInsidersGraphResponse)

_get_token_insiders_networks

_get_token_insiders_networks(
    sync: Literal[True], mint: str
) -> GetTokenInsidersNetworksResponse

_get_token_insiders_networks(
    sync: Literal[False], mint: str
) -> Coroutine[
    None, None, GetTokenInsidersNetworksResponse
]

_get_token_insiders_networks(
    sync: bool, mint: str
) -> (
    GetTokenInsidersNetworksResponse
    | Coroutine[
        None, None, GetTokenInsidersNetworksResponse
    ]
)

This function refers to the Get Token Insiders Networks API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	token mint address.	required

Returns:

Name	Type	Description
GetTokenInsidersNetworksResponse	GetTokenInsidersNetworksResponse | Coroutine[None, None, GetTokenInsidersNetworksResponse]	summarised list of insider network metadata.

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

def _get_token_insiders_networks(self, sync: bool, mint: str) -> GetTokenInsidersNetworksResponse | Coroutine[None, None, GetTokenInsidersNetworksResponse]:
    """
    This function refers to the **Get Token Insiders Networks** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        mint: token mint address.

    Returns:
        GetTokenInsidersNetworksResponse: summarised list of insider network metadata.
    """
    url = self.url_api + f"/v1/tokens/{mint}/insiders/networks"
    return self.api_return_model(sync, RequestType.GET.value, url, GetTokenInsidersNetworksResponse)

_get_stats_new_tokens

_get_stats_new_tokens(
    sync: Literal[True],
) -> GetStatsNewTokensResponse

_get_stats_new_tokens(
    sync: Literal[False],
) -> Coroutine[None, None, GetStatsNewTokensResponse]

_get_stats_new_tokens(
    sync: bool,
) -> (
    GetStatsNewTokensResponse
    | Coroutine[None, None, GetStatsNewTokensResponse]
)

This function refers to the Get Stats New Tokens API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required

Returns:

Name	Type	Description
GetStatsNewTokensResponse	GetStatsNewTokensResponse | Coroutine[None, None, GetStatsNewTokensResponse]	list of recently created tokens.

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

def _get_stats_new_tokens(self, sync: bool) -> GetStatsNewTokensResponse | Coroutine[None, None, GetStatsNewTokensResponse]:
    """
    This function refers to the **Get Stats New Tokens** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.

    Returns:
        GetStatsNewTokensResponse: list of recently created tokens.
    """
    url = self.url_api + "/v1/stats/new_tokens"
    return self.api_return_model(sync, RequestType.GET.value, url, GetStatsNewTokensResponse)

_get_stats_recent

_get_stats_recent(
    sync: Literal[True],
) -> GetStatsRecentResponse

_get_stats_recent(
    sync: Literal[False],
) -> Coroutine[None, None, GetStatsRecentResponse]

_get_stats_recent(
    sync: bool,
) -> (
    GetStatsRecentResponse
    | Coroutine[None, None, GetStatsRecentResponse]
)

This function refers to the Get Stats Recent API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required

Returns:

Name	Type	Description
GetStatsRecentResponse	GetStatsRecentResponse | Coroutine[None, None, GetStatsRecentResponse]	list of recently visited/checked tokens.

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

def _get_stats_recent(self, sync: bool) -> GetStatsRecentResponse | Coroutine[None, None, GetStatsRecentResponse]:
    """
    This function refers to the **Get Stats Recent** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.

    Returns:
        GetStatsRecentResponse: list of recently visited/checked tokens.
    """
    url = self.url_api + "/v1/stats/recent"
    return self.api_return_model(sync, RequestType.GET.value, url, GetStatsRecentResponse)

_get_stats_trending

_get_stats_trending(
    sync: Literal[True],
) -> GetStatsTrendingResponse

_get_stats_trending(
    sync: Literal[False],
) -> Coroutine[None, None, GetStatsTrendingResponse]

_get_stats_trending(
    sync: bool,
) -> (
    GetStatsTrendingResponse
    | Coroutine[None, None, GetStatsTrendingResponse]
)

This function refers to the Get Stats Trending API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required

Returns:

Name	Type	Description
GetStatsTrendingResponse	GetStatsTrendingResponse | Coroutine[None, None, GetStatsTrendingResponse]	trending tokens by vote activity (may be null).

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

def _get_stats_trending(self, sync: bool) -> GetStatsTrendingResponse | Coroutine[None, None, GetStatsTrendingResponse]:
    """
    This function refers to the **Get Stats Trending** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.

    Returns:
        GetStatsTrendingResponse: trending tokens by vote activity (may be null).
    """
    url = self.url_api + "/v1/stats/trending"
    return self.api_return_model(sync, RequestType.GET.value, url, GetStatsTrendingResponse)

_get_stats_verified

_get_stats_verified(
    sync: Literal[True],
) -> GetStatsVerifiedResponse

_get_stats_verified(
    sync: Literal[False],
) -> Coroutine[None, None, GetStatsVerifiedResponse]

_get_stats_verified(
    sync: bool,
) -> (
    GetStatsVerifiedResponse
    | Coroutine[None, None, GetStatsVerifiedResponse]
)

This function refers to the Get Stats Verified API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required

Returns:

Name	Type	Description
GetStatsVerifiedResponse	GetStatsVerifiedResponse | Coroutine[None, None, GetStatsVerifiedResponse]	list of verified tokens with project metadata.

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

def _get_stats_verified(self, sync: bool) -> GetStatsVerifiedResponse | Coroutine[None, None, GetStatsVerifiedResponse]:
    """
    This function refers to the **Get Stats Verified** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.

    Returns:
        GetStatsVerifiedResponse: list of verified tokens with project metadata.
    """
    url = self.url_api + "/v1/stats/verified"
    return self.api_return_model(sync, RequestType.GET.value, url, GetStatsVerifiedResponse)

_get_stats_analytics

_get_stats_analytics(
    sync: Literal[True],
    window: RugcheckAnalyticsWindow = RugcheckAnalyticsWindow.D7,
) -> GetStatsAnalyticsResponse

_get_stats_analytics(
    sync: Literal[False],
    window: RugcheckAnalyticsWindow = RugcheckAnalyticsWindow.D7,
) -> Coroutine[None, None, GetStatsAnalyticsResponse]

_get_stats_analytics(
    sync: bool,
    window: RugcheckAnalyticsWindow = RugcheckAnalyticsWindow.D7,
) -> (
    GetStatsAnalyticsResponse
    | Coroutine[None, None, GetStatsAnalyticsResponse]
)

This function refers to the Get Stats Analytics API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
window	RugcheckAnalyticsWindow	time window for the analytics data (default: 7d).	RugcheckAnalyticsWindow.D7

Returns:

Name	Type	Description
GetStatsAnalyticsResponse	GetStatsAnalyticsResponse | Coroutine[None, None, GetStatsAnalyticsResponse]	aggregate analytics statistics.

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

def _get_stats_analytics(self, sync: bool, window: RugcheckAnalyticsWindow = RugcheckAnalyticsWindow.D7) -> GetStatsAnalyticsResponse | Coroutine[None, None, GetStatsAnalyticsResponse]:
    """
    This function refers to the **Get Stats Analytics** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        window: time window for the analytics data (default: 7d).

    Returns:
        GetStatsAnalyticsResponse: aggregate analytics statistics.
    """
    url = self.url_api + "/v1/stats/analytics"
    params = {"window": window.value}
    return self.api_return_model(sync, RequestType.GET.value, url, GetStatsAnalyticsResponse, params=params)

_get_stats_rugs_ticker

_get_stats_rugs_ticker(
    sync: Literal[True], limit: int = 10
) -> GetStatsRugsTickerResponse

_get_stats_rugs_ticker(
    sync: Literal[False], limit: int = 10
) -> Coroutine[None, None, GetStatsRugsTickerResponse]

_get_stats_rugs_ticker(
    sync: bool, limit: int = 10
) -> (
    GetStatsRugsTickerResponse
    | Coroutine[None, None, GetStatsRugsTickerResponse]
)

This function refers to the Get Stats Rugs Ticker API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
limit	int	maximum number of items to return, max 50 (default 10).	10

Returns:

Name	Type	Description
GetStatsRugsTickerResponse	GetStatsRugsTickerResponse | Coroutine[None, None, GetStatsRugsTickerResponse]	recent rug-pull ticker items.

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

def _get_stats_rugs_ticker(self, sync: bool, limit: int = 10) -> GetStatsRugsTickerResponse | Coroutine[None, None, GetStatsRugsTickerResponse]:
    """
    This function refers to the **Get Stats Rugs Ticker** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        limit: maximum number of items to return, max 50 (default 10).

    Returns:
        GetStatsRugsTickerResponse: recent rug-pull ticker items.
    """
    url = self.url_api + "/v1/stats/rugs/ticker"
    params = {"limit": limit}
    return self.api_return_model(sync, RequestType.GET.value, url, GetStatsRugsTickerResponse, params=params)

_get_creator

_get_creator(
    sync: Literal[True], wallet: str
) -> GetCreatorResponse

_get_creator(
    sync: Literal[False], wallet: str
) -> Coroutine[None, None, GetCreatorResponse]

_get_creator(
    sync: bool, wallet: str
) -> (
    GetCreatorResponse
    | Coroutine[None, None, GetCreatorResponse]
)

This function refers to the Get Creator API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
wallet	str	creator wallet address.	required

Returns:

Name	Type	Description
GetCreatorResponse	GetCreatorResponse | Coroutine[None, None, GetCreatorResponse]	creator statistics including rug history.

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

def _get_creator(self, sync: bool, wallet: str) -> GetCreatorResponse | Coroutine[None, None, GetCreatorResponse]:
    """
    This function refers to the **Get Creator** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        wallet: creator wallet address.

    Returns:
        GetCreatorResponse: creator statistics including rug history.
    """
    url = self.url_api + f"/v1/creators/{wallet}"
    return self.api_return_model(sync, RequestType.GET.value, url, GetCreatorResponse)

_get_domains

_get_domains(
    sync: Literal[True],
    page: int | None = None,
    limit: int | None = None,
    verified: bool | None = None,
) -> GetDomainsResponse

_get_domains(
    sync: Literal[False],
    page: int | None = None,
    limit: int | None = None,
    verified: bool | None = None,
) -> Coroutine[None, None, GetDomainsResponse]

_get_domains(
    sync: bool,
    page: int | None = None,
    limit: int | None = None,
    verified: bool | None = None,
) -> (
    GetDomainsResponse
    | Coroutine[None, None, GetDomainsResponse]
)

This function refers to the Get Domains API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
page	int | None	page number for pagination.	None
limit	int | None	number of results per page.	None
verified	bool | None	if True, return only verified domain tokens.	None

Returns:

Name	Type	Description
GetDomainsResponse	GetDomainsResponse | Coroutine[None, None, GetDomainsResponse]	list of domain-mapped tokens.

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

def _get_domains(self, sync: bool, page: int | None = None, limit: int | None = None, verified: bool | None = None) -> GetDomainsResponse | Coroutine[None, None, GetDomainsResponse]:
    """
    This function refers to the **Get Domains** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        page: page number for pagination.
        limit: number of results per page.
        verified: if True, return only verified domain tokens.

    Returns:
        GetDomainsResponse: list of domain-mapped tokens.
    """
    url = self.url_api + "/v1/domains"
    params = {"page": page, "limit": limit, "verified": verified}
    return self.api_return_model(sync, RequestType.GET.value, url, GetDomainsResponse, params=params)

_get_domain_lookup

_get_domain_lookup(
    sync: Literal[True], domain_id: str
) -> GetDomainLookupResponse

_get_domain_lookup(
    sync: Literal[False], domain_id: str
) -> Coroutine[None, None, GetDomainLookupResponse]

_get_domain_lookup(
    sync: bool, domain_id: str
) -> (
    GetDomainLookupResponse
    | Coroutine[None, None, GetDomainLookupResponse]
)

This function refers to the Get Domain Lookup API endpoint.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
domain_id	str	domain identifier to resolve.	required

Returns:

Name	Type	Description
GetDomainLookupResponse	GetDomainLookupResponse | Coroutine[None, None, GetDomainLookupResponse]	resolved mint address for the domain.

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

def _get_domain_lookup(self, sync: bool, domain_id: str) -> GetDomainLookupResponse | Coroutine[None, None, GetDomainLookupResponse]:
    """
    This function refers to the **Get Domain Lookup** API endpoint.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        domain_id: domain identifier to resolve.

    Returns:
        GetDomainLookupResponse: resolved mint address for the domain.
    """
    url = self.url_api + f"/v1/domains/lookup/{domain_id}"
    return self.api_return_model(sync, RequestType.GET.value, url, GetDomainLookupResponse)

_post_token_report

_post_token_report(
    sync: Literal[True], mint: str
) -> PostTokenReportResponse

_post_token_report(
    sync: Literal[False], mint: str
) -> Coroutine[None, None, PostTokenReportResponse]

_post_token_report(
    sync: bool, mint: str
) -> (
    PostTokenReportResponse
    | Coroutine[None, None, PostTokenReportResponse]
)

This function refers to the Post Token Report API endpoint.

Requires authentication.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	token mint address to trigger report generation for.	required

Returns:

Name	Type	Description
PostTokenReportResponse	PostTokenReportResponse | Coroutine[None, None, PostTokenReportResponse]	confirmation that report generation was queued.

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

def _post_token_report(self, sync: bool, mint: str) -> PostTokenReportResponse | Coroutine[None, None, PostTokenReportResponse]:
    """
    This function refers to the **Post Token Report** API endpoint.

    Requires authentication.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        mint: token mint address to trigger report generation for.

    Returns:
        PostTokenReportResponse: confirmation that report generation was queued.
    """
    url = self.url_api + f"/v1/tokens/{mint}/report"
    return self.api_return_model(sync, RequestType.POST.value, url, PostTokenReportResponse)

_post_token_vote

_post_token_vote(
    sync: Literal[True], body: PostTokenVoteBody
) -> PostTokenVoteResponse

_post_token_vote(
    sync: Literal[False], body: PostTokenVoteBody
) -> Coroutine[None, None, PostTokenVoteResponse]

_post_token_vote(
    sync: bool, body: PostTokenVoteBody
) -> (
    PostTokenVoteResponse
    | Coroutine[None, None, PostTokenVoteResponse]
)

This function refers to the Post Token Vote API endpoint.

Requires authentication.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostTokenVoteBody	vote body containing mint address and vote direction.	required

Returns:

Name	Type	Description
PostTokenVoteResponse	PostTokenVoteResponse | Coroutine[None, None, PostTokenVoteResponse]	updated vote counts after casting the vote.

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

def _post_token_vote(self, sync: bool, body: PostTokenVoteBody) -> PostTokenVoteResponse | Coroutine[None, None, PostTokenVoteResponse]:
    """
    This function refers to the **Post Token Vote** API endpoint.

    Requires authentication.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        body: vote body containing mint address and vote direction.

    Returns:
        PostTokenVoteResponse: updated vote counts after casting the vote.
    """
    url = self.url_api + f"/v1/tokens/{body.mint}/vote"
    return self.api_return_model(sync, RequestType.POST.value, url, PostTokenVoteResponse, json=body.model_dump())

_get_token_lockers

_get_token_lockers(
    sync: Literal[True], mint: str
) -> GetTokenLockersResponse

_get_token_lockers(
    sync: Literal[False], mint: str
) -> Coroutine[None, None, GetTokenLockersResponse]

_get_token_lockers(
    sync: bool, mint: str
) -> (
    GetTokenLockersResponse
    | Coroutine[None, None, GetTokenLockersResponse]
)

This function refers to the Get Token Lockers API endpoint.

Requires authentication.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	token mint address.	required

Returns:

Name	Type	Description
GetTokenLockersResponse	GetTokenLockersResponse | Coroutine[None, None, GetTokenLockersResponse]	locker details and aggregate vault totals.

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

def _get_token_lockers(self, sync: bool, mint: str) -> GetTokenLockersResponse | Coroutine[None, None, GetTokenLockersResponse]:
    """
    This function refers to the **Get Token Lockers** API endpoint.

    Requires authentication.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        mint: token mint address.

    Returns:
        GetTokenLockersResponse: locker details and aggregate vault totals.
    """
    url = self.url_api + f"/v1/tokens/{mint}/lockers"
    return self.api_return_model(sync, RequestType.GET.value, url, GetTokenLockersResponse)

_get_token_lockers_flux

_get_token_lockers_flux(
    sync: Literal[True], mint: str
) -> GetTokenLockersFluxResponse

_get_token_lockers_flux(
    sync: Literal[False], mint: str
) -> Coroutine[None, None, GetTokenLockersFluxResponse]

_get_token_lockers_flux(
    sync: bool, mint: str
) -> (
    GetTokenLockersFluxResponse
    | Coroutine[None, None, GetTokenLockersFluxResponse]
)

This function refers to the Get Token Lockers Flux API endpoint.

Requires authentication.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
mint	str	token mint address.	required

Returns:

Name	Type	Description
GetTokenLockersFluxResponse	GetTokenLockersFluxResponse | Coroutine[None, None, GetTokenLockersFluxResponse]	flux vault locker details and aggregate totals.

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

def _get_token_lockers_flux(self, sync: bool, mint: str) -> GetTokenLockersFluxResponse | Coroutine[None, None, GetTokenLockersFluxResponse]:
    """
    This function refers to the **Get Token Lockers Flux** API endpoint.

    Requires authentication.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        mint: token mint address.

    Returns:
        GetTokenLockersFluxResponse: flux vault locker details and aggregate totals.
    """
    url = self.url_api + f"/v1/tokens/{mint}/lockers/flux"
    return self.api_return_model(sync, RequestType.GET.value, url, GetTokenLockersFluxResponse)

_post_bulk_tokens_report

_post_bulk_tokens_report(
    sync: Literal[True], body: PostBulkTokensBody
) -> PostBulkTokensReportResponse

_post_bulk_tokens_report(
    sync: Literal[False], body: PostBulkTokensBody
) -> Coroutine[None, None, PostBulkTokensReportResponse]

_post_bulk_tokens_report(
    sync: bool, body: PostBulkTokensBody
) -> (
    PostBulkTokensReportResponse
    | Coroutine[None, None, PostBulkTokensReportResponse]
)

This function refers to the Post Bulk Tokens Report API endpoint.

Requires authentication.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostBulkTokensBody	bulk request body with list of token mint addresses.	required

Returns:

Name	Type	Description
PostBulkTokensReportResponse	PostBulkTokensReportResponse | Coroutine[None, None, PostBulkTokensReportResponse]	detailed reports for all requested tokens.

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

def _post_bulk_tokens_report(self, sync: bool, body: PostBulkTokensBody) -> PostBulkTokensReportResponse | Coroutine[None, None, PostBulkTokensReportResponse]:
    """
    This function refers to the **Post Bulk Tokens Report** API endpoint.

    Requires authentication.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        body: bulk request body with list of token mint addresses.

    Returns:
        PostBulkTokensReportResponse: detailed reports for all requested tokens.
    """
    url = self.url_api + "/v1/bulk/tokens/report"
    return self.api_return_model(sync, RequestType.POST.value, url, PostBulkTokensReportResponse, json=body.model_dump(by_alias=True))

_post_bulk_tokens_summary

_post_bulk_tokens_summary(
    sync: Literal[True], body: PostBulkTokensBody
) -> PostBulkTokensSummaryResponse

_post_bulk_tokens_summary(
    sync: Literal[False], body: PostBulkTokensBody
) -> Coroutine[None, None, PostBulkTokensSummaryResponse]

_post_bulk_tokens_summary(
    sync: bool, body: PostBulkTokensBody
) -> (
    PostBulkTokensSummaryResponse
    | Coroutine[None, None, PostBulkTokensSummaryResponse]
)

This function refers to the Post Bulk Tokens Summary API endpoint.

Requires authentication.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostBulkTokensBody	bulk request body with list of token mint addresses.	required

Returns:

Name	Type	Description
PostBulkTokensSummaryResponse	PostBulkTokensSummaryResponse | Coroutine[None, None, PostBulkTokensSummaryResponse]	summary reports for all requested tokens.

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

def _post_bulk_tokens_summary(self, sync: bool, body: PostBulkTokensBody) -> PostBulkTokensSummaryResponse | Coroutine[None, None, PostBulkTokensSummaryResponse]:
    """
    This function refers to the **Post Bulk Tokens Summary** API endpoint.

    Requires authentication.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        body: bulk request body with list of token mint addresses.

    Returns:
        PostBulkTokensSummaryResponse: summary reports for all requested tokens.
    """
    url = self.url_api + "/v1/bulk/tokens/summary"
    return self.api_return_model(sync, RequestType.POST.value, url, PostBulkTokensSummaryResponse, json=body.model_dump(by_alias=True))

_post_tokens_verify_eligible

_post_tokens_verify_eligible(
    sync: Literal[True], body: PostTokensVerifyEligibleBody
) -> PostTokensVerifyEligibleResponse

_post_tokens_verify_eligible(
    sync: Literal[False], body: PostTokensVerifyEligibleBody
) -> Coroutine[
    None, None, PostTokensVerifyEligibleResponse
]

_post_tokens_verify_eligible(
    sync: bool, body: PostTokensVerifyEligibleBody
) -> (
    PostTokensVerifyEligibleResponse
    | Coroutine[
        None, None, PostTokensVerifyEligibleResponse
    ]
)

This function refers to the Post Tokens Verify Eligible API endpoint.

Requires authentication.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostTokensVerifyEligibleBody	body containing the mint address to evaluate.	required

Returns:

Name	Type	Description
PostTokensVerifyEligibleResponse	PostTokensVerifyEligibleResponse | Coroutine[None, None, PostTokensVerifyEligibleResponse]	eligibility check result with detailed criteria.

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

def _post_tokens_verify_eligible(self, sync: bool, body: PostTokensVerifyEligibleBody) -> PostTokensVerifyEligibleResponse | Coroutine[None, None, PostTokensVerifyEligibleResponse]:
    """
    This function refers to the **Post Tokens Verify Eligible** API endpoint.

    Requires authentication.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        body: body containing the mint address to evaluate.

    Returns:
        PostTokensVerifyEligibleResponse: eligibility check result with detailed criteria.
    """
    url = self.url_api + "/v1/tokens/verify/eligible"
    return self.api_return_model(sync, RequestType.POST.value, url, PostTokensVerifyEligibleResponse, json=body.model_dump())

_post_tokens_verify

_post_tokens_verify(
    sync: Literal[True], body: PostTokensVerifyBody
) -> PostTokensVerifyResponse

_post_tokens_verify(
    sync: Literal[False], body: PostTokensVerifyBody
) -> Coroutine[None, None, PostTokensVerifyResponse]

_post_tokens_verify(
    sync: bool, body: PostTokensVerifyBody
) -> (
    PostTokensVerifyResponse
    | Coroutine[None, None, PostTokensVerifyResponse]
)

This function refers to the Post Tokens Verify API endpoint.

Requires authentication.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostTokensVerifyBody	verification submission body with mint, payer, signature, and metadata.	required

Returns:

Name	Type	Description
PostTokensVerifyResponse	PostTokensVerifyResponse | Coroutine[None, None, PostTokensVerifyResponse]	confirmation that the verification was submitted.

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

def _post_tokens_verify(self, sync: bool, body: PostTokensVerifyBody) -> PostTokensVerifyResponse | Coroutine[None, None, PostTokensVerifyResponse]:
    """
    This function refers to the **Post Tokens Verify** API endpoint.

    Requires authentication.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        body: verification submission body with mint, payer, signature, and metadata.

    Returns:
        PostTokensVerifyResponse: confirmation that the verification was submitted.
    """
    url = self.url_api + "/v1/tokens/verify"
    return self.api_return_model(sync, RequestType.POST.value, url, PostTokensVerifyResponse, json=body.model_dump(by_alias=True))

_post_tokens_verify_transaction

_post_tokens_verify_transaction(
    sync: Literal[True],
    body: PostTokensVerifyTransactionBody,
) -> PostTokensVerifyTransactionResponse

_post_tokens_verify_transaction(
    sync: Literal[False],
    body: PostTokensVerifyTransactionBody,
) -> Coroutine[
    None, None, PostTokensVerifyTransactionResponse
]

_post_tokens_verify_transaction(
    sync: bool, body: PostTokensVerifyTransactionBody
) -> (
    PostTokensVerifyTransactionResponse
    | Coroutine[
        None, None, PostTokensVerifyTransactionResponse
    ]
)

This function refers to the Post Tokens Verify Transaction API endpoint.

Requires authentication.

Parameters:

Name	Type	Description	Default
sync	bool	if True run synchronously, else return a coroutine.	required
body	PostTokensVerifyTransactionBody	body containing mint, payer, data payload, and priority fee.	required

Returns:

Name	Type	Description
PostTokensVerifyTransactionResponse	PostTokensVerifyTransactionResponse | Coroutine[None, None, PostTokensVerifyTransactionResponse]	serialised transaction for on-chain submission.

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

def _post_tokens_verify_transaction(self, sync: bool, body: PostTokensVerifyTransactionBody) -> PostTokensVerifyTransactionResponse | Coroutine[None, None, PostTokensVerifyTransactionResponse]:
    """
    This function refers to the **Post Tokens Verify Transaction** API endpoint.

    Requires authentication.

    Parameters:
        sync: if True run synchronously, else return a coroutine.
        body: body containing mint, payer, data payload, and priority fee.

    Returns:
        PostTokensVerifyTransactionResponse: serialised transaction for on-chain submission.
    """
    url = self.url_api + "/v1/tokens/verify/transaction"
    return self.api_return_model(sync, RequestType.POST.value, url, PostTokensVerifyTransactionResponse, json=body.model_dump())