@gearbox-protocol/sdk 13.3.0-next.3 → 13.3.1

package/dist/types/common-utils/static/strategy.d.ts

@@ -0,0 +1,78 @@
+import type { Address } from "viem";
+import type { PartialRecord } from "../../sdk/index.js";
+export type TokenTypeStrategy = "eth" | "s" | "btc" | "stable" | "wbnb" | "wxtz" | "bfBTC" | "mon";
+export interface StrategyConfigPayload {
+    name: string;
+    /**
+     * Token symbol of the strategy, is used as key in the strategies list.
+     */
+    id: string;
+    /**
+     * Token address of the strategy
+     */
+    tokenOutAddress: Address;
+    /**
+     * Chain id and network type as they are written in sdk. Wrong entries are being omitted
+     */
+    chainId: number;
+    network: string;
+    /**
+     * Credit managers strategy can be opened on. If it doesn't present - strategy won't be shown
+     */
+    creditManagers: Array<Address>;
+    /**
+     * Strategy type. Used for filtering
+     */
+    strategyType: [TokenTypeStrategy];
+    /**
+     * undefined - released;
+     * number - one value for the current chain.
+     * In ms, for example: 1740398400_000;
+     */
+    releaseAt?: number;
+    /**
+     * An option to show strategies in dev environment only.
+     * undefined, false = no.
+     */
+    hideInProd?: boolean;
+    /** An option to show strategies in main app only.
+     * undefined, true = yes; false = no.
+     */
+    showInMainApp?: boolean;
+    /**
+     * undefined - no restrictions.
+     * number - one value for the current chain.
+     */
+    maxLeverage?: number;
+    /**
+     * undefined, false = no.
+     * PartialRecord<number, boolean> - delayed withdrawal for each chain separately.
+     */
+    delayedWithdrawal?: boolean;
+    /**
+     * previously known as "bad asset", an asset closing account with may need extra capital.
+     * undefined, false = no.
+     * VersionRange - problems only in this range.
+     */
+    issuesOnClose?: boolean | VersionRange;
+    /**
+     * pools in which current token has zero slippage.
+     * pool - boolean.
+     */
+    zeroSlippage?: PartialRecord<Address, boolean>;
+    /**
+     * pools in which additional quota should be bought for current token.
+     * pool - boolean
+     */
+    additionalRewardQuotas?: PartialRecord<Address, Address[]>;
+    /**
+     * If address provided - it is considered that this collateral can be used across all listed cms.
+     * If object provided - it is considered that this collateral can be used only on the specified cm.
+     */
+    additionalCollaterals?: Array<Address | {
+        token: Address;
+        cm: Address;
+    }>;
+}
+type VersionRange = [number, number];
+export {};

package/dist/types/common-utils/static/trading-pair.d.ts

@@ -0,0 +1,15 @@
+import type { Address } from "viem";
+export type TradingType = "long" | "short";
+export interface TradingPairConfigPayload {
+    name: string;
+    type: TradingType;
+    id: string;
+    tokenOutAddress: Address;
+    baseOfTokenOutAddress?: Address;
+    pricePair: [string, string];
+    chainId: number;
+    network: string;
+    creditManagers: Array<Address>;
+    hideInProd?: boolean;
+    maxLeverage?: number;
+}

package/dist/types/common-utils/utils/creditAccount/index.d.ts

@@ -1,10 +1,10 @@
-export * from "./calcHealthFactor.js";
-export * from "./calcOverallAPY.js";
-export * from "./calcQuotaBorrowRate.js";
-export * from "./calcQuotaBorrowRate.js";
-export * from "./calcRelativeBaseBorrowRate.js";
+export * from "./calc-health-factor.js";
+export * from "./calc-overall-apy.js";
+export * from "./calc-quota-borrow-rate.js";
+export * from "./calc-quota-borrow-rate.js";
+export * from "./calc-relative-base-borrow-rate.js";
 export * from "./debt.js";
-export * from "./getTimeToLiquidation.js";
-export * from "./liquidationPrice.js";
-export * from "./quotaUtils.js";
+export * from "./get-time-to-liquidation.js";
+export * from "./liquidation-price.js";
+export * from "./quota-utils.js";
 export * from "./sort.js";

package/dist/types/common-utils/utils/index.d.ts

@@ -1,5 +1,4 @@
-export * from "./assetsMath.js";
-export * from "./bigintMath.js";
+export * from "./assets-math.js";
+export * from "./bigint-math.js";
 export * from "./creditAccount/index.js";
-export * from "./endpoints.js";
-export * from "./priceMath.js";
+export * from "./price-math.js";

package/dist/types/plugins/zappers/ZappersPlugin.d.ts

