@defillama/sdk 5.0.234 → 5.0.236

package/build/chains/cosmos.d.ts

@@ -0,0 +1,252 @@
+import { Endpoints } from "./rpc";
+/** Default LCD endpoints. Comma separated values are fallbacks, tried in order. */
+export declare const DEFAULT_ENDPOINTS: Record<string, string>;
+/**
+ * Module-specific REST prefix used by `queryV1Beta1` (e.g. `/osmosis/gamm/...`,
+ * `/kava/hard/...`). Standard sdk modules (bank, staking, ...) always live under
+ * `/cosmos/`, use `query` / `getBalances` / `totalSupply` for those.
+ */
+export declare const chainSubpaths: Record<string, string>;
+/** Some contract calls need an endpoint with a higher gas limit. contract address -> endpoint */
+export declare const highGasLimitEndpoints: Record<string, string>;
+/**
+ * Cosmos chains that also expose an EVM JSON-RPC. For these `<CHAIN>_RPC` is the
+ * EVM url and is never used as LCD, and `isCosmosChain` stays false so block
+ * lookups keep going through the EVM provider (same as before this module).
+ */
+export declare const EVM_COSMOS_CHAINS: string[];
+/**
+ * Chains always treated as cosmos chains by `isCosmosChain` (legacy list from
+ * util/cosmos.ts plus the pure cosmos chains of the adapters map).
+ */
+export declare const ibcChains: string[];
+/** bech32 human readable prefix per chain (falls back to the chain name) */
+export declare const BECH32_PREFIXES: Record<string, string>;
+export declare const isCosmosChain: (chain: string) => boolean;
+/** Resolve the LCD endpoint list for a chain, see the module header for the order. */
+export declare function getEndpoints({ chain }: {
+    chain: string;
+}): string[];
+/** First LCD endpoint. `contract` switches to a high gas limit endpoint when one is configured for it. */
+export declare function getEndpoint({ chain, contract }: {
+    chain: string;
+    contract?: string;
+}): string;
+/** base64 encode a cosmwasm query message (objects are JSON.stringified first) */
+export declare function encodeQuery(data: any): string;
+/**
+ * Heuristic: cosmwasm contract addresses are 32 byte bech32 strings (~63 chars)
+ * while accounts are 20 bytes (~43 chars).
+ */
+export declare function isContractAddress(chain: string, address: string): boolean;
+/** Cosmos block times carry nanosecond precision; trim to millis before parsing. */
+export declare function parseBlockTime(iso: string): number;
+/**
+ * Explicit "this height is pruned / does not exist" answers from a node. A bare 404
+ * is NOT enough: LCDs also answer 404 for routes they do not serve (older chains
+ * without `/cosmos/base/tendermint/v1beta1`), and that case must fall back to the
+ * legacy `/blocks/{h}` route instead of being reported as a pruned block.
+ */
+export declare function isPrunedHeightError(e: any): boolean;
+export interface QueryOptions {
+    chain: string;
+    /** path relative to the LCD root, e.g. `cosmos/bank/v1beta1/supply` */
+    path: string;
+    /** height for historical state, sent as `x-cosmos-block-height` */
+    block?: number | string;
+    /** query string params */
+    params?: Record<string, any>;
+    /** explicit endpoint(s), overrides chain resolution */
+    endpoint?: Endpoints;
+    /** used to pick a high gas limit endpoint */
+    contract?: string;
+    timeout?: number;
+    retries?: number;
+}
+/** GET `<lcd>/<path>`; rotates over the chain endpoints on failure. Returns the raw JSON body. */
+export declare function query({ chain, path, block, params, endpoint, contract, timeout, retries }: QueryOptions): Promise<any>;
+/**
+ * GET `<lcd>/<subpath>/<url>` where subpath is `chainSubpaths[chain]` or `cosmos`
+ * (module specific queries such as `gamm/v1beta1/pools` on osmosis).
+ */
+export declare function queryV1Beta1({ chain, url, block, paginationKey, subpath, endpoint }: {
+    chain: string;
+    url: string;
+    block?: number | string;
+    paginationKey?: string;
+    subpath?: string;
+    endpoint?: Endpoints;
+}): Promise<any>;
+/**
+ * Follow `pagination.next_key` over `path` and return the concatenated `dataKey`
+ * items. When `dataKey` is omitted the first array field of the response is used.
+ */
+export declare function paginate({ chain, path, dataKey, limit, block, endpoint }: {
+    chain: string;
+    path: string;
+    dataKey?: string;
+    limit?: number;
+    block?: number | string;
+    endpoint?: Endpoints;
+}): Promise<any[]>;
+/** Auto-paginating `queryV1Beta1`; returns the concatenated `dataKey` items. */
+export declare function queryV1Beta1All({ chain, url, dataKey, limit, block, subpath, endpoint }: {
+    chain: string;
+    url: string;
+    dataKey?: string;
+    limit?: number;
+    block?: number | string;
+    subpath?: string;
+    endpoint?: Endpoints;
+}): Promise<any[]>;
+export interface Coin {
+    denom: string;
+    amount: string;
+}
+/** All native balances of `owner` (every page). */
+export declare function getBalances({ chain, owner, block }: {
+    chain: string;
+    owner: string;
+    block?: number | string;
+}): Promise<Coin[]>;
+/** Native balance of one denom, `"0"` when the account does not hold it. */
+export declare function getDenomBalance({ chain, denom, owner, block }: {
+    chain: string;
+    denom: string;
+    owner: string;
+    block?: number | string;
+}): Promise<string>;
+/** Balance of a cw20 contract (`token` looks like a contract address) or a native denom. */
+export declare function getBalance({ chain, token, owner, block }: {
+    chain: string;
+    token: string;
+    owner: string;
+    block?: number | string;
+}): Promise<string>;
+/** Balance for an astroport style asset info (`{ native_token: { denom } }` / `{ token: { contract_addr } }`) or a plain string. */
+export declare function getTokenBalance({ chain, token, owner, block }: {
+    chain: string;
+    token: any;
+    owner: string;
+    block?: number | string;
+}): Promise<string>;
+/** Total supply of a native denom via `bank/v1beta1/supply/by_denom`. */
+export declare function totalSupply({ chain, denom, block }: {
+    chain: string;
+    denom: string;
+    block?: number | string;
+}): Promise<string>;
+/** Total supply of every denom (all pages). */
+export declare function getSupplyAll({ chain, block }: {
+    chain: string;
+    block?: number | string;
+}): Promise<Coin[]>;
+/** cosmwasm smart query; `data` is the query message (object or JSON string). Returns the `data` field. */
+export declare function queryContract({ chain, contract, data, block, endpoint }: {
+    chain: string;
+    contract: string;
+    data: any;
+    block?: number | string;
+    endpoint?: Endpoints;
+}): Promise<any>;
+/** Same as `queryContract`; every configured endpoint is tried before giving up. */
+export declare function queryContractWithRetries({ chain, contract, data, block }: {
+    chain: string;
+    contract: string;
+    data: any;
+    block?: number | string;
+}): Promise<any>;
+/** Run the same smart query against many contracts. Results keep the input order; failures resolve to `undefined` when `permitFailure` is set. */
+export declare function queryManyContracts({ chain, contracts, data, block, permitFailure, concurrency }: {
+    chain: string;
+    contracts: string[];
+    data: any;
+    block?: number | string;
+    permitFailure?: boolean;
+    concurrency?: number;
+}): Promise<any[]>;
+/** All contract addresses instantiated from `codeId` (all pages). */
+export declare function queryContracts({ chain, codeId, limit }: {
+    chain: string;
+    codeId: number | string;
+    limit?: number;
+}): Promise<string[]>;
+/** Legacy (terra classic) `/wasm/contracts/{contract}/store?query_msg=` query. Returns the `result` field. */
+export declare function queryContractStore({ chain, contract, queryParam, block }: {
+    chain: string;
+    contract: string;
+    queryParam: any;
+    block?: number | string;
+}): Promise<any>;
+/** `/cosmwasm/wasm/v1/contract/{contract}` -> `contract_info` (code_id, creator, admin, label, ...). */
+export declare function getContractInfo({ chain, contract }: {
+    chain: string;
+    contract: string;
+}): Promise<any>;
+/** cw20 `token_info` -> { name, symbol, decimals, total_supply } */
+export declare function getTokenInfo({ chain, contract, block }: {
+    chain: string;
+    contract: string;
+    block?: number | string;
+}): Promise<{
+    name: string;
+    symbol: string;
+    decimals: number;
+    total_supply: string;
+}>;
+/** cw20 `minter` -> minter address (the pair contract for LP tokens) */
+export declare function getLpMinter({ chain, token, block }: {
+    chain: string;
+    token: string;
+    block?: number | string;
+}): Promise<string>;
+export interface CosmosBlock {
+    number: number;
+    timestamp: number;
+}
+/** Block header via `/cosmos/base/tendermint/v1beta1/blocks/{h}`, falling back to the legacy `/blocks/{h}` route. */
+export declare function getBlock({ chain, height }: {
+    chain: string;
+    height?: number | string;
+}): Promise<CosmosBlock>;
+export declare function getLatestBlock({ chain }: {
+    chain: string;
+}): Promise<CosmosBlock>;
+/** Block time in seconds, `null` when the height is pruned / unavailable. Cached per chain. */
+export declare function getBlockTime({ chain, height }: {
+    chain: string;
+    height: number;
+}): Promise<number | null>;
+/**
+ * Largest height whose block time is <= `timestamp` (binary search over block
+ * headers, pruned heights count as "too old"). Throws when every retained block is
+ * newer than `timestamp`.
+ */
+export declare function getBlockAtTimestamp({ chain, timestamp }: {
+    chain: string;
+    timestamp: number;
+}): Promise<CosmosBlock>;
+export declare function getCosmosBlock(block?: number | string, chain?: string): Promise<CosmosBlock>;
+export declare function getCosmosProvider(chain: string): {
+    getBlock: (block?: number | string) => Promise<CosmosBlock>;
+};
+export declare const tendermint: {
+    /** `<CHAIN>_TENDERMINT_RPC`, then `https://rpc.cosmos.directory/<chain>` */
+    getEndpoints({ chain }: {
+        chain: string;
+    }): string[];
+    /** JSON-RPC `status` -> { node_info, sync_info: { latest_block_height, latest_block_time, earliest_block_height, ... } } */
+    getStatus({ chain }: {
+        chain: string;
+    }): Promise<any>;
+    /** JSON-RPC `block` -> { block_id, block: { header, data, ... } } (latest when height is omitted) */
+    getTendermintBlock({ chain, height }: {
+        chain: string;
+        height?: number | string;
+    }): Promise<any>;
+    /** `{ number, timestamp }` from the tendermint `block` call */
+    getBlock({ chain, height }: {
+        chain: string;
+        height?: number | string;
+    }): Promise<CosmosBlock>;
+};