@xyo-network/bridge-websocket 5.3.20 → 5.3.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/bridge-websocket",
-  "version": "5.3.20",
+  "version": "5.3.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -38,46 +38,63 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
-    "!**/*.test.*"
+    "!**/*.test.*",
+    "README.md"
   ],
   "dependencies": {
-    "@xyo-network/account": "~5.3.20",
-    "@xyo-network/boundwitness-model": "~5.3.20",
-    "@xyo-network/bridge-abstract": "~5.3.20",
-    "@xyo-network/bridge-model": "~5.3.20",
-    "@xyo-network/config-payload-plugin": "~5.3.20",
-    "@xyo-network/module-model": "~5.3.20",
-    "@xyo-network/payload-model": "~5.3.20",
     "async-mutex": "~0.5.0",
-    "lru-cache": "^11.2.7"
+    "lru-cache": "~11.2.7",
+    "@xyo-network/account": "~5.3.24",
+    "@xyo-network/bridge-abstract": "~5.3.24",
+    "@xyo-network/bridge-model": "~5.3.24",
+    "@xyo-network/config-payload-plugin": "~5.3.24",
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24",
+    "@xyo-network/module-model": "~5.3.24"
   },
   "devDependencies": {
-    "@xylabs/sdk-js": "^5.0.90",
-    "@xylabs/ts-scripts-common": "~7.5.6",
-    "@xylabs/ts-scripts-yarn3": "~7.5.6",
-    "@xylabs/tsconfig": "~7.5.6",
-    "@xylabs/vitest-extended": "~5.0.90",
-    "@xyo-network/account": "~5.3.20",
-    "@xyo-network/archivist-model": "~5.3.20",
-    "@xyo-network/node-memory": "~5.3.20",
-    "@xyo-network/node-model": "~5.3.20",
-    "@xyo-network/payload-builder": "~5.3.20",
-    "@xyo-network/payload-wrapper": "~5.3.20",
+    "@opentelemetry/api": "^1.9.1",
+    "@types/node": "^25.5.0",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "~7.6.16",
+    "@xylabs/vitest-extended": "~5.0.93",
+    "acorn": "^8.16.0",
+    "async-mutex": "~0.5.0",
+    "axios": "^1.14.0",
+    "esbuild": "^0.28.0",
+    "ethers": "^6.16.0",
+    "lru-cache": "~11.2.7",
     "socket.io": "~4.8.3",
     "socket.io-client": "~4.8.3",
+    "tslib": "^2.8.1",
     "typescript": "~5.9.3",
+    "vite": "^8.0.3",
     "vitest": "~4.1.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/bridge-abstract": "~5.3.24",
+    "@xyo-network/account": "~5.3.24",
+    "@xyo-network/archivist-model": "~5.3.24",
+    "@xyo-network/bridge-model": "~5.3.24",
+    "@xyo-network/config-payload-plugin": "~5.3.24",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24",
+    "@xyo-network/node-model": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24",
+    "@xyo-network/payload-wrapper": "~5.3.24",
+    "@xyo-network/node-memory": "~5.3.24"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
+    "ethers": "^6",
     "socket.io": "^4",
     "tslib": "^2.8.1"
   },
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/Bridge.ts

@@ -1,89 +0,0 @@
-import { createServer as createHttpServer, Server as HttpServer } from 'node:http'
-
-import {
-  Address, assertEx, Promisable,
-} from '@xylabs/sdk-js'
-import { BridgeExposeOptions, BridgeModule } from '@xyo-network/bridge-model'
-import {
-  AnyConfigSchema, creatableModule, ModuleInstance,
-} from '@xyo-network/module-model'
-import { Payload } from '@xyo-network/payload-model'
-import { Server, Socket } from 'socket.io'
-
-import { WebsocketClientBridge } from './ClientBridge.ts'
-import { WebsocketBridgeConfig } from './Config.ts'
-import { WebsocketBridgeParams } from './Params.ts'
-
-export const BridgeCommands = {
-  join: 'join',
-  query: 'query',
-}
-
-const DEFAULT_HOST_PORT = 8080
-
-@creatableModule()
-export class WebsocketBridge<
-  TParams extends WebsocketBridgeParams<AnyConfigSchema<WebsocketBridgeConfig>> = WebsocketBridgeParams<WebsocketBridgeConfig>,
->
-  extends WebsocketClientBridge<TParams>
-  implements BridgeModule<TParams> {
-  httpServer?: HttpServer
-  server?: Server
-
-  get host() {
-    return this.config.host
-  }
-
-  override exposeHandler(_id: string, _options?: BridgeExposeOptions | undefined): Promisable<ModuleInstance[]> {
-    throw new Error('Unsupported')
-  }
-
-  override exposedHandler(): Promisable<Address[]> {
-    throw new Error('Unsupported')
-  }
-
-  override async startHandler() {
-    if (this.host) {
-      this.startServer()
-    }
-    await super.startHandler()
-  }
-
-  override async stopHandler() {
-    if (this.host) {
-      await this.stopServer()
-    }
-    await super.stopHandler()
-  }
-
-  private startServer() {
-    if (this.httpServer) {
-      throw new Error('Http Server already started')
-    }
-    if (this.server) {
-      throw new Error('Socket Server already started')
-    }
-    const host = assertEx(this.host, () => 'No Host Configured')
-    this.httpServer = createHttpServer() as HttpServer
-    this.server = new Server(this.httpServer)
-
-    this.server.on('connection', (socket: Socket) => {
-      socket.on(BridgeCommands.join, async (address: Address) => {
-        await socket.join(address)
-        console.log(`User ${socket.id} has connected to module ${address}`)
-      })
-
-      socket.on(BridgeCommands.query, ({ address, query }: { address: Address; query: Payload[] }) => {
-        socket.to(address).emit('message', query)
-      })
-    })
-    this.httpServer.listen(host.port ?? DEFAULT_HOST_PORT)
-  }
-
-  private async stopServer() {
-    await this.server?.close()
-    this.server = undefined
-    this.httpServer?.close()
-    this.httpServer = undefined
-  }
-}

