@merkl/api 0.10.129 → 0.10.130

package/dist/src/utils/error.js

@@ -0,0 +1,90 @@
+import { HttpError } from "../errors";
+import { NETWORK_LABELS } from "@sdk";
+import { ValidationError } from "elysia";
+export class InvalidParameter extends Error {
+    message;
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = "INVALID_PARAMETER";
+    }
+}
+export class UnsupportedNetwork extends Error {
+    chainId;
+    constructor(chainId) {
+        super(`API for Merkl products by Angle Labs does not support (yet) network ${chainId}`);
+        this.chainId = chainId;
+        this.name = "UNSUPPORTED_NETWORK";
+    }
+}
+export class OpportunityNotFound extends Error {
+    mainParameter;
+    chainId;
+    constructor(mainParameter, chainId) {
+        super(`No campaigns found for mainParameter ${mainParameter} on chain ${NETWORK_LABELS[chainId]}`);
+        this.mainParameter = mainParameter;
+        this.chainId = chainId;
+        this.name = "OPPORTUNITY_NOT_FOUND";
+    }
+}
+export class MerkleRootNotFound extends Error {
+    chainId;
+    constructor(chainId) {
+        super(`No Merkl root found for network ${NETWORK_LABELS[chainId]} (${chainId})`);
+        this.chainId = chainId;
+        this.name = "MERKLE_ROOT_NOT_FOUND";
+    }
+}
+export class InvalidCacheCall extends Error {
+    message;
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = "INVALID_CACHE_CALL";
+    }
+}
+export const errorHandler = (canLog = true) => {
+    return (app) => app
+        .error({
+        InvalidParameter,
+        UnsupportedNetwork,
+        OpportunityNotFound,
+        MerkleRootNotFound,
+        ValidationError,
+        InvalidCacheCall,
+        HttpError,
+    })
+        .onError(({ error, path, query, code, set, ...all }) => {
+        const response = (status, log = true, overrides) => {
+            if (canLog && log)
+                console.error(`[${path}](${JSON.stringify(query) ?? ""}): ${error.message} : ${error.stack}`);
+            return new Response(JSON.stringify(Object.assign({
+                error: error.name !== "Error" ? error.name : code,
+                message: error.message,
+            }, overrides ?? {})), {
+                status,
+            });
+        };
+        switch (code) {
+            case "InvalidParameter":
+            case "InvalidCacheCall":
+                return response(400, false);
+            case "NOT_FOUND":
+                return response(404, false, { message: `${path} does not exist` });
+            case "UnsupportedNetwork":
+            case "OpportunityNotFound":
+            case "MerkleRootNotFound":
+                return response(404, false);
+            case "VALIDATION": {
+                const errorObj = JSON.parse(error.message);
+                const property = (errorObj.property ?? "").replaceAll("/", "");
+                return response(400, false, {
+                    message: errorObj.summary,
+                    found: (property === "" ? errorObj.found : errorObj.found?.[property]) ?? "undefined",
+                });
+            }
+            default:
+                return response(500);
+        }
+    });
+};

package/dist/src/utils/execute.js

@@ -0,0 +1,41 @@
+import { batchMulticallCall, multicallContractCall } from "./generic";
+import { log } from "./logger";
+import { archiveMulticalls, multicalls } from "./providers";
+/**
+ * Functions
+ */
+export async function executeSimple(chainId, componentCall) {
+    const c = await componentCall;
+    if (c.cached === true)
+        return c.result;
+    return (await execute(chainId, [c.call]))[0];
+}
+const execute = async (chainId, callList, shouldRetry, blockNumber) => {
+    const calls = [];
+    for (const subCall of callList) {
+        calls.push(...subCall.callData);
+    }
+    try {
+        let result;
+        if (calls.length > 0) {
+            result = await batchMulticallCall(multicallContractCall, !!blockNumber ? archiveMulticalls[chainId] : multicalls[chainId], { blockNumber: blockNumber, data: calls }, shouldRetry);
+        }
+        else {
+            result = [];
+        }
+        let startIndex = 0;
+        const promises = [];
+        for (const subCall of callList) {
+            promises.push(subCall.reducer(result.slice(startIndex, startIndex + subCall.callData.length)));
+            startIndex += subCall.callData.length;
+        }
+        return await Promise.all(promises);
+    }
+    catch (e) {
+        for (const subCall of callList) {
+            log.error("execute", e);
+            subCall.handler();
+        }
+    }
+    return [];
+};

