@gearbox-protocol/sdk 14.0.0-next.1 → 14.0.0-next.10

package/dist/esm/sdk/MultichainSDK.js

@@ -15,8 +15,10 @@ class MultichainSDK {
   #chains;
   #redstoneCache;
   #pythCache;
+  #logger;
   constructor(options) {
     this.#chains = /* @__PURE__ */ new Map();
+    this.#logger = options.logger;
     for (const [network, chainConfig] of Object.entries(options.chains)) {
       const { gasLimit, ...clientOptions } = chainConfig;
       let plugins;
@@ -78,6 +80,7 @@ class MultichainSDK {
         });
       })
     );
+    this.#logger?.info("Attached all chains");
   }
   /**
    * Hydrate all configured chains from serialised state.
@@ -85,7 +88,8 @@ class MultichainSDK {
    * @param state - Multichain serialised state.
    * @param options - Shared and per-chain hydrate options.
    * @throws {@link SdkStateVersionMismatchError} if version doesn't match.
-   * @throws {@link SdkMissingChainStateError} if a configured chain has no state.
+   * @throws {@link SdkMissingChainStateError} if a configured chain has no
+   *   state and `allowMissingChains` is not set.
    */
   hydrate(state, options) {
     if (state.version !== STATE_VERSION) {
@@ -107,6 +111,9 @@ class MultichainSDK {
     for (const [network, sdk] of this.#chains) {
       const chainState = stateByNetwork.get(network);
       if (!chainState) {
+        if (options?.allowMissingChains) {
+          continue;
+        }
         throw new SdkMissingChainStateError(network);
       }
       const perChainOpts = options?.perChain?.[network] ?? {};
@@ -124,6 +131,7 @@ class MultichainSDK {
         }
       });
     }
+    this.#logger?.info("Hydrated all chains");
   }
   /**
    * Returns the {@link OnchainSDK} for a given network or chain ID.
@@ -182,6 +190,7 @@ class MultichainSDK {
     if (Object.keys(errors).length > 0) {
       throw new SdkSyncFailedError(errors);
     }
+    this.#logger?.info("Synced state for all chains");
   }
   /**
    * Serialisable snapshot of all chains' state.

package/dist/esm/sdk/OnchainSDK.js

@@ -223,10 +223,18 @@ class OnchainSDK extends ChainContractsRegister {
     this.logger?.info("hydrated sdk state");
     this.#attached = true;
   }
-  /** Gearbox network type the SDK is connected to (e.g. `"Mainnet"`, `"Arbitrum"`). */
+  /**
+   * Gearbox network type the SDK is connected to (e.g. `"Mainnet"`, `"Arbitrum"`).
+   **/
   get networkType() {
     return this.client.chain.network;
   }
