@xyo-network/module-abstract 2.75.0 → 2.75.2

package/dist/node/AbstractModuleInstance.js

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -17,19 +18,767 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/AbstractModuleInstance.ts
 var AbstractModuleInstance_exports = {};
 __export(AbstractModuleInstance_exports, {
   AbstractModuleInstance: () => AbstractModuleInstance
 });
 module.exports = __toCommonJS(AbstractModuleInstance_exports);
+var import_assert2 = require("@xylabs/assert");
+
+// src/AbstractModule.ts
 var import_assert = require("@xylabs/assert");
-var import_AbstractModule = require("./AbstractModule");
-class AbstractModuleInstance extends import_AbstractModule.AbstractModule {
-  static {
-    __name(this, "AbstractModuleInstance");
+var import_exists = require("@xylabs/exists");
+var import_lodash = require("@xylabs/lodash");
+var import_account = require("@xyo-network/account");
+var import_address_payload_plugin = require("@xyo-network/address-payload-plugin");
+var import_archivist_model = require("@xyo-network/archivist-model");
+var import_boundwitness_builder3 = require("@xyo-network/boundwitness-builder");
+var import_config_payload_plugin = require("@xyo-network/config-payload-plugin");
+var import_core2 = require("@xyo-network/core");
+var import_error = require("@xyo-network/error");
+var import_manifest_model = require("@xyo-network/manifest-model");
+var import_module_model = require("@xyo-network/module-model");
+var import_module_resolver = require("@xyo-network/module-resolver");
+var import_payload_builder2 = require("@xyo-network/payload-builder");
+var import_promise = require("@xyo-network/promise");
+var import_query_payload_plugin = require("@xyo-network/query-payload-plugin");
+var import_shared = require("@xyo-network/shared");
+
+// src/BaseEmitter.ts
+var import_core = require("@xyo-network/core");
+var import_module_events = require("@xyo-network/module-events");
+var _BaseEmitter = class _BaseEmitter extends import_core.Base {
+  //just here to query types
+  eventData = {};
+  events;
+  constructor(params) {
+    super(params);
+    this.events = new import_module_events.Events();
+  }
+  clearListeners(eventNames) {
+    return this.events.clearListeners(eventNames);
+  }
+  emit(eventName, eventArgs) {
+    return this.events.emit(eventName, eventArgs);
+  }
+  emitSerial(eventName, eventArgs) {
+    return this.events.emitSerial(eventName, eventArgs);
+  }
+  listenerCount(eventNames) {
+    return this.events.listenerCount(eventNames);
+  }
+  off(eventNames, listener) {
+    return this.events.off(eventNames, listener);
+  }
+  offAny(listener) {
+    return this.events.offAny(listener);
+  }
+  on(eventNames, listener) {
+    return this.events.on(eventNames, listener);
+  }
+  onAny(listener) {
+    return this.events.onAny(listener);
+  }
+  once(eventName, listener) {
+    return this.events.once(eventName, listener);
+  }
+};
+__name(_BaseEmitter, "BaseEmitter");
+var BaseEmitter = _BaseEmitter;
+
+// src/Error.ts
+var import_payload_builder = require("@xyo-network/payload-builder");
+var import_payload_model = require("@xyo-network/payload-model");
+var _ModuleErrorBuilder = class _ModuleErrorBuilder extends import_payload_builder.PayloadBuilder {
+  _message;
+  _name;
+  _query;
+  _sources;
+  constructor() {
+    super({
+      schema: import_payload_model.ModuleErrorSchema
+    });
+  }
+  build() {
+    return {
+      message: this._message,
+      name: this._name,
+      query: this._query,
+      schema: import_payload_model.ModuleErrorSchema,
+      sources: this._sources
+    };
+  }
+  message(message) {
+    this._message = message;
+    return this;
+  }
+  name(name) {
+    this._name = name;
+    return this;
+  }
+  query(query) {
+    this._query = query;
+    return this;
+  }
+  sources(sources) {
+    this._sources = sources;
+    return this;
+  }
+};
+__name(_ModuleErrorBuilder, "ModuleErrorBuilder");
+var ModuleErrorBuilder = _ModuleErrorBuilder;
+
+// src/QueryValidator/ModuleConfigQueryValidator.ts
+var import_boundwitness_builder = require("@xyo-network/boundwitness-builder");
+var delimiter = "";
+var _ModuleConfigQueryValidator = class _ModuleConfigQueryValidator {
+  allowed = {};
+  disallowed = {};
+  hasAllowedRules;
+  hasDisallowedRules;
+  hasRules;
+  constructor(config) {
+    var _a, _b, _c, _d;
+    if ((_a = config == null ? void 0 : config.security) == null ? void 0 : _a.allowed) {
+      Object.entries((_b = config.security) == null ? void 0 : _b.allowed).forEach(([schema, addresses]) => {
+        this.allowed[schema] = addresses.map(toAddressesString);
+      });
+    }
+    if ((_c = config == null ? void 0 : config.security) == null ? void 0 : _c.disallowed) {
+      Object.entries((_d = config.security) == null ? void 0 : _d.disallowed).forEach(([schema, addresses]) => {
+        this.disallowed[schema] = addresses.map(toAddressesString);
+      });
+    }
+    this.hasAllowedRules = Object.keys(this.allowed).length > 0;
+    this.hasDisallowedRules = Object.keys(this.disallowed).length > 0;
+    this.hasRules = this.hasAllowedRules || this.hasDisallowedRules;
+  }
+  queryable = async (query, payloads) => {
+    if (!this.hasRules)
+      return true;
+    const addresses = query.addresses;
+    if (!addresses.length)
+      return false;
+    const wrapper = import_boundwitness_builder.QueryBoundWitnessWrapper.parseQuery(query, payloads);
+    const schema = (await wrapper.getQuery()).schema;
+    return this.queryAllowed(schema, addresses) && !this.queryDisallowed(schema, addresses);
+  };
+  queryAllowed = (schema, addresses) => {
+    var _a, _b;
+    if (!this.hasAllowedRules)
+      return true;
+    if (addresses.length > 1) {
+      const signatories = toAddressesString(addresses);
+      const validCosigners = (_b = (_a = this.allowed) == null ? void 0 : _a[schema]) == null ? void 0 : _b.includes(signatories);
+      if (validCosigners)
+        return true;
+    }
+    return addresses.every((address) => {
+      var _a2, _b2;
+      return ((_b2 = (_a2 = this.allowed) == null ? void 0 : _a2[schema]) == null ? void 0 : _b2.includes(address)) || false;
+    });
+  };
+  queryDisallowed = (schema, addresses) => {
+    if (!this.hasDisallowedRules)
+      return false;
+    return addresses.some((address) => {
+      var _a, _b;
+      return (_b = (_a = this.disallowed) == null ? void 0 : _a[schema]) == null ? void 0 : _b.includes(address);
+    });
+  };
+};
+__name(_ModuleConfigQueryValidator, "ModuleConfigQueryValidator");
+var ModuleConfigQueryValidator = _ModuleConfigQueryValidator;
+var toAddressesString = /* @__PURE__ */ __name((addresses) => {
+  return Array.isArray(addresses) ? addresses.sort().map((address) => address.toLowerCase()).join(delimiter) : addresses.toLowerCase();
+}, "toAddressesString");
+
+// src/QueryValidator/SupportedQueryValidator.ts
+var import_boundwitness_builder2 = require("@xyo-network/boundwitness-builder");
+var isQuerySupportedByModule = /* @__PURE__ */ __name(async (mod, query, payloads) => {
+  const wrapper = import_boundwitness_builder2.QueryBoundWitnessWrapper.parseQuery(query, payloads);
+  const schema = (await wrapper.getQuery()).schema;
+  return mod.queries.includes(schema);
+}, "isQuerySupportedByModule");
+var _SupportedQueryValidator = class _SupportedQueryValidator {
+  mod;
+  constructor(mod) {
+    this.mod = mod;
+    this.queryable = (query, payloads) => {
+      return isQuerySupportedByModule(this.mod, query, payloads);
+    };
+  }
+  queryable;
+};
+__name(_SupportedQueryValidator, "SupportedQueryValidator");
+var SupportedQueryValidator = _SupportedQueryValidator;
+
+// src/AbstractModule.ts
+var _AbstractModule = class _AbstractModule extends BaseEmitter {
+  downResolver = new import_module_resolver.CompositeModuleResolver();
+  upResolver = new import_module_resolver.CompositeModuleResolver();
+  _account = void 0;
+  _baseModuleQueryAccountPaths = {
+    [import_module_model.ModuleAddressQuerySchema]: "1",
+    [import_module_model.ModuleDescribeQuerySchema]: "4",
+    [import_module_model.ModuleDiscoverQuerySchema]: "2",
+    [import_module_model.ModuleManifestQuerySchema]: "5",
+    [import_module_model.ModuleSubscribeQuerySchema]: "3"
+  };
+  _queryAccounts = {
+    [import_module_model.ModuleAddressQuerySchema]: void 0,
+    [import_module_model.ModuleDescribeQuerySchema]: void 0,
+    [import_module_model.ModuleDiscoverQuerySchema]: void 0,
+    [import_module_model.ModuleManifestQuerySchema]: void 0,
+    [import_module_model.ModuleSubscribeQuerySchema]: void 0
+  };
+  _startPromise = void 0;
+  _started = void 0;
+  moduleConfigQueryValidator;
+  supportedQueryValidator;
+  _busyCount = 0;
+  constructor(privateConstructorKey, params, account) {
+    (0, import_assert.assertEx)(_AbstractModule.privateConstructorKey === privateConstructorKey, "Use create function instead of constructor");
+    const mutatedParams = {
+      ...params
+    };
+    super(mutatedParams);
+    this._account = account;
+    this.supportedQueryValidator = new SupportedQueryValidator(this).queryable;
+    this.moduleConfigQueryValidator = new ModuleConfigQueryValidator(mutatedParams == null ? void 0 : mutatedParams.config).queryable;
+  }
+  static get configSchema() {
+    return this.configSchemas[0];
+  }
+  get account() {
+    return (0, import_assert.assertEx)(this._account, "Missing account");
+  }
+  get address() {
+    return this.account.address;
+  }
+  get allowAnonymous() {
+    var _a;
+    return !!((_a = this.config.security) == null ? void 0 : _a.allowAnonymous);
+  }
+  get config() {
+    return this.params.config;
+  }
+  get ephemeralQueryAccountEnabled() {
+    return !!this.params.ephemeralQueryAccountEnabled;
+  }
+  get queries() {
+    return [
+      import_module_model.ModuleDiscoverQuerySchema,
+      import_module_model.ModuleAddressQuerySchema,
+      import_module_model.ModuleSubscribeQuerySchema,
+      import_module_model.ModuleDescribeQuerySchema,
+      import_module_model.ModuleManifestQuerySchema
+    ];
+  }
+  get queryAccountPaths() {
+    return {
+      ...this._baseModuleQueryAccountPaths,
+      ...this._queryAccountPaths
+    };
+  }
+  get queryAccounts() {
+    return this._queryAccounts;
+  }
+  get timestamp() {
+    return this.config.timestamp ?? false;
+  }
+  static _getRootFunction(funcName) {
+    let anyThis = this;
+    while (anyThis.__proto__[funcName]) {
+      anyThis = anyThis.__proto__;
+    }
+    return anyThis[funcName];
+  }
+  static _noOverride(functionName) {
+    const thisFunc = this[functionName];
+    const rootFunc = this._getRootFunction(functionName);
+    (0, import_assert.assertEx)(thisFunc === rootFunc, `Override not allowed for [${functionName}] - override ${functionName}Handler instead`);
   }
+  static async create(params) {
+    var _a, _b, _c, _d;
+    this._noOverride("create");
+    if (!this.configSchemas || this.configSchemas.length === 0) {
+      throw Error(`Missing configSchema [${(_a = params == null ? void 0 : params.config) == null ? void 0 : _a.schema}][${this.name}]`);
+    }
+    const { account, config, wallet } = params ?? {};
+    const { accountDerivationPath } = config ?? {};
+    (0, import_assert.assertEx)(!(!!account && !!wallet), `Specifying both {account} and {wallet} are not allowed [${config == null ? void 0 : config.schema}] [${account === "random" ? "random" : account == null ? void 0 : account.address}, ${wallet == null ? void 0 : wallet.address}]`);
+    const schema = ((_b = params == null ? void 0 : params.config) == null ? void 0 : _b.schema) ?? this.configSchema;
+    const allowedSchemas = this.configSchemas;
+    (0, import_assert.assertEx)(allowedSchemas.filter((allowedSchema) => allowedSchema === schema).length > 0, `Bad Config Schema [Received ${schema}] [Expected ${JSON.stringify(allowedSchemas)}]`);
+    const mutatedConfig = {
+      ...params == null ? void 0 : params.config,
+      schema
+    };
+    (_c = params == null ? void 0 : params.logger) == null ? void 0 : _c.debug(`config: ${JSON.stringify(mutatedConfig, null, 2)}`);
+    const mutatedParams = {
+      ...params,
+      config: mutatedConfig
+    };
+    const activeLogger = (params == null ? void 0 : params.logger) ?? _AbstractModule.defaultLogger;
+    const generatedAccount = await _AbstractModule.determineAccount({
+      account,
+      accountDerivationPath,
+      wallet
+    });
+    const address = generatedAccount.address;
+    mutatedParams.logger = activeLogger ? new import_shared.IdLogger(activeLogger, () => `0x${address}`) : void 0;
+    const newModule = new this(_AbstractModule.privateConstructorKey, mutatedParams, generatedAccount);
+    if (!_AbstractModule.enableLazyLoad) {
+      await ((_d = newModule.start) == null ? void 0 : _d.call(newModule));
+    }
+    return newModule;
+  }
+  static async determineAccount({ account, accountDerivationPath, wallet }) {
+    if (wallet) {
+      return (0, import_assert.assertEx)(accountDerivationPath ? await wallet.derivePath(accountDerivationPath) : wallet, "Failed to derive account from path");
+    } else if (account === "random") {
+      return await import_account.HDWallet.random();
+    } else if (account) {
+      return account;
+    } else {
+      console.warn("AbstractModule.determineAccount: No account provided - Creating Random account");
+      return await import_account.HDWallet.random();
+    }
+  }
+  static factory(params) {
+    return import_module_model.ModuleFactory.withParams(this, params);
+  }
+  _getRootFunction(funcName) {
+    let anyThis = this;
+    while (anyThis.__proto__[funcName]) {
+      anyThis = anyThis.__proto__;
+    }
+    return anyThis[funcName];
+  }
+  _noOverride(functionName) {
+    const thisFunc = this[functionName];
+    const rootFunc = this._getRootFunction(functionName);
+    (0, import_assert.assertEx)(thisFunc === rootFunc, `Override not allowed for [${functionName}] - override ${functionName}Handler instead`);
+  }
+  async busy(closure) {
+    if (this._busyCount <= 0) {
+      this._busyCount = 0;
+      const args = {
+        busy: true,
+        module: this
+      };
+      await this.emit("moduleBusy", args);
+    }
+    this._busyCount++;
+    try {
+      return await closure();
+    } finally {
+      this._busyCount--;
+      if (this._busyCount <= 0) {
+        this._busyCount = 0;
+        const args = {
+          busy: false,
+          module: this
+        };
+        await this.emit("moduleBusy", args);
+      }
+    }
+  }
+  emit(eventName, eventArgs) {
+    return super.emit(eventName, eventArgs);
+  }
+  previousHash() {
+    return this.account.previousHash;
+  }
+  async query(query, payloads, queryConfig) {
+    this._noOverride("query");
+    return await this.busy(async () => {
+      const resultPayloads = [];
+      const errorPayloads = [];
+      const queryAccount = this.ephemeralQueryAccountEnabled ? await import_account.HDWallet.random() : void 0;
+      try {
+        await this.started("throw");
+        if (!this.allowAnonymous) {
+          if (query.addresses.length === 0) {
+            throw Error(`Anonymous Queries not allowed, but running anyway [${this.config.name}], [${this.address}]`);
+          }
+        }
+        resultPayloads.push(...await this.queryHandler((0, import_assert.assertEx)(import_boundwitness_builder3.QueryBoundWitnessWrapper.unwrap(query)), payloads, queryConfig));
+      } catch (ex) {
+        await (0, import_error.handleErrorAsync)(ex, async (error) => {
+          errorPayloads.push(new ModuleErrorBuilder().sources([
+            await import_core2.PayloadHasher.hashAsync(query)
+          ]).name(this.config.name ?? "<Unknown>").query(query.schema).message(error.message).build());
+        });
+      }
+      if (this.timestamp) {
+        const timestamp = {
+          schema: "network.xyo.timestamp",
+          timestamp: Date.now()
+        };
+        resultPayloads.push(timestamp);
+      }
+      const result = await this.bindQueryResult(query, resultPayloads, queryAccount ? [
+        queryAccount
+      ] : [], errorPayloads);
+      const args = {
+        module: this,
+        payloads,
+        query,
+        result
+      };
+      await this.emit("moduleQueried", args);
+      return result;
+    });
+  }
+  queryable(query, payloads, queryConfig) {
+    if (!this.started("warn"))
+      return false;
+    const configValidator = queryConfig ? new ModuleConfigQueryValidator(Object.assign({}, this.config, queryConfig)).queryable : this.moduleConfigQueryValidator;
+    const validators = [
+      this.supportedQueryValidator,
+      configValidator
+    ];
+    return validators.every((validator) => validator(query, payloads));
+  }
+  async resolve(nameOrAddressOrFilter, options) {
+    const direction = (options == null ? void 0 : options.direction) ?? "all";
+    const up = direction === "up" || direction === "all";
+    const down = direction === "down" || direction === "all";
+    switch (typeof nameOrAddressOrFilter) {
+      case "string": {
+        return (down ? await this.downResolver.resolve(nameOrAddressOrFilter, options) : void 0) ?? (up ? await this.upResolver.resolve(nameOrAddressOrFilter, options) : void 0);
+      }
+      default: {
+        const filter = nameOrAddressOrFilter;
+        return [
+          ...down ? await this.downResolver.resolve(filter, options) : [],
+          ...up ? await this.upResolver.resolve(filter, options) : []
+        ].filter(import_module_model.duplicateModules);
+      }
+    }
+  }
+  start(_timeout) {
+    this._startPromise = this._startPromise ?? this.startHandler();
+    return this._startPromise;
+  }
+  async started(notStartedAction = "log", tryStart = true) {
+    const started = await this._started;
+    if (started === true) {
+      return true;
+    }
+    if (!started) {
+      this._started = (async () => {
+        var _a, _b, _c;
+        if (tryStart) {
+          try {
+            await this.start();
+            return true;
+          } catch (ex) {
+            (0, import_error.handleError)(ex, (error) => {
+              var _a2;
+              (_a2 = this.logger) == null ? void 0 : _a2.warn(`Autostart of Module Failed: ${error.message})`);
+              this._started = void 0;
+            });
+          }
+        }
+        switch (notStartedAction) {
+          case "throw":
+            throw Error(`Module not Started [${this.address}]`);
+          case "warn":
+            (_a = this.logger) == null ? void 0 : _a.warn("Module not started");
+            break;
+          case "error":
+            (_b = this.logger) == null ? void 0 : _b.error("Module not started");
+            break;
+          case "none":
+            break;
+          case "log":
+          default: {
+            (_c = this.logger) == null ? void 0 : _c.log("Module not started");
+            break;
+          }
+        }
+        return false;
+      })();
+    }
+    if (!this._started) {
+      throw "Failed to create start promise";
+    }
+    return await this._started;
+  }
+  async stop(_timeout) {
+    return await this.busy(async () => {
+      const result = await this.stopHandler();
+      this._started = void 0;
+      this._startPromise = void 0;
+      return result;
+    });
+  }
+  bindHashes(hashes, schema, account) {
+    const promise = new import_promise.PromiseEx((resolve) => {
+      const result = this.bindHashesInternal(hashes, schema, account);
+      resolve == null ? void 0 : resolve(result);
+      return result;
+    }, account);
+    return promise;
+  }
+  async bindHashesInternal(hashes, schema, account) {
+    var _a;
+    const builder = new import_boundwitness_builder3.BoundWitnessBuilder().hashes(hashes, schema).witness(this.account);
+    const result = (await (account ? builder.witness(account) : builder).build())[0];
+    (_a = this.logger) == null ? void 0 : _a.debug(`result: ${JSON.stringify(result, null, 2)}`);
+    return result;
+  }
+  bindQuery(query, payloads, account) {
+    const promise = new import_promise.PromiseEx(async (resolve) => {
+      const result = await this.bindQueryInternal(query, payloads, account);
+      resolve == null ? void 0 : resolve(result);
+      return result;
+    }, account);
+    return promise;
+  }
+  async bindQueryInternal(query, payloads, account) {
+    const builder = new import_boundwitness_builder3.QueryBoundWitnessBuilder().payloads(payloads).witness(this.account).query(query);
+    const result = await (account ? builder.witness(account) : builder).build();
+    return result;
+  }
+  async bindQueryResult(query, payloads, additionalWitnesses = [], errors) {
+    const builder = new import_boundwitness_builder3.BoundWitnessBuilder().payloads(payloads).errors(errors);
+    const queryWitnessAccount = this.queryAccounts[query.schema];
+    const witnesses = [
+      this.account,
+      queryWitnessAccount,
+      ...additionalWitnesses
+    ].filter(import_exists.exists);
+    builder.witnesses(witnesses);
+    const result = [
+      (await builder.build())[0],
+      payloads,
+      errors ?? []
+    ];
+    return result;
+  }
+  commitArchivist = () => this.getArchivist("commit");
+  async describeHandler() {
+    var _a;
+    const description = {
+      address: this.address,
+      queries: this.queries,
+      schema: import_module_model.ModuleDescriptionSchema
+    };
+    if ((_a = this.config) == null ? void 0 : _a.name) {
+      description.name = this.config.name;
+    }
+    const discover = await this.discoverHandler();
+    description.children = (0, import_lodash.compact)((discover == null ? void 0 : discover.map((payload) => {
+      const address = payload.schema === import_address_payload_plugin.AddressSchema ? payload.address : void 0;
+      return address != this.address ? address : void 0;
+    })) ?? []);
+    return description;
+  }
+  discoverHandler() {
+    var _a;
+    const config = this.config;
+    const address = new import_payload_builder2.PayloadBuilder({
+      schema: import_address_payload_plugin.AddressSchema
+    }).fields({
+      address: this.address,
+      name: (_a = this.config) == null ? void 0 : _a.name
+    }).build();
+    const queries = this.queries.map((query) => {
+      return new import_payload_builder2.PayloadBuilder({
+        schema: import_query_payload_plugin.QuerySchema
+      }).fields({
+        query
+      }).build();
+    });
+    const configSchema = {
+      config: config.schema,
+      schema: import_config_payload_plugin.ConfigSchema
+    };
+    return (0, import_lodash.compact)([
+      config,
+      configSchema,
+      address,
+      ...queries
+    ]);
+  }
+  async getArchivist(kind) {
+    var _a, _b;
+    if (!this.config.archivist)
+      return void 0;
+    const filter = typeof this.config.archivist === "string" || this.config.archivist instanceof String ? this.config.archivist : (_b = (_a = this.config) == null ? void 0 : _a.archivist) == null ? void 0 : _b[kind];
+    const resolved = await this.upResolver.resolve(filter);
+    return (0, import_archivist_model.asArchivistInstance)(resolved);
+  }
+  async initializeQueryAccounts() {
+    var _a, _b;
+    const paths = Object.values(this.queryAccountPaths).filter(import_exists.exists);
+    const distinctPaths = new Set(paths);
+    (0, import_assert.assertEx)(distinctPaths.size === paths.length, `${((_a = this.config) == null ? void 0 : _a.name) ? this.config.name + ": " : ""}Duplicate query account paths`);
+    const wallet = this.account;
+    if (wallet == null ? void 0 : wallet.derivePath) {
+      for (const key in this.queryAccountPaths) {
+        if (Object.prototype.hasOwnProperty.call(this.queryAccountPaths, key)) {
+          const query = key;
+          const queryAccountPath = this.queryAccountPaths[query];
+          if (queryAccountPath) {
+            this._queryAccounts[query] = await ((_b = wallet.derivePath) == null ? void 0 : _b.call(wallet, queryAccountPath));
+          }
+        }
+      }
+    }
+  }
+  manifestHandler(_ignoreAddresses) {
+    const name = this.config.name ?? "Anonymous";
+    return {
+      config: {
+        name,
+        ...this.config
+      },
+      schema: import_manifest_model.ModuleManifestPayloadSchema
+    };
+  }
+  moduleAddressHandler() {
+    const queryAccounts = Object.entries(this.queryAccounts).filter((value) => {
+      return (0, import_exists.exists)(value[1]);
+    }).map(([name2, account]) => {
+      const address2 = account.address;
+      const previousHash2 = account.previousHash;
+      return [
+        {
+          address: address2,
+          name: name2,
+          schema: import_address_payload_plugin.AddressSchema
+        },
+        {
+          address: address2,
+          previousHash: previousHash2,
+          schema: import_module_model.AddressPreviousHashSchema
+        }
+      ];
+    });
+    const address = this.address;
+    const name = this.config.name;
+    const previousHash = this.address;
+    const moduleAccount = name ? {
+      address,
+      name,
+      schema: import_address_payload_plugin.AddressSchema
+    } : {
+      address,
+      schema: import_address_payload_plugin.AddressSchema
+    };
+    const moduleAccountPreviousHash = previousHash ? {
+      address,
+      previousHash,
+      schema: import_module_model.AddressPreviousHashSchema
+    } : {
+      address,
+      schema: import_module_model.AddressPreviousHashSchema
+    };
+    return [
+      moduleAccount,
+      moduleAccountPreviousHash,
+      ...queryAccounts
+    ].flat();
+  }
+  async queryHandler(query, payloads, queryConfig) {
+    await this.started("throw");
+    const wrapper = import_boundwitness_builder3.QueryBoundWitnessWrapper.parseQuery(query, payloads);
+    const queryPayload = await wrapper.getQuery();
+    (0, import_assert.assertEx)(this.queryable(query, payloads, queryConfig));
+    const resultPayloads = [];
+    switch (queryPayload.schema) {
+      case import_module_model.ModuleManifestQuerySchema: {
+        resultPayloads.push(await this.manifestHandler());
+        break;
+      }
+      case import_module_model.ModuleDiscoverQuerySchema: {
+        resultPayloads.push(...await this.discoverHandler());
+        break;
+      }
+      case import_module_model.ModuleDescribeQuerySchema: {
+        resultPayloads.push(await this.describeHandler());
+        break;
+      }
+      case import_module_model.ModuleAddressQuerySchema: {
+        resultPayloads.push(...await this.moduleAddressHandler());
+        break;
+      }
+      case import_module_model.ModuleSubscribeQuerySchema: {
+        this.subscribeHandler();
+        break;
+      }
+      default:
+        throw Error(`Unsupported Query [${queryPayload.schema}]`);
+    }
+    return resultPayloads;
+  }
+  readArchivist = () => this.getArchivist("read");
+  async startHandler() {
+    this.validateConfig();
+    await this.initializeQueryAccounts();
+    this._started = true;
+    return true;
+  }
+  stopHandler(_timeout) {
+    this._started = void 0;
+    return true;
+  }
+  subscribeHandler() {
+    return;
+  }
+  validateConfig(config, parents = []) {
+    return Object.entries(config ?? this.config ?? {}).reduce((valid, [key, value]) => {
+      var _a, _b;
+      switch (typeof value) {
+        case "function":
+          (_a = this.logger) == null ? void 0 : _a.warn(`Fields of type function not allowed in config [${parents == null ? void 0 : parents.join(".")}.${key}]`);
+          return false;
+        case "object": {
+          if (Array.isArray(value)) {
+            return value.reduce((valid2, value2) => {
+              return this.validateConfig(value2, [
+                ...parents,
+                key
+              ]) && valid2;
+            }, true) && valid;
+          }
+          if (!(0, import_module_model.serializableField)(value)) {
+            (_b = this.logger) == null ? void 0 : _b.warn(`Fields that are not serializable to JSON are not allowed in config [${parents == null ? void 0 : parents.join(".")}.${key}]`);
+            return false;
+          }
+          return value ? this.validateConfig(value, [
+            ...parents,
+            key
+          ]) && valid : true;
+        }
+        default:
+          return valid;
+      }
+    }, true);
+  }
+  writeArchivist = () => this.getArchivist("write");
+};
+__name(_AbstractModule, "AbstractModule");
+__publicField(_AbstractModule, "configSchemas");
+__publicField(_AbstractModule, "enableLazyLoad", false);
+__publicField(_AbstractModule, "privateConstructorKey", Date.now().toString());
+var AbstractModule = _AbstractModule;
+
+// src/AbstractModuleInstance.ts
+var _AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModule {
   constructor(privateConstructorKey, params, account) {
-    (0, import_assert.assertEx)(import_AbstractModule.AbstractModule.privateConstructorKey === privateConstructorKey, "Use create function instead of constructor");
+    (0, import_assert2.assertEx)(AbstractModule.privateConstructorKey === privateConstructorKey, "Use create function instead of constructor");
     const mutatedParams = {
       ...params
     };
@@ -60,7 +809,9 @@ class AbstractModuleInstance extends import_AbstractModule.AbstractModule {
   subscribe(_queryAccount) {
     return this.subscribeHandler();
   }
-}
+};
+__name(_AbstractModuleInstance, "AbstractModuleInstance");
+var AbstractModuleInstance = _AbstractModuleInstance;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbstractModuleInstance