@defisaver/positions-sdk 2.0.14 → 2.0.15-dev-2

package/src/aaveV3/merit.ts

@@ -0,0 +1,98 @@
+
+import { DEFAULT_TIMEOUT } from '../services/utils';
+import { NetworkNumber } from '../types/common';
+import { aprToApy } from '../moneymarket';
+import { AaveVersions } from '../types';
+
+
+type RewardInfo = { apy: string; rewardTokenSymbol: string, description: string };
+type MeritTokenRewardMap = { supply: Record<string, RewardInfo>; borrow: Record<string, RewardInfo> };
+
+/**
+ * Maps API keys to reward data & actions - hardcoded and needs to be maintained actively.
+ * Mapping based on Aave interface implementation: https://github.com/aave/interface/blob/main/src/hooks/useMeritIncentives.ts
+ * Active campaigns found here: https://apps.aavechan.com/merit
+ */
+const MERIT_DATA_MAP:
+Record<
+NetworkNumber,
+Partial<Record<
+AaveVersions,
+Record<string, {
+  rewardTokenSymbol: string;
+  action: 'supply' | 'borrow' | 'stake';
+  message?: string;
+  supplyTokens?: string[],
+  borrowTokens?: string[],
+}>
+>>
+> = {
+  [NetworkNumber.Eth]: {
+    [AaveVersions.AaveV3]: {
+      'ethereum-supply-ethx': { rewardTokenSymbol: 'SD', action: 'supply', supplyTokens: ['ETHx'] },
+      'ethereum-supply-rlusd': { rewardTokenSymbol: 'aEthRLUSD', action: 'supply', supplyTokens: ['RLUSD'] },
+      // Campaign disabled here as it's present on Merkl API:
+      // 'ethereum-borrow-eurc': { rewardTokenSymbol: 'aEthEURC', action: 'borrow', borrowTokens: ['EURC'] },
+    },
+    [AaveVersions.AaveV3Lido]: {},
+    [AaveVersions.AaveV3Etherfi]: {},
+  },
+  [NetworkNumber.Arb]: {
+    [AaveVersions.AaveV3]: {},
+  },
+  [NetworkNumber.Opt]: {
+    [AaveVersions.AaveV3]: {},
+  },
+  [NetworkNumber.Base]: {
+    [AaveVersions.AaveV3]: {
+      'base-borrow-usdc': { rewardTokenSymbol: 'USDC', action: 'borrow', borrowTokens: ['USDC'] },
+      'base-borrow-gho': { rewardTokenSymbol: 'GHO', action: 'borrow', borrowTokens: ['GHO'] },
+      'base-borrow-eurc': { rewardTokenSymbol: 'EURC', action: 'borrow', borrowTokens: ['EURC'] },
+    },
+  },
+  [NetworkNumber.Linea]: {
+    [AaveVersions.AaveV3]: {},
+  },
+};
+
+/**
+ * Fetches merit rewards data from Aave API
+ */
+export const fetchMeritRewardsData = async (): Promise<Record<string, number | null>> => {
+  try {
+    const response = await fetch('https://apps.aavechan.com/api/merit/aprs', {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT),
+    });
+    const data = await response.json();
+    return data.currentAPR.actionsAPR as Record<string, number | null>;
+  } catch (error) {
+    console.error('Failed to fetch merit rewards data:', error);
+    return {};
+  }
+};
+
+export const getMeritCampaigns = async (chainId: NetworkNumber, market: AaveVersions): Promise<MeritTokenRewardMap> => {
+  const meritData = await fetchMeritRewardsData();
+  const relevantCampaigns = {
+    supply: {},
+    borrow: {},
+  } as MeritTokenRewardMap;
+  Object.entries(MERIT_DATA_MAP[chainId]?.[market] || {})
+    .filter(([key, rewardData]) => !!meritData[key])
+    .forEach(([key, rewardData]) => {
+      const apr = meritData[key]!;
+      if (!apr) return;
+      const reward = {
+        rewardTokenSymbol: rewardData.rewardTokenSymbol,
+        apy: aprToApy(apr).toString(),
+        description: `Eligible for Merit rewards in ${rewardData.rewardTokenSymbol}. ${rewardData.message ? `\n${rewardData.message}` : ''}`,
+      };
+      rewardData.supplyTokens?.forEach(token => {
+        relevantCampaigns.supply[token] = reward;
+      });
+      rewardData.borrowTokens?.forEach(token => {
+        relevantCampaigns.borrow[token] = reward;
+      });
+    });
+  return relevantCampaigns;
+};

package/src/aaveV3/merkl.ts

