@xyo-network/xl1-validation 1.7.16

package/src/transaction/validateTransaction.ts

@@ -0,0 +1,33 @@
+import type { Address } from '@xylabs/hex'
+import type { HydratedTransaction, HydratedTransactionValidationFunction } from '@xyo-network/xl1-protocol'
+import { isTransactionBoundWitness } from '@xyo-network/xl1-protocol'
+
+import {
+  TransactionDurationValidator,
+  TransactionElevationValidator, TransactionFromValidator, TransactionGasValidator, TransactionJsonSchemaValidator, TransactionProtocolValidator,
+} from './validators/index.ts'
+
+export async function validateTransaction(
+  tx: HydratedTransaction,
+  chainId?: Address,
+  additionalValidators: HydratedTransactionValidationFunction[] = [],
+) {
+  try {
+    if (!isTransactionBoundWitness(tx[0])) {
+      return [new Error('failed isTransactionBoundWitness identity check')]
+    }
+
+    const validators: HydratedTransactionValidationFunction[] = [
+      TransactionProtocolValidator,
+      TransactionJsonSchemaValidator,
+      TransactionDurationValidator,
+      TransactionFromValidator,
+      TransactionGasValidator,
+      TransactionElevationValidator,
+      ...additionalValidators,
+    ]
+    return (await Promise.all(validators.map(v => v(tx, chainId)))).flat()
+  } catch (ex) {
+    return [(new Error(`Failed TransactionGasValidator: ${ex}`))]
+  }
+}

package/src/transaction/validators/TransactionDurationValidator.ts

@@ -0,0 +1,33 @@
+import { ZERO_HASH } from '@xylabs/hex'
+import type {
+  HydratedTransaction, HydratedTransactionValidationFunction, TransactionBoundWitness,
+} from '@xyo-network/xl1-protocol'
+import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol'
+
+// eslint-disable-next-line complexity
+export const TransactionDurationValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = (
+  tx: HydratedTransaction,
+) => {
+  const errors: HydratedTransactionValidationError[] = []
+  try {
+    const { exp, nbf } = tx[0]
+    if (nbf < 0) errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, 'Transaction nbf must be positive'))
+
+    if (exp < 0) errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, 'Transaction exp must be positive'))
+    if (exp <= nbf) errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, 'Transaction exp must greater than nbf'))
+    if (exp - nbf > 10_000) errors.push(new HydratedTransactionValidationError(
+      tx?.[0]?._hash ?? ZERO_HASH,
+      tx,
+      'Transaction exp must not be too far in the future',
+    ))
+  } catch (ex) {
+    errors.push(new HydratedTransactionValidationError(
+      tx?.[0]?._hash ?? ZERO_HASH,
+      tx,
+      `Failed TransactionDurationValidator: ${ex}`,
+      ex,
+    ))
+  }
+
+  return errors
+}

package/src/transaction/validators/TransactionElevationValidator.ts

@@ -0,0 +1,27 @@
+import { ZERO_HASH } from '@xylabs/hex'
+import type {
+  HydratedTransaction, HydratedTransactionValidationFunction, TransactionBoundWitness,
+} from '@xyo-network/xl1-protocol'
+import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol'
+import { extractElevatedHashes } from '@xyo-network/xl1-protocol-sdk'
+
+export const TransactionElevationValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = (
+  tx: HydratedTransaction,
+) => {
+  const errors: HydratedTransactionValidationError[] = []
+  try {
+    try {
+      extractElevatedHashes(tx)
+    } catch {
+      errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, 'Hydrated transaction does not include all script hashes'))
+    }
+  } catch (ex) {
+    errors.push(new HydratedTransactionValidationError(
+      tx?.[0]?._hash ?? ZERO_HASH,
+      tx,
+      `Failed TransactionElevationValidator: ${ex}`,
+      ex,
+    ))
+  }
+  return errors
+}

package/src/transaction/validators/TransactionFromValidator.ts

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

package/src/transaction/validators/TransactionGasValidator.ts

