refactor: 🔧 Update dancelight smoketests

test/suites/smoke-test-dancelight/test-authority-consistency-assignation.ts

@@ -1,5 +1,5 @@
+import "@tanssi/api-augment/dancelight";
 import { beforeAll, describeSuite, expect } from "@moonwall/cli";
-
 import type { ApiPromise } from "@polkadot/api";
 
 describeSuite({
@@ -17,22 +17,32 @@ describeSuite({
             id: "C01",
             title: "Collator assignation and authority assignation should match with observed mapping in containers",
             test: async () => {
-                const assignmentCollatorAccount = (
-                    await api.query.tanssiCollatorAssignment.collatorContainerChain()
-                ).toJSON();
+                const assignmentCollatorAccount = await api.query.tanssiCollatorAssignment.collatorContainerChain();
                 const sessionIndex = (await api.query.session.currentIndex()).toNumber();
                 const assignmentCollatorKey = (
                     await api.query.tanssiAuthorityAssignment.collatorContainerChain(sessionIndex)
-                ).toJSON();
+                ).unwrap();
                 const authorityKeyMapping = (
                     await api.query.tanssiAuthorityMapping.authorityIdMapping(sessionIndex)
-                ).toJSON();
-                for (const container of Object.keys(assignmentCollatorKey.containerChains)) {
-                    for (const key of assignmentCollatorKey.containerChains[container]) {
-                        const assignedAccount = authorityKeyMapping[key.toString()];
-                        expect(
-                            assignmentCollatorAccount.containerChains[container].includes(assignedAccount.toString())
-                        ).to.be.true;
+                ).unwrap();
+
+                const remappedAssignmentCollatorAccount = Object.fromEntries(
+                    [...assignmentCollatorAccount.containerChains.entries()].map(([key, value]) => [
+                        key.toString(),
+                        value.map((v) => v.toHuman()),
+                    ])
+                );
+
+                const remappedAuthorityKeyMapping = Object.fromEntries(
+                    [...authorityKeyMapping.entries()].map(([key, value]) => [key.toHex(), value.toHuman()])
+                );
+
+                const containerChains = assignmentCollatorKey.containerChains.keys();
+
+                for (const container of containerChains) {
+                    for (const key of assignmentCollatorKey.containerChains.get(container)) {
+                        const assignedAccount = remappedAuthorityKeyMapping[key.toHex()];
+                        expect(remappedAssignmentCollatorAccount[container.toString()]).toContain(assignedAccount);
                     }
                 }
             },

test/suites/smoke-test-dancelight/test-babe.ts

@@ -1,29 +1,25 @@
+import "@tanssi/api-augment/dancelight";
 import { beforeAll, describeSuite, expect } from "@moonwall/cli";
 import { getBlockArray } from "@moonwall/util";
 import type { ApiPromise } from "@polkadot/api";
-import type { GenericExtrinsic, U32 } from "@polkadot/types";
-import type { FrameSystemEventRecord } from "@polkadot/types/lookup";
+import type { GenericExtrinsic, u64 } from "@polkadot/types";
+import type {
+    FrameSystemEventRecord,
+    SpConsensusBabeAppPublic,
+    SpConsensusBabeDigestsPreDigest,
+} from "@polkadot/types/lookup";
 import type { AnyTuple } from "@polkadot/types/types";
 import { hexToU8a, stringToHex } from "@polkadot/util";
 import { sr25519Verify } from "@polkadot/wasm-crypto";
 import Bottleneck from "bottleneck";
+import type { AccountId32, BlockHash, DigestItem, Header } from "@polkadot/types/interfaces";
+import type { HexString } from "@polkadot/util/types";
+import type { ApiDecoration } from "@polkadot/api/types";
 
 const timePeriod = process.env.TIME_PERIOD ? Number(process.env.TIME_PERIOD) : 1 * 60 * 60 * 1000;
 const timeout = Math.max(Math.floor(timePeriod / 12), 5000);
 const hours = (timePeriod / (1000 * 60 * 60)).toFixed(2);
 
-type BlockFilteredRecord = {
-    blockNum: number;
-    blockHash;
-    header;
-    preHash;
-    extrinsics: GenericExtrinsic<AnyTuple>[];
-    events: FrameSystemEventRecord[];
-    logs;
-    authorities;
-    accountsWithBabeKeys;
-};
-
 describeSuite({
     id: "SMOK02",
     title: "Sample suite that only runs on Dancelight chains",
@@ -49,7 +45,7 @@ describeSuite({
                 const authorities = await apiAt.query.session.validators();
                 const babeAuthorities = await apiAt.query.babe.authorities();
 
-                const blockBabeEpochStart = (await apiAt.query.babe.epochStart()).toJSON()[0];
+                const blockBabeEpochStart = (await apiAt.query.babe.epochStart())[0].toNumber();
                 const apiAtSessionChange = await api.at(await api.rpc.chain.getBlockHash(blockBabeEpochStart));
 
                 // If there has been a recent change in session keys,
@@ -66,13 +62,15 @@ describeSuite({
 
                 return {
                     blockNum: blockNum,
+                    header,
+                    blockHash,
                     preHash,
                     extrinsics: signedBlock.block.extrinsics,
                     events: await apiAt.query.system.events(),
                     logs: signedBlock.block.header.digest.logs,
                     authorities,
                     accountsWithBabeKeys,
-                };
+                } satisfies BlockFilteredRecord;
             };
             const limiter = new Bottleneck({ maxConcurrent: 5, minTime: 100 });
             blockData = await Promise.all(blockNumArray.map((num) => limiter.schedule(() => getBlockData(num))));
@@ -85,7 +83,7 @@ describeSuite({
                 // Check the previous epoch digest.
                 // The [0] index indicates the block number in which the previous session started.
                 // The [1] index indicates the block number in which the current session started.
-                const blockToCheck = ((await api.query.babe.epochStart()) as unknown as [U32, U32])[0];
+                const blockToCheck = (await api.query.babe.epochStart())[0];
                 const apiAtSessionChange = await api.at(await api.rpc.chain.getBlockHash(blockToCheck));
 
                 const digestsInSessionChange = (await apiAtSessionChange.query.system.digest()).logs;
@@ -104,23 +102,25 @@ describeSuite({
                     filteredDigests[0].asConsensus[1].toHex()
                 );
 
-                expect(babeConsensusLog[1]).to.deep.equal(babeAuthoritiesFromPallet);
+                expect(babeConsensusLog[1].eq(babeAuthoritiesFromPallet)).toBe(true);
 
-                const keyOwnersArray = [];
+                const keyOwnersArray: string[] = [];
                 const keyOwnersInPalletSession = await keyOwners(babeAuthoritiesFromPallet, api);
 
                 for (const keyOwner of keyOwnersInPalletSession) {
                     keyOwnersArray.push(keyOwner[0]);
                 }
 
                 // Get validators from pallet session
-                const sessionValidators = await api.query.session.validators();
+                const sessionValidators = (await api.query.session.validators()).map((validator) =>
+                    validator.toPrimitive()
+                );
 
                 keyOwnersArray.sort();
                 sessionValidators.sort();
 
                 // Check that key owners found are the same validators in pallet session
-                expect(keyOwnersArray).to.deep.equal(sessionValidators.toJSON());
+                expect(keyOwnersArray).toEqual(sessionValidators);
             },
         });
 
@@ -135,17 +135,17 @@ describeSuite({
                         );
                         expect(babeLogs.length).to.eq(1);
 
-                        const babeLogEnum = api.registry.createType(
+                        const babeLogEnum: SpConsensusBabeDigestsPreDigest = api.registry.createType(
                             "SpConsensusBabeDigestsPreDigest",
                             babeLogs[0].asPreRuntime[1].toHex()
                         );
 
-                        expect(babeLogEnum.isSecondaryVRF || babeLogEnum.isPrimary).toBeTruthy();
+                        expect(babeLogEnum.isSecondaryVRF || babeLogEnum.isPrimary).toBe(true);
                         const babeLog = babeLogEnum.isSecondaryVRF ? babeLogEnum.asSecondaryVRF : babeLogEnum.asPrimary;
 
                         // Get expected author from BABE log and on chain authorities
                         const authorityIndex = babeLog.authorityIndex;
-                        const orchestratorAuthorities = authorities.toJSON();
+                        const orchestratorAuthorities = authorities;
                         const expectedAuthor = orchestratorAuthorities[authorityIndex.toNumber()];
 
                         // Get block author signature from seal log
@@ -162,7 +162,7 @@ describeSuite({
                         // Verify seal signature
                         const message = hexToU8a(preHash);
                         const signature = hexToU8a(sealLog.toHex());
-                        const authorBabe = accountsWithBabeKeys.find((acc) => acc[0] === expectedAuthor);
+                        const authorBabe = accountsWithBabeKeys.find((acc) => acc[0] === expectedAuthor.toHuman());
                         expect(authorBabe, `Missing babe key for block author: ${expectedAuthor}`).toBeTruthy();
                         const pubKey = hexToU8a(authorBabe[1]);
 
@@ -189,7 +189,7 @@ describeSuite({
 
 // Given a block header, returns its preHash. This is the hash of the header before adding the seal.
 // The hash of the block header after adding the seal is the block hash.
-function getPreHash(api, header) {
+function getPreHash(api: ApiPromise, header: Header) {
     const logsNoSeal = header.digest.logs.filter((log) => !log.isSeal);
     const headerWithoutSeal = api.registry.createType("Header", {
         parentHash: header.parentHash,
@@ -205,22 +205,32 @@ function getPreHash(api, header) {
 
 // Helper function to retrieve the validators from pallet session given
 // the babe authorities (babeKeys) and a specific api instance.
-async function keyOwners(babeAuthoritiesFromPallet, api) {
-    const keyOwnersInPalletSession = [];
+async function keyOwners(
+    babeAuthoritiesFromPallet: [SpConsensusBabeAppPublic, u64][],
+    api: ApiPromise | ApiDecoration<"promise">
+) {
+    const keyOwnersInPalletSession: [string, string][] = [];
 
     for (const authority of babeAuthoritiesFromPallet) {
-        const param = api.registry.createType("(SpCoreCryptoKeyTypeId, Bytes)", [
-            stringToHex("babe"),
-            authority[0].toHex(),
-        ]);
-        const keyOwner = await api.query.session.keyOwner(param);
-
-        expect(
-            keyOwner.isSome,
-            `Validator with babe key ${authority[0].toJSON()} not found in pallet session!`
-        ).toBeTruthy();
-        keyOwnersInPalletSession.push([keyOwner.toJSON(), authority[0].toJSON()]);
+        const keyOwner = await api.query.session.keyOwner([stringToHex("babe"), authority[0].toHex()]);
+
+        expect(keyOwner.isSome, `Validator with babe key ${authority[0].toHuman()} not found in pallet session!`).toBe(
+            true
+        );
+        keyOwnersInPalletSession.push([keyOwner.unwrap().toHuman(), authority[0].toJSON()]);
     }
 
     return keyOwnersInPalletSession;
 }
+
+interface BlockFilteredRecord {
+    blockNum: number;
+    blockHash: BlockHash;
+    header: Header;
+    preHash: HexString;
+    extrinsics: GenericExtrinsic<AnyTuple>[];
+    events: FrameSystemEventRecord[];
+    logs: DigestItem[];
+    authorities: AccountId32[];
+    accountsWithBabeKeys: [string, string][];
+}

test/suites/smoke-test-dancelight/test-beefy-mmr-digests.ts

@@ -1,5 +1,5 @@
+import "@tanssi/api-augment/dancelight";
 import { beforeAll, describeSuite, expect } from "@moonwall/cli";
-
 import { stringToHex } from "@polkadot/util";
 import type { ApiPromise } from "@polkadot/api";
 
@@ -18,7 +18,7 @@ describeSuite({
             id: "C01",
             title: "Session change block should update BEEFY and MMR root digests properly",
             test: async () => {
-                const blockToCheck = (await api.query.babe.epochStart()).toJSON()[1];
+                const blockToCheck = (await api.query.babe.epochStart())[1].toNumber();
 
                 const apiAtBeforeSessionChange = await api.at(await api.rpc.chain.getBlockHash(blockToCheck - 5));
                 const beefyNextAuthorities = await apiAtBeforeSessionChange.query.beefy.nextAuthorities();
@@ -37,10 +37,16 @@ describeSuite({
                 expect(filteredDigests[0].asConsensus[1].toHex().startsWith("0x01")).to.be.true;
 
                 // Check if each authority is included in the BEEFY digest
-                for (const authority of Object.values(beefyNextAuthorities.toJSON())) {
-                    expect(filteredDigests[0].asConsensus[1].toHex().includes(authority.slice(2))).to.be.true;
+                const failures = beefyNextAuthorities
+                    .map((authority) => authority.toHex().slice(2))
+                    .filter((authority) => !filteredDigests[0].asConsensus[1].toHex().includes(authority));
+
+                for (const failure of failures) {
+                    console.error(`${failure} is not included in the BEEFY digest`);
                 }
 
+                expect(failures.length).to.eq(0);
+
                 const firstMmrRootDigest = filteredDigests[1].asConsensus[1].toHex();
 
                 // 0x03 corresponds to ConsensusLog::MmrRoot enum variant.

test/suites/smoke-test-dancelight/test-configuration-consistency.ts

@@ -1,5 +1,5 @@
+import "@tanssi/api-augment/dancelight";
 import { beforeAll, describeSuite, expect } from "@moonwall/cli";
-
 import type { ApiPromise } from "@polkadot/api";
 import { hasEnoughCredits } from "util/payment";
 import type { u32, Vec } from "@polkadot/types-codec";
@@ -23,29 +23,36 @@ describeSuite({
             title: "Config for registered paras should be consistent",
             test: async () => {
                 const sessionIndex = (await api.query.session.currentIndex()).toNumber();
-                const blockToCheck = (await api.query.babe.epochStart()).toJSON()[1];
+                const blockToCheck = (await api.query.babe.epochStart())[1].toNumber();
 
                 const apiBeforeLatestNewSession = await api.at(await api.rpc.chain.getBlockHash(blockToCheck - 1));
                 const config = await api.query.collatorConfiguration.activeConfig();
 
                 // get pending authorities
                 // the reason for getting pending is that the hasEnoughCredits check it's done over the pending ones
-                const pendingAuthorityAssignment = (
-                    await api.query.tanssiAuthorityAssignment.collatorContainerChain(sessionIndex + 1)
-                ).toJSON();
-
+                const pendingAuthorityAssignment = Object.fromEntries(
+                    [
+                        ...(await api.query.tanssiAuthorityAssignment.collatorContainerChain(sessionIndex + 1))
+                            .unwrap()
+                            .containerChains.entries(),
+                    ].map(([key, value]) => [key.toString(), value.map((v) => v.toHuman())])
+                );
                 // get current authorities
                 // we need to know whether a chain is assigned currently
-                const currentAuthorityAssignment = (
-                    await api.query.tanssiAuthorityAssignment.collatorContainerChain(sessionIndex)
-                ).toJSON();
-
+                const currentAuthorityAssignment = Object.fromEntries(
+                    [
+                        ...(await api.query.tanssiAuthorityAssignment.collatorContainerChain(sessionIndex))
+                            .unwrap()
+                            .containerChains.entries(),
+                    ].map(([key, value]) => [key.toString(), value.map((v) => v.toHuman())])
+                );
                 const currentAuthorities = await api.query.session.validators();
 
-                const currentCollatorNumber = Math.min(currentAuthorities.length, config.maxCollators);
+                const currentCollatorNumber = Math.min(currentAuthorities.length, config.maxCollators.toNumber());
 
                 const maxParas = Math.trunc(
-                    (currentCollatorNumber - config.minOrchestratorCollators) / config.collatorsPerContainer
+                    (currentCollatorNumber - config.minOrchestratorCollators.toNumber()) /
+                        config.collatorsPerContainer.toNumber()
                 );
 
                 // If we have container chain collators, is because the collator number is higher
@@ -76,8 +83,8 @@ describeSuite({
                         let sessionRequirements: bigint;
 
                         if (
-                            currentAuthorityAssignment.containerChains[container.toString()] === null ||
-                            currentAuthorityAssignment.containerChains[container.toString()].length === 0
+                            currentAuthorityAssignment[container.toString()] === null ||
+                            currentAuthorityAssignment[container.toString()].length === 0
                         ) {
                             sessionRequirements = 1n;
                         } else {
@@ -99,9 +106,7 @@ describeSuite({
                             // Here we only check that  that we have collators
                             // If we are able to cover all paras, then all of them should have collators if credits
                             if (maxParas >= containersToCompareAgainst.length) {
-                                expect(
-                                    pendingAuthorityAssignment.containerChains[container.toString()].length
-                                ).to.be.greaterThan(0);
+                                expect(pendingAuthorityAssignment[container.toString()].length).to.be.greaterThan(0);
                             }
                         } else {
                             numWithNoCredits += 1;
@@ -114,9 +119,7 @@ describeSuite({
                         containersToCompareAgainst.length - numWithNoCredits,
                         maxParas
                     );
-                    expect(Object.keys(pendingAuthorityAssignment.containerChains).length).to.be.equal(
-                        expectedNumberOfChainsAssigned
-                    );
+                    expect(Object.keys(pendingAuthorityAssignment).length).to.be.equal(expectedNumberOfChainsAssigned);
                 }
             },
         });