Class AsyncQueryBusHost<TParams>

Type Parameters

Hierarchy

  • AsyncQueryBusBase<TParams>
    • AsyncQueryBusHost

Constructors

constructor

Properties

_exposedAddresses _lastState? _targetConfigs _targetQueries callLocalModule findQueriesToAddress defaultLogger? globalInstances globalInstancesCountHistory uniqueName

Accessors

config exposedAddresses idlePollFrequency idleThreshold lastState logger params perAddressBatchQueryLimit pollFrequency rootModule started historyInterval historyTime maxGcFrequency maxHistoryDepth

Methods

commitState expose listeningModules queriesArchivist queriesDiviner responsesArchivist responsesDiviner retrieveState start stop unexpose gc instanceCount instanceCounts startHistory stopHistory

Constructors

constructor

Properties

Protected_exposedAddresses

_exposedAddresses: Set<Lowercase<string>>

Protected Optional_lastState

_lastState?: LRUCache<Lowercase<string>, Lowercase<string>>

Protected_targetConfigs

_targetConfigs: Record<
    Lowercase<string>,
    DeepRestrictToStringKeys<
        {
            allowedQueries?: string[];
            archiving?: { archivists?: string[]; queries?: string[] };
            archivist?: string;
            consoleLogger?: LogLevel;
            labels?: { [key: string]: undefined | string };
            name?: string;
            paging?: { [key: string]: { size?: number } };
            retry?: { backoff?: number; interval?: number; retries?: number };
            schema: "network.xyo.module.config";
            security?: {
                allowAnonymous?: boolean;
                allowed?: { [key: string]: (Lowercase<string> | Lowercase<(...)>[])[] };
                disallowed?: { [key: string]: Lowercase<string>[] };
            };
            sign?: boolean;
            storeQueries?: boolean;
            timestamp?: boolean;
        },
    >,
>

Protected_targetQueries

_targetQueries: Record<Lowercase<string>, string[]>

ProtectedcallLocalModule

callLocalModule: (
    localModule: ModuleInstance,
    query: WithStorageMeta<UnsignedQueryBoundWitness>,
) => Promise<void>

ProtectedfindQueriesToAddress

findQueriesToAddress: (
    address: Lowercase<string>,
) => Promise<undefined | WithStorageMeta<UnsignedQueryBoundWitness>[]>

Static OptionaldefaultLogger

defaultLogger?: Logger

Static ReadonlyglobalInstances

globalInstances: Record<string, WeakRef<Base<undefined | BaseParamsFields>>[]>

Static ReadonlyglobalInstancesCountHistory

globalInstancesCountHistory: Record<string, number[]>

Static ReadonlyuniqueName

uniqueName: string

Accessors

config

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

  • Returns TParams["config"]

exposedAddresses

  • get exposedAddresses(): Set<Lowercase<string>>

  • Returns Set<Lowercase<string>>

idlePollFrequency

  • get idlePollFrequency(): number

  • Returns number

idleThreshold

  • get idleThreshold(): number

  • Returns number

ProtectedlastState

  • get lastState(): LRUCache<Lowercase<string>, Lowercase<string>>

  • Returns LRUCache<Lowercase<string>, Lowercase<string>>

logger

  • get logger(): undefined | Logger

  • Returns undefined | Logger

params

  • get params(): TParams

  • Returns TParams

perAddressBatchQueryLimit

  • get perAddressBatchQueryLimit(): number

  • Returns number

pollFrequency

  • get pollFrequency(): number

  • Returns number