+  /**
+   * Whether the SDK has been initialised via {@link attach} or {@link hydrate}.
+   **/
+  get attached() {
+    return this.#attached;
+  }
   /**
    * Returns a human-readable snapshot of the entire SDK state.
    * @param raw - When `true`, include raw numeric values alongside formatted ones.

package/dist/esm/sdk/market/pricefeeds/updates/PythAccumulatorUpdateData.js

@@ -1,4 +1,3 @@
-import BN from "bn.js";
 import { Buffer } from "buffer";
 const ACCUMULATOR_MAGIC = "504e4155";
 const MAJOR_VERSION = 1;
@@ -6,6 +5,14 @@ const MINOR_VERSION = 0;
 const KECCAK160_HASH_SIZE = 20;
 const PRICE_FEED_MESSAGE_VARIANT = 0;
 const TWAP_MESSAGE_VARIANT = 1;
+function bufToBigInt(buf) {
+  if (buf.length === 0) return 0n;
+  let result = 0n;
+  for (let i = 0; i < buf.length; i++) {
+    result = result << 8n | BigInt(buf[i]);
+  }
+  return result;
+}
 function isAccumulatorUpdateData(updateBytes) {
   return updateBytes.toString("hex").slice(0, 8) === ACCUMULATOR_MAGIC && updateBytes[4] === MAJOR_VERSION && updateBytes[5] === MINOR_VERSION;
 }
@@ -18,19 +25,19 @@ function parsePriceFeedMessage(message) {
   cursor += 1;
   const feedId = message.subarray(cursor, cursor + 32);
   cursor += 32;
-  const price = new BN(message.subarray(cursor, cursor + 8), "be");
+  const price = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
-  const confidence = new BN(message.subarray(cursor, cursor + 8), "be");
+  const confidence = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
   const exponent = message.readInt32BE(cursor);
   cursor += 4;
-  const publishTime = new BN(message.subarray(cursor, cursor + 8), "be");
+  const publishTime = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
-  const prevPublishTime = new BN(message.subarray(cursor, cursor + 8), "be");
+  const prevPublishTime = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
-  const emaPrice = new BN(message.subarray(cursor, cursor + 8), "be");
+  const emaPrice = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
-  const emaConf = new BN(message.subarray(cursor, cursor + 8), "be");
+  const emaConf = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
   return {
     feedId,
@@ -52,19 +59,19 @@ function parseTwapMessage(message) {
   cursor += 1;
   const feedId = message.subarray(cursor, cursor + 32);
   cursor += 32;
-  const cumulativePrice = new BN(message.subarray(cursor, cursor + 16), "be");
+  const cumulativePrice = bufToBigInt(message.subarray(cursor, cursor + 16));
   cursor += 16;
-  const cumulativeConf = new BN(message.subarray(cursor, cursor + 16), "be");
+  const cumulativeConf = bufToBigInt(message.subarray(cursor, cursor + 16));
   cursor += 16;
-  const numDownSlots = new BN(message.subarray(cursor, cursor + 8), "be");
+  const numDownSlots = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
   const exponent = message.readInt32BE(cursor);
   cursor += 4;
-  const publishTime = new BN(message.subarray(cursor, cursor + 8), "be");
+  const publishTime = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
-  const prevPublishTime = new BN(message.subarray(cursor, cursor + 8), "be");
+  const prevPublishTime = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
-  const publishSlot = new BN(message.subarray(cursor, cursor + 8), "be");
+  const publishSlot = bufToBigInt(message.subarray(cursor, cursor + 8));
   cursor += 8;
   return {
     feedId,

package/dist/esm/sdk/market/pricefeeds/updates/fetchPythPayloads.js

@@ -104,7 +104,7 @@ function splitAccumulatorUpdates(binary) {
     const msg = parsePriceFeedMessage(upd);
     results.push({
       dataFeedId: toHex(msg.feedId),
-      timestamp: msg.publishTime.toNumber(),
+      timestamp: Number(msg.publishTime),
       data: toHex(sliceAccumulatorUpdateData(data, i, i + 1))
     });
   }

package/dist/esm/sdk/utils/formatter.js

@@ -1,5 +1,4 @@
 import { formatDuration as fmtDuration, intervalToDuration } from "date-fns";
-import Decimal from "decimal.js-light";
 import { LEVERAGE_DECIMALS, PERCENTAGE_FACTOR } from "../constants/index.js";
 const toBigInt = (v) => {
   const value = typeof v === "object" && v.type === "BigNumber" ? v.hex : v.toString();
@@ -103,17 +102,22 @@ function formatTimestamp(timestamp, raw = true) {
 function rayToNumber(num) {
   return Number(toBigInt(num) / 10n ** 21n) / 1e6;
 }
-function toSignificant(num, decimals, precision = 6) {
-  if (num === 1n) return "0";
-  const divider = new Decimal(10).toPower(decimals);
-  const number = new Decimal(num.toString()).div(divider);
-  return number.toSignificantDigits(precision, 4).toString();
-}
 function toBN(num, decimals) {
   if (num === "") return 0n;
-  const multiplier = new Decimal(10).toPower(decimals);
-  const number = new Decimal(num).mul(multiplier);
-  return BigInt(number.toFixed(0));
+  const negative = num.startsWith("-");
+  const abs = negative ? num.slice(1) : num;
+  const [intPart = "0", fracPart = ""] = abs.split(".");
+  let frac = fracPart;
+  let roundUp = false;
+  if (frac.length > decimals) {
+    roundUp = frac.charCodeAt(decimals) >= 53;
+    frac = frac.slice(0, decimals);
+  } else {
+    frac = frac.padEnd(decimals, "0");
+  }
+  let result = BigInt(intPart + frac);
+  if (roundUp) result += 1n;
+  return negative ? -result : result;
 }
 function shortAddress(address) {
   return address === void 0 ? "" : `${address.slice(0, 6)}...${address.slice(address.length - 4)}`;
@@ -127,6 +131,91 @@ function formatPercentage(healthFactor, decimals = 2) {
 function formatLeverage(leverage, decimals = 2) {
   return (leverage / Number(LEVERAGE_DECIMALS)).toFixed(decimals);
 }
+function formatDecimalJsLikeToString(digits, base10exp) {
+  const len = digits.length;
+  const isExp = base10exp <= -7 || base10exp >= 21;
+  if (isExp) {
+    let coeff = digits;
+    if (len > 1) {
+      coeff = `${digits[0]}.${digits.slice(1)}`;
+    }
+    const exp = base10exp;
+    const expStr = exp < 0 ? `e${exp}` : `e+${exp}`;
+    return `${coeff}${expStr}`;
+  }
+  if (base10exp < 0) {
+    return `0.${"0".repeat(-base10exp - 1)}${digits}`;
+  }
+  if (base10exp >= len) {
+    return `${digits}${"0".repeat(base10exp + 1 - len)}`;
+  }
+  const k = base10exp + 1;
+  if (k === len) return digits;
+  return `${digits.slice(0, k)}.${digits.slice(k)}`;
+}
+function roundToSignificantDigitsHalfUp(digits, base10exp, precision) {
+  if (precision < 1) {
+    throw new Error(`Invalid precision: ${precision}`);
+  }
+  if (digits === "0") return { digits: "0", base10exp: 0 };
+  let norm = digits;
+  while (norm.length > 1 && norm.endsWith("0")) {
+    norm = norm.slice(0, -1);
+  }
+  digits = norm;
+  if (digits.length <= precision) {
+    return { digits, base10exp };
+  }
+  const cut = digits.slice(0, precision).split("");
+  const next = digits.charCodeAt(precision) - 48;
+  if (next >= 5) {
+    let i = cut.length - 1;
+    while (i >= 0) {
+      const cur = cut[i];
+      if (cur === void 0) {
+        throw new Error("roundToSignificantDigitsHalfUp: invalid state");
+      }
+      const d = cur.charCodeAt(0) - 48;
+      if (d !== 9) {
+        cut[i] = String.fromCharCode(48 + d + 1);
+        break;
+      }
+      cut[i] = "0";
+      i -= 1;
+    }
+    if (i < 0) {
+      cut.unshift("1");
+      base10exp += 1;
+    }
+  }
+  let rounded = cut.join("");
+  let tz = 0;
+  for (let i = rounded.length - 1; i >= 0 && rounded[i] === "0"; i -= 1) {
+    tz += 1;
+  }
+  if (tz > 0) {
+    rounded = rounded.slice(0, -tz);
+  }
+  if (rounded === "") {
+    return { digits: "0", base10exp: 0 };
+  }
+  return { digits: rounded, base10exp };
+}
+function toSignificant(num, decimals, precision = 6) {
+  if (num === 1n) return "0";
+  if (num === 0n) return "0";
+  const negative = num < 0n;
+  const abs = negative ? -num : num;
+  const rawDigits = abs.toString();
+  const base10exp = rawDigits.length - decimals - 1;
+  const rounded = roundToSignificantDigitsHalfUp(
+    rawDigits,
+    base10exp,
+    precision
+  );
+  const body = formatDecimalJsLikeToString(rounded.digits, rounded.base10exp);
+  return negative ? `-${body}` : body;
+}
 export {
   fmtBinaryMask,
   formatBN,

package/dist/types/{src/dev → dev}/RevolverTransport.d.ts

@@ -167,7 +167,8 @@ export type RevolverTransportConfig = {
     onRotateFailed?: (oldTransportName: string, reason?: BaseError) => void | Promise<void>;
 } & z.infer<typeof revolverTransportConfigSchema>;
 export declare class NoAvailableTransportsError extends BaseError {
-    constructor(cause?: Error);
+    statuses: ProviderStatus[];
+    constructor(statuses: ProviderStatus[], cause?: Error);
 }
 export interface RevolverTransportValue {
     /**

package/dist/types/{src/dev → dev}/create2.d.ts

@@ -1,5 +1,4 @@
-import type { Abi } from "abitype";
-import type { Account, Address, Chain, Client, ContractConstructorArgs, GetChainParameter, Hash, Hex, SendTransactionParameters, SendTransactionReturnType, Transport, UnionEvaluate, UnionOmit, WalletClient } from "viem";
+import type { Abi, Account, Address, Chain, Client, ContractConstructorArgs, GetChainParameter, Hash, Hex, SendTransactionParameters, SendTransactionReturnType, Transport, UnionEvaluate, UnionOmit, WalletClient } from "viem";
 import type { OnchainSDK } from "../sdk/index.js";
 import { Construct } from "../sdk/index.js";
 export declare const PUBLIC_CREATE2_FACTORY: Address;

package/dist/types/{src/dev → dev}/logSplitterTransport.d.ts

@@ -56,7 +56,9 @@ export declare function isRangeError(error: unknown): boolean;
  * 1. **Alchemy JSON details** — parses the `details` field of a
  *    {@link HttpRequestError} for a suggested `[fromHex, toHex]` range and
  *    computes the span as `toHex - fromHex + 1`.
- * 2. **Generic N-blocks pattern** — matches `/<number> block(s)/i` in the
+ * 2. **DRPC decimal range** — matches `retry with the range <from>-<to>` and
+ *    computes the span as `to - from + 1`.
+ * 3. **Generic N-blocks pattern** — matches `/<number> block(s)/i` in the
  *    error message.
  *
  * @param error - Any thrown value.

package/dist/types/{src/dev → dev}/replaceStorage.d.ts

@@ -1,4 +1,4 @@
-import type { Abi } from "abitype";
+import type { Abi } from "viem";
 import { type ContractFunctionArgs, type ContractFunctionName, type ContractFunctionParameters, type ReadContractReturnType } from "viem";
 import type { AnvilClient } from "./createAnvilClient.js";
 export type ReplaceStorageParams<abi extends Abi | readonly unknown[] = Abi, functionName extends ContractFunctionName<abi, "pure" | "view"> = ContractFunctionName<abi, "pure" | "view">, args extends ContractFunctionArgs<abi, "pure" | "view", functionName> = ContractFunctionArgs<abi, "pure" | "view", functionName>> = ContractFunctionParameters<abi, "pure" | "view", functionName, args, false> & {

package/dist/types/plugins/apy/ApyPlugin.d.ts

@@ -0,0 +1,46 @@
+import type { Address } from "viem";
+import type { IOnchainSDKPlugin } from "../../sdk/index.js";
+import { AddressMap, BasePlugin } from "../../sdk/index.js";
+import type { GetPoolsAPYResult } from "./pool-apy-types.js";
+import type { ApySnapshotState, Pool7DAgoState, Pools7DAgoStateHuman } from "./types.js";
+export interface ApyPluginState {
+    pools7DAgo: Record<Address, Pool7DAgoState>;
+    apySnapshot: ApySnapshotState;
+}
+export interface ApyPluginConstructorOptions {
+    apyUrl?: string;
+    /** TTL for the shared HTTP cache in milliseconds (default: 10 minutes, see `DEFAULT_APY_INTERVAL_MS`) */
+    cacheTtlMs?: number;
+}
+export interface ApyPluginLoadOptions {
+    /**
+     * When `false` and the plugin is already loaded, skips the multicall that loads
+     * pool diesel rates at the ~7d-ago block; only the APY snapshot is refreshed.
+     * Ignored on the first load (both datasets are always fetched initially).
+     */
+    loadPools7DAgo?: boolean;
+}
+export declare class ApyPlugin extends BasePlugin<ApyPluginState> implements IOnchainSDKPlugin<ApyPluginState> {
+    #private;
+    constructor(loadOnAttach?: boolean, options?: ApyPluginConstructorOptions);
+    load(force?: boolean, loadOptions?: ApyPluginLoadOptions): Promise<ApyPluginState>;
+    get loaded(): boolean;
+    /**
+     * @throws if plugin is not loaded
+     */
+    get pools7DAgo(): AddressMap<Pool7DAgoState>;
+    /**
+     * @throws if plugin is not loaded
+     */
+    get apySnapshot(): ApySnapshotState;
+    /**
+     * Computes per-pool APY (current + 7d-ago) and points for all markets.
+     *
+     * @throws if plugin is not loaded
+     */
+    getPoolsAPY(): GetPoolsAPYResult;
+    syncState(): Promise<void>;
+    stateHuman(_?: boolean): Pools7DAgoStateHuman[];
+    get state(): ApyPluginState;
+    hydrate(state: ApyPluginState): void;
+}

