@typeberry/convert 0.1.2-7ebe1f6 → 0.1.2-ced735c9

package/index.js

@@ -4477,7 +4477,7 @@ function assert (t, m) {
 
 /***/ }),
 
-/***/ 405:
+/***/ 786:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 module.exports = __nccwpck_require__.p + "6b655f8772c01b768329.js?bandersnatch_bg.wasm";
@@ -4605,8 +4605,6 @@ module.exports = __nccwpck_require__.p + "ccf8ada94096a8f232f5.js?reed_solomon_w
 /************************************************************************/
 var __webpack_exports__ = {};
 
-;// CONCATENATED MODULE: external "node:url"
-const external_node_url_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:url");
 ;// CONCATENATED MODULE: ./packages/core/logger/options.ts
 var Level;
 (function (Level) {
@@ -4697,8 +4695,8 @@ function print(level, levelAndName, strings, data) {
         return;
     }
     const lvlText = Level[level].padEnd(5);
-    const val = strings.map((v, idx) => `${v}${idx < data.length ? data[idx] : ""}`);
-    const msg = `${lvlText} [${levelAndName[1]}] ${val.join("")}`;
+    const val = strings.map((v, idx) => `${v}${data[idx]}`);
+    const msg = `${lvlText} [${levelAndName[1]}] ${val}`;
     if (level === Level.WARN) {
         console.warn(msg);
     }
@@ -7599,7 +7597,7 @@ async function __wbg_init$2(module_or_path) {
 	if (wasm$2 !== void 0) return wasm$2;
 	if (typeof module_or_path !== "undefined") if (Object.getPrototypeOf(module_or_path) === Object.prototype) ({module_or_path} = module_or_path);
 	else console.warn("using deprecated parameters for the initialization function; pass a single object instead");
-	if (typeof module_or_path === "undefined") module_or_path = new URL(/* asset import */ __nccwpck_require__(405), __nccwpck_require__.b);
+	if (typeof module_or_path === "undefined") module_or_path = new URL(/* asset import */ __nccwpck_require__(786), __nccwpck_require__.b);
 	const imports = __wbg_get_imports$2();
 	if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) module_or_path = fetch(module_or_path);
 	__wbg_init_memory$2(imports);
@@ -17475,17 +17473,6 @@ class page_range_PageRange {
         }
         return new page_range_PageRange(start, length);
     }
-    /** Returns true if the page range is wrapped (`start` >= `end`) and is not empty */
-    isWrapped() {
-        return this.start >= this.end && !this.isEmpty();
-    }
-    /** Checks if given page number is within the range */
-    isInRange(page) {
-        if (this.isWrapped()) {
-            return page >= this.start || page < this.end;
-        }
-        return page >= this.start && page < this.end;
-    }
     /** Checks if a range is empty (`length === 0`) */
     isEmpty() {
         return this.length === 0;
@@ -17865,11 +17852,10 @@ class memory_builder_MemoryBuilder {
       startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})
     `;
         this.ensureNotFinalized();
-        const heapRange = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
-        const heapPagesRange = PageRange.fromMemoryRange(heapRange);
-        const initializedPageNumbers = Array.from(this.initialMemory.keys());
-        for (const pageNumber of initializedPageNumbers) {
-            if (heapPagesRange.isInRange(pageNumber)) {
+        const range = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
+        const pages = PageRange.fromMemoryRange(range);
+        for (const pageNumber of pages) {
+            if (this.initialMemory.has(pageNumber)) {
                 throw new IncorrectSbrkIndex();
             }
         }
@@ -26823,12 +26809,6 @@ async function runPvmTest(testContent) {
 
 
 
-function looseType(output) {
-    return {
-        value: output.value,
-        encode: output.encode,
-    };
-}
 const SUPPORTED_TYPES = [
     {
         name: "block",
@@ -26846,12 +26826,8 @@ const SUPPORTED_TYPES = [
             run(spec, data, option) {
                 const header = data;
                 if (option === "as-hash") {
-                    return looseType({
-                        value: hashBytes(encoder_Encoder.encodeObject(header_Header.Codec, header, spec)),
-                        encode: descriptors_codec.bytes(hash_HASH_SIZE),
-                    });
+                    return hashBytes(encoder_Encoder.encodeObject(header_Header.Codec, header, spec));
                 }
-                throw new Error(`Invalid processing option: ${option}`);
             },
         },
     },
@@ -26895,17 +26871,11 @@ const SUPPORTED_TYPES = [
             run(spec, data, option) {
                 const state = data;
                 if (option === "as-entries") {
-                    return looseType({
-                        value: Object.fromEntries(state_entries_StateEntries.serializeInMemory(spec, state)),
-                    });
+                    return Object.fromEntries(state_entries_StateEntries.serializeInMemory(spec, state));
                 }
                 if (option === "as-root-hash") {
-                    return looseType({
-                        value: state_entries_StateEntries.serializeInMemory(spec, state).getRootHash(),
-                        encode: descriptors_codec.bytes(hash_HASH_SIZE),
-                    });
+                    return state_entries_StateEntries.serializeInMemory(spec, state).getRootHash();
                 }
-                throw new Error(`Invalid processing option: ${option}`);
             },
         },
     },
@@ -26915,39 +26885,19 @@ const SUPPORTED_TYPES = [
         decode: StateTransitionGenesis.Codec,
         json: () => StateTransitionGenesis.fromJson,
         process: {
-            options: ["as-state", "as-jip4", "as-fuzz-message"],
+            options: ["as-state", "as-jip4"],
             run(spec, data, option) {
                 const test = data;
                 if (option === "as-state") {
-                    return looseType({
-                        value: stateFromKeyvals(spec, test.state),
-                    });
+                    return stateFromKeyvals(spec, test.state);
                 }
                 if (option === "as-jip4") {
                     const genesisState = new Map(test.state.keyvals.map((x) => [x.key, x.value]));
-                    return looseType({
-                        value: JipChainSpec.create({
-                            genesisHeader: encoder_Encoder.encodeObject(header_Header.Codec, test.header, spec),
-                            genesisState,
-                        }),
+                    return JipChainSpec.create({
+                        genesisHeader: encoder_Encoder.encodeObject(header_Header.Codec, test.header, spec),
+                        genesisState,
                     });
                 }
-                if (option === "as-fuzz-message") {
-                    const init = Initialize.create({
-                        header: test.header,
-                        keyvals: test.state.keyvals,
-                        ancestry: [],
-                    });
-                    const msg = {
-                        type: types_MessageType.Initialize,
-                        value: init,
-                    };
-                    return looseType({
-                        value: msg,
-                        encode: types_messageCodec,
-                    });
-                }
-                throw new Error(`Invalid processing option: ${option}`);
             },
         },
     },
@@ -26957,32 +26907,15 @@ const SUPPORTED_TYPES = [
         decode: StateTransition.Codec,
         json: () => StateTransition.fromJson,
         process: {
-            options: ["as-pre-state", "as-post-state", "as-fuzz-message"],
+            options: ["as-pre-state", "as-post-state"],
             run(spec, data, option) {
                 const test = data;
                 if (option === "as-pre-state") {
-                    return looseType({
-                        value: stateFromKeyvals(spec, test.pre_state),
-                    });
+                    return stateFromKeyvals(spec, test.pre_state);
                 }
                 if (option === "as-post-state") {
-                    return looseType({
-                        value: stateFromKeyvals(spec, test.post_state),
-                    });
-                }
-                if (option === "as-fuzz-message") {
-                    const encoded = encoder_Encoder.encodeObject(block_Block.Codec, test.block, spec);
-                    const blockView = decoder_Decoder.decodeObject(block_Block.Codec.View, encoded, spec);
-                    const msg = {
-                        type: types_MessageType.ImportBlock,
-                        value: blockView,
-                    };
-                    return looseType({
-                        value: msg,
-                        encode: types_messageCodec,
-                    });
+                    return stateFromKeyvals(spec, test.post_state);
                 }
-                throw new Error(`Invalid processing option: ${option}`);
             },
         },
     },
@@ -27005,7 +26938,7 @@ const HELP = `
 @typeberry/convert ${package_namespaceObject.rE} by Fluffy Labs.
 
 Usage:
-  @typeberry/convert [options] <bin-hex-or-json-input-file> <type> [process] [output-format] [output-file]
+  @typeberry/convert [options] <bin-hex-or-json-input-file> <type> [process] [output-format]
 
 Attempts to read provided input file as 'type' and output in requested 'output-format'.
 For some 'type's it's additionally possible to process the data before outputting it.
@@ -27014,7 +26947,6 @@ The input type is detected from file extension ('.bin', '.hex' or '.json').
 Example usage:
   @typeberry/convert ./genesis-header.json header to-hex
   @typeberry/convert ./state-snapshot.json state-dump as-entries to-json
-  @typeberry/convert ./state-snapshot.json stf-vector as-fuzz-message to-bin msg0.bin
 
 Options:
   --flavor    - chain spec flavor, either 'full' or 'tiny'.
@@ -27024,7 +26956,6 @@ Output formats:
   to-print       - Print the object to the console
   to-json        - JSON format (when supported)
   to-hex         - JAM-codec hex-encoded string (when supported)
-  to-bin         - JAM-codec binary data (when supported)
   to-repl        - Start a JavaScript REPL with the data loaded into a variable
 
 Input types:
@@ -27047,7 +26978,6 @@ var OutputFormat;
     OutputFormat["Print"] = "to-print";
     OutputFormat["Json"] = "to-json";
     OutputFormat["Hex"] = "to-hex";
-    OutputFormat["Bin"] = "to-bin";
     OutputFormat["Repl"] = "to-repl";
 })(OutputFormat || (OutputFormat = {}));
 function parseArgs(cliInput, withRelPath) {
@@ -27069,16 +26999,14 @@ function parseArgs(cliInput, withRelPath) {
     const type = parseType(args._.shift());
     const maybeProcess = args._.shift();
     const maybeOutputFormat = args._.shift();
-    const maybeDestination = args._.shift();
     assertNoMoreArgs(args);
-    const { process, format, destination } = getProcessFormatAndDestination(type, maybeProcess, maybeOutputFormat, maybeDestination);
+    const { process, format } = getProcessAndOutput(type, maybeProcess, maybeOutputFormat);
     return {
         flavor: chainSpec.flavor,
         type,
         process,
         inputPath: withRelPath(input),
         outputFormat: format,
-        destination,
     };
 }
 function parseType(type) {
@@ -27104,21 +27032,10 @@ function parseOutputFormat(output) {
             return OutputFormat.Json;
         case OutputFormat.Repl:
             return OutputFormat.Repl;
-        case OutputFormat.Bin:
-            return OutputFormat.Bin;
         default:
             throw new Error(`Invalid output format: '${output}'.`);
     }
 }
-function parseProcess(processOptions, maybeProcess) {
-    if (maybeProcess === undefined) {
-        return null;
-    }
-    if (!processOptions.includes(maybeProcess)) {
-        throw new Error(`Incorrect processing option: ${maybeProcess}. Expected one of: ${processOptions}.`);
-    }
-    return maybeProcess;
-}
 // TODO [ToDr] Consider sharing that?
 function parseOption(args, option, parser, defaultValue) {
     if (args[option] === undefined) {
@@ -27154,64 +27071,33 @@ function assertNoMoreArgs(args) {
         throw new Error(`Unrecognized options: '${keysLeft}'`);
     }
 }
-function getProcessFormatAndDestination(type, maybeProcess, maybeOutputFormat, maybeDestination) {
-    const defaultProcess = "";
+function getProcessAndOutput(type, maybeProcess, maybeOutputFormat) {
     const defaultFormat = parseOutputFormat(undefined);
-    const processOptions = type.process?.options ?? [];
-    // we have all three so it must be in order
-    if (maybeProcess !== undefined && maybeOutputFormat !== undefined && maybeDestination !== undefined) {
-        const format = parseOutputFormat(maybeOutputFormat);
-        const process = parseProcess(processOptions, maybeProcess) ?? defaultProcess;
-        const destination = maybeDestination;
-        throwIfDumpNotSupported(format, destination);
-        return { process, format, destination };
-    }
-    // we have either:
-    // 1. process + format
-    // 2. format + destination
+    const options = type.process?.options ?? [];
+    // we have both options, so we expect them in the right order.
     if (maybeProcess !== undefined && maybeOutputFormat !== undefined) {
-        // we've got processing first, so easy-peasy
-        if (processOptions.includes(maybeProcess)) {
-            const format = parseOutputFormat(maybeOutputFormat);
-            throwIfDumpNotSupported(format, null);
-            return { process: maybeProcess, format, destination: null };
-        }
-        // first one has to be format then.
-        const format = parseOutputFormat(maybeProcess);
-        const destination = maybeOutputFormat;
-        throwIfDumpNotSupported(format, destination);
-        return { process: defaultProcess, format, destination };
+        const format = parseOutputFormat(maybeOutputFormat);
+        if (!options.includes(maybeProcess)) {
+            throw new Error(`Incorrect processing option: ${maybeProcess}. Expected one of: ${options}.`);
+        }
+        return { process: maybeProcess, format };
     }
     // only one parameter, but it can be either output or processing.
-    const destination = null;
     if (maybeProcess !== undefined) {
-        if (processOptions.includes(maybeProcess)) {
-            return { process: maybeProcess, format: defaultFormat, destination };
+        if (options.includes(maybeProcess)) {
+            return { process: maybeProcess, format: defaultFormat };
         }
         // now it should be output format, but we want to give a better error message,
         // if user mispelled processing.
         try {
             const format = parseOutputFormat(maybeProcess);
-            throwIfDumpNotSupported(format, destination);
-            return { process: defaultProcess, format, destination };
+            return { process: "", format };
         }
         catch {
             throw new Error(`'${maybeProcess}' is neither output format nor processing parameter.`);
         }
     }
-    return { process: defaultProcess, format: defaultFormat, destination };
-}
-function throwIfDumpNotSupported(format, destination) {
-    if (destination !== null) {
-        if (format === OutputFormat.Print || format === OutputFormat.Repl) {
-            throw new Error(`Dumping to file is not supported for ${format}`);
-        }
-    }
-    else {
-        if (format === OutputFormat.Bin) {
-            throw new Error(`${format} requires destination file`);
-        }
-    }
+    return { process: "", format: defaultFormat };
 }
 
 // EXTERNAL MODULE: ./node_modules/json-bigint-patch/dist/index.js
@@ -27271,13 +27157,9 @@ function loadInputFile(file, withRelPath) {
     throw new Error("Input file format unsupported.");
 }
 function dumpOutput(spec, data, type, outputFormat, args, withRelPath) {
-    const { destination } = args;
-    const dump = destination !== null
-        ? (v) => external_node_fs_default().writeFileSync(withRelPath(destination), v)
-        : (v) => console.info(v);
     switch (outputFormat) {
         case OutputFormat.Print: {
-            dump(`${debug_inspect(data)}`);
+            console.info(`${debug_inspect(data)}`);
             return;
         }
         case OutputFormat.Hex: {
@@ -27285,24 +27167,13 @@ function dumpOutput(spec, data, type, outputFormat, args, withRelPath) {
                 throw new Error(`${type.name} does not support encoding to JAM codec.`);
             }
             const encoded = encoder_Encoder.encodeObject(type.encode, data, spec);
-            dump(`${encoded}`);
-            return;
-        }
-        case OutputFormat.Bin: {
-            if (type.encode === undefined) {
-                throw new Error(`${type.name} does not support encoding to JAM codec.`);
-            }
-            if (destination === null) {
-                throw new Error(`${OutputFormat.Bin} requires destination file.`);
-            }
-            const encoded = encoder_Encoder.encodeObject(type.encode, data, spec);
-            dump(encoded.raw);
+            console.info(`${encoded}`);
             return;
         }
         case OutputFormat.Json: {
             // TODO [ToDr] this will probably not work for all cases,
             // but for now may be good enough.
-            dump(toJson(data));
+            console.info(toJson(data));
             return;
         }
         case OutputFormat.Repl: {
@@ -27379,14 +27250,12 @@ function processOutput(spec, data, type, process) {
     if (type.process === undefined || !type.process.options.includes(process)) {
         throw new Error(`Unsupported processing: '${process}' for '${type.name}'`);
     }
-    const processed = type.process.run(spec, data, process);
     return {
-        processed: processed.value,
+        processed: type.process.run(spec, data, process),
         type: {
             ...type,
-            name: `${type.name}(${process})`,
-            // use encoding from processed type
-            encode: processed.encode,
+            // disable encoding, since it won't match
+            encode: undefined,
         },
     };
 }
@@ -27423,26 +27292,23 @@ function loadAndProcessDataFile(file, withRelPath, flavor, decodeType, process)
 
 
 
-
-if (import.meta.url === (0,external_node_url_namespaceObject.pathToFileURL)(process.argv[1]).href) {
-    Logger.configureAll(process.env.JAM_LOG ?? "", Level.LOG);
-    const withRelPath = workspacePathFix(`${import.meta.dirname}/../..`);
-    let args;
-    try {
-        args = parseArgs(process.argv.slice(2), withRelPath);
-    }
-    catch (e) {
-        console.error(`\n${e}\n`);
-        console.info(HELP);
-        process.exit(1);
-    }
-    try {
-        main(args, withRelPath);
-    }
-    catch (e) {
-        console.error(`${e}`);
-        process.exit(-1);
-    }
+Logger.configureAll(process.env.JAM_LOG ?? "", Level.LOG);
+const withRelPath = workspacePathFix(`${import.meta.dirname}/../..`);
+let args;
+try {
+    args = parseArgs(process.argv.slice(2), withRelPath);
+}
+catch (e) {
+    console.error(`\n${e}\n`);
+    console.info(HELP);
+    process.exit(1);
+}
+try {
+    main(args, withRelPath);
+}
+catch (e) {
+    console.error(`${e}`);
+    process.exit(-1);
 }