@haneullabs/walrus-wasm 0.1.0

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@haneullabs/walrus-wasm",
+  "collaborators": [
+    "jonaslindstrom"
+  ],
+  "version": "0.1.0",
+  "private": false,
+  "main": "index.js",
+  "types": "./web/walrus_wasm.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GeunhwaJeong/haneul-ts-sdks.git"
+  },
+  "exports": {
+    ".": {
+      "types": "./web/walrus_wasm.d.ts",
+      "browser": "./web/walrus_wasm.js",
+      "import": "./index.mjs",
+      "require": "./index.js"
+    },
+    "./web/walrus_wasm_bg.wasm": {
+      "browser": "./web/walrus_wasm_bg.wasm",
+      "import": "./web/walrus_wasm_bg.wasm",
+      "require": "./web/walrus_wasm_bg.wasm"
+    }
+  },
+  "devDependencies": {
+    "vite": "^7.2.6",
+    "vitest": "^4.0.15",
+    "@haneullabs/bcs": "0.1.0"
+  },
+  "scripts": {
+    "build:wasm": "pnpm build:nodejs && pnpm build:web",
+    "build:nodejs": "wasm-pack build --target nodejs --release --out-dir nodejs --no-pack && rm nodejs/.gitignore",
+    "build:web": "wasm-pack build --target web --release --out-dir web --no-pack && rm web/.gitignore",
+    "test": "vitest run"
+  }
+}

package/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "1.91"
+components = ["clippy", "rustfmt"]

package/src/bls12381.rs

@@ -0,0 +1,47 @@
+use fastcrypto::bls12381::min_pk::BLS12381AggregateSignature;
+use fastcrypto::bls12381::min_pk::{BLS12381PublicKey, BLS12381Signature};
+use fastcrypto::traits::AggregateAuthenticator;
+use fastcrypto::traits::ToFromBytes;
+use fastcrypto::traits::VerifyingKey;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::{JsError, JsValue};
+
+#[wasm_bindgen]
+pub fn bls12381_min_pk_verify(
+    signature: &[u8],
+    public_key: &[u8],
+    msg: &[u8],
+) -> Result<bool, JsError> {
+    let signature = BLS12381Signature::from_bytes(signature)?;
+    let public_key = BLS12381PublicKey::from_bytes(public_key)?;
+    Ok(public_key.verify(msg, &signature).is_ok())
+}
+
+/// Aggregate a list of signatures.
+/// The signatures must be of the type Vec<Vec<u8>> with each signature being a 96 bytes long serialized signature.
+#[wasm_bindgen]
+pub fn bls12381_min_pk_aggregate(signatures: JsValue) -> Result<Vec<u8>, JsError> {
+    let signatures = serde_wasm_bindgen::from_value::<Vec<Vec<u8>>>(signatures)?;
+    let signatures = signatures
+        .iter()
+        .map(|sig| BLS12381Signature::from_bytes(sig))
+        .collect::<Result<Vec<_>, _>>()?;
+    let aggregate_signatures = BLS12381AggregateSignature::aggregate(&signatures)?;
+    Ok(aggregate_signatures.as_bytes().to_vec())
+}
+
+/// Verify an aggregate signature.
+#[wasm_bindgen]
+pub fn bls12381_min_pk_verify_aggregate(
+    public_keys: JsValue, // Vec<Vec<u8>>
+    msg: &[u8],
+    signature: &[u8],
+) -> Result<bool, JsError> {
+    let public_keys = serde_wasm_bindgen::from_value::<Vec<Vec<u8>>>(public_keys)?;
+    let public_keys = public_keys
+        .iter()
+        .map(|pk| BLS12381PublicKey::from_bytes(pk))
+        .collect::<Result<Vec<_>, _>>()?;
+    let signature = BLS12381AggregateSignature::from_bytes(signature)?;
+    Ok(signature.verify(&public_keys, msg).is_ok())
+}

package/src/encoder.rs

