@gearbox-protocol/sdk 16.0.0-next.2 → 16.0.0-next.21

package/dist/types/onchain/router/createRouter.d.ts

@@ -0,0 +1,7 @@
+import { IRouterContract } from "./types.js";
+import { OnchainSDK } from "../OnchainSDK.js";
+import { Address } from "viem";
+//#region src/onchain/router/createRouter.d.ts
+declare function createRouter(sdk: OnchainSDK, address: Address, version: number): IRouterContract;
+//#endregion
+export { createRouter };

package/dist/types/onchain/router/helpers.d.ts

@@ -0,0 +1,15 @@
+import { AddressMap } from "../utils/AddressMap.js";
+import { Asset } from "../base/types.js";
+import "../utils/index.js";
+import { Address } from "viem";
+//#region src/onchain/router/helpers.d.ts
+declare function assetsMap<T extends Asset>(assets: Array<T> | readonly T[]): AddressMap<T>;
+/**
+ * TODO: is this weird workaround still needed?
+ * According to van0k, leftover balance for 0x19ebd191f7a24ece672ba13a302212b5ef7f35cb
+ * should always be rounded up to 5e17 if amount is less than 5e17
+ * Should NEVER be compared with "||" since function will lose it's effect
+ */
+declare function limitLeftover(balance: bigint | undefined, token: Address): bigint | undefined;
+//#endregion
+export { assetsMap, limitLeftover };

package/dist/types/onchain/router/types.d.ts

