@defillama/sdk 5.0.235 → 5.0.238

package/build/chains/aptos.js

@@ -0,0 +1,612 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APT_DECIMALS = exports.APT_COIN_TYPE = exports.aptosChains = exports.ARCHIVAL_ENDPOINTS = exports.DEFAULT_ENDPOINTS = void 0;
+exports.isAptosChain = isAptosChain;
+exports.getEndpointList = getEndpointList;
+exports.getEndpoint = getEndpoint;
+exports.getArchivalEndpointList = getArchivalEndpointList;
+exports.get = get;
+exports.post = post;
+exports.getLedgerInfo = getLedgerInfo;
+exports.getAccount = getAccount;
+exports.getResources = getResources;
+exports.getResource = getResource;
+exports.getAccountModules = getAccountModules;
+exports.getAccountModule = getAccountModule;
+exports.getTableItem = getTableItem;
+exports.view = view;
+exports.getEvents = getEvents;
+exports.getEventsByCreationNumber = getEventsByCreationNumber;
+exports.getBlockByHeight = getBlockByHeight;
+exports.getBlockByVersion = getBlockByVersion;
+exports.getLatestBlock = getLatestBlock;
+exports.getBlockAtTimestamp = getBlockAtTimestamp;
+exports.getVersionAtTimestamp = getVersionAtTimestamp;
+exports.getBalance = getBalance;
+exports.getCoinInfo = getCoinInfo;
+exports.getCoinSupply = getCoinSupply;
+exports.hexToString = hexToString;
+exports.octasToApt = octasToApt;
+exports.isFungibleAssetAddress = isFungibleAssetAddress;
+exports.normalizeAddress = normalizeAddress;
+exports.parseTypeTag = parseTypeTag;
+/**
+ * Aptos-style Move REST client for `aptos` (default) and `move` (Movement).
+ *
+ * Replaces the scattered per-repo helpers:
+ * - DefiLlama-Adapters `projects/helper/chain/aptos.js` (endpointMap, aQuery, getResources with
+ *   `x-aptos-cursor` pagination, getResource, getBalance, getTableData, function_view, hexToString,
+ *   timestampToVersion)
+ * - DefiLlama-Adapters `projects/helper/env.js` (APTOS_RPC / MOVE_RPC defaults)
+ * - defillama-server `defi/l2/utils.ts` (aptosFetch with 404-as-answer, getAptosSupplies resolution chain)
+ * - defillama-server `coins/src/scripts/coingeckoUtils.ts` (CoinInfo metadata lookup)
+ * - peggedassets-server `src/adapters/peggedAssets/helper/aptos.ts` (getTokenSupply FA branches, function_view)
+ * - dimension-adapters `helpers/aptos.ts` (getResources, view, getCoinSupply, octasToApt, getVersionFromTimestamp)
+ *
+ * All endpoints resolve through `rpc.getEndpoints`, so `APTOS_RPC` / `MOVE_RPC` (comma separated
+ * for fallbacks) override the defaults. An optional `<CHAIN>_API_KEY` (e.g. `APTOS_API_KEY`) is sent
+ * as a bearer token. Requests the primary answers with 410 `block_pruned` / `version_pruned` are
+ * retried on the archival endpoint (`<CHAIN>_ARCHIVAL_RPC`, default `archive.mainnet.aptoslabs.com`).
+ * Timestamp -> version lookups use a REST binary search over block heights instead of the
+ * aptoslabs indexer GraphQL API, so they work on any full node and on Movement.
+ *
+ * Usage: `sdk.chains.aptos.getResource({ account: '0x1', type: '0x1::coin::CoinInfo<0x1::aptos_coin::AptosCoin>' })`
+ */
+const axios_1 = __importDefault(require("axios"));
+const env_1 = require("../util/env");
+const debugLog_1 = require("../util/debugLog");
+const rpc_1 = require("./rpc");
+// ---------------------------------------------------------------------------
+// config
+// ---------------------------------------------------------------------------
+exports.DEFAULT_ENDPOINTS = {
+    aptos: 'https://fullnode.mainnet.aptoslabs.com',
+    move: 'https://mainnet.movementnetwork.xyz',
+};
+/**
+ * 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`.
+ */
+exports.ARCHIVAL_ENDPOINTS = {
+    aptos: 'https://archive.mainnet.aptoslabs.com',
+};
+exports.aptosChains = Object.keys(exports.DEFAULT_ENDPOINTS);
+exports.APT_COIN_TYPE = '0x1::aptos_coin::AptosCoin';
+exports.APT_DECIMALS = 8;
+const DEFAULT_TIMEOUT = 30000;
+const RESOURCE_PAGE_SIZE = 9999;
+const MODULE_PAGE_SIZE = 1000;
+const EVENT_PAGE_SIZE = 100;
+function isAptosChain(chain) {
+    return !!chain && exports.aptosChains.includes(chain);
+}
+function resolveChain(chain) {
+    return chain !== null && chain !== void 0 ? chain : 'aptos';
+}
+/** All configured endpoints for the chain (env override first, then defaults). */
+function getEndpointList({ chain } = {}) {
+    chain = resolveChain(chain);
+    return (0, rpc_1.getEndpoints)(chain, exports.DEFAULT_ENDPOINTS[chain]);
+}
+/** First configured endpoint for the chain. */
+function getEndpoint({ chain } = {}) {
+    chain = resolveChain(chain);
+    return (0, rpc_1.getEndpoint)(chain, exports.DEFAULT_ENDPOINTS[chain]);
+}
+/** Archival endpoints for the chain (`<CHAIN>_ARCHIVAL_RPC` env, then built-in); empty when none. */
+function getArchivalEndpointList({ chain } = {}) {
+    chain = resolveChain(chain);
+    try {
+        return (0, rpc_1.getEndpoints)(chain, exports.ARCHIVAL_ENDPOINTS[chain], { envKey: `${chain.toUpperCase()}_ARCHIVAL_RPC` });
+    }
+    catch {
+        return [];
+    }
+}
+function getHeaders(chain) {
+    const headers = { 'Content-Type': 'application/json' };
+    const apiKey = (0, env_1.getEnvValue)(`${chain.toUpperCase()}_API_KEY`);
+    if (apiKey)
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    return headers;
+}
+// ---------------------------------------------------------------------------
+// transport
+// ---------------------------------------------------------------------------
+const NOT_FOUND = Symbol('aptos:not-found');
+function isNotFound(e) {
+    var _a;
+    return ((_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.status) === 404;
+}
+/** 410 `block_pruned` / `version_pruned`: the data exists but this node no longer has it. */
+function isPruned(e) {
+    var _a, _b, _c, _d;
+    if (((_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.status) === 410 || (e === null || e === void 0 ? void 0 : e.status) === 410)
+        return true;
+    const code = String((_d = (_c = (_b = e === null || e === void 0 ? void 0 : e.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.error_code) !== null && _d !== void 0 ? _d : '');
+    return code.includes('pruned');
+}
+/**
+ * Low level request: rotates through the configured endpoints, retries transient
+ * failures, sends the optional bearer key and (when `allowNotFound`) turns a 404 into
+ * `null` before the retry layer sees it (a 404 is a real answer for missing resources).
+ * A 410 "pruned" answer from the primary is retried once against the archival endpoints.
+ */
+async function request(options) {
+    const chain = resolveChain(options.chain);
+    const archivalEndpoints = getArchivalEndpointList({ chain });
+    if (options.archival) {
+        if (!archivalEndpoints.length)
+            throw new Error(`[${chain}] no archival endpoint configured (env ${chain.toUpperCase()}_ARCHIVAL_RPC)`);
+        return requestOn(archivalEndpoints, options);
+    }
+    try {
+        return await requestOn(getEndpointList({ chain }), options);
+    }
+    catch (e) {
+        if (!archivalEndpoints.length || !isPruned(e))
+            throw e;
+        (0, debugLog_1.debugLog)(`[chains.aptos] ${chain} ${options.method.toUpperCase()} ${options.path} pruned on primary, retrying on archival`);
+        return requestOn(archivalEndpoints, options);
+    }
+}
+async function requestOn(endpoints, options) {
+    var _a;
+    const chain = resolveChain(options.chain);
+    const limiter = (0, rpc_1.getLimiter)(chain.toUpperCase(), 10);
+    const { method, path, params, body, allowNotFound, withMetadata, timeout = DEFAULT_TIMEOUT } = options;
+    const headers = getHeaders(chain);
+    const config = { timeout, headers, params };
+    const res = await (0, rpc_1.withRetry)(async (attempt) => {
+        const base = endpoints[attempt % endpoints.length];
+        const url = (0, rpc_1.joinUrl)(base, path);
+        return limiter(async () => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            try {
+                const response = method === 'post'
+                    ? await axios_1.default.post(url, body, config)
+                    : await axios_1.default.get(url, config);
+                return withMetadata ? response : response.data;
+            }
+            catch (e) {
+                if (allowNotFound && isNotFound(e)) {
+                    (0, debugLog_1.debugLog)(`[chains.aptos] ${chain} ${method.toUpperCase()} ${path} -> 404 (treated as not found)`);
+                    return NOT_FOUND;
+                }
+                // keep the error message helpful when the retry layer reformats it
+                const status = (_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.status;
+                const detail = (_g = (_d = (_c = (_b = e === null || e === void 0 ? void 0 : e.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : (_f = (_e = e === null || e === void 0 ? void 0 : e.response) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.error_code) !== null && _g !== void 0 ? _g : e === null || e === void 0 ? void 0 : e.message;
+                const err = new Error(`[${chain}] ${method.toUpperCase()} ${path} failed${status ? ` [${status}]` : ''}: ${String(detail !== null && detail !== void 0 ? detail : '').slice(0, 300)} (${(0, rpc_1.shortUrl)(url)})`);
+                err.response = e === null || e === void 0 ? void 0 : e.response;
+                err.status = status;
+                err.errorCode = (_j = (_h = e === null || e === void 0 ? void 0 : e.response) === null || _h === void 0 ? void 0 : _h.data) === null || _j === void 0 ? void 0 : _j.error_code;
+                err._isCustomError = true; // already formatted: keeps status/errorCode intact through withRetry/formError
+                throw err;
+            }
+        });
+    }, {
+        label: `${chain} ${method.toUpperCase()} ${path.split('?')[0].slice(0, 80)}`,
+        retries: (_a = options.retries) !== null && _a !== void 0 ? _a : Math.max(3, endpoints.length),
+        shouldRetry: rpc_1.isRetryableError,
+    });
+    return res === NOT_FOUND ? null : res;
+}
+function withLedgerVersion(params, ledgerVersion) {
+    if (ledgerVersion === undefined || ledgerVersion === null)
+        return params;
+    return { ...(params !== null && params !== void 0 ? params : {}), ledger_version: String(ledgerVersion) };
+}
+function encodeSegment(value) {
+    return encodeURIComponent(value);
+}
+/** GET `path` (relative to the node root, e.g. `/v1/accounts/0x1`). 404 -> `null` when `allowNotFound`. */
+async function get({ chain, path, params, allowNotFound, timeout, retries, archival }) {
+    return request({ chain, method: 'get', path, params, allowNotFound, timeout, retries, archival });
+}
+/** POST `body` to `path` (relative to the node root, e.g. `/v1/view`). */
+async function post({ chain, path, body, params, allowNotFound, timeout, retries, archival }) {
+    return request({ chain, method: 'post', path, body, params, allowNotFound, timeout, retries, archival });
+}
+// ---------------------------------------------------------------------------
+// ledger / accounts / resources
+// ---------------------------------------------------------------------------
+function microsToSeconds(value) {
+    return Math.floor(Number(value) / 1e6);
+}
+async function getLedgerInfo({ chain, archival } = {}) {
+    const raw = await get({ chain, path: '/v1', archival });
+    return {
+        chainId: Number(raw.chain_id),
+        ledgerVersion: Number(raw.ledger_version),
+        ledgerTimestamp: microsToSeconds(raw.ledger_timestamp),
+        blockHeight: Number(raw.block_height),
+        oldestLedgerVersion: Number(raw.oldest_ledger_version),
+        oldestBlockHeight: Number(raw.oldest_block_height),
+        epoch: Number(raw.epoch),
+        raw,
+    };
+}
+/** `{ sequence_number, authentication_key }` or `null` when the account does not exist. */
+async function getAccount({ chain, address, ledgerVersion }) {
+    return get({ chain, path: `/v1/accounts/${address}`, params: withLedgerVersion(undefined, ledgerVersion), allowNotFound: true });
+}
+function extractPage(data) {
+    if (Array.isArray(data))
+        return data;
+    if (Array.isArray(data === null || data === void 0 ? void 0 : data.resources))
+        return data.resources;
+    if (Array.isArray(data === null || data === void 0 ? void 0 : data.data))
+        return data.data;
+    if (Array.isArray(data === null || data === void 0 ? void 0 : data.items))
+        return data.items;
+    return [];
+}
+async function getPaginated({ chain, path, pageSize, ledgerVersion, label }) {
+    var _a;
+    const items = [];
+    let cursor;
+    let pageLength = 0;
+    do {
+        const params = { limit: pageSize };
+        if (cursor)
+            params.start = cursor;
+        const res = await request({ chain, method: 'get', path, params: withLedgerVersion(params, ledgerVersion), withMetadata: true });
+        const page = extractPage(res === null || res === void 0 ? void 0 : res.data);
+        items.push(...page);
+        pageLength = page.length;
+        cursor = (_a = res === null || res === void 0 ? void 0 : res.headers) === null || _a === void 0 ? void 0 : _a['x-aptos-cursor'];
+        (0, debugLog_1.debugLog)(`[chains.aptos] ${resolveChain(chain)} ${label}: fetched ${pageLength} (total ${items.length})${cursor ? ', more pages' : ''}`);
+    } while (pageLength === pageSize && cursor);
+    return items;
+}
+/** Every resource of `account` (`{ type, data }[]`), following `x-aptos-cursor` pagination. */
+async function getResources({ chain, account, ledgerVersion }) {
+    return getPaginated({ chain, path: `/v1/accounts/${account}/resources`, pageSize: RESOURCE_PAGE_SIZE, ledgerVersion, label: `resources ${account}` });
+}
+/** `data` of one resource, or `null` when the account does not hold it. */
+async function getResource({ chain, account, type, ledgerVersion }) {
+    var _a;
+    const res = await get({ chain, path: `/v1/accounts/${account}/resource/${encodeSegment(type)}`, params: withLedgerVersion(undefined, ledgerVersion), allowNotFound: true });
+    if (res === null || res === undefined)
+        return null;
+    return (_a = res.data) !== null && _a !== void 0 ? _a : null;
+}
+/** Every module published by `account`, following `x-aptos-cursor` pagination. */
+async function getAccountModules({ chain, account, ledgerVersion }) {
+    return getPaginated({ chain, path: `/v1/accounts/${account}/modules`, pageSize: MODULE_PAGE_SIZE, ledgerVersion, label: `modules ${account}` });
+}
+/** Single module ABI/bytecode, or `null` when missing. */
+async function getAccountModule({ chain, account, name, ledgerVersion }) {
+    return get({ chain, path: `/v1/accounts/${account}/module/${encodeSegment(name)}`, params: withLedgerVersion(undefined, ledgerVersion), allowNotFound: true });
+}
+/**
+ * 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).
+ */
+async function getTableItem({ chain, handle, keyType, valueType, key, ledgerVersion, allowNotFound }) {
+    return post({ chain, path: `/v1/tables/${handle}/item`, body: { key_type: keyType, value_type: valueType, key }, params: withLedgerVersion(undefined, ledgerVersion), allowNotFound });
+}
+/** Run a `#[view]` function. Returns the result array as the node encodes it (u64/u128 as strings). */
+async function view({ chain, function: fn, typeArguments = [], args = [], ledgerVersion }) {
+    const res = await post({ chain, path: '/v1/view', body: { function: fn, type_arguments: typeArguments, arguments: args }, params: withLedgerVersion(undefined, ledgerVersion) });
+    return (Array.isArray(res) ? res : [res]);
+}
+// ---------------------------------------------------------------------------
+// events
+// ---------------------------------------------------------------------------
+/** Events of an event handle field, e.g. `{ eventHandle: '0x1::coin::CoinStore<...>', field: 'deposit_events' }`. */
+async function getEvents({ chain, account, eventHandle, field, start, limit = EVENT_PAGE_SIZE }) {
+    const params = { limit };
+    if (start !== undefined)
+        params.start = String(start);
+    const res = await get({ chain, path: `/v1/accounts/${account}/events/${encodeSegment(eventHandle)}/${encodeSegment(field)}`, params });
+    return extractPage(res);
+}
+async function getEventsByCreationNumber({ chain, account, creationNumber, start, limit = EVENT_PAGE_SIZE }) {
+    const params = { limit };
+    if (start !== undefined)
+        params.start = String(start);
+    const res = await get({ chain, path: `/v1/accounts/${account}/events/${creationNumber}`, params });
+    return extractPage(res);
+}
+// ---------------------------------------------------------------------------
+// blocks / time travel
+// ---------------------------------------------------------------------------
+function toBlock(raw) {
+    return {
+        number: Number(raw.block_height),
+        timestamp: microsToSeconds(raw.block_timestamp),
+        hash: raw.block_hash,
+        firstVersion: Number(raw.first_version),
+        lastVersion: Number(raw.last_version),
+        transactions: raw.transactions,
+        raw,
+    };
+}
+/**
+ * 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.
+ */
+async function getBlockByHeight({ chain, height, withTransactions = false, archival }) {
+    const raw = await get({ chain, path: `/v1/blocks/by_height/${height}`, params: { with_transactions: withTransactions }, allowNotFound: true, archival });
+    return raw ? toBlock(raw) : null;
+}
+/** Block containing ledger version `version`; `null` when unknown. Pruned versions fall back to archival like `getBlockByHeight`. */
+async function getBlockByVersion({ chain, version, withTransactions = false, archival }) {
+    const raw = await get({ chain, path: `/v1/blocks/by_version/${version}`, params: { with_transactions: withTransactions }, allowNotFound: true, archival });
+    return raw ? toBlock(raw) : null;
+}
+/** Latest block height + timestamp (seconds) from ledger info; `version` is the latest ledger version. */
+async function getLatestBlock({ chain } = {}) {
+    const info = await getLedgerInfo({ chain });
+    return { number: info.blockHeight, timestamp: info.ledgerTimestamp, version: info.ledgerVersion };
+}
+/**
+ * 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.
+ */
+async function getBlockAtTimestamp({ chain, timestamp, minBlock }) {
+    chain = resolveChain(chain);
+    if (timestamp > 1e12)
+        timestamp = Math.floor(timestamp / 1000); // tolerate milliseconds
+    const hasArchival = getArchivalEndpointList({ chain }).length > 0;
+    let archival = false;
+    let info = await getLedgerInfo({ chain });
+    let lo = Math.max(minBlock !== null && minBlock !== void 0 ? minBlock : 0, info.oldestBlockHeight);
+    let hi = info.blockHeight;
+    const cache = new Map();
+    const fetchBlock = async (height) => {
+        if (!cache.has(height))
+            cache.set(height, await getBlockByHeight({ chain, height, archival }));
+        return cache.get(height);
+    };
+    const latest = await fetchBlock(hi);
+    if (latest && latest.timestamp <= timestamp)
+        return latest;
+    let first = await fetchBlock(lo);
+    if ((!first || first.timestamp > timestamp) && hasArchival) {
+        (0, debugLog_1.debugLog)(`[chains.aptos] ${chain} timestamp ${timestamp} predates primary history (oldest block ${lo}), searching archival`);
+        archival = true;
+        info = await getLedgerInfo({ chain, archival: true });
+        lo = Math.max(minBlock !== null && minBlock !== void 0 ? minBlock : 0, info.oldestBlockHeight);
+        first = await fetchBlock(lo);
+    }
+    if (!first)
+        throw new Error(`[${chain}] block ${lo} is not available on this node`);
+    if (first.timestamp > timestamp)
+        throw new Error(`[${chain}] timestamp ${timestamp} predates available history (oldest block ${lo} at ${first.timestamp})`);
+    // invariant: block(lo).timestamp <= timestamp < block(hi).timestamp
+    let steps = 0;
+    while (hi - lo > 1) {
+        const mid = Math.floor((lo + hi) / 2);
+        const block = await fetchBlock(mid);
+        steps++;
+        if (!block || block.timestamp <= timestamp)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    (0, debugLog_1.debugLog)(`[chains.aptos] ${chain} getBlockAtTimestamp(${timestamp}) -> block ${lo} in ${steps} steps`);
+    const result = await fetchBlock(lo);
+    if (!result)
+        throw new Error(`[${chain}] block ${lo} is not available on this node`);
+    return result;
+}
+/**
+ * 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`.
+ */
+async function getVersionAtTimestamp({ chain, timestamp, minBlock }) {
+    if (timestamp > 1e12)
+        timestamp = Math.floor(timestamp / 1000);
+    const info = await getLedgerInfo({ chain });
+    if (info.ledgerTimestamp <= timestamp)
+        return info.ledgerVersion;
+    const block = await getBlockAtTimestamp({ chain, timestamp, minBlock });
+    return block.lastVersion;
+}
+// ---------------------------------------------------------------------------
+// token helpers
+// ---------------------------------------------------------------------------
+function optionValue(value) {
+    // Move `Option<T>` is encoded as `{ vec: [T] }`
+    if (value && typeof value === 'object' && Array.isArray(value.vec))
+        return value.vec.length ? value.vec[0] : undefined;
+    return value;
+}
+function coinModuleAddress(coinType) {
+    return coinType.substring(0, coinType.indexOf('::'));
+}
+/**
+ * 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`.
+ */
+async function getBalance({ chain, account, coinType = exports.APT_COIN_TYPE, ledgerVersion }) {
+    var _a, _b;
+    if (isFungibleAssetAddress(coinType)) {
+        const [balance] = await view({ chain, function: '0x1::primary_fungible_store::balance', typeArguments: ['0x1::fungible_asset::Metadata'], args: [account, coinType], ledgerVersion });
+        return String(balance !== null && balance !== void 0 ? balance : '0');
+    }
+    const store = await getResource({ chain, account, type: `0x1::coin::CoinStore<${coinType}>`, ledgerVersion });
+    if (((_a = store === null || store === void 0 ? void 0 : store.coin) === null || _a === void 0 ? void 0 : _a.value) !== undefined && ((_b = store === null || store === void 0 ? void 0 : store.coin) === null || _b === void 0 ? void 0 : _b.value) !== null)
+        return String(store.coin.value);
+    const [balance] = await view({ chain, function: '0x1::coin::balance', typeArguments: [coinType], args: [account], ledgerVersion });
+    return String(balance !== null && balance !== void 0 ? balance : '0');
+}
+/**
+ * Token metadata: `0x1::coin::CoinInfo<T>` for coin types, `0x1::fungible_asset::Metadata` for
+ * fungible asset addresses. Throws when the token is unknown.
+ */
+async function getCoinInfo({ chain, coinType, ledgerVersion }) {
+    var _a;
+    chain = resolveChain(chain);
+    if (isFungibleAssetAddress(coinType)) {
+        const data = await getResource({ chain, account: coinType, type: '0x1::fungible_asset::Metadata', ledgerVersion });
+        if (!data)
+            throw new Error(`[${chain}] no fungible asset metadata at ${coinType}`);
+        return { decimals: Number(data.decimals), symbol: data.symbol, name: data.name };
+    }
+    const data = await getResource({ chain, account: coinModuleAddress(coinType), type: `0x1::coin::CoinInfo<${coinType}>`, ledgerVersion });
+    if (!data)
+        throw new Error(`[${chain}] no CoinInfo for ${coinType}`);
+    const info = { decimals: Number(data.decimals), symbol: data.symbol, name: data.name };
+    const integer = optionValue((_a = optionValue(data.supply)) === null || _a === void 0 ? void 0 : _a.integer);
+    if ((integer === null || integer === void 0 ? void 0 : integer.value) !== undefined)
+        info.supply = String(integer.value);
+    return info;
+}
+async function getFungibleAssetSupply({ chain, metadata, ledgerVersion }) {
+    var _a, _b;
+    // 1. view sums both supply variants and is a single request
+    try {
+        const [res] = await view({ chain, function: '0x1::fungible_asset::supply', typeArguments: ['0x1::fungible_asset::Metadata'], args: [metadata], ledgerVersion });
+        const value = optionValue(res);
+        if (value !== undefined && value !== null)
+            return String(value);
+    }
+    catch (e) {
+        (0, debugLog_1.debugLog)(`[chains.aptos] fungible_asset::supply view failed for ${metadata}, falling back to resources: ${e === null || e === void 0 ? void 0 : e.message}`);
+    }
+    // 2. ConcurrentSupply (newer) then Supply resource; a 404 is a real answer here
+    const concurrent = await getResource({ chain, account: metadata, type: '0x1::fungible_asset::ConcurrentSupply', ledgerVersion });
+    if (((_a = concurrent === null || concurrent === void 0 ? void 0 : concurrent.current) === null || _a === void 0 ? void 0 : _a.value) !== undefined && ((_b = concurrent === null || concurrent === void 0 ? void 0 : concurrent.current) === null || _b === void 0 ? void 0 : _b.value) !== null)
+        return String(concurrent.current.value);
+    const supply = await getResource({ chain, account: metadata, type: '0x1::fungible_asset::Supply', ledgerVersion });
+    if ((supply === null || supply === void 0 ? void 0 : supply.current) !== undefined && (supply === null || supply === void 0 ? void 0 : supply.current) !== null)
+        return String(supply.current);
+    return null;
+}
+/**
+ * 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`).
+ */
+async function getCoinSupply({ chain, coinType, ledgerVersion }) {
+    var _a;
+    chain = resolveChain(chain);
+    let metadata;
+    if (!isFungibleAssetAddress(coinType)) {
+        try {
+            const [res] = await view({ chain, function: '0x1::coin::supply', typeArguments: [coinType], ledgerVersion });
+            const value = optionValue(res);
+            if (value !== undefined && value !== null)
+                return String(value);
+        }
+        catch (e) {
+            (0, debugLog_1.debugLog)(`[chains.aptos] coin::supply view failed for ${coinType}, falling back to CoinInfo: ${e === null || e === void 0 ? void 0 : e.message}`);
+        }
+        const info = await getResource({ chain, account: coinModuleAddress(coinType), type: `0x1::coin::CoinInfo<${coinType}>`, ledgerVersion });
+        const supply = optionValue(info === null || info === void 0 ? void 0 : info.supply);
+        const integer = optionValue(supply === null || supply === void 0 ? void 0 : supply.integer);
+        if ((integer === null || integer === void 0 ? void 0 : integer.value) !== undefined && (integer === null || integer === void 0 ? void 0 : integer.value) !== null)
+            return String(integer.value);
+        const aggregator = optionValue(supply === null || supply === void 0 ? void 0 : supply.aggregator);
+        if (aggregator === null || aggregator === void 0 ? void 0 : aggregator.handle) {
+            const item = await getTableItem({ chain, handle: aggregator.handle, keyType: 'address', valueType: 'u128', key: aggregator.key, ledgerVersion, allowNotFound: true });
+            if (typeof item === 'string' || typeof item === 'number')
+                return String(item);
+        }
+        try {
+            const [paired] = await view({ chain, function: '0x1::coin::paired_metadata', typeArguments: [coinType], ledgerVersion });
+            metadata = (_a = optionValue(paired)) === null || _a === void 0 ? void 0 : _a.inner;
+        }
+        catch (e) {
+            (0, debugLog_1.debugLog)(`[chains.aptos] coin::paired_metadata view failed for ${coinType}: ${e === null || e === void 0 ? void 0 : e.message}`);
+        }
+        if (!metadata)
+            throw new Error(`[${chain}] could not resolve supply for ${coinType}`);
+    }
+    else {
+        metadata = coinType;
+    }
+    const faSupply = await getFungibleAssetSupply({ chain, metadata, ledgerVersion });
+    if (faSupply === null)
+        throw new Error(`[${chain}] could not resolve supply for ${coinType}`);
+    return faSupply;
+}
+// ---------------------------------------------------------------------------
+// pure helpers
+// ---------------------------------------------------------------------------
+/** Decode a hex string (with or without `0x`) as UTF-8. */
+function hexToString(hex) {
+    if (typeof hex !== 'string')
+        return '';
+    let clean = hex.startsWith('0x') || hex.startsWith('0X') ? hex.slice(2) : hex;
+    if (clean.length % 2)
+        clean = '0' + clean;
+    return Buffer.from(clean, 'hex').toString('utf8');
+}
+/** Octas (1e-8 APT) to APT as a JS number. */
+function octasToApt(octas) {
+    return Number(octas) / Math.pow(10, exports.APT_DECIMALS);
+}
+/** Fungible asset tokens are identified by an object address (no `::`), coins by `addr::module::Name`. */
+function isFungibleAssetAddress(type) {
+    return typeof type === 'string' && !type.includes('::');
+}
+/** `0x1` -> `0x0000...0001` (64 hex chars, lowercase). Throws on non-hex input. */
+function normalizeAddress(address) {
+    if (typeof address !== 'string')
+        throw new Error(`Invalid aptos address: ${address}`);
+    let hex = address.trim();
+    if (hex.startsWith('0x') || hex.startsWith('0X'))
+        hex = hex.slice(2);
+    hex = hex.toLowerCase();
+    if (!hex.length || hex.length > 64 || !/^[0-9a-f]+$/.test(hex))
+        throw new Error(`Invalid aptos address: ${address}`);
+    return '0x' + hex.padStart(64, '0');
+}
+/** Depth-aware split of generic arguments: `A<B, C>, D` -> `['A<B, C>', 'D']`. */
+function splitTypeArgs(inner) {
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of inner) {
+        if (ch === '<')
+            depth++;
+        else if (ch === '>')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts;
+}
+/**
+ * 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.
+ */
+function parseTypeTag(type) {
+    const raw = type.trim();
+    const open = raw.indexOf('<');
+    let head = raw;
+    let typeArgs = [];
+    if (open !== -1) {
+        if (!raw.endsWith('>'))
+            throw new Error(`Invalid type tag: ${type}`);
+        head = raw.slice(0, open).trim();
+        typeArgs = splitTypeArgs(raw.slice(open + 1, -1));
+    }
+    const parts = head.split('::');
+    if (parts.length === 1)
+        return { raw, address: '', module: '', name: parts[0], typeArgs, isStruct: false };
+    if (parts.length !== 3 || parts.some(p => !p))
+        throw new Error(`Invalid type tag: ${type}`);
+    return { raw, address: parts[0], module: parts[1], name: parts[2], typeArgs, isStruct: true };
+}