@1delta/margin-fetcher 0.0.1

package/dist/utils/index.js

@@ -0,0 +1,71 @@
+import { AAVE_FORK_POOL_DATA, AAVE_STYLE_RESERVE_ASSETS, AAVE_V2_LENDERS, AAVE_V3_LENDERS, COMPOUND_BASE_TOKENS, COMPOUND_STYLE_RESERVE_ASSETS, INIT_STYLE_RESERVE_ASSETS, Lender, SWAYLEND_RESERVE_ASSETS, INIT_CONFIG_DATA } from "@1delta/asset-registry";
+import { uniq } from "lodash";
+import { COMPOSERS } from "./constants";
+export const AAVE_V3_2_PROTOCOLS = [
+    Lender.AAVE_V3,
+    Lender.AAVE_V3_ETHER_FI,
+    Lender.AAVE_V3_PRIME,
+];
+export function isAaveV3Type(lender) { return AAVE_V3_LENDERS.includes(lender); }
+const AAVE_V3_KEY = "AAVE_V3";
+export function isAaveV3Original(lender) { return lender.startsWith(AAVE_V3_KEY); }
+export function isAaveV2Type(lender) { return AAVE_V2_LENDERS.includes(lender); }
+export function isAaveV32Type(lender) { return AAVE_V3_2_PROTOCOLS.includes(lender); }
+export function isAaveType(lender) { return [...AAVE_V3_LENDERS, ...AAVE_V2_LENDERS].includes(lender); }
+const COMPOUND_V3_KEY = "COMPOUND_V3";
+export function isCompoundV3(lender) { return lender.startsWith(COMPOUND_V3_KEY); }
+export function isCompoundV3Type(lender) { return lender.startsWith(COMPOUND_V3_KEY); }
+export function isInit(lender) { return lender === Lender.INIT; }
+const SWAYLEND_KEY = "SWAYLEND";
+export function isSwaylend(lender) { return lender.startsWith(SWAYLEND_KEY); }
+export const getLendersForChain = (c) => {
+    let lenders = [];
+    // aaves
+    Object.entries(AAVE_FORK_POOL_DATA).forEach(([l, data]) => {
+        const chains = Object.keys(data);
+        if (chains.includes(c))
+            lenders.push(l);
+    });
+    // compound V3s
+    Object.entries(COMPOUND_BASE_TOKENS).forEach(([l, data]) => {
+        const chains = Object.keys(data);
+        if (chains.includes(c))
+            lenders.push(l);
+    });
+    // init
+    Object.entries(INIT_CONFIG_DATA).forEach(([l, data]) => {
+        const chains = Object.keys(data);
+        if (chains.includes(c))
+            lenders.push(l);
+    });
+    return lenders;
+};
+const getAavesForChain = () => {
+    let lenders = {};
+    Object.entries(AAVE_FORK_POOL_DATA).forEach(([l, data]) => {
+        Object.entries(data).forEach(([chain, data]) => {
+            if (!lenders[chain])
+                lenders[chain] = [];
+            lenders[chain] = uniq([...lenders[chain], l]);
+        });
+    });
+    return lenders;
+};
+/** All aave protocols per chain */
+export const AAVES_PER_CHAIN = getAavesForChain();
+export const getComposerAddress = (chainId) => {
+    return COMPOSERS[chainId];
+};
+export const getLenderAssets = (chainId, lendingProtocol = Lender.AAVE_V3) => {
+    if (!chainId)
+        return [];
+    if (isAaveType(lendingProtocol))
+        return AAVE_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId] ?? [];
+    if (isCompoundV3(lendingProtocol))
+        return COMPOUND_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId] ?? [];
+    if (isInit(lendingProtocol))
+        return INIT_STYLE_RESERVE_ASSETS[lendingProtocol]?.[chainId] ?? [];
+    if (isSwaylend(lendingProtocol))
+        return SWAYLEND_RESERVE_ASSETS[lendingProtocol]?.[chainId ?? 0] ?? [];
+    return [];
+};

package/dist/utils/multicall.d.ts

@@ -0,0 +1,5 @@
+import { GeneralCall, GetEvmClientFunction } from '../types';
+export type Call = GeneralCall;
+/** Same as Multicall viem except that the abi param is supposed to be the abi per call */
+export declare const multicallViemAbiArray: (chainId: string, abi: any[], calls: Call[], getEvmClient: GetEvmClientFunction, retry?: boolean, providerId?: number, retries?: number) => Promise<any[]>;
+//# sourceMappingURL=multicall.d.ts.map

