@gearbox-protocol/sdk 3.0.0-next.99 → 3.0.0-prevfour.10

package/lib/core/protocols.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProtocolData = exports.isExtendedProtocol = void 0;
+const PROTOCOL_DATA = {
+    Uniswap: {
+        name: "Uniswap",
+        icon: "/protocols/uniswap.png",
+    },
+    Sushiswap: {
+        name: "Sushiswap",
+        icon: "/protocols/sushi.svg",
+    },
+    Curve: {
+        name: "Curve",
+        icon: "/protocols/curve.svg",
+    },
+    Yearn: {
+        name: "Yearn",
+        icon: "/protocols/yearn.svg",
+    },
+    Convex: {
+        name: "Convex",
+        icon: "/protocols/convex.svg",
+    },
+    Lido: {
+        name: "Lido",
+        icon: "/protocols/lido.svg",
+    },
+    Gearbox: {
+        name: "Gearbox",
+        icon: "/protocols/gearbox.svg",
+    },
+    Balancer: {
+        name: "Balancer",
+        icon: "/protocols/balancer.svg",
+    },
+    AaveV2: {
+        name: "Aave V2",
+        icon: "/protocols/aavev2.svg",
+    },
+    CompoundV2: {
+        name: "Compound V2",
+        icon: "/protocols/compoundv2.svg",
+    },
+    Flux: {
+        name: "Flux",
+        icon: "/protocols/flux.svg",
+    },
+    Aura: {
+        name: "Aura",
+        icon: "/protocols/aura.svg",
+    },
+    MakerDSR: {
+        name: "MakerDSR",
+        icon: "/protocols/maker.svg",
+    },
+    Sommelier: {
+        name: "Sommelier",
+        icon: "/protocols/sommelier.svg",
+    },
+    Fraxswap: {
+        name: "Fraxswap",
+        icon: "/protocols/fraxswap.svg",
+    },
+    Stakewise: {
+        name: "Stakewise",
+        icon: "/protocols/stakewise.svg",
+    },
+    Rocketpool: {
+        name: "Rocketpool",
+        icon: "/protocols/rocketpool.svg",
+    },
+    Etherfi: {
+        name: "Ether.fi",
+        icon: "/protocols/etherfi.svg",
+    },
+    Renzo: {
+        name: "Renzo",
+        icon: "/protocols/renzo.svg",
+    },
+    Coinbase: {
+        name: "Coinbase",
+        icon: "/protocols/coinbase.svg",
+    },
+    Camelot: {
+        name: "Camelot",
+        icon: "/protocols/camelot.svg",
+    },
+    Ethena: {
+        name: "Ethena",
+        icon: "/protocols/ethena.svg",
+    },
+    Velodrome: {
+        name: "Velodrome",
+        icon: "/protocols/velodrome.svg",
+    },
+    AaveV3: {
+        name: "Aave V3",
+        icon: "/protocols/aavev3.svg",
+    },
+    Kelp: {
+        name: "Kelp",
+        icon: "/protocols/kelp.svg",
+    },
+    Pancakeswap: {
+        name: "Pancakeswap",
+        icon: "/protocols/pancakeswap.svg",
+    },
+    Swell: {
+        name: "Swell",
+        icon: "/protocols/swell.svg",
+    },
+    Puffer: {
+        name: "Puffer",
+        icon: "/protocols/puffer.svg",
+    },
+    Zircuit: {
+        name: "Zircuit",
+        icon: "/protocols/zircuit.svg",
+    },
+    Mellow: {
+        name: "Mellow",
+        icon: "/protocols/mellow.svg",
+    },
+    Pendle: {
+        name: "Pendle",
+        icon: "/protocols/pendle.svg",
+    },
+    Lombard: {
+        name: "Lombard",
+        icon: "/protocols/lombard.svg",
+    },
+    Sky: {
+        name: "Sky",
+        icon: "/protocols/sky.svg",
+    },
+};
+const isExtendedProtocol = (t) => typeof t === "string" && !!PROTOCOL_DATA[t];
+exports.isExtendedProtocol = isExtendedProtocol;
+function getProtocolData(t) {
+    return (0, exports.isExtendedProtocol)(t)
+        ? PROTOCOL_DATA[t]
+        : { name: "unknown", icon: "" };
+}
+exports.getProtocolData = getProtocolData;

package/lib/core/rewardClaimer/aura.d.ts

@@ -0,0 +1 @@
+export declare function getAURAMintAmount(amount: bigint, totalSupply: bigint, multiplier: bigint): bigint;

