Class AsyncQueryBusClient<TParams>

Type Parameters

Hierarchy

  • AsyncQueryBusBase<TParams>
    • AsyncQueryBusClient

Constructors

constructor

Properties

_lastState? _queryCache? _targetConfigs _targetQueries defaultLogger? globalInstances globalInstancesCountHistory uniqueName

Accessors

config lastState logger params pollFrequency queryCache queryCacheConfig rootModule started historyInterval historyTime maxGcFrequency maxHistoryDepth

Methods

commitState listeningAddresses queriesArchivist queriesDiviner responsesArchivist responsesDiviner retrieveState send gc instanceCount instanceCounts startHistory stopHistory

Constructors

constructor

Properties

Protected Optional_lastState

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

Protected Optional_queryCache

_queryCache?: LRUCache<Lowercase<string>, ModuleQueryResult | "pending">

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

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"]

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

pollFrequency

  • get pollFrequency(): number

  • Returns number

ProtectedqueryCache

  • get queryCache(): LRUCache<Lowercase<string>, ModuleQueryResult | "pending">

  • Returns LRUCache<Lowercase<string>, ModuleQueryResult | "pending">

queryCacheConfig

  • get queryCacheConfig(): Options<
        Lowercase<string>,
        ModuleQueryResult | "pending",
        unknown,
    >

  • Returns Options<Lowercase<string>, ModuleQueryResult | "pending", unknown>

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>

listeningAddresses

  • listeningAddresses(): undefined | Generator<Lowercase<string>, void>

  • Returns undefined | Generator<Lowercase<string>, void>

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>>

send

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