smoldot 0.3.6 → 0.7.10

package/dist/cjs/instance/bindings-smoldot-light.d.ts

@@ -0,0 +1,154 @@
+import type { SmoldotWasmInstance } from './bindings.js';
+export interface Config {
+    instance?: SmoldotWasmInstance;
+    /**
+     * Returns the number of milliseconds since an arbitrary epoch.
+     */
+    performanceNow: () => number;
+    /**
+     * Tries to open a new connection using the given configuration.
+     *
+     * @see Connection
+     * @throws {@link ConnectionError} If the multiaddress couldn't be parsed or contains an invalid protocol.
+     */
+    connect(config: ConnectionConfig): Connection;
+    /**
+     * Closure to call when the Wasm instance calls `panic`.
+     *
+     * This callback will always be invoked from within a binding called the Wasm instance.
+     */
+    onPanic: (message: string) => never;
+    logCallback: (level: number, target: string, message: string) => void;
+    jsonRpcResponsesNonEmptyCallback: (chainId: number) => void;
+    currentTaskCallback?: (taskName: string | null) => void;
+}
+/**
+ * Connection to a remote node.
+ *
+ * At any time, a connection can be in one of the three following states:
+ *
+ * - `Opening` (initial state)
+ * - `Open`
+ * - `Reset`
+ *
+ * When in the `Opening` or `Open` state, the connection can transition to the `Reset` state
+ * if the remote closes the connection or refuses the connection altogether. When that
+ * happens, `config.onReset` is called. Once in the `Reset` state, the connection cannot
+ * transition back to another state.
+ *
+ * Initially in the `Opening` state, the connection can transition to the `Open` state if the
+ * remote accepts the connection. When that happens, `config.onOpen` is called.
+ *
+ * When in the `Open` state, the connection can receive messages. When a message is received,
+ * `config.onMessage` is called.
+ *
+ * @see connect
+ */
+export interface Connection {
+    /**
+     * Transitions the connection or one of its substreams to the `Reset` state.
+     *
+     * If the connection is of type "single-stream", the whole connection must be shut down.
+     * If the connection is of type "multi-stream", a `streamId` can be provided, in which case
+     * only the given substream is shut down.
+     *
+     * The `config.onReset` or `config.onStreamReset` callbacks are **not** called.
+     *
+     * The transition is performed in the background.
+     * If the whole connection is to be shut down, none of the callbacks passed to the `Config`
+     * must be called again. If only a substream is shut down, the `onStreamReset` and `onMessage`
+     * callbacks must not be called again with that substream.
+     */
+    reset(streamId?: number): void;
+    /**
+     * Queues data to be sent on the given connection.
+     *
+     * The connection must currently be in the `Open` state.
+     *
+     * The `streamId` must be provided if and only if the connection is of type "multi-stream".
+     * It indicates which substream to send the data on.
+     */
+    send(data: Uint8Array, streamId?: number): void;
+    /**
+     * Start opening an additional outbound substream on the given connection.
+     *
+     * The state of the connection must be `Open`. This function must only be called for
+     * connections of type "multi-stream".
+     *
+     * The `onStreamOpened` callback must later be called with an outbound direction.
+     *
+     * Note that no mechanism exists in this API to handle the situation where a substream fails
+     * to open, as this is not supposed to happen. If you need to handle such a situation, either
+     * try again opening a substream again or reset the entire connection.
+     */
+    openOutSubstream(): void;
+}
+/**
+ * Configuration for a connection.
+ *
+ * @see connect
+ */
+export interface ConnectionConfig {
+    /**
+     * Multiaddress in string format that describes which node to try to connect to.
+     *
+     * Note that this address shouldn't be trusted. The value in this field might have been chosen
+     * by a potentially malicious peer.
+     */
+    address: string;
+    /**
+     * Callback called when the connection transitions from the `Opening` to the `Open` state.
+     *
+     * Must only be called once per connection.
+     */
+    onOpen: (info: {
+        type: 'single-stream';
+        handshake: 'multistream-select-noise-yamux';
+    } | {
+        type: 'multi-stream';
+        handshake: 'webrtc';
+        localTlsCertificateMultihash: Uint8Array;
+        remoteTlsCertificateMultihash: Uint8Array;
+    }) => void;
+    /**
+     * Callback called when the connection transitions to the `Reset` state.
+     *
+     * It it **not** called if `Connection.reset` is manually called by the API user.
+     */
+    onConnectionReset: (message: string) => void;
+    /**
+     * Callback called when a new substream has been opened.
+     *
+     * This function must only be called for connections of type "multi-stream".
+     */
+    onStreamOpened: (streamId: number, direction: 'inbound' | 'outbound') => void;
+    /**
+     * Callback called when a stream transitions to the `Reset` state.
+     *
+     * It it **not** called if `Connection.resetStream` is manually called by the API user.
+     *
+     * This function must only be called for connections of type "multi-stream".
+     */
+    onStreamReset: (streamId: number) => void;
+    /**
+     * Callback called when a message sent by the remote has been received.
+     *
+     * Can only happen while the connection is in the `Open` state.
+     *
+     * The `streamId` parameter must be provided if and only if the connection is of type
+     * "multi-stream".
+     */
+    onMessage: (message: Uint8Array, streamId?: number) => void;
+}
+/**
+ * Emitted by `connect` if the multiaddress couldn't be parsed or contains an invalid protocol.
+ *
+ * @see connect
+ */
+export declare class ConnectionError extends Error {
+    constructor(message: string);
+}
+export default function (config: Config): {
+    imports: WebAssembly.ModuleImports;
+    killAll: () => void;
+};