@@ -0,0 +1,97 @@
+import { hexToBigInt, ZERO_HASH } from '@xylabs/hex'
+import type {
+  HydratedTransaction,
+  HydratedTransactionValidationFunction,
+  TransactionBoundWitness, TransactionFeesBigInt, TransactionFeesHex,
+} from '@xyo-network/xl1-protocol'
+import {
+  AttoXL1,
+  HydratedTransactionValidationError,
+  minTransactionFees,
+} from '@xyo-network/xl1-protocol'
+
+// eslint-disable-next-line complexity
+export const TransactionGasValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = (
+  tx: HydratedTransaction,
+) => {
+  const errors: HydratedTransactionValidationError[] = []
+  try {
+    if (tx?.[0].fees === undefined) {
+      errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH,
+        tx,
+        'Missing fees',
+      ))
+    } else {
+      const {
+        base, gasLimit, gasPrice, priority,
+      } = parseFees(tx[0].fees)
+
+      if (base === undefined) errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH,
+        tx,
+        'fees.base must be defined and a valid number',
+      ))
+      else if (base < minTransactionFees.base) errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH,
+        tx,
+        `fees.base must be >= ${minTransactionFees.base}`,
+      ))
+
+      if (gasLimit === undefined) errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH,
+        tx,
+        'fees.gasLimit must be defined and a valid number',
+      ))
+      else if (gasLimit < minTransactionFees.gasLimit) errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH,
+        tx,
+        `fees.gasLimit must be >= ${minTransactionFees.gasLimit}`,
+      ))
+
+      if (gasPrice === undefined) errors.push(
+        new HydratedTransactionValidationError(
+          tx?.[0]?._hash ?? ZERO_HASH,
+          tx,
+          'fees.gasPrice must be defined and a valid number',
+        ),
+      )
+      else if (gasPrice < minTransactionFees.gasPrice) errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH,
+        tx,
+        `fees.gasPrice must be >= ${minTransactionFees.gasPrice}`,
+      ))
+
+      if (priority === undefined) errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH,
+        tx,
+        'fees.priority must be defined and a valid number',
+      ))
+      else if (priority < minTransactionFees.priority) errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH,
+        tx,
+        `fees.priority must be >= ${minTransactionFees.priority}`,
+      ))
+    }
+  } catch (ex) {
+    errors.push(new HydratedTransactionValidationError(
+      tx?.[0]?._hash ?? ZERO_HASH,
+      tx,
+      `Failed TransactionGasValidator: ${ex}`,
+      ex,
+    ))
+  }
+  return errors
+}
+
+const parseFees = (fees: TransactionFeesHex): Partial<TransactionFeesBigInt> => {
+  const ret: Partial<TransactionFeesBigInt> = {}
+  const {
+    base, gasLimit, gasPrice, priority,
+  } = fees
+  if (base !== undefined) ret.base = AttoXL1(hexToBigInt(base))
+  if (gasLimit !== undefined) ret.gasLimit = AttoXL1(hexToBigInt(gasLimit))
+  if (gasPrice !== undefined) ret.gasPrice = AttoXL1(hexToBigInt(gasPrice))
+  if (priority !== undefined) ret.priority = AttoXL1(hexToBigInt(priority))
+  return ret
+}

package/src/transaction/validators/TransactionJsonSchemaValidator.ts

@@ -0,0 +1,34 @@
+import { ZERO_HASH } from '@xylabs/hex'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type {
+  HydratedTransaction, HydratedTransactionValidationFunction, TransactionBoundWitness,
+} from '@xyo-network/xl1-protocol'
+import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol'
+import { TransactionBoundWitnessJsonSchema } from '@xyo-network/xl1-schema'
+import type { ValidateFunction } from 'ajv'
+import { Ajv } from 'ajv'
+
+const ajv = new Ajv({ allErrors: true, strict: true })
+
+let validate: ValidateFunction<TransactionBoundWitness> | undefined
+
+export const TransactionJsonSchemaValidator: HydratedTransactionValidationFunction<TransactionBoundWitness> = (
+  tx: HydratedTransaction,
+) => {
+  const errors: HydratedTransactionValidationError[] = []
+  try {
+    if (validate === undefined) validate = ajv.compile(TransactionBoundWitnessJsonSchema)
+    if (!validate(PayloadBuilder.omitStorageMeta(tx[0]))) {
+      const error = new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH,
+        tx,
+        `failed JSON schema validation: ${ajv.errorsText(validate.errors, { separator: '\n' })}`,
+      )
+      error.cause = validate.errors
+      errors.push(error)
+    }
+  } catch (ex) {
+    errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, 'validation excepted', ex))
+  }
+  return errors
+}