package/dist/types/plugins/apy/apy-cache.d.ts

@@ -0,0 +1,28 @@
+import type { Output } from "../../rewards/apy/index.js";
+import type { ILogger } from "../../sdk/index.js";
+/**
+ * Process-wide cache for the APY state-cache JSON.
+ *
+ * Multiple ApyPlugin instances (one per SDK / network) share the same
+ * cached HTTP response so that only **one** request is made per TTL window
+ * regardless of how many SDK instances exist.
+ *
+ * Concurrent callers that arrive while a fetch is already in flight
+ * are de-duplicated — they all await the same promise.
+ */
+export declare class ApyOutputCache {
+    #private;
+    private constructor();
+    /**
+     * Returns a shared cache instance for the given URL.
+     * The same instance is reused across all callers with identical URL.
+     */
+    static get(url: string, ttlMs: number, logger?: ILogger): ApyOutputCache;
+    /**
+     * Returns cached Output if fresh, otherwise fetches from the network.
+     * Concurrent calls are de-duplicated.
+     */
+    fetch(): Promise<Output<string, string> | undefined>;
+    /** Evicts all cached entries. Mainly useful for tests. */
+    static clearAll(): void;
+}

package/dist/types/plugins/apy/apy-parser.d.ts

@@ -0,0 +1,5 @@
+import type { DataResult, Output, PoolOutputDetails, TokenOutputDetails } from "../../rewards/apy/index.js";
+import type { GearStats, NetworkApyData } from "./types.js";
+export declare function numberToAPY(baseApy: number): number;
+export declare function parseGearStats(output: Output<string, string>): GearStats | null;
+export declare function parseNetworkApy(apyResp: DataResult<TokenOutputDetails<string>[]> | undefined, poolResp: DataResult<PoolOutputDetails<string>[]> | undefined): NetworkApyData | undefined;

