@xyo-network/chain-validation 1.5.30 → 1.5.32

package/src/transaction/validators/TransactionGasValidator.ts

@@ -1,37 +1,61 @@
 import { hexToBigInt } from '@xylabs/hex'
+import type {
+  HydratedTransaction,
+  HydratedTransactionValidationFunction,
+  TransactionBoundWitness, TransactionFeesBigInt, TransactionFeesHex,
+} from '@xyo-network/xl1-protocol'
 import {
   AttoXL1,
-  type HydratedTransaction, type HydratedTransactionValidatorFunction,
+  HydratedTransactionValidationError,
   minTransactionFees,
-  type TransactionBoundWitness, type TransactionFeesBigInt, type TransactionFeesHex,
 } from '@xyo-network/xl1-protocol'
 
-export const TransactionGasValidator: HydratedTransactionValidatorFunction<TransactionBoundWitness> = (
-  [tx]: HydratedTransaction,
-): Error[] => {
-  const errors: Error[] = []
+export const TransactionGasValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = (
+  tx: HydratedTransaction,
+) => {
+  const errors: (HydratedTransactionValidationError | Error)[] = []
   try {
-    if (tx?.fees === undefined) {
-      errors.push(new Error('Missing fees'))
+    if (tx?.[0].fees === undefined) {
+      errors.push(new HydratedTransactionValidationError(tx, 'Missing fees'))
     } else {
       const {
         base, gasLimit, gasPrice, priority,
-      } = parseFees(tx.fees)
+      } = parseFees(tx[0].fees)
 
-      if (base === undefined) errors.push(new Error('fees.base must be defined and a valid number'))
-      else if (base < minTransactionFees.base) errors.push(new Error(`fees.base must be >= ${minTransactionFees.base}`))
+      if (base === undefined) errors.push(new HydratedTransactionValidationError(
+        tx,
+        'fees.base must be defined and a valid number',
+      ))
+      else if (base < minTransactionFees.base) errors.push(new HydratedTransactionValidationError(
+        tx,
+        `fees.base must be >= ${minTransactionFees.base}`,
+      ))
 
-      if (gasLimit === undefined) errors.push(new Error('fees.gasLimit must be defined and a valid number'))
-      else if (gasLimit < minTransactionFees.gasLimit) errors.push(new Error(`fees.gasLimit must be >= ${minTransactionFees.gasLimit}`))
+      if (gasLimit === undefined) errors.push(new HydratedTransactionValidationError(tx, 'fees.gasLimit must be defined and a valid number'))
+      else if (gasLimit < minTransactionFees.gasLimit) errors.push(new HydratedTransactionValidationError(
+        tx,
+        `fees.gasLimit must be >= ${minTransactionFees.gasLimit}`,
+      ))
 
-      if (gasPrice === undefined) errors.push(new Error('fees.gasPrice must be defined and a valid number'))
-      else if (gasPrice < minTransactionFees.gasPrice) errors.push(new Error(`fees.gasPrice must be >= ${minTransactionFees.gasPrice}`))
+      if (gasPrice === undefined) errors.push(
+        new HydratedTransactionValidationError(tx, 'fees.gasPrice must be defined and a valid number'),
+      )
+      else if (gasPrice < minTransactionFees.gasPrice) errors.push(new HydratedTransactionValidationError(
+        tx,
+        `fees.gasPrice must be >= ${minTransactionFees.gasPrice}`,
+      ))
 
-      if (priority === undefined) errors.push(new Error('fees.priority must be defined and a valid number'))
-      else if (priority < minTransactionFees.priority) errors.push(new Error(`fees.priority must be >= ${minTransactionFees.priority}`))
+      if (priority === undefined) errors.push(new HydratedTransactionValidationError(
+        tx,
+        'fees.priority must be defined and a valid number',
+      ))
+      else if (priority < minTransactionFees.priority) errors.push(new HydratedTransactionValidationError(
+        tx,
+        `fees.priority must be >= ${minTransactionFees.priority}`,
+      ))
     }
   } catch (e) {
-    errors.push(new Error(`Failed TransactionGasValidator: ${e instanceof Error ? e.message : String(e)}`))
+    errors.push(new HydratedTransactionValidationError(tx, `Failed TransactionGasValidator: ${e instanceof Error ? e.message : String(e)}`))
   }
   return errors
 }

package/src/transaction/validators/TransactionJsonSchemaValidator.ts

@@ -1,9 +1,9 @@
-import type { Promisable } from '@xylabs/promise'
 import { TransactionBoundWitnessJsonSchema } from '@xyo-network/chain-schema'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type {
-  HydratedTransaction, HydratedTransactionValidatorFunction, TransactionBoundWitness,
+  HydratedTransaction, HydratedTransactionValidationFunction, TransactionBoundWitness,
 } from '@xyo-network/xl1-protocol'
+import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol'
 import type { ValidateFunction } from 'ajv'
 import { Ajv } from 'ajv'
 
@@ -11,20 +11,20 @@ const ajv = new Ajv({ allErrors: true, strict: true })
 
 let validate: ValidateFunction<TransactionBoundWitness> | undefined
 
-export const TransactionJsonSchemaValidator: HydratedTransactionValidatorFunction<TransactionBoundWitness> = (
-  [tx]: HydratedTransaction,
-): Promisable<Error[]> => {
-  const errors: Error[] = []
+export const TransactionJsonSchemaValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = (
+  tx: HydratedTransaction,
+) => {
+  const errors: (HydratedTransactionValidationError | Error)[] = []
   try {
     if (validate === undefined) validate = ajv.compile(TransactionBoundWitnessJsonSchema)
     // see if you can export the super set
-    if (!validate(PayloadBuilder.omitStorageMeta(tx))) {
-      const error = new Error('failed JSON schema validation')
+    if (!validate(PayloadBuilder.omitStorageMeta(tx[0]))) {
+      const error = new HydratedTransactionValidationError(tx, 'failed JSON schema validation')
       error.cause = validate.errors
       errors.push(error)
     }
   } catch (ex) {
-    errors.push(new Error('validation excepted'), ex as Error)
+    errors.push(new HydratedTransactionValidationError(tx, 'validation excepted'), ex as Error)
   }
   return errors
 }

package/src/transaction/validators/TransactionProtocolValidator.ts

@@ -1,19 +1,20 @@
 import type { Address } from '@xylabs/hex'
 import type {
-  HydratedTransaction, HydratedTransactionValidatorFunction, TransactionBoundWitness,
+  HydratedTransaction, HydratedTransactionValidationFunction, TransactionBoundWitness,
 } from '@xyo-network/xl1-protocol'
+import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol'
 
-export const TransactionProtocolValidator: HydratedTransactionValidatorFunction<TransactionBoundWitness> = async (
-  [tx]: HydratedTransaction,
+export const TransactionProtocolValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = async (
+  tx: HydratedTransaction,
   chainId?: Address,
-): Promise<Error[]> => {
-  const errors: Error[] = []
+) => {
+  const errors: (HydratedTransactionValidationError | Error)[] = []
   try {
-    if (chainId !== undefined && tx.chain !== chainId) {
-      errors.push(new Error('invalid chain id'))
+    if (chainId !== undefined && tx[0].chain !== chainId) {
+      errors.push(new HydratedTransactionValidationError(tx, 'invalid chain id'))
     }
   } catch (ex) {
-    errors.push(new Error('validation excepted'), ex as Error)
+    errors.push(new HydratedTransactionValidationError(tx, 'validation excepted'), ex as Error)
   }
   return await Promise.resolve(errors)
 }