Interface TaskConnectorContract

interface TaskConnectorContract {
    "[internal]": any;
    fallback: null | WrappedFallback;
    filters: Record<string, ContractEvent<any[]>>;
    interface: Interface;
    runner: null | ContractRunner;
    target: string | Addressable;
    addListener(
        event: ContractEventName,
        listener: Listener,
    ): Promise<TaskConnectorContract>;
    attach(target: string | Addressable): BaseContract;
    connect(runner: null | ContractRunner): BaseContract;
    deploymentTransaction(): null | ContractTransactionResponse;
    emit(event: ContractEventName, ...args: any[]): Promise<boolean>;
    execute(
        data: string,
        target: string,
        value: BigNumberish,
    ): Promise<
        {
            wait(): Promise<
                {
                    events: {
                        args: { success: boolean; taskId: BigNumberish };
                        event: string;
                    }[];
                },
            >;
        },
    >;
    getAddress(): Promise<string>;
    getDeployedCode(): Promise<null | string>;
    getEvent(key: string | EventFragment): ContractEvent;
    getFunction<
        T extends
            ContractMethod<any[], any, any> = ContractMethod<any[], any, any>,
    >(
        key: string | FunctionFragment,
    ): T;
    listenerCount(event?: ContractEventName): Promise<number>;
    listeners(event?: ContractEventName): Promise<Listener[]>;
    off(
        event: ContractEventName,
        listener?: Listener,
    ): Promise<TaskConnectorContract>;
    on(
        event: ContractEventName,
        listener: Listener,
    ): Promise<TaskConnectorContract>;
    once(
        event: ContractEventName,
        listener: Listener,
    ): Promise<TaskConnectorContract>;
    queryFilter(
        event: ContractEventName,
        fromBlock?: BlockTag,
        toBlock?: BlockTag,
    ): Promise<(EventLog | Log)[]>;
    queryTransaction(hash: string): Promise<EventLog[]>;
    removeAllListeners(
        event?: ContractEventName,
    ): Promise<TaskConnectorContract>;
    removeListener(
        event: ContractEventName,
        listener: Listener,
    ): Promise<TaskConnectorContract>;
    waitForDeployment(): Promise<TaskConnectorContract>;
}

Hierarchy

  • BaseContract
    • TaskConnectorContract

Properties

[internal] fallback filters interface runner target

Methods

addListener attach connect deploymentTransaction emit execute getAddress getDeployedCode getEvent getFunction listenerCount listeners off on once queryFilter queryTransaction removeAllListeners removeListener waitForDeployment

Properties

Readonly[internal]

"[internal]": any

@_ignore:

Readonlyfallback

fallback: null | WrappedFallback

The fallback or receive function if any.

Readonlyfilters

filters: Record<string, ContractEvent<any[]>>

All the Events available on this contract.

Readonlyinterface

interface: Interface

The contract Interface.

Readonlyrunner

runner: null | ContractRunner

The connected runner. This is generally a [[Provider]] or a [[Signer]], which dictates what operations are supported.

For example, a Contract connected to a [[Provider]] may only execute read-only operations.

Readonlytarget

target: string | Addressable

The target to connect to.

This can be an address, ENS name or any [[Addressable]], such as another contract. To get the resovled address, use the getAddress method.

Methods

addListener

  • addListener(
        event: ContractEventName,
        listener: Listener,
    ): Promise<TaskConnectorContract>

    Alias for [on].

    Parameters

    • event: ContractEventName
    • listener: Listener

    Returns Promise<TaskConnectorContract>

attach

  • attach(target: string | Addressable): BaseContract

    Return a new Contract instance with the same ABI and runner, but a different %%target%%.

    Parameters

    • target: string | Addressable

    Returns BaseContract

connect

  • connect(runner: null | ContractRunner): BaseContract

    Return a new Contract instance with the same target and ABI, but a different %%runner%%.

    Parameters

    • runner: null | ContractRunner

    Returns BaseContract

deploymentTransaction

  • deploymentTransaction(): null | ContractTransactionResponse

    Return the transaction used to deploy this contract.

    This is only available if this instance was returned from a [[ContractFactory]].

    Returns null | ContractTransactionResponse

emit

  • emit(event: ContractEventName, ...args: any[]): Promise<boolean>

    Emit an %%event%% calling all listeners with %%args%%.

    Resolves to true if any listeners were called.

    Parameters

    • event: ContractEventName
    • ...args: any[]

    Returns Promise<boolean>

