moonwall 1.0.0-dev.0

package/dist/cli/lib/rpcFunctions.js

@@ -0,0 +1,26 @@
+import { vitestAutoUrl } from "../internal/providerFactories.js";
+import { getEnvironmentFromConfig } from "./configReader.js";
+import { normalizeUrlToHttps } from "../../util/index.js";
+export async function customDevRpcRequest(method, params = []) {
+    const env = getEnvironmentFromConfig();
+    const endpoint = normalizeUrlToHttps(env.connections ? env.connections[0].endpoints[0] : vitestAutoUrl());
+    const data = {
+        jsonrpc: "2.0",
+        id: 1,
+        method,
+        params,
+    };
+    if (endpoint.startsWith("ws")) {
+        console.log("you've passed a websocket to fetch, is this intended?");
+    }
+    const response = await fetch(endpoint, {
+        method: "POST",
+        body: JSON.stringify(data),
+        headers: { "Content-Type": "application/json" },
+    });
+    const responseData = (await response.json());
+    if (responseData.error) {
+        throw new Error(responseData.error.message);
+    }
+    return responseData.result;
+}

package/dist/cli/lib/runnerContext.d.ts

@@ -0,0 +1,32 @@
+import type { FoundationType, ITestSuiteType } from "../../api/types/index.js";
+/**
+ *  * Defines a suite of tests based on provided parameters.
+ *
+ * @param {object} params - The setup parameters for the test suite.
+ * @param {string} params.id - A unique identifier for the test suite (e.g. D03).
+ * @param {string} params.title - The title of the test suite (e.g. 'Fee calculation: congestion handling').
+ * @param {function} params.testCases - A callback function that houses the individual test cases of this suite.
+ * @param {string} params.foundationMethods - Explicitly specify which foundation these tests will run against reveal which methods to make available.
+ * @param {number} [params.minRtVersion] - The minimum runtime version required for the test suite, otherwise will be skipped.
+ * @param {string} [params.chainType] - The required runtime name required for the test suite, otherwise will be skipped.
+ * @param {string} [params.notChainType] - The runtime name to not run against this test suite, otherwise will not be skipped.
+ *
+ * @returns {void} - No explicit return value, this function results is wrapped and handled by the vitest instance.
+ * @example
+ *      describeSuite({
+ *        id: "D01",
+ *        title: "Sample test suite",
+ *        foundationMethods: "dev",
+ *        testCases: ({ it, context, log }) => {
+ *          it({
+ *            id: "T01",
+ *            title: "Sample test case",
+ *            testds: async function () {
+ *              expect(true).to.be.true;
+ *            },
+ *          });
+ *        },
+ *      });
+ */
+export declare function describeSuite<T extends FoundationType>({ id: suiteId, title, testCases, foundationMethods, minRtVersion, chainType, notChainType, options, }: ITestSuiteType<T>): void;
+//# sourceMappingURL=runnerContext.d.ts.map

package/dist/cli/lib/runnerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runnerContext.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/runnerContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EAGd,cAAc,EAOf,iCAAiC;AAmBlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,cAAc,EAAE,EACtD,EAAE,EAAE,OAAO,EACX,KAAK,EACL,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,OAAO,GACR,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,CA6G1B"}

package/dist/cli/lib/runnerContext.js