rootModule

  • get rootModule(): ModuleInstance<
        BaseParamsFields & {
            account?: AccountInstance
            | "random";
            additionalSigners?: AccountInstance[];
            addToResolvers?: boolean;
            allowNameResolution?: boolean;
            config: DeepRestrictToStringKeys<
                {
                    allowedQueries?: string[];
                    archiving?: { archivists?: string[]; queries?: string[] };
                    archivist?: string;
                    consoleLogger?: LogLevel;
                    labels?: { [x: string]: undefined | string };
                    name?: string;
                    paging?: { [x: string]: { size?: number } };
                    retry?: { backoff?: number; interval?: number; retries?: number };
                    schema: string;
                    security?: {
                        allowAnonymous?: boolean;
                        allowed?: { [x: string]: ((...) | (...))[] };
                        disallowed?: { [x: string]: Lowercase<(...)>[] };
                    };
                    sign?: boolean;
                    storeQueries?: boolean;
                    timestamp?: boolean;
                },
            >;
            ephemeralQueryAccountEnabled?: boolean;
            moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
        },
    >

  • Returns ModuleInstance<
        BaseParamsFields & {
            account?: AccountInstance
            | "random";
            additionalSigners?: AccountInstance[];
            addToResolvers?: boolean;
            allowNameResolution?: boolean;
            config: DeepRestrictToStringKeys<
                {
                    allowedQueries?: string[];
                    archiving?: { archivists?: string[]; queries?: string[] };
                    archivist?: string;
                    consoleLogger?: LogLevel;
                    labels?: { [x: string]: undefined | string };
                    name?: string;
                    paging?: { [x: string]: { size?: number } };
                    retry?: { backoff?: number; interval?: number; retries?: number };
                    schema: string;
                    security?: {
                        allowAnonymous?: boolean;
                        allowed?: { [x: string]: ((...) | (...))[] };
                        disallowed?: { [x: string]: Lowercase<(...)>[] };
                    };
                    sign?: boolean;
                    storeQueries?: boolean;
                    timestamp?: boolean;
                },
            >;
            ephemeralQueryAccountEnabled?: boolean;
            moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
        },
    >

started

  • get started(): boolean

  • Returns boolean

StatichistoryInterval

  • get historyInterval(): number

  • Returns number

  • set historyInterval(value: number): void

  • Parameters

    • value: number

    Returns void

StatichistoryTime

  • get historyTime(): number

  • Returns number

  • set historyTime(value: number): void

  • Parameters

    • value: number

    Returns void

StaticmaxGcFrequency

  • get maxGcFrequency(): number

  • Returns number

  • set maxGcFrequency(value: number): void

  • Parameters

    • value: number

    Returns void

StaticmaxHistoryDepth

  • get maxHistoryDepth(): number

  • Returns number

Methods

ProtectedcommitState

  • commitState(
        address: Lowercase<string>,
        nextState: Lowercase<string>,
    ): Promise<void>

  • Parameters

    • address: Lowercase<string>
    • nextState: Lowercase<string>

    Returns Promise<void>

expose

  • expose(
        mod: ModuleInstance,
        options?: ExposeOptions,
    ):
        | undefined
        | ModuleInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: string[]; queries?: string[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: number } };
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: string]: (...)[] };
                            disallowed?: { [x: string]: (...)[] };
                        };
                        sign?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
        >

  • Parameters

    Returns
        | undefined
        | ModuleInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: string[]; queries?: string[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: number } };
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: string]: (...)[] };
                            disallowed?: { [x: string]: (...)[] };
                        };
                        sign?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
        >

listeningModules

  • listeningModules(): Promise<ModuleInstance[]>

  • Returns Promise<ModuleInstance[]>

queriesArchivist

  • queriesArchivist(): Promise<
        | undefined
        | ArchivistInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: (...)[]; queries?: (...)[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: (...) | (...) } };
                        parents?: { commit?: (...)[]; read?: (...)[]; write?: (...)[] };
                        requireAllParents?: boolean;
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: ...]: ... };
                            disallowed?: { [x: ...]: ... };
                        };
                        sign?: boolean;
                        storage?: { indexes?: (...)[] };
                        storeParentReads?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
            DeepRestrictToStringKeys<{ schema: string }>,
        >,
    >

  • Returns Promise<
        | undefined
        | ArchivistInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: (...)[]; queries?: (...)[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: (...) | (...) } };
                        parents?: { commit?: (...)[]; read?: (...)[]; write?: (...)[] };
                        requireAllParents?: boolean;
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: ...]: ... };
                            disallowed?: { [x: ...]: ... };
                        };
                        sign?: boolean;
                        storage?: { indexes?: (...)[] };
                        storeParentReads?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
            DeepRestrictToStringKeys<{ schema: string }>,
        >,
    >

