@xyo-network/xl1-validation 1.26.11 → 1.26.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/xl1-validation",
-  "version": "1.26.11",
+  "version": "1.26.13",
   "description": "XYO Layer One SDK Validation",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -22,7 +22,6 @@
   "exports": {
     ".": {
       "types": "./dist/neutral/index.d.ts",
-      "source": "./src/index.ts",
       "default": "./dist/neutral/index.mjs"
     },
     "./package.json": "./package.json"
@@ -32,29 +31,47 @@
   "types": "./dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
-    "!**/*.test.*"
+    "!**/*.test.*",
+    "README.md"
   ],
   "dependencies": {
-    "@xyo-network/xl1-protocol-lib": "~1.26.11",
-    "@xyo-network/xl1-protocol-sdk": "~1.26.11",
-    "@xyo-network/xl1-schema": "~1.26.11"
+    "@xyo-network/xl1-protocol-lib": "~1.26.13",
+    "@xyo-network/xl1-protocol-sdk": "~1.26.13",
+    "@xyo-network/xl1-schema": "~1.26.13"
   },
   "devDependencies": {
+    "@firebase/app": "0.x",
+    "@firebase/app-compat": "0.x",
+    "@firebase/app-types": "0.x",
+    "@firebase/util": "1.x",
+    "@metamask/providers": "^22",
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.90",
-    "@xylabs/ts-scripts-common": "~7.5.6",
-    "@xylabs/ts-scripts-yarn3": "~7.5.6",
-    "@xylabs/tsconfig": "~7.5.6",
-    "@xyo-network/sdk-js": "^5.3.17",
+    "@xylabs/geo": "^5",
+    "@xylabs/sdk-js": "^5.0.91",
+    "@xylabs/ts-scripts-common": "~7.6.13",
+    "@xylabs/ts-scripts-yarn3": "~7.6.13",
+    "@xylabs/tsconfig": "~7.6.13",
+    "@xyo-network/sdk-js": "^5.3.22",
+    "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0",
     "ajv": "^8.18.0",
-    "axios": "^1.13.6",
+    "axios": "^1.14.0",
+    "cosmiconfig": ">=9",
+    "esbuild": ">=0.18",
+    "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0",
     "ethers": "^6.16.0",
+    "firebase": "^12",
+    "lru-cache": "^11",
+    "mapbox-gl": "^3",
+    "mongodb": "^6 || ^7",
+    "rollup": "^3.29.4 || ^4",
+    "tslib": "^2.8.1",
     "typescript": "~5.9.3",
+    "vite": "^8.0.3",
     "vitest": "~4.1.2",
+    "webextension-polyfill": "^0.10.0 || ^0.11.0 || ^0.12.0",
     "zod": "~4.3.6"
   },
   "peerDependencies": {
@@ -64,6 +81,8 @@
     "ajv": "^8",
     "axios": "^1",
     "ethers": "^6",
+    "mongodb": "^6 || ^7",
+    "typescript": ">=4.9.5",
     "zod": "^4"
   },
   "engines": {

package/src/block/index.ts

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

package/src/block/validators/BlockCumulativeBalanceValidator.ts

@@ -1,90 +0,0 @@
-import {
-  type Address, type Hex, hexToBigInt,
-} from '@xylabs/sdk-js'
-import type {
-  HydratedBlockStateValidationFunction,
-  HydratedBlockWithHashMeta,
-  TransactionBoundWitnessWithHashMeta,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  HydratedBlockStateValidationError,
-  isTransactionBoundWitnessWithHashMeta,
-  isTransfer,
-  XYO_ZERO_ADDRESS,
-} from '@xyo-network/xl1-protocol-lib'
-
-/** Compute the maximum fee commitment for a transaction (base + priority + gasLimit). */
-function maxTransactionFeeCost(tx: TransactionBoundWitnessWithHashMeta): bigint {
-  const {
-    base, gasLimit, priority,
-  } = tx.fees
-  return hexToBigInt(base) + hexToBigInt(priority) + hexToBigInt(gasLimit)
-}
-
-/** Accumulate outflows per address from fees and transfers in the given transactions. */
-export function accumulateOutflows(
-  transactions: TransactionBoundWitnessWithHashMeta[],
-  payloads: HydratedBlockWithHashMeta[1],
-): Record<Address, bigint> {
-  const outflows: Record<Address, bigint> = {}
-
-  for (const tx of transactions) {
-    // Fee cost charged to the transaction sender
-    const feeCost = maxTransactionFeeCost(tx)
-    const feePayer = tx.from
-    outflows[feePayer] = (outflows[feePayer] ?? 0n) + feeCost
-
-    // Find transfer payloads belonging to this transaction
-    const txPayloadHashes = new Set(tx.payload_hashes)
-    for (const payload of payloads) {
-      if (!txPayloadHashes.has(payload._hash) || !isTransfer(payload)) continue
-      const { from } = payload
-      for (const [to, amount] of Object.entries(payload.transfers) as [Address, Hex][]) {
-        if (to === from) continue // self-transfers are not outflows
-        outflows[from] = (outflows[from] ?? 0n) + hexToBigInt(amount)
-      }
-    }
-  }
-
-  return outflows
-}
-
-/** Creates a block state validator that checks cumulative outflows per address do not exceed pre-block balances. */
-export function BlockCumulativeBalanceValidatorFactory(): HydratedBlockStateValidationFunction {
-  return async (context, hydratedBlock) => {
-    const [blockBw, payloads] = hydratedBlock
-
-    // Find all transactions in the block
-    const transactions = payloads.filter(isTransactionBoundWitnessWithHashMeta)
-
-    if (transactions.length === 0) return []
-
-    const outflows = accumulateOutflows(transactions, payloads)
-
-    // Query pre-block balances for all addresses with outflows
-    const addresses = Object.keys(outflows) as Address[]
-    if (addresses.length === 0) return []
-
-    const balances = await context.accountBalance.accountBalances(addresses)
-
-    // Check each address
-    const chainId = await context.chainIdAtBlockNumber(blockBw.block)
-    const errors: HydratedBlockStateValidationError[] = []
-    for (const address of addresses) {
-      if (address === XYO_ZERO_ADDRESS) continue // Skip zero address as it's used for burn transactions and doesn't have a balance
-      // TODO: Add specific validation for block reward transfer
-      const balance = balances[address] ?? 0n
-      const totalOutflow = outflows[address]
-      if (totalOutflow > balance) {
-        errors.push(new HydratedBlockStateValidationError(
-          blockBw._hash,
-          chainId,
-          hydratedBlock,
-          `Cumulative outflow for address ${address} exceeds available balance: outflow ${totalOutflow} > balance ${balance}`,
-        ))
-      }
-    }
-
-    return errors
-  }
-}

package/src/block/validators/index.ts

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

package/src/boundwitness/index.ts

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

package/src/boundwitness/validators/BoundWitnessReferences.ts

@@ -1,58 +0,0 @@
-import type { Hash, Promisable } from '@xylabs/sdk-js'
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type {
-  BoundWitness,
-  Payload,
-  Schema,
-  WithHashMeta,
-} from '@xyo-network/sdk-js'
-import { isAnyPayload } from '@xyo-network/sdk-js'
-import type { HydratedBoundWitnessValidationFunction, HydratedBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-import { HydratedBoundWitnessValidationError } from '@xyo-network/xl1-protocol-lib'
-
-function getPayloadsFromPayloadArray(payloads: WithHashMeta<Payload>[], hashes: Hash[]): (WithHashMeta<Payload> | undefined)[] {
-  return hashes.map(hash => payloads.find(payload => payload._hash === hash || payload._dataHash === hash))
-}
-
-/** Creates a validator that checks all payload references in a BoundWitness are present, have matching schemas, and optionally conform to an allowed schema list. */
-export const BoundWitnessReferencesValidator
-
-  = <T extends BoundWitness = BoundWitness>(allowedSchemas?: Schema[]): HydratedBoundWitnessValidationFunction<T> => (
-    [bw, payloadSet]: HydratedBoundWitnessWithHashMeta<T>,
-  // eslint-disable-next-line complexity
-  ): Promisable<HydratedBoundWitnessValidationError[]> => {
-    const errors: HydratedBoundWitnessValidationError[] = []
-    try {
-      const payloads = getPayloadsFromPayloadArray(payloadSet, bw.payload_hashes)
-      if (payloads.length !== bw.payload_hashes.length) {
-        errors.push(new HydratedBoundWitnessValidationError(bw?._hash ?? ZERO_HASH, [bw, payloadSet], 'unable to locate payloads'))
-      }
-
-      // check if payloads are valid and if their schemas match the declared schemas
-      for (let payload of payloads) {
-        if (isAnyPayload(payload)) {
-          const payloadHashIndex = bw.payload_hashes.indexOf(payload._hash)
-          const payloadDataHashIndex = bw.payload_hashes.indexOf(payload._dataHash)
-          const payloadIndex = Math.max(payloadHashIndex, payloadDataHashIndex)
-          if (payloadIndex === -1) {
-            errors.push(new HydratedBoundWitnessValidationError(bw?._hash ?? ZERO_HASH, [bw, payloadSet], 'payload hash not found'))
-          }
-
-          const declaredSchema = bw.payload_schemas[payloadIndex]
-          if (declaredSchema !== payload.schema) {
-            errors.push(new HydratedBoundWitnessValidationError(bw?._hash ?? ZERO_HASH, [bw, payloadSet], 'mismatched schema'))
-          }
-
-          if (allowedSchemas && !allowedSchemas.includes(payload.schema)) {
-            errors.push(new HydratedBoundWitnessValidationError(bw?._hash ?? ZERO_HASH, [bw, payloadSet], `disallowed schema [${payload.schema}]`))
-          }
-        } else {
-          errors.push(new HydratedBoundWitnessValidationError(bw?._hash ?? ZERO_HASH, [bw, payloadSet], 'invalid payload'))
-        }
-      }
-    } catch (ex) {
-      const error = new HydratedBoundWitnessValidationError(bw?._hash ?? ZERO_HASH, [bw, payloadSet], `validation excepted: ${ex}`, ex)
-      errors.push(error)
-    }
-    return errors
-  }

package/src/boundwitness/validators/BoundWitnessSignatures.ts

@@ -1,31 +0,0 @@
-import { type Address, ZERO_HASH } from '@xylabs/sdk-js'
-import { toArrayBuffer } from '@xylabs/sdk-js'
-import type { BoundWitness, WithStorageMeta } from '@xyo-network/sdk-js'
-import { BoundWitnessBuilder, BoundWitnessValidator } from '@xyo-network/sdk-js'
-import type { BoundWitnessValidationFunction } from '@xyo-network/xl1-protocol-lib'
-import { BoundWitnessValidationError } from '@xyo-network/xl1-protocol-lib'
-
-/** Validates that all signatures on a BoundWitness are cryptographically valid for their corresponding addresses. */
-export const BoundWitnessSignaturesValidator: BoundWitnessValidationFunction = async (
-  bw: BoundWitness,
-) => {
-  const errors: BoundWitnessValidationError[] = []
-  try {
-    const dataHash = await BoundWitnessBuilder.dataHash(bw)
-    const results: [Address, Error[]][] = await Promise.all(bw.addresses.map(async (address, index) => {
-      return [address, await BoundWitnessValidator.validateSignature(
-        toArrayBuffer(dataHash),
-        toArrayBuffer(address),
-        toArrayBuffer(bw.$signatures[index] ?? undefined),
-      )]
-    }))
-    for (const [, bwErrors] of results) {
-      for (const bwError of bwErrors) {
-        errors.push(new BoundWitnessValidationError((bw as WithStorageMeta<BoundWitness>)?._hash ?? ZERO_HASH, bw, 'validation errors', bwError))
-      }
-    }
-  } catch (ex) {
-    errors.push(new BoundWitnessValidationError((bw as WithStorageMeta<BoundWitness>)?._hash ?? ZERO_HASH, bw, 'validation excepted', ex))
-  }
-  return errors
-}

package/src/boundwitness/validators/index.ts

@@ -1,2 +0,0 @@
-export * from './BoundWitnessReferences.ts'
-export * from './BoundWitnessSignatures.ts'

package/src/index.ts

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

package/src/transaction/index.ts

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

package/src/transaction/validateTransaction.ts

@@ -1,36 +0,0 @@
-import type {
-  HydratedTransactionValidationFunction,
-  HydratedTransactionValidationFunctionContext,
-  HydratedTransactionWithHashMeta,
-} from '@xyo-network/xl1-protocol-lib'
-import { isTransactionBoundWitness } from '@xyo-network/xl1-protocol-lib'
-
-import {
-  TransactionDurationValidator,
-  TransactionElevationValidator, TransactionFromValidator, TransactionGasValidator, TransactionProtocolValidator,
-} from './validators/index.ts'
-
-/** Validates a hydrated transaction using built-in validators plus any additional validators provided. */
-export async function validateTransaction(
-  context: HydratedTransactionValidationFunctionContext,
-  tx: HydratedTransactionWithHashMeta,
-  additionalValidators?: HydratedTransactionValidationFunction[],
-) {
-  try {
-    if (!isTransactionBoundWitness(tx[0])) {
-      return [new Error('failed isTransactionBoundWitness identity check')]
-    }
-
-    const validators: HydratedTransactionValidationFunction<HydratedTransactionValidationFunctionContext>[] = [
-      TransactionProtocolValidator,
-      TransactionDurationValidator,
-      TransactionFromValidator,
-      TransactionGasValidator,
-      TransactionElevationValidator,
-      ...(additionalValidators ?? []),
-    ]
-    return (await Promise.all(validators.map(v => v(context, tx)))).flat()
-  } catch (ex) {
-    return [(new Error(`Failed TransactionGasValidator: ${ex}`))]
-  }
-}

package/src/transaction/validators/TransactionDurationValidator.ts

@@ -1,33 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type { HydratedTransactionValidationFunction } from '@xyo-network/xl1-protocol-lib'
-import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol-lib'
-
-/** Validates that transaction timing fields (nbf and exp) are positive, correctly ordered, and within allowed duration limits. */
-export const TransactionDurationValidator: HydratedTransactionValidationFunction = (
-  context,
-  tx,
-// eslint-disable-next-line complexity
-) => {
-  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

@@ -1,27 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type { HydratedTransactionValidationFunction } from '@xyo-network/xl1-protocol-lib'
-import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol-lib'
-import { extractElevatedHashes } from '@xyo-network/xl1-protocol-sdk'
-
-/** Validates that a hydrated transaction includes all required elevated script hashes. */
-export const TransactionElevationValidator: HydratedTransactionValidationFunction = (
-  context,
-  tx,
-) => {
-  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

@@ -1,33 +0,0 @@
-import { asAddress, ZERO_HASH } from '@xylabs/sdk-js'
-import { addressesContains } from '@xyo-network/sdk-js'
-import type { HydratedTransactionValidationFunction } from '@xyo-network/xl1-protocol-lib'
-import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol-lib'
-
-/** Validates that the transaction's from field is a valid address and is included in the BoundWitness addresses. */
-export const TransactionFromValidator: HydratedTransactionValidationFunction = (
-  context,
-  tx,
-) => {
-  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

@@ -1,98 +0,0 @@
-import { hexToBigInt, ZERO_HASH } from '@xylabs/sdk-js'
-import type {
-  HydratedTransactionValidationFunction,
-  TransactionFeesBigInt, TransactionFeesHex,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  AttoXL1,
-  HydratedTransactionValidationError,
-  minTransactionFees,
-} from '@xyo-network/xl1-protocol-lib'
-
-/** Validates that transaction fee fields (base, gasLimit, gasPrice, priority) are present and meet minimum requirements. */
-export const TransactionGasValidator: HydratedTransactionValidationFunction = (
-  context,
-  tx,
-// eslint-disable-next-line complexity
-) => {
-  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

@@ -1,34 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { HydratedTransactionValidationFunction, TransactionBoundWitness } from '@xyo-network/xl1-protocol-lib'
-import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol-lib'
-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
-
-/** Validates a transaction against the TransactionBoundWitness JSON schema using AJV. */
-export const TransactionJsonSchemaValidator: HydratedTransactionValidationFunction = (
-  context,
-  tx,
-) => {
-  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' })}`,
-        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

@@ -1,22 +0,0 @@
-import { ZERO_HASH } from '@xylabs/sdk-js'
-import type {
-  ChainId,
-  HydratedTransactionValidationFunction,
-} from '@xyo-network/xl1-protocol-lib'
-import { HydratedTransactionValidationError } from '@xyo-network/xl1-protocol-lib'
-
-/** Validates that the transaction's chain ID matches the expected chain ID from the validation context. */
-export const TransactionProtocolValidator: HydratedTransactionValidationFunction = async (
-  context: { chainId?: ChainId },
-  tx,
-) => {
-  const errors: HydratedTransactionValidationError[] = []
-  try {
-    if (context?.chainId !== undefined && tx[0].chain !== context.chainId) {
-      errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, `invalid chain id [${context.chainId}, ${tx[0].chain}]`))
-    }
-  } catch (ex) {
-    errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH, tx, 'validation excepted', ex))
-  }
-  return await Promise.resolve(errors)
-}

package/src/transaction/validators/TransactionTransfersValidator.ts

@@ -1,81 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { isDefined, isUndefined } from '@xylabs/sdk-js'
-import type {
-  HydratedTransactionValidationFunction, StepIdentity,
-  Transfer,
-} from '@xyo-network/xl1-protocol-lib'
-import { HydratedTransactionValidationError, isTransfer } from '@xyo-network/xl1-protocol-lib'
-import {
-  completedStepRewardAddress, derivedReceiveAddress, elevatedPayloads,
-} from '@xyo-network/xl1-protocol-sdk'
-
-/** Function type that checks whether a signer is authorized to sign for a given signee address. */
-export type SignerValidator = (signer: Address, signee: Address, context?: { address?: Address; scope?: string; step?: StepIdentity }) => boolean
-
-/** Maps addresses to their list of authorized signer addresses. */
-export type SignerMapping = Map<Address, Address[]>
-
-/** A signer validator that only allows an address to sign for itself. */
-export const SelfSignerValidator: SignerValidator = (signer: Address, signee: Address) => signer === signee
-
-/** Creates a signer validator that authorizes specified signers to sign for completed step reward addresses. */
-export const CompletedStepRewardAddressValidatorFactory = (allowedSigners: Address[]): SignerValidator => (
-  signer: Address,
-  signee: Address,
-  context?: { step?: StepIdentity },
-) => {
-  const step = context?.step
-  if (isDefined(step)) {
-    const contextAddress = completedStepRewardAddress(step)
-    return allowedSigners.includes(signer) && signee === contextAddress
-  } else {
-    return false
-  }
-}
-
-/** Creates a signer validator that authorizes specified signers to sign for derived receive addresses within a given scope. */
-export const DerivedReceiveAddressValidatorFactory = (allowedSigners: Address[], allowedScope: string): SignerValidator => (
-  signer: Address,
-  signee: Address,
-  context?: { address?: Address; scope?: string },
-) => {
-  const { address, scope } = context ?? {}
-  if (scope !== allowedScope) {
-    return false
-  }
-  if (isDefined(address)) {
-    const derivedAddress = derivedReceiveAddress(address, scope)
-    return allowedSigners.includes(signer) && signee === derivedAddress
-  } else {
-    return false
-  }
-}
-
-/** Creates a transaction validator that checks all transfers are authorized by the transaction signer. */
-export function TransactionTransfersValidatorFactory(
-  signerValidators: SignerValidator[] = [SelfSignerValidator],
-): HydratedTransactionValidationFunction {
-  return async (
-    context,
-    hydratedTx,
-  ) => {
-    const errors: HydratedTransactionValidationError[] = []
-    const signer = hydratedTx[0].from
-    try {
-      const payloads = elevatedPayloads(hydratedTx)
-      const transfers = payloads.filter(isTransfer) as Transfer[]
-      for (const transfer of transfers) {
-        if (isUndefined(signerValidators.find(v => v(signer, transfer.from, transfer.context)))) {
-          errors.push(new HydratedTransactionValidationError(
-            hydratedTx[0]._hash,
-            hydratedTx,
-            `transfer from address ${transfer.from} is not authorized by signer ${signer}`,
-          ))
-        }
-      }
-    } catch (ex) {
-      errors.push(new HydratedTransactionValidationError(hydratedTx[0]._hash, hydratedTx, 'validation excepted', ex))
-    }
-    return await Promise.resolve(errors)
-  }
-}

package/src/transaction/validators/index.ts

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