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

package/src/simple/network/lib/StatusNetworks.ts

@@ -1,32 +0,0 @@
-import type { GatewayName } from '@xyo-network/xl1-protocol-lib'
-
-/** StatusNetwork type. */
-export type StatusNetwork = {
-  id: GatewayName
-  statusUrl: string
-}
-
-/** MainNetworkStats constant. */
-export const MainNetworkStats: StatusNetwork = {
-  id: 'mainnet' as GatewayName,
-  statusUrl: 'https://xyo.network/chain-network-status-mainnet.json',
-}
-
-/** SequenceNetworkStats constant. */
-export const SequenceNetworkStats: StatusNetwork = {
-  id: 'sequence' as GatewayName,
-  statusUrl: 'https://beta.xyo.network/chain-network-status-sequence.json',
-}
-
-/** LocalNetworkStats constant. */
-export const LocalNetworkStats: StatusNetwork = {
-  id: 'local' as GatewayName,
-  statusUrl: 'http://localhost:3002/chain-network-status-local.json',
-}
-
-/** StatusNetworks constant. */
-export const StatusNetworks: Record<GatewayName, StatusNetwork> = {
-  ['mainnet' as GatewayName]: MainNetworkStats,
-  ['sequence' as GatewayName]: SequenceNetworkStats,
-  ['local' as GatewayName]: LocalNetworkStats,
-}

package/src/simple/network/lib/index.ts

@@ -1,2 +0,0 @@
-export * from './FailedNetworkStatusPayloads.ts'
-export * from './StatusNetworks.ts'

package/src/simple/permissions/SimpleXyoPermissions.ts

