Interface ERC721Interface

interface ERC721Interface {
    deploy: ConstructorFragment;
    fallback: null | FallbackFragment;
    fragments: readonly Fragment[];
    receive: boolean;
    _decodeParams(params: readonly ParamType[], data: BytesLike): Result;
    _encodeParams(params: readonly ParamType[], values: readonly any[]): string;
    decodeErrorResult(fragment: string | ErrorFragment, data: BytesLike): Result;
    decodeEventLog(fragment: string | EventFragment, data: BytesLike, topics?: readonly string[]): Result;
    decodeFunctionData(fragment: string | FunctionFragment, data: BytesLike): Result;
    decodeFunctionResult(fragment: string | FunctionFragment, data: BytesLike): Result;
    encodeDeploy(values?: readonly any[]): string;
    encodeErrorResult(fragment: string | ErrorFragment, values?: readonly any[]): string;
    encodeEventLog(fragment: string | EventFragment, values: readonly any[]): {
        data: string;
        topics: string[];
    };
    encodeFilterTopics(fragment: string | EventFragment, values: readonly any[]): (null | string | string[])[];
    encodeFunctionData(fragment: string | FunctionFragment, values?: readonly any[]): string;
    encodeFunctionResult(fragment: string | FunctionFragment, values?: readonly any[]): string;
    forEachError(callback: ((func: ErrorFragment, index: number) => void)): void;
    forEachEvent(callback: ((func: EventFragment, index: number) => void)): void;
    forEachFunction(callback: ((func: FunctionFragment, index: number) => void)): void;
    format(minimal?: boolean): string[];
    formatJson(): string;
    getAbiCoder(): AbiCoder;
    getError(key: string, values?: any[]): null | ErrorFragment;
    getEvent(key: string, values?: any[]): null | EventFragment;
    getEventName(key: string): string;
    getFunction(key: string, values?: any[]): null | FunctionFragment;
    getFunctionName(key: string): string;
    hasEvent(key: string): boolean;
    hasFunction(key: string): boolean;
    makeError(_data: BytesLike, tx: CallExceptionTransaction): CallExceptionError;
    parseCallResult(data: BytesLike): Result;
    parseError(data: BytesLike): null | ErrorDescription;
    parseLog(log: {
        data: string;
        topics: readonly string[];
    }): null | LogDescription;
    parseTransaction(tx: {
        data: string;
        value?: BigNumberish;
    }): null | TransactionDescription;
}

Hierarchy

  • Interface
    • ERC721Interface

Properties

deploy fallback fragments receive

Methods

_decodeParams _encodeParams decodeErrorResult decodeEventLog decodeFunctionData decodeFunctionResult encodeDeploy encodeErrorResult encodeEventLog encodeFilterTopics encodeFunctionData encodeFunctionResult forEachError forEachEvent forEachFunction format formatJson getAbiCoder getError getEvent getEventName getFunction getFunctionName hasEvent hasFunction makeError parseCallResult parseError parseLog parseTransaction

Properties

Readonlydeploy

deploy: ConstructorFragment

The Contract constructor.

Readonlyfallback

fallback: null | FallbackFragment

The Fallback method, if any.

Readonlyfragments

fragments: readonly Fragment[]

All the Contract ABI members (i.e. methods, events, errors, etc).

Readonlyreceive

receive: boolean

If receiving ether is supported.

Methods

_decodeParams

  • _decodeParams(params, data): Result

  • Parameters

    • params: readonly ParamType[]
    • data: BytesLike

    Returns Result

_encodeParams

  • _encodeParams(params, values): string

  • Parameters

    • params: readonly ParamType[]
    • values: readonly any[]

    Returns string

decodeErrorResult

  • decodeErrorResult(fragment, data): Result

  • Decodes the result %%data%% (e.g. from an eth_call) for the specified error (see [[getError]] for valid values for %%key%%).

    Most developers should prefer the [[parseCallResult]] method instead, which will automatically detect a CALL_EXCEPTION and throw the corresponding error.

    Parameters

    • fragment: string | ErrorFragment
    • data: BytesLike

    Returns Result

decodeEventLog

  • decodeEventLog(fragment, data, topics?): Result

  • Parameters

    • fragment: string | EventFragment
    • data: BytesLike
    • Optionaltopics: readonly string[]

    Returns Result