@@ -0,0 +1,156 @@
+import Bottleneck from "bottleneck";
+import { createLogger } from "../../util/index.js";
+import { afterAll, beforeAll, describe, it } from "vitest";
+import { getEnvironmentFromConfig } from "./configReader.js";
+import { MoonwallContext, contextCreator } from "./globalContext.js";
+import { chopsticksHandler, devHandler, readOnlyHandler, zombieHandler } from "./handlers/index.js";
+const RT_VERSION = Number(process.env.MOON_RTVERSION);
+const RT_NAME = process.env.MOON_RTNAME;
+let limiter;
+// About: This has been designed in the handler pattern so that eventually we can integrate it to vitest
+// https://vitest.dev/advanced/runner.html
+/**
+ *  * Defines a suite of tests based on provided parameters.
+ *
+ * @param {object} params - The setup parameters for the test suite.
+ * @param {string} params.id - A unique identifier for the test suite (e.g. D03).
+ * @param {string} params.title - The title of the test suite (e.g. 'Fee calculation: congestion handling').
+ * @param {function} params.testCases - A callback function that houses the individual test cases of this suite.
+ * @param {string} params.foundationMethods - Explicitly specify which foundation these tests will run against reveal which methods to make available.
+ * @param {number} [params.minRtVersion] - The minimum runtime version required for the test suite, otherwise will be skipped.
+ * @param {string} [params.chainType] - The required runtime name required for the test suite, otherwise will be skipped.
+ * @param {string} [params.notChainType] - The runtime name to not run against this test suite, otherwise will not be skipped.
+ *
+ * @returns {void} - No explicit return value, this function results is wrapped and handled by the vitest instance.
+ * @example
+ *      describeSuite({
+ *        id: "D01",
+ *        title: "Sample test suite",
+ *        foundationMethods: "dev",
+ *        testCases: ({ it, context, log }) => {
+ *          it({
+ *            id: "T01",
+ *            title: "Sample test case",
+ *            testds: async function () {
+ *              expect(true).to.be.true;
+ *            },
+ *          });
+ *        },
+ *      });
+ */
+export function describeSuite({ id: suiteId, title, testCases, foundationMethods, minRtVersion, chainType, notChainType, options, }) {
+    if ((minRtVersion && minRtVersion > RT_VERSION) ||
+        (chainType && chainType !== RT_NAME) ||
+        (notChainType && notChainType === RT_NAME)) {
+        describe.skip(`🗃️  ${suiteId} ${title}`);
+        return;
+    }
+    let ctx = null;
+    const logger = createLogger({ name: suiteId });
+    beforeAll(async () => {
+        const env = getEnvironmentFromConfig();
+        ctx = env.foundation.type === "dev" ? await contextCreator(options) : await contextCreator();
+        if (env.foundation.type === "read_only") {
+            const settings = loadParams(env.foundation.launchSpec);
+            limiter = new Bottleneck(settings);
+        }
+    });
+    afterAll(async () => {
+        // The termination reason will be set by the test runner or signal handlers
+        // Default to "tests finished" if not set explicitly
+        const reason = global.MOONWALL_TERMINATION_REASON || "tests finished";
+        await MoonwallContext.destroy(reason);
+        ctx = null;
+    });
+    const testCase = (params) => {
+        if (params.modifier) {
+            it[params.modifier](`📁  ${suiteId.concat(params.id)} ${params.title}`, params.test, params.timeout);
+            return;
+        }
+        if ((params.minRtVersion && params.minRtVersion > RT_VERSION) ||
+            (params.chainType && params.chainType !== RT_NAME) ||
+            (params.notChainType && params.notChainType === RT_NAME)) {
+            it.skip(`📁  ${suiteId.concat(params.id)} ${params.title}`, params.test, params.timeout);
+            return;
+        }
+        it(`📁  ${suiteId.concat(params.id)} ${params.title}`, params.test, params.timeout);
+    };
+    describe(`🗃️  ${suiteId} ${title}`, () => {
+        const getApi = (apiType, apiName) => {
+            if (!ctx) {
+                throw new Error("Context not initialized");
+            }
+            const provider = ctx.providers.find((prov) => {
+                if (apiType && apiName) {
+                    return prov.type === apiType && prov.name === apiName;
+                }
+                if (apiType && !apiName) {
+                    return prov.type === apiType;
+                }
+                if (!apiType && apiName) {
+                    return prov.name === apiName;
+                }
+                return false;
+            });
+            if (!provider) {
+                throw new Error(`API of type ${apiType} ${apiName ? `and name ${apiName}` : ""} could not be found`);
+            }
+            return !limiter
+                ? provider.api
+                : scheduleWithBottleneck(provider.api);
+        };
+        const context = {
+            api: (type, name) => getApi(type, name),
+            viem: (apiName) => getApi("viem", apiName),
+            polkadotJs: (apiName) => getApi("polkadotJs", apiName),
+            ethers: (apiName) => getApi("ethers", apiName),
+            web3: (apiName) => getApi("web3", apiName),
+            papi: (apiName) => getApi("papi", apiName),
+        };
+        const foundationHandlers = {
+            dev: devHandler,
+            chopsticks: chopsticksHandler,
+            zombie: zombieHandler,
+            read_only: readOnlyHandler,
+        };
+        const handler = foundationHandlers[foundationMethods];
+        if (!handler) {
+            throw new Error(`Unsupported foundation methods: ${foundationMethods}`);
+        }
+        handler({
+            testCases: testCases,
+            context,
+            testCase,
+            logger,
+            ctx,
+        });
+    });
+}
+const loadParams = (config) => {
+    const defaultParams = { maxConcurrent: 5, minTime: 100 };
+    if (!config || config.rateLimiter === undefined || config.rateLimiter === true) {
+        return defaultParams;
+    }
+    if (config.rateLimiter === false) {
+        return {};
+    }
+    if (typeof config.rateLimiter === "object") {
+        return config.rateLimiter;
+    }
+};
+const scheduleWithBottleneck = (api) => {
+    return new Proxy(api, {
+        get(target, propKey) {
+            const origMethod = target[propKey];
+            if (typeof origMethod === "function" && propKey !== "rpc" && propKey !== "tx") {
+                return (...args) => {
+                    if (!limiter) {
+                        throw new Error("Limiter not initialized");
+                    }
+                    return limiter.schedule(() => origMethod.apply(target, args));
+                };
+            }
+            return origMethod;
+        },
+    });
+};