@@ -1,82 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type {
-  CaveatTypes,
-  InvokerPermission, PermissionRequest, RequestedPermission, XyoPermissions,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { Invoker, PermissionsStore } from './store/index.ts'
-
-/**
- * In-memory implementation of XyoPermissions for testing or ephemeral use cases.
- * Does not persist data beyond the lifetime of the instance.
- * Assumes all permission requests are granted and revocations always succeed.
- */
-export class SimpleXyoPermissions implements XyoPermissions {
-  invoker: Invoker
-  private _store: PermissionsStore
-
-  constructor(store: PermissionsStore) {
-    this._store = store
-    this.invoker = store.invoker
-  }
-
-  get store(): PermissionsStore {
-    return assertEx(this._store, () => 'Store must be defined to get permissions')
-  }
-
-  async getPermissions(): Promise<InvokerPermission[]> {
-    return await this.store.getPermissions()
-  }
-
-  // assumed the permissions are always granted
-  async requestPermissions(permissions: PermissionRequest[]): Promise<RequestedPermission[]> {
-    await Promise.resolve()
-    // Flatten PermissionRequest[] into InvokerPermission[]
-    const newPermissions: InvokerPermission[] = []
-    const now = Date.now()
-    for (const req of permissions) {
-      for (const parentCapability in req) {
-        newPermissions.push({
-          invoker: this.invoker,
-          parentCapability,
-          caveats: Object.entries(req[parentCapability]).map(([type, value]) => ({ type: type as CaveatTypes, value })),
-          date: now,
-        })
-      }
-    }
-
-    // Update or add permissions in the store
-    const existingPermissions = await this.getPermissions()
-    for (const perm of newPermissions) {
-      const idx = existingPermissions.findIndex(
-        p => p.invoker === perm.invoker && p.parentCapability === perm.parentCapability,
-      )
-      if (idx === -1) {
-        existingPermissions.push(perm)
-      } else {
-        existingPermissions[idx] = perm
-      }
-    }
-    await this.store.setPermissions(existingPermissions)
-
-    // Return the granted permissions in RequestedPermission shape
-    return newPermissions.map(({ parentCapability, date }) => ({ parentCapability, date }))
-  }
-
-  // Assumes the permissions are always revoked
-  async revokePermissions(permissions: PermissionRequest): Promise<RequestedPermission[]> {
-    const existingPermissions = await this.getPermissions()
-    const revoked: RequestedPermission[] = []
-    for (const parentCapability in permissions) {
-      const idx = existingPermissions.findIndex(
-        p => p.invoker === this.invoker && p.parentCapability === parentCapability,
-      )
-      if (idx !== -1) {
-        const removed = existingPermissions.splice(idx, 1)[0]
-        revoked.push({ parentCapability: removed.parentCapability, date: removed.date })
-      }
-    }
-    await this.store.setPermissions(existingPermissions)
-    return revoked
-  }
-}

package/src/simple/permissions/index.ts

@@ -1,2 +0,0 @@
-export * from './SimpleXyoPermissions.ts'
-export * from './store/index.ts'

package/src/simple/permissions/store/MemoryPermissions.ts

@@ -1,32 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { InvokerPermission } from '@xyo-network/xl1-protocol-lib'
-
-import type { Invoker, PermissionsStore } from './PermissionsStore.ts'
-
-/**
- * In-memory implementation of XyoPermissions for testing or ephemeral use cases.
- * Does not persist data beyond the lifetime of the instance.
- * Assumes all permission requests are granted and revocations always succeed.
- */
-export class MemoryPermissionsStore implements PermissionsStore {
-  private _invoker: Invoker
-  private permissions: InvokerPermission[] = []
-
-  constructor(invoker: Invoker) {
-    this._invoker = invoker
-  }
-
-  get invoker(): Invoker {
-    return assertEx(this._invoker, () => 'Invoker must be defined to get permissions')
-  }
-
-  async getPermissions(): Promise<InvokerPermission[]> {
-    await Promise.resolve()
-    return this.permissions
-  }
-
-  async setPermissions(permissions: InvokerPermission[]): Promise<void> {
-    await Promise.resolve()
-    this.permissions = permissions
-  }
-}

package/src/simple/permissions/store/PermissionsStore.ts

@@ -1,17 +0,0 @@
-import type { InvokerPermission, PermissionsGetHandler } from '@xyo-network/xl1-protocol-lib'
-
-/** Invoker type. */
-export type Invoker = string
-/** ParentCapability type. */
-export type ParentCapability = string
-/**
- * Interface for a permissions store that abstracts away the storage medium.
- * (i.e. in-memory, browser storage, database, etc.)
- */
-export interface PermissionsStore extends PermissionsGetHandler {
-  // The invoker associated with this permissions store
-  readonly invoker: Invoker
-  // Retrieve all permissions associated with the invoker.
-  // Store or update permissions for the invoker
-  setPermissions(permissions: InvokerPermission[]): Promise<void>
-}

package/src/simple/permissions/store/index.ts

@@ -1,2 +0,0 @@
-export * from './MemoryPermissions.ts'
-export * from './PermissionsStore.ts'

package/src/simple/runner/SimpleXyoRunner.ts

@@ -1,41 +0,0 @@
-import { type Hash } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  MempoolRunner,
-  MempoolRunnerMoniker, SignedHydratedTransactionWithStorageMeta,
-  XyoRunner, XyoRunnerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleXyoRunner. */
-export interface SimpleXyoRunnerParams extends CreatableProviderParams {
-}
-
-/** SimpleXyoRunner implementation. */
-@creatableProvider()
-export class SimpleXyoRunner extends AbstractCreatableProvider<SimpleXyoRunnerParams> implements XyoRunner {
-  static readonly defaultMoniker = XyoRunnerMoniker
-  static readonly dependencies = [MempoolRunnerMoniker]
-  static readonly monikers = [XyoRunnerMoniker]
-  moniker = SimpleXyoRunner.defaultMoniker
-
-  private _mempoolRunner?: MempoolRunner
-
-  get mempool() {
-    return this._mempoolRunner!
-  }
-
-  async broadcastTransaction(transaction: SignedHydratedTransactionWithStorageMeta): Promise<Hash> {
-    await this.mempool.submitTransactions([transaction])
-    const hash = await PayloadBuilder.hash(transaction[0])
-    this.logger?.info(`Broadcasted transaction with hash ${hash}`)
-    return hash
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._mempoolRunner = await this.locator.getInstance<MempoolRunner>(MempoolRunnerMoniker)
-  }
-}

package/src/simple/runner/index.ts

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

package/src/simple/signer/SimpleXyoSigner.ts

@@ -1,78 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import type { AccountInstance, Payload } from '@xyo-network/sdk-js'
-import { Account, PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, ChainId, SignedHydratedTransactionWithHashMeta,
-  SignedTransactionBoundWitness, TransactionFeesBigInt,
-  UnsignedTransactionBoundWitness,
-  XL1BlockNumber, XyoSigner,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  SignedHydratedTransactionWithHashMetaZod,
-  XyoSignerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider } from '../../CreatableProvider/index.ts'
-import { buildTransaction, signTransaction } from '../../transaction/index.ts'
-
-/** Parameters for SimpleXyoSigner. */
-export interface SimpleXyoSignerParams extends CreatableProviderParams {
-  account: AccountInstance
-}
-
-/** SimpleXyoSigner implementation. */
-export class SimpleXyoSigner extends AbstractCreatableProvider<SimpleXyoSignerParams> implements XyoSigner {
-  static readonly defaultMoniker = XyoSignerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [XyoSignerMoniker]
-  moniker = SimpleXyoSigner.defaultMoniker
-
-  static override async paramsHandler(params?: Partial<SimpleXyoSignerParams>) {
-    let account: AccountInstance
-    if (params?.account) {
-      account = params.account
-    } else {
-      const localLogger = params?.logger ?? params?.context?.logger
-      localLogger?.warn(`No account provided to SimpleXyoSigner, generating a random account. 
-        This account will not be persisted and any transactions signed with it may be lost.
-      `)
-
-      account = await Account.random()
-    }
-    return { ...await super.paramsHandler(params), account }
-  }
-
-  address(): Promisable<Address> {
-    return this.params.account.address
-  }
-
-  /** @deprecated - use signTransaction instead */
-  async createSignedTransaction(
-    chain: ChainId,
-    elevatedPayloads: AllowedBlockPayload[],
-    additionalPayloads: Payload[],
-    nbf: XL1BlockNumber,
-    exp: XL1BlockNumber,
-    fees: TransactionFeesBigInt,
-    from?: Address,
-  ): Promise<SignedTransactionBoundWitness> {
-    const fromAddress = from ?? await this.address()
-    const transaction = await buildTransaction(
-      chain,
-      elevatedPayloads,
-      additionalPayloads,
-      this.params.account,
-      nbf,
-      exp,
-      fromAddress,
-      fees,
-    )
-    return transaction[0]
-  }
-
-  async signTransaction(tx: [UnsignedTransactionBoundWitness, Payload[]]): Promise<SignedHydratedTransactionWithHashMeta> {
-    const txBW = await signTransaction(tx[0], this.params.account)
-    return SignedHydratedTransactionWithHashMetaZod.parse([await PayloadBuilder.addStorageMeta(txBW), await PayloadBuilder.addStorageMeta(tx[1])])
-  }
-}

package/src/simple/signer/index.ts

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

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'