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

package/src/simple/timeSync2/SimpleTimeSyncViewer.ts

@@ -1,132 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import {
-  asHash, assertEx, isDefined,
-} from '@xylabs/sdk-js'
-import type {
-  BlockViewer,
-  TimeDomain, TimePayload, TimeSyncViewer,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asTimePayload, asXL1BlockNumber, BlockViewerMoniker, TimeSchema,
-  TimeSyncViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-import type { Provider } from 'ethers'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleTimeSyncViewer. */
-export interface SimpleTimeSyncViewerParams extends CreatableProviderParams {
-  ethProvider?: Provider
-}
-
-/** SimpleTimeSyncViewer implementation. */
-@creatableProvider()
-export class SimpleTimeSyncViewer extends AbstractCreatableProvider<SimpleTimeSyncViewerParams> implements TimeSyncViewer {
-  static readonly defaultMoniker = TimeSyncViewerMoniker
-  static readonly dependencies = [BlockViewerMoniker]
-  static readonly monikers = [TimeSyncViewerMoniker]
-  moniker = SimpleTimeSyncViewer.defaultMoniker
-
-  private _blockViewer?: BlockViewer
-
-  protected get blockViewer() {
-    return this._blockViewer!
-  }
-
-  protected get ethProvider() {
-    return this.params.ethProvider
-  }
-
-  async convertTime(fromDomain: TimeDomain, toDomain: TimeDomain, from: number): Promise<number> {
-    switch (fromDomain) {
-      case 'xl1': {
-        const [block, payloads] = assertEx(await this.blockViewer.blockByNumber(asXL1BlockNumber(from, true)), () => 'Block not found')
-        const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema)
-        const hash = timeSchemaIndex === -1 ? undefined : block.payload_hashes[timeSchemaIndex]
-        const timePayload = asTimePayload(isDefined(hash) ? payloads.find(p => p._hash === hash) : undefined)
-        if (timePayload === undefined) return 0
-        switch (toDomain) {
-          case 'xl1': {
-            return timePayload.xl1 ?? 0
-          }
-          case 'epoch': {
-            return timePayload.epoch ?? 0
-          }
-          case 'ethereum': {
-            return timePayload.ethereum ?? 0
-          }
-          default: {
-            throw new Error(`Unsupported to toDomain: ${toDomain}`)
-          }
-        }
-      }
-      default: {
-        throw new Error(`Unsupported from fromDomain: ${fromDomain}`)
-      }
-    }
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-  }
-
-  async currentTime(domain: TimeDomain): Promise<[string, number]> {
-    switch (domain) {
-      case 'xl1': {
-        return ['xl1', (await this.blockViewer.currentBlock())?.[0].block ?? -1]
-      }
-      case 'epoch': {
-        return ['epoch', Date.now()]
-      }
-      case 'ethereum': {
-        return ['ethereum', (await this.ethProvider?.getBlockNumber()) ?? 0]
-      }
-      default: {
-        throw new Error(`Unknown time domain: ${domain}`)
-      }
-    }
-  }
-
-  async currentTimeAndHash(domain: TimeDomain): Promise<[number, Hash | null]> {
-    switch (domain) {
-      case 'xl1': {
-        const [head] = await this.blockViewer.currentBlock()
-        return [head.block, head._hash]
-      }
-      case 'epoch': {
-        return [Date.now(), null]
-      }
-      case 'ethereum': {
-        const provider = assertEx(this.ethProvider, () => 'Ethereum provider not configured')
-        const blockNumber = (await provider.getBlockNumber()) ?? 0
-        const block = await provider.getBlock(blockNumber)
-        const blockHash = asHash(assertEx(block?.hash, () => 'Block hash not found'), true)
-        return [blockNumber, blockHash]
-      }
-      default: {
-        throw new Error(`Unknown time domain: ${domain}`)
-      }
-    }
-  }
-
-  async currentTimePayload(): Promise<TimePayload> {
-    const [xl1, xl1Hash] = await this.currentTimeAndHash('xl1')
-    const timePayload: TimePayload = {
-      schema: TimeSchema,
-      // this is for the previous block
-      xl1,
-      // this is for the previous block
-      xl1Hash: assertEx(xl1Hash, () => 'No xl1 hash available from time sync service'),
-      epoch: Date.now(),
-    }
-    if (isDefined(this.ethProvider)) {
-      const [ethereum, ethHashOrNull] = await this.currentTimeAndHash('ethereum')
-      const ethereumHash = asHash(ethHashOrNull, () => 'No ethereum hash available from time sync service')
-      timePayload.ethereum = ethereum
-      timePayload.ethereumHash = ethereumHash
-    }
-    return timePayload
-  }
-}

package/src/simple/timeSync2/index.ts

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

package/src/simple/transactionInvalidation/SimpleTransactionInvalidationViewer.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/transactionInvalidation/index.ts

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

package/src/simple/transactionValidation/SimpleTransactionValidationViewer.ts

