@gearbox-protocol/sdk 13.0.0-next.9 → 13.1.0-next.1

package/dist/types/sdk/market/pool/PoolSuite.d.ts

@@ -6,6 +6,7 @@ import type { PoolSuiteStateHuman } from "../../types/index.js";
 import type { MarketConfiguratorContract } from "../MarketConfiguratorContract.js";
 import { GaugeContract } from "./GaugeContract.js";
 import { LinearInterestRateModelContract } from "./LinearInterestRateModelContract.js";
+import type { SecuritizeKYCFactory } from "./SecuritizeKYCFactory.js";
 import { TumblerContract } from "./TumblerContract.js";
 import type { IInterestRateModelContract, IRateKeeperContract, PoolContract, PoolQuotaKeeperContract } from "./types.js";
 export declare class PoolSuite extends SDKConstruct {
@@ -20,6 +21,7 @@ export declare class PoolSuite extends SDKConstruct {
     get linearModel(): LinearInterestRateModelContract;
     get marketConfigurator(): MarketConfiguratorContract;
     get underlying(): Address;
+    getKYCFactory(): Promise<SecuritizeKYCFactory | undefined>;
     get dirty(): boolean;
     get watchAddresses(): Set<Address>;
     stateHuman(raw?: boolean): PoolSuiteStateHuman;

package/dist/types/sdk/market/pool/PoolV310Contract.d.ts

@@ -1,8 +1,10 @@
 import type { ContractEventName, DecodeFunctionDataReturnType, Log } from "viem";
-import type { ConstructOptions, CreditManagerDebtParams, PoolState } from "../../base/index.js";
+import type { CreditManagerDebtParams, PoolState } from "../../base/index.js";
 import { BaseContract } from "../../base/index.js";
+import type { GearboxSDK } from "../../GearboxSDK.js";
 import type { PoolStateHuman } from "../../types/index.js";
 import { AddressMap } from "../../utils/index.js";
+import { SecuritizeKYCFactory } from "./SecuritizeKYCFactory.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [];
@@ -1130,8 +1132,10 @@ type abi = typeof abi;
 export interface PoolV310Contract extends Omit<PoolState, "baseParams" | "creditManagerDebtParams" | "name">, BaseContract<abi> {
 }
 export declare class PoolV310Contract extends BaseContract<abi> {
+    #private;
     readonly creditManagerDebtParams: AddressMap<CreditManagerDebtParams>;
-    constructor(options: ConstructOptions, data: PoolState);
+    constructor(sdk: GearboxSDK, data: PoolState);
+    getKYCFactory(): Promise<SecuritizeKYCFactory | undefined>;
     stateHuman(raw?: boolean): PoolStateHuman;
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];

package/dist/types/sdk/market/pool/SecuritizeKYCFactory.d.ts

@@ -0,0 +1,345 @@
+import type { Address } from "viem";
+import type { ConstructOptions } from "../../base/index.js";
+import { BaseContract } from "../../base/index.js";
+import type { MultiCall, RawTx } from "../../types/index.js";
+declare const abi: readonly [{
+    readonly type: "function";
+    readonly name: "contractType";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getCreditAccounts";
+    readonly inputs: readonly [{
+        readonly name: "investor";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getDegenNFT";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getInvestor";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getWallet";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isCreditAccount";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isFrozen";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "multicall";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "calls";
+        readonly type: "tuple[]";
+        readonly internalType: "struct MultiCall[]";
+        readonly components: readonly [{
+            readonly name: "target";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }, {
+        readonly name: "tokensToRegister";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "openCreditAccount";
+    readonly inputs: readonly [{
+        readonly name: "creditManager";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "calls";
+        readonly type: "tuple[]";
+        readonly internalType: "struct MultiCall[]";
+        readonly components: readonly [{
+            readonly name: "target";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }, {
+        readonly name: "tokensToRegister";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "wallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "precomputeWalletAddress";
+    readonly inputs: readonly [{
+        readonly name: "creditManager";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "investor";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "serialize";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "serializedData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "setFrozenStatus";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "frozen";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setInvestor";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "investor";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "version";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "CreateWallet";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "wallet";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "investor";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "SetFrozenStatus";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "frozen";
+        readonly type: "bool";
+        readonly indexed: false;
+        readonly internalType: "bool";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "SetInvestor";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "oldInvestor";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newInvestor";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "CallerIsNotInvestorException";
+    readonly inputs: readonly [{
+        readonly name: "caller";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "FrozenCreditAccountException";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidCreditManagerException";
+    readonly inputs: readonly [{
+        readonly name: "creditManager";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidUnderlyingTokenException";
+    readonly inputs: readonly [{
+        readonly name: "underlying";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "UnknownCreditAccountException";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "ZeroAddressException";
+    readonly inputs: readonly [];
+}];
+type abi = typeof abi;
+export declare class SecuritizeKYCFactory extends BaseContract<abi> {
+    #private;
+    private investorCache;
+    constructor(options: ConstructOptions, address: Address);
+    precomputeWalletAddress(creditManager: Address, investor: Address): Promise<Address>;
+    getWallet(creditAccount: Address): Promise<Address>;
+    /**
+     * Returns the investor address for a credit account.
+     * @param creditAccount - Credit account address
+     * @param fromCache - If true, use and update an in-memory cache (creditAccount -> investor). On cache miss, loads from contract and stores the result for future calls.
+     */
+    getInvestor(creditAccount: Address, fromCache?: boolean): Promise<Address>;
+    getDSTokens(): Promise<Address[]>;
+    multicall(creditAccount: Address, calls: MultiCall[], tokensToRegister: Address[]): RawTx;
+    openCreditAccount(creditManager: Address, calls: MultiCall[], tokensToRegister: Address[]): RawTx;
+    getDegenNFT(): Promise<Address>;
+}
+export {};

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

@@ -1,6 +1,6 @@
 export * from "./GaugeContract.js";
 export * from "./LinearInterestRateModelContract.js";
-export * from "./PoolQuotaKeeperV300Contract.js";
 export * from "./PoolSuite.js";
-export * from "./PoolV300Contract.js";
+export * from "./PoolV310Contract.js";
+export * from "./SecuritizeKYCFactory.js";
 export * from "./types.js";

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

@@ -1,9 +1,7 @@
 import type { IBaseContract } from "../../base/index.js";
 import type { InterestRateModelStateHuman, RateKeeperStateHuman } from "../../types/index.js";
 import type { AddressMap } from "../../utils/index.js";
-import type { PoolQuotaKeeperV300Contract } from "./PoolQuotaKeeperV300Contract.js";
 import type { PoolQuotaKeeperV310Contract } from "./PoolQuotaKeeperV310Contract.js";
-import type { PoolV300Contract } from "./PoolV300Contract.js";
 import type { PoolV310Contract } from "./PoolV310Contract.js";
 export type RateKeeperType = `RATE_KEEPER::${string}`;
 export type InterestRateModelType = `IRM::${string}`;
@@ -14,5 +12,5 @@ export interface IRateKeeperContract extends IBaseContract {
 export interface IInterestRateModelContract extends IBaseContract {
     stateHuman: (raw?: boolean) => InterestRateModelStateHuman;
 }
-export type PoolContract = PoolV300Contract | PoolV310Contract;
-export type PoolQuotaKeeperContract = PoolQuotaKeeperV300Contract | PoolQuotaKeeperV310Contract;
+export type PoolContract = PoolV310Contract;
+export type PoolQuotaKeeperContract = PoolQuotaKeeperV310Contract;

package/dist/types/sdk/market/pricefeeds/AbstractLPPriceFeed.d.ts

@@ -7,9 +7,6 @@ export declare abstract class AbstractLPPriceFeedContract<const abi extends Abi
     readonly lpToken: Address;
     readonly lowerBound: bigint;
     readonly upperBound: bigint;
-    readonly exchangeRate?: bigint;
-    readonly aggregatePrice?: bigint;
-    readonly scale?: bigint;
     constructor(options: ConstructOptions, args: PriceFeedConstructorArgs<abi>);
     stateHuman(raw?: boolean): UnionOmit<LPPriceFeedStateHuman, "stalenessPeriod">;
 }

package/dist/types/sdk/market/pricefeeds/PythPriceFeed.d.ts

@@ -1,4 +1,4 @@
-import type { Address, Hex } from "viem";
+import type { Address, ContractFunctionParameters, Hex } from "viem";
 import type { ConstructOptions } from "../../base/Construct.js";
 import type { RawTx } from "../../types/index.js";
 import type { PartialPriceFeedTreeNode } from "./AbstractPriceFeed.js";
@@ -217,6 +217,20 @@ declare const abi: readonly [{
     readonly inputs: readonly [];
 }];
 type abi = typeof abi;
+declare const iPythAbi: readonly [{
+    readonly name: "getUpdateFee";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes[]";
+        readonly name: "updateData";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "feeAmount";
+    }];
+}];
+type iPythAbi = typeof iPythAbi;
 export declare class PythPriceFeed extends AbstractPriceFeedContract<abi> implements IUpdatablePriceFeedContract {
     readonly token: Address;
     readonly priceFeedId: Hex;
@@ -224,5 +238,11 @@ export declare class PythPriceFeed extends AbstractPriceFeedContract<abi> implem
     readonly maxConfToPriceRatio?: bigint;
     constructor(options: ConstructOptions, args: PartialPriceFeedTreeNode);
     createPriceUpdateTx(data: `0x${string}`): RawTx;
+    /**
+     * Returns contract function parameters for the getUpdateFee function on original Pyth contract
+     * @param calldata
+     * @returns
+     */
+    getUpdateFeeParams(calldata: Hex): ContractFunctionParameters<iPythAbi, "view", "getUpdateFee">;
 }
 export {};

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

@@ -3,7 +3,6 @@ import type { IBaseContract, PriceFeedAnswer } from "../../base/index.js";
 import type { IPriceUpdateTx, PriceFeedStateHuman, RawTx } from "../../types/index.js";
 import type { PriceFeedRef } from "./PriceFeedRef.js";
 export type PriceFeedUsageType = "Main" | "Reserve";
-export type PriceFeedContractTypeLegacy = "PF_BALANCER_STABLE_LP_ORACLE" | "PF_BALANCER_WEIGHTED_LP_ORACLE" | "PF_BOUNDED_ORACLE" | "PF_CHAINLINK_ORACLE" | "PF_COMPOSITE_ORACLE" | "PF_CURVE_CRYPTO_LP_ORACLE" | "PF_CURVE_STABLE_LP_ORACLE" | "PF_CURVE_USD_ORACLE" | "PF_ERC4626_ORACLE" | "PF_MELLOW_LRT_ORACLE" | "PF_PENDLE_PT_TWAP_ORACLE" | "PF_PYTH_ORACLE" | "PF_REDSTONE_ORACLE" | "PF_WSTETH_ORACLE" | "PF_YEARN_ORACLE" | "PF_ZERO_ORACLE";
 export type PriceFeedContractType = "PRICE_FEED::BALANCER_STABLE" | "PRICE_FEED::BALANCER_WEIGHTED" | "PRICE_FEED::BOUNDED" | "PRICE_FEED::COMPOSITE" | "PRICE_FEED::CONSTANT" | "PRICE_FEED::CURVE_CRYPTO" | "PRICE_FEED::CURVE_STABLE" | "PRICE_FEED::CURVE_USD" | "PRICE_FEED::ERC4626" | "PRICE_FEED::EXTERNAL" | "PRICE_FEED::MELLOW_LRT" | "PRICE_FEED::PENDLE_PT_TWAP" | "PRICE_FEED::PYTH" | "PRICE_FEED::REDSTONE" | "PRICE_FEED::WSTETH" | "PRICE_FEED::YEARN" | "PRICE_FEED::ZERO";
 export interface IPriceFeedContract extends IBaseContract {
     readonly hasLowerBoundCap: boolean;
@@ -49,11 +48,3 @@ export interface PriceUpdateV310 {
      */
     data: Hex;
 }
-export interface PriceUpdateV300 {
-    token: Address;
-    reserve: boolean;
-    /**
-     * Data that can be passed to IUpdatablePriceFeed.updatePrice
-     */
-    data: Hex;
-}

package/dist/types/sdk/market/pricefeeds/updates/PriceUpdatesCache.d.ts

@@ -11,14 +11,7 @@ export interface PriceUpdatesCacheOptions {
 }
 export declare class PriceUpdatesCache {
     #private;
-    /**
-     * Price update caches can be shared across networks
-     * @param id - unique key to identify the cache
-     * @param opts
-     * @returns
-     */
-    static get(id: string, opts: PriceUpdatesCacheOptions): PriceUpdatesCache;
-    private constructor();
+    constructor(opts: PriceUpdatesCacheOptions);
     get(...path: Array<number | string>): Omit<TimestampedCalldata, "cached"> | undefined;
     set(value: Omit<TimestampedCalldata, "cached">, ...path: Array<number | string>): void;
 }

package/dist/types/sdk/market/pricefeeds/updates/PythUpdater.d.ts

@@ -12,7 +12,7 @@ export declare const PythOptions: z.ZodObject<{
     historicTimestamp: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<true>]>>;
     apiProxy: z.ZodOptional<z.ZodURL>;
     cacheTTL: z.ZodOptional<z.ZodNumber>;
-    ignoreMissingFeeds: z.ZodOptional<z.ZodBoolean>;
+    failOnMissingFeeds: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type PythOptions = z.infer<typeof PythOptions>;
 /**

package/dist/types/sdk/market/pricefeeds/updates/RedstoneUpdater.d.ts

@@ -14,7 +14,7 @@ export declare const RedstoneOptions: z.ZodObject<{
     historicTimestamp: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<true>]>>;
     gateways: z.ZodOptional<z.ZodArray<z.ZodURL>>;
     cacheTTL: z.ZodOptional<z.ZodNumber>;
-    ignoreMissingFeeds: z.ZodOptional<z.ZodBoolean>;
+    failOnMissingFeeds: z.ZodOptional<z.ZodBoolean>;
     enableLogging: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type RedstoneOptions = z.infer<typeof RedstoneOptions>;

package/dist/types/sdk/market/pricefeeds/updates/fetchPythPayloads.d.ts

@@ -6,9 +6,9 @@ export interface FetchPythPayloadsOptions {
      */
     dataFeedsIds: Iterable<string>;
     /**
-     * When true, will not throw an error if pyth is unable to fetch data for some feeds
+     * When true, will throw an error if pyth is unable to fetch data for some feeds
      */
-    ignoreMissingFeeds?: boolean;
+    failOnMissingFeeds?: boolean;
     /**
      * Historical timestamp in seconds
      */

package/dist/types/sdk/market/pricefeeds/updates/fetchRedstonePayloads.d.ts

@@ -33,9 +33,9 @@ export interface FetchRedstonePayloadsOptions {
      */
     enableLogging?: boolean;
     /**
-     * When true, will not throw an error if redstone is unable to fetch data for some feeds
+     * When true, will throw an error if redstone is unable to fetch data for some feeds
      */
-    ignoreMissingFeeds?: boolean;
+    failOnMissingFeeds?: boolean;
     /**
      * Logger to use
      */

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

@@ -14,14 +14,14 @@ export declare const SDKOptions: z.ZodObject<{
         historicTimestamp: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<true>]>>;
         gateways: z.ZodOptional<z.ZodArray<z.ZodURL>>;
         cacheTTL: z.ZodOptional<z.ZodNumber>;
-        ignoreMissingFeeds: z.ZodOptional<z.ZodBoolean>;
+        failOnMissingFeeds: z.ZodOptional<z.ZodBoolean>;
         enableLogging: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     pyth: z.ZodOptional<z.ZodObject<{
         historicTimestamp: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<true>]>>;
         apiProxy: z.ZodOptional<z.ZodURL>;
         cacheTTL: z.ZodOptional<z.ZodNumber>;
-        ignoreMissingFeeds: z.ZodOptional<z.ZodBoolean>;
+        failOnMissingFeeds: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     gasLimit: z.ZodOptional<z.ZodNullable<z.ZodBigInt>>;
 }, z.core.$strip>;

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

@@ -1,4 +1,3 @@
 export * from "./BasePlugin.js";
 export * from "./errors.js";
 export * from "./types.js";
-export * from "./V300StalenessPeriodPlugin.js";

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

@@ -1,11 +1,14 @@
 import type { Address } from "viem";
 import { SDKConstruct } from "../base/index.js";
-import type { AddLiquidityProps, DepositMetadata, IPoolsService, PoolServiceCall, RemoveLiquidityProps } from "./types.js";
+import type { AddLiquidityProps, DepositMetadata, IPoolsService, PoolServiceCall, RemoveLiquidityProps, WithdrawalMetadata } from "./types.js";
 export declare class PoolService extends SDKConstruct implements IPoolsService {
     #private;
     getDepositTokensIn(pool: Address): Address[];
     getDepositTokensOut(pool: Address, tokenIn: Address): Address[];
     getDepositMetadata(pool: Address, tokenIn: Address, tokenOut?: Address): DepositMetadata;
     addLiquidity(props: AddLiquidityProps): PoolServiceCall | undefined;
+    getWithdrawalTokensIn(pool: Address): Address[];
+    getWithdrawalTokensOut(pool: Address, tokenIn: Address): Address[];
     removeLiquidity(props: RemoveLiquidityProps): PoolServiceCall;
+    getWithdrawalMetadata(pool: Address, tokenIn: Address, tokenOut?: Address): WithdrawalMetadata;
 }

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

@@ -2,7 +2,6 @@ import type { Abi } from "abitype";
 import type { Address, ContractFunctionArgs, ContractFunctionName } from "viem";
 import type { ZapperData } from "../market/index.js";
 import type { Asset } from "../router/index.js";
-import type { PoolData_Legacy } from "../sdk-legacy/index.js";
 interface PermitResult {
     r: Address;
     s: Address;
@@ -32,9 +31,9 @@ export interface AddLiquidityProps {
 export interface RemoveLiquidityProps {
     pool: Address;
     amount: bigint;
-    account: Address;
+    wallet: Address;
     permit: PermitResult | undefined;
-    zapper: PoolData_Legacy["zappers"][Address][Address];
+    meta: WithdrawalMetadata;
 }
 export interface DepositMetadata {
     /**
@@ -56,6 +55,26 @@ export interface DepositMetadata {
      */
     type: "kyc-on-demand" | "kyc-default" | "classic";
 }
+export interface WithdrawalMetadata {
+    /**
+     * Zapper that will perform the deposit, undefined in case of direct pool underlying deposit
+     */
+    zapper?: ZapperData;
+    /**
+     * Before deposit user will nedd to call approve method on token that he wants to deposit,
+     * this is the spender address that will be used to call approve method.
+     *
+     */
+    approveTarget?: Address;
+    /**
+     * If true, user can avoid approval step and deposit with permit
+     */
+    permissible: boolean;
+    /**
+     * Type of deposit
+     */
+    type: "kyc-on-demand" | "kyc-default" | "classic";
+}
 export interface IPoolsService {
     /**
      * Returns list of tokens that can be deposited to a pool

package/dist/types/sdk/router/AbstractRouterContract.d.ts

@@ -3,18 +3,13 @@ import { BaseContract, type BaseContractArgs } from "../base/index.js";
 import type { GearboxSDK } from "../GearboxSDK.js";
 import type { IPriceOracleContract } from "../market/index.js";
 import { AddressMap, AddressSet } from "../utils/index.js";
-import type { IHooks } from "../utils/internal/index.js";
-import { Hooks } from "../utils/internal/index.js";
-import type { Asset, ExpectedAndLeftoverOptions, RouterCASlice, RouterCMSlice, RouterHooks } from "./types.js";
+import type { Asset, ExpectedAndLeftoverOptions, RouterCASlice, RouterCMSlice } from "./types.js";
 export interface Leftovers {
     expectedBalances: AddressMap<Asset>;
     leftoverBalances: AddressMap<Asset>;
     tokensToClaim: AddressMap<Asset>;
 }
-export declare abstract class AbstractRouterContract<abi extends Abi | readonly unknown[]> extends BaseContract<abi> implements IHooks<RouterHooks> {
-    protected readonly hooks: Hooks<RouterHooks>;
-    readonly addHook: <K extends "foundPathOptions">(hookName: K, fn: (...args: RouterHooks[K]) => void | Promise<void>) => void;
-    readonly removeHook: <K extends "foundPathOptions">(hookName: K, fn: (...args: RouterHooks[K]) => void | Promise<void>) => void;
+export declare abstract class AbstractRouterContract<abi extends Abi | readonly unknown[]> extends BaseContract<abi> {
     readonly sdk: GearboxSDK;
     constructor(sdk: GearboxSDK, args: BaseContractArgs<abi>);
     protected getExpectedAndLeftover(ca: RouterCASlice, cm: RouterCMSlice, options?: ExpectedAndLeftoverOptions): Leftovers;