@merkl/api 0.21.46 → 1.0.0

package/dist/src/libs/positions/clamm/thegraph/index.js

@@ -1,163 +0,0 @@
-// @ts-nocheck
-import { gql } from "graphql-request";
-// End timestamp is 0 for active positions
-export const positionsQuery = gql `
-  query Positions($owner: String!) {
-    nft: nftpositions(where: { owner: $owner, endTimestamp: 0 }) {
-      id
-      pool {
-        id
-      }
-      startTimestamp
-      endTimestamp
-      tickLower
-      tickUpper
-      liquidity
-      owner
-    }
-    direct: directPositions(where: { owner: $owner, endTimestamp: 0 }) {
-      id
-      pool {
-        id
-      }
-      startTimestamp
-      endTimestamp
-      tickLower
-      tickUpper
-      liquidity
-      owner
-    }
-  }
-`;
-export const nftWrapperPositionsQuery = gql `
-  query Holders($owners: [String!], $first: Int!, $skip: Int!) {
-    holderNFTs(where: { holder_in: $owners, balance: 1 }, first: $first, skip: $skip) {
-      holder
-      token
-      tokenId
-      id
-    }
-  }
-`;
-export const nftPositionByIdsQuery = gql `
-  query Positions($ids: [String!], $skip: Int) {
-    nft: nftpositions(where: { id_in: $ids, endTimestamp: 0 }, first: 1000, skip: $skip, orderBy: liquidity, orderDirection: desc) {
-      id
-      pool {
-        id
-      }
-      startTimestamp
-      endTimestamp
-      tickLower
-      tickUpper
-      liquidity
-      owner
-    }
-  }
-`;
-/** Queries */
-// End timestamp is 0 for active positions
-// TODO: add sorting
-export const positionMultipleOwnersQuery = gql `
-  query Positions($owners: [String!], $skip: Int) {
-    nft: nftpositions(where: { owner_in: $owners, endTimestamp: 0 }, first: 1000, skip: $skip, orderBy: liquidity, orderDirection: desc) {
-      id
-      pool {
-        id
-      }
-      startTimestamp
-      endTimestamp
-      tickLower
-      tickUpper
-      liquidity
-      owner
-    }
-    direct: directPositions(
-      where: { owner_in: $owners, endTimestamp: 0 }
-      first: 1000
-      skip: $skip
-      orderBy: liquidity
-      orderDirection: desc
-    ) {
-      id
-      pool {
-        id
-      }
-      startTimestamp
-      endTimestamp
-      tickLower
-      tickUpper
-      liquidity
-      owner
-    }
-  }
-`;
-export const positionsWithPastQuery = gql `
-  query Positions($owners: [String!], $timestamp: Int!, $pool: String!) {
-    nft: nftpositions(where: { owner_in: $owners, pool: $pool, endTimestamp: 0 }) {
-      id
-      pool {
-        id
-      }
-      startTimestamp
-      endTimestamp
-      tickLower
-      tickUpper
-      liquidity
-      owner
-    }
-    nftPast: nftpositions(where: { owner_in: $owners, pool: $pool, endTimestamp_gt: $timestamp }) {
-      id
-      pool {
-        id
-      }
-      startTimestamp
-      endTimestamp
-      tickLower
-      tickUpper
-      liquidity
-      owner
-    }
-    direct: directPositions(where: { owner_in: $owners, pool: $pool, endTimestamp: 0 }) {
-      id
-      pool {
-        id
-      }
-      startTimestamp
-      endTimestamp
-      tickLower
-      tickUpper
-      liquidity
-      owner
-    }
-    directPast: directPositions(where: { owner_in: $owners, pool: $pool, endTimestamp_gt: $timestamp }) {
-      id
-      pool {
-        id
-      }
-      startTimestamp
-      endTimestamp
-      tickLower
-      tickUpper
-      liquidity
-      owner
-    }
-  }
-`;
-export const almBalancesQuery = gql `
-  query Holders($owner: String!) {
-    holders(where: { holder: $owner, week: 0 }) {
-      token
-      balance
-    }
-  }
-`;
-export const almNFTBalancesQuery = gql `
-  query Holders($owner: String!) {
-    holders: holderNFTs(where: { holder: $owner, week: 0 }) {
-      token
-      tokenId
-      balance
-    }
-  }
-`;

package/dist/src/libs/positions/compound/index.js

