@xyo-network/bridge-pub-sub 5.3.22 → 5.3.25

package/src/AsyncQueryBus/AsyncQueryBusHost.ts

@@ -1,305 +0,0 @@
-import {
-  assertEx, clearTimeoutEx, containsAll, setTimeoutEx,
-} from '@xylabs/sdk-js'
-import {
-  type Address, hexFromBigInt, hexToBigInt,
-} from '@xylabs/sdk-js'
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { isQueryBoundWitnessWithStorageMeta } from '@xyo-network/boundwitness-model'
-import { isBridgeInstance } from '@xyo-network/bridge-model'
-import type { BoundWitnessDivinerQueryPayload } from '@xyo-network/diviner-boundwitness-model'
-import { BoundWitnessDivinerQuerySchema } from '@xyo-network/diviner-boundwitness-model'
-import type {
-  ModuleIdentifier,
-  ModuleInstance,
-} from '@xyo-network/module-model'
-import {
-  asModuleInstance,
-  ModuleConfigSchema,
-  resolveAddressToInstance,
-  ResolveHelper,
-} from '@xyo-network/module-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type {
-  Schema, Sequence, WithStorageMeta,
-} from '@xyo-network/payload-model'
-import { SequenceConstants } from '@xyo-network/payload-model'
-
-import { AsyncQueryBusBase } from './AsyncQueryBusBase.ts'
-import type { AsyncQueryBusHostParams } from './model/index.ts'
-
-export interface ExposeOptions {
-  allowedQueries?: Schema[]
-  failOnAlreadyExposed?: boolean
-}
-
-const IDLE_POLLING_FREQUENCY_RATIO_MIN = 4 as const
-const IDLE_POLLING_FREQUENCY_RATIO_MAX = 64 as const
-const IDLE_POLLING_FREQUENCY_RATIO_DEFAULT = 16 as const
-
-const IDLE_THRESHOLD_RATIO_MIN = 4 as const
-const IDLE_THRESHOLD_RATIO_MAX = 64 as const
-const IDLE_THRESHOLD_RATIO_DEFAULT = 16 as const
-
-function bigintMax(...args: bigint[]): bigint {
-  if (args.length === 0) throw new Error('No values provided to bigintMax')
-  // eslint-disable-next-line unicorn/prefer-math-min-max, unicorn/no-array-reduce
-  return args.reduce((max, val) => (val > max ? val : max))
-}
-
-export class AsyncQueryBusHost<TParams extends AsyncQueryBusHostParams = AsyncQueryBusHostParams> extends AsyncQueryBusBase<TParams> {
-  protected _exposedAddresses = new Set<Address>()
-  private _exposeOptions: Record<Address, ExposeOptions> = {}
-  private _idle = false
-  private _lastQueryTime?: number
-  private _pollId?: string
-
-  constructor(params: TParams) {
-    super(params)
-  }
-
-  get exposedAddresses() {
-    return this._exposedAddresses
-  }
-
-  get idlePollFrequency() {
-    const frequency = this.config?.idlePollFrequency ?? IDLE_POLLING_FREQUENCY_RATIO_DEFAULT * this.pollFrequency
-    if (frequency < this.pollFrequency * IDLE_POLLING_FREQUENCY_RATIO_MIN) {
-      return IDLE_POLLING_FREQUENCY_RATIO_MIN * this.pollFrequency
-    }
-    if (frequency > this.pollFrequency * IDLE_POLLING_FREQUENCY_RATIO_MAX) {
-      return IDLE_POLLING_FREQUENCY_RATIO_MAX * this.pollFrequency
-    }
-    return frequency
-  }
-
-  get idleThreshold() {
-    const threshold = this.config?.idleThreshold ?? IDLE_THRESHOLD_RATIO_DEFAULT * this.idlePollFrequency
-    if (threshold < this.idlePollFrequency * IDLE_THRESHOLD_RATIO_MIN) {
-      return IDLE_POLLING_FREQUENCY_RATIO_MIN * this.pollFrequency
-    }
-    if (threshold > this.idlePollFrequency * IDLE_THRESHOLD_RATIO_MAX) {
-      return IDLE_POLLING_FREQUENCY_RATIO_MAX * this.pollFrequency
-    }
-    return threshold
-  }
-
-  get perAddressBatchQueryLimit(): number {
-    return this.config?.perAddressBatchQueryLimit ?? 10
-  }
-
-  get started() {
-    return !!this._pollId
-  }
-
-  expose(mod: ModuleInstance, options?: ExposeOptions) {
-    const { failOnAlreadyExposed } = options ?? {}
-    if (isBridgeInstance(mod)) {
-      this.logger?.warn(`Attempted to expose a BridgeModule [${mod.id}] - Not exposing`)
-    } else {
-      assertEx(!failOnAlreadyExposed || !this._exposedAddresses.has(mod.address), () => `Address already exposed: ${mod.id} [${mod.address}]`)
-      this._exposedAddresses.add(mod.address)
-      this._exposeOptions[mod.address] = { ...options }
-      this.logger?.debug(`${mod.id} exposed [${mod.address}]`)
-      return mod
-    }
-  }
-
-  async listeningModules(): Promise<ModuleInstance[]> {
-    const exposedModules = [...(this.config?.listeningModules ?? []), ...this.exposedAddresses.values()]
-    return await Promise.all(
-      exposedModules.map(async exposedModule =>
-        assertEx(
-          asModuleInstance(await resolveAddressToInstance(this.rootModule, exposedModule)),
-          () => `Unable to resolve listeningModule [${exposedModule}]`,
-        )),
-    )
-  }
-
-  start() {
-    if (this.started) {
-      console.warn('AsyncQueryBus starting when already started')
-    }
-    this.poll()
-  }
-
-  stop() {
-    if (!this.started) {
-      console.warn('AsyncQueryBus stopping when already stopped')
-    }
-    if (this._pollId) clearTimeoutEx(this._pollId)
-    this._pollId = undefined
-  }
-
-  async unexpose(id: ModuleIdentifier, validate = true) {
-    const mod = asModuleInstance(await this.rootModule.resolve(id, { maxDepth: 10 }))
-    if (mod) {
-      assertEx(!validate || this._exposedAddresses.has(mod.address), () => `Address not exposed [${mod.address}][${mod.id}]`)
-      this._exposedAddresses.delete(mod.address)
-      delete this._exposeOptions[mod.address]
-      this.logger?.debug(`${mod.address} [${mod.id}] unexposed`)
-    }
-    return mod
-  }
-
-  // eslint-disable-next-line complexity
-  protected callLocalModule = async (localModule: ModuleInstance, query: WithStorageMeta<QueryBoundWitness>) => {
-    this._idle = false
-    this._lastQueryTime = Date.now()
-    const localModuleName = localModule.id
-    const queryArchivist = assertEx(
-      await this.queriesArchivist(),
-      () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`,
-    )
-    const responsesArchivist = assertEx(
-      await this.responsesArchivist(),
-      () => `Unable to contact responsesArchivist [${this.config?.intersect?.queries?.archivist}]`,
-    )
-    const queryDestination = query?.$destination
-    if (queryDestination && queryDestination?.includes(localModule.address)) {
-      // Find the query
-      const queryIndex = query.payload_hashes.indexOf(query.query)
-      if (queryIndex !== -1) {
-        const querySchema = query.payload_schemas[queryIndex]
-        // If the destination can process this type of query
-        if (localModule.queries.includes(querySchema)) {
-          // Get the associated payloads
-          const queryPayloads = await queryArchivist.get(query.payload_hashes)
-          this.params.onQueryFulfillStarted?.({ payloads: queryPayloads, query })
-          const queryPayloadsDict = await PayloadBuilder.toAllHashMap(queryPayloads)
-          const queryHash = await PayloadBuilder.dataHash(query)
-          // Check that we have all the arguments for the command
-          if (!containsAll(Object.keys(queryPayloadsDict), query.payload_hashes)) {
-            this.logger?.error(`Error processing command ${queryHash} for module ${localModuleName}, missing payloads`)
-            return
-          }
-          try {
-            // Issue the query against module
-            const querySchema = queryPayloadsDict[query.query].schema
-            this.logger?.debug(`Issuing query ${querySchema} (${queryHash}) addressed to module: ${localModuleName}`)
-            const result = await localModule.query(query, queryPayloads, {
-              allowedQueries: this._exposeOptions[localModule.address]?.allowedQueries,
-              schema: ModuleConfigSchema,
-            })
-            const [bw, payloads, errors] = result
-            this.logger?.debug(`Replying to query ${queryHash} addressed to module: ${localModuleName}`)
-            const insertResult = await responsesArchivist.insert([bw, ...payloads, ...errors])
-            // If all archivists support the contract that numPayloads inserted === numPayloads returned we can
-            // do some deeper assertions here like lenIn === lenOut, but for now this should be good enough since BWs
-            // should always be unique causing at least one insertion
-            if (insertResult.length === 0) {
-              this.logger?.error(`Error replying to query ${queryHash} addressed to module: ${localModuleName}`)
-            }
-            if (query?._sequence) {
-              // TODO: This needs to be thought through as we can't use a distributed timestamp
-              // because of collisions. We need to ensure we are using the timestamp of the store
-              // so there's no chance of multiple commands at the same time
-              await this.commitState(localModule.address, query._sequence)
-            }
-            this.params.onQueryFulfillFinished?.({
-              payloads: queryPayloads, query, result, status: 'success',
-            })
-          } catch (error) {
-            this.params.onQueryFulfillFinished?.({
-              payloads: queryPayloads, query, status: 'failure',
-            })
-            this.logger?.error(`Error processing query ${queryHash} for module ${localModuleName}: ${error}`)
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Finds unprocessed commands addressed to the supplied address
-   * @param address The address to find commands for
-   */
-  protected findQueriesToAddress = async (address: Address) => {
-    const queriesDivinerId = assertEx(this.config?.intersect?.queries?.boundWitnessDiviner, () => 'No queries Diviner defined')
-    const queriesBoundWitnessDiviner = await this.queriesDiviner()
-    if (queriesBoundWitnessDiviner) {
-      // Retrieve last offset from state store
-      const prevState = await this.retrieveState(address)
-      const destination = [address]
-      const limit = this.perAddressBatchQueryLimit
-      // Filter for commands to us by destination address
-      const divinerQuery: BoundWitnessDivinerQueryPayload = {
-        destination,
-        limit,
-        order: 'asc',
-        schema: BoundWitnessDivinerQuerySchema,
-        cursor: prevState,
-      }
-      const result = await queriesBoundWitnessDiviner.divine([divinerQuery])
-      const queries = result.filter(isQueryBoundWitnessWithStorageMeta)
-      // eslint-disable-next-line unicorn/no-array-reduce
-      const highestQuerySequence = queries.reduce(
-        (acc, query) => (hexFromBigInt(bigintMax(hexToBigInt(query._sequence), hexToBigInt(acc)))) as Sequence,
-        SequenceConstants.minLocalSequence as Sequence,
-      )
-      const nextState = queries.length > 0 ? highestQuerySequence : SequenceConstants.minLocalSequence
-      // TODO: This needs to be thought through as we can't use a distributed timestamp
-      // because of collisions. We need to use the timestamp of the store so there's no
-      // chance of multiple commands at the same time
-      await this.commitState(address, nextState)
-      this.logger?.debug('findQueriesToAddress', address, prevState, nextState)
-      return queries
-    } else {
-      this.logger?.warn(
-        `Unable to resolve queriesBoundWitnessDiviner [${queriesDivinerId}] [${await ResolveHelper.traceModuleIdentifier(this.rootModule, queriesDivinerId)}]`,
-      )
-    }
-  }
-
-  /**
-   * Runs the background divine process on a loop with a delay
-   * specified by the `config.pollFrequency`
-   */
-  private poll() {
-    this._pollId = setTimeoutEx(
-      async () => {
-        try {
-          await this.processIncomingQueries()
-        } catch (e) {
-          this.logger?.error?.(`Error in main loop: ${e}`)
-        } finally {
-          if (this._pollId) clearTimeoutEx(this._pollId)
-          this._pollId = undefined
-          this.poll()
-        }
-        const now = Date.now()
-        if (this.idleThreshold < now - (this._lastQueryTime ?? now)) {
-          this._idle = true
-        }
-      },
-      this._idle ? this.idlePollFrequency : this.pollFrequency,
-    )
-  }
-
-  /**
-   * Background process for checking for inbound queries
-   */
-  private processIncomingQueries = async () => {
-    this.logger?.debug('Checking for inbound queries')
-    // Check for any queries that have been issued and have not been responded to
-    const localModules = await this.listeningModules()
-
-    // TODO: Do in throttled batches
-    await Promise.allSettled(
-      localModules.map(async (localModule) => {
-        try {
-          const localModuleName = localModule.id
-          this.logger?.debug(`Checking for inbound queries to ${localModuleName} [${localModule.address}]`)
-          const queries = (await this.findQueriesToAddress(localModule.address)) ?? []
-          if (queries.length === 0) return
-          this.logger?.debug(`Found queries addressed to local module: ${localModuleName}`)
-          for (const query of queries) {
-            await this.callLocalModule(localModule, query)
-          }
-        } catch (error) {
-          this.logger?.error(`Error processing queries for address ${localModule.address}: ${error}`)
-        }
-      }),
-    )
-  }
-}

package/src/AsyncQueryBus/ModuleHost/ModuleHost.ts

@@ -1,30 +0,0 @@
-import type { ModuleHostParams } from '../../AbstractModuleHost/index.ts'
-import { AbstractModuleHost } from '../../AbstractModuleHost/index.ts'
-import { AsyncQueryBusHost } from '../AsyncQueryBusHost.ts'
-import type { AsyncQueryBusHostConfig } from '../model/index.ts'
-
-export type AsyncQueryBusModuleHostParams = ModuleHostParams & {
-  config: AsyncQueryBusHostConfig
-}
-
-export class AsyncQueryBusModuleHost extends AbstractModuleHost<AsyncQueryBusModuleHostParams> {
-  private _busHost?: AsyncQueryBusHost
-
-  constructor(params: AsyncQueryBusModuleHostParams) {
-    super(params)
-  }
-
-  override async start(): Promise<void> {
-    const listeningModules = this.params.config.listeningModules ?? (await this.params.mod.resolve('*', { direction: 'down' })).map(m => m.address)
-    this._busHost = new AsyncQueryBusHost({
-      config: { ...this.params.config, listeningModules },
-      logger: this.params.logger,
-      rootModule: this.params.mod,
-    })
-    this._busHost?.start()
-  }
-
-  override stop() {
-    this._busHost?.stop()
-  }
-}

package/src/AsyncQueryBus/ModuleHost/index.ts

@@ -1 +0,0 @@
-export * from './ModuleHost.ts'

package/src/AsyncQueryBus/ModuleProxy/ModuleProxy.ts

@@ -1,104 +0,0 @@
-import {
-  assertEx,
-  CreatableInstance, exists,
-  forget,
-  isAddress, isString,
-} from '@xylabs/sdk-js'
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import type { ModuleProxyParams } from '@xyo-network/bridge-abstract'
-import { AbstractModuleProxy } from '@xyo-network/bridge-abstract'
-import { AbstractModule } from '@xyo-network/module-abstract'
-import type {
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-  ModuleName,
-  ModuleQueryResult,
-  ResolveHelperConfig,
-} from '@xyo-network/module-model'
-import { creatableModule, ResolveHelper } from '@xyo-network/module-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { AsyncQueryBusClient } from '../AsyncQueryBusClient.ts'
-
-export interface AsyncQueryBusModuleProxyParams extends ModuleProxyParams {
-  busClient: AsyncQueryBusClient
-}
-
-@creatableModule()
-export class AsyncQueryBusModuleProxy<
-  TWrappedModule extends ModuleInstance = ModuleInstance,
->
-  extends AbstractModuleProxy<TWrappedModule, AsyncQueryBusModuleProxyParams & TWrappedModule['params']> {
-  override get id(): ModuleIdentifier {
-    return this.address
-  }
-
-  override get modName(): ModuleName | undefined {
-    return undefined
-  }
-
-  static override async createHandler<T extends CreatableInstance>(
-    inInstance: T,
-  ) {
-    const instance: T & AbstractModule = (await super.createHandler(inInstance))
-    return instance
-  }
-
-  async proxyQueryHandler<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryResult> {
-    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget(this.storeToArchivists([query, ...(payloads ?? [])]))
-    }
-    const result = await this.params.busClient.send(this.address, query, payloads)
-    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget(this.storeToArchivists(result.flat()))
-    }
-    return result
-  }
-
-  override async publicChildren(): Promise<ModuleInstance[]> {
-    return (
-      await Promise.all(
-        Object.keys(await this.childAddressMap())
-          .filter(exists)
-          .map(address => this.resolve(address)),
-      )
-    ).filter(exists)
-  }
-
-  /** @deprecated do not pass undefined.  If trying to get all, pass '*' */
-  override async resolve(): Promise<ModuleInstance[]>
-  override async resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
-  override async resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
-  override async resolve<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options: ModuleFilterOptions<T> = {},
-  ): Promise<T | T[] | undefined> {
-    const config: ResolveHelperConfig = {
-      address: this.address,
-      dead: this.dead,
-      downResolver: this.downResolver,
-      logger: this.logger,
-      mod: this,
-      transformers: this.moduleIdentifierTransformers,
-      upResolver: this.upResolver,
-    }
-    if (id === '*') {
-      return (await this.publicChildren()) as T[]
-    }
-    switch (typeof id) {
-      case 'string': {
-        const parts = id.split(':')
-        const first = assertEx(parts.shift(), () => 'Missing first')
-        const remainingPath = parts.length > 0 ? parts.join(':') : undefined
-        const address = isAddress(first) ? first : this.childAddressByName(first)
-        if (!isAddress(address)) return undefined
-        const firstInstance = (await this.params.host.resolve(address)) as ModuleInstance | undefined
-        return (isString(remainingPath) ? await firstInstance?.resolve(remainingPath) : firstInstance) as T | undefined
-      }
-      default: {
-        return (await ResolveHelper.resolve(config, id, options)).filter(mod => mod.address !== this.address)
-      }
-    }
-  }
-}

package/src/AsyncQueryBus/ModuleProxy/index.ts

@@ -1 +0,0 @@
-export * from './ModuleProxy.ts'

package/src/AsyncQueryBus/index.ts

@@ -1,5 +0,0 @@
-export * from './AsyncQueryBusClient.ts'
-export * from './AsyncQueryBusHost.ts'
-export * from './model/index.ts'
-export * from './ModuleHost/index.ts'
-export * from './ModuleProxy/index.ts'

package/src/AsyncQueryBus/model/BaseConfig.ts

@@ -1,17 +0,0 @@
-import type { SearchableStorage } from '@xyo-network/diviner-model'
-
-import type { AsyncQueryBusIntersectConfig } from './IntersectConfig.ts'
-
-export interface AsyncQueryBusBaseConfig {
-  intersect?: AsyncQueryBusIntersectConfig
-
-  /**
-   * How often to poll for new queries/responses
-   */
-  pollFrequency?: number
-
-  /**
-   * Where the archivist should persist its internal state
-   */
-  stateStore?: SearchableStorage
-}

package/src/AsyncQueryBus/model/ClientConfig.ts

@@ -1,11 +0,0 @@
-import type { BridgeClientConfig } from '@xyo-network/bridge-model'
-import type { CacheConfig } from '@xyo-network/module-model'
-
-import type { AsyncQueryBusBaseConfig } from './BaseConfig.ts'
-
-export interface AsyncQueryBusClientConfig extends AsyncQueryBusBaseConfig, BridgeClientConfig {
-  /**
-   * Configuration for intermediary response storage
-   */
-  queryCache?: CacheConfig | true
-}

package/src/AsyncQueryBus/model/HostConfig.ts

@@ -1,29 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-
-import type { AsyncQueryBusBaseConfig } from './BaseConfig.ts'
-
-export interface AsyncQueryBusHostConfig extends AsyncQueryBusBaseConfig {
-  /**
-   * The frequency at which the host should poll for new queries when no new queries have been received for a while
-   */
-
-  idlePollFrequency?: number
-
-  /**
-   * The threshold at which the host should consider itself idle and switch to the idle poll frequency
-   */
-
-  idleThreshold?: number
-
-  /**
-   * Modules that should be exposed via this host
-   */
-
-  listeningModules?: Address[]
-
-  /**
-   * How many queries to process at once when retrieving queries
-   * for an address
-   */
-  perAddressBatchQueryLimit?: number
-}

package/src/AsyncQueryBus/model/IntersectConfig.ts

@@ -1,13 +0,0 @@
-import type { SearchableStorage } from '@xyo-network/diviner-model'
-
-export interface AsyncQueryBusIntersectConfig {
-  /**
-   * Configuration for intermediary query storage
-   */
-  queries?: SearchableStorage
-
-  /**
-   * Configuration for intermediary response storage
-   */
-  responses?: SearchableStorage
-}

package/src/AsyncQueryBus/model/Params.ts

@@ -1,18 +0,0 @@
-import type { BaseParams } from '@xylabs/sdk-js'
-import type { QueryFulfillFinishedEventArgs, QueryFulfillStartedEventArgs } from '@xyo-network/bridge-model'
-import type { ModuleInstance } from '@xyo-network/module-model'
-
-import type { AsyncQueryBusBaseConfig } from './BaseConfig.ts'
-import type { AsyncQueryBusClientConfig } from './ClientConfig.ts'
-import type { AsyncQueryBusHostConfig } from './HostConfig.ts'
-
-export type AsyncQueryBusParams<TConfig extends AsyncQueryBusBaseConfig = AsyncQueryBusBaseConfig> = BaseParams<{
-  config?: TConfig
-  rootModule: ModuleInstance
-}>
-
-export type AsyncQueryBusClientParams = AsyncQueryBusParams<AsyncQueryBusClientConfig>
-export type AsyncQueryBusHostParams = AsyncQueryBusParams<AsyncQueryBusHostConfig> & {
-  onQueryFulfillFinished?: (args: Omit<QueryFulfillFinishedEventArgs, 'mod'>) => void
-  onQueryFulfillStarted?: (args: Omit<QueryFulfillStartedEventArgs, 'mod'>) => void
-}

package/src/AsyncQueryBus/model/QueryStatus.ts

@@ -1,2 +0,0 @@
-export const Pending = 'pending' as const
-export type Pending = typeof Pending

package/src/AsyncQueryBus/model/index.ts

@@ -1,6 +0,0 @@
-export * from './BaseConfig.ts'
-export * from './ClientConfig.ts'
-export * from './HostConfig.ts'
-export * from './IntersectConfig.ts'
-export * from './Params.ts'
-export * from './QueryStatus.ts'

package/src/Config.ts

@@ -1,22 +0,0 @@
-import type { Address, EmptyObject } from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/bridge-model'
-import type { Schema } from '@xyo-network/payload-model'
-import { asSchema } from '@xyo-network/payload-model'
-
-import type { AsyncQueryBusClientConfig, AsyncQueryBusHostConfig } from './AsyncQueryBus/index.ts'
-import { PubSubBridgeSchema } from './Schema.ts'
-
-export const PubSubBridgeConfigSchema = asSchema(`${PubSubBridgeSchema}.config`, true)
-export type PubSubBridgeConfigSchema = typeof PubSubBridgeConfigSchema
-
-/**
- * Configuration for the PubSubBridge
- */
-export type PubSubBridgeConfig<TConfig extends EmptyObject = EmptyObject, TSchema extends string | void = void> = BridgeConfig<
-  {
-    client?: AsyncQueryBusClientConfig
-    host?: AsyncQueryBusHostConfig
-    roots?: Address[]
-  } & TConfig,
-  TSchema extends Schema ? TSchema : PubSubBridgeConfigSchema
->

package/src/Params.ts

@@ -1,9 +0,0 @@
-import type { BridgeParams } from '@xyo-network/bridge-model'
-import type { AnyConfigSchema } from '@xyo-network/module-model'
-
-import type { PubSubBridgeConfig } from './Config.ts'
-
-/**
- * The parameters for the PubSubBridge
- */
-export type PubSubBridgeParams<TConfig extends AnyConfigSchema<PubSubBridgeConfig> = AnyConfigSchema<PubSubBridgeConfig>> = BridgeParams<TConfig>