package/dist/cjs/instance/bindings-smoldot-light.js

@@ -0,0 +1,266 @@
+"use strict";
+// Smoldot
+// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionError = void 0;
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//! Exports a function that provides bindings for the bindings found in the Rust part of the code.
+//!
+//! In order to use this code, call the function passing an object, then fill the `instance` field
+//! of that object with the Wasm instance.
+const buffer = require("./buffer.js");
+/**
+ * Emitted by `connect` if the multiaddress couldn't be parsed or contains an invalid protocol.
+ *
+ * @see connect
+ */
+class ConnectionError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ConnectionError = ConnectionError;
+function default_1(config) {
+    // Used below to store the list of all connections.
+    // The indices within this array are chosen by the Rust code.
+    let connections = {};
+    // Object containing a boolean indicating whether the `killAll` function has been invoked by
+    // the user.
+    const killedTracked = { killed: false };
+    const killAll = () => {
+        killedTracked.killed = true;
+        // TODO: kill timers as well?
+        for (const connection in connections) {
+            connections[connection].reset();
+            delete connections[connection];
+        }
+    };
+    const imports = {
+        // Must exit with an error. A human-readable message can be found in the WebAssembly
+        // memory in the given buffer.
+        panic: (ptr, len) => {
+            const instance = config.instance;
+            ptr >>>= 0;
+            len >>>= 0;
+            const message = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), ptr, len);
+            config.onPanic(message);
+        },
+        // Used by the Rust side to notify that a JSON-RPC response or subscription notification
+        // is available in the queue of JSON-RPC responses.
+        json_rpc_responses_non_empty: (chainId) => {
+            if (killedTracked.killed)
+                return;
+            config.jsonRpcResponsesNonEmptyCallback(chainId);
+        },
+        // Used by the Rust side to emit a log entry.
+        // See also the `max_log_level` parameter in the configuration.
+        log: (level, targetPtr, targetLen, messagePtr, messageLen) => {
+            if (killedTracked.killed)
+                return;
+            const instance = config.instance;
+            targetPtr >>>= 0;
+            targetLen >>>= 0;
+            messagePtr >>>= 0;
+            messageLen >>>= 0;
+            if (config.logCallback) {
+                const mem = new Uint8Array(instance.exports.memory.buffer);
+                let target = buffer.utf8BytesToString(mem, targetPtr, targetLen);
+                let message = buffer.utf8BytesToString(mem, messagePtr, messageLen);
+                config.logCallback(level, target, message);
+            }
+        },
+        // Must return the UNIX time in milliseconds.
+        unix_time_ms: () => Date.now(),
+        // Must return the value of a monotonic clock in milliseconds.
+        monotonic_clock_ms: () => config.performanceNow(),
+        // Must call `timer_finished` after the given number of milliseconds has elapsed.
+        start_timer: (id, ms) => {
+            if (killedTracked.killed)
+                return;
+            const instance = config.instance;
+            // In both NodeJS and browsers, if `setTimeout` is called with a value larger than
+            // 2147483647, the delay is for some reason instead set to 1.
+            // As mentioned in the documentation of `start_timer`, it is acceptable to end the
+            // timer before the given number of milliseconds has passed.
+            if (ms > 2147483647)
+                ms = 2147483647;
+            // In browsers, `setTimeout` works as expected when `ms` equals 0. However, NodeJS
+            // requires a minimum of 1 millisecond (if `0` is passed, it is automatically replaced
+            // with `1`) and wants you to use `setImmediate` instead.
+            if (ms == 0 && typeof setImmediate === "function") {
+                setImmediate(() => {
+                    if (killedTracked.killed)
+                        return;
+                    try {
+                        instance.exports.timer_finished(id);
+                    }
+                    catch (_error) { }
+                });
+            }
+            else {
+                setTimeout(() => {
+                    if (killedTracked.killed)
+                        return;
+                    try {
+                        instance.exports.timer_finished(id);
+                    }
+                    catch (_error) { }
+                }, ms);
+            }
+        },
+        // Must create a new connection object. This implementation stores the created object in
+        // `connections`.
+        connection_new: (connectionId, addrPtr, addrLen, errorPtrPtr) => {
+            const instance = config.instance;
+            addrPtr >>>= 0;
+            addrLen >>>= 0;
+            errorPtrPtr >>>= 0;
+            if (!!connections[connectionId]) {
+                throw new Error("internal error: connection already allocated");
+            }
+            try {
+                if (killedTracked.killed)
+                    throw new Error("killAll invoked");
+                const address = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), addrPtr, addrLen);
+                const connec = config.connect({
+                    address,
+                    onOpen: (info) => {
+                        if (killedTracked.killed)
+                            return;
+                        try {
+                            switch (info.type) {
+                                case 'single-stream': {
+                                    instance.exports.connection_open_single_stream(connectionId, 0);
+                                    break;
+                                }
+                                case 'multi-stream': {
+                                    const bufferLen = 1 + info.localTlsCertificateMultihash.length + info.remoteTlsCertificateMultihash.length;
+                                    const ptr = instance.exports.alloc(bufferLen) >>> 0;
+                                    const mem = new Uint8Array(instance.exports.memory.buffer);
+                                    buffer.writeUInt8(mem, ptr, 0);
+                                    mem.set(info.localTlsCertificateMultihash, ptr + 1);
+                                    mem.set(info.remoteTlsCertificateMultihash, ptr + 1 + info.localTlsCertificateMultihash.length);
+                                    instance.exports.connection_open_multi_stream(connectionId, ptr, bufferLen);
+                                    break;
+                                }
+                            }
+                        }
+                        catch (_error) { }
+                    },
+                    onConnectionReset: (message) => {
+                        if (killedTracked.killed)
+                            return;
+                        try {
+                            const encoded = new TextEncoder().encode(message);
+                            const ptr = instance.exports.alloc(encoded.length) >>> 0;
+                            new Uint8Array(instance.exports.memory.buffer).set(encoded, ptr);
+                            instance.exports.connection_reset(connectionId, ptr, encoded.length);
+                        }
+                        catch (_error) { }
+                    },
+                    onMessage: (message, streamId) => {
+                        if (killedTracked.killed)
+                            return;
+                        try {
+                            const ptr = instance.exports.alloc(message.length) >>> 0;
+                            new Uint8Array(instance.exports.memory.buffer).set(message, ptr);
+                            instance.exports.stream_message(connectionId, streamId || 0, ptr, message.length);
+                        }
+                        catch (_error) { }
+                    },
+                    onStreamOpened: (streamId, direction) => {
+                        if (killedTracked.killed)
+                            return;
+                        try {
+                            instance.exports.connection_stream_opened(connectionId, streamId, direction === 'outbound' ? 1 : 0);
+                        }
+                        catch (_error) { }
+                    },
+                    onStreamReset: (streamId) => {
+                        if (killedTracked.killed)
+                            return;
+                        try {
+                            instance.exports.stream_reset(connectionId, streamId);
+                        }
+                        catch (_error) { }
+                    }
+                });
+                connections[connectionId] = connec;
+                return 0;
+            }
+            catch (error) {
+                const isBadAddress = error instanceof ConnectionError;
+                let errorStr = "Unknown error";
+                if (error instanceof Error) {
+                    errorStr = error.toString();
+                }
+                const mem = new Uint8Array(instance.exports.memory.buffer);
+                const encoded = new TextEncoder().encode(errorStr);
+                const ptr = instance.exports.alloc(encoded.length) >>> 0;
+                mem.set(encoded, ptr);
+                buffer.writeUInt32LE(mem, errorPtrPtr, ptr);
+                buffer.writeUInt32LE(mem, errorPtrPtr + 4, encoded.length);
+                buffer.writeUInt8(mem, errorPtrPtr + 8, isBadAddress ? 1 : 0);
+                return 1;
+            }
+        },
+        // Must close and destroy the connection object.
+        reset_connection: (connectionId) => {
+            if (killedTracked.killed)
+                return;
+            const connection = connections[connectionId];
+            connection.reset();
+            delete connections[connectionId];
+        },
+        // Opens a new substream on a multi-stream connection.
+        connection_stream_open: (connectionId) => {
+            const connection = connections[connectionId];
+            connection.openOutSubstream();
+        },
+        // Closes a substream on a multi-stream connection.
+        connection_stream_reset: (connectionId, streamId) => {
+            const connection = connections[connectionId];
+            connection.reset(streamId);
+        },
+        // Must queue the data found in the WebAssembly memory at the given pointer. It is assumed
+        // that this function is called only when the connection is in an open state.
+        stream_send: (connectionId, streamId, ptr, len) => {
+            if (killedTracked.killed)
+                return;
+            const instance = config.instance;
+            ptr >>>= 0;
+            len >>>= 0;
+            const data = new Uint8Array(instance.exports.memory.buffer).slice(ptr, ptr + len);
+            const connection = connections[connectionId];
+            connection.send(data, streamId); // TODO: docs says the streamId is provided only for multi-stream connections, but here it's always provided
+        },
+        current_task_entered: (ptr, len) => {
+            if (killedTracked.killed)
+                return;
+            const instance = config.instance;
+            ptr >>>= 0;
+            len >>>= 0;
+            const taskName = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), ptr, len);
+            if (config.currentTaskCallback)
+                config.currentTaskCallback(taskName);
+        },
+        current_task_exit: () => {
+            if (killedTracked.killed)
+                return;
+            if (config.currentTaskCallback)
+                config.currentTaskCallback(null);
+        }
+    };
+    return { imports, killAll };
+}
+exports.default = default_1;