package/lib/core/rewardClaimer/aura.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAURAMintAmount = void 0;
+const CVX_MAX_SUPPLY = 50000000000000000000000000n;
+const CVX_REDUCTION_PER_CLIFF = 100000000000000000000000n;
+const CVX_TOTAL_CLIFFS = 500n;
+const INITIAL_SUPPLY = 5n * 10n ** 25n;
+const INITIAL_CLIFFS = 700n;
+function getAURAMintAmount(amount, totalSupply, multiplier) {
+    if (totalSupply <= 0n)
+        return 0n;
+    const effectiveAmount = (amount * multiplier) / 10000n;
+    const emissionMinted = totalSupply - INITIAL_SUPPLY;
+    const cliff = emissionMinted / CVX_REDUCTION_PER_CLIFF;
+    if (cliff < CVX_TOTAL_CLIFFS) {
+        const reduction = INITIAL_CLIFFS + ((CVX_TOTAL_CLIFFS - cliff) * 5n) / 2n;
+        const mintedAmount = (effectiveAmount * reduction) / CVX_TOTAL_CLIFFS;
+        const amountTillMax = CVX_MAX_SUPPLY - emissionMinted;
+        return mintedAmount > amountTillMax ? amountTillMax : mintedAmount;
+    }
+    return 0n;
+}
+exports.getAURAMintAmount = getAURAMintAmount;

package/lib/core/rewardClaimer/auraAbi.d.ts

@@ -0,0 +1,15 @@
+export declare const AURA_BOOSTER_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "input";
+        readonly type: "address";
+    }];
+    readonly name: "getRewardMultipliers";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "multiplier";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

package/lib/core/rewardClaimer/auraAbi.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AURA_BOOSTER_ABI = void 0;
+exports.AURA_BOOSTER_ABI = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "input",
+                type: "address",
+            },
+        ],
+        name: "getRewardMultipliers",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "multiplier",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];

package/lib/core/rewardClaimer/convex.d.ts

@@ -0,0 +1 @@
+export declare function getCVXMintAmount(crvAmount: bigint, cvxTokenSupply: bigint): bigint;

package/lib/core/rewardClaimer/convex.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCVXMintAmount = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const CVX_MAX_SUPPLY = sdk_gov_1.WAD * 100000000n;
+const CVX_REDUCTION_PER_CLIFF = 100000n;
+const CVX_TOTAL_CLIFFS = sdk_gov_1.WAD * 1000n;
+function getCVXMintAmount(crvAmount, cvxTokenSupply) {
+    const currentCliff = cvxTokenSupply / CVX_REDUCTION_PER_CLIFF;
+    if (currentCliff < CVX_TOTAL_CLIFFS) {
+        const remainingCliffs = CVX_TOTAL_CLIFFS - currentCliff;
+        const mintedAmount = (crvAmount * remainingCliffs) / CVX_TOTAL_CLIFFS;
+        const amountTillMax = CVX_MAX_SUPPLY - cvxTokenSupply;
+        return mintedAmount > amountTillMax ? amountTillMax : mintedAmount;
+    }
+    return 0n;
+}
+exports.getCVXMintAmount = getCVXMintAmount;

package/lib/core/rewardClaimer/index.d.ts

@@ -0,0 +1,25 @@
+import { NetworkType, PartialRecord, Protocols, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address, PublicClient } from "viem";
+import { MultiCall } from "../../pathfinder/core";
+import { CreditAccountData } from "../creditAccount";
+import { CreditManagerData } from "../creditManager";
+export interface Rewards {
+    contract: SupportedContract;
+    protocol: Protocols.Aura | Protocols.Convex | Protocols.Sky;
+    rewards: PartialRecord<SupportedToken, bigint>;
+    calls: Array<MultiCall>;
+}
+export interface AdapterWithType {
+    contractAddress: Address;
+    adapter: Address;
+    contract: SupportedContract;
+}
+export declare class RewardClaimer {
+    static findRewards(ca: CreditAccountData, cm: CreditManagerData, network: NetworkType, provider: PublicClient): Promise<Array<Rewards>>;
+    static findRewardTokens(cm: CreditManagerData, provider: PublicClient): Promise<{
+        staking: {
+            adapters: AdapterWithType[];
+            tokens: (`0x${string}` | undefined)[];
+        };
+    }>;
+}

