@xyo-network/chain-validation 1.5.29 → 1.5.31

package/src/block/validateBlock.ts

@@ -1,5 +1,6 @@
 import type { Address } from '@xylabs/hex'
 import type { BlockBoundWitness, BlockValidatorFunction } from '@xyo-network/xl1-protocol'
+import { BlockValidationError } from '@xyo-network/xl1-protocol'
 
 import { BoundWitnessSignaturesValidator } from '../boundwitness/index.ts'
 import {
@@ -10,7 +11,7 @@ import {
 export const validateBlock: BlockValidatorFunction = async (
   block: BlockBoundWitness,
   chainId?: Address,
-): Promise<Error[]> => {
+): Promise<(BlockValidationError | Error)[]> => {
   const errors: Error[] = []
   try {
     const validators: BlockValidatorFunction[] = [
@@ -24,7 +25,7 @@ export const validateBlock: BlockValidatorFunction = async (
       validators.map(validator => validator(block, chainId)),
     )).flat())
   } catch (ex) {
-    errors.push(new Error('validation excepted'), ex as Error)
+    errors.push(new BlockValidationError(block, 'validation excepted'), ex as Error)
   }
   return errors
 }

package/src/block/validators/AllowedPayloadSchemas.ts

@@ -1,19 +1,19 @@
 import {
-  type BlockBoundWitness, type BlockValidatorFunction, isAllowedBlockPayloadSchema,
+  type BlockBoundWitness, BlockValidationError, type BlockValidatorFunction, isAllowedBlockPayloadSchema,
 } from '@xyo-network/xl1-protocol'
 
 export const BlockAllowedPayloadSchemasValidator: BlockValidatorFunction = (
   block: BlockBoundWitness,
 ) => {
-  const errors: Error[] = []
+  const errors: (BlockValidationError | Error)[] = []
   try {
     for (const schema of block.payload_schemas) {
       if (!isAllowedBlockPayloadSchema(schema)) {
-        errors.push(new Error(`payload schema not allowed in block: ${schema}`))
+        errors.push(new BlockValidationError(block, `payload schema not allowed in block: ${schema}`))
       }
     }
   } catch (e) {
-    errors.push(new Error(`Failed BlockAllowedPayloadSchemasValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new BlockValidationError(block, `Failed BlockAllowedPayloadSchemasValidator: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/block/validators/Fields.ts

@@ -1,16 +1,18 @@
 import type { Address, Hash } from '@xylabs/hex'
 import { isDefined } from '@xylabs/typeof'
 import { BoundWitnessSchema } from '@xyo-network/boundwitness-model'
-import type { BlockBoundWitness, BlockValidatorFunction } from '@xyo-network/xl1-protocol'
+import {
+  type BlockBoundWitness, BlockValidationError, type BlockValidatorFunction,
+} from '@xyo-network/xl1-protocol'
 
 export const BlockFieldsValidator: BlockValidatorFunction = (
   block: BlockBoundWitness,
   chainId?: Address,
 ) => {
-  const errors: Error[] = []
+  const errors: (BlockValidationError | Error)[] = []
   try {
     if (isDefined(chainId) && block.chain !== chainId.toLowerCase()) {
-      errors.push(new Error('Invalid chain id'))
+      errors.push(new BlockValidationError(block, 'Invalid chain id'))
     }
 
     // get transaction hashes
@@ -23,10 +25,10 @@ export const BlockFieldsValidator: BlockValidatorFunction = (
 
     // check if transaction hashes are unique
     if (new Set(txHashes).size < txHashes.length) {
-      errors.push(new Error(`Duplicate Transaction Hashes: ${txHashes}`))
+      errors.push(new BlockValidationError(block, `Duplicate Transaction Hashes: ${txHashes}`))
     }
   } catch (e) {
-    errors.push(new Error(`Failed BlockFieldsValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new BlockValidationError(block, `Failed BlockFieldsValidator: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/block/validators/JsonSchema.ts

@@ -1,24 +1,25 @@
 import { BlockBoundWitnessWithStorageMetaJsonSchema } from '@xyo-network/chain-schema'
-import type { BlockBoundWitness, BlockValidatorFunction } from '@xyo-network/xl1-protocol'
+import {
+  type BlockBoundWitness, BlockValidationError, type BlockValidatorFunction,
+} from '@xyo-network/xl1-protocol'
 import type { AnySchema } from 'ajv'
 import { Ajv } from 'ajv'
 
 export const BlockJsonSchemaValidator = (jsonSchema: AnySchema = BlockBoundWitnessWithStorageMetaJsonSchema): BlockValidatorFunction => async (
   block: BlockBoundWitness,
 ) => {
-  const errors: Error[] = []
+  const errors: (BlockValidationError | Error)[] = []
   try {
     const ajv = new Ajv({ allErrors: true, strict: true })
     // see if you can export the super set
     const validate = ajv.compile(jsonSchema)
     await validate(block)
     if ((validate.errors ?? []).length > 0) {
-      const error = new Error('failed JSON schema validation')
-      error.cause = validate.errors
-      errors.push(error)
+      const error = new BlockValidationError(block, 'failed JSON schema validation: ')
+      errors.push(error, ...validate.errors?.map(e => new Error(`  ${e.instancePath} ${e.message ?? ''}`)) ?? [])
     }
   } catch (e) {
-    errors.push(new Error(`Failed BlockJsonSchemaValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new BlockValidationError(block, `Failed BlockJsonSchemaValidator: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/block/validators/PreviousHash.ts

@@ -1,28 +1,29 @@
 import { isHash } from '@xylabs/hex'
 import type { BlockBoundWitness, BlockValidatorFunction } from '@xyo-network/xl1-protocol'
+import { BlockValidationError } from '@xyo-network/xl1-protocol'
 
 export const BlockPreviousHashValidator: BlockValidatorFunction = (
   block: BlockBoundWitness,
 ) => {
-  const errors: Error[] = []
+  const errors: (BlockValidationError | Error)[] = []
   try {
     const blockNumber = block.block
     if (blockNumber > 0n) {
     // if this is not the first block, validate previous hashes
       if (!isHash(block.previous)) {
-        errors.push(new Error('previous hash is missing or invalid'))
+        errors.push(new BlockValidationError(block, 'previous hash is missing or invalid'))
       }
     } else if (blockNumber === 0) {
     // if this is the first block, validate previous hashes
       if (block.previous !== null) {
-        errors.push(new Error('previous hash should not be set'))
+        errors.push(new BlockValidationError(block, 'previous hash should not be set'))
       }
     } else {
     // we have a negative block number
-      errors.push(new Error('invalid block number'))
+      errors.push(new BlockValidationError(block, 'invalid block number'))
     }
   } catch (e) {
-    errors.push(new Error(`Failed BlockPreviousHashValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new BlockValidationError(block, `Failed BlockPreviousHashValidator: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/boundwitness/validators/BoundWitnessReferences.ts

@@ -8,6 +8,7 @@ import type {
 } from '@xyo-network/payload-model'
 import { isAnyPayload } from '@xyo-network/payload-model'
 import type { HydratedBoundWitnessValidationFunction, HydratedBoundWitnessWithHashStorageMeta } from '@xyo-network/xl1-protocol'
+import { HydratedBoundWitnessValidationError } from '@xyo-network/xl1-protocol'
 
 function getPayloadsFromPayloadArray(payloads: WithHashStorageMeta<Payload>[], hashes: Hash[]): (WithHashStorageMeta<Payload> | undefined)[] {
   return hashes.map(hash => payloads.find(payload => payload._hash === hash || payload._dataHash === hash))
@@ -16,12 +17,12 @@ function getPayloadsFromPayloadArray(payloads: WithHashStorageMeta<Payload>[], h
 export const BoundWitnessReferencesValidator
 = <T extends BoundWitness = BoundWitness>(allowedSchemas?: Schema[]): HydratedBoundWitnessValidationFunction<T> => (
   [bw, payloadSet]: HydratedBoundWitnessWithHashStorageMeta<T>,
-): Promisable<Error[]> => {
-  const errors: Error[] = []
+): Promisable<(HydratedBoundWitnessValidationError | Error)[]> => {
+  const errors: (HydratedBoundWitnessValidationError | Error)[] = []
   try {
     const payloads = getPayloadsFromPayloadArray(payloadSet, bw.payload_hashes)
     if (payloads.length !== bw.payload_hashes.length) {
-      errors.push(new Error('unable to locate payloads'))
+      errors.push(new HydratedBoundWitnessValidationError([bw, payloadSet], 'unable to locate payloads'))
     }
 
     // check if payloads are valid and if their schemas match the declared schemas
@@ -31,23 +32,23 @@ export const BoundWitnessReferencesValidator
         const payloadDataHashIndex = bw.payload_hashes.indexOf(payload._dataHash)
         const payloadIndex = Math.max(payloadHashIndex, payloadDataHashIndex)
         if (payloadIndex === -1) {
-          errors.push(new Error('payload hash not found'))
+          errors.push(new HydratedBoundWitnessValidationError([bw, payloadSet], 'payload hash not found'))
         }
 
         const declaredSchema = bw.payload_schemas[payloadIndex]
         if (declaredSchema !== payload.schema) {
-          errors.push(new Error('mismatched schema'))
+          errors.push(new HydratedBoundWitnessValidationError([bw, payloadSet], 'mismatched schema'))
         }
 
         if (allowedSchemas && !allowedSchemas.includes(payload.schema)) {
-          errors.push(new Error(`disallowed schema [${payload.schema}]`))
+          errors.push(new HydratedBoundWitnessValidationError([bw, payloadSet], `disallowed schema [${payload.schema}]`))
         }
       } else {
-        errors.push(new Error('invalid payload'))
+        errors.push(new HydratedBoundWitnessValidationError([bw, payloadSet], 'invalid payload'))
       }
     }
   } catch (ex) {
-    errors.push(new Error('validation excepted'), ex as Error)
+    errors.push(new HydratedBoundWitnessValidationError([bw, payloadSet], 'validation excepted'), ex as Error)
   }
   return errors
 }

package/src/boundwitness/validators/BoundWitnessSignatures.ts

@@ -4,21 +4,22 @@ import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
 import type { BoundWitness } from '@xyo-network/boundwitness-model'
 import { BoundWitnessValidator } from '@xyo-network/boundwitness-validator'
 import type { BoundWitnessValidationFunction } from '@xyo-network/xl1-protocol'
+import { BoundWitnessValidationError } from '@xyo-network/xl1-protocol'
 
 export const BoundWitnessSignaturesValidator: BoundWitnessValidationFunction = async (
   bw: BoundWitness,
-): Promise<Error[]> => {
-  const errors: Error[] = []
+) => {
+  const errors: (BoundWitnessValidationError | Error)[] = []
   try {
     const dataHash = await BoundWitnessBuilder.dataHash(bw)
-    const results: [Address, Error[]][] = await Promise.all(bw.addresses.map(async (address, index) => {
+    const results: [Address, (Error | BoundWitnessValidationError)[]][] = await Promise.all(bw.addresses.map(async (address, index) => {
       return [address, await BoundWitnessValidator.validateSignature(toArrayBuffer(dataHash), toArrayBuffer(address), toArrayBuffer(bw.$signatures[index]))]
     }))
     for (const [, bwErrors] of results) {
       errors.push(...bwErrors)
     }
   } catch (ex) {
-    errors.push(new Error('validation excepted'), ex as Error)
+    errors.push(new BoundWitnessValidationError(bw, 'validation excepted'), ex as Error)
   }
   return errors
 }

package/src/elevatedPayload/payloads/validateChainStakeIntentInBlock.ts

@@ -1,17 +1,17 @@
 import type { HydratedBlock, InBlockPayloadValidationFunction } from '@xyo-network/xl1-protocol'
-import { isChainStakeIntent } from '@xyo-network/xl1-protocol'
+import { InBlockPayloadValidationError, isChainStakeIntent } from '@xyo-network/xl1-protocol'
 
 import { validateTypedPayloadInBlock } from '../lib/index.ts'
 
 export const validateChainStakeIntentInBlock: InBlockPayloadValidationFunction = async (
   payload,
   block: HydratedBlock,
-): Promise<Error[]> => {
-  const errors: Error[] = []
+): Promise<(InBlockPayloadValidationError | Error)[]> => {
+  const errors: (InBlockPayloadValidationError | Error)[] = []
   try {
     errors.push(...await validateTypedPayloadInBlock(payload, block, isChainStakeIntent))
   } catch (e) {
-    errors.push(new Error(`Failed validateChainStakeIntentInBlock: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new InBlockPayloadValidationError(block, payload, `Failed validateChainStakeIntentInBlock: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/elevatedPayload/payloads/validateHashInBlock.ts

@@ -1,17 +1,17 @@
 import type { HydratedBlock, InBlockPayloadValidationFunction } from '@xyo-network/xl1-protocol'
-import { isHashPayload } from '@xyo-network/xl1-protocol'
+import { InBlockPayloadValidationError, isHashPayload } from '@xyo-network/xl1-protocol'
 
 import { validateTypedPayloadInBlock } from '../lib/index.ts'
 
 export const validateHashInBlock: InBlockPayloadValidationFunction = async (
   payload,
   block: HydratedBlock,
-): Promise<Error[]> => {
-  const errors: Error[] = []
+): Promise<(InBlockPayloadValidationError | Error)[]> => {
+  const errors: (InBlockPayloadValidationError | Error)[] = []
   try {
     errors.push(...await validateTypedPayloadInBlock(payload, block, isHashPayload))
   } catch (e) {
-    errors.push(new Error(`Failed validateHashInBlock: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new InBlockPayloadValidationError(block, payload, `Failed validateHashInBlock: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/elevatedPayload/payloads/validateSchemaInBlock.ts

@@ -1,17 +1,18 @@
 import { isSchemaPayload } from '@xyo-network/schema-payload-plugin'
 import type { HydratedBlock, InBlockPayloadValidationFunction } from '@xyo-network/xl1-protocol'
+import { InBlockPayloadValidationError } from '@xyo-network/xl1-protocol'
 
 import { validateTypedPayloadInBlock } from '../lib/index.ts'
 
 export const validateSchemaInBlock: InBlockPayloadValidationFunction = async (
   payload,
   block: HydratedBlock,
-): Promise<Error[]> => {
+): Promise<(InBlockPayloadValidationError | Error)[]> => {
   const errors: Error[] = []
   try {
     errors.push(...await validateTypedPayloadInBlock(payload, block, isSchemaPayload))
   } catch (e) {
-    errors.push(new Error(`Failed validateSchemaInBlock: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new InBlockPayloadValidationError(block, payload, `Failed validateSchemaInBlock: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/elevatedPayload/payloads/validateTransferInBlock.ts

@@ -1,6 +1,8 @@
-import {
-  type HydratedBlock, type InBlockPayloadValidationFunction, isTransfer,
+import type {
+  HydratedBlock,
+  InBlockPayloadValidationFunction,
 } from '@xyo-network/xl1-protocol'
+import { InBlockPayloadValidationError, isTransfer } from '@xyo-network/xl1-protocol'
 
 import { validateTypedPayloadInBlock } from '../lib/index.ts'
 
@@ -8,11 +10,11 @@ export const validateTransferInBlock: InBlockPayloadValidationFunction = async (
   payload,
   block: HydratedBlock,
 ): Promise<Error[]> => {
-  const errors: Error[] = []
+  const errors: (InBlockPayloadValidationError | Error)[] = []
   try {
     errors.push(...await validateTypedPayloadInBlock(payload, block, isTransfer))
   } catch (e) {
-    errors.push(new Error(`Failed validateTransferInBlock: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new InBlockPayloadValidationError(block, payload, `Failed validateTransferInBlock: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/elevatedPayload/validatePayloadInBlock.ts

@@ -6,7 +6,8 @@ import type {
   InBlockPayloadValidationFunction,
 } from '@xyo-network/xl1-protocol'
 import {
-  ChainStakeIntentSchema, HashSchema, TransferSchema,
+  ChainStakeIntentSchema, HashSchema, InBlockPayloadValidationError,
+  TransferSchema,
 } from '@xyo-network/xl1-protocol'
 
 import { validateTransactionInBlock } from './lib/index.ts'
@@ -25,17 +26,17 @@ const payloadValidators: Partial<Record<Schema, InBlockPayloadValidationFunction
 export const validatePayloadInBlock: InBlockPayloadValidationFunction = async (
   payload,
   block: HydratedBlock,
-): Promise<Error[]> => {
-  const errors: Error[] = []
+): Promise<(InBlockPayloadValidationError | Error)[]> => {
+  const errors: (InBlockPayloadValidationError | Error)[] = []
   try {
     const validator = payloadValidators[payload.schema]
     if (validator) {
       errors.push(...await validator(payload, block))
     } else {
-      errors.push(new Error(`Unsupported payload schema: ${payload.schema}`))
+      errors.push(new InBlockPayloadValidationError(block, payload, `Unsupported payload schema: ${payload.schema}`))
     }
   } catch (e) {
-    errors.push(new Error(`Failed validatePayloadInBlock: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new InBlockPayloadValidationError(block, payload, `Failed validatePayloadInBlock: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/hydratedBlock/validateHydratedBlock.ts

@@ -1,26 +1,27 @@
 import type { Address } from '@xylabs/hex'
-import type { HydratedBlock, HydratedBlockValidatorFunction } from '@xyo-network/xl1-protocol'
+import type { HydratedBlock, HydratedBlockValidationFunction } from '@xyo-network/xl1-protocol'
+import { HydratedBlockValidationError } from '@xyo-network/xl1-protocol'
 
 import { validateBlock } from '../block/index.ts'
 import { BoundWitnessReferencesValidator } from '../boundwitness/index.ts'
 import { PayloadsInBlockValidator } from './validators/index.ts'
 
-export const validateHydratedBlock: HydratedBlockValidatorFunction = async (
+export const validateHydratedBlock: HydratedBlockValidationFunction = async (
   hydratedBlock: HydratedBlock,
   chainId?: Address,
-  additionalValidators: HydratedBlockValidatorFunction[] = [],
-): Promise<Error[]> => {
+  additionalValidators: HydratedBlockValidationFunction[] = [],
+): Promise<(HydratedBlockValidationError | Error)[]> => {
   const errors: Error[] = []
   try {
     errors.push(...await validateBlock(hydratedBlock[0], chainId))
-    const validators: HydratedBlockValidatorFunction[] = [
+    const validators: HydratedBlockValidationFunction[] = [
       BoundWitnessReferencesValidator(),
       PayloadsInBlockValidator,
       ...additionalValidators,
     ]
     errors.push(...(await Promise.all(validators.map(v => v(hydratedBlock, chainId)))).flat())
   } catch (e) {
-    errors.push(new Error(`Failed validateHydratedBlock: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new HydratedBlockValidationError(hydratedBlock, `Failed validateHydratedBlock: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/hydratedBlock/validators/Payloads.ts

@@ -2,15 +2,16 @@ import type { Hash } from '@xylabs/hex'
 import type { Payload, WithHashStorageMeta } from '@xyo-network/payload-model'
 import type {
   HydratedBlock,
-  HydratedBlockValidatorFunction,
+  HydratedBlockValidationFunction,
 } from '@xyo-network/xl1-protocol'
+import { HydratedBlockValidationError } from '@xyo-network/xl1-protocol'
 
 import { validatePayloadInBlock } from '../../elevatedPayload/validatePayloadInBlock.ts'
 
-export const PayloadsInBlockValidator: HydratedBlockValidatorFunction = async (
+export const PayloadsInBlockValidator: HydratedBlockValidationFunction = async (
   [block, payloads]: HydratedBlock,
 ) => {
-  const errors: Error[] = []
+  const errors: (HydratedBlockValidationError | Error)[] = []
   try {
     const payloadMap: Partial<Record<Hash, WithHashStorageMeta<Payload>>> = {}
     for (const payload of payloads) {
@@ -27,15 +28,15 @@ export const PayloadsInBlockValidator: HydratedBlockValidatorFunction = async (
         errors.push(...await validatePayloadInBlock(payload, [block, payloads]))
         delete remainingPayloads[hash]
       } else {
-        errors.push(new Error(`missing payload ${hash} ${schema}`))
+        errors.push(new HydratedBlockValidationError([block, payloads], `missing payload ${hash} ${schema}`))
       }
     }
 
     if (Object.keys(remainingPayloads).length > 0) {
-      errors.push(new Error(`extra payloads ${Object.keys(payloadMap).join(', ')}`))
+      errors.push(new HydratedBlockValidationError([block, payloads], `extra payloads ${Object.keys(payloadMap).join(', ')}`))
     }
   } catch (e) {
-    errors.push(new Error(`Failed PayloadsInBlockValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new HydratedBlockValidationError([block, payloads], `Failed PayloadsInBlockValidator: ${e instanceof Error ? e.message : String(e)}`))
   }
 
   return errors

package/src/hydratedBlockState/validateHydratedBlockState.ts

@@ -2,6 +2,7 @@ import type { Address } from '@xylabs/hex'
 import type {
   AccountBalanceService, HydratedBlock, HydratedBlockStateValidationFunction,
 } from '@xyo-network/xl1-protocol'
+import { HydratedBlockStateValidationError } from '@xyo-network/xl1-protocol'
 
 import { validateHydratedBlock } from '../hydratedBlock/index.ts'
 import { RequiredBalanceBlockStateValidator } from './validators/index.ts'
@@ -11,7 +12,7 @@ export const validateHydratedBlockState: HydratedBlockStateValidationFunction =
   chainId: Address,
   services: { accountBalance: AccountBalanceService },
   additionalValidators: HydratedBlockStateValidationFunction[] = [],
-): Promise<Error[]> => {
+): Promise<(HydratedBlockStateValidationError | Error)[]> => {
   const errors: Error[] = []
   try {
     errors.push(...await validateHydratedBlock(hydratedBlock, chainId))
@@ -21,7 +22,11 @@ export const validateHydratedBlockState: HydratedBlockStateValidationFunction =
     ]
     errors.push(...(await Promise.all(validators.map(v => v(hydratedBlock, chainId, services)))).flat())
   } catch (e) {
-    errors.push(new Error(`Failed validateHydratedBlockState: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new HydratedBlockStateValidationError(
+      chainId,
+      hydratedBlock,
+      `Failed validateHydratedBlockState: ${e instanceof Error ? e.message : String(e)}`,
+    ))
   }
   return errors
 }

package/src/hydratedBlockState/validators/RequiredBalance.ts

@@ -4,13 +4,14 @@ import { XYO_ZERO_ADDRESS } from '@xyo-network/chain-utils'
 import type {
   AccountBalanceService, HydratedBlock, HydratedBlockStateValidationFunction,
 } from '@xyo-network/xl1-protocol'
+import { HydratedBlockStateValidationError } from '@xyo-network/xl1-protocol'
 
 export const RequiredBalanceBlockStateValidator: HydratedBlockStateValidationFunction = async (
   block: HydratedBlock,
   chainId: Address,
   services: { accountBalance: AccountBalanceService },
 ) => {
-  const errors: Error[] = []
+  const errors: (HydratedBlockStateValidationError | Error)[] = []
   try {
   // TODO: Filter by non-producer elevated payloads
     // to allow for transfers from ZERO address
@@ -23,16 +24,24 @@ export const RequiredBalanceBlockStateValidator: HydratedBlockStateValidationFun
       }
     }
     const previous = block[0].previous
-    if (previous === null) return [new Error('Insufficient funds because first block')]
+    if (previous === null) return [new HydratedBlockStateValidationError(chainId, block, 'Insufficient funds because first block')]
 
     for (const [address, reqBalance] of Object.entries(requiredBalances) as [Address, bigint][]) {
       const balance = hexToBigInt(services.accountBalance.getBalance(address))
       if (address !== XYO_ZERO_ADDRESS && reqBalance > balance) {
-        errors.push(new Error(`insufficient balance for ${address} ${balance} < ${requiredBalances[address]}`))
+        errors.push(new HydratedBlockStateValidationError(
+          chainId,
+          block,
+          `insufficient balance for ${address} ${balance} < ${requiredBalances[address]}`,
+        ))
       }
     }
   } catch (e) {
-    errors.push(new Error(`Failed RequiredBalanceBlockStateValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new HydratedBlockStateValidationError(
+      chainId,
+      block,
+      `Failed RequiredBalanceBlockStateValidator: ${e instanceof Error ? e.message : String(e)}`,
+    ))
   }
   return await Promise.resolve(errors)
 }

package/src/transaction/validateTransaction.ts

@@ -1,5 +1,5 @@
 import type { Address } from '@xylabs/hex'
-import type { HydratedTransactionValidatorFunction, HydratedTransactionWithHashStorageMeta } from '@xyo-network/xl1-protocol'
+import type { HydratedTransaction, HydratedTransactionValidationFunction } from '@xyo-network/xl1-protocol'
 import { isTransactionBoundWitness } from '@xyo-network/xl1-protocol'
 
 import {
@@ -8,16 +8,16 @@ import {
 } from './validators/index.ts'
 
 export async function validateTransaction(
-  tx: HydratedTransactionWithHashStorageMeta,
+  tx: HydratedTransaction,
   chainId?: Address,
-  additionalValidators: HydratedTransactionValidatorFunction[] = [],
-): Promise<Error[]> {
+  additionalValidators: HydratedTransactionValidationFunction[] = [],
+) {
   try {
     if (!isTransactionBoundWitness(tx[0])) {
       return [new Error('failed isTransactionBoundWitness identity check')]
     }
 
-    const validators: HydratedTransactionValidatorFunction[] = [
+    const validators: HydratedTransactionValidationFunction[] = [
       TransactionProtocolValidator,
       TransactionJsonSchemaValidator,
       TransactionDurationValidator,

package/src/transaction/validators/TransactionDurationValidator.ts

@@ -1,20 +1,21 @@
 import type {
-  HydratedTransaction, HydratedTransactionValidatorFunction, TransactionBoundWitness,
+  HydratedTransaction, HydratedTransactionValidationFunction, TransactionBoundWitness,
 } from '@xyo-network/xl1-protocol'
+import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol'
 
-export const TransactionDurationValidator: HydratedTransactionValidatorFunction<TransactionBoundWitness> = (
-  [tx]: HydratedTransaction,
-): Error[] => {
-  const errors: Error[] = []
+export const TransactionDurationValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = (
+  tx: HydratedTransaction,
+) => {
+  const errors: (HydratedTransactionValidationError | Error)[] = []
   try {
-    const { exp, nbf } = tx
-    if (nbf < 0) errors.push(new Error('Transaction nbf must be positive'))
+    const { exp, nbf } = tx[0]
+    if (nbf < 0) errors.push(new HydratedTransactionValidationError(tx, 'Transaction nbf must be positive'))
 
-    if (exp < 0) errors.push(new Error('Transaction exp must be positive'))
-    if (exp <= nbf) errors.push(new Error('Transaction exp must greater than nbf'))
-    if (exp - nbf > 10_000) errors.push(new Error('Transaction exp must not be too far in the future'))
+    if (exp < 0) errors.push(new HydratedTransactionValidationError(tx, 'Transaction exp must be positive'))
+    if (exp <= nbf) errors.push(new HydratedTransactionValidationError(tx, 'Transaction exp must greater than nbf'))
+    if (exp - nbf > 10_000) errors.push(new HydratedTransactionValidationError(tx, 'Transaction exp must not be too far in the future'))
   } catch (e) {
-    errors.push(new Error(`Failed TransactionDurationValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new HydratedTransactionValidationError(tx, `Failed TransactionDurationValidator: ${e instanceof Error ? e.message : String(e)}`))
   }
 
   return errors

package/src/transaction/validators/TransactionElevationValidator.ts

@@ -1,21 +1,21 @@
-import type { Promisable } from '@xylabs/promise'
 import { extractElevatedHashes } from '@xyo-network/chain-protocol'
 import type {
-  HydratedTransactionValidatorFunction, HydratedTransactionWithHashStorageMeta, TransactionBoundWitness,
+  HydratedTransaction, HydratedTransactionValidationFunction, TransactionBoundWitness,
 } from '@xyo-network/xl1-protocol'
+import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol'
 
-export const TransactionElevationValidator: HydratedTransactionValidatorFunction<TransactionBoundWitness> = (
-  tx: HydratedTransactionWithHashStorageMeta,
-): Promisable<Error[]> => {
-  const errors: Error[] = []
+export const TransactionElevationValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = (
+  tx: HydratedTransaction,
+) => {
+  const errors: (HydratedTransactionValidationError | Error)[] = []
   try {
     try {
       extractElevatedHashes(tx)
     } catch {
-      errors.push(new Error('Hydrated transaction does not include all script hashes'))
+      errors.push(new HydratedTransactionValidationError(tx, 'Hydrated transaction does not include all script hashes'))
     }
   } catch (e) {
-    errors.push(new Error(`Failed TransactionElevationValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new HydratedTransactionValidationError(tx, `Failed TransactionElevationValidator: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/transaction/validators/TransactionFromValidator.ts

@@ -1,19 +1,20 @@
 import { asAddress } from '@xylabs/hex'
 import { addressesContains } from '@xyo-network/boundwitness-validator'
 import type {
-  HydratedTransaction, HydratedTransactionValidatorFunction, TransactionBoundWitness,
+  HydratedTransaction, HydratedTransactionValidationFunction, TransactionBoundWitness,
 } from '@xyo-network/xl1-protocol'
+import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol'
 
-export const TransactionFromValidator: HydratedTransactionValidatorFunction<TransactionBoundWitness> = (
-  [tx]: HydratedTransaction,
-): Error[] => {
-  const errors: Error[] = []
+export const TransactionFromValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = (
+  tx: HydratedTransaction,
+) => {
+  const errors: (HydratedTransactionValidationError | Error)[] = []
   try {
-    const from = asAddress(tx.from)
-    if (from === undefined)errors.push(new Error('Transaction from is not a valid address'))
-    else if (!addressesContains(tx, from)) errors.push(new Error('Transaction from address must be listed in addresses'))
+    const from = asAddress(tx[0].from)
+    if (from === undefined)errors.push(new HydratedTransactionValidationError(tx, 'Transaction from is not a valid address'))
+    else if (!addressesContains(tx[0], from)) errors.push(new HydratedTransactionValidationError(tx, 'Transaction from address must be listed in addresses'))
   } catch (e) {
-    errors.push(new Error(`Failed TransactionFromValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new HydratedTransactionValidationError(tx, `Failed TransactionFromValidator: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }