@defisaver/positions-sdk 2.0.13 → 2.0.14-dev-portfolio1

package/esm/claiming/king.js

@@ -0,0 +1,64 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Dec from 'decimal.js';
+import { assetAmountInEth } from '@defisaver/tokens';
+import { UUPSViem } from '../contracts';
+import { ClaimType } from '../types/claiming';
+export const fetchKingRewards = (walletAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield fetch(`https://fe.defisaver.com/api/etherfi/get-king-rewards/${walletAddress}`, { signal: AbortSignal.timeout(5000) });
+        if (!res.ok)
+            throw new Error(yield res.text());
+        return yield res.json();
+    }
+    catch (err) {
+        console.error('External API Error: Error fetching KING rewards:', err);
+        return { Amount: '0', Root: '', Proofs: [] };
+    }
+});
+export const getKingRewards = (provider, network, walletAddresses) => __awaiter(void 0, void 0, void 0, function* () {
+    // 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 = yield 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 = yield Promise.all(cumulativePromises);
+    // Process results
+    const results = {};
+    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()] = [];
+        }
+        else {
+            results[walletAddress.toLowerCase()] = [{
+                    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/esm/claiming/morphoBlue.d.ts

@@ -0,0 +1,6 @@
+import { Client } from 'viem';
+import { ClaimableToken } from '../types/claiming';
+import { EthAddress, NetworkNumber } from '../types/common';
+export declare const getMorphoUnderlyingSymbol: (_symbol: string) => any;
+export declare const getMorphoBlueRewardsInfo: (address: EthAddress) => Promise<any>;
+export declare const fetchMorphoBlueRewards: (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[]) => Promise<Record<string, ClaimableToken[]>>;

package/esm/claiming/morphoBlue.js

@@ -0,0 +1,104 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import Dec from 'decimal.js';
+import { ClaimType } from '../types/claiming';
+import { createViemContractFromConfigFunc } from '../contracts';
+import { wethToEth } from '../services/utils';
+const MORPHO_ALLOWED_CONTRACTS = [
+    '0x330eefa8a787552DC5cAd3C3cA644844B1E61Ddb',
+    '0x678dDC1d07eaa166521325394cDEb1E4c086DF43',
+    '0x2efd4625d0c149ebadf118ec5446c6de24d916a4',
+];
+const MORPHO_ALLOWED_TOKENS = [
+    'MORPHO',
+    'MORPHO Legacy',
+];
+export const getMorphoUnderlyingSymbol = (_symbol) => {
+    if (_symbol === 'MORPHO Legacy')
+        return 'MORPHO';
+    return wethToEth(_symbol);
+};
+export const getMorphoBlueRewardsInfo = (address) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!address)
+        return { claimable: '0' };
+    const res = yield fetch(`https://rewards.morpho.org/v1/users/${address}/distributions`, { signal: AbortSignal.timeout(3000) });
+    if (!res.ok)
+        throw new Error(yield res.text());
+    return res.json();
+});
+export const fetchMorphoBlueRewards = (provider, network, walletAddresses) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // 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 = yield Promise.all(apiDataPromises);
+    // Process API data to get claimable tokens for each wallet
+    const allClaimableTokens = [];
+    const contractCallsData = [];
+    for (let i = 0; i < walletAddresses.length; i++) {
+        const walletAddress = walletAddresses[i];
+        const data = apiDataArray[i];
+        const claimableTokens = ((_a = data === null || data === void 0 ? void 0 : data.data) === null || _a === void 0 ? void 0 : _a.reduce((acc, reward) => {
+            var _a, _b, _c;
+            const token = getAssetInfoByAddress(reward.asset.address);
+            if (!MORPHO_ALLOWED_CONTRACTS.includes((_a = reward === null || reward === void 0 ? void 0 : reward.distributor) === null || _a === void 0 ? void 0 : _a.address) || !MORPHO_ALLOWED_TOKENS.includes(token.symbol)) {
+                return acc;
+            }
+            // Store contract call data for batching
+            contractCallsData.push({
+                walletAddress,
+                tokenAddress: reward.asset.address,
+                distributor: (_b = reward === null || reward === void 0 ? void 0 : reward.distributor) === null || _b === void 0 ? void 0 : _b.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: (_c = reward === null || reward === void 0 ? void 0 : reward.distributor) === null || _c === void 0 ? void 0 : _c.address,
+                        merkleProofs: reward === null || reward === void 0 ? void 0 : reward.proof,
+                        isLegacy: token.symbol === 'MORPHO Legacy',
+                        txData: reward === null || reward === void 0 ? void 0 : 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 = yield Promise.all(contractPromises);
+    // Process results
+    const results = {};
+    let contractCallIndex = 0;
+    for (const { walletAddress, tokens } of allClaimableTokens) {
+        const updatedTokens = [];
+        for (let i = 0; i < tokens.length; i++) {
+            const claimableToken = tokens[i];
+            const claimed = assetAmountInEth(contractResults[contractCallIndex].toString(), claimableToken.underlyingSymbol);
+            contractCallIndex++;
+            const updatedToken = Object.assign({}, claimableToken);
+            updatedToken.amount = new Dec(claimableToken.amount).sub(claimed).toString();
+            updatedTokens.push(updatedToken);
+        }
+        results[walletAddress.toLowerCase()] = updatedTokens.filter((claimableToken) => new Dec(claimableToken.amount).gt(0));
+    }
+    return results;
+});

package/esm/claiming/spark.d.ts

@@ -0,0 +1,6 @@
+import { Client } from 'viem';
+import { EthAddress, NetworkNumber } from '../types/common';
+import { SparkRewardsClaimableToken } from '../types/claiming';
+export declare const fetchSpkAirdropRewards: (walletAddress: EthAddress) => Promise<any>;
+export declare const fetchSparkAirdropRewards: (provider: Client, network: NetworkNumber, walletAddresses: EthAddress[]) => Promise<Record<string, any[]>>;
+export declare const fetchSparkRewards: (provider: Client, network: NetworkNumber, walletAddress: EthAddress, marketAddress: EthAddress) => Promise<SparkRewardsClaimableToken[]>;

package/esm/claiming/spark.js

@@ -0,0 +1,179 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { assetAmountInEth, getAssetInfoByAddress } from '@defisaver/tokens';
+import Dec from 'decimal.js';
+import { createViemContractFromConfigFunc, SparkIncentiveDataProviderContractViem, SparkRewardsControllerViem, } from '../contracts';
+import { ClaimType, SparkAirdropType } from '../types/claiming';
+import { compareAddresses, getEthAmountForDecimals } from '../services/utils';
+const IGNITION_REWARDS = '0xCBA0C0a2a0B6Bb11233ec4EA85C5bFfea33e724d';
+const PFL3_REWARDS = '0x7ac96180C4d6b2A328D3a19ac059D0E7Fc3C6d41';
+export const fetchSpkAirdropRewards = (walletAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield fetch(`https://fe.defisaver.com/api/spark/get-spk-airdrop-rewards/${walletAddress}`, { signal: AbortSignal.timeout(3000) });
+        if (!res.ok)
+            throw new Error(yield res.text());
+        return yield res.json();
+    }
+    catch (err) {
+        console.error('External API Error: Error fetching SPK airdrop rewards:', err);
+        return [];
+    }
+});
+const getCumulativeClaimedSpkAirdrop = (provider, network, data) => __awaiter(void 0, void 0, void 0, function* () {
+    const contractIgnition = createViemContractFromConfigFunc('SparkAirdrop', IGNITION_REWARDS)(provider, network);
+    const contractPFL = createViemContractFromConfigFunc('SparkAirdrop', PFL3_REWARDS)(provider, network);
+    const cumulativeAmounts = yield Promise.all(data.map((airdrop) => {
+        const { user, tokenAddress, epoch, type, } = airdrop;
+        const contract = type === SparkAirdropType.SPARK_IGNITION ? contractIgnition : contractPFL;
+        return contract.read.cumulativeClaimed([user, tokenAddress, BigInt(epoch)]);
+    }));
+    return cumulativeAmounts.map((amount, i) => assetAmountInEth(amount.toString(), getAssetInfoByAddress(data[i].tokenAddress).symbol).toString());
+});
+export const fetchSparkAirdropRewards = (provider, network, walletAddresses) => __awaiter(void 0, void 0, void 0, function* () {
+    // Fetch all API data in parallel (these are external API calls, can't be batched with multicall)
+    const apiDataPromises = walletAddresses.map(address => fetchSpkAirdropRewards(address));
+    const apiDataArray = yield Promise.all(apiDataPromises);
+    // Process API data and collect contract call data
+    const allClaimData = [];
+    const contractCallsData = [];
+    for (let i = 0; i < walletAddresses.length; i++) {
+        const walletAddress = walletAddresses[i];
+        const data = apiDataArray[i];
+        const falseResponse = !data;
+        const emptyResponse = data && data.length === 0;
+        const singleResponseWithoutAmount = data && data.length === 1 && !+data[0].amount;
+        if (falseResponse || emptyResponse || singleResponseWithoutAmount) {
+            allClaimData.push({ walletAddress, data: [] });
+            continue;
+        }
+        // Filter out IGNITION_REWARDS since they are no longer active
+        const filteredData = data.filter((rewardInfo) => rewardInfo.type !== SparkAirdropType.SPARK_IGNITION);
+        allClaimData.push({ walletAddress, data: filteredData });
+        // Collect contract call data
+        filteredData.forEach((airdropInfo) => {
+            contractCallsData.push({
+                user: airdropInfo.wallet_address,
+                tokenAddress: airdropInfo.token_address,
+                epoch: airdropInfo.epoch,
+                type: airdropInfo.type,
+            });
+        });
+    }
+    // Batch all contract calls
+    const cumulativeClaimedAmounts = yield getCumulativeClaimedSpkAirdrop(provider, network, contractCallsData);
+    // Process results
+    const results = {};
+    let contractCallIndex = 0;
+    for (const { walletAddress, data } of allClaimData) {
+        if (data.length === 0) {
+            results[walletAddress.toLowerCase()] = [];
+            continue;
+        }
+        const processedRewards = [];
+        for (let i = 0; i < data.length; i++) {
+            const rewardInfo = data[i];
+            const assetInfo = getAssetInfoByAddress(rewardInfo.token_address);
+            const claimedAmount = cumulativeClaimedAmounts[contractCallIndex];
+            contractCallIndex++;
+            const amount = new Dec(rewardInfo.amount_normalized).minus(claimedAmount).toString();
+            if (new Dec(amount).gt('0')) {
+                processedRewards.push({
+                    symbol: assetInfo.symbol,
+                    underlyingSymbol: assetInfo.symbol,
+                    amount,
+                    claimType: ClaimType.SPARK_AIRDROP,
+                    tokenAddress: rewardInfo.token_address,
+                    walletAddress: rewardInfo.wallet_address,
+                    label: 'Spark Airdrop',
+                    additionalClaimFields: {
+                        merkleRoot: rewardInfo.root_hash,
+                        merkleProofs: rewardInfo.proof,
+                        epoch: rewardInfo.epoch,
+                        rewardType: rewardInfo.type,
+                        allRewardsAmount: rewardInfo.amount_normalized,
+                    },
+                });
+            }
+        }
+        results[walletAddress.toLowerCase()] = processedRewards;
+    }
+    return results;
+});
+export const fetchSparkRewards = (provider, network, walletAddress, marketAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = SparkIncentiveDataProviderContractViem(provider, network);
+    const tokensData = yield contract.read.getUserReservesIncentivesData([marketAddress, walletAddress]);
+    const allTokensDataArrays = tokensData.reduce((acc, val) => {
+        acc.push(val.aTokenIncentivesUserData.userRewardsInformation);
+        acc.push(val.vTokenIncentivesUserData.userRewardsInformation);
+        return acc;
+    }, []);
+    const allATokens = tokensData.reduce((acc, val) => {
+        acc.push(val.aTokenIncentivesUserData.tokenAddress);
+        acc.push(val.vTokenIncentivesUserData.tokenAddress);
+        return acc;
+    }, []);
+    const rewardsPerAAsset = yield Promise.all(allATokens.map((token) => {
+        const sparkRewardsContract = SparkRewardsControllerViem(provider, network);
+        return sparkRewardsContract.read.getAllUserRewards([[token], walletAddress]);
+    }));
+    // match amounts to token symbol, parse decimal amounts
+    const rewardsPerAAssetWithInfo = rewardsPerAAsset.map((rewardForAAsset, aaIndex) => {
+        const rewardsList = rewardForAAsset[0];
+        const amounts = rewardForAAsset[1];
+        const rewardsDataArraysForAAsset = allTokensDataArrays[aaIndex];
+        const aTokenAddress = allATokens[aaIndex];
+        return rewardsList.map((rewardTokenAddress, rewardIndex) => {
+            var _a, _b;
+            const dataArrIndex = rewardsDataArraysForAAsset.findIndex((arr) => compareAddresses(arr.rewardTokenAddress, rewardTokenAddress));
+            const amountWei = amounts[rewardIndex];
+            const amount = getEthAmountForDecimals(amountWei.toString(), (_a = rewardsDataArraysForAAsset[dataArrIndex]) === null || _a === void 0 ? void 0 : _a.rewardTokenDecimals);
+            const symbol = ((_b = rewardsDataArraysForAAsset[dataArrIndex]) === null || _b === void 0 ? void 0 : _b.rewardTokenSymbol) || '';
+            const underlyingAsset = symbol;
+            return ({
+                amount,
+                symbol,
+                underlyingAsset,
+                rewardTokenAddress,
+                aTokenAddress,
+            });
+        });
+    });
+    // sum all unclaimed rewards of all markets per each token
+    // (e.g. how much awstETH is claimable in total from both aUSDC and awstETH markets)
+    const totalUnclaimedPerRewardToken = {};
+    rewardsPerAAssetWithInfo
+        .flat()
+        .forEach(({ amount, symbol, underlyingAsset, rewardTokenAddress, aTokenAddress, }) => {
+        if (+amount > 0) {
+            if (!totalUnclaimedPerRewardToken[symbol]) {
+                totalUnclaimedPerRewardToken[symbol] = {
+                    amount, symbol, underlyingAsset, rewardTokenAddress, aTokenAddresses: [aTokenAddress],
+                };
+            }
+            else {
+                totalUnclaimedPerRewardToken[symbol].amount =
+                    new Dec(totalUnclaimedPerRewardToken[symbol].amount).add(amount).toString();
+                totalUnclaimedPerRewardToken[symbol].aTokenAddresses.push(aTokenAddress);
+            }
+        }
+    }, []);
+    return Object.values(totalUnclaimedPerRewardToken).map((reward) => ({
+        symbol: reward.symbol,
+        amount: reward.amount,
+        claimType: ClaimType.SPARK_REWARDS,
+        tokenAddress: reward.rewardTokenAddress,
+        underlyingSymbol: reward.underlyingAsset,
+        walletAddress,
+        label: 'Spark',
+        additionalClaimFields: {
+            sparkAssetAddresses: reward.aTokenAddresses,
+        },
+    }));
+});