queriesDiviner

  • queriesDiviner(): Promise<
        DivinerInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: string[]; queries?: string[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: number } };
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: string]: (...)[] };
                            disallowed?: { [x: string]: (...)[] };
                        };
                        sign?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
            DeepRestrictToStringKeys<
                {
                    address?: Lowercase<string>
                    | Lowercase<string>[];
                    addresses?: Lowercase<string>[];
                    block?: Lowercase<string>;
                    budget?: number;
                    chain?: Lowercase<string>;
                    cursor?: Lowercase<string>;
                    destination?: string[];
                    limit?: number;
                    maxFrequency?:
                        | "once"
                        | "second"
                        | "minute"
                        | "hour"
                        | "day"
                        | "week"
                        | "month"
                        | "year";
                    minBid?: number;
                    order?: any;
                    payload_hashes?: Lowercase<string>[];
                    payload_schemas?: string[];
                    previous_hashes?: DeepRestrictToStringKeys<null | Lowercase<string>>[];
                    root?: Lowercase<string>;
                    schema: "network.xyo.diviner.boundwitness.query";
                    sourceQuery?: string;
                },
            >,
            UnsignedQueryBoundWitness,
            DivinerModuleEventData<
                ModuleInstance<
                    BaseParamsFields & {
                        account?: AccountInstance
                        | "random";
                        additionalSigners?: AccountInstance[];
                        addToResolvers?: boolean;
                        allowNameResolution?: boolean;
                        config: DeepRestrictToStringKeys<
                            {
                                allowedQueries?: string[];
                                archiving?: { archivists?: (...)
                                | (...); queries?: (...) | (...) };
                                archivist?: string;
                                consoleLogger?: LogLevel;
                                labels?: { [x: string]: (...) | (...) };
                                name?: string;
                                paging?: { [x: string]: { size?: ... } };
                                retry?: {
                                    backoff?: (...) | (...);
                                    interval?: (...) | (...);
                                    retries?: (...) | (...);
                                };
                                schema: string;
                                security?: {
                                    allowAnonymous?: (...)
                                    | (...)
                                    | (...);
                                    allowed?: (...) | (...);
                                    disallowed?: (...) | (...);
                                };
                                sign?: boolean;
                                storeQueries?: boolean;
                                timestamp?: boolean;
                            },
                        >;
                        ephemeralQueryAccountEnabled?: boolean;
                        moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
                    },
                >,
                DeepRestrictToStringKeys<{ schema: string }>,
                DeepRestrictToStringKeys<{ schema: string }>,
            >,
        >,
    >

  • Returns Promise<
        DivinerInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: string[]; queries?: string[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: number } };
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: string]: (...)[] };
                            disallowed?: { [x: string]: (...)[] };
                        };
                        sign?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
            DeepRestrictToStringKeys<
                {
                    address?: Lowercase<string>
                    | Lowercase<string>[];
                    addresses?: Lowercase<string>[];
                    block?: Lowercase<string>;
                    budget?: number;
                    chain?: Lowercase<string>;
                    cursor?: Lowercase<string>;
                    destination?: string[];
                    limit?: number;
                    maxFrequency?:
                        | "once"
                        | "second"
                        | "minute"
                        | "hour"
                        | "day"
                        | "week"
                        | "month"
                        | "year";
                    minBid?: number;
                    order?: any;
                    payload_hashes?: Lowercase<string>[];
                    payload_schemas?: string[];
                    previous_hashes?: DeepRestrictToStringKeys<null | Lowercase<string>>[];
                    root?: Lowercase<string>;
                    schema: "network.xyo.diviner.boundwitness.query";
                    sourceQuery?: string;
                },
            >,
            UnsignedQueryBoundWitness,
            DivinerModuleEventData<
                ModuleInstance<
                    BaseParamsFields & {
                        account?: AccountInstance
                        | "random";
                        additionalSigners?: AccountInstance[];
                        addToResolvers?: boolean;
                        allowNameResolution?: boolean;
                        config: DeepRestrictToStringKeys<
                            {
                                allowedQueries?: string[];
                                archiving?: { archivists?: (...)
                                | (...); queries?: (...) | (...) };
                                archivist?: string;
                                consoleLogger?: LogLevel;
                                labels?: { [x: string]: (...) | (...) };
                                name?: string;
                                paging?: { [x: string]: { size?: ... } };
                                retry?: {
                                    backoff?: (...) | (...);
                                    interval?: (...) | (...);
                                    retries?: (...) | (...);
                                };
                                schema: string;
                                security?: {
                                    allowAnonymous?: (...)
                                    | (...)
                                    | (...);
                                    allowed?: (...) | (...);
                                    disallowed?: (...) | (...);
                                };
                                sign?: boolean;
                                storeQueries?: boolean;
                                timestamp?: boolean;
                            },
                        >;
                        ephemeralQueryAccountEnabled?: boolean;
                        moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
                    },
                >,
                DeepRestrictToStringKeys<{ schema: string }>,
                DeepRestrictToStringKeys<{ schema: string }>,
            >,
        >,
    >