package/dist/src/utils/generateCardName.js

@@ -0,0 +1,89 @@
+import { tokenType } from "../libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType";
+export function generateCardName(type, typeInfo, campaign, symbols = [""]) {
+    switch (type) {
+        case tokenType.uniswapv2:
+        case tokenType.poolside:
+        case tokenType.velodrome:
+        case tokenType.aerodrome:
+        case tokenType.dragonswap:
+        case tokenType.akron:
+        case tokenType.koi:
+        case tokenType.baseswap:
+        case tokenType.fenix:
+        case tokenType.zkswap:
+        case tokenType.ra:
+        case tokenType.syncswap:
+            return `${typeInfo.protocol} ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+        case tokenType.pendle:
+            return `Provide ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.balancerGauge:
+            return `${typeInfo.protocol} ${symbols.join("/")}`;
+        case tokenType.balancerPool: {
+            let cardName = `${typeInfo.protocol} ${symbols.join("/")}`;
+            if (typeInfo.vault === "0xFB43069f6d0473B85686a85F4Ce4Fc1FD8F00875") {
+                cardName = `Jellyverse Pool ${symbols.join("/")}`;
+            }
+            return cardName;
+        }
+        case tokenType.aura:
+            return `${typeInfo.protocol} ${symbols.join("/")}`;
+        case tokenType.gearbox:
+            return `${typeInfo.protocol} ${typeInfo.symbolUnderlyingToken} Deposit`;
+        case tokenType.compound:
+            return `Lend ${typeInfo.symbolBaseToken} on ${typeInfo.protocol}`;
+        case tokenType.radiant_lend: {
+            let cardToken = typeInfo.symbolUnderlyingToken;
+            if (campaign.campaignParameters.symbolTargetToken.startsWith("r")) {
+                cardToken = campaign.campaignParameters.symbolTargetToken.substring(1);
+            }
+            return `Lend ${cardToken} on ${typeInfo.protocol}`;
+        }
+        case tokenType.rfx:
+            return `Supply ${typeInfo.symbolShortToken}/${typeInfo.symbolLongToken} on ${typeInfo.protocol}`;
+        case tokenType.radiant_borrow:
+        case tokenType.aave_borrowing:
+        case tokenType.yei_borrowing:
+        case tokenType.ironclad_borrowing:
+        case tokenType.zerolend_borrowing:
+        case tokenType.euler_borrow:
+            return `Borrow ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.ionic:
+        case tokenType.layerbank:
+        case tokenType.moonwell:
+        case tokenType.splice:
+        case tokenType.aave_lending:
+        case tokenType.yei_lending:
+        case tokenType.ironclad_lending:
+        case tokenType.zerolend_lending:
+        case tokenType.fraxlend:
+        case tokenType.euler_lend:
+            return `Supply ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.metamorpho:
+            return `Supply to ${typeInfo.name} on ${typeInfo.protocol}`;
+        case tokenType.sturdy_aggregator:
+            return `Supply ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol} ${typeInfo.name}`;
+        case tokenType.sturdy_silo:
+            return `Supply ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol} ${typeInfo.symbolCollateral} Silo`;
+        case tokenType.curve:
+        case tokenType.curve_2:
+            return `${typeInfo.protocol} ${Object.values(typeInfo.poolTokens).join("/")}`;
+        case tokenType.fluid:
+            return `Lend ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.enzyme:
+            return `Supply to the ${typeInfo.name} on ${typeInfo.protocol}`;
+        case tokenType.filament:
+            return `Earn Yield on ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.silostaking:
+            return `Stake ${typeInfo.symbolUnderlyingToken} on ${typeInfo.protocol}`;
+        case tokenType.beefy:
+            return `${typeInfo.protocol} ${typeInfo.symbolToken0}/${typeInfo.symbolToken1}`;
+        case tokenType.toros:
+            return `${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken}) on ${typeInfo.protocol}`;
+        case tokenType.ironcladStaking:
+            return `Stake ${campaign.campaignParameters.symbolTargetToken} on ${typeInfo.protocol}`;
+        case tokenType.woofi:
+            return `Supercharge ${typeInfo.symbolUnderlying} on ${typeInfo.protocol}`;
+        default:
+            return `Hold ${typeInfo.name} (${campaign.campaignParameters.symbolTargetToken})`;
+    }
+}

