Class EvmAbiImplementedDiviner<TParams>

Type Parameters

Hierarchy

Constructors

constructor

Properties

_account _baseModuleQueryAccountPaths _queryAccounts _startPromise _started downResolver eventData moduleConfigQueryValidator params supportedQueryValidator upResolver allowRandomAccount configSchemas defaultLogger? enableLazyLoad privateConstructorKey targetSchema

Accessors

_queryAccountPaths abi account address allowAnonymous config ephemeralQueryAccountEnabled id logger queries queryAccountPaths queryAccounts timestamp configSchema

Methods

_getRootFunction _noOverride bindHashes bindHashesInternal bindQuery bindQueryInternal bindQueryResult busy clearListeners describe describeHandler discover discoverHandler divine divineHandler emit emitSerial getArchivist initializeQueryAccounts listenerCount manifest manifestHandler moduleAddress moduleAddressHandler off offAny on onAny once previousHash query queryHandler queryable resolve resolveArchivingArchivists start startHandler started stop stopHandler storeToArchivists subscribe subscribeHandler validateConfig _getRootFunction _noOverride create determineAccount factory

Constructors

constructor

  • new EvmAbiImplementedDiviner<TParams>(privateConstructorKey, params, account): EvmAbiImplementedDiviner<TParams>

  • Type Parameters

    • TParams extends BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.evm.abi.implemented.diviner.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.evm.abi.implemented.diviner.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.evm.abi.implemented.diviner.config";
          } & {
              abi?: InterfaceAbi;
              schema: "network.xyo.evm.abi.implemented.diviner.config";
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      } = BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.evm.abi.implemented.diviner.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.evm.abi.implemented.diviner.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.evm.abi.implemented.diviner.config";
          } & {
              abi?: InterfaceAbi;
              schema: "network.xyo.evm.abi.implemented.diviner.config";
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }

    Parameters

    • privateConstructorKey: string
    • params: TParams
    • account: AccountInstance

    Returns EvmAbiImplementedDiviner<TParams>

Properties

Protected _account

_account: undefined | AccountInstance

Protected Readonly _baseModuleQueryAccountPaths

_baseModuleQueryAccountPaths: Record<"network.xyo.query.module.discover" | "network.xyo.query.module.address" | "network.xyo.query.module.subscribe" | "network.xyo.query.module.describe" | "network.xyo.query.module.manifest", string>

Protected Readonly _queryAccounts

_queryAccounts: Record<"network.xyo.query.module.discover" | "network.xyo.query.module.address" | "network.xyo.query.module.subscribe" | "network.xyo.query.module.describe" | "network.xyo.query.module.manifest", undefined | AccountInstance>

Protected _startPromise

_startPromise: undefined | Promisable<boolean>

Protected _started

_started: undefined | Promisable<boolean>

Readonly downResolver

downResolver: Omit<CompositeModuleResolver, "resolve">

eventData

eventData: DivinerModuleEventData<DivinerModule<TParams, {
    schema: string;
} & object, {
    schema: string;
} & object>, SchemaFields & object & {
    address: string;
    block: number;
    chainId: number;
    code?: string;
} & {
    schema: "network.xyo.evm.contract";
}, SchemaFields & object & {
    address: string;
    implemented: boolean;
    selector: string;
} & {
    schema: "network.xyo.evm.function.implemented";
}>

Protected Readonly moduleConfigQueryValidator

moduleConfigQueryValidator: Queryable

Readonly params

params: TParams

Protected Readonly supportedQueryValidator

supportedQueryValidator: Queryable

Readonly upResolver

upResolver: Omit<CompositeModuleResolver, "resolve>">

Static Readonly allowRandomAccount

allowRandomAccount: boolean

Static configSchemas

configSchemas: string[]

Static Optional defaultLogger

defaultLogger?: Logger

Static enableLazyLoad

enableLazyLoad: boolean

Protected Static privateConstructorKey

privateConstructorKey: string

Static targetSchema

targetSchema: string

Accessors

Protected _queryAccountPaths

  • get _queryAccountPaths(): Record<"network.xyo.query.diviner.divine", string>

  • Returns Record<"network.xyo.query.diviner.divine", string>

abi

  • get abi(): InterfaceAbi

  • Returns InterfaceAbi

account

  • get account(): AccountInstance

  • Returns AccountInstance

address

  • get address(): string

  • Returns string

allowAnonymous

  • get allowAnonymous(): boolean

  • Returns boolean

