@defillama/sdk 5.0.149 → 5.0.151

package/build/Balances.d.ts

@@ -1,30 +1,32 @@
 import { Balances as BalancesV1 } from "./types";
 import { Chain } from "./general";
+type BalancesOptions = {
+    skipChain?: boolean;
+    label?: string;
+};
+type BalancesOptionsWithLabel = BalancesOptions | string;
 export declare class Balances {
     chain: Chain | string;
     timestamp?: number;
     _balances: BalancesV1;
+    _breakdownBalances: {
+        [key: string]: Balances;
+    };
     constructor(params: {
         chain?: Chain | string;
         timestamp?: number;
     });
-    _add(token: string, balance: any, { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    add(token: string | string[], balance: any, { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    addToken(token: string, balance: any, { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    addGasToken(balance: any): void;
-    addCGToken(token: string, balance: any): void;
-    addTokenVannila(token: string, balance: any): void;
-    addUSDValue(balance: any): void;
-    addTokens(tokens: string[], balances: any[], { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    addBalances(balances: BalancesV1 | Balances): void;
+    _add(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    add(token: string | string[] | Balances, balance?: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addToken(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addGasToken(balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addCGToken(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addTokenVannila(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addUSDValue(balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addTokens(tokens: string[], balances: any[], optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addBalances(balances: BalancesV1 | Balances, optionsOrLabel?: BalancesOptionsWithLabel, options?: (BalancesOptions & {
+        skipBreakdown?: boolean;
+    })): void;
     getBalances(): BalancesV1;
     removeTokenBalance(token: string): void;
     getUSDValue(): Promise<number>;
@@ -46,11 +48,16 @@ export declare class Balances {
         usdTokenBalances: BalancesV1;
         rawTokenBalances: BalancesV1;
     }>;
-    clone(ratio?: number): Balances;
-    subtract(balances: BalancesV1 | Balances): void;
-    subtractToken(token: string, balance: any, { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
+    clone(ratio?: number, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): Balances;
+    subtract(balances: BalancesV1 | Balances, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    subtractToken(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
     removeNegativeBalances(): void;
+    _breakdownBalancesAction(action: string, args?: any[]): Promise<{
+        [key: string]: any;
+    }>;
+    hasBreakdownBalances(): boolean;
+    getBreakdownBalances(): {
+        [key: string]: Balances;
+    };
 }
 export default Balances;

package/build/Balances.js

@@ -7,14 +7,36 @@ exports.Balances = void 0;
 const generalUtil_1 = require("./generalUtil");
 const computeTVL_1 = __importDefault(require("./util/computeTVL"));
 const nullAddress = '0x0000000000000000000000000000000000000000';
+// the last parameter of add function can be either a string or an object with options (or both as last two parameters)
+function getOptions({ optionsOrLabel = {}, options = {} } = {}) {
+    var _a;
+    let label;
+    if (optionsOrLabel) {
+        if (typeof optionsOrLabel === 'string') {
+            label = optionsOrLabel;
+        }
+        else {
+            options = optionsOrLabel;
+            label = options.label;
+        }
+    }
+    return {
+        ...options,
+        skipChain: (_a = options === null || options === void 0 ? void 0 : options.skipChain) !== null && _a !== void 0 ? _a : false,
+        label,
+    };
+}
 class Balances {
     constructor(params) {
         var _a;
         this.chain = (_a = params.chain) !== null && _a !== void 0 ? _a : 'ethereum';
         this.timestamp = params.timestamp;
         this._balances = {};
+        this._breakdownBalances = {};
     }
-    _add(token, balance, { skipChain = false } = {}) {
+    _add(token, balance, optionsOrLabel, options) {
+        var _a;
+        const { label, skipChain } = getOptions({ optionsOrLabel, options });
         token = token.replace(/\//g, ':');
         const isIBCToken = token.startsWith('ibc:');
         let chain = this.chain;
@@ -30,59 +52,88 @@ class Balances {
             token = token.replace('0x', '0x0');
         }
         (0, generalUtil_1.sumSingleBalance)(this._balances, token, balance, chain);
+        if (label) {
+            this._breakdownBalances[label] = (_a = this._breakdownBalances[label]) !== null && _a !== void 0 ? _a : new Balances({ chain: this.chain, timestamp: this.timestamp });
+            this._breakdownBalances[label]._add(token, balance, { skipChain });
+        }
     }
-    add(token, balance, { skipChain = false } = {}) {
+    add(token, balance, optionsOrLabel, options) {
+        if (token instanceof Balances) {
+            if (typeof optionsOrLabel === 'string')
+                throw new Error('When adding a Balances instance, optionsOrLabel must be an object with options, not a string');
+            this.addBalances(token, balance, optionsOrLabel);
+            return;
+        }
+        options = getOptions({ optionsOrLabel, options });
         if (!token)
             throw new Error('token is required');
         if (!balance)
             return;
         if (Array.isArray(balance)) {
             if (Array.isArray(token)) {
-                this.addTokens(token, balance, { skipChain });
+                this.addTokens(token, balance, options);
                 return;
             }
             else if (typeof token === 'string') {
-                balance.forEach((v) => this._add(token, v, { skipChain }));
+                balance.forEach((v) => this._add(token, v, options));
                 return;
             }
         }
         if (typeof token !== 'string')
             throw new Error('token must be a string');
-        this._add(token, balance, { skipChain });
+        this._add(token, balance, options);
     }
-    addToken(token, balance, { skipChain = false } = {}) {
-        this._add(token, balance, { skipChain });
+    addToken(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(token, balance, options);
     }
-    addGasToken(balance) {
-        this._add(nullAddress, balance);
+    addGasToken(balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(nullAddress, balance, options);
     }
-    addCGToken(token, balance) {
-        this.addTokenVannila('coingecko:' + token, balance);
+    addCGToken(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this.addTokenVannila('coingecko:' + token, balance, options);
     }
-    addTokenVannila(token, balance) {
-        this._add(token, balance, { skipChain: true });
+    addTokenVannila(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(token, balance, { ...options, skipChain: true });
     }
-    addUSDValue(balance) {
-        this.addCGToken('tether', balance);
+    addUSDValue(balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this.addCGToken('tether', balance, { ...options, skipChain: true });
     }
-    addTokens(tokens, balances, { skipChain = false } = {}) {
+    addTokens(tokens, balances, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
         if (!Array.isArray(tokens))
             throw new Error('tokens must be an array');
         if (!Array.isArray(balances))
             throw new Error('balances must be an array');
         if (tokens.length !== balances.length)
             throw new Error('token and balance must have the same length');
-        tokens.forEach((v, i) => this._add(v, balances[i], { skipChain }));
+        tokens.forEach((v, i) => this._add(v, balances[i], options));
     }
-    addBalances(balances) {
+    addBalances(balances, optionsOrLabel, options) {
+        var _a;
+        options = getOptions({ optionsOrLabel, options });
         if (balances instanceof Balances) {
             if (balances === this)
                 return;
+            // if balances object has breakdown by label, and overall label is not set, we copy existing breakdown balances into this instance
+            if (balances.hasBreakdownBalances() && !options.skipBreakdown && !options.label) {
+                this._breakdownBalances = (_a = this._breakdownBalances) !== null && _a !== void 0 ? _a : {};
+                const { label, ...restOptions } = options;
+                Object.entries(balances.getBreakdownBalances()).forEach(([label, breakdown]) => {
+                    var _a;
+                    this._breakdownBalances[label] = (_a = this._breakdownBalances[label]) !== null && _a !== void 0 ? _a : new Balances({ chain: this.chain, timestamp: this.timestamp });
+                    this._breakdownBalances[label].addBalances(breakdown, restOptions);
+                });
+            }
             balances = balances.getBalances();
         }
         if (balances === this._balances)
             return;
-        Object.entries(balances).forEach(([token, balance]) => this._add(token, balance, { skipChain: true }));
+        Object.entries(balances).forEach(([token, balance]) => this._add(token, balance, { ...options, skipChain: true }));
     }
     getBalances() {
         return this._balances;
@@ -93,6 +144,7 @@ class Balances {
             if (regex.test(i))
                 delete this._balances[i];
         });
+        this._breakdownBalancesAction('removeTokenBalance', [token]);
     }
     async getUSDValue() {
         const { usdTvl } = await (0, computeTVL_1.default)(this.getBalances(), this.timestamp);
@@ -109,6 +161,7 @@ class Balances {
         Object.keys(this._balances).forEach((token) => {
             this._balances[token] = Number(this._balances[token]) * ratio;
         });
+        this._breakdownBalancesAction('resizeBy', [ratio]);
         return this;
     }
     static async getUSDValue(balances, timestamp) {
@@ -124,31 +177,58 @@ class Balances {
         const { usdTvl, usdTokenBalances } = await (0, computeTVL_1.default)(balances, timestamp);
         return { usdTvl, usdTokenBalances, rawTokenBalances: balances };
     }
-    clone(ratio = 1) {
+    clone(ratio = 1, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
         const newBalances = new Balances({ chain: this.chain, timestamp: this.timestamp });
-        newBalances.addBalances(this);
+        newBalances.addBalances(this, options);
         if (ratio !== 1)
             newBalances.resizeBy(ratio);
         return newBalances;
     }
-    subtract(balances) {
+    subtract(balances, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
         if (balances instanceof Balances) {
             if (balances === this)
                 return;
             balances = balances.getBalances();
         }
         Object.entries(balances).forEach(([token, balance]) => {
-            this._add(token, Number(balance) * -1, { skipChain: true });
+            this._add(token, Number(balance) * -1, { skipChain: true, label: options.label });
         });
     }
-    subtractToken(token, balance, { skipChain = false } = {}) {
-        this._add(token, Number(balance) * -1, { skipChain });
+    subtractToken(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(token, Number(balance) * -1, options);
     }
     removeNegativeBalances() {
         Object.keys(this._balances).forEach((token) => {
             if (Number(this._balances[token]) <= 0)
                 delete this._balances[token];
         });
+        if (this._breakdownBalances) {
+            Object.values(this._breakdownBalances).forEach((breakdown) => breakdown.removeNegativeBalances());
+        }
+    }
+    async _breakdownBalancesAction(action, args = []) {
+        if (!this._breakdownBalances)
+            return {};
+        const response = {};
+        const entries = Object.entries(this._breakdownBalances);
+        for (const [label, breakdown] of entries) {
+            if (typeof breakdown[action] === 'function') {
+                response[label] = breakdown[action](...args);
+                if (response[label] instanceof Promise) {
+                    response[label] = await response[label];
+                }
+            }
+        }
+        return response;
+    }
+    hasBreakdownBalances() {
+        return Object.keys(this._breakdownBalances).length > 0;
+    }
+    getBreakdownBalances() {
+        return this._breakdownBalances;
     }
 }
 exports.Balances = Balances;

package/build/ChainApi.d.ts

@@ -12,6 +12,14 @@ type Erc4626SumOptions = {
     permitFailure?: boolean;
     isOG4626?: boolean;
 };
+type DebugStats = {
+    total: number;
+    [key: string]: any;
+};
+type BalancesV2Options = {
+    skipChain?: boolean;
+    label?: string;
+};
 export declare class ChainApi {
     block?: Block;
     chain: Chain | string;
@@ -20,13 +28,16 @@ export declare class ChainApi {
     provider: Provider;
     _balances: Balances;
     storedKey?: string;
+    stats: DebugStats;
     api: ChainApi;
     constructor(params: {
         block?: Block;
         chain?: Chain | string;
         storedKey?: string;
         timestamp?: number;
+        protocol?: string;
     });
+    addStat(method: string, value?: any, skipTotal?: boolean): void;
     call(params: CallOptions): Promise<any>;
     batchCall(params: CallOptions[]): Promise<any[]>;
     multiCall(params: MulticallOptions): Promise<any[]>;
@@ -35,20 +46,14 @@ export declare class ChainApi {
     getBlock(): Promise<number>;
     log(...args: any): void;
     logTable(...args: any): void;
-    add(token: any, balance: any, { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    addToken(token: string, balance: any, { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    addGasToken(balance: any): void;
-    addUSDValue(balance: any): void;
-    addTokens(tokens: string[], balances: any[], { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    addBalances(balances: Balances | BalancesV1): void;
-    addCGToken(token: string, balance: any): void;
-    addTokenVannila(token: string, balance: any): void;
+    add(token: any, balance: any, options?: BalancesV2Options): void;
+    addToken(token: string, balance: any, options?: BalancesV2Options): void;
+    addGasToken(balance: any, options?: BalancesV2Options): void;
+    addUSDValue(balance: any, options?: BalancesV2Options): void;
+    addTokens(tokens: string[], balances: any[], options?: BalancesV2Options): void;
+    addBalances(balances: Balances | BalancesV1, options?: BalancesV2Options): void;
+    addCGToken(token: string, balance: any, options?: BalancesV2Options): void;
+    addTokenVannila(token: string, balance: any, options?: BalancesV2Options): void;
     getBalances(): BalancesV1;
     getChainId(): number | undefined;
     removeTokenBalance(token: string): void;
@@ -56,7 +61,7 @@ export declare class ChainApi {
     deleteTokens(tokens: string[]): void;
     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, }: {
+    sumTokens({ token, tokens, owners, owner, tokensAndOwners, tokensAndOwners2, blacklistedTokens, blacklistedOwners, ownerTokens, balancesV2Options, }: {
         token?: string;
         tokens?: string[];
         owner?: string;
@@ -66,6 +71,7 @@ export declare class ChainApi {
         ownerTokens?: any[];
         blacklistedTokens?: string[];
         blacklistedOwners?: string[];
+        balancesV2Options?: BalancesV2Options;
     }): Promise<BalancesV1>;
     getUSDValue(): Promise<number>;
     getUSDString(): Promise<string>;
@@ -80,3 +86,4 @@ export declare class ChainApi {
     getTransactionReceipt(tx: string): Promise<import("ethers").TransactionReceipt | null>;
 }
 export default ChainApi;
+export declare function getDebugStats(): Record<string, DebugStats>;

package/build/ChainApi.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChainApi = void 0;
+exports.getDebugStats = exports.ChainApi = void 0;
 const abi2_1 = require("./abi/abi2");
 const Balances_1 = __importDefault(require("./Balances"));
 const blocks_1 = require("./computeTVL/blocks");
@@ -15,6 +15,7 @@ const generalUtil_1 = require("./generalUtil");
 const debugLog_1 = require("./util/debugLog");
 const logs_1 = __importDefault(require("./util/logs"));
 const transactions_1 = require("./util/transactions");
+const callStatsByProject = {};
 const nullAddress = '0x0000000000000000000000000000000000000000';
 class ChainApi {
     constructor(params) {
@@ -28,8 +29,28 @@ 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 stats = {
+            meta: {
+                chain: this.chain,
+                storedKey: this.storedKey,
+                protocol: params.protocol,
+            },
+            label: uKey,
+            total: 0,
+        };
+        callStatsByProject[uKey] = stats;
+        this.stats = stats;
+    }
+    addStat(method, value = 1, skipTotal = false) {
+        if (!skipTotal)
+            this.stats.total += value;
+        if (!this.stats[method])
+            this.stats[method] = 0;
+        this.stats[method] += value;
     }
     call(params) {
+        this.addStat('call');
         return (0, abi2_1.call)({
             ...params,
             block: this.block,
@@ -40,6 +61,8 @@ class ChainApi {
         return Promise.all(params.map(i => this.call(i)));
     }
     multiCall(params) {
+        this.addStat('multiCall', params.calls.length, true);
+        this.addStat('call');
         return (0, abi2_1.multiCall)({
             ...params,
             block: this.block,
@@ -47,6 +70,7 @@ class ChainApi {
         });
     }
     fetchList(params) {
+        this.addStat('fetchList');
         return (0, abi2_1.fetchList)({
             ...params,
             block: this.block,
@@ -61,6 +85,7 @@ class ChainApi {
         });
     }
     async getBlock() {
+        this.addStat('getBlock');
         if (!this.block)
             this.block = await (0, blocks_1.getBlockNumber)(this.chain, this.timestamp);
         return this.block;
@@ -71,29 +96,29 @@ class ChainApi {
     logTable(...args) {
         (0, debugLog_1.debugTable)(...args);
     }
-    add(token, balance, { skipChain = false } = {}) {
-        this._balances.add(token, balance, { skipChain });
+    add(token, balance, options = {}) {
+        this._balances.add(token, balance, options);
     }
-    addToken(token, balance, { skipChain = false } = {}) {
-        this.add(token, balance, { skipChain });
+    addToken(token, balance, options = {}) {
+        this.add(token, balance, options);
     }
-    addGasToken(balance) {
-        this.add(nullAddress, balance);
+    addGasToken(balance, options = {}) {
+        this.add(nullAddress, balance, options);
     }
-    addUSDValue(balance) {
-        this._balances.addUSDValue(balance);
+    addUSDValue(balance, options = {}) {
+        this._balances.addUSDValue(balance, options);
     }
-    addTokens(tokens, balances, { skipChain = false } = {}) {
-        this.add(tokens, balances, { skipChain });
+    addTokens(tokens, balances, options = {}) {
+        this.add(tokens, balances, options);
     }
-    addBalances(balances) {
-        this._balances.addBalances(balances);
+    addBalances(balances, options = {}) {
+        this._balances.addBalances(balances, options);
     }
-    addCGToken(token, balance) {
-        this._balances.addCGToken(token, balance);
+    addCGToken(token, balance, options = {}) {
+        this._balances.addCGToken(token, balance, options);
     }
-    addTokenVannila(token, balance) {
-        this._balances.addTokenVannila(token, balance);
+    addTokenVannila(token, balance, options = {}) {
+        this._balances.addTokenVannila(token, balance, options);
     }
     getBalances() {
         return this._balances.getBalances();
@@ -139,7 +164,7 @@ class ChainApi {
             });
         return this.getBalances();
     }
-    async sumTokens({ token, tokens = [], owners = [], owner, tokensAndOwners = [], tokensAndOwners2 = [], blacklistedTokens = [], blacklistedOwners = [], ownerTokens = [], }) {
+    async sumTokens({ token, tokens = [], owners = [], owner, tokensAndOwners = [], tokensAndOwners2 = [], blacklistedTokens = [], blacklistedOwners = [], ownerTokens = [], balancesV2Options = {}, }) {
         if (tokensAndOwners2.length)
             tokensAndOwners.push(...tokensAndOwners2[0].map((i, j) => [i, tokensAndOwners2[1][j]]));
         if (token)
@@ -157,11 +182,12 @@ class ChainApi {
         tokensAndOwners = tokensAndOwners.filter(i => !blacklistedTokens.includes(i[0]) && !blacklistedOwners.includes(i[1]));
         const ethBalOwners = tokensAndOwners.filter(i => i[0] === nullAddress).map(i => i[1]);
         tokensAndOwners = tokensAndOwners.filter(i => i[0] !== nullAddress);
+        this.addStat('sumTokens', tokensAndOwners.length + ethBalOwners.length, true);
         const bals = await this.multiCall({
             calls: tokensAndOwners.map(i => ({ target: i[0], params: [i[1]] })),
             abi: 'erc20:balanceOf',
         });
-        this.addTokens(tokensAndOwners.map(i => i[0]), bals);
+        this.addTokens(tokensAndOwners.map(i => i[0]), bals, balancesV2Options);
         if (ethBalOwners.length) {
             let ethBals = [];
             const multicallAddress = (0, multicall3_1.getMulticallAddress)(this.chain, this.block);
@@ -176,7 +202,7 @@ class ChainApi {
                 const res = await (0, eth_1.getBalances)({ chain: this.chain, targets: ethBalOwners, block: this.block });
                 ethBals = res.output.map((i) => i.balance);
             }
-            ethBals.map(i => this.addToken(nullAddress, i));
+            ethBals.map(i => this.addToken(nullAddress, i, balancesV2Options));
         }
         return this.getBalances();
     }
@@ -190,6 +216,8 @@ class ChainApi {
         return this._balances.getUSDJSONs();
     }
     async getLogs(params) {
+        var _a;
+        this.addStat('getLogs', ((_a = params.targets) === null || _a === void 0 ? void 0 : _a.length) || 1);
         params.chain = this.chain;
         return (0, logs_1.default)(params);
     }
@@ -197,9 +225,11 @@ class ChainApi {
         return this._balances;
     }
     async getTransactions(params) {
+        this.addStat('getTransactions');
         return (0, transactions_1.getTransactions)({ ...params, chain: this.chain });
     }
     async getTransactionReceipt(tx) {
+        this.addStat('getTransactionReceipt');
         return this.provider.getTransactionReceipt(tx);
     }
 }
@@ -212,3 +242,7 @@ function getUniqueTokensAndOwners(toa, chain) {
     const uniqueMerged = (0, generalUtil_1.getUniqueAddresses)(mergedToa, chain);
     return uniqueMerged.map(i => i.split('~'));
 }
+function getDebugStats() {
+    return callStatsByProject;
+}
+exports.getDebugStats = getDebugStats;

package/build/abi/multicall3.js

@@ -201,6 +201,12 @@ const DEPLOYMENT_BLOCK = {
     lens: 1,
     basecamp: 1,
     platon: 1,
+    xrplevm: 1,
+    katana: 1,
+    mint: 1,
+    btnx: 1,
+    vechain: 22103870,
+    tac: 1,
 };
 async function makeMultiCall(functionABI, calls, chain, block) {
     if (chain === 'tron')
@@ -344,6 +350,12 @@ function getMulticallAddress(chain, block) {
         case 'hedera':
             multicallAddress = '0x18fa376d92511dd04090566ab6144847c03557d8';
             break;
+        case 'xrplevm':
+            multicallAddress = '0xaB3a12b26e72F4D6D9B579aCb5027a0918eF1114';
+            break;
+        case 'vechain':
+            multicallAddress = '0x8B2fF167683c5e1DFD6717d934B560F20cf9F2a3';
+            break;
     }
     return multicallAddress;
 }