responsesArchivist

  • responsesArchivist(): Promise<
        | undefined
        | ArchivistInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: (...)[]; queries?: (...)[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: (...) | (...) } };
                        parents?: { commit?: (...)[]; read?: (...)[]; write?: (...)[] };
                        requireAllParents?: boolean;
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: ...]: ... };
                            disallowed?: { [x: ...]: ... };
                        };
                        sign?: boolean;
                        storage?: { indexes?: (...)[] };
                        storeParentReads?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
            DeepRestrictToStringKeys<{ schema: string }>,
        >,
    >

  • Returns Promise<
        | undefined
        | ArchivistInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: (...)[]; queries?: (...)[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: (...) | (...) } };
                        parents?: { commit?: (...)[]; read?: (...)[]; write?: (...)[] };
                        requireAllParents?: boolean;
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: ...]: ... };
                            disallowed?: { [x: ...]: ... };
                        };
                        sign?: boolean;
                        storage?: { indexes?: (...)[] };
                        storeParentReads?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
            DeepRestrictToStringKeys<{ schema: string }>,
        >,
    >

responsesDiviner

  • responsesDiviner(): Promise<
        DivinerInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: string[]; queries?: string[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: number } };
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: string]: (...)[] };
                            disallowed?: { [x: string]: (...)[] };
                        };
                        sign?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
            DeepRestrictToStringKeys<
                {
                    address?: Lowercase<string>
                    | Lowercase<string>[];
                    addresses?: Lowercase<string>[];
                    block?: Lowercase<string>;
                    budget?: number;
                    chain?: Lowercase<string>;
                    cursor?: Lowercase<string>;
                    destination?: string[];
                    limit?: number;
                    maxFrequency?:
                        | "once"
                        | "second"
                        | "minute"
                        | "hour"
                        | "day"
                        | "week"
                        | "month"
                        | "year";
                    minBid?: number;
                    order?: any;
                    payload_hashes?: Lowercase<string>[];
                    payload_schemas?: string[];
                    previous_hashes?: DeepRestrictToStringKeys<null | Lowercase<string>>[];
                    root?: Lowercase<string>;
                    schema: "network.xyo.diviner.boundwitness.query";
                    sourceQuery?: string;
                },
            >,
            BoundWitness,
            DivinerModuleEventData<
                ModuleInstance<
                    BaseParamsFields & {
                        account?: AccountInstance
                        | "random";
                        additionalSigners?: AccountInstance[];
                        addToResolvers?: boolean;
                        allowNameResolution?: boolean;
                        config: DeepRestrictToStringKeys<
                            {
                                allowedQueries?: string[];
                                archiving?: { archivists?: (...)
                                | (...); queries?: (...) | (...) };
                                archivist?: string;
                                consoleLogger?: LogLevel;
                                labels?: { [x: string]: (...) | (...) };
                                name?: string;
                                paging?: { [x: string]: { size?: ... } };
                                retry?: {
                                    backoff?: (...) | (...);
                                    interval?: (...) | (...);
                                    retries?: (...) | (...);
                                };
                                schema: string;
                                security?: {
                                    allowAnonymous?: (...)
                                    | (...)
                                    | (...);
                                    allowed?: (...) | (...);
                                    disallowed?: (...) | (...);
                                };
                                sign?: boolean;
                                storeQueries?: boolean;
                                timestamp?: boolean;
                            },
                        >;
                        ephemeralQueryAccountEnabled?: boolean;
                        moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
                    },
                >,
                DeepRestrictToStringKeys<{ schema: string }>,
                DeepRestrictToStringKeys<{ schema: string }>,
            >,
        >,
    >

  • Returns Promise<
        DivinerInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: string[]; queries?: string[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: number } };
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: string]: (...)[] };
                            disallowed?: { [x: string]: (...)[] };
                        };
                        sign?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
            DeepRestrictToStringKeys<
                {
                    address?: Lowercase<string>
                    | Lowercase<string>[];
                    addresses?: Lowercase<string>[];
                    block?: Lowercase<string>;
                    budget?: number;
                    chain?: Lowercase<string>;
                    cursor?: Lowercase<string>;
                    destination?: string[];
                    limit?: number;
                    maxFrequency?:
                        | "once"
                        | "second"
                        | "minute"
                        | "hour"
                        | "day"
                        | "week"
                        | "month"
                        | "year";
                    minBid?: number;
                    order?: any;
                    payload_hashes?: Lowercase<string>[];
                    payload_schemas?: string[];
                    previous_hashes?: DeepRestrictToStringKeys<null | Lowercase<string>>[];
                    root?: Lowercase<string>;
                    schema: "network.xyo.diviner.boundwitness.query";
                    sourceQuery?: string;
                },
            >,
            BoundWitness,
            DivinerModuleEventData<
                ModuleInstance<
                    BaseParamsFields & {
                        account?: AccountInstance
                        | "random";
                        additionalSigners?: AccountInstance[];
                        addToResolvers?: boolean;
                        allowNameResolution?: boolean;
                        config: DeepRestrictToStringKeys<
                            {
                                allowedQueries?: string[];
                                archiving?: { archivists?: (...)
                                | (...); queries?: (...) | (...) };
                                archivist?: string;
                                consoleLogger?: LogLevel;
                                labels?: { [x: string]: (...) | (...) };
                                name?: string;
                                paging?: { [x: string]: { size?: ... } };
                                retry?: {
                                    backoff?: (...) | (...);
                                    interval?: (...) | (...);
                                    retries?: (...) | (...);
                                };
                                schema: string;
                                security?: {
                                    allowAnonymous?: (...)
                                    | (...)
                                    | (...);
                                    allowed?: (...) | (...);
                                    disallowed?: (...) | (...);
                                };
                                sign?: boolean;
                                storeQueries?: boolean;
                                timestamp?: boolean;
                            },
                        >;
                        ephemeralQueryAccountEnabled?: boolean;
                        moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
                    },
                >,
                DeepRestrictToStringKeys<{ schema: string }>,
                DeepRestrictToStringKeys<{ schema: string }>,
            >,
        >,
    >