package/dist/types/plugins/apy/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const APY_STATE_CACHE_URL = "https://state-cache.gearbox.foundation/apy-server/latest.json";
+export declare const DEFAULT_APY_INTERVAL_MS: number;

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

@@ -0,0 +1,7 @@
+export * from "./ApyPlugin.js";
+export * from "./apy-cache.js";
+export * from "./apy-parser.js";
+export * from "./constants.js";
+export * from "./pool-apy-types.js";
+export * from "./pool-apy-utils.js";
+export * from "./types.js";

package/dist/types/plugins/apy/pool-apy-types.d.ts

@@ -0,0 +1,41 @@
+import type { Address } from "viem";
+import type { ExternalApy as ExternalApySDK, PoolExtraApy, PoolPointsInfo } from "../../rewards/apy/index.js";
+import type { PoolPointsBase } from "../../rewards/index.js";
+export interface PoolBaseAPY {
+    type: "supplyAPY" | "tokenYield";
+    apy: number;
+}
+/**
+ * External APY enriched with the cumulative `totalValue`
+ * (base + extra + external).
+ */
+export interface PoolExternalAPY extends ExternalApySDK {
+    totalValue: number;
+}
+export interface PoolFullAPY {
+    totalAPY: number;
+    baseAPY: PoolBaseAPY[];
+    extraAPY: PoolExtraApy[];
+    extraAPYTotal: number;
+    externalAPY: PoolExternalAPY | undefined;
+}
+export interface PoolFullAPY7DAgo extends PoolFullAPY {
+    loading7DAgo: boolean;
+}
+export interface PoolPointsWithTips {
+    reward?: PoolPointsInfo<string>;
+    amount: string;
+    name: string;
+    tokenTitle?: string;
+    fullTip: string;
+}
+type AllPoolsAPY = Record<Address, PoolFullAPY>;
+type AllPoolsAPY7DAgo = Record<Address, PoolFullAPY7DAgo>;
+type AllPoolsPoints = Record<Address, PoolPointsWithTips[] | undefined>;
+export interface GetPoolsAPYResult {
+    data: AllPoolsAPY;
+    data7DAgo: AllPoolsAPY7DAgo;
+    pointsBase: PoolPointsBase;
+    points: AllPoolsPoints;
+}
+export {};