package/src/ClientBridge.ts

@@ -1,114 +0,0 @@
-import {
-  Address, assertEx, Promisable,
-} from '@xylabs/sdk-js'
-import { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { AbstractBridge } from '@xyo-network/bridge-abstract'
-import {
-  BridgeExposeOptions, BridgeModule, BridgeUnexposeOptions,
-} from '@xyo-network/bridge-model'
-import {
-  creatableModule, ModuleInstance, ModuleQueryResult,
-} from '@xyo-network/module-model'
-import { Payload, Schema } from '@xyo-network/payload-model'
-import { Semaphore } from 'async-mutex'
-import { LRUCache } from 'lru-cache'
-
-import { WebsocketBridgeConfigSchema } from './Config.ts'
-import { WebsocketBridgeQuerySender } from './ModuleProxy/index.ts'
-import { WebsocketBridgeParams } from './Params.ts'
-import { WebsocketBridgeModuleResolver } from './WebsocketBridgeModuleResolver.ts'
-
-@creatableModule()
-export class WebsocketClientBridge<TParams extends WebsocketBridgeParams = WebsocketBridgeParams>
-  extends AbstractBridge<TParams>
-  implements BridgeModule<TParams>, WebsocketBridgeQuerySender {
-  static override readonly configSchemas: Schema[] = [...super.configSchemas, WebsocketBridgeConfigSchema]
-  static override readonly defaultConfigSchema: Schema = WebsocketBridgeConfigSchema
-  protected static defaultFailureRetryTime = 1000 * 60
-  protected static defaultMaxConnections = 4
-  protected static defaultMaxPayloadSizeWarning = 256 * 256
-  protected static maxFailureCacheSize = 1000
-
-  private _failureTimeCache = new LRUCache<Address, number>({ max: WebsocketClientBridge.maxFailureCacheSize })
-  private _querySemaphore?: Semaphore
-
-  private _resolver?: WebsocketBridgeModuleResolver
-
-  get client() {
-    return this.config.client
-  }
-
-  get failureRetryTime() {
-    return this.client?.failureRetryTime ?? WebsocketClientBridge.defaultFailureRetryTime
-  }
-
-  get maxConnections() {
-    return this.client?.maxConnections ?? WebsocketClientBridge.defaultMaxConnections
-  }
-
-  get maxPayloadSizeWarning() {
-    return this.client?.maxPayloadSizeWarning ?? WebsocketClientBridge.defaultMaxPayloadSizeWarning
-  }
-
-  get querySemaphore() {
-    this._querySemaphore = this._querySemaphore ?? new Semaphore(this.maxConnections)
-    return this._querySemaphore
-  }
-
-  override get resolver() {
-    this._resolver
-      = this._resolver
-        ?? new WebsocketBridgeModuleResolver({
-          archiving: { ...this.archiving, resolveArchivists: this.resolveArchivingArchivists.bind(this) },
-          bridge: this,
-          querySender: this,
-          root: this,
-          wrapperAccount: this.account,
-        })
-    return this._resolver
-  }
-
-  get url() {
-    return assertEx(this.config.client?.url, () => 'No Url Set')
-  }
-
-  override exposeHandler(_id: string, _options?: BridgeExposeOptions | undefined): Promisable<ModuleInstance[]> {
-    throw new Error('Unsupported')
-  }
-
-  override exposedHandler(): Promisable<Address[]> {
-    throw new Error('Unsupported')
-  }
-
-  async getRoots(): Promise<ModuleInstance[]> {
-    return await Promise.resolve([])
-  }
-
-  async sendBridgeQuery<TOut extends Payload = Payload, TQuery extends QueryBoundWitness = QueryBoundWitness, TIn extends Payload = Payload>(
-    targetAddress: Address,
-    _query: TQuery,
-    _payloads?: TIn[],
-  ): Promise<ModuleQueryResult<TOut>> {
-    const lastFailureTime = this._failureTimeCache.get(targetAddress)
-    if (lastFailureTime !== undefined) {
-      const now = Date.now()
-      const timeSincePreviousFailure = now - lastFailureTime
-      if (timeSincePreviousFailure > this.failureRetryTime) {
-        throw new Error(`target module failed recently [${targetAddress}] [${timeSincePreviousFailure}ms ago]`)
-      }
-      this._failureTimeCache.delete(targetAddress)
-    }
-    try {
-      await this.querySemaphore.acquire()
-      throw new Error('Unsupported')
-    } catch (ex) {
-      throw ex as Error
-    } finally {
-      this.querySemaphore.release()
-    }
-  }
-
-  override unexposeHandler(_id: string, _options?: BridgeUnexposeOptions | undefined): Promisable<ModuleInstance[]> {
-    throw new Error('Unsupported')
-  }
-}

package/src/Config.ts

@@ -1,24 +0,0 @@
-import type { 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'
-
-export const WebsocketBridgeConfigSchema = asSchema('network.xyo.bridge.websocket.config', true)
-export type WebsocketBridgeConfigSchema = typeof WebsocketBridgeConfigSchema
-
-export type WebsocketBridgeConfig<TConfig extends EmptyObject = EmptyObject, TSchema extends string | void = void> = BridgeConfig<
-  {
-    schema: WebsocketBridgeConfigSchema
-  } & TConfig,
-  TSchema extends Schema ? TSchema : WebsocketBridgeConfigSchema,
-  {
-    failureRetryTime?: number
-    failureTimeCacheMax?: number
-    maxConnections?: number
-    maxPayloadSizeWarning?: number
-    url: string
-  },
-  {
-    port?: number
-  }
->

package/src/ModuleProxy/ModuleProxy.ts

@@ -1,34 +0,0 @@
-import type { Address } 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 {
-  creatableModule, type ModuleInstance, type ModuleQueryResult,
-} from '@xyo-network/module-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-export interface WebsocketBridgeQuerySender {
-  sendBridgeQuery: <TOut extends Payload = Payload, TQuery extends QueryBoundWitness = QueryBoundWitness, TIn extends Payload = Payload>(
-    targetAddress: Address,
-    query: TQuery,
-    payloads?: TIn[],
-  ) => Promise<ModuleQueryResult<TOut>>
-}
-
-export type WebsocketModuleProxyParams = ModuleProxyParams & {
-  querySender: WebsocketBridgeQuerySender
-}
-
-@creatableModule()
-export class WebsocketModuleProxy<
-  TWrappedModule extends ModuleInstance = ModuleInstance,
-  TParams extends Omit<WebsocketModuleProxyParams, 'config'> & { config: TWrappedModule['config'] } = Omit<WebsocketModuleProxyParams, 'config'> & {
-    config: TWrappedModule['config']
-  },
->
-  extends AbstractModuleProxy<TWrappedModule, TParams>
-  implements ModuleInstance<TParams, TWrappedModule['eventData']> {
-  async proxyQueryHandler<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads: Payload[] = []): Promise<ModuleQueryResult> {
-    return await this.params.querySender.sendBridgeQuery(this.params.moduleAddress, query, payloads)
-  }
-}

