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

package/src/simple/blockInvalidation/SimpleBlockInvalidationViewer.ts

@@ -1,197 +0,0 @@
-import { assertEx, Promisable } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  AccountBalanceViewer,
-  AccountBalanceViewerMoniker,
-  asXL1BlockRange,
-  BlockInvalidationConfig,
-  BlockInvalidationQualification,
-  BlockInvalidationViewer,
-  BlockInvalidationViewerMoniker,
-  BlockViewer,
-  BlockViewerMoniker,
-  ChainContractViewer,
-  ChainContractViewerMoniker,
-  ChainId,
-  HydratedBlockStateValidationFunction,
-  HydratedBlockValidationError,
-  HydratedBlockValidationFunction,
-  isChainQualifiedHeadConfig,
-  isHydratedBlock,
-  SignedHydratedBlock,
-  type SignedHydratedBlockWithHashMeta,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import { findUncles, getWindowedChain } from '../../primitives/index.ts'
-
-/** Parameters for SimpleBlockInvalidationViewer. */
-export interface SimpleBlockInvalidationViewerParams extends CreatableProviderParams {
-  maxUncleWindowSize?: number
-  state?: HydratedBlockStateValidationFunction
-  value?: HydratedBlockValidationFunction
-}
-
-/** SimpleBlockInvalidationViewer implementation. */
-@creatableProvider()
-export class SimpleBlockInvalidationViewer extends AbstractCreatableProvider<SimpleBlockInvalidationViewerParams> implements BlockInvalidationViewer {
-  static readonly defaultMoniker = BlockInvalidationViewerMoniker
-  static readonly dependencies = [AccountBalanceViewerMoniker, BlockViewerMoniker, ChainContractViewerMoniker]
-  static readonly monikers = [BlockInvalidationViewerMoniker]
-  moniker = SimpleBlockInvalidationViewer.defaultMoniker
-
-  private _accountBalanceViewer!: AccountBalanceViewer
-  private _blockViewer!: BlockViewer
-  private _chainContractViewer!: ChainContractViewer
-  private _uncleWindowedChainCache: SignedHydratedBlockWithHashMeta[] | null = null
-
-  protected get blockViewer() {
-    return this._blockViewer
-  }
-
-  protected get chainContractViewer() {
-    return this._chainContractViewer
-  }
-
-  protected get maxUncleWindowSize() {
-    return this.params.maxUncleWindowSize!
-  }
-
-  static override async paramsHandler(params: Partial<SimpleBlockInvalidationViewerParams>): Promise<SimpleBlockInvalidationViewerParams> {
-    return {
-      ...await super.paramsHandler(params),
-      value: params.value,
-      state: params.state,
-      maxUncleWindowSize: params.maxUncleWindowSize ?? 100,
-    } satisfies SimpleBlockInvalidationViewerParams
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._accountBalanceViewer = await this.locator.getInstance<AccountBalanceViewer>(AccountBalanceViewerMoniker)
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-    this._chainContractViewer = await this.locator.getInstance<ChainContractViewer>(ChainContractViewerMoniker)
-  }
-
-  async invalidateBlock(
-    block: SignedHydratedBlock,
-    config?: BlockInvalidationConfig,
-  ): Promise<HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta> {
-    return (await this.invalidateBlocks([block], config))[0]
-  }
-
-  async invalidateBlocks(
-    blocks: SignedHydratedBlock[],
-    config?: BlockInvalidationConfig,
-  ): Promise<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]> {
-    return (await this.qualifiedInvalidateBlocks(blocks, config))[0]
-  }
-
-  async invalidateUncle(
-    blocks: SignedHydratedBlock[],
-    config?: BlockInvalidationConfig,
-  ): Promise<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]> {
-    return (await this.qualifiedInvalidateUncle(blocks, config))[0]
-  }
-
-  async qualifiedInvalidateBlock(
-    block: SignedHydratedBlockWithHashMeta,
-    config?: BlockInvalidationConfig,
-  ): Promise<[HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta, BlockInvalidationQualification]> {
-    const result = (await this.qualifiedInvalidateBlocks([block], config))
-    return [result[0][0], result[1]]
-  }
-
-  async qualifiedInvalidateBlocks(
-    blocks: SignedHydratedBlock[],
-    config?: BlockInvalidationConfig,
-  ): Promise<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockInvalidationQualification]> {
-    const { value, state } = config ?? {
-      shape: true, links: true, state: true, head: undefined,
-    }
-
-    const blocksWithMeta = await Promise.all(blocks.map(b => Promise.all([PayloadBuilder.addHashMeta(b[0]), PayloadBuilder.addHashMeta(b[1])])))
-
-    const head = isChainQualifiedHeadConfig(config)
-      ? assertEx(
-          (await this.blockViewer.blockByHash(config.head))?.[0],
-          () => `Specified a head that is not in the chain [${config.head}]`,
-        )
-      : undefined
-
-    const headBlock = head ?? (await this.blockViewer.currentBlock())[0]
-
-    const validateProtocol = value ? this.doInvalidateProtocol.bind(this) : undefined
-    const validateState = state ? this.doInvalidateState.bind(this) : undefined
-
-    const chainIdAtBlockNumber = (blockNumber: XL1BlockNumber) => this.chainContractViewer.chainIdAtBlockNumber(blockNumber)
-
-    const qualification = { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) }
-    const [protocolResults, stateResults] = await Promise.all([
-      validateProtocol?.(blocksWithMeta, chainIdAtBlockNumber), validateState?.(blocksWithMeta, chainIdAtBlockNumber),
-    ])
-    const blockResults = blocksWithMeta.map((r, i) => {
-      const errors = []
-      if (protocolResults && !isHydratedBlock(protocolResults[i])) {
-        errors.push(...(protocolResults[i]))
-      }
-      if (stateResults && !isHydratedBlock(stateResults[i])) {
-        errors.push(...(stateResults[i]))
-      }
-      return errors.length === 0 ? r : errors
-    })
-    return [blockResults, qualification]
-  }
-
-  qualifiedInvalidateUncle(
-    _blocks: SignedHydratedBlock[],
-    _config?: BlockInvalidationConfig,
-  ): Promise<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockInvalidationQualification]> {
-    throw new Error('Method not implemented.')
-  }
-
-  private async doInvalidateProtocol(
-    blocks: SignedHydratedBlockWithHashMeta[],
-    chainIdAtBlockNumber: (blockNumber: XL1BlockNumber) => Promisable<ChainId>,
-  ): Promise<(SignedHydratedBlockWithHashMeta | HydratedBlockValidationError[])[]> {
-    return (await Promise.all(blocks.map(async (block) => {
-      const errors = await this.params.value!(
-        this.context,
-        block,
-        chainIdAtBlockNumber,
-      )
-      return (errors.length === 0) ? block : errors
-    })))
-  }
-
-  private async doInvalidateState(
-    blocks: SignedHydratedBlockWithHashMeta[],
-    chainIdAtBlockNumber: (blockNumber: XL1BlockNumber) => Promisable<ChainId>,
-  ): Promise<(SignedHydratedBlockWithHashMeta | HydratedBlockValidationError[])[]> {
-    const windowedUncleChain = await this.updateWindowedChainCache()
-
-    const uncles = findUncles(this.context, windowedUncleChain, blocks)
-
-    if (uncles.length !== 1) {
-      this.logger?.warn(JSON.stringify({ uncles, blocks }, null, 2))
-      this.logger?.warn(JSON.stringify(windowedUncleChain, null, 2))
-      throw new Error(`No uncles or greater than one uncle found in block validation, which is not supported [${uncles.length}, ${blocks.length}]`)
-    }
-    return (await Promise.all(uncles[0].map(async (block) => {
-      const errors = await this.params.state!(
-        {
-          ...this.context, chainIdAtBlockNumber, accountBalance: this._accountBalanceViewer,
-        },
-        block,
-      )
-      return (errors.length === 0) ? block : errors
-    })))
-  }
-
-  private async updateWindowedChainCache() {
-    this._uncleWindowedChainCache = await getWindowedChain(this.context, this.blockViewer, this.maxUncleWindowSize, this._uncleWindowedChainCache ?? [])
-    return [...this._uncleWindowedChainCache]
-  }
-}

