Class MemoryNode<TParams, TEventData>

Type Parameters

TParams extends MemoryNodeParams = MemoryNodeParams
TEventData extends NodeModuleEventData = NodeModuleEventData

Hierarchy

AbstractNode<TParams, TEventData>
- MemoryNode

Implements

NodeModule<TParams, TEventData>

Index

Constructors

constructor

Accessors

_queryAccountPaths address allowAnonymous config isModuleResolver logger queries queryAccountPaths queryAccounts

Constructors

constructor

new MemoryNode<TParams, TEventData>(params): MemoryNode<TParams, TEventData>
Type Parameters
- TParams extends MemoryNodeParams = MemoryNodeParams
- TEventData extends NodeModuleEventData<TEventData> = NodeModuleEventData
Parameters
- params: TParams
Returns MemoryNode<TParams, TEventData>
Inherited from AbstractNode.constructor
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:22

Properties

`Protected` `Readonly` _baseModuleQueryAccountPaths

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

`Protected` `Readonly` _queryAccounts

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

`Protected` _started

_started: boolean

`Protected` `Readonly` account

account: AccountInstance

`Private` attachUsingAddress

attachUsingAddress: any

`Private` attachUsingName

attachUsingName: any

`Protected` commitArchivist

commitArchivist: (() => Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.archivist.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<{
    parents?: ArchivistParents;
    schema: "network.xyo.archivist.config";
    storeParentReads?: boolean;
} & Omit<undefined, "schema">, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ArchivistModuleEventData>>)

Type declaration

- (): Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>
- Returns Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>

`Private` detachUsingAddress

detachUsingAddress: any

`Private` detachUsingName

detachUsingName: any

`Readonly` downResolver

downResolver: CompositeModuleResolver

eventData

eventData: TEventData

`Private` moduleAddressFromName

moduleAddressFromName: any

`Protected` `Readonly` moduleConfigQueryValidator

moduleConfigQueryValidator: Queryable<SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}>

`Readonly` params

params: TParams

`Protected` `Readonly` privateResolver

privateResolver: CompositeModuleResolver

`Protected` readArchivist

readArchivist: (() => Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.archivist.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<{
    parents?: ArchivistParents;
    schema: "network.xyo.archivist.config";
    storeParentReads?: boolean;
} & Omit<undefined, "schema">, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ArchivistModuleEventData>>)

Type declaration

- (): Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>
- Returns Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>

`Private` registeredModuleMap

registeredModuleMap: any

`Protected` `Readonly` supportedQueryValidator

supportedQueryValidator: Queryable<SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}>

`Readonly` upResolver

upResolver: CompositeModuleResolver

`Protected` writeArchivist

writeArchivist: (() => Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.archivist.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<{
    parents?: ArchivistParents;
    schema: "network.xyo.archivist.config";
    storeParentReads?: boolean;
} & Omit<undefined, "schema">, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ArchivistModuleEventData>>)

Type declaration

- (): Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>
- Returns Promise<undefined | ArchivistModule<ArchivistParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.archivist.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<{
      parents?: ArchivistParents;
      schema: "network.xyo.archivist.config";
      storeParentReads?: boolean;
  } & Omit<undefined, "schema">, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ArchivistModuleEventData>>

`Static` configSchema

configSchema: "network.xyo.node.config"

`Static` `Optional` defaultLogger

defaultLogger?: Logger

Accessors

`Protected` _queryAccountPaths

get _queryAccountPaths(): Record<"network.xyo.query.node.attach" | "network.xyo.query.node.attached" | "network.xyo.query.node.detach" | "network.xyo.query.node.registered", string>
Returns Record<"network.xyo.query.node.attach" | "network.xyo.query.node.attached" | "network.xyo.query.node.detach" | "network.xyo.query.node.registered", string>
Inherited from AbstractNode._queryAccountPaths
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:11

address

get address(): string
Returns string
Implementation of NodeModule.address

Inherited from AbstractNode.address
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:23

allowAnonymous

get allowAnonymous(): boolean
Returns boolean
Inherited from AbstractNode.allowAnonymous
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:24

config

get config(): TParams["config"]
Returns TParams["config"]
Implementation of NodeModule.config

Inherited from AbstractNode.config
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:25

isModuleResolver

get isModuleResolver(): boolean
Returns boolean
Inherited from AbstractNode.isModuleResolver
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:9

`Protected` logger

get logger(): Logger | Console
Returns Logger | Console
Inherited from AbstractNode.logger
- Defined in protocol/packages/core/dist/types/lib/Base.d.ts:23

