View Source Hyperliquid.Api.Info.VaultDetails (hyperliquid v0.2.2)

@type t() :: %Hyperliquid.Api.Info.VaultDetails{
  allow_deposits: boolean(),
  always_close_on_withdraw: boolean(),
  apr: float(),
  description: String.t(),
  follower_state: map() | nil,
  followers: list(),
  is_closed: boolean(),
  leader: String.t(),
  leader_commission: float(),
  leader_fraction: float(),
  max_distributable: float(),
  max_withdrawable: float(),
  name: String.t(),
  portfolio: list(),
  relationship: map(),
  vault_address: String.t()
}

Functions

__endpoint_info__()

Returns metadata about this endpoint.

Example

iex> Hyperliquid.Api.Info.VaultDetails.__endpoint_info__()
%{
  endpoint: "vaultDetails",
  type: :info,
  rate_limit_cost: 1,
  params: [:vaultAddress],
  optional_params: [:user],
  doc: "Retrieve detailed vault information",
  returns: "Comprehensive details about a specific vault"
}

__postgres_tables__()

Returns postgres table configurations (multi-table support).

__storage_config__()

Returns storage configuration for this endpoint.

build_cache_key(data)

Build a cache key from response data using the configured pattern. Returns nil if cache is not enabled or no pattern configured.

build_request(vaultAddress, opts \\ [])

@spec build_request(
  term(),
  keyword()
) :: map()

Build the request payload.

build_request_with_user(vault_address, user)

@spec build_request_with_user(String.t(), String.t()) :: map()

Build the request payload with optional user parameter.

Parameters

vault_address: Vault address (0x...)
user: Optional user address to get follower state

Returns

Map with request parameters

cache_enabled?()

Returns true if cache storage is enabled.

cache_ttl()

Returns the cache TTL if configured.

changeset(details \\ %MODULE{}, attrs)

@spec changeset(t(), map()) :: Ecto.Changeset.t()

closed?(vault_details)

@spec closed?(t()) :: boolean()

Check if vault is closed.

deposits_allowed?(vault_details)

@spec deposits_allowed?(t()) :: boolean()

Check if deposits are allowed.

fetch(vaultAddress, opts \\ [])

Fetch is an alias for request when no storage is configured.

fetch!(vaultAddress, opts \\ [])

parse_response(data)

@spec parse_response(map()) :: {:ok, t()} | {:error, term()}

Parse and validate the API response.

postgres_enabled?()

Returns true if postgres storage is enabled.

postgres_table()

Returns the postgres table name if configured (primary table for legacy support).

postgres_upsert_config()

Returns the upsert config for postgres (primary table for legacy support).

rate_limit_cost()

@spec rate_limit_cost() :: non_neg_integer()

Get the rate limit cost for this endpoint.

request(vaultAddress, opts \\ [])

@spec request(
  term(),
  keyword()
) :: {:ok, t()} | {:error, term()}

Make the API request and parse the response.

request!(vaultAddress, opts \\ [])

@spec request!(
  term(),
  keyword()
) :: t()

Make the API request, raising on error.

request_raw(vaultAddress, opts \\ [])

@spec request_raw(
  term(),
  keyword()
) :: {:ok, map()} | {:error, term()}

Make the API request and return the raw response map (no key transformation).

request_raw!(vaultAddress, opts \\ [])

@spec request_raw!(
  term(),
  keyword()
) :: map()

Make the API request returning raw map, raising on error.

request_with_user(vault_address, user)

@spec request_with_user(String.t(), String.t() | nil) :: {:ok, t()} | {:error, term()}

Fetches vault details with optional user parameter.

Parameters

vault_address: Vault address (0x...)
user: Optional user address to get follower state

Returns

{:ok, %VaultDetails{}} - Parsed and validated data
{:error, term()} - Error from HTTP or validation

Example

{:ok, details} = VaultDetails.request_with_user("0x1234...", "0x5678...")

storage_enabled?()

Returns true if any storage backend is enabled.