package/lib/core/rewardClaimer/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardClaimer = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const rewardConvex_1 = require("./rewardConvex");
+const stakingRewards_1 = require("./stakingRewards");
+class RewardClaimer {
+    static async findRewards(ca, cm, network, provider) {
+        const tokens = await RewardClaimer.findRewardTokens(cm, provider);
+        const [convex, staking] = await Promise.all([
+            rewardConvex_1.RewardConvex.findRewards(ca, cm, network, provider),
+            stakingRewards_1.StakingRewards.findRewards(ca, provider, tokens.staking.adapters, tokens.staking.tokens),
+        ]);
+        return [...convex, ...staking];
+    }
+    static async findRewardTokens(cm, provider) {
+        const { calls: stakingCalls, adapters: stakingAdapters } = stakingRewards_1.StakingRewards.getRewardTokenCalls(cm);
+        const stakingTotal = stakingCalls.flat(1);
+        const response = await provider.multicall({
+            allowFailure: true,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: [...stakingTotal],
+        });
+        const stakingEnd = stakingTotal.length;
+        const stakingRewardTokensResponse = response.slice(0, stakingEnd);
+        return {
+            staking: {
+                adapters: stakingAdapters,
+                tokens: stakingRewardTokensResponse.map(r => r?.result),
+            },
+        };
+    }
+}
+exports.RewardClaimer = RewardClaimer;

package/lib/core/rewardClaimer/rewardConvex.d.ts

@@ -0,0 +1,42 @@
+import { NetworkType, Protocols, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Abi, Address, PublicClient } from "viem";
+import { CreditAccountData } from "../creditAccount";
+import { CreditManagerData } from "../creditManager";
+import { AdapterWithType, Rewards } from "../rewardClaimer";
+type DistributionList = Array<Array<RewardDistribution>>;
+type CallsList = Array<Array<{
+    address: Address;
+    abi: Abi;
+    functionName: string;
+    args: unknown[];
+}>>;
+export interface RewardDistribution {
+    contract: Rewards["contract"];
+    protocol: Rewards["protocol"];
+    token: SupportedToken;
+    adapter: Address;
+    contractAddress: Address;
+}
+interface ParseProps {
+    convexResponse: Array<bigint>;
+    convexDistribution: DistributionList;
+    convexTotalSupply: bigint;
+    auraResponse: Array<bigint>;
+    auraDistribution: DistributionList;
+    auraTotalSupply: bigint;
+}
+export declare class RewardConvex {
+    static findRewards(ca: CreditAccountData, cm: CreditManagerData, network: NetworkType, provider: PublicClient): Promise<Array<Rewards>>;
+    static findAdapters(cm: CreditManagerData): AdapterWithType[];
+    static prepareMultiCalls(creditAccount: Address, cm: CreditManagerData, network: NetworkType): {
+        convexDistribution: DistributionList;
+        auraDistribution: DistributionList;
+        convexCalls: CallsList;
+        auraCalls: CallsList;
+    } | undefined;
+    static parseResults({ convexDistribution, convexResponse, convexTotalSupply, auraDistribution, auraResponse, auraTotalSupply, }: ParseProps): Array<Rewards>;
+    static getRewardObject(baseReward: bigint, baseDistribution: RewardDistribution, boostedRewardToken: SupportedToken, extraDistribution: Array<RewardDistribution>, rewardsResp: Array<bigint>, totalSupply: bigint, callData: Address, multiplier: bigint): Rewards | undefined;
+    static getBaseRewardToken(protocol: Protocols): SupportedToken | undefined;
+    static getBBoostedRewardToken(protocol: Protocols): SupportedToken | undefined;
+}
+export {};

