@merkl/api 0.9.15

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

@@ -0,0 +1,163 @@
+// @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.d.ts

@@ -0,0 +1,24 @@
+import { type Forwarder, type ForwarderParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+type FetchedCampaign = {
+    rewardToken: string;
+    symbolRewardToken: string;
+    subtype: number;
+    compFork: number;
+    tvl: number;
+    forwarders?: {
+        [address: string]: ForwarderParameters<Forwarder>;
+    };
+    targetToken: string;
+    decimalsTargetToken: number;
+    totalSupplyTargetToken: number;
+    underlyingToken: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: number;
+    symbolTargetToken: string;
+    amount: number;
+};
+export declare function getCompoundUserPositions(user: string, _chainId: MerklChainId, campaigns: {
+    [mainparameter: string]: FetchedCampaign;
+}): Promise<UncachedResult<any>>;
+export {};

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

@@ -0,0 +1,91 @@
+// @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.d.ts

@@ -0,0 +1,17 @@
+import type { MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+import type { DolomitePositionFetchingDataType } from "../prepareFetch";
+export type DolomitePositionType = {
+    [mainParameter: string]: {
+        decimals: number;
+        token: string;
+        symbol: string;
+        userPositions: {
+            borrowBalance: number;
+            supplyBalance: number;
+            token: string;
+            origin: string;
+        }[];
+    };
+};
+export declare function getDolomiteUserPositions(user: string, _chainId: MerklChainId, dolomitePositionFetchingData: DolomitePositionFetchingDataType): Promise<UncachedResult<DolomitePositionType>>;

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

@@ -0,0 +1,51 @@
+// @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.d.ts

@@ -0,0 +1,5 @@
+import { type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export declare function getERC20UserPositions(user: string, _chainId: MerklChainId, tokens: {
+    [marketAddress: string]: string[];
+}): Promise<UncachedResult<any>>;

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

@@ -0,0 +1,56 @@
+// @ts-nocheck
+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.d.ts

@@ -0,0 +1,5 @@
+import { type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+export declare function getEulerUserPositions(user: string, _chainId: MerklChainId, tokens: {
+    [marketAddress: string]: string[];
+}): Promise<UncachedResult<any>>;

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

@@ -0,0 +1,57 @@
+// @ts-nocheck
+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.d.ts

@@ -0,0 +1,3 @@
+import { type MerklChainId } from "@sdk";
+export declare function getUserPositionsV2(positionsToCheck: any, // TODO: add typing (depends on campaign type)
+chainId: MerklChainId, user: string): Promise<any>;

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

@@ -0,0 +1,53 @@
+// @ts-nocheck
+import { Campaign, withTimeout } from "@sdk";
+import { MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT } from "../../constants";
+import { executeSimple } from "../../utils/execute";
+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:
+                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.d.ts

@@ -0,0 +1,6 @@
+import { type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../../utils/execute";
+import type { MorphoFetchedCampaign, PositionType } from "../types";
+export declare function getMorphoUserPositions(user: string, _chainId: MerklChainId, campaigns: {
+    [mainparameter: string]: MorphoFetchedCampaign;
+}): Promise<UncachedResult<PositionType>>;