@@ -0,0 +1,178 @@
+use core::num::NonZeroU16;
+use js_sys::{Array, Uint8Array};
+use walrus_core::encoding::{
+    EncodingConfig, EncodingConfigEnum, EncodingFactory, Primary, SliverData,
+};
+use walrus_core::metadata::{BlobMetadata, BlobMetadataApi};
+use walrus_core::{BlobId, EncodingType};
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::{JsCast, JsError, JsValue};
+
+#[wasm_bindgen]
+pub struct BlobEncoder {
+    encoder: EncodingConfigEnum,
+}
+
+#[wasm_bindgen]
+impl BlobEncoder {
+    #[wasm_bindgen(constructor)]
+    pub fn new(n_shards: u16) -> Result<Self, JsError> {
+        let config = EncodingConfig::new(
+            NonZeroU16::new(n_shards).ok_or(JsError::new("n_shards must be greater than 0"))?,
+        );
+        let encoder = config.get_for_type(EncodingType::RS2);
+        Ok(Self { encoder })
+    }
+
+    /// Encode data and write BCS-encoded SliverData directly into pre-allocated buffers.
+    ///
+    /// Arguments:
+    /// - data: Input data to encode
+    /// - primary_buffers: Array of Uint8Array buffers (one per shard) for primary slivers
+    /// - secondary_buffers: Array of Uint8Array buffers (one per shard) for secondary slivers
+    ///
+    /// Each buffer will be written with BCS-encoded SliverData.
+    ///
+    /// Returns: JsValue with (metadata, root_hash)
+    #[wasm_bindgen]
+    pub fn encode(
+        &self,
+        data: &Uint8Array,
+        primary_buffers: &Array,
+        secondary_buffers: &Array,
+    ) -> Result<JsValue, JsError> {
+        let data_vec = data.to_vec();
+        let (sliver_pairs, metadata) = self.encoder.encode_with_metadata(data_vec)?;
+
+        // Validate buffer counts
+        if primary_buffers.length() != sliver_pairs.len() as u32 {
+            return Err(JsError::new(&format!(
+                "Expected {} primary buffers, got {}",
+                sliver_pairs.len(),
+                primary_buffers.length()
+            )));
+        }
+        if secondary_buffers.length() != sliver_pairs.len() as u32 {
+            return Err(JsError::new(&format!(
+                "Expected {} secondary buffers, got {}",
+                sliver_pairs.len(),
+                secondary_buffers.length()
+            )));
+        }
+
+        // Write BCS-encoded slivers to buffers
+        for (i, sliver_pair) in sliver_pairs.iter().enumerate() {
+            let primary_buffer = primary_buffers
+                .get(i as u32)
+                .dyn_into::<Uint8Array>()
+                .map_err(|_| JsError::new(&format!("Primary buffer {} is not a Uint8Array", i)))?;
+            Self::write_sliver_data_bcs(&sliver_pair.primary, &primary_buffer)?;
+
+            let secondary_buffer = secondary_buffers
+                .get(i as u32)
+                .dyn_into::<Uint8Array>()
+                .map_err(|_| {
+                    JsError::new(&format!("Secondary buffer {} is not a Uint8Array", i))
+                })?;
+            Self::write_sliver_data_bcs(&sliver_pair.secondary, &secondary_buffer)?;
+        }
+
+        let root_hash = match metadata.metadata() {
+            BlobMetadata::V1(inner) => inner.compute_root_hash(),
+        };
+
+        Ok(serde_wasm_bindgen::to_value(&(metadata, root_hash))?)
+    }
+
+    /// Compute metadata for data without encoding it.
+    /// Returns only the essential fields needed for blob registration:
+    /// (blob_id, root_hash, unencoded_length, encoding_type)
+    ///
+    /// This avoids serializing all 2k sliver hashes across the JS/WASM boundary.
+    #[wasm_bindgen]
+    pub fn compute_metadata(&self, data: &Uint8Array) -> Result<JsValue, JsError> {
+        let data_vec = data.to_vec();
+        let metadata = self.encoder.compute_metadata(&data_vec)?;
+        let blob_id = metadata.blob_id();
+        let (root_hash, unencoded_length, encoding_type) = match metadata.metadata() {
+            BlobMetadata::V1(inner) => (
+                inner.compute_root_hash(),
+                inner.unencoded_length,
+                inner.encoding_type,
+            ),
+        };
+        Ok(serde_wasm_bindgen::to_value(&(
+            blob_id,
+            root_hash,
+            unencoded_length,
+            encoding_type,
+        ))?)
+    }
+
+    /// Decode blob from BCS-encoded SliverData buffers.
+    ///
+    /// Arguments:
+    /// - blob_id: The blob identifier
+    /// - blob_size: The original unencoded blob size in bytes
+    /// - bcs_buffers: Vec<Uint8Array>, each containing BCS-encoded SliverData<Primary>
+    /// - output_buffer: Uint8Array to write decoded data into (must be exactly blob_size bytes)
+    #[wasm_bindgen]
+    pub fn decode(
+        &self,
+        blob_id: JsValue,
+        blob_size: u64,
+        bcs_buffers: Vec<Uint8Array>,
+        output_buffer: &Uint8Array,
+    ) -> Result<(), JsError> {
+        let _blob_id = serde_wasm_bindgen::from_value::<BlobId>(blob_id)?;
+
+        if output_buffer.length() as u64 != blob_size {
+            return Err(JsError::new(&format!(
+                "Output buffer size mismatch: expected {}, got {}",
+                blob_size,
+                output_buffer.length()
+            )));
+        }
+
+        let mut sliver_data: Vec<SliverData<Primary>> = Vec::with_capacity(bcs_buffers.len());
+
+        for (i, buffer) in bcs_buffers.iter().enumerate() {
+            let bytes = buffer.to_vec();
+            let sliver: SliverData<Primary> = bcs::from_bytes(&bytes).map_err(|e| {
+                JsError::new(&format!(
+                    "BCS deserialization failed at index {} (buffer size {}): {}",
+                    i,
+                    bytes.len(),
+                    e
+                ))
+            })?;
+            sliver_data.push(sliver);
+        }
+
+        let decoded = self.encoder.decode(blob_size, sliver_data)?;
+        output_buffer.copy_from(&decoded[..]);
+
+        Ok(())
+    }
+
+    fn write_sliver_data_bcs<T: walrus_core::encoding::EncodingAxis>(
+        sliver: &SliverData<T>,
+        buffer: &Uint8Array,
+    ) -> Result<(), JsError> {
+        let serialized = bcs::to_bytes(sliver)
+            .map_err(|e| JsError::new(&format!("BCS serialization failed: {}", e)))?;
+
+        // Verify buffer size
+        if buffer.length() as usize != serialized.len() {
+            return Err(JsError::new(&format!(
+                "Buffer size mismatch: expected {}, got {}",
+                serialized.len(),
+                buffer.length()
+            )));
+        }
+
+        buffer.copy_from(&serialized[..]);
+
+        Ok(())
+    }
+}

