@xyo-network/chain-validation 1.20.14 → 1.20.16

package/src/elevatedPayload/lib/validateElevatedFromTransaction.ts

@@ -1,30 +0,0 @@
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import { InBlockPayloadValidationError, transactionsFromHydratedBlock } from '@xyo-network/xl1-sdk'
-
-export const validateElevatedFromTransaction: InBlockPayloadValidationFunction = (
-  context,
-  payload,
-  block,
-) => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    const txs = transactionsFromHydratedBlock(block)
-    if (txs.length > 0) {
-      const hashes = txs.flatMap(tx => tx.payload_hashes)
-      if (!hashes.includes(payload._hash)) {
-        errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, 'Transaction does not include payload'))
-      }
-    } else {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, 'No Transactions in block'))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(
-      payload._hash,
-      block,
-      payload,
-      `Failed validateElevatedFromTransaction: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/elevatedPayload/lib/validateIncludedInBlock.ts

@@ -1,14 +0,0 @@
-import type { Payload, WithStorageMeta } from '@xyo-network/sdk-js'
-import type { BlockBoundWitness } from '@xyo-network/xl1-sdk'
-
-export const validateIncludedInBlock = (payload: WithStorageMeta<Payload>, block: BlockBoundWitness): Error[] => {
-  const errors: Error[] = []
-  try {
-    if (!block.payload_hashes.includes(payload._hash)) {
-      errors.push(new Error('Payload not included in block'))
-    }
-  } catch (ex) {
-    errors.push(new Error(`Failed validateIncludedInBlock: ${ex}`))
-  }
-  return errors
-}

package/src/elevatedPayload/lib/validateTransactionInBlock.ts

@@ -1,43 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import { isHashMeta } from '@xyo-network/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import {
-  BoundWitnessSignaturesValidator, InBlockPayloadValidationError, isTransactionBoundWitness, validateTransaction,
-} from '@xyo-network/xl1-sdk'
-
-export const validateTransactionInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-): Promise<InBlockPayloadValidationError[]> => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    if (isTransactionBoundWitness(payload) && isHashMeta(payload)) {
-      const txErrors = await validateTransaction({ ...context, chainId: block[0].chain }, [payload, block[1]])
-      for (const txError of txErrors) {
-        errors.push(new InBlockPayloadValidationError(
-          payload._hash,
-          block,
-          payload,
-          `TransactionValidation error: ${txError}`,
-          txError,
-        ))
-      }
-      const txSignatureErrors = await BoundWitnessSignaturesValidator(payload)
-      for (const txSignatureError of txSignatureErrors) {
-        errors.push(new InBlockPayloadValidationError(
-          payload._hash,
-          block,
-          payload,
-          `BoundWitnessSignaturesValidator error: ${txSignatureError}`,
-          txSignatureError,
-        ))
-      }
-    } else {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, 'Payload failed isTransactionBoundWitness or isHashMeta'))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(payload._hash ?? ZERO_HASH, block, payload, `validation excepted: ${ex}`, ex))
-  }
-  return errors
-}

package/src/elevatedPayload/lib/validateTypedPayloadInBlock.ts

@@ -1,32 +0,0 @@
-import type { IdentityFunction } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-import { isHashMeta } from '@xyo-network/sdk-js'
-import type { HydratedBlockWithHashMeta, InBlockPayloadValidationFunctionContext } from '@xyo-network/xl1-sdk'
-
-import { isElevatedFromBlock } from './isElevatedFromBlock.ts'
-import { validateElevatedFromBlock } from './validateElevatedFromBlock.ts'
-import { validateElevatedFromTransaction } from './validateElevatedFromTransaction.ts'
-
-export const validateTypedPayloadInBlock = async <T extends Payload>(
-  context: InBlockPayloadValidationFunctionContext,
-  payload: Payload,
-  block: HydratedBlockWithHashMeta,
-  identityFunction: IdentityFunction<T>,
-): Promise<Error[]> => {
-  const errors: Error[] = []
-  try {
-    if (identityFunction(payload) && isHashMeta(payload)) {
-      if (isElevatedFromBlock(payload, block)) {
-        errors.push(...await validateElevatedFromBlock(context, payload, block))
-      } else {
-        errors.push(...await validateElevatedFromTransaction(context, payload, block))
-      }
-    } else {
-      errors.push(new Error('Payload failed identityFunction or isElevated or isStorageMeta'))
-    }
-  } catch (ex) {
-    errors.push(new Error(`Failed validateTypedPayloadInBlock: ${ex}`))
-  }
-  return errors
-}
-//

package/src/elevatedPayload/payloads/index.ts

@@ -1,8 +0,0 @@
-export * from './validateBridgeDestinationObservationInBlock.ts'
-export * from './validateBridgeIntentInBlock.ts'
-export * from './validateBridgeSourceObservationInBlock.ts'
-export * from './validateChainStakeIntentInBlock.ts'
-export * from './validateHashInBlock.ts'
-export * from './validateSchemaInBlock.ts'
-export * from './validateTimeInBlock.ts'
-export * from './validateTransferInBlock.ts'

package/src/elevatedPayload/payloads/validateBridgeDestinationObservationInBlock.ts

@@ -1,28 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import { InBlockPayloadValidationError, isBridgeDestinationObservation } from '@xyo-network/xl1-sdk'
-
-import { validateTypedPayloadInBlock } from '../lib/index.ts'
-
-export const validateBridgeDestinationObservationInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-) => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isBridgeDestinationObservation)
-    for (const typedError of typedErrors) {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(
-      (block?.[0])?._hash ?? ZERO_HASH,
-      block,
-      payload,
-      `Failed validateBridgeObservationInBlock: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/elevatedPayload/payloads/validateBridgeIntentInBlock.ts

@@ -1,28 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import { InBlockPayloadValidationError, isBridgeIntent } from '@xyo-network/xl1-sdk'
-
-import { validateTypedPayloadInBlock } from '../lib/index.ts'
-
-export const validateBridgeIntentInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-) => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isBridgeIntent)
-    for (const typedError of typedErrors) {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(
-      (block?.[0])?._hash ?? ZERO_HASH,
-      block,
-      payload,
-      `Failed validateBridgeIntentInBlock: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/elevatedPayload/payloads/validateBridgeSourceObservationInBlock.ts

@@ -1,28 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import { InBlockPayloadValidationError, isBridgeSourceObservation } from '@xyo-network/xl1-sdk'
-
-import { validateTypedPayloadInBlock } from '../lib/index.ts'
-
-export const validateBridgeSourceObservationInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-) => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isBridgeSourceObservation)
-    for (const typedError of typedErrors) {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(
-      (block?.[0])?._hash ?? ZERO_HASH,
-      block,
-      payload,
-      `Failed validateBridgeObservationInBlock: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/elevatedPayload/payloads/validateChainStakeIntentInBlock.ts

@@ -1,28 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import { InBlockPayloadValidationError, isChainStakeIntent } from '@xyo-network/xl1-sdk'
-
-import { validateTypedPayloadInBlock } from '../lib/index.ts'
-
-export const validateChainStakeIntentInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-) => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isChainStakeIntent)
-    for (const typedError of typedErrors) {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(
-      block[0]?._hash ?? ZERO_HASH,
-      block,
-      payload,
-      `validation excepted: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/elevatedPayload/payloads/validateHashInBlock.ts

@@ -1,28 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import { InBlockPayloadValidationError, isHashPayload } from '@xyo-network/xl1-sdk'
-
-import { validateTypedPayloadInBlock } from '../lib/index.ts'
-
-export const validateHashInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-) => {
-  const errors: (InBlockPayloadValidationError)[] = []
-  try {
-    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isHashPayload)
-    for (const typedError of typedErrors) {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(
-      (block?.[0])?._hash ?? ZERO_HASH,
-      block,
-      payload,
-      `validation excepted: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/elevatedPayload/payloads/validateSchemaInBlock.ts

@@ -1,29 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import { isSchemaPayload } from '@xyo-network/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import { InBlockPayloadValidationError } from '@xyo-network/xl1-sdk'
-
-import { validateTypedPayloadInBlock } from '../lib/index.ts'
-
-export const validateSchemaInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-) => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isSchemaPayload)
-    for (const typedError of typedErrors) {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(
-      (block?.[0])?._hash ?? ZERO_HASH,
-      block,
-      payload,
-      `Failed validateSchemaInBlock: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/elevatedPayload/payloads/validateTimeInBlock.ts

@@ -1,28 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import { InBlockPayloadValidationError, isTimePayload } from '@xyo-network/xl1-sdk'
-
-import { validateTypedPayloadInBlock } from '../lib/index.ts'
-
-export const validateTimeInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-) => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isTimePayload)
-    for (const typedError of typedErrors) {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(
-      (block?.[0])?._hash ?? ZERO_HASH,
-      block,
-      payload,
-      `Failed validateTimeInBlock: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/elevatedPayload/payloads/validateTransferInBlock.ts

@@ -1,28 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import { InBlockPayloadValidationError, isTransfer } from '@xyo-network/xl1-sdk'
-
-import { validateTypedPayloadInBlock } from '../lib/index.ts'
-
-export const validateTransferInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-) => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isTransfer)
-    for (const typedError of typedErrors) {
-      errors.push(new InBlockPayloadValidationError(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError))
-    }
-  } catch (ex) {
-    errors.push(new InBlockPayloadValidationError(
-      (block?.[0])?._hash ?? ZERO_HASH,
-      block,
-      payload,
-      `Failed validateTransferInBlock: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/elevatedPayload/validatePayloadInBlock.ts

@@ -1,53 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
-import type { Schema } from '@xyo-network/sdk-js'
-import { SchemaSchema } from '@xyo-network/sdk-js'
-import type { InBlockPayloadValidationFunction } from '@xyo-network/xl1-sdk'
-import {
-  BridgeDestinationObservationSchema, BridgeIntentSchema, BridgeSourceObservationSchema, ChainStakeIntentSchema, HashSchema, InBlockPayloadValidationError,
-  TimeSchema, TransferSchema,
-} from '@xyo-network/xl1-sdk'
-
-import { validateTransactionInBlock } from './lib/index.ts'
-import {
-  validateBridgeDestinationObservationInBlock, validateBridgeIntentInBlock, validateBridgeSourceObservationInBlock, validateChainStakeIntentInBlock,
-  validateHashInBlock, validateSchemaInBlock, validateTimeInBlock, validateTransferInBlock,
-} from './payloads/index.ts'
-
-const payloadValidators: Partial<Record<Schema, InBlockPayloadValidationFunction>> = {
-  [BoundWitnessSchema]: validateTransactionInBlock,
-  [BridgeDestinationObservationSchema]: validateBridgeDestinationObservationInBlock,
-  [BridgeIntentSchema]: validateBridgeIntentInBlock,
-  [BridgeSourceObservationSchema]: validateBridgeSourceObservationInBlock,
-  [ChainStakeIntentSchema]: validateChainStakeIntentInBlock,
-  [HashSchema]: validateHashInBlock,
-  [SchemaSchema]: validateSchemaInBlock,
-  [TimeSchema]: validateTimeInBlock,
-  [TransferSchema]: validateTransferInBlock,
-}
-
-export const validatePayloadInBlock: InBlockPayloadValidationFunction = async (
-  context,
-  payload,
-  block,
-): Promise<InBlockPayloadValidationError[]> => {
-  const errors: InBlockPayloadValidationError[] = []
-  try {
-    const validator = payloadValidators[payload.schema]
-    if (validator) {
-      errors.push(...await validator(context, payload, block))
-    } else {
-      errors.push(new InBlockPayloadValidationError((block?.[0])?._hash ?? ZERO_HASH, block, payload, `Unsupported payload schema: ${payload.schema}`))
-    }
-  } catch (ex) {
-    const error = new InBlockPayloadValidationError(
-      (block?.[0])?._hash ?? ZERO_HASH,
-      block,
-      payload,
-      `validation excepted: ${ex}`,
-      ex,
-    )
-    errors.push(error)
-  }
-  return errors
-}

package/src/hydratedBlock/index.ts

@@ -1,2 +0,0 @@
-export * from './validateHydratedBlock.ts'
-export * from './validators/index.ts'

package/src/hydratedBlock/validateHydratedBlock.ts

@@ -1,49 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type {
-  BaseContext,
-  BlockValidatorFunction, ChainId, HydratedBlockValidationFunction, HydratedBlockWithHashMeta,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-sdk'
-import { BoundWitnessReferencesValidator, HydratedBlockValidationError } from '@xyo-network/xl1-sdk'
-
-import { validateBlock } from '../block/index.ts'
-import { PayloadsInBlockValidator } from './validators/index.ts'
-
-export const validateHydratedBlock = async (
-  context: BaseContext,
-  hydratedBlock: HydratedBlockWithHashMeta,
-  chainIdAtBlockNumber?: (blockNumber: XL1BlockNumber) => Promisable<ChainId>,
-  additionalValidators: HydratedBlockValidationFunction[] = [],
-  additionalBlockValidators: BlockValidatorFunction[] = [],
-) => {
-  const errors: HydratedBlockValidationError[] = []
-  try {
-    const validateBlockErrors = await validateBlock(
-      context,
-      hydratedBlock[0],
-      chainIdAtBlockNumber ? await chainIdAtBlockNumber(hydratedBlock[0].block) : undefined,
-      additionalBlockValidators,
-    )
-    for (const validateBlockError of validateBlockErrors) {
-      errors.push(new HydratedBlockValidationError(hydratedBlock[0]._hash, hydratedBlock, `validateBlock error: ${validateBlockError}`, validateBlockError))
-    }
-    const bwRefErrors = await BoundWitnessReferencesValidator()(hydratedBlock)
-    for (const bwRefError of bwRefErrors) {
-      errors.push(new HydratedBlockValidationError(hydratedBlock[0]._hash, hydratedBlock, `boundwitness reference error: ${bwRefError}`, bwRefError))
-    }
-    const validators: HydratedBlockValidationFunction[] = [
-      PayloadsInBlockValidator,
-      ...additionalValidators,
-    ]
-    errors.push(...(await Promise.all(validators.map(v => v(context, hydratedBlock, chainIdAtBlockNumber)))).flat())
-  } catch (ex) {
-    errors.push(new HydratedBlockValidationError(
-      hydratedBlock?.[0]?._hash ?? ZERO_HASH,
-      hydratedBlock,
-      `Failed validateHydratedBlock: ${ex}`,
-      ex,
-    ))
-  }
-  return errors
-}

package/src/hydratedBlock/validators/Payloads.ts

@@ -1,54 +0,0 @@
-import { type Hash, ZERO_HASH } from '@xylabs/sdk-js'
-import type { Payload, WithHashMeta } from '@xyo-network/sdk-js'
-import type { HydratedBlockValidationFunction } from '@xyo-network/xl1-sdk'
-import { HydratedBlockValidationError } from '@xyo-network/xl1-sdk'
-
-import { validatePayloadInBlock } from '../../elevatedPayload/index.ts'
-
-export const PayloadsInBlockValidator: HydratedBlockValidationFunction = async (
-  context,
-  [block, payloads],
-) => {
-  const errors: HydratedBlockValidationError[] = []
-  try {
-    const payloadMap: Partial<Record<Hash, WithHashMeta<Payload>>> = {}
-    for (const payload of payloads) {
-      payloadMap[payload._hash] = payload
-    }
-
-    const remainingPayloads = { ...payloadMap }
-
-    for (let i = 0; i < block.payload_hashes.length; i++) {
-      const hash = block.payload_hashes[i]
-      const schema = block.payload_schemas[i]
-      const payload = payloadMap[hash]
-      if (payload) {
-        const payloadInBlockErrors = await validatePayloadInBlock(context, payload, [block, payloads])
-        for (const payloadInBlockError of payloadInBlockErrors) {
-          errors.push(new HydratedBlockValidationError(
-            block?._hash ?? ZERO_HASH,
-            [block, payloads],
-            `validatePayloadInBlock error: ${payloadInBlockError}`,
-            payloadInBlockError,
-          ))
-        }
-        delete remainingPayloads[hash]
-      } else {
-        errors.push(new HydratedBlockValidationError(block?._hash ?? ZERO_HASH, [block, payloads], `missing payload ${hash} ${schema}`))
-      }
-    }
-
-    if (Object.keys(remainingPayloads).length > 0) {
-      errors.push(new HydratedBlockValidationError(block?._hash ?? ZERO_HASH, [block, payloads], `extra payloads ${Object.keys(payloadMap).join(', ')}`))
-    }
-  } catch (ex) {
-    errors.push(new HydratedBlockValidationError(
-      block?._hash ?? ZERO_HASH,
-      [block, payloads],
-      `Failed PayloadsInBlockValidator: ${ex}`,
-      ex,
-    ))
-  }
-
-  return errors
-}

package/src/hydratedBlock/validators/index.ts

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

package/src/hydratedBlockState/index.ts

@@ -1,2 +0,0 @@
-export * from './validateHydratedBlockState.ts'
-export * from './validators/index.ts'

package/src/hydratedBlockState/validateHydratedBlockState.ts

@@ -1,44 +0,0 @@
-import { spanRootAsync, ZERO_HASH } from '@xylabs/sdk-js'
-import type { ChainId, HydratedBlockStateValidationFunction } from '@xyo-network/xl1-sdk'
-import { HydratedBlockStateValidationError } from '@xyo-network/xl1-sdk'
-
-import { validateHydratedBlock } from '../hydratedBlock/index.ts'
-import { RequiredBalanceBlockStateValidator } from './validators/index.ts'
-
-export const validateHydratedBlockState: HydratedBlockStateValidationFunction = async (
-  context,
-  hydratedBlock,
-  additionalValidators = [],
-) => {
-  return await spanRootAsync('validateHydratedBlockState', async () => {
-    const errors: HydratedBlockStateValidationError[] = []
-    let chainId: ChainId | undefined
-    try {
-      chainId = await context.chainIdAtBlockNumber(hydratedBlock[0].block)
-      const validateHydratedBlockErrors = await validateHydratedBlock(context, hydratedBlock, context.chainIdAtBlockNumber)
-      for (const validateHydratedBlockError of validateHydratedBlockErrors) {
-        errors.push(new HydratedBlockStateValidationError(
-          hydratedBlock[0]._hash,
-          chainId,
-          hydratedBlock,
-          `validateBlock error: ${validateHydratedBlockError}`,
-          validateHydratedBlockError,
-        ))
-      }
-      const validators: HydratedBlockStateValidationFunction[] = [
-        RequiredBalanceBlockStateValidator,
-        ...additionalValidators,
-      ]
-      errors.push(...(await Promise.all(validators.map(v => v(context, hydratedBlock)))).flat())
-    } catch (ex) {
-      errors.push(new HydratedBlockStateValidationError(
-        hydratedBlock?.[0]?._hash ?? ZERO_HASH,
-        chainId ?? '00' as ChainId,
-        hydratedBlock,
-        `Failed validateHydratedBlockState: ${ex}`,
-        ex,
-      ))
-    }
-    return errors
-  }, context)
-}

package/src/hydratedBlockState/validators/RequiredBalance.ts

@@ -1,59 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { spanRootAsync, ZERO_HASH } from '@xylabs/sdk-js'
-import type { ChainId, HydratedBlockStateValidationFunction } from '@xyo-network/xl1-sdk'
-import {
-  AttoXL1, HydratedBlockStateValidationError, netBalancesForPayloads, XYO_ZERO_ADDRESS,
-} from '@xyo-network/xl1-sdk'
-
-export const RequiredBalanceBlockStateValidator: HydratedBlockStateValidationFunction = async (
-  context,
-  block,
-) => {
-  return await spanRootAsync('RequiredBalanceBlockStateValidator', async () => {
-    const errors: HydratedBlockStateValidationError[] = []
-    let chainId = '00' as ChainId
-    try {
-      // TODO: Filter by non-producer elevated payloads
-    // to allow for transfers from ZERO address
-      const netBalances = netBalancesForPayloads({ singletons: {} }, (block[1]))
-      const netBalanceAddresses = Object.keys(netBalances) as Address[]
-      const requiredBalances: Record<Address, bigint> = {}
-      for (const address of netBalanceAddresses) {
-        if (netBalances[address] < 0n) {
-          requiredBalances[address] = -netBalances[address]
-        }
-      }
-      const previous = block[0].previous
-      if (previous === null) return [new HydratedBlockStateValidationError(
-        block?.[0]?._hash ?? ZERO_HASH,
-        '00' as ChainId,
-        block,
-        'Insufficient funds because first block',
-      )]
-      chainId = await context.chainIdAtBlockNumber(block[0].block)
-      await spanRootAsync('RequiredBalanceBlockStateValidator|balancesLoop', async () => {
-        for (const [address, reqBalance] of Object.entries(requiredBalances) as [Address, bigint][]) {
-          const result = await context.accountBalance.accountBalances([address], { head: previous })
-          const balance = result[address] ?? AttoXL1(0n)
-          if (address !== XYO_ZERO_ADDRESS && reqBalance > balance) {
-            errors.push(new HydratedBlockStateValidationError(
-              block?.[0]?._hash ?? ZERO_HASH,
-              chainId,
-              block,
-              `insufficient balance for ${address} ${balance} < ${requiredBalances[address]}`,
-            ))
-          }
-        }
-      }, context)
-    } catch (ex) {
-      errors.push(new HydratedBlockStateValidationError(
-        block?.[0]?._hash ?? ZERO_HASH,
-        chainId,
-        block,
-        `Failed RequiredBalanceBlockStateValidator: ${ex}`,
-        ex,
-      ))
-    }
-    return await Promise.resolve(errors)
-  }, context)
-}

package/src/hydratedBlockState/validators/index.ts

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

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './block/index.ts'
-export * from './hydratedBlock/index.ts'
-export * from './hydratedBlockState/index.ts'