@@ -1,91 +0,0 @@
-// @ts-nocheck
-import { BN2Number, CTokenInterface, CompFork, CompoundSubCampaignType, ERC20Interface, IonicERC20_INTERFACE, LayerBankERC20Interface, } from "@sdk";
-export async function getCompoundUserPositions(user, _chainId, campaigns) {
-    /**
-     * Fetch user positions
-     */
-    const calls = [];
-    for (const mainParameter of Object.keys(campaigns)) {
-        if (campaigns[mainParameter].subtype === CompoundSubCampaignType.supply) {
-            calls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
-                target: campaigns[mainParameter].targetToken,
-            });
-        }
-        switch (campaigns[mainParameter].compFork) {
-            case CompFork.Ionic || CompFork.Venus:
-                calls.push({
-                    allowFailure: true,
-                    callData: IonicERC20_INTERFACE.encodeFunctionData("borrowBalanceCurrent", [user]),
-                    target: campaigns[mainParameter].targetToken,
-                });
-                break;
-            case CompFork.LayerBank:
-                calls.push({
-                    allowFailure: true,
-                    callData: LayerBankERC20Interface.encodeFunctionData("borrowBalanceOf", [user]),
-                    target: campaigns[mainParameter].targetToken,
-                });
-                break;
-            default:
-                calls.push({
-                    allowFailure: true,
-                    callData: CTokenInterface.encodeFunctionData("borrowBalanceStored", [user]),
-                    target: campaigns[mainParameter].targetToken,
-                });
-        }
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                const finalRes = {};
-                let i = 0;
-                for (const mainParameter of Object.keys(campaigns)) {
-                    // Initialization
-                    const res = {
-                        userPositions: [],
-                        symbol: campaigns[mainParameter].symbolUnderlyingToken,
-                        decimals: campaigns[mainParameter].decimalsUnderlyingToken,
-                        totalSupply: campaigns[mainParameter].totalSupplyTargetToken,
-                        userTVL: 0,
-                    };
-                    let balance = 0;
-                    if (campaigns[mainParameter].subtype === CompoundSubCampaignType.supply) {
-                        balance = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i])[0], campaigns[mainParameter].decimalsUnderlyingToken);
-                    }
-                    switch (campaigns[mainParameter].compFork) {
-                        case CompFork.Ionic:
-                        case CompFork.Venus:
-                            balance = BN2Number(IonicERC20_INTERFACE.decodeFunctionResult("borrowBalanceCurrent", result[i])[0], campaigns[mainParameter].decimalsUnderlyingToken);
-                            break;
-                        case CompFork.LayerBank:
-                            balance = BN2Number(LayerBankERC20Interface.decodeFunctionResult("borrowBalanceOf", result[i])[0], campaigns[mainParameter].decimalsUnderlyingToken);
-                            break;
-                        default:
-                            balance = BN2Number(CTokenInterface.decodeFunctionResult("borrowBalanceStored", result[i])[0], campaigns[mainParameter].decimalsUnderlyingToken);
-                    }
-                    // Direct Positions
-                    if (balance > 0) {
-                        res.userPositions.push({
-                            balance: balance,
-                            token: campaigns[mainParameter].targetToken,
-                            origin: "Direct",
-                            totalSupply: campaigns[mainParameter].totalSupplyTargetToken,
-                            tvl: balance * campaigns[mainParameter].tvl,
-                        });
-                    }
-                    // Add to final result if there are positions
-                    if (res.userPositions.length > 0) {
-                        finalRes[`10_${mainParameter}`] = { ...res };
-                    }
-                    i++;
-                }
-                return finalRes;
-            },
-        },
-    };
-}

package/dist/src/libs/positions/dolomite/index.js