decodeFunctionData

  • decodeFunctionData(fragment, data): Result

  • Decodes the %%data%% from a transaction tx.data for the function specified (see [[getFunction]] for valid values for %%fragment%%).

    Most developers should prefer the [[parseTransaction]] method instead, which will automatically detect the fragment.

    Parameters

    • fragment: string | FunctionFragment
    • data: BytesLike

    Returns Result

decodeFunctionResult

  • decodeFunctionResult(fragment, data): Result

  • Decodes the result %%data%% (e.g. from an eth_call) for the specified function (see [[getFunction]] for valid values for %%key%%).

    Most developers should prefer the [[parseCallResult]] method instead, which will automatically detect a CALL_EXCEPTION and throw the corresponding error.

    Parameters

    • fragment: string | FunctionFragment
    • data: BytesLike

    Returns Result

encodeDeploy

  • encodeDeploy(values?): string

  • Encodes a tx.data object for deploying the Contract with the %%values%% as the constructor arguments.

    Parameters

    • Optionalvalues: readonly any[]

    Returns string

encodeErrorResult

  • encodeErrorResult(fragment, values?): string

  • Encodes the transaction revert data for a call result that reverted from the the Contract with the sepcified %%error%% (see [[getError]] for valid values for %%fragment%%) with the %%values%%.

    This is generally not used by most developers, unless trying to mock a result from a Contract.

    Parameters

    • fragment: string | ErrorFragment
    • Optionalvalues: readonly any[]

    Returns string

encodeEventLog

  • encodeEventLog(fragment, values): {
        data: string;
        topics: string[];
    }

  • Parameters

    • fragment: string | EventFragment
    • values: readonly any[]

    Returns {
        data: string;
        topics: string[];
    }

    • data: string
    • topics: string[]

encodeFilterTopics

  • encodeFilterTopics(fragment, values): (null | string | string[])[]

  • Parameters

    • fragment: string | EventFragment
    • values: readonly any[]

    Returns (null | string | string[])[]

encodeFunctionData

  • encodeFunctionData(fragment, values?): string

  • Encodes the tx.data for a transaction that calls the function specified (see [[getFunction]] for valid values for %%fragment%%) with the %%values%%.

    Parameters

    • fragment: string | FunctionFragment
    • Optionalvalues: readonly any[]

    Returns string

encodeFunctionResult

  • encodeFunctionResult(fragment, values?): string

  • Encodes the result data (e.g. from an eth_call) for the specified function (see [[getFunction]] for valid values for %%fragment%%) with %%values%%.

    This is generally not used by most developers, unless trying to mock a result from a Contract.

    Parameters

    • fragment: string | FunctionFragment
    • Optionalvalues: readonly any[]

    Returns string

forEachError

  • forEachError(callback): void

  • Iterate over all errors, calling %%callback%%, sorted by their name.

    Parameters

    • callback: ((func: ErrorFragment, index: number) => void)
        • (func, index): void

        • Parameters

          • func: ErrorFragment
          • index: number

          Returns void

    Returns void

forEachEvent

  • forEachEvent(callback): void

  • Iterate over all events, calling %%callback%%, sorted by their name.

    Parameters

    • callback: ((func: EventFragment, index: number) => void)
        • (func, index): void

        • Parameters

          • func: EventFragment
          • index: number

          Returns void

    Returns void

forEachFunction

  • forEachFunction(callback): void

  • Iterate over all functions, calling %%callback%%, sorted by their name.

    Parameters

    • callback: ((func: FunctionFragment, index: number) => void)
        • (func, index): void

        • Parameters

          • func: FunctionFragment
          • index: number

          Returns void

    Returns void

format

  • format(minimal?): string[]

  • Returns the entire Human-Readable ABI, as an array of signatures, optionally as %%minimal%% strings, which removes parameter names and unneceesary spaces.

    Parameters

    • Optionalminimal: boolean

    Returns string[]

formatJson

  • formatJson(): string

  • Return the JSON-encoded ABI. This is the format Solidiy returns.

    Returns string

getAbiCoder

  • getAbiCoder(): AbiCoder

  • The ABI coder that will be used to encode and decode binary data.

    Returns AbiCoder