package/dist/cjs/instance/bindings-wasi.d.ts

@@ -0,0 +1,23 @@
+import type { SmoldotWasmInstance } from './bindings.js';
+export interface Config {
+    instance?: SmoldotWasmInstance;
+    /**
+     * Fills the given buffer with randomly-generated bytes.
+     */
+    getRandomValues: (buffer: Uint8Array) => void;
+    /**
+     * List of environment variables to feed to the Rust program. An array of strings.
+     * Example: `["RUST_BACKTRACE=1", "RUST_LOG=foo"];`
+     *
+     * Must never be modified after the bindings have been initialized.
+     */
+    envVars: string[];
+    /**
+     * Closure to call when the Wasm instance calls `proc_exit`.
+     *
+     * This callback will always be invoked from within a binding called the Wasm instance.
+     */
+    onProcExit: (retCode: number) => never;
+}
+declare const _default: (config: Config) => WebAssembly.ModuleImports;
+export default _default;

package/dist/cjs/instance/bindings-wasi.js

@@ -0,0 +1,142 @@
+"use strict";
+// Smoldot
+// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//! Exports a function that provides bindings for the Wasi interface.
+//!
+//! These bindings can then be used by the Wasm virtual machine to invoke Wasi-related functions.
+//! See <https://wasi.dev/>.
+//!
+//! In order to use this code, call the function passing an object, then fill the `instance` field
+//! of that object with the Wasm instance.
+const buffer = require("./buffer.js");
+exports.default = (config) => {
+    // Buffers holding temporary data being written by the Rust code to respectively stdout and
+    // stderr.
+    let stdoutBuffer = "";
+    let stderrBuffer = "";
+    return {
+        // Need to fill the buffer described by `ptr` and `len` with random data.
+        // This data will be used in order to generate secrets. Do not use a dummy implementation!
+        random_get: (ptr, len) => {
+            const instance = config.instance;
+            ptr >>>= 0;
+            len >>>= 0;
+            const baseBuffer = new Uint8Array(instance.exports.memory.buffer)
+                .subarray(ptr, ptr + len);
+            for (let iter = 0; iter < len; iter += 65536) {
+                // `baseBuffer.subarray` automatically saturates at the end of the buffer
+                config.getRandomValues(baseBuffer.subarray(iter, iter + 65536));
+            }
+            return 0;
+        },
+        // Writing to a file descriptor is used in order to write to stdout/stderr.
+        fd_write: (fd, addr, num, outPtr) => {
+            const instance = config.instance;
+            outPtr >>>= 0;
+            // Only stdout and stderr are open for writing.
+            if (fd != 1 && fd != 2) {
+                return 8;
+            }
+            const mem = new Uint8Array(instance.exports.memory.buffer);
+            // `fd_write` passes a buffer containing itself a list of pointers and lengths to the
+            // actual buffers. See writev(2).
+            let toWrite = "";
+            let totalLength = 0;
+            for (let i = 0; i < num; i++) {
+                const buf = buffer.readUInt32LE(mem, addr + 4 * i * 2);
+                const bufLen = buffer.readUInt32LE(mem, addr + 4 * (i * 2 + 1));
+                toWrite += buffer.utf8BytesToString(mem, buf, bufLen);
+                totalLength += bufLen;
+            }
+            const flushBuffer = (string) => {
+                // As documented in the documentation of `println!`, lines are always split by a
+                // single `\n` in Rust.
+                while (true) {
+                    const index = string.indexOf('\n');
+                    if (index != -1) {
+                        // Note that it is questionnable to use `console.log` from within a
+                        // library. However this simply reflects the usage of `println!` in the
+                        // Rust code. In other words, it is `println!` that shouldn't be used in
+                        // the first place. The harm of not showing text printed with `println!`
+                        // at all is greater than the harm possibly caused by accidentally leaving
+                        // a `println!` in the code.
+                        console.log(string.substring(0, index));
+                        string = string.substring(index + 1);
+                    }
+                    else {
+                        return string;
+                    }
+                }
+            };
+            // Append the newly-written data to either `stdout_buffer` or `stderr_buffer`, and
+            // print their content if necessary.
+            if (fd == 1) {
+                stdoutBuffer += toWrite;
+                stdoutBuffer = flushBuffer(stdoutBuffer);
+            }
+            else if (fd == 2) {
+                stderrBuffer += toWrite;
+                stderrBuffer = flushBuffer(stderrBuffer);
+            }
+            // Need to write in `out_ptr` how much data was "written".
+            buffer.writeUInt32LE(mem, outPtr, totalLength);
+            return 0;
+        },
+        // It's unclear how to properly implement yielding, but a no-op works fine as well.
+        sched_yield: () => {
+            return 0;
+        },
+        // Used by Rust in catastrophic situations, such as a double panic.
+        proc_exit: (retCode) => {
+            config.onProcExit(retCode);
+        },
+        // Return the number of environment variables and the total size of all environment
+        // variables. This is called in order to initialize buffers before `environ_get`.
+        environ_sizes_get: (argcOut, argvBufSizeOut) => {
+            const instance = config.instance;
+            argcOut >>>= 0;
+            argvBufSizeOut >>>= 0;
+            let totalLen = 0;
+            config.envVars.forEach(e => totalLen += new TextEncoder().encode(e).length + 1); // +1 for trailing \0
+            const mem = new Uint8Array(instance.exports.memory.buffer);
+            buffer.writeUInt32LE(mem, argcOut, config.envVars.length);
+            buffer.writeUInt32LE(mem, argvBufSizeOut, totalLen);
+            return 0;
+        },
+        // Write the environment variables to the given pointers.
+        // `argv` is a pointer to a buffer that must be overwritten with a list of pointers to
+        // environment variables, and `argvBuf` is a pointer to a buffer where to actually store
+        // the environment variables.
+        // The sizes of the buffers were determined by calling `environ_sizes_get`.
+        environ_get: (argv, argvBuf) => {
+            const instance = config.instance;
+            argv >>>= 0;
+            argvBuf >>>= 0;
+            const mem = new Uint8Array(instance.exports.memory.buffer);
+            let argvPos = 0;
+            let argvBufPos = 0;
+            config.envVars.forEach(envVar => {
+                const encoded = new TextEncoder().encode(envVar);
+                buffer.writeUInt32LE(mem, argv + argvPos, argvBuf + argvBufPos);
+                argvPos += 4;
+                mem.set(encoded, argvBuf + argvBufPos);
+                argvBufPos += encoded.length;
+                buffer.writeUInt8(mem, argvBuf + argvBufPos, 0);
+                argvBufPos += 1;
+            });
+            return 0;
+        },
+    };
+};

