@gearbox-protocol/sdk 11.9.0 → 11.11.0-next.1

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

@@ -1,58 +1,102 @@
-import type { Abi, Address, Client, ContractEventName, ContractFunctionName, DecodeFunctionDataReturnType, EncodeFunctionDataParameters, GetContractReturnType, Hex, Log } from "viem";
-import type { GearboxSDK } from "../GearboxSDK.js";
-import type { BaseContractStateHuman, ILogger, RawTx } from "../types/index.js";
-import { SDKConstruct } from "./SDKConstruct.js";
-export interface BaseContractOptions<abi extends Abi | readonly unknown[]> {
+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 { BaseContractStateHuman, RawTx } from "../types/index.js";
+import { Construct, type ConstructOptions } from "./Construct.js";
+import type { IBaseContract, ParsedCall, ParsedCallArgs } from "./types.js";
+export interface BaseContractArgs<abi extends Abi | readonly unknown[]> {
     abi: abi;
     addr: Address;
     name?: string;
     version?: number | bigint;
     contractType?: string;
 }
-export interface IBaseContract {
+export interface ContractParseErrorOptions {
     address: Address;
-    contractType: string;
-    version: number;
-    name: string;
-    dirty: boolean;
+    callData: Hex;
+    contractName?: string;
 }
-export declare abstract class BaseContract<abi extends Abi | readonly unknown[]> extends SDKConstruct implements IBaseContract {
-    #private;
-    readonly contract: GetContractReturnType<abi, {
-        public: Client;
-    }, Address>;
+export declare class ContractParseError extends BaseError {
+    readonly address: Address;
+    readonly callData: Hex;
+    readonly selector: Hex;
+    constructor(cause: Error, options: ContractParseErrorOptions);
+}
+export declare class BaseContract<abi extends Abi | readonly unknown[]> extends Construct implements IBaseContract {
+    readonly contract: GetContractReturnType<abi, PublicClient<Transport, Chain>, Address>;
     readonly abi: abi;
-    readonly logger?: ILogger;
     readonly contractType: string;
-    version: number;
-    constructor(sdk: GearboxSDK, args: BaseContractOptions<abi>);
-    get address(): Address;
-    set address(address: Address);
-    get name(): string;
-    set name(name: string);
+    readonly version: number;
+    readonly address: Address;
+    readonly name: string;
+    constructor({ client, logger }: ConstructOptions, args: BaseContractArgs<abi>);
     stateHuman(_?: boolean): BaseContractStateHuman;
     /**
      * Updates (or not) contract's internal state from event
      * @param _log
      */
     processLog(_log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
+    /**
+     * 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)
+     * @param calldata
+     * @returns
+     */
+    parseFunctionData(calldata: Hex): ParsedCall;
+    /**
+     * Same as {@link parseFunctionData}, but throws {@link ContractParseError} if error occurs
+     * @param callData
+     * @returns
+     */
+    mustParseFunctionData(callData: Hex): ParsedCall;
+    /**
+     * Parses viem-decoded contract function arguments to a map of named arguments
+     * This default implementation uses abi-based parsing, you can override it,
+     * but use this super implementation as fallback
+     * @param params
+     * @returns
+     */
+    protected parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): ParsedCallArgs;
     /**
      * Converts contract calldata to some human-friendly string
      * This is safe function which should not throw
      * @param calldata
      * @returns
      */
-    parseFunctionData(calldata: Hex): string;
-    mustParseFunctionData(calldata: Hex): string;
+    stringifyFunctionData(calldata: Hex): string;
     /**
-     * Return args and function name from calldata
+     * Same as {@link stingifyFunctionData}, but throws if error occurs
      * @param calldata
      * @returns
      */
-    parseFunctionDataToObject(calldata: Hex): DecodeFunctionDataReturnType<abi, ContractFunctionName<abi, import("viem").AbiStateMutability>>;
-    protected parseFunctionParams(_params: DecodeFunctionDataReturnType<abi>): Array<string> | undefined;
-    getVersion(): Promise<number>;
+    mustStringifyFunctionData(calldata: Hex): string;
+    /**
+     * Pretty-prints values of function arguments (do not include parameter names)
+     * Can be overriden in classes, but use this super implementation as fallback
+     *
+     * @param decoded - Function arguments decoded by viem
+     * @returns
+     */
+    protected stringifyFunctionParams(decoded: DecodeFunctionDataReturnType<abi>): string[];
+    protected wrapParseCall(functionName: string, args: Record<string, string>): ParsedCall;
+    /**
+     * Creates a raw transaction for a function in this contract
+     * @param parameters
+     * @returns
+     */
     createRawTx<functionName extends ContractFunctionName<abi> | undefined = undefined>(parameters: Omit<EncodeFunctionDataParameters<abi, functionName>, "abi"> & {
         description?: string;
     }): RawTx;
+    /**
+     * Get events in safe manner, by bisecting block range if needed
+     *
+     * @deprecated TODO: this should be moved to viem transport
+     *
+     * @param eventName
+     * @param fromBlock
+     * @param toBlock
+     * @param args
+     * @param chunkSize
+     * @returns
+     */
+    getEvents<EventName extends ContractEventName<abi>>(eventName: EventName, fromBlock: bigint, toBlock: bigint, args?: ContractEventArgs<abi, EventName extends ContractEventName<abi> ? EventName : ContractEventName<abi>> | undefined, chunkSize?: number): Promise<GetContractEventsReturnType<abi, EventName, undefined, bigint, bigint>>;
 }

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

@@ -0,0 +1,57 @@
+import type { Abi, Address, Chain, Hex, PublicClient, Transport } from "viem";
+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";
+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>;
+    /**
+     * Token metadata such as symbol and decimals
+     */
+    readonly tokensMeta: TokensMeta;
+    readonly logger?: ILogger;
+    constructor(client: PublicClient<Transport, Chain>, logger?: ILogger);
+    getContract<T = unknown[]>(address: Address): ContractOrInterface<T> | undefined;
+    mustGetContract<T = unknown[]>(address: Address): ContractOrInterface<T>;
+    setContract(address: Address, contract: BaseContract<any>): void;
+    setAddressLabel(address: Address, label: string | ((oldLabel?: string) => string)): void;
+    labelAddress(address: Address): string;
+    get chain(): Chain;
+    get chainId(): number;
+    /**
+     * Converts contract call into some human-friendly string
+     * This method is safe and should not throw
+     * @param address
+     * @param calldata
+     * @returns
+     */
+    stringifyFunctionData(address: Address, calldata: Hex): string;
+    /**
+     * Converts multicalls into some human-friendly strings
+     * This method is safe and should not throw
+     * @param address
+     * @param calldata
+     * @returns
+     */
+    stringifyMultiCall(calls: MultiCall[]): string[];
+    /**
+     * Return args, function, type and address name from contract call
+     * @param address
+     * @param calldata
+     * @returns
+     */
+    parseFunctionData(address: Address, calldata: Hex): ParsedCall;
+    /**
+     * Converts multicalls into call info
+     * @param address
+     * @param calldata
+     * @returns
+     */
+    parseMultiCall(calls: MultiCall[]): ParsedCall[];
+}

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

@@ -0,0 +1,38 @@
+import type { Address, Chain, PublicClient, Transport } from "viem";
+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 {
+    client: PublicClient<Transport, Chain>;
+    logger?: ILogger;
+}
+export declare class Construct {
+    #private;
+    readonly logger?: ILogger;
+    readonly client: PublicClient<Transport, Chain>;
+    readonly register: ChainContractsRegister;
+    constructor({ client, logger }: ConstructOptions);
+    get chain(): Chain;
+    get chainId(): number;
+    get networkType(): NetworkType;
+    /**
+     * Indicates that contract state diverged from onchain state and needs to be updated
+     */
+    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;
+    /**
+     * Returns list of addresses that should be watched for events to sync state
+     */
+    get watchAddresses(): Set<Address>;
+}

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

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

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

@@ -1,21 +1,7 @@
-import type { Address, PublicClient } from "viem";
-import type { NetworkType } from "../chain/index.js";
 import type { GearboxSDK } from "../GearboxSDK.js";
 import type { PluginsMap } from "../plugins/index.js";
-export declare class SDKConstruct<const Plugins extends PluginsMap = {}> {
-    #private;
+import { Construct } from "./Construct.js";
+export declare class SDKConstruct<const Plugins extends PluginsMap = {}> extends Construct {
     readonly sdk: GearboxSDK<Plugins>;
     constructor(sdk: GearboxSDK<Plugins>);
-    get networkType(): NetworkType;
-    get client(): PublicClient;
-    /**
-     * Indicates that contract state needs to be updated
-     */
-    get dirty(): boolean;
-    protected set dirty(value: boolean);
-    protected labelAddress(address: Address): string;
-    /**
-     * Returns list of addresses that should be watched for events to sync state
-     */
-    get watchAddresses(): Set<Address>;
 }

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

@@ -1,5 +1,4 @@
-import type { Address } from "viem";
-import type { GearboxSDK } from "../GearboxSDK.js";
+import type { Address, Chain, PublicClient, Transport } from "viem";
 import { type PhantomTokenContractType } from "../index.js";
 import type { Asset } from "../router/index.js";
 import { AddressMap } from "../utils/index.js";
@@ -16,7 +15,7 @@ export interface TokenMetaDataExtended extends TokenMetaData {
 }
 export declare class TokensMeta extends AddressMap<TokenMetaDataExtended> {
     #private;
-    constructor(sdk: GearboxSDK);
+    constructor(client: PublicClient<Transport, Chain>);
     symbol(token: Address): string;
     decimals(token: Address): number;
     /**

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

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

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

@@ -41,3 +41,53 @@ export declare enum VotingContractStatus {
     ALLOWED = 1,
     UNVOTE_ONLY = 2
 }
+export type ParsedCallArgs = Record<string, string>;
+export interface ParsedCall {
+    chainId: number;
+    target: Address;
+    contractType: string;
+    label: string;
+    functionName: string;
+    args: ParsedCallArgs;
+}
+export interface IBaseContract {
+    /**
+     * Contract address
+     **/
+    readonly address: Address;
+    /**
+     * Contract type (parsed bytes32 or empty string)
+     **/
+    readonly contractType: string;
+    /**
+     * Contract version
+     **/
+    readonly version: number;
+    /**
+     * Internal name, for labeling purposes
+     * However, other contracts may add more labels, so prefer use labeling methods instead
+     **/
+    readonly name: string;
+    /**
+     * Indicates that contract state diverged from onchain state and needs to be updated
+     */
+    dirty: boolean;
+    /**
+     * 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)
+     **/
+    parseFunctionData: (calldata: Hex) => ParsedCall;
+    /**
+     * Same as {@link parseFunctionData}, but throws if error occurs
+     **/
+    mustParseFunctionData: (calldata: Hex) => ParsedCall;
+    /**
+     * Converts contract calldata to some human-friendly string
+     * This is safe function which should not throw
+     **/
+    stringifyFunctionData: (calldata: Hex) => string;
+    /**
+     * Same as {@link stringifyFunctionData}, but throws if error occurs
+     **/
+    mustStringifyFunctionData: (calldata: Hex) => string;
+}

package/dist/types/sdk/core/BotListV3Contract.d.ts

@@ -314,7 +314,7 @@ type abi = typeof abi;
 export declare class BotListContract extends BaseContract<abi> {
     #private;
     constructor(sdk: GearboxSDK, address: Address);
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): Array<string> | undefined;
+    protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
     syncState(toBlock: bigint): Promise<void>;
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     get approvedCreditManagers(): Set<Address>;

package/dist/types/sdk/core/GearStakingV3Contract.d.ts

@@ -509,7 +509,7 @@ export interface MultiVote {
 }
 export declare class GearStakingContract extends BaseContract<abi> {
     constructor(sdk: GearboxSDK, address: Address);
-    parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): Array<string> | undefined;
+    protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
     stateHuman(raw?: boolean): GearStakingV3StateHuman;
     deposit(amount: bigint, votes: Array<MultiVote>): RawTx;
     depositWithPermit(amount: bigint, votes: Array<MultiVote>, permit: PermitResult): RawTx;

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

@@ -1,13 +1,12 @@
 import { type Abi, type Address } from "viem";
-import type { BaseContractOptions } from "../../base/BaseContract.js";
-import { BaseContract } from "../../base/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 { GearboxSDK } from "../../GearboxSDK.js";
 import type { AddressProviderV3StateHuman } from "../../types/index.js";
 import type { AddressProviderState } from "./types.js";
 export default abstract class AbstractAddressProviderContract<abi extends Abi | readonly unknown[]> extends BaseContract<abi> {
     #private;
-    constructor(sdk: GearboxSDK, args: BaseContractOptions<abi>, addresses?: Record<string, Record<number, Address>>);
+    constructor(options: ConstructOptions, args: BaseContractArgs<abi>, addresses?: Record<string, Record<number, Address>>);
     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,5 +1,5 @@
 import type { Address, ContractEventName, DecodeFunctionDataReturnType, Log } from "viem";
-import type { GearboxSDK } from "../../GearboxSDK.js";
+import type { ConstructOptions } from "../../base/Construct.js";
 import AbstractAddressProviderContract from "./AbstractAddressProviderContract.js";
 import type { IAddressProviderContract } from "./types.js";
 declare const abi: readonly [{
@@ -89,8 +89,8 @@ declare const abi: readonly [{
 }];
 type abi = typeof abi;
 export declare class AddressProviderV300Contract extends AbstractAddressProviderContract<abi> implements IAddressProviderContract {
-    constructor(sdk: GearboxSDK, address: Address, version: number, addresses?: Record<string, Record<number, Address>>);
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): Array<string> | undefined;
+    constructor(options: ConstructOptions, address: Address, version: number, addresses?: Record<string, Record<number, Address>>);
+    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,5 +1,5 @@
 import type { Address, ContractEventName, DecodeFunctionDataReturnType, Log } from "viem";
-import type { GearboxSDK } from "../../GearboxSDK.js";
+import type { ConstructOptions } from "../../base/Construct.js";
 import AbstractAddressProviderContract from "./AbstractAddressProviderContract.js";
 import type { IAddressProviderContract } from "./types.js";
 declare const abi: readonly [{
@@ -254,8 +254,8 @@ declare const abi: readonly [{
 }];
 type abi = typeof abi;
 export declare class AddressProviderV310Contract extends AbstractAddressProviderContract<abi> implements IAddressProviderContract {
-    constructor(sdk: GearboxSDK, address: Address, version: number, addresses?: Record<string, Record<number, Address>>);
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): Array<string> | undefined;
+    constructor(options: ConstructOptions, address: Address, version?: number, addresses?: Record<string, Record<number, Address>>);
+    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/market/MarketConfiguratorContract.d.ts

@@ -1,7 +1,7 @@
 import { type Address, type ContractEventName, type Log } from "viem";
+import type { ConstructOptions } from "../base/Construct.js";
 import { BaseContract } from "../base/index.js";
 import type { PeripheryContract } from "../constants/index.js";
-import type { GearboxSDK } from "../GearboxSDK.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [];
@@ -1529,7 +1529,7 @@ declare const abi: readonly [{
 type abi = typeof abi;
 export declare class MarketConfiguratorContract extends BaseContract<abi> {
     #private;
-    constructor(sdk: GearboxSDK, address: Address);
+    constructor(options: ConstructOptions, address: Address);
     loadCuratorName(): Promise<void>;
     getPeripheryContract(contract: PeripheryContract): Promise<Address>;
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;

package/dist/types/sdk/market/credit/CreditConfiguratorV300Contract.d.ts

@@ -1,4 +1,4 @@
-import type { Address, ContractEventName, DecodeFunctionDataReturnType, GetEventArgs, Log } from "viem";
+import type { ContractEventName, DecodeFunctionDataReturnType, GetEventArgs, Log } from "viem";
 import type { CreditSuiteState } from "../../base/index.js";
 import { BaseContract } from "../../base/index.js";
 import type { GearboxSDK } from "../../GearboxSDK.js";
@@ -638,11 +638,11 @@ export type RampEvent = GetEventArgs<abi, "ScheduleTokenLiquidationThresholdRamp
     Required: true;
 }>;
 export declare class CreditConfiguratorV300Contract extends BaseContract<abi> implements ICreditConfiguratorContract {
-    readonly adapters: Address[];
+    readonly sdk: GearboxSDK;
     isPaused: boolean;
     constructor(sdk: GearboxSDK, { creditConfigurator, creditManager }: CreditSuiteState);
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     checkRamps(): Promise<RampEvent[]>;
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): Array<string> | undefined;
+    protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
 }
 export {};

package/dist/types/sdk/market/credit/CreditConfiguratorV310Contract.d.ts

@@ -1,4 +1,4 @@
-import type { Address, ContractEventName, DecodeFunctionDataReturnType, Log } from "viem";
+import type { ContractEventName, DecodeFunctionDataReturnType, Log } from "viem";
 import type { CreditSuiteState } from "../../base/index.js";
 import { BaseContract } from "../../base/index.js";
 import type { GearboxSDK } from "../../GearboxSDK.js";
@@ -484,11 +484,11 @@ declare const abi: readonly [{
 }];
 type abi = typeof abi;
 export declare class CreditConfiguratorV310Contract extends BaseContract<abi> implements ICreditConfiguratorContract {
-    readonly adapters: Address[];
+    readonly sdk: GearboxSDK;
     isPaused: boolean;
     constructor(sdk: GearboxSDK, { creditConfigurator, creditManager }: CreditSuiteState);
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     checkRamps(): Promise<RampEvent[]>;
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): Array<string> | undefined;
+    protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
 }
 export {};

package/dist/types/sdk/market/credit/CreditFacadeV300Contract.d.ts

@@ -1,7 +1,6 @@
 import type { Address, ContractEventName, DecodeFunctionDataReturnType, Hex, Log } from "viem";
-import type { CreditFacadeState, CreditSuiteState } from "../../base/index.js";
+import type { ConstructOptions, CreditFacadeState, CreditSuiteState } from "../../base/index.js";
 import { BaseContract } from "../../base/index.js";
-import type { GearboxSDK } from "../../GearboxSDK.js";
 import type { CreditFacadeStateHuman, MultiCall, RawTx } from "../../types/index.js";
 declare const abi: readonly [{
     readonly type: "function";
@@ -777,13 +776,13 @@ export interface CreditFacadeV300Contract extends Omit<CreditFacadeState, "baseP
 }
 export declare class CreditFacadeV300Contract extends BaseContract<abi> {
     readonly underlying: Address;
-    constructor(sdk: GearboxSDK, { creditFacade, creditManager }: CreditSuiteState);
+    constructor(options: ConstructOptions, { creditFacade, creditManager }: CreditSuiteState);
     stateHuman(raw?: boolean): CreditFacadeStateHuman;
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     liquidateCreditAccount(ca: Address, to: Address, calls: MultiCall[], lossPolicyData?: Hex): RawTx;
     closeCreditAccount(ca: Address, calls: MultiCall[]): RawTx;
     multicall(ca: Address, calls: MultiCall[]): RawTx;
     openCreditAccount(to: Address, calls: MultiCall[], referralCode: bigint): RawTx;
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[] | undefined;
+    protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
 }
 export {};

package/dist/types/sdk/market/credit/CreditFacadeV310Contract.d.ts

@@ -1,7 +1,6 @@
 import type { Address, ContractEventName, DecodeFunctionDataReturnType, Hex, Log } from "viem";
-import type { CreditFacadeState, CreditSuiteState } from "../../base/index.js";
+import type { ConstructOptions, CreditFacadeState, CreditSuiteState } from "../../base/index.js";
 import { BaseContract } from "../../base/index.js";
-import type { GearboxSDK } from "../../GearboxSDK.js";
 import type { CreditFacadeStateHuman, MultiCall, RawTx } from "../../types/index.js";
 declare const abi: readonly [{
     readonly type: "function";
@@ -850,13 +849,13 @@ export interface CreditFacadeV310Contract extends Omit<CreditFacadeState, "baseP
 }
 export declare class CreditFacadeV310Contract extends BaseContract<abi> {
     readonly underlying: Address;
-    constructor(sdk: GearboxSDK, { creditFacade, creditManager }: CreditSuiteState);
+    constructor(options: ConstructOptions, { creditFacade, creditManager }: CreditSuiteState);
     stateHuman(raw?: boolean): CreditFacadeStateHuman;
     processLog(log: Log<bigint, number, false, undefined, undefined, abi, ContractEventName<abi>>): void;
     liquidateCreditAccount(ca: Address, to: Address, calls: MultiCall[], lossPolicyData?: Hex): RawTx;
     closeCreditAccount(ca: Address, calls: MultiCall[]): RawTx;
     multicall(ca: Address, calls: MultiCall[]): RawTx;
     openCreditAccount(to: Address, calls: MultiCall[], referralCode: bigint): RawTx;
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[] | undefined;
+    protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
 }
 export {};

package/dist/types/sdk/market/credit/CreditManagerV300Contract.d.ts

@@ -1024,7 +1024,7 @@ declare const abi: readonly [{
     }];
     readonly anonymous: false;
 }];
-export interface CreditManagerV300Contract extends Omit<CreditManagerState, "baseParams" | "collateralTokens" | "liquidationThresholds">, BaseContract<abi> {
+export interface CreditManagerV300Contract extends Omit<CreditManagerState, "baseParams" | "collateralTokens" | "liquidationThresholds" | "name">, BaseContract<abi> {
 }
 export declare class CreditManagerV300Contract extends BaseContract<abi> implements ICreditManagerContract {
     /**

package/dist/types/sdk/market/credit/CreditManagerV310Contract.d.ts

@@ -981,7 +981,7 @@ declare const abi: readonly [{
     readonly name: "SetCreditConfigurator";
 }];
 type abi = typeof iCreditManagerV310Abi;
-export interface CreditManagerV310Contract extends Omit<CreditManagerState, "baseParams" | "collateralTokens" | "liquidationThresholds">, BaseContract<abi> {
+export interface CreditManagerV310Contract extends Omit<CreditManagerState, "baseParams" | "collateralTokens" | "liquidationThresholds" | "name">, BaseContract<abi> {
 }
 export declare class CreditManagerV310Contract extends BaseContract<abi> implements ICreditManagerContract {
     /**

package/dist/types/sdk/market/credit/CreditSuite.d.ts

@@ -6,7 +6,6 @@ import type { IRouterContract } from "../../router/index.js";
 import type { CreditSuiteStateHuman } from "../../types/index.js";
 import type { CreditFacadeContract, ICreditConfiguratorContract, ICreditManagerContract } from "./types.js";
 export declare class CreditSuite extends SDKConstruct {
-    readonly name: string;
     readonly pool: Address;
     readonly underlying: Address;
     readonly creditManager: ICreditManagerContract;
@@ -14,8 +13,10 @@ export declare class CreditSuite extends SDKConstruct {
     readonly creditConfigurator: ICreditConfiguratorContract;
     readonly marketConfigurator: Address;
     readonly state: CreditSuiteState;
+    readonly name: string;
     constructor(sdk: GearboxSDK, marketData: MarketData, index: number);
     get router(): IRouterContract;
+    get isExpired(): boolean;
     get dirty(): boolean;
     get watchAddresses(): Set<Address>;
     stateHuman(raw?: boolean): CreditSuiteStateHuman;

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

@@ -6,12 +6,11 @@ import type { IAdapterContract } from "../adapters/index.js";
 import type { CreditFacadeV300Contract, CreditFacadeV310Contract } from "../index.js";
 import type { RampEvent } from "./CreditConfiguratorV300Contract.js";
 export interface ICreditConfiguratorContract extends IBaseContract {
-    adapters: Address[];
     isPaused: boolean;
     checkRamps: () => Promise<RampEvent[]>;
     stateHuman: (raw?: boolean) => CreditConfiguratorStateHuman;
 }
-export interface ICreditManagerContract extends IBaseContract, Omit<CreditManagerState, "baseParams" | "collateralTokens"> {
+export interface ICreditManagerContract extends IBaseContract, Omit<CreditManagerState, "baseParams" | "collateralTokens" | "name"> {
     /**
      * Mapping targetContract => adapter
      */

package/dist/types/sdk/market/loss-policy/AliasLossPolicyV310Contract.d.ts

@@ -285,6 +285,7 @@ export declare class AliasLossPolicyV310Contract extends BaseContract<abi> imple
     readonly checksEnabled: boolean;
     readonly tokens: readonly Address[];
     readonly priceFeedParams: readonly AliasedPriceFeedParams[];
+    readonly sdk: GearboxSDK;
     constructor(sdk: GearboxSDK, params: BaseParams);
     getLiquidationData(creditAccount: Address, blockNumber?: bigint): Promise<Hex | undefined>;
     stateHuman(raw?: boolean): AliasLossPolicyStateHuman;

package/dist/types/sdk/market/loss-policy/LossPolicyContract.d.ts

@@ -1,6 +1,5 @@
 import type { Address, Hex } from "viem";
-import { BaseContract, type BaseParams } from "../../base/index.js";
-import type { GearboxSDK } from "../../GearboxSDK.js";
+import { BaseContract, type BaseParams, type ConstructOptions } from "../../base/index.js";
 import type { ILossPolicyContract } from "./types.js";
 declare const abi: readonly [{
     readonly type: "function";
@@ -130,7 +129,7 @@ declare const abi: readonly [{
 }];
 type abi = typeof abi;
 export declare class LossPolicyContract extends BaseContract<abi> implements ILossPolicyContract {
-    constructor(sdk: GearboxSDK, params: BaseParams);
+    constructor(options: ConstructOptions, params: BaseParams);
     getLiquidationData(_creditAccount: Address, _blockNumber?: bigint): Promise<Hex | undefined>;
 }
 export {};