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

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

@@ -3,9 +3,9 @@ import type { creditAccountCompressorAbi } from "../../abi/compressors/creditAcc
 import type { iWithdrawalCompressorV310Abi } from "../../abi/IWithdrawalCompressorV310.js";
 import type { ConnectedBotData, Construct, CreditAccountData } from "../base/index.js";
 import type { GearboxSDK } from "../GearboxSDK.js";
-import type { CreditSuite, OnDemandPriceUpdates, PriceUpdateV300, PriceUpdateV310, UpdatePriceFeedsResult } from "../market/index.js";
+import type { CreditSuite, OnDemandPriceUpdates, 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
      */
@@ -235,29 +239,17 @@ export interface ClaimFarmRewardsProps extends PrepareUpdateQuotasProps {
     */
     tokensToDisable: Array<Asset>;
     /**
-     * Legacy property - array of MultiCall from getRewards
+     * External calls to execute instead of finding claim path
      */
-    calls: Array<MultiCall>;
+    calls: Array<MultiCall> | undefined;
     /**
      * minimal credit account data on which operation is performed
      */
     creditAccount: RouterCASlice;
-    tokensToClaim: Asset[];
-    forceCalls?: boolean;
-}
-export interface EnableTokensProps {
     /**
-     * List of tokens to disable
+     * List of token rewards of which we want to claim
      */
-    disabledTokens: Array<Address>;
-    /**
-     * List of tokens to enable
-     */
-    enabledTokens: Array<Address>;
-    /**
-     * Minimal credit account data on which operation is performed
-     */
-    creditAccount: RouterCASlice;
+    tokensToClaim: Asset[];
 }
 export interface OpenCAProps extends PrepareUpdateQuotasProps {
     /**
@@ -275,8 +267,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 +279,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 +314,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 {
     /**
@@ -329,10 +335,6 @@ export interface FullyLiquidateProps {
      * Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
      */
     slippage?: bigint;
-    /**
-     * TODO: legacy v3 option to remove
-     */
-    force?: boolean;
     /**
      * List of assets to keep on account after liquidation
      */
@@ -434,6 +436,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 +459,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): Promise<Array<CreditAccountData>>;
+    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
+     */
+    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
@@ -473,7 +514,7 @@ export interface ICreditAccountsService extends Construct {
         additionalBots: Array<Omit<NonNullable<GetConnectedMigrationBotsResult>, "botAddress">>;
     }>;
     /**
-     * V3.1 method, throws in V3. Connects/disables a bot and updates prices
+     * Connects/disables a bot and updates prices
      * @param props - {@link SetBotProps}
      * @return All necessary data to execute the transaction (call, credit facade)
      */
@@ -481,9 +522,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 ->
@@ -547,11 +588,12 @@ export interface ICreditAccountsService extends Construct {
     */
     claimDelayed(props: ClaimDelayedProps): Promise<CreditAccountOperationResult>;
     /**
-     * Executes enable/disable tokens specified by given tokens lists and token prices
-     * @param props - {@link EnableTokensProps}
-     * @returns All necessary data to execute the transaction (call, credit facade)
+     * 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
      */
-    enableTokens(props: EnableTokensProps): Promise<CreditAccountOperationResult>;
+    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 ->
@@ -589,13 +631,49 @@ export interface ICreditAccountsService extends Construct {
      * @param options
      * @returns
      */
-    getOnDemandPriceUpdates(options: PriceUpdatesOptions): Promise<OnDemandPriceUpdates<PriceUpdateV310 | PriceUpdateV300>>;
+    getOnDemandPriceUpdates(options: PriceUpdatesOptions): Promise<OnDemandPriceUpdates>;
     /**
      * Returns price updates in format that is accepted by various credit facade methods (multicall, close/liquidate, etc...).
      * @param options
      * @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
@@ -608,8 +686,6 @@ export interface ICreditAccountsService extends Construct {
      * Fully repays credit account or repays credit account and keeps it open with zero debt
      * - Repays in the following order: price update -> add collateral to cover the debt ->
      *   -> disable quotas for all tokens -> decrease debt -> disable tokens all tokens -> withdraw all tokens
-     * - V3.0 claims rewards for tokens which are specified in legacy SDK
-     * - V3.1 claims rewards for all tokens IF router is also V3.1
      * @param props - {@link RepayCreditAccountProps}
      * @return All necessary data to execute the transaction (call, credit facade)
      */
@@ -618,18 +694,14 @@ export interface ICreditAccountsService extends Construct {
      * Fully repays liquidatable account
      * - Repay and liquidate is executed in the following order: price update -> add collateral to cover the debt ->
      *   withdraw all tokens from credit account
-     * - V3.0 claims rewards for tokens which are specified in legacy SDK
-     * - V3.1 claims rewards for all tokens IF router is also V3.1
      * @param props - {@link RepayAndLiquidateCreditAccountProps}
      * @return All necessary data to execute the transaction (call, credit facade)
      */
     repayAndLiquidateCreditAccount(props: RepayAndLiquidateCreditAccountProps): Promise<CreditAccountOperationResult>;
     /**
-     * Executes swap specified by given calls, update quotas of affected tokens
+     * Claims farm rewards and optionally updates quotas
      *  - Claim rewards is executed in the following order: price update -> execute claim calls ->
-     *   -> (optionally: disable reward tokens) -> (optionally: update quotas)
-     * - V3.0 claims rewards for tokens which are specified in legacy SDK
-     * - V3.1 claims rewards for all tokens IF router is also V3.1 and falls back to legacy calls if router is not v3.0
+     *   -> (optionally: update quotas)
      * @param props - {@link ClaimFarmRewardsProps}
      * @return All necessary data to execute the transaction (call, credit facade)
      */

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

@@ -1,8 +1,8 @@
-import type { Abi, Address, Chain, ContractEventName, ContractFunctionName, DecodeFunctionDataReturnType, EncodeFunctionDataParameters, GetContractReturnType, Hex, Log, PublicClient, Transport } from "viem";
-import { BaseError, type ContractEventArgs, type GetContractEventsReturnType } from "viem";
+import type { Abi, Address, Chain, ContractEventArgs, ContractEventName, ContractFunctionName, DecodeFunctionDataReturnType, EncodeFunctionDataParameters, GetContractEventsReturnType, GetContractReturnType, Hex, Log, PublicClient, Transport } from "viem";
+import { BaseError } 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,11 +3,9 @@ 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;
-    static for(client: PublicClient<Transport, Chain>, logger?: ILogger): ChainContractsRegister;
     private readonly contracts;
     private readonly labels;
     readonly client: PublicClient<Transport, Chain>;
@@ -55,4 +53,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,24 @@ 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 = ChainContractsRegister | {
     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);
+    /**
+     * Throws if register was not provided in constructor options
+     * Ephemeral contracts that do not need to access other contracts may not need it
+     */
+    get register(): ChainContractsRegister;
+    protected safeGetRegister(): ChainContractsRegister | undefined;
     get chain(): Chain;
     get chainId(): number;
     get networkType(): NetworkType;
@@ -21,16 +29,8 @@ export declare class Construct {
      */
     get dirty(): boolean;
     protected set dirty(value: boolean);
-    /**
-     * Syntax sugar for rgister.tokensMeta
-     */
     protected get tokensMeta(): TokensMeta;
-    /**
-     * Syntax suggar for getting contract labels
-     * @param address
-     * @returns
-     */
-    protected labelAddress(address: Address): string;
+    protected labelAddress(address: Address, omitAddress?: boolean): string;
     /**
      * Returns list of addresses that should be watched for events to sync state
      */

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,54 @@
 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
      */

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
@@ -71,6 +97,11 @@ export interface IBaseContract {
      * Indicates that contract state diverged from onchain state and needs to be updated
      */
     dirty: boolean;
+    /**
+     * Human-readable contract state
+     * @param raw
+     */
+    stateHuman(raw?: boolean): unknown;
     /**
      * Return parsed args and function name from calldata belonging to this contract
      * Target of the call is always this contract, but args can be parsed into calls to other contracts (de-facto recursive ParsedCall)
@@ -89,4 +120,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/constants/addresses.d.ts

@@ -1,5 +1,4 @@
 import type { Address } from "viem";
-import type { NetworkType } from "../chain/index.js";
 export declare const MULTICALL_ADDRESS: Address;
 /**
  * Address 0x0000000000000000000000000000000000000000
@@ -9,21 +8,3 @@ export declare const ADDRESS_0X0: Address;
  * Dummy address to satisfy `0x${string}` typecheck, but fail on `isAddress` check
  */
 export declare const NOT_DEPLOYED = "0xNOT DEPLOYED";
-/**
- * Well-known USDC token address used to determine NetworkType on testnets with different chain ids
- *
- * @deprecated TODO: delete me
- */
-/**
- * @deprecated TODO: delete me
- */
-/**
- * @deprecated TODO: delete me
- */
-export declare const TIMELOCK: Record<NetworkType, Address>;
-export declare const GEARBOX_MULTISIG: Record<NetworkType, Address>;
-export declare const GEARBOX_RISK_CURATORS: Record<NetworkType, Address[]>;
-/**
- * Depreciated pools
- */
-export declare const DEPRECIATED_POOLS: Record<NetworkType, Record<Address, string>>;

package/dist/types/sdk/constants/networks.d.ts

@@ -1,8 +1,3 @@
 import { type NetworkType } from "../chain/index.js";
-/**
- * Block number when address provider was deployed
- * @deprecated use chain.firstBlock instead
- */
-export declare const ADDRESS_PROVIDER_BLOCK: Record<NetworkType, bigint>;
 export declare const RAMP_DURATION_BY_NETWORK: Record<NetworkType, bigint>;
 export declare const BLOCKS_PER_WEEK_BY_NETWORK: Record<NetworkType, bigint>;

package/dist/types/sdk/constants/versions.d.ts

@@ -2,8 +2,6 @@
  * Version range, inclusive of both ends
  */
 export type VersionRange = [number, number];
-export declare const VERSION_RANGE_300: VersionRange;
 export declare const VERSION_RANGE_310: VersionRange;
-export declare function isV300(version: number | bigint | string): boolean;
 export declare function isV310(version: number | bigint | string): boolean;
 export declare function isVersionRange(version: number | bigint | string, range: VersionRange): boolean;

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

@@ -1,8 +1,8 @@
 import { type Abi, type Address } from "viem";
-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 { 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 { AddressProviderAddresses, AddressProviderState } from "./types.js";
 export default abstract class AbstractAddressProviderContract<abi extends Abi | readonly unknown[]> extends BaseContract<abi> {
     #private;