@merkl/api 0.10.129 → 0.10.130

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

@@ -0,0 +1,162 @@
+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

@@ -0,0 +1,93 @@
+import { BN2Number, CTokenInterface, CompFork, CompoundSubCampaignType, ERC20Interface, LayerBankERC20Interface, } from "@sdk";
+import { utils } from "ethers";
+const IONICCERC20_ABI = ["function borrowBalanceCurrent(address account) public view returns (uint256)"];
+export const IONICCERC20_INTERFACE = new utils.Interface(IONICCERC20_ABI);
+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: IONICCERC20_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(IONICCERC20_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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,57 @@
+import { BN2Number, Campaign, ERC20Interface, EulerVault__factory } from "@sdk";
+import { getAddress } from "ethers/lib/utils";
+const EulerVaultInterface = EulerVault__factory.createInterface();
+export async function getEulerUserPositions(user, _chainId, tokens) {
+    /**
+     * Fetch user positions
+     */
+    const calls = [];
+    for (const token of Object.keys(tokens)) {
+        calls.push({
+            allowFailure: true,
+            callData: EulerVaultInterface.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

@@ -0,0 +1,48 @@
+import { Campaign, withTimeout } from "@sdk";
+import { MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT } from "../../constants";
+import { executeSimple } from "../../utils/execute";
+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(executeSimple(chainId, getClammUserPositions(user, chainId, positionsToCheck[numkey])), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
+                break;
+            case Campaign.ERC20:
+                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));
+        }
+    }
+    return Object.assign({}, ...(await Promise.all(promises)));
+}

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

@@ -0,0 +1,177 @@
+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: BN2Number(campaigns[campaign].totalSupplyTargetToken, campaigns[campaign].decimals),
+                        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;
+            },
+        },
+    };
+}