package/dist/cli/lib/shardManager.d.ts

@@ -0,0 +1,40 @@
+interface ShardInfo {
+    readonly current: number;
+    readonly total: number;
+    readonly isSharded: boolean;
+}
+export declare class ShardManager {
+    private static instance;
+    private _shardInfo;
+    private constructor();
+    static getInstance(): ShardManager;
+    /**
+     * Initialize shard configuration from command line argument or environment
+     * @param shardArg Optional shard argument from CLI (format: "current/total")
+     */
+    initializeSharding(shardArg?: string): void;
+    /**
+     * Get current shard information
+     */
+    getShardInfo(): ShardInfo;
+    /**
+     * Get shard index (0-based) for port calculations
+     */
+    getShardIndex(): number;
+    /**
+     * Get total number of shards
+     */
+    getTotalShards(): number;
+    /**
+     * Check if sharding is enabled
+     */
+    isSharded(): boolean;
+    /**
+     * Reset shard configuration (mainly for testing)
+     */
+    reset(): void;
+    private parseShardString;
+}
+export declare const shardManager: ShardManager;
+export {};
+//# sourceMappingURL=shardManager.d.ts.map

package/dist/cli/lib/shardManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shardManager.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/shardManager.ts"],"names":[],"mappings":"AAAA,UAAU,SAAS;IACjB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IACpD,OAAO,CAAC,UAAU,CAA0B;IAE5C,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,YAAY;IAOlC;;;OAGG;IACH,kBAAkB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;IAY3C;;OAEG;IACH,YAAY,IAAI,SAAS;IAOzB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,gBAAgB;CA2BzB;AAGD,eAAO,MAAM,YAAY,cAA6B,CAAC"}

package/dist/cli/lib/shardManager.js

