@xyo-network/bridge-abstract 2.107.3 → 2.107.4

package/dist/neutral/index.js

@@ -1,2 +1,575 @@
-var k=Object.defineProperty;var l=(a,e)=>k(a,"name",{value:e,configurable:!0});import{assertEx as m}from"@xylabs/assert";import{exists as y}from"@xylabs/exists";import{forget as D}from"@xylabs/forget";import{globallyUnique as $}from"@xylabs/object";import{asArchivistInstance as U}from"@xyo-network/archivist-model";import{QueryBoundWitnessWrapper as L}from"@xyo-network/boundwitness-wrapper";import{BridgeConfigSchema as _,BridgeConnectQuerySchema as O,BridgeDisconnectQuerySchema as V,BridgeExposeQuerySchema as Q,BridgeUnexposeQuerySchema as R,ModuleFilterPayloadSchema as b}from"@xyo-network/bridge-model";import{AbstractModuleInstance as z}from"@xyo-network/module-abstract";import{AddressSchema as q,isAddressModuleFilter as J,isNameModuleFilter as K,resolveAddressToInstance as F,resolvePathToAddress as M,transformModuleIdentifier as G}from"@xyo-network/module-model";import{isPayloadOfSchemaType as C}from"@xyo-network/payload-model";var T=class a extends z{static{l(this,"AbstractBridge")}static configSchemas=[...super.configSchemas,_];static defaultConfigSchema=_;static uniqueName=$("AbstractBridge",a,"xyo");_roots;get allowNameResolution(){return this.params.allowNameResolution??!0}get discoverRoots(){return this.config.client?.discoverRoots??this.config.discoverRoots??(this.config.client===void 0?!1:"start")}get queries(){return[O,V,Q,R,...super.queries]}get resolver(){return m(this.params.resolver,()=>"No resolver provided")}async expose(e,s){this._noOverride("expose"),m(e!=="*",()=>"Exposing '*' not supported");let t=m(await M(this,e),()=>`Module to expose not found [${e}]`);console.log(`expose: ${t}`);let r=await this.exposeHandler(t,s);return await this.emit("exposed",{module:this,modules:r}),r}async exposed(){return this._noOverride("exposed"),await this.exposedHandler()}async resolve(e="*",s={}){let t=this._roots??[],r=s.direction==="up"?[this]:[...t,this];if(e==="*"){let o=(s.maxDepth??5)-1;return o<=0?r:[...r,...(await Promise.all(t.map(i=>i.resolve("*",{...s,maxDepth:o})))).flat()]}switch(typeof e){case"string":{let o=e.split(":"),i=m(o.shift(),()=>"Missing module identifier"),n=await G(i,this.moduleIdentifierTransformers),d=r.find(c=>n===c.address||n===c.modName);return o.length===0?d:d?.resolve(o.join(":"),s)}case"object":{let o=[];if(K(e))for(let i of r)i.modName&&e.name.includes(i.modName)&&o.push(i);if(J(e))for(let i of r)i.modName&&e.address.includes(i.address)&&o.push(i);return o}default:return}}async startHandler(){return this.discoverRoots==="lazy"?D(this.getRoots()):this.discoverRoots==="start"&&await this.getRoots(),!0}async unexpose(e,s){this._noOverride("unexpose");let t=m(await M(this,e),()=>`Module to unexpose not found [${e}]`),r=await this.unexposeHandler(t,s);return await this.emit("unexposed",{module:this,modules:r}),r}async queryHandler(e,s){let r=await(await L.parseQuery(e,s)).getQuery(),o=[];switch(r.schema){case Q:{let i=(s??[]).filter(C(b));m(i,()=>"At least one filter is required"),await Promise.all(i.map(async n=>{let{id:d,...c}=n;(await this.expose(d,c)).map(u=>{let g={address:u.address,schema:q};o.push(g)})}));break}case R:{let i=(s??[]).filter(C(b));m(i,()=>"At least one filter is required"),await Promise.all(i.map(async n=>{let{id:d,...c}=n;(await this.unexpose(d,c)).map(u=>{let g={address:u.address,schema:q};o.push(g)})}));break}default:return await super.queryHandler(e,s)}return o}async resolveArchivingArchivists(){let e=this.archiving?.archivists;if(!e)return[];let s=(await Promise.all(e.map(async r=>(await Promise.all((await this.parents()).map(o=>M(o,r)))).filter(y)))).flat().filter(y);return(await Promise.all(s.map(r=>F(this,r)))).filter(y).map(r=>U(r)).filter(y)}};import{ObjectResolverPriority as X}from"@xyo-network/module-model";import{CompositeModuleResolver as Y}from"@xyo-network/module-resolver";var H=class extends Y{static{l(this,"AbstractBridgeModuleResolver")}get priority(){return X.VeryLow}async resolveHandler(e,s,t){return e==="*"?[]:await super.resolveHandler(e,s)}};import{assertEx as f}from"@xylabs/assert";import{forget as P}from"@xylabs/forget";import{asAddress as fe}from"@xylabs/hex";import{compact as ye}from"@xylabs/lodash";import{toJsonString as we}from"@xylabs/object";import{BoundWitnessWrapper as ve,QueryBoundWitnessWrapper as ge}from"@xyo-network/boundwitness-wrapper";import{ModuleManifestPayloadSchema as Me,NodeManifestPayloadSchema as v}from"@xyo-network/manifest-model";import{AbstractModuleInstance as xe}from"@xyo-network/module-abstract";import{AddressPreviousHashSchema as Pe,DeadModuleError as Ae,ModuleAddressQuerySchema as A,ModuleManifestQuerySchema as I,ModuleStateQuerySchema as W}from"@xyo-network/module-model";import{ModuleWrapper as Se}from"@xyo-network/module-wrapper";import{PayloadBuilder as E}from"@xyo-network/payload-builder";import{isPayloadOfSchemaType as h,ModuleErrorSchema as j}from"@xyo-network/payload-model";import{QuerySchema as S}from"@xyo-network/query-payload-plugin";import{LRUCache as _e}from"lru-cache";import{assertEx as le}from"@xylabs/assert";import{exists as x}from"@xylabs/exists";import{Account as ce}from"@xyo-network/account";import{isAddressModuleFilter as ue,isNameModuleFilter as me,ObjectResolverPriority as he}from"@xyo-network/module-model";import{CompositeModuleResolver as pe}from"@xyo-network/module-resolver";import{isArchivistModule as Z}from"@xyo-network/archivist-model";import{ArchivistWrapper as ee}from"@xyo-network/archivist-wrapper";import{isDivinerModule as se}from"@xyo-network/diviner-model";import{DivinerWrapper as re}from"@xyo-network/diviner-wrapper";import{isNodeModule as te}from"@xyo-network/node-model";import{NodeWrapper as ie}from"@xyo-network/node-wrapper";import{isSentinelModule as oe}from"@xyo-network/sentinel-model";import{SentinelWrapper as ae}from"@xyo-network/sentinel-wrapper";import{isWitnessModule as ne}from"@xyo-network/witness-model";import{WitnessWrapper as de}from"@xyo-network/witness-wrapper";var N=l((a,e)=>{if(Z(a))return ee.wrap(a,e);if(se(a))return re.wrap(a,e);if(te(a))return ie.wrap(a,e);if(oe(a))return ae.wrap(a,e);if(ne(a))return de.wrap(a,e);throw"Failed to wrap"},"wrapModuleWithType");var w=class{static{l(this,"ModuleProxyResolver")}options;downResolver;constructor(e){this.options=e,this.downResolver=new pe({moduleIdentifierTransformers:e.moduleIdentifierTransformers,root:this.root})}get priority(){return he.VeryLow}get root(){return this.options.module}get childAddressMap(){return this.options.childAddressMap}get host(){return this.options.host}get module(){return this.options.module}addResolver(e){throw new Error("Not supported")}childManifest(e){return this.options.childManifests?.[e]}childState(e){return this.options.childStates?.[e]}removeResolver(e){throw new Error("Not supported")}async resolve(e="*",s){let t=s?.direction??"all";if(e==="*"){let r=Object.keys(this.childAddressMap);return(await Promise.all(r.map(i=>this.resolve(i,s)))).filter(x)}else if(typeof e=="string"){let r=e.split(":"),o=le(r.shift(),()=>"Invalid module identifier at first position"),i=await this.resolveIdentifier(o);if(i){let n=r.length>0?r.join(":"):void 0;if(t==="down"||t==="all"){let d=await this.downResolver.resolve(i);if(d)return n?d.resolve(n,s):d;let c=Object.keys(this.childAddressMap).includes(i)?i:Object.entries(this.childAddressMap).find(([p,u])=>u===i)?.[0];if(c){let p=await this.host.resolve(c,{...s,direction:"down"});if(p){let u=N(p,ce.randomSync());return n?u?.resolve(n,s):u}return}}}return}else{let r=e;if(ue(r))return(await Promise.all(r.address.map(i=>this.resolve(i,s)))).filter(x);if(me(r))return(await Promise.all(r.name.map(o=>this.resolve(o,s)))).filter(x)}}resolveIdentifier(e,s){if(this.childAddressMap[e])return e;let t=Object.entries(this.childAddressMap).find(([,r])=>r===e)?.[0];if(t)return t}async resolvePrivate(e,s){if(e==="*")return await Promise.resolve([])}};var B=class a extends xe{static{l(this,"AbstractModuleProxy")}static requiredQueries=[W];_config;_publicChildren;_state=void 0;_stateInProcess=!1;_spamTrap=new _e({max:1e3,ttl:1e3*60,ttlAutopurge:!0});constructor(e){e.addToResolvers=!1,super(a.privateConstructorKey,e,e.account)}get address(){return this.params.moduleAddress}get archiving(){return this.params?.archiving}get config(){return f(this._config,()=>"Config not set")}get queries(){return f(this._state,()=>"Module state not found.  Make sure proxy has been started").filter(s=>h(S)(s)).map(s=>s.query)}static hasRequiredQueries(e){return this.missingRequiredQueries(e).length===0}static missingRequiredQueries(e){let s=e.queries;return ye(this.requiredQueries.map(t=>s.includes(t)?null:t))}async addressPreviousHash(){let e={schema:A};return f((await this.sendQuery(e,void 0,this.account)).find(h(Pe)),()=>"Result did not include correct payload")}childAddressByName(e){let t=this._state?.filter(h(v))?.flatMap(r=>Object.entries(r.status?.children??{}));return fe(t?.find(([r,o])=>o===e)?.[0])}async childAddressMap(){let e=h(v)(this.params.manifest)?[this.params.manifest]:void 0,s={};e===void 0&&(e=(await this.state()).filter(h(v)));for(let t of e??[]){let r=t.modules?.public??[];for(let o of r)if(typeof o=="object"){let i=o.status?.address;i&&(s[i]=o.config.name??null)}}return s}async manifest(e){let s={schema:I,...e===void 0?{}:{maxDepth:e}};return(await this.sendQuery(s))[0]}async moduleAddress(){let e={schema:A};return await this.sendQuery(e)}async previousHash(){let e={schema:A};return(await this.sendQuery(e)).pop().previousHash}async publicChildren(){return this._publicChildren=this._publicChildren??await super.publicChildren(),this._publicChildren}async query(e,s){return this._checkDead(),await this.busy(async()=>{try{await this.checkSpam(e),this.archiving&&this.isAllowedArchivingQuery(e.schema)&&P(this.storeToArchivists([e,...s??[]])),this.params.onQuerySendStarted?.({payloads:s,query:e});let t=await this.proxyQueryHandler(e,s);return this.params.onQuerySendFinished?.({payloads:s,query:e,result:t,status:"success"}),this.archiving&&this.isAllowedArchivingQuery(e.schema)&&P(this.storeToArchivists(t.flat())),P(this.emit("moduleQueried",{module:this,payloads:s,query:e,result:t})),t}catch(t){this.params.onQuerySendFinished?.({payloads:s,query:e,status:"failure"});let r=t;this._lastError=r;let o=new Ae(this.address,r),i={message:o.message,name:o.name,schema:j},n=await E.build(f(ge.unwrap(e),()=>"Invalid query"));return await this.bindQueryResult(n,[],void 0,[i])}})}queryHandler(e,s,t){throw new Error("queryHandler should never be called")}async queryable(e,s,t){return await Promise.resolve(!0)}async resolveArchivingArchivists(){return await this.params.archiving?.resolveArchivists()??[]}setConfig(e){this._config=e}setState(e){this._state=e}async startHandler(){let e=this.params.manifest;if(!e){let t=(await this.state()).find(r=>h(v)(r)||h(Me)(r));e=f(t,()=>"Can't find manifest payload")}return this.setConfig({...e.config}),this.downResolver.addResolver(new w({childAddressMap:await this.childAddressMap(),host:this.params.host,module:this,moduleIdentifierTransformers:this.params.moduleIdentifierTransformers})),await super.startHandler()}async state(){if(this._state===void 0){let e={query:W,schema:S},s={query:I,schema:S};this._state=[e,s];let t=Se.wrap(this,this.account);this._state=await t.state()}return this._state}async filterErrors(e){return(await ve.wrap(e[0],e[1])).payloadsBySchema(j)}async checkSpam(e){let s=await E.hash(e),t=this._spamTrap.get(s)??0;t>0&&this.logger?.warn(`Spam trap triggered for query: ${s} from ${we(e.addresses)}`),this._spamTrap.set(s,t+1)}};export{T as AbstractBridge,H as AbstractBridgeModuleResolver,B as AbstractModuleProxy,w as ModuleProxyResolver,N as wrapModuleWithType};
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/AbstractBridge.ts
+import { assertEx } from "@xylabs/assert";
+import { exists } from "@xylabs/exists";
+import { forget } from "@xylabs/forget";
+import { globallyUnique } from "@xylabs/object";
+import { asArchivistInstance } from "@xyo-network/archivist-model";
+import { QueryBoundWitnessWrapper } from "@xyo-network/boundwitness-wrapper";
+import { BridgeConfigSchema, BridgeConnectQuerySchema, BridgeDisconnectQuerySchema, BridgeExposeQuerySchema, BridgeUnexposeQuerySchema, ModuleFilterPayloadSchema } from "@xyo-network/bridge-model";
+import { AbstractModuleInstance } from "@xyo-network/module-abstract";
+import { AddressSchema, isAddressModuleFilter, isNameModuleFilter, resolveAddressToInstance, resolvePathToAddress, transformModuleIdentifier } from "@xyo-network/module-model";
+import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
+var AbstractBridge = class _AbstractBridge extends AbstractModuleInstance {
+  static {
+    __name(this, "AbstractBridge");
+  }
+  static configSchemas = [
+    ...super.configSchemas,
+    BridgeConfigSchema
+  ];
+  static defaultConfigSchema = BridgeConfigSchema;
+  static uniqueName = globallyUnique("AbstractBridge", _AbstractBridge, "xyo");
+  _roots;
+  get allowNameResolution() {
+    return this.params.allowNameResolution ?? true;
+  }
+  get discoverRoots() {
+    return this.config.client?.discoverRoots ?? this.config.discoverRoots ?? (this.config.client === void 0 ? false : "start");
+  }
+  get queries() {
+    return [
+      BridgeConnectQuerySchema,
+      BridgeDisconnectQuerySchema,
+      BridgeExposeQuerySchema,
+      BridgeUnexposeQuerySchema,
+      ...super.queries
+    ];
+  }
+  get resolver() {
+    return assertEx(this.params.resolver, () => "No resolver provided");
+  }
+  async expose(id, options) {
+    this._noOverride("expose");
+    assertEx(id !== "*", () => "Exposing '*' not supported");
+    const addressToExpose = assertEx(await resolvePathToAddress(this, id), () => `Module to expose not found [${id}]`);
+    console.log(`expose: ${addressToExpose}`);
+    const modules = await this.exposeHandler(addressToExpose, options);
+    await this.emit("exposed", {
+      module: this,
+      modules
+    });
+    return modules;
+  }
+  async exposed() {
+    this._noOverride("exposed");
+    return await this.exposedHandler();
+  }
+  // eslint-disable-next-line complexity
+  async resolve(idOrFilter = "*", options = {}) {
+    const roots = this._roots ?? [];
+    const workingSet = options.direction === "up" ? [
+      this
+    ] : [
+      ...roots,
+      this
+    ];
+    if (idOrFilter === "*") {
+      const remainingDepth = (options.maxDepth ?? 5) - 1;
+      return remainingDepth <= 0 ? workingSet : [
+        ...workingSet,
+        ...(await Promise.all(roots.map((mod) => mod.resolve("*", {
+          ...options,
+          maxDepth: remainingDepth
+        })))).flat()
+      ];
+    }
+    switch (typeof idOrFilter) {
+      case "string": {
+        const parts = idOrFilter.split(":");
+        const first = assertEx(parts.shift(), () => "Missing module identifier");
+        const firstId = await transformModuleIdentifier(first, this.moduleIdentifierTransformers);
+        const result = workingSet.find((mod) => {
+          return firstId === mod.address || firstId === mod.modName;
+        });
+        return parts.length === 0 ? result : result?.resolve(parts.join(":"), options);
+      }
+      case "object": {
+        const results = [];
+        if (isNameModuleFilter(idOrFilter)) {
+          for (const mod of workingSet) {
+            if (mod.modName && idOrFilter.name.includes(mod.modName)) results.push(mod);
+          }
+        }
+        if (isAddressModuleFilter(idOrFilter)) {
+          for (const mod of workingSet) {
+            if (mod.modName && idOrFilter.address.includes(mod.address)) results.push(mod);
+          }
+        }
+        return results;
+      }
+      default: {
+        return;
+      }
+    }
+  }
+  async startHandler() {
+    if (this.discoverRoots === "lazy") {
+      forget(this.getRoots());
+    } else if (this.discoverRoots === "start") {
+      await this.getRoots();
+    }
+    return true;
+  }
+  async unexpose(id, options) {
+    this._noOverride("unexpose");
+    const addressToUnexpose = assertEx(await resolvePathToAddress(this, id), () => `Module to unexpose not found [${id}]`);
+    const modules = await this.unexposeHandler(addressToUnexpose, options);
+    await this.emit("unexposed", {
+      module: this,
+      modules
+    });
+    return modules;
+  }
+  async queryHandler(query, payloads) {
+    const wrapper = await QueryBoundWitnessWrapper.parseQuery(query, payloads);
+    const queryPayload = await wrapper.getQuery();
+    const resultPayloads = [];
+    switch (queryPayload.schema) {
+      case BridgeExposeQuerySchema: {
+        const filterPayloads = (payloads ?? []).filter(isPayloadOfSchemaType(ModuleFilterPayloadSchema));
+        assertEx(filterPayloads, () => "At least one filter is required");
+        await Promise.all(filterPayloads.map(async (filter) => {
+          const { id, ...options } = filter;
+          const modules = await this.expose(id, options);
+          modules.map((module) => {
+            const addressPayload = {
+              address: module.address,
+              schema: AddressSchema
+            };
+            resultPayloads.push(addressPayload);
+          });
+        }));
+        break;
+      }
+      case BridgeUnexposeQuerySchema: {
+        const filterPayloads = (payloads ?? []).filter(isPayloadOfSchemaType(ModuleFilterPayloadSchema));
+        assertEx(filterPayloads, () => "At least one filter is required");
+        await Promise.all(filterPayloads.map(async (filter) => {
+          const { id, ...options } = filter;
+          const modules = await this.unexpose(id, options);
+          modules.map((module) => {
+            const addressPayload = {
+              address: module.address,
+              schema: AddressSchema
+            };
+            resultPayloads.push(addressPayload);
+          });
+        }));
+        break;
+      }
+      default: {
+        return await super.queryHandler(query, payloads);
+      }
+    }
+    return resultPayloads;
+  }
+  async resolveArchivingArchivists() {
+    const archivists = this.archiving?.archivists;
+    if (!archivists) return [];
+    const resolvedAddresses = (await Promise.all(archivists.map(async (archivist) => (await Promise.all((await this.parents()).map((parent) => resolvePathToAddress(parent, archivist)))).filter(exists)))).flat().filter(exists);
+    const resolved = (await Promise.all(resolvedAddresses.map((address) => resolveAddressToInstance(this, address)))).filter(exists);
+    return resolved.map((mod) => asArchivistInstance(mod)).filter(exists);
+  }
+};
+
+// src/AbstractBridgeModuleResolver.ts
+import { ObjectResolverPriority } from "@xyo-network/module-model";
+import { CompositeModuleResolver } from "@xyo-network/module-resolver";
+var AbstractBridgeModuleResolver = class extends CompositeModuleResolver {
+  static {
+    __name(this, "AbstractBridgeModuleResolver");
+  }
+  get priority() {
+    return ObjectResolverPriority.VeryLow;
+  }
+  async resolveHandler(id, options, _params) {
+    if (id === "*") {
+      return [];
+    }
+    return await super.resolveHandler(id, options);
+  }
+};
+
+// src/AbstractModuleProxy/AbstractModuleProxy.ts
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { forget as forget2 } from "@xylabs/forget";
+import { asAddress } from "@xylabs/hex";
+import { compact } from "@xylabs/lodash";
+import { toJsonString } from "@xylabs/object";
+import { BoundWitnessWrapper, QueryBoundWitnessWrapper as QueryBoundWitnessWrapper2 } from "@xyo-network/boundwitness-wrapper";
+import { ModuleManifestPayloadSchema, NodeManifestPayloadSchema } from "@xyo-network/manifest-model";
+import { AbstractModuleInstance as AbstractModuleInstance2 } from "@xyo-network/module-abstract";
+import { AddressPreviousHashSchema, DeadModuleError, ModuleAddressQuerySchema, ModuleManifestQuerySchema, ModuleStateQuerySchema } from "@xyo-network/module-model";
+import { ModuleWrapper } from "@xyo-network/module-wrapper";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { isPayloadOfSchemaType as isPayloadOfSchemaType2, ModuleErrorSchema } from "@xyo-network/payload-model";
+import { QuerySchema } from "@xyo-network/query-payload-plugin";
+import { LRUCache } from "lru-cache";
+
+// src/AbstractModuleProxy/ModuleProxyResolver.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { exists as exists2 } from "@xylabs/exists";
+import { Account } from "@xyo-network/account";
+import { isAddressModuleFilter as isAddressModuleFilter2, isNameModuleFilter as isNameModuleFilter2, ObjectResolverPriority as ObjectResolverPriority2 } from "@xyo-network/module-model";
+import { CompositeModuleResolver as CompositeModuleResolver2 } from "@xyo-network/module-resolver";
+
+// src/wrapModuleWithType.ts
+import { isArchivistModule } from "@xyo-network/archivist-model";
+import { ArchivistWrapper } from "@xyo-network/archivist-wrapper";
+import { isDivinerModule } from "@xyo-network/diviner-model";
+import { DivinerWrapper } from "@xyo-network/diviner-wrapper";
+import { isNodeModule } from "@xyo-network/node-model";
+import { NodeWrapper } from "@xyo-network/node-wrapper";
+import { isSentinelModule } from "@xyo-network/sentinel-model";
+import { SentinelWrapper } from "@xyo-network/sentinel-wrapper";
+import { isWitnessModule } from "@xyo-network/witness-model";
+import { WitnessWrapper } from "@xyo-network/witness-wrapper";
+var wrapModuleWithType = /* @__PURE__ */ __name((module, account) => {
+  if (isArchivistModule(module)) {
+    return ArchivistWrapper.wrap(module, account);
+  }
+  if (isDivinerModule(module)) {
+    return DivinerWrapper.wrap(module, account);
+  }
+  if (isNodeModule(module)) {
+    return NodeWrapper.wrap(module, account);
+  }
+  if (isSentinelModule(module)) {
+    return SentinelWrapper.wrap(module, account);
+  }
+  if (isWitnessModule(module)) {
+    return WitnessWrapper.wrap(module, account);
+  }
+  throw "Failed to wrap";
+}, "wrapModuleWithType");
+
+// src/AbstractModuleProxy/ModuleProxyResolver.ts
+var ModuleProxyResolver = class {
+  static {
+    __name(this, "ModuleProxyResolver");
+  }
+  options;
+  downResolver;
+  constructor(options) {
+    this.options = options;
+    this.downResolver = new CompositeModuleResolver2({
+      moduleIdentifierTransformers: options.moduleIdentifierTransformers,
+      root: this.root
+    });
+  }
+  get priority() {
+    return ObjectResolverPriority2.VeryLow;
+  }
+  get root() {
+    return this.options.module;
+  }
+  get childAddressMap() {
+    return this.options.childAddressMap;
+  }
+  get host() {
+    return this.options.host;
+  }
+  get module() {
+    return this.options.module;
+  }
+  addResolver(_resolver) {
+    throw new Error("Not supported");
+  }
+  childManifest(address) {
+    return this.options.childManifests?.[address];
+  }
+  childState(address) {
+    return this.options.childStates?.[address];
+  }
+  removeResolver(_resolver) {
+    throw new Error("Not supported");
+  }
+  // eslint-disable-next-line complexity
+  async resolve(idOrFilter = "*", options) {
+    const direction = options?.direction ?? "all";
+    if (idOrFilter === "*") {
+      const childAddresses = Object.keys(this.childAddressMap);
+      const resolvedChildren = await Promise.all(childAddresses.map((address) => this.resolve(address, options)));
+      return resolvedChildren.filter(exists2);
+    } else if (typeof idOrFilter === "string") {
+      const idParts = idOrFilter.split(":");
+      const firstPart = assertEx2(idParts.shift(), () => "Invalid module identifier at first position");
+      const firstPartAddress = await this.resolveIdentifier(firstPart);
+      if (firstPartAddress) {
+        const remainingParts = idParts.length > 0 ? idParts.join(":") : void 0;
+        if (direction === "down" || direction === "all") {
+          const downResolverModule = await this.downResolver.resolve(firstPartAddress);
+          if (downResolverModule) {
+            return remainingParts ? downResolverModule.resolve(remainingParts, options) : downResolverModule;
+          }
+          const addressToProxy = Object.keys(this.childAddressMap).includes(firstPartAddress) ? firstPartAddress : Object.entries(this.childAddressMap).find(([_, value]) => value === firstPartAddress)?.[0];
+          if (addressToProxy) {
+            const proxy = await this.host.resolve(addressToProxy, {
+              ...options,
+              direction: "down"
+            });
+            if (proxy) {
+              const wrapped = wrapModuleWithType(proxy, Account.randomSync());
+              return remainingParts ? wrapped?.resolve(remainingParts, options) : wrapped;
+            }
+            return;
+          }
+        }
+      }
+      return;
+    } else {
+      const filter = idOrFilter;
+      if (isAddressModuleFilter2(filter)) {
+        const results = (await Promise.all(filter.address.map((item) => this.resolve(item, options)))).filter(exists2);
+        return results;
+      } else if (isNameModuleFilter2(filter)) {
+        return (await Promise.all(filter.name.map((item) => this.resolve(item, options)))).filter(exists2);
+      }
+    }
+  }
+  resolveIdentifier(id, _options) {
+    if (this.childAddressMap[id]) {
+      return id;
+    }
+    const addressFromName = Object.entries(this.childAddressMap).find(([, name]) => name === id)?.[0];
+    if (addressFromName) {
+      return addressFromName;
+    }
+  }
+  async resolvePrivate(id, _options) {
+    if (id === "*") return await Promise.resolve([]);
+  }
+};
+
+// src/AbstractModuleProxy/AbstractModuleProxy.ts
+var AbstractModuleProxy = class _AbstractModuleProxy extends AbstractModuleInstance2 {
+  static {
+    __name(this, "AbstractModuleProxy");
+  }
+  static requiredQueries = [
+    ModuleStateQuerySchema
+  ];
+  _config;
+  _publicChildren;
+  _state = void 0;
+  _stateInProcess = false;
+  _spamTrap = new LRUCache({
+    max: 1e3,
+    ttl: 1e3 * 60,
+    ttlAutopurge: true
+  });
+  constructor(params) {
+    params.addToResolvers = false;
+    super(_AbstractModuleProxy.privateConstructorKey, params, params.account);
+  }
+  get address() {
+    return this.params.moduleAddress;
+  }
+  get archiving() {
+    return this.params?.archiving;
+  }
+  get config() {
+    return assertEx3(this._config, () => "Config not set");
+  }
+  get queries() {
+    const queryPayloads = assertEx3(this._state, () => "Module state not found.  Make sure proxy has been started").filter((item) => isPayloadOfSchemaType2(QuerySchema)(item));
+    return queryPayloads.map((payload) => payload.query);
+  }
+  static hasRequiredQueries(module) {
+    return this.missingRequiredQueries(module).length === 0;
+  }
+  static missingRequiredQueries(module) {
+    const moduleQueries = module.queries;
+    return compact(this.requiredQueries.map((query) => {
+      return moduleQueries.includes(query) ? null : query;
+    }));
+  }
+  async addressPreviousHash() {
+    const queryPayload = {
+      schema: ModuleAddressQuerySchema
+    };
+    const result = assertEx3((await this.sendQuery(queryPayload, void 0, this.account)).find(isPayloadOfSchemaType2(AddressPreviousHashSchema)), () => "Result did not include correct payload");
+    return result;
+  }
+  childAddressByName(name) {
+    const nodeManifests = this._state?.filter(isPayloadOfSchemaType2(NodeManifestPayloadSchema));
+    const childPairs = nodeManifests?.flatMap((nodeManifest) => Object.entries(nodeManifest.status?.children ?? {}));
+    return asAddress(childPairs?.find(([_, childName]) => childName === name)?.[0]);
+  }
+  async childAddressMap() {
+    let nodeManifests = isPayloadOfSchemaType2(NodeManifestPayloadSchema)(this.params.manifest) ? [
+      this.params.manifest
+    ] : void 0;
+    const result = {};
+    if (nodeManifests === void 0) {
+      const state = await this.state();
+      nodeManifests = state.filter(isPayloadOfSchemaType2(NodeManifestPayloadSchema));
+    }
+    for (const manifest of nodeManifests ?? []) {
+      const children = manifest.modules?.public ?? [];
+      for (const child of children) {
+        if (typeof child === "object") {
+          const address = child.status?.address;
+          if (address) {
+            result[address] = child.config.name ?? null;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  async manifest(maxDepth) {
+    const queryPayload = {
+      schema: ModuleManifestQuerySchema,
+      ...maxDepth === void 0 ? {} : {
+        maxDepth
+      }
+    };
+    return (await this.sendQuery(queryPayload))[0];
+  }
+  async moduleAddress() {
+    const queryPayload = {
+      schema: ModuleAddressQuerySchema
+    };
+    return await this.sendQuery(queryPayload);
+  }
+  async previousHash() {
+    const queryPayload = {
+      schema: ModuleAddressQuerySchema
+    };
+    return (await this.sendQuery(queryPayload)).pop().previousHash;
+  }
+  async publicChildren() {
+    this._publicChildren = this._publicChildren ?? await super.publicChildren();
+    return this._publicChildren;
+  }
+  async query(query, payloads) {
+    this._checkDead();
+    return await this.busy(async () => {
+      try {
+        await this.checkSpam(query);
+        if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
+          forget2(this.storeToArchivists([
+            query,
+            ...payloads ?? []
+          ]));
+        }
+        this.params.onQuerySendStarted?.({
+          payloads,
+          query
+        });
+        const result = await this.proxyQueryHandler(query, payloads);
+        this.params.onQuerySendFinished?.({
+          payloads,
+          query,
+          result,
+          status: "success"
+        });
+        if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
+          forget2(this.storeToArchivists(result.flat()));
+        }
+        forget2(this.emit("moduleQueried", {
+          module: this,
+          payloads,
+          query,
+          result
+        }));
+        return result;
+      } catch (ex) {
+        this.params.onQuerySendFinished?.({
+          payloads,
+          query,
+          status: "failure"
+        });
+        const error = ex;
+        this._lastError = error;
+        const deadError = new DeadModuleError(this.address, error);
+        const errorPayload = {
+          message: deadError.message,
+          name: deadError.name,
+          schema: ModuleErrorSchema
+        };
+        const sourceQuery = await PayloadBuilder.build(assertEx3(QueryBoundWitnessWrapper2.unwrap(query), () => "Invalid query"));
+        return await this.bindQueryResult(sourceQuery, [], void 0, [
+          errorPayload
+        ]);
+      }
+    });
+  }
+  queryHandler(_query, _payloads, _queryConfig) {
+    throw new Error("queryHandler should never be called");
+  }
+  async queryable(_query, _payloads, _queryConfig) {
+    return await Promise.resolve(true);
+  }
+  async resolveArchivingArchivists() {
+    return await this.params.archiving?.resolveArchivists() ?? [];
+  }
+  setConfig(config) {
+    this._config = config;
+  }
+  setState(state) {
+    this._state = state;
+  }
+  async startHandler() {
+    let manifest = this.params.manifest;
+    if (!manifest) {
+      const state = await this.state();
+      const manifestPayload = state.find((payload) => isPayloadOfSchemaType2(NodeManifestPayloadSchema)(payload) || isPayloadOfSchemaType2(ModuleManifestPayloadSchema)(payload));
+      manifest = assertEx3(manifestPayload, () => "Can't find manifest payload");
+    }
+    this.setConfig({
+      ...manifest.config
+    });
+    this.downResolver.addResolver(new ModuleProxyResolver({
+      childAddressMap: await this.childAddressMap(),
+      host: this.params.host,
+      module: this,
+      moduleIdentifierTransformers: this.params.moduleIdentifierTransformers
+    }));
+    return await super.startHandler();
+  }
+  async state() {
+    if (this._state === void 0) {
+      const stateQueryPayload = {
+        query: ModuleStateQuerySchema,
+        schema: QuerySchema
+      };
+      const manifestQueryPayload = {
+        query: ModuleManifestQuerySchema,
+        schema: QuerySchema
+      };
+      this._state = [
+        stateQueryPayload,
+        manifestQueryPayload
+      ];
+      const wrapper = ModuleWrapper.wrap(this, this.account);
+      this._state = await wrapper.state();
+    }
+    return this._state;
+  }
+  async filterErrors(result) {
+    const wrapper = await BoundWitnessWrapper.wrap(result[0], result[1]);
+    return wrapper.payloadsBySchema(ModuleErrorSchema);
+  }
+  //this checks and warns if we are getting spammed by the same query
+  async checkSpam(query) {
+    const hash = await PayloadBuilder.hash(query);
+    const previousCount = this._spamTrap.get(hash) ?? 0;
+    if (previousCount > 0) {
+      this.logger?.warn(`Spam trap triggered for query: ${hash} from ${toJsonString(query.addresses)}`);
+    }
+    this._spamTrap.set(hash, previousCount + 1);
+  }
+};
+export {
+  AbstractBridge,
+  AbstractBridgeModuleResolver,
+  AbstractModuleProxy,
+  ModuleProxyResolver,
+  wrapModuleWithType
+};
 //# sourceMappingURL=index.js.map