@reclaimprotocol/attestor-core 3.0.1

package/lib/avs/contracts/ReclaimServiceManager.d.ts

@@ -0,0 +1,697 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export declare namespace IReclaimServiceManager {
+    type ClaimRequestStruct = {
+        provider: string;
+        claimUserId: BytesLike;
+        claimHash: BytesLike;
+        requestedAt: BigNumberish;
+        owner: string;
+    };
+    type ClaimRequestStructOutput = [
+        string,
+        string,
+        string,
+        number,
+        string
+    ] & {
+        provider: string;
+        claimUserId: string;
+        claimHash: string;
+        requestedAt: number;
+        owner: string;
+    };
+    type OperatorMetadataStruct = {
+        addr: string;
+        url: string;
+    };
+    type OperatorMetadataStructOutput = [string, string] & {
+        addr: string;
+        url: string;
+    };
+    type OperatorStruct = {
+        addr: string;
+        url: string;
+    };
+    type OperatorStructOutput = [string, string] & {
+        addr: string;
+        url: string;
+    };
+    type TaskStruct = {
+        request: IReclaimServiceManager.ClaimRequestStruct;
+        createdAt: BigNumberish;
+        expiresAt: BigNumberish;
+        minimumSignatures: BigNumberish;
+        operators: IReclaimServiceManager.OperatorStruct[];
+        feePaid: BigNumberish;
+    };
+    type TaskStructOutput = [
+        IReclaimServiceManager.ClaimRequestStructOutput,
+        number,
+        number,
+        number,
+        IReclaimServiceManager.OperatorStructOutput[],
+        BigNumber
+    ] & {
+        request: IReclaimServiceManager.ClaimRequestStructOutput;
+        createdAt: number;
+        expiresAt: number;
+        minimumSignatures: number;
+        operators: IReclaimServiceManager.OperatorStructOutput[];
+        feePaid: BigNumber;
+    };
+    type CompletedTaskStruct = {
+        task: IReclaimServiceManager.TaskStruct;
+        signatures: BytesLike[];
+    };
+    type CompletedTaskStructOutput = [
+        IReclaimServiceManager.TaskStructOutput,
+        string[]
+    ] & {
+        task: IReclaimServiceManager.TaskStructOutput;
+        signatures: string[];
+    };
+    type TaskCreationMetadataStruct = {
+        maxTaskLifetimeS: BigNumberish;
+        minSignaturesPerTask: BigNumberish;
+        maxTaskCreationDelayS: BigNumberish;
+    };
+    type TaskCreationMetadataStructOutput = [number, number, number] & {
+        maxTaskLifetimeS: number;
+        minSignaturesPerTask: number;
+        maxTaskCreationDelayS: number;
+    };
+}
+export declare namespace IPaymentCoordinator {
+    type StrategyAndMultiplierStruct = {
+        strategy: string;
+        multiplier: BigNumberish;
+    };
+    type StrategyAndMultiplierStructOutput = [string, BigNumber] & {
+        strategy: string;
+        multiplier: BigNumber;
+    };
+    type RangePaymentStruct = {
+        strategiesAndMultipliers: IPaymentCoordinator.StrategyAndMultiplierStruct[];
+        token: string;
+        amount: BigNumberish;
+        startTimestamp: BigNumberish;
+        duration: BigNumberish;
+    };
+    type RangePaymentStructOutput = [
+        IPaymentCoordinator.StrategyAndMultiplierStructOutput[],
+        string,
+        BigNumber,
+        number,
+        number
+    ] & {
+        strategiesAndMultipliers: IPaymentCoordinator.StrategyAndMultiplierStructOutput[];
+        token: string;
+        amount: BigNumber;
+        startTimestamp: number;
+        duration: number;
+    };
+}
+export declare namespace ISignatureUtils {
+    type SignatureWithSaltAndExpiryStruct = {
+        signature: BytesLike;
+        salt: BytesLike;
+        expiry: BigNumberish;
+    };
+    type SignatureWithSaltAndExpiryStructOutput = [
+        string,
+        string,
+        BigNumber
+    ] & {
+        signature: string;
+        salt: string;
+        expiry: BigNumber;
+    };
+}
+export interface ReclaimServiceManagerInterface extends utils.Interface {
+    functions: {
+        "admins(uint256)": FunctionFragment;
+        "allTaskHashes(uint32)": FunctionFragment;
+        "avsDirectory()": FunctionFragment;
+        "checkSignerAddress((string,bytes32,bytes32,uint32,address),bytes)": FunctionFragment;
+        "createNewTask((string,bytes32,bytes32,uint32,address),bytes)": FunctionFragment;
+        "deregisterOperatorFromAVS(address)": FunctionFragment;
+        "encodeClaimRequest((string,bytes32,bytes32,uint32,address))": FunctionFragment;
+        "getMetadataForOperator(address)": FunctionFragment;
+        "getOperatorRestakedStrategies(address)": FunctionFragment;
+        "getRestakeableStrategies()": FunctionFragment;
+        "isAdmin(address)": FunctionFragment;
+        "isOperatorWhitelisted(address)": FunctionFragment;
+        "latestTaskNum()": FunctionFragment;
+        "operatorHasMinimumWeight(address)": FunctionFragment;
+        "owner()": FunctionFragment;
+        "pause(uint256)": FunctionFragment;
+        "pauseAll()": FunctionFragment;
+        "paused(uint8)": FunctionFragment;
+        "paused()": FunctionFragment;
+        "pauserRegistry()": FunctionFragment;
+        "payForRange(((address,uint96)[],address,uint256,uint32,uint32)[])": FunctionFragment;
+        "registerOperatorToAVS(address,(bytes,bytes32,uint256))": FunctionFragment;
+        "registeredOperators(uint256)": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "setPauserRegistry(address)": FunctionFragment;
+        "setup(address)": FunctionFragment;
+        "stakeRegistry()": FunctionFragment;
+        "taskCompleted((((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256),bytes[]),uint32)": FunctionFragment;
+        "taskCreationMetadata()": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+        "unpause(uint256)": FunctionFragment;
+        "updateAVSMetadataURI(string)": FunctionFragment;
+        "updateOperatorMetadata((address,string))": FunctionFragment;
+        "updateTaskCreationMetadata((uint32,uint8,uint32))": FunctionFragment;
+        "whitelistAddressAsOperator(address,bool)": FunctionFragment;
+        "whitelistedOperators(uint256)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "admins" | "allTaskHashes" | "avsDirectory" | "checkSignerAddress" | "createNewTask" | "deregisterOperatorFromAVS" | "encodeClaimRequest" | "getMetadataForOperator" | "getOperatorRestakedStrategies" | "getRestakeableStrategies" | "isAdmin" | "isOperatorWhitelisted" | "latestTaskNum" | "operatorHasMinimumWeight" | "owner" | "pause" | "pauseAll" | "paused(uint8)" | "paused()" | "pauserRegistry" | "payForRange" | "registerOperatorToAVS" | "registeredOperators" | "renounceOwnership" | "setPauserRegistry" | "setup" | "stakeRegistry" | "taskCompleted" | "taskCreationMetadata" | "transferOwnership" | "unpause" | "updateAVSMetadataURI" | "updateOperatorMetadata" | "updateTaskCreationMetadata" | "whitelistAddressAsOperator" | "whitelistedOperators"): FunctionFragment;
+    encodeFunctionData(functionFragment: "admins", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "allTaskHashes", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "avsDirectory", values?: undefined): string;
+    encodeFunctionData(functionFragment: "checkSignerAddress", values: [IReclaimServiceManager.ClaimRequestStruct, BytesLike]): string;
+    encodeFunctionData(functionFragment: "createNewTask", values: [IReclaimServiceManager.ClaimRequestStruct, BytesLike]): string;
+    encodeFunctionData(functionFragment: "deregisterOperatorFromAVS", values: [string]): string;
+    encodeFunctionData(functionFragment: "encodeClaimRequest", values: [IReclaimServiceManager.ClaimRequestStruct]): string;
+    encodeFunctionData(functionFragment: "getMetadataForOperator", values: [string]): string;
+    encodeFunctionData(functionFragment: "getOperatorRestakedStrategies", values: [string]): string;
+    encodeFunctionData(functionFragment: "getRestakeableStrategies", values?: undefined): string;
+    encodeFunctionData(functionFragment: "isAdmin", values: [string]): string;
+    encodeFunctionData(functionFragment: "isOperatorWhitelisted", values: [string]): string;
+    encodeFunctionData(functionFragment: "latestTaskNum", values?: undefined): string;
+    encodeFunctionData(functionFragment: "operatorHasMinimumWeight", values: [string]): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pause", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "pauseAll", values?: undefined): string;
+    encodeFunctionData(functionFragment: "paused(uint8)", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "paused()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pauserRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "payForRange", values: [IPaymentCoordinator.RangePaymentStruct[]]): string;
+    encodeFunctionData(functionFragment: "registerOperatorToAVS", values: [string, ISignatureUtils.SignatureWithSaltAndExpiryStruct]): string;
+    encodeFunctionData(functionFragment: "registeredOperators", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setPauserRegistry", values: [string]): string;
+    encodeFunctionData(functionFragment: "setup", values: [string]): string;
+    encodeFunctionData(functionFragment: "stakeRegistry", values?: undefined): string;
+    encodeFunctionData(functionFragment: "taskCompleted", values: [IReclaimServiceManager.CompletedTaskStruct, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "taskCreationMetadata", values?: undefined): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
+    encodeFunctionData(functionFragment: "unpause", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "updateAVSMetadataURI", values: [string]): string;
+    encodeFunctionData(functionFragment: "updateOperatorMetadata", values: [IReclaimServiceManager.OperatorMetadataStruct]): string;
+    encodeFunctionData(functionFragment: "updateTaskCreationMetadata", values: [IReclaimServiceManager.TaskCreationMetadataStruct]): string;
+    encodeFunctionData(functionFragment: "whitelistAddressAsOperator", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "whitelistedOperators", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "admins", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "allTaskHashes", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "avsDirectory", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "checkSignerAddress", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "createNewTask", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "deregisterOperatorFromAVS", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "encodeClaimRequest", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getMetadataForOperator", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getOperatorRestakedStrategies", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRestakeableStrategies", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isAdmin", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isOperatorWhitelisted", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "latestTaskNum", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "operatorHasMinimumWeight", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pauseAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "paused(uint8)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "paused()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pauserRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "payForRange", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "registerOperatorToAVS", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "registeredOperators", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPauserRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setup", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stakeRegistry", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "taskCompleted", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "taskCreationMetadata", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateAVSMetadataURI", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateOperatorMetadata", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateTaskCreationMetadata", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "whitelistAddressAsOperator", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "whitelistedOperators", data: BytesLike): Result;
+    events: {
+        "Initialized(uint8)": EventFragment;
+        "NewTaskCreated(uint32,((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256))": EventFragment;
+        "OwnershipTransferred(address,address)": EventFragment;
+        "Paused(address,uint256)": EventFragment;
+        "PauserRegistrySet(address,address)": EventFragment;
+        "TaskCompleted(uint32,(((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256),bytes[]))": EventFragment;
+        "Unpaused(address,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "NewTaskCreated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "PauserRegistrySet"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TaskCompleted"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
+}
+export interface InitializedEventObject {
+    version: number;
+}
+export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+export interface NewTaskCreatedEventObject {
+    taskIndex: number;
+    task: IReclaimServiceManager.TaskStructOutput;
+}
+export type NewTaskCreatedEvent = TypedEvent<[
+    number,
+    IReclaimServiceManager.TaskStructOutput
+], NewTaskCreatedEventObject>;
+export type NewTaskCreatedEventFilter = TypedEventFilter<NewTaskCreatedEvent>;
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface PausedEventObject {
+    account: string;
+    newPausedStatus: BigNumber;
+}
+export type PausedEvent = TypedEvent<[string, BigNumber], PausedEventObject>;
+export type PausedEventFilter = TypedEventFilter<PausedEvent>;
+export interface PauserRegistrySetEventObject {
+    pauserRegistry: string;
+    newPauserRegistry: string;
+}
+export type PauserRegistrySetEvent = TypedEvent<[
+    string,
+    string
+], PauserRegistrySetEventObject>;
+export type PauserRegistrySetEventFilter = TypedEventFilter<PauserRegistrySetEvent>;
+export interface TaskCompletedEventObject {
+    taskIndex: number;
+    task: IReclaimServiceManager.CompletedTaskStructOutput;
+}
+export type TaskCompletedEvent = TypedEvent<[
+    number,
+    IReclaimServiceManager.CompletedTaskStructOutput
+], TaskCompletedEventObject>;
+export type TaskCompletedEventFilter = TypedEventFilter<TaskCompletedEvent>;
+export interface UnpausedEventObject {
+    account: string;
+    newPausedStatus: BigNumber;
+}
+export type UnpausedEvent = TypedEvent<[
+    string,
+    BigNumber
+], UnpausedEventObject>;
+export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;
+export interface ReclaimServiceManager extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: ReclaimServiceManagerInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        avsDirectory(overrides?: CallOverrides): Promise<[string]>;
+        checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<[string]>;
+        createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        deregisterOperatorFromAVS(operator: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<[string]>;
+        getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<[IReclaimServiceManager.OperatorMetadataStructOutput]>;
+        getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<[string[]]>;
+        getRestakeableStrategies(overrides?: CallOverrides): Promise<[string[]]>;
+        isAdmin(_admin: string, overrides?: CallOverrides): Promise<[boolean]>;
+        isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<[boolean]>;
+        latestTaskNum(overrides?: CallOverrides): Promise<[number]>;
+        operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<[boolean]>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        pause(newPausedStatus: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        pauseAll(overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>;
+        "paused()"(overrides?: CallOverrides): Promise<[BigNumber]>;
+        pauserRegistry(overrides?: CallOverrides): Promise<[string]>;
+        payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
+            addr: string;
+            url: string;
+        }>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setPauserRegistry(newPauserRegistry: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setup(initialAdmin: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        stakeRegistry(overrides?: CallOverrides): Promise<[string]>;
+        taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        taskCreationMetadata(overrides?: CallOverrides): Promise<[
+            number,
+            number,
+            number
+        ] & {
+            maxTaskLifetimeS: number;
+            minSignaturesPerTask: number;
+            maxTaskCreationDelayS: number;
+        }>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        unpause(newPausedStatus: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        updateAVSMetadataURI(_metadataURI: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+    };
+    admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    avsDirectory(overrides?: CallOverrides): Promise<string>;
+    checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<string>;
+    createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    deregisterOperatorFromAVS(operator: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<string>;
+    getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<IReclaimServiceManager.OperatorMetadataStructOutput>;
+    getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<string[]>;
+    getRestakeableStrategies(overrides?: CallOverrides): Promise<string[]>;
+    isAdmin(_admin: string, overrides?: CallOverrides): Promise<boolean>;
+    isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<boolean>;
+    latestTaskNum(overrides?: CallOverrides): Promise<number>;
+    operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<boolean>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    pause(newPausedStatus: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    pauseAll(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+    "paused()"(overrides?: CallOverrides): Promise<BigNumber>;
+    pauserRegistry(overrides?: CallOverrides): Promise<string>;
+    payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
+        addr: string;
+        url: string;
+    }>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setPauserRegistry(newPauserRegistry: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setup(initialAdmin: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    stakeRegistry(overrides?: CallOverrides): Promise<string>;
+    taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    taskCreationMetadata(overrides?: CallOverrides): Promise<[
+        number,
+        number,
+        number
+    ] & {
+        maxTaskLifetimeS: number;
+        minSignaturesPerTask: number;
+        maxTaskCreationDelayS: number;
+    }>;
+    transferOwnership(newOwner: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    unpause(newPausedStatus: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    updateAVSMetadataURI(_metadataURI: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        avsDirectory(overrides?: CallOverrides): Promise<string>;
+        checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<string>;
+        createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<void>;
+        deregisterOperatorFromAVS(operator: string, overrides?: CallOverrides): Promise<void>;
+        encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<string>;
+        getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<IReclaimServiceManager.OperatorMetadataStructOutput>;
+        getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<string[]>;
+        getRestakeableStrategies(overrides?: CallOverrides): Promise<string[]>;
+        isAdmin(_admin: string, overrides?: CallOverrides): Promise<boolean>;
+        isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<boolean>;
+        latestTaskNum(overrides?: CallOverrides): Promise<number>;
+        operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<boolean>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        pause(newPausedStatus: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        pauseAll(overrides?: CallOverrides): Promise<void>;
+        "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+        "paused()"(overrides?: CallOverrides): Promise<BigNumber>;
+        pauserRegistry(overrides?: CallOverrides): Promise<string>;
+        payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: CallOverrides): Promise<void>;
+        registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: CallOverrides): Promise<void>;
+        registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
+            addr: string;
+            url: string;
+        }>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        setPauserRegistry(newPauserRegistry: string, overrides?: CallOverrides): Promise<void>;
+        setup(initialAdmin: string, overrides?: CallOverrides): Promise<void>;
+        stakeRegistry(overrides?: CallOverrides): Promise<string>;
+        taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        taskCreationMetadata(overrides?: CallOverrides): Promise<[
+            number,
+            number,
+            number
+        ] & {
+            maxTaskLifetimeS: number;
+            minSignaturesPerTask: number;
+            maxTaskCreationDelayS: number;
+        }>;
+        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
+        unpause(newPausedStatus: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        updateAVSMetadataURI(_metadataURI: string, overrides?: CallOverrides): Promise<void>;
+        updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: CallOverrides): Promise<void>;
+        updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: CallOverrides): Promise<void>;
+        whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: CallOverrides): Promise<void>;
+        whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
+        "NewTaskCreated(uint32,((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256))"(taskIndex?: BigNumberish | null, task?: null): NewTaskCreatedEventFilter;
+        NewTaskCreated(taskIndex?: BigNumberish | null, task?: null): NewTaskCreatedEventFilter;
+        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
+        "Paused(address,uint256)"(account?: string | null, newPausedStatus?: null): PausedEventFilter;
+        Paused(account?: string | null, newPausedStatus?: null): PausedEventFilter;
+        "PauserRegistrySet(address,address)"(pauserRegistry?: null, newPauserRegistry?: null): PauserRegistrySetEventFilter;
+        PauserRegistrySet(pauserRegistry?: null, newPauserRegistry?: null): PauserRegistrySetEventFilter;
+        "TaskCompleted(uint32,(((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256),bytes[]))"(taskIndex?: BigNumberish | null, task?: null): TaskCompletedEventFilter;
+        TaskCompleted(taskIndex?: BigNumberish | null, task?: null): TaskCompletedEventFilter;
+        "Unpaused(address,uint256)"(account?: string | null, newPausedStatus?: null): UnpausedEventFilter;
+        Unpaused(account?: string | null, newPausedStatus?: null): UnpausedEventFilter;
+    };
+    estimateGas: {
+        admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        avsDirectory(overrides?: CallOverrides): Promise<BigNumber>;
+        checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        deregisterOperatorFromAVS(operator: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<BigNumber>;
+        getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<BigNumber>;
+        getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<BigNumber>;
+        getRestakeableStrategies(overrides?: CallOverrides): Promise<BigNumber>;
+        isAdmin(_admin: string, overrides?: CallOverrides): Promise<BigNumber>;
+        isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<BigNumber>;
+        latestTaskNum(overrides?: CallOverrides): Promise<BigNumber>;
+        operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        pause(newPausedStatus: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        pauseAll(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        "paused()"(overrides?: CallOverrides): Promise<BigNumber>;
+        pauserRegistry(overrides?: CallOverrides): Promise<BigNumber>;
+        payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setPauserRegistry(newPauserRegistry: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setup(initialAdmin: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        stakeRegistry(overrides?: CallOverrides): Promise<BigNumber>;
+        taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        taskCreationMetadata(overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        unpause(newPausedStatus: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        updateAVSMetadataURI(_metadataURI: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        avsDirectory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        deregisterOperatorFromAVS(operator: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getRestakeableStrategies(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isAdmin(_admin: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        latestTaskNum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pause(newPausedStatus: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        pauseAll(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "paused()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pauserRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setPauserRegistry(newPauserRegistry: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setup(initialAdmin: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        stakeRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        taskCreationMetadata(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        unpause(newPausedStatus: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        updateAVSMetadataURI(_metadataURI: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}