package/dist/src/utils/generic.js

@@ -0,0 +1,117 @@
+import { withRetry } from "@sdk";
+import { constants, BigNumber } from "ethers";
+import { MAX_NUM_SUBCALLS } from "../constants";
+import { log } from "./logger";
+import { multicalls } from "./providers";
+export async function multicallContractCall(contract, args) {
+    let result;
+    try {
+        // TO SIMULATE - USE CAUTIOUSLY AS IT USES CREDITS
+        // console.log(
+        //   await callTenderly(
+        //     {
+        //       chainId: (await contract.provider.getNetwork()).chainId.toString(),
+        //       data: contract.interface.encodeFunctionData('aggregate', [args.data]),
+        //       from: !!args.from ? args.from : constants.AddressZero,
+        //       saveSimulation: true,
+        //       to: contract.address,
+        //       value: '0',
+        //     },
+        //     undefined,
+        //     true
+        //   )
+        // );
+        result = await contract.provider.call({
+            data: contract.interface.encodeFunctionData("aggregate3", [
+                args.data.map(c => {
+                    return {
+                        allowFailure: !!c.allowFailure,
+                        callData: c.callData,
+                        target: c.target,
+                    };
+                }),
+            ]),
+            from: !!args.from ? args.from : constants.AddressZero,
+            to: contract.address,
+        }, !!args.blockNumber ? args.blockNumber : undefined);
+    }
+    catch (e) {
+        log.error("multicallContractCall failed", e);
+        throw new Error("❌ failed to decode multicall data");
+    }
+    return contract.interface.decodeFunctionResult("aggregate3", result)[0].map((r) => r?.returnData);
+}
+export async function batchMulticallCall(func, contract, args, shouldRetry = true) {
+    let callsLeft = args.data.length;
+    let lowerIdx = 0;
+    let upperIdx = Math.min(args.data.length, MAX_NUM_SUBCALLS);
+    const multicallBatch = [];
+    while (callsLeft !== 0) {
+        multicallBatch.push(shouldRetry
+            ? withRetry(func, [
+                // TODO: fix typing
+                contract,
+                {
+                    blockNumber: args.blockNumber,
+                    data: args.data.slice(lowerIdx, upperIdx),
+                },
+            ])
+            : func(contract, args));
+        callsLeft -= upperIdx - lowerIdx;
+        lowerIdx = upperIdx;
+        upperIdx = Math.min(args.data.length, upperIdx + MAX_NUM_SUBCALLS);
+    }
+    /** Executing batched multicall */
+    const results = await Promise.allSettled(multicallBatch);
+    let fetchedData = [];
+    for (let k = 0; k < results.length; k++) {
+        const res = results[k];
+        if (res.status === "fulfilled") {
+            fetchedData = fetchedData.concat(res.value);
+        }
+        else {
+            log.error(`batchMulticallCall failed to ${args.data[k].target}, data: ${args.data[k].callData}`, res);
+            fetchedData.concat("0x");
+        }
+    }
+    return fetchedData;
+}
+export async function archiveContractMethodCall(contract, args) {
+    return contract.interface.decodeFunctionResult("aggregate3", !!args.blockNumber
+        ? await contract.provider.call({
+            data: contract.interface.encodeFunctionData("aggregate3", [args.calls]),
+            to: contract.address,
+        }, BigNumber.from(args.blockNumber).toNumber())
+        : await contract.provider.call({
+            data: contract.interface.encodeFunctionData("aggregate3", [args.calls]),
+            to: contract.address,
+        }))[0];
+}
+export async function batchMulticallCallWithRetry(chainId, args) {
+    let fetchedData = [];
+    let remainingCalls = args.calls.length;
+    let lowerIdx = 0;
+    let upperIdx = Math.min(args.calls.length, MAX_NUM_SUBCALLS);
+    const multicallBatch = [];
+    while (remainingCalls !== 0) {
+        multicallBatch.push(await withRetry(archiveContractMethodCall, [
+            multicalls[chainId],
+            {
+                blockNumber: args.blockNumber,
+                calls: args.calls.slice(lowerIdx, upperIdx),
+            },
+        ]));
+        remainingCalls -= upperIdx - lowerIdx;
+        lowerIdx = upperIdx;
+        upperIdx = Math.min(args.calls.length, upperIdx + MAX_NUM_SUBCALLS);
+    }
+    /** Executing batched multicall */
+    const results = await Promise.allSettled(multicallBatch);
+    for (let k = 0; k < results.length; k++) {
+        const res = results[k];
+        if (res.status === "fulfilled") {
+            fetchedData = fetchedData.concat(res.value);
+        }
+    }
+    return fetchedData;
+}

