@defillama/sdk 5.0.198 → 5.0.204

package/build/ChainApi.d.ts

@@ -111,6 +111,7 @@ export declare class ChainApi {
     getBalancesV2(): Balances;
     getTransactions(params: GetTransactionOptions): Promise<any>;
     getTransactionReceipt(tx: string): Promise<import("ethers").TransactionReceipt | null>;
+    getStats(): DebugStats;
 }
 export default ChainApi;
 export declare function getDebugStats(): Record<string, DebugStats>;

package/build/ChainApi.js

@@ -29,7 +29,7 @@ class ChainApi {
         this.chainId = (_b = providers_json_1.default[this.chain]) === null || _b === void 0 ? void 0 : _b.chainId;
         this.storedKey = params.storedKey;
         this.api = this;
-        const uKey = `${params.protocol}:${this.storedKey}`;
+        const uKey = this.storedKey ? `${params.protocol}:${this.storedKey}` : (params.protocol ? `${params.protocol}` : `chain-${this.chain}`);
         const stats = {
             meta: {
                 chain: this.chain,
@@ -98,7 +98,8 @@ class ChainApi {
         });
     }
     async getBlock() {
-        this.addStat('getBlock');
+        if (!this.block)
+            this.addStat('getBlock');
         if (!this.block)
             this.block = await (0, blocks_1.getBlockNumber)(this.chain, this.timestamp);
         return this.block;
@@ -277,6 +278,9 @@ class ChainApi {
         this.addStat('getTransactionReceipt');
         return this.provider.getTransactionReceipt(tx);
     }
+    getStats() {
+        return this.stats;
+    }
 }
 exports.ChainApi = ChainApi;
 exports.default = ChainApi;

package/build/abi/abi2.js

@@ -39,8 +39,10 @@ exports.fetchList = fetchList;
 exports.bytecodeCall = bytecodeCall;
 const abi1 = __importStar(require("./index"));
 async function call(params) {
+    if (params.abis)
+        return callWithAlternateAbis();
     try {
-        const response = await abi1.call(params);
+        const response = await abi1.call(params); // abi v1 doesnt have support for 'abis' param
         if (params.field)
             response.output = response.output[params.field];
         if (params.withMetadata)
@@ -54,10 +56,25 @@ async function call(params) {
             return { success: false, error: e };
         return null;
     }
+    async function callWithAlternateAbis() {
+        const { abis, ...restParams } = params;
+        if (!abis || abis.length === 0)
+            throw new Error('No alternate ABIs provided!');
+        for (let i = 0; i < abis.length - 1; i++) {
+            const res = await call({ ...restParams, abi: abis[i], permitFailure: true, withMetadata: true });
+            const response = params.withMetadata ? res : res.output;
+            if (res.success)
+                return response;
+        }
+        const lastAbi = abis[abis.length - 1];
+        return call({ ...restParams, abi: lastAbi, });
+    }
 }
 async function multiCall(params) {
     if (params.excludeFailed)
         params.permitFailure = true;
+    if (params.abis)
+        return multiCallWithAlternateAbis();
     params.calls = params.calls.map(i => {
         if (typeof i === 'object')
             return i;
@@ -76,6 +93,40 @@ async function multiCall(params) {
     if (params.withMetadata)
         return output;
     return output.map((i) => i.output);
+    async function multiCallWithAlternateAbis() {
+        const { abis, ...restParams } = params;
+        if (!abis || abis.length === 0)
+            throw new Error('No alternate ABIs provided!');
+        const outputs = [];
+        for (let i = 0; i < abis.length; i++) {
+            const res = await multiCall({ ...restParams, abi: abis[i], permitFailure: true, withMetadata: true, excludeFailed: false, });
+            outputs.push(res);
+        }
+        let finalOutput;
+        const permitFailure = params.permitFailure || params.excludeFailed;
+        outputs.forEach((res) => {
+            if (!finalOutput) { // First iteration
+                finalOutput = res;
+                return;
+            }
+            res.forEach((callRes, idx) => {
+                var _a;
+                if ((_a = finalOutput[idx]) === null || _a === void 0 ? void 0 : _a.success)
+                    return; // Already succeeded with an earlier ABI
+                finalOutput[idx] = callRes;
+            });
+        });
+        if (!permitFailure)
+            finalOutput.forEach((data) => {
+                if (!(data === null || data === void 0 ? void 0 : data.success))
+                    throw new Error(`All ABI alternatives failed for multiCall! Last error: ${data === null || data === void 0 ? void 0 : data.error}`);
+            });
+        if (params.excludeFailed)
+            finalOutput = finalOutput.filter((i) => i === null || i === void 0 ? void 0 : i.success);
+        if (params.withMetadata)
+            return finalOutput;
+        return finalOutput.map((i) => i.output);
+    }
 }
 async function fetchList(params) {
     // itemAbi2 is used when we need to make a second call to get the final result

package/build/abi/index.js

@@ -84,6 +84,8 @@ function isValidTarget(target, chain) {
 }
 async function call(params) {
     var _a;
+    if (!params.abi)
+        throw new Error('Missing ABI parameter ("abis" is supported only in abi2/ChainApi)!');
     if (params.chain === 'tron')
         (0, common_1.fixTronCallParams)(params);
     if (!isValidTarget(params.target, params.chain))
@@ -145,6 +147,8 @@ async function bytecodeCall(params) {
 }
 async function multiCall(params) {
     var _a;
+    if (!params.abi)
+        throw new Error('Missing ABI parameter ("abis" is supported only in abi2/ChainApi)!');
     fixBlockTag(params);
     if (params.chain === 'tron')
         (0, common_1.fixTronCallParams)(params);

package/build/abi/multicall3.js

@@ -206,6 +206,7 @@ const DEPLOYMENT_BLOCK = {
     doma: 1,
     capx: 30800,
     stable: 2423647,
+    megaeth: 1858081,
 };
 async function makeMultiCall(functionABI, calls, chain, block) {
     if (!functionABI)