package/lib/core/rewardClaimer/rewardConvex.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardConvex = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const viem_1 = require("viem");
+const types_1 = require("../../types");
+const aura_1 = require("./aura");
+const auraAbi_1 = require("./auraAbi");
+const convex_1 = require("./convex");
+// convex[totalSupply, ...tokens] aura[totalSupply, multiplier, ...tokens]
+class RewardConvex {
+    static async findRewards(ca, cm, network, provider) {
+        const prepared = RewardConvex.prepareMultiCalls(ca.creditAccount, cm, network);
+        if (!prepared)
+            return [];
+        const { auraCalls, auraDistribution, convexCalls, convexDistribution } = prepared;
+        const auraTotal = auraCalls.flat(1);
+        const convexTotal = convexCalls.flat(1);
+        const allCalls = [...auraTotal, ...convexTotal];
+        if (allCalls.length === 0)
+            return [];
+        const response = (await provider.multicall({
+            allowFailure: false,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: allCalls,
+        }));
+        const auraEnd = auraTotal.length;
+        const [auraTotalSupply, ...auraResponse] = response.slice(0, auraEnd);
+        const convexEnd = auraEnd + convexTotal.length;
+        const [convexTotalSupply, ...convexResponse] = response.slice(auraEnd, convexEnd);
+        const results = RewardConvex.parseResults({
+            auraDistribution,
+            auraResponse,
+            auraTotalSupply: auraTotalSupply,
+            convexDistribution,
+            convexResponse,
+            convexTotalSupply: convexTotalSupply,
+        });
+        return results;
+    }
+    static findAdapters(cm) {
+        const convexPools = sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.contractParams).reduce((acc, [token, params]) => {
+            if (params.type === sdk_gov_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL) {
+                acc[token] = params;
+            }
+            return acc;
+        }, {});
+        return Object.entries(cm.adapters)
+            .filter(([contract]) => !!convexPools[sdk_gov_1.contractsByAddress[contract.toLowerCase()]])
+            .map(([contract, adapter]) => ({
+            adapter,
+            contractAddress: contract,
+            contract: sdk_gov_1.contractsByAddress[contract.toLowerCase()],
+        }));
+    }
+    static prepareMultiCalls(creditAccount, cm, network) {
+        const tokens = sdk_gov_1.tokenDataByNetwork[network];
+        const contracts = sdk_gov_1.contractsByNetwork[network];
+        const adapters = this.findAdapters(cm);
+        if (adapters.length === 0) {
+            return undefined;
+        }
+        const res = adapters.reduce((acc, a) => {
+            const currentContract = sdk_gov_1.contractParams[a.contract];
+            const baseRewardToken = this.getBaseRewardToken(currentContract.protocol);
+            if (!baseRewardToken) {
+                throw new Error(`Unknown rewards protocol: ${currentContract.protocol}`);
+            }
+            const currentCalls = [
+                ...(currentContract.protocol === sdk_gov_1.Protocols.Aura
+                    ? [
+                        {
+                            address: contracts.AURA_BOOSTER,
+                            abi: auraAbi_1.AURA_BOOSTER_ABI,
+                            functionName: "getRewardMultipliers",
+                            args: [tokens[currentContract.stakedToken]],
+                        },
+                    ]
+                    : []),
+            ];
+            const currentDistribution = [];
+            currentCalls.push({
+                address: a.contractAddress,
+                abi: types_1.iBaseRewardPoolAbi,
+                functionName: "earned",
+                args: [creditAccount],
+            });
+            currentDistribution.push({
+                protocol: currentContract.protocol,
+                contract: a.contract,
+                token: baseRewardToken,
+                contractAddress: a.contractAddress,
+                adapter: a.adapter,
+            });
+            currentContract.extraRewards.forEach(extra => {
+                currentCalls.push({
+                    address: extra.poolAddress[network],
+                    abi: types_1.iBaseRewardPoolAbi,
+                    functionName: "earned",
+                    args: [creditAccount],
+                });
+                currentDistribution.push({
+                    protocol: currentContract.protocol,
+                    contract: a.contract,
+                    token: extra.rewardToken,
+                    contractAddress: a.contractAddress,
+                    adapter: a.adapter,
+                });
+            });
+            if (currentContract.protocol === sdk_gov_1.Protocols.Aura) {
+                acc.auraCalls.push(currentCalls);
+                acc.auraDistribution.push(currentDistribution);
+            }
+            else if (currentContract.protocol === sdk_gov_1.Protocols.Convex) {
+                acc.convexCalls.push(currentCalls);
+                acc.convexDistribution.push(currentDistribution);
+            }
+            return acc;
+        }, {
+            convexDistribution: [],
+            auraDistribution: [],
+            convexCalls: [
+                [
+                    {
+                        address: tokens.CVX,
+                        abi: types_1.iConvexTokenAbi,
+                        functionName: "totalSupply",
+                        args: [],
+                    },
+                ],
+            ],
+            auraCalls: [
+                [
+                    {
+                        address: tokens.AURA,
+                        abi: types_1.iConvexTokenAbi,
+                        functionName: "totalSupply",
+                        args: [],
+                    },
+                ],
+            ],
+        });
+        return res;
+    }
+    static parseResults({ convexDistribution, convexResponse, convexTotalSupply, auraDistribution, auraResponse, auraTotalSupply, }) {
+        const callData = (0, viem_1.encodeFunctionData)({
+            abi: types_1.iBaseRewardPoolAbi,
+            functionName: "getReward",
+            args: [],
+        });
+        const rewardsRecord = {};
+        let start = 0;
+        convexDistribution.forEach(list => {
+            // rewards[]
+            const end = start + list.length;
+            const [baseRewardResp, ...rewardsResp] = convexResponse.slice(start, end);
+            start = end;
+            const [baseDistribution, ...extraDistribution] = list;
+            const boostedRewardToken = this.getBBoostedRewardToken(baseDistribution.protocol);
+            if (rewardsResp.length !== extraDistribution.length ||
+                baseRewardResp === undefined) {
+                throw new Error(`Rewards response length mismatch: expected: ${extraDistribution.length}, got: ${rewardsResp.length}`);
+            }
+            if (!boostedRewardToken) {
+                throw new Error(`Unknown rewards protocol: ${baseDistribution.protocol}`);
+            }
+            // create base
+            const rewardObject = this.getRewardObject(baseRewardResp || 0n, baseDistribution, boostedRewardToken, extraDistribution, rewardsResp, convexTotalSupply, callData, 0n);
+            if (rewardObject)
+                rewardsRecord[baseDistribution.contract] = rewardObject;
+        });
+        start = 0;
+        auraDistribution.forEach(list => {
+            // multiplier + rewards[]
+            const end = start + list.length + 1;
+            const [mp, baseRewardResp, ...rewardsResp] = auraResponse.slice(start, end);
+            start = end;
+            const multiplier = mp;
+            const [baseDistribution, ...extraDistribution] = list;
+            const boostedRewardToken = this.getBBoostedRewardToken(baseDistribution.protocol);
+            if (rewardsResp.length !== extraDistribution.length ||
+                mp === undefined ||
+                baseRewardResp === undefined) {
+                throw new Error(`Rewards response length mismatch: expected: ${extraDistribution.length}, got: ${rewardsResp.length}`);
+            }
+            if (!boostedRewardToken) {
+                throw new Error(`Unknown rewards protocol: ${baseDistribution.protocol}`);
+            }
+            // create base
+            const rewardObject = this.getRewardObject(baseRewardResp || 0n, baseDistribution, boostedRewardToken, extraDistribution, rewardsResp, auraTotalSupply, callData, multiplier);
+            if (rewardObject)
+                rewardsRecord[baseDistribution.contract] = rewardObject;
+        });
+        const result = Object.values(rewardsRecord);
+        return result;
+    }
+    static getRewardObject(baseReward, baseDistribution, boostedRewardToken, extraDistribution, rewardsResp, totalSupply, callData, multiplier) {
+        // create base
+        const base = {
+            contract: baseDistribution.contract,
+            protocol: baseDistribution.protocol,
+            rewards: {
+                [baseDistribution.token]: baseReward,
+            },
+            calls: [
+                {
+                    target: baseDistribution.adapter,
+                    callData,
+                },
+            ],
+        };
+        // add boosted
+        const boostedReward = baseDistribution.protocol === sdk_gov_1.Protocols.Aura
+            ? (0, aura_1.getAURAMintAmount)(baseReward, totalSupply, multiplier)
+            : (0, convex_1.getCVXMintAmount)(baseReward, totalSupply);
+        base.rewards = {
+            ...base.rewards,
+            [boostedRewardToken]: boostedReward,
+        };
+        // extra
+        extraDistribution.forEach((distribution, j) => {
+            const token = distribution.token;
+            const prevReward = base.rewards[token] || 0n;
+            const reward = rewardsResp[j] || 0n;
+            base.rewards = {
+                ...base.rewards,
+                [token]: prevReward + reward,
+            };
+        });
+        if (Object.values(base.rewards).some(r => r > 0)) {
+            return base;
+        }
+        return undefined;
+    }
+    static getBaseRewardToken(protocol) {
+        return protocol === sdk_gov_1.Protocols.Aura
+            ? "BAL"
+            : protocol === sdk_gov_1.Protocols.Convex
+                ? "CRV"
+                : undefined;
+    }
+    static getBBoostedRewardToken(protocol) {
+        return protocol === sdk_gov_1.Protocols.Aura
+            ? "AURA"
+            : protocol === sdk_gov_1.Protocols.Convex
+                ? "CVX"
+                : undefined;
+    }
+}
+exports.RewardConvex = RewardConvex;