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

package/cjs/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/cjs/claiming/spark.js

@@ -0,0 +1,188 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSparkRewards = exports.fetchSparkAirdropRewards = exports.fetchSpkAirdropRewards = void 0;
+const tokens_1 = require("@defisaver/tokens");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const contracts_1 = require("../contracts");
+const claiming_1 = require("../types/claiming");
+const utils_1 = require("../services/utils");
+const IGNITION_REWARDS = '0xCBA0C0a2a0B6Bb11233ec4EA85C5bFfea33e724d';
+const PFL3_REWARDS = '0x7ac96180C4d6b2A328D3a19ac059D0E7Fc3C6d41';
+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 [];
+    }
+});
+exports.fetchSpkAirdropRewards = fetchSpkAirdropRewards;
+const getCumulativeClaimedSpkAirdrop = (provider, network, data) => __awaiter(void 0, void 0, void 0, function* () {
+    const contractIgnition = (0, contracts_1.createViemContractFromConfigFunc)('SparkAirdrop', IGNITION_REWARDS)(provider, network);
+    const contractPFL = (0, contracts_1.createViemContractFromConfigFunc)('SparkAirdrop', PFL3_REWARDS)(provider, network);
+    const cumulativeAmounts = yield Promise.all(data.map((airdrop) => {
+        const { user, tokenAddress, epoch, type, } = airdrop;
+        const contract = type === claiming_1.SparkAirdropType.SPARK_IGNITION ? contractIgnition : contractPFL;
+        return contract.read.cumulativeClaimed([user, tokenAddress, BigInt(epoch)]);
+    }));
+    return cumulativeAmounts.map((amount, i) => (0, tokens_1.assetAmountInEth)(amount.toString(), (0, tokens_1.getAssetInfoByAddress)(data[i].tokenAddress).symbol).toString());
+});
+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 => (0, exports.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 !== claiming_1.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 = (0, tokens_1.getAssetInfoByAddress)(rewardInfo.token_address);
+            const claimedAmount = cumulativeClaimedAmounts[contractCallIndex];
+            contractCallIndex++;
+            const amount = new decimal_js_1.default(rewardInfo.amount_normalized).minus(claimedAmount).toString();
+            if (new decimal_js_1.default(amount).gt('0')) {
+                processedRewards.push({
+                    symbol: assetInfo.symbol,
+                    underlyingSymbol: assetInfo.symbol,
+                    amount,
+                    claimType: claiming_1.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;
+});
+exports.fetchSparkAirdropRewards = fetchSparkAirdropRewards;
+const fetchSparkRewards = (provider, network, walletAddress, marketAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const contract = (0, contracts_1.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 = (0, contracts_1.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) => (0, utils_1.compareAddresses)(arr.rewardTokenAddress, rewardTokenAddress));
+            const amountWei = amounts[rewardIndex];
+            const amount = (0, utils_1.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 decimal_js_1.default(totalUnclaimedPerRewardToken[symbol].amount).add(amount).toString();
+                totalUnclaimedPerRewardToken[symbol].aTokenAddresses.push(aTokenAddress);
+            }
+        }
+    }, []);
+    return Object.values(totalUnclaimedPerRewardToken).map((reward) => ({
+        symbol: reward.symbol,
+        amount: reward.amount,
+        claimType: claiming_1.ClaimType.SPARK_REWARDS,
+        tokenAddress: reward.rewardTokenAddress,
+        underlyingSymbol: reward.underlyingAsset,
+        walletAddress,
+        label: 'Spark',
+        additionalClaimFields: {
+            sparkAssetAddresses: reward.aTokenAddresses,
+        },
+    }));
+});
+exports.fetchSparkRewards = fetchSparkRewards;