@xyo-network/chain-validation 1.22.0 → 1.23.2

package/dist/neutral/index.mjs

@@ -1,44 +1,49 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/block/validateBlock.ts
 import { ZERO_HASH as ZERO_HASH6 } from "@xylabs/sdk-js";
 import { BlockValidationError as BlockValidationError6 } from "@xyo-network/xl1-sdk";
 
 // src/block/validators/AllowedPayloadSchemas.ts
 import { ZERO_HASH } from "@xylabs/sdk-js";
-import { BlockValidationError, isAllowedBlockPayloadSchema } from "@xyo-network/xl1-sdk";
-var BlockAllowedPayloadSchemasValidator = /* @__PURE__ */ __name((context, block) => {
+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: ${schema}`));
+        errors.push(new BlockValidationError(
+          block?._hash ?? ZERO_HASH,
+          block,
+          `payload schema not allowed in block: ${schema}`
+        ));
       }
     }
   } catch (ex) {
-    errors.push(new BlockValidationError(block?._hash ?? ZERO_HASH, block, `validation excepted: ${ex}`, ex));
+    errors.push(new BlockValidationError(
+      block?._hash ?? ZERO_HASH,
+      block,
+      `validation excepted: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "BlockAllowedPayloadSchemasValidator");
+};
 
 // src/block/validators/BoundWitness.ts
 import { ZERO_HASH as ZERO_HASH2 } from "@xylabs/sdk-js";
 import { BoundWitnessValidator } from "@xyo-network/sdk-js";
 import { BlockValidationError as BlockValidationError2 } from "@xyo-network/xl1-sdk";
-var error = /* @__PURE__ */ __name((block, message) => new BlockValidationError2(block?._hash ?? ZERO_HASH2, block, message), "error");
-var checkSignaturesShape = /* @__PURE__ */ __name((block) => {
+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 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 [];
-}, "checkSignaturesShape");
-var BlockBoundWitnessValidator = /* @__PURE__ */ __name(async (_context, block) => {
+};
+var BlockBoundWitnessValidator = async (_context, block) => {
   try {
     const shapeErrors = checkSignaturesShape(block);
     if (shapeErrors.length > 0) return shapeErrors;
@@ -46,17 +51,15 @@ var BlockBoundWitnessValidator = /* @__PURE__ */ __name(async (_context, 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)}`)
-    ];
+    return [error(block, `Failed BlockBoundWitnessValidator: ${String(ex)}`)];
   }
-}, "BlockBoundWitnessValidator");
+};
 
 // src/block/validators/Fields.ts
 import { isDefined, ZERO_HASH as ZERO_HASH3 } from "@xylabs/sdk-js";
 import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
 import { BlockValidationError as BlockValidationError3 } from "@xyo-network/xl1-sdk";
-var BlockFieldsValidator = /* @__PURE__ */ __name((context, block, chainId) => {
+var BlockFieldsValidator = (context, block, chainId) => {
   const errors = [];
   try {
     if (isDefined(chainId) && block.chain !== chainId.toLowerCase()) {
@@ -69,48 +72,60 @@ var BlockFieldsValidator = /* @__PURE__ */ __name((context, block, chainId) => {
       }
     }
     if (new Set(txHashes).size < txHashes.length) {
-      errors.push(new BlockValidationError3(block?._hash ?? ZERO_HASH3, block, `Duplicate Transaction Hashes: ${txHashes}`));
+      errors.push(new BlockValidationError3(
+        block?._hash ?? ZERO_HASH3,
+        block,
+        `Duplicate Transaction Hashes: ${txHashes}`
+      ));
     }
   } catch (ex) {
-    errors.push(new BlockValidationError3(block?._hash ?? ZERO_HASH3, block, `validation excepted: ${ex}`, ex));
+    errors.push(new BlockValidationError3(
+      block?._hash ?? ZERO_HASH3,
+      block,
+      `validation excepted: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "BlockFieldsValidator");
+};
 
 // src/block/validators/JsonSchema.ts
 import { ZERO_HASH as ZERO_HASH4 } from "@xylabs/sdk-js";
 import { BlockBoundWitnessWithStorageMetaJsonSchema, BlockValidationError as BlockValidationError4 } from "@xyo-network/xl1-sdk";
 import { Ajv } from "ajv";
-var BlockJsonSchemaValidator = /* @__PURE__ */ __name((jsonSchema = BlockBoundWitnessWithStorageMetaJsonSchema) => {
-  const ajv = new Ajv({
-    allErrors: true,
-    strict: true
-  });
+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"
-        })}`);
+        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: ${ex}`);
+      const error2 = new BlockValidationError4(
+        block?._hash ?? ZERO_HASH4,
+        block,
+        `validation excepted: ${ex}`
+      );
       error2.cause = ex;
       errors.push(error2);
     }
     return errors;
   };
