@gearbox-protocol/sdk 3.0.0-next.284 → 3.0.0-next.286

package/lib/gearboxRewards/api.d.ts

@@ -6,6 +6,8 @@ import { ExtraRewardApy } from "./apy";
 export interface GearboxExtraMerkleLmReward {
     pool: Address;
     poolToken: Address;
+    rewardTokenSymbol: string;
+    rewardTokenDecimals: number;
     rewardToken: Address;
     amount: bigint;
     type: "extraMerkle";
@@ -13,6 +15,8 @@ export interface GearboxExtraMerkleLmReward {
 export interface GearboxStakedV3LmReward {
     pool: Address;
     poolToken: Address;
+    rewardTokenSymbol: string;
+    rewardTokenDecimals: number;
     rewardToken: Address;
     amount: bigint;
     type: "stakedV3";
@@ -20,6 +24,8 @@ export interface GearboxStakedV3LmReward {
 export interface GearboxMerkleV2LmReward {
     pool?: undefined;
     poolToken?: undefined;
+    rewardTokenSymbol: string;
+    rewardTokenDecimals: number;
     rewardToken: Address;
     amount: bigint;
     type: "merkleV2";
@@ -53,6 +59,7 @@ export interface GetExtraRewardsProps {
     tokensList: Record<Address, TokenData>;
 }
 export interface GetLmRewardsProps {
+    pools: Array<PoolData>;
     baseRewardPoolsInfo: Record<string, FarmInfo>;
     currentTokenData: Record<SupportedToken, Address>;
     tokensList: Record<Address, TokenData>;
@@ -84,7 +91,7 @@ export declare class GearboxRewardsApi {
     static getLmRewardsV2({ provider, account, currentTokenData, network, airdropDistributorAddress, }: GetLmRewardsProps): Promise<{
         rewards: GearboxLmReward[];
     }>;
-    static getLmRewardsV3({ baseRewardPoolsInfo, currentTokenData, tokensList, provider, account, network, reportError, }: GetLmRewardsProps): Promise<{
+    static getLmRewardsV3({ pools, baseRewardPoolsInfo, currentTokenData, tokensList, provider, account, network, reportError, }: GetLmRewardsProps): Promise<{
         rewards: (GearboxLmReward | GearboxLmReward[])[];
     }>;
     private static extractFulfilled;

package/lib/gearboxRewards/api.js

@@ -15,13 +15,34 @@ class GearboxRewardsApi {
     static async getExtraRewards({ chainId, tokensList }) {
         const res = await axios_1.default.get(merklAPI_1.MerkleXYZApi.getGearboxCampaignsUrl());
         const currentActiveCampaigns = res.data.filter(c => c.status === "LIVE" && c.chainId === chainId);
+        const aprIdsList = currentActiveCampaigns
+            .map(c => 
+        // apr token for campaigns with a single reward is obvious
+        c.aprRecord.breakdowns.length > 1
+            ? c.aprRecord.breakdowns.map(b => {
+                return {
+                    campaignId: c.id,
+                    aprId: b.identifier,
+                };
+            })
+            : [])
+            .flat(1);
+        const aprIdsResponse = await Promise.allSettled(aprIdsList.map(id => axios_1.default.get(merklAPI_1.MerkleXYZApi.getGearboxRewardCampaignUrl(id.aprId))));
+        const aprCampaignByAPRId = aprIdsResponse.reduce((acc, r, i) => {
+            const id = aprIdsList[i].aprId;
+            acc[id] = r.status === "fulfilled" ? r.value.data : undefined;
+            return acc;
+        }, {});
         const r = currentActiveCampaigns.reduce((acc, campaign) => {
             const rewardSource = (campaign.tokens[0]?.address || campaign.identifier).toLowerCase();
-            const allRewards = campaign.rewardsRecord.breakdowns
+            const allRewards = campaign.aprRecord.breakdowns
                 .map((r, i) => {
-                const tokenLc = r.token.address.toLowerCase();
-                const { symbol = r.token.symbol } = tokensList[tokenLc] || {};
-                const apy = campaign.aprRecord.breakdowns[i]?.value || 0;
+                const apy = r.value;
+                const { rewardToken } = aprCampaignByAPRId[r.identifier]?.[0] || {};
+                const tokenRewardsRecord = campaign.rewardsRecord.breakdowns[i]?.token;
+                const { address = tokenRewardsRecord?.address || "" } = rewardToken || {};
+                const tokenLc = address.toLowerCase();
+                const { symbol = rewardToken?.symbol || tokenRewardsRecord?.symbol || "", } = tokensList[tokenLc] || {};
                 const apyObject = {
                     token: rewardSource,
                     balance: null,
@@ -147,11 +168,13 @@ class GearboxRewardsApi {
                 amount: availableToClaimV2,
                 type: "merkleV2",
                 rewardToken: currentTokenData.GEAR,
+                rewardTokenDecimals: 18,
+                rewardTokenSymbol: "GEAR",
             },
         ];
         return { rewards: rewards };
     }
-    static async getLmRewardsV3({ baseRewardPoolsInfo, currentTokenData, tokensList, provider, account, network, reportError, }) {
+    static async getLmRewardsV3({ pools, baseRewardPoolsInfo, currentTokenData, tokensList, provider, account, network, reportError, }) {
         const poolTokens = Object.keys(baseRewardPoolsInfo);
         const [gearboxLmResponse, merkleXYZLMResponse] = await Promise.allSettled([
             provider.multicall({
@@ -172,34 +195,53 @@ class GearboxRewardsApi {
             })),
         ]);
         const gearboxLm = (this.extractFulfilled(gearboxLmResponse, reportError, "v3Rewards") || []);
-        const merkleXYZLM = this.extractFulfilled(merkleXYZLMResponse, reportError, "merkleRewards")?.data;
-        const PREFIX = "ERC20";
-        const REWARD_KEYS_RECORD = poolTokens.reduce((acc, t) => {
-            const key = [PREFIX, (0, viem_1.getAddress)(t)].join("_");
-            acc[key] = t;
+        const merkleXYZLm = this.extractFulfilled(merkleXYZLMResponse, reportError, "merkleRewards")?.data;
+        const poolByItsToken = Object.values(pools).reduce((acc, p) => {
+            p.stakedDieselToken.forEach(t => {
+                if (t)
+                    acc[t] = p.address;
+            });
+            p.stakedDieselToken_old.forEach(t => {
+                if (t)
+                    acc[t] = p.address;
+            });
+            acc[p.dieselToken] = p.address;
             return acc;
         }, {});
-        const extraRewards = Object.entries(merkleXYZLM || {}).reduce((acc, [k, v]) => {
-            const rewardToken = k.toLowerCase();
-            Object.entries(v.reasons).forEach(([key, reason]) => {
-                const poolToken = REWARD_KEYS_RECORD[key];
-                if (poolToken && tokensList[rewardToken]) {
-                    acc.push({
-                        pool: baseRewardPoolsInfo[poolToken].pool,
-                        poolToken,
-                        rewardToken,
-                        amount: (0, sdk_gov_1.toBigInt)(reason.unclaimed || 0n),
-                        type: "extraMerkle",
-                    });
-                }
+        const extraRewards = (merkleXYZLm || []).reduce((acc, chainRewards) => {
+            chainRewards.rewards.forEach(reward => {
+                const rewardToken = reward.token.address.toLowerCase();
+                reward.breakdowns.forEach(reason => {
+                    const poolToken = ((reason.reason || "").split("_")[1] || "").toLowerCase();
+                    const pool = (baseRewardPoolsInfo[poolToken]?.pool ||
+                        poolToken ||
+                        "").toLowerCase();
+                    if (poolByItsToken[poolToken] && poolByItsToken[pool]) {
+                        const total = (0, sdk_gov_1.toBigInt)(reason.amount || 0);
+                        const claimed = (0, sdk_gov_1.toBigInt)(reason.claimed || 0);
+                        acc.push({
+                            pool,
+                            poolToken,
+                            rewardToken,
+                            rewardTokenSymbol: reward.token.symbol,
+                            rewardTokenDecimals: reward.token.decimals || 18,
+                            amount: math_1.BigIntMath.max(total - claimed, 0n),
+                            type: "extraMerkle",
+                        });
+                    }
+                });
             });
             return acc;
         }, []);
         const gearboxLmRewards = poolTokens.map((address, i) => {
+            const info = baseRewardPoolsInfo[address];
+            const rewardToken = currentTokenData[info.symbol];
             return {
-                pool: baseRewardPoolsInfo[address].pool,
+                pool: info.pool,
                 poolToken: address,
-                rewardToken: currentTokenData[baseRewardPoolsInfo[address].symbol],
+                rewardToken,
+                rewardTokenDecimals: tokensList[rewardToken]?.decimals || 18,
+                rewardTokenSymbol: info.symbol,
                 amount: gearboxLm[i] || 0n,
                 type: "stakedV3",
             };

package/lib/gearboxRewards/merklAPI.d.ts

@@ -4,21 +4,50 @@ interface UserOptions {
     params: {
         user: string;
         chainId: number;
-        mainParameter?: string;
-        rewardToken?: string;
     };
 }
-export interface MerkleXYZUserRewards {
-    accumulated: BigNumberish;
-    decimals: number;
-    reasons: Record<string, {
-        accumulated: BigNumberish;
-        unclaimed: BigNumberish;
+export interface MerkleXYZUserRewardsV4 {
+    chain: MerkleXYZChain;
+    rewards: Array<{
+        root: Address;
+        recipient: Address;
+        amount: BigNumberish;
+        claimed: BigNumberish;
+        pending: BigNumberish;
+        proofs: Array<Address>;
+        token: {
+            address: Address;
+            chainId: number;
+            symbol: string;
+            decimals: number;
+        };
+        breakdowns: Array<{
+            reason: string;
+            amount: BigNumberish;
+            claimed: BigNumberish;
+            pending: BigNumberish;
+            campaignId: Address;
+        }>;
     }>;
+}
+export type MerkleXYZUserRewardsV4Response = Array<MerkleXYZUserRewardsV4>;
+interface MerkleXYZChain {
+    id: number;
+    name: string;
+    icon: string;
+}
+interface MerkleXYZToken {
+    id: string;
+    name: string;
+    chainId: number;
+    address: Address;
+    decimals: number;
+    icon: string;
+    verified: boolean;
+    isTest: boolean;
+    price: number | null;
     symbol: string;
-    unclaimed: BigNumberish;
 }
-export type MerkleXYZUserRewardsResponse = Record<string, MerkleXYZUserRewards>;
 export interface MerklXYZV4Campaign {
     chainId: number;
     type: string;
@@ -31,23 +60,8 @@ export interface MerklXYZV4Campaign {
     dailyRewards: number;
     tags: Array<string>;
     id: string;
-    tokens: Array<{
-        id: string;
-        name: string;
-        chainId: number;
-        address: Address;
-        decimals: number;
-        icon: string;
-        verified: boolean;
-        isTest: boolean;
-        price: number | null;
-        symbol: string;
-    }>;
-    chain: {
-        id: number;
-        name: string;
-        icon: string;
-    };
+    tokens: Array<MerkleXYZToken>;
+    chain: MerkleXYZChain;
     aprRecord: {
         cumulated: number;
         timestamp: string;
@@ -70,19 +84,7 @@ export interface MerklXYZV4Campaign {
         total: number;
         timestamp: string;
         breakdowns: Array<{
-            token: {
-                id: string;
-                name: string;
-                chainId: number;
-                address: Address;
-                decimals: 18;
-                symbol: string;
-                displaySymbol: string;
-                icon: string;
-                verified: boolean;
-                isTest: boolean;
-                price: number;
-            };
+            token: MerkleXYZToken;
             amount: string;
             id: number;
             value: number;
@@ -92,19 +94,45 @@ export interface MerklXYZV4Campaign {
     };
 }
 export type MerkleXYZV4CampaignsResponse = Array<MerklXYZV4Campaign>;
-interface Campaign {
-    amountDecimal: string;
-    campaignId: string;
-    campaignType: number;
-    endTimestamp: number;
-    rewardToken: string;
-    rewardTokenSymbol: string;
-    startTimestamp: number;
+export interface MerklXYZV4RewardCampaign {
+    id: string;
+    computeChainId: number;
+    distributionChainId: number;
+    campaignId: Address;
+    rewardTokenId: string;
+    amount: string;
+    opportunityId: string;
+    startTimestamp: string;
+    endTimestamp: string;
+    creatorAddress: Address;
+    params: {
+        url: string;
+        duration: number;
+        blacklist: Array<Address>;
+        whitelist: Array<Address>;
+        forwarders: Array<Address>;
+        targetToken: Address;
+        symbolRewardToken: string;
+        symbolTargetToken: string;
+        decimalsRewardToken: number;
+        decimalsTargetToken: number;
+    };
+    chain: MerkleXYZChain;
+    rewardToken: MerkleXYZToken;
+    distributionChain: MerkleXYZChain;
+    campaignStatus: {
+        campaignId: string;
+        computedUntil: string;
+        processingStarted: string;
+        status: "SUCCESS";
+        error: string;
+        details: string;
+    };
 }
-export type MerkleXYZRewardsCampaignsResponse = Array<Campaign>;
+export type MerkleXYZV4RewardCampaignResponse = Array<MerklXYZV4RewardCampaign>;
 export declare class MerkleXYZApi {
-    static domain: string;
     static getUserRewardsUrl: (options: UserOptions) => string;
     static getGearboxCampaignsUrl: () => string;
+    static getGearboxRewardCampaignUrl: (campaignId: Address) => string;
 }
 export {};

package/lib/gearboxRewards/merklAPI.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MerkleXYZApi = void 0;
-const endpoint_1 = require("../core/endpoint");
 // https://api.merkl.xyz/v3/campaignsForMainParameter?chainId=1&mainParameter=0xE2037090f896A858E3168B978668F22026AC52e7
 class MerkleXYZApi {
-    static domain = "https://api.merkl.xyz/v3";
-    static getUserRewardsUrl = (options) => endpoint_1.URLApi.getRelativeUrl([this.domain, "userRewards"].join("/"), options);
+    static getUserRewardsUrl = (options) => `https://api.merkl.xyz/v4/users/${options.params.user}/rewards?chainId=${options.params.chainId}`;
     static getGearboxCampaignsUrl = () => "https://api.merkl.xyz/v4/opportunities?name=gearbox";
+    static getGearboxRewardCampaignUrl = (campaignId) => `https://api.merkl.xyz/v4/campaigns?campaignId=${campaignId}`;
 }
 exports.MerkleXYZApi = MerkleXYZApi;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "3.0.0-next.284",
+  "version": "3.0.0-next.286",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",