@defillama/sdk 5.0.219 → 5.0.220

package/README.md

@@ -20,6 +20,20 @@ ETHEREUM_RPC="https://..."
 BSC_RPC="https://..."
 ```
 
+### Environment variables
+
+Most settings can be overridden per chain via environment variables. The chain
+name is uppercased and used as a prefix, e.g. `ETHEREUM_RPC`, `BSC_RPC_MULTICALL_V3`.
+Every key is also resolved with an `SDK_` or `LLAMA_SDK_` prefix (checked in the
+order `LLAMA_SDK_<KEY>` → `SDK_<KEY>` → `<KEY>`), so `SDK_ETHEREUM_RPC` works too.
+
+| Variable | Description |
+| --- | --- |
+| `<CHAIN>_RPC` | RPC URL(s) for the chain (comma-separated for multiple). |
+| `<CHAIN>_RPC_MULTICALL_V3` | Address of a Multicall3 contract for the chain. Setting it enables the Multicall3 code path for that chain (even if the chain is not in the built-in registry) and uses this address. Takes precedence over the built-in registry and the deployment-block gating. |
+| `<CHAIN>_RPC_MULTICALL` | Address of a legacy (v2) multicall contract, used only when Multicall3 is not available for the chain. |
+| `<CHAIN>_MULTICALL_CHUNK_SIZE` | Max number of calls per multicall batch for the chain. |
+
 ## Chain RPC PR
 
 Before putting up a PR for new chain, check if we already support it here: https://unpkg.com/@defillama/sdk@latest/build/providers.json 

package/build/Balances.js

@@ -195,7 +195,7 @@ class Balances {
     }
     async getUSDValue() {
         let { usdTvl } = await (0, computeTVL_1.default)(this.getBalances(), this.timestamp);
-        usdTvl = Object.values(this._usdBalances).reduce((a, b) => a + b, usdTvl);
+        usdTvl = Object.values(this._usdBalances).reduce((a, b) => a + Number(b), usdTvl);
         return usdTvl;
     }
     async getUSDString() {

package/build/ChainApi.js

@@ -193,8 +193,8 @@ class ChainApi {
             tokens.forEach((i) => tokensAndOwners.push([i, owner]));
         if (skipDuplicates)
             tokensAndOwners = getUniqueTokensAndOwners(tokensAndOwners, this.chain);
-        blacklistedOwners = (0, common_1.getUniqueAddresses)(blacklistedOwners);
-        blacklistedTokens = (0, common_1.getUniqueAddresses)(blacklistedTokens);
+        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]));
         const tokenBalances = [];
         const erc20TokensResponseIndex = [];

package/build/abi/abi2.js

@@ -63,7 +63,7 @@ async function call(params) {
         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)
+            if (res.success !== false)
                 return response;
         }
         const lastAbi = abis[abis.length - 1];

package/build/abi/index.js

@@ -195,13 +195,34 @@ async function multiCall(params) {
     if (!params.skipCache)
         return cachedMultiCall(params);
     const abi = resolveABI(params.abi);
+    const chunkedCalls = (0, util_1.sliceIntoChunks)(contractCalls, chunkSize);
     const results = await (0, util_1.runInPromisePool)({
-        items: (0, util_1.sliceIntoChunks)(contractCalls, chunkSize),
+        items: chunkedCalls,
         concurrency: 10,
         processor: (calls) => (0, multicall3_1.default)(abi, calls, chain, params.block),
         permitFailure: params.permitFailure,
     });
-    const flatResults = [].concat.apply([], results);
+    // When an entire chunk's processor call throws (e.g. a chunk-level RPC
+    // failure, as opposed to an individual call within it), runInPromisePool
+    // returns `undefined` for that chunk's slot instead of the expected array
+    // of one result per call. If permitFailure is set, that undefined flows
+    // straight through here uncaught, and both the .filter(r => !r.success)
+    // below and the flatResults[i].output access further down crash on it -
+    // and even without the crash, replacing a whole chunk's many calls with a
+    // single slot silently shortens and misaligns the array against
+    // contractCalls. Reconstruct a properly-shaped failure entry per call in
+    // any failed chunk instead, matching what makeMultiCall itself returns on
+    // an individual call failure, so length/order stay correct either way.
+    const resultsWithFailedChunksExpanded = results.map((chunkResult, i) => {
+        if (chunkResult !== undefined)
+            return chunkResult;
+        return chunkedCalls[i].map((call) => ({
+            input: { params: call.params, target: call.contract },
+            success: false,
+            output: null,
+        }));
+    });
+    const flatResults = [].concat.apply([], resultsWithFailedChunksExpanded);
     const failedQueries = flatResults.filter(r => !r.success);
     if (failedQueries.length) {
         // debugLog(`[chain: ${params.chain ?? "ethereum"}] [abi: ${params.abi}] Failed multicalls:`, failedQueries.map(r => r.input))

package/build/abi/multicall3.d.ts

@@ -4,4 +4,4 @@ export default function makeMultiCall(functionABI: any, calls: {
     params: any[];
 }[], chain: Chain, block?: string | number): Promise<any>;
 export declare function isMulticallV3Supported(chain: Chain, block?: string | number): boolean;
-export declare function getMulticallAddress(chain: Chain, block?: string | number): string | null;
+export declare function getMulticallAddress(chain: Chain, block?: string | number): any;

package/build/abi/multicall3.js

@@ -10,6 +10,7 @@ const ethers_1 = require("ethers");
 const convertResults_1 = __importDefault(require("./convertResults"));
 const multicall_1 = __importDefault(require("./multicall"));
 const index_1 = require("./index");
+const env_1 = require("../util/env");
 // https://github.com/mds1/multicall
 // https://www.multicall3.com/deployments
 const MULTICALL_V3_ADDRESS = '0xca11bde05977b3631167028862be2a173976ca11';
@@ -222,6 +223,8 @@ const DEPLOYMENT_BLOCK = {
     srx: 1,
     xo: 1,
     rls: 1,
+    quai: 1,
+    adi: 1,
 };
 async function makeMultiCall(functionABI, calls, chain, block) {
     if (!functionABI)
@@ -236,16 +239,17 @@ async function makeMultiCall(functionABI, calls, chain, block) {
     const goodEncodingIndexes = [];
     const goodCalls = [];
     const contractCalls = calls.map((call, idx) => {
-        var _a;
         try {
             const data = contractInterface.encodeFunctionData(fd, call.params);
-            if ((_a = call.contract) === null || _a === void 0 ? void 0 : _a.startsWith('0x')) {
-                const _isValidAddress = ethers_1.ethers.getAddress(call.contract); // Validates and checksums the address
+            let contract = call.contract;
+            if (contract === null || contract === void 0 ? void 0 : contract.startsWith('0x')) {
+                contract = contract.toLowerCase(); // lowercase so a bad EIP-55 checksum does not reject the call - single `call` passes the target as-is to eth_call, so multiCall should accept the same input
+                const _isValidAddress = ethers_1.ethers.getAddress(contract); // Validates the address
             }
             goodCalls.push(call);
             goodEncodingIndexes.push(idx);
             return {
-                to: call.contract,
+                to: contract,
                 data,
             };
         }
@@ -300,7 +304,18 @@ async function makeMultiCall(functionABI, calls, chain, block) {
         returnValues = returnData;
     }
 }
+const envMulticallCache = {};
+function getMulticallV3ContractFromEnv(chain) {
+    var _a;
+    if (!envMulticallCache.hasOwnProperty(chain)) {
+        envMulticallCache[chain] = (_a = (0, env_1.getEnvValue)(`${chain}_RPC_MULTICALL_V3`)) !== null && _a !== void 0 ? _a : null;
+    }
+    return envMulticallCache[chain];
+}
 function isMulticallV3Supported(chain, block) {
+    const contractFromEnv = getMulticallV3ContractFromEnv(chain);
+    if (contractFromEnv)
+        return true;
     const startBlock = DEPLOYMENT_BLOCK[chain];
     if (!startBlock)
         return false;
@@ -312,6 +327,9 @@ function isMulticallV3Supported(chain, block) {
 }
 function getMulticallAddress(chain, block) {
     var _a;
+    const contractFromEnv = getMulticallV3ContractFromEnv(chain);
+    if (contractFromEnv)
+        return contractFromEnv;
     if (!isMulticallV3Supported(chain, block))
         return null;
     return (_a = CUSTOM_MULTICALL_ADDRESSES[chain]) !== null && _a !== void 0 ? _a : MULTICALL_V3_ADDRESS;
@@ -354,4 +372,6 @@ const CUSTOM_MULTICALL_ADDRESSES = {
     'anubi': '0x2BaB36196519Ce9Cc31Bc4899FCBB8124A413b02',
     'srx': '0xFd4b34b5763f54a580a0d9f7997A2A993ef9ceE9',
     'xo': '0x7c6d6eAafF566E3B8a6D072ca1825E8F18141fDb',
+    'quai': '0x00567637197E6554e2CF47a3988Cb7B819f4E92C',
+    'adi': '0xcC5fae7aF4A6684d05D92Db59279B70e827F31BE',
 };