package/dist/src/utils/hashArray.js

@@ -0,0 +1,4 @@
+import { sha256 } from "../utils/crypto";
+export function hashArray(...args) {
+    return args.length > 0 ? sha256(JSON.stringify(args.map(a => a.toString()))) : "";
+}

package/dist/src/utils/lastBlockBefore.js

@@ -0,0 +1,78 @@
+import { Redis } from "../cache";
+import { hashArray } from "./hashArray";
+import { BigNumber } from "ethers";
+import moment from "moment";
+import { log } from "./logger";
+import { providers } from "./providers";
+/**
+ * Fetches the timestamp of a block with up to RETRIES retries in case of failure
+ */
+const RETRIES = 10;
+export const getBlockTimestamp = async (provider, blockNumber) => {
+    let res = null;
+    let trial = 0;
+    while (res === null && trial < RETRIES) {
+        try {
+            res = await provider.send("eth_getBlockByNumber", [`0x${blockNumber.toString(16)}`, false]);
+        }
+        catch { }
+        trial++;
+    }
+    if (trial > 1) {
+        console.log(`${trial - 1} calls failed fetching blocktimestamp for block ${blockNumber}.`);
+    }
+    return BigNumber.from(res?.timestamp).toNumber();
+};
+/**
+ * Binary search to search the last block before a given timestamp
+ */
+const getLastBlockBefore = async (timestamp, chainId) => {
+    if (moment().unix() < timestamp) {
+        log.error("getLastBlockBefore", `Timestamp ${timestamp} is in the future`);
+        return 0;
+    }
+    const provider = providers[chainId];
+    const current = await provider.getBlockNumber();
+    let upper = current;
+    let lower = 0;
+    let step = Math.floor((upper - lower) / 2);
+    let fixUpper = false;
+    let fixLower = false;
+    while (upper - lower > 1) {
+        // Reduce step size of interval has been found
+        if (upper - lower < 2 * step) {
+            step = Math.floor(step / 2);
+            fixUpper = false;
+            fixLower = false;
+        }
+        // Check reduction of upper bound
+        if (!fixUpper) {
+            const auxUpper = upper - step;
+            const auxUpperTimestamp = await getBlockTimestamp(provider, auxUpper);
+            if (auxUpperTimestamp > timestamp) {
+                upper = auxUpper;
+            }
+            else {
+                fixUpper = true;
+            }
+        }
+        // Check reduction of lower bound
+        if (!fixLower) {
+            const auxLower = lower + step;
+            const auxLowerTimestamp = await getBlockTimestamp(provider, auxLower);
+            if (auxLowerTimestamp <= timestamp) {
+                lower = auxLower;
+            }
+            else {
+                // auxLower timestamp >= timestamp
+                // We want to return the last block with a timestamp <= timestamp
+                fixLower = true;
+                if (auxLowerTimestamp === timestamp) {
+                    return auxLower;
+                }
+            }
+        }
+    }
+    return lower;
+};
+export const getLastBlockBeforeWithCache = async (timestamp, chainId) => await Redis.getOrSet(`LastBlockBefore_${hashArray([timestamp, chainId])}`, getLastBlockBefore, timestamp, chainId);