@@ -0,0 +1,141 @@
+import { aprToApy } from '../moneymarket';
+import { DEFAULT_TIMEOUT, wethToEth } from '../services/utils';
+import { EthAddress, NetworkNumber } from '../types/common';
+
+enum OpportunityAction {
+  LEND = 'LEND',
+  BORROW = 'BORROW',
+}
+
+enum OpportunityStatus {
+  LIVE = 'LIVE',
+  PAST = 'PAST',
+  UPCOMING = 'UPCOMING',
+}
+
+type MerklOpportunity = {
+  chainId: number;
+  type: string;
+  identifier: EthAddress;
+  name: string;
+  status: OpportunityStatus;
+  action: OpportunityAction;
+  tvl: number;
+  apr: number;
+  dailyRewards: number;
+  tags: [];
+  id: string;
+  explorerAddress?: EthAddress;
+  description?: string;
+  tokens: {
+    id: string;
+    name: string;
+    chainId: number;
+    address: EthAddress;
+    decimals: number;
+    icon: string;
+    verified: boolean;
+    isTest: boolean;
+    price: number;
+    symbol: string;
+  }[];
+  rewardsRecord: {
+    id: string;
+    total: number;
+    timestamp: string;
+    breakdowns: {
+      token: {
+        id: string;
+        name: string;
+        chainId: number;
+        address: EthAddress;
+        decimals: number;
+        symbol: string;
+        displaySymbol: string;
+        icon: string;
+        verified: boolean;
+        isTest: boolean;
+        type: string;
+        isNative: boolean;
+        price: number;
+      };
+      amount: string;
+      value: number;
+      distributionType: string;
+      id: string;
+      campaignId: string;
+      dailyRewardsRecordId: string;
+    }[];
+  };
+};
+
+type RewardInfo = { apy: string; rewardTokenSymbol: string, description: string, identifier: string };
+type MerkleRewardMap = Record<EthAddress, { supply?: RewardInfo; borrow?: RewardInfo }>;
+
+export const getAaveUnderlyingSymbol = (_symbol = '') => {
+  let symbol = _symbol
+    .replace(/^aEthLido/, '')
+    .replace(/^aEthEtherFi/, '')
+    .replace(/^aEth/, '')
+    .replace(/^aArb/, '')
+    .replace(/^aOpt/, '')
+    .replace(/^aBas/, '')
+    .replace(/^aLin/, '');
+  if (symbol.startsWith('a')) symbol = symbol.slice(1);
+  return wethToEth(symbol);
+};
+
+/**
+ * aEthLidoUSDC -> aUSDC
+ * USDC -> USDC
+ */
+export const formatAaveAsset = (_symbol: string) => {
+  if (_symbol.startsWith('a')) {
+    return `a${getAaveUnderlyingSymbol(_symbol)}`;
+  }
+  return _symbol;
+};
+
+export const getMerkleCampaigns = async (chainId: NetworkNumber): Promise<MerkleRewardMap> => {
+  try {
+    const res = await fetch('https://api.merkl.xyz/v4/opportunities?mainProtocolId=aave', {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT),
+    });
+    if (!res.ok) throw new Error('Failed to fetch Merkle campaigns');
+    const opportunities = await res.json() as MerklOpportunity[];
+    const relevantOpportunities = opportunities
+      .filter((o: MerklOpportunity) => o.chainId === chainId)
+      .filter((o: MerklOpportunity) => o.status === OpportunityStatus.LIVE);
+    return relevantOpportunities.reduce((acc, opportunity) => {
+      const rewardToken = opportunity.rewardsRecord.breakdowns[0].token;
+      const description = `Eligible for ${formatAaveAsset(rewardToken.symbol)} rewards through Merkl. ${opportunity.description ? `\n${opportunity.description}` : ''}`;
+      if (opportunity.action === OpportunityAction.LEND && opportunity.explorerAddress) {
+        const supplyAToken = opportunity.explorerAddress?.toLowerCase() as EthAddress;
+        if (!acc[supplyAToken]) acc[supplyAToken] = {};
+        acc[supplyAToken].supply = {
+          apy: aprToApy(opportunity.apr),
+          // rewardToken: rewardToken.address,
+          rewardTokenSymbol: rewardToken.symbol,
+          description,
+          identifier: opportunity.identifier,
+        };
+      }
+      if (opportunity.action === OpportunityAction.BORROW && opportunity.explorerAddress) {
+        const borrowAToken = opportunity.explorerAddress?.toLowerCase() as EthAddress;
+        if (!acc[borrowAToken]) acc[borrowAToken] = {};
+        acc[borrowAToken].borrow = {
+          apy: aprToApy(opportunity.apr),
+          // rewardToken: rewardToken.address,
+          rewardTokenSymbol: rewardToken.symbol,
+          description,
+          identifier: opportunity.identifier,
+        };
+      }
+      return acc;
+    }, {} as MerkleRewardMap);
+  } catch (e) {
+    console.error('Failed to fetch Merkle campaigns', e);
+    return {};
+  }
+};
+