@@ -0,0 +1,285 @@
+import { Asset, CreditAccountData, IBaseContract } from "../base/types.js";
+import { MultiCall } from "../types/transactions.js";
+import "../types/index.js";
+import "../base/index.js";
+import { Address } from "viem";
+//#region src/onchain/router/types.d.ts
+/**
+ * Type of swap the router should perform.
+ *
+ * - `"EXACT_INPUT"` — swap an exact amount of the input token.
+ * - `"EXACT_INPUT_ALL"` — swap the entire balance of the input token.
+ * - `"EXACT_OUTPUT"` — swap to receive an exact amount of the output token (no longer supported by the router).
+ **/
+type SwapOperation = "EXACT_INPUT" | "EXACT_INPUT_ALL" | "EXACT_OUTPUT";
+/**
+ * Result returned from router contract
+ */
+interface RouterResult {
+  /**
+   * Amount received by router after all swaps in the block where the router is called
+   * Always denominated in target token
+   */
+  amount: bigint;
+  /**
+   * amount * (1 - slippage)
+   * Always denominated in target token
+   */
+  minAmount: bigint;
+  /**
+   * List of calls swap/unwrap/etc calls to adapters returned by router
+   */
+  calls: Array<MultiCall>;
+}
+interface RouterRewardsResult {
+  /**
+   * List of calls swap/unwrap/etc calls to adapters returned by router
+   */
+  calls: Array<MultiCall>;
+}
+/**
+ * Router return list of all balances (including 0 balances) after operation, but it doesn't include original balance
+ * - For example you had 5k sUSDS  and 5k DAI as collateral, debt is 20k DAI, router will return 25k sUDS and all other token allowed on CM will be 0n or 1n
+ * Since front-end is interested in FULL balances structure, we override target balance in the following way:
+ * min = record[sUSDS] = 5k from collateral + 25k of minAmount; avg = record[sUSDS] = 5k from collateral + 25.5k of avgAmount
+ * - minAmount
+ * - avgAmount
+ * - array of calls to execute swap
+ */
+interface OpenStrategyResult extends RouterResult {
+  /**
+   * Balances of opened credit account
+   * Leftover balances stay the same
+   * All expected balances are converted into target token, which amount is returned in router result
+   */
+  balances: Record<Address, bigint>;
+  /**
+   * Same as balances, but for min balance in target token
+   * @see RouterResult.minAmount
+   */
+  minBalances: Record<Address, bigint>;
+}
+interface RouterCloseResult extends RouterResult {
+  /**
+   * When account is closed, the router swaps only tokens different from underlying,
+   * we are more interested in TOTAL balance of underlying token after all swaps are done
+   * for this reason we sum up underlying token that was on account before swap
+   * with underlying token amount received during swap and call it underlyingBalance
+   */
+  underlyingBalance: bigint;
+}
+/**
+ * Slice of credit manager data required for router operations
+ */
+interface RouterCMSlice {
+  address: Address;
+  creditFacade: Address;
+  collateralTokens: Array<Address>;
+}
+/**
+ * Minimal slice of credit-account data required by router operations.
+ **/
+type RouterCASlice = Pick<CreditAccountData, "tokens" | "enabledTokensMask" | "underlying" | "creditAccount" | "creditFacade" | "debt" | "totalDebtUSD" | "creditManager">;
+interface FindOneTokenPathProps {
+  /**
+   * Minimal credit account data on which operation is performed
+   */
+  creditAccount: RouterCASlice;
+  /**
+   * Minimal credit manager data on which operation is performed
+   */
+  creditManager: RouterCMSlice;
+  /**
+   * Address of input token
+   */
+  tokenIn: Address;
+  /**
+   * Address of target token
+   */
+  tokenOut: Address;
+  /**
+   * Incoming amount of tokenIn to swap
+   */
+  amount: bigint;
+  /**
+   * Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
+   */
+  slippage: number | bigint;
+}
+interface FindManyToOnePathProps {
+  /**
+   * Minimal credit account data on which operation is performed.
+   */
+  creditAccount: RouterCASlice;
+  /**
+   * Minimal credit manager data on which operation is performed.
+   */
+  creditManager: RouterCMSlice;
+  /**
+   * Balances available at execution time.
+   */
+  expectedBalances: Array<Asset>;
+  /**
+   * Balances that must remain on the account after routing.
+   */
+  leftoverBalances: Array<Asset>;
+  /**
+   * Address of desired token to swap into.
+   */
+  target: Address;
+  /**
+   * Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation.
+   */
+  slippage: number | bigint;
+}
+interface FindOpenStrategyPathProps {
+  /**
+   * Minimal credit manager data on which operation is performed
+   */
+  creditManager: RouterCMSlice;
+  /**
+   * Collateral assets + debt asset, nominated in ther respective tokens.
+   * For example, if you open an USDC Credit Account, borrow 50_000 USDC and provide 10 WETH and 10_000 DAI as collateral
+   * from your own funds, expectedBalances should be: [{amount: 10*10^wethDecimals}, {amount: 10000*10^daiDecimals}, {amount: 10000*10^usdcDecimals}]
+   */
+  expectedBalances: Array<Asset>;
+  /**
+   * Balances to keep on account after opening.
+   * For example if don't want to swap WETH in the example above, leftoverBalances should be: [{amount: 10*10^wethDecimals}]
+   */
+  leftoverBalances: Array<Asset>;
+  /**
+   * Address of desired token to swap into
+   */
+  target: Address;
+  /**
+   * Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
+   */
+  slippage: number | bigint;
+}
+interface FindClaimAllRewardsProps {
+  /**
+   * Minimal credit account data on which operation is performed
+   */
+  creditAccount: RouterCASlice;
+  /**
+   * List of token rewards of which we want to claim and swap to underlying token during closing ca process
+   */
+  tokensToClaim: Array<Asset>;
+}
+interface FindBestClosePathProps {
+  /**
+   * Minimal credit account data on which operation is performed
+   */
+  creditAccount: RouterCASlice;
+  /**
+   * Minimal credit manager data on which operation is performed
+   */
+  creditManager: RouterCMSlice;
+  /**
+   * Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
+   */
+  slippage: bigint | number;
+  /**
+   * Balances {@link ClosePathBalances} to close account with, if not provided, all assets will be swapped according to inner logic.
+   */
+  balances?: ClosePathBalances;
+  /**
+   * List of assets to keep on account after closing.
+   * When balances are explicitly provided, keepAssets is ignored.
+   */
+  keepAssets?: Address[];
+  /**
+   * Debt only mode - will try to sell just enough of most valuable token to cover debt
+   */
+  debtOnly?: boolean;
+}
+interface ClosePathBalances {
+  /**
+   * List of all credit account balances nominated in their respective tokens.
+   * Current balances or expected balances after some actions (e.g. add/withdraw collateral),
+   * if these actions are before router calls — including balances of tokens
+   * not yet on the account (e.g. a claim token about to be received), which
+   * are absent from `creditAccount.tokens` and must be added here explicitly.
+   */
+  expectedBalances: Array<Asset>;
+  /**
+   * List of all credit account balances that shouldn't be swapped nominated in their respective tokens.
+   * Will be kept on account after all actions.
+   * If the final balance is 0, we set 1 for gas optimization, except for forbidden tokens
+   */
+  leftoverBalances: Array<Asset>;
+  /**
+   * List of token rewards of which we want to claim and swap to underlying token during closing ca process
+   */
+  tokensToClaim?: Array<Asset>;
+}
+/**
+ * On-chain router contract that finds optimal multi-hop swap paths
+ * for credit-account operations: single-token swaps, open-strategy
+ * collateral conversion, reward claiming, and full account closure.
+ *
+ * Which finder to use:
+ *
+ * - {@link findOneTokenPath} — full spend of a single token. The on-chain
+ *   `routeOneToOne` reads leftovers from the **live** account balances:
+ *   a full spend emits `leftover=1` diff encodings, while pre-existing dust
+ *   of intermediate tokens is preserved as leftover.
+ * - {@link findOpenStrategyPath} — partial spend: swap a token while keeping
+ *   an exact remainder on the account. `expectedBalances` is the total amount
+ *   available at execution time (may differ from the live balance, e.g. when
+ *   the input token arrives in the same multicall from a delayed-withdrawal
+ *   claim), `leftoverBalances` is the amount to keep; the router swaps the
+ *   difference.
+ * - {@link findBestClosePath} account closure: converts all remaining assets
+ *   (including dust) into underlying.
+ **/
+interface IRouterContract extends IBaseContract {
+  /**
+   * Find the best path to swap one token into another.
+   * Use for full spends of a single token; to keep an exact remainder
+   * on the account, use {@link findOpenStrategyPath} instead.
+   *
+   * @param props - {@link FindOneTokenPathProps}
+   * @returns The optimal swap result including amount, slippage-adjusted
+   *   minimum, and the multi-call sequence to execute.
+   **/
+  findOneTokenPath: (props: FindOneTokenPathProps) => Promise<RouterResult>;
+  /**
+   * Find the best path for swapping one or more balances on an existing
+   * credit account into a target token while preserving explicit leftovers.
+   *
+   * @param props - {@link FindManyToOnePathProps}
+   * @returns The optimal swap result including amount, minimum and calls.
+   */
+  findManyToOnePath: (props: FindManyToOnePathProps) => Promise<RouterResult>;
+  /**
+   * Find the best path for opening a credit account by converting all
+   * collateral (except leftovers) into a single target token.
+   * Also the right choice for any partial spend that must keep an exact
+   * remainder on the account (see {@link IRouterContract}).
+   *
+   * @param props - {@link FindOpenStrategyPathProps}
+   * @returns Swap result with projected post-open balances.
+   **/
+  findOpenStrategyPath: (props: FindOpenStrategyPathProps) => Promise<OpenStrategyResult>;
+  /**
+   * Construct calls to claim all pending rewards on a credit account
+   * and swap them to the underlying token.
+   *
+   * @param props - {@link FindClaimAllRewardsProps}
+   * @returns Multi-call sequence for claiming and swapping rewards.
+   **/
+  findClaimAllRewards: (props: FindClaimAllRewardsProps) => Promise<RouterRewardsResult>;
+  /**
+   * Find the best path to swap all credit-account assets into the
+   * underlying token. Used for account closure and liquidation
+   *
+   * @param props - {@link FindBestClosePathProps}
+   * @returns Swap result including the total underlying balance
+   *   after all swaps.
+   **/
+  findBestClosePath: (props: FindBestClosePathProps) => Promise<RouterCloseResult>;
+}
+//#endregion
+export { ClosePathBalances, FindBestClosePathProps, FindClaimAllRewardsProps, FindManyToOnePathProps, FindOneTokenPathProps, FindOpenStrategyPathProps, IRouterContract, OpenStrategyResult, RouterCASlice, RouterCMSlice, RouterCloseResult, RouterResult, RouterRewardsResult, SwapOperation };