package/src/transaction/validators/TransactionProtocolValidator.ts

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

package/src/transaction/validators/index.ts

@@ -0,0 +1,6 @@
+export * from './TransactionDurationValidator.ts'
+export * from './TransactionElevationValidator.ts'
+export * from './TransactionFromValidator.ts'
+export * from './TransactionGasValidator.ts'
+export * from './TransactionJsonSchemaValidator.ts'
+export * from './TransactionProtocolValidator.ts'

package/src/transaction/validators/spec/TransactionDurationValidator.spec.ts

@@ -0,0 +1,49 @@
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import { buildTransaction } from '@xyo-network/xl1-protocol-sdk'
+import {
+  beforeAll, describe, expect, it,
+} from 'vitest'
+
+import { TransactionDurationValidator } from '../TransactionDurationValidator.ts'
+
+describe('TransactionDurationValidator', () => {
+  const chain = 'a82920051db4fcbb804463440dd45e03f72442fd'
+  let signer: AccountInstance
+  beforeAll(async () => {
+    signer = await Account.random()
+  })
+  describe('with valid duration', () => {
+    it('should return no errors', async () => {
+      const hydratedTransaction = await buildTransaction(chain, [], [], signer, 0, 1000)
+      const errors = await TransactionDurationValidator(hydratedTransaction, chain)
+      expect(errors.length).toBe(0)
+    })
+  })
+  describe('with invalid', () => {
+    describe('nbf', () => {
+      it('should return error if nbf too low', async () => {
+        const hydratedTransaction = await buildTransaction(chain, [], [], signer, -1, 1000)
+        const errors = await TransactionDurationValidator(hydratedTransaction, chain)
+        expect(errors.length).toBeGreaterThan(0)
+      })
+    })
+    describe('exp', () => {
+      it('should return error if exp less than nbf', async () => {
+        const hydratedTransaction = await buildTransaction(chain, [], [], signer, 1, 0)
+        const errors = await TransactionDurationValidator(hydratedTransaction, chain)
+        expect(errors.length).toBeGreaterThan(0)
+      })
+      it('should return error if exp is equal to nbf', async () => {
+        const hydratedTransaction = await buildTransaction(chain, [], [], signer, 0, 0)
+        const errors = await TransactionDurationValidator(hydratedTransaction, chain)
+        expect(errors.length).toBeGreaterThan(0)
+      })
+      it('should return error if exp too high', async () => {
+        const hydratedTransaction = await buildTransaction(chain, [], [], signer, 0, Number.MAX_SAFE_INTEGER)
+        const errors = await TransactionDurationValidator(hydratedTransaction, chain)
+        expect(errors.length).toBeGreaterThan(0)
+      })
+    })
+  })
+})

package/src/transaction/validators/spec/TransactionElevationValidator.spec.ts

