@typeberry/convert 0.5.3 → 0.5.4

package/index.js

@@ -4956,7 +4956,7 @@ function isResult(x) {
 var minimist = __nccwpck_require__(595);
 var minimist_default = /*#__PURE__*/__nccwpck_require__.n(minimist);
 ;// CONCATENATED MODULE: ./bin/convert/package.json
-const package_namespaceObject = {"rE":"0.5.3"};
+const package_namespaceObject = {"rE":"0.5.4"};
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 
 /**
@@ -5346,7 +5346,7 @@ const bytesBlobComparator = (a, b) => a.compare(b);
 const asTypedNumber = (v) => v;
 const MAX_VALUE_U8 = 0xff;
 const MAX_VALUE_U16 = 0xffff;
-const MAX_VALUE_U32 = 0xffff_ffff;
+const numbers_MAX_VALUE_U32 = 0xffff_ffff;
 const MAX_VALUE_U64 = 0xffffffffffffffffn;
 /** Attempt to cast an input number into U8. */
 const tryAsU8 = (v) => {
@@ -5368,7 +5368,7 @@ const numbers_tryAsU32 = (v) => {
     return asTypedNumber(v);
 };
 /** Check if given number is a valid U32 number. */
-const isU32 = (v) => (v & MAX_VALUE_U32) >>> 0 === v;
+const isU32 = (v) => (v & numbers_MAX_VALUE_U32) >>> 0 === v;
 /** Attempt to cast an input number into U64. */
 const numbers_tryAsU64 = (x) => {
     const v = BigInt(x);
@@ -7743,6 +7743,7 @@ const ZERO_HASH = bytes_Bytes.zero(hash_HASH_SIZE);
 class WithHash extends WithDebug {
     hash;
     data;
+    // TODO [ToDr] use static method and make constructor private
     constructor(hash, data) {
         super();
         this.hash = hash;
@@ -9751,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. */
@@ -9859,6 +9864,12 @@ class WorkExecResult extends WithDebug {
         }
         return { kind: x.kind };
     }, (x) => new WorkExecResult(x.kind, x.kind === WorkExecResultKind.ok ? x.okBlob : null));
+    static ok(blob) {
+        return new WorkExecResult(WorkExecResultKind.ok, blob);
+    }
+    static error(kind) {
+        return new WorkExecResult(kind, null);
+    }
     constructor(
     /** The execution result tag. */
     kind, 
@@ -10949,22 +10960,22 @@ const workExecResultFromJson = json.object({
 }, (val) => {
     const { ok, out_of_gas, panic, bad_code, code_oversize, output_oversize } = val;
     if (ok !== undefined) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.ok), ok);
+        return WorkExecResult.ok(ok);
     }
     if (out_of_gas === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.outOfGas));
+        return WorkExecResult.error(WorkExecResultKind.outOfGas);
     }
     if (panic === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.panic));
+        return WorkExecResult.error(WorkExecResultKind.panic);
     }
     if (bad_code === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.badCode));
+        return WorkExecResult.error(WorkExecResultKind.badCode);
     }
     if (code_oversize === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.codeOversize));
+        return WorkExecResult.error(WorkExecResultKind.codeOversize);
     }
     if (output_oversize === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.digestTooBig));
+        return WorkExecResult.error(WorkExecResultKind.digestTooBig);
     }
     throw new Error("Invalid WorkExecResult");
 });
@@ -11162,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
 
@@ -11656,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();
@@ -11716,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}`);
@@ -11737,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}`);
     }
