@defillama/sdk 5.0.235 → 5.0.238

package/build/ChainApi.d.ts

@@ -112,7 +112,29 @@ export declare class ChainApi {
     }>;
     getLogs(params: GetLogsOptions): Promise<any[] | import("ethers").EventLog[] | import("ethers").EventLog[][]>;
     getBalancesV2(): Balances;
-    getTransactions(params: GetTransactionOptions): Promise<any>;
+    getTransactions(params: GetTransactionOptions): Promise<{
+        hash: any;
+        blockNumber: number;
+        transactionIndex: number;
+        from: any;
+        to: any;
+        value: any;
+        gasPrice: any;
+        gas: any;
+        input: any;
+        nonce: number;
+        data: any;
+        type: any;
+        maxFeePerGas: any;
+        maxPriorityFeePerGas: any;
+        baseFeePerGas: any;
+        effectiveGasPrice: any;
+        gasUsed: any;
+        cumulativeGasUsed: any;
+        status: number;
+        contractCreated: any;
+        timestamp: any;
+    }[] | null>;
     getTransactionReceipt(tx: string): Promise<import("ethers").TransactionReceipt | null>;
     getStats(): DebugStats;
 }

package/build/ChainApi.js

@@ -17,6 +17,15 @@ const logs_1 = __importDefault(require("./util/logs"));
 const transactions_1 = require("./util/transactions");
 const callStatsByProject = {};
 const nullAddress = '0x0000000000000000000000000000000000000000';