package/dist/src/utils/logger.js

@@ -0,0 +1,52 @@
+import { createPinoLogger } from "@bogeychan/elysia-logger";
+export const logger = createPinoLogger({
+    base: undefined,
+    formatters: {
+        level(level) {
+            return { level };
+        },
+    },
+    level: process.env.LOG_LEVEL || "info",
+    name: process.env.APP_NAME || "api",
+    transport: process.env.ENV !== "local"
+        ? undefined
+        : {
+            options: {
+                colorize: true,
+                ignore: "time,name,hostname,pid,baseUrl,fullUrl,requestId,chain",
+                messageFormat: "\u001b[35m{baseUrl}\u001b[39m \u001b[33m{chain}\u001b[39m {msg}",
+            },
+            target: "pino-pretty",
+        },
+});
+const logConstructor = (type, message, errorMessage, onlyDev, service, url) => {
+    if (onlyDev && process.env.ENV !== "local")
+        return;
+    if (type === "error") {
+        if (!!service && !!url) {
+            logger.child({ service, url }).error(errorMessage, message);
+        }
+        else if (!!service) {
+            logger.child({ service }).error(errorMessage, message);
+        }
+        else {
+            logger.error(errorMessage, message);
+        }
+    }
+    else if (type === "warn") {
+        logger.warn(message);
+    }
+    else if (type === "debug") {
+        logger.debug(message);
+    }
+    else {
+        logger.info(message);
+    }
+};
+export const log = {
+    debug: (message) => logConstructor("debug", message),
+    error: (message, errorMessage, service, url) => logConstructor("error", message, errorMessage, false, service, url),
+    info: (message) => logConstructor("info", message),
+    local: (message) => logConstructor("info", message, undefined, true),
+    warn: (message) => logConstructor("warn", message),
+};

package/dist/src/utils/pricer.js