@@ -0,0 +1,18 @@
+import type { Address } from "viem";
+import type { IGearboxSDKPlugin } from "../../sdk/index.js";
+import { AddressMap, BasePlugin } from "../../sdk/index.js";
+import type { ZapperDataFull, ZapperStateHuman } from "./types.js";
+export interface ZappersPluginState {
+    zappers: Record<Address, ZapperDataFull[]>;
+}
+export declare class ZappersPlugin extends BasePlugin<ZappersPluginState> implements IGearboxSDKPlugin<ZappersPluginState> {
+    #private;
+    constructor(extraZappers?: ZapperDataFull[], loadOnAttach?: boolean);
+    load(force?: boolean): Promise<ZappersPluginState>;
+    get extraZappers(): AddressMap<ZapperDataFull[]>;
+    get zappers(): AddressMap<ZapperDataFull[]>;
+    get loaded(): boolean;
+    stateHuman(_?: boolean): ZapperStateHuman[];
+    get state(): ZappersPluginState;
+    hydrate(state: ZappersPluginState): void;
+}

package/dist/types/plugins/zappers/extraZappers.d.ts

@@ -0,0 +1,6 @@
+import type { NetworkType } from "../../sdk/index.js";
+import type { ZapperDataFull } from "./types.js";
+/**
+ * Temporary zappers
+ */
+export declare const extraZappers: Partial<Record<NetworkType, ZapperDataFull[]>>;

package/dist/types/plugins/zappers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./extraZappers.js";
+export * from "./types.js";
+export * from "./ZappersPlugin.js";

package/dist/types/plugins/zappers/types.d.ts

