Class NodeSystemInfoWitness<TParams>

Type Parameters

Hierarchy

  • AbstractWitness<TParams>
    • NodeSystemInfoWitness

Implements

  • WitnessModule

Constructors

constructor

Properties

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

Accessors

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

Methods

_getRootFunction _noOverride bindHashes bindHashesInternal bindQuery bindQueryInternal bindQueryResult busy clearListeners describe describeHandler discover discoverHandler emit emitSerial getArchivist getArchivistInstance initializeQueryAccounts listenerCount manifest manifestHandler moduleAddress moduleAddressHandler observe observeHandler 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 NodeSystemInfoWitness<TParams>(privateConstructorKey, params, account): NodeSystemInfoWitness<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.system.info.witness.node.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.system.info.witness.node.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.system.info.witness.node.config";
          } & {
              nodeValues?: Record<string, string>;
              schema: "network.xyo.system.info.witness.node.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.system.info.witness.node.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.system.info.witness.node.config";
              security?: {
                  allowAnonymous?: boolean;
                  allowed?: Record<string, (string | CosigningAddressSet)[]>;
                  disallowed?: Record<string, string[]>;
              };
              sign?: boolean;
              storeQueries?: boolean;
              timestamp?: boolean;
          } & {
              schema: "network.xyo.system.info.witness.node.config";
          } & {
              nodeValues?: Record<string, string>;
              schema: "network.xyo.system.info.witness.node.config";
          }, "schema"> & {
              schema: string;
          };
          ephemeralQueryAccountEnabled?: boolean;
      }

    Parameters

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

    Returns NodeSystemInfoWitness<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: WitnessModuleEventData<WitnessInstance<TParams, {
    schema: string;
} & object, {
    schema: string;
} & object>, {
    schema: string;
} & object, {
    schema: string;
} & object>

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: "network.xyo.system.info.witness.node.config"[]

Static Optional defaultLogger

defaultLogger?: Logger

Static enableLazyLoad

enableLazyLoad: boolean

Protected Static privateConstructorKey

privateConstructorKey: string

Accessors

Protected _queryAccountPaths

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

  • Returns Record<"network.xyo.query.witness.observe", string>

account

  • get account(): AccountInstance

  • Returns AccountInstance

address

  • get address(): string

  • Returns string

allowAnonymous

  • get allowAnonymous(): boolean

  • Returns boolean

archivist

  • get archivist(): undefined | string

  • Returns undefined | string

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 WitnessModuleEventData<WitnessInstance<TParams, { schema: string; } & object, { schema: string; } & object>, { schema: string; } & object, { schema: string; } & object>) | (keyof WitnessModuleEventData<WitnessInstance<TParams, { schema: string; } & object, { schema: string; } & object>, { schema: string; } & object, { schema: string; } & object>)[]

    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)[]>

emit

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

  • Type Parameters

    • TEventName extends keyof WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object> = keyof WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    • TEventArgs extends EventArgs = WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[TEventName]

    Parameters

    Returns Promise<void>

emitSerial

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

  • Type Parameters

    • TEventName extends keyof WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object> = keyof WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    • TEventArgs extends EventArgs = WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[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>>

getArchivistInstance

  • getArchivistInstance(): 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 WitnessModuleEventData<WitnessInstance<TParams, { schema: string; } & object, { schema: string; } & object>, { schema: string; } & object, { schema: string; } & object>) | (keyof WitnessModuleEventData<WitnessInstance<TParams, { schema: string; } & object, { schema: string; } & object>, { schema: string; } & object, { schema: string; } & object>)[]

    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;
    })[]>

observe

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

  • Parameters

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

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

    Function

    observe The main entry point for a witness. Do not override this function. Implement/override observeHandler for custom functionality

Protected observeHandler

  • observeHandler(payloads?): Promise<any[]>

  • Parameters

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

    Returns Promise<any[]>

off

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

  • Type Parameters

    • TEventName extends keyof WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    Parameters

    • eventNames: TEventName | TEventName[]
    • listener: EventListener<WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[TEventName]>

    Returns void

offAny

  • offAny(listener): void

  • Parameters

    • listener: EventAnyListener

    Returns void

on

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

  • Type Parameters

    • TEventName extends keyof WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    Parameters

    • eventNames: TEventName | TEventName[]
    • listener: EventListener<WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[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 WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>

    Parameters

    • eventName: TEventName
    • listener: EventListener<WitnessModuleEventData<WitnessInstance<TParams, {
          schema: string;
      } & object, {
          schema: string;
      } & object>, {
          schema: string;
      } & object, {
          schema: string;
      } & object>[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 observe for an observe 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