@@ -11763,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}`);
@@ -11826,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: {
@@ -12314,13 +12356,6 @@ function hashComparator(a, b) {
     return a.compare(b);
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/ops/math-consts.ts
-const math_consts_MAX_VALUE = 4294967295;
-const math_consts_MAX_VALUE_U64 = (/* unused pure expression or super */ null && (2n ** 63n));
-const math_consts_MIN_VALUE = (/* unused pure expression or super */ null && (-(2 ** 31)));
-const math_consts_MAX_SHIFT_U32 = 32;
-const math_consts_MAX_SHIFT_U64 = 64n;
-
 ;// CONCATENATED MODULE: ./packages/jam/state/recent-blocks.ts
 
 
@@ -13300,7 +13335,6 @@ class UpdateStorage {
 
 
 
-
 
 
 var UpdateError;
@@ -13733,7 +13767,7 @@ class InMemoryState extends WithDebug {
                 manager: tryAsServiceId(0),
                 assigners: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
                 delegator: tryAsServiceId(0),
-                registrar: tryAsServiceId(math_consts_MAX_VALUE),
+                registrar: tryAsServiceId(numbers_MAX_VALUE_U32),
                 autoAccumulateServices: new Map(),
             }),
             accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
@@ -16065,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;
@@ -17893,22 +17927,22 @@ class memory_builder_MemoryBuilder {
  * Overflowing addition for two-complement representation of 32-bit signed numbers.
  */
 function math_utils_addWithOverflowU32(a, b) {
-    if (a > MAX_VALUE - b) {
+    if (a > MAX_VALUE_U32 - b) {
         /**
-         * MAX_VALUE is equal to 2 ** 32 - 1
-         * MAX_VALUE - ( (MAX_VALUE - a) + (MAX_VALUE - b) ) - 1
-         * = MAX_VALUE - (2MAX_VALUE - a - b) -1
-         * = MAX_VALUE - 2MAX_VALUE + a + b - 1
-         * = a + b - MAX_VALUE - 1
+         * MAX_VALUE_U32 is equal to 2 ** 32 - 1
+         * MAX_VALUE_U32 - ( (MAX_VALUE_U32 - a) + (MAX_VALUE_U32 - b) ) - 1
+         * = MAX_VALUE_U32 - (2MAX_VALUE_U32 - a - b) -1
+         * = MAX_VALUE_U32 - 2MAX_VALUE_U32 + a + b - 1
+         * = a + b - MAX_VALUE_U32 - 1
          * = a + b - 2 ** 32
-         * but we know that 2MAX_VALUE > a + b > MAX_VALUE so in this case:
+         * but we know that 2MAX_VALUE_U32 > a + b > MAX_VALUE_U32 so in this case:
          * a + b - 2 ** 32 <=> (a + b) % 2 ** 32
-         * = (a + b) % (MAX_VALUE + 1)
+         * = (a + b) % (MAX_VALUE_U32 + 1)
          */
-        const spaceToMaxA = MAX_VALUE - a;
-        const spaceToMaxB = MAX_VALUE - b;
+        const spaceToMaxA = MAX_VALUE_U32 - a;
+        const spaceToMaxB = MAX_VALUE_U32 - b;
         const overflowSum = spaceToMaxA + spaceToMaxB;
-        return MAX_VALUE - overflowSum - 1;
+        return MAX_VALUE_U32 - overflowSum - 1;
     }
     return a + b;
 }
@@ -17923,7 +17957,7 @@ function math_utils_addWithOverflowU64(a, b) {
  */
 function math_utils_subU32(a, b) {
     if (b > a) {
-        return MAX_VALUE - b + a + 1;
+        return MAX_VALUE_U32 - b + a + 1;
     }
     return a - b;
 }
@@ -18509,7 +18543,7 @@ class math_ops_MathOps {
         if (this.regs.getLowerU32(secondIndex) === 0) {
             this.regs.setU64(resultIndex, 2n ** 64n - 1n);
         }
-        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE) {
+        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE_I32) {
             this.regs.setU64(resultIndex, signExtend32To64(this.regs.getLowerU32(firstIndex)));
         }
         else {
@@ -18547,7 +18581,7 @@ class math_ops_MathOps {
         if (this.regs.getLowerU32(secondIndex) === 0) {
             this.regs.setU64(resultIndex, BigInt(this.regs.getLowerI32(firstIndex)));
         }
-        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE) {
+        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE_I32) {
             this.regs.setU64(resultIndex, 0n);
         }
         else {
@@ -20273,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") {
@@ -20281,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,
@@ -20293,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)),
                             }),
                         ],
                     });