@typeberry/native 0.0.1-64ee5ed

package/index.js

@@ -0,0 +1,555 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function.");
+});
+
+//#endregion
+//#region \0wasmHelpers.js
+function _loadWasmModule(sync, filepath, src, imports) {
+	function _instantiateOrCompile(source, imports$1, stream) {
+		var instantiateFunc = stream ? WebAssembly.instantiateStreaming : WebAssembly.instantiate;
+		var compileFunc = stream ? WebAssembly.compileStreaming : WebAssembly.compile;
+		if (imports$1) return instantiateFunc(source, imports$1);
+		else return compileFunc(source);
+	}
+	var buf = null;
+	var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+	if (filepath && isNode) {
+		var fs = __require("fs");
+		var path = __require("path");
+		return new Promise((resolve, reject) => {
+			fs.readFile(path.resolve(__dirname, filepath), (error, buffer) => {
+				if (error != null) reject(error);
+				else resolve(_instantiateOrCompile(buffer, imports, false));
+			});
+		});
+	} else if (filepath) return _instantiateOrCompile(fetch(filepath), imports, true);
+	if (isNode) buf = Buffer.from(src, "base64");
+	else {
+		var raw = globalThis.atob(src);
+		var rawLength = raw.length;
+		buf = new Uint8Array(new ArrayBuffer(rawLength));
+		for (var i = 0; i < rawLength; i++) buf[i] = raw.charCodeAt(i);
+	}
+	if (sync) {
+		var mod = new WebAssembly.Module(buf);
+		return imports ? new WebAssembly.Instance(mod, imports) : mod;
+	} else return _instantiateOrCompile(buf, imports, false);
+}
+
+//#endregion
+//#region bandersnatch/pkg/bandersnatch_bg.wasm
+var bandersnatch_bg_exports = {};
+__export(bandersnatch_bg_exports, { default: () => bandersnatch_bg_default });
+function bandersnatch_bg_default(imports) {
+	return _loadWasmModule(0, "6cfc4680c1b51f91.wasm", null, imports);
+}
+
+//#endregion
+//#region bandersnatch/pkg/bandersnatch_bg.js
+let wasm$2;
+function __wbg_set_wasm$2(val) {
+	wasm$2 = val;
+}
+let cachedUint8Memory0 = null;
+function getUint8Memory0() {
+	if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) cachedUint8Memory0 = new Uint8Array(wasm$2.memory.buffer);
+	return cachedUint8Memory0;
+}
+let WASM_VECTOR_LEN$1 = 0;
+function passArray8ToWasm0$1(arg, malloc) {
+	const ptr = malloc(arg.length * 1, 1) >>> 0;
+	getUint8Memory0().set(arg, ptr / 1);
+	WASM_VECTOR_LEN$1 = arg.length;
+	return ptr;
+}
+let cachedInt32Memory0 = null;
+function getInt32Memory0() {
+	if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) cachedInt32Memory0 = new Int32Array(wasm$2.memory.buffer);
+	return cachedInt32Memory0;
+}
+function getArrayU8FromWasm0$1(ptr, len) {
+	ptr = ptr >>> 0;
+	return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
+}
+/**
+* @param {Uint8Array} keys
+* @returns {Uint8Array}
+*/
+function ring_commitment(keys) {
+	try {
+		const retptr = wasm$2.__wbindgen_add_to_stack_pointer(-16);
+		const ptr0 = passArray8ToWasm0$1(keys, wasm$2.__wbindgen_malloc);
+		const len0 = WASM_VECTOR_LEN$1;
+		wasm$2.ring_commitment(retptr, ptr0, len0);
+		var r0 = getInt32Memory0()[retptr / 4 + 0];
+		var r1 = getInt32Memory0()[retptr / 4 + 1];
+		var v2 = getArrayU8FromWasm0$1(r0, r1).slice();
+		wasm$2.__wbindgen_free(r0, r1 * 1, 1);
+		return v2;
+	} finally {
+		wasm$2.__wbindgen_add_to_stack_pointer(16);
+	}
+}
+/**
+* Derive Private and Public Key from Seed
+*
+* returns: `Vec<u8>` containing the exit (1 byte) status followed by the (32 bytes) public key
+* @param {Uint8Array} seed
+* @returns {Uint8Array}
+*/
+function derive_public_key(seed) {
+	try {
+		const retptr = wasm$2.__wbindgen_add_to_stack_pointer(-16);
+		const ptr0 = passArray8ToWasm0$1(seed, wasm$2.__wbindgen_malloc);
+		const len0 = WASM_VECTOR_LEN$1;
+		wasm$2.derive_public_key(retptr, ptr0, len0);
+		var r0 = getInt32Memory0()[retptr / 4 + 0];
+		var r1 = getInt32Memory0()[retptr / 4 + 1];
+		var v2 = getArrayU8FromWasm0$1(r0, r1).slice();
+		wasm$2.__wbindgen_free(r0, r1 * 1, 1);
+		return v2;
+	} finally {
+		wasm$2.__wbindgen_add_to_stack_pointer(16);
+	}
+}
+/**
+* Seal verification as defined in:
+* https://graypaper.fluffylabs.dev/#/68eaa1f/0eff000eff00?v=0.6.4
+* or
+* https://graypaper.fluffylabs.dev/#/68eaa1f/0e54010e5401?v=0.6.4
+* @param {Uint8Array} keys
+* @param {number} signer_key_index
+* @param {Uint8Array} seal_data
+* @param {Uint8Array} payload
+* @param {Uint8Array} aux_data
+* @returns {Uint8Array}
+*/
+function verify_seal(keys, signer_key_index, seal_data, payload, aux_data) {
+	try {
+		const retptr = wasm$2.__wbindgen_add_to_stack_pointer(-16);
+		const ptr0 = passArray8ToWasm0$1(keys, wasm$2.__wbindgen_malloc);
+		const len0 = WASM_VECTOR_LEN$1;
+		const ptr1 = passArray8ToWasm0$1(seal_data, wasm$2.__wbindgen_malloc);
+		const len1 = WASM_VECTOR_LEN$1;
+		const ptr2 = passArray8ToWasm0$1(payload, wasm$2.__wbindgen_malloc);
+		const len2 = WASM_VECTOR_LEN$1;
+		const ptr3 = passArray8ToWasm0$1(aux_data, wasm$2.__wbindgen_malloc);
+		const len3 = WASM_VECTOR_LEN$1;
+		wasm$2.verify_seal(retptr, ptr0, len0, signer_key_index, ptr1, len1, ptr2, len2, ptr3, len3);
+		var r0 = getInt32Memory0()[retptr / 4 + 0];
+		var r1 = getInt32Memory0()[retptr / 4 + 1];
+		var v5 = getArrayU8FromWasm0$1(r0, r1).slice();
+		wasm$2.__wbindgen_free(r0, r1 * 1, 1);
+		return v5;
+	} finally {
+		wasm$2.__wbindgen_add_to_stack_pointer(16);
+	}
+}
+/**
+* Verify multiple tickets at once as defined in:
+* https://graypaper.fluffylabs.dev/#/68eaa1f/0f3e000f3e00?v=0.6.4
+*
+* NOTE: the aux_data of VRF function is empty!
+* @param {Uint8Array} keys
+* @param {Uint8Array} tickets_data
+* @param {number} vrf_input_data_len
+* @returns {Uint8Array}
+*/
+function batch_verify_tickets(keys, tickets_data, vrf_input_data_len) {
+	try {
+		const retptr = wasm$2.__wbindgen_add_to_stack_pointer(-16);
+		const ptr0 = passArray8ToWasm0$1(keys, wasm$2.__wbindgen_malloc);
+		const len0 = WASM_VECTOR_LEN$1;
+		const ptr1 = passArray8ToWasm0$1(tickets_data, wasm$2.__wbindgen_malloc);
+		const len1 = WASM_VECTOR_LEN$1;
+		wasm$2.batch_verify_tickets(retptr, ptr0, len0, ptr1, len1, vrf_input_data_len);
+		var r0 = getInt32Memory0()[retptr / 4 + 0];
+		var r1 = getInt32Memory0()[retptr / 4 + 1];
+		var v3 = getArrayU8FromWasm0$1(r0, r1).slice();
+		wasm$2.__wbindgen_free(r0, r1 * 1, 1);
+		return v3;
+	} finally {
+		wasm$2.__wbindgen_add_to_stack_pointer(16);
+	}
+}
+
+//#endregion
+//#region bandersnatch/pkg/bandersnatch.js
+var bandersnatch_exports = {};
+__export(bandersnatch_exports, {
+	__wbg_set_wasm: () => __wbg_set_wasm$2,
+	batch_verify_tickets: () => batch_verify_tickets,
+	derive_public_key: () => derive_public_key,
+	ring_commitment: () => ring_commitment,
+	verify_seal: () => verify_seal
+});
+__wbg_set_wasm$2(bandersnatch_bg_exports);
+
+//#endregion
+//#region ed25519/pkg/ed25519_wasm_bg.wasm
+var ed25519_wasm_bg_exports = {};
+__export(ed25519_wasm_bg_exports, { default: () => ed25519_wasm_bg_default });
+function ed25519_wasm_bg_default(imports) {
+	return _loadWasmModule(0, "5941c010ea533d2f.wasm", null, imports);
+}
+
+//#endregion
+//#region ed25519/pkg/ed25519_wasm_bg.js
+let wasm$1;
+function __wbg_set_wasm$1(val) {
+	wasm$1 = val;
+}
+let cachedUint8ArrayMemory0$1 = null;
+function getUint8ArrayMemory0$1() {
+	if (cachedUint8ArrayMemory0$1 === null || cachedUint8ArrayMemory0$1.byteLength === 0) cachedUint8ArrayMemory0$1 = new Uint8Array(wasm$1.memory.buffer);
+	return cachedUint8ArrayMemory0$1;
+}
+let WASM_VECTOR_LEN = 0;
+function passArray8ToWasm0(arg, malloc) {
+	const ptr = malloc(arg.length * 1, 1) >>> 0;
+	getUint8ArrayMemory0$1().set(arg, ptr / 1);
+	WASM_VECTOR_LEN = arg.length;
+	return ptr;
+}
+function getArrayU8FromWasm0(ptr, len) {
+	ptr = ptr >>> 0;
+	return getUint8ArrayMemory0$1().subarray(ptr / 1, ptr / 1 + len);
+}
+/**
+*
+* * Verify Ed25519 signatures one by one using strict verification.
+* *
+* * This function is slower but does strict verification.
+*
+* @param {Uint8Array} data
+* @returns {Uint8Array}
+*/
+function verify_ed25519(data) {
+	const ptr0 = passArray8ToWasm0(data, wasm$1.__wbindgen_malloc);
+	const len0 = WASM_VECTOR_LEN;
+	const ret = wasm$1.verify_ed25519(ptr0, len0);
+	var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+	wasm$1.__wbindgen_free(ret[0], ret[1] * 1, 1);
+	return v2;
+}
+/**
+*
+* * Verify Ed25519 signatures using build-in batch verification.
+* *
+* * This function is faster but does not do strict verification.
+* * See https://crates.io/crates/ed25519-dalek#batch-verification for more information.
+*
+* @param {Uint8Array} data
+* @returns {boolean}
+*/
+function verify_ed25519_batch(data) {
+	const ptr0 = passArray8ToWasm0(data, wasm$1.__wbindgen_malloc);
+	const len0 = WASM_VECTOR_LEN;
+	return wasm$1.verify_ed25519_batch(ptr0, len0) !== 0;
+}
+function __wbindgen_init_externref_table() {
+	const table = wasm$1.__wbindgen_export_0;
+	const offset = table.grow(4);
+	table.set(0, void 0);
+	table.set(offset + 0, void 0);
+	table.set(offset + 1, null);
+	table.set(offset + 2, true);
+	table.set(offset + 3, false);
+}
+
+//#endregion
+//#region ed25519/pkg/ed25519_wasm.js
+var ed25519_wasm_exports = {};
+__export(ed25519_wasm_exports, {
+	__wbg_set_wasm: () => __wbg_set_wasm$1,
+	__wbindgen_init_externref_table: () => __wbindgen_init_externref_table,
+	verify_ed25519: () => verify_ed25519,
+	verify_ed25519_batch: () => verify_ed25519_batch
+});
+__wbg_set_wasm$1(ed25519_wasm_bg_exports);
+(void 0)();
+
+//#endregion
+//#region reed-solomon/pkg/reed_solomon_wasm_bg.wasm
+var reed_solomon_wasm_bg_exports = {};
+__export(reed_solomon_wasm_bg_exports, { default: () => reed_solomon_wasm_bg_default });
+function reed_solomon_wasm_bg_default(imports) {
+	return _loadWasmModule(0, "d8c79d763f7586dd.wasm", null, imports);
+}
+
+//#endregion
+//#region reed-solomon/pkg/reed_solomon_wasm_bg.js
+let wasm;
+function __wbg_set_wasm(val) {
+	wasm = val;
+}
+const heap = new Array(128).fill(void 0);
+heap.push(void 0, null, true, false);
+let heap_next = heap.length;
+function addHeapObject(obj) {
+	if (heap_next === heap.length) heap.push(heap.length + 1);
+	const idx = heap_next;
+	heap_next = heap[idx];
+	heap[idx] = obj;
+	return idx;
+}
+function getObject(idx) {
+	return heap[idx];
+}
+function dropObject(idx) {
+	if (idx < 132) return;
+	heap[idx] = heap_next;
+	heap_next = idx;
+}
+function takeObject(idx) {
+	const ret = getObject(idx);
+	dropObject(idx);
+	return ret;
+}
+let cachedTextDecoder = new (typeof TextDecoder === "undefined" ? (0, module.require)("util").TextDecoder : TextDecoder)("utf-8", {
+	ignoreBOM: true,
+	fatal: true
+});
+cachedTextDecoder.decode();
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+	if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+	return cachedUint8ArrayMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+	ptr = ptr >>> 0;
+	return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+function isLikeNone(x) {
+	return x === void 0 || x === null;
+}
+function _assertClass(instance, klass) {
+	if (!(instance instanceof klass)) throw new Error(`expected instance of ${klass.name}`);
+	return instance.ptr;
+}
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+	if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+	return cachedDataViewMemory0;
+}
+/**
+* @param {number} recovery_count
+* @param {ShardsCollection} shards
+* @returns {ShardsCollection}
+*/
+function encode(recovery_count, shards) {
+	try {
+		const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+		_assertClass(shards, ShardsCollection);
+		var ptr0 = shards.__destroy_into_raw();
+		wasm.encode(retptr, recovery_count, ptr0);
+		var r0 = getDataViewMemory0().getInt32(retptr + 0, true);
+		var r1 = getDataViewMemory0().getInt32(retptr + 4, true);
+		if (getDataViewMemory0().getInt32(retptr + 8, true)) throw takeObject(r1);
+		return ShardsCollection.__wrap(r0);
+	} finally {
+		wasm.__wbindgen_add_to_stack_pointer(16);
+	}
+}
+/**
+* @param {number} original_count
+* @param {number} recovery_count
+* @param {ShardsCollection} shards
+* @returns {ShardsCollection}
+*/
+function decode(original_count, recovery_count, shards) {
+	try {
+		const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+		_assertClass(shards, ShardsCollection);
+		var ptr0 = shards.__destroy_into_raw();
+		wasm.decode(retptr, original_count, recovery_count, ptr0);
+		var r0 = getDataViewMemory0().getInt32(retptr + 0, true);
+		var r1 = getDataViewMemory0().getInt32(retptr + 4, true);
+		if (getDataViewMemory0().getInt32(retptr + 8, true)) throw takeObject(r1);
+		return ShardsCollection.__wrap(r0);
+	} finally {
+		wasm.__wbindgen_add_to_stack_pointer(16);
+	}
+}
+const ShardsCollectionFinalization = typeof FinalizationRegistry === "undefined" ? {
+	register: () => {},
+	unregister: () => {}
+} : new FinalizationRegistry((ptr) => wasm.__wbg_shardscollection_free(ptr >>> 0, 1));
+/**
+* Collection of shards (either input or output).
+*
+* To efficiently pass data between JS and WASM all of the shards
+* are passed as one big vector of bytes.
+* It's assumed that every shard has the same length (`shard_len`).
+* If the shards are NOT passed in the exact order they were created
+* it's possible to pass `indices` array.
+* A value of `indices` array at position `idx` is the shard index
+* that resides at `[ idx * shard_len .. idx * shard_len + shard_len )`
+* in `data` array.
+*
+* This collection is only used to get the data from JS or pass the data back.
+* Internally we convert it to [`RsShardsCollection`], which copies
+* the memory to/from WASM.
+*/
+var ShardsCollection = class ShardsCollection {
+	static __wrap(ptr) {
+		ptr = ptr >>> 0;
+		const obj = Object.create(ShardsCollection.prototype);
+		obj.__wbg_ptr = ptr;
+		ShardsCollectionFinalization.register(obj, obj.__wbg_ptr, obj);
+		return obj;
+	}
+	__destroy_into_raw() {
+		const ptr = this.__wbg_ptr;
+		this.__wbg_ptr = 0;
+		ShardsCollectionFinalization.unregister(this);
+		return ptr;
+	}
+	free() {
+		const ptr = this.__destroy_into_raw();
+		wasm.__wbg_shardscollection_free(ptr, 0);
+	}
+	/**
+	* Number of shards within the collection.
+	* @returns {number}
+	*/
+	get length() {
+		return wasm.__wbg_get_shardscollection_length(this.__wbg_ptr) >>> 0;
+	}
+	/**
+	* Number of shards within the collection.
+	* @param {number} arg0
+	*/
+	set length(arg0) {
+		wasm.__wbg_set_shardscollection_length(this.__wbg_ptr, arg0);
+	}
+	/**
+	* The length of each shard.
+	* @returns {number}
+	*/
+	get shard_len() {
+		return wasm.__wbg_get_shardscollection_shard_len(this.__wbg_ptr);
+	}
+	/**
+	* The length of each shard.
+	* @param {number} arg0
+	*/
+	set shard_len(arg0) {
+		wasm.__wbg_set_shardscollection_shard_len(this.__wbg_ptr, arg0);
+	}
+	/**
+	* @param {number} shard_len
+	* @param {Uint8Array} data
+	* @param {Uint16Array | undefined} [indices]
+	*/
+	constructor(shard_len, data, indices) {
+		this.__wbg_ptr = wasm.shardscollection_new(shard_len, addHeapObject(data), isLikeNone(indices) ? 0 : addHeapObject(indices)) >>> 0;
+		ShardsCollectionFinalization.register(this, this.__wbg_ptr, this);
+		return this;
+	}
+	/**
+	* Extract the `indices` from this shards container.
+	*
+	* Should be called on the JS side to avoid copying.
+	* NOTE that subsequent calls to that method will return `None`.
+	* @returns {Uint16Array | undefined}
+	*/
+	take_indices() {
+		const ret = wasm.shardscollection_take_indices(this.__wbg_ptr);
+		return takeObject(ret);
+	}
+	/**
+	* Take the underlying `data` to the JS side.
+	*
+	* NOTE this object is destroyed after the data is consumed,
+	* so make sure to [`take_indices`] first.
+	* @returns {Uint8Array}
+	*/
+	take_data() {
+		const ptr = this.__destroy_into_raw();
+		const ret = wasm.shardscollection_take_data(ptr);
+		return takeObject(ret);
+	}
+};
+function __wbindgen_memory() {
+	const ret = wasm.memory;
+	return addHeapObject(ret);
+}
+function __wbg_buffer_b7b08af79b0b0974(arg0) {
+	const ret = getObject(arg0).buffer;
+	return addHeapObject(ret);
+}
+function __wbg_newwithbyteoffsetandlength_8a2cb9ca96b27ec9(arg0, arg1, arg2) {
+	const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+	return addHeapObject(ret);
+}
+function __wbindgen_object_drop_ref(arg0) {
+	takeObject(arg0);
+}
+function __wbg_new_ea1883e1e5e86686(arg0) {
+	const ret = new Uint8Array(getObject(arg0));
+	return addHeapObject(ret);
+}
+function __wbg_newwithbyteoffsetandlength_bd3d5191e8925067(arg0, arg1, arg2) {
+	const ret = new Uint16Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+	return addHeapObject(ret);
+}
+function __wbg_new_51798470384ee5a8(arg0) {
+	const ret = new Uint16Array(getObject(arg0));
+	return addHeapObject(ret);
+}
+function __wbg_length_8339fcf5d8ecd12e(arg0) {
+	return getObject(arg0).length;
+}
+function __wbg_length_ff22981e43417ccf(arg0) {
+	return getObject(arg0).length;
+}
+function __wbindgen_string_new(arg0, arg1) {
+	const ret = getStringFromWasm0(arg0, arg1);
+	return addHeapObject(ret);
+}
+function __wbg_set_d1e79e2388520f18(arg0, arg1, arg2) {
+	getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+}
+function __wbg_set_e83c20bbf4b38a6b(arg0, arg1, arg2) {
+	getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+}
+function __wbindgen_throw(arg0, arg1) {
+	throw new Error(getStringFromWasm0(arg0, arg1));
+}
+
+//#endregion
+//#region reed-solomon/pkg/reed_solomon_wasm.js
+var reed_solomon_wasm_exports = {};
+__export(reed_solomon_wasm_exports, {
+	ShardsCollection: () => ShardsCollection,
+	__wbg_buffer_b7b08af79b0b0974: () => __wbg_buffer_b7b08af79b0b0974,
+	__wbg_length_8339fcf5d8ecd12e: () => __wbg_length_8339fcf5d8ecd12e,
+	__wbg_length_ff22981e43417ccf: () => __wbg_length_ff22981e43417ccf,
+	__wbg_new_51798470384ee5a8: () => __wbg_new_51798470384ee5a8,
+	__wbg_new_ea1883e1e5e86686: () => __wbg_new_ea1883e1e5e86686,
+	__wbg_newwithbyteoffsetandlength_8a2cb9ca96b27ec9: () => __wbg_newwithbyteoffsetandlength_8a2cb9ca96b27ec9,
+	__wbg_newwithbyteoffsetandlength_bd3d5191e8925067: () => __wbg_newwithbyteoffsetandlength_bd3d5191e8925067,
+	__wbg_set_d1e79e2388520f18: () => __wbg_set_d1e79e2388520f18,
+	__wbg_set_e83c20bbf4b38a6b: () => __wbg_set_e83c20bbf4b38a6b,
+	__wbg_set_wasm: () => __wbg_set_wasm,
+	__wbindgen_memory: () => __wbindgen_memory,
+	__wbindgen_object_drop_ref: () => __wbindgen_object_drop_ref,
+	__wbindgen_string_new: () => __wbindgen_string_new,
+	__wbindgen_throw: () => __wbindgen_throw,
+	decode: () => decode,
+	encode: () => encode
+});
+__wbg_set_wasm(reed_solomon_wasm_bg_exports);
+
+//#endregion
+export { bandersnatch_exports as bandersnatch, ed25519_wasm_exports as ed25519, reed_solomon_wasm_exports as reedSolomon };

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@typeberry/native",
+  "version": "0.0.1-64ee5ed",
+  "main": "./index.js",
+  "type": "module",
+  "author": "Fluffy Labs",
+  "license": "MPL-2.0",
+  "scripts": {
+    "lint": "true",
+    "test": "true",
+    "build": "true"
+  }
+}