Fixed smoldot westend integration test

.github/workflows/integration-test.yml

@@ -154,26 +154,22 @@ jobs:
           echo "ZOMBIENET_BINARY=zombienet-linux-x64" >> "$GITHUB_ENV"
 
       # Westend parachain
-      - name: Run authorize and store (PAPI, RPC node, Westend parachain)
+      - name: Run authorize and store (PAPI, smoldot, Westend parachain)
         working-directory: examples
         run: |
           export TEST_DIR="$(mktemp -d $GITHUB_WORKSPACE/bulletin-tests-run-XXXXX)/test"
           echo "TEST_DIR=$TEST_DIR" >> "$GITHUB_ENV"
           mkdir -p "$TEST_DIR"
-          just run-authorize-and-store "bulletin-westend-runtime" "ws"
-      - name: Run authorize and store (PAPI, smoldot, Westend parachain)
+          just run-authorize-and-store "bulletin-westend-runtime" "smoldot"
+      - name: Run authorize and store (PAPI, RPC node, Westend parachain)
         working-directory: examples
-        # TODO: remove when smoldot for para is fixed
-        continue-on-error: true
         run: |
           export TEST_DIR="$(mktemp -d $GITHUB_WORKSPACE/bulletin-tests-run-XXXXX)/test"
           echo "TEST_DIR=$TEST_DIR" >> "$GITHUB_ENV"
           mkdir -p "$TEST_DIR"
-          just run-authorize-and-store "bulletin-westend-runtime" "smoldot"
+          just run-authorize-and-store "bulletin-westend-runtime" "ws"
       - name: Run store chunked data + DAG-PB (PJS-API, RPC node, Westend parachain)
         working-directory: examples
-        # TODO: tmp
-        continue-on-error: true
         run: |
           export TEST_DIR="$(mktemp -d $GITHUB_WORKSPACE/bulletin-tests-run-XXXXX)/test"
           echo "TEST_DIR=$TEST_DIR" >> "$GITHUB_ENV"

examples/api.js

@@ -37,31 +37,56 @@ export const TX_MODE_IN_BLOCK = "in-block";
 export const TX_MODE_FINALIZED_BLOCK = "finalized-block";
 export const TX_MODE_IN_POOL = "in-tx-pool";
 
-function waitForTransaction(tx, signer, txName, txMode = TX_MODE_IN_BLOCK) {
+const DEFAULT_TX_TIMEOUT_MS = 120_000; // 2 minutes default timeout
+
+function waitForTransaction(tx, signer, txName, txMode = TX_MODE_IN_BLOCK, timeoutMs = DEFAULT_TX_TIMEOUT_MS) {
     return new Promise((resolve, reject) => {
-        const sub = tx.signSubmitAndWatch(signer).subscribe({
+        let sub;
+        let resolved = false;
+
+        const timeoutId = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                if (sub) sub.unsubscribe();
+                reject(new Error(`${txName} transaction timed out after ${timeoutMs}ms waiting for ${txMode}`));
+            }
+        }, timeoutMs);
+
+        sub = tx.signSubmitAndWatch(signer).subscribe({
             next: (ev) => {
                 console.log(`✅ ${txName} event:`, ev.type);
                 switch (txMode) {
                     case TX_MODE_IN_BLOCK:
                         if (ev.type === "txBestBlocksState" && ev.found) {
                             console.log(`📦 ${txName} included in block:`, ev.block.hash);
-                            sub.unsubscribe();
-                            resolve(ev);
+                            if (!resolved) {
+                                resolved = true;
+                                clearTimeout(timeoutId);
+                                sub.unsubscribe();
+                                resolve(ev);
+                            }
                         }
                         break;
                     case TX_MODE_IN_POOL:
                         if (ev.type === "broadcasted") {
                             console.log(`📦 ${txName} broadcasted with txHash:`, ev.txHash);
-                            sub.unsubscribe();
-                            resolve(ev);
+                            if (!resolved) {
+                                resolved = true;
+                                clearTimeout(timeoutId);
+                                sub.unsubscribe();
+                                resolve(ev);
+                            }
                         }
                         break;
                     case TX_MODE_FINALIZED_BLOCK:
                         if (ev.type === "finalized") {
                             console.log(`📦 ${txName} included in finalized block:`, ev.block.hash);
-                            sub.unsubscribe();
-                            resolve(ev);
+                            if (!resolved) {
+                                resolved = true;
+                                clearTimeout(timeoutId);
+                                sub.unsubscribe();
+                                resolve(ev);
+                            }
                         }
                         break;
 
@@ -71,8 +96,12 @@ function waitForTransaction(tx, signer, txName, txMode = TX_MODE_IN_BLOCK) {
             },
             error: (err) => {
                 console.error(`❌ ${txName} error:`, err);
-                sub.unsubscribe();
-                reject(err);
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeoutId);
+                    sub.unsubscribe();
+                    reject(err);
+                }
             },
             complete: () => {
                 console.log(`✅ ${txName} complete!`);

examples/authorize_and_store_papi_smoldot.js

@@ -5,19 +5,68 @@ import { createClient } from 'polkadot-api';
 import { getSmProvider } from 'polkadot-api/sm-provider';
 import { cryptoWaitReady } from '@polkadot/util-crypto';
 import { authorizeAccount, fetchCid, store } from './api.js';
-import { setupKeyringAndSigners } from './common.js';
+import { setupKeyringAndSigners, waitForChainReady } from './common.js';
 import { cidFromBytes } from "./cid_dag_metadata.js";
 import { bulletin } from './.papi/descriptors/dist/index.mjs';
 
 // Constants
 const SYNC_WAIT_SEC = 15;
-const SMOLDOT_LOG_LEVEL = 3; // 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
+const SMOLDOT_LOG_LEVEL = 4; // 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
 const HTTP_IPFS_API = 'http://127.0.0.1:8080'   // Local IPFS HTTP gateway
 
+/**
+ * Converts TCP bootnodes to WebSocket bootnodes for smoldot compatibility.
+ * Uses convention: WebSocket port = TCP p2p_port + 1
+ *
+ * Example: /ip4/127.0.0.1/tcp/30333/p2p/PEER_ID
+ *       -> /ip4/127.0.0.1/tcp/30334/ws/p2p/PEER_ID
+ */
+function convertBootNodesToWebSocket(bootNodes) {
+    if (!bootNodes || bootNodes.length === 0) {
+        return [];
+    }
+
+    const wsBootNodes = [];
+    for (const addr of bootNodes) {
+        // Parse multiaddr: /ip4/HOST/tcp/PORT/p2p/PEER_ID or /ip4/HOST/tcp/PORT/ws/p2p/PEER_ID
+        const tcpMatch = addr.match(/^(\/ip[46]\/[^/]+)\/tcp\/(\d+)\/p2p\/(.+)$/);
+        if (tcpMatch) {
+            const [, hostPart, portStr, peerId] = tcpMatch;
+            const tcpPort = parseInt(portStr, 10);
+            const wsPort = tcpPort + 1; // Convention: WS port = TCP port + 1
+            const wsAddr = `${hostPart}/tcp/${wsPort}/ws/p2p/${peerId}`;
+            wsBootNodes.push(wsAddr);
+            console.log(`  📡 Converted: tcp/${tcpPort} -> tcp/${wsPort}/ws`);
+        }
+        // Check if already a WebSocket address
+        const wsMatch = addr.match(/\/tcp\/\d+\/ws\/p2p\//);
+        if (wsMatch) {
+            wsBootNodes.push(addr);
+            console.log(`  ✅ Already WebSocket: ${addr.substring(0, 50)}...`);
+        }
+    }
+    return wsBootNodes;
+}
+
 function readChainSpec(chainspecPath) {
     const chainSpecContent = readFileSync(chainspecPath, 'utf8');
     const chainSpecObj = JSON.parse(chainSpecContent);
     chainSpecObj.protocolId = null;
+
+    // Convert TCP bootnodes to WebSocket for smoldot
+    if (chainSpecObj.bootNodes && chainSpecObj.bootNodes.length > 0) {
+        console.log(`🔄 Converting ${chainSpecObj.bootNodes.length} bootnode(s) to WebSocket for smoldot...`);
+        const wsBootNodes = convertBootNodesToWebSocket(chainSpecObj.bootNodes);
+        if (wsBootNodes.length > 0) {
+            chainSpecObj.bootNodes = wsBootNodes;
+            console.log(`✅ Using ${wsBootNodes.length} WebSocket bootnode(s)`);
+        } else {
+            console.log(`⚠️ No bootnodes could be converted to WebSocket`);
+        }
+    } else {
+        console.log(`⚠️ No bootnodes found in chain spec: ${chainspecPath}`);
+    }
+
     return JSON.stringify(chainSpecObj);
 }
 
@@ -33,34 +82,55 @@ function initSmoldot() {
     return sd;
 }
 
-async function createSmoldotClient(chainspecPath) {
-    const chainSpec = readChainSpec(chainspecPath);
+async function createSmoldotClient(chainSpecPath, parachainSpecPath = null) {
     const sd = initSmoldot();
-    const chain = await sd.addChain({ chainSpec });
-    const client = createClient(getSmProvider(chain));
 
+    const chainSpec = readChainSpec(chainSpecPath);
+    const mainChain = await sd.addChain({ chainSpec });
+    console.log(`✅ Added main chain: ${chainSpecPath}`);
+
+    if (parachainSpecPath) {
+        const parachainSpec = readChainSpec(parachainSpecPath);
+        const parachain = await sd.addChain({
+            chainSpec: parachainSpec,
+            potentialRelayChains: [mainChain]
+        });
+        console.log(`✅ Added parachain: ${parachainSpecPath}`);
+        const client = createClient(getSmProvider(parachain));
+        return { client, sd };
+    }
+
+    const client = createClient(getSmProvider(mainChain));
     return { client, sd };
 }
 
 async function main() {
     await cryptoWaitReady();
 
-    // Get chainspec path from command line argument
-    const chainspecPath = process.argv[2];
-    if (!chainspecPath) {
-        console.error('❌ Error: Chainspec path is required as first argument');
-        console.error('Usage: node authorize_and_store_papi_smoldot.js <chainspec-path>');
+    // Get chainspec path from command line argument (required - main chain: relay for para, or solo)
+    const chainSpecPath = process.argv[2];
+    if (!chainSpecPath) {
+        console.error('❌ Error: Chain spec path is required as first argument');
+        console.error('Usage: node authorize_and_store_papi_smoldot.js <chain-spec-path> [parachain-spec-path]');
+        console.error('  For parachains: <relay-chain-spec-path> <parachain-spec-path>');
+        console.error('  For solochains: <solo-chain-spec-path>');
         process.exit(1);
     }
 
+    // Optional parachain chainspec path (only needed for parachains)
+    const parachainSpecPath = process.argv[3] || null;
+
     let sd, client, resultCode;
     try {
         // Init Smoldot PAPI client and typed api.
-        ({ client, sd } = await createSmoldotClient(chainspecPath));
+        ({ client, sd } = await createSmoldotClient(chainSpecPath, parachainSpecPath));
         console.log(`⏭️ Waiting ${SYNC_WAIT_SEC} seconds for smoldot to sync...`);
         // TODO: check better way, when smoldot is synced, maybe some RPC/runtime api that checks best vs finalized block?        
         await new Promise(resolve => setTimeout(resolve, SYNC_WAIT_SEC * 1000));
+
+        console.log('🔍 Checking if chain is ready...');
         const bulletinAPI = client.getTypedApi(bulletin);
+        await waitForChainReady(bulletinAPI);
 
         // Signers.
         const { sudoSigner, whoSigner, whoAddress } = setupKeyringAndSigners('//Alice', '//Alice');

examples/common.js

@@ -118,3 +118,28 @@ export class NonceManager {
         return current;
     }
 }
+
+/**
+ * Wait for a PAPI typed API chain to be ready by checking runtime constants.
+ * Retries until the chain is ready or max retries reached.
+ */
+export async function waitForChainReady(typedApi, maxRetries = 10, retryDelayMs = 2000) {
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            // Check runtime constants to verify chain is accessible
+            const version = typedApi.constants.System.Version;
+            console.log(`✅ Chain is ready! Runtime: ${version.spec_name} v${version.spec_version}`);
+            return true;
+        } catch (error) {
+            if (attempt < maxRetries) {
+                console.log(`⏳ Chain not ready yet (attempt ${attempt}/${maxRetries}), retrying in ${retryDelayMs/1000}s... Error: ${error.message}`);
+                await new Promise(resolve => setTimeout(resolve, retryDelayMs));
+            } else {
+                console.log(`⚠️ Chain readiness check failed after ${maxRetries} attempts. Proceeding anyway... Error: ${error.message}`);
+                return false;
+            }
+        }
+    }
+    return false;
+}

examples/justfile

@@ -387,11 +387,14 @@ run-authorize-and-store runtime mode="ws": npm-install
     if [ "{{ mode }}" = "smoldot" ]; then
         # Set chainspec path based on runtime
         if [ "{{ runtime }}" = "bulletin-westend-runtime" ]; then
-            CHAINSPEC_PATH="$TEST_DIR/bulletin-westend-collator-1/cfg/westend-local-1006.json"
-        else # bulletin-polkadot-runtime
+            # Parachain: relay chain (required) + parachain spec (optional)
+            RELAY_CHAINSPEC_PATH="$TEST_DIR/bob/cfg/westend-local.json"
+            PARACHAIN_CHAINSPEC_PATH="$TEST_DIR/bulletin-westend-collator-2/cfg/westend-local-1006.json"
+            node $SCRIPT_NAME "$RELAY_CHAINSPEC_PATH" "$PARACHAIN_CHAINSPEC_PATH"
+        else # bulletin-polkadot-runtime (solochain)
             CHAINSPEC_PATH="$TEST_DIR/bob/cfg/bulletin-polkadot-local.json"
+            node $SCRIPT_NAME "$CHAINSPEC_PATH"
         fi
-        node $SCRIPT_NAME "$CHAINSPEC_PATH"
     else
         node $SCRIPT_NAME
     fi

runtimes/bulletin-westend/Cargo.toml

@@ -67,7 +67,7 @@ xcm-runtime-apis = { workspace = true }
 
 # Cumulus
 cumulus-pallet-aura-ext = { workspace = true }
-cumulus-pallet-parachain-system = { workspace = true }
+cumulus-pallet-parachain-system = { features = ["transaction-index"], workspace = true }
 cumulus-pallet-session-benchmarking = { workspace = true }
 cumulus-pallet-weight-reclaim = { workspace = true }
 cumulus-pallet-xcm = { workspace = true }

zombienet/bulletin-westend-local.toml

@@ -15,14 +15,20 @@ chain = "westend-local"
 [[relaychain.nodes]]
 name = "alice"
 validator = true
+p2p_port = 30333
 rpc_port = 9942
 balance = 2000000000000
+# WebSocket P2P on p2p_port + 1 for smoldot light client support
+args = ["--listen-addr", "/ip4/0.0.0.0/tcp/30334/ws"]
 
 [[relaychain.nodes]]
 name = "bob"
 validator = true
+p2p_port = 30433
 rpc_port = 9943
 balance = 2000000000000
+# WebSocket P2P on p2p_port + 1 for smoldot light client support
+args = ["--listen-addr", "/ip4/0.0.0.0/tcp/30434/ws"]
 
 [[parachains]]
 id = 1006
@@ -38,6 +44,9 @@ rpc_port = 10000
 args = [
 	"--ipfs-server",
 	"-lparachain=debug,runtime=trace,xcm=trace,bitswap=trace,sub-libp2p::bitswap=trace",
+	# WebSocket P2P on p2p_port + 1 for smoldot light client support
+	"--listen-addr",
+	"/ip4/0.0.0.0/tcp/10002/ws",
 ]
 
 [[parachains.collators]]
@@ -49,4 +58,7 @@ rpc_port = 12346
 args = [
 	"--ipfs-server",
 	"-lparachain=debug,runtime=trace,xcm=trace,bitswap=trace,sub-libp2p::bitswap=trace",
+	# WebSocket P2P on p2p_port + 1 for smoldot light client support
+	"--listen-addr",
+	"/ip4/0.0.0.0/tcp/12348/ws",
 ]