@@ -0,0 +1,180 @@
+import { Redis } from "../cache";
+import { ChainId, NETWORK_LABELS } from "@sdk";
+import axios from "axios";
+import { log } from "./logger";
+import PriceService from "./prices/priceService";
+const defiLamaChains = {
+    [ChainId.MAINNET]: "ethereum",
+    [ChainId.POLYGON]: "polygon",
+    [ChainId.FANTOM]: "fantom",
+    [ChainId.AVALANCHE]: "avax",
+    [ChainId.BSC]: "bsc",
+    [ChainId.OPTIMISM]: "optimism",
+    [ChainId.ARBITRUM]: "arbitrum",
+    [ChainId.BASE]: "base",
+    [ChainId.GNOSIS]: "gnosis",
+};
+export var PRICING_METHODS;
+(function (PRICING_METHODS) {
+    PRICING_METHODS[PRICING_METHODS["defillama"] = 0] = "defillama";
+    PRICING_METHODS[PRICING_METHODS["quickswap"] = 1] = "quickswap";
+    PRICING_METHODS[PRICING_METHODS["abandonned"] = -1] = "abandonned";
+})(PRICING_METHODS || (PRICING_METHODS = {}));
+export class Pricer {
+    prices;
+    extraPricesData;
+    constructor(prices, extraPricesData) {
+        this.prices = prices;
+        this.extraPricesData = extraPricesData;
+    }
+    static async load() {
+        const { prices, extraPricesData } = await Redis.get("Prices");
+        const pricer = new Pricer(prices ?? {}, extraPricesData ?? []);
+        if (!prices) {
+            log.error("Pricer", "prices not found in cache when instanciating class");
+            await pricer.update();
+        }
+        return pricer;
+    }
+    getArray() {
+        return Object.keys(this.prices)
+            .filter(t => this.prices[t] >= 0)
+            .map(t => {
+            return {
+                rate: this.prices[t],
+                token: t,
+            };
+        });
+    }
+    /** Tries to fetch a given price sequentially using a given method */
+    async fetchPerMethod(x, method) {
+        switch (method) {
+            case PRICING_METHODS.abandonned:
+                return 0;
+            case PRICING_METHODS.defillama: {
+                let defillamaId;
+                if (!!x.chainId && !!x.address) {
+                    defillamaId = `${defiLamaChains[x.chainId] ?? NETWORK_LABELS[x.chainId].toLowerCase()}:${x.address}`;
+                }
+                else {
+                    defillamaId = `coingecko:${x.symbol}`;
+                }
+                const defillamaUrl = `https://coins.llama.fi/prices/current/${defillamaId}`;
+                try {
+                    return (await axios.get(defillamaUrl, { timeout: 1000 })).data.coins[defillamaId].price;
+                }
+                catch { }
+                break;
+            }
+            case PRICING_METHODS.quickswap:
+                if (!!x.chainId && !!x.address) {
+                    const quickswapUrl = `https://leaderboard.quickswap.exchange/utils/token-prices/v3?chainId=${x.chainId}&addresses=${x.address}`;
+                    try {
+                        return (await axios.get(quickswapUrl, { timeout: 1000 })).data?.[0].price;
+                    }
+                    catch { }
+                }
+                break;
+        }
+        return 0;
+    }
+    /** Tries to fetch a given price sequentially using all available methods */
+    async fetch(x) {
+        if (!!x.symbol && x.symbol?.toLowerCase().includes("test"))
+            return { method: PRICING_METHODS.abandonned, price: 0 };
+        for (const method of Object.values(PRICING_METHODS)) {
+            if (method === Number.parseInt(method.toString())) {
+                const price = await this.fetchPerMethod(x, method);
+                if (!!price)
+                    return { method, price };
+            }
+        }
+        return { method: PRICING_METHODS.abandonned, price: 0 };
+    }
+    /** Returns the price if possible, otherwise tries to fetch it */
+    async get(x) {
+        if (x.symbol === "test")
+            return 0; // FIXME
+        // Normalize address
+        x.address = x?.address?.toLowerCase();
+        if (!!x.address && !!this.prices[x.address]) {
+            if (this.prices[x.address] !== -1)
+                return this.prices[x.address];
+        }
+        if (!!x.symbol && !!this.prices[x.symbol]) {
+            if (this.prices[x.symbol] === -1)
+                return undefined;
+            return this.prices[x.symbol];
+        }
+        if (!!x.symbol && x.symbol.toLowerCase().startsWith("w")) {
+            const symbol = x.symbol.slice(1);
+            if (!!this.prices[symbol]) {
+                if (this.prices[symbol] === -1)
+                    return undefined;
+                return this.prices[symbol];
+            }
+        }
+        if (!!x.symbol && x.symbol.toLowerCase().startsWith("r")) {
+            const symbol = x.symbol.slice(1);
+            if (!!this.prices[symbol]) {
+                if (this.prices[symbol] === -1)
+                    return undefined;
+                return this.prices[symbol];
+            }
+        }
+        if (!!x.symbol && x.symbol.toLowerCase().startsWith("r") && x.symbol.toLowerCase().endsWith("n")) {
+            const symbol = x.symbol.slice(1, -1);
+            if (!!this.prices[symbol]) {
+                if (this.prices[symbol] === -1)
+                    return undefined;
+                return this.prices[symbol];
+            }
+        }
+        if (!!x.symbol && x.symbol.toLowerCase().startsWith("variableDebt")) {
+            const symbol = x.symbol.slice(12);
+            if (!!this.prices[symbol]) {
+                if (this.prices[symbol] === -1)
+                    return undefined;
+                return this.prices[symbol];
+            }
+        }
+        if (!!x.symbol && x.symbol.toLowerCase().startsWith("variableDebt") && x.symbol.toLowerCase().endsWith("n")) {
+            const symbol = x.symbol.slice(12, -1);
+            if (!!this.prices[symbol]) {
+                if (this.prices[symbol] === -1)
+                    return undefined;
+                return this.prices[symbol];
+            }
+        }
+    }
+    /** Saves the current price data in the cache */
+    async save() {
+        await Redis.safeSet("Prices", {
+            extraPricesData: this.extraPricesData,
+            prices: this.prices,
+        });
+    }
+    /** Recomputes all prices and saves them in the cache */
+    async update() {
+        // Update prices
+        this.prices = await PriceService.instance.fetchPrices();
+        // Update extra prices
+        this.extraPricesData = this.extraPricesData.filter(x => !!x.symbol && this.prices[x.symbol] === undefined && !!x.address && this.prices[x.address] === undefined);
+        for (const x of this.extraPricesData) {
+            try {
+                const price = await this.fetchPerMethod({ address: x.address, chainId: x.chainId, symbol: x.symbol }, x.method);
+                if (!!price) {
+                    log.info(`price for ${x.symbol} - ${x.address} on ${NETWORK_LABELS[x.chainId ?? 1]}: ${price} added to cache`);
+                    if (!!x.address && this.prices[x.address] === undefined)
+                        this.prices[x.address] = price;
+                    if (!!x.symbol && this.prices[x.symbol] === undefined)
+                        this.prices[x.symbol] = price;
+                }
+            }
+            catch (e) {
+                log.error("pricer update", e);
+            }
+        } // Update extraPricesData
+        await this.save();
+    }
+}