package/dist/types/onchain/types/logger.d.ts

@@ -0,0 +1,15 @@
+//#region src/onchain/types/logger.d.ts
+interface LogFn {
+  <T extends object>(obj: T, msg?: string, ...args: any[]): void;
+  (obj: unknown, msg?: string, ...args: any[]): void;
+  (msg: string, ...args: any[]): void;
+}
+interface ILogger {
+  debug: LogFn;
+  info: LogFn;
+  warn: LogFn;
+  error: LogFn;
+  child?: (bindings: Record<string, any>) => ILogger;
+}
+//#endregion
+export { ILogger, LogFn };

package/dist/types/onchain/types/multichain.d.ts

@@ -0,0 +1,45 @@
+import { ChainId } from "../../model/primitives.js";
+import { NetworkType } from "../chain/chains.js";
+//#region src/onchain/types/multichain.d.ts
+/**
+ * Selects the chain for single-account methods of a multichain service.
+ **/
+interface MultichainNetworkProps {
+  /**
+   * Network the entity lives on.
+   **/
+  network: NetworkType;
+}
+/**
+ * Restricts which chains a multichain list method queries.
+ **/
+interface MultichainChainIdsProps {
+  /**
+   * Chains to query. All chains configured in {@link MultichainSDK} when
+   * omitted, and one the SDK is not configured for is dropped.
+   *
+   * A caller who thinks in network labels converts with {@link toChainIds}.
+   **/
+  chainIds?: ChainId[];
+}
+/**
+ * Adds chain-scoping props `T` only when the service spans multiple chains.
+ **/
+type WithMultichain<Multichain extends boolean, T extends object> = Multichain extends true ? T : {};
+/**
+ * Pins a live read to a block. Only meaningful on one chain: a height is not
+ * a shared moment across networks.
+ **/
+interface BlockNumberProps {
+  /**
+   * Block to read at. Defaults to the latest block.
+   **/
+  blockNumber?: bigint;
+}
+/**
+ * Adds {@link BlockNumberProps} only for a single-chain call. Fan-out methods
+ * omit it so a caller cannot pass one height to every network.
+ **/
+type WithBlock<Multichain extends boolean> = Multichain extends true ? {} : BlockNumberProps;
+//#endregion
+export { BlockNumberProps, MultichainChainIdsProps, MultichainNetworkProps, WithBlock, WithMultichain };