@@ -0,0 +1,80 @@
+export class ShardManager {
+    static instance = null;
+    _shardInfo = null;
+    constructor() { }
+    static getInstance() {
+        if (!ShardManager.instance) {
+            ShardManager.instance = new ShardManager();
+        }
+        return ShardManager.instance;
+    }
+    /**
+     * Initialize shard configuration from command line argument or environment
+     * @param shardArg Optional shard argument from CLI (format: "current/total")
+     */
+    initializeSharding(shardArg) {
+        if (shardArg) {
+            this._shardInfo = this.parseShardString(shardArg);
+            process.env.MOONWALL_TEST_SHARD = shardArg;
+        }
+        else if (process.env.MOONWALL_TEST_SHARD) {
+            this._shardInfo = this.parseShardString(process.env.MOONWALL_TEST_SHARD);
+        }
+        else {
+            // Default: no sharding
+            this._shardInfo = { current: 1, total: 1, isSharded: false };
+        }
+    }
+    /**
+     * Get current shard information
+     */
+    getShardInfo() {
+        if (!this._shardInfo) {
+            this.initializeSharding();
+        }
+        return this._shardInfo;
+    }
+    /**
+     * Get shard index (0-based) for port calculations
+     */
+    getShardIndex() {
+        return this.getShardInfo().current - 1;
+    }
+    /**
+     * Get total number of shards
+     */
+    getTotalShards() {
+        return this.getShardInfo().total;
+    }
+    /**
+     * Check if sharding is enabled
+     */
+    isSharded() {
+        return this.getShardInfo().isSharded;
+    }
+    /**
+     * Reset shard configuration (mainly for testing)
+     */
+    reset() {
+        this._shardInfo = null;
+        delete process.env.MOONWALL_TEST_SHARD;
+    }
+    parseShardString(shardString) {
+        if (!shardString.includes("/")) {
+            throw new Error(`Invalid shard format: "${shardString}". Expected format: "current/total" (e.g., "1/3")`);
+        }
+        const [currentStr, totalStr] = shardString.split("/");
+        const current = parseInt(currentStr, 10);
+        const total = parseInt(totalStr, 10);
+        if (Number.isNaN(current) || Number.isNaN(total) || current < 1 || total < 1) {
+            throw new Error(`Invalid shard numbers in "${shardString}". Both current and total must be positive integers.`);
+        }
+        if (current > total) {
+            throw new Error(`Invalid shard configuration: current shard ${current} cannot be greater than total ${total}`);
+        }
+        const isSharded = total > 1;
+        return { current, total, isSharded };
+    }
+}
+// Export singleton instance for convenience
+export const shardManager = ShardManager.getInstance();

package/dist/cli/lib/upgradeProcedures.d.ts

@@ -0,0 +1,5 @@
+import type { ChopsticksContext, UpgradePreferences } from "../../api/types/index.js";
+import type { ApiPromise } from "@polkadot/api";
+export declare function upgradeRuntimeChopsticks(context: ChopsticksContext, path: string, providerName?: string): Promise<void>;
+export declare function upgradeRuntime(api: ApiPromise, preferences: UpgradePreferences): Promise<number>;
+//# sourceMappingURL=upgradeProcedures.d.ts.map

package/dist/cli/lib/upgradeProcedures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgradeProcedures.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/upgradeProcedures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,iCAAiC;AACtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAahD,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,MAAM,EACZ,YAAY,CAAC,EAAE,MAAM,iBAkCtB;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,WAAW,EAAE,kBAAkB,mBAoPpF"}

package/dist/cli/lib/upgradeProcedures.js

@@ -0,0 +1,221 @@
+import { blake2AsHex } from "@polkadot/util-crypto";
+import chalk from "chalk";
+import { sha256 } from "ethers";
+import fs, { existsSync, readFileSync } from "node:fs";
+import { getRuntimeWasm } from "./binariesHelpers.js";
+import { cancelReferendaWithCouncil, executeOpenTechCommitteeProposal, executeProposalWithCouncil, } from "./governanceProcedures.js";
+export async function upgradeRuntimeChopsticks(context, path, providerName) {
+    if (!existsSync(path)) {
+        throw new Error(`Runtime wasm not found at path: ${path}`);
+    }
+    const rtWasm = readFileSync(path);
+    const rtHex = `0x${rtWasm.toString("hex")}`;
+    const rtHash = blake2AsHex(rtHex);
+    const api = context.polkadotJs(providerName);
+    const signer = context.keyring.alice;
+    if ("authorizedUpgrade" in api.query.system) {
+        await context.setStorage({
+            providerName,
+            module: "system",
+            method: "authorizedUpgrade",
+            methodParams: `${rtHash}01`, // 01 is for the RT ver check = true
+        });
+        await context.createBlock({ providerName });
+        await api.tx.system.applyAuthorizedUpgrade(rtHex).signAndSend(signer);
+    }
+    else {
+        await context.setStorage({
+            providerName,
+            module: "parachainSystem",
+            method: "authorizedUpgrade",
+            methodParams: `${rtHash}01`, // 01 is for the RT ver check = true
+        });
+        await context.createBlock({ providerName });
+        await api.tx.parachainSystem.enactAuthorizedUpgrade(rtHex).signAndSend(signer);
+    }
+    await context.createBlock({ providerName, count: 3 });
+}
+export async function upgradeRuntime(api, preferences) {
+    const options = {
+        waitMigration: true,
+        upgradeMethod: "Sudo",
+        ...preferences,
+    };
+    return new Promise(async (resolve, reject) => {
+        const log = (text) => {
+            if (options.logger) {
+                // Check if logger is a function (backward compatibility) or an object with methods
+                if (typeof options.logger === "function") {
+                    return options.logger(text);
+                }
+                if (typeof options.logger.info === "function") {
+                    return options.logger.info(text);
+                }
+            }
+            return;
+        };
+        if (!options.runtimeName) {
+            throw new Error("'runtimeName' is required to upgrade runtime");
+        }
+        if (!options.runtimeTag) {
+            throw new Error("'runtimeTag' is required to upgrade runtime");
+        }
+        if (!options.from) {
+            throw new Error("'from' is required to upgrade runtime");
+        }
+        try {
+            const code = fs
+                .readFileSync(await getRuntimeWasm(options.runtimeName, options.runtimeTag, options.localPath))
+                .toString();
+            log("Checking if upgrade is needed...");
+            const existingCode = await api.rpc.state.getStorage(":code");
+            if (!existingCode) {
+                throw "No existing runtime code found";
+            }
+            if (existingCode.toString() === code) {
+                reject(`Runtime upgrade with same code: ${existingCode.toString().slice(0, 20)} vs ${code
+                    .toString()
+                    .slice(0, 20)}`);
+            }
+            let nonce = (await api.rpc.system.accountNextIndex(options.from.address)).toNumber();
+            switch (options.upgradeMethod) {
+                case "Sudo": {
+                    log(`Sending sudo.setCode (${sha256(Buffer.from(code))} [~${Math.floor(code.length / 1024)} kb])...`);
+                    const isWeightV1 = !api.registry.createType("Weight").proofSize;
+                    await api.tx.sudo
+                        .sudoUncheckedWeight(await api.tx.system.setCodeWithoutChecks(code), isWeightV1
+                        ? "1"
+                        : {
+                            proofSize: 1,
+                            refTime: 1,
+                        })
+                        .signAndSend(options.from, { nonce: nonce++ });
+                    log("✅");
+                    break;
+                }
+                case "Governance": {
+                    log("Using governance...");
+                    // TODO: remove support for old style after all chains upgraded to 2400+
+                    const proposal = api.consts.system.version.specVersion.toNumber() >= 2400
+                        ? api.tx.parachainSystem.authorizeUpgrade(blake2AsHex(code), true)
+                        : api.tx.parachainSystem.authorizeUpgrade(blake2AsHex(code));
+                    const encodedProposal = proposal.method.toHex();
+                    const encodedHash = blake2AsHex(encodedProposal);
+                    log("Checking if preimage already exists...");
+                    // Check if already in governance
+                    const preImageExists = api.query.preimage && (await api.query.preimage.statusFor(encodedHash));
+                    const democracyPreImageExists = !api.query.preimage && (await api.query.democracy.preimages(encodedHash));
+                    if (api.query.preimage && preImageExists.isSome && preImageExists.unwrap().isRequested) {
+                        log(`Preimage ${encodedHash} already exists !\n`);
+                    }
+                    else if (!api.query.preimage && democracyPreImageExists) {
+                        log(`Preimage ${encodedHash} already exists !\n`);
+                    }
+                    else {
+                        log(`Registering preimage (${sha256(Buffer.from(code))} [~${Math.floor(code.length / 1024)} kb])...`);
+                        if (api.query.preimage) {
+                            await api.tx.preimage
+                                .notePreimage(encodedProposal)
+                                .signAndSend(options.from, { nonce: nonce++ });
+                        }
+                        else {
+                            // TODO: remove support for democracy after 2000
+                            await api.tx.democracy
+                                .notePreimage(encodedProposal)
+                                .signAndSend(options.from, { nonce: nonce++ });
+                        }
+                        log("Complete ✅");
+                    }
+                    // Check if already in referendum
+                    const referendum = await api.query.democracy.referendumInfoOf.entries();
+                    // TODO: remove support for democracy after 2000
+                    const referendaIndex = api.query.preimage
+                        ? referendum
+                            .filter((ref) => ref[1].unwrap().isOngoing &&
+                            ref[1].unwrap().asOngoing.proposal.isLookup &&
+                            ref[1].unwrap().asOngoing.proposal.asLookup.hash.toHex() === encodedHash)
+                            .map((ref) => api.registry.createType("u32", ref[0].toU8a().slice(-4)).toNumber())?.[0]
+                        : referendum
+                            .filter((ref) => ref[1].unwrap().isOngoing &&
+                            ref[1].unwrap().asOngoing.proposalHash.toHex() === encodedHash)
+                            .map((ref) => api.registry.createType("u32", ref[0].toU8a().slice(-4)).toNumber())?.[0];
+                    if (referendaIndex !== null && referendaIndex !== undefined) {
+                        log("Vote for upgrade already in referendum, cancelling it.");
+                        await cancelReferendaWithCouncil(api, referendaIndex);
+                    }
+                    await executeProposalWithCouncil(api, encodedHash);
+                    // Needs to retrieve nonce after those governance calls
+                    nonce = (await api.rpc.system.accountNextIndex(options.from.address)).toNumber();
+                    log("Enacting authorized upgrade...");
+                    await api.tx.parachainSystem
+                        .enactAuthorizedUpgrade(code)
+                        .signAndSend(options.from, { nonce: nonce++ });
+                    log("Complete ✅");
+                    break;
+                }
+                case "WhiteListedCaller": {
+                    log("Using WhiteListed Caller...");
+                    const proposal = api.tx.parachainSystem.authorizeUpgrade(blake2AsHex(code), true);
+                    const encodedProposal = proposal.method.toHex();
+                    const encodedHash = blake2AsHex(encodedProposal);
+                    log("Checking if preimage already exists...");
+                    const preImageExists = api.query.preimage && (await api.query.preimage.statusFor(encodedHash));
+                    if (preImageExists.isSome && preImageExists.unwrap().isRequested) {
+                        log(`Preimage ${encodedHash} already exists !\n`);
+                    }
+                    else {
+                        log(`Registering preimage (${sha256(Buffer.from(code))} [~${Math.floor(code.length / 1024)} kb])...`);
+                        await api.tx.preimage
+                            .notePreimage(encodedProposal)
+                            .signAndSend(options.from, { nonce: nonce++ });
+                        log("Complete ✅");
+                    }
+                    const referendum = await api.query.referenda.referendumInfoFor.entries();
+                    const _referendaIndex = referendum
+                        .filter((ref) => ref[1].unwrap().isOngoing &&
+                        ref[1].unwrap().asOngoing.proposal.isLookup &&
+                        ref[1].unwrap().asOngoing.proposal.asLookup.hash.toHex() === encodedHash)
+                        .map((ref) => api.registry.createType("u32", ref[0].toU8a().slice(-4)).toNumber())?.[0];
+                    await executeOpenTechCommitteeProposal(api, encodedHash);
+                    break;
+                }
+            }
+            log(`Waiting to apply new runtime (${chalk.red("~4min")})...`);
+            let isInitialVersion = true;
+            const unsub = await api.rpc.state.subscribeStorage([":code"], async (newCode) => {
+                if (!isInitialVersion) {
+                    const blockNumber = (await api.rpc.chain.getHeader()).number.toNumber();
+                    log(`Complete ✅ [New Code: ${newCode.toString().slice(0, 5)}...${newCode
+                        .toString()
+                        .slice(-4)} , Old Code:${existingCode.toString().slice(0, 5)}...${existingCode
+                        .toString()
+                        .slice(-4)}] [#${blockNumber}]`);
+                    unsub();
+                    if (newCode.toString() !== code) {
+                        reject(`Unexpected new code: ${newCode.toString().slice(0, 20)} vs ${code
+                            .toString()
+                            .slice(0, 20)}`);
+                    }
+                    if (options.waitMigration) {
+                        const blockToWait = (await api.rpc.chain.getHeader()).number.toNumber() + 1;
+                        await new Promise(async (resolve) => {
+                            const subBlocks = await api.rpc.chain.subscribeNewHeads(async (header) => {
+                                if (header.number.toNumber() === blockToWait) {
+                                    subBlocks();
+                                    resolve(blockToWait);
+                                }
+                            });
+                        });
+                    }
+                    resolve(blockNumber);
+                }
+                isInitialVersion = false;
+            });
+        }
+        catch (e) {
+            console.error(e);
+            console.error("Failed to setCode");
+            reject(e);
+        }
+    });
+}

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env -S node --no-warnings --no-deprecation
+import "./cli/internal/logging.js";
+import "./cli/cmds/entrypoint.js";
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA,mCAAmC;AACnC,kCAAkC"}