queries

get queries(): string[]
Returns string[]
Implementation of NodeModule.queries

Inherited from AbstractNode.queries
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:10

queryAccountPaths

get queryAccountPaths(): Readonly<Record<string, undefined | string>>
Returns Readonly<Record<string, undefined | string>>
Inherited from AbstractNode.queryAccountPaths
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:27

queryAccounts

get queryAccounts(): Readonly<Record<string, undefined | AccountInstance>>
Returns Readonly<Record<string, undefined | AccountInstance>>
Inherited from AbstractNode.queryAccounts
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:28

Methods

attach

attach(nameOrAddress, external?): Promise<undefined | string>
Parameters
- nameOrAddress: string
- Optional external: boolean
Returns Promise<undefined | string>
Implementation of NodeModule.attach

Overrides AbstractNode.attach
- Defined in modules/packages/node/dist/types/MemoryNode.d.ts:8

attached

attached(): Promise<string[]>
Returns Promise<string[]>
Implementation of NodeModule.attached

Inherited from AbstractNode.attached
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:13

attachedModules

attachedModules(): Promise<Module<ModuleParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.module.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<undefined, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ModuleEventData>[]>
Returns Promise<Module<ModuleParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.module.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<undefined, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ModuleEventData>[]>
Inherited from AbstractNode.attachedModules
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:14

`Protected` bindHashes

bindHashes(hashes, schema, account?): PromiseEx<unknown, AccountInstance>
Parameters
- hashes: string[]
- schema: string[]
- Optional account: AccountInstance
Returns PromiseEx<unknown, AccountInstance>
Inherited from AbstractNode.bindHashes
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:39

`Protected` bindHashesInternal

bindHashesInternal(hashes, schema, account?): Promise<SchemaFields & PayloadFields & BoundWitnessFields & {
schema: "network.xyo.boundwitness";
}>
Parameters
- hashes: string[]
- schema: string[]
- Optional account: AccountInstance
Returns Promise<SchemaFields & PayloadFields & BoundWitnessFields & {
schema: "network.xyo.boundwitness";
}>
Inherited from AbstractNode.bindHashesInternal
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:40

`Protected` bindQuery

bindQuery<T>(query, payloads?, account?): PromiseEx<[SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}, (SchemaFields & PayloadFields & {
    schema: string;
})[]], AccountInstance>
Type Parameters
- T extends SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  } | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  }>
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional account: AccountInstance
Returns PromiseEx<[SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}, (SchemaFields & PayloadFields & {
    schema: string;
})[]], AccountInstance>
Inherited from AbstractNode.bindQuery
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:41

`Protected` bindQueryInternal

bindQueryInternal<T>(query, payloads?, account?): Promise<[SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}, (SchemaFields & PayloadFields & {
    schema: string;
})[]]>
Type Parameters
- T extends SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  } | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  }>
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional account: AccountInstance
Returns Promise<[SchemaFields & PayloadFields & BoundWitnessFields & {
    query: string;
    resultSet?: string;
    schema: "network.xyo.boundwitness";
}, (SchemaFields & PayloadFields & {
    schema: string;
})[]]>
Inherited from AbstractNode.bindQueryInternal
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:42

`Protected` bindQueryResult

bindQueryResult<T>(query, payloads, additionalWitnesses?): PromiseEx<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>, AccountInstance[]>
Type Parameters
- T extends SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  } | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
  schema: string;
  }>
Parameters
- query: T
- payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional additionalWitnesses: AccountInstance[]
Returns PromiseEx<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>, AccountInstance[]>
Inherited from AbstractNode.bindQueryResult
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:43

clearListeners

clearListeners(eventNames): void
Parameters
- eventNames: keyof TEventData | (keyof TEventData)[]
Returns void
Implementation of NodeModule.clearListeners

Inherited from AbstractNode.clearListeners
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:7

detach

detach(nameOrAddress): Promise<undefined | string>
Parameters
- nameOrAddress: string
Returns Promise<undefined | string>
Implementation of NodeModule.detach

Overrides AbstractNode.detach
- Defined in modules/packages/node/dist/types/MemoryNode.d.ts:9

discover

discover(): Promise<(SchemaFields & PayloadFields & {
schema: string;
})[]>
Returns Promise<(SchemaFields & PayloadFields & {
schema: string;
})[]>
Inherited from AbstractNode.discover
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:15

emit