getError

  • getError(key, values?): null | ErrorFragment

  • Get the [[ErrorFragment]] for %%key%%, which may be an error selector, error name or error signature that belongs to the ABI.

    If %%values%% is provided, it will use the Typed API to handle ambiguous cases where multiple errors match by name.

    If the %%key%% and %%values%% do not refine to a single error in the ABI, this will throw.

    Parameters

    • key: string
    • Optionalvalues: any[]

    Returns null | ErrorFragment

getEvent

  • getEvent(key, values?): null | EventFragment

  • Get the [[EventFragment]] for %%key%%, which may be a topic hash, event name or event signature that belongs to the ABI.

    If %%values%% is provided, it will use the Typed API to handle ambiguous cases where multiple events match by name.

    If the %%key%% and %%values%% do not refine to a single event in the ABI, this will throw.

    Parameters

    • key: string
    • Optionalvalues: any[]

    Returns null | EventFragment

getEventName

  • getEventName(key): string

  • Get the event name for %%key%%, which may be a topic hash, event name or event signature that belongs to the ABI.

    Parameters

    • key: string

    Returns string

getFunction

  • getFunction(key, values?): null | FunctionFragment

  • Get the [[FunctionFragment]] for %%key%%, which may be a function selector, function name or function signature that belongs to the ABI.

    If %%values%% is provided, it will use the Typed API to handle ambiguous cases where multiple functions match by name.

    If the %%key%% and %%values%% do not refine to a single function in the ABI, this will throw.

    Parameters

    • key: string
    • Optionalvalues: any[]

    Returns null | FunctionFragment

getFunctionName

  • getFunctionName(key): string

  • Get the function name for %%key%%, which may be a function selector, function name or function signature that belongs to the ABI.

    Parameters

    • key: string

    Returns string

hasEvent

  • hasEvent(key): boolean

  • Returns true if %%key%% (an event topic hash, event name or event signature) is present in the ABI.

    In the case of an event name, the name may be ambiguous, so accessing the [[EventFragment]] may require refinement.

    Parameters

    • key: string

    Returns boolean

hasFunction

  • hasFunction(key): boolean

  • Returns true if %%key%% (a function selector, function name or function signature) is present in the ABI.

    In the case of a function name, the name may be ambiguous, so accessing the [[FunctionFragment]] may require refinement.

    Parameters

    • key: string

    Returns boolean

makeError

  • makeError(_data, tx): CallExceptionError

  • Parameters

    • _data: BytesLike
    • tx: CallExceptionTransaction

    Returns CallExceptionError

parseCallResult

  • parseCallResult(data): Result

  • Parameters

    • data: BytesLike

    Returns Result

parseError

  • parseError(data): null | ErrorDescription

  • Parses a revert data, finding the matching error and extracts the parameter values along with other useful error details.

    If the matching error cannot be found, returns null.

    Parameters

    • data: BytesLike

    Returns null | ErrorDescription

parseLog

  • parseLog(log): null | LogDescription

  • Parses a receipt log, finding the matching event and extracts the parameter values along with other useful event details.

    If the matching event cannot be found, returns null.

    Parameters

    • log: {
          data: string;
          topics: readonly string[];
      }
      • data: string
      • topics: readonly string[]

    Returns null | LogDescription

parseTransaction

  • parseTransaction(tx): null | TransactionDescription

  • Parses a transaction, finding the matching function and extracts the parameter values along with other useful function details.

    If the matching function cannot be found, return null.

    Parameters

    • tx: {
          data: string;
          value?: BigNumberish;
      }
      • data: string
      • Optionalvalue?: BigNumberish

    Returns null | TransactionDescription

Settings

Member Visibility

On This Page

deployfallbackfragmentsreceive_decodeParams_encodeParamsdecodeErrorResultdecodeEventLogdecodeFunctionDatadecodeFunctionResultencodeDeployencodeErrorResultencodeEventLogencodeFilterTopicsencodeFunctionDataencodeFunctionResultforEachErrorforEachEventforEachFunctionformatformatJsongetAbiCodergetErrorgetEventgetEventNamegetFunctiongetFunctionNamehasEventhasFunctionmakeErrorparseCallResultparseErrorparseLogparseTransaction