@xyo-network/xl1-protocol-sdk 1.26.11 → 1.26.13

package/src/simple/chainContractViewer/SimpleChainContractViewer.ts

@@ -1,92 +0,0 @@
-import {
-  type Address, assertEx,
-  type Hash,
-} from '@xylabs/sdk-js'
-import {
-  ChainContractViewer, ChainContractViewerMoniker, ChainId, FinalizationViewer, FinalizationViewerMoniker, XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { withContextCacheResponse } from '../../ChainContextHelpers.ts'
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleChainContractViewer. */
-export interface SimpleChainContractViewerParams extends CreatableProviderParams {
-  forkedAtBlockNumber?: XL1BlockNumber
-  forkedAtHash?: Hash
-  forkedChainContractViewer?: ChainContractViewer
-  forkedChainId?: ChainId
-  minWithdrawalBlocks: number
-  rewardsContract: Address
-  stakingTokenAddress: Address
-}
-
-/**
- * A class that represents a chain stake as backed by an EVM smart contract
- */
-@creatableProvider()
-export class SimpleChainContractViewer extends AbstractCreatableProvider<SimpleChainContractViewerParams> implements ChainContractViewer {
-  static readonly defaultMoniker = ChainContractViewerMoniker
-  static readonly dependencies = [FinalizationViewerMoniker]
-  static readonly monikers = [ChainContractViewerMoniker]
-  override moniker = SimpleChainContractViewer.defaultMoniker
-
-  protected _finalizationViewer!: FinalizationViewer
-
-  protected get finalizationViewer() {
-    return this._finalizationViewer
-  }
-
-  chainId() {
-    return this.finalizationViewer.chainId()
-  }
-
-  async chainIdAtBlockNumber(blockNumber: XL1BlockNumber) {
-    return await withContextCacheResponse(this.context, 'chainIdAtBlockNumber', `${blockNumber}`, async () => {
-      let chainId = this.chainId()
-      // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias
-      let contractViewer: ChainContractViewer = this
-      let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber()
-      while (forkedAtBlockNumber !== null && blockNumber <= forkedAtBlockNumber) {
-        contractViewer = assertEx(await contractViewer.forkedChainContractViewer())
-        forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber()
-        chainId = await contractViewer.chainId()
-      }
-      return chainId
-    })
-  }
-
-  override async createHandler() {
-    this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker)
-    return await super.createHandler()
-  }
-
-  forkedAtBlockNumber() {
-    return this.params.forkedAtBlockNumber ?? null
-  }
-
-  forkedAtHash() {
-    return this.params.forkedAtHash ?? null
-  }
-
-  forkedChainContractViewer() {
-    return this.params.forkedChainContractViewer ?? null
-  }
-
-  forkedChainId() {
-    return this.params.forkedChainId ?? null
-  }
-
-  minWithdrawalBlocks() {
-    return this.params.minWithdrawalBlocks
-  }
-
-  rewardsContract() {
-    return this.params.rewardsContract
-  }
-
-  stakingTokenAddress() {
-    return this.params.stakingTokenAddress
-  }
-}

package/src/simple/chainContractViewer/index.ts

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

package/src/simple/client/SimpleXyoClient.ts

@@ -1,14 +0,0 @@
-import type {
-  XyoClient, XyoGatewayRunner, XyoPermissions,
-} from '@xyo-network/xl1-protocol-lib'
-
-/** SimpleXyoClient implementation. */
-export class SimpleXyoClient implements XyoClient {
-  gateways: Readonly<Partial<Record<string, XyoGatewayRunner>>>
-  permissions: XyoPermissions
-
-  constructor(gateways: Readonly<Partial<Record<string, XyoGatewayRunner>>>, permissions: XyoPermissions) {
-    this.gateways = gateways
-    this.permissions = permissions
-  }
-}

package/src/simple/client/index.ts

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

package/src/simple/datalake/AbstractRestDataLake.ts

