@xyo-network/module-abstract 2.56.2 → 2.57.4

package/src/AbstractModule.ts

@@ -1,5 +1,6 @@
 import { assertEx } from '@xylabs/assert'
-import { Account } from '@xyo-network/account'
+import { exists } from '@xylabs/exists'
+import { Account, HDWallet } from '@xyo-network/account'
 import { AccountInstance } from '@xyo-network/account-model'
 import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
 import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
@@ -8,7 +9,7 @@ import { ConfigPayload, ConfigSchema } from '@xyo-network/config-payload-plugin'
 import {
   AccountModuleParams,
   CreatableModule,
-  creatableModule,
+  CreatableModuleFactory,
   Module,
   ModuleConfig,
   ModuleDiscoverQuerySchema,
@@ -18,6 +19,7 @@ import {
   ModulePreviousHashQuerySchema,
   ModuleQueriedEventArgs,
   ModuleQuery,
+  ModuleQueryBase,
   ModuleQueryResult,
   ModuleSubscribeQuerySchema,
   Query,
@@ -36,12 +38,13 @@ import compact from 'lodash/compact'
 import { BaseEmitter } from './BaseEmitter'
 import { ModuleErrorBuilder } from './Error'
 import { duplicateModules, serializableField } from './lib'
+import { ModuleFactory } from './ModuleFactory'
 import { QueryBoundWitnessBuilder, QueryBoundWitnessWrapper } from './Query'
 import { ModuleConfigQueryValidator, Queryable, SupportedQueryValidator } from './QueryValidator'
 import { CompositeModuleResolver } from './Resolver'
 
-@creatableModule()
-export class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventData extends ModuleEventData = ModuleEventData>
+// @creatableModule()
+export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventData extends ModuleEventData = ModuleEventData>
   extends BaseEmitter<TParams, TEventData>
   implements Module<TParams, TEventData>
 {
@@ -50,10 +53,19 @@ export class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventD
   readonly downResolver = new CompositeModuleResolver()
   readonly upResolver = new CompositeModuleResolver()
 
+  protected readonly _baseModuleQueryAccountPaths: Record<ModuleQueryBase['schema'], string> = {
+    'network.xyo.query.module.account.hash.previous': '1',
+    'network.xyo.query.module.discover': '2',
+    'network.xyo.query.module.subscribe': '3',
+  }
+  protected readonly _queryAccounts: Record<ModuleQueryBase['schema'], AccountInstance | undefined> = {
+    'network.xyo.query.module.account.hash.previous': undefined,
+    'network.xyo.query.module.discover': undefined,
+    'network.xyo.query.module.subscribe': undefined,
+  }
   protected _started = false
   protected readonly account: AccountInstance
   protected readonly moduleConfigQueryValidator: Queryable
-
   protected readonly supportedQueryValidator: Queryable
 
   constructor(params: TParams) {
@@ -95,6 +107,16 @@ export class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventD
     return [ModuleDiscoverQuerySchema, ModulePreviousHashQuerySchema, ModuleSubscribeQuerySchema]
   }
 
+  get queryAccountPaths(): Readonly<Record<Query['schema'], string | undefined>> {
+    return { ...this._baseModuleQueryAccountPaths, ...this._queryAccountPaths }
+  }
+
+  get queryAccounts(): Readonly<Record<Query['schema'], AccountInstance | undefined>> {
+    return this._queryAccounts
+  }
+
+  protected abstract get _queryAccountPaths(): Record<Query['schema'], string>
+
   static async create<TModule extends Module>(this: CreatableModule<TModule>, params?: TModule['params']) {
     if (!this.configSchema) {
       throw Error(`Missing configSchema [${params?.config?.schema}][${this.name}]`)
@@ -113,6 +135,10 @@ export class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventD
     return newModule
   }
 
+  static factory<TModule extends Module>(this: CreatableModule<TModule>, params?: TModule['params']): CreatableModuleFactory<TModule> {
+    return ModuleFactory.withParams(this, params)
+  }
+
   discover(): Promisable<Payload[]> {
     const config = this.config
     const address = new PayloadBuilder<AddressPayload>({ schema: AddressSchema }).fields({ address: this.address, name: this.config.name }).build()
@@ -127,11 +153,25 @@ export class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventD
   }
 
   previousHash(): Promisable<Payload[]> {
-    const previous = {
-      huri: [this.account.previousHash?.hex],
-      schema: 'network.xyo.huri',
-    }
-    return [previous]
+    // Return array of all addresses and their previous hash
+    const queryAccountPreviousHashes = Object.entries(this.queryAccounts)
+      .filter((value): value is [string, AccountInstance] => {
+        return exists(value[1])
+      })
+      .map(([name, account]) => {
+        const address = account.addressValue.hex
+        const previousHash = account.previousHash?.hex
+        return { address, name, previousHash, schema: AddressSchema }
+      })
+    const moduleAccountPreviousHash = new PayloadBuilder<AddressPayload>({ schema: AddressSchema })
+      .fields({
+        address: this.address,
+        name: this.config.name,
+        previousHash: this.account.previousHash?.hex,
+        schema: AddressSchema,
+      })
+      .build()
+    return [moduleAccountPreviousHash, ...queryAccountPreviousHashes]
   }
 
   async query<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(
@@ -164,6 +204,7 @@ export class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventD
 
   start(_timeout?: number): Promisable<void> {
     this.validateConfig()
+    this.initializeQueryAccounts()
     this._started = true
   }
 
@@ -228,23 +269,43 @@ export class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventD
   ): [QueryBoundWitness, Payload[]] {
     const builder = new QueryBoundWitnessBuilder().payloads(payloads).witness(this.account).query(query)
     const result = (account ? builder.witness(account) : builder).build()
-    //this.logger?.debug(`result: ${JSON.stringify(result, null, 2)}`)
     return result
   }
 
-  protected bindResult(payloads: Payload[], account?: AccountInstance): PromiseEx<ModuleQueryResult, AccountInstance> {
-    const promise = new PromiseEx<ModuleQueryResult, AccountInstance>((resolve) => {
-      const result = this.bindResultInternal(payloads, account)
+  protected bindQueryResult<T extends Query | PayloadWrapper<Query>>(
+    query: T,
+    payloads: Payload[],
+    additionalWitnesses: AccountInstance[] = [],
+  ): PromiseEx<ModuleQueryResult, AccountInstance[]> {
+    const builder = new BoundWitnessBuilder().payloads(payloads)
+    const queryWitnessAccount = this.queryAccounts[query.schema as ModuleQueryBase['schema']]
+    const witnesses = [this.account, queryWitnessAccount, ...additionalWitnesses].filter(exists)
+    builder.witnesses(witnesses)
+    const result: ModuleQueryResult = [builder.build()[0], payloads]
+    return new PromiseEx<ModuleQueryResult, AccountInstance[]>((resolve) => {
       resolve?.(result)
       return result
-    }, account)
-    return promise
+    }, witnesses)
   }
 
-  protected bindResultInternal(payloads: Payload[], account?: AccountInstance): ModuleQueryResult {
-    const builder = new BoundWitnessBuilder().payloads(payloads).witness(this.account)
-    const result: ModuleQueryResult = [(account ? builder.witness(account) : builder).build()[0], payloads]
-    return result
+  protected initializeQueryAccounts() {
+    // Ensure distinct/unique wallet paths
+    const paths = Object.values(this.queryAccountPaths).filter(exists)
+    const distinctPaths = new Set<string>(paths)
+    assertEx(distinctPaths.size === paths.length, `${this.config?.name ? this.config.name + ': ' : ''}Duplicate query account paths`)
+    // Create an account for query this module supports
+    const wallet = this.account as unknown as HDWallet
+    if (wallet?.derivePath) {
+      for (const key in this.queryAccountPaths) {
+        if (Object.prototype.hasOwnProperty.call(this.queryAccountPaths, key)) {
+          const query = key as ModuleQueryBase['schema']
+          const queryAccountPath = this.queryAccountPaths[query]
+          if (queryAccountPath) {
+            this._queryAccounts[query] = wallet.derivePath(queryAccountPath)
+          }
+        }
+      }
+    }
   }
 
   protected loadAccount(account?: AccountInstance): AccountInstance {
@@ -288,7 +349,7 @@ export class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventD
       const error = ex as Error
       resultPayloads.push(new ModuleErrorBuilder().sources([wrapper.hash]).message(error.message).build())
     }
-    return await this.bindResult(resultPayloads, queryAccount)
+    return await this.bindQueryResult(typedQuery, resultPayloads, [queryAccount])
   }
 
   protected async resolve<TModule extends Module = Module>(filter?: ModuleFilter): Promise<TModule[]> {

package/src/ModuleFactory.ts

@@ -0,0 +1,35 @@
+import { Logger } from '@xyo-network/core'
+import { CreatableModule, CreatableModuleFactory, Module } from '@xyo-network/module-model'
+
+export interface CreatableModuleDictionary {
+  [key: string]: CreatableModuleFactory
+}
+
+export class ModuleFactory<TModule extends Module> implements CreatableModuleFactory<TModule> {
+  configSchema: CreatableModuleFactory<TModule>['configSchema']
+
+  creatableModule: CreatableModule<TModule>
+
+  defaultLogger?: Logger | undefined
+
+  defaultParams?: TModule['params']
+
+  constructor(creatableModule: CreatableModule<TModule>, params?: TModule['params']) {
+    this.creatableModule = creatableModule
+    this.defaultParams = params
+    this.configSchema = creatableModule.configSchema
+  }
+
+  static withParams<T extends Module>(creatableModule: CreatableModule<T>, params?: T['params']) {
+    return new ModuleFactory(creatableModule, params)
+  }
+
+  create<T extends Module>(this: CreatableModuleFactory<T>, params?: TModule['params'] | undefined): Promise<T> {
+    const factory = this as ModuleFactory<T>
+    return factory.creatableModule.create<T>(factory.defaultParams ? { ...factory.defaultParams, ...params } : params)
+  }
+
+  factory<T extends Module>(this: CreatableModule<T>, _params?: T['params'] | undefined): CreatableModuleFactory<T> {
+    throw new Error('Method not implemented.')
+  }
+}

package/src/Resolver/index.ts

@@ -1,8 +1,3 @@
-import { CompositeModuleResolver } from './CompositeModuleResolver'
+export * from './CompositeModuleResolver'
 export * from './ResolverEventEmitter'
-
-/** @deprecated use ModuleResolver */
-class SimpleModuleResolver extends CompositeModuleResolver {}
-
-// eslint-disable-next-line deprecation/deprecation
-export { CompositeModuleResolver, SimpleModuleResolver }
+export * from './SimpleModuleResolver'

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './AbstractModule'
 export * from './BaseEmitter'
 export * from './Error'
 export * from './lib'
+export * from './ModuleFactory'
 export * from './Query'
 export * from './QueryValidator'
 export * from './Resolver'

package/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["src/index.ts"],
+  "tsconfig": "./tsconfig.typedoc.json"
+}