package/dist/types/onchain/types/state-human.d.ts

@@ -0,0 +1,229 @@
+import { RWAStateHuman } from "../market/rwa/types.js";
+import "../market/rwa/index.js";
+import { PriceFeedContractType } from "../market/pricefeeds/types.js";
+import "../market/index.js";
+import { TokenMetaData } from "../base/token-types.js";
+import "../base/index.js";
+import { Address } from "viem";
+//#region src/onchain/types/state-human.d.ts
+interface BaseContractStateHuman {
+  address: string;
+  version: number;
+  contractType?: string;
+}
+interface AddressProviderV3StateHuman extends BaseContractStateHuman {
+  addresses: Record<string, Record<number, string>>;
+}
+interface GearStakingV3StateHuman extends BaseContractStateHuman {
+  successor: string;
+  migrator: string;
+}
+type BotListStateHuman = BaseContractStateHuman;
+interface CoreStateHuman {
+  addressProviderV3: AddressProviderV3StateHuman;
+  botList?: BotListStateHuman;
+  gearStakingV3?: GearStakingV3StateHuman;
+}
+type PriceFeedStateHuman = BoundedOracleStateHuman | AssetPriceFeedStateHuman | RedstonePriceFeedStateHuman | LPPriceFeedStateHuman | BalancerWeightedPriceFeedStateHuman;
+interface BasePriceFeedStateHuman extends BaseContractStateHuman {
+  description?: string;
+  stalenessPeriod: string;
+  skipCheck: boolean;
+  pricefeeds: PriceFeedStateHuman[];
+  trusted?: boolean;
+}
+interface BoundedOracleStateHuman extends BasePriceFeedStateHuman {
+  contractType: "PRICE_FEED::BOUNDED";
+  upperBound: bigint;
+}
+interface ConstantOracleStateHuman extends BasePriceFeedStateHuman {
+  contractType: "PRICE_FEED::CONSTANT";
+  price: bigint;
+}
+interface AssetPriceFeedStateHuman extends BasePriceFeedStateHuman {
+  contractType: PriceFeedContractType;
+}
+interface LPPriceFeedStateHuman extends BasePriceFeedStateHuman {
+  contractType: PriceFeedContractType;
+  lpContract: Address;
+  lpToken: Address;
+  lowerBound: bigint;
+  upperBound: bigint;
+}
+interface BalancerWeightedPriceFeedStateHuman extends LPPriceFeedStateHuman {
+  contractType: "PRICE_FEED::BALANCER_WEIGHTED";
+  vault: Address;
+  poolId: Address;
+  weights: [bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint];
+}
+interface RedstonePriceFeedStateHuman extends BasePriceFeedStateHuman {
+  contractType: "PRICE_FEED::REDSTONE";
+  dataId: string;
+  signers: Array<string>;
+  signersThreshold: number;
+  lastPrice: string;
+  lastPayloadTimestamp: string;
+}
+interface PriceOracleStateHuman extends BaseContractStateHuman {
+  mainPriceFeeds: Record<string, PriceFeedStateHuman>;
+  reservePriceFeeds: Record<string, PriceFeedStateHuman>;
+  mainPrices: Record<string, string>;
+  reservePrices: Record<string, string>;
+}
+interface CreditFacadeStateHuman extends BaseContractStateHuman {
+  expirable: boolean;
+  isDegenMode: boolean;
+  degenNFT: string;
+  expirationDate: string;
+  maxDebtPerBlockMultiplier: number;
+  botList: string;
+  minDebt: string;
+  maxDebt: string;
+  forbiddenTokensMask: string;
+  isPaused: boolean;
+}
+interface CreditManagerStateHuman extends BaseContractStateHuman {
+  name: string;
+  accountFactory: string;
+  underlying: string;
+  pool: string;
+  creditFacade: string;
+  creditConfigurator: string;
+  maxEnabledTokens: number;
+  collateralTokens: Record<string, string>;
+  feeInterest: string;
+  feeLiquidation: string;
+  liquidationDiscount: string;
+  feeLiquidationExpired: string;
+  liquidationDiscountExpired: string;
+  quotedTokensMask: string;
+  contractsToAdapters: Record<string, unknown>;
+  creditAccounts: Array<Address>;
+}
+type CreditConfiguratorStateHuman = BaseContractStateHuman;
+interface CreditSuiteStateHuman {
+  isExpired: boolean;
+  creditFacade: CreditFacadeStateHuman;
+  creditManager: CreditManagerStateHuman;
+  creditConfigurator: CreditConfiguratorStateHuman;
+}
+interface CreditManagerDebtParamsHuman {
+  borrowed: string;
+  limit: string;
+  availableToBorrow: string;
+}
+interface PoolStateHuman extends BaseContractStateHuman {
+  underlying: string;
+  symbol: string;
+  name: string;
+  decimals: number;
+  availableLiquidity: string;
+  expectedLiquidity: string;
+  totalBorrowed: string;
+  totalDebtLimit: string;
+  creditManagerDebtParams: Record<string, CreditManagerDebtParamsHuman>;
+  totalSupply: string;
+  supplyRate: string;
+  baseInterestIndex: string;
+  baseInterestRate: string;
+  withdrawFee: string;
+  lastBaseInterestUpdate: string;
+  baseInterestIndexLU: string;
+  isPaused: boolean;
+}
+interface QuotaParamsHuman {
+  rate: number;
+  quotaIncreaseFee: number;
+  totalQuoted: string;
+  limit: string;
+  isActive: boolean;
+}
+interface PoolQuotaKeeperStateHuman extends BaseContractStateHuman {
+  quotas: Record<Address, QuotaParamsHuman>;
+}
+interface GaugeParamsHuman {
+  minRate: string;
+  maxRate: string;
+  totalVotesLpSide: number;
+  totalVotesCaSide: number;
+  rate: string;
+}
+interface GaugeStateHuman extends BaseContractStateHuman {
+  epochLastUpdate: number;
+  epochFrozen: boolean;
+  quotaParams: Record<Address, GaugeParamsHuman>;
+}
+interface TumblerStateHuman extends BaseContractStateHuman {
+  epochLength: string;
+  rates: Record<string, string>;
+}
+type RateKeeperStateHuman = GaugeStateHuman | TumblerStateHuman;
+interface LinearInterestRateModelStateHuman extends BaseContractStateHuman {
+  U1: string;
+  U2: string;
+  Rbase: string;
+  Rslope1: string;
+  Rslope2: string;
+  Rslope3: string;
+  isBorrowingMoreU2Forbidden: boolean;
+}
+type InterestRateModelStateHuman = LinearInterestRateModelStateHuman;
+interface PoolSuiteStateHuman {
+  pool: PoolStateHuman;
+  poolQuotaKeeper: PoolQuotaKeeperStateHuman;
+  interestRateModel?: InterestRateModelStateHuman;
+  rateKeeper: RateKeeperStateHuman;
+}
+interface AliasLossPolicyStateHuman extends BaseContractStateHuman {
+  contractType: "LOSS_POLICY::ALIASED";
+  accessMode: string;
+  checksEnabled: boolean;
+  tokens: string[];
+  priceFeedParams: {
+    priceFeed: string;
+    stalenessPeriod: string;
+    skipCheck: boolean;
+    tokenDecimals: number;
+  }[];
+}
+type LossPolicyStateHuman = AliasLossPolicyStateHuman | BaseContractStateHuman;
+interface MarketStateHuman {
+  configurator: string;
+  pool: PoolSuiteStateHuman;
+  creditManagers: CreditSuiteStateHuman[];
+  priceOracle: PriceOracleStateHuman;
+  lossPolicy: LossPolicyStateHuman;
+  pausableAdmins: string[];
+  unpausableAdmins: string[];
+  emergencyLiquidators: string[];
+}
+interface ZapperStateHuman {
+  address: string;
+  contractType: string;
+  type: "migration" | "rwa" | "base";
+  pool: string;
+  tokenIn: string;
+  tokenOut: string;
+}
+interface GearboxStateHuman {
+  network: string;
+  block: number;
+  timestamp: string;
+  core: CoreStateHuman;
+  markets: MarketStateHuman[];
+  plugins: Record<string, unknown>;
+  tokens: TokenMetaData[];
+  rwa: RWAStateHuman;
+  zappers?: ZapperStateHuman[];
+}
+/**
+ * Human-readable state for all chains managed by {@link MultichainSDK}.
+ **/
+interface MultichainStateHuman {
+  /** State format version. */
+  version: number;
+  /** Per-chain human-readable state. */
+  chains: GearboxStateHuman[];
+}
+//#endregion
+export { AddressProviderV3StateHuman, AliasLossPolicyStateHuman, AssetPriceFeedStateHuman, BalancerWeightedPriceFeedStateHuman, BaseContractStateHuman, BasePriceFeedStateHuman, BotListStateHuman, BoundedOracleStateHuman, ConstantOracleStateHuman, CoreStateHuman, CreditConfiguratorStateHuman, CreditFacadeStateHuman, CreditManagerDebtParamsHuman, CreditManagerStateHuman, CreditSuiteStateHuman, GaugeParamsHuman, GaugeStateHuman, GearStakingV3StateHuman, GearboxStateHuman, InterestRateModelStateHuman, LPPriceFeedStateHuman, LinearInterestRateModelStateHuman, LossPolicyStateHuman, MarketStateHuman, MultichainStateHuman, PoolQuotaKeeperStateHuman, PoolStateHuman, PoolSuiteStateHuman, PriceFeedStateHuman, PriceOracleStateHuman, QuotaParamsHuman, RateKeeperStateHuman, RedstonePriceFeedStateHuman, TumblerStateHuman, ZapperStateHuman };