@@ -1,70 +0,0 @@
-import { axiosJsonConfig } from '@xylabs/sdk-js'
-import {
-  exists, type Hash, type PromisableArray,
-} from '@xylabs/sdk-js'
-import type {
-  NextOptions, Schema, Sequence,
-} from '@xyo-network/sdk-js'
-import { asAnyPayload, isAnyPayload } from '@xyo-network/sdk-js'
-import type { DataLakeData, DataLakeViewer } from '@xyo-network/xl1-protocol-lib'
-import { Axios } from 'axios'
-
-import { AbstractCreatableProvider, type CreatableProviderParams } from '../../CreatableProvider/index.ts'
-
-/** Parameters for AbstractRestDataLake. */
-export interface AbstractRestDataLakeParams extends
-  CreatableProviderParams {
-
-  allowedSchemas?: Schema[]
-  disallowedSchemas?: Schema[]
-  endpoint: string
-}
-
-/** Abstract base class for RestDataLake implementations. */
-export abstract class AbstractRestDataLake<TParams extends AbstractRestDataLakeParams = AbstractRestDataLakeParams> extends
-  AbstractCreatableProvider<TParams> implements Omit<DataLakeViewer, 'moniker'> {
-  get allowedSchemas(): Schema[] | undefined {
-    return this.params.allowedSchemas
-  }
-
-  get axios() {
-    return new Axios(axiosJsonConfig())
-  }
-
-  get disallowedSchemas(): Schema[] | undefined {
-    return this.params.disallowedSchemas
-  }
-
-  get endpoint() {
-    return this.params.endpoint
-  }
-
-  async get(hashes: Hash[]): Promise<DataLakeData[]> {
-    return (await Promise.all(hashes.map(hash => this.getOne(hash)))).filter(exists)
-  }
-
-  next(_options?: NextOptions<Sequence> | undefined): PromisableArray<DataLakeData> {
-    throw new Error('Method not implemented.')
-  }
-
-  protected async getOne(hash: Hash): Promise<DataLakeData | undefined> {
-    return asAnyPayload((await this.axios.get(`${this.params.endpoint}/get/${hash}`)).data)
-  }
-
-  protected isAllowed(value: DataLakeData | undefined): boolean {
-    if (isAnyPayload(value)) {
-      return this.isAllowedSchema(value.schema)
-    }
-    return false
-  }
-
-  protected isAllowedSchema(schema: Schema): boolean {
-    if (this.allowedSchemas && !this.allowedSchemas.includes(schema)) {
-      return false
-    }
-    if (this.disallowedSchemas && this.disallowedSchemas.includes(schema)) {
-      return false
-    }
-    return true
-  }
-}

package/src/simple/datalake/AbstractSimpleDataLake.ts

