@gearbox-protocol/sdk 13.0.0-next.3 → 13.0.0-next.31

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

@@ -5,7 +5,7 @@ import type { ConnectedBotData, Construct, CreditAccountData } from "../base/ind
 import type { GearboxSDK } from "../GearboxSDK.js";
 import type { CreditSuite, OnDemandPriceUpdates, PriceUpdateV300, PriceUpdateV310, UpdatePriceFeedsResult } from "../market/index.js";
 import type { Asset, CreditAccountTokensSlice, RouterCASlice, RouterCloseResult } from "../router/index.js";
-import type { MultiCall, RawTx } from "../types/index.js";
+import type { IPriceUpdateTx, MultiCall, RawTx } from "../types/index.js";
 export type GetCreditAccountsArgs = ContractFunctionArgs<typeof creditAccountCompressorAbi, "pure" | "view", "getCreditAccounts">;
 export interface CreditAccountFilter {
     owner: Address;
@@ -83,6 +83,10 @@ export interface CloseCreditAccountProps {
     closePath?: RouterCloseResult;
 }
 export interface RepayCreditAccountProps extends RepayAndLiquidateCreditAccountProps {
+    /**
+     * Swap calls for repay
+     */
+    calls?: Array<MultiCall>;
     /**
      * close or zeroDebt
      */
@@ -275,8 +279,9 @@ export interface OpenCAProps extends PrepareUpdateQuotasProps {
     /**
      * Flag to withdraw debt to wallet after opening credit account;
      * used for borrowing functionality
+     * If true, will withdraw underlying token, otherwise will withdraw specified token
      */
-    withdrawDebt?: boolean;
+    withdrawToken?: boolean | Address;
     /**
      * Permits of collateral tokens (in any permittable token is present) {@link PermitResult}
      */
@@ -286,10 +291,19 @@ export interface OpenCAProps extends PrepareUpdateQuotasProps {
      * Used for trading and strategy functionality
      */
     calls: Array<MultiCall>;
+    /**
+     * Slot for optional call to execute after main tx.
+     * For example: add bots
+     */
+    callsAfter?: Array<MultiCall>;
     /**
      * Address of credit manager to open credit account on
      */
     creditManager: Address;
+    /**
+     * Optional address of credit account to reopen
+     */
+    reopenCreditAccount?: Address;
     /**
      * Wallet address to transfer credit account to
      */
@@ -312,9 +326,13 @@ export interface ChangeDeptProps {
      */
     amount: bigint;
     /**
-     * If true, will add collateral to the credit account
+     * Assets to add as collateral
      */
-    addCollateral: boolean;
+    collateral?: [Asset];
+    /**
+     * Assets to wrap
+     */
+    wrapAsset?: [Asset];
 }
 export interface FullyLiquidateProps {
     /**
@@ -434,6 +452,19 @@ export interface LlamathenaProportionalWithdrawProps extends PrepareUpdateQuotas
      */
     creditAccount: RouterCASlice;
 }
+/**
+ * Options to get approval address for collateral token
+ */
+export type GetApprovalAddressProps = {
+    creditManager: Address;
+    borrower: Address;
+} | {
+    creditManager: Address;
+    creditAccount: Address;
+};
+export type CreditAccountDataWithInvestor = CreditAccountData & {
+    investor: Address;
+};
 export interface ICreditAccountsService extends Construct {
     sdk: GearboxSDK;
     /**
@@ -444,15 +475,41 @@ export interface ICreditAccountsService extends Construct {
      * @returns
      */
     getCreditAccountData(account: Address, blockNumber?: bigint): Promise<CreditAccountData | undefined>;
+    /**
+     * Returns credit account data for a single account with the investor address resolved (from KYC factory when applicable).
+     * @param account - Credit account address
+     * @param blockNumber - Optional block number for the read
+     * @returns CreditAccountDataWithInvestor, or undefined if the account is not found
+     */
+    getCreditAccountDataWithInvestor(account: Address, blockNumber?: bigint): Promise<CreditAccountDataWithInvestor | undefined>;
     /**
      * Methods to get all credit accounts with some optional filtering
      * Performs all necessary price feed updates under the hood
      *
      * @param options
      * @param blockNumber
-     * @returns returned credit accounts are sorted by health factor in ascending order
+     * @param priceUpdate - Optional pre-computed price feed update (e.g. from generatePriceFeedsUpdateTxs)
+     * @returns Credit accounts sorted by health factor ascending
+     */
+    getCreditAccounts(options?: GetCreditAccountsOptions, blockNumber?: bigint, priceUpdate?: UpdatePriceFeedsResult): Promise<Array<CreditAccountData>>;
+    /**
+     * Returns all credit accounts matching the filter with investor set on each; when options.owner is set, includes KYC CAs for that owner.
+     * @param options - Filter options (owner, creditManager, health factor, etc.)
+     * @param blockNumber - Optional block number for the read
+     * @returns Credit accounts (with investor) sorted by health factor ascending
+     */
+    getCreditAccountsWithInvestor(options?: GetCreditAccountsOptions, blockNumber?: bigint): Promise<Array<CreditAccountDataWithInvestor>>;
+    /**
+     * Loads credit account data for the given addresses using simulateWithPriceUpdates (with price updates applied before the read).
+     * @param accounts - Credit account addresses to load
+     * @param priceUpdateTxs - Price feed update txs to simulate before the read (e.g. from generatePriceFeedsUpdateTxs)
+     * @param blockNumber - Optional block number for the read
+     * @returns Array of CreditAccountData in the same order as accounts
      */
-    getCreditAccounts(options?: GetCreditAccountsOptions, blockNumber?: bigint): Promise<Array<CreditAccountData>>;
+    loadSpecifiedAccounts(accounts: Address[], priceUpdateTxs: IPriceUpdateTx<{
+        priceFeed: `0x${string}`;
+        timestamp: number;
+    }>[], blockNumber?: bigint): Promise<Array<CreditAccountData>>;
     /**
      * Method to get all claimable rewards for credit account (ex. stkUSDS SKY rewards)
      * Assosiates rewards by adapter + stakedPhantomToken
@@ -481,9 +538,9 @@ export interface ICreditAccountsService extends Construct {
     /**
      * Generates transaction to liquidate credit account
      * @param props - {@link FullyLiquidateProps}
-     * @returns
+     * @returns Transaction data and optional loss policy data
      */
-    fullyLiquidate(props: FullyLiquidateProps): Promise<CloseCreditAccountResult>;
+    fullyLiquidate(props: FullyLiquidateProps): Promise<FullyLiquidateResult>;
     /**
      * Closes credit account or closes credit account and keeps it open with zero debt.
      * - Ca is closed in the following order: price update -> close path to swap all tokens into underlying ->
@@ -552,6 +609,13 @@ export interface ICreditAccountsService extends Construct {
      * @returns All necessary data to execute the transaction (call, credit facade)
      */
     enableTokens(props: EnableTokensProps): Promise<CreditAccountOperationResult>;
+    /**
+     * Returns address to which approval should be given on collateral token
+     * It's credit manager for classical markets and special wallet for KYC markets
+     * @param props - {@link GetApprovalAddressProps}
+     * @returns
+     */
+    getApprovalAddress(props: GetApprovalAddressProps): Promise<Address>;
     /**
      * Executes swap specified by given calls, update quotas of affected tokens
      * - Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
@@ -596,6 +660,42 @@ export interface ICreditAccountsService extends Construct {
      * @returns
      */
     getPriceUpdatesForFacade(options: PriceUpdatesOptions): Promise<Array<MultiCall>>;
+    /**
+     * Returns multicall entries to redeem (unwrap) KYC ERC-4626 vault shares into underlying for the given credit manager.
+     * Used when withdrawing debt from a KYC market: redeems adapter vault shares so the underlying can be withdrawn.
+     * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+     * @param amount - Number of vault shares (adapter tokens) to redeem
+     * @param creditManager - Credit manager address
+     * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+     */
+    getKYCUnwrapCalls(amount: bigint, creditManager: Address): Promise<Array<MultiCall> | undefined>;
+    /**
+     * Returns multicall entries to deposit (wrap) underlying into KYC ERC-4626 vault shares for the given credit manager.
+     * Used when adding debt on a KYC market: deposits underlying into the adapter vault so shares are minted on the account.
+     * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+     * @param amount - Amount of underlying assets to deposit into the vault (in underlying decimals)
+     * @param creditManager - Credit manager address
+     * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+     */
+    getKYCWrapCalls(amount: bigint, creditManager: Address): Promise<Array<MultiCall> | undefined>;
+    /**
+     * Returns multicall entries to call redeemDiff on the KYC ERC-4626 adapter for the given credit manager.
+     * Redeems the leftover vault shares (e.g. after repaying debt) so the account does not hold excess KYC vault tokens.
+     * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+     * @param amount - Leftover vault share amount to redeem (in adapter/vault decimals)
+     * @param creditManager - Credit manager address
+     * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+     */
+    getRedeemDiffCalls(amount: bigint, creditManager: Address): Promise<Array<MultiCall> | undefined>;
+    /**
+     * Returns multicall entries to call depositDiff on the KYC ERC-4626 adapter for the given credit manager.
+     * Deposits the leftover underlying (e.g. after decreasing debt) into the vault so the account does not hold excess underlying.
+     * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+     * @param amount - Leftover underlying amount to deposit into the vault (in underlying decimals)
+     * @param creditManager - Credit manager address
+     * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+     */
+    getDepositDiffCalls(amount: bigint, creditManager: Address): Promise<Array<MultiCall> | undefined>;
     /**
      * Withdraws a single collateral from credit account to wallet to and updates quotas;
      * technically can withdraw several tokens at once

package/dist/types/sdk/base/BaseContract.d.ts

@@ -2,7 +2,7 @@ import type { Abi, Address, Chain, ContractEventName, ContractFunctionName, Deco
 import { BaseError, type ContractEventArgs, type GetContractEventsReturnType } from "viem";
 import type { BaseContractStateHuman, RawTx } from "../types/index.js";
 import { Construct, type ConstructOptions } from "./Construct.js";
-import type { IBaseContract, ParsedCall, ParsedCallArgs } from "./types.js";
+import type { IBaseContract, ParsedCall, ParsedCallArgs, ParsedCallV2 } from "./types.js";
 export interface BaseContractArgs<abi extends Abi | readonly unknown[]> {
     abi: abi;
     addr: Address;
@@ -28,7 +28,7 @@ export declare class BaseContract<abi extends Abi | readonly unknown[]> extends
     readonly version: number;
     readonly address: Address;
     readonly name: string;
-    constructor({ client, logger }: ConstructOptions, args: BaseContractArgs<abi>);
+    constructor(options: ConstructOptions, args: BaseContractArgs<abi>);
     stateHuman(_?: boolean): BaseContractStateHuman;
     /**
      * Updates (or not) contract's internal state from event
@@ -78,6 +78,19 @@ export declare class BaseContract<abi extends Abi | readonly unknown[]> extends
      */
     protected stringifyFunctionParams(decoded: DecodeFunctionDataReturnType<abi>): string[];
     protected wrapParseCall(functionName: string, args: Record<string, string>): ParsedCall;
+    /**
+     * Parses calldata into structured result with preserved original types.
+     * When strict is true, throws {@link ContractParseError} on unknown selectors;
+     * otherwise returns a fallback with the raw calldata.
+     */
+    parseFunctionDataV2(calldata: Hex, strict?: boolean): ParsedCallV2;
+    /**
+     * Converts viem-decoded function arguments to a record preserving original types.
+     * Override in subclasses to handle nesting (e.g., multicall inner calls).
+     * @param strict - propagated from parseFunctionDataV2 for recursive parsing
+     */
+    protected parseFunctionParamsV2(params: DecodeFunctionDataReturnType<abi>, _strict?: boolean): Record<string, unknown>;
+    protected wrapParseCallV2(functionName: string, rawArgs: Record<string, unknown>): ParsedCallV2;
     /**
      * Creates a raw transaction for a function in this contract
      * @param parameters

package/dist/types/sdk/base/ChainContractsRegister.d.ts

@@ -3,7 +3,7 @@ import type { MultiCall } from "../types/index.js";
 import type { ILogger } from "../types/logger.js";
 import type { BaseContract } from "./BaseContract.js";
 import { TokensMeta } from "./TokensMeta.js";
-import type { ParsedCall } from "./types.js";
+import type { ParsedCall, ParsedCallV2 } from "./types.js";
 export type ContractOrInterface<T> = T extends Abi | readonly unknown[] ? BaseContract<T> : T;
 export declare class ChainContractsRegister {
     #private;
@@ -55,4 +55,14 @@ export declare class ChainContractsRegister {
      * @returns
      */
     parseMultiCall(calls: MultiCall[]): ParsedCall[];
+    /**
+     * Parses calldata for a contract at the given address, preserving original types.
+     * When strict is true, throws on unknown address or selector; otherwise returns a fallback.
+     */
+    parseFunctionDataV2(address: Address, calldata: Hex, strict?: boolean): ParsedCallV2;
+    /**
+     * Parses multicalls preserving original types.
+     * When strict is true, throws on unknown targets or selectors.
+     */
+    parseMultiCallV2(calls: MultiCall[], strict?: boolean): ParsedCallV2[];
 }

package/dist/types/sdk/base/Construct.d.ts

@@ -3,16 +3,19 @@ import type { NetworkType } from "../chain/index.js";
 import type { ILogger } from "../types/index.js";
 import { ChainContractsRegister } from "./ChainContractsRegister.js";
 import type { TokensMeta } from "./TokensMeta.js";
-export interface ConstructOptions {
+export type ConstructOptions = {
     client: PublicClient<Transport, Chain>;
     logger?: ILogger;
-}
+} | {
+    register: ChainContractsRegister;
+    logger?: ILogger;
+};
 export declare class Construct {
     #private;
     readonly logger?: ILogger;
     readonly client: PublicClient<Transport, Chain>;
     readonly register: ChainContractsRegister;
-    constructor({ client, logger }: ConstructOptions);
+    constructor(options: ConstructOptions);
     get chain(): Chain;
     get chainId(): number;
     get networkType(): NetworkType;

package/dist/types/sdk/base/PlaceholderContract.d.ts

@@ -1,9 +1,9 @@
-import type { GearboxSDK } from "../GearboxSDK.js";
 import type { BaseContractArgs } from "./BaseContract.js";
 import { BaseContract } from "./BaseContract.js";
+import type { ConstructOptions } from "./index.js";
 declare const abi: unknown[];
 type abi = typeof abi;
 export declare class PlaceholderContract extends BaseContract<abi> {
-    constructor(sdk: GearboxSDK, args: Omit<BaseContractArgs<abi>, "abi">);
+    constructor(options: ConstructOptions, args: Omit<BaseContractArgs<abi>, "abi">);
 }
 export {};

package/dist/types/sdk/base/TokensMeta.d.ts

@@ -1,31 +1,56 @@
 import { type Address, type Chain, type PublicClient, type Transport } from "viem";
 import type { Asset } from "../router/index.js";
+import type { ILogger } from "../types/logger.js";
 import { AddressMap } from "../utils/index.js";
-import type { KYCTokenMeta, PhantomTokenMeta, TokenMetaData } from "./token-types.js";
+import { type DSTokenMeta, type KYCTokenMeta, type PhantomTokenMeta, type TokenMetaData } from "./token-types.js";
 export interface FormatBNOptions {
     precision?: number;
     symbol?: boolean;
 }
 export declare class TokensMeta extends AddressMap<TokenMetaData> {
     #private;
-    constructor(client: PublicClient<Transport, Chain>);
+    constructor(client: PublicClient<Transport, Chain>, logger?: ILogger);
     reset(): void;
+    upsert(address: string, value: TokenMetaData | undefined): void;
     symbol(token: Address): string;
     decimals(token: Address): number;
+    /**
+     * Returns true if the token is a phantom token, throws if the token data is not loaded
+     * @param t
+     * @returns
+     */
     isPhantomToken(t: TokenMetaData): t is PhantomTokenMeta;
+    /**
+     * Returns true if the token is a KYC underlying token, throws if the token data is not loaded
+     * @param t
+     * @returns
+     */
     isKYCUnderlying(t: TokenMetaData): t is KYCTokenMeta;
+    /**
+     * Returns true if the token is a DSToken, throws if the token data is not loaded
+     * @param t
+     * @returns
+     */
+    isDSToken(t: TokenMetaData): t is DSTokenMeta;
     /**
      * Returns a map of all phantom tokens
-     * Throws if the phantom token data is not loaded
+     * Throws if token data is not loaded
      */
     get phantomTokens(): AddressMap<PhantomTokenMeta>;
+    /**
+     * Returns a map of all KYC underlying tokens
+     * Throws if token data is not loaded
+     */
     get kycUnderlyings(): AddressMap<KYCTokenMeta>;
+    get dsTokens(): AddressMap<DSTokenMeta>;
     formatBN(asset: Asset, options?: FormatBNOptions): string;
     formatBN(token: Address, amount: number | bigint | string | undefined, options?: FormatBNOptions): string;
     findBySymbol(symbol: string): TokenMetaData | undefined;
     mustFindBySymbol(symbol: string): TokenMetaData;
     /**
-     * Loads token information about phantom token and KYC underlying tokens
+     * Loads token information about phantom tokens, KYC underlying tokens and DSTokens
+     *
+     * @param tokens - tokens to load data for, defaults to all tokens
      */
-    loadTokenData(): Promise<void>;
+    loadTokenData(...tokens: Address[]): Promise<void>;
 }

package/dist/types/sdk/base/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class MissingSerializedParamsError extends Error {
+    constructor(propertyName: string);
+}

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

@@ -1,6 +1,7 @@
 export * from "./BaseContract.js";
 export * from "./ChainContractsRegister.js";
 export * from "./Construct.js";
+export * from "./errors.js";
 export * from "./PlaceholderContract.js";
 export * from "./SDKConstruct.js";
 export * from "./TokensMeta.js";

package/dist/types/sdk/base/token-types.d.ts

@@ -1,11 +1,15 @@
 import type { Address } from "viem";
 import type { MarketData, Unarray } from "./types.js";
-export type SimpleTokenMeta = Unarray<MarketData["tokens"]>;
+type TokenData = Unarray<MarketData["tokens"]>;
 export declare const PHANTOM_TOKEN_CONTRACT_TYPES: readonly ["PHANTOM_TOKEN::CONVEX", "PHANTOM_TOKEN::INFINIFI_UNWIND", "PHANTOM_TOKEN::INFRARED", "PHANTOM_TOKEN::MELLOW_WITHDRAWAL", "PHANTOM_TOKEN::MIDAS_REDEMPTION", "PHANTOM_TOKEN::STAKING_REWARDS", "PHANTOM_TOKEN::UPSHIFT_WITHDRAW"];
 export declare const KYC_UNDERLYING_DEFAULT = "KYC_UNDERLYING::DEFAULT";
 export declare const KYC_UNDERLYING_ON_DEMAND = "KYC_UNDERLYING::ON_DEMAND";
 export type KYCUnderlyingContractType = typeof KYC_UNDERLYING_DEFAULT | typeof KYC_UNDERLYING_ON_DEMAND;
 export type PhantomTokenContractType = (typeof PHANTOM_TOKEN_CONTRACT_TYPES)[number];
+export type SimpleTokenMeta = TokenData & {
+    isDSToken?: boolean;
+    contractType?: string;
+};
 export type PhantomTokenMeta = SimpleTokenMeta & {
     contractType: PhantomTokenContractType;
 };
@@ -21,5 +25,9 @@ export type KYCOnDemandTokenMeta = SimpleTokenMeta & {
     pool: Address;
     liquidityProvider: Address;
 };
+export type DSTokenMeta = Omit<SimpleTokenMeta, "isDSToken"> & {
+    isDSToken: true;
+};
 export type KYCTokenMeta = KYCDefaultTokenMeta | KYCOnDemandTokenMeta;
-export type TokenMetaData = SimpleTokenMeta | PhantomTokenMeta | KYCTokenMeta;
+export type TokenMetaData = SimpleTokenMeta | PhantomTokenMeta | KYCTokenMeta | DSTokenMeta;
+export {};

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

@@ -12,6 +12,15 @@ export interface BaseParams {
     contractType: Hex;
     serializedParams: Hex;
 }
+export interface RelaxedBaseParams {
+    addr: Address;
+    version: number | bigint;
+    /**
+     * Hex or parsed hex32 string
+     */
+    contractType: string;
+    serializedParams?: Hex;
+}
 export interface BaseState {
     baseParams: BaseParams;
 }
@@ -49,6 +58,23 @@ export interface ParsedCall {
     functionName: string;
     args: ParsedCallArgs;
 }
+export interface ParsedCallV2 {
+    chainId: number;
+    target: Address;
+    contractType: string;
+    label?: string;
+    version: number;
+    /**
+     * Function signature produced by viem's `toFunctionSignature`, e.g.:
+     * - `"balanceOf(address)"`
+     * - `"multicall(address,(address,bytes)[])"`
+     * - `"swap(uint256,uint256,bool)"`
+     *
+     * For unknown selectors: `"unknown function 0x1a2b3c4d"`
+     */
+    functionName: string;
+    rawArgs: Record<string, unknown>;
+}
 export interface IBaseContract {
     /**
      * Contract address
@@ -89,4 +115,9 @@ export interface IBaseContract {
      * Same as {@link stringifyFunctionData}, but throws if error occurs
      **/
     mustStringifyFunctionData: (calldata: Hex) => string;
+    /**
+     * Parses calldata into structured result with preserved original types.
+     * When strict is true, throws on unknown selectors; otherwise returns a fallback.
+     **/
+    parseFunctionDataV2: (calldata: Hex, strict?: boolean) => ParsedCallV2;
 }

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

@@ -1,6 +1,6 @@
 import type { Address, Chain } from "viem";
 import { z } from "zod/v4";
-export type Curator = "Chaos Labs" | "K3" | "cp0x" | "Re7" | "Invariant Group" | "Tulipa" | "M11 Credit" | "kpk" | "Hyperithm" | "Edge UltraYield" | "TelosC" | "Gami Labs";
+export type Curator = "Chaos Labs" | "K3" | "cp0x" | "Re7" | "Invariant Group" | "Tulipa" | "M11 Credit" | "kpk" | "Hyperithm" | "Edge UltraYield" | "TelosC" | "Gami Labs" | "Securitize";
 export interface GearboxChain extends Chain {
     network: NetworkType;
     defaultMarketConfigurators: Record<Address, Curator>;

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

@@ -1,6 +1,5 @@
 import type { Address } from "viem";
 import type { MarketData, MarketFilter } from "../base/index.js";
-import { SDKConstruct } from "../base/index.js";
 import type { GearboxSDK } from "../GearboxSDK.js";
 import type { MarketStateHuman } from "../types/index.js";
 import { AddressMap } from "../utils/index.js";
@@ -9,7 +8,8 @@ import { MarketConfiguratorContract } from "./MarketConfiguratorContract.js";
 import { MarketSuite } from "./MarketSuite.js";
 import type { IPriceOracleContract } from "./oracle/index.js";
 import type { PoolSuite } from "./pool/index.js";
-export declare class MarketRegister extends SDKConstruct {
+import { ZapperRegister } from "./ZapperRegister.js";
+export declare class MarketRegister extends ZapperRegister {
     #private;
     constructor(sdk: GearboxSDK, ignoreMarkets?: Address[]);
     hydrate(state: MarketData[]): void;

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

@@ -8,6 +8,7 @@ import { type ILossPolicyContract } from "./loss-policy/index.js";
 import { MarketConfiguratorContract } from "./MarketConfiguratorContract.js";
 import type { IPriceOracleContract } from "./oracle/index.js";
 import { PoolSuite } from "./pool/index.js";
+import type { SecuritizeKYCFactory } from "./pool/SecuritizeKYCFactory.js";
 export declare class MarketSuite extends SDKConstruct {
     readonly acl: Address;
     readonly treasury: Address;
@@ -22,6 +23,7 @@ export declare class MarketSuite extends SDKConstruct {
     readonly state: MarketData;
     constructor(sdk: GearboxSDK, marketData: MarketData);
     get underlying(): Address;
+    getKYCFactory(): Promise<SecuritizeKYCFactory | undefined>;
     get dirty(): boolean;
     get watchAddresses(): Set<Address>;
     stateHuman(raw?: boolean): MarketStateHuman;

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

@@ -0,0 +1,17 @@
+import type { Address } from "viem";
+import { SDKConstruct } from "../base/index.js";
+import { AddressMap } from "../utils/index.js";
+import type { ZapperData } from "./types.js";
+export declare class ZapperRegister extends SDKConstruct {
+    #private;
+    /**
+     * Load zappers for all pools using periphery compressor, adds hardcoded zappers
+     */
+    loadZappers(force?: boolean): Promise<void>;
+    get zappers(): AddressMap<ZapperData[]>;
+    poolZappers(pool: Address): ZapperData[];
+    /**
+     * Can return multiple zappers if there are multiple zappers for the same tokenIn and tokenOut
+     */
+    getZapper(pool: Address, tokenIn: Address, tokenOut: Address): Array<ZapperData> | undefined;
+}

package/dist/types/sdk/market/adapters/PlaceholderAdapterContracts.d.ts

@@ -1,9 +1,14 @@
 import type { Address } from "viem";
-import type { AdapterData } from "../../base/index.js";
+import type { ConstructOptions } from "../../base/index.js";
 import { PlaceholderContract } from "../../base/index.js";
-import type { GearboxSDK } from "../../GearboxSDK.js";
+import type { RelaxedBaseParams } from "../../index.js";
 import type { IAdapterContract } from "./types.js";
+export interface PlaceholderAdapterContractOptions {
+    baseParams: RelaxedBaseParams;
+    targetContract?: Address;
+}
 export declare class PlaceholderAdapterContract extends PlaceholderContract implements IAdapterContract {
-    readonly targetContract: Address;
-    constructor(sdk: GearboxSDK, args: AdapterData);
+    #private;
+    constructor(options: ConstructOptions, args: PlaceholderAdapterContractOptions);
+    get targetContract(): Address;
 }

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

@@ -1,3 +1,3 @@
-export * from "./factory.js";
+export * from "./createAdapter.js";
 export * from "./PlaceholderAdapterContracts.js";
 export * from "./types.js";