emit<TEventName, TEventArgs>(eventName, eventArgs): Promise<void>
Type Parameters
- TEventName extends string | number | symbol = keyof TEventData
- TEventArgs extends EventArgs = TEventData[TEventName]
Parameters
- eventName: TEventName
- eventArgs: TEventArgs
Returns Promise<void>
Implementation of NodeModule.emit

Inherited from AbstractNode.emit
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:8

emitSerial

emitSerial<TEventName, TEventArgs>(eventName, eventArgs): Promise<void>
Type Parameters
- TEventName extends string | number | symbol = keyof TEventData
- TEventArgs extends EventArgs = TEventData[TEventName]
Parameters
- eventName: TEventName
- eventArgs: TEventArgs
Returns Promise<void>
Implementation of NodeModule.emitSerial

Inherited from AbstractNode.emitSerial
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:9

`Protected` initializeQueryAccounts

initializeQueryAccounts(): void
Returns void
Inherited from AbstractNode.initializeQueryAccounts
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:77

listenerCount

listenerCount(eventNames): number
Parameters
- eventNames: keyof TEventData | (keyof TEventData)[]
Returns number
Implementation of NodeModule.listenerCount

Inherited from AbstractNode.listenerCount
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:10

`Protected` loadAccount

loadAccount(account?): AccountInstance
Parameters
- Optional account: AccountInstance
Returns AccountInstance
Inherited from AbstractNode.loadAccount
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:78

moduleAccountQuery

moduleAccountQuery(): Promisable<(SchemaFields & PayloadFields & {
    address: string;
    name?: string;
    schema: "network.xyo.address";
} | SchemaFields & PayloadFields & {
    address: string;
    previousHash?: string;
    schema: string;
})[], never>
Returns Promisable<(SchemaFields & PayloadFields & {
    address: string;
    name?: string;
    schema: "network.xyo.address";
} | SchemaFields & PayloadFields & {
    address: string;
    previousHash?: string;
    schema: string;
})[], never>
Inherited from AbstractNode.moduleAccountQuery
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:33

off

off<TEventName>(eventNames, listener): void
Type Parameters
- TEventName extends string | number | symbol
Parameters
- eventNames: TEventName | TEventName[]
- listener: EventListener<TEventData[TEventName]>
Returns void
Implementation of NodeModule.off

Inherited from AbstractNode.off
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:11

offAny

offAny(listener): void
Parameters
- listener: EventAnyListener<EventArgs>
Returns void
Implementation of NodeModule.offAny

Inherited from AbstractNode.offAny
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:12

on

on<TEventName>(eventNames, listener): (() => void)
Type Parameters
- TEventName extends string | number | symbol
Parameters
- eventNames: TEventName | TEventName[]
- listener: EventListener<TEventData[TEventName]>
Returns (() => void)
- - (): void
  - Returns void
Implementation of NodeModule.on

Inherited from AbstractNode.on
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:13

onAny

onAny(listener): (() => void)
Parameters
- listener: EventAnyListener<EventArgs>
Returns (() => void)
- - (): void
  - Returns void
Implementation of NodeModule.onAny

Inherited from AbstractNode.onAny
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:14

once

once<TEventName>(eventName, listener): (() => void)
Type Parameters
- TEventName extends string | number | symbol
Parameters
- eventName: TEventName
- listener: EventListener<TEventData[TEventName]>
Returns (() => void)
- - (): void
  - Returns void
Implementation of NodeModule.once

Inherited from AbstractNode.once
- Defined in modules/packages/module/packages/abstract/dist/types/BaseEmitter.d.ts:15

query

query<T, TConfig>(query, payloads?, queryConfig?): Promise<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>>
Type Parameters
- T extends SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  } = SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  }
- TConfig extends SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema"> = SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional queryConfig: TConfig
Returns Promise<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>>
Implementation of NodeModule.query

Inherited from AbstractNode.query
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:34

`Protected` queryHandler

queryHandler<T, TConfig>(query, payloads?, queryConfig?): Promise<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>>
Type Parameters
- T extends SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  } = SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  }
- TConfig extends SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema"> = SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional queryConfig: TConfig
Returns Promise<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>>
Inherited from AbstractNode.queryHandler
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:20

queryable

queryable<T, TConfig>(query, payloads?, queryConfig?): boolean
Type Parameters
- T extends SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  } = SchemaFields & PayloadFields & BoundWitnessFields & {
      query: string;
      resultSet?: string;
      schema: "network.xyo.boundwitness";
  }