+// ERC-20 views of the native coin: balanceOf returns the same balance as eth_getBalance, so when summing
+// they are read as the native coin and deduped per owner, otherwise listing both counts the coin twice
+const nativeTokenAliases = {
+    polygon: '0x0000000000000000000000000000000000001010', // POL (MRC20)
+    celo: '0x471ece3750da237f93b8e339c536989b8978a438', // CELO (GoldToken)
+    metis: '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000', // METIS
+    arc: '0x3600000000000000000000000000000000000000', // USDC (6 decimals, native is 18)
+    stable: '0x779ded0c9e1022225f8e0630b35a9b54be713736', // USDT0 (6 decimals, native is 18)
+};
 class ChainApi {
     constructor(params) {
         var _a, _b;
@@ -197,6 +206,10 @@ class ChainApi {
         blacklistedOwners = (0, common_1.getUniqueAddresses)(blacklistedOwners, this.chain);
         blacklistedTokens = (0, common_1.getUniqueAddresses)(blacklistedTokens, this.chain);
         tokensAndOwners = tokensAndOwners.filter(i => !blacklistedTokens.includes(i[0]) && !blacklistedOwners.includes(i[1]));
+        // only when summing: plain balance lookups expect the alias's own (ERC-20 decimals) value back
+        const nativeAlias = nativeTokenAliases[this.chain];
+        if (skipDuplicates && nativeAlias)
+            tokensAndOwners = getUniqueTokensAndOwners(tokensAndOwners.map(([t, o]) => [t === nativeAlias ? nullAddress : t, o]), this.chain);
         const tokenBalances = [];
         const erc20TokensResponseIndex = [];
         const ethBalanceResponseIndex = [];

package/build/abi/tron.js

@@ -65,7 +65,13 @@ async function getBalance(params) {
         throw new Error('getBalance: target is required');
     const data = await limitRPCCalls(() => {
         if (!balanceCache[params.target])
-            balanceCache[params.target] = post({ address: params.target, visible: true, }, '/wallet/getaccount');
+            // drop the entry if the request fails, otherwise the rejected promise is served to every
+            // later call for this address and the process never retries it
+            balanceCache[params.target] = post({ address: params.target, visible: true, }, '/wallet/getaccount')
+                .catch((e) => {
+                delete balanceCache[params.target];
+                throw e;
+            });
         return balanceCache[params.target];
     });
     const frozenBalance = (_b = (_a = data.frozen) === null || _a === void 0 ? void 0 : _a.reduce((t, { frozen_balance }) => t + frozen_balance, 0)) !== null && _b !== void 0 ? _b : 0;

package/build/chains/algorand.d.ts

@@ -0,0 +1,277 @@
+export declare const DEFAULT_INDEXER = "https://mainnet-idx.algonode.cloud";
+export declare const DEFAULT_ALGOD = "https://mainnet-api.algonode.cloud";
+/** Indexer endpoint list: `ALGORAND_INDEXER` env (comma separated) or the default. */
+export declare function getIndexerEndpoints(): string[];
+/** First indexer endpoint. */
+export declare function getIndexerEndpoint(): string;
+/** Algod endpoint list: `ALGORAND_RPC` env (comma separated) or the default. */
+export declare function getAlgodEndpoints(): string[];
+/** First algod endpoint. */
+export declare function getAlgodEndpoint(): string;
+export type AlgoAmount = number | string;
+export interface GlobalStateEntry {
+    key: string;
+    value: {
+        type: number;
+        bytes?: string;
+        uint?: AlgoAmount;
+    };
+}
+export interface AlgorandApplication {
+    id: number;
+    'created-at-round'?: number;
+    deleted?: boolean;
+    params: {
+        creator: string;
+        'global-state'?: GlobalStateEntry[];
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface AlgorandAssetHolding {
+    'asset-id': AlgoAmount;
+    amount: AlgoAmount;
+    'is-frozen'?: boolean;
+    [key: string]: any;
+}
+export interface AlgorandAccount {
+    address: string;
+    amount: AlgoAmount;
+    assets?: AlgorandAssetHolding[];
+    'created-apps'?: AlgorandApplication[];
+    round?: number;
+    status?: string;
+    [key: string]: any;
+}
+/** `getAccountInfo` result: the indexer account with string asset ids and an `assetMapping` index. */
+export interface AlgorandAccountInfo extends AlgorandAccount {
+    assets: AlgorandAssetHolding[];
+    /** holdings keyed by asset id (string); the native ALGO balance is also exposed under the pseudo id '1' */
+    assetMapping: {
+        [assetId: string]: AlgorandAssetHolding;
+    };
+}
+export interface AlgorandAssetParams {
+    creator: string;
+    decimals: number;
+    total: AlgoAmount;
+    name?: string;
+    'unit-name'?: string;
+    reserve?: string;
+    manager?: string;
+    freeze?: string;
+    clawback?: string;
+    url?: string;
+    'default-frozen'?: boolean;
+    [key: string]: any;
+}
+/** `getAssetInfo` result: asset params flattened next to the asset metadata (`id`, `created-at-round`, ...) */
+export interface AlgorandAssetInfo extends AlgorandAssetParams {
+    id: number;
+    params: AlgorandAssetParams;
+    'created-at-round'?: number;
+    deleted?: boolean;
+}
+export interface AlgorandAssetSupply {
+    total: string;
+    decimals: number;
+    reserve: string | undefined;
+    /** total minus the reserve account's holding (equals total when there is no reserve) */
+    circulating: string;
+}
+export interface AlgorandBox {
+    name: string;
+    value: string;
+    round?: number;
+}
+export interface AlgorandBlock {
+    round: number;
+    timestamp: number;
+    [key: string]: any;
+}
+export interface BlockRef {
+    number: number;
+    timestamp: number;
+}
+export type GlobalStateValue = number | string;
+export type DecodedGlobalState = {
+    [key: string]: GlobalStateValue;
+};
+/**
+ * JSON.parse that keeps integers too large for a JS number as decimal strings.
+ * Only integer literals outside of strings that fail `Number.isSafeInteger` are quoted.
+ */
+export declare function parseJsonSafe(text: string): any;
+/** Raw GET against the indexer (`/v2/...`), parsed with the uint64-safe parser. */
+export declare function indexerGet({ path, params }: {
+    path: string;
+    params?: Record<string, any>;
+}): Promise<any>;
+/** Raw GET against algod (`/v2/...`), parsed with the uint64-safe parser. */
+export declare function algodGet({ path, params }: {
+    path: string;
+    params?: Record<string, any>;
+}): Promise<any>;
+/** `/v2/applications/{appId}` -> the `application` object (id, params, global-state, ...) */
+export declare function lookupApplication({ appId }: {
+    appId: number | string;
+}): Promise<AlgorandApplication>;
+/**
+ * `/v2/accounts/{address}` -> the `account` object. `includeAll` also returns closed-out / deleted holdings.
+ * Resolves to `undefined` when the indexer has never seen the account (404).
+ */
+export declare function lookupAccount({ address, includeAll, params }: {
+    address: string;
+    includeAll?: boolean;
+    params?: Record<string, any>;
+}): Promise<AlgorandAccount | undefined>;
+/**
+ * Account with holdings indexed by asset id. Memoised per process (same address -> same promise), like the
+ * adapters helper it replaces. A numeric `address` is treated as an application id and resolved to its escrow address.
+ * The ALGO balance is added to `assets` / `assetMapping` under the pseudo asset id '1'.
+ */
+export declare function getAccountInfo({ address }: {
+    address: string | number;
+}): Promise<AlgorandAccountInfo>;
+/** Drop the memoised `getAccountInfo` entries (all, or one address). */
+export declare function clearAccountInfoCache(address?: string): void;
+export interface SearchAccountsOptions {
+    /** only accounts opted into this application */
+    appId?: number | string;
+    /** only accounts holding this asset */
+    assetId?: number | string;
+    limit?: number;
+    nextToken?: string;
+    /** extra indexer query params (`currency-greater-than`, `include-all`, `exclude`, ...) */
+    params?: Record<string, any>;
+}
+/** `/v2/accounts` search, one page -> `{ accounts, 'next-token', 'current-round' }` */
+export declare function searchAccounts({ appId, assetId, limit, nextToken, params }: SearchAccountsOptions): Promise<{
+    accounts: AlgorandAccount[];
+    'next-token'?: string;
+    [key: string]: any;
+}>;
+/** All pages of `searchAccounts`. `onPage` is called with every page as it arrives. */
+export declare function searchAccountsAll({ appId, assetId, limit, params, onPage }: Omit<SearchAccountsOptions, 'nextToken'> & {
+    onPage?: (accounts: AlgorandAccount[], page: number) => void | Promise<void>;
+}): Promise<AlgorandAccount[]>;
+/** `/v2/accounts/{address}/created-applications` -> `{ applications, 'next-token', ... }` */
+export declare function lookupApplicationsCreatedByAccount({ address, params }: {
+    address: string;
+    params?: Record<string, any>;
+}): Promise<{
+    applications: AlgorandApplication[];
+    [key: string]: any;
+}>;
+/** `/v2/assets/{assetId}` -> asset params (total, decimals, reserve, unit-name, ...) flattened with the asset metadata. */
+export declare function getAssetInfo({ assetId }: {
+    assetId: number | string;
+}): Promise<AlgorandAssetInfo>;
+/** Amount of `assetId` held by `address` as a base-unit string; '0' when the account is not opted in or unknown. */
+export declare function getAssetBalance({ address, assetId }: {
+    address: string;
+    assetId: number | string;
+}): Promise<string>;
+/** Native ALGO balance of `address` in microalgos as a string; '0' for unknown accounts. */
+export declare function getAlgoBalance({ address }: {
+    address: string;
+}): Promise<string>;
+/**
+ * Supply figures for an ASA, all in base units. `circulating` is `total` minus the reserve account's holding,
+ * which is how Algorand issuers (USDC, USDt, ...) signal the un-issued part of a fixed total.
+ */
+export declare function getAssetSupply({ assetId }: {
+    assetId: number | string;
+}): Promise<AlgorandAssetSupply>;
+/** Global state key: base64 -> utf8 string. */
+export declare function decodeGlobalStateKey(b64: string): string;
+/**
+ * Global state value: uint (type 2) -> number (or decimal string when above 2^53), bytes (type 1) -> base64
+ * string as delivered by the indexer. Use `bytesAsAddress` / `bytesAsUint64s` / `bytesAsUtf8` to interpret bytes.
+ */
+export declare function decodeGlobalStateValue(value: GlobalStateEntry['value']): GlobalStateValue;
+/** Decode an indexer `global-state` (or `local-state`) key/value list into a plain object. */
+export declare function decodeGlobalState(entries?: GlobalStateEntry[]): DecodedGlobalState;
+/** Decoded global state of an application: `{ [utf8 key]: number | string }`. */
+export declare function getAppGlobalState({ appId }: {
+    appId: number | string;
+}): Promise<DecodedGlobalState>;
+/** Interpret a 32 byte base64 state value as an Algorand address. */
+export declare function bytesAsAddress(b64: string): string;
+/** Interpret a base64 state value as consecutive big-endian uint64s (packed structs used by Folks, Tinyman, ...). */
+export declare function bytesAsUint64s(b64: string): bigint[];
+/** Interpret a base64 state value as utf8 text. */
+export declare function bytesAsUtf8(b64: string): string;
+/** `/v2/applications/{appId}/boxes`, one page -> `{ boxes: [{ name }], 'next-token' }` */
+export declare function getApplicationBoxes({ appId, limit, nextToken }: {
+    appId: number | string;
+    limit?: number;
+    nextToken?: string;
+}): Promise<{
+    boxes: {
+        name: string;
+    }[];
+    'next-token'?: string;
+    [key: string]: any;
+}>;
+/** All box names of an application (base64 encoded). */
+export declare function getApplicationBoxesAll({ appId, limit }: {
+    appId: number | string;
+    limit?: number;
+}): Promise<{
+    name: string;
+}[]>;
+/**
+ * Encode a box name for the `name` query param. Strings already prefixed with `b64:` / `str:` / `int:` are passed
+ * through, raw bytes are base64 encoded, plain strings are sent as `str:`.
+ */
+export declare function encodeBoxName(name: string | Uint8Array): string;
+/** `/v2/applications/{appId}/box?name=...` -> `{ name, value, round }` (base64 encoded name/value). */
+export declare function getApplicationBox({ appId, name }: {
+    appId: number | string;
+    name: string | Uint8Array;
+}): Promise<AlgorandBox>;
+/** `/v2/transactions` search with raw indexer params (`address`, `asset-id`, `min-round`, `after-time`, `next`, ...). */
+export declare function lookupTransactions({ params }?: {
+    params?: Record<string, any>;
+}): Promise<{
+    transactions: any[];
+    'next-token'?: string;
+    [key: string]: any;
+}>;
+/** `/v2/blocks/{round}` -> block header (round, timestamp, transactions, ...) */
+export declare function getBlock({ round }: {
+    round: number;
+}): Promise<AlgorandBlock>;
+/** Latest round the indexer has ingested (from `/health`) with its timestamp. */
+export declare function getLatestBlock(): Promise<BlockRef>;
+/**
+ * First block whose timestamp is >= `timestamp` (unix seconds). Fast path: the first transaction after that time
+ * (indexer `after-time`); falls back to a binary search over block headers.
+ */
+export declare function getBlockAtTimestamp({ timestamp }: {
+    timestamp: number;
+}): Promise<BlockRef>;
+/** RFC 4648 base32 with `=` padding. */
+export declare function base32Encode(bytes: Uint8Array): string;
+/** RFC 4648 base32 decode; padding optional, case insensitive, throws on invalid characters. */
+export declare function base32Decode(str: string): Uint8Array;
+/** SHA-512/256 digest (Algorand's "genericHash"). */
+export declare function sha512_256(bytes: Uint8Array | Buffer): Uint8Array;
+export declare function concatArrays(...arrs: Uint8Array[]): Uint8Array;
+/** 32 byte public key -> 58 char address (base32 of key + 4 byte sha512/256 checksum, padding stripped). */
+export declare function encodeAddress(publicKey: Uint8Array): string;
+/**
+ * 58 char address -> `{ publicKey, checksum }`; throws when the length, the checksum or the
+ * encoding is wrong. Like algosdk, only the canonical upper-case base32 form is accepted: the
+ * last character carries 2 padding bits that must be zero, so re-encoding must reproduce the input.
+ */
+export declare function decodeAddress(address: string): {
+    publicKey: Uint8Array;
+    checksum: Uint8Array;
+};
+export declare function isValidAddress(address: string): boolean;
+/** Big-endian 8 byte encoding of an unsigned 64-bit integer. */
+export declare function encodeUint64(num: number | bigint | string): Uint8Array;
+/** Escrow address of an application: encodeAddress(sha512_256("appID" || uint64(appId))). */
+export declare function getApplicationAddress(appId: number | bigint | string): string;