package/dist/utils/multicall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multicall.d.ts","sourceRoot":"","sources":["../../src/utils/multicall.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAE5D,MAAM,MAAM,IAAI,GAAG,WAAW,CAAA;AAa9B,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB,GAC9B,SAAS,MAAM,EACf,KAAK,GAAG,EAAE,EACV,OAAO,IAAI,EAAE,EACb,cAAc,oBAAoB,EAClC,eAAY,EACZ,mBAAc,EACd,gBAAoB,KACrB,OAAO,CAAC,GAAG,EAAE,CA2Bf,CAAA"}

package/dist/utils/multicall.js

@@ -0,0 +1,30 @@
+import { isArray } from 'lodash';
+const MULTICALL_DEFAULT_BATCH_SIZE = 4096;
+const maxRetries = 3;
+/** Same as Multicall viem except that the abi param is supposed to be the abi per call */
+export const multicallViemAbiArray = async (chainId, abi, calls, getEvmClient, retry = true, providerId = 0, retries = maxRetries) => {
+    try {
+        const provider = getEvmClient(chainId, providerId);
+        const abiIsArray = isArray(abi[0]);
+        const returnData = await provider.multicall({
+            allowFailure: true,
+            batchSize: MULTICALL_DEFAULT_BATCH_SIZE,
+            contracts: calls.map(({ address, name, params }, i) => ({
+                abi: abiIsArray ? abi?.[i] : abi,
+                address: address,
+                functionName: name,
+                args: params,
+            })),
+        });
+        const res = returnData.map(({ result, status }) => status !== "success" ? '0x' : result);
+        return res;
+    }
+    catch (error) {
+        console.log("error in multicall", error);
+        retries--;
+        if (retries < 0)
+            throw new Error("Failed too often");
+        providerId++;
+        return multicallViemAbiArray(chainId, abi, calls, getEvmClient, retry, providerId, retries);
+    }
+};

package/dist/utils/parsing.d.ts

@@ -0,0 +1,14 @@
+import { Lender } from "@1delta/asset-registry";
+export declare const BPS = 10000;
+export declare const parseRawAmount: (answer?: string, decimals?: number) => string;
+export declare enum TimeScale {
+    BLOCK = 0,
+    MS = 1
+}
+export declare const aprToApy: (apr: number) => number;
+export declare const apyToApr: (apy: number) => number;
+export declare const formatAaveYieldToNumber: (n?: string | bigint) => number;
+export declare const calculateRateForCompound: (n: string, chainId: string, lender?: Lender) => number;
+export declare const formatAaveRawApyToApr: (raw: bigint | string | undefined) => number;
+export declare const convertRateToApr: (ratePerSecond: number | string) => number;
+//# sourceMappingURL=parsing.d.ts.map

package/dist/utils/parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsing.d.ts","sourceRoot":"","sources":["../../src/utils/parsing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAItD,eAAO,MAAM,GAAG,QAAQ,CAAA;AAExB,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,EAAE,iBAAa,KAAG,MAO/D,CAAA;AAED,oBAAY,SAAS;IACjB,KAAK,IAAA;IACL,EAAE,IAAA;CACL;AAYD,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,WAEnC,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,WAEnC,CAAA;AAGD,eAAO,MAAM,uBAAuB,GAAI,IAAI,MAAM,GAAG,MAAM,KAAG,MAG7D,CAAA;AAGD,eAAO,MAAM,wBAAwB,GACjC,GAAG,MAAM,EACT,SAAS,MAAM,EACf,eAAkC,KACnC,MAYF,CAAA;AACD,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,GAAG,MAAM,GAAG,SAAS,WAGrE,CAAA;AAKD,eAAO,MAAM,gBAAgB,GAAI,eAAe,MAAM,GAAG,MAAM,WAI9D,CAAA"}

package/dist/utils/parsing.js