-}, "BlockJsonSchemaValidator");
+};
 
 // src/block/validators/PreviousHash.ts
 import { isHash, ZERO_HASH as ZERO_HASH5 } from "@xylabs/sdk-js";
 import { BlockValidationError as BlockValidationError5 } from "@xyo-network/xl1-sdk";
-var BlockPreviousHashValidator = /* @__PURE__ */ __name((context, block) => {
+var BlockPreviousHashValidator = (context, block) => {
   const errors = [];
   try {
     const blockNumber = block.block;
@@ -126,15 +141,19 @@ var BlockPreviousHashValidator = /* @__PURE__ */ __name((context, block) => {
       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: ${ex}`);
+    const error2 = new BlockValidationError5(
+      block?._hash ?? ZERO_HASH5,
+      block,
+      `Failed BlockPreviousHashValidator: ${ex}`
+    );
     error2.cause = ex;
     errors.push(error2);
   }
   return errors;
-}, "BlockPreviousHashValidator");
+};
 
 // src/block/validateBlock.ts
-var validateBlock = /* @__PURE__ */ __name(async (context, block, chainId, additionalValidators = []) => {
+var validateBlock = async (context, block, chainId, additionalValidators = []) => {
   const errors = [];
   try {
     const validators = [
@@ -144,12 +163,14 @@ var validateBlock = /* @__PURE__ */ __name(async (context, block, chainId, addit
       BlockAllowedPayloadSchemasValidator,
       ...additionalValidators
     ];
-    errors.push(...(await Promise.all(validators.map((validator) => validator(context, block, chainId)))).flat());
+    errors.push(...(await Promise.all(
+      validators.map((validator) => validator(context, block, chainId))
+    )).flat());
   } catch (ex) {
     errors.push(new BlockValidationError6(block?._hash ?? ZERO_HASH6, block, "validation excepted", ex));
   }
   return errors;
-}, "validateBlock");
+};
 
 // src/hydratedBlock/validateHydratedBlock.ts
 import { ZERO_HASH as ZERO_HASH18 } from "@xylabs/sdk-js";
@@ -163,11 +184,20 @@ import { HydratedBlockValidationError } from "@xyo-network/xl1-sdk";
 import { ZERO_HASH as ZERO_HASH16 } from "@xylabs/sdk-js";
 import { BoundWitnessSchema as BoundWitnessSchema2 } from "@xyo-network/boundwitness-model";
 import { SchemaSchema } from "@xyo-network/sdk-js";
-import { BridgeDestinationObservationSchema, BridgeIntentSchema, BridgeSourceObservationSchema, ChainStakeIntentSchema, HashSchema, InBlockPayloadValidationError as InBlockPayloadValidationError12, TimeSchema, TransferSchema } from "@xyo-network/xl1-sdk";
+import {
+  BridgeDestinationObservationSchema,
+  BridgeIntentSchema,
+  BridgeSourceObservationSchema,
+  ChainStakeIntentSchema,
+  HashSchema,
+  InBlockPayloadValidationError as InBlockPayloadValidationError12,
+  TimeSchema,
+  TransferSchema
+} from "@xyo-network/xl1-sdk";
 
 // src/elevatedPayload/lib/isElevatedFromBlock.ts
 import { isTransactionBoundWitness } from "@xyo-network/xl1-sdk";
-var isElevatedFromBlock = /* @__PURE__ */ __name((payload, [, payloads]) => {
+var isElevatedFromBlock = (payload, [, payloads]) => {
   const txs = payloads.filter((p) => isTransactionBoundWitness(p));
   for (const tx of txs) {
     if (tx.payload_hashes.includes(payload._hash)) {
@@ -175,27 +205,32 @@ var isElevatedFromBlock = /* @__PURE__ */ __name((payload, [, payloads]) => {
     }
   }
   return true;
-}, "isElevatedFromBlock");
+};
 
 // src/elevatedPayload/lib/validateElevatedFromBlock.ts
 import { InBlockPayloadValidationError, transactionsFromHydratedBlock } from "@xyo-network/xl1-sdk";
-var validateElevatedFromBlock = /* @__PURE__ */ __name((context, payload, block) => {
+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}`));
+      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: ${ex}`, ex));
   }
   return errors;
-}, "validateElevatedFromBlock");
+};
 
 // src/elevatedPayload/lib/validateElevatedFromTransaction.ts
 import { InBlockPayloadValidationError as InBlockPayloadValidationError2, transactionsFromHydratedBlock as transactionsFromHydratedBlock2 } from "@xyo-network/xl1-sdk";
-var validateElevatedFromTransaction = /* @__PURE__ */ __name((context, payload, block) => {
+var validateElevatedFromTransaction = (context, payload, block) => {
   const errors = [];
   try {
     const txs = transactionsFromHydratedBlock2(block);
@@ -208,32 +243,49 @@ var validateElevatedFromTransaction = /* @__PURE__ */ __name((context, payload,
       errors.push(new InBlockPayloadValidationError2(payload._hash, block, payload, "No Transactions in block"));
     }
   } catch (ex) {
-    errors.push(new InBlockPayloadValidationError2(payload._hash, block, payload, `Failed validateElevatedFromTransaction: ${ex}`, ex));
+    errors.push(new InBlockPayloadValidationError2(
+      payload._hash,
+      block,
+      payload,
+      `Failed validateElevatedFromTransaction: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateElevatedFromTransaction");
+};
 
 // src/elevatedPayload/lib/validateTransactionInBlock.ts
 import { ZERO_HASH as ZERO_HASH7 } from "@xylabs/sdk-js";
 import { isHashMeta } from "@xyo-network/sdk-js";
-import { BoundWitnessSignaturesValidator, InBlockPayloadValidationError as InBlockPayloadValidationError3, isTransactionBoundWitness as isTransactionBoundWitness2, validateTransaction } from "@xyo-network/xl1-sdk";
-var validateTransactionInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+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]
-      ]);
+      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));
+        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));
+        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"));
@@ -242,11 +294,11 @@ var validateTransactionInBlock = /* @__PURE__ */ __name(async (context, payload,
     errors.push(new InBlockPayloadValidationError3(payload._hash ?? ZERO_HASH7, block, payload, `validation excepted: ${ex}`, ex));
   }
   return errors;
-}, "validateTransactionInBlock");
+};
 
 // src/elevatedPayload/lib/validateTypedPayloadInBlock.ts
 import { isHashMeta as isHashMeta2 } from "@xyo-network/sdk-js";
