[WIP] Additional bridges+zombienet test: only required bridged headers are synced

.gitlab/pipeline/zombienet/bridges.yml

@@ -38,9 +38,10 @@
   after_script:
     - mkdir -p ./zombienet-logs
     # copy logs of tests runner (run-tests.sh)
-    - cp -r /tmp/bridges-zombienet-tests.*/tmp.*/tmp.* ./zombienet-logs/
+    - cp -r /tmp/bridges-zombienet-tests.*/test-*.*/* ./zombienet-logs/
     # copy logs of all nodes
     - cp /tmp/zombie*/logs/* ./zombienet-logs/
+    - cp /tmp/zombie*/*.log ./zombienet-logs/
 # following lines are causing spurious test failures ("At least one of the nodes fails to start")
 #  retry: 2
 #  tags:
@@ -50,5 +51,19 @@ zombienet-bridges-0001-asset-transfer-works:
   extends:
     - .zombienet-bridges-common
   script:
-    - /home/nonroot/bridges-polkadot-sdk/bridges/zombienet/run-tests.sh --docker
+    - /home/nonroot/bridges-polkadot-sdk/bridges/zombienet/run-tests.sh --docker --test 1
+    - echo "Done"
+
+zombienet-bridges-0002-mandatory-headers-synced-while-idle:
+  extends:
+    - .zombienet-bridges-common
+  script:
+    - /home/nonroot/bridges-polkadot-sdk/bridges/zombienet/run-tests.sh --docker --test 2
+    - echo "Done"
+
+zombienet-bridges-0003-required-headers-synced-while-active:
+  extends:
+    - .zombienet-bridges-common
+  script:
+    - /home/nonroot/bridges-polkadot-sdk/bridges/zombienet/run-tests.sh --docker --test 3
     - echo "Done"

bridges/zombienet/helpers/chains/rococo-at-westend.js

@@ -0,0 +1,11 @@
+module.exports = {
+	grandpaPalletName: "bridgeRococoGrandpa",
+	parachainsPalletName: "bridgeRococoParachains",
+	messagesPalletName: "bridgeRococoMessages",
+	bestBridgedRelayChainGrandpaAuthoritySet: async function(api) {
+		return await api.query.bridgeRococoGrandpa.currentAuthoritySet();
+	},
+	bestBridgedParachainInfo: async function(api) {
+		return await api.query.bridgeRococoParachains.parasInfo(1013);
+	},
+}

bridges/zombienet/helpers/chains/westend-at-rococo.js

@@ -0,0 +1,11 @@
+module.exports = {
+	grandpaPalletName: "bridgeWestendGrandpa",
+	parachainsPalletName: "bridgeWestendParachains",
+	messagesPalletName: "bridgeWestendMessages",
+	bestBridgedRelayChainGrandpaAuthoritySet: async function(api) {
+		return await api.query.bridgeWestendGrandpa.currentAuthoritySet();
+	},
+	bestBridgedParachainInfo: async function(api) {
+		return await api.query.bridgeWestendParachains.parasInfo(1002);
+	},
+}

bridges/zombienet/helpers/only-mandatory-headers-synced-when-idle.js

@@ -0,0 +1,44 @@
+const utils = require("./utils");
+
+async function run(nodeName, networkInfo, args) {
+    const {wsUri, userDefinedTypes} = networkInfo.nodesByName[nodeName];
+    const api = await zombie.connect(wsUri, userDefinedTypes);
+
+    // parse arguments
+    const exitAfterSeconds = Number(args[0]);
+    const bridgedChain = require("./chains/" + args[1]);
+
+    // start listening to new blocks
+    let totalGrandpaHeaders = 0;
+    let totalParachainHeaders = 0;
+    api.rpc.chain.subscribeNewHeads(async function (header) {
+        const apiAtParent = await api.at(header.parentHash);
+        const apiAtCurrent = await api.at(header.hash);
+        const currentEvents = await apiAtCurrent.query.system.events();
+
+        totalGrandpaHeaders += await utils.ensureOnlyMandatoryGrandpaHeadersImported(
+            bridgedChain,
+            apiAtParent,
+            apiAtCurrent,
+            currentEvents,
+        );
+        totalParachainHeaders += await utils.ensureOnlyInitialParachainHeaderImported(
+            bridgedChain,
+            apiAtParent,
+            apiAtCurrent,
+            currentEvents,
+        );
+    });
+
+    // wait given time
+    await new Promise(resolve => setTimeout(resolve, exitAfterSeconds * 1000));
+    // if we haven't seen any new GRANDPA or parachain headers => fail
+    if (totalGrandpaHeaders == 0) {
+        throw new Error("No bridged relay chain headers imported");
+    }
+    if (totalParachainHeaders == 0) {
+        throw new Error("No bridged parachain headers imported");
+    }
+}
+
+module.exports = { run }

bridges/zombienet/helpers/only-required-headers-synced-when-active.js