- TConfig extends SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema"> = SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">
Parameters
- query: T
- Optional payloads: (SchemaFields & PayloadFields & {
  schema: string;
  })[]
- Optional queryConfig: TConfig
Returns boolean
Implementation of NodeModule.queryable

Inherited from AbstractNode.queryable
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:35

register

register(module): Promise<MemoryNode<TParams, TEventData>>
Parameters
- module: Module<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ModuleEventData>
Returns Promise<MemoryNode<TParams, TEventData>>
Overrides AbstractNode.register
- Defined in modules/packages/node/dist/types/MemoryNode.d.ts:10

registered

registered(): string[]
Returns string[]
Implementation of NodeModule.registered

Overrides AbstractNode.registered
- Defined in modules/packages/node/dist/types/MemoryNode.d.ts:11

registeredModules

registeredModules(): Module<ModuleParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.module.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<undefined, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ModuleEventData>[]
Returns Module<ModuleParams<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: string;
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<Omit<SchemaFields & PayloadFields & {
    archivist?: ArchivistModuleConfig;
    name?: string;
    paging?: Record<string, {
        size?: number;
    }>;
    schema: "network.xyo.module.config";
    security?: {
        allowAnonymous?: boolean;
        allowed?: Record<string, (string | CosigningAddressSet)[]>;
        disallowed?: Record<string, string[]>;
    };
    storeQueries?: boolean;
} & Omit<undefined, "schema">, "schema"> & {
    schema: string;
}, "schema">, undefined>, ModuleEventData>[]
Overrides AbstractNode.registeredModules
- Defined in modules/packages/node/dist/types/MemoryNode.d.ts:12

`Protected` resolve

resolve<TModule>(filter?): Promise<TModule[]>
Type Parameters
- TModule extends ModuleFields<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>> & EventFunctions<ModuleEventData, TModule> = Module<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ModuleEventData>
Parameters
- Optional filter: ModuleFilter
Returns Promise<TModule[]>
Overrides AbstractNode.resolve
- Defined in modules/packages/node/dist/types/MemoryNode.d.ts:42

start

start(_timeout?): Promisable<void, never>
Parameters
- Optional _timeout: number
Returns Promisable<void, never>
Implementation of NodeModule.start

Inherited from AbstractNode.start
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:36

started

started(notStartedAction?): boolean
Parameters
- Optional notStartedAction: "error" | "throw" | "warn" | "log" | "none"
Returns boolean
Inherited from AbstractNode.started
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:37

`Protected` stop

stop(_timeout?): Promisable<MemoryNode<TParams, TEventData>, never>
Parameters
- Optional _timeout: number
Returns Promisable<MemoryNode<TParams, TEventData>, never>
Inherited from AbstractNode.stop
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:114

subscribe(_queryAccount?): void
Parameters
- Optional _queryAccount: AccountInstance
Returns void
Inherited from AbstractNode.subscribe
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:38

unregister

unregister(module): Promise<MemoryNode<TParams, TEventData>>
Parameters
- module: Module<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>, ModuleEventData>
Returns Promise<MemoryNode<TParams, TEventData>>
Overrides AbstractNode.unregister
- Defined in modules/packages/node/dist/types/MemoryNode.d.ts:41

`Protected` validateConfig

validateConfig(config?, parents?): boolean
Parameters
- Optional config: unknown
- Optional parents: string[]
Returns boolean
Inherited from AbstractNode.validateConfig
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:115

`Static` create

create<TModule>(this, params?): Promise<TModule>
Type Parameters
- TModule extends ModuleFields<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>> & EventFunctions<ModuleEventData, TModule>
Parameters
- this: CreatableModule<TModule>
- Optional params: TModule["params"]
Returns Promise<TModule>
Inherited from AbstractNode.create
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:30

`Static` factory

factory<TModule>(this, params?): CreatableModuleFactory<TModule>
Type Parameters
- TModule extends ModuleFields<ModuleParams<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: string;
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<Omit<SchemaFields & PayloadFields & {
      archivist?: ArchivistModuleConfig;
      name?: string;
      paging?: Record<string, {
          size?: number;
      }>;
      schema: "network.xyo.module.config";
      security?: {
          allowAnonymous?: boolean;
          allowed?: Record<string, (string | CosigningAddressSet)[]>;
          disallowed?: Record<string, string[]>;
      };
      storeQueries?: boolean;
  } & Omit<undefined, "schema">, "schema"> & {
      schema: string;
  }, "schema">, undefined>> & EventFunctions<ModuleEventData, TModule>