-var validateTypedPayloadInBlock = /* @__PURE__ */ __name(async (context, payload, block, identityFunction) => {
+var validateTypedPayloadInBlock = async (context, payload, block, identityFunction) => {
   const errors = [];
   try {
     if (identityFunction(payload) && isHashMeta2(payload)) {
@@ -262,12 +314,12 @@ var validateTypedPayloadInBlock = /* @__PURE__ */ __name(async (context, payload
     errors.push(new Error(`Failed validateTypedPayloadInBlock: ${ex}`));
   }
   return errors;
-}, "validateTypedPayloadInBlock");
+};
 
 // src/elevatedPayload/payloads/validateBridgeDestinationObservationInBlock.ts
 import { ZERO_HASH as ZERO_HASH8 } from "@xylabs/sdk-js";
 import { InBlockPayloadValidationError as InBlockPayloadValidationError4, isBridgeDestinationObservation } from "@xyo-network/xl1-sdk";
-var validateBridgeDestinationObservationInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+var validateBridgeDestinationObservationInBlock = async (context, payload, block) => {
   const errors = [];
   try {
     const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isBridgeDestinationObservation);
@@ -275,15 +327,21 @@ var validateBridgeDestinationObservationInBlock = /* @__PURE__ */ __name(async (
       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: ${ex}`, ex));
+    errors.push(new InBlockPayloadValidationError4(
+      block?.[0]?._hash ?? ZERO_HASH8,
+      block,
+      payload,
+      `Failed validateBridgeObservationInBlock: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateBridgeDestinationObservationInBlock");
+};
 
 // src/elevatedPayload/payloads/validateBridgeIntentInBlock.ts
 import { ZERO_HASH as ZERO_HASH9 } from "@xylabs/sdk-js";
 import { InBlockPayloadValidationError as InBlockPayloadValidationError5, isBridgeIntent } from "@xyo-network/xl1-sdk";
-var validateBridgeIntentInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+var validateBridgeIntentInBlock = async (context, payload, block) => {
   const errors = [];
   try {
     const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isBridgeIntent);
@@ -291,15 +349,21 @@ var validateBridgeIntentInBlock = /* @__PURE__ */ __name(async (context, payload
       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: ${ex}`, ex));
+    errors.push(new InBlockPayloadValidationError5(
+      block?.[0]?._hash ?? ZERO_HASH9,
+      block,
+      payload,
+      `Failed validateBridgeIntentInBlock: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateBridgeIntentInBlock");
+};
 
 // src/elevatedPayload/payloads/validateBridgeSourceObservationInBlock.ts
 import { ZERO_HASH as ZERO_HASH10 } from "@xylabs/sdk-js";
 import { InBlockPayloadValidationError as InBlockPayloadValidationError6, isBridgeSourceObservation } from "@xyo-network/xl1-sdk";
-var validateBridgeSourceObservationInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+var validateBridgeSourceObservationInBlock = async (context, payload, block) => {
   const errors = [];
   try {
     const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isBridgeSourceObservation);
@@ -307,15 +371,21 @@ var validateBridgeSourceObservationInBlock = /* @__PURE__ */ __name(async (conte
       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: ${ex}`, ex));
+    errors.push(new InBlockPayloadValidationError6(
+      block?.[0]?._hash ?? ZERO_HASH10,
+      block,
+      payload,
+      `Failed validateBridgeObservationInBlock: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateBridgeSourceObservationInBlock");
+};
 
 // src/elevatedPayload/payloads/validateChainStakeIntentInBlock.ts
 import { ZERO_HASH as ZERO_HASH11 } from "@xylabs/sdk-js";
 import { InBlockPayloadValidationError as InBlockPayloadValidationError7, isChainStakeIntent } from "@xyo-network/xl1-sdk";
-var validateChainStakeIntentInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+var validateChainStakeIntentInBlock = async (context, payload, block) => {
   const errors = [];
   try {
     const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isChainStakeIntent);
@@ -323,15 +393,21 @@ var validateChainStakeIntentInBlock = /* @__PURE__ */ __name(async (context, pay
       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: ${ex}`, ex));
+    errors.push(new InBlockPayloadValidationError7(
+      block[0]?._hash ?? ZERO_HASH11,
+      block,
+      payload,
+      `validation excepted: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateChainStakeIntentInBlock");
+};
 
 // src/elevatedPayload/payloads/validateHashInBlock.ts
 import { ZERO_HASH as ZERO_HASH12 } from "@xylabs/sdk-js";
 import { InBlockPayloadValidationError as InBlockPayloadValidationError8, isHashPayload } from "@xyo-network/xl1-sdk";
-var validateHashInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+var validateHashInBlock = async (context, payload, block) => {
   const errors = [];
   try {
     const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isHashPayload);
@@ -339,16 +415,22 @@ var validateHashInBlock = /* @__PURE__ */ __name(async (context, payload, block)
       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: ${ex}`, ex));
+    errors.push(new InBlockPayloadValidationError8(
+      block?.[0]?._hash ?? ZERO_HASH12,
+      block,
+      payload,
+      `validation excepted: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateHashInBlock");
+};
 
 // src/elevatedPayload/payloads/validateSchemaInBlock.ts
 import { ZERO_HASH as ZERO_HASH13 } from "@xylabs/sdk-js";
 import { isSchemaPayload } from "@xyo-network/sdk-js";
 import { InBlockPayloadValidationError as InBlockPayloadValidationError9 } from "@xyo-network/xl1-sdk";
-var validateSchemaInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+var validateSchemaInBlock = async (context, payload, block) => {
   const errors = [];
   try {
     const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isSchemaPayload);
@@ -356,15 +438,21 @@ var validateSchemaInBlock = /* @__PURE__ */ __name(async (context, payload, bloc
       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: ${ex}`, ex));
+    errors.push(new InBlockPayloadValidationError9(
+      block?.[0]?._hash ?? ZERO_HASH13,
+      block,
+      payload,
+      `Failed validateSchemaInBlock: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateSchemaInBlock");
+};
 
 // src/elevatedPayload/payloads/validateTimeInBlock.ts
 import { ZERO_HASH as ZERO_HASH14 } from "@xylabs/sdk-js";
 import { InBlockPayloadValidationError as InBlockPayloadValidationError10, isTimePayload } from "@xyo-network/xl1-sdk";
-var validateTimeInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+var validateTimeInBlock = async (context, payload, block) => {
   const errors = [];
   try {
     const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isTimePayload);
@@ -372,15 +460,21 @@ var validateTimeInBlock = /* @__PURE__ */ __name(async (context, payload, block)
       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: ${ex}`, ex));
+    errors.push(new InBlockPayloadValidationError10(
+      block?.[0]?._hash ?? ZERO_HASH14,
+      block,
+      payload,
+      `Failed validateTimeInBlock: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateTimeInBlock");
+};
 
 // src/elevatedPayload/payloads/validateTransferInBlock.ts
 import { ZERO_HASH as ZERO_HASH15 } from "@xylabs/sdk-js";
 import { InBlockPayloadValidationError as InBlockPayloadValidationError11, isTransfer } from "@xyo-network/xl1-sdk";
-var validateTransferInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+var validateTransferInBlock = async (context, payload, block) => {
   const errors = [];
   try {
     const typedErrors = await validateTypedPayloadInBlock(context, payload, block, isTransfer);
@@ -388,10 +482,16 @@ var validateTransferInBlock = /* @__PURE__ */ __name(async (context, payload, bl
       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: ${ex}`, ex));
+    errors.push(new InBlockPayloadValidationError11(
+      block?.[0]?._hash ?? ZERO_HASH15,
+      block,
+      payload,
+      `Failed validateTransferInBlock: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateTransferInBlock");
+};
 
 // src/elevatedPayload/validatePayloadInBlock.ts
 var payloadValidators = {
@@ -405,7 +505,7 @@ var payloadValidators = {
   [TimeSchema]: validateTimeInBlock,
   [TransferSchema]: validateTransferInBlock
 };
-var validatePayloadInBlock = /* @__PURE__ */ __name(async (context, payload, block) => {
+var validatePayloadInBlock = async (context, payload, block) => {
   const errors = [];
   try {
     const validator = payloadValidators[payload.schema];
@@ -415,66 +515,70 @@ var validatePayloadInBlock = /* @__PURE__ */ __name(async (context, payload, blo
       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: ${ex}`, ex);
+    const error2 = new InBlockPayloadValidationError12(
+      block?.[0]?._hash ?? ZERO_HASH16,
+      block,
+      payload,
+      `validation excepted: ${ex}`,
+      ex
+    );
     errors.push(error2);
   }
   return errors;
-}, "validatePayloadInBlock");
+};
 
 // src/hydratedBlock/validators/Payloads.ts
-var PayloadsInBlockValidator = /* @__PURE__ */ __name(async (context, [block, payloads]) => {
+var PayloadsInBlockValidator = async (context, [block, payloads]) => {
   const errors = [];
   try {
     const payloadMap = {};
     for (const payload of payloads) {
       payloadMap[payload._hash] = payload;
     }
-    const remainingPayloads = {
-      ...payloadMap
-    };
+    const remainingPayloads = { ...payloadMap };
     for (let i = 0; i < block.payload_hashes.length; i++) {
       const hash = block.payload_hashes[i];
       const schema = block.payload_schemas[i];
       const payload = payloadMap[hash];
       if (payload) {
-        const payloadInBlockErrors = await validatePayloadInBlock(context, payload, [
-          block,
-          payloads
-        ]);
+        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));
+          errors.push(new HydratedBlockValidationError(
+            block?._hash ?? ZERO_HASH17,
+            [block, payloads],
+            `validatePayloadInBlock error: ${payloadInBlockError}`,
+            payloadInBlockError
+          ));
         }
         delete remainingPayloads[hash];
       } else {
-        errors.push(new HydratedBlockValidationError(block?._hash ?? ZERO_HASH17, [
-          block,
-          payloads
-        ], `missing payload ${hash} ${schema}`));
+        errors.push(new HydratedBlockValidationError(block?._hash ?? ZERO_HASH17, [block, payloads], `missing payload ${hash} ${schema}`));
       }
     }
     if (Object.keys(remainingPayloads).length > 0) {
-      errors.push(new HydratedBlockValidationError(block?._hash ?? ZERO_HASH17, [
-        block,
-        payloads
-      ], `extra payloads ${Object.keys(payloadMap).join(", ")}`));
+      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: ${ex}`, ex));
+    errors.push(new HydratedBlockValidationError(
+      block?._hash ?? ZERO_HASH17,
+      [block, payloads],
+      `Failed PayloadsInBlockValidator: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "PayloadsInBlockValidator");
+};
 
 // src/hydratedBlock/validateHydratedBlock.ts
-var validateHydratedBlock = /* @__PURE__ */ __name(async (context, hydratedBlock, chainIdAtBlockNumber, additionalValidators = [], additionalBlockValidators = []) => {
+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);
+    const validateBlockErrors = await validateBlock(
+      context,
+      hydratedBlock[0],
+      chainIdAtBlockNumber ? await chainIdAtBlockNumber(hydratedBlock[0].block) : void 0,
+      additionalBlockValidators
+    );
     for (const validateBlockError of validateBlockErrors) {
       errors.push(new HydratedBlockValidationError2(hydratedBlock[0]._hash, hydratedBlock, `validateBlock error: ${validateBlockError}`, validateBlockError));
     }
@@ -488,10 +592,15 @@ var validateHydratedBlock = /* @__PURE__ */ __name(async (context, hydratedBlock
     ];
     errors.push(...(await Promise.all(validators.map((v) => v(context, hydratedBlock, chainIdAtBlockNumber)))).flat());
   } catch (ex) {
-    errors.push(new HydratedBlockValidationError2(hydratedBlock?.[0]?._hash ?? ZERO_HASH18, hydratedBlock, `Failed validateHydratedBlock: ${ex}`, ex));
+    errors.push(new HydratedBlockValidationError2(
+      hydratedBlock?.[0]?._hash ?? ZERO_HASH18,
+      hydratedBlock,
+      `Failed validateHydratedBlock: ${ex}`,
+      ex
+    ));
   }
   return errors;
-}, "validateHydratedBlock");
+};
 
 // src/hydratedBlockState/validateHydratedBlockState.ts
 import { spanRootAsync as spanRootAsync2, ZERO_HASH as ZERO_HASH20 } from "@xylabs/sdk-js";
@@ -499,15 +608,28 @@ import { HydratedBlockStateValidationError as HydratedBlockStateValidationError2
 
 // src/hydratedBlockState/validators/RequiredBalance.ts
 import { spanRootAsync, ZERO_HASH as ZERO_HASH19 } from "@xylabs/sdk-js";
-import { AttoXL1, HydratedBlockStateValidationError, netBalancesForPayloads, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
-var RequiredBalanceBlockStateValidator = /* @__PURE__ */ __name(async (context, block) => {
+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 netBalances = netBalancesForPayloads({ singletons: {} }, block[1]);
       const netBalanceAddresses = Object.keys(netBalances);
       const requiredBalances = {};
       for (const address of netBalanceAddresses) {
@@ -516,32 +638,45 @@ var RequiredBalanceBlockStateValidator = /* @__PURE__ */ __name(async (context,
         }
       }
       const previous = block[0].previous;
-      if (previous === null) return [
-        new HydratedBlockStateValidationError(block?.[0]?._hash ?? ZERO_HASH19, "00", block, "Insufficient funds because first block")
-      ];
+      if (previous === null) return [new HydratedBlockStateValidationError(
+        block?.[0]?._hash ?? ZERO_HASH19,
+        "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 result = await context.accountBalance.accountBalances([
-            address
-          ], {
-            head: previous
-          });
+          const result = await context.accountBalance.accountBalances([address], { head: previous });
           const balance = result[address] ?? AttoXL1(0n);
           if (address !== XYO_ZERO_ADDRESS && reqBalance > balance) {
-            errors.push(new HydratedBlockStateValidationError(block?.[0]?._hash ?? ZERO_HASH19, chainId, block, `insufficient balance for ${address} ${balance} < ${requiredBalances[address]}`));
+            const offendingTransactionHashes = offendingTransactionHashesForAddress(block, address);
+            errors.push(new HydratedBlockStateValidationError(
+              block?.[0]?._hash ?? ZERO_HASH19,
+              chainId,
+              block,
+              `insufficient balance for ${address} ${balance} < ${requiredBalances[address]}`,
+              void 0,
+              offendingTransactionHashes.length > 0 ? offendingTransactionHashes : void 0
+            ));
           }
         }
       }, context);
     } catch (ex) {
-      errors.push(new HydratedBlockStateValidationError(block?.[0]?._hash ?? ZERO_HASH19, chainId, block, `Failed RequiredBalanceBlockStateValidator: ${ex}`, ex));
+      errors.push(new HydratedBlockStateValidationError(
+        block?.[0]?._hash ?? ZERO_HASH19,
+        chainId,
+        block,
+        `Failed RequiredBalanceBlockStateValidator: ${ex}`,
+        ex
+      ));
     }
     return await Promise.resolve(errors);
   }, context);
-}, "RequiredBalanceBlockStateValidator");
+};
 
 // src/hydratedBlockState/validateHydratedBlockState.ts
-var validateHydratedBlockState = /* @__PURE__ */ __name(async (context, hydratedBlock, additionalValidators = []) => {
+var validateHydratedBlockState = async (context, hydratedBlock, additionalValidators = []) => {
   return await spanRootAsync2("validateHydratedBlockState", async () => {
     const errors = [];
     let chainId;
@@ -549,7 +684,13 @@ var validateHydratedBlockState = /* @__PURE__ */ __name(async (context, hydrated
       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));
+        errors.push(new HydratedBlockStateValidationError2(
+          hydratedBlock[0]._hash,
+          chainId,
+          hydratedBlock,
+          `validateBlock error: ${validateHydratedBlockError}`,
+          validateHydratedBlockError
+        ));
       }
       const validators = [
         RequiredBalanceBlockStateValidator,
@@ -557,11 +698,17 @@ var validateHydratedBlockState = /* @__PURE__ */ __name(async (context, hydrated
       ];
       errors.push(...(await Promise.all(validators.map((v) => v(context, hydratedBlock)))).flat());
     } catch (ex) {
-      errors.push(new HydratedBlockStateValidationError2(hydratedBlock?.[0]?._hash ?? ZERO_HASH20, chainId ?? "00", hydratedBlock, `Failed validateHydratedBlockState: ${ex}`, ex));
+      errors.push(new HydratedBlockStateValidationError2(
+        hydratedBlock?.[0]?._hash ?? ZERO_HASH20,
+        chainId ?? "00",
+        hydratedBlock,
+        `Failed validateHydratedBlockState: ${ex}`,
+        ex
+      ));
     }
     return errors;
   }, context);
-}, "validateHydratedBlockState");
+};
 
 // src/hydratedTransactionState/validateHydratedTransactionState.ts
 import { spanRootAsync as spanRootAsync4, ZERO_HASH as ZERO_HASH22 } from "@xylabs/sdk-js";
@@ -569,45 +716,73 @@ import { HydratedTransactionValidationError as HydratedTransactionValidationErro
 
 // src/hydratedTransactionState/validators/RequiredBalance.ts
 import { spanRootAsync as spanRootAsync3, ZERO_HASH as ZERO_HASH21 } from "@xylabs/sdk-js";
-import { AttoXL1 as AttoXL12, HydratedTransactionValidationError, HydratedTransactionWrapper, netBalancesForPayloads as netBalancesForPayloads2, transactionRequiredGas, XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS2 } from "@xyo-network/xl1-sdk";
-var RequiredBalanceTransactionStateValidator = /* @__PURE__ */ __name(async (context, tx) => {
+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())[0];
+  const balances = await context.accountBalanceViewer.accountBalances(
+    requiredAddresses,
+    { head: headBlock._hash }
+  );
+  for (const address of requiredAddresses) {
+    const reqBalance = requiredBalances[address];
+    const balance = balances[address] ?? AttoXL12(0n);
+    if (address !== XYO_ZERO_ADDRESS2 && reqBalance > balance) {
+      errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH21,
+        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 netBalances = netBalancesForPayloads2({ singletons: {} }, tx[1]);
       const wrapper = await HydratedTransactionWrapper.parse(tx);
       const from = wrapper.boundWitness.from;
-      const gasCost = transactionRequiredGas(tx) * wrapper.fees.gasPrice;
+      const gasRequired = transactionRequiredGas(tx);
+      if (wrapper.fees.gasLimit < gasRequired) {
+        errors.push(new HydratedTransactionValidationError(
+          tx?.[0]?._hash ?? ZERO_HASH21,
+          tx,
+          `fees.gasLimit ${wrapper.fees.gasLimit} < required gas ${gasRequired}`
+        ));
+      }
+      const gasCost = gasRequired * wrapper.fees.gasPrice;
       const baseCost = wrapper.fees.base;
       netBalances[from] = (netBalances[from] ?? 0n) - gasCost - baseCost;
       const requiredBalances = {};
       for (const [address, net] of Object.entries(netBalances)) {
         if (net < 0n) requiredBalances[address] = -net;
       }
-      const requiredAddresses = Object.keys(requiredBalances);
-      if (requiredAddresses.length === 0) return errors;
-      const headBlock = (await context.blockViewer.currentBlock())[0];
-      const balances = await context.accountBalanceViewer.accountBalances(requiredAddresses, {
-        head: headBlock._hash
-      });
-      for (const address of requiredAddresses) {
-        const reqBalance = requiredBalances[address];
-        const balance = balances[address] ?? AttoXL12(0n);
-        if (address !== XYO_ZERO_ADDRESS2 && reqBalance > balance) {
-          errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH21, tx, `insufficient balance for ${address} ${balance} < ${reqBalance}`));
-        }
-      }
+      errors.push(...await balanceShortfallErrors(context, tx, requiredBalances));
     } catch (ex) {
-      errors.push(new HydratedTransactionValidationError(tx?.[0]?._hash ?? ZERO_HASH21, tx, `Failed RequiredBalanceTransactionStateValidator: ${ex}`, ex));
+      errors.push(new HydratedTransactionValidationError(
+        tx?.[0]?._hash ?? ZERO_HASH21,
+        tx,
+        `Failed RequiredBalanceTransactionStateValidator: ${ex}`,
+        ex
+      ));
     }
     return errors;
   }, context);
-}, "RequiredBalanceTransactionStateValidator");
+};
 
 // src/hydratedTransactionState/validateHydratedTransactionState.ts
-var validateHydratedTransactionState = /* @__PURE__ */ __name(async (context, tx) => {
+var validateHydratedTransactionState = async (context, tx) => {
   return await spanRootAsync4("validateHydratedTransactionState", async () => {
     const errors = [];
     try {
@@ -616,11 +791,16 @@ var validateHydratedTransactionState = /* @__PURE__ */ __name(async (context, tx
       ];
       errors.push(...(await Promise.all(validators.map((v) => v(context, tx)))).flat());
     } catch (ex) {
-      errors.push(new HydratedTransactionValidationError2(tx?.[0]?._hash ?? ZERO_HASH22, tx, `Failed validateHydratedTransactionState: ${ex}`, ex));
+      errors.push(new HydratedTransactionValidationError2(
+        tx?.[0]?._hash ?? ZERO_HASH22,
+        tx,
+        `Failed validateHydratedTransactionState: ${ex}`,
+        ex
+      ));
     }
     return errors;
   }, context);
-}, "validateHydratedTransactionState");
+};
 export {
   BlockAllowedPayloadSchemasValidator,
   BlockBoundWitnessValidator,
@@ -635,4 +815,4 @@ export {
   validateHydratedBlockState,
   validateHydratedTransactionState
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map