package/src/lib.rs

@@ -0,0 +1,9 @@
+use wasm_bindgen::prelude::*;
+
+mod bls12381;
+mod encoder;
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = console)]
+    fn log(s: &str);
+}

package/test/encoder.test.ts

@@ -0,0 +1,260 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { describe, expect, it } from 'vitest';
+import { BlobEncoder } from '../nodejs/walrus_wasm.js';
+
+/**
+ * Helper functions for computing BCS buffer sizes (copied from walrus SDK)
+ */
+interface BcsBufferSizes {
+	primary: number;
+	secondary: number;
+}
+
+function getSourceSymbols(nShards: number) {
+	const maxFaulty = Math.floor((nShards - 1) / 3);
+	const minCorrect = nShards - maxFaulty;
+	return {
+		primarySymbols: minCorrect - maxFaulty,
+		secondarySymbols: minCorrect,
+	};
+}
+
+function uleb128Size(value: number): number {
+	let size = 1;
+	value >>= 7;
+	while (value !== 0) {
+		size++;
+		value >>= 7;
+	}
+	return size;
+}
+
+function computeBcsBufferSize(dataLength: number): number {
+	const ulebSize = uleb128Size(dataLength);
+	return ulebSize + dataLength + 2 + 2; // ULEB128 + data + symbol_size + index
+}
+
+function computeBcsBufferSizes(blobSize: number, nShards: number): BcsBufferSizes[] {
+	const { primarySymbols, secondarySymbols } = getSourceSymbols(nShards);
+
+	let symbolSize = Math.floor((Math.max(blobSize, 1) - 1) / (primarySymbols * secondarySymbols)) + 1;
+	if (symbolSize % 2 === 1) {
+		symbolSize = symbolSize + 1;
+	}
+
+	const primarySliverSize = secondarySymbols * symbolSize;
+	const secondarySliverSize = primarySymbols * symbolSize;
+
+	const primaryBcsSize = computeBcsBufferSize(primarySliverSize);
+	const secondaryBcsSize = computeBcsBufferSize(secondarySliverSize);
+
+	const sizes: BcsBufferSizes[] = [];
+	for (let i = 0; i < nShards; i++) {
+		sizes.push({
+			primary: primaryBcsSize,
+			secondary: secondaryBcsSize,
+		});
+	}
+
+	return sizes;
+}
+
+async function sha256(data: Uint8Array<ArrayBuffer>): Promise<string> {
+	const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+	return Array.from(new Uint8Array(hashBuffer))
+		.map((b) => b.toString(16).padStart(2, '0'))
+		.join('');
+}
+
+describe('BlobEncoder', () => {
+	const nShards = 1000;
+
+	it('should encode and decode a 5MB blob correctly', async () => {
+		const blobSize = 5 * 1024 * 1024; // 5MB
+		const inputData = new Uint8Array(blobSize);
+
+		// Fill with pseudo-random data for better testing
+		for (let i = 0; i < blobSize; i++) {
+			inputData[i] = (i * 7 + 13) % 256;
+		}
+
+		// Compute hash of original data
+		const originalHash = await sha256(inputData);
+
+		// Create encoder
+		const encoder = new BlobEncoder(nShards);
+
+		// Pre-allocate BCS buffers
+		const bufferSizes = computeBcsBufferSizes(blobSize, nShards);
+		const primaryBuffers = bufferSizes.map((size) => new Uint8Array(size.primary));
+		const secondaryBuffers = bufferSizes.map((size) => new Uint8Array(size.secondary));
+
+		// Encode
+		const [metadata, rootHash] = encoder.encode(inputData, primaryBuffers, secondaryBuffers);
+
+		// Verify we got metadata and root hash
+		expect(metadata).toBeDefined();
+		expect(metadata.blob_id).toBeDefined();
+		expect(rootHash).toBeDefined();
+		expect(rootHash.Digest).toBeDefined();
+
+		// Convert to Uint8Array if needed (wasm-bindgen may return Array)
+		const rootHashBytes = rootHash.Digest instanceof Uint8Array ? rootHash.Digest : new Uint8Array(rootHash.Digest);
+		expect(rootHashBytes.length).toBe(32); // SHA-256 hash
+
+		// Verify buffers were written
+		expect(primaryBuffers.length).toBe(nShards);
+		expect(secondaryBuffers.length).toBe(nShards);
+
+		// Verify buffers contain data (not all zeros)
+		const primaryHasData = primaryBuffers.some((buf) => buf.some((byte) => byte !== 0));
+		expect(primaryHasData).toBe(true);
+
+		// Decode using only primary slivers (minimum required for RS2)
+		const outputBuffer = new Uint8Array(blobSize);
+		encoder.decode(metadata.blob_id, BigInt(blobSize), primaryBuffers, outputBuffer);
+
+		// Verify decoded data matches original
+		const decodedHash = await sha256(outputBuffer);
+		expect(decodedHash).toBe(originalHash);
+
+		// Byte-by-byte comparison for first 100 bytes
+		for (let i = 0; i < 100; i++) {
+			expect(outputBuffer[i]).toBe(inputData[i]);
+		}
+	});
+
+	it('should encode and decode a small 1KB blob correctly', async () => {
+		const blobSize = 1024; // 1KB
+		const inputData = new Uint8Array(blobSize);
+
+		// Fill with pattern
+		for (let i = 0; i < blobSize; i++) {
+			inputData[i] = i % 256;
+		}
+
+		const originalHash = await sha256(inputData);
+
+		const encoder = new BlobEncoder(nShards);
+
+		const bufferSizes = computeBcsBufferSizes(blobSize, nShards);
+		const primaryBuffers = bufferSizes.map((size) => new Uint8Array(size.primary));
+		const secondaryBuffers = bufferSizes.map((size) => new Uint8Array(size.secondary));
+
+		const [metadata] = encoder.encode(inputData, primaryBuffers, secondaryBuffers);
+
+		const outputBuffer = new Uint8Array(blobSize);
+		encoder.decode(metadata.blob_id, BigInt(blobSize), primaryBuffers, outputBuffer);
+
+		const decodedHash = await sha256(outputBuffer);
+		expect(decodedHash).toBe(originalHash);
+	});
+
+	it('should compute metadata without encoding', async () => {
+		const blobSize = 1024 * 1024; // 1MB
+		const inputData = new Uint8Array(blobSize);
+
+		// Fill with data
+		for (let i = 0; i < blobSize; i++) {
+			inputData[i] = (i * 3) % 256;
+		}
+
+		const encoder = new BlobEncoder(nShards);
+
+		// Compute metadata only - returns (blob_id, root_hash, unencoded_length, encoding_type)
+		const [blobId, rootHash, unencodedLength, encodingType] = encoder.compute_metadata(inputData);
+
+		// Verify blob_id
+		expect(blobId).toBeDefined();
+		const blobIdBytes = blobId instanceof Uint8Array ? blobId : new Uint8Array(blobId);
+		expect(blobIdBytes.length).toBe(32); // u256 = 32 bytes
+
+		// Verify root hash
+		expect(rootHash).toBeDefined();
+		const rootHashBytes = rootHash.Digest instanceof Uint8Array ? rootHash.Digest : new Uint8Array(rootHash.Digest);
+		expect(rootHashBytes.length).toBe(32);
+
+		// Verify unencoded_length
+		expect(Number(unencodedLength)).toBe(blobSize);
+
+		// Verify encoding_type (RS2)
+		expect(encodingType).toBe('RS2');
+	});
+
+	it('should produce deterministic blob IDs for known inputs', async () => {
+		const encoder = new BlobEncoder(nShards);
+
+		// Test with empty blob
+		const emptyData = new Uint8Array(0);
+		const [emptyBlobId] = encoder.compute_metadata(emptyData);
+		const emptyBlobIdHex = Buffer.from(emptyBlobId).toString('hex');
+
+		// Empty blob should always produce the same blob ID
+		const [emptyBlobId2] = encoder.compute_metadata(emptyData);
+		const emptyBlobIdHex2 = Buffer.from(emptyBlobId2).toString('hex');
+		expect(emptyBlobIdHex).toBe(emptyBlobIdHex2);
+
+		// Verify against known static value (for nShards=1000)
+		expect(emptyBlobIdHex).toBe('dc63d02f71d936716137f17b97901af97d553ad00ac08b20f73b9693c47cd6fe');
+
+		// Test with simple known data
+		const testData = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+		const [testBlobId] = encoder.compute_metadata(testData);
+		const testBlobIdHex = Buffer.from(testBlobId).toString('hex');
+
+		// Same input should always produce the same blob ID
+		const [testBlobId2] = encoder.compute_metadata(testData);
+		const testBlobIdHex2 = Buffer.from(testBlobId2).toString('hex');
+		expect(testBlobIdHex).toBe(testBlobIdHex2);
+
+		// Verify against known static value (for nShards=1000)
+		expect(testBlobIdHex).toBe('865ca48479104a9bdc136f7d6730b7f3920012eccb4e99ba8540b9363766e093');
+	});
+
+	it('should produce consistent metadata for the same input', async () => {
+		const blobSize = 512 * 1024; // 512KB
+		const inputData = new Uint8Array(blobSize);
+
+		// Fill with deterministic data
+		for (let i = 0; i < blobSize; i++) {
+			inputData[i] = (i * 11 + 7) % 256;
+		}
+
+		const encoder = new BlobEncoder(nShards);
+
+		// Compute metadata twice
+		const [blobId1, rootHash1, unencodedLength1] = encoder.compute_metadata(inputData);
+		const [blobId2, rootHash2, unencodedLength2] = encoder.compute_metadata(inputData);
+
+		// Blob IDs should match
+		expect(blobId1).toEqual(blobId2);
+
+		// Root hashes should match
+		expect(rootHash1.Digest).toEqual(rootHash2.Digest);
+
+		// Unencoded lengths should match
+		expect(unencodedLength1).toBe(unencodedLength2);
+	});
+
+	it('should fail decode with wrong buffer size', () => {
+		const blobSize = 1024;
+		const inputData = new Uint8Array(blobSize);
+
+		const encoder = new BlobEncoder(nShards);
+
+		const bufferSizes = computeBcsBufferSizes(blobSize, nShards);
+		const primaryBuffers = bufferSizes.map((size) => new Uint8Array(size.primary));
+		const secondaryBuffers = bufferSizes.map((size) => new Uint8Array(size.secondary));
+
+		const [metadata] = encoder.encode(inputData, primaryBuffers, secondaryBuffers);
+
+		// Try to decode with wrong output buffer size
+		const wrongSizeBuffer = new Uint8Array(blobSize - 1);
+
+		expect(() => {
+			encoder.decode(metadata.blob_id, BigInt(blobSize), primaryBuffers, wrongSizeBuffer);
+		}).toThrow(/Output buffer size mismatch/);
+	});
+});

package/vitest.config.mts

@@ -0,0 +1,17 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+	test: {
+		minWorkers: 1,
+		maxWorkers: 4,
+		hookTimeout: 60000,
+		testTimeout: 60000,
+		env: {
+			NODE_ENV: 'test',
+		},
+		pool: 'threads',
+	},
+});

package/web/walrus_wasm.d.ts

@@ -0,0 +1,95 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Aggregate a list of signatures.
+ * The signatures must be of the type Vec<Vec<u8>> with each signature being a 96 bytes long serialized signature.
+ */
+export function bls12381_min_pk_aggregate(signatures: any): Uint8Array;
+/**
+ * Verify an aggregate signature.
+ */
+export function bls12381_min_pk_verify_aggregate(public_keys: any, msg: Uint8Array, signature: Uint8Array): boolean;
+export function bls12381_min_pk_verify(signature: Uint8Array, public_key: Uint8Array, msg: Uint8Array): boolean;
+export class BlobEncoder {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Compute metadata for data without encoding it.
+   * Returns only the essential fields needed for blob registration:
+   * (blob_id, root_hash, unencoded_length, encoding_type)
+   *
+   * This avoids serializing all 2k sliver hashes across the JS/WASM boundary.
+   */
+  compute_metadata(data: Uint8Array): any;
+  constructor(n_shards: number);
+  /**
+   * Decode blob from BCS-encoded SliverData buffers.
+   *
+   * Arguments:
+   * - blob_id: The blob identifier
+   * - blob_size: The original unencoded blob size in bytes
+   * - bcs_buffers: Vec<Uint8Array>, each containing BCS-encoded SliverData<Primary>
+   * - output_buffer: Uint8Array to write decoded data into (must be exactly blob_size bytes)
+   */
+  decode(blob_id: any, blob_size: bigint, bcs_buffers: Uint8Array[], output_buffer: Uint8Array): void;
+  /**
+   * Encode data and write BCS-encoded SliverData directly into pre-allocated buffers.
+   *
+   * Arguments:
+   * - data: Input data to encode
+   * - primary_buffers: Array of Uint8Array buffers (one per shard) for primary slivers
+   * - secondary_buffers: Array of Uint8Array buffers (one per shard) for secondary slivers
+   *
+   * Each buffer will be written with BCS-encoded SliverData.
+   *
+   * Returns: JsValue with (metadata, root_hash)
+   */
+  encode(data: Uint8Array, primary_buffers: Array<any>, secondary_buffers: Array<any>): any;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_blobencoder_free: (a: number, b: number) => void;
+  readonly blobencoder_compute_metadata: (a: number, b: any) => [number, number, number];
+  readonly blobencoder_decode: (a: number, b: any, c: bigint, d: number, e: number, f: any) => [number, number];
+  readonly blobencoder_encode: (a: number, b: any, c: any, d: any) => [number, number, number];
+  readonly blobencoder_new: (a: number) => [number, number, number];
+  readonly bls12381_min_pk_aggregate: (a: any) => [number, number, number, number];
+  readonly bls12381_min_pk_verify: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly bls12381_min_pk_verify_aggregate: (a: any, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly rustsecp256k1_v0_8_1_context_create: (a: number) => number;
+  readonly rustsecp256k1_v0_8_1_context_destroy: (a: number) => void;
+  readonly rustsecp256k1_v0_8_1_default_error_callback_fn: (a: number, b: number) => void;
+  readonly rustsecp256k1_v0_8_1_default_illegal_callback_fn: (a: number, b: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_externrefs: WebAssembly.Table;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;