@gearbox-protocol/sdk 11.11.0-next.2 → 11.11.0

package/dist/esm/sdk/router/createRouter.js

@@ -2,10 +2,6 @@ import { isV300, isV310 } from "../constants/index.js";
 import { RouterV300Contract } from "./RouterV300Contract.js";
 import { RouterV310Contract } from "./RouterV310Contract.js";
 function createRouter(sdk, address, version) {
-  const contract = sdk.getContract(address);
-  if (contract) {
-    return contract;
-  }
   if (isV300(version)) {
     return new RouterV300Contract(sdk, address, version);
   }

package/dist/esm/sdk/utils/index.js

@@ -1,6 +1,5 @@
 export * from "./AddressMap.js";
 export * from "./AddressSet.js";
-export * from "./abi-decode.js";
 export * from "./bytes32ToString.js";
 export * from "./childLogger.js";
 export * from "./createRawTx.js";

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

@@ -1,7 +1,7 @@
 import type { Abi } from "abitype";
 import type { Account, Address, Chain, Client, ContractConstructorArgs, GetChainParameter, Hash, Hex, SendTransactionParameters, SendTransactionReturnType, Transport, UnionEvaluate, UnionOmit, WalletClient } from "viem";
 import type { GearboxSDK } from "../sdk/index.js";
-import { Construct } from "../sdk/index.js";
+import { SDKConstruct } from "../sdk/index.js";
 export declare const PUBLIC_CREATE2_FACTORY: Address;
 export declare const DEFAULT_CREATE2_SALT = "GEARBOX";
 export type Create2Parameters<abi extends Abi | readonly unknown[] = Abi, chain extends Chain = Chain, account extends Account = Account, chainOverride extends Chain | undefined = Chain | undefined, allArgs = ContractConstructorArgs<abi>> = UnionOmit<SendTransactionParameters<chain, account, chainOverride>, "accessList" | "chain" | "to" | "data"> & GetChainParameter<chain, chainOverride> & UnionEvaluate<readonly [] extends allArgs ? {
@@ -24,7 +24,7 @@ export interface EnsureExistsUsingPublicCreate2ReturnType {
     address: Address;
     hash?: Hash;
 }
-export declare class Create2Deployer<transport extends Transport = Transport, chain extends Chain = Chain, account extends Account = Account> extends Construct {
+export declare class Create2Deployer<transport extends Transport = Transport, chain extends Chain = Chain, account extends Account = Account> extends SDKConstruct {
     #private;
     constructor(sdk: GearboxSDK, walletClient: WalletClient<transport, chain, account>);
     ensureExists<abi extends Abi | readonly unknown[], chainOverride extends Chain | undefined = Chain | undefined>(parameters: Create2Parameters<abi, chain, account, chainOverride>): Promise<EnsureExistsUsingPublicCreate2ReturnType>;

package/dist/types/dev/mint/AbstractMinter.d.ts

@@ -1,11 +1,12 @@
 import { type Address } from "viem";
-import { type GearboxSDK, SDKConstruct } from "../../sdk/index.js";
+import { type GearboxSDK, type ILogger, SDKConstruct } from "../../sdk/index.js";
 import type { AnvilClient } from "../createAnvilClient.js";
 import type { IMinter } from "./types.js";
 export default abstract class AbstractMinter extends SDKConstruct implements IMinter {
     protected readonly anvil: AnvilClient;
-    name: string;
-    constructor(sdk: GearboxSDK, anvil: AnvilClient);
+    protected readonly logger?: ILogger;
+    readonly name: string;
+    constructor(sdk: GearboxSDK, anvil: AnvilClient, name?: string);
     tryMint(token: Address, dest: Address, amount: bigint): Promise<bigint>;
     abstract mint(token: Address, dest: Address, amount: bigint): Promise<void>;
     protected getOwner(address: Address): Promise<Address>;

package/dist/types/dev/mint/DealMinter.d.ts

@@ -1,6 +1,9 @@
 import type { Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
 import AbstractMinter from "./AbstractMinter.js";
 import type { IMinter } from "./types.js";
 export declare class DealMinter extends AbstractMinter implements IMinter {
+    constructor(sdk: GearboxSDK, anvil: AnvilClient);
     mint(token: Address, dest: Address, amount: bigint): Promise<void>;
 }

package/dist/types/dev/mint/DirectMinter.d.ts

@@ -1,6 +1,9 @@
 import { type Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
 import AbstractMinter from "./AbstractMinter.js";
 import type { IMinter } from "./types.js";
 export declare class DirectMinter extends AbstractMinter implements IMinter {
+    constructor(sdk: GearboxSDK, anvil: AnvilClient);
     mint(token: Address, dest: Address, amount: bigint): Promise<void>;
 }

package/dist/types/dev/mint/TransferMinter.d.ts

@@ -1,6 +1,9 @@
 import { type Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
 import AbstractMinter from "./AbstractMinter.js";
 import type { IMinter } from "./types.js";
 export declare class TransferMinter extends AbstractMinter implements IMinter {
+    constructor(sdk: GearboxSDK, anvil: AnvilClient);
     mint(token: Address, dest: Address, amount: bigint): Promise<void>;
 }

package/dist/types/permissionless/bindings/address-provider.d.ts

@@ -1,8 +1,259 @@
-import { type Address, type Chain, type PublicClient, type Transport } from "viem";
-import { AddressProviderV310Contract } from "../../sdk/index.js";
-export declare class AddressProviderContract extends AddressProviderV310Contract {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+import { type Address, type PublicClient } from "viem";
+import { BaseContract } from "./base-contract.js";
+declare const abi: readonly [{
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "contractType";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "getAddress";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "getAddressOrRevert";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "getAllEntries";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "struct AddressProviderEntry[]";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "key";
+            readonly internalType: "bytes32";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "ver";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }, {
+            readonly name: "value";
+            readonly internalType: "address";
+            readonly type: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "getKeys";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32[]";
+        readonly type: "bytes32[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "majorVersion";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "getLatestMinorVersion";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "minorVersion";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "getLatestPatchVersion";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getLatestVersion";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getVersions";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256[]";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "owner";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "value";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "saveVersion";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "setAddress";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "version";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "value";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }];
+    readonly name: "SetAddress";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "AddressNotFoundException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "caller";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "CallerIsNotOwnerException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "ver";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "InvalidVersionException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "VersionNotFoundException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "key";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly name: "ZeroAddressException";
+}];
+export declare class AddressProviderContract extends BaseContract<typeof abi> {
+    constructor(address: Address, client: PublicClient);
     getAddressOrRevert(key: string, version?: bigint): Promise<Address>;
     getLatestVersionAddress(key: string): Promise<Address>;
     getLatestVersion(key: string): Promise<bigint>;
 }
+export {};

package/dist/types/permissionless/bindings/base-contract.d.ts

@@ -0,0 +1,23 @@
+import { type Abi, type Address, type Client, type ContractEventArgs, type ContractEventName, type ContractFunctionName, type DecodeFunctionDataReturnType, type EncodeFunctionDataParameters, type GetContractEventsReturnType, type GetContractReturnType, type Hex, type PublicClient } from "viem";
+import type { RawTx } from "../../sdk/types/index.js";
+import type { CrossChainCall, ParsedCall } from "../core/proposal.js";
+export declare class BaseContract<const abi extends Abi | readonly unknown[]> {
+    readonly abi: abi;
+    readonly address: Address;
+    readonly name: string;
+    protected static register: Record<Address, BaseContract<any>>;
+    protected contract: GetContractReturnType<abi, Client, Address>;
+    readonly client: PublicClient;
+    constructor(abi: abi, address: Address, client: PublicClient, name: string);
+    static parseCall(call: CrossChainCall): ParsedCall;
+    static parse(address: Address, calldata: Hex): ParsedCall;
+    parseFunctionData(calldata: Hex): ParsedCall;
+    protected wrapParseCall(params: DecodeFunctionDataReturnType<abi>, parsedParams: Record<string, string>): ParsedCall;
+    parseFunctionParams(_params: DecodeFunctionDataReturnType<abi>): ParsedCall | undefined;
+    createRawTx<functionName extends ContractFunctionName<abi> | undefined = undefined>(parameters: Omit<EncodeFunctionDataParameters<abi, functionName>, "abi"> & {
+        description?: string;
+    }): RawTx;
+    protected stringifyParsedCall(parsedCall: ParsedCall): string;
+    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>>;
+    getContract(): GetContractReturnType<abi, Client, Address>;
+}

package/dist/types/permissionless/bindings/bytecode-repository.d.ts

@@ -1,8 +1,9 @@
-import { type Address, type Chain, type DecodeFunctionDataReturnType, type Hex, type Log, type PublicClient, type Transport, type WalletClient } from "viem";
-import type { RawTx } from "../../sdk/index.js";
-import { BaseContract, type ParsedCallArgs } from "../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType, type Hex, type Log, type PublicClient, type WalletClient } from "viem";
+import type { RawTx } from "../../sdk/types/index.js";
 import type { Auditor } from "../core/auditor.js";
 import type { AuditEvent, Bytecode, DeploymentExtended } from "../core/bytecode.js";
+import type { ParsedCall } from "../core/proposal.js";
+import { BaseContract } from "./base-contract.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [];
@@ -1150,7 +1151,7 @@ interface ComputeAddressArgs {
     owner: Address;
 }
 export declare class BytecodeRepositoryContract extends BaseContract<typeof abi> {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     getBytecodeByHash(hash: `0x${string}`): Promise<{
         contractType: `0x${string}`;
         version: bigint;
@@ -1190,7 +1191,7 @@ export declare class BytecodeRepositoryContract extends BaseContract<typeof abi>
         blockNumber: number;
     }>>;
     getUploadUpdates(fromBlock: bigint, toBlock: bigint): Promise<Omit<Bytecode, "uploadedAt">[]>;
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCallArgs;
+    parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCall | undefined;
     signBytecodeHash(bytecodeHash: Hex, auditor: Address, reportUrl: string, signature: Hex, sponsor: WalletClient): Promise<`0x${string}`>;
     signBytecodeHashTx(bytecodeHash: Hex, auditor: Address, reportUrl: string, signature: Hex): RawTx;
     recoverAuditorSignature(bytecodeHash: Hex, auditor: Address, reportUrl: string, signature: Hex): Promise<Address>;

package/dist/types/permissionless/bindings/compressors/token-compressor.d.ts

@@ -1,5 +1,5 @@
-import { type Address, type Chain, type PublicClient, type Transport } from "viem";
-import { BaseContract } from "../../../sdk/index.js";
+import { type Address, type PublicClient } from "viem";
+import { BaseContract } from "../base-contract.js";
 declare const abi: readonly [{
     readonly type: "constructor";
     readonly inputs: readonly [{
@@ -102,7 +102,7 @@ declare const abi: readonly [{
     readonly stateMutability: "view";
 }];
 export declare class TokenCompressorContract extends BaseContract<typeof abi> {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     getTokenInfo(token: Address): Promise<{
         name: string;
         symbol: string;

package/dist/types/permissionless/bindings/compressors/withdrawal-compressor.d.ts

@@ -1,5 +1,6 @@
-import { type Address, type Chain, type DecodeFunctionDataReturnType, type PublicClient, type Transport } from "viem";
-import { BaseContract, type ParsedCallArgs } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType, type PublicClient } from "viem";
+import type { ParsedCall } from "../../core/index.js";
+import { BaseContract } from "../base-contract.js";
 declare const abi: readonly [{
     readonly type: "constructor";
     readonly inputs: readonly [{
@@ -393,7 +394,7 @@ declare const abi: readonly [{
     readonly anonymous: false;
 }];
 export declare class WithdrawalCompressorContract extends BaseContract<typeof abi> {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCallArgs;
+    constructor(address: Address, client: PublicClient);
+    parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCall | undefined;
 }
 export {};

package/dist/types/permissionless/bindings/cross-chain-multisig.d.ts

@@ -1,7 +1,7 @@
-import { type Address, type Chain, type DecodeFunctionDataReturnType, type Hex, type PublicClient, type Transport, type WalletClient } from "viem";
-import type { RawTx } from "../../sdk/index.js";
-import { BaseContract, type ParsedCallArgs } from "../../sdk/index.js";
-import type { Batch, RecoveryMessage } from "../core/proposal.js";
+import { type Address, type DecodeFunctionDataReturnType, type Hex, type PublicClient, type WalletClient } from "viem";
+import type { RawTx } from "../../sdk/types/index.js";
+import type { Batch, ParsedCall, RecoveryMessage } from "../core/proposal.js";
+import { BaseContract } from "./base-contract.js";
 declare const abi: readonly [{
     readonly type: "constructor";
     readonly inputs: readonly [{
@@ -725,8 +725,7 @@ export interface Proposal {
     }[];
 }
 export declare class CrossChainMultisigContract extends BaseContract<typeof abi> {
-    #private;
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     getExecutedBatches(fromBlock: bigint, toBlock: bigint): Promise<Omit<Batch, "timestamp">[]>;
     getCurrentBatches(): Promise<Batch[]>;
     getBatchData(args: {
@@ -787,7 +786,8 @@ export declare class CrossChainMultisigContract extends BaseContract<typeof abi>
     enableRecovery(recovery: RecoveryMessage, sponsor: WalletClient): Promise<`0x${string}`>;
     getConfirmationThreshold(): Promise<number>;
     getSigners(): Promise<Address[]>;
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCallArgs;
+    decodeFunctionData(target: Address, calldata: Hex): ParsedCall | undefined;
+    parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCall | undefined;
     validateProposalSignature(proposalHash: Hex, signature: Hex): Promise<{
         success: boolean;
         error?: string;

package/dist/types/permissionless/bindings/factory/abstract-factory.d.ts

@@ -1,4 +1,4 @@
-import { type Abi, type ContractFunctionName, type EncodeFunctionDataParameters, type Hex } from "viem";
+import type { Abi, ContractFunctionName, EncodeFunctionDataParameters, Hex } from "viem";
 export declare class AbstractFactory<const abi extends Abi | readonly unknown[]> {
     readonly abi: abi;
     constructor(abi: abi);

package/dist/types/permissionless/bindings/governance/batches-chain.d.ts

@@ -1,5 +1,6 @@
-import type { Address, Chain, Hash, PublicClient, Transport } from "viem";
-import { BaseContract, type RawTx } from "../../../sdk/index.js";
+import type { Address, Hash, PublicClient } from "viem";
+import type { RawTx } from "../../../sdk/types/index.js";
+import { BaseContract } from "../base-contract.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly name: "contractType";
@@ -32,7 +33,7 @@ declare const abi: readonly [{
     readonly stateMutability: "view";
 }];
 export declare class BatchesChainContract extends BaseContract<typeof abi> {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     createBatchOrderingTx(prevHash: Hash): RawTx;
 }
 export {};

package/dist/types/permissionless/bindings/governance/governor.d.ts

@@ -1,6 +1,7 @@
-import { type Address, type Chain, type DecodeFunctionDataReturnType, type Hash, type PublicClient, type Transport } from "viem";
-import type { ParsedCallArgs, RawTx } from "../../../sdk/index.js";
-import { BaseContract } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType, type Hash, type Hex, type PublicClient } from "viem";
+import type { RawTx } from "../../../sdk/types/index.js";
+import type { ParsedCall } from "../../core/index.js";
+import { BaseContract } from "../base-contract.js";
 import { BatchesChainContract } from "./batches-chain.js";
 import type { SafeTx } from "./types.js";
 declare const abi: readonly [{
@@ -588,9 +589,8 @@ declare const abi: readonly [{
     }];
 }];
 export declare class GovernorContract extends BaseContract<typeof abi> {
-    #private;
     readonly batchesChainContract: BatchesChainContract;
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     getTxHash(tx: RawTx): Hash;
     owner(): Promise<Address>;
     createQueueTx(args: {
@@ -609,6 +609,7 @@ export declare class GovernorContract extends BaseContract<typeof abi> {
     createExecuteBatchTx(args: {
         txs: SafeTx[];
     }): RawTx;
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCallArgs;
+    decodeFunctionData(target: Address, calldata: Hex): ParsedCall | undefined;
+    parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCall | undefined;
 }
 export {};

package/dist/types/permissionless/bindings/governance/timelock.d.ts

@@ -1,9 +1,9 @@
-import type { Address, Chain, PublicClient, Transport } from "viem";
+import type { Address, PublicClient } from "viem";
 import { iTimeLockAbi } from "../../../abi/governance/iTimeLock.js";
-import { BaseContract } from "../../../sdk/index.js";
+import { BaseContract } from "../base-contract.js";
 import type { QueuedAndExecutedTransaction } from "./types.js";
 export declare class TimeLockContract extends BaseContract<typeof iTimeLockAbi> {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     admin(): Promise<Address>;
     getGracePeriod(): Promise<bigint>;
     getQueuedAndExecutedTransactions(fromBlock: bigint, toBlock: bigint): Promise<QueuedAndExecutedTransaction>;

package/dist/types/permissionless/bindings/governance/types.d.ts

@@ -1,5 +1,5 @@
 import type { Address, Hex } from "viem";
-import type { ContractMethod } from "../../../sdk/index.js";
+import type { ContractMethod } from "../../../sdk/types/index.js";
 export interface SafeTx {
     to: string;
     value: string;

package/dist/types/permissionless/bindings/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./address-provider.js";
+export * from "./base-contract.js";
 export * from "./bytecode-repository.js";
 export * from "./compressors/index.js";
 export * from "./cross-chain-multisig.js";

package/dist/types/permissionless/bindings/instance-manager.d.ts

@@ -1,6 +1,7 @@
-import { type Address, type Chain, type DecodeFunctionDataReturnType, type PublicClient, type Transport } from "viem";
-import type { RawTx } from "../../sdk/index.js";
-import { BaseContract, type ParsedCallArgs } from "../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType, type Hex, type PublicClient } from "viem";
+import type { RawTx } from "../../sdk/types/index.js";
+import type { ParsedCall } from "../core/proposal.js";
+import { BaseContract } from "./base-contract.js";
 declare const abi: readonly [{
     readonly type: "constructor";
     readonly inputs: readonly [{
@@ -328,9 +329,9 @@ declare const abi: readonly [{
     readonly name: "InvalidKeyException";
 }];
 export declare class InstanceManagerContract extends BaseContract<typeof abi> {
-    #private;
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCallArgs;
+    constructor(address: Address, client: PublicClient);
+    decodeFunctionData(target: Address, calldata: Hex): ParsedCall | undefined;
+    parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCall | undefined;
     isActivated(): Promise<boolean>;
     getOwner(): Promise<Address>;
     wrapConfigureGlobal(rawTx: RawTx): RawTx;

package/dist/types/permissionless/bindings/market-configurator-factory.d.ts

@@ -1,6 +1,6 @@
-import type { Address, Chain, PublicClient, Transport } from "viem";
-import type { RawTx } from "../../sdk/index.js";
-import { BaseContract } from "../../sdk/index.js";
+import type { Address, PublicClient } from "viem";
+import type { RawTx } from "../../sdk/types/index.js";
+import { BaseContract } from "./base-contract.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [{
@@ -220,7 +220,7 @@ declare const abi: readonly [{
     readonly name: "MarketConfiguratorIsNotRegisteredException";
 }];
 export declare class MarketConfiguratorFactoryContract extends BaseContract<typeof abi> {
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     createMarketConfiguratorTx(args: {
         emergencyAdmin: Address;
         adminFeeTreasury: Address;

package/dist/types/permissionless/bindings/market-configurator.d.ts

@@ -1,10 +1,10 @@
-import { type Address, type Chain, type DecodeFunctionDataReturnType, type Hex, type PublicClient, type Transport } from "viem";
-import type { ParsedCallArgs, RawTx } from "../../sdk/index.js";
-import { BaseContract } from "../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType, type Hex, type PublicClient } from "viem";
+import type { RawTx } from "../../sdk/types/index.js";
+import type { ParsedCall } from "../core/proposal.js";
 import { CreditFactory } from "./factory/credit-factory.js";
 import { PoolFactory } from "./factory/pool-factory.js";
 import { PriceOracleFactory } from "./factory/price-oracle-factory.js";
-import { AddressProviderContract } from "./index.js";
+import { AddressProviderContract, BaseContract } from "./index.js";
 import type { AddAssetParams, AllowTokenParams, DeployParams, ForbidAdapterParams, ForbidTokenParams, Market, PauseCreditManagerParams, SetExpirationDateParams, SetFeesParams, SetPriceFeedParams, SetReservePriceFeedParams, SetTokenQuotaIncreaseFeeParams, UnpauseCreditManagerParams } from "./types.js";
 declare const abi: readonly [{
     readonly type: "function";
@@ -1534,7 +1534,7 @@ export declare class MarketConfiguratorContract extends BaseContract<typeof abi>
     readonly creditFactory: CreditFactory;
     readonly poolFactory: PoolFactory;
     readonly priceOracleFactory: PriceOracleFactory;
-    constructor(addr: Address, client: PublicClient<Transport, Chain>);
+    constructor(address: Address, client: PublicClient);
     getAddressProvider(): Promise<AddressProviderContract>;
     previewCreateMarket(params: {
         minorVersion: number;
@@ -1649,7 +1649,7 @@ export declare class MarketConfiguratorContract extends BaseContract<typeof abi>
         fromBlock: bigint;
         toBlock: bigint;
     }): Promise<Market[]>;
-    protected parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCallArgs;
+    parseFunctionParams(params: DecodeFunctionDataReturnType<typeof abi>): ParsedCall | undefined;
     emergencyConfigurePool(pool: Address, calldata: Hex): RawTx;
     emergencyConfigureCreditSuite(creditManager: Address, calldata: Hex): RawTx;
     emergencyConfigurePriceOracle(pool: Address, calldata: Hex): RawTx;