package/src/ModuleProxy/index.ts

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

package/src/Params.ts

@@ -1,7 +0,0 @@
-import type { BridgeParams } from '@xyo-network/bridge-model'
-import type { AnyConfigSchema } from '@xyo-network/module-model'
-
-import type { WebsocketBridgeConfig } from './Config.ts'
-
-export type WebsocketBridgeParams<TConfig extends AnyConfigSchema<WebsocketBridgeConfig> = AnyConfigSchema<WebsocketBridgeConfig>>
-  = BridgeParams<TConfig>

package/src/WebsocketBridgeModuleResolver.ts

@@ -1,88 +0,0 @@
-import type { Address, CreatableName } from '@xylabs/sdk-js'
-import { assertEx, isAddress } from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import type { BridgeModuleResolverParams } from '@xyo-network/bridge-abstract'
-import { AbstractBridgeModuleResolver, wrapModuleWithType } from '@xyo-network/bridge-abstract'
-import type { ConfigPayload } from '@xyo-network/config-payload-plugin'
-import { ConfigSchema } from '@xyo-network/config-payload-plugin'
-import type {
-  ModuleConfig,
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-} from '@xyo-network/module-model'
-import {
-  asModuleInstance,
-  ModuleConfigSchema,
-  ResolveHelper,
-} from '@xyo-network/module-model'
-
-import type { WebsocketBridgeQuerySender, WebsocketModuleProxyParams } from './ModuleProxy/index.ts'
-import { WebsocketModuleProxy } from './ModuleProxy/index.ts'
-
-export interface WebsocketBridgeModuleResolverParams extends BridgeModuleResolverParams {
-  querySender: WebsocketBridgeQuerySender
-}
-
-export class WebsocketBridgeModuleResolver<
-  T extends WebsocketBridgeModuleResolverParams = WebsocketBridgeModuleResolverParams,
-> extends AbstractBridgeModuleResolver<T> {
-  get querySender() {
-    return this.params.querySender
-  }
-
-  override async resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T[]> {
-    const parentResult = await super.resolveHandler(id, options)
-    if (parentResult) {
-      return parentResult
-    }
-    if (id === '*') {
-      return []
-    }
-    const idParts = id.split(':')
-    const untransformedFirstPart = assertEx(idParts.shift(), () => `Invalid module identifier: ${id}`)
-    const firstPart = await ResolveHelper.transformModuleIdentifier(untransformedFirstPart)
-    const moduleAddress = firstPart as Address
-    assertEx(isAddress(firstPart), () => `Invalid module address: ${firstPart}`)
-    const remainderParts = idParts.join(':')
-    const params: WebsocketModuleProxyParams = {
-      name: 'WebsocketBridgeModuleResolver' as CreatableName,
-      account: await Account.random(),
-      config: { schema: ModuleConfigSchema },
-      host: this,
-      moduleAddress,
-      querySender: this.querySender,
-    }
-
-    this.logger?.debug(`creating HttpProxy [${moduleAddress}] ${id}`)
-
-    const proxy = await WebsocketModuleProxy.create(params)
-    // calling state here to get the config
-    if (proxy) {
-      const state = await proxy.state()
-      if (state) {
-        const configSchema = (state.find(payload => payload.schema === ConfigSchema) as ConfigPayload | undefined)?.config
-        const config = assertEx(
-          state.find(payload => payload.schema === configSchema),
-          () => 'Unable to locate config',
-        ) as ModuleConfig
-        proxy.setConfig(config)
-      }
-    }
-
-    await proxy.start()
-
-    const wrapped = assertEx(wrapModuleWithType(proxy, await Account.random()) as unknown as T, () => `Failed to wrapModuleWithType [${id}]`)
-    const instance = assertEx(asModuleInstance<T>(wrapped, {}), () => `Failed to asModuleInstance [${id}]`)
-    proxy.upResolver.add(instance)
-    proxy.downResolver.add(instance)
-
-    if (remainderParts.length > 0) {
-      const result = await wrapped.resolve<T>(remainderParts, options)
-      return result ? [result] : []
-    }
-
-    // console.log(`resolved: ${proxy.address} [${wrapped.constructor.name}] [${as.constructor.name}]`)
-    return [instance]
-  }
-}

