@gearbox-protocol/sdk 12.9.7 → 13.0.0-beta.1

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

@@ -1,10 +1,9 @@
 import type { Address } from "viem";
 import type { GearboxSDK } from "../sdk/index.js";
-export declare function unsafeMigrateFaucet(sdk: GearboxSDK, faucet?: Address): Promise<void>;
 /**
- * Sets new faucet address on v3.1 address provider
+ * Sets faucet address on address provider
  * @param sdk
- * @param faucet - new faucet address. If not provided, will try to get one from v3.0 address provider
- * @returns faucet address as read from v3.1 address provider
+ * @param faucet - faucet address.
+ * @returns faucet address as read from address provider
  */
-export declare function migrateFaucet(sdk: GearboxSDK, faucet?: Address): Promise<Address>;
+export declare function migrateFaucet(sdk: GearboxSDK, faucet: Address): Promise<Address>;

package/dist/types/plugins/adapters/contracts/AbstractAdapter.d.ts

@@ -2,11 +2,9 @@ import { type Abi, type Address, type Hex, type PartialBy } from "viem";
 import type { ConstructOptions, ParsedCallV2, RelaxedBaseParams } from "../../../sdk/index.js";
 import { BaseContract } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
-import type { AdapterContractType, AdapterOperation, TokenTransfer } from "../types.js";
+import type { AdapterContractStateHuman, AdapterContractType, AdapterOperation, TokenTransfer } from "../types.js";
 export interface ConcreteAdapterContractOptions {
     baseParams: RelaxedBaseParams;
-    targetContract?: Address;
-    name?: string;
 }
 export interface AbstractAdapterContractOptions<abi extends Abi | readonly unknown[], protocolAbi extends Abi | readonly unknown[]> extends ConcreteAdapterContractOptions {
     abi: abi;
@@ -20,7 +18,9 @@ export declare class AbstractAdapterContract<const abi extends Abi | readonly un
     readonly protocolAbi: protocolAbi;
     constructor(options: ConstructOptions, args: AbstractAdapterContractOptions<abi, protocolAbi>);
     get targetContract(): Address;
+    get creditManager(): Address;
     get adapterType(): AdapterContractType;
+    stateHuman(raw?: boolean): AdapterContractStateHuman;
     /**
      * Builds an {@link AdapterOperation} from a parsed call and ordered transfer entries.
      *

package/dist/types/plugins/adapters/contracts/BalancerV3RouterAdapterContract.d.ts

@@ -2,7 +2,17 @@ import { type Address } from "viem";
 import type { ConstructOptions } from "../../../sdk/index.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
-import type { BalancerV3PoolStatus } from "./types.js";
+export declare enum BalancerV3PoolStatus {
+    NOT_ALLOWED = 0,
+    ALLOWED = 1,
+    EXIT_AND_SWAP = 2,
+    SWAP_ONLY = 3,
+    EXIT_ONLY = 4
+}
+export interface BalancerV3Pool {
+    pool: Address;
+    status?: BalancerV3PoolStatus;
+}
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [{
@@ -429,9 +439,17 @@ type protocolAbi = typeof protocolAbi;
 export declare class BalancerV3RouterAdapterContract extends AbstractAdapterContract<abi, protocolAbi> {
     #private;
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
-    get allowedPools(): Address[] | {
-        pool: Address;
-        status: BalancerV3PoolStatus;
-    }[];
+    get allowedPools(): BalancerV3Pool[];
+    stateHuman(raw?: boolean): {
+        allowedPools: {
+            pool: string;
+            status: BalancerV3PoolStatus | undefined;
+        }[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/BalancerV3WrapperAdapterContract.d.ts

@@ -156,5 +156,13 @@ export declare class BalancerV3WrapperAdapterContract extends AbstractAdapterCon
     #private;
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get balancerPoolToken(): Address;
+    stateHuman(raw?: boolean): {
+        balancerPoolToken: string | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/CamelotV3AdapterContract.d.ts

@@ -2,6 +2,10 @@ import { type Address } from "viem";
 import type { ConstructOptions } from "../../../sdk/index.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
+export interface CamelotPool {
+    token0: Address;
+    token1: Address;
+}
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [];
@@ -639,9 +643,17 @@ type protocolAbi = typeof protocolAbi;
 export declare class CamelotV3AdapterContract extends AbstractAdapterContract<abi, protocolAbi> {
     #private;
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
-    get supportedPools(): {
-        token0: Address;
-        token1: Address;
-    }[];
+    get supportedPools(): CamelotPool[];
+    stateHuman(raw?: boolean): {
+        supportedPools: {
+            token0: string;
+            token1: string;
+        }[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/ConvexV1BaseRewardPoolAdapterContract.d.ts

@@ -674,6 +674,17 @@ export declare class ConvexV1BaseRewardPoolAdapterContract extends AbstractAdapt
     get stakingToken(): Address;
     get stakedPhantomToken(): Address;
     get extraRewards(): [Address, Address, Address, Address];
+    stateHuman(raw?: boolean): {
+        curveLPtoken: string | undefined;
+        stakingToken: string | undefined;
+        stakedPhantomToken: string | undefined;
+        extraRewards: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /**
      * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L200-L262
      * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L76-L83

package/dist/types/plugins/adapters/contracts/ConvexV1BoosterAdapterContract.d.ts

@@ -3,6 +3,12 @@ import { type ConstructOptions, type ParsedCallV2 } from "../../../sdk/index.js"
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
+interface ConvexV1BoosterPool {
+    pid: number;
+    curveToken: Address;
+    convexToken: Address;
+    phantomToken: Address;
+}
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [];
@@ -393,12 +399,20 @@ type protocolAbi = typeof protocolAbi;
 export declare class ConvexV1BoosterAdapterContract extends AbstractAdapterContract<abi, protocolAbi> {
     #private;
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
-    get supportedPools(): {
-        pid: number;
-        curveToken: Address;
-        convexToken: Address;
-        phantomToken: Address;
-    }[];
+    get supportedPools(): ConvexV1BoosterPool[];
+    stateHuman(raw?: boolean): {
+        supportedPools: {
+            pid: number;
+            curveToken: string;
+            convexToken: string;
+            phantomToken: string;
+        }[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /**
      * Charts_server only maps `withdrawAll(uint256)` → CurveWithdrawal.
      * `withdrawDiff` and other withdraw variants fall to the base class fallback → Swap.

package/dist/types/plugins/adapters/contracts/Curve2AssetsAdapterContract.d.ts

@@ -1762,6 +1762,19 @@ export declare class Curve2AssetsAdapterContract extends AbstractAdapterContract
     get use256(): boolean;
     get tokens(): [Address, Address];
     get underlyings(): [Address, Address, Address, Address];
+    stateHuman(raw?: boolean): {
+        token: string | undefined;
+        lpToken: string | undefined;
+        metapoolBase: string | undefined;
+        use256: boolean | undefined;
+        tokens: string[] | undefined;
+        underlyings: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L132-L164 */
     protected classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
 }