ProtectedretrieveState

  • retrieveState(address: Lowercase<string>): Promise<Lowercase<string>>

  • Parameters

    • address: Lowercase<string>

    Returns Promise<Lowercase<string>>

start

  • start(): void

  • Returns void

stop

  • stop(): void

  • Returns void

unexpose

  • unexpose(
        id: string,
        validate?: boolean,
    ): Promise<
        | undefined
        | ModuleInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: (...)[]; queries?: (...)[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: (...) | (...) } };
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: ...]: ... };
                            disallowed?: { [x: ...]: ... };
                        };
                        sign?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
        >,
    >

  • Parameters

    • id: string
    • Optionalvalidate: boolean

    Returns Promise<
        | undefined
        | ModuleInstance<
            BaseParamsFields & {
                account?: AccountInstance
                | "random";
                additionalSigners?: AccountInstance[];
                addToResolvers?: boolean;
                allowNameResolution?: boolean;
                config: DeepRestrictToStringKeys<
                    {
                        allowedQueries?: string[];
                        archiving?: { archivists?: (...)[]; queries?: (...)[] };
                        archivist?: string;
                        consoleLogger?: LogLevel;
                        labels?: { [x: string]: undefined | string };
                        name?: string;
                        paging?: { [x: string]: { size?: (...) | (...) } };
                        retry?: { backoff?: number; interval?: number; retries?: number };
                        schema: string;
                        security?: {
                            allowAnonymous?: boolean;
                            allowed?: { [x: ...]: ... };
                            disallowed?: { [x: ...]: ... };
                        };
                        sign?: boolean;
                        storeQueries?: boolean;
                        timestamp?: boolean;
                    },
                >;
                ephemeralQueryAccountEnabled?: boolean;
                moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
            },
        >,
    >

Staticgc

  • gc(force?: boolean): void

  • Parameters

    • Optionalforce: boolean

    Returns void

  • gc(className: string): void

  • Parameters

    • className: string

    Returns void

StaticinstanceCount

  • instanceCount(className: string): number

  • Parameters

    • className: string

    Returns number

StaticinstanceCounts

  • instanceCounts(): Record<string, number>

  • Returns Record<string, number>

StaticstartHistory

  • startHistory(): void

  • Returns void

StaticstopHistory

  • stopHistory(): void

  • Returns void

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods