Update integration test for valid relay chain timestamp in parachain storage

integration-tests/README.md

@@ -86,10 +86,10 @@ Unable to map [u8; 32] to a lookup index
 [16:36:17.240] INFO (xcm/24440): Connected relaychain 'Polkadot' with parachain 'Zeitgeist'
 ```
 
-#### Test the upgrade to the WASM from `./target/release/wbuild/zeitgeist-runtime` on zombienet:
+#### Test the upgrade to the WASM from `./target/release/wbuild/battery-station-runtime` on zombienet:
 
 ```bash
-pnpm exec moonwall test zombienet_zeitgeist_upgrade --runInBand
+pnpm exec moonwall test zombienet_battery_station_upgrade --runInBand
 ```
 
 #### Test the upgrade to the WASM from `./target/release/wbuild/zeitgeist-runtime` on the live main-net fork using chopsticks:

integration-tests/moonwall.config.json

@@ -4,7 +4,7 @@
   "scriptsDir": "scripts/",
   "environments": [
     {
-      "name": "zombienet_zeitgeist_upgrade",
+      "name": "zombienet_battery_station_upgrade",
       "testFileDir": ["tests/rt-upgrade-zombienet"],
       "runScripts": [
         "build-node.sh",
@@ -17,10 +17,10 @@
             "binPath": "../target/release/zeitgeist"
           }
         ],
-        "rtUpgradePath": "../target/release/wbuild/zeitgeist-runtime/zeitgeist_runtime.compact.compressed.wasm",
+        "rtUpgradePath": "../target/release/wbuild/battery-station-runtime/battery_station_runtime.compact.compressed.wasm",
         "type": "zombie",
         "zombieSpec": {
-          "configPath": "./configs/zombieZeitgeist.json"
+          "configPath": "./configs/zombieBatteryStation.json"
         }
       },
       "connections": [

integration-tests/package.json

@@ -12,6 +12,7 @@
     "@polkadot/api": "16.5.2",
     "@polkadot/keyring": "13.5.2",
     "@polkadot/types": "16.5.2",
+    "@polkadot/util": "13.5.2",
     "@polkadot/util-crypto": "13.5.2",
     "@types/node": "22.10.2",
     "debug": "4.3.4",

integration-tests/tests/rt-upgrade-zombienet/test-zombienet-runtime-upgrade.ts

@@ -24,6 +24,9 @@ import {
 } from "@moonwall/cli";
 import { KeyringPair } from "@moonwall/util";
 import { ApiPromise, Keyring } from "@polkadot/api";
+import { u8aConcat } from "@polkadot/util";
+import { blake2AsHex, xxhashAsU8a } from "@polkadot/util-crypto";
+import { u8aToBigInt } from "@polkadot/util";
 import fs from "node:fs";
 import { RuntimeVersion } from "@polkadot/types/interfaces";
 
@@ -83,6 +86,12 @@ describeSuite({
         const codeString = currentCode.toString();
 
         const moonwallContext = await MoonwallContext.getContext();
+        const specVersion = (
+          paraApi.consts.system.version as unknown as RuntimeVersion
+        ).specVersion.toNumber();
+        log(
+          `Parachain specVersion=${specVersion}, block=${blockNumberBefore}, rtUpgradePath=${moonwallContext.rtUpgradePath}`
+        );
         log(
           "Moonwall Context providers: " +
             moonwallContext.providers.map((p) => p.name).join(", ")
@@ -109,16 +118,184 @@ describeSuite({
           );
         }
 
-        await context.upgradeRuntime({ from: alice, logger: log });
+        const txStatus = async (tx: any, label: string) =>
+          new Promise<void>((resolve, reject) => {
+            let unsubscribe: (() => void) | undefined;
+            tx.signAndSend(alice, (result: any) => {
+              if (result.dispatchError) {
+                // Dispatch errors won't throw, so surface them explicitly.
+                const errText = result.dispatchError.toString();
+                log(`${label} dispatchError=${errText}`);
+                reject(new Error(`${label} failed: ${errText}`));
+                unsubscribe?.();
+                return;
+              }
+              log(
+                `${label} status=${result.status?.type ?? "unknown"}, events=${result.events
+                  ?.map((ev: any) => `${ev.event.section}.${ev.event.method}`)
+                  .join(",")}`
+              );
+              if (result.status?.isInBlock || result.status?.isFinalized) {
+                unsubscribe?.();
+                resolve();
+              }
+            })
+              .then((unsub: () => void) => {
+                unsubscribe = unsub;
+              })
+              .catch(reject);
+          });
+
+        const findCall = (callName: string) => {
+          for (const [section, calls] of Object.entries(paraApi.tx)) {
+            const typedCalls = calls as Record<string, any>;
+            if (typedCalls?.[callName]) {
+              return { call: typedCalls[callName], section };
+            }
+          }
+          return undefined;
+        };
+
+        const upgradeCallLocation = {
+          authorize: undefined as string | undefined,
+          enact: undefined as string | undefined,
+        };
+
+        const authorizeUpgradeResult = findCall("authorizeUpgrade");
+        if (authorizeUpgradeResult) {
+          upgradeCallLocation.authorize = authorizeUpgradeResult.section;
+        }
+
+        // On this SDK the enact call lives in frame-system as applyAuthorizedUpgrade.
+        const applyAuthorizedUpgradeResult = findCall("applyAuthorizedUpgrade");
+        if (applyAuthorizedUpgradeResult) {
+          upgradeCallLocation.enact = applyAuthorizedUpgradeResult.section;
+        }
+
+        const authorizeUpgrade = authorizeUpgradeResult?.call;
+        const applyAuthorizedUpgrade = applyAuthorizedUpgradeResult?.call;
+        const upgradeAvailable = authorizeUpgrade && applyAuthorizedUpgrade;
+
+        const upgradeSections = Object.keys(paraApi.tx).filter((section) =>
+          /parachain|upgrade|system/i.test(section)
+        );
+        log(`tx sections matching /parachain|upgrade|system/: ${upgradeSections.join(",")}`);
+
+        if (upgradeAvailable) {
+          // Zeitgeist runtime blocks `setCode`, so use the authorized upgrade flow.
+          const wasmHash = blake2AsHex(wasm);
+          log("Authorizing runtime upgrade via system.authorizeUpgrade");
+          const authorizeTx =
+            authorizeUpgrade.meta.args.length === 1
+              ? authorizeUpgrade(wasmHash)
+              : authorizeUpgrade(wasmHash, true);
+          log(
+            `authorizeUpgrade located in section=${upgradeCallLocation.authorize}, args=${authorizeUpgrade.meta.args.length}`
+          );
+          await txStatus(
+            paraApi.tx.sudo.sudo(authorizeTx),
+            "authorizeUpgrade"
+          );
+
+          log("Waiting for validation function approval");
+          await context.waitBlock(2);
+
+          log("Enacting authorized upgrade");
+          log(
+            `applyAuthorizedUpgrade located in section=${upgradeCallLocation.enact}, args=${applyAuthorizedUpgrade.meta.args.length}`
+          );
+          await txStatus(
+            paraApi.tx.sudo.sudo(applyAuthorizedUpgrade(rtHex)),
+            "applyAuthorizedUpgrade"
+          );
+        } else {
+          throw new Error(
+            "Runtime upgrade calls missing in metadata; expected system.authorizeUpgrade/applyAuthorizedUpgrade"
+          );
+        }
+
         await context.waitBlock(2);
         const blockNumberAfter = (
           await paraApi.rpc.chain.getBlock()
         ).block.header.number.toNumber();
-        log(`Before: #${blockNumberBefore}, After: #${blockNumberAfter}`);
+        const codeAfter = (await paraApi.rpc.state.getStorage(":code"))?.toString();
+        log(
+          `Before: #${blockNumberBefore}, After: #${blockNumberAfter}, code changed=${
+            codeAfter !== codeString
+          }`
+        );
+        log(
+          `Code (before): ${codeString.slice(0, 10)}...${codeString.slice(-10)}, code (after): ${
+            codeAfter ? codeAfter.slice(0, 10) + "..." + codeAfter.slice(-10) : "undefined"
+          }`
+        );
         expect(
           blockNumberAfter,
           "Block number did not increase"
         ).to.be.greaterThan(blockNumberBefore);
+        expect(codeAfter, "Runtime code should match upgraded wasm").to.equal(rtHex);
+      },
+    });
+
+    it({
+      id: "T03",
+      title: "Relay timestamp (from relay proof) is present and increases across blocks",
+      timeout: 120000,
+      test: async function () {
+        const relayTsStorageKey =
+          "0x54dbd40f5201dbc18b0eed4b2ecd9cc67e2cdf745d68eeb295336330e3a1a063";
+
+        const readRelayTs = async (): Promise<bigint> => {
+          const raw = await paraApi.rpc.state.getStorage(relayTsStorageKey);
+          expect(raw, "RelayTimestampNow storage should exist").to.not.be.null;
+          const rawHex = raw?.toHex();
+          expect(rawHex, "RelayTimestampNow should decode to hex").to.not.be.undefined;
+          log(`RelayTimestampNow raw=${rawHex}`);
+          // Storage encodes u64 little-endian; decode explicitly.
+          const ts = u8aToBigInt(raw?.toU8a(true) ?? new Uint8Array(), true);
+          return ts;
+        };
+
+        let tsRelay1 = 0n;
+        let retries = 0;
+        while (tsRelay1 === 0n && retries < 5) {
+          log(`Attempt ${retries + 1}: reading RelayTimestampNow`);
+          tsRelay1 = await readRelayTs();
+          const rawDirect = await paraApi.rpc.state.getStorage(
+            relayTsStorageKey
+          );
+          log(`RelayTimestampNow direct RPC read: ${rawDirect?.toHex() ?? "null"}`);
+          if (tsRelay1 === 0n) {
+            await context.waitBlock(1);
+          }
+          retries++;
+        }
+
+        const tsPara1 = (await paraApi.query.timestamp.now()).toBigInt();
+        const block1 = (
+          await paraApi.rpc.chain.getBlock()
+        ).block.header.number.toNumber();
+
+        expect(tsRelay1, "Initial relay timestamp should be non-zero").to.be.greaterThan(0n);
+        expect(
+          tsPara1,
+          "Parachain timestamp should mirror relay timestamp"
+        ).to.equal(tsRelay1);
+
+        await context.waitBlock(2);
+
+        const tsRelay2 = await readRelayTs();
+        const tsPara2 = (await paraApi.query.timestamp.now()).toBigInt();
+        const block2 = (
+          await paraApi.rpc.chain.getBlock()
+        ).block.header.number.toNumber();
+
+        expect(block2, "Block height should advance").to.be.greaterThan(block1);
+        expect(
+          tsRelay2,
+          "Relay timestamp should increase with new relay proofs"
+        ).to.be.greaterThan(tsRelay1);
+        expect(tsPara2, "Parachain timestamp should mirror relay timestamp").to.equal(tsRelay2);
       },
     });
   },