Parameters
- this: CreatableModule<TModule>
- Optional params: TModule["params"]
Returns CreatableModuleFactory<TModule>
Inherited from AbstractNode.factory
- Defined in modules/packages/module/packages/abstract/dist/types/AbstractModule.d.ts:31

`Static` isNode

isNode(module): boolean
Parameters
- module: unknown
Returns boolean
Inherited from AbstractNode.isNode
- Defined in modules/packages/node/dist/types/AbstractNode.d.ts:12

Class MemoryNode<TParams, TEventData>

Type Parameters

TParams extends MemoryNodeParams = MemoryNodeParams

TEventData extends NodeModuleEventData = NodeModuleEventData

Hierarchy

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

TParams extends MemoryNodeParams = MemoryNodeParams

TEventData extends NodeModuleEventData<TEventData> = NodeModuleEventData

Parameters

params: TParams

Returns MemoryNode<TParams, TEventData>

Properties

Protected Readonly _baseModuleQueryAccountPaths

Protected Readonly _queryAccounts

Protected _started

Protected Readonly account

Private attachUsingAddress

Private attachUsingName

Protected commitArchivist

Type declaration

Private detachUsingAddress

Private detachUsingName

Readonly downResolver

eventData

Private moduleAddressFromName

Protected Readonly moduleConfigQueryValidator

Readonly params

Protected Readonly privateResolver

Protected readArchivist

Type declaration

Private registeredModuleMap

Protected Readonly supportedQueryValidator

Readonly upResolver

Protected writeArchivist

Type declaration

Static configSchema

Static Optional defaultLogger

Accessors

Protected _queryAccountPaths

Returns Record<"network.xyo.query.node.attach" | "network.xyo.query.node.attached" | "network.xyo.query.node.detach" | "network.xyo.query.node.registered", string>

address

Returns string

allowAnonymous

Returns boolean

config

Returns TParams["config"]

isModuleResolver

Returns boolean

Protected logger

Returns Logger | Console

queries

Returns string[]

queryAccountPaths

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

queryAccounts

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

Methods

attach

Parameters

nameOrAddress: string

Optional external: boolean

Returns Promise<undefined | string>

attached

Returns Promise<string[]>

attachedModules

Protected bindHashes

Parameters

hashes: string[]

schema: string[]

Optional account: AccountInstance

Returns PromiseEx<unknown, AccountInstance>

Protected bindHashesInternal

`Protected` `Readonly` _baseModuleQueryAccountPaths

`Protected` `Readonly` _queryAccounts

`Protected` _started

`Protected` `Readonly` account

`Private` attachUsingAddress

`Private` attachUsingName

`Protected` commitArchivist

`Private` detachUsingAddress

`Private` detachUsingName

`Readonly` downResolver

`Private` moduleAddressFromName

`Protected` `Readonly` moduleConfigQueryValidator

`Readonly` params

`Protected` `Readonly` privateResolver

`Protected` readArchivist

`Private` registeredModuleMap

`Protected` `Readonly` supportedQueryValidator

`Readonly` upResolver

`Protected` writeArchivist

`Static` configSchema

`Static` `Optional` defaultLogger

`Protected` _queryAccountPaths

`Protected` logger

`Optional` external: boolean

`Protected` bindHashes

`Optional` account: AccountInstance

`Protected` bindHashesInternal

`Optional` account: AccountInstance

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

`Protected` bindQuery

T extends SchemaFields & PayloadFields & QueryFields & {
schema: string;
} | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
schema: string;
}>

`Optional` payloads: (SchemaFields & PayloadFields & {
schema: string;
})[]

`Optional` account: AccountInstance

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

`Protected` bindQueryInternal

T extends SchemaFields & PayloadFields & QueryFields & {
schema: string;
} | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
schema: string;
}>

`Optional` payloads: (SchemaFields & PayloadFields & {
schema: string;
})[]

`Optional` account: AccountInstance

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

`Protected` bindQueryResult

T extends SchemaFields & PayloadFields & QueryFields & {
schema: string;
} | PayloadWrapper<SchemaFields & PayloadFields & QueryFields & {
schema: string;
}>

payloads: (SchemaFields & PayloadFields & {
schema: string;
})[]

`Optional` additionalWitnesses: AccountInstance[]

Returns PromiseEx<ModuleQueryResult<SchemaFields & PayloadFields & {
schema: string;
}>, AccountInstance[]>

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

`Protected` initializeQueryAccounts

`Protected` loadAccount

`Optional` account: AccountInstance