@defisaver/positions-sdk 2.1.7 → 2.1.9-dev-spark-1

package/src/claiming/compV3.ts

@@ -1,23 +1,23 @@
-import { Client } from 'viem';
-import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
-import { EthAddress, NetworkNumber } from '../types/common';
-import { CompV3ViewContractViem } from '../contracts';
-import { ClaimType } from '../types/claiming';
-
-export const getCompoundV3Rewards = async (provider: Client, network: NetworkNumber, user: EthAddress, market: any) => {
-  const compV3View = CompV3ViewContractViem(provider, network);
-  const rewards = await compV3View.read.getRewardsOwed([market, user]);
-  if (!rewards || rewards.owed.toString() === '0' || getAssetInfoByAddress(rewards.token, network).symbol !== 'COMP') return [];
-  return [{
-    symbol: 'COMP',
-    underlyingSymbol: 'COMP',
-    tokenAddress: rewards.token,
-    amount: assetAmountInEth(rewards.owed.toString() || 0, 'COMP'),
-    walletAddress: user,
-    label: 'Compound V3',
-    claimType: ClaimType.COMPOUND_V3_COMP,
-    additionalClaimFields: {
-      marketAddress: market,
-    },
-  }];
+import { Client } from 'viem';
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import { EthAddress, NetworkNumber } from '../types/common';
+import { CompV3ViewContractViem } from '../contracts';
+import { ClaimType } from '../types/claiming';
+
+export const getCompoundV3Rewards = async (provider: Client, network: NetworkNumber, user: EthAddress, market: any) => {
+  const compV3View = CompV3ViewContractViem(provider, network);
+  const rewards = await compV3View.read.getRewardsOwed([market, user]);
+  if (!rewards || rewards.owed.toString() === '0' || getAssetInfoByAddress(rewards.token, network).symbol !== 'COMP') return [];
+  return [{
+    symbol: 'COMP',
+    underlyingSymbol: 'COMP',
+    tokenAddress: rewards.token,
+    amount: assetAmountInEth(rewards.owed.toString() || 0, 'COMP'),
+    walletAddress: user,
+    label: 'Compound V3',
+    claimType: ClaimType.COMPOUND_V3_COMP,
+    additionalClaimFields: {
+      marketAddress: market,
+    },
+  }];
 };

package/src/claiming/index.ts

@@ -1,13 +1,13 @@
-import * as aaveV3Claim from './aaveV3';
-import * as compV3Claim from './compV3';
-import * as kingV3Claim from './king';
-import * as morphoBlueClaim from './morphoBlue';
-import * as sparkClaim from './spark';
-
-export {
-  aaveV3Claim,
-  compV3Claim,
-  kingV3Claim,
-  morphoBlueClaim,
-  sparkClaim,
+import * as aaveV3Claim from './aaveV3';
+import * as compV3Claim from './compV3';
+import * as kingV3Claim from './king';
+import * as morphoBlueClaim from './morphoBlue';
+import * as sparkClaim from './spark';
+
+export {
+  aaveV3Claim,
+  compV3Claim,
+  kingV3Claim,
+  morphoBlueClaim,
+  sparkClaim,
 };

package/src/claiming/king.ts

@@ -1,66 +1,66 @@
-import Dec from 'decimal.js';
-import { assetAmountInEth } from '@defisaver/tokens';
-import { Client } from 'viem';
-import { UUPSViem } from '../contracts';
-import { EthAddress, HexString, NetworkNumber } from '../types/common';
-import { ClaimType } from '../types/claiming';
-
-export const fetchKingRewards = async (walletAddress: EthAddress) => {
-  try {
-    const res = await fetch(`https://fe.defisaver.com/api/etherfi/get-king-rewards/${walletAddress}`,
-      { signal: AbortSignal.timeout(5000) });
-
-    if (!res.ok) throw new Error(await res.text());
-
-    return await res.json();
-  } catch (err) {
-    console.error('External API Error: Error fetching KING rewards:', err);
-    return { Amount: '0', Root: '', Proofs: [] };
-  }
-};
-
-export const getKingRewards = async (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[]) => {
-  // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
-  const apiDataPromises = walletAddresses.map(address => fetchKingRewards(address));
-  const apiDataArray = await Promise.all(apiDataPromises);
-
-  // Batch all contract calls using multicall
-  const contract = UUPSViem(provider, network);
-  const cumulativePromises = walletAddresses.map(address => contract.read.cumulativeClaimed([address]),
-  );
-  const cumulativeResults = await Promise.all(cumulativePromises);
-
-  // Process results
-  const results: Record<string, any[]> = {};
-
-  for (let i = 0; i < walletAddresses.length; i++) {
-    const walletAddress = walletAddresses[i];
-    const data = apiDataArray[i];
-    const cumulative = cumulativeResults[i];
-
-    const allRewardsAmount = assetAmountInEth(data.Amount, 'KING');
-    const claimedAmount = assetAmountInEth(cumulative.toString(), 'KING');
-    const amountToClaim = new Dec(allRewardsAmount).sub(claimedAmount);
-
-    if (amountToClaim.lessThanOrEqualTo('0')) {
-      results[walletAddress.toLowerCase() as EthAddress] = [];
-    } else {
-      results[walletAddress.toLowerCase() as EthAddress] = [{
-        symbol: 'KING',
-        underlyingSymbol: 'KING',
-        tokenAddress: '0x8F08B70456eb22f6109F57b8fafE862ED28E6040',
-        amount: amountToClaim.toString(),
-        walletAddress,
-        label: 'weETH',
-        claimType: ClaimType.KING_REWARDS,
-        additionalClaimFields: {
-          allRewardsAmount,
-          merkleRoot: data.Root,
-          merkleProofs: data.Proofs,
-        },
-      }];
-    }
-  }
-
-  return results;
-};
+import Dec from 'decimal.js';
+import { assetAmountInEth } from '@defisaver/tokens';
+import { Client } from 'viem';
+import { UUPSViem } from '../contracts';
+import { EthAddress, HexString, NetworkNumber } from '../types/common';
+import { ClaimType } from '../types/claiming';
+
+export const fetchKingRewards = async (walletAddress: EthAddress) => {
+  try {
+    const res = await fetch(`https://fe.defisaver.com/api/etherfi/get-king-rewards/${walletAddress}`,
+      { signal: AbortSignal.timeout(5000) });
+
+    if (!res.ok) throw new Error(await res.text());
+
+    return await res.json();
+  } catch (err) {
+    console.error('External API Error: Error fetching KING rewards:', err);
+    return { Amount: '0', Root: '', Proofs: [] };
+  }
+};
+
+export const getKingRewards = async (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[]) => {
+  // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
+  const apiDataPromises = walletAddresses.map(address => fetchKingRewards(address));
+  const apiDataArray = await Promise.all(apiDataPromises);
+
+  // Batch all contract calls using multicall
+  const contract = UUPSViem(provider, network);
+  const cumulativePromises = walletAddresses.map(address => contract.read.cumulativeClaimed([address]),
+  );
+  const cumulativeResults = await Promise.all(cumulativePromises);
+
+  // Process results
+  const results: Record<string, any[]> = {};
+
+  for (let i = 0; i < walletAddresses.length; i++) {
+    const walletAddress = walletAddresses[i];
+    const data = apiDataArray[i];
+    const cumulative = cumulativeResults[i];
+
+    const allRewardsAmount = assetAmountInEth(data.Amount, 'KING');
+    const claimedAmount = assetAmountInEth(cumulative.toString(), 'KING');
+    const amountToClaim = new Dec(allRewardsAmount).sub(claimedAmount);
+
+    if (amountToClaim.lessThanOrEqualTo('0')) {
+      results[walletAddress.toLowerCase() as EthAddress] = [];
+    } else {
+      results[walletAddress.toLowerCase() as EthAddress] = [{
+        symbol: 'KING',
+        underlyingSymbol: 'KING',
+        tokenAddress: '0x8F08B70456eb22f6109F57b8fafE862ED28E6040',
+        amount: amountToClaim.toString(),
+        walletAddress,
+        label: 'weETH',
+        claimType: ClaimType.KING_REWARDS,
+        additionalClaimFields: {
+          allRewardsAmount,
+          merkleRoot: data.Root,
+          merkleProofs: data.Proofs,
+        },
+      }];
+    }
+  }
+
+  return results;
+};

package/src/claiming/morphoBlue.ts

@@ -1,119 +1,119 @@
-import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
-import { Client } from 'viem';
-import Dec from 'decimal.js';
-import { ClaimableToken, ClaimType } from '../types/claiming';
-import { EthAddress, NetworkNumber } from '../types/common';
-import { createViemContractFromConfigFunc } from '../contracts';
-import { getMorphoUnderlyingSymbol } from '../helpers/morphoBlueHelpers';
-
-const MORPHO_ALLOWED_CONTRACTS = [
-  '0x330eefa8a787552DC5cAd3C3cA644844B1E61Ddb',
-  '0x678dDC1d07eaa166521325394cDEb1E4c086DF43',
-  '0x2efd4625d0c149ebadf118ec5446c6de24d916a4',
-];
-
-const MORPHO_ALLOWED_TOKENS = [
-  'MORPHO',
-  'MORPHO Legacy',
-];
-
-
-export const getMorphoBlueRewardsInfo = async (address: EthAddress) => {
-  if (!address) return { claimable: '0' };
-
-  try {
-    const res = await fetch(`https://rewards.morpho.org/v1/users/${address}/distributions`,
-      { signal: AbortSignal.timeout(3000) });
-
-    if (!res.ok) throw new Error(await res.text());
-    return await res.json();
-  } catch (error) {
-    console.error('External API Failure: Morpho Merit', error);
-    return { claimable: '0' };
-  }
-};
-
-export const fetchMorphoBlueRewards = async (
-  provider: Client,
-  network: NetworkNumber,
-  walletAddresses: EthAddress[],
-): Promise<Record<string, ClaimableToken[]>> => {
-  // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
-  const apiDataPromises = walletAddresses.map(address => getMorphoBlueRewardsInfo(address));
-  const apiDataArray = await Promise.all(apiDataPromises);
-
-  // Process API data to get claimable tokens for each wallet
-  const allClaimableTokens: Array<{ walletAddress: EthAddress; tokens: ClaimableToken[] }> = [];
-  const contractCallsData: Array<{ walletAddress: EthAddress; tokenAddress: EthAddress; distributor: EthAddress }> = [];
-
-  for (let i = 0; i < walletAddresses.length; i++) {
-    const walletAddress = walletAddresses[i];
-    const data = apiDataArray[i];
-
-    const claimableTokens = data?.data?.reduce((acc: ClaimableToken[], reward: any) => {
-      const token = getAssetInfoByAddress(reward.asset.address);
-      if (!MORPHO_ALLOWED_CONTRACTS.includes(reward?.distributor?.address) || !MORPHO_ALLOWED_TOKENS.includes(token.symbol)) {
-        return acc;
-      }
-
-      // Store contract call data for batching
-      contractCallsData.push({
-        walletAddress,
-        tokenAddress: reward.asset.address,
-        distributor: reward?.distributor?.address,
-      });
-
-      return [
-        ...acc,
-        {
-          symbol: token.symbol,
-          underlyingSymbol: getMorphoUnderlyingSymbol(token.symbol),
-          tokenAddress: reward.asset.address,
-          amount: assetAmountInEth(reward.claimable, token.symbol),
-          walletAddress,
-          label: token.symbol,
-          claimType: ClaimType.MORPHO,
-          additionalClaimFields: {
-            originalAmount: reward.claimable,
-            distributor: reward?.distributor?.address,
-            merkleProofs: reward?.proof,
-            isLegacy: token.symbol === 'MORPHO Legacy',
-            txData: reward?.tx_data,
-          },
-        }];
-    }, []) || [];
-
-    allClaimableTokens.push({ walletAddress, tokens: claimableTokens });
-  }
-
-  // Batch all contract calls using multicall
-  const contractPromises = contractCallsData.map(({ walletAddress, tokenAddress, distributor }) => {
-    const distributorContract = createViemContractFromConfigFunc('MorphoDistributor', distributor)(provider, network);
-    return distributorContract.read.claimed([walletAddress, tokenAddress]);
-  });
-  const contractResults = await Promise.all(contractPromises);
-
-  // Process results
-  const results: Record<string, ClaimableToken[]> = {};
-  let contractCallIndex = 0;
-
-  for (const { walletAddress, tokens } of allClaimableTokens) {
-    const updatedTokens: ClaimableToken[] = [];
-
-    for (let i = 0; i < tokens.length; i++) {
-      const claimableToken = tokens[i];
-      const claimed = assetAmountInEth(contractResults[contractCallIndex].toString(), claimableToken.underlyingSymbol);
-      contractCallIndex++;
-
-      const updatedToken = { ...claimableToken };
-      updatedToken.amount = new Dec(claimableToken.amount).sub(claimed).toString();
-      updatedTokens.push(updatedToken);
-    }
-
-    results[walletAddress.toLowerCase() as EthAddress] = updatedTokens.filter(
-      (claimableToken) => new Dec(claimableToken.amount).gt(0),
-    );
-  }
-
-  return results;
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import { Client } from 'viem';
+import Dec from 'decimal.js';
+import { ClaimableToken, ClaimType } from '../types/claiming';
+import { EthAddress, NetworkNumber } from '../types/common';
+import { createViemContractFromConfigFunc } from '../contracts';
+import { getMorphoUnderlyingSymbol } from '../helpers/morphoBlueHelpers';
+
+const MORPHO_ALLOWED_CONTRACTS = [
+  '0x330eefa8a787552DC5cAd3C3cA644844B1E61Ddb',
+  '0x678dDC1d07eaa166521325394cDEb1E4c086DF43',
+  '0x2efd4625d0c149ebadf118ec5446c6de24d916a4',
+];
+
+const MORPHO_ALLOWED_TOKENS = [
+  'MORPHO',
+  'MORPHO Legacy',
+];
+
+
+export const getMorphoBlueRewardsInfo = async (address: EthAddress) => {
+  if (!address) return { claimable: '0' };
+
+  try {
+    const res = await fetch(`https://rewards.morpho.org/v1/users/${address}/distributions`,
+      { signal: AbortSignal.timeout(3000) });
+
+    if (!res.ok) throw new Error(await res.text());
+    return await res.json();
+  } catch (error) {
+    console.error('External API Failure: Morpho Merit', error);
+    return { claimable: '0' };
+  }
+};
+
+export const fetchMorphoBlueRewards = async (
+  provider: Client,
+  network: NetworkNumber,
+  walletAddresses: EthAddress[],
+): Promise<Record<string, ClaimableToken[]>> => {
+  // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
+  const apiDataPromises = walletAddresses.map(address => getMorphoBlueRewardsInfo(address));
+  const apiDataArray = await Promise.all(apiDataPromises);
+
+  // Process API data to get claimable tokens for each wallet
+  const allClaimableTokens: Array<{ walletAddress: EthAddress; tokens: ClaimableToken[] }> = [];
+  const contractCallsData: Array<{ walletAddress: EthAddress; tokenAddress: EthAddress; distributor: EthAddress }> = [];
+
+  for (let i = 0; i < walletAddresses.length; i++) {
+    const walletAddress = walletAddresses[i];
+    const data = apiDataArray[i];
+
+    const claimableTokens = data?.data?.reduce((acc: ClaimableToken[], reward: any) => {
+      const token = getAssetInfoByAddress(reward.asset.address);
+      if (!MORPHO_ALLOWED_CONTRACTS.includes(reward?.distributor?.address) || !MORPHO_ALLOWED_TOKENS.includes(token.symbol)) {
+        return acc;
+      }
+
+      // Store contract call data for batching
+      contractCallsData.push({
+        walletAddress,
+        tokenAddress: reward.asset.address,
+        distributor: reward?.distributor?.address,
+      });
+
+      return [
+        ...acc,
+        {
+          symbol: token.symbol,
+          underlyingSymbol: getMorphoUnderlyingSymbol(token.symbol),
+          tokenAddress: reward.asset.address,
+          amount: assetAmountInEth(reward.claimable, token.symbol),
+          walletAddress,
+          label: token.symbol,
+          claimType: ClaimType.MORPHO,
+          additionalClaimFields: {
+            originalAmount: reward.claimable,
+            distributor: reward?.distributor?.address,
+            merkleProofs: reward?.proof,
+            isLegacy: token.symbol === 'MORPHO Legacy',
+            txData: reward?.tx_data,
+          },
+        }];
+    }, []) || [];
+
+    allClaimableTokens.push({ walletAddress, tokens: claimableTokens });
+  }
+
+  // Batch all contract calls using multicall
+  const contractPromises = contractCallsData.map(({ walletAddress, tokenAddress, distributor }) => {
+    const distributorContract = createViemContractFromConfigFunc('MorphoDistributor', distributor)(provider, network);
+    return distributorContract.read.claimed([walletAddress, tokenAddress]);
+  });
+  const contractResults = await Promise.all(contractPromises);
+
+  // Process results
+  const results: Record<string, ClaimableToken[]> = {};
+  let contractCallIndex = 0;
+
+  for (const { walletAddress, tokens } of allClaimableTokens) {
+    const updatedTokens: ClaimableToken[] = [];
+
+    for (let i = 0; i < tokens.length; i++) {
+      const claimableToken = tokens[i];
+      const claimed = assetAmountInEth(contractResults[contractCallIndex].toString(), claimableToken.underlyingSymbol);
+      contractCallIndex++;
+
+      const updatedToken = { ...claimableToken };
+      updatedToken.amount = new Dec(claimableToken.amount).sub(claimed).toString();
+      updatedTokens.push(updatedToken);
+    }
+
+    results[walletAddress.toLowerCase() as EthAddress] = updatedTokens.filter(
+      (claimableToken) => new Dec(claimableToken.amount).gt(0),
+    );
+  }
+
+  return results;
 };