@@ -1,62 +0,0 @@
-import type { Hash, PromisableArray } from '@xylabs/sdk-js'
-import type {
-  NextOptions, Schema, Sequence,
-} from '@xyo-network/sdk-js'
-import { isAnyPayload } from '@xyo-network/sdk-js'
-import type {
-  DataLakeData, DataLakeViewer, MapTypeRead,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { AbstractCreatableProvider, type CreatableProviderParams } from '../../CreatableProvider/index.ts'
-
-/** Parameters for AbstractSimpleDataLake. */
-export interface AbstractSimpleDataLakeParams<TMap extends
-MapTypeRead<Hash, DataLakeData> = MapTypeRead<Hash, DataLakeData>> extends
-  CreatableProviderParams {
-
-  allowedSchemas?: Schema[]
-  disallowedSchemas?: Schema[]
-  map: TMap
-}
-
-/** Abstract base class for SimpleDataLake implementations. */
-export abstract class AbstractSimpleDataLake<TParams extends AbstractSimpleDataLakeParams = AbstractSimpleDataLakeParams> extends
-  AbstractCreatableProvider<TParams> implements Omit<DataLakeViewer, 'moniker'> {
-  get allowedSchemas(): Schema[] | undefined {
-    return this.params.allowedSchemas
-  }
-
-  get disallowedSchemas(): Schema[] | undefined {
-    return this.params.disallowedSchemas
-  }
-
-  protected get map(): TParams['map'] {
-    return this.params.map
-  }
-
-  async get(hashes: Hash[]): Promise<DataLakeData[]> {
-    const result = await this.map.getMany(hashes)
-    return result.filter(data => this.isAllowed(data))
-  }
-
-  next(_options?: NextOptions<Sequence> | undefined): PromisableArray<DataLakeData> {
-    throw new Error('Method not implemented.')
-  }
-
-  protected isAllowed(value: DataLakeData | undefined): boolean {
-    if (isAnyPayload(value)) {
-      return this.isAllowedSchema(value.schema)
-    }
-    return true
-  }
-
-  protected isAllowedSchema(schema: Schema): boolean {
-    if (this.allowedSchemas && !this.allowedSchemas.includes(schema)) {
-      return false
-    }
-    if (this.disallowedSchemas && this.disallowedSchemas.includes(schema)) {
-      return false
-    }
-    return true
-  }
-}

package/src/simple/datalake/RestDataLakeRunner.ts

@@ -1,54 +0,0 @@
-import {
-  assertEx, BrandedHash, exists, type Hash,
-  Promisable,
-  PromisableArray,
-} from '@xylabs/sdk-js'
-import { isAnyPayload, PayloadZodLoose } from '@xyo-network/sdk-js'
-import {
-  DataLakeData,
-  DataLakeRunner,
-  DataLakeRunnerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-import { AxiosResponse } from 'axios'
-import z from 'zod'
-
-import { creatableProvider } from '../../CreatableProvider/index.ts'
-import { AbstractRestDataLake } from './AbstractRestDataLake.ts'
-import { RestDataLakeViewerParams } from './RestDataLakeViewer.ts'
-
-/** Parameters for RestDataLakeRunner. */
-export interface RestDataLakeRunnerParams extends RestDataLakeViewerParams {}
-
-/** RestDataLakeRunner implementation. */
-@creatableProvider()
-export class RestDataLakeRunner<TParams extends RestDataLakeRunnerParams> extends
-  AbstractRestDataLake<TParams> implements DataLakeRunner {
-  static readonly defaultMoniker = DataLakeRunnerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [DataLakeRunnerMoniker]
-  moniker = RestDataLakeRunner.defaultMoniker
-
-  clear(): Promisable<void> {
-    throw new Error('Method not implemented.')
-  }
-
-  delete(_hashes: BrandedHash[]): PromisableArray<DataLakeData> {
-    throw new Error('Method not implemented.')
-  }
-
-  async insert(items: DataLakeData[]): Promise<DataLakeData[]> {
-    const allowedItems = items.map((item) => {
-      if (isAnyPayload(item) && this.isAllowed(item)) {
-        assertEx(typeof item === 'object' && item !== null, () => 'Data must be an object')
-        return item
-      }
-      return null
-    }).filter(exists)
-    if (allowedItems.length > 0) {
-      const result = await this.axios.post<DataLakeData[], AxiosResponse<Hash[]>>(`${this.params.endpoint}/insert`, allowedItems)
-      return z.array(PayloadZodLoose).parse(result.data)
-    } else {
-      return []
-    }
-  }
-}

package/src/simple/datalake/RestDataLakeViewer.ts

@@ -1,22 +0,0 @@
-import {
-  DataLakeViewer,
-  DataLakeViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { creatableProvider } from '../../CreatableProvider/index.ts'
-import { AbstractRestDataLake, AbstractRestDataLakeParams } from './AbstractRestDataLake.ts'
-
-/** Parameters for RestDataLakeViewer. */
-export interface RestDataLakeViewerParams extends
-  AbstractRestDataLakeParams {
-}
-
-/** RestDataLakeViewer implementation. */
-@creatableProvider()
-export class RestDataLakeViewer<TParams extends RestDataLakeViewerParams = RestDataLakeViewerParams>
-  extends AbstractRestDataLake<TParams> implements DataLakeViewer {
-  static readonly defaultMoniker = DataLakeViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [DataLakeViewerMoniker]
-  moniker = RestDataLakeViewer.defaultMoniker
-}

package/src/simple/datalake/SimpleDataLakeRunner.ts

@@ -1,44 +0,0 @@
-import { exists, type Hash } from '@xylabs/sdk-js'
-import { isAnyPayload, PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  DataLakeData,
-  DataLakeRunner,
-  DataLakeRunnerMoniker, MapType,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { creatableProvider } from '../../CreatableProvider/index.ts'
-import { AbstractSimpleDataLake } from './AbstractSimpleDataLake.ts'
-import { SimpleDataLakeViewerParams } from './SimpleDataLakeViewer.ts'
-
-/** Parameters for SimpleDataLakeRunner. */
-export interface SimpleDataLakeRunnerParams extends SimpleDataLakeViewerParams<MapType<Hash, DataLakeData>> {}
-
-/** SimpleDataLakeRunner implementation. */
-@creatableProvider()
-export class SimpleDataLakeRunner<TParams extends SimpleDataLakeRunnerParams> extends
-  AbstractSimpleDataLake<TParams> implements DataLakeRunner {
-  static readonly defaultMoniker = DataLakeRunnerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [DataLakeRunnerMoniker]
-  moniker = SimpleDataLakeRunner.defaultMoniker
-
-  async clear(): Promise<void> {
-    await this.map.clear()
-  }
-
-  async delete(hashes: Hash[]) {
-    return (await Promise.all(hashes.map(async (hash) => {
-      const payload = await this.map.get(hash)
-      return (await this.map.delete(hash)) ? payload : undefined
-    }))).filter(exists)
-  }
-
-  async insert(items: DataLakeData[]) {
-    const payloads = items.filter(isAnyPayload).filter(i => this.isAllowed(i))
-    const hashPairs = await PayloadBuilder.hashPairs(payloads)
-    for (const [payload, hash] of hashPairs) {
-      await this.map.set(hash, payload)
-    }
-    return hashPairs.map(([payload]) => payload)
-  }
-}

package/src/simple/datalake/SimpleDataLakeViewer.ts

@@ -1,24 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import {
-  DataLakeData,
-  DataLakeViewer,
-  DataLakeViewerMoniker, MapTypeRead,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { creatableProvider } from '../../CreatableProvider/index.ts'
-import { AbstractSimpleDataLake, AbstractSimpleDataLakeParams } from './AbstractSimpleDataLake.ts'
-
-/** Parameters for SimpleDataLakeViewer. */
-export interface SimpleDataLakeViewerParams<TMap extends MapTypeRead<Hash, DataLakeData> = MapTypeRead<Hash, DataLakeData>> extends
-  AbstractSimpleDataLakeParams<TMap> {
-}
-
-/** SimpleDataLakeViewer implementation. */
-@creatableProvider()
-export class SimpleDataLakeViewer<TParams extends SimpleDataLakeViewerParams = SimpleDataLakeViewerParams>
-  extends AbstractSimpleDataLake<TParams> implements DataLakeViewer {
-  static readonly defaultMoniker = DataLakeViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [DataLakeViewerMoniker]
-  moniker = SimpleDataLakeViewer.defaultMoniker
-}

package/src/simple/datalake/index.ts

@@ -1,4 +0,0 @@
-export * from './RestDataLakeRunner.ts'
-export * from './RestDataLakeViewer.ts'
-export * from './SimpleDataLakeRunner.ts'
-export * from './SimpleDataLakeViewer.ts'

package/src/simple/finalization/SimpleFinalizationRunner.ts

@@ -1,45 +0,0 @@
-import { type Hash } from '@xylabs/sdk-js'
-import type { ArchivistInstance } from '@xyo-network/sdk-js'
-import { type SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-import { FinalizationRunner, FinalizationRunnerMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import { ChainStoreWrite } from '../../model/index.ts'
-
-/** Parameters for SimpleFinalizationRunner. */
-export interface SimpleFinalizationRunnerParams extends CreatableProviderParams {
-  finalizedArchivist: ArchivistInstance
-}
-
-/** SimpleFinalizationRunner implementation. */
-@creatableProvider()
-export class SimpleFinalizationRunner extends AbstractCreatableProvider<SimpleFinalizationRunnerParams> implements FinalizationRunner {
-  static readonly defaultMoniker = FinalizationRunnerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [FinalizationRunnerMoniker]
-  moniker = SimpleFinalizationRunner.defaultMoniker
-
-  protected _store: ChainStoreWrite | undefined
-
-  protected get store() {
-    return this._store!
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._store = { chainMap: this.params.finalizedArchivist }
-  }
-
-  async finalizeBlock(block: SignedHydratedBlockWithHashMeta): Promise<Hash> {
-    return (await this.finalizeBlocks([block]))[0]
-  }
-
-  async finalizeBlocks(blocks: SignedHydratedBlockWithHashMeta[]): Promise<Hash[]> {
-    const sortedBlocks = blocks.toSorted((a, b) => a[0].block - b[0].block)
-    const payloads = sortedBlocks.flatMap(block => [...block[1], block[0]])
-    await this.store.chainMap.insert(payloads)
-    return sortedBlocks.map(b => b[0]._hash)
-  }
-}

package/src/simple/finalization/SimpleFinalizationViewer.ts

@@ -1,123 +0,0 @@
-import {
-  assertEx,
-  Hash,
-} from '@xylabs/sdk-js'
-import type { ReadArchivist } from '@xyo-network/sdk-js'
-import {
-  asSignedHydratedBlockWithStorageMeta, BlockContextRead, ChainContextRead, ChainContractViewerMoniker, ChainId, FinalizationViewer,
-  FinalizationViewerMoniker, type SignedBlockBoundWitnessWithHashMeta, type SignedHydratedBlockWithHashMeta,
-  SignedHydratedBlockWithStorageMeta,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { hydrateBlock } from '../../block/index.ts'
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import { ChainStoreRead } from '../../model/index.ts'
-import { findMostRecentBlock } from '../../primitives/index.ts'
-import { HydratedCache } from '../../utils/index.ts'
-
-/** Parameters for SimpleFinalizationViewer. */
-export interface SimpleFinalizationViewerParams extends CreatableProviderParams {
-  finalizedArchivist: ReadArchivist
-}
-
-/** SimpleFinalizationViewer implementation. */
-@creatableProvider()
-export class SimpleFinalizationViewer extends AbstractCreatableProvider<SimpleFinalizationViewerParams> implements FinalizationViewer {
-  static readonly defaultMoniker = FinalizationViewerMoniker
-  static readonly dependencies = [ChainContractViewerMoniker]
-  static readonly monikers = [FinalizationViewerMoniker]
-  moniker = SimpleFinalizationViewer.defaultMoniker
-
-  protected _chainId!: ChainId
-  protected _store: ChainStoreRead | undefined
-
-  private _signedHydratedBlockCache: HydratedCache<SignedHydratedBlockWithStorageMeta> | undefined
-
-  protected get finalizedArchivist() {
-    return this.params.finalizedArchivist
-  }
-
-  protected get hydratedBlockCache(): HydratedCache<SignedHydratedBlockWithStorageMeta> {
-    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache
-    const context = this.getBlockContextRead()
-    this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithStorageMeta>(context, async (
-      store: ChainStoreRead,
-      hash: Hash,
-      maxDepth?: number,
-      minDepth?: number,
-    ) => {
-      const result = await hydrateBlock(context, hash, maxDepth, minDepth)
-      return asSignedHydratedBlockWithStorageMeta(result, true)
-    }, 200)
-    return this._signedHydratedBlockCache
-  }
-
-  protected get store() {
-    return this._store!
-  }
-
-  static override async paramsHandler(params: Partial<SimpleFinalizationViewerParams>) {
-    return {
-      ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx(params.finalizedArchivist, () => 'finalizedArchivist is required'),
-    } satisfies SimpleFinalizationViewerParams
-  }
-
-  chainId() {
-    return this._chainId
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._chainId = assertEx(this.config.chain.id ?? (await findMostRecentBlock(this.params.finalizedArchivist))?.chain, () => 'chain.id is required if empty archivist')
-    this._store = { chainMap: this.params.finalizedArchivist }
-  }
-
-  async head(): Promise<SignedHydratedBlockWithHashMeta> {
-    return await this.spanAsync('head', async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlock]')
-      const cache = this.hydratedBlockCache
-      const block = await cache.get(currentHead._hash)
-      if (!block) {
-        console.log(`Could not find current block with hash ${currentHead!._hash}`)
-      }
-      return assertEx(block, () => 'Could not find current block')
-    }, this.context)
-  }
-
-  async headBlock(): Promise<SignedBlockBoundWitnessWithHashMeta> {
-    return (await this.head())[0]
-  }
-
-  async headHash(): Promise<Hash> {
-    return (await this.headBlock())._hash
-  }
-
-  async headNumber(): Promise<XL1BlockNumber> {
-    return (await this.headBlock()).block
-  }
-
-  protected getBlockContextRead(): BlockContextRead {
-    return {
-      ...this.context,
-      chainMap: this.store.chainMap,
-    }
-  }
-
-  protected async getChainContextRead(): Promise<ChainContextRead> {
-    return {
-      ...this.getBlockContextRead(),
-      head: (await this.head())[0],
-    }
-  }
-
-  protected async getCurrentHead() {
-    const chainArchivist = this.finalizedArchivist
-    const result = assertEx(await findMostRecentBlock(chainArchivist), () => 'Could not find most recent block [getCurrentHead]')
-    assertEx(result?.chain === this._chainId, () => 'Chain ID does not match head block chain ID')
-    return result
-  }
-}

package/src/simple/finalization/index.ts

@@ -1,2 +0,0 @@
-export * from './SimpleFinalizationRunner.ts'
-export * from './SimpleFinalizationViewer.ts'

package/src/simple/gateway/SimpleXyoGateway.ts

@@ -1,30 +0,0 @@
-import type {
-  XyoConnection,
-  XyoGateway,
-} from '@xyo-network/xl1-protocol-lib'
-import { XyoConnectionMoniker, XyoGatewayMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider } from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleXyoGateway. */
-export interface SimpleXyoGatewayParams extends CreatableProviderParams {}
-
-/** SimpleXyoGateway implementation. */
-export class SimpleXyoGateway extends AbstractCreatableProvider<SimpleXyoGatewayParams> implements XyoGateway {
-  static readonly defaultMoniker = XyoGatewayMoniker
-  static readonly dependencies = [XyoConnectionMoniker]
-  static readonly monikers = [XyoGatewayMoniker]
-  moniker = SimpleXyoGateway.defaultMoniker
-
-  private _connection!: XyoConnection
-
-  get connection(): XyoConnection {
-    return this._connection
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._connection = await this.locator.getInstance<XyoConnection>(XyoConnectionMoniker)
-  }
-}