package/dist/src/utils/prices/chainlinkRead.js

@@ -0,0 +1,8 @@
+import { BN2Number } from "@sdk";
+import { Contract, utils } from "ethers";
+import { providers } from "../providers";
+export async function getChainlinkLatestPrice(chainId, oracle) {
+    const abi = new utils.Interface(["function latestAnswer() external view returns(int256)"]);
+    const contract = new Contract(oracle, abi, providers[chainId]);
+    return BN2Number(await contract.latestAnswer(), 8);
+}

package/dist/src/utils/prices/curveVirtualPrice.js

@@ -0,0 +1,7 @@
+import { BN2Number } from "@sdk";
+import { Contract } from "ethers";
+import { providers } from "../providers";
+export async function getVirtualPrice(chainId, pool) {
+    const contract = new Contract(pool, ["function get_virtual_price() external view returns(uint256)"], providers[chainId]);
+    return BN2Number(await contract.get_virtual_price());
+}

package/dist/src/utils/prices/getDQUICK.js

@@ -0,0 +1,8 @@
+import { BN2Number } from "@sdk";
+import { Contract, utils } from "ethers";
+import { providers } from "../providers";
+export async function getDQUICKPrice(chainId, contractAddress, assetDecimals = 18, vaultDecimals = 18) {
+    const contract = new Contract(contractAddress, ["function dQUICKForQUICK(uint256) external view returns(uint256)"], providers[chainId]);
+    const assetAmount = await contract.dQUICKForQUICK(utils.parseUnits("1", vaultDecimals));
+    return BN2Number(assetAmount, assetDecimals);
+}