@@ -1,51 +0,0 @@
-// @ts-nocheck
-// import type { MerklChainId } from "@sdk";
-import axios from "axios";
-import { utils } from "ethers";
-export async function getDolomiteUserPositions(user, _chainId, dolomitePositionFetchingData) {
-    const calls = [];
-    // const pricer = await Pricer.load();
-    const dolomitePositionData = (await axios.get(`https://api.dolomite.io/balances/${_chainId}/users/${user}`)).data
-        .Result;
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (_) => {
-                const finalRes = {};
-                for (const mainParameter of Object.keys(dolomitePositionFetchingData)) {
-                    const x = dolomitePositionFetchingData[mainParameter];
-                    const positionIndex = dolomitePositionData.findIndex(y => utils.getAddress(y.token.id) === utils.getAddress(x.targetToken));
-                    const position = positionIndex >= 0 ? dolomitePositionData[positionIndex] : undefined;
-                    if (!!position) {
-                        const borrowBalance = Number.parseFloat(position.token.borrowLiquidity);
-                        const supplyBalance = Number.parseFloat(position.token.supplyLiquidity);
-                        // const priceTargetToken =
-                        //   (await pricer.get({
-                        //     symbol: x.symbol,
-                        //     address: x.targetToken,
-                        //     chainId: _chainId,
-                        //   })) ?? 0;
-                        const res = {
-                            userPositions: [],
-                            symbol: x.symbol,
-                            decimals: x.decimals,
-                            token: x.targetToken,
-                        };
-                        if (supplyBalance > 0 || borrowBalance > 0) {
-                            res.userPositions.push({
-                                borrowBalance: borrowBalance,
-                                supplyBalance: supplyBalance,
-                                token: utils.getAddress(res.token),
-                                origin: "Direct",
-                            });
-                        }
-                        finalRes[mainParameter] = res;
-                    }
-                }
-                return finalRes;
-            },
-        },
-    };
-}

package/dist/src/libs/positions/erc20/index.js

@@ -1,55 +0,0 @@
-import { BN2Number, ERC20Interface } from "@sdk";
-import { getAddress } from "ethers/lib/utils";
-export async function getERC20UserPositions(user, _chainId, tokens) {
-    /**
-     * Fetch user positions
-     */
-    const calls = [];
-    for (const token of Object.keys(tokens)) {
-        calls.push({
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
-            target: token,
-        });
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                const finalRes = {};
-                let i = 0;
-                for (const token of Object.keys(tokens)) {
-                    // Initialization
-                    const res = {
-                        userPositions: [],
-                        symbol: tokens[token].symbol,
-                        decimals: tokens[token].decimals,
-                        totalSupply: tokens[token].totalSupplyTargetToken,
-                        userTVL: 0,
-                    };
-                    // Direct Positions
-                    const balance = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i])[0], tokens[token].decimals);
-                    if (balance > 0) {
-                        res.userPositions.push({
-                            balance: balance,
-                            token: getAddress(token),
-                            origin: "Direct",
-                            totalSupply: tokens[token].totalSupplyTargetToken,
-                            tvl: balance * tokens[token].priceTargetToken,
-                        });
-                        res.userTVL += balance * tokens[token].priceTargetToken;
-                    }
-                    // TODO - Add staking contract positions
-                    // Add to final result if there are positions
-                    if (res.userPositions.length > 0) {
-                        finalRes[`1_${token}`] = { ...res };
-                    }
-                    i++;
-                }
-                return finalRes;
-            },
-        },
-    };
-}

package/dist/src/libs/positions/euler/index.js

@@ -1,56 +0,0 @@
-import { BN2Number, Campaign, ERC20Interface } from "@sdk";
-import { getAddress } from "ethers/lib/utils";
-export async function getEulerUserPositions(user, _chainId, tokens) {
-    /**
-     * Fetch user positions
-     */
-    const calls = [];
-    for (const token of Object.keys(tokens)) {
-        calls.push({
-            allowFailure: true,
-            callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
-            target: token,
-        });
-    }
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                const finalRes = {};
-                let i = 0;
-                for (const token of Object.keys(tokens)) {
-                    // Initialization
-                    const res = {
-                        userPositions: [],
-                        symbol: tokens[token].symbol,
-                        decimals: tokens[token].decimals,
-                        totalSupply: tokens[token].totalSupplyTargetToken,
-                        userTVL: 0,
-                    };
-                    // Direct Positions
-                    const balance = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i])[0], tokens[token].decimals);
-                    if (balance > 0) {
-                        res.userPositions.push({
-                            id: `${Campaign[Campaign.EULER]}_${token}`,
-                            balance: balance,
-                            token: getAddress(token),
-                            origin: "Direct",
-                            totalSupply: tokens[token].totalSupplyTargetToken,
-                            tvl: balance * tokens[token].priceTargetToken,
-                        });
-                        res.userTVL += balance * tokens[token].priceTargetToken;
-                    }
-                    // TODO - Add staking contract positions
-                    // Add to final result if there are positions
-                    if (res.userPositions.length > 0) {
-                        finalRes[`${Campaign.EULER}_${token}`] = { ...res };
-                    }
-                    i++;
-                }
-                return finalRes;
-            },
-        },
-    };
-}

