smoldot 2.0.18 → 2.0.20

package/dist/cjs/internals/client.js

@@ -66,7 +66,8 @@ function start(options, wasmModule, platformBindings) {
         instance: { status: "not-created" },
         chainIds: new WeakMap(),
         connections: new Map(),
-        addChainResults: [],
+        addChainIdAllocations: [],
+        addChainResults: new Map(),
         onExecutorShutdownOrWasmPanic: () => { },
         chains: new Map(),
     };
@@ -85,10 +86,14 @@ function start(options, wasmModule, platformBindings) {
                 };
                 state.connections.forEach((connec) => connec.reset());
                 state.connections.clear();
-                for (const addChainResult of state.addChainResults) {
+                for (const addChainResult of state.addChainIdAllocations) {
                     addChainResult({ success: false, error: "Smoldot has crashed" });
                 }
-                state.addChainResults = [];
+                state.addChainIdAllocations = [];
+                state.addChainResults.forEach((addChainResult) => {
+                    addChainResult({ success: false, error: "Smoldot has crashed" });
+                });
+                state.addChainResults.clear();
                 for (const chain of Array.from(state.chains.values())) {
                     for (const callback of chain.jsonRpcResponsesPromises) {
                         callback();
@@ -111,8 +116,14 @@ function start(options, wasmModule, platformBindings) {
                 logCallback(event.level, event.target, event.message);
                 break;
             }
+            case "add-chain-id-allocated": {
+                const callback = state.addChainIdAllocations.shift();
+                state.addChainResults.set(event.chainId, callback);
+                break;
+            }
             case "add-chain-result": {
-                (state.addChainResults.shift())(event);
+                (state.addChainResults.get(event.chainId))(event);
+                state.addChainResults.delete(event.chainId);
                 break;
             }
             case "json-rpc-responses-non-empty": {
@@ -290,7 +301,7 @@ function start(options, wasmModule, platformBindings) {
             // Sanitize `databaseContent`.
             if (options.databaseContent !== undefined && typeof options.databaseContent !== 'string')
                 throw new public_types_js_1.AddChainError("`databaseContent` is not a string");
-            const promise = new Promise((resolve) => state.addChainResults.push(resolve));
+            const promise = new Promise((resolve) => state.addChainIdAllocations.push(resolve));
             state.instance.instance.addChain(options.chainSpec, options.databaseContent || "", potentialRelayChainsIds, !!options.disableJsonRpc, jsonRpcMaxPendingRequests, jsonRpcMaxSubscriptions);
             const outcome = yield promise;
             if (!outcome.success)
@@ -371,10 +382,14 @@ function start(options, wasmModule, platformBindings) {
                 state.instance = { status: "destroyed", error: new public_types_js_1.AlreadyDestroyedError() };
             state.connections.forEach((connec) => connec.reset());
             state.connections.clear();
-            for (const addChainResult of state.addChainResults) {
+            for (const addChainResult of state.addChainIdAllocations) {
                 addChainResult({ success: false, error: "Client.terminate() has been called" });
             }
-            state.addChainResults = [];
+            state.addChainIdAllocations = [];
+            state.addChainResults.forEach((addChainResult) => {
+                addChainResult({ success: false, error: "Client.terminate() has been called" });
+            });
+            state.addChainResults.clear();
             for (const chain of Array.from(state.chains.values())) {
                 for (const callback of chain.jsonRpcResponsesPromises) {
                     callback();

package/dist/cjs/internals/local-instance.d.ts

@@ -30,11 +30,15 @@ export interface Config {
     getRandomValues: (buffer: Uint8Array) => void;
 }
 export type Event = {
+    ty: "add-chain-id-allocated";
+    chainId: number;
+} | {
     ty: "add-chain-result";
-    success: true;
     chainId: number;
+    success: true;
 } | {
     ty: "add-chain-result";
+    chainId: number;
     success: false;
     error: string;
 } | {
@@ -92,6 +96,15 @@ export type ParsedMultiaddr = {
 export interface Instance {
     request: (request: string, chainId: number) => number;
     peekJsonRpcResponse: (chainId: number) => string | null;
+    /**
+     * Later generates a `add-chain-id-allocated` event.
+     * If this function is called multiple times, the `add-chain-id-allocated` events are generated
+     * in the same order as the function calls.
+     *
+     * Then, later and asynchronously, a `add-chain-result` event is generated in order to
+     * indicate whether the initialization was actually successful. If `success` is `false`, then
+     * the `chainId` becomes unallocated.
+     */
     addChain: (chainSpec: string, databaseContent: string, potentialRelayChains: number[], disableJsonRpc: boolean, jsonRpcMaxPendingRequests: number, jsonRpcMaxSubscriptions: number) => void;
     removeChain: (chainId: number) => void;
     /**

package/dist/cjs/internals/local-instance.js

@@ -59,6 +59,19 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                 state.onShutdownExecutorOrWasmPanic = () => { };
                 throw new Error();
             },
+            chain_initialized: (chainId, errorMsgPtr, errorMsgLen) => {
+                const instance = state.instance;
+                const mem = new Uint8Array(instance.exports.memory.buffer);
+                errorMsgPtr >>>= 0;
+                errorMsgLen >>>= 0;
+                if (errorMsgPtr === 0) {
+                    eventCallback({ ty: "add-chain-result", chainId, success: true });
+                }
+                else {
+                    const errorMsg = buffer.utf8BytesToString(mem, errorMsgPtr, errorMsgLen);
+                    eventCallback({ ty: "add-chain-result", chainId, success: false, error: errorMsg });
+                }
+            },
             random_get: (ptr, len) => {
                 const instance = state.instance;
                 ptr >>>= 0;
@@ -368,7 +381,8 @@ function startLocalInstance(config, wasmModule, eventCallback) {
             },
             addChain: (chainSpec, databaseContent, potentialRelayChains, disableJsonRpc, jsonRpcMaxPendingRequests, jsonRpcMaxSubscriptions) => {
                 if (!state.instance) {
-                    eventCallback({ ty: "add-chain-result", success: false, error: "Smoldot has crashed" });
+                    eventCallback({ ty: "add-chain-id-allocated", chainId: 0 });
+                    eventCallback({ ty: "add-chain-result", chainId: 0, success: false, error: "Smoldot has crashed" });
                     return;
                 }
                 // The caller is supposed to avoid this situation.
@@ -387,16 +401,7 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                 delete state.bufferIndices[0];
                 delete state.bufferIndices[1];
                 delete state.bufferIndices[2];
-                if (state.instance.exports.chain_is_ok(chainId) != 0) {
-                    eventCallback({ ty: "add-chain-result", success: true, chainId });
-                }
-                else {
-                    const errorMsgLen = state.instance.exports.chain_error_len(chainId) >>> 0;
-                    const errorMsgPtr = state.instance.exports.chain_error_ptr(chainId) >>> 0;
-                    const errorMsg = buffer.utf8BytesToString(new Uint8Array(state.instance.exports.memory.buffer), errorMsgPtr, errorMsgLen);
-                    state.instance.exports.remove_chain(chainId);
-                    eventCallback({ ty: "add-chain-result", success: false, error: errorMsg });
-                }
+                eventCallback({ ty: "add-chain-id-allocated", chainId });
             },
             removeChain: (chainId) => {
                 if (!state.instance)