@gearbox-protocol/sdk 7.11.0-next.3 → 7.11.0

package/dist/esm/sdk/sdk-legacy/gearboxRewards/api.js

@@ -8,48 +8,10 @@ import { GearboxBackendApi } from "../core/endpoint.js";
 import { BigIntMath } from "../utils/math.js";
 import { MerkleXYZApi } from "./merklAPI.js";
 class GearboxRewardsApi {
-  static async getLmRewardsV2({
-    provider,
-    account,
-    currentTokenData,
-    network,
-    airdropDistributorAddress,
-    reportError
-  }) {
-    if (!airdropDistributorAddress) return [];
-    const [claimedRespUnsafe, merkleDataRespUnsafe] = await Promise.allSettled([
-      this.getClaimed({ airdropDistributorAddress, provider, account }),
-      this.getMerkle(provider, airdropDistributorAddress, network, account)
-    ]);
-    const claimedResp = this.extractFulfilled(claimedRespUnsafe, reportError, "getLmRewardsV2") || 0n;
-    const merkleDataResp = this.extractFulfilled(
-      merkleDataRespUnsafe,
-      reportError,
-      "getLmRewardsV2"
-    );
-    const amountOnContract = this.getAmountOnContract({
-      account,
-      merkleData: merkleDataResp
-    });
-    const diff = amountOnContract - claimedResp;
-    const availableToClaimV2 = BigIntMath.max(0n, diff);
-    const rewards = [
-      {
-        amount: availableToClaimV2,
-        type: "merkleV2",
-        rewardToken: currentTokenData.GEAR,
-        rewardTokenDecimals: 18,
-        rewardTokenSymbol: "GEAR"
-      }
-    ];
-    return rewards;
-  }
-  static async getLmRewardsV3({
+  static async getLmRewardsInfo({
     pools,
-    tokensList,
     provider,
-    account,
-    reportError
+    tokensList
   }) {
     const poolByStakedDiesel = Object.values(pools).reduce((acc, p) => {
       p.stakedDieselToken.forEach((t) => {
@@ -60,85 +22,155 @@ class GearboxRewardsApi {
       });
       return acc;
     }, {});
-    const stakedDieselTokens = TypedObjectUtils.keys(poolByStakedDiesel);
-    const farmInfoCalls = stakedDieselTokens.map((address) => ({
+    const poolByDiesel = Object.values(pools).reduce(
+      (acc, p) => {
+        acc[p.dieselToken] = p.address;
+        return acc;
+      },
+      {}
+    );
+    const poolByItsToken = { ...poolByStakedDiesel, ...poolByDiesel };
+    const poolStakedTokens = TypedObjectUtils.keys(poolByStakedDiesel);
+    const allPoolTokens = TypedObjectUtils.keys(poolByItsToken);
+    const farmInfoCalls = poolStakedTokens.map((address) => ({
       address,
       abi: iFarmingPoolAbi,
       functionName: "farmInfo",
       args: []
     }));
-    const rewardTokenCalls = stakedDieselTokens.map((address) => ({
+    const farmSupplyCalls = allPoolTokens.map((address) => ({
       address,
-      abi: POOL_REWARDS_ABI,
-      functionName: "rewardsToken",
+      abi: iFarmingPoolAbi,
+      functionName: "totalSupply",
       args: []
     }));
-    const farmedCalls = stakedDieselTokens.map((address) => ({
+    const rewardTokenCalls = poolStakedTokens.map((address) => ({
       address,
-      abi: iFarmingPoolAbi,
-      functionName: "farmed",
-      args: [account]
+      abi: POOL_REWARDS_ABI,
+      functionName: "rewardsToken",
+      args: []
     }));
-    const [response] = await Promise.allSettled([
-      provider.multicall({
-        allowFailure: false,
-        contracts: [...farmInfoCalls, ...rewardTokenCalls, ...farmedCalls]
-      })
-    ]);
-    const safeResponse = this.extractFulfilled(response, reportError, "v3Rewards") || [];
+    const mc = await provider.multicall({
+      allowFailure: false,
+      contracts: [...farmInfoCalls, ...farmSupplyCalls, ...rewardTokenCalls]
+    });
+    const mcResponse = mc;
+    const [...restMCResponse] = mcResponse;
     const farmInfoCallsEnd = farmInfoCalls.length;
-    const farmInfo = safeResponse.slice(
+    const farmInfo = restMCResponse.slice(
       0,
       farmInfoCallsEnd
     );
-    const rewardTokenCallsEnd = farmInfoCallsEnd + rewardTokenCalls.length;
-    const rewardTokens = safeResponse.slice(
+    const farmSupplyCallsEnd = farmInfoCallsEnd + farmSupplyCalls.length;
+    const farmSupply = restMCResponse.slice(
       farmInfoCallsEnd,
-      rewardTokenCallsEnd
+      farmSupplyCallsEnd
     );
-    const farmedCallsEnd = rewardTokenCallsEnd + farmedCalls.length;
-    const farmedList = safeResponse.slice(
-      rewardTokenCallsEnd,
-      farmedCallsEnd
+    const rewardTokenCallsEnd = farmSupplyCallsEnd + rewardTokenCalls.length;
+    const rewardTokens = restMCResponse.slice(
+      farmSupplyCallsEnd,
+      rewardTokenCallsEnd
     );
-    const gearboxLmRewards = stakedDieselTokens.map(
-      (address, i) => {
-        const pool = poolByStakedDiesel[address];
-        const info = farmInfo[i];
-        const rewardToken = rewardTokens[i]?.toLowerCase();
-        const farmed = farmedList[i];
-        if (!pool || !info || !rewardToken) return void 0;
-        return {
-          pool,
-          poolToken: address,
-          rewardToken,
-          rewardTokenDecimals: tokensList[rewardToken]?.decimals || 18,
-          rewardTokenSymbol: tokensList[rewardToken]?.symbol || "unknown",
-          amount: farmed ?? 0n,
-          type: "stakedV3"
-        };
-      }
+    const infoByPool = poolStakedTokens.reduce(
+      (acc, p, index) => {
+        const info = farmInfo[index];
+        if (info) acc[p] = info;
+        return acc;
+      },
+      {}
     );
-    const { zero, nonZero } = gearboxLmRewards.reduce(
-      (acc, r) => {
-        if (r && r.amount > 0n) {
-          acc.nonZero.push(r);
-        } else if (r) {
-          acc.zero.push(r);
+    const rewardTokenPool = poolStakedTokens.reduce(
+      (acc, p, index) => {
+        const token = rewardTokens[index];
+        if (token) {
+          acc[p] = token.toLowerCase();
         }
         return acc;
       },
-      { nonZero: [], zero: [] }
+      {}
+    );
+    const stakedTokenRewards = allPoolTokens.reduce(
+      (acc, pool) => {
+        const info = infoByPool[pool];
+        const token = rewardTokenPool[pool];
+        const tokenData = tokensList[token];
+        const baseReward = info && tokenData ? {
+          pool: poolByItsToken[pool],
+          duration: BigInt(info.duration),
+          finished: BigInt(info.finished),
+          reward: info.reward,
+          balance: info.balance,
+          symbol: tokenData.symbol
+        } : void 0;
+        if (baseReward) acc.base[pool] = baseReward;
+        acc.all[pool] = [...baseReward ? [baseReward] : []];
+        return acc;
+      },
+      { base: {}, all: {} }
     );
-    return [...nonZero, zero];
+    const rewardPoolsSupply = allPoolTokens.reduce(
+      (acc, address, i) => {
+        acc[address] = farmSupply[i] || 0n;
+        return acc;
+      },
+      {}
+    );
+    return {
+      rewardPoolsInfo: stakedTokenRewards.all,
+      baseRewardPoolsInfo: stakedTokenRewards.base,
+      rewardPoolsSupply
+    };
   }
-  static async getLmRewardsMerkle({
+  static async getLmRewardsV2({
+    provider,
+    account,
+    currentTokenData,
+    network,
+    airdropDistributorAddress
+  }) {
+    if (!airdropDistributorAddress) return { rewards: [] };
+    const [claimedResp, merkleDataResp] = await Promise.all([
+      this.getClaimed({ airdropDistributorAddress, provider, account }),
+      this.getMerkle(provider, airdropDistributorAddress, network, account)
+    ]);
+    const amountOnContract = this.getAmountOnContract({
+      account,
+      merkleData: merkleDataResp
+    });
+    const diff = amountOnContract - claimedResp;
+    const availableToClaimV2 = BigIntMath.max(0n, diff);
+    const rewards = [
+      {
+        amount: availableToClaimV2,
+        type: "merkleV2",
+        rewardToken: currentTokenData.GEAR,
+        rewardTokenDecimals: 18,
+        rewardTokenSymbol: "GEAR"
+      }
+    ];
+    return { rewards };
+  }
+  static async getLmRewardsV3({
     pools,
+    baseRewardPoolsInfo,
+    currentTokenData,
+    tokensList,
+    provider,
     account,
     network,
     reportError
   }) {
-    const [merkleXYZLMResponse] = await Promise.allSettled([
+    const poolTokens = Object.keys(baseRewardPoolsInfo);
+    const [gearboxLmResponse, merkleXYZLMResponse] = await Promise.allSettled([
+      provider.multicall({
+        allowFailure: false,
+        contracts: poolTokens.map((address) => ({
+          address,
+          abi: iFarmingPoolAbi,
+          functionName: "farmed",
+          args: [account]
+        }))
+      }),
       axios.get(
         MerkleXYZApi.getUserRewardsUrl({
           params: {
@@ -148,10 +180,15 @@ class GearboxRewardsApi {
         })
       )
     ]);
+    const gearboxLm = this.extractFulfilled(
+      gearboxLmResponse,
+      reportError,
+      "v3Rewards"
+    ) || [];
     const merkleXYZLm = this.extractFulfilled(
       merkleXYZLMResponse,
       reportError,
-      "merkleXYZLm"
+      "merkleRewards"
     )?.data;
     const poolByItsToken = Object.values(pools).reduce((acc, p) => {
       p.stakedDieselToken.forEach((t) => {
@@ -189,7 +226,34 @@ class GearboxRewardsApi {
       });
       return acc;
     }, {});
-    return Object.values(extraRewards);
+    const gearboxLmRewards = poolTokens.map((address, i) => {
+      const info = baseRewardPoolsInfo[address];
+      const rewardToken = currentTokenData[info.symbol];
+      return {
+        pool: info.pool,
+        poolToken: address,
+        rewardToken,
+        rewardTokenDecimals: tokensList[rewardToken]?.decimals || 18,
+        rewardTokenSymbol: info.symbol,
+        amount: gearboxLm[i] || 0n,
+        type: "stakedV3"
+      };
+    });
+    const { zero, nonZero } = gearboxLmRewards.reduce(
+      (acc, r) => {
+        const amount = r.amount || 0n;
+        if (amount > 0n) {
+          acc.nonZero.push(r);
+        } else {
+          acc.zero.push(r);
+        }
+        return acc;
+      },
+      { nonZero: [], zero: [] }
+    );
+    return {
+      rewards: [...nonZero, ...Object.values(extraRewards), zero]
+    };
   }
   static extractFulfilled(r, reportError, description) {
     if (r.status === "fulfilled") {
@@ -294,7 +358,8 @@ class GearboxRewardsApi {
     account,
     merkleData
   }) {
-    const { amount } = merkleData?.claims?.[getAddress(account)] || {};
+    const { claims = {} } = merkleData || {};
+    const { amount } = claims[getAddress(account)] || {};
     return BigInt(amount || 0);
   }
 }

package/dist/esm/sdk/sdk-legacy/gearboxRewards/apy.js

@@ -20,7 +20,7 @@ class GearboxRewardsApy {
     if (!isV3 || !stakedDieselToken) return [];
     const info = rewardPoolsInfo[stakedDieselToken];
     if (!info) return [];
-    const extra = (Array.isArray(info) ? info : [info]).map(
+    const extra = info.map(
       (inf) => this.getPoolSingleExtraLmAPY_V3({
         ...restProps,
         stakedDieselToken,

package/dist/esm/sdk/sdk-legacy/index.js

@@ -9,6 +9,7 @@ export * from "./core/pool.js";
 export * from "./core/strategy.js";
 export * from "./core/transactions.js";
 export * from "./gearboxRewards/index.js";
+export * from "./pathfinder/index.js";
 export * from "./payload/creditAccount.js";
 export * from "./payload/creditManager.js";
 export * from "./payload/creditSession.js";

package/dist/esm/sdk/sdk-legacy/pathfinder/index.js

@@ -0,0 +1 @@
+export * from "./core.js";

package/dist/esm/sdk/utils/viem/simulateWithPriceUpdates.js

@@ -79,6 +79,7 @@ async function simulateWithPriceUpdates(client, parameters) {
       if (mustThrow) {
         throw err;
       }
+      console.warn(err);
     }
     const restResults = multicallResults.slice(priceUpdates.length + 2).map((r) => r.result);
     return restResults;

package/dist/esm/zappers/ZappersPlugin.js

@@ -8,16 +8,10 @@ import {
 class ZappersPlugin extends SDKConstruct {
   #zappers;
   version = 1;
-  // public async attach(): Promise<void> {
-  //   await this.load(true);
-  // }
-  async syncState() {
-    await this.load();
+  async attach() {
+    await this.loadZappers();
   }
-  async load(force) {
-    if (!force && this.loaded) {
-      return this.state;
-    }
+  async loadZappers() {
     this.#zappers = new AddressMap(void 0, "zappers");
     const [pcAddr] = this.sdk.addressProvider.mustGetLatest(
       AP_PERIPHERY_COMPRESSOR,
@@ -54,7 +48,6 @@ class ZappersPlugin extends SDKConstruct {
       }
     }
     this.#loadZapperTokens();
-    return this.state;
   }
   get zappers() {
     if (!this.#zappers) {
@@ -62,9 +55,6 @@ class ZappersPlugin extends SDKConstruct {
     }
     return this.#zappers;
   }
-  get loaded() {
-    return !!this.#zappers;
-  }
   stateHuman(_) {
     return this.zappers.values().flatMap(
       (l) => l.flatMap((z) => ({
@@ -78,6 +68,7 @@ class ZappersPlugin extends SDKConstruct {
   }
   get state() {
     return {
+      version: this.version,
       zappers: this.zappers.asRecord()
     };
   }

package/dist/types/adapters/AdaptersPlugin.d.ts

@@ -1,11 +1,10 @@
-import type { BaseState, IBaseContract, IGearboxSDKPlugin } from "../sdk/index.js";
+import type { BaseState, IBaseContract, IGearboxSDKPlugin, IPluginState } from "../sdk/index.js";
 import { SDKConstruct } from "../sdk/index.js";
-export declare class AdaptersPlugin extends SDKConstruct implements IGearboxSDKPlugin<{}> {
+export declare class AdaptersPlugin extends SDKConstruct implements IGearboxSDKPlugin<IPluginState> {
     readonly name = "Adapters";
     readonly version = 1;
-    readonly loaded = true;
     createContract(data: BaseState): IBaseContract | undefined;
     stateHuman(_?: boolean): {};
-    get state(): {};
-    hydrate(_: {}): void;
+    get state(): IPluginState;
+    hydrate(_: IPluginState): void;
 }

package/dist/types/bots/BotsPlugin.d.ts

@@ -1,6 +1,6 @@
 import type { Address } from "viem";
 import type { GearboxSDK, IGearboxSDKPlugin } from "../sdk/index.js";
-import { AddressMap, SDKConstruct } from "../sdk/index.js";
+import { SDKConstruct } from "../sdk/index.js";
 import { PartialLiquidationBotV300Contract } from "./PartialLiquidationBotV300Contract.js";
 import { PartialLiquidationBotV310Contract } from "./PartialLiquidationBotV310Contract.js";
 import { type BotsPluginState, type BotsPluginStateHuman, type BotState } from "./types.js";
@@ -13,13 +13,11 @@ export declare class BotsPlugin extends SDKConstruct implements IGearboxSDKPlugi
     #private;
     readonly version = 1;
     constructor(sdk: GearboxSDK);
+    attach(): Promise<void>;
     syncState(): Promise<void>;
-    get loaded(): boolean;
-    load(force?: boolean): Promise<BotsPluginState>;
-    stateHuman(raw?: boolean): BotsPluginStateHuman;
-    get botsByMarket(): AddressMap<PartialLiquidationBotContract[]>;
     botsByMarketConfigurator(mc: Address): PartialLiquidationBotContract[];
     get allBots(): PartialLiquidationBotContract[];
+    stateHuman(raw?: boolean): BotsPluginStateHuman;
     get state(): BotsPluginState;
     hydrate(state: BotsPluginState): void;
 }

package/dist/types/bots/types.d.ts

@@ -1,7 +1,7 @@
 import type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from "abitype";
 import type { Address } from "viem";
 import type { iPeripheryCompressorAbi } from "../abi/compressors.js";
-import type { BaseContractStateHuman, Unarray } from "../sdk/index.js";
+import type { BaseContractStateHuman, IPluginState, Unarray } from "../sdk/index.js";
 export type BotState = Unarray<AbiParametersToPrimitiveTypes<ExtractAbiFunction<typeof iPeripheryCompressorAbi, "getBots">["outputs"]>>;
 export interface BotParameters {
     treasury: Address;
@@ -31,7 +31,7 @@ export interface BotsPluginStateHuman {
      */
     bots: Record<string, BotStateHuman[]>;
 }
-export interface BotsPluginState {
+export interface BotsPluginState extends IPluginState {
     /**
      * Mapping market configurator address to bot states
      */

package/dist/types/dev/AccountsCounterPlugin.d.ts

@@ -1,7 +1,7 @@
 import type { Address } from "viem";
-import type { IGearboxSDKPlugin } from "../sdk/index.js";
+import type { IGearboxSDKPlugin, IPluginState } from "../sdk/index.js";
 import { AddressMap, SDKConstruct } from "../sdk/index.js";
-export interface AccountsCounterPluginState {
+export interface AccountsCounterPluginState extends IPluginState {
     /**
      * Mapping of credit manager addresses to the number of accounts
      */
@@ -13,9 +13,7 @@ export declare class AccountsCounterPlugin extends SDKConstruct implements IGear
     attach(): Promise<void>;
     syncState(): Promise<void>;
     get accounts(): AddressMap<bigint>;
-    get loaded(): boolean;
     forCreditManager(addr: Address): bigint;
-    load(force?: boolean): Promise<AccountsCounterPluginState>;
     get state(): AccountsCounterPluginState;
     hydrate(state: AccountsCounterPluginState): void;
 }

package/dist/types/sdk/GearboxSDK.d.ts

@@ -60,7 +60,6 @@ export interface SyncStateOptions {
 }
 export type SDKHooks = {
     syncState: [SyncStateOptions];
-    rehydrate: [SyncStateOptions];
 };
 export declare class GearboxSDK<const Plugins extends PluginsMap = {}> {
     #private;
@@ -84,8 +83,8 @@ export declare class GearboxSDK<const Plugins extends PluginsMap = {}> {
      * Token metadata such as symbol and decimals
      */
     readonly tokensMeta: TokensMeta;
-    addHook: <K extends keyof SDKHooks>(hookName: K, fn: (...args: SDKHooks[K]) => void | Promise<void>) => void;
-    removeHook: <K extends keyof SDKHooks>(hookName: K, fn: (...args: SDKHooks[K]) => void | Promise<void>) => void;
+    addHook: <K extends "syncState">(hookName: K, fn: (...args: SDKHooks[K]) => void | Promise<void>) => void;
+    removeHook: <K extends "syncState">(hookName: K, fn: (...args: SDKHooks[K]) => void | Promise<void>) => void;
     static attach<const Plugins extends PluginsMap>(options: SDKOptions<Plugins> & Partial<NetworkOptions> & ConnectionOptions & TransportOptions): Promise<GearboxSDK<Plugins>>;
     static hydrate<const Plugins extends PluginsMap>(options: HydrateOptions<Plugins> & ConnectionOptions & TransportOptions, state: GearboxState<Plugins>): GearboxSDK<Plugins>;
     private constructor();
@@ -97,7 +96,7 @@ export declare class GearboxSDK<const Plugins extends PluginsMap = {}> {
     /**
      * Rehydrate existing SDK from new state without re-creating instance
      */
-    rehydrate(state: GearboxState<Plugins>): Promise<void>;
+    rehydrate(state: GearboxState<Plugins>): void;
     /**
      * Converts contract call into some human-friendly string
      * This method is safe and should not throw

package/dist/types/sdk/chain/chains.d.ts

@@ -23,8 +23,8 @@ export interface GearboxChain extends Chain {
      */
     alchemyDomain?: string;
 }
-export declare const SUPPORTED_NETWORKS: readonly ["Mainnet", "Arbitrum", "Optimism", "Base", "Sonic", "MegaETH", "Monad", "Berachain", "Avalanche", "BNB", "WorldChain"];
-export declare const NetworkType: z.ZodEnum<["Mainnet", "Arbitrum", "Optimism", "Base", "Sonic", "MegaETH", "Monad", "Berachain", "Avalanche", "BNB", "WorldChain"]>;
+export declare const SUPPORTED_NETWORKS: readonly ["Mainnet", "Arbitrum", "Optimism", "Base", "Sonic", "MegaETH", "Monad", "Berachain", "Avalanche", "BNB", "WorldChain", "Etherlink"];
+export declare const NetworkType: z.ZodEnum<["Mainnet", "Arbitrum", "Optimism", "Base", "Sonic", "MegaETH", "Monad", "Berachain", "Avalanche", "BNB", "WorldChain", "Etherlink"]>;
 export type NetworkType = z.infer<typeof NetworkType>;
 export declare const chains: Record<NetworkType, GearboxChain>;
 export declare function getChain(chainIdOrNetworkType: number | bigint | NetworkType): GearboxChain;

package/dist/types/sdk/plugins/V300StalenessPeriodPlugin.d.ts

@@ -1,7 +1,7 @@
 import type { Address } from "viem";
 import { SDKConstruct } from "../base/index.js";
 import type { GearboxSDK } from "../GearboxSDK.js";
-import type { IGearboxSDKPlugin } from "./types.js";
+import type { IGearboxSDKPlugin, IPluginState } from "./types.js";
 export interface StalenessEvent {
     oracle: Address;
     priceFeed: Address;
@@ -9,7 +9,7 @@ export interface StalenessEvent {
     stalenessPeriod: number;
     reserve: boolean;
 }
-export interface V300StalenessPeriodPluginState {
+export interface V300StalenessPeriodPluginState extends IPluginState {
     events: StalenessEvent[];
 }
 /**
@@ -22,7 +22,6 @@ export declare class V300StalenessPeriodPlugin extends SDKConstruct implements I
     #private;
     readonly version = 1;
     constructor(sdk: GearboxSDK);
-    get loaded(): boolean;
     attach(): Promise<void>;
     syncState(): Promise<void>;
     get state(): V300StalenessPeriodPluginState;

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

@@ -1,47 +1,20 @@
 import type { BaseState, IBaseContract } from "../base/index.js";
 import type { GearboxSDK } from "../GearboxSDK.js";
-export type IPluginState<State extends Record<keyof State, unknown> = {}> = {
+export interface IPluginState {
     version: number;
-} & ({
-    loaded: false;
-} | ({
-    loaded: true;
-} & State));
-export type IGearboxSDKPluginConstructor<TState extends Record<keyof TState, unknown>, TPlugin extends IGearboxSDKPlugin<TState>> = new (sdk: GearboxSDK<any>) => TPlugin;
-export interface IGearboxSDKPlugin<TState extends Record<keyof TState, unknown> = {}> {
+}
+export type IGearboxSDKPluginConstructor<TState extends IPluginState | undefined, TPlugin extends IGearboxSDKPlugin<TState>> = new (sdk: GearboxSDK<any>) => TPlugin;
+export interface IGearboxSDKPlugin<TState extends IPluginState | undefined> {
     /**
      * Plugin version, used to check if the plugin state is compatible with the plugin during hydration
      */
     version: number;
-    /**
-     * Indicates that plugins state is ready to use
-     * It does not matter how this state was obtained, be it via attach, hydrate or on-demand load
-     */
-    loaded: boolean;
-    /**
-     * Plugin state, can be hydarted/dehydrated
-     */
-    state: TState;
-    /**
-     * Loads state on demand
-     * If it's already loaded, does nothing and returns the same state, unless force is set to true
-     * @param force
-     * @returns
-     */
-    load?: (force?: boolean) => Promise<TState>;
     /**
      * Called after SDK is attached
-     * Plugins are not required to implement this. For example plugin can be stateless, or load state on demand only
      * @param sdk
      * @returns
      */
     attach?: () => Promise<void>;
-    /**
-     * Loads plugin state from dehydrated state
-     * @param state
-     * @returns
-     */
-    hydrate?: (state: TState) => void;
     /**
      * Called after SDK state is already synced, meaning that block number and timestamp are accessible from SDK
      *
@@ -51,7 +24,6 @@ export interface IGearboxSDKPlugin<TState extends Record<keyof TState, unknown>
     syncState?: () => Promise<void>;
     /**
      * Can be called by SDK to create some auxiliary contracts, such as zappers and adapters
-     * Otherwise they are created as BaseContract instances by sdk
      * @param params
      * @returns
      */
@@ -62,11 +34,21 @@ export interface IGearboxSDKPlugin<TState extends Record<keyof TState, unknown>
      * @returns
      */
     stateHuman?: (raw?: boolean) => unknown;
+    /**
+     * Plugin state, can be hydarted/dehydrated
+     */
+    state: TState;
+    /**
+     * Loads plugin state from dehydrated state
+     * @param state
+     * @returns
+     */
+    hydrate?: (state: TState) => void;
 }
 /**
  * Helper type that extracts the state type from a plugin instance
  */
-export type PluginState<T> = T extends IGearboxSDKPlugin<infer TState> ? IPluginState<TState> : never;
+export type PluginState<T> = T extends IGearboxSDKPlugin<infer TState> ? TState : never;
 /**
  * Mapping between plugin name and plugin instance
  */