package/dist/types/plugins/apy/pool-apy-utils.d.ts

@@ -0,0 +1,73 @@
+import type { Address } from "viem";
+import type { ExternalApy, PoolExtraApy } from "../../rewards/apy/index.js";
+import type { PoolPointsBase } from "../../rewards/rewards/extra-apy.js";
+import type { AddressMap } from "../../sdk/index.js";
+import type { PoolFullAPY, PoolFullAPY7DAgo, PoolPointsWithTips } from "./pool-apy-types.js";
+/**
+ * Collects extra APY entries for the given token addresses from the
+ * `poolExtraAPYList` map.
+ *
+ * In the client, `lookupAddresses` = [pool.address, ...pool.stakedDieselToken].
+ * The caller is responsible for providing the correct set of addresses.
+ */
+export declare function getPoolExtraAPY(lookupAddresses: Address[], poolExtraAPYList: Record<Address, PoolExtraApy[]> | undefined): PoolExtraApy[];
+/**
+ * Computes annualized supply APY based on diesel rate change over ~7 days.
+ *
+ * Returns a value in "percentage" units (e.g. 5 ≈ 5 %).
+ * Falls back to current on-chain `supplyRate` if 7d-ago diesel rate is
+ * missing or higher than the current rate.
+ */
+export declare function calculateSupplyApy7d(currentDieselRate: bigint, currentSupplyRate: bigint, dieselRate7DAgo: bigint): number;
+interface CalculatePoolFullAPYProps {
+    depositAPY: number;
+    underlyingAPY: number;
+    extraAPY: PoolExtraApy[] | undefined;
+    currentExternalList: ExternalApy[] | undefined;
+}
+/**
+ * Aggregates all APY components for a single pool.
+ *
+ * `depositAPY` and returned values are in "percentage" units (5 ≈ 5 %).
+ * `underlyingAPY` comes from `apyList` (scaled by `PERCENTAGE_FACTOR`),
+ *  so it is divided by `PERCENTAGE_FACTOR` here.
+ *
+ * External APY: first entry in `currentExternalList`, enriched with `totalValue`.
+ */
+export declare function calculatePoolFullAPY({ depositAPY, underlyingAPY, extraAPY, currentExternalList, }: CalculatePoolFullAPYProps): PoolFullAPY;
+interface CalculatePoolFullAPY7DAgoProps {
+    depositAPY: number;
+    /**
+     * Annualized supply APY from the ~7d diesel snapshot, in the same units as
+     * `depositAPY`.
+     *
+     * - `undefined` — 7d snapshot not loaded yet (`loading7DAgo: true`); supply
+     *   row uses `depositAPY`.
+     * - `null` — snapshot loaded but no numeric 7d supply; supply row uses
+     *   `depositAPY` (`||` semantics, same as client `pool7DAgo` with missing
+     *   `supplyAPY7DAgo`).
+     * - `number` — explicit 7d supply; `0` falls back to `depositAPY` via `||`.
+     */
+    supplyAPY7DAgo?: number | null;
+    poolAPY?: PoolFullAPY | null;
+}
+/**
+ * Computes the 7-days-ago APY snapshot for a pool.
+ *
+ * `supplyAPY7DAgo` replaces the current deposit APY in the base component;
+ * extra & external APY are kept from the "current" calculation.
+ */
+export declare function calculatePoolFullAPY7DAgo({ supplyAPY7DAgo, depositAPY, poolAPY, }: CalculatePoolFullAPY7DAgoProps): PoolFullAPY7DAgo;
+interface CalculatePoolPointsProps {
+    poolTokenSymbol: string | undefined;
+    points: PoolPointsBase[Address] | undefined;
+    tokensList: AddressMap<{
+        decimals: number;
+    }>;
+}
+/**
+ * Transforms raw `PoolPointsBase` entries into consumer-friendly
+ * `PoolPointsWithTips` items with formatted amounts and tooltip strings.
+ */
+export declare function calculatePoolPoints({ poolTokenSymbol, points, tokensList, }: CalculatePoolPointsProps): PoolPointsWithTips[] | undefined;
+export {};

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