config

  • get config(): TParams["config"]

  • Returns TParams["config"]

ephemeralQueryAccountEnabled

  • get ephemeralQueryAccountEnabled(): boolean

  • Returns boolean

id

  • get id(): string

  • Returns string

Protected logger

  • get logger(): undefined | Logger

  • Returns undefined | Logger

queries

  • get queries(): string[]

  • Returns string[]

queryAccountPaths

  • get queryAccountPaths(): Readonly<Record<string, undefined | string>>

  • Returns Readonly<Record<string, undefined | string>>

queryAccounts

  • get queryAccounts(): Readonly<Record<string, undefined | AccountInstance>>

  • Returns Readonly<Record<string, undefined | AccountInstance>>

timestamp

  • get timestamp(): boolean

  • Returns boolean

Static configSchema

  • get configSchema(): string

  • Returns string

Methods

_getRootFunction

  • _getRootFunction(funcName): any

  • Parameters

    • funcName: string

    Returns any

_noOverride

  • _noOverride(functionName): void

  • Parameters

    • functionName: string

    Returns void

Protected bindHashes

  • bindHashes(hashes, schema, account?): PromiseEx<unknown, AccountInstance>

  • Parameters

    • hashes: string[]
    • schema: string[]
    • Optional account: AccountInstance

    Returns PromiseEx<unknown, AccountInstance>

Protected bindHashesInternal

  • bindHashesInternal(hashes, schema, account?): Promise<SchemaFields & object & BoundWitnessFields & {
        schema: "network.xyo.boundwitness";
    }>

  • Parameters

    • hashes: string[]
    • schema: string[]
    • Optional account: AccountInstance

    Returns Promise<SchemaFields & object & BoundWitnessFields & {
        schema: "network.xyo.boundwitness";
    }>

Protected bindQuery

  • bindQuery<T>(query, payloads?, account?): PromiseEx<[SchemaFields & object & Omit<BoundWitnessFields & {
        query: string;
        resultSet?: string;
        schema: "network.xyo.boundwitness";
    }, "schema"> & {
        schema: "network.xyo.boundwitness";
    }, ({
        schema: string;
    } & object)[], ({
        schema: string;
    } & object)[]], AccountInstance>

  • Type Parameters

    • T extends SchemaFields & object & QueryFields & {
          schema: string;
      }

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional account: AccountInstance

    Returns PromiseEx<[SchemaFields & object & Omit<BoundWitnessFields & {
        query: string;
        resultSet?: string;
        schema: "network.xyo.boundwitness";
    }, "schema"> & {
        schema: "network.xyo.boundwitness";
    }, ({
        schema: string;
    } & object)[], ({
        schema: string;
    } & object)[]], AccountInstance>

Protected bindQueryInternal

  • bindQueryInternal<T>(query, payloads?, account?): Promise<[SchemaFields & object & Omit<BoundWitnessFields & {
        query: string;
        resultSet?: string;
        schema: "network.xyo.boundwitness";
    }, "schema"> & {
        schema: "network.xyo.boundwitness";
    }, ({
        schema: string;
    } & object)[], ({
        schema: string;
    } & object)[]]>

  • Type Parameters

    • T extends SchemaFields & object & QueryFields & {
          schema: string;
      }

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional account: AccountInstance

    Returns Promise<[SchemaFields & object & Omit<BoundWitnessFields & {
        query: string;
        resultSet?: string;
        schema: "network.xyo.boundwitness";
    }, "schema"> & {
        schema: "network.xyo.boundwitness";
    }, ({
        schema: string;
    } & object)[], ({
        schema: string;
    } & object)[]]>

Protected bindQueryResult

  • bindQueryResult<T>(query, payloads, additionalWitnesses?, errors?): Promise<ModuleQueryResult>

  • Type Parameters

    • T extends SchemaFields & object & QueryFields & {
          schema: string;
      }

    Parameters

    • query: WithMeta<T>
    • payloads: ({
          schema: string;
      } & object)[]
    • Optional additionalWitnesses: AccountInstance[]
    • Optional errors: (SchemaFields & object & {
          message?: string;
          name?: string;
          query?: string;
          schema: "network.xyo.error.module";
          sources?: string[];
      })[]

    Returns Promise<ModuleQueryResult>

busy

  • busy<R>(closure): Promise<R>

  • Type Parameters

    • R

    Parameters

    • closure: (() => Promise<R>)
        • (): Promise<R>

        • Returns Promise<R>

    Returns Promise<R>