execute

  • execute(
        data: string,
        target: string,
        value: BigNumberish,
    ): Promise<
        {
            wait(): Promise<
                {
                    events: {
                        args: { success: boolean; taskId: BigNumberish };
                        event: string;
                    }[];
                },
            >;
        },
    >

    Parameters

    • data: string
    • target: string
    • value: BigNumberish

    Returns Promise<
        {
            wait(): Promise<
                {
                    events: {
                        args: { success: boolean; taskId: BigNumberish };
                        event: string;
                    }[];
                },
            >;
        },
    >

getAddress

  • getAddress(): Promise<string>

    Return the resolved address of this Contract.

    Returns Promise<string>

getDeployedCode

  • getDeployedCode(): Promise<null | string>

    Return the deployed bytecode or null if no bytecode is found.

    Returns Promise<null | string>

getEvent

  • getEvent(key: string | EventFragment): ContractEvent

    Return the event for a given name. This is useful when a contract event name conflicts with a JavaScript name such as prototype or when using a Contract programatically.

    Parameters

    • key: string | EventFragment

    Returns ContractEvent

getFunction

  • getFunction<
        T extends
            ContractMethod<any[], any, any> = ContractMethod<any[], any, any>,
    >(
        key: string | FunctionFragment,
    ): T

    Return the function for a given name. This is useful when a contract method name conflicts with a JavaScript name such as prototype or when using a Contract programatically.

    Type Parameters

    • T extends ContractMethod<any[], any, any> = ContractMethod<any[], any, any>

    Parameters

    • key: string | FunctionFragment

    Returns T

listenerCount

  • listenerCount(event?: ContractEventName): Promise<number>

    Resolves to the number of listeners of %%event%% or the total number of listeners if unspecified.

    Parameters

    • Optionalevent: ContractEventName

    Returns Promise<number>

listeners

  • listeners(event?: ContractEventName): Promise<Listener[]>

    Resolves to the listeners subscribed to %%event%% or all listeners if unspecified.

    Parameters

    • Optionalevent: ContractEventName

    Returns Promise<Listener[]>

off

  • off(
        event: ContractEventName,
        listener?: Listener,
    ): Promise<TaskConnectorContract>

    Remove the %%listener%% from the listeners for %%event%% or remove all listeners if unspecified.

    Parameters

    • event: ContractEventName
    • Optionallistener: Listener

    Returns Promise<TaskConnectorContract>

on

  • on(event: ContractEventName, listener: Listener): Promise<TaskConnectorContract>

    Add an event %%listener%% for the %%event%%.

    Parameters

    • event: ContractEventName
    • listener: Listener

    Returns Promise<TaskConnectorContract>

once

  • once(
        event: ContractEventName,
        listener: Listener,
    ): Promise<TaskConnectorContract>

    Add an event %%listener%% for the %%event%%, but remove the listener after it is fired once.

    Parameters

    • event: ContractEventName
    • listener: Listener

    Returns Promise<TaskConnectorContract>

queryFilter

  • queryFilter(
        event: ContractEventName,
        fromBlock?: BlockTag,
        toBlock?: BlockTag,
    ): Promise<(EventLog | Log)[]>

    Provide historic access to event data for %%event%% in the range %%fromBlock%% (default: 0) to %%toBlock%% (default: "latest") inclusive.

    Parameters

    • event: ContractEventName
    • OptionalfromBlock: BlockTag
    • OptionaltoBlock: BlockTag

    Returns Promise<(EventLog | Log)[]>

queryTransaction

  • queryTransaction(hash: string): Promise<EventLog[]>

    @_ignore:

    Parameters

    • hash: string

    Returns Promise<EventLog[]>

removeAllListeners

  • removeAllListeners(event?: ContractEventName): Promise<TaskConnectorContract>

    Remove all the listeners for %%event%% or remove all listeners if unspecified.

    Parameters

    • Optionalevent: ContractEventName

    Returns Promise<TaskConnectorContract>

removeListener

  • removeListener(
        event: ContractEventName,
        listener: Listener,
    ): Promise<TaskConnectorContract>

    Alias for [off].

    Parameters

    • event: ContractEventName
    • listener: Listener

    Returns Promise<TaskConnectorContract>

waitForDeployment

  • waitForDeployment(): Promise<TaskConnectorContract>

    Resolve to this Contract once the bytecode has been deployed, or resolve immediately if already deployed.

    Returns Promise<TaskConnectorContract>

Settings

Member Visibility

On This Page

Properties
Methods