package/dist/cjs/instance/bindings.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Interface that the Wasm module exports. Contains the functions that are exported by the Rust
+ * code.
+ *
+ * Must match the bindings found in the Rust code.
+ */
+export interface SmoldotWasmExports extends WebAssembly.Exports {
+    memory: WebAssembly.Memory;
+    init: (maxLogLevel: number, enableCurrentTask: number, cpuRateLimit: number, periodicallyYield: number) => void;
+    set_periodically_yield: (periodicallyYield: number) => void;
+    start_shutdown: () => void;
+    alloc: (len: number) => number;
+    add_chain: (chainSpecPointer: number, chainSpecLen: number, databaseContentPointer: number, databaseContentLen: number, jsonRpcRunning: number, potentialRelayChainsPtr: number, potentialRelayChainsLen: number) => number;
+    remove_chain: (chainId: number) => void;
+    chain_is_ok: (chainId: number) => number;
+    chain_error_len: (chainId: number) => number;
+    chain_error_ptr: (chainId: number) => number;
+    json_rpc_send: (textPtr: number, textLen: number, chainId: number) => number;
+    json_rpc_responses_peek: (chainId: number) => number;
+    json_rpc_responses_pop: (chainId: number) => void;
+    timer_finished: (timerId: number) => void;
+    connection_open_single_stream: (connectionId: number, handshakeTy: number) => void;
+    connection_open_multi_stream: (connectionId: number, handshakeTyPtr: number, handshakeTyLen: number) => void;
+    stream_message: (connectionId: number, streamId: number, ptr: number, len: number) => void;
+    connection_stream_opened: (connectionId: number, streamId: number, outbound: number) => void;
+    connection_reset: (connectionId: number, ptr: number, len: number) => void;
+    stream_reset: (connectionId: number, streamId: number) => void;
+}
+export interface SmoldotWasmInstance extends WebAssembly.Instance {
+    readonly exports: SmoldotWasmExports;
+}

package/dist/cjs/instance/bindings.js

@@ -0,0 +1,5 @@
+"use strict";
+// Smoldot
+// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/instance/buffer.d.ts

@@ -0,0 +1,10 @@
+export declare function utf8BytesToString(buffer: Uint8Array, offset: number, length: number): string;
+export declare function readUInt32LE(buffer: Uint8Array, offset: number): number;
+/**
+ * Sets the value of a given byte in the buffer.
+ *
+ * This function is equivalent to `buffer[offset] = value`, except that an exception is thrown
+ * if `offset` is out of range.
+ */
+export declare function writeUInt8(buffer: Uint8Array, offset: number, value: number): void;
+export declare function writeUInt32LE(buffer: Uint8Array, offset: number, value: number): void;