package/dist/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --no-warnings --no-deprecation
+import "./cli/internal/logging.js";
+import "./cli/cmds/entrypoint.js";

package/dist/contracts/contractInteraction.d.ts

@@ -0,0 +1,17 @@
+import type { ContractCallOptions, ContractDeploymentOptions, DevModeContext, GenericContext, MoonwallContract, PrecompileCallOptions } from "../api/types/index.js";
+import type { Abi } from "viem";
+import { type Log } from "viem";
+export declare function fetchCompiledContract<TAbi extends Abi>(contractName: string): MoonwallContract<TAbi>;
+export declare function recursiveSearch(dir: string, filename: string): string | null;
+export declare function interactWithPrecompileContract(context: GenericContext, callOptions: PrecompileCallOptions): Promise<any>;
+export declare function interactWithContract(context: GenericContext, callOptions: ContractCallOptions): Promise<any>;
+export declare function deployCreateCompiledContract<TOptions extends ContractDeploymentOptions>(context: DevModeContext, contractName: string, options?: TOptions): Promise<{
+    contractAddress: `0x${string}`;
+    logs: Log<bigint, number>[];
+    hash: `0x${string}`;
+    status: "success" | "reverted";
+    abi: Abi;
+    bytecode: `0x${string}`;
+    methods: any;
+}>;
+//# sourceMappingURL=contractInteraction.d.ts.map

package/dist/contracts/contractInteraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contractInteraction.d.ts","sourceRoot":"","sources":["../../src/contracts/contractInteraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EACzB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACtB,8BAA8B;AAY/B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAChC,OAAO,EAAE,KAAK,GAAG,EAAmD,MAAM,MAAM,CAAC;AAoCjF,wBAAgB,qBAAqB,CAAC,IAAI,SAAS,GAAG,EACpD,YAAY,EAAE,MAAM,GACnB,gBAAgB,CAAC,IAAI,CAAC,CAUxB;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmB5E;AAED,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,cAAc,EACvB,WAAW,EAAE,qBAAqB,gBAoBnC;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,cAAc,EACvB,WAAW,EAAE,mBAAmB,gBAkGjC;AAED,wBAAsB,4BAA4B,CAAC,QAAQ,SAAS,yBAAyB,EAC3F,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC;IACT,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAC5B,IAAI,EAAE,KAAK,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,SAAS,GAAG,UAAU,CAAC;IAC/B,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;IACxB,OAAO,EAAE,GAAG,CAAC;CACd,CAAC,CA2BD"}