@typeberry/convert 0.5.3-5a6cfcc → 0.5.3-a1dad13

package/index.js

@@ -9752,14 +9752,18 @@ class work_item_WorkItem extends WithDebug {
 
 
 
-/** Verify the value is within the `WorkItemsCount` bounds. */
+/** Convert the value to `WorkItemsCount` bounds. */
 function tryAsWorkItemsCount(len) {
     debug_check `
-    ${len >= MIN_NUMBER_OF_WORK_ITEMS && len <= work_package_MAX_NUMBER_OF_WORK_ITEMS}
+    ${isWorkItemsCount(len)}
     WorkItemsCount: Expected '${MIN_NUMBER_OF_WORK_ITEMS} <= count <= ${work_package_MAX_NUMBER_OF_WORK_ITEMS}' got ${len}
   `;
     return tryAsU8(len);
 }
+/** Verify the value is within the `WorkItemsCount` bounds. */
+function isWorkItemsCount(len) {
+    return len >= MIN_NUMBER_OF_WORK_ITEMS && len <= work_package_MAX_NUMBER_OF_WORK_ITEMS;
+}
 /** Minimal number of work items in the work package or results in work report. */
 const MIN_NUMBER_OF_WORK_ITEMS = 1;
 /** `I`: Maximal number of work items in the work package or results in work report. */
@@ -11169,6 +11173,13 @@ const blockFromJson = (spec) => json.object({
     header: headerFromJson,
     extrinsic: getExtrinsicFromJson(spec),
 }, ({ header, extrinsic }) => Block.create({ header, extrinsic }));
+const blockViewFromJson = (spec) => {
+    const parseBlock = blockFromJson(spec);
+    return json.fromAny((p) => {
+        const block = parse_parseFromJson(p, parseBlock);
+        return reencodeAsView(Block.Codec, block, spec);
+    });
+};
 
 ;// CONCATENATED MODULE: ./packages/jam/block-json/index.ts
 
@@ -11663,13 +11674,13 @@ const getStateCodec = codec_codec.bytes(hash_HASH_SIZE).asOpaque();
 /** StateRoot ::= StateRootHash */
 const stateRootCodec = codec_codec.bytes(hash_HASH_SIZE).asOpaque();
 /** Error ::= UTF8String */
-class ErrorMessage extends WithDebug {
+class types_ErrorMessage extends WithDebug {
     message;
-    static Codec = codec_codec.Class(ErrorMessage, {
+    static Codec = codec_codec.Class(types_ErrorMessage, {
         message: codec_codec.string,
     });
     static create({ message }) {
-        return new ErrorMessage(message);
+        return new types_ErrorMessage(message);
     }
     constructor(message) {
         super();
@@ -11723,7 +11734,7 @@ const types_messageCodec = codec_codec.custom({
             stateCodec.encode(e, msg.value);
             break;
         case types_MessageType.Error:
-            ErrorMessage.Codec.encode(e, msg.value);
+            types_ErrorMessage.Codec.encode(e, msg.value);
             break;
         default:
             throw new Error(`Unknown message type: ${msg}`);
@@ -11744,7 +11755,7 @@ const types_messageCodec = codec_codec.custom({
         case types_MessageType.State:
             return { type: types_MessageType.State, value: stateCodec.decode(d) };
         case types_MessageType.Error:
-            return { type: types_MessageType.Error, value: ErrorMessage.Codec.decode(d) };
+            return { type: types_MessageType.Error, value: types_ErrorMessage.Codec.decode(d) };
         default:
             throw new Error(`Unknown message type: ${type}`);
     }
@@ -11770,7 +11781,7 @@ const types_messageCodec = codec_codec.custom({
             stateCodec.View.skip(s);
             break;
         case types_MessageType.Error:
-            ErrorMessage.Codec.View.skip(s);
+            types_ErrorMessage.Codec.View.skip(s);
             break;
         default:
             throw new Error(`Unknown message type: ${type}`);
@@ -11833,35 +11844,59 @@ class FuzzTarget {
                 break;
             }
             case MessageType.Initialize: {
-                const stateRoot = await this.msgHandler.initialize(message.value);
-                response = {
-                    type: MessageType.StateRoot,
-                    value: stateRoot,
-                };
-                break;
-            }
-            case MessageType.ImportBlock: {
-                const result = await this.msgHandler.importBlock(message.value);
-                if (result.isOk) {
+                try {
+                    const stateRoot = await this.msgHandler.initialize(message.value);
                     response = {
                         type: MessageType.StateRoot,
-                        value: result.ok,
+                        value: stateRoot,
                     };
                 }
-                else {
+                catch (e) {
                     response = {
                         type: MessageType.Error,
-                        value: result.error,
+                        value: ErrorMessage.create({ message: `initialize error: ${e}` }),
+                    };
+                }
+                break;
+            }
+            case MessageType.ImportBlock: {
+                try {
+                    const result = await this.msgHandler.importBlock(message.value);
+                    if (result.isOk) {
+                        response = {
+                            type: MessageType.StateRoot,
+                            value: result.ok,
+                        };
+                    }
+                    else {
+                        response = {
+                            type: MessageType.Error,
+                            value: result.error,
+                        };
+                    }
+                }
+                catch (e) {
+                    response = {
+                        type: MessageType.Error,
+                        value: ErrorMessage.create({ message: `importBlock error: ${e}` }),
                     };
                 }
                 break;
             }
             case MessageType.GetState: {
-                const state = await this.msgHandler.getSerializedState(message.value);
-                response = {
-                    type: MessageType.State,
-                    value: state,
-                };
+                try {
+                    const state = await this.msgHandler.getSerializedState(message.value);
+                    response = {
+                        type: MessageType.State,
+                        value: state,
+                    };
+                }
+                catch (e) {
+                    response = {
+                        type: MessageType.Error,
+                        value: ErrorMessage.create({ message: `getState error: ${e}` }),
+                    };
+                }
                 break;
             }
             case MessageType.StateRoot: {
@@ -16064,11 +16099,11 @@ class StateTransition {
     static fromJson = {
         pre_state: TestState.fromJson,
         post_state: TestState.fromJson,
-        block: blockFromJson(chain_spec_tinyChainSpec),
+        block: blockViewFromJson(chain_spec_tinyChainSpec),
     };
     static Codec = codec_codec.object({
         pre_state: TestState.Codec,
-        block: Block.Codec,
+        block: Block.Codec.View,
         post_state: TestState.Codec,
     });
     pre_state;
@@ -20272,7 +20307,7 @@ const SUPPORTED_TYPES = [
                 if (option === "as-block") {
                     return looseType({
                         encode: Block.Codec,
-                        value: test.block,
+                        value: test.block.materialize(),
                     });
                 }
                 if (option === "as-fuzz-message") {
@@ -20280,11 +20315,9 @@ const SUPPORTED_TYPES = [
                     console.warn("⚠️  Warning: 'as-fuzz-message' is deprecated and will be removed in version 0.6.0. Use 'as-block-fuzz-message' instead.");
                 }
                 if (option === "as-block-fuzz-message" || option === "as-fuzz-message") {
-                    const encoded = encoder_Encoder.encodeObject(Block.Codec, test.block, spec);
-                    const blockView = decoder_Decoder.decodeObject(Block.Codec.View, encoded, spec);
                     const msg = {
                         type: types_MessageType.ImportBlock,
-                        value: blockView,
+                        value: test.block,
                     };
                     return looseType({
                         value: msg,
@@ -20292,13 +20325,14 @@ const SUPPORTED_TYPES = [
                     });
                 }
                 if (option === "as-state-fuzz-message") {
+                    const blockHeader = test.block.header.materialize();
                     const init = Initialize.create({
                         header: header_Header.empty(),
                         keyvals: test.pre_state.keyvals,
                         ancestry: [
                             AncestryItem.create({
-                                headerHash: test.block.header.parentHeaderHash,
-                                slot: common_tryAsTimeSlot(Math.max(0, test.block.header.timeSlotIndex - 1)),
+                                headerHash: blockHeader.parentHeaderHash,
+                                slot: common_tryAsTimeSlot(Math.max(0, blockHeader.timeSlotIndex - 1)),
                             }),
                         ],
                     });