package/dist/src/libs/positions/index.js

@@ -1,56 +0,0 @@
-import { executeSimple } from "@/utils/execute";
-// @ts-nocheck
-import { Campaign, withTimeout } from "@sdk";
-import { MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT } from "../../constants";
-import { getEigenLayerUserPositions } from "./EigenLayer";
-import { getAjnaUserPositions } from "./ajna";
-import { getBadgerUserPositions } from "./badger";
-import { getClammUserPositions } from "./clamm";
-import { getCompoundUserPositions } from "./compound";
-import { getDolomiteUserPositions } from "./dolomite";
-import { getERC20UserPositions } from "./erc20";
-import { getEulerUserPositions } from "./euler";
-import { getMorphoUserPositions } from "./morpho";
-import { getSiloUserPositions } from "./silo";
-export async function getUserPositionsV2(positionsToCheck, // TODO: add typing (depends on campaign type)
-chainId, user) {
-    const promises = [];
-    for (const key of Object.keys(positionsToCheck)) {
-        const numkey = Number(key);
-        switch (numkey) {
-            case Campaign.CLAMM:
-                promises.push(withTimeout(getClammUserPositions(user, chainId, positionsToCheck[numkey]), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-                break;
-            case Campaign.ERC20:
-            case Campaign.ERC20LOGPROCESSOR:
-            case Campaign.ERC20REBASELOGPROCESSOR:
-            case Campaign.ERC20_FIX_APR:
-                promises.push(withTimeout(executeSimple(chainId, getERC20UserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-                break;
-            case Campaign.SILO:
-                promises.push(withTimeout(executeSimple(chainId, getSiloUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-                break;
-            case Campaign.DOLOMITE:
-                promises.push(withTimeout(executeSimple(chainId, getDolomiteUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-                break;
-            case Campaign.EULER:
-                promises.push(withTimeout(executeSimple(chainId, getEulerUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-                break;
-            case Campaign.MORPHO:
-                promises.push(withTimeout(executeSimple(chainId, getMorphoUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-                break;
-            case Campaign.BADGER:
-                promises.push(withTimeout(executeSimple(chainId, getBadgerUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-                break;
-            case Campaign.AJNA:
-                promises.push(withTimeout(executeSimple(chainId, getAjnaUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-                break;
-            case Campaign.COMPOUND:
-                promises.push(withTimeout(executeSimple(chainId, getCompoundUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-                break;
-            case Campaign.EIGENLAYER:
-                promises.push(withTimeout(executeSimple(chainId, getEigenLayerUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
-        }
-    }
-    return Object.assign({}, ...(await Promise.all(promises)));
-}

package/dist/src/libs/positions/morpho/index.js

@@ -1,177 +0,0 @@
-import { BN2Number, ERC20Interface, MorphoSubCampaignType, } from "@sdk";
-const axios = require("axios");
-export async function getMorphoUserPositions(user, _chainId, campaigns) {
-    /**
-     * Fetch user positions
-     */
-    const calls = [];
-    for (const campaign of Object.keys(campaigns)) {
-        if (campaigns[campaign].subtype === MorphoSubCampaignType.SUPPLY_BLUE) {
-            const forwarders = campaigns[campaign]?.forwarders;
-            if (!!forwarders) {
-                for (const forwarder of Object.keys(forwarders)) {
-                    calls.push({
-                        allowFailure: true,
-                        callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
-                        target: forwarder,
-                    });
-                    calls.push({
-                        allowFailure: true,
-                        callData: ERC20Interface.encodeFunctionData("totalSupply"),
-                        target: forwarder,
-                    });
-                }
-            }
-        }
-        if (campaigns[campaign].subtype === MorphoSubCampaignType.META) {
-            calls.push({
-                allowFailure: true,
-                callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
-                target: campaigns[campaign].targetToken,
-            });
-        }
-    }
-    const endpoint = "https://blue-api.morpho.org/graphql";
-    const headers = {
-        "content-type": "application/json",
-    };
-    const morphoQuery = {
-        query: `query($address: String!, $chainId: Int) {
-  userByAddress(address: $address, chainId: $chainId) {
-    address
-    marketPositions {
-      market {
-        uniqueKey
-      }
-      supplyAssets
-      supplyAssetsUsd
-      borrowAssets
-      borrowAssetsUsd
-      collateral
-      collateralUsd
-    }
-  }
-}
-`,
-        variables: { address: user.toLowerCase(), chainId: _chainId },
-    };
-    let response;
-    return {
-        cached: false,
-        call: {
-            callData: calls,
-            handler: () => { },
-            reducer: async (result) => {
-                const finalRes = {};
-                let i = 0;
-                for (const campaign of Object.keys(campaigns)) {
-                    const marketId = campaigns[campaign].marketId;
-                    // Initialization
-                    const res = {
-                        userPositions: [],
-                        decimals: campaigns[campaign].decimals,
-                        // FIXME only have the borrowed/supplied part
-                        totalSupply: campaigns[campaign].totalSupplyTargetToken,
-                        userTVL: 0,
-                    };
-                    let balance = 0;
-                    //TODO Check in the case of the creation of a campaign
-                    if (campaigns[campaign].subtype === MorphoSubCampaignType.META) {
-                        balance = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i])[0], campaigns[campaign].decimals);
-                    }
-                    //TODO check the case for only the supply to the contract
-                    if (campaigns[campaign].subtype === MorphoSubCampaignType.SUPPLY_BLUE) {
-                        const forwarders = campaigns[campaign]?.forwarders;
-                        if (!!forwarders) {
-                            for (const forwarder of Object.keys(forwarders)) {
-                                const supplyQuery = {
-                                    query: `query($address: String!, $chainId: Int) {
-              userByAddress(address: $address, chainId: $chainId) {
-                address
-                marketPositions {
-                  market {
-                    uniqueKey
-                  }
-                  supplyAssets
-                  supplyAssetsUsd
-                }
-                }
-              }
-              `,
-                                    variables: { address: forwarder, chainId: _chainId },
-                                };
-                                try {
-                                    response = await axios({
-                                        url: endpoint,
-                                        method: "post",
-                                        headers: headers,
-                                        data: supplyQuery,
-                                    });
-                                }
-                                catch (e) {
-                                    console.log(e);
-                                }
-                                const balanceOfForwarder = BN2Number(ERC20Interface.decodeFunctionResult("balanceOf", result[i])[0], campaigns[campaign].decimals);
-                                i++;
-                                const totalSupply = BN2Number(ERC20Interface.decodeFunctionResult("totalSupply", result[i])[0], campaigns[campaign].decimals);
-                                const marketPositions = response.data.data?.userByAddress?.marketPositions;
-                                if (!!marketPositions) {
-                                    for (const market of marketPositions) {
-                                        if (market.market.uniqueKey === marketId && market.supplyAssets !== 0) {
-                                            balance +=
-                                                (balanceOfForwarder / totalSupply) *
-                                                    BN2Number(market.supplyAssets, campaigns[campaign].decimals);
-                                        }
-                                    }
-                                }
-                                i++;
-                            }
-                        }
-                    }
-                    if (campaigns[campaign].subtype === MorphoSubCampaignType.BORROWING_BLUE ||
-                        campaigns[campaign].subtype === MorphoSubCampaignType.COLLATERAL_BLUE) {
-                        try {
-                            response = await axios({
-                                url: endpoint,
-                                method: "post",
-                                headers: headers,
-                                data: morphoQuery,
-                            });
-                        }
-                        catch (e) {
-                            console.log(e);
-                        }
-                        const marketPositions = response.data.data?.userByAddress?.marketPositions;
-                        if (!!marketPositions) {
-                            for (const market of marketPositions) {
-                                if (market.market.uniqueKey === marketId) {
-                                    if (campaigns[campaign].subtype === 2 && market.borrowAssets !== 0) {
-                                        balance = BN2Number(market.borrowAssets, campaigns[campaign].decimals);
-                                    }
-                                    else if (campaigns[campaign].subtype === 3 && market.collateral !== 0) {
-                                        balance = BN2Number(market.collateral, campaigns[campaign].decimals);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    if (balance > 0) {
-                        res.userPositions.push({
-                            balance: balance,
-                            token: campaigns[campaign].targetToken,
-                            origin: "Direct",
-                            totalSupply: BN2Number(campaigns[campaign].totalSupplyTargetToken, campaigns[campaign].decimals),
-                            tvl: campaigns[campaign].tvl,
-                        });
-                        res.userTVL += campaigns[campaign].tvl;
-                    }
-                    // Add to final result if there are positions
-                    if (res.userPositions.length > 0) {
-                        finalRes[`7_${campaign}`] = { ...res };
-                    }
-                }
-                return finalRes;
-            },
-        },
-    };
-}