@@ -1,173 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  AccountBalanceViewer,
-  AccountBalanceViewerMoniker,
-  asXL1BlockRange,
-  BlockViewer,
-  BlockViewerMoniker,
-  ChainContractViewer,
-  ChainContractViewerMoniker,
-  ChainId,
-  HydratedTransactionStateValidationFunction,
-  HydratedTransactionValidationError,
-  HydratedTransactionValidationFunction,
-  isChainQualifiedHeadConfig,
-  isHydratedTransaction,
-  SignedHydratedTransaction,
-  type SignedHydratedTransactionWithHashMeta,
-  TransactionValidationConfig,
-  TransactionValidationQualification,
-  TransactionValidationViewer,
-  TransactionValidationViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleTransactionValidationViewer. */
-export interface SimpleTransactionValidationViewerParams extends CreatableProviderParams {
-  maxUncleWindowSize?: number
-  protocol?: HydratedTransactionValidationFunction
-  state?: HydratedTransactionStateValidationFunction
-}
-
-/** SimpleTransactionValidationViewer implementation. */
-@creatableProvider()
-export class SimpleTransactionValidationViewer extends
-  AbstractCreatableProvider<SimpleTransactionValidationViewerParams> implements TransactionValidationViewer {
-  static readonly defaultMoniker = TransactionValidationViewerMoniker
-  static readonly dependencies = [AccountBalanceViewerMoniker, ChainContractViewerMoniker, BlockViewerMoniker]
-  static readonly monikers = [TransactionValidationViewerMoniker]
-  moniker = SimpleTransactionValidationViewer.defaultMoniker
-
-  private _accountBalanceViewer!: AccountBalanceViewer
-  private _blockViewer!: BlockViewer
-  private _chainContractViewer!: ChainContractViewer
-
-  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<SimpleTransactionValidationViewerParams>): Promise<SimpleTransactionValidationViewerParams> {
-    return {
-      ...await super.paramsHandler(params),
-      protocol: params.protocol,
-      state: params.state,
-      maxUncleWindowSize: params.maxUncleWindowSize ?? 100,
-    } satisfies SimpleTransactionValidationViewerParams
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._accountBalanceViewer = await this.locator.getInstance<AccountBalanceViewer>(AccountBalanceViewerMoniker)
-    this._chainContractViewer = await this.locator.getInstance<ChainContractViewer>(ChainContractViewerMoniker)
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-  }
-
-  async qualifiedValidateTransaction(
-    block: SignedHydratedTransactionWithHashMeta,
-    config?: TransactionValidationConfig,
-  ): Promise<[HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta, TransactionValidationQualification]> {
-    const result = (await this.qualifiedValidateTransactions([block], config))
-    return [result[0][0], result[1]]
-  }
-
-  async qualifiedValidateTransactions(
-    transactions: SignedHydratedTransaction[],
-    config?: TransactionValidationConfig,
-  ): Promise<[(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[], TransactionValidationQualification]> {
-    const { value, state } = config ?? {
-      shape: true, links: true, state: true, head: undefined,
-    }
-
-    const transactionsWithMeta = await Promise.all(transactions.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 chainId = headBlock.chain
-
-    const qualification = { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) }
-    const [protocolResults, stateResults] = await Promise.all([
-      validateProtocol?.(transactionsWithMeta, chainId), validateState?.(transactionsWithMeta, chainId),
-    ])
-    const blockResults = transactionsWithMeta.map((r, i) => {
-      const errors = []
-      if (protocolResults && !isHydratedTransaction(protocolResults[i])) {
-        errors.push(...(protocolResults[i]))
-      }
-      if (stateResults && !isHydratedTransaction(stateResults[i])) {
-        errors.push(...(stateResults[i]))
-      }
-      return errors.length === 0 ? r : errors
-    })
-    return [blockResults, qualification]
-  }
-
-  qualifiedValidateUncle(
-    _transactions: SignedHydratedTransaction[],
-    _config?: TransactionValidationConfig,
-  ): Promise<[(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[], TransactionValidationQualification]> {
-    throw new Error('Method not implemented.')
-  }
-
-  async validateTransaction(
-    block: SignedHydratedTransaction,
-    config?: TransactionValidationConfig,
-  ): Promise<HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta> {
-    return (await this.validateTransactions([block], config))[0]
-  }
-
-  async validateTransactions(
-    transactions: SignedHydratedTransaction[],
-    config?: TransactionValidationConfig,
-  ): Promise<(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[]> {
-    return (await this.qualifiedValidateTransactions(transactions, config))[0]
-  }
-
-  private async doValidateProtocol(
-    transactions: SignedHydratedTransactionWithHashMeta[],
-    chainId: ChainId,
-  ): Promise<(SignedHydratedTransactionWithHashMeta | HydratedTransactionValidationError[])[]> {
-    return (await Promise.all(transactions.map(async (tx) => {
-      const errors = await this.params.protocol!(
-        { ...this.context, chainId },
-        tx,
-      )
-      return (errors.length === 0) ? tx : errors
-    })))
-  }
-
-  private async doValidateState(
-    transactions: SignedHydratedTransactionWithHashMeta[],
-    chainId: ChainId,
-  ): Promise<(SignedHydratedTransactionWithHashMeta | HydratedTransactionValidationError[])[]> {
-    return (await Promise.all(transactions.map(async (tx) => {
-      const errors = await this.params.state!(
-        {
-          ...this.context, chainId, accountBalanceViewer: this._accountBalanceViewer, blockViewer: this.blockViewer,
-        },
-        tx,
-      )
-      return (errors.length === 0) ? tx : errors
-    })))
-  }
-}

package/src/simple/transactionValidation/index.ts

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