@defillama/sdk 5.0.73 → 5.0.76

package/build/ChainApi.d.ts

@@ -3,6 +3,14 @@ import Balances from "./Balances";
 import { Chain } from "./general";
 import { Provider } from "ethers";
 import { GetLogsOptions } from "./util/logs";
+type Erc4626SumOptions = {
+    calls: string[];
+    tokenAbi?: string;
+    balanceAbi?: string;
+    balanceCalls?: any[];
+    permitFailure?: boolean;
+    isOG4626?: boolean;
+};
 export declare class ChainApi {
     block?: Block;
     chain: Chain | string;
@@ -21,7 +29,7 @@ export declare class ChainApi {
     call(params: CallOptions): Promise<any>;
     batchCall(params: CallOptions[]): Promise<any[]>;
     multiCall(params: MulticallOptions): Promise<any[]>;
-    fetchList(params: FetchListOptions): Promise<any[]>;
+    fetchList(params: FetchListOptions): Promise<any>;
     bytecodeCall(params: ByteCodeCallOptions): Promise<any>;
     getBlock(): Promise<number>;
     log(...args: any): void;
@@ -44,14 +52,8 @@ export declare class ChainApi {
     removeTokenBalance(token: string): void;
     deleteToken(token: string): void;
     deleteTokens(tokens: string[]): void;
-    erc4626Sum({ calls, tokenAbi, balanceAbi, balanceCalls, permitFailure, isOG4626 }: {
-        calls: string[];
-        tokenAbi?: string;
-        balanceAbi?: string;
-        balanceCalls?: any[];
-        permitFailure?: boolean;
-        isOG4626?: boolean;
-    }): Promise<BalancesV1>;
+    erc4626Sum2(options: Erc4626SumOptions): Promise<BalancesV1>;
+    erc4626Sum({ calls, tokenAbi, balanceAbi, balanceCalls, permitFailure, isOG4626 }: Erc4626SumOptions): Promise<BalancesV1>;
     sumTokens({ token, tokens, owners, owner, tokensAndOwners, tokensAndOwners2, blacklistedTokens, blacklistedOwners, ownerTokens, }: {
         token?: string;
         tokens?: string[];

package/build/ChainApi.js

@@ -106,11 +106,20 @@ class ChainApi {
     deleteTokens(tokens) {
         tokens.forEach(i => this.deleteToken(i));
     }
-    async erc4626Sum({ calls, tokenAbi = 'address:token', balanceAbi = 'uint256:balance', balanceCalls, permitFailure = false, isOG4626 = false }) {
-        if (isOG4626) {
+    async erc4626Sum2(options) {
+        if (options.isOG4626 !== false)
+            options.isOG4626 = true;
+        return this.erc4626Sum(options);
+    }
+    async erc4626Sum({ calls, tokenAbi, balanceAbi, balanceCalls, permitFailure = false, isOG4626 = false }) {
+        if (isOG4626 && !tokenAbi && !balanceAbi) {
             tokenAbi = 'asset';
             balanceAbi = 'totalAssets';
         }
+        if (!tokenAbi)
+            tokenAbi = 'address:token';
+        if (!balanceAbi)
+            balanceAbi = 'uint256:balance';
         if (typeof tokenAbi === 'string' && (!tokenAbi.includes(':') && !tokenAbi.includes('(')))
             tokenAbi = `address:${tokenAbi}`;
         if (typeof balanceAbi === 'string' && (!balanceAbi.includes(':') && !balanceAbi.includes('(')))

package/build/abi/abi2.d.ts

@@ -1,5 +1,5 @@
 import { CallOptions, MulticallOptions, FetchListOptions, ByteCodeCallOptions } from "../types";
 export declare function call(params: CallOptions): Promise<any>;
 export declare function multiCall(params: MulticallOptions): Promise<any[]>;
-export declare function fetchList(params: FetchListOptions): Promise<any[]>;
+export declare function fetchList(params: FetchListOptions): Promise<any>;
 export declare function bytecodeCall(params: ByteCodeCallOptions): Promise<any>;

package/build/abi/abi2.js

@@ -27,13 +27,26 @@ exports.bytecodeCall = exports.fetchList = exports.multiCall = exports.call = vo
 const abi1 = __importStar(require("./index"));
 const debugLog_1 = require("../util/debugLog");
 async function call(params) {
-    const response = await abi1.call(params);
-    if (params.withMetadata)
-        return response;
-    return response.output;
+    try {
+        const response = await abi1.call(params);
+        if (params.field)
+            response.output = response.output[params.field];
+        if (params.withMetadata)
+            return response;
+        return response.output;
+    }
+    catch (e) {
+        if (!params.permitFailure)
+            throw e;
+        if (params.withMetadata)
+            return { success: false, error: e };
+        return null;
+    }
 }
 exports.call = call;
 async function multiCall(params) {
+    if (params.excludeFailed)
+        params.permitFailure = true;
     params.calls = params.calls.map(i => {
         if (typeof i === 'object')
             return i;
@@ -44,33 +57,94 @@ async function multiCall(params) {
         }
         return { params: i };
     });
-    const { output } = await abi1.multiCall(params);
+    let { output } = await abi1.multiCall(params);
+    if (params.excludeFailed)
+        output = output.filter((i) => i.success);
+    if (params.field)
+        output = output.forEach((i) => i.output = i.output[params.field]);
     if (params.withMetadata)
         return output;
     return output.map((i) => i.output);
 }
 exports.multiCall = multiCall;
 async function fetchList(params) {
-    let { startFrom = 0, lengthAbi, itemAbi, withMetadata, startFromOne = false, itemCount, ...commonParams } = params;
+    // itemAbi2 is used when we need to make a second call to get the final result
+    let { startFrom = 0, lengthAbi, itemAbi, withMetadata, startFromOne = false, itemCount, target, targets, calls: _targets, chain, block, permitFailure, groupedByInput, excludeFailed, itemAbi2, field, field2, } = params;
+    if (!targets)
+        targets = _targets;
+    const _groupedByInputOrignal = groupedByInput;
+    if (targets && itemAbi2)
+        groupedByInput = true;
+    permitFailure = permitFailure || excludeFailed;
+    if (excludeFailed && groupedByInput)
+        throw new Error('excludeFailed and groupedByInput cannot be used together!');
+    if (withMetadata && groupedByInput)
+        throw new Error('withMetadata and groupedByInput cannot be used together!');
     if (typeof lengthAbi === 'string' && (!lengthAbi.includes(':') && !lengthAbi.includes('(')))
         lengthAbi = `uint256:${lengthAbi}`;
     if (typeof itemAbi === 'string' && (!itemAbi.includes(':') && !itemAbi.includes('(')))
         itemAbi = `function ${itemAbi}(uint256) view returns (address)`;
-    let itemLength;
+    let itemLength, itemLengths;
+    const calls = [];
+    if (!target && !targets)
+        throw new Error('Need to provide either target or targets parameter!');
+    if (target) {
+        if (itemCount)
+            itemLength = itemCount;
+        else
+            itemLength = await call({ chain, block, target, abi: lengthAbi, });
+        (0, debugLog_1.debugLog)('length: ', itemLength);
+        if (startFromOne) {
+            itemLength++;
+            if (startFrom === 0)
+                startFrom = 1;
+        }
+        for (let i = startFrom; i < itemLength; i++)
+            calls.push({ target, params: [i] });
+        const response = await multiCall({ chain, block, permitFailure, abi: itemAbi, calls, withMetadata, excludeFailed, field, });
+        if (!itemAbi2)
+            return response;
+        return multiCall({ chain, block, target, permitFailure, abi: itemAbi2, calls: response, withMetadata, excludeFailed, field: field2, });
+    }
     if (itemCount)
-        itemLength = itemCount;
+        itemLengths = targets.map(() => itemCount);
     else
-        itemLength = await call({ ...commonParams, abi: lengthAbi, });
-    (0, debugLog_1.debugLog)('length: ', itemLength);
-    if (startFromOne) {
-        itemLength++;
-        if (startFrom === 0)
-            startFrom = 1;
+        itemLengths = await multiCall({ chain, block, calls: targets, abi: lengthAbi, });
+    (0, debugLog_1.debugLog)('itemLengths: ', itemLengths);
+    let groupedByRes = itemLengths.map(() => []);
+    const indexToTargetMapping = {};
+    let k = 0;
+    for (let i = 0; i < itemLengths.length; i++) {
+        let itemLength = itemLengths[i];
+        if (startFromOne) {
+            itemLength++;
+            if (startFrom === 0)
+                startFrom = 1;
+        }
+        for (let j = startFrom; j < itemLength; j++) {
+            calls.push({ target: targets[i], params: [j] });
+            indexToTargetMapping[k] = i;
+            k++;
+        }
     }
-    const calls = [];
-    for (let i = startFrom; i < itemLength; i++)
-        calls.push(i);
-    return multiCall({ ...commonParams, abi: itemAbi, calls, withMetadata });
+    const res = await multiCall({ chain, block, permitFailure, abi: itemAbi, calls, withMetadata, excludeFailed, field, });
+    if (!groupedByInput)
+        return res;
+    res.forEach((i, idx) => groupedByRes[indexToTargetMapping[idx]].push(i));
+    if (!itemAbi2)
+        return groupedByRes;
+    const calls2 = [];
+    for (let i = 0; i < targets.length; i++) {
+        for (let j = 0; j < groupedByRes[i].length; j++) {
+            calls2.push({ target: targets[i], params: groupedByRes[i][j] });
+        }
+    }
+    const res2 = await multiCall({ chain, block, permitFailure, abi: itemAbi2, calls: calls2, withMetadata, excludeFailed, field: field2, });
+    if (!_groupedByInputOrignal)
+        return res2;
+    groupedByRes = itemLengths.map(() => []);
+    res2.forEach((i, idx) => groupedByRes[indexToTargetMapping[idx]].push(i));
+    return groupedByRes;
 }
 exports.fetchList = fetchList;
 async function bytecodeCall(params) {

package/build/abi/multicall3.js

@@ -144,6 +144,7 @@ const DEPLOYMENT_BLOCK = {
     sei: 79351444,
     aura: 6731307,
     conflux: 97705330,
+    etlk: 1,
 };
 async function makeMultiCall(functionABI, calls, chain, block) {
     if (chain === 'tron')