@xyo-network/chain-sdk 4.0.4 → 4.0.6

package/dist/neutral/validation.mjs

@@ -0,0 +1,863 @@
+// src/modules/validation/block/validateBlock.ts
+import { ZERO_HASH as ZERO_HASH6 } from "@ariestools/sdk";
+import { BlockValidationError as BlockValidationError6 } from "@xyo-network/xl1-sdk";
+
+// src/modules/validation/block/validators/AllowedPayloadSchemas.ts
+import { ZERO_HASH } from "@ariestools/sdk";
+import {
+  BlockValidationError,
+  isAllowedBlockPayloadSchema
+} from "@xyo-network/xl1-sdk";
+var BlockAllowedPayloadSchemasValidator = (context, block) => {
+  const errors = [];
+  try {
+    for (const schema of block.payload_schemas) {
+      if (!isAllowedBlockPayloadSchema(schema)) {
+        errors.push(new BlockValidationError(
+          block?._hash ?? ZERO_HASH,
+          block,
+          `payload schema not allowed in block: ${String(schema)}`
+        ));
+      }
+    }
+  } catch (ex) {
+    errors.push(new BlockValidationError(
+      block?._hash ?? ZERO_HASH,
+      block,
+      `validation excepted: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/block/validators/BoundWitness.ts
+import { ZERO_HASH as ZERO_HASH2 } from "@ariestools/sdk";
+import { BoundWitnessValidator } from "@xyo-network/sdk";
+import { BlockValidationError as BlockValidationError2 } from "@xyo-network/xl1-sdk";
+var error = (block, message) => new BlockValidationError2(block?._hash ?? ZERO_HASH2, block, message);
+var checkSignaturesShape = (block) => {
+  const bw = block;
+  if (bw.$signatures === void 0) {
+    return Array.isArray(bw.signatures) ? [error(block, "BoundWitness has `signatures` but expected `$signatures` (signatures must be in the meta-prefixed `$signatures` key)")] : [error(block, "BoundWitness is missing `$signatures`")];
+  }
+  return [];
+};
+var BlockBoundWitnessValidator = async (_context, block) => {
+  try {
+    const shapeErrors = checkSignaturesShape(block);
+    if (shapeErrors.length > 0) return shapeErrors;
+    const bwValidator = new BoundWitnessValidator(block);
+    const bwErrors = await bwValidator.validate();
+    return bwErrors.map((e) => error(block, `BoundWitness validation: ${e.message}`));
+  } catch (ex) {
+    return [error(block, `Failed BlockBoundWitnessValidator: ${String(ex)}`)];
+  }
+};
+
+// src/modules/validation/block/validators/Fields.ts
+import { isDefined, ZERO_HASH as ZERO_HASH3 } from "@ariestools/sdk";
+import { BoundWitnessSchema } from "@xyo-network/sdk";
+import { BlockValidationError as BlockValidationError3 } from "@xyo-network/xl1-sdk";
+var BlockFieldsValidator = (context, block, chainId) => {
+  const errors = [];
+  try {
+    if (isDefined(chainId) && block.chain !== chainId.toLowerCase()) {
+      errors.push(new BlockValidationError3(block?._hash ?? ZERO_HASH3, block, "Invalid chain id"));
+    }
+    const txHashes = [];
+    for (let i = 0; i < block.payload_hashes.length; i++) {
+      if (block.payload_schemas[i] === BoundWitnessSchema) {
+        txHashes.push(block.payload_hashes[i]);
+      }
+    }
+    const uniqueTxHashes = new Set(txHashes);
+    if (uniqueTxHashes.size < txHashes.length) {
+      errors.push(new BlockValidationError3(
+        block?._hash ?? ZERO_HASH3,
+        block,
+        `Duplicate Transaction Hashes: ${txHashes.join(", ")}`
+      ));
+    }
+  } catch (ex) {
+    errors.push(new BlockValidationError3(
+      block?._hash ?? ZERO_HASH3,
+      block,
+      `validation excepted: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/block/validators/JsonSchema.ts
+import { ZERO_HASH as ZERO_HASH4 } from "@ariestools/sdk";
+import { BlockBoundWitnessWithStorageMetaJsonSchema, BlockValidationError as BlockValidationError4 } from "@xyo-network/xl1-sdk";
+import { Ajv } from "ajv";
+var BlockJsonSchemaValidator = (jsonSchema = BlockBoundWitnessWithStorageMetaJsonSchema) => {
+  const ajv = new Ajv({ allErrors: true, strict: true });
+  const validate = ajv.compile(jsonSchema);
+  return async (context, block) => {
+    const errors = [];
+    try {
+      await validate(block);
+      if ((validate.errors ?? []).length > 0) {
+        const error2 = new BlockValidationError4(
+          block?._hash ?? ZERO_HASH4,
+          block,
+          `failed JSON schema validation: ${ajv.errorsText(validate.errors, { separator: "\n" })}`
+        );
+        error2.cause = validate.errors;
+        errors.push(error2);
+      }
+    } catch (ex) {
+      const error2 = new BlockValidationError4(
+        block?._hash ?? ZERO_HASH4,
+        block,
+        `validation excepted: ${String(ex)}`
+      );
+      error2.cause = ex;
+      errors.push(error2);
+    }
+    return errors;
+  };
+};
+
+// src/modules/validation/block/validators/PreviousHash.ts
+import { isHash, ZERO_HASH as ZERO_HASH5 } from "@ariestools/sdk";
+import { BlockValidationError as BlockValidationError5 } from "@xyo-network/xl1-sdk";
+var BlockPreviousHashValidator = (context, block) => {
+  const errors = [];
+  try {
+    const blockNumber = block.block;
+    if (blockNumber > 0n) {
+      if (!isHash(block.previous)) {
+        errors.push(new BlockValidationError5(block?._hash ?? ZERO_HASH5, block, "previous hash is missing or invalid"));
+      }
+    } else if (blockNumber === 0) {
+      if (block.previous !== null) {
+        errors.push(new BlockValidationError5(block?._hash ?? ZERO_HASH5, block, "previous hash should not be set"));
+      }
+    } else {
+      errors.push(new BlockValidationError5(block?._hash ?? ZERO_HASH5, block, "invalid block number"));
+    }
+  } catch (ex) {
+    const error2 = new BlockValidationError5(
+      block?._hash ?? ZERO_HASH5,
+      block,
+      `Failed BlockPreviousHashValidator: ${String(ex)}`
+    );
+    error2.cause = ex;
+    errors.push(error2);
+  }
+  return errors;
+};
+
+// src/modules/validation/block/validateBlock.ts
+var validateBlock = async (context, block, chainId, additionalValidators = []) => {
+  const errors = [];
+  try {
+    const validators = [
+      BlockBoundWitnessValidator,
+      BlockFieldsValidator,
+      BlockPreviousHashValidator,
+      BlockAllowedPayloadSchemasValidator,
+      ...additionalValidators
+    ];
+    for (const validator of validators) {
+      errors.push(...await Promise.resolve(validator(context, block, chainId)));
+    }
+  } catch (ex) {
+    errors.push(new BlockValidationError6(block?._hash ?? ZERO_HASH6, block, "validation excepted", ex));
+  }
+  return errors;
+};
+
+// src/modules/validation/hydratedBlock/validateHydratedBlock.ts
+import { ZERO_HASH as ZERO_HASH19 } from "@ariestools/sdk";
+import { BoundWitnessReferencesValidator, HydratedBlockValidationError as HydratedBlockValidationError3 } from "@xyo-network/xl1-sdk";
+
+// src/modules/validation/hydratedBlock/validators/Payloads.ts
+import { ZERO_HASH as ZERO_HASH17 } from "@ariestools/sdk";
+import { HydratedBlockValidationError } from "@xyo-network/xl1-sdk";
+
+// src/modules/validation/elevatedPayload/validatePayloadInBlock.ts
+import { ZERO_HASH as ZERO_HASH16 } from "@ariestools/sdk";
+import { BoundWitnessSchema as BoundWitnessSchema2, SchemaSchema } from "@xyo-network/sdk";
+import {
+  BridgeDestinationObservationSchema,
+  BridgeIntentSchema,
+  BridgeSourceObservationSchema,
+  ChainStakeIntentSchema,
+  HashSchema,
+  InBlockPayloadValidationError as InBlockPayloadValidationError12,
+  TimeSchema,
+  TransferSchema
+} from "@xyo-network/xl1-sdk";
+
+// src/modules/validation/elevatedPayload/lib/isElevatedFromBlock.ts
+import { isTransactionBoundWitness } from "@xyo-network/xl1-sdk";
+var isElevatedFromBlock = (payload, [, payloads]) => {
+  const txs = payloads.filter((p) => isTransactionBoundWitness(p));
+  for (const tx of txs) {
+    if (tx.payload_hashes.includes(payload._hash)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// src/modules/validation/elevatedPayload/lib/validateElevatedFromBlock.ts
+import { InBlockPayloadValidationError, transactionsFromHydratedBlock } from "@xyo-network/xl1-sdk";
+var validateElevatedFromBlock = (context, payload, block) => {
+  const errors = [];
+  try {
+    const txs = transactionsFromHydratedBlock(block);
+    const allTxPayloadHashes = new Set(txs.flatMap((tx) => tx.payload_hashes));
+    if (allTxPayloadHashes.has(payload._hash)) {
+      errors.push(new InBlockPayloadValidationError(
+        block[0]?._hash,
+        block,
+        payload,
+        `Transaction may not include block payload hash [${payload.schema}]: ${payload._hash}`
+      ));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError(block[0]?._hash, block, payload, `validation excepted: ${String(ex)}`, ex));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/lib/validateElevatedFromTransaction.ts
+import { InBlockPayloadValidationError as InBlockPayloadValidationError2, transactionsFromHydratedBlock as transactionsFromHydratedBlock2 } from "@xyo-network/xl1-sdk";
+var validateElevatedFromTransaction = (context, payload, block) => {
+  const errors = [];
+  try {
+    const txs = transactionsFromHydratedBlock2(block);
+    if (txs.length > 0) {
+      const hashes = txs.flatMap((tx) => tx.payload_hashes);
+      if (!hashes.includes(payload._hash)) {
+        errors.push(new InBlockPayloadValidationError2(payload._hash, block, payload, "Transaction does not include payload"));
+      }
+    } else {
+      errors.push(new InBlockPayloadValidationError2(payload._hash, block, payload, "No Transactions in block"));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError2(
+      payload._hash,
+      block,
+      payload,
+      `Failed validateElevatedFromTransaction: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/lib/validateTransactionInBlock.ts
+import { ZERO_HASH as ZERO_HASH7 } from "@ariestools/sdk";
+import { isHashMeta } from "@xyo-network/sdk";
+import {
+  BoundWitnessSignaturesValidator,
+  InBlockPayloadValidationError as InBlockPayloadValidationError3,
+  isTransactionBoundWitness as isTransactionBoundWitness2,
+  validateTransaction
+} from "@xyo-network/xl1-sdk";
+var validateTransactionInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    if (isTransactionBoundWitness2(payload) && isHashMeta(payload)) {
+      const txErrors = await validateTransaction({ ...context, chainId: block[0].chain }, [payload, block[1]]);
+      for (const txError of txErrors) {
+        errors.push(new InBlockPayloadValidationError3(
+          payload._hash,
+          block,
+          payload,
+          `TransactionValidation error: ${txError}`,
+          txError
+        ));
+      }
+      const txSignatureErrors = await BoundWitnessSignaturesValidator(payload);
+      for (const txSignatureError of txSignatureErrors) {
+        errors.push(new InBlockPayloadValidationError3(
+          payload._hash,
+          block,
+          payload,
+          `BoundWitnessSignaturesValidator error: ${txSignatureError}`,
+          txSignatureError
+        ));
+      }
+    } else {
+      errors.push(new InBlockPayloadValidationError3(payload._hash, block, payload, "Payload failed isTransactionBoundWitness or isHashMeta"));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError3(payload._hash ?? ZERO_HASH7, block, payload, `validation excepted: ${String(ex)}`, ex));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/lib/validateTypedPayloadInBlock.ts
+import { isHashMeta as isHashMeta2 } from "@xyo-network/sdk";
+var validateTypedPayloadInBlock = async (context, payload, block, identityFunction) => {
+  const errors = [];
+  try {
+    if (identityFunction(payload) && isHashMeta2(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: ${String(ex)}`));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/payloads/validateBridgeDestinationObservationInBlock.ts
+import { ZERO_HASH as ZERO_HASH8 } from "@ariestools/sdk";
+import { InBlockPayloadValidationError as InBlockPayloadValidationError4, isBridgeDestinationObservation } from "@xyo-network/xl1-sdk";
+var validateBridgeDestinationObservationInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isBridgeDestinationObservation);
+    for (const typedError of typedErrors) {
+      errors.push(new InBlockPayloadValidationError4(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError4(
+      block?.[0]?._hash ?? ZERO_HASH8,
+      block,
+      payload,
+      `Failed validateBridgeObservationInBlock: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/payloads/validateBridgeIntentInBlock.ts
+import { ZERO_HASH as ZERO_HASH9 } from "@ariestools/sdk";
+import { InBlockPayloadValidationError as InBlockPayloadValidationError5, isBridgeIntent } from "@xyo-network/xl1-sdk";
+var validateBridgeIntentInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isBridgeIntent);
+    for (const typedError of typedErrors) {
+      errors.push(new InBlockPayloadValidationError5(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError5(
+      block?.[0]?._hash ?? ZERO_HASH9,
+      block,
+      payload,
+      `Failed validateBridgeIntentInBlock: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/payloads/validateBridgeSourceObservationInBlock.ts
+import { ZERO_HASH as ZERO_HASH10 } from "@ariestools/sdk";
+import { InBlockPayloadValidationError as InBlockPayloadValidationError6, isBridgeSourceObservation } from "@xyo-network/xl1-sdk";
+var validateBridgeSourceObservationInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isBridgeSourceObservation);
+    for (const typedError of typedErrors) {
+      errors.push(new InBlockPayloadValidationError6(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError6(
+      block?.[0]?._hash ?? ZERO_HASH10,
+      block,
+      payload,
+      `Failed validateBridgeObservationInBlock: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/payloads/validateChainStakeIntentInBlock.ts
+import { ZERO_HASH as ZERO_HASH11 } from "@ariestools/sdk";
+import { InBlockPayloadValidationError as InBlockPayloadValidationError7, isChainStakeIntent } from "@xyo-network/xl1-sdk";
+var validateChainStakeIntentInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isChainStakeIntent);
+    for (const typedError of typedErrors) {
+      errors.push(new InBlockPayloadValidationError7(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError7(
+      block[0]?._hash ?? ZERO_HASH11,
+      block,
+      payload,
+      `validation excepted: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/payloads/validateHashInBlock.ts
+import { ZERO_HASH as ZERO_HASH12 } from "@ariestools/sdk";
+import { InBlockPayloadValidationError as InBlockPayloadValidationError8, isHashPayload } from "@xyo-network/xl1-sdk";
+var validateHashInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isHashPayload);
+    for (const typedError of typedErrors) {
+      errors.push(new InBlockPayloadValidationError8(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError8(
+      block?.[0]?._hash ?? ZERO_HASH12,
+      block,
+      payload,
+      `validation excepted: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/payloads/validateSchemaInBlock.ts
+import { ZERO_HASH as ZERO_HASH13 } from "@ariestools/sdk";
+import { isSchemaPayload } from "@xyo-network/sdk";
+import { InBlockPayloadValidationError as InBlockPayloadValidationError9 } from "@xyo-network/xl1-sdk";
+var validateSchemaInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isSchemaPayload);
+    for (const typedError of typedErrors) {
+      errors.push(new InBlockPayloadValidationError9(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError9(
+      block?.[0]?._hash ?? ZERO_HASH13,
+      block,
+      payload,
+      `Failed validateSchemaInBlock: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/payloads/validateTimeInBlock.ts
+import { ZERO_HASH as ZERO_HASH14 } from "@ariestools/sdk";
+import { InBlockPayloadValidationError as InBlockPayloadValidationError10, isTimePayload } from "@xyo-network/xl1-sdk";
+var validateTimeInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isTimePayload);
+    for (const typedError of typedErrors) {
+      errors.push(new InBlockPayloadValidationError10(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError10(
+      block?.[0]?._hash ?? ZERO_HASH14,
+      block,
+      payload,
+      `Failed validateTimeInBlock: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/payloads/validateTransferInBlock.ts
+import { ZERO_HASH as ZERO_HASH15 } from "@ariestools/sdk";
+import { InBlockPayloadValidationError as InBlockPayloadValidationError11, isTransfer } from "@xyo-network/xl1-sdk";
+var validateTransferInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isTransfer);
+    for (const typedError of typedErrors) {
+      errors.push(new InBlockPayloadValidationError11(payload._hash, block, payload, `validateTypedPayloadInBlock error: ${typedError}`, typedError));
+    }
+  } catch (ex) {
+    errors.push(new InBlockPayloadValidationError11(
+      block?.[0]?._hash ?? ZERO_HASH15,
+      block,
+      payload,
+      `Failed validateTransferInBlock: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/elevatedPayload/validatePayloadInBlock.ts
+var payloadValidators = {
+  [BoundWitnessSchema2]: validateTransactionInBlock,
+  [BridgeDestinationObservationSchema]: validateBridgeDestinationObservationInBlock,
+  [BridgeIntentSchema]: validateBridgeIntentInBlock,
+  [BridgeSourceObservationSchema]: validateBridgeSourceObservationInBlock,
+  [ChainStakeIntentSchema]: validateChainStakeIntentInBlock,
+  [HashSchema]: validateHashInBlock,
+  [SchemaSchema]: validateSchemaInBlock,
+  [TimeSchema]: validateTimeInBlock,
+  [TransferSchema]: validateTransferInBlock
+};
+var validatePayloadInBlock = async (context, payload, block) => {
+  const errors = [];
+  try {
+    const validator = payloadValidators[payload.schema];
+    if (validator) {
+      errors.push(...await validator(context, payload, block));
+    } else {
+      errors.push(new InBlockPayloadValidationError12(block?.[0]?._hash ?? ZERO_HASH16, block, payload, `Unsupported payload schema: ${payload.schema}`));
+    }
+  } catch (ex) {
+    const error2 = new InBlockPayloadValidationError12(
+      block?.[0]?._hash ?? ZERO_HASH16,
+      block,
+      payload,
+      `validation excepted: ${String(ex)}`,
+      ex
+    );
+    errors.push(error2);
+  }
+  return errors;
+};
+
+// src/modules/validation/hydratedBlock/validators/Payloads.ts
+var PayloadsInBlockValidator = async (context, [block, payloads]) => {
+  const errors = [];
+  try {
+    const payloadMap = {};
+    for (const payload of payloads) {
+      const propertyKey = String(payload._hash);
+      payloadMap[propertyKey] = payload;
+    }
+    const remainingPayloads = { ...payloadMap };
+    for (let i = 0; i < block.payload_hashes.length; i++) {
+      const propertyKey = String(block.payload_hashes[i]);
+      const schema = block.payload_schemas[i];
+      const payload = payloadMap[propertyKey];
+      if (payload) {
+        const payloadInBlockErrors = await validatePayloadInBlock(context, payload, [block, payloads]);
+        for (const payloadInBlockError of payloadInBlockErrors) {
+          errors.push(new HydratedBlockValidationError(
+            block?._hash ?? ZERO_HASH17,
+            [block, payloads],
+            `validatePayloadInBlock error: ${payloadInBlockError}`,
+            payloadInBlockError
+          ));
+        }
+        delete remainingPayloads[propertyKey];
+      } else {
+        errors.push(new HydratedBlockValidationError(block?._hash ?? ZERO_HASH17, [block, payloads], `missing payload ${propertyKey} ${schema}`));
+      }
+    }
+    if (Object.keys(remainingPayloads).length > 0) {
+      errors.push(new HydratedBlockValidationError(block?._hash ?? ZERO_HASH17, [block, payloads], `extra payloads ${Object.keys(payloadMap).join(", ")}`));
+    }
+  } catch (ex) {
+    errors.push(new HydratedBlockValidationError(
+      block?._hash ?? ZERO_HASH17,
+      [block, payloads],
+      `Failed PayloadsInBlockValidator: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/hydratedBlock/validators/TransactionTransfersInBlock.ts
+import { ZERO_HASH as ZERO_HASH18 } from "@ariestools/sdk";
+import { isHashMeta as isHashMeta3 } from "@xyo-network/sdk";
+import { HydratedBlockValidationError as HydratedBlockValidationError2, isTransactionBoundWitness as isTransactionBoundWitness3 } from "@xyo-network/xl1-sdk";
+function TransactionTransfersInBlockValidatorFactory(transfersValidator) {
+  return async (context, hydratedBlock) => {
+    const [block, payloads] = hydratedBlock;
+    const errors = [];
+    try {
+      for (const payload of payloads) {
+        if (isTransactionBoundWitness3(payload) && isHashMeta3(payload)) {
+          const txErrors = await transfersValidator({ ...context, chainId: block.chain }, [payload, payloads]);
+          for (const txError of txErrors) {
+            errors.push(new HydratedBlockValidationError2(payload._hash, hydratedBlock, `transfer authorization error: ${txError}`, txError));
+          }
+        }
+      }
+    } catch (ex) {
+      errors.push(new HydratedBlockValidationError2(
+        block?._hash ?? ZERO_HASH18,
+        hydratedBlock,
+        `Failed TransactionTransfersInBlockValidator: ${String(ex)}`,
+        ex
+      ));
+    }
+    return errors;
+  };
+}
+
+// src/modules/validation/hydratedBlock/validateHydratedBlock.ts
+var validateHydratedBlock = async (context, hydratedBlock, chainIdAtBlockNumber, additionalValidators = [], additionalBlockValidators = []) => {
+  const errors = [];
+  try {
+    const validateBlockErrors = await validateBlock(
+      context,
+      hydratedBlock[0],
+      chainIdAtBlockNumber ? await chainIdAtBlockNumber(hydratedBlock[0].block) : void 0,
+      additionalBlockValidators
+    );
+    for (const validateBlockError of validateBlockErrors) {
+      errors.push(new HydratedBlockValidationError3(hydratedBlock[0]._hash, hydratedBlock, `validateBlock error: ${validateBlockError}`, validateBlockError));
+    }
+    const bwRefErrors = await BoundWitnessReferencesValidator()(hydratedBlock);
+    for (const bwRefError of bwRefErrors) {
+      errors.push(new HydratedBlockValidationError3(hydratedBlock[0]._hash, hydratedBlock, `boundwitness reference error: ${bwRefError}`, bwRefError));
+    }
+    const validators = [
+      PayloadsInBlockValidator,
+      ...additionalValidators
+    ];
+    for (const validator of validators) {
+      errors.push(...await Promise.resolve(validator(context, hydratedBlock, chainIdAtBlockNumber)));
+    }
+  } catch (ex) {
+    errors.push(new HydratedBlockValidationError3(
+      hydratedBlock?.[0]?._hash ?? ZERO_HASH19,
+      hydratedBlock,
+      `Failed validateHydratedBlock: ${String(ex)}`,
+      ex
+    ));
+  }
+  return errors;
+};
+
+// src/modules/validation/hydratedBlockState/validateHydratedBlockState.ts
+import { spanRootAsync as spanRootAsync2, ZERO_HASH as ZERO_HASH21 } from "@ariestools/sdk";
+import { HydratedBlockStateValidationError as HydratedBlockStateValidationError2 } from "@xyo-network/xl1-sdk";
+
+// src/modules/validation/hydratedBlockState/validators/RequiredBalance.ts
+import { spanRootAsync, ZERO_HASH as ZERO_HASH20 } from "@ariestools/sdk";
+import {
+  AttoXL1,
+  HydratedBlockStateValidationError,
+  isSignedTransactionBoundWitnessWithHashMeta,
+  netBalancesForPayloads,
+  XYO_ZERO_ADDRESS
+} from "@xyo-network/xl1-sdk";
+function offendingTransactionHashesForAddress(block, address) {
+  const hashes = [];
+  for (const payload of block[1]) {
+    if (isSignedTransactionBoundWitnessWithHashMeta(payload) && payload.from === address) {
+      hashes.push(payload._hash);
+    }
+  }
+  return hashes;
+}
+var RequiredBalanceBlockStateValidator = async (context, block) => {
+  return await spanRootAsync("RequiredBalanceBlockStateValidator", async () => {
+    const errors = [];
+    let chainId = "00";
+    try {
+      const netBalances = netBalancesForPayloads({ singletons: {} }, block[1]);
+      const netBalanceAddresses = Object.keys(netBalances);
+      const requiredBalances = {};
+      for (const address of netBalanceAddresses) {
+        const propertyKey = String(address);
+        const netBalance = netBalances[propertyKey];
+        if (netBalance < 0n) {
+          requiredBalances[propertyKey] = -netBalance;
+        }
+      }
+      const previous = block[0].previous;
+      if (previous === null) return [new HydratedBlockStateValidationError(
+        block?.[0]?._hash ?? ZERO_HASH20,
+        "00",
+        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)) {
+          const propertyKey = String(address);
+          const result = await context.accountBalance.accountBalances([address], { head: previous });
+          const balance = result[propertyKey] ?? AttoXL1(0n);
+          if (address !== XYO_ZERO_ADDRESS && reqBalance > balance) {
+            const offendingTransactionHashes = offendingTransactionHashesForAddress(block, address);
+            errors.push(new HydratedBlockStateValidationError(
+              block?.[0]?._hash ?? ZERO_HASH20,
+              chainId,
+              block,
+              `insufficient balance for ${address} ${balance} < ${reqBalance}`,
+              void 0,
+              offendingTransactionHashes.length > 0 ? offendingTransactionHashes : void 0
+            ));
+          }
+        }
+      }, context);
+    } catch (ex) {
+      errors.push(new HydratedBlockStateValidationError(
+        block?.[0]?._hash ?? ZERO_HASH20,
+        chainId,
+        block,
+        `Failed RequiredBalanceBlockStateValidator: ${String(ex)}`,
+        ex
+      ));
+    }
+    return await Promise.resolve(errors);
+  }, context);
+};
+
+// src/modules/validation/hydratedBlockState/validateHydratedBlockState.ts
+var validateHydratedBlockState = async (context, hydratedBlock, additionalValidators = []) => {
+  return await spanRootAsync2("validateHydratedBlockState", async () => {
+    const errors = [];
+    let chainId;
+    try {
+      chainId = await context.chainIdAtBlockNumber(hydratedBlock[0].block);
+      const validateHydratedBlockErrors = await validateHydratedBlock(context, hydratedBlock, context.chainIdAtBlockNumber);
+      for (const validateHydratedBlockError of validateHydratedBlockErrors) {
+        errors.push(new HydratedBlockStateValidationError2(
+          hydratedBlock[0]._hash,
+          chainId,
+          hydratedBlock,
+          `validateBlock error: ${validateHydratedBlockError}`,
+          validateHydratedBlockError
+        ));
+      }
+      const validators = [
+        RequiredBalanceBlockStateValidator,
+        ...additionalValidators
+      ];
+      for (const validator of validators) {
+        errors.push(...await Promise.resolve(validator(context, hydratedBlock)));
+      }
+    } catch (ex) {
+      errors.push(new HydratedBlockStateValidationError2(
+        hydratedBlock?.[0]?._hash ?? ZERO_HASH21,
+        chainId ?? "00",
+        hydratedBlock,
+        `Failed validateHydratedBlockState: ${String(ex)}`,
+        ex
+      ));
+    }
+    return errors;
+  }, context);
+};
+
+// src/modules/validation/hydratedTransactionState/validateHydratedTransactionState.ts
+import { spanRootAsync as spanRootAsync4, ZERO_HASH as ZERO_HASH23 } from "@ariestools/sdk";
+import { HydratedTransactionValidationError as HydratedTransactionValidationError2 } from "@xyo-network/xl1-sdk";
+
+// src/modules/validation/hydratedTransactionState/validators/RequiredBalance.ts
+import { spanRootAsync as spanRootAsync3, ZERO_HASH as ZERO_HASH22 } from "@ariestools/sdk";
+import {
+  AttoXL1 as AttoXL12,
+  HydratedTransactionValidationError,
+  HydratedTransactionWrapper,
+  netBalancesForPayloads as netBalancesForPayloads2,
+  transactionRequiredGas,
+  XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS2
+} from "@xyo-network/xl1-sdk";
+async function balanceShortfallErrors(context, tx, requiredBalances) {
+  const errors = [];
+  const requiredAddresses = Object.keys(requiredBalances);
+  if (requiredAddresses.length === 0) return errors;
+  const [headBlock] = await context.blockViewer.currentBlock();
+  const balances = await context.accountBalanceViewer.accountBalances(
+    requiredAddresses,
+    { head: headBlock._hash }
+  );
+  const balancesByKey = balances;
+  for (const address of requiredAddresses) {
+    const propertyKey = String(address);
+    const reqBalance = requiredBalances[propertyKey];
+    const balance = balancesByKey[propertyKey] ?? AttoXL12(0n);
+    if (address !== XYO_ZERO_ADDRESS2 && reqBalance > balance) {
+      errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH22,
+        tx,
+        `insufficient balance for ${address} ${balance} < ${reqBalance}`
+      ));
+    }
+  }
+  return errors;
+}
+var RequiredBalanceTransactionStateValidator = async (context, tx) => {
+  return await spanRootAsync3("RequiredBalanceTransactionStateValidator", async () => {
+    const errors = [];
+    try {
+      const netBalances = netBalancesForPayloads2({ singletons: {} }, tx[1]);
+      const wrapper = await HydratedTransactionWrapper.parse(tx);
+      const from = wrapper.boundWitness.from;
+      const gasRequired = transactionRequiredGas(tx);
+      if (wrapper.fees.gasLimit < gasRequired) {
+        errors.push(new HydratedTransactionValidationError(
+          tx?.[0]?._hash ?? ZERO_HASH22,
+          tx,
+          `fees.gasLimit ${wrapper.fees.gasLimit} < required gas ${gasRequired}`
+        ));
+      }
+      const baseCost = wrapper.fees.base;
+      const priorityCost = wrapper.fees.priority;
+      const maxGasCost = wrapper.fees.gasLimit;
+      const fromKey = String(from);
+      netBalances[fromKey] = (netBalances[fromKey] ?? 0n) - baseCost - priorityCost - maxGasCost;
+      const requiredBalances = {};
+      for (const [address, net] of Object.entries(netBalances)) {
+        const propertyKey = String(address);
+        if (net < 0n) requiredBalances[propertyKey] = -net;
+      }
+      errors.push(...await balanceShortfallErrors(context, tx, requiredBalances));
+    } catch (ex) {
+      errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH22,
+        tx,
+        `Failed RequiredBalanceTransactionStateValidator: ${String(ex)}`,
+        ex
+      ));
+    }
+    return errors;
+  }, context);
+};
+
+// src/modules/validation/hydratedTransactionState/validateHydratedTransactionState.ts
+var validateHydratedTransactionState = async (context, tx) => {
+  return await spanRootAsync4("validateHydratedTransactionState", async () => {
+    const errors = [];
+    try {
+      const validators = [
+        RequiredBalanceTransactionStateValidator
+      ];
+      for (const validator of validators) {
+        errors.push(...await Promise.resolve(validator(context, tx)));
+      }
+    } catch (ex) {
+      errors.push(new HydratedTransactionValidationError2(
+        tx?.[0]?._hash ?? ZERO_HASH23,
+        tx,
+        `Failed validateHydratedTransactionState: ${String(ex)}`,
+        ex
+      ));
+    }
+    return errors;
+  }, context);
+};
+export {
+  BlockAllowedPayloadSchemasValidator,
+  BlockBoundWitnessValidator,
+  BlockFieldsValidator,
+  BlockJsonSchemaValidator,
+  BlockPreviousHashValidator,
+  PayloadsInBlockValidator,
+  RequiredBalanceBlockStateValidator,
+  RequiredBalanceTransactionStateValidator,
+  TransactionTransfersInBlockValidatorFactory,
+  validateBlock,
+  validateHydratedBlock,
+  validateHydratedBlockState,
+  validateHydratedTransactionState
+};
+//# sourceMappingURL=validation.mjs.map