smoldot 1.0.1 → 1.0.3

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

@@ -2,9 +2,11 @@ import type { SmoldotWasmInstance } from './bindings.js';
 export interface Config {
     instance?: SmoldotWasmInstance;
     /**
-     * Returns the number of milliseconds since an arbitrary epoch.
+     * Array used to store the buffers provided to the Rust code.
+     *
+     * When `buffer_size` or `buffer_index` are called, the buffer is found here.
      */
-    performanceNow: () => number;
+    bufferIndices: Array<Uint8Array>;
     /**
      * Tries to open a new connection using the given configuration.
      *
@@ -65,7 +67,7 @@ export interface Connection {
      *
      * The connection and stream must currently be in the `Open` state.
      *
-     * The number of bytes most never exceed the number of "writable bytes" of the stream.
+     * The number of bytes must never exceed the number of "writable bytes" of the stream.
      * `onWritableBytes` can be used in order to notify that more writable bytes are available.
      *
      * The `streamId` must be provided if and only if the connection is of type "multi-stream".
@@ -154,7 +156,8 @@ export interface ConnectionConfig {
      */
     onStreamReset: (streamId: number) => void;
     /**
-     * Callback called when more data can be written on the stream.
+     * Callback called when some data sent using {@link Connection.send} has effectively been
+     * written on the stream, meaning that some buffer space is now free.
      *
      * Can only happen while the connection is in the `Open` state.
      *
@@ -162,6 +165,9 @@ export interface ConnectionConfig {
      *
      * The `streamId` parameter must be provided if and only if the connection is of type
      * "multi-stream".
+     *
+     * Only a number of bytes equal to the size of the data provided to {@link Connection.send}
+     * must be reported. In other words, the `initialWritableBytes` must never be exceeded.
      */
     onWritableBytes: (numExtra: number, streamId?: number) => void;
     /**

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

@@ -51,6 +51,16 @@ export default function (config) {
             const message = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), ptr, len);
             config.onPanic(message);
         },
+        buffer_size: (bufferIndex) => {
+            const buf = config.bufferIndices[bufferIndex];
+            return buf.byteLength;
+        },
+        buffer_copy: (bufferIndex, targetPtr) => {
+            const instance = config.instance;
+            targetPtr = targetPtr >>> 0;
+            const buf = config.bufferIndices[bufferIndex];
+            new Uint8Array(instance.exports.memory.buffer).set(buf, targetPtr);
+        },
         // 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) => {
@@ -75,10 +85,6 @@ export default function (config) {
                 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)
@@ -116,11 +122,11 @@ export default function (config) {
         },
         // Must create a new connection object. This implementation stores the created object in
         // `connections`.
-        connection_new: (connectionId, addrPtr, addrLen, errorPtrPtr) => {
+        connection_new: (connectionId, addrPtr, addrLen, errorBufferIndexPtr) => {
             const instance = config.instance;
             addrPtr >>>= 0;
             addrLen >>>= 0;
-            errorPtrPtr >>>= 0;
+            errorBufferIndexPtr >>>= 0;
             if (!!connections[connectionId]) {
                 throw new Error("internal error: connection already allocated");
             }
@@ -140,13 +146,13 @@ export default function (config) {
                                     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);
+                                    const handshakeTy = new Uint8Array(1 + info.localTlsCertificateMultihash.length + info.remoteTlsCertificateMultihash.length);
+                                    buffer.writeUInt8(handshakeTy, 0, 0);
+                                    handshakeTy.set(info.localTlsCertificateMultihash, 1);
+                                    handshakeTy.set(info.remoteTlsCertificateMultihash, 1 + info.localTlsCertificateMultihash.length);
+                                    config.bufferIndices[0] = handshakeTy;
+                                    instance.exports.connection_open_multi_stream(connectionId, 0);
+                                    delete config.bufferIndices[0];
                                     break;
                                 }
                             }
@@ -157,10 +163,9 @@ export default function (config) {
                         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);
+                            config.bufferIndices[0] = new TextEncoder().encode(message);
+                            instance.exports.connection_reset(connectionId, 0);
+                            delete config.bufferIndices[0];
                         }
                         catch (_error) { }
                     },
@@ -176,9 +181,9 @@ export default function (config) {
                         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);
+                            config.bufferIndices[0] = message;
+                            instance.exports.stream_message(connectionId, streamId || 0, 0);
+                            delete config.bufferIndices[0];
                         }
                         catch (_error) { }
                     },
@@ -209,12 +214,9 @@ export default function (config) {
                     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);
+                config.bufferIndices[0] = new TextEncoder().encode(errorStr);
+                buffer.writeUInt32LE(mem, errorBufferIndexPtr, 0);
+                buffer.writeUInt8(mem, errorBufferIndexPtr + 4, isBadAddress ? 1 : 0);
                 return 1;
             }
         },

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

@@ -5,6 +5,10 @@ export interface Config {
      * Fills the given buffer with randomly-generated bytes.
      */
     getRandomValues: (buffer: Uint8Array) => void;
+    /**
+     * Returns the number of milliseconds since an arbitrary epoch.
+     */
+    performanceNow: () => number;
     /**
      * List of environment variables to feed to the Rust program. An array of strings.
      * Example: `["RUST_BACKTRACE=1", "RUST_LOG=foo"];`

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

@@ -39,6 +39,36 @@ export default (config) => {
             }
             return 0;
         },
+        clock_time_get: (clockId, _precision, outPtr) => {
+            // See <https://github.com/rust-lang/rust/blob/master/library/std/src/sys/wasi/time.rs>
+            // and <docs.rs/wasi/> for help.
+            const instance = config.instance;
+            const mem = new Uint8Array(instance.exports.memory.buffer);
+            outPtr >>>= 0;
+            // We ignore the precision, as it can't be implemented anyway.
+            switch (clockId) {
+                case 0: {
+                    // Realtime clock.
+                    const now = BigInt(Math.floor(Date.now())) * BigInt(1000000);
+                    buffer.writeUInt64LE(mem, outPtr, now);
+                    // Success.
+                    return 0;
+                }
+                case 1: {
+                    // Monotonic clock.
+                    const nowMs = config.performanceNow();
+                    const nowMsInt = Math.floor(nowMs);
+                    const now = BigInt(nowMsInt) * BigInt(1000000) +
+                        BigInt(Math.floor(((nowMs - nowMsInt) * 1000000)));
+                    buffer.writeUInt64LE(mem, outPtr, now);
+                    // Success.
+                    return 0;
+                }
+                default:
+                    // Return an `EINVAL` error.
+                    return 28;
+            }
+        },
         // Writing to a file descriptor is used in order to write to stdout/stderr.
         fd_write: (fd, addr, num, outPtr) => {
             const instance = config.instance;

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

@@ -9,22 +9,21 @@ export interface SmoldotWasmExports extends WebAssembly.Exports {
     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;
+    add_chain: (chainSpecBufferIndex: number, databaseContentBufferIndex: number, jsonRpcRunning: number, potentialRelayChainsBufferIndex: 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_send: (textBufferIndex: 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, initialWritableBytes: number, writeClosable: number) => void;
-    connection_open_multi_stream: (connectionId: number, handshakeTyPtr: number, handshakeTyLen: number) => void;
+    connection_open_multi_stream: (connectionId: number, handshakeTyBufferIndex: number) => void;
     stream_writable_bytes: (connectionId: number, streamId: number, numBytes: number) => void;
-    stream_message: (connectionId: number, streamId: number, ptr: number, len: number) => void;
+    stream_message: (connectionId: number, streamId: number, bufferIndex: number) => void;
     connection_stream_opened: (connectionId: number, streamId: number, outbound: number, initialWritableBytes: number) => void;
-    connection_reset: (connectionId: number, ptr: number, len: number) => void;
+    connection_reset: (connectionId: number, bufferIndex: number) => void;
     stream_reset: (connectionId: number, streamId: number) => void;
 }
 export interface SmoldotWasmInstance extends WebAssembly.Instance {

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

@@ -8,3 +8,4 @@ export declare function readUInt32LE(buffer: Uint8Array, offset: number): number
  */
 export declare function writeUInt8(buffer: Uint8Array, offset: number, value: number): void;
 export declare function writeUInt32LE(buffer: Uint8Array, offset: number, value: number): void;
+export declare function writeUInt64LE(buffer: Uint8Array, offset: number, value: bigint): void;

package/dist/mjs/instance/buffer.js

@@ -38,6 +38,17 @@ export function writeUInt32LE(buffer, offset, value) {
     buffer[offset + 1] = (value >>> 8) & 0xff;
     buffer[offset] = value & 0xff;
 }
+export function writeUInt64LE(buffer, offset, value) {
+    checkRange(buffer, offset, 8);
+    buffer[offset + 7] = Number((value >> BigInt(56)) & BigInt(0xff));
+    buffer[offset + 6] = Number((value >> BigInt(48)) & BigInt(0xff));
+    buffer[offset + 5] = Number((value >> BigInt(40)) & BigInt(0xff));
+    buffer[offset + 4] = Number((value >> BigInt(32)) & BigInt(0xff));
+    buffer[offset + 3] = Number((value >> BigInt(24)) & BigInt(0xff));
+    buffer[offset + 2] = Number((value >> BigInt(16)) & BigInt(0xff));
+    buffer[offset + 1] = Number((value >> BigInt(8)) & BigInt(0xff));
+    buffer[offset] = Number(value & BigInt(0xff));
+}
 function checkRange(buffer, offset, length) {
     if (!Number.isInteger(offset) || offset < 0)
         throw new RangeError();

package/dist/mjs/instance/instance.js

@@ -97,7 +97,7 @@ export function start(configMessage, platformBindings) {
         cpuRateLimit: configMessage.cpuRateLimit,
     };
     state = {
-        initialized: false, promise: instance.startInstance(config, platformBindings).then((instance) => {
+        initialized: false, promise: instance.startInstance(config, platformBindings).then(([instance, bufferIndices]) => {
             // `config.cpuRateLimit` is a floating point that should be between 0 and 1, while the value
             // to pass as parameter must be between `0` and `2^32-1`.
             // The few lines of code below should handle all possible values of `number`, including
@@ -120,8 +120,8 @@ export function start(configMessage, platformBindings) {
                 }
             });
             instance.exports.init(configMessage.maxLogLevel, configMessage.enableCurrentTask ? 1 : 0, cpuRateLimit, periodicallyYield ? 1 : 0);
-            state = { initialized: true, instance, unregisterCallback };
-            return instance;
+            state = { initialized: true, instance, bufferIndices, unregisterCallback };
+            return [instance, bufferIndices];
         })
     };
     function queueOperation(operation) {
@@ -131,11 +131,11 @@ export function start(configMessage, platformBindings) {
             if (!state.initialized) {
                 // A message has been received while the Wasm VM is still initializing. Queue it for when
                 // initialization is over.
-                return state.promise.then((instance) => operation(instance));
+                return state.promise.then(([instance, bufferIndices]) => operation(instance, bufferIndices));
             }
             else {
                 // Everything is already initialized. Process the message synchronously.
-                return operation(state.instance);
+                return operation(state.instance, state.bufferIndices);
             }
         });
     }
@@ -150,10 +150,8 @@ export function start(configMessage, platformBindings) {
                 throw crashError.error;
             let retVal;
             try {
-                const encoded = new TextEncoder().encode(request);
-                const ptr = state.instance.exports.alloc(encoded.length) >>> 0;
-                new Uint8Array(state.instance.exports.memory.buffer).set(encoded, ptr);
-                retVal = state.instance.exports.json_rpc_send(ptr, encoded.length, chainId) >>> 0;
+                state.bufferIndices[0] = new TextEncoder().encode(request);
+                retVal = state.instance.exports.json_rpc_send(0, chainId) >>> 0;
             }
             catch (_error) {
                 console.assert(crashError.error);
@@ -200,29 +198,25 @@ export function start(configMessage, platformBindings) {
             }
         }),
         addChain: (chainSpec, databaseContent, potentialRelayChains, disableJsonRpc) => {
-            return queueOperation((instance) => {
+            return queueOperation((instance, bufferIndices) => {
                 if (crashError.error)
                     throw crashError.error;
                 try {
-                    // Write the chain specification into memory.
-                    const chainSpecEncoded = new TextEncoder().encode(chainSpec);
-                    const chainSpecPtr = instance.exports.alloc(chainSpecEncoded.length) >>> 0;
-                    new Uint8Array(instance.exports.memory.buffer).set(chainSpecEncoded, chainSpecPtr);
-                    // Write the database content into memory.
-                    const databaseContentEncoded = new TextEncoder().encode(databaseContent);
-                    const databaseContentPtr = instance.exports.alloc(databaseContentEncoded.length) >>> 0;
-                    new Uint8Array(instance.exports.memory.buffer).set(databaseContentEncoded, databaseContentPtr);
-                    // Write the potential relay chains into memory.
-                    const potentialRelayChainsLen = potentialRelayChains.length;
-                    const potentialRelayChainsPtr = instance.exports.alloc(potentialRelayChainsLen * 4) >>> 0;
-                    for (let idx = 0; idx < potentialRelayChains.length; ++idx) {
-                        buffer.writeUInt32LE(new Uint8Array(instance.exports.memory.buffer), potentialRelayChainsPtr + idx * 4, potentialRelayChains[idx]);
-                    }
                     // `add_chain` unconditionally allocates a chain id. If an error occurs, however, this chain
                     // id will refer to an *erroneous* chain. `chain_is_ok` is used below to determine whether it
                     // has succeeeded or not.
                     // Note that `add_chain` properly de-allocates buffers even if it failed.
-                    const chainId = instance.exports.add_chain(chainSpecPtr, chainSpecEncoded.length, databaseContentPtr, databaseContentEncoded.length, disableJsonRpc ? 0 : 1, potentialRelayChainsPtr, potentialRelayChainsLen);
+                    bufferIndices[0] = new TextEncoder().encode(chainSpec);
+                    bufferIndices[1] = new TextEncoder().encode(databaseContent);
+                    const potentialRelayChainsEncoded = new Uint8Array(potentialRelayChains.length * 4);
+                    for (let idx = 0; idx < potentialRelayChains.length; ++idx) {
+                        buffer.writeUInt32LE(potentialRelayChainsEncoded, idx * 4, potentialRelayChains[idx]);
+                    }
+                    bufferIndices[2] = potentialRelayChainsEncoded;
+                    const chainId = instance.exports.add_chain(0, 1, disableJsonRpc ? 0 : 1, 2);
+                    delete bufferIndices[0];
+                    delete bufferIndices[1];
+                    delete bufferIndices[2];
                     if (instance.exports.chain_is_ok(chainId) != 0) {
                         console.assert(!chains.has(chainId));
                         chains.set(chainId, {

package/dist/mjs/instance/raw-instance.d.ts

@@ -62,4 +62,4 @@ export interface PlatformBindings {
      */
     connect(config: ConnectionConfig): Connection;
 }
-export declare function startInstance(config: Config, platformBindings: PlatformBindings): Promise<SmoldotWasmInstance>;
+export declare function startInstance(config: Config, platformBindings: PlatformBindings): Promise<[SmoldotWasmInstance, Array<Uint8Array>]>;

package/dist/mjs/instance/raw-instance.js

@@ -32,8 +32,9 @@ export function startInstance(config, platformBindings) {
         // cross-platform cross-bundler approach.
         const wasmBytecode = yield platformBindings.trustedBase64DecodeAndZlibInflate(wasmBase64);
         let killAll;
+        const bufferIndices = new Array;
         // Used to bind with the smoldot-light bindings. See the `bindings-smoldot-light.js` file.
-        const smoldotJsConfig = Object.assign({ performanceNow: platformBindings.performanceNow, connect: platformBindings.connect, onPanic: (message) => {
+        const smoldotJsConfig = Object.assign({ bufferIndices, connect: platformBindings.connect, onPanic: (message) => {
                 killAll();
                 config.onWasmPanic(message);
                 throw new Error();
@@ -42,6 +43,7 @@ export function startInstance(config, platformBindings) {
         const wasiConfig = {
             envVars: [],
             getRandomValues: platformBindings.getRandomValues,
+            performanceNow: platformBindings.performanceNow,
             onProcExit: (retCode) => {
                 killAll();
                 config.onWasmPanic(`proc_exit called: ${retCode}`);
@@ -62,6 +64,6 @@ export function startInstance(config, platformBindings) {
         const instance = result.instance;
         smoldotJsConfig.instance = instance;
         wasiConfig.instance = instance;
-        return instance;
+        return [instance, bufferIndices];
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoldot",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Light client that connects to Polkadot and Substrate-based blockchains",
   "author": "Parity Technologies <admin@parity.io>",
   "license": "GPL-3.0-or-later WITH Classpath-exception-2.0",
@@ -46,8 +46,8 @@
     "@types/ws": "^8.5.3",
     "ava": "^5.0.1",
     "dtslint": "^4.0.6",
-    "rimraf": "^4.1.2",
-    "typedoc": "^0.23.15",
+    "rimraf": "^5.0.0",
+    "typedoc": "^0.24.1",
     "typescript": "^5.0.2"
   }
 }