package/dist/types/onchain/types/state.d.ts

@@ -0,0 +1,92 @@
+import { NetworkType } from "../chain/chains.js";
+import { WithdrawalsState } from "../accounts/withdrawal-compressor/types.js";
+import { MarketData } from "../base/types.js";
+import { RWAState } from "../market/rwa/types.js";
+import "../market/rwa/index.js";
+import { ZapperData } from "../market/types.js";
+import "../market/index.js";
+import { PluginStatesMap, PluginsMap } from "../plugins/types.js";
+import "../plugins/index.js";
+import { TokensMetaState } from "../base/TokensMeta.js";
+import { AddressProviderState } from "../core/types.js";
+import "../core/index.js";
+import "../base/index.js";
+//#region src/onchain/types/state.d.ts
+/**
+ * Complete serialisable snapshot of the SDK state for a single chain.
+ *
+ * Produced by {@link OnchainSDK.state} and consumed by
+ * {@link OnchainSDK.hydrate} for instant offline restoration.
+ *
+ * @typeParam Plugins - Map of plugin names to plugin instances.
+ **/
+interface GearboxState<Plugins extends PluginsMap = {}> {
+  /**
+   * State format version, checked during hydration.
+   * This is *not* the `@gearbox-protocol/sdk` package version.
+   **/
+  version: number;
+  /**
+   * Gearbox network type the snapshot was taken from.
+   **/
+  network: NetworkType;
+  /**
+   * EVM chain ID the snapshot was taken from.
+   **/
+  chainId: number;
+  /**
+   * Block number the snapshot corresponds to.
+   **/
+  currentBlock: bigint;
+  /**
+   * Block timestamp (Unix epoch seconds).
+   **/
+  timestamp: bigint;
+  /**
+   * Address provider contract state.
+   **/
+  addressProvider: AddressProviderState;
+  /**
+   * All loaded market data.
+   **/
+  markets: MarketData[];
+  /**
+   * Metadata of all known tokens, including the extended data (contract types,
+   * serialized params) that has no compressor of its own.
+   **/
+  tokens?: TokensMetaState;
+  /**
+   * RWA compressor state snapshot, if RWA factories were loaded.
+   **/
+  rwa?: RWAState;
+  /**
+   * All loaded zappers, keyed implicitly by their `pool` field.
+   *
+   * Present only when zappers were loaded (they are optional)
+   **/
+  zappers?: ZapperData[];
+  /**
+   * Withdrawal compressor's withdrawable assets cache.
+   *
+   * Present only when the compressor exists on the chain and its assets
+   * were loaded
+   **/
+  withdrawals?: WithdrawalsState;
+  /**
+   * Per-plugin serialised state.
+   **/
+  plugins: PluginStatesMap<Plugins>;
+}
+/**
+ * Serialised state for all chains managed by {@link MultichainSDK}.
+ *
+ * @typeParam Plugins - Map of plugin names to plugin instances.
+ **/
+interface MultichainState<Plugins extends PluginsMap = {}> {
+  /** State format version. */
+  version: number;
+  /** Per-chain serialised state. */
+  chains: GearboxState<Plugins>[];
+}
+//#endregion
+export { GearboxState, MultichainState };