@defillama/sdk 5.0.240 → 5.0.244

package/build/chains/aptos.d.ts

@@ -0,0 +1,269 @@
+export declare const DEFAULT_ENDPOINTS: Record<string, string>;
+/**
+ * Archival nodes used when the primary answers 410 `block_pruned` / `version_pruned`
+ * (the public aptos fullnode keeps only a few weeks of blocks). Override with `<CHAIN>_ARCHIVAL_RPC`.
+ */
+export declare const ARCHIVAL_ENDPOINTS: Record<string, string>;
+/**
+ * Indexer (Hasura GraphQL) endpoints. Override / add fallbacks with `<CHAIN>_INDEXER` (comma separated).
+ * The `<CHAIN>_API_KEY` bearer key is sent here too (aptoslabs keys cover both the full node and the indexer).
+ */
+export declare const INDEXER_ENDPOINTS: Record<string, string>;
+export declare const aptosChains: string[];
+export declare const APT_COIN_TYPE = "0x1::aptos_coin::AptosCoin";
+export declare const APT_DECIMALS = 8;
+export type AptosChain = 'aptos' | 'move' | string;
+export interface ChainOptions {
+    /** chain key, default `aptos` */
+    chain?: AptosChain;
+}
+export interface RequestOptions extends ChainOptions {
+    timeout?: number;
+    retries?: number;
+    /** send straight to the archival endpoint(s) instead of falling back to them on 410 */
+    archival?: boolean;
+}
+export interface LedgerInfo {
+    chainId: number;
+    ledgerVersion: number;
+    /** unix seconds */
+    ledgerTimestamp: number;
+    blockHeight: number;
+    oldestLedgerVersion: number;
+    oldestBlockHeight: number;
+    epoch: number;
+    raw: any;
+}
+export interface AptosBlock {
+    /** block height */
+    number: number;
+    /** unix seconds */
+    timestamp: number;
+    hash: string;
+    firstVersion: number;
+    lastVersion: number;
+    transactions?: any[];
+    raw: any;
+}
+export interface CoinInfo {
+    decimals: number;
+    symbol: string;
+    name: string;
+    /** raw supply (only when directly available on the metadata resource) */
+    supply?: string;
+}
+export interface TypeTag {
+    /** full type string as given */
+    raw: string;
+    /** module address (`0x1`), empty for primitives */
+    address: string;
+    /** module name (`coin`), empty for primitives */
+    module: string;
+    /** struct / primitive name (`CoinInfo`, `u64`) */
+    name: string;
+    /** generic type arguments, unparsed (`['0x1::aptos_coin::AptosCoin']`) */
+    typeArgs: string[];
+    /** true when the tag is a struct (`addr::module::Name`) */
+    isStruct: boolean;
+}
+export declare function isAptosChain(chain?: string): boolean;
+/** All configured endpoints for the chain (env override first, then defaults). */
+export declare function getEndpointList({ chain }?: ChainOptions): string[];
+/** First configured endpoint for the chain. */
+export declare function getEndpoint({ chain }?: ChainOptions): string;
+/** Archival endpoints for the chain (`<CHAIN>_ARCHIVAL_RPC` env, then built-in); empty when none. */
+export declare function getArchivalEndpointList({ chain }?: ChainOptions): string[];
+/** Indexer GraphQL endpoints for the chain (`<CHAIN>_INDEXER` env first, then built-in); empty when none. */
+export declare function getIndexerEndpointList({ chain }?: ChainOptions): string[];
+/** GET `path` (relative to the node root, e.g. `/v1/accounts/0x1`). 404 -> `null` when `allowNotFound`. */
+export declare function get({ chain, path, params, allowNotFound, timeout, retries, archival }: RequestOptions & {
+    path: string;
+    params?: Record<string, any>;
+    allowNotFound?: boolean;
+}): Promise<any>;
+/** POST `body` to `path` (relative to the node root, e.g. `/v1/view`). */
+export declare function post({ chain, path, body, params, allowNotFound, timeout, retries, archival }: RequestOptions & {
+    path: string;
+    body: any;
+    params?: Record<string, any>;
+    allowNotFound?: boolean;
+}): Promise<any>;
+/** GraphQL `errors` in a 200 response (bad query, or a rate limit the indexer reports in-band). */
+export declare class IndexerError extends Error {
+    errors: any[];
+    constructor(errors: any[]);
+}
+/**
+ * Run a GraphQL query against the chain's indexer, returning `data`. Same transport as the node calls:
+ * rotates over `<CHAIN>_INDEXER` endpoints (then the default), retries transport/5xx/429 failures with
+ * backoff and sends the `<CHAIN>_API_KEY` bearer key. GraphQL `errors` throw `IndexerError` and are
+ * only retried when they report a rate limit (a bad query fails fast).
+ */
+export declare function indexerQuery<T = any>({ chain, query, variables, timeout, retries }: RequestOptions & {
+    query: string;
+    variables?: Record<string, any>;
+}): Promise<T>;
+export interface FungibleAssetBalance {
+    owner: string;
+    /** coin type (`0x1::aptos_coin::AptosCoin`) or FA metadata address */
+    assetType: string;
+    /** raw amount (coin + fungible store balance combined by the indexer) */
+    amount: string;
+}
+/**
+ * Coin + fungible asset balances of many owners from the indexer (`current_fungible_asset_balances`),
+ * `chunkSize` owners per query and paginated, so a few requests replace one node call per owner per token.
+ * Owners are matched by the indexer's 64-hex form, so short addresses are padded first.
+ */
+export declare function getFungibleAssetBalances({ chain, owners, chunkSize, pageSize, timeout, retries }: RequestOptions & {
+    owners: string[];
+    chunkSize?: number;
+    pageSize?: number;
+}): Promise<FungibleAssetBalance[]>;
+export declare function getLedgerInfo({ chain, archival }?: ChainOptions & {
+    archival?: boolean;
+}): Promise<LedgerInfo>;
+/** `{ sequence_number, authentication_key }` or `null` when the account does not exist. */
+export declare function getAccount({ chain, address, ledgerVersion }: ChainOptions & {
+    address: string;
+    ledgerVersion?: number | string;
+}): Promise<any>;
+/** Every resource of `account` (`{ type, data }[]`), following `x-aptos-cursor` pagination. */
+export declare function getResources({ chain, account, ledgerVersion }: ChainOptions & {
+    account: string;
+    ledgerVersion?: number | string;
+}): Promise<any[]>;
+/** `data` of one resource, or `null` when the account does not hold it. */
+export declare function getResource({ chain, account, type, ledgerVersion }: ChainOptions & {
+    account: string;
+    type: string;
+    ledgerVersion?: number | string;
+}): Promise<any>;
+/** Every module published by `account`, following `x-aptos-cursor` pagination. */
+export declare function getAccountModules({ chain, account, ledgerVersion }: ChainOptions & {
+    account: string;
+    ledgerVersion?: number | string;
+}): Promise<any[]>;
+/** Single module ABI/bytecode, or `null` when missing. */
+export declare function getAccountModule({ chain, account, name, ledgerVersion }: ChainOptions & {
+    account: string;
+    name: string;
+    ledgerVersion?: number | string;
+}): Promise<any>;
+/**
+ * Read one table item. Returns the decoded value, or `null` when `allowNotFound` is set and the
+ * key is missing (the node answers 404 for absent keys).
+ */
+export declare function getTableItem({ chain, handle, keyType, valueType, key, ledgerVersion, allowNotFound }: ChainOptions & {
+    handle: string;
+    keyType: string;
+    valueType: string;
+    key: any;
+    ledgerVersion?: number | string;
+    allowNotFound?: boolean;
+}): Promise<any>;
+/** Run a `#[view]` function. Returns the result array as the node encodes it (u64/u128 as strings). */
+export declare function view<T extends any[] = any[]>({ chain, function: fn, typeArguments, args, ledgerVersion }: ChainOptions & {
+    function: string;
+    typeArguments?: string[];
+    args?: any[];
+    ledgerVersion?: number | string;
+}): Promise<T>;
+/** Events of an event handle field, e.g. `{ eventHandle: '0x1::coin::CoinStore<...>', field: 'deposit_events' }`. */
+export declare function getEvents({ chain, account, eventHandle, field, start, limit }: ChainOptions & {
+    account: string;
+    eventHandle: string;
+    field: string;
+    start?: number | string;
+    limit?: number;
+}): Promise<any[]>;
+export declare function getEventsByCreationNumber({ chain, account, creationNumber, start, limit }: ChainOptions & {
+    account: string;
+    creationNumber: number | string;
+    start?: number | string;
+    limit?: number;
+}): Promise<any[]>;
+/**
+ * Block by height; `null` when it does not exist (yet). Heights pruned from the primary are
+ * fetched from the archival endpoint when one is configured, otherwise the 410 error propagates.
+ */
+export declare function getBlockByHeight({ chain, height, withTransactions, archival }: ChainOptions & {
+    height: number | string;
+    withTransactions?: boolean;
+    archival?: boolean;
+}): Promise<AptosBlock | null>;
+/** Block containing ledger version `version`; `null` when unknown. Pruned versions fall back to archival like `getBlockByHeight`. */
+export declare function getBlockByVersion({ chain, version, withTransactions, archival }: ChainOptions & {
+    version: number | string;
+    withTransactions?: boolean;
+    archival?: boolean;
+}): Promise<AptosBlock | null>;
+/** Latest block height + timestamp (seconds) from ledger info; `version` is the latest ledger version. */
+export declare function getLatestBlock({ chain }?: ChainOptions): Promise<{
+    number: number;
+    timestamp: number;
+    version: number;
+}>;
+/**
+ * Binary search over block heights (REST only) for the last block whose timestamp is at or
+ * before `timestamp` (unix seconds). Starts on the primary node; when the target predates the
+ * primary's oldest block the search moves to the archival endpoint (the public aptos fullnode
+ * keeps only a few weeks). Throws when `timestamp` predates all available history.
+ */
+export declare function getBlockAtTimestamp({ chain, timestamp, minBlock }: ChainOptions & {
+    timestamp: number;
+    minBlock?: number;
+}): Promise<AptosBlock>;
+/**
+ * Last ledger version at or before `timestamp` (unix seconds). Every transaction in a block
+ * shares the block timestamp, so this is the `last_version` of the block found by `getBlockAtTimestamp`.
+ */
+export declare function getVersionAtTimestamp({ chain, timestamp, minBlock }: ChainOptions & {
+    timestamp: number;
+    minBlock?: number;
+}): Promise<number>;
+/**
+ * Raw balance of `account` for a coin type (`0x1::aptos_coin::AptosCoin`) or a fungible asset
+ * metadata address. Coins: `CoinStore<T>` resource, falling back to the `0x1::coin::balance` view
+ * (which also counts the paired FA store after a coin -> FA migration). FA: `0x1::primary_fungible_store::balance`.
+ */
+export declare function getBalance({ chain, account, coinType, ledgerVersion }: ChainOptions & {
+    account: string;
+    coinType?: string;
+    ledgerVersion?: number | string;
+}): Promise<string>;
+/**
+ * Token metadata: `0x1::coin::CoinInfo<T>` for coin types, `0x1::fungible_asset::Metadata` for
+ * fungible asset addresses. Throws when the token is unknown.
+ */
+export declare function getCoinInfo({ chain, coinType, ledgerVersion }: ChainOptions & {
+    coinType: string;
+    ledgerVersion?: number | string;
+}): Promise<CoinInfo>;
+/**
+ * Raw total supply of a coin type or fungible asset address. Resolution order (ported from the
+ * server l2 adapter):
+ * 1. `0x1::coin::supply<T>` view: sums the legacy CoinInfo supply and the paired FA supply, which
+ *    matters for coins that migrated to the FA standard (CoinInfo alone undercounts).
+ * 2. `CoinInfo<T>.supply` integer value, or the aggregator table item it points at (native APT).
+ * 3. The paired FA metadata (`0x1::coin::paired_metadata<T>`), then the FA branch.
+ * 4. FA: `0x1::fungible_asset::supply` view -> `ConcurrentSupply` -> `Supply` resource.
+ * Throws when nothing resolves (e.g. coins initialised with `monitor_supply = false`).
+ */
+export declare function getCoinSupply({ chain, coinType, ledgerVersion }: ChainOptions & {
+    coinType: string;
+    ledgerVersion?: number | string;
+}): Promise<string>;
+/** Decode a hex string (with or without `0x`) as UTF-8. */
+export declare function hexToString(hex: string): string;
+/** Octas (1e-8 APT) to APT as a JS number. */
+export declare function octasToApt(octas: string | number | bigint): number;
+/** Fungible asset tokens are identified by an object address (no `::`), coins by `addr::module::Name`. */
+export declare function isFungibleAssetAddress(type: string): boolean;
+/** `0x1` -> `0x0000...0001` (64 hex chars, lowercase). Throws on non-hex input. */
+export declare function normalizeAddress(address: string): string;
+/**
+ * Parse `0x1::coin::CoinInfo<0x1::aptos_coin::AptosCoin>` into address / module / name / generics.
+ * Primitive and vector types (`u64`, `vector<u8>`) parse with an empty address and module.
+ */
+export declare function parseTypeTag(type: string): TypeTag;