clearListeners

  • clearListeners(eventNames): void

  • Parameters

    • eventNames: (keyof DivinerModuleEventData<DivinerModule<TParams, { schema: string; } & object, { schema: string; } & object>, SchemaFields & object & { address: string; block: number; chainId: number; code?: string | undefined; } & { ...; }, SchemaFields & ... 2 more ... & { ...; }>) | (keyof DivinerModuleEventData<DivinerModule<TParams, { schema: string; } & object, { schema: string; } & object>, SchemaFields & object & { address: string; block: number; chainId: number; code?: string | undefined; } & { ...; }, SchemaFields & ... 2 more ... & { ...; }>)[]

    Returns void

describe

  • describe(): Promise<SchemaFields & object & ModuleDescription & {
        schema: "network.xyo.module.description";
    }>

  • Returns Promise<SchemaFields & object & ModuleDescription & {
        schema: "network.xyo.module.description";
    }>

Protected describeHandler

  • describeHandler(): Promise<SchemaFields & object & ModuleDescription & {
        schema: "network.xyo.module.description";
    }>

  • Returns Promise<SchemaFields & object & ModuleDescription & {
        schema: "network.xyo.module.description";
    }>

discover

  • discover(): Promise<({
        schema: string;
    } & object)[]>

  • Returns Promise<({
        schema: string;
    } & object)[]>

Protected discoverHandler

  • discoverHandler(_maxDepth?): Promise<({
        schema: string;
    } & object)[]>

  • Parameters

    • Optional _maxDepth: number

    Returns Promise<({
        schema: string;
    } & object)[]>

divine

  • divine(payloads?, retryConfigIn?): Promise<(SchemaFields & object & {
        address: string;
        implemented: boolean;
        selector: string;
    } & {
        schema: "network.xyo.evm.function.implemented";
    })[]>

  • Parameters

    • Optional payloads: (SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      })[]
    • Optional retryConfigIn: RetryConfigWithComplete<unknown>

    Returns Promise<(SchemaFields & object & {
        address: string;
        implemented: boolean;
        selector: string;
    } & {
        schema: "network.xyo.evm.function.implemented";
    })[]>

    Function

    divine The main entry point for a diviner. Do not override this function. Implement/override divineHandler for custom functionality

Protected divineHandler

  • divineHandler(inPayloads?): Promise<(SchemaFields & object & {
        address: string;
        implemented: boolean;
        selector: string;
    } & {
        schema: "network.xyo.evm.function.implemented";
    })[]>

  • Parameters

    • Optional inPayloads: (SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      })[]

    Returns Promise<(SchemaFields & object & {
        address: string;
        implemented: boolean;
        selector: string;
    } & {
        schema: "network.xyo.evm.function.implemented";
    })[]>

emit

  • emit<TEventName, TEventArgs>(eventName, eventArgs): Promise<void>

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }> = keyof DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>

    • TEventArgs extends EventArgs = DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>[TEventName]

    Parameters

    Returns Promise<void>

emitSerial

  • emitSerial<TEventName, TEventArgs>(eventName, eventArgs): Promise<void>

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }> = keyof DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>

    • TEventArgs extends EventArgs = DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>[TEventName]

    Parameters

    Returns Promise<void>

Protected getArchivist

  • getArchivist(): Promise<undefined | ArchivistInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>>

  • Returns Promise<undefined | ArchivistInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>>

Protected initializeQueryAccounts

  • initializeQueryAccounts(): Promise<void>

  • Returns Promise<void>

listenerCount

  • listenerCount(eventNames): number

  • Parameters

    • eventNames: (keyof DivinerModuleEventData<DivinerModule<TParams, { schema: string; } & object, { schema: string; } & object>, SchemaFields & object & { address: string; block: number; chainId: number; code?: string | undefined; } & { ...; }, SchemaFields & ... 2 more ... & { ...; }>) | (keyof DivinerModuleEventData<DivinerModule<TParams, { schema: string; } & object, { schema: string; } & object>, SchemaFields & object & { address: string; block: number; chainId: number; code?: string | undefined; } & { ...; }, SchemaFields & ... 2 more ... & { ...; }>)[]

    Returns number

manifest

  • manifest(maxDepth?, ignoreAddresses?): Promise<SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.module.manifest";
    } | SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.node.manifest";
    }>

  • Parameters

    • Optional maxDepth: number
    • Optional ignoreAddresses: string[]

    Returns Promise<SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.module.manifest";
    } | SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.node.manifest";
    }>