@@ -0,0 +1,61 @@
+import { Chain, Lender } from "@1delta/asset-registry";
+import { formatEther, formatUnits } from "viem";
+import { isCompoundV3 } from ".";
+export const BPS = 10000;
+export const parseRawAmount = (answer, decimals = 18) => {
+    if (!answer || answer === "0x")
+        return "0";
+    try {
+        return (formatUnits(BigInt(answer ?? '0'), decimals ?? 18));
+    }
+    catch (e) {
+        return "0";
+    }
+};
+export var TimeScale;
+(function (TimeScale) {
+    TimeScale[TimeScale["BLOCK"] = 0] = "BLOCK";
+    TimeScale[TimeScale["MS"] = 1] = "MS";
+})(TimeScale || (TimeScale = {}));
+const BLOCK_TIMES = {
+    5: 12,
+    1: 12,
+    56: 3,
+};
+// Converters from apy to apr and reversed
+const SECONDS_PER_YEAR = 31536000;
+export const aprToApy = (apr) => {
+    return (1 + apr / SECONDS_PER_YEAR) ** SECONDS_PER_YEAR - 1;
+};
+export const apyToApr = (apy) => {
+    return ((apy + 1) ** (1 / SECONDS_PER_YEAR) - 1) * SECONDS_PER_YEAR;
+};
+export const formatAaveYieldToNumber = (n) => {
+    if (!n)
+        return 0;
+    return Number(formatEther(BigInt(n) / BigInt(1e7)));
+};
+export const calculateRateForCompound = (n, chainId, lender = Lender.COMPOUND_V3_USDC_E) => {
+    let scale = TimeScale.MS;
+    if (isCompoundV3(lender) || Lender.COMPOUND_V2) {
+        scale = TimeScale.BLOCK;
+    }
+    else if (chainId === Chain.BNB_SMART_CHAIN_MAINNET) {
+        scale = TimeScale.BLOCK;
+    }
+    const rate = Number(formatEther(BigInt(n)));
+    if (scale === TimeScale.BLOCK)
+        return (Math.pow((rate * 60 * 60 * 24) / (BLOCK_TIMES[chainId] ?? 1) + 1, 365) - 1) * 100;
+    return (Math.pow(rate * 60 * 60 * 24 + 1, 365) - 1) * 100;
+};
+export const formatAaveRawApyToApr = (raw) => {
+    const apy = formatAaveYieldToNumber(raw);
+    return apyToApr(apy / 100) * 100;
+};
+// converts rate per second to rate per year
+export const convertRateToApr = (ratePerSecond) => {
+    const rps = Number(ratePerSecond);
+    if (isNaN(rps))
+        return 0;
+    return rps * 3600 * 24 * 365 * 100;
+};

package/dist/yields/index.d.ts

@@ -0,0 +1,21 @@
+interface LenderAssetReward {
+    deposit: number;
+    borrow: number;
+    additionalDepositData: any;
+    additionalBorrowData: any;
+}
+export interface YieldDataWithTimestamp {
+    intrinsicYields: {
+        [asset: string]: number | undefined;
+    };
+    lenderRewards: {
+        [chainId: number]: {
+            [lender: string]: {
+                [asset: string]: LenderAssetReward;
+            };
+        };
+    };
+}
+export declare const fetchGeneralYields: () => Promise<YieldDataWithTimestamp>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/yields/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/yields/index.ts"],"names":[],"mappings":"AAiCA,UAAU,iBAAiB;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,qBAAqB,EAAE,GAAG,CAAA;IAC1B,oBAAoB,EAAE,GAAG,CAAA;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACnC,eAAe,EAAE;QAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,CAAA;IACxD,aAAa,EAAE;QAAE,CAAC,OAAO,EAAE,MAAM,GAAG;YAAE,CAAC,MAAM,EAAE,MAAM,GAAG;gBAAE,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAAA;aAAE,CAAA;SAAE,CAAA;KAAE,CAAA;CACrG;AAYD,eAAO,MAAM,kBAAkB,uCA6I9B,CAAA"}

package/dist/yields/index.js