package/dist/types/plugins/adapters/contracts/Curve3AssetsAdapterContract.d.ts

@@ -1762,6 +1762,19 @@ export declare class Curve3AssetsAdapterContract extends AbstractAdapterContract
     get use256(): boolean;
     get tokens(): [Address, Address, Address];
     get underlyings(): [Address, Address, Address, Address];
+    stateHuman(raw?: boolean): {
+        token: string | undefined;
+        lpToken: string | undefined;
+        metapoolBase: string | undefined;
+        use256: boolean | undefined;
+        tokens: string[] | undefined;
+        underlyings: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L132-L164 */
     protected classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
 }

package/dist/types/plugins/adapters/contracts/Curve4AssetsAdapterContract.d.ts

@@ -1762,6 +1762,19 @@ export declare class Curve4AssetsAdapterContract extends AbstractAdapterContract
     get use256(): boolean;
     get tokens(): [Address, Address, Address, Address];
     get underlyings(): [Address, Address, Address, Address];
+    stateHuman(raw?: boolean): {
+        token: string | undefined;
+        lpToken: string | undefined;
+        metapoolBase: string | undefined;
+        use256: boolean | undefined;
+        tokens: string[] | undefined;
+        underlyings: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L132-L164 */
     protected classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
 }

package/dist/types/plugins/adapters/contracts/CurveV1StableNGAdapterContract.d.ts

@@ -1731,6 +1731,20 @@ export declare class CurveV1StableNGAdapterContract extends AbstractAdapterContr
     get use256(): boolean;
     get tokens(): [Address, Address, Address, Address];
     get underlyings(): [Address, Address, Address, Address];
+    stateHuman(raw?: boolean): {
+        token: string | undefined;
+        lpToken: string | undefined;
+        metapoolBase: string | undefined;
+        nCoins: number | undefined;
+        use256: boolean | undefined;
+        tokens: string[] | undefined;
+        underlyings: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L132-L164 */
     protected classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
 }

package/dist/types/plugins/adapters/contracts/DaiUsdsAdapterContract.d.ts

@@ -194,6 +194,15 @@ export declare class DaiUsdsAdapterContract extends AbstractAdapterContract<abi,
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get dai(): Address;
     get usds(): Address;
+    stateHuman(raw?: boolean): {
+        dai: string | undefined;
+        usds: string | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L51-L68 */
     protected classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
 }

package/dist/types/plugins/adapters/contracts/ERC4626AdapterContract.d.ts

@@ -655,6 +655,15 @@ export declare class ERC4626AdapterContract extends AbstractAdapterContract<abi,
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get vault(): Address;
     get asset(): Address;
+    stateHuman(raw?: boolean): {
+        vault: string | undefined;
+        asset: string | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /**
      * Charts_server maps `redeem(uint256,address,address)` → MakerRedeem.
      * Diff variants (`redeemDiff`) should also map to MakerRedeem.

package/dist/types/plugins/adapters/contracts/ERC4626ReferralAdapterContract.d.ts

@@ -286,6 +286,15 @@ export declare class ERC4626ReferralAdapterContract extends AbstractAdapterContr
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get asset(): Address;
     get referral(): number;
+    stateHuman(raw?: boolean): {
+        asset: string | undefined;
+        referral: number | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /**
      * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L32-L38
      */

package/dist/types/plugins/adapters/contracts/FluidDexAdapterContract.d.ts

@@ -243,5 +243,14 @@ export declare class FluidDexAdapterContract extends AbstractAdapterContract<abi
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get token0(): Address;
     get token1(): Address;
+    stateHuman(raw?: boolean): {
+        token0: string | undefined;
+        token1: string | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/InfinifiGatewayAdapterContract.d.ts

@@ -472,5 +472,16 @@ export declare class InfinifiGatewayAdapterContract extends AbstractAdapterContr
     get iusd(): Address;
     get siusd(): Address;
     get allowedLockedTokens(): Address[];
+    stateHuman(raw?: boolean): {
+        usdc: string | undefined;
+        iusd: string | undefined;
+        siusd: string | undefined;
+        allowedLockedTokens: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/InfinifiUnwindingGatewayAdapterContract.d.ts

@@ -354,5 +354,13 @@ export declare class InfinifiUnwindingGatewayAdapterContract extends AbstractAda
     #private;
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get allowedLockedTokens(): Address[];
+    stateHuman(raw?: boolean): {
+        allowedLockedTokens: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/KelpLRTDepositPoolAdapterContract.d.ts

@@ -241,5 +241,13 @@ export declare class KelpLRTDepositPoolAdapterContract extends AbstractAdapterCo
     #private;
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get allowedAssets(): Address[];
+    stateHuman(raw?: boolean): {
+        allowedAssets: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/KelpLRTWithdrawalManagerAdapterContract.d.ts

@@ -360,5 +360,16 @@ export declare class KelpLRTWithdrawalManagerAdapterContract extends AbstractAda
         tokenOut: Address;
         phantomToken: Address;
     }[];
+    stateHuman(raw?: boolean): {
+        allowedTokensOut: {
+            tokenOut: string;
+            phantomToken: string;
+        }[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/LidoV1AdapterContract.d.ts

@@ -202,6 +202,16 @@ export declare class LidoV1AdapterContract extends AbstractAdapterContract<abi,
     get stETH(): Address;
     get weth(): Address;
     get treasury(): Address;
+    stateHuman(raw?: boolean): {
+        stETH: string | undefined;
+        weth: string | undefined;
+        treasury: string | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L277-L282 */
     protected classifyLegacyOperation(_parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
 }

package/dist/types/plugins/adapters/contracts/MellowClaimerAdapterContract.d.ts

@@ -286,5 +286,13 @@ export declare class MellowClaimerAdapterContract extends AbstractAdapterContrac
     #private;
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get allowedMultiVaults(): Address[];
+    stateHuman(raw?: boolean): {
+        allowedMultiVaults: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/MellowDVVAdapterContract.d.ts

@@ -697,6 +697,15 @@ export declare class MellowDVVAdapterContract extends AbstractAdapterContract<ab
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get vault(): Address;
     get asset(): Address;
+    stateHuman(raw?: boolean): {
+        vault: string | undefined;
+        asset: string | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /**
      * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L32-L38
      */

package/dist/types/plugins/adapters/contracts/{deprecated/MellowDepositQueueAdapterContract.d.ts → MellowDepositQueueAdapterContract.d.ts}

@@ -1,8 +1,8 @@
 import { type Address } from "viem";
-import { type ConstructOptions, type ParsedCallV2 } from "../../../../sdk/index.js";
-import type { LegacyAdapterOperation, Transfers } from "../../legacyAdapterOperations.js";
-import type { ConcreteAdapterContractOptions } from "../AbstractAdapter.js";
-import { AbstractAdapterContract } from "../AbstractAdapter.js";
+import { type ConstructOptions, type ParsedCallV2 } from "../../../sdk/index.js";
+import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
+import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [];
 type abi = typeof abi;
 declare const protocolAbi: readonly [];
@@ -13,6 +13,16 @@ export declare class MellowDepositQueueAdapterContract extends AbstractAdapterCo
     get asset(): Address;
     get phantomToken(): Address;
     get referral(): Address;
+    stateHuman(raw?: boolean): {
+        asset: string | undefined;
+        phantomToken: string | undefined;
+        referral: string | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /** Legacy adapter not present in integrations-v3. */
     protected classifyLegacyOperation(_parsed: ParsedCallV2, _transfers: Transfers): LegacyAdapterOperation;
 }

package/dist/types/plugins/adapters/contracts/MellowERC4626VaultAdapterContract.d.ts

@@ -660,6 +660,16 @@ export declare class MellowERC4626VaultAdapterContract extends AbstractAdapterCo
     get vault(): Address;
     get asset(): Address;
     get stakedPhantomToken(): Address;
+    stateHuman(raw?: boolean): {
+        vault: string | undefined;
+        asset: string | undefined;
+        stakedPhantomToken: string | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /**
      * Charts_server maps `redeem(uint256,address,address)` → MakerRedeem.
      * Diff variants (`redeemDiff`) should also map to MakerRedeem.

package/dist/types/plugins/adapters/contracts/{deprecated/MellowRedeemQueueAdapterContract.d.ts → MellowRedeemQueueAdapterContract.d.ts}

@@ -1,8 +1,8 @@
 import { type Address } from "viem";
-import { type ConstructOptions, type ParsedCallV2 } from "../../../../sdk/index.js";
-import type { LegacyAdapterOperation, Transfers } from "../../legacyAdapterOperations.js";
-import type { ConcreteAdapterContractOptions } from "../AbstractAdapter.js";
-import { AbstractAdapterContract } from "../AbstractAdapter.js";
+import { type ConstructOptions, type ParsedCallV2 } from "../../../sdk/index.js";
+import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
+import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [];
 type abi = typeof abi;
 declare const protocolAbi: readonly [];
@@ -12,6 +12,15 @@ export declare class MellowRedeemQueueAdapterContract extends AbstractAdapterCon
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get vaultToken(): Address;
     get phantomToken(): Address;
+    stateHuman(raw?: boolean): {
+        vaultToken: string | undefined;
+        phantomToken: string | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
     /** Legacy adapter not present in integrations-v3. */
     protected classifyLegacyOperation(_parsed: ParsedCallV2, _transfers: Transfers): LegacyAdapterOperation;
 }

package/dist/types/plugins/adapters/contracts/MellowWrapperAdapterContract.d.ts

@@ -200,5 +200,13 @@ export declare class MellowWrapperAdapterContract extends AbstractAdapterContrac
     #private;
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
     get allowedVaults(): Address[];
+    stateHuman(raw?: boolean): {
+        allowedVaults: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/MidasIssuanceVaultAdapterContract.d.ts

@@ -223,5 +223,15 @@ export declare class MidasIssuanceVaultAdapterContract extends AbstractAdapterCo
     get mToken(): Address;
     get referrerId(): string;
     get allowedTokens(): Address[];
+    stateHuman(raw?: boolean): {
+        mToken: string | undefined;
+        referrerId: string | undefined;
+        allowedTokens: string[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/MidasRedemptionVaultAdapterContract.d.ts

@@ -466,5 +466,18 @@ export declare class MidasRedemptionVaultAdapterContract extends AbstractAdapter
         token: Address;
         phantomToken: Address;
     }[];
+    stateHuman(raw?: boolean): {
+        gateway: string | undefined;
+        mToken: string | undefined;
+        allowedTokens: {
+            token: string;
+            phantomToken: string;
+        }[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};

package/dist/types/plugins/adapters/contracts/PendleRouterAdapterContract.d.ts

@@ -2,7 +2,15 @@ import { type Address } from "viem";
 import { type ConstructOptions } from "../../../sdk/index.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
-import type { PendlePairStatus, PendleTokenType } from "./types.js";
+export declare enum PendleTokenType {
+    PT = 0,
+    LP = 1
+}
+export declare enum PendlePairStatus {
+    NOT_ALLOWED = 0,
+    ALLOWED = 1,
+    EXIT_ONLY = 2
+}
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [{
@@ -2374,20 +2382,30 @@ declare const protocolAbi: readonly [{
     readonly stateMutability: "payable";
 }];
 type protocolAbi = typeof protocolAbi;
+export interface PendlePair {
+    market: Address;
+    inputToken: Address;
+    pendleToken: Address;
+    pendleTokenType?: PendleTokenType;
+    status: PendlePairStatus;
+}
 export declare class PendleRouterAdapterContract extends AbstractAdapterContract<abi, protocolAbi> {
     #private;
     constructor(options: ConstructOptions, args: ConcreteAdapterContractOptions);
-    get allowedPairs(): {
-        market: Address;
-        inputToken: Address;
-        pendleToken: Address;
-        status: PendlePairStatus;
-    }[] | {
-        market: Address;
-        inputToken: Address;
-        pendleToken: Address;
-        pendleTokenType: PendleTokenType;
-        status: PendlePairStatus;
-    }[];
+    get allowedPairs(): PendlePair[];
+    stateHuman(raw?: boolean): {
+        allowedPairs: {
+            market: string;
+            inputToken: string;
+            pendleToken: string;
+            pendleTokenType: PendleTokenType | undefined;
+            status: PendlePairStatus;
+        }[] | undefined;
+        creditManager?: string;
+        targetContract?: string;
+        address: string;
+        version: number;
+        contractType?: string;
+    };
 }
 export {};