Fixed smoldot westend integration test

.github/workflows/integration-test.yml

@@ -42,6 +42,7 @@ jobs:
           components: rust-src
       - name: Install system dependencies
         run: |
+          sudo rm -f /etc/apt/sources.list.d/microsoft-prod.list /etc/apt/sources.list.d/azure-cli.list
           sudo apt-get update
           sudo apt-get install -y protobuf-compiler libclang-dev
 
@@ -112,6 +113,7 @@ jobs:
 
       - name: Install system dependencies
         run: |
+          sudo rm -f /etc/apt/sources.list.d/microsoft-prod.list /etc/apt/sources.list.d/azure-cli.list
           sudo apt-get update
           sudo apt-get install -y protobuf-compiler libclang-dev
 
@@ -154,26 +156,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,42 +37,61 @@ 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 = 60_000; // 60 seconds or 10 blocks
+
+const TX_MODE_CONFIG = {
+    [TX_MODE_IN_BLOCK]: {
+        match: (ev) => ev.type === "txBestBlocksState" && ev.found,
+        log: (txName, ev) => `📦 ${txName} included in block: ${ev.block.hash}`,
+    },
+    [TX_MODE_IN_POOL]: {
+        match: (ev) => ev.type === "broadcasted",
+        log: (txName, ev) => `📦 ${txName} broadcasted with txHash: ${ev.txHash}`,
+    },
+    [TX_MODE_FINALIZED_BLOCK]: {
+        match: (ev) => ev.type === "finalized",
+        log: (txName, ev) => `📦 ${txName} included in finalized block: ${ev.block.hash}`,
+    },
+};
+
+function waitForTransaction(tx, signer, txName, txMode = TX_MODE_IN_BLOCK, timeoutMs = DEFAULT_TX_TIMEOUT_MS) {
+    const config = TX_MODE_CONFIG[txMode];
+    if (!config) {
+        return Promise.reject(new Error(`Unhandled txMode: ${txMode}`));
+    }
+
     return new Promise((resolve, reject) => {
-        const sub = tx.signSubmitAndWatch(signer).subscribe({
+        let sub;
+        let resolved = false;
+
+        const cleanup = () => {
+            resolved = true;
+            clearTimeout(timeoutId);
+            if (sub) sub.unsubscribe();
+        };
+
+        const timeoutId = setTimeout(() => {
+            if (!resolved) {
+                cleanup();
+                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);
-                        }
-                        break;
-                    case TX_MODE_IN_POOL:
-                        if (ev.type === "broadcasted") {
-                            console.log(`📦 ${txName} broadcasted with txHash:`, ev.txHash);
-                            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);
-                        }
-                        break;
-
-                    default:
-                        throw new Error("Unhandled txMode: " + txMode)
+                if (!resolved && config.match(ev)) {
+                    console.log(config.log(txName, ev));
+                    cleanup();
+                    resolve(ev);
                 }
             },
             error: (err) => {
                 console.error(`❌ ${txName} error:`, err);
-                sub.unsubscribe();
-                reject(err);
+                if (!resolved) {
+                    cleanup();
+                    reject(err);
+                }
             },
             complete: () => {
                 console.log(`✅ ${txName} complete!`);

examples/authorize_and_store_papi_smoldot.js

@@ -5,62 +5,120 @@ 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
 
+const TCP_BOOTNODE_REGEX = /^(\/ip[46]\/[^/]+)\/tcp\/(\d+)\/p2p\/(.+)$/;
+const WS_BOOTNODE_REGEX = /\/tcp\/\d+\/ws\/p2p\//;
+
+/**
+ * Converts a TCP bootnode to WebSocket format 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 convertBootNodeToWebSocket(addr) {
+    // Already a WebSocket address
+    if (WS_BOOTNODE_REGEX.test(addr)) {
+        console.log(`  ✅ Already WebSocket: ${addr.substring(0, 50)}...`);
+        return addr;
+    }
+
+    const match = addr.match(TCP_BOOTNODE_REGEX);
+    if (match) {
+        const [, hostPart, portStr, peerId] = match;
+        const wsPort = parseInt(portStr, 10) + 1;
+        console.log(`  📡 Converted: tcp/${portStr} -> tcp/${wsPort}/ws`);
+        return `${hostPart}/tcp/${wsPort}/ws/p2p/${peerId}`;
+    }
+
+    return null;
+}
+
 function readChainSpec(chainspecPath) {
-    const chainSpecContent = readFileSync(chainspecPath, 'utf8');
-    const chainSpecObj = JSON.parse(chainSpecContent);
+    const chainSpecObj = JSON.parse(readFileSync(chainspecPath, 'utf8'));
     chainSpecObj.protocolId = null;
+
+    const bootNodes = chainSpecObj.bootNodes || [];
+    if (bootNodes.length === 0) {
+        console.log(`⚠️ No bootnodes found in chain spec: ${chainspecPath}`);
+        return JSON.stringify(chainSpecObj);
+    }
+
+    console.log(`🔄 Converting ${bootNodes.length} bootnode(s) to WebSocket for smoldot...`);
+    const wsBootNodes = bootNodes.map(convertBootNodeToWebSocket).filter(Boolean);
+
+    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`);
+    }
+
     return JSON.stringify(chainSpecObj);
 }
 
 function initSmoldot() {
-    const sd = smoldot.start({
+    return smoldot.start({
         maxLogLevel: SMOLDOT_LOG_LEVEL,
         logCallback: (level, target, message) => {
-            const levelNames = ['ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE'];
-            const levelName = levelNames[level - 1] || 'UNKNOWN';
+            const levelName = ['ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE'][level - 1] || 'UNKNOWN';
             console.log(`[smoldot:${levelName}] ${target}: ${message}`);
         }
     });
-    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));
-
-    return { client, sd };
+
+    const mainChain = await sd.addChain({ chainSpec: readChainSpec(chainSpecPath) });
+    console.log(`✅ Added main chain: ${chainSpecPath}`);
+
+    let targetChain = mainChain;
+    if (parachainSpecPath) {
+        targetChain = await sd.addChain({
+            chainSpec: readChainSpec(parachainSpecPath),
+            potentialRelayChains: [mainChain]
+        });
+        console.log(`✅ Added parachain: ${parachainSpecPath}`);
+    }
+
+    return { client: createClient(getSmProvider(targetChain)), 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",
 ]