@@ -0,0 +1,157 @@
+import { apyToApr } from "../utils/parsing";
+const FeedData = {
+    WSTETH: 'https://eth-api.lido.fi/v1/protocol/steth/apr/sma',
+    STMATIC: 'https://polygon.lido.fi/api/stats',
+    CBETH: 'https://api.exchange.coinbase.com/wrapped-assets/cbeth',
+    MATICX: 'https://universe.staderlabs.com/polygon/apy',
+    METH: 'https://meth.mantle.xyz/api/stats/apy',
+    SUSDE: 'https://yields.llama.fi/poolsEnriched?pool=66985a81-9c51-46ca-9977-42b4fe7bc6df',
+    EZETH: 'https://app.renzoprotocol.com/api/stats?chainId=1',
+    RETH: 'https://api.rocketpool.net/api/mainnet/payload',
+    WEETH: 'https://www.ether.fi/api/apr',
+    SAVAX: "https://api.benqi.fi/liquidstaking/apr",
+    RSETH: "https://universe.kelpdao.xyz/rseth/totalApy",
+};
+const LenderAPIs = {
+    MERIDIAN: 'https://omnidex.bmaa3ajd1gjri.eu-west-2.cs.amazonlightsail.com/lending_yields'
+};
+var MeridainNetwork;
+(function (MeridainNetwork) {
+    MeridainNetwork["TAIKO"] = "taiko";
+})(MeridainNetwork || (MeridainNetwork = {}));
+function formatMeridianKey(k) {
+    const _k = k.toUpperCase();
+    if (_k === "USDT")
+        return 'USDT.E';
+    if (_k === "USDCE")
+        return 'USDC.E';
+    return _k;
+}
+const safeFetch = async (label, fn) => {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        console.error(`Error fetching ${label}:`, e);
+        return undefined;
+    }
+};
+export const fetchGeneralYields = async () => {
+    const wstethPromise = safeFetch('WSTETH', async () => {
+        const res = await fetch(FeedData.WSTETH).then(r => r.json());
+        return Number(res.data.aprs.at(-1).apr) * 0.9;
+    });
+    const ezethPromise = safeFetch('EZETH', async () => {
+        const res = await fetch(FeedData.EZETH).then(r => r.json());
+        return Number(res.data.apr.data.rate);
+    });
+    const rethPromise = safeFetch('RETH', async () => {
+        const res = await fetch(FeedData.RETH).then(r => r.json());
+        return Number(res.rethAPR);
+    });
+    const weethPromise = safeFetch('WEETH', async () => {
+        const wstethRes = await fetch(FeedData.WSTETH).then(r => r.json());
+        const wstethApr = Number(wstethRes.data.aprs.at(-1).apr) * 0.9;
+        let aYield = 0;
+        try {
+            const weethRes = await fetch(FeedData.WEETH).then(r => r.json());
+            aYield = Number(weethRes.lrt2Apr);
+        }
+        catch (e) {
+            aYield = 0.5;
+        }
+        return aYield + wstethApr;
+    });
+    const stmaticPromise = safeFetch('STMATIC', async () => {
+        const res = await fetch(FeedData.STMATIC).then(r => r.json());
+        return Number(res.apr) * 0.9;
+    });
+    const savaxPromise = safeFetch('SAVAX', async () => {
+        const res = await fetch(FeedData.SAVAX).then(r => r.json());
+        return Number(res.apr) * 100;
+    });
+    const methPromise = safeFetch('METH', async () => {
+        const res = await fetch(FeedData.METH).then(r => r.json());
+        return apyToApr(Number(res.data[0]?.OneDayAPY)) * 100;
+    });
+    const maticxPromise = safeFetch('MATICX', async () => {
+        const res = await fetch(FeedData.MATICX).then(r => r.json());
+        return Number(res.value) * 0.9;
+    });
+    const susdePromise = safeFetch('SUSDE', async () => {
+        try {
+            const res = await fetch(FeedData.SUSDE).then(r => r.json());
+            return Number(res?.data[0]?.apy ?? 0);
+        }
+        catch (e) {
+            return 0;
+        }
+    });
+    const rsethPromise = safeFetch('RSETH', async () => {
+        const res = await fetch(FeedData.RSETH).then(r => r.json());
+        return Number(res.totalAPY);
+    });
+    const cbethPromise = safeFetch('CBETH', async () => {
+        try {
+            const res = await fetch(FeedData.CBETH, {
+                headers: {
+                    "User-Agent": "1delta/yields",
+                    "Content-Type": "application/json"
+                }
+            }).then(r => r.json());
+            return Number(res.apy) * 100;
+        }
+        catch (e) {
+            console.log("CBETH failed", e);
+            return 0;
+        }
+    });
+    const meridianPromise = safeFetch('MERIDIAN', async () => {
+        const res = await fetch(LenderAPIs.MERIDIAN).then(r => r.json());
+        const taikoData = res[MeridainNetwork.TAIKO];
+        return Object.assign({}, ...Object.keys(taikoData).map(key => ({
+            [formatMeridianKey(key)]: {
+                deposit: taikoData[key].apy_reward,
+                borrow: taikoData[key].apy_reward_borrow
+            }
+        })));
+    });
+    const [wstethData, ezethData, rethData, weethData, stmaticData, methData, maticXdata, susdeData, meridianData, savaxData, cbethData, rsethData,] = await Promise.all([
+        wstethPromise,
+        ezethPromise,
+        rethPromise,
+        weethPromise,
+        stmaticPromise,
+        methPromise,
+        maticxPromise,
+        susdePromise,
+        meridianPromise,
+        savaxPromise,
+        cbethPromise,
+        rsethPromise,
+    ]);
+    const data = {
+        intrinsicYields: {
+            MATICX: maticXdata,
+            METH: methData,
+            CMETH: methData,
+            WSTETH: wstethData,
+            EZETH: ezethData,
+            RETH: rethData,
+            WEETH: weethData,
+            STMATIC: stmaticData,
+            USDY: 4.35,
+            USDE: 0,
+            SUSDE: susdeData,
+            SAVAX: savaxData,
+            CBETH: cbethData,
+            RSETH: rsethData,
+        },
+        lenderRewards: {
+            "167000": {
+                MERIDIAN: meridianData
+            }
+        }
+    };
+    return data;
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@1delta/margin-fetcher",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/async-retry": "^1.4.9",
+    "async-retry": "^1.3.3",
+    "typescript": "^5.8.3",
+    "@1delta/providers": "1.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest"
+  }
+}