@@ -0,0 +1,37 @@
+import type { Address } from "viem";
+import type { ExternalApy, ExtraCollateralAPY, GearAPYDetails, PointsInfo, PoolExtraApy, PoolPointsInfo } from "../../rewards/apy/index.js";
+import type { BaseContractStateHuman } from "../../sdk/index.js";
+export interface Pool7DAgoState {
+    pool: Address;
+    dieselRate: bigint;
+}
+export interface Pools7DAgoStateHuman extends BaseContractStateHuman {
+    dieselRate: bigint;
+}
+export interface FarmRewardInfo {
+    address: Address;
+    symbol: string;
+    rewardToken: Address;
+    rewardSymbol: string;
+    token: Address;
+    duration: bigint;
+    finished: bigint;
+    reward: bigint;
+    balance: bigint;
+}
+export interface NetworkApyData {
+    apyList: Record<Address, number> | undefined;
+    extraCollateralAPYList: Record<Address, Record<Address, ExtraCollateralAPY>> | undefined;
+    pointsList: Record<Address, PointsInfo<string>> | undefined;
+    extraCollateralPointsList: Record<Address, Record<Address, PointsInfo<string>>> | undefined;
+    poolRewardsList: Record<Address, Array<PoolPointsInfo<string>>> | undefined;
+    tokenExtraRewardsList: Record<Address, Array<FarmRewardInfo>> | undefined;
+    poolExternalAPYList: Record<Address, Array<ExternalApy>> | undefined;
+    poolExtraAPYList: Record<Address, Array<PoolExtraApy>> | undefined;
+}
+export type GearStats = Omit<GearAPYDetails, "lastUpdated">;
+export interface ApySnapshotState {
+    apy: NetworkApyData;
+    gearStats: GearStats | null;
+    timestamp: string;
+}

package/dist/types/{src/rewards → rewards}/rewards/api.d.ts

@@ -1,6 +1,15 @@
 import type { Address } from "viem";
 import { type NetworkType } from "../../sdk/index.js";
-import type { PoolData } from "./common.js";
+export interface PoolData {
+    address: Address;
+    version: number;
+    underlyingToken: Address;
+    dieselRateRay: bigint;
+    dieselToken: Address;
+    stakedDieselToken: Address[];
+    stakedDieselToken_old: Address[];
+    expectedLiquidity: bigint;
+}
 export interface GearboxExtraMerkleLmReward {
     pool: Address;
     poolToken: Address;

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

@@ -0,0 +1,6 @@
+import type { Address } from "viem";
+export interface TokenData {
+    address: Address;
+    symbol: string;
+    decimals: number;
+}

package/dist/types/{src/rewards → rewards}/rewards/extra-apy.d.ts

@@ -1,13 +1,12 @@
 import type { Address } from "viem";
-import { type Asset, type NetworkType } from "../../sdk/index.js";
+import { type Asset, type MarketSuite, type NetworkType, type TokensMeta } from "../../sdk/index.js";
 import type { PoolPointsInfo } from "../index.js";
-import type { PoolData, TokenData } from "./common.js";
-type PartialPool = Pick<PoolData, "expectedLiquidity" | "underlyingToken" | "address">;
+import type { TokenData } from "./common.js";
 export interface GetPointsByPoolProps {
     poolRewards: Record<Address, Array<PoolPointsInfo<string>>>;
     totalTokenBalances: Record<Address, Asset>;
-    pools: Array<PartialPool>;
-    tokensList: Record<Address, TokenData>;
+    pools: MarketSuite[];
+    tokensList: TokensMeta;
 }
 export interface GetTotalTokensOnProtocolProps {
     tokensToCheck: Array<Address>;
@@ -27,4 +26,3 @@ export declare class PoolPointsAPI {
     static getPointsByPool({ poolRewards, totalTokenBalances, pools, tokensList, }: GetPointsByPoolProps): PoolPointsBase;
     private static getPoolTokenPoints;
 }
-export {};

package/dist/types/{src/sdk → sdk}/MultichainSDK.d.ts

@@ -72,6 +72,14 @@ export interface MultichainHydrateOptions {
      * Options for Pyth price-feed updates (shared cache across chains).
      **/
     pyth?: PythOptions;
+    /**
+     * When `true`, chains missing from the serialised state are silently skipped
+     * instead of throwing {@link SdkMissingChainStateError}.
+     *
+     * Useful when a deprecated chain is no longer included in cached state snapshots
+     * but users still need it in legacy mode to exit existing positions.
+     **/
+    allowMissingChains?: boolean;
 }
 /**
  * Options for {@link MultichainSDK.syncState}.
@@ -102,7 +110,8 @@ export declare class MultichainSDK<const Plugins extends PluginsMap = {}> {
      * @param state - Multichain serialised state.
      * @param options - Shared and per-chain hydrate options.
      * @throws {@link SdkStateVersionMismatchError} if version doesn't match.
-     * @throws {@link SdkMissingChainStateError} if a configured chain has no state.
+     * @throws {@link SdkMissingChainStateError} if a configured chain has no
+     *   state and `allowMissingChains` is not set.
      */
     hydrate(state: MultichainState<Plugins>, options?: MultichainHydrateOptions): void;
     /**