types.ts

import type BN from "bn.js";
import type Big from "big.js";

import type * as Abi from "@truffle/abi-utils";
import type * as Types from "@truffle/codec/format/types";
import type * as Values from "@truffle/codec/format/values";
import type { PaddingMode } from "@truffle/codec/common";

/**
 * A type representing a transaction (calldata) decoding.  As you can see, these come in five types,
 * each of which is documented separately.
 * @Category Output
 */
export type CalldataDecoding =
  | FunctionDecoding
  | ConstructorDecoding
  | MessageDecoding
  | UnknownCallDecoding
  | UnknownCreationDecoding;

/**
 * A type representing a log (event) decoding.  As you can see, these come in two types, each of which
 * is documented separately.
 * @Category Output
 */
export type LogDecoding = EventDecoding | AnonymousDecoding;

/**
 * A type representing a returndata (return value or revert message) decoding.
 * As you can see, these come in six types, each of which is documented
 * separately.
 * @Category Output
 */
export type ReturndataDecoding =
  | ReturnDecoding
  | RawReturnDecoding
  | BytecodeDecoding
  | UnknownBytecodeDecoding
  | SelfDestructDecoding
  | RevertMessageDecoding
  | EmptyFailureDecoding;

/**
 * This is a type for recording what decoding mode a given decoding was produced in.  There are two
 * decoding modes, full mode and ABI mode.  In ABI mode, decoding is done purely based on the ABI JSON.
 * Full mode, by contrast, additionally uses AST information to produce a more informative decoding.
 * For more on full mode and ABI mode, see the notes on [Decoding modes](../#decoding-modes).
 * @Category Output
 */
export type DecodingMode = "full" | "abi";

/**
 * Used for representing decoded state variables.
 * @category Output
 */
export interface StateVariable {
  /**
   * The name of the variable.  Note that due to inheritance, this may not be unique
   * among the contract's state variables.
   */
  name: string;
  /**
   * The class of the contract that defined the variable, as a Format.Types.ContractType.
   * Note that this class may differ from that of the contract being decoded, due
   * to inheritance.
   */
  class: Types.ContractType;
  /**
   * The decoded value of the variable.  Note this is a Format.Values.Result, so it may be an error.
   */
  value: Values.Result;
}

/**
 * This type represents a transaction decoding for an ordinary function call to a known class;
 * not a constructor call, not a fallback call.
 * @Category Output
 */
export interface FunctionDecoding {
  /**
   * The kind of decoding; indicates that this is a FunctionDecoding.
   */
  kind: "function";
  /**
   * The class of contract that was called, as a Format.Types.ContractType.
   */
  class: Types.ContractType;
  /**
   * The list of decoded arguments to the function.
   */
  arguments: AbiArgument[];
  /**
   * The ABI entry for the function that was called.  You can use this
   * to extract the name, for instance.
   */
  abi: Abi.FunctionEntry;
  /**
   * The selector for the function that was called, as a hexadecimal string.
   */
  selector: string;
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   */
  interpretations: {
    /**
     * If this interpretation is present, indicates that the transaction can be
     * understood as a multicall (v1).  The field contains decodings for the
     * individual calls that the multicall can be broken into.  Note that in
     * case of an error, individual decodings will be returned as null, so be
     * sure to check for this.
     */
    multicall?: (CalldataDecoding | null)[];
    /**
     * If this interpretation is present, indicates that the transaction can be
     * understood as an `aggregate` (from multicallv2).  This also includes
     * `blockAndAggregate`.  See [[CallInterpretationInfo]] for more
     * information.
     */
    aggregate?: CallInterpretationInfo[];
    /**
     * Similar to the `aggregate` interpretation, but for `tryAggregate`.  Also
     * includes `tryBlockAndAggregate`.
     */
    tryAggregate?: TryAggregateInfo;
    /**
     * Similar to `multicall`, but for Uniswap's deadlined multicall.
     */
    deadlinedMulticall?: DeadlinedMulticallInfo;
    /**
     * Similar to `multicall`, but for Uniswap's multicall with previous block hash.
     */
    specifiedBlockhashMulticall?: BlockhashedMulticallInfo;
  };
}

/**
 * This type represents a transaction decoding for a constructor call.
 * It's even possible to decode a library constructor call with this.
 *
 * NOTE: In the future, this type will also contain information about
 * any linked libraries the contract being constructed uses.  However,
 * this is not implemented at present.
 *
 * @Category Output
 */