@@ -0,0 +1,39 @@
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import { buildRandomTransaction } from '@xyo-network/chain-protocol'
+import type { HydratedTransaction, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
+import { buildTransaction } from '@xyo-network/xl1-protocol-sdk'
+import {
+  beforeAll, describe, expect, it,
+} from 'vitest'
+
+import { TransactionElevationValidator } from '../TransactionElevationValidator.ts'
+
+describe('TransactionDurationValidator', () => {
+  const chain = 'a82920051db4fcbb804463440dd45e03f72442fd'
+  let signer: AccountInstance
+  beforeAll(async () => {
+    signer = await Account.random()
+  })
+  describe('should return no errors', () => {
+    it('if all script hash payloads are supplied', async () => {
+      const tx = await buildRandomTransaction(chain, [], signer)
+      const result = await TransactionElevationValidator(tx, chain)
+      expect(result.length).toBe(0)
+    })
+    it('when no payloads referenced in script hash', async () => {
+      const sample = await buildRandomTransaction(chain, [], signer)
+      const tx = await buildTransaction(chain, [], sample[1], signer, 1, 2)
+      const result = await TransactionElevationValidator(tx, chain)
+      expect(result.length).toBe(0)
+    })
+  })
+  describe('should return errors', () => {
+    it('if not all script hash payloads are supplied', async () => {
+      const [bw] = await buildRandomTransaction(chain, [], signer)
+      const tx = [bw, []] as HydratedTransaction<TransactionBoundWitness>
+      const result = await TransactionElevationValidator(tx, chain)
+      expect(result.length).toBe(1)
+    })
+  })
+})

package/src/transaction/validators/spec/TransactionFromValidator.spec.ts

@@ -0,0 +1,43 @@
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type { HydratedTransaction, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
+import { buildTransaction } from '@xyo-network/xl1-protocol-sdk'
+import {
+  beforeAll,
+  beforeEach,
+  describe, expect, it,
+} from 'vitest'
+
+import { TransactionFromValidator } from '../TransactionFromValidator.ts'
+
+describe('TransactionFromValidator', () => {
+  const chain = 'a82920051db4fcbb804463440dd45e03f72442fd'
+  let signer: AccountInstance
+  beforeAll(async () => {
+    signer = await Account.random()
+  })
+  describe('with from empty', () => {
+    let hydratedTransaction: HydratedTransaction
+    beforeEach(async () => {
+      const transaction = await buildTransaction(chain, [], [], signer, 0, Number.MAX_SAFE_INTEGER)
+      const { from, ...tx } = transaction[0]
+      hydratedTransaction = [tx as WithStorageMeta<TransactionBoundWitness>, transaction[1]]
+    })
+    it('should return error', async () => {
+      const errors = await TransactionFromValidator(hydratedTransaction, chain)
+      expect(errors.length).toBeGreaterThan(0)
+    })
+  })
+  describe('with from not in addresses', () => {
+    let hydratedTransaction: HydratedTransaction
+    beforeEach(async () => {
+      const from = await Account.random()
+      hydratedTransaction = await buildTransaction(chain, [], [], signer, 0, Number.MAX_SAFE_INTEGER, from.address)
+    })
+    it('should return error', async () => {
+      const errors = await TransactionFromValidator(hydratedTransaction, chain)
+      expect(errors.length).toBeGreaterThan(0)
+    })
+  })
+})

package/src/transaction/validators/spec/TransactionGasValidator.spec.ts

@@ -0,0 +1,88 @@
+import { type Address, hexFromBigInt } from '@xylabs/hex'
+import { Account } from '@xyo-network/account'
+import { buildRandomTransaction } from '@xyo-network/chain-protocol'
+import type {
+  HydratedTransaction, TransactionBoundWitness, TransactionFeesHex,
+} from '@xyo-network/xl1-protocol'
+import {
+  beforeAll, beforeEach, describe, expect, it,
+} from 'vitest'
+
+import { TransactionGasValidator } from '../TransactionGasValidator.ts'
+
+describe('TransactionGasValidator', () => {
+  let chainId: Address
+  let transaction: HydratedTransaction
+
+  beforeAll(async () => {
+    chainId = (await Account.random()).address
+  })
+
+  beforeEach(async () => {
+    transaction = await buildRandomTransaction(chainId)
+  })
+
+  describe('with valid transaction', () => {
+    it('should return no errors for valid fees', async () => {
+      const result = await TransactionGasValidator(transaction, chainId)
+      expect(result).toEqual([])
+    })
+  })
+
+  describe('with invalid transaction', () => {
+    describe('fees', () => {
+      it('should return an error if fees are missing', async () => {
+        delete (transaction[0] as Partial<TransactionBoundWitness>).fees
+        const result = await TransactionGasValidator(transaction, chainId)
+        expect(result[0].message).toEqual('Missing fees')
+      })
+    })
+
+    describe('base', () => {
+      it('should return an error if fees.base is undefined', async () => {
+        delete (transaction[0].fees as Partial<TransactionFeesHex>)?.base
+        const result = await TransactionGasValidator(transaction, chainId)
+        expect(result[0].message).toEqual('fees.base must be defined and a valid number')
+      })
+      it('should return an error if fees.base is less than or equal to 0', async () => {
+        transaction[0].fees.base = hexFromBigInt(0n)
+        const result = await TransactionGasValidator(transaction, chainId)
+        expect(result.length).toEqual(1)
+      })
+    })
+
+    describe('gasLimit', () => {
+      it('should return an error if fees.gasLimit is undefined', async () => {
+        delete (transaction[0].fees as Partial<TransactionFeesHex>)?.gasLimit
+        const result = await TransactionGasValidator(transaction, chainId)
+        expect(result[0].message).toEqual('fees.gasLimit must be defined and a valid number')
+      })
+      it('should return an error if fees.gasLimit is less than or equal to 0', async () => {
+        transaction[0].fees.gasLimit = hexFromBigInt(0n)
+        const result = await TransactionGasValidator(transaction, chainId)
+        expect(result.length).toEqual(1)
+      })
+    })
+  })
+
+  describe('gasPrice', () => {
+    it('should return an error if fees.gasPrice is undefined', async () => {
+      delete (transaction[0].fees as Partial<TransactionFeesHex>)?.gasPrice
+      const result = await TransactionGasValidator(transaction, chainId)
+      expect(result[0].message).toEqual('fees.gasPrice must be defined and a valid number')
+    })
+    it('should return an error if fees.gasPrice is less than or equal to 0', async () => {
+      transaction[0].fees.gasPrice = hexFromBigInt(0n)
+      const result = await TransactionGasValidator(transaction, chainId)
+      expect(result.length).toEqual(1)
+    })
+  })
+
+  describe('priority', () => {
+    it('should return an error if fees.priority is undefined', async () => {
+      delete (transaction[0].fees as Partial<TransactionFeesHex>)?.priority
+      const result = await TransactionGasValidator(transaction, chainId)
+      expect(result[0].message).toEqual('fees.priority must be defined and a valid number')
+    })
+  })
+})

package/src/transaction/validators/spec/TransactionJsonSchemaValidator.spec.ts

@@ -0,0 +1,33 @@
+import { buildRandomTransaction } from '@xyo-network/chain-protocol'
+import type { HydratedTransaction } from '@xyo-network/xl1-protocol'
+import {
+  beforeEach, describe, expect, it,
+} from 'vitest'
+
+import { TransactionJsonSchemaValidator } from '../TransactionJsonSchemaValidator.ts'
+
+describe('TransactionJsonSchemaValidator', () => {
+  const chain = 'a82920051db4fcbb804463440dd45e03f72442fd'
+
+  describe('with valid transaction', () => {
+    let hydratedTransaction: HydratedTransaction
+    beforeEach(async () => {
+      hydratedTransaction = await buildRandomTransaction(chain)
+    })
+    it('should return no errors', async () => {
+      const errors = await TransactionJsonSchemaValidator(hydratedTransaction, chain)
+      expect(errors).toEqual([])
+    })
+  })
+  describe('with invalid transaction', () => {
+    let hydratedTransaction: HydratedTransaction
+    beforeEach(async () => {
+      hydratedTransaction = await buildRandomTransaction(chain)
+      hydratedTransaction[0].chain = 'invalid'
+    })
+    it('should return error', async () => {
+      const errors = await TransactionJsonSchemaValidator(hydratedTransaction, chain)
+      expect(errors.length).toBeGreaterThan(0)
+    })
+  })
+})