package/src/simple/blockInvalidation/index.ts

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

package/src/simple/blockReward/SimpleBlockRewardViewer.ts

@@ -1,27 +0,0 @@
-import { Promisable } from '@xylabs/sdk-js'
-import {
-  AttoXL1, BlockRewardViewer, BlockRewardViewerMoniker, XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import { rewardFromBlockNumber } from '../../primitives/index.ts'
-
-/** Parameters for SimpleBlockRewardViewer. */
-export interface SimpleBlockRewardViewerParams extends CreatableProviderParams {}
-
-/** SimpleBlockRewardViewer implementation. */
-@creatableProvider()
-export class SimpleBlockRewardViewer extends AbstractCreatableProvider<SimpleBlockRewardViewerParams> implements BlockRewardViewer {
-  static readonly defaultMoniker = BlockRewardViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [BlockRewardViewerMoniker]
-  moniker = SimpleBlockRewardViewer.defaultMoniker
-
-  allowedRewardForBlock(block: XL1BlockNumber): Promisable<AttoXL1> {
-    return rewardFromBlockNumber(
-      block,
-    )
-  }
-}

package/src/simple/blockReward/index.ts

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

package/src/simple/blockValidation/SimpleBlockValidationViewer.ts

@@ -1,194 +0,0 @@
-import { assertEx, Promisable } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  AccountBalanceViewer,
-  AccountBalanceViewerMoniker,
-  asXL1BlockRange,
-  BlockValidationConfig,
-  BlockValidationQualification,
-  BlockValidationViewer,
-  BlockValidationViewerMoniker,
-  BlockViewer,
-  BlockViewerMoniker,
-  ChainContractViewer,
-  ChainContractViewerMoniker,
-  ChainId,
-  HydratedBlockStateValidationFunction,
-  HydratedBlockValidationError,
-  HydratedBlockValidationFunction,
-  isChainQualifiedHeadConfig,
-  isHydratedBlock,
-  SignedHydratedBlock,
-  type SignedHydratedBlockWithHashMeta,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import { findUncles, getWindowedChain } from '../../primitives/index.ts'
-
-/** Parameters for SimpleBlockValidationViewer. */
-export interface SimpleBlockValidationViewerParams extends CreatableProviderParams {
-  maxUncleWindowSize?: number
-  protocol?: HydratedBlockValidationFunction
-  state?: HydratedBlockStateValidationFunction
-}
-
-/** SimpleBlockValidationViewer implementation. */
-@creatableProvider()
-export class SimpleBlockValidationViewer extends AbstractCreatableProvider<SimpleBlockValidationViewerParams> implements BlockValidationViewer {
-  static readonly defaultMoniker = BlockValidationViewerMoniker
-  static readonly dependencies = [AccountBalanceViewerMoniker, BlockViewerMoniker, ChainContractViewerMoniker]
-  static readonly monikers = [BlockValidationViewerMoniker]
-  moniker = SimpleBlockValidationViewer.defaultMoniker
-
-  private _accountBalanceViewer!: AccountBalanceViewer
-  private _blockViewer!: BlockViewer
-  private _chainContractViewer!: ChainContractViewer
-  private _uncleWindowedChainCache: SignedHydratedBlockWithHashMeta[] | null = null
-
-  protected get blockViewer() {
-    return this._blockViewer
-  }
-
-  protected get chainContractViewer() {
-    return this._chainContractViewer
-  }
-
-  protected get maxUncleWindowSize() {
-    return this.params.maxUncleWindowSize!
-  }
-
-  static override async paramsHandler(params: Partial<SimpleBlockValidationViewerParams>): Promise<SimpleBlockValidationViewerParams> {
-    return {
-      ...await super.paramsHandler(params),
-      protocol: params.protocol,
-      state: params.state,
-      maxUncleWindowSize: params.maxUncleWindowSize ?? 100,
-    } satisfies SimpleBlockValidationViewerParams
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._accountBalanceViewer = await this.locator.getInstance<AccountBalanceViewer>(AccountBalanceViewerMoniker)
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-    this._chainContractViewer = await this.locator.getInstance<ChainContractViewer>(ChainContractViewerMoniker)
-  }
-
-  async qualifiedValidateBlock(
-    block: SignedHydratedBlockWithHashMeta,
-    config?: BlockValidationConfig,
-  ): Promise<[HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta, BlockValidationQualification]> {
-    const result = (await this.qualifiedValidateBlocks([block], config))
-    return [result[0][0], result[1]]
-  }
-
-  async qualifiedValidateBlocks(
-    blocks: SignedHydratedBlock[],
-    config?: BlockValidationConfig,
-  ): Promise<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockValidationQualification]> {
-    const { value, state } = config ?? {
-      shape: true, links: true, state: true, head: undefined,
-    }
-
-    const blocksWithMeta = await Promise.all(blocks.map(b => Promise.all([PayloadBuilder.addHashMeta(b[0]), PayloadBuilder.addHashMeta(b[1])])))
-
-    const head = isChainQualifiedHeadConfig(config)
-      ? assertEx(
-          (await this.blockViewer.blockByHash(config.head))?.[0],
-          () => `Specified a head that is not in the chain [${config.head}]`,
-        )
-      : undefined
-
-    const headBlock = head ?? (await this.blockViewer.currentBlock())[0]
-
-    const validateProtocol = value ? this.doValidateProtocol.bind(this) : undefined
-    const validateState = state ? this.doValidateState.bind(this) : undefined
-
-    const chainIdAtBlockNumber = (blockNumber: XL1BlockNumber) => this.chainContractViewer.chainIdAtBlockNumber(blockNumber)
-
-    const qualification = { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) }
-    const [protocolResults, stateResults] = await Promise.all([
-      validateProtocol?.(blocksWithMeta, chainIdAtBlockNumber), validateState?.(blocksWithMeta, chainIdAtBlockNumber),
-    ])
-    const blockResults = blocksWithMeta.map((r, i) => {
-      const errors = []
-      if (protocolResults && !isHydratedBlock(protocolResults[i])) {
-        errors.push(...(protocolResults[i]))
-      }
-      if (stateResults && !isHydratedBlock(stateResults[i])) {
-        errors.push(...(stateResults[i]))
-      }
-      return errors.length === 0 ? r : errors
-    })
-    return [blockResults, qualification]
-  }
-
-  qualifiedValidateUncle(
-    _blocks: SignedHydratedBlock[],
-    _config?: BlockValidationConfig,
-  ): Promise<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockValidationQualification]> {
-    throw new Error('Method not implemented.')
-  }
-
-  async validateBlock(block: SignedHydratedBlock, config?: BlockValidationConfig): Promise<HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta> {
-    return (await this.validateBlocks([block], config))[0]
-  }
-
-  async validateBlocks(
-    blocks: SignedHydratedBlock[],
-    config?: BlockValidationConfig,
-  ): Promise<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]> {
-    return (await this.qualifiedValidateBlocks(blocks, config))[0]
-  }
-
-  async validateUncle(
-    blocks: SignedHydratedBlock[],
-    config?: BlockValidationConfig,
-  ): Promise<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]> {
-    return (await this.qualifiedValidateUncle(blocks, config))[0]
-  }
-
-  private async doValidateProtocol(
-    blocks: SignedHydratedBlockWithHashMeta[],
-    chainIdAtBlockNumber: (blockNumber: XL1BlockNumber) => Promisable<ChainId>,
-  ): Promise<(SignedHydratedBlockWithHashMeta | HydratedBlockValidationError[])[]> {
-    return (await Promise.all(blocks.map(async (block) => {
-      const errors = await this.params.protocol!(
-        this.context,
-        block,
-        chainIdAtBlockNumber,
-      )
-      return (errors.length === 0) ? block : errors
-    })))
-  }
-
-  private async doValidateState(
-    blocks: SignedHydratedBlockWithHashMeta[],
-    chainIdAtBlockNumber: (blockNumber: XL1BlockNumber) => Promisable<ChainId>,
-  ): Promise<(SignedHydratedBlockWithHashMeta | HydratedBlockValidationError[])[]> {
-    const windowedUncleChain = await this.updateWindowedChainCache()
-
-    const uncles = findUncles(this.context, windowedUncleChain, blocks)
-
-    if (uncles.length !== 1) {
-      this.logger?.warn(JSON.stringify({ uncles, blocks }, null, 2))
-      this.logger?.warn(JSON.stringify(windowedUncleChain, null, 2))
-      throw new Error(`No uncles or greater than one uncle found in block validation, which is not supported [${uncles.length}, ${blocks.length}]`)
-    }
-    return (await Promise.all(uncles[0].map(async (block) => {
-      const errors = await this.params.state!(
-        {
-          ...this.context, chainIdAtBlockNumber, accountBalance: this._accountBalanceViewer,
-        },
-        block,
-      )
-      return (errors.length === 0) ? block : errors
-    })))
-  }
-
-  private async updateWindowedChainCache() {
-    this._uncleWindowedChainCache = await getWindowedChain(this.context, this.blockViewer, this.maxUncleWindowSize, this._uncleWindowedChainCache ?? [])
-    return [...this._uncleWindowedChainCache]
-  }
-}

package/src/simple/blockValidation/index.ts

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

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
-  }
-}