export interface ConstructorDecoding {
  /**
   * The kind of decoding; indicates that this is a ConstructorDecoding.
   */
  kind: "constructor";
  /**
   * The class of contract being constructed, as a Format.Types.ContractType.
   */
  class: Types.ContractType;
  /**
   * The list of decoded arguments to the constructor.  This will be empty for a
   * default constructor.
   */
  arguments: AbiArgument[];
  /**
   * The ABI entry for the constructor that was called.  Note that although
   * default constructors don't actually get an ABI entry, we still return an
   * ABI entry regardless in that case.
   */
  abi: Abi.ConstructorEntry;
  /**
   * The bytecode of the constructor that was called.
   */
  bytecode: string;
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding for a call to a known class that does not appear
 * to be a function call, i.e., one that will result in the fallback function being invoked
 * if there is one.
 *
 * @Category Output
 */
export interface MessageDecoding {
  /**
   * The kind of decoding; indicates that this is a MessageDecoding.
   */
  kind: "message";
  /**
   * The class of contract that was called, as a Format.Types.ContractType.
   */
  class: Types.ContractType;
  /**
   * The ABI entry for the contract's fallback or receive function that would
   * handle this message; will be null if there is none.
   */
  abi: Abi.FallbackEntry | Abi.ReceiveEntry | null;
  /**
   * The data that was sent to the contract.
   */
  data: string;
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   */
  interpretations: {
    /**
     * If we can't recognize the function, we attempt to see if we can decode based on the
     * function selector alone using https://www.4byte.directory/ to determine possible
     * signatures.  Note these decodings will necessarily be made in ABI mode, and will
     * even be lacking names of struct members.
     *
     * This interpretation will only be present if the array is nonempty.
     */
    selectorBasedDecodings?: FunctionDecoding[];
  };
}

/**
 * This type represents a function call to an unknown class.  In this case,
 * it's simply not possible to return much information.
 *
 * @Category Output
 */
export interface UnknownCallDecoding {
  /**
   * The kind of decoding; indicates that this is an UnknownDecoding.
   */
  kind: "unknown";
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * The data that was sent to the contract.
   */
  data: string;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   */
  interpretations: {
    /**
     * If we can't recognize the function, we attempt to see if we can decode based on the
     * function selector alone using https://www.4byte.directory/ to determine possible
     * signatures.  Note these decodings will necessarily be made in ABI mode, and will
     * even be lacking names of struct members.
     *
     * This interpretation will only be present if the array is nonempty.
     */
    selectorBasedDecodings?: FunctionDecoding[];
  };
}

/**
 * This type represents a contract creation for an unknown class. In this case,
 * it's simply not possible to return much information.
 *
 * @Category Output
 */
export interface UnknownCreationDecoding {
  /**
   * The kind of decoding; indicates that this is an UnknownCreationDecoding.
   */
  kind: "create";
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * The bytecode of the contract creation.
   */
  bytecode: string;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding of a log as a non-anonymous event.
 *
 * @Category Output
 */
export interface EventDecoding {
  /**
   * The kind of decoding; indicates that this is an EventDecoding.
   */
  kind: "event";
  /**
   * The class of the contract that (according to this decoding) emitted the event, as a Format.Types.ContractType.
   * This may be a library!  When a library emits an event, the EVM records it as the calling contract
   * having emitted the event, but we decode it as if the library emitted the event, for clarity.
   * (The address of the contract the EVM thinks emitted the event can of course be found in the original log.)
   */
  class: Types.ContractType;
  /**
   * The class of the contract that (according to this decoding) defined the event, as a Format.Types.ContractType.
   * May be omitted if we can't determine it, as may occur in ABI mode.
   */
  definedIn?: Types.ContractType;
  /**
   * The list of decoded arguments to the event.
   */
  arguments: AbiArgument[];
  /**
   * The ABI entry for the event.  You can use this to extract the name, for
   * instance.
   */
  abi: Abi.EventEntry; //should be non-anonymous
  /**
   * The selector for the event, as a hexadecimal string.
   */
  selector: string;
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding of a log as an anonymous event.
 *
 * @Category Output
 */
export interface AnonymousDecoding {
  /**
   * The kind of decoding; indicates that this is an AnonymousDecoding.
   */
  kind: "anonymous";
  /**
   * The class of the contract that (according to this decoding) emitted the event, as a Format.Types.ContractType.
   * This may be a library!  When a library emits an event, the EVM records it as the calling contract
   * having emitted the event, but we decode it as if the library emitted the event, for clarity.
   * (The address of the contract the EVM thinks emitted the event can of course be found in the original log.)
   */
  class: Types.ContractType;
  /**
   * The class of the contract that (according to this decoding) defined the event, as a Format.Types.ContractType.
   * May be omitted if we can't determine it, as may occur in ABI mode.
   */
  definedIn?: Types.ContractType;
  /**
   * The list of decoded arguments to the event.
   */
  arguments: AbiArgument[];
  /**
   * The ABI entry for the event.  You can use this to extract the name, for
   * instance.
   */
  abi: Abi.EventEntry; //should be anonymous
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding of the return data as a collection of
 * return values from a successful call.
 * @Category Output
 */
export interface ReturnDecoding {
  /**
   * The kind of decoding; indicates that this is a ReturnDecoding.
   */
  kind: "return";
  /**
   * Indicates that this kind of decoding indicates a successful return.
   */
  status: true;
  /**
   * The list of decoded return values from the function.
   */
  arguments: AbiArgument[];
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding of the return data as a raw bytestring
 * (as might be returned from a fallback function).
 * @Category Output
 */
export interface RawReturnDecoding {
  /**
   * The kind of decoding; indicates that this is a RawReturnDecoding.
   */
  kind: "returnmessage";
  /**
   * Indicates that this kind of decoding indicates a successful return.
   */
  status: true;
  /**
   * The returned bytestring, as a hex string.
   */
  data: string;
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding of unexpectedly empty return data from a
 * successful call, indicating that the contract self-destructed.
 * @Category Output
 */
export interface SelfDestructDecoding {
  /**
   * The kind of decoding; indicates that this is an SelfDestructDecoding.
   */
  kind: "selfdestruct";
  /**
   * Indicates that this kind of decoding indicates a successful return.
   */
  status: true;
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding of empty return data from an unsuccessful
 * call, a reversion with no message.
 * @Category Output
 */
export interface EmptyFailureDecoding {
  /**
   * The kind of decoding; indicates that this is an EmptyFailureDecoding.
   */
  kind: "failure";
  /**
   * Indicates that this kind of decoding indicates an unsuccessful return.
   */
  status: false;
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding of the return data as a revert message.
 * For forward-compatibility, we do not assume that the revert message is
 * a string.
 * @Category Output
 */
export interface RevertMessageDecoding {
  /**
   * The kind of decoding; indicates that this is a RevertMessageDecoding.
   */
  kind: "revert";
  /**
   * The ABI entry for the error that was thrown.  You can use this
   * to extract the name, for instance.  This may be spoofed for built-in
   * types of errors.
   */
  abi: Abi.ErrorEntry;
  /**
   * The class of the contract that (according to this decoding) defined the
   * error type, as a Format.Types.ContractType.  This will be `null` if the
   * error was defined outside of the contract or it's one of the builtin
   * `Error(string)` or `Panic(uint)` types.
   * May be omitted if we can't determine it, as may occur in ABI mode.
   */
  definedIn?: Types.ContractType | null;
  /**
   * Indicates that this kind of decoding indicates an unsuccessful return.
   */
  status: false;
  /**
   * The list of decoded arguments passed to revert(); currently, this will
   * always contain just a single string.
   */
  arguments: AbiArgument[];
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding of the return data as bytecode for a known
 * class returned from a constructor.
 *
 * NOTE: In the future, this type will also contain information about
 * any linked libraries the contract being constructed uses.  However,
 * this is not implemented at present.
 *
 * @Category Output
 */
export interface BytecodeDecoding {
  /**
   * The kind of decoding; indicates that this is a BytecodeDecoding.
   */
  kind: "bytecode";
  /**
   * Indicates that this kind of decoding indicates a successful return.
   */
  status: true;
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * The class of contract being constructed, as a Format.Types.ContractType.
   */
  class: Types.ContractType;
  /**
   * Decodings for any immutable state variables the created contract contains.
   * Omitted in ABI mode.
   */
  immutables?: StateVariable[];
  /**
   * The bytecode of the contract that was created.
   */
  bytecode: string;
  /**
   * If the contract created was a library, and was compiled with Solidity
   * 0.4.20 or later, this field will be included, which gives the address of
   * the created contract (checksummed).  This field will not be included
   * otherwise!
   */
  address?: string;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoding of the return data as bytecode for an
 * unknown class returned from a constructor.
 *
 * NOTE: In the future, this type will also contain information about
 * any linked libraries the contract being constructed uses.  However,
 * this is not implemented at present.
 *
 * @Category Output
 */
export interface UnknownBytecodeDecoding {
  /**
   * The kind of decoding; indicates that this is an UnknownBytecodeDecoding.
   */
  kind: "unknownbytecode";
  /**
   * Indicates that this kind of decoding indicates a successful return.
   */
  status: true;
  /**
   * The decoding mode that was used; [see the README](../#decoding-modes) for
   * more on these.
   */
  decodingMode: DecodingMode;
  /**
   * The bytecode of the contract that was created.
   */
  bytecode: string;
  /**
   * Further information about how the decoding may be interpreted.  Note that interpretations
   * may be added by things that use @truffle/codec, such as @truffle/decoder, rather than by
   * @truffle/codec itself.  See individual interpretations for details.
   * (Currently there are none for this type.)
   */
  interpretations: {};
}

/**
 * This type represents a decoded argument passed to a transaction or event,
 * or returned from a call.
 *
 * @Category Output
 */
export interface AbiArgument {
  /**
   * The name of the parameter.  Excluded if the parameter is nameless.
   */
  name?: string; //included if parameter is named
  /**
   * Whether this is an indexed paramter.  Only included for event parameters.
   */
  indexed?: boolean; //included for event parameters
  /**
   * The decoded value of the argument.  Note that this is a [[Format.Values.Result|Format.Values.Result]], so it
   * may contain errors (although event decodings should typically not contain errors;
   * see the [[DecodedLog]] documentation for why).
   */
  value: Values.Result;
}

/**
 * @Category Requests
 */
export type DecoderRequest =
  | StorageRequest
  | CodeRequest
  | EnsPrimaryNameRequest;

/**
 * A request for storage
 *
 * @Category Requests
 */
export interface StorageRequest {
  type: "storage";
  slot: BN; //will add more fields as needed
}

/**
 * A request for code
 *
 * @Category Requests
 */
export interface CodeRequest {
  type: "code";
  address: string;
}

/**
 * A request for a (primary) ENS name
 *
 * @Category Requests
 */
export interface EnsPrimaryNameRequest {
  type: "ens-primary-name";
  address: string;
}

export interface DecoderOptions {
  paddingMode?: PaddingMode;
  strictAbiMode?: boolean; //throw errors instead of returning; check array & string lengths (crudely)
  allowRetry?: boolean; //turns on error-throwing for retry-allowed errors only
  abiPointerBase?: number; //what relative pointers should be considered relative to
  memoryVisited?: number[]; //for circularity detection
  lengthOverride?: BN; //if present, causes the ABI decoder to use this length instead of reading it from the data
}

/**
 * Used to indicate whether "extra" event decodings -- event decodings from
 * non-library contracts other than the one that appears to have emitted
 * the event -- should be returned.
 *
 * * `"off"`: Exclude extra decodings (the default).
 * * `"on"`: Include extra decodings.
 * * `"necessary"`: Include extra decodings only if there are no others.
 *
 * Extra decodings will always be returned after other decodings.
 *
 * @Category Inputs
 */
export type ExtrasAllowed = "off" | "on" | "necessary";

/**
 * The type of the options parameter to [[decodeEvent]].  This type will be expanded in the future
 * as more filtering options are added.
 *
 * @Category Inputs
 */
export interface LogOptions {
  /**
   * If passed, restricts to events with the given name.
   */
  name?: string;
  /**
   * Used to indicate whether "extra" event decodings -- event decodings from
   * non-library contracts other than the one that appears to have emitted
   * the event -- should be returned.  Defaults to `"off"`.
   */
  extras?: ExtrasAllowed;
  /**
   * If passed, restricts to events with the given ID.  This is meant for
   * internal use by Truffle Debugger; you probably don't want to bother
   * with this option.
   */
  id?: string;
  /**
   * Allows decodings that don't pass the re-encoding test.  Don't turn
   * this on unless you know what you're doing!
   */
  disableChecks?: boolean;
}

/**
 * An encoder request; can come in one of three types.  It can be either a
 * request to understand a numeric input (integer or decimal), or a request to
 * resolve a contract name.  The "kind" field distinguishes.
 *
 * @Category Requests
 */
export type WrapRequest =
  | IntegerWrapRequest
  | DecimalWrapRequest
  | AddressWrapRequest;

/**
 * A request to understand an integer value.
 *
 * @Category Requests
 */
export interface IntegerWrapRequest {
  /**
   * Indicates that this is a IntegerWrapRequest.
   */
  kind: "integer";
  /**
   * The input whose numeric value needs to be extracted.
   */
  input: unknown;
}

/**
 * A request to understand an decimal value.
 *
 * @Category Requests
 */
export interface DecimalWrapRequest {
  /**
   * Indicates that this is a DecimalWrapRequest.
   */
  kind: "decimal";
  /**
   * The input whose numeric value needs to be extracted.
   */
  input: unknown;
}

/**
 * A request to resolve a contract name to an address.
 *
 * @Category Requests
 */
export interface AddressWrapRequest {
  /**
   * Indicates that this is an AddressWrapRequest.
   */
  kind: "address";
  /**
   * The name that needs to be resolved to an address.
   */
  name: string;
}

/**
 * An encoder response; contains either a numeric value (as a BigInt or Big)
 * or an address.
 *
 * @Category Requests
 */
export type WrapResponse =
  | IntegerWrapResponse
  | DecimalWrapResponse
  | AddressWrapResponse;

/**
 * A response with an integral numeric value, as BigInt.
 *
 * @Category Requests
 */
export interface IntegerWrapResponse {
  /**
   * Indicates that this is a IntegerWrapResponse.
   */
  kind: "integer";
  /**
   * The numeric value that was extracted, as a BigInt, or null, to indicate
   * that either the number format wasn't recognized or wasn't an integer.
   */
  value: bigint | null;
  /**
   * If present, the reason the number wasn't recognized as an integer.
   */
  reason?: string;
  /**
   * If present, indicates that the input was recognized but not as an integer.
   */
  partiallyRecognized?: true;
}

/**
 * A response with an decimal numeric value, as Big.
 *
 * @Category Requests
 */
export interface DecimalWrapResponse {
  /**
   * Indicates that this is a DecimalWrapResponse.
   */
  kind: "decimal";
  /**
   * The numeric value that was extracted, as a Big, or null, to indicate
   * that the number format wasn't recognized.
   */
  value: Big | null;
  /**
   * If present, the reason the number wasn't recognized as a decimal.
   */
  reason?: string;
  /**
   * If present, indicates that the input was recognized but not as a decimal.
   */
  partiallyRecognized?: true;
}

/**
 * A response with an address for a contract name (or unusual address form).
 *
 * @Category Requests
 */
export interface AddressWrapResponse {
  /**
   * Indicates that this is an AddressWrapResponse.
   */
  kind: "address";
  /**
   * The address for the contract name, or null, to indicate that no such
   * contract was found.
   */
  address: string | null;
  /**
   * If present, the reason the address wasn't found.
   */
  reason?: string;
  /**
   * If present, indicates that the input was recognized but not as a valid address.
   */
  partiallyRecognized?: true;
}

/**
 * Specifies a block.  Can be given by number, or can be given via the
 * special strings "genesis", "latest", or "pending".
 *
 * Intended to work like Web3's
 * [BlockType](https://web3js.readthedocs.io/en/v1.2.1/web3-eth.html#id14).
 *
 * *Warning*: Using "pending", while allowed, is not advised, as it may lead
 * to internally inconsistent results.  Use of "latest" is safe and will not
 * lead to inconsistent results from a single decoder call due to the decoder's
 * caching system, but pending blocks cannot be cached under this system, which
 * may cause inconsistencies.
 * @category Inputs
 */
export type BlockSpecifier = number | "genesis" | "latest" | "pending";

/**
 * @hidden
 */
export type RegularizedBlockSpecifier = number | "pending";

/**
 * Used by some multicall-like interpretations.
 * @category Output
 */
export interface CallInterpretationInfo {
  /**
   * The address the call was sent to; may be null in case of
   * an error.
   */
  address: string | null;
  /**
   * The decoding of the call; may be null in case of error.
   */
  decoding: CalldataDecoding | null;
}

/**
 * Used by the `tryAggregate` interpretation.
 * @category Output
 */
export interface TryAggregateInfo {
  /**
   * Whether success was required.
   */
  requireSuccess: boolean;
  /**
   * The decodings of the individual calls.
   */
  calls: CallInterpretationInfo[];
}

/**
 * Used by the `deadlinedMulticall` interpretation.
 * @category Output
 */
export interface DeadlinedMulticallInfo {
  /**
   * The deadline.
   */
  deadline: BN;
  /**
   * The decodings of the individual calls; these may each be null in
   * case of an error.
   */
  calls: (CalldataDecoding | null)[];
}

/**
 * Used by the `specifiedBlockhashMulticall` interpretation.
 * @category Output
 */
export interface BlockhashedMulticallInfo {
  /**
   * The specified parent blockhash.
   */
  specifiedBlockhash: string;
  /**
   * The decodings of the individual calls; these may each be null in
   * case of an error.
   */
  calls: (CalldataDecoding | null)[];
}