@@ -0,0 +1,12 @@
+import type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from "abitype";
+import type { Address } from "viem";
+import type { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
+import type { BaseContractStateHuman, Unarray } from "../../sdk/index.js";
+export type ZapperData = Unarray<AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof peripheryCompressorAbi, "getZappers">["outputs"]>>;
+export interface ZapperDataFull extends ZapperData {
+    pool: Address;
+}
+export interface ZapperStateHuman extends BaseContractStateHuman {
+    tokenIn: string;
+    tokenOut: string;
+}

package/dist/types/rewards/apy/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./output.js";
+export * from "./output-details.js";

package/dist/types/rewards/apy/output-details.d.ts

@@ -0,0 +1,96 @@
+import type { Address } from "viem";
+export interface GearAPY {
+    base: number;
+    crv: number;
+    gear: number;
+    gearPrice: number;
+}
+export type GearAPYDetails = GearAPY & {
+    lastUpdated: string;
+};
+export interface TokenOutputDetails<T extends string> {
+    chainId: number;
+    address: string;
+    symbol: string;
+    rewards: {
+        apy: Array<Omit<ApyDetails, "symbol" | "address">>;
+        points: Array<Omit<PointsInfo<T>, "symbol" | "address">>;
+        extraRewards: Array<Omit<FarmInfo, "symbol" | "address">>;
+        extraCollateralAPY: Array<Omit<ExtraCollateralAPY, "symbol" | "address">>;
+        extraCollateralPoints: Array<Omit<ExtraCollateralPointsInfo<T>, "symbol" | "address">>;
+    };
+}
+export type ApyDetails = Apy & {
+    lastUpdated: string;
+};
+export interface FarmInfo {
+    address: Address;
+    symbol: string;
+    rewardToken: Address;
+    rewardSymbol: string;
+    duration: bigint;
+    finished: bigint;
+    reward: bigint;
+    balance: bigint;
+}
+export interface Apy {
+    address: Address;
+    symbol: string;
+    protocol: string;
+    value: number;
+}
+export interface ExtraCollateralAPY extends Omit<Apy, "protocol"> {
+    pool: Address;
+    type: "relative" | "absolute";
+}
+export interface PointsReward<T extends string> {
+    name: string;
+    units: string;
+    multiplier: bigint | "soon";
+    type: T;
+}
+export interface DebtReward<T extends string> extends PointsReward<T> {
+    cm: Address | "any";
+}
+export interface PointsInfo<T extends string> {
+    symbol: string;
+    address: Address;
+    rewards: Array<PointsReward<T>>;
+    debtRewards?: Array<DebtReward<T>>;
+}
+export interface ExtraCollateralPointsInfo<T extends string> extends PointsInfo<T> {
+    pool: Address;
+}
+export interface PoolOutputDetails<T extends string> {
+    chainId: number;
+    pool: Address;
+    rewards: {
+        points: Array<Omit<PoolPointsInfo<T>, "pool">>;
+        externalAPY: Array<Omit<ExternalApy, "pool">>;
+        extraAPY: Array<Omit<PoolExtraApy, "pool">>;
+    };
+}
+export interface PoolPointsInfo<T extends string> {
+    pool: Address;
+    token: Address;
+    symbol: string;
+    amount: bigint;
+    duration: string | undefined;
+    name: string;
+    type: T;
+    estimation: "absolute" | "relative";
+    condition: "deposit" | "cross-chain-deposit" | "holding";
+}
+export interface ExternalApy {
+    value: number;
+    name: string;
+    pool: Address;
+}
+export interface PoolExtraApy {
+    token: Address;
+    apy: number;
+    rewardToken: Address;
+    rewardTokenSymbol: string;
+    endTimestamp?: number;
+    lastUpdated: string;
+}

package/dist/types/rewards/apy/output.d.ts

@@ -0,0 +1,22 @@
+import type { GearAPYDetails, PoolOutputDetails, TokenOutputDetails } from "./output-details.js";
+export interface Output<POOL_POINTS_TYPE extends string, TOKEN_POINTS_TYPE extends string> {
+    gearApy: DataResult<GearAPYDetails>;
+    chains: Record<string, {
+        tokens: DataResult<TokenOutputDetails<TOKEN_POINTS_TYPE>[]>;
+        pools: DataResult<PoolOutputDetails<POOL_POINTS_TYPE>[]>;
+    }>;
+    timestamp: string;
+    metadata: {
+        totalChains: number;
+        successfulChains: number;
+        failedChains: number;
+    };
+}
+export type DataResult<T> = {
+    status: "ok";
+    data: T;
+} | {
+    status: "error";
+    message: string;
+    code?: string;
+};

package/dist/types/rewards/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./apy/index.js";
+export * from "./rewards/index.js";

package/dist/types/rewards/rewards/api.d.ts

@@ -0,0 +1,49 @@
+import type { Address, PublicClient, WalletClient } from "viem";
+import { type NetworkType } from "../../sdk/index.js";
+import type { PoolData, TokenData } from "./common.js";
+export interface GearboxExtraMerkleLmReward {
+    pool: Address;
+    poolToken: Address;
+    rewardTokenSymbol: string;
+    rewardTokenDecimals: number;
+    rewardToken: Address;
+    amount: bigint;
+    type: "extraMerkle";
+}
+export interface GearboxStakedV3LmReward {
+    pool: Address;
+    poolToken: Address;
+    rewardTokenSymbol: string;
+    rewardTokenDecimals: number;
+    rewardToken: Address;
+    amount: bigint;
+    type: "stakedV3";
+}
+export type GearboxLmReward = GearboxStakedV3LmReward | GearboxExtraMerkleLmReward;
+type ReportHandler = (e: unknown, description?: string) => void;
+export interface GetLmRewardsV3Props {
+    pools: Record<`0x${string}`, PoolData>;
+    tokensList: Record<Address, TokenData>;
+    account: Address;
+    provider: PublicClient;
+    reportError?: ReportHandler;
+}
+export interface GetLmRewardsMerkleProps {
+    pools: Record<Address, PoolData>;
+    account: Address;
+    network: NetworkType;
+    reportError?: ReportHandler;
+}
+export interface ClaimLmRewardsV3Props {
+    reward: GearboxStakedV3LmReward;
+    account: Address;
+    signer: WalletClient;
+}
+export declare class GearboxRewardsApi {
+    private constructor();
+    static getLmRewardsV3({ pools, tokensList, provider, account, reportError, }: GetLmRewardsV3Props): Promise<(GearboxLmReward | GearboxLmReward[])[]>;
+    static getLmRewardsMerkle({ pools, account, network, reportError, }: GetLmRewardsMerkleProps): Promise<GearboxLmReward[]>;
+    private static extractFulfilled;
+    static claimLmRewardsV3({ reward, signer, account, }: ClaimLmRewardsV3Props): Promise<`0x${string}`>;
+}
+export {};

package/dist/types/rewards/rewards/apy.d.ts

@@ -0,0 +1,41 @@
+import type { Address } from "viem";
+import { type Asset } from "../../sdk/index.js";
+import type { FarmInfo } from "../index.js";
+import type { PoolData, TokenData } from "./common.js";
+interface InnerFarmInfo extends FarmInfo {
+    token: Address;
+}
+export interface ExtraRewardApy {
+    token: Address;
+    balance: bigint | null;
+    apy: number;
+    rewardToken: Address;
+    rewardTokenSymbol: string;
+    endTimestamp?: number;
+}
+interface GetPoolExtraAPY_V3Props {
+    stakedDieselToken: Address | undefined;
+    pool: PoolData;
+    prices: Record<Address, bigint>;
+    rewardPoolsInfo: Record<Address, Array<InnerFarmInfo>> | Record<Address, InnerFarmInfo>;
+    rewardPoolsSupply: Record<Address, bigint>;
+    tokensList: Record<Address, TokenData>;
+    currentTimestamp: number;
+}
+interface GetCAExtraAPYProps {
+    assets: Array<Asset>;
+    supply: Record<Address, bigint> | Record<Address, Asset>;
+    rewardInfo: Record<Address, Array<InnerFarmInfo>>;
+    currentTimestamp: number;
+    prices: Record<Address, bigint>;
+    tokensList: Record<Address, TokenData>;
+}
+export declare class GearboxRewardsApy {
+    private constructor();
+    static getPoolExtraAPY_V3({ rewardPoolsInfo, stakedDieselToken, ...restProps }: GetPoolExtraAPY_V3Props): Array<ExtraRewardApy>;
+    private static getPoolSingleExtraLmAPY_V3;
+    private static calculateAPY_V3;
+    static getCAExtraAPY_V3({ rewardInfo, assets, ...restProps }: GetCAExtraAPYProps): Array<ExtraRewardApy>;
+    private static getCASingleExtraAPY_V3;
+}
+export {};

package/dist/types/rewards/rewards/common.d.ts

@@ -0,0 +1,16 @@
+import type { Address } from "viem";
+export interface TokenData {
+    address: Address;
+    symbol: string;
+    decimals: number;
+}
+export interface PoolData {
+    address: Address;
+    version: number;
+    underlyingToken: Address;
+    dieselRateRay: bigint;
+    dieselToken: Address;
+    stakedDieselToken: Address[];
+    stakedDieselToken_old: Address[];
+    expectedLiquidity: bigint;
+}

package/dist/types/rewards/rewards/extra-apy.d.ts

@@ -0,0 +1,30 @@
+import type { Address } from "viem";
+import { type Asset, type NetworkType } from "../../sdk/index.js";
+import type { PoolPointsInfo } from "../index.js";
+import type { PoolData, TokenData } from "./common.js";
+type PartialPool = Pick<PoolData, "expectedLiquidity" | "underlyingToken" | "address">;
+export interface GetPointsByPoolProps {
+    poolRewards: Record<Address, Array<PoolPointsInfo<string>>>;
+    totalTokenBalances: Record<Address, Asset>;
+    pools: Array<PartialPool>;
+    tokensList: Record<Address, TokenData>;
+}
+export interface GetTotalTokensOnProtocolProps {
+    tokensToCheck: Array<Address>;
+    tokensList: Record<Address, TokenData>;
+    network: NetworkType;
+}
+export type PoolPointsBase = Record<Address, Array<{
+    key: string;
+    info: PoolPointsInfo<string>;
+    points: bigint;
+}>>;
+export declare function getKeyForPoolPointsInfo(i: PoolPointsInfo<string>): string;
+export declare class GearboxRewardsExtraApy {
+    private constructor();
+    static getTotalTokensOnProtocol({ tokensToCheck, tokensList, network, }: GetTotalTokensOnProtocolProps): Promise<[`0x${string}`, PromiseSettledResult<Asset>][]>;
+    private static getTokenTotal;
+    static getPointsByPool({ poolRewards, totalTokenBalances, pools, tokensList, }: GetPointsByPoolProps): PoolPointsBase;
+    private static getPoolTokenPoints;
+}
+export {};

package/dist/types/rewards/rewards/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./api.js";
+export * from "./apy.js";
+export * from "./extra-apy.js";
+export * from "./merkl-api.js";

package/dist/types/rewards/rewards/merkl-api.d.ts

@@ -0,0 +1,45 @@
+import type { Address } from "viem";
+interface UserOptions {
+    params: {
+        user: string;
+        chainId: number;
+    };
+}
+export interface MerkleXYZUserRewardsV4 {
+    chain: MerkleXYZChain;
+    rewards: Array<{
+        root: Address;
+        recipient: Address;
+        amount: string;
+        claimed: string;
+        pending: string;
+        proofs: Array<Address>;
+        token: {
+            address: Address;
+            chainId: number;
+            symbol: string;
+            decimals: number;
+        };
+        breakdowns: Array<{
+            reason: string;
+            amount: string;
+            claimed: string;
+            pending: string;
+            campaignId: Address;
+        }>;
+    }>;
+}
+export type MerkleXYZUserRewardsV4Response = Array<MerkleXYZUserRewardsV4>;
+interface MerkleXYZChain {
+    id: number;
+    name: string;
+    icon: string;
+}
+export declare class MerkleXYZApi {
+    private constructor();
+    static defaultDomain: string;
+    static angleDomain: string;
+    static fetchWithFallback: <T>(getUrl: (domain: string) => string) => Promise<import("axios").AxiosResponse<T, any, {}>>;
+    static getUserRewardsUrl: (options: UserOptions) => (domain: string) => string;
+}
+export {};