Feat/Node: Validation Block

bindings/nodejs/lib/types/block/core/block.ts

@@ -2,12 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { BasicBlock } from './basic';
+import { ValidationBlock } from './validation';
 /**
  * All of the block types.
  */
 export enum BlockType {
     /// A Basic block.
     Basic = 0,
+    /// A Validation block.
+    Validation = 1,
 }
 
 export abstract class Block {
@@ -40,4 +43,25 @@ export abstract class Block {
             throw new Error('invalid downcast of non-BasicBlock');
         }
     }
+
+    /**
+     * Checks whether the block is a `ValidationBlock`.
+     * @returns true if it is, otherwise false
+     */
+    isValidation(): boolean {
+        return this.type === BlockType.Validation;
+    }
+
+    /**
+     * Gets the block as an actual `ValidationBlock`.
+     * NOTE: Will throw an error if the block is not a `ValidationBlock`.
+     * @returns The block
+     */
+    asValidation(): ValidationBlock {
+        if (this.isValidation()) {
+            return this as unknown as ValidationBlock;
+        } else {
+            throw new Error('invalid downcast of non-ValidationBlock');
+        }
+    }
 }

bindings/nodejs/lib/types/block/core/index.ts

@@ -3,13 +3,18 @@
 
 import { BlockType } from './block';
 import { BasicBlock } from './basic';
+import { ValidationBlock } from './validation';
 
 export * from './block';
 export * from './basic';
+export * from './validation';
 export * from './wrapper';
 
 // Here because in block.ts it causes a circular dependency
 export const BlockDiscriminator = {
     property: 'type',
-    subTypes: [{ value: BasicBlock, name: BlockType.Basic as any }],
+    subTypes: [
+        { value: BasicBlock, name: BlockType.Basic as any },
+        { value: ValidationBlock, name: BlockType.Validation as any },
+    ],
 };

bindings/nodejs/lib/types/block/core/validation.ts

@@ -0,0 +1,38 @@
+// Copyright 2023 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import { StrongParents, WeakParents, ShallowLikeParents } from '../parents';
+import { HexEncodedString } from '../../utils';
+import { Block } from './block';
+
+/**
+ * A Validation Block is a special type of block used by validators to secure the network.
+ * It is recognised by the Congestion Control of the IOTA 2.0 protocol and can be issued without
+ * burning Mana within the constraints of the allowed validator throughput.
+ *
+ * It is allowed to reference more parent blocks than a normal Basic Block.
+ */
+export class ValidationBlock extends Block {
+    /**
+     * Blocks that are strongly directly approved.
+     */
+    readonly strongParents!: StrongParents;
+    /**
+     * Blocks that are weakly directly approved.
+     */
+    readonly weakParents!: WeakParents;
+    /**
+     * Blocks that are directly referenced to adjust opinion.
+     */
+    readonly shallowLikeParents!: ShallowLikeParents;
+
+    /**
+     * The highest supported protocol version the issuer of this block supports.
+     */
+    readonly highestSupportedVersion!: number;
+
+    /**
+     * The hash of the protocol parameters for the Highest Supported Version.
+     */
+    readonly protocolParametersHash!: HexEncodedString;
+}

bindings/nodejs/lib/types/block/core/wrapper.ts

@@ -8,6 +8,7 @@ import { u64 } from '../../utils/type-aliases';
 import { plainToInstance, Type } from 'class-transformer';
 import { Block, BlockType } from './block';
 import { BasicBlock } from './basic';
+import { ValidationBlock } from './validation';
 import { BlockDiscriminator } from './';
 
 /**
@@ -92,6 +93,27 @@ class BlockWrapper {
             throw new Error('invalid downcast of non-BasicBlock');
         }
     }
+
+    /**
+     * Checks whether the block is a `ValidationBlock`.
+     * @returns true if it is, otherwise false
+     */
+    isValidation(): boolean {
+        return this.block.type === BlockType.Validation;
+    }
+
+    /**
+     * Gets the block as an actual `ValidationBlock`.
+     * NOTE: Will throw an error if the block is not a `ValidationBlock`.
+     * @returns The block
+     */
+    asValidation(): ValidationBlock {
+        if (this.isValidation()) {
+            return this.block as unknown as ValidationBlock;
+        } else {
+            throw new Error('invalid downcast of non-ValidationBlock');
+        }
+    }
 }
 
 function parseBlockWrapper(data: any): BlockWrapper {