package/src/index-browser.ts

@@ -1,4 +0,0 @@
-import { WebsocketClientBridge } from './ClientBridge.ts'
-export * from './Config.ts'
-
-export class WebsocketBridge extends WebsocketClientBridge {}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './Bridge.ts'
-export * from './Config.ts'

package/src/socketServer.ts

@@ -1,31 +0,0 @@
-import { createServer as createHttpServer } from 'node:http'
-
-import type { Address } from '@xylabs/sdk-js'
-import type { Socket } from 'socket.io'
-import { Server } from 'socket.io'
-
-export const BridgeCommands = {
-  bridge: 'bridge',
-  sendMessage: 'send message',
-}
-
-export const createServer = (port: number) => {
-  const httpServer = createHttpServer()
-  const io = new Server(httpServer)
-
-  io.on('connection', (socket: Socket) => {
-    socket.on(BridgeCommands.bridge, async (address: Address) => {
-      await socket.join(address)
-      console.log(`User ${socket.id} has connected to module ${address}`)
-    })
-
-    socket.on(BridgeCommands.sendMessage, ({ address, query }: { address: Address; query: string }) => {
-      socket.to(address).emit('message', query)
-    })
-  })
-
-  return {
-    start: () => httpServer.listen(port),
-    stop: () => httpServer.close(),
-  }
-}