Protected manifestHandler

  • manifestHandler(_depth?, _ignoreAddresses?): Promisable<SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.module.manifest";
    } | SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.node.manifest";
    }>

  • Parameters

    • Optional _depth: number
    • Optional _ignoreAddresses: string[]

    Returns Promisable<SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.module.manifest";
    } | SchemaFields & object & ModuleManifest & {
        schema: "network.xyo.node.manifest";
    }>

moduleAddress

  • moduleAddress(): Promise<(SchemaFields & object & {
        address: string;
        previousHash?: string;
        schema: string;
    })[]>

  • Returns Promise<(SchemaFields & object & {
        address: string;
        previousHash?: string;
        schema: string;
    })[]>

Protected moduleAddressHandler

  • moduleAddressHandler(): Promisable<(SchemaFields & object & {
        address: string;
        previousHash?: string;
        schema: string;
    })[]>

  • Returns Promisable<(SchemaFields & object & {
        address: string;
        previousHash?: string;
        schema: string;
    })[]>

off

  • off<TEventName>(eventNames, listener): void

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>

    Parameters

    • eventNames: TEventName | TEventName[]
    • listener: EventListener<DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>[TEventName]>

    Returns void

offAny

  • offAny(listener): void

  • Parameters

    • listener: EventAnyListener

    Returns void

on

  • on<TEventName>(eventNames, listener): (() => void)

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>

    Parameters

    • eventNames: TEventName | TEventName[]
    • listener: EventListener<DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>[TEventName]>

    Returns (() => void)

      • (): void

      • Returns void

onAny

  • onAny(listener): (() => void)

  • Parameters

    • listener: EventAnyListener

    Returns (() => void)

      • (): void

      • Returns void

once

  • once<TEventName>(eventName, listener): (() => void)

  • Type Parameters

    • TEventName extends keyof DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>

    Parameters

    • eventName: TEventName
    • listener: EventListener<DivinerModuleEventData<DivinerModule<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, SchemaFields & object & {
          address: string;
          block: number;
          chainId: number;
          code?: string;
      } & {
          schema: "network.xyo.evm.contract";
      }, SchemaFields & object & {
          address: string;
          implemented: boolean;
          selector: string;
      } & {
          schema: "network.xyo.evm.function.implemented";
      }>[TEventName]>

    Returns (() => void)

      • (): void

      • Returns void

previousHash

  • previousHash(): Promisable<undefined | string>

  • Returns Promisable<undefined | string>

query

  • query<T, TConfig>(query, payloads?, queryConfig?): Promise<ModuleQueryResult>

  • Type Parameters

    • T extends SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      } = SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      }

    • TConfig extends SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig = SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional queryConfig: TConfig

    Returns Promise<ModuleQueryResult>

Protected queryHandler

  • queryHandler<T, TConfig>(query, payloads?, queryConfig?): Promise<ModuleQueryHandlerResult>

  • Type Parameters

    • T extends SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      } = SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      }

    • TConfig extends SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig = SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional queryConfig: TConfig

    Returns Promise<ModuleQueryHandlerResult>

    Function

    queryHandler Calls divine for a divine query. Override to support additional queries.

queryable

  • queryable<T, TConfig>(query, payloads?, queryConfig?): Promise<boolean>

  • Type Parameters

    • T extends SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      } = SchemaFields & object & Omit<BoundWitnessFields & {
          query: string;
          resultSet?: string;
          schema: "network.xyo.boundwitness";
      }, "schema"> & {
          schema: "network.xyo.boundwitness";
      }

    • TConfig extends SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig = SchemaFields & object & {
          archivist?: string;
          labels?: Labels;
          name?: string;
          paging?: Record<string, {
              size?: number;
          }>;
          retry?: RetryConfig;
          schema: "network.xyo.module.config";
          security?: {
              allowAnonymous?: boolean;
              allowed?: Record<string, (string | CosigningAddressSet)[]>;
              disallowed?: Record<string, string[]>;
          };
          sign?: boolean;
          storeQueries?: boolean;
          timestamp?: boolean;
      } & ArchivingModuleConfig

    Parameters

    • query: T
    • Optional payloads: ({
          schema: string;
      } & object)[]
    • Optional queryConfig: TConfig

    Returns Promise<boolean>

resolve

  • resolve<T>(filter?, options?): Promise<T[]>

  • Type Parameters

    • T extends ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>> = ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>>

    Parameters

    • Optional filter: ModuleFilter
    • Optional options: ModuleFilterOptions<T>

    Returns Promise<T[]>

  • resolve<T>(nameOrAddress, options?): Promise<undefined | T>

  • Type Parameters

    • T extends ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>> = ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>>

    Parameters

    • nameOrAddress: string
    • Optional options: ModuleFilterOptions<T>

    Returns Promise<undefined | T>

Protected resolveArchivingArchivists

  • resolveArchivingArchivists(): Promise<ArchivistInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>[]>

  • Returns Promise<ArchivistInstance<BaseParamsFields & {
        account?: AccountInstance | "random";
        config: SchemaFields & object & Omit<{
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & ArchivingModuleConfig & SchemaFields & object & {
            archivist?: string;
            labels?: Labels;
            name?: string;
            paging?: Record<string, {
                size?: number;
            }>;
            retry?: RetryConfig;
            schema: "network.xyo.archivist.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: Record<string, (string | CosigningAddressSet)[]>;
                disallowed?: Record<string, string[]>;
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        } & {
            parents?: ArchivistParents;
            requireAllParents?: boolean;
            schema: "network.xyo.archivist.config";
            storeParentReads?: boolean;
        }, "schema"> & {
            schema: string;
        };
        ephemeralQueryAccountEnabled?: boolean;
    }, ArchivistModuleEventData>[]>

start

  • start(_timeout?): Promisable<boolean>

  • Parameters

    • Optional _timeout: number

    Returns Promisable<boolean>

Protected startHandler

  • startHandler(): Promise<boolean>

  • Returns Promise<boolean>

started

  • started(notStartedAction?, tryStart?): Promise<boolean>

  • Parameters

    • Optional notStartedAction: "error" | "throw" | "warn" | "log" | "none"
    • Optional tryStart: boolean

    Returns Promise<boolean>

stop

  • stop(_timeout?): Promise<boolean>

  • Parameters

    • Optional _timeout: number

    Returns Promise<boolean>

Protected stopHandler

  • stopHandler(_timeout?): Promisable<boolean>

  • Parameters

    • Optional _timeout: number

    Returns Promisable<boolean>

Protected storeToArchivists

  • storeToArchivists(payloads): Promise<({
        schema: string;
    } & object)[]>

  • Parameters

    • payloads: ({
          schema: string;
      } & object)[]

    Returns Promise<({
        schema: string;
    } & object)[]>

subscribe

  • subscribe(_queryAccount?): void

  • Parameters

    • Optional _queryAccount: AccountInstance

    Returns void

Protected subscribeHandler

  • subscribeHandler(): void

  • Returns void

Protected validateConfig

  • validateConfig(config?, parents?): boolean

  • Parameters

    • Optional config: unknown
    • Optional parents: string[]

    Returns boolean

Static _getRootFunction

  • _getRootFunction(funcName): any

  • Parameters

    • funcName: string

    Returns any

Static _noOverride

  • _noOverride(functionName): void

  • Parameters

    • functionName: string

    Returns void

Static create

  • create<TModule>(this, params?): Promise<TModule>

  • Type Parameters

    • TModule extends ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>>

    Parameters

    • this: CreatableModule<TModule>
    • Optional params: Omit<TModule["params"], "config"> & {
          config?: TModule["params"]["config"];
      }

    Returns Promise<TModule>

Static determineAccount

  • determineAccount(params): Promise<AccountInstance>

  • Parameters

    • params: {
          account?: AccountInstance | "random";
          accountPath?: string;
          wallet?: WalletInstance;
      }
      • Optional account?: AccountInstance | "random"
      • Optional accountPath?: string
      • Optional wallet?: WalletInstance

    Returns Promise<AccountInstance>

Static factory

  • factory<TModule>(this, params?): CreatableModuleFactory<TModule>

  • Type Parameters

    • TModule extends ModuleInstance<BaseParamsFields & {
          account?: AccountInstance | "random";
          config: SchemaFields & object & Omit<{
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & ArchivingModuleConfig & SchemaFields & object & {
              archivist?: string;
              labels?: Labels;
              name?: string;
              paging?: Record<string, {
                  size?: number;
              }>;
              retry?: RetryConfig;
              schema: "network.xyo.module.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }, ModuleEventData<object>>

    Parameters

    • this: CreatableModule<TModule>
    • Optional params: Omit<TModule["params"], "config"> & {
          config?: TModule["params"]["config"];
      }

    Returns CreatableModuleFactory<TModule>

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc