@gearbox-protocol/sdk 12.4.0-next.1 → 12.5.0

package/dist/esm/sdk/pools/AbstractPoolService.js

@@ -0,0 +1,113 @@
+import { ierc20ZapperDepositsAbi } from "../../abi/iERC20ZapperDeposits.js";
+import { iethZapperDepositsAbi } from "../../abi/iETHZapperDeposits.js";
+import { iZapperAbi } from "../../abi/iZapper.js";
+import { iPoolV300Abi } from "../../abi/v300.js";
+import { SDKConstruct } from "../base/index.js";
+class AbstractPoolService extends SDKConstruct {
+  #version;
+  constructor(sdk, version) {
+    super(sdk);
+    this.#version = version;
+    this.logger?.debug(`Created PoolService with version: ${this.#version}`);
+  }
+  addLiquidity({
+    collateral,
+    pool,
+    account,
+    zapper,
+    permit,
+    nativeTokenAddress,
+    referralCode = 0n,
+    migrate
+  }) {
+    if (zapper?.tokenIn === nativeTokenAddress) {
+      return [
+        {
+          target: zapper.zapper,
+          abi: iethZapperDepositsAbi,
+          functionName: "depositWithReferral",
+          args: [account, referralCode],
+          value: collateral.balance
+        }
+      ];
+    } else if (zapper) {
+      return permit ? [
+        {
+          target: zapper.zapper,
+          abi: ierc20ZapperDepositsAbi,
+          functionName: "depositWithReferralAndPermit",
+          args: [
+            collateral.balance,
+            account,
+            referralCode,
+            permit.deadline,
+            permit.v,
+            permit.r,
+            permit.s
+          ]
+        }
+      ] : [
+        {
+          target: zapper.zapper,
+          abi: ierc20ZapperDepositsAbi,
+          functionName: "depositWithReferral",
+          args: [collateral.balance, account, referralCode]
+        }
+      ];
+    } else {
+      if (migrate) throw Error("No zapper for migration");
+      return [
+        {
+          target: pool,
+          abi: iPoolV300Abi,
+          functionName: "depositWithReferral",
+          args: [collateral.balance, account, referralCode]
+        }
+      ];
+    }
+  }
+  removeLiquidity({
+    pool,
+    amount,
+    account,
+    zapper,
+    permit
+  }) {
+    if (zapper) {
+      return permit ? [
+        {
+          target: zapper.zapper,
+          abi: iZapperAbi,
+          functionName: "redeemWithPermit",
+          args: [
+            amount,
+            account,
+            permit.deadline,
+            permit.v,
+            permit.r,
+            permit.s
+          ]
+        }
+      ] : [
+        {
+          target: zapper.zapper,
+          abi: iZapperAbi,
+          functionName: "redeem",
+          args: [amount, account]
+        }
+      ];
+    } else {
+      return [
+        {
+          target: pool,
+          abi: iPoolV300Abi,
+          functionName: "redeem",
+          args: [amount, account, account]
+        }
+      ];
+    }
+  }
+}
+export {
+  AbstractPoolService
+};

package/dist/esm/sdk/pools/PoolServiceV300.js

@@ -0,0 +1,6 @@
+import { AbstractPoolService } from "./AbstractPoolService.js";
+class PoolServiceV300 extends AbstractPoolService {
+}
+export {
+  PoolServiceV300
+};

package/dist/esm/sdk/pools/PoolServiceV310.js

@@ -0,0 +1,6 @@
+import { AbstractPoolService } from "./AbstractPoolService.js";
+class PoolServiceV310 extends AbstractPoolService {
+}
+export {
+  PoolServiceV310
+};

package/dist/esm/sdk/pools/createPoolService.js

@@ -0,0 +1,15 @@
+import { isV300, isV310 } from "../constants/index.js";
+import { PoolServiceV300 } from "./PoolServiceV300.js";
+import { PoolServiceV310 } from "./PoolServiceV310.js";
+function createPoolService(sdk, version) {
+  if (isV300(version)) {
+    return new PoolServiceV300(sdk, version);
+  }
+  if (isV310(version)) {
+    return new PoolServiceV310(sdk, version);
+  }
+  throw new Error(`Unsupported Pool Service version ${version}`);
+}
+export {
+  createPoolService
+};

package/dist/esm/sdk/pools/index.js

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

package/dist/esm/sdk/sdk-legacy/core/endpoint.js

@@ -85,15 +85,9 @@ class GearboxBackendApi {
     return `${LEADERBOARD_APIS[chainId]}${url}`;
   };
   static getReferralUrl = () => REFERRAL_API;
-  static apyServerAllRewards = (chainId) => URLApi.getRelativeUrl("https://apy-server.fly.dev/api/rewards/tokens/all", {
-    params: { chain_id: chainId }
-  });
-  static apyServerGearAPY = (chainId) => URLApi.getRelativeUrl("https://apy-server.fly.dev/api/rewards/gear-apy", {
-    params: { chain_id: chainId }
-  });
-  static apyServerAllPoolRewards = (chainId) => URLApi.getRelativeUrl("https://apy-server.fly.dev/api/rewards/pools/all", {
-    params: { chain_id: chainId }
-  });
+  static apyAllRewards = () => URLApi.getRelativeUrl(
+    "https://state-cache.gearbox.foundation/apy-server/latest.json"
+  );
 }
 class URLApi {
   static getRelativeUrl = (url, options) => {

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

@@ -95,7 +95,8 @@ class GearboxRewardsApi {
     const [response] = await Promise.allSettled([
       provider.multicall({
         allowFailure: false,
-        contracts: [...farmInfoCalls, ...rewardTokenCalls, ...farmedCalls]
+        contracts: [...farmInfoCalls, ...rewardTokenCalls, ...farmedCalls],
+        batchSize: 0
       })
     ]);
     const safeResponse = GearboxRewardsApi.extractFulfilled(response, reportError, "v3Rewards") || [];

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

@@ -91,12 +91,19 @@ function formatDuration(seconds, raw = true) {
 function formatNumberToString_(value) {
   return value.toLocaleString("en-US", { minimumIntegerDigits: 1, useGrouping: true }).replaceAll(",", "_");
 }
+function formatTimestamp(timestamp) {
+  return new Date(timestamp * 1e3).toLocaleString("en-GB", {
+    dateStyle: "short",
+    timeStyle: "short"
+  });
+}
 export {
   fmtBinaryMask,
   formatBN,
   formatBNvalue,
   formatDuration,
   formatNumberToString_,
+  formatTimestamp,
   numberWithCommas,
   percentFmt,
   toBigInt

package/dist/types/abi/errors.d.ts

@@ -953,6 +953,23 @@ export declare const iExceptionsV310Abi: readonly [{
     readonly name: "ZeroAddressException";
     readonly inputs: readonly [];
 }];
+export declare const iPartialLiquidationBotV310ErrorsAbi: readonly [{
+    readonly type: "error";
+    readonly name: "LiquidatedLessThanNeededException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "LiquidatedMoreThanNeededException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "SeizedLessThanRequiredException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "UnderlyingNotLiquidatableException";
+    readonly inputs: readonly [];
+}];
 export declare const errorAbis: readonly [{
     readonly type: "error";
     readonly inputs: readonly [];
@@ -1901,5 +1918,21 @@ export declare const errorAbis: readonly [{
         readonly type: "address";
         readonly internalType: "address";
     }];
+}, {
+    readonly type: "error";
+    readonly name: "LiquidatedLessThanNeededException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "LiquidatedMoreThanNeededException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "SeizedLessThanRequiredException";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "UnderlyingNotLiquidatableException";
+    readonly inputs: readonly [];
 }];
 export type errorAbis = typeof errorAbis;

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

@@ -6,7 +6,7 @@ export declare const providerConfigSchema: z.ZodObject<{
     name: z.ZodString;
     url: z.ZodURL;
     cooldown: z.ZodOptional<z.ZodNumber>;
-    httpClientOptions: z.ZodOptional<z.ZodObject<{
+    httpTransportOptions: z.ZodOptional<z.ZodObject<{
         batch: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
             batchSize: z.ZodOptional<z.ZodNumber>;
             wait: z.ZodOptional<z.ZodNumber>;
@@ -40,29 +40,11 @@ export declare const SelectionStrategy: z.ZodEnum<{
  */
 export type SelectionStrategy = z.infer<typeof SelectionStrategy>;
 export declare const revolverTransportConfigSchema: z.ZodObject<{
-    network: z.ZodEnum<{
-        Mainnet: "Mainnet";
-        Arbitrum: "Arbitrum";
-        Optimism: "Optimism";
-        Base: "Base";
-        Sonic: "Sonic";
-        MegaETH: "MegaETH";
-        Monad: "Monad";
-        Berachain: "Berachain";
-        Avalanche: "Avalanche";
-        BNB: "BNB";
-        WorldChain: "WorldChain";
-        Etherlink: "Etherlink";
-        Hemi: "Hemi";
-        Lisk: "Lisk";
-        Plasma: "Plasma";
-        Somnia: "Somnia";
-    }>;
     providers: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         url: z.ZodURL;
         cooldown: z.ZodOptional<z.ZodNumber>;
-        httpClientOptions: z.ZodOptional<z.ZodObject<{
+        httpTransportOptions: z.ZodOptional<z.ZodObject<{
             batch: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
                 batchSize: z.ZodOptional<z.ZodNumber>;
                 wait: z.ZodOptional<z.ZodNumber>;

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

@@ -1,6 +1,13 @@
+import { z } from "zod/v4";
 import { type NetworkType } from "../sdk/index.js";
 export declare const SUPPORTED_RPC_PROVIDERS: readonly ["alchemy", "drpc", "thirdweb", "ankr"];
-export type RpcProvider = (typeof SUPPORTED_RPC_PROVIDERS)[number];
+export declare const rpcProvidersSchema: z.ZodEnum<{
+    alchemy: "alchemy";
+    drpc: "drpc";
+    thirdweb: "thirdweb";
+    ankr: "ankr";
+}>;
+export type RpcProvider = z.infer<typeof rpcProvidersSchema>;
 export declare function getRpcProviderUrl(provider: RpcProvider, network: NetworkType, apiKey: string, protocol?: "http" | "ws"): string | undefined;
 export declare function getAlchemyUrl(network: NetworkType, apiKey: string, protocol?: "http" | "ws"): string | undefined;
 export declare function getDrpcUrl(network: NetworkType, apiKey: string, protocol?: "http" | "ws"): string | undefined;

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

@@ -1,5 +1,5 @@
 import { z } from "zod/v4";
-export declare const httpTransportConfigSchema: z.ZodObject<{
+export declare const httpTransportOptionsSchema: z.ZodObject<{
     batch: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
         batchSize: z.ZodOptional<z.ZodNumber>;
         wait: z.ZodOptional<z.ZodNumber>;

package/dist/types/permissionless/utils/format.d.ts

@@ -1,6 +1,5 @@
 export declare function formatBytecodeSize(size: number): string;
 export declare function formatBytecodeVersion(version: number): string;
-export declare function formatTimestamp(timestamp: number): string;
 export declare function shortenHash(hash: string, chars?: number): string;
 export declare function convertPercent(percent: number): number;
 export declare function significantTrunc(x: number): string;

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

@@ -40,7 +40,7 @@ export type ClientOptions = {
      * Retry count for RPC
      */
     retryCount?: number;
-    httpClientOptions?: HttpRpcClientOptions | undefined;
+    httpTransportOptions?: HttpRpcClientOptions | undefined;
 } | {
     /**
      * Alternatively, can pass viem transport

package/dist/types/sdk/core/address-provider/AbstractAddressProviderContract.d.ts

@@ -3,10 +3,10 @@ import type { BaseContractArgs } from "../../base/BaseContract.js";
 import { BaseContract, type ConstructOptions } from "../../base/index.js";
 import type { VersionRange } from "../../constants/index.js";
 import type { AddressProviderV3StateHuman } from "../../types/index.js";
-import type { AddressProviderState } from "./types.js";
+import type { AddressProviderAddresses, AddressProviderState } from "./types.js";
 export default abstract class AbstractAddressProviderContract<abi extends Abi | readonly unknown[]> extends BaseContract<abi> {
     #private;
-    constructor(options: ConstructOptions, args: BaseContractArgs<abi>, addresses?: Record<string, Record<number, Address>>);
+    constructor(options: ConstructOptions, args: BaseContractArgs<abi>, addresses?: AddressProviderAddresses);
     protected setInternalAddress(key: string, address: Address, version: number): void;
     getAddress(contract: string, version?: number): Address;
     getLatest(contract: string, range: VersionRange): [address: Address, version: number] | undefined;

package/dist/types/sdk/core/address-provider/AddressProviderV300Contract.d.ts

@@ -1,7 +1,7 @@
 import type { Address, ContractEventName, DecodeFunctionDataReturnType, Log } from "viem";
 import type { ConstructOptions } from "../../base/Construct.js";
 import AbstractAddressProviderContract from "./AbstractAddressProviderContract.js";
-import type { IAddressProviderContract } from "./types.js";
+import type { AddressProviderAddresses, IAddressProviderContract } from "./types.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly name: "addresses";
@@ -89,7 +89,7 @@ declare const abi: readonly [{
 }];
 type abi = typeof abi;
 export declare class AddressProviderV300Contract extends AbstractAddressProviderContract<abi> implements IAddressProviderContract {
-    constructor(options: ConstructOptions, address: Address, version: number, addresses?: Record<string, Record<number, Address>>);
+    constructor(options: ConstructOptions, address: Address, version: number, addresses?: AddressProviderAddresses);
     protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     syncState(blockNumber?: bigint): Promise<void>;

package/dist/types/sdk/core/address-provider/AddressProviderV310Contract.d.ts

@@ -1,7 +1,7 @@
 import type { Address, ContractEventName, DecodeFunctionDataReturnType, Log } from "viem";
 import type { ConstructOptions } from "../../base/Construct.js";
 import AbstractAddressProviderContract from "./AbstractAddressProviderContract.js";
-import type { IAddressProviderContract } from "./types.js";
+import type { AddressProviderAddresses, IAddressProviderContract } from "./types.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [];
@@ -254,7 +254,7 @@ declare const abi: readonly [{
 }];
 type abi = typeof abi;
 export declare class AddressProviderV310Contract extends AbstractAddressProviderContract<abi> implements IAddressProviderContract {
-    constructor(options: ConstructOptions, address: Address, version?: number, addresses?: Record<string, Record<number, Address>>);
+    constructor(options: ConstructOptions, address: Address, version?: number, addresses?: AddressProviderAddresses);
     protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     syncState(blockNumber?: bigint): Promise<void>;

package/dist/types/sdk/core/address-provider/types.d.ts

@@ -2,6 +2,21 @@ import type { Address } from "viem";
 import type { BaseParams, IBaseContract } from "../../base/index.js";
 import type { VersionRange } from "../../constants/versions.js";
 import type { AddressProviderV3StateHuman } from "../../types/index.js";
+export interface AddressProviderAddresses {
+    /**
+     * Initialize address provider with these addresses
+     * Used in hydration
+     */
+    addresses?: Record<string, Record<number, Address>>;
+    /**
+     * Override addresses for this address provider
+     * These addresses will precede over addresses loaded from chain
+     *
+     * This is an escape hatch.
+     * We used it when we need to fix price feed compressor/market compressor urgently
+     */
+    overrides?: Record<string, Record<number, Address>>;
+}
 export interface AddressProviderState {
     baseParams: BaseParams;
     addresses: Record<string, Record<number, Address>>;

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

@@ -10,6 +10,7 @@ export * from "./market/index.js";
 export * from "./options.js";
 export * from "./plugins/index.js";
 export * from "./poolMigration/index.js";
+export * from "./pools/index.js";
 export * from "./router/index.js";
 export * from "./sdk-gov-legacy/index.js";
 export * from "./sdk-legacy/index.js";

package/dist/types/sdk/market/MarketConfiguratorContract.d.ts

@@ -1531,6 +1531,15 @@ export declare class MarketConfiguratorContract extends BaseContract<abi> {
     #private;
     constructor(options: ConstructOptions, address: Address);
     loadCuratorName(): Promise<void>;
+    static getPeripheryContractBatch(configurators: MarketConfiguratorContract[], client: MarketConfiguratorContract["client"], contract: PeripheryContract): Promise<({
+        error: Error;
+        result?: undefined;
+        status: "failure";
+    } | {
+        error?: undefined;
+        result: readonly `0x${string}`[];
+        status: "success";
+    })[]>;
     getPeripheryContract(contract: PeripheryContract): Promise<Address>;
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
 }

package/dist/types/sdk/pools/AbstractPoolService.d.ts

@@ -0,0 +1,9 @@
+import { SDKConstruct } from "../base/index.js";
+import type { GearboxSDK } from "../GearboxSDK.js";
+import type { AddLiquidityCall, AddLiquidityProps, RemoveLiquidityCall, RemoveLiquidityProps } from "./types.js";
+export declare abstract class AbstractPoolService extends SDKConstruct {
+    #private;
+    constructor(sdk: GearboxSDK, version: number);
+    addLiquidity({ collateral, pool, account, zapper, permit, nativeTokenAddress, referralCode, migrate, }: AddLiquidityProps): AddLiquidityCall;
+    removeLiquidity({ pool, amount, account, zapper, permit, }: RemoveLiquidityProps): RemoveLiquidityCall;
+}

package/dist/types/sdk/pools/PoolServiceV300.d.ts

@@ -0,0 +1,4 @@
+import { AbstractPoolService } from "./AbstractPoolService.js";
+import type { IPoolsService } from "./types.js";
+export declare class PoolServiceV300 extends AbstractPoolService implements IPoolsService {
+}

package/dist/types/sdk/pools/PoolServiceV310.d.ts

@@ -0,0 +1,4 @@
+import { AbstractPoolService } from "./AbstractPoolService.js";
+import type { IPoolsService } from "./types.js";
+export declare class PoolServiceV310 extends AbstractPoolService implements IPoolsService {
+}

package/dist/types/sdk/pools/createPoolService.d.ts

@@ -0,0 +1,8 @@
+import type { GearboxSDK } from "../GearboxSDK.js";
+import type { AbstractPoolService } from "./AbstractPoolService.js";
+/**
+ * @sdk
+ * @version version of desired pool service; either v300 or v310
+ * @returns
+ */
+export declare function createPoolService(sdk: GearboxSDK, version: number): AbstractPoolService;

package/dist/types/sdk/pools/index.d.ts

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

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

@@ -0,0 +1,92 @@
+import type { Address } from "viem";
+import type { ierc20ZapperDepositsAbi } from "../../abi/iERC20ZapperDeposits.js";
+import type { iethZapperDepositsAbi } from "../../abi/iETHZapperDeposits.js";
+import type { iZapperAbi } from "../../abi/iZapper.js";
+import type { iPoolV300Abi } from "../../abi/v300.js";
+import type { PoolData_Legacy } from "../index.js";
+import type { Asset } from "../router/index.js";
+interface PermitResult {
+    r: Address;
+    s: Address;
+    v: number;
+    token: Address;
+    owner: Address;
+    spender: Address;
+    value: bigint;
+    deadline: bigint;
+    nonce: bigint;
+}
+export interface AddLiquidityProps {
+    collateral: Asset;
+    pool: Address;
+    account: Address;
+    migrate: boolean;
+    zapper: PoolData_Legacy["zappers"][Address][Address] | undefined;
+    permit: PermitResult | undefined;
+    nativeTokenAddress: Address;
+    referralCode: bigint | undefined;
+}
+export type AddLiquidityCall = [
+    {
+        target: Address;
+        abi: typeof iethZapperDepositsAbi;
+        functionName: "depositWithReferral";
+        args: [Address, bigint];
+        value: bigint;
+    } | {
+        target: Address;
+        abi: typeof ierc20ZapperDepositsAbi;
+        functionName: "depositWithReferralAndPermit";
+        args: [bigint, Address, bigint, bigint, number, Address, Address];
+    } | {
+        target: Address;
+        abi: typeof ierc20ZapperDepositsAbi;
+        functionName: "depositWithReferral";
+        args: [bigint, Address, bigint];
+    } | {
+        target: Address;
+        abi: typeof iPoolV300Abi;
+        functionName: "depositWithReferral";
+        args: [bigint, Address, bigint];
+    }
+];
+export interface RemoveLiquidityProps {
+    pool: Address;
+    amount: bigint;
+    account: Address;
+    permit: PermitResult | undefined;
+    zapper: PoolData_Legacy["zappers"][Address][Address];
+}
+export type RemoveLiquidityCall = [
+    {
+        target: Address;
+        abi: typeof iZapperAbi;
+        functionName: "redeemWithPermit";
+        args: [bigint, Address, bigint, number, Address, Address];
+    } | {
+        target: Address;
+        abi: typeof iZapperAbi;
+        functionName: "redeem";
+        args: [bigint, Address];
+    } | {
+        target: Address;
+        abi: typeof iPoolV300Abi;
+        functionName: "redeem";
+        args: [bigint, Address, Address];
+    }
+];
+export interface IPoolsService {
+    /**
+     * Add liquidity to a pool
+     * @param props - {@link AddLiquidityProps}
+     * @returns - {@link AddLiquidityCall}
+     */
+    addLiquidity(props: AddLiquidityProps): AddLiquidityCall;
+    /**
+     * Remove liquidity from a pool
+     * @param props - {@link RemoveLiquidityProps}
+     * @returns - {@link RemoveLiquidityCall}
+     */
+    removeLiquidity(props: RemoveLiquidityProps): RemoveLiquidityCall;
+}
+export {};

package/dist/types/sdk/sdk-legacy/core/endpoint.d.ts

@@ -13,9 +13,7 @@ export declare class GearboxBackendApi {
     static getNFTMerkleUrl: (network: NetworkType, root: Address) => string;
     static getLeaderboardUrl: (url: string, chainId: number) => string;
     static getReferralUrl: () => string;
-    static apyServerAllRewards: (chainId: number) => string;
-    static apyServerGearAPY: (chainId: number) => string;
-    static apyServerAllPoolRewards: (chainId: number) => string;
+    static apyAllRewards: () => string;
 }
 interface Options {
     params?: Record<string, string | number>;

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

@@ -72,7 +72,7 @@ export interface CreditFacadeStateHuman extends BaseContractStateHuman {
     expirable: boolean;
     isDegenMode: boolean;
     degenNFT: string;
-    expirationDate: number;
+    expirationDate: string;
     maxDebtPerBlockMultiplier: number;
     botList: string;
     minDebt: string;

package/dist/types/sdk/utils/formatter.d.ts

@@ -9,3 +9,4 @@ export declare function fmtBinaryMask(mask: bigint): string;
 export declare function numberWithCommas(x: number | bigint): string;
 export declare function formatDuration(seconds: number, raw?: boolean): string;
 export declare function formatNumberToString_(value: bigint | number): string;
+export declare function formatTimestamp(timestamp: number): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "12.4.0-next.1",
+  "version": "12.5.0",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.js",
@@ -62,13 +62,13 @@
     "date-fns": "^4.1.0",
     "decimal.js-light": "^2.5.1",
     "viem": ">=2.23.15 <3.0.0",
-    "zod": "^4.2.1"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.10",
-    "@commitlint/cli": "^20.2.0",
-    "@commitlint/config-conventional": "^20.2.0",
-    "@gearbox-protocol/biome-config": "^1.0.16",
+    "@biomejs/biome": "^2.3.11",
+    "@commitlint/cli": "^20.3.0",
+    "@commitlint/config-conventional": "^20.3.0",
+    "@gearbox-protocol/biome-config": "^1.0.17",
     "@types/cross-spawn": "^6.0.6",
     "axios": "^1.13.2",
     "cross-spawn": "^7.0.6",