@@ -0,0 +1,81 @@
+const utils = require("./utils");
+
+async function run(nodeName, networkInfo, args) {
+    const {wsUri, userDefinedTypes} = networkInfo.nodesByName[nodeName];
+    const api = await zombie.connect(wsUri, userDefinedTypes);
+
+    // parse arguments
+    const exitAfterSeconds = Number(args[0]);
+    const bridgedChain = require("./chains/" + args[1]);
+
+    // start listening to new blocks
+    let atLeastOneMessageReceived = false;
+    let atLeastOneMessageDelivered = false;
+    const unsubscribe = await api.rpc.chain.subscribeNewHeads(async function (header) {
+        const apiAtParent = await api.at(header.parentHash);
+        const apiAtCurrent = await api.at(header.hash);
+        const currentEvents = await apiAtCurrent.query.system.events();
+
+        const messagesReceived = currentEvents.find((record) => {
+            return record.event.section == bridgedChain.messagesPalletName
+                && record.event.method == "MessagesReceived";
+        }) != undefined;
+        const messagesDelivered = currentEvents.find((record) => {
+            return record.event.section == bridgedChain.messagesPalletName &&
+                record.event.method == "MessagesDelivered";
+        }) != undefined;
+        const hasMessageUpdates = messagesReceived || messagesDelivered;
+        atLeastOneMessageReceived = atLeastOneMessageReceived || messagesReceived;
+        atLeastOneMessageDelivered = atLeastOneMessageDelivered || messagesDelivered;
+
+        if (!hasMessageUpdates) {
+            // if there are no any message update transactions, we only expect mandatory GRANDPA
+            // headers and initial parachain headers
+            await utils.ensureOnlyMandatoryGrandpaHeadersImported(
+                bridgedChain,
+                apiAtParent,
+                apiAtCurrent,
+                currentEvents,
+            );
+            await utils.ensureOnlyInitialParachainHeaderImported(
+                bridgedChain,
+                apiAtParent,
+                apiAtCurrent,
+                currentEvents,
+            );
+        } else {
+            const messageTransactions = (messagesReceived ? 1 : 0) + (messagesDelivered ? 1 : 0);
+
+            // otherwise we only accept at most one GRANDPA header
+            const newGrandpaHeaders = utils.countGrandpaHeaderImports(bridgedChain, currentEvents);
+            if (newGrandpaHeaders > 1) {
+                utils.logEvents(currentEvents);
+                throw new Error("Unexpected relay chain header import: " + newGrandpaHeaders + " / " + messageTransactions);
+            }
+
+            // ...and at most one parachain header
+            const newParachainHeaders = utils.countParachainHeaderImports(bridgedChain, currentEvents);
+            if (newParachainHeaders > 1) {
+                utils.logEvents(currentEvents);
+                throw new Error("Unexpected parachain header import: " + newParachainHeaders + " / " + messageTransactions);
+            }
+        }
+    });
+
+    // wait until we have received + delivered messages OR until timeout
+    await utils.pollUntil(
+        exitAfterSeconds,
+        () => { return atLeastOneMessageReceived && atLeastOneMessageDelivered; },
+        () => { unsubscribe(); },
+        () => {
+            if (!atLeastOneMessageReceived) {
+                throw new Error("No messages received from bridged chain");
+            }
+            if (!atLeastOneMessageDelivered) {
+                throw new Error("No messages delivered to bridged chain");
+            }
+        },
+    );
+}
+
+module.exports = { run }

bridges/zombienet/helpers/test.js

@@ -0,0 +1,41 @@
+#!node
+const { WsProvider, ApiPromise } = require("@polkadot/api");
+const util = require("@polkadot/util");
+
+async function connect(endpoint, types = {}) {
+	const provider = new WsProvider(endpoint);
+	const api = await ApiPromise.create({
+		provider,
+		types: {/*
+			HeaderId: {
+				number: "u32",
+				hash: "H256"
+			}*/
+		},
+		throwOnConnect: false,
+	});
+	return api;
+}
+
+async function test() {
+	const api = await connect("wss://rococo-bridge-hub-rpc.polkadot.io");
+
+	let count = 0;
+	console.log("begin");
+	const unsubscribe = await api.rpc.chain.subscribeNewHeads((header) => {
+		++count;
+		console.log(count);
+		return 1;
+		if (count === 2) {
+			console.log('2 headers retrieved, unsubscribing');
+			unsubscribe();
+			resolve(123)
+		}
+	}).then((v) => { console.log(100); });
+	console.log("end");
+	//await new Promise(resolve => setTimeout(resolve, 60 * 1000));
+	console.log(unsubscribe);
+	console.log("end++");
+}
+
+test()

bridges/zombienet/helpers/utils.js

@@ -0,0 +1,103 @@
+module.exports = {
+    logEvents: function(events) {
+        let sevents = "";
+        events.forEach((record) => {
+            if (sevents != "") {
+                sevents += ", ";
+            }
+            sevents += record.event.section + "::" + record.event.method;
+        });
+        console.log("Block events: " + sevents);
+    },
+    countGrandpaHeaderImports: function(bridgedChain, events) {
+        return events.reduce(
+            (count, record) => {
+                const { event } = record;
+                if (event.section == bridgedChain.grandpaPalletName && event.method == "UpdatedBestFinalizedHeader") {
+                    count += 1;
+                }
+                return count;
+            },
+            0,
+        );
+    },
+    countParachainHeaderImports: function(bridgedChain, events) {
+        return events.reduce(
+            (count, record) => {
+                const { event } = record;
+                if (event.section == bridgedChain.parachainsPalletName && event.method == "UpdatedParachainHead") {
+                    count += 1;
+                }
+                return count;
+            },
+            0,
+        );
+    },
+    pollUntil: async function(
+        timeoutInSecs,
+        predicate,
+        cleanup,
+        onFailure,
+    )  {
+        const begin = new Date().getTime();
+        const end = begin + timeoutInSecs * 1000;
+        while (new Date().getTime() < end) {
+            if (predicate()) {
+                cleanup();
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+
+        cleanup();
+        onFailure();
+    },
+    ensureOnlyMandatoryGrandpaHeadersImported: async function(
+        bridgedChain,
+        apiAtParent,
+        apiAtCurrent,
+        currentEvents,
+    ) {
+        // remember id of bridged relay chain GRANDPA authorities set at parent block
+        const authoritySetAtParent = await bridgedChain.bestBridgedRelayChainGrandpaAuthoritySet(apiAtParent);
+        const authoritySetIdAtParent = authoritySetAtParent["setId"];
+
+        // now read the id of bridged relay chain GRANDPA authorities set at current block
+        const authoritySetAtCurrent = await bridgedChain.bestBridgedRelayChainGrandpaAuthoritySet(apiAtCurrent);
+        const authoritySetIdAtCurrent = authoritySetAtCurrent["setId"];
+
+        // we expect to see no more than `authoritySetIdAtCurrent - authoritySetIdAtParent` new GRANDPA headers
+        const maxNewGrandpaHeaders = authoritySetIdAtCurrent - authoritySetIdAtParent;
+        const newGrandpaHeaders = module.exports.countGrandpaHeaderImports(bridgedChain, currentEvents);
+
+        // check that our assumptions are correct
+        if (newGrandpaHeaders > maxNewGrandpaHeaders) {
+            module.exports.logEvents(currentEvents);
+            throw new Error("Unexpected relay chain header import: " + newGrandpaHeaders + " / " + maxNewGrandpaHeaders);
+        }
+
+        return newGrandpaHeaders;
+    },
+    ensureOnlyInitialParachainHeaderImported: async function(
+        bridgedChain,
+        apiAtParent,
+        apiAtCurrent,
+        currentEvents,
+    ) {
+        // remember whether we already know bridged parachain header at a parent block
+        const bestBridgedParachainHeader = await bridgedChain.bestBridgedParachainInfo(apiAtParent);
+        const hasBestBridgedParachainHeader = bestBridgedParachainHeader.isSome;
+
+        // we expect to see: no more than `1` bridged parachain header if there were no parachain header before.
+        const maxNewParachainHeaders = hasBestBridgedParachainHeader ? 0 : 1;
+        const newParachainHeaders = module.exports.countParachainHeaderImports(bridgedChain, currentEvents);
+
+        // check that our assumptions are correct
+        if (newParachainHeaders > maxNewParachainHeaders) {
+            module.exports.logEvents(currentEvents);
+            throw new Error("Unexpected parachain header import: " + newParachainHeaders + " / " + maxNewParachainHeaders);
+        }
+
+        return newParachainHeaders;
+    },
+}

bridges/zombienet/helpers/wait-account-nonce-finalized.js

@@ -0,0 +1,32 @@
+const utils = require("./utils");
+
+async function run(nodeName, networkInfo, args) {
+    const {wsUri, userDefinedTypes} = networkInfo.nodesByName[nodeName];
+    const api = await zombie.connect(wsUri, userDefinedTypes);
+
+    // parse arguments
+    const account = args[0];
+    const expectedNonce = Number(args[1]);
+
+    // start listening to new finalized blocks
+    let nonceMatches = false;
+    const unsubscribe = await api.rpc.chain.subscribeFinalizedHeads(async function (header) {
+        const apiAtCurrent = await api.at(header.hash);
+        const accountState = await apiAtCurrent.query.system.account(account);
+        const accountNonce = accountState.nonce.toNumber();
+        console.log("Nonce of account " + account + " is " + accountNonce + " (expected " + expectedNonce + ") at block " + header.hash);
+        if (accountNonce >= expectedNonce) {
+            nonceMatches = true;
+        }
+    });
+
+    // wait until we have received + delivered messages OR until timeout
+    await utils.pollUntil(
+        60 * 60,
+        () => { return nonceMatches; },
+        () => { unsubscribe(); },
+        () => { throw new Error("Account transactions are not included into finalized block. Too many reorgs?"); },
+    );
+}
+
+module.exports = { run }

bridges/zombienet/helpers/wait-hrmp-channel-opened.js

@@ -3,7 +3,6 @@ async function run(nodeName, networkInfo, args) {
     const api = await zombie.connect(wsUri, userDefinedTypes);
 
     const sibling = args[0];
-
     while (true) {
         const messagingStateAsObj = await api.query.parachainSystem.relevantMessagingState();
         const messagingState = api.createType("Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>", messagingStateAsObj);