moonwall 1.0.0-dev.0

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

@@ -0,0 +1,27 @@
+import type { DevModeContext } from "../../api/types/index.js";
+import type { ApiPromise } from "@polkadot/api";
+import type { ApiTypes, SubmittableExtrinsic } from "@polkadot/api/types";
+import type { KeyringPair } from "@polkadot/keyring/types";
+export declare const COUNCIL_MEMBERS: KeyringPair[];
+export declare const COUNCIL_THRESHOLD: number;
+export declare const TECHNICAL_COMMITTEE_MEMBERS: KeyringPair[];
+export declare const TECHNICAL_COMMITTEE_THRESHOLD: number;
+export declare const OPEN_TECHNICAL_COMMITTEE_MEMBERS: KeyringPair[];
+export declare const OPEN_TECHNICAL_COMMITTEE_THRESHOLD: number;
+export declare const notePreimage: <Call extends SubmittableExtrinsic<ApiType>, ApiType extends ApiTypes>(context: DevModeContext, proposal: Call, account?: KeyringPair) => Promise<string>;
+export declare const instantFastTrack: <Call extends SubmittableExtrinsic<ApiType>, ApiType extends ApiTypes>(context: DevModeContext, proposal: string | Call, { votingPeriod, delayPeriod }?: {
+    votingPeriod: number;
+    delayPeriod: number;
+}) => Promise<string>;
+export declare const whiteListedTrack: <Call extends SubmittableExtrinsic<ApiType>, ApiType extends ApiTypes>(context: DevModeContext, proposal: string | Call) => Promise<boolean>;
+export declare const execOpenTechCommitteeProposal: <Call extends SubmittableExtrinsic<ApiType>, ApiType extends ApiTypes>(context: DevModeContext, call: Call | string, voters?: KeyringPair[], threshold?: number) => Promise<import("../../index.js").ExtrinsicCreation>;
+export declare const execCouncilProposal: <Call extends SubmittableExtrinsic<ApiType>, ApiType extends ApiTypes>(context: DevModeContext, polkadotCall: Call, index?: number, voters?: KeyringPair[], threshold?: number) => Promise<import("../../index.js").ExtrinsicCreation | import("../../index.js").BlockCreationResponse<ApiTypes, Promise<SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>>>;
+export declare const proposeReferendaAndDeposit: <Call extends SubmittableExtrinsic<ApiType>, ApiType extends ApiTypes>(context: DevModeContext, decisionDepositer: KeyringPair, proposal: string | Call, origin: unknown) => Promise<[number, string]>;
+export declare const dispatchAsGeneralAdmin: <Call extends SubmittableExtrinsic<ApiType>, ApiType extends ApiTypes>(context: DevModeContext, call: string | Call) => Promise<void>;
+export declare const maximizeConvictionVotingOf: (context: DevModeContext, voters: KeyringPair[], refIndex: number) => Promise<void>;
+export declare const execTechnicalCommitteeProposal: <Call extends SubmittableExtrinsic<ApiType>, ApiType extends ApiTypes>(context: DevModeContext, polkadotCall: Call, voters?: KeyringPair[], threshold?: number) => Promise<import("../../index.js").ExtrinsicCreation | undefined>;
+export declare const executeOpenTechCommitteeProposal: (api: ApiPromise, encodedHash: string) => Promise<void>;
+export declare const executeProposalWithCouncil: (api: ApiPromise, encodedHash: string) => Promise<void>;
+export declare const cancelReferendaWithCouncil: (api: ApiPromise, refIndex: number) => Promise<void>;
+export declare const fastFowardToNextEvent: (context: DevModeContext) => Promise<void>;
+//# sourceMappingURL=governanceProcedures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"governanceProcedures.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/governanceProcedures.ts"],"names":[],"mappings":"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"}

package/dist/cli/lib/governanceProcedures.js

@@ -0,0 +1,458 @@
+import { GLMR, alith, baltathar, charleth, dorothy, ethan, faith, filterAndApply, signAndSend, } from "../../util/index.js";
+import { blake2AsHex } from "@polkadot/util-crypto";
+export const COUNCIL_MEMBERS = [baltathar, charleth, dorothy];
+export const COUNCIL_THRESHOLD = Math.ceil((COUNCIL_MEMBERS.length * 2) / 3);
+export const TECHNICAL_COMMITTEE_MEMBERS = [alith, baltathar];
+export const TECHNICAL_COMMITTEE_THRESHOLD = Math.ceil((TECHNICAL_COMMITTEE_MEMBERS.length * 2) / 3);
+export const OPEN_TECHNICAL_COMMITTEE_MEMBERS = [alith, baltathar];
+export const OPEN_TECHNICAL_COMMITTEE_THRESHOLD = Math.ceil((OPEN_TECHNICAL_COMMITTEE_MEMBERS.length * 2) / 3);
+// TODO: Refactor to support both instant sealing and parachain environment
+// (using a waitOrCreateNextBlock common function)
+export const notePreimage = async (context, proposal, account = alith) => {
+    const encodedProposal = proposal.method.toHex() || "";
+    await context.createBlock(context.polkadotJs().tx.preimage.notePreimage(encodedProposal).signAsync(account));
+    return blake2AsHex(encodedProposal);
+};
+// Creates the Council Proposal and fast track it before executing it
+export const instantFastTrack = async (context, proposal, { votingPeriod, delayPeriod } = { votingPeriod: 2, delayPeriod: 0 }) => {
+    const proposalHash = typeof proposal === "string" ? proposal : await notePreimage(context, proposal);
+    await execCouncilProposal(context, context.polkadotJs().tx.democracy.externalProposeMajority({
+        Lookup: {
+            hash: proposalHash,
+            len: typeof proposal === "string" ? proposal : proposal.method.encodedLength,
+        },
+    }));
+    await execTechnicalCommitteeProposal(context, context.polkadotJs().tx.democracy.fastTrack(proposalHash, votingPeriod, delayPeriod));
+    return proposalHash;
+};
+// Uses WhitelistedOrigin track to quickly execute a call
+export const whiteListedTrack = async (context, proposal) => {
+    const proposalHash = typeof proposal === "string" ? proposal : await notePreimage(context, proposal);
+    // Construct dispatchWhiteListed call
+    const proposalLen = (await context.pjsApi.query.preimage.requestStatusFor(proposalHash)).unwrap().asUnrequested.len;
+    const dispatchWLCall = context.pjsApi.tx.whitelist.dispatchWhitelistedCall(proposalHash, proposalLen, {
+        refTime: 2_000_000_000,
+        proofSize: 100_000,
+    });
+    // Note preimage of it
+    const wLPreimage = await notePreimage(context, dispatchWLCall);
+    const wLPreimageLen = dispatchWLCall.encodedLength - 2;
+    console.log(`📝 DispatchWhitelistedCall preimage noted: ${wLPreimage.slice(0, 6)}...${wLPreimage.slice(-4)}, len: ${wLPreimageLen}`);
+    // Submit openGov proposal
+    const openGovProposal = await context.pjsApi.tx.referenda
+        .submit({
+        Origins: { whitelistedcaller: "WhitelistedCaller" },
+    }, { Lookup: { hash: wLPreimage, len: wLPreimageLen } }, { After: { After: 0 } })
+        .signAsync(faith);
+    const { result } = await context.createBlock(openGovProposal);
+    if (!result?.events) {
+        throw new Error("No events in block");
+    }
+    let proposalId;
+    filterAndApply(result.events, "referenda", ["Submitted"], (found) => {
+        proposalId = found.event.data.index.toNumber();
+    });
+    if (typeof proposalId === "undefined") {
+        throw new Error("No proposal id found");
+    }
+    console.log(`🏛️ Referendum submitted with proposal id: ${proposalId}`);
+    await context.createBlock(context.pjsApi.tx.referenda.placeDecisionDeposit(proposalId));
+    const whitelistCall = context.pjsApi.tx.whitelist.whitelistCall(proposalHash);
+    await execOpenTechCommitteeProposal(context, whitelistCall);
+    await maximizeConvictionVotingOf(context, [ethan], proposalId);
+    await context.createBlock();
+    const checkCompletion = async () => {
+        const authorized = (await context.pjsApi.query.system.authorizedUpgrade());
+        if (!authorized.isNone) {
+            return true;
+        }
+        const events = (await context.pjsApi.query.system.events());
+        return events.some(({ event, }) => {
+            const section = event.section.toString();
+            const method = event.method.toString();
+            return section === "whitelist" && method === "WhitelistedCallDispatched";
+        });
+    };
+    await fastFowardToNextEvent(context); // ⏩️ until preparation done
+    if (await checkCompletion()) {
+        return true;
+    }
+    await fastFowardToNextEvent(context); // ⏩️ until proposal confirmed
+    if (await checkCompletion()) {
+        return true;
+    }
+    await fastFowardToNextEvent(context); // ⏩️ until proposal enacted
+    if (await checkCompletion()) {
+        return true;
+    }
+    // Some runtimes enqueue extra agenda items before the whitelist dispatch completes.
+    // Keep fast-forwarding until the authorized upgrade is populated or the agenda is empty.
+    for (let attempt = 0; attempt < 5; attempt++) {
+        if (await checkCompletion()) {
+            break;
+        }
+        try {
+            await fastFowardToNextEvent(context);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("No items in scheduler.agenda")) {
+                break;
+            }
+            throw error;
+        }
+    }
+    return await checkCompletion();
+};
+// Creates a OpenTechCommitteeProposal and attempts to execute it
+export const execOpenTechCommitteeProposal = async (context, call, voters = OPEN_TECHNICAL_COMMITTEE_MEMBERS, threshold = OPEN_TECHNICAL_COMMITTEE_THRESHOLD) => {
+    const openTechCommitteeProposal = context.pjsApi.tx.openTechCommitteeCollective.propose(threshold, call, 100);
+    const { result: result2 } = await context.createBlock(openTechCommitteeProposal, {
+        signer: voters[0],
+    });
+    if (!result2?.events) {
+        throw new Error("No events in block");
+    }
+    let openTechProposal;
+    let openTechProposalIndex;
+    filterAndApply(result2.events, "openTechCommitteeCollective", ["Proposed"], (found) => {
+        openTechProposalIndex = found.event.data.proposalIndex.toNumber();
+        openTechProposal = found.event.data.proposalHash.toHex();
+    });
+    if (typeof openTechProposal === "undefined" || typeof openTechProposalIndex === "undefined") {
+        console.error("Error submitting OpenTechCommittee proposal");
+        return result2;
+    }
+    console.log(`🏛️ OpenTechCommittee proposal submitted with proposal id: ${openTechProposalIndex} and hash: ${openTechProposal?.slice(0, 6)}...${openTechProposal?.slice(-4)}`);
+    // Vote on it
+    for (const voter of voters) {
+        const nonce = (await context.pjsApi.query.system.account(voter.address)).nonce.toNumber();
+        const vote = context.pjsApi.tx.openTechCommitteeCollective
+            .vote(openTechProposal, openTechProposalIndex, true)
+            .signAsync(voter, { nonce });
+        await context.createBlock(vote);
+    }
+    // Close proposal
+    const { result } = await context.createBlock(context.pjsApi.tx.openTechCommitteeCollective.close(openTechProposal, openTechProposalIndex, {
+        refTime: 2_000_000_000,
+        proofSize: 100_000,
+    }, 100), { signer: voters[0] });
+    if (!result) {
+        throw new Error("No result in block");
+    }
+    return result;
+};
+// Creates the Council Proposal
+// Vote with the members (all members by default)
+// Close it (Execute if successful)
+export const execCouncilProposal = async (context, polkadotCall, index = -1, voters = COUNCIL_MEMBERS, threshold = COUNCIL_THRESHOLD) => {
+    // Charleth submit the proposal to the council (and therefore implicitly votes for)
+    const lengthBound = polkadotCall.method.encodedLength;
+    const { result: proposalResult } = await context.createBlock(context
+        .polkadotJs()
+        .tx.councilCollective.propose(threshold, polkadotCall, lengthBound)
+        .signAsync(charleth));
+    if (!proposalResult) {
+        throw "Proposal result is undefined";
+    }
+    if (threshold <= 1) {
+        // Proposal are automatically executed on threshold <= 1
+        return proposalResult;
+    }
+    if (!proposalResult.successful) {
+        throw `Council proposal refused: ${proposalResult?.error?.name}`;
+    }
+    const proposed = proposalResult.events.find(({ event: { method } }) => method.toString() === "Proposed");
+    if (!proposed) {
+        throw "Proposed event not found";
+    }
+    const proposalHash = proposed.event.data[2].toHex();
+    // Dorothy vote for this proposal and close it
+    const proposalIndex = index >= 0
+        ? index
+        : (await context.polkadotJs().query.councilCollective.proposalCount()).toNumber() -
+            1;
+    await Promise.all(voters.map((voter) => context
+        .polkadotJs()
+        .tx.councilCollective.vote(proposalHash, proposalIndex, true)
+        .signAndSend(voter)));
+    await context.createBlock();
+    return await context.createBlock(context
+        .polkadotJs()
+        .tx.councilCollective.close(proposalHash, proposalIndex, {
+        refTime: 2_000_000_000,
+        proofSize: 100_000,
+    }, lengthBound)
+        .signAsync(dorothy));
+};
+// Proposes referenda and places decision deposit
+// Returns referendum index and proposal hash
+export const proposeReferendaAndDeposit = async (context, decisionDepositer, proposal, origin) => {
+    // Fetch proposal hash
+    const proposalHash = typeof proposal === "string" ? proposal : await notePreimage(context, proposal);
+    // Post referenda
+    const { result: proposalResult } = await context.createBlock(context
+        .polkadotJs()
+        .tx.referenda.submit(origin, {
+        Lookup: {
+            hash: proposalHash,
+            len: typeof proposal === "string" ? proposal : proposal.method.encodedLength,
+        },
+    }, { At: 0 })
+        .signAsync(alith));
+    if (!proposalResult) {
+        throw "Proposal result is undefined";
+    }
+    if (!proposalResult.successful) {
+        throw `Unable to post referenda: ${proposalResult?.error?.name}`;
+    }
+    const refIndex = proposalResult.events
+        .find(({ event: { method } }) => method.toString() === "Submitted")
+        ?.event.data[0].toString();
+    if (!refIndex) {
+        throw "Referendum index not found";
+    }
+    // Place decision deposit
+    await context.createBlock(context.polkadotJs().tx.referenda.placeDecisionDeposit(refIndex).signAsync(decisionDepositer));
+    return [+refIndex, proposalHash];
+};
+// Proposes referenda and places decision deposit
+// Returns referendum index and proposal hash
+export const dispatchAsGeneralAdmin = async (context, call) => {
+    // Post referenda
+    await context.createBlock(context.polkadotJs().tx.sudo.sudo(context.polkadotJs().tx.utility.dispatchAs({
+        Origins: "GeneralAdmin",
+    }, call)));
+};
+// Maximizes conviction voting of some voters
+// with respect to an ongoing referenda
+// Their whole free balance will be used to vote
+export const maximizeConvictionVotingOf = async (context, voters, refIndex) => {
+    // We need to have enough to pay for fee
+    const fee = (await context
+        .polkadotJs()
+        .tx.convictionVoting.vote(refIndex, {
+        Standard: {
+            vote: { aye: true, conviction: "Locked6x" },
+            balance: (await context.polkadotJs().query.system.account(alith.address)).data
+                .free,
+        },
+    })
+        .paymentInfo(alith)).partialFee;
+    // We vote with everything but fee
+    await context.createBlock(voters.map(async (voter) => context
+        .polkadotJs()
+        .tx.convictionVoting.vote(refIndex, {
+        Standard: {
+            vote: { aye: true, conviction: "Locked6x" },
+            balance: await (await context.polkadotJs().query.system.account(voter.address)).data.free.sub(fee),
+        },
+    })
+        .signAsync(voter)));
+};
+// Creates the Technical Committee Proposal
+// Vote with the members (all members by default)
+// Close it (Execute if successful)
+export const execTechnicalCommitteeProposal = async (context, polkadotCall, voters = TECHNICAL_COMMITTEE_MEMBERS, threshold = TECHNICAL_COMMITTEE_THRESHOLD) => {
+    // Tech committee members
+    // Alith submit the proposal to the council (and therefore implicitly votes for)
+    const lengthBound = polkadotCall.encodedLength;
+    const { result: proposalResult } = await context.createBlock(context.polkadotJs().tx.techCommitteeCollective.propose(threshold, polkadotCall, lengthBound));
+    if (!proposalResult) {
+        throw "Proposal result is undefined";
+    }
+    if (threshold <= 1) {
+        // Proposal are automatically executed on threshold <= 1
+        return proposalResult;
+    }
+    if (!proposalResult.successful) {
+        throw `Council proposal refused: ${proposalResult?.error?.name}`;
+    }
+    const proposalHash = proposalResult.events
+        .find(({ event: { method } }) => method.toString() === "Proposed")
+        ?.event.data[2].toHex();
+    if (!proposalHash) {
+        throw "Proposed event not found";
+    }
+    // Get proposal count
+    const proposalCount = await context.polkadotJs().query.techCommitteeCollective.proposalCount();
+    await context.createBlock(voters.map((voter) => context
+        .polkadotJs()
+        .tx.techCommitteeCollective.vote(proposalHash, Number(proposalCount) - 1, true)
+        .signAsync(voter)));
+    const { result: closeResult } = await context.createBlock(context
+        .polkadotJs()
+        .tx.techCommitteeCollective.close(proposalHash, Number(proposalCount) - 1, {
+        refTime: 2_000_000_000,
+        proofSize: 100_000,
+    }, lengthBound)
+        .signAsync(baltathar));
+    return closeResult;
+};
+export const executeOpenTechCommitteeProposal = async (api, encodedHash) => {
+    console.log("Executing OpenTechCommittee proposal");
+    const queryPreimage = (await api.query.preimage.requestStatusFor(encodedHash));
+    if (queryPreimage.isNone) {
+        throw new Error("Preimage not found");
+    }
+    process.stdout.write(`Sending proposal + vote for ${encodedHash}...`);
+    // Noting new preimage to dispatchWhiteList
+    const proposalLen = queryPreimage.unwrap().asUnrequested.len;
+    const dispatchCallHex = api.tx.whitelist
+        .dispatchWhitelistedCall(encodedHash, proposalLen, {
+        refTime: 2_000_000_000,
+        proofSize: 100_000,
+    })
+        .method.toHex();
+    const dispatchCallPreimageHash = blake2AsHex(dispatchCallHex);
+    await signAndSend(api.tx.preimage.notePreimage(dispatchCallHex), charleth);
+    const queryDispatchPreimage = (await api.query.preimage.requestStatusFor(dispatchCallPreimageHash));
+    if (queryDispatchPreimage.isNone) {
+        throw new Error("Dispatch preimage not found");
+    }
+    const dispatchCallPreimageLen = queryDispatchPreimage.unwrap().asUnrequested.len;
+    // Raising new proposal to OpenGov under whitelisted track
+    await signAndSend(api.tx.referenda.submit({
+        Origins: { whitelistedcaller: "WhitelistedCaller" },
+    }, {
+        Lookup: {
+            hash: dispatchCallPreimageHash,
+            len: dispatchCallPreimageLen,
+        },
+    }, { After: { After: 0 } }), charleth);
+    // await api.tx.referenda
+    //   .submit(
+    //     {
+    //       Origins: { whitelistedcaller: "WhitelistedCaller" },
+    //     },
+    //     { Lookup: { hash: dispatchCallPreimageHash, len: dispatchCallPreimageLen } },
+    //     { After: { After: 0 } }
+    //   )
+    //   .signAsync(charleth);
+    const proposalId = (await api.query.referenda.referendumCount()).toNumber() - 1;
+    if (proposalId < 0) {
+        throw new Error("Proposal id not found");
+    }
+    await api.tx.referenda.placeDecisionDeposit(proposalId).signAndSend(alith);
+    // Opening Proposal to whiteList
+    process.stdout.write(`Sending proposal to openTechCommittee to whitelist ${encodedHash}...`);
+    await signAndSend(api.tx.openTechCommitteeCollective.propose(2, api.tx.whitelist.whitelistCall(encodedHash), 100));
+    const openTechProposal = (await api.query.openTechCommitteeCollective.proposals()).at(-1);
+    if (!openTechProposal || openTechProposal?.isEmpty) {
+        throw new Error("OpenTechProposal not found");
+    }
+    const index = (await api.query.openTechCommitteeCollective.proposalCount()).toNumber() - 1;
+    if (index < 0) {
+        throw new Error("OpenTechProposal index not found");
+    }
+    process.stdout.write("✅\n");
+    const baltaNonce = (await api.rpc.system.accountNextIndex(baltathar.address)).toNumber();
+    // Voting and closing on openTech proposal
+    process.stdout.write("Voting on openTechCommittee proposal...");
+    await Promise.all([
+        signAndSend(api.tx.openTechCommitteeCollective.vote(openTechProposal, index, true)),
+        signAndSend(api.tx.openTechCommitteeCollective.vote(openTechProposal, index, true), baltathar, baltaNonce),
+        signAndSend(api.tx.openTechCommitteeCollective.close(openTechProposal, index, {
+            refTime: 2_000_000_000,
+            proofSize: 100_000,
+        }, 100), baltathar, baltaNonce + 1),
+    ]);
+    process.stdout.write("✅\n");
+    // Voting on referendum with lots of money
+    process.stdout.write("Voting on main referendum proposal...");
+    const bal = (await api.query.system.account(dorothy.address)).data.free.toBigInt();
+    if (bal <= GLMR) {
+        throw new Error("Dorothy has no funds to vote with");
+    }
+    await signAndSend(api.tx.convictionVoting.vote(proposalId, {
+        Standard: {
+            vote: { aye: true, conviction: "Locked6x" },
+            balance: bal - GLMR,
+        },
+    }), dorothy);
+    process.stdout.write("✅\n");
+    // Waiting one million years for the referendum to be enacted
+    process.stdout.write(`Waiting for referendum [${proposalId}] to be no longer ongoing...`);
+    let referendaInfo;
+    for (;;) {
+        try {
+            referendaInfo = (await api.query.referenda.referendumInfoFor(proposalId)).unwrap();
+            if (!referendaInfo?.isOngoing) {
+                process.stdout.write("✅\n");
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        catch (e) {
+            console.error(e);
+            throw new Error(`Error querying referendum info for proposalId: ${proposalId}`);
+        }
+    }
+    process.stdout.write(`${referendaInfo?.isApproved ? "✅" : "❌"} \n`);
+    if (!referendaInfo?.isApproved) {
+        throw new Error("Finished Referendum was not approved");
+    }
+};
+export const executeProposalWithCouncil = async (api, encodedHash) => {
+    let nonce = (await api.rpc.system.accountNextIndex(alith.address)).toNumber();
+    const referendumNextIndex = (await api.query.democracy.referendumCount()).toNumber();
+    const callData = api.consts.system.version.specVersion.toNumber() >= 2000
+        ? { Legacy: encodedHash }
+        : encodedHash;
+    const external = api.tx.democracy.externalProposeMajority(callData);
+    const fastTrack = api.tx.democracy.fastTrack(encodedHash, 1, 0);
+    const voteAmount = 1n * 10n ** BigInt(api.registry.chainDecimals[0]);
+    process.stdout.write(`Sending motion + fast-track + vote for ${encodedHash}...`);
+    await Promise.all([
+        api.tx.councilCollective
+            .propose(1, external, external.length)
+            .signAndSend(alith, { nonce: nonce++ }),
+        api.tx.techCommitteeCollective
+            .propose(1, fastTrack, fastTrack.length)
+            .signAndSend(alith, { nonce: nonce++ }),
+        api.tx.democracy
+            .vote(referendumNextIndex, {
+            Standard: {
+                balance: voteAmount,
+                vote: { aye: true, conviction: 1 },
+            },
+        })
+            .signAndSend(alith, { nonce: nonce++ }),
+    ]);
+    process.stdout.write("✅\n");
+    process.stdout.write(`Waiting for referendum [${referendumNextIndex}] to be executed...`);
+    let referenda;
+    while (!referenda) {
+        try {
+            referenda = ((await api.query.democracy.referendumInfoOf.entries()).find((ref) => ref[1].unwrap().isFinished &&
+                api.registry.createType("u32", ref[0].toU8a().slice(-4)).toNumber() ===
+                    referendumNextIndex)?.[1]).unwrap();
+        }
+        catch {
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+    }
+    process.stdout.write(`${referenda.asFinished.approved ? "✅" : "❌"} \n`);
+    if (!referenda.asFinished.approved) {
+        throw new Error("Finished Referendum was not approved");
+    }
+};
+export const cancelReferendaWithCouncil = async (api, refIndex) => {
+    const proposal = api.tx.democracy.cancelReferendum(refIndex);
+    const encodedProposal = proposal.method.toHex();
+    const encodedHash = blake2AsHex(encodedProposal);
+    let nonce = (await api.rpc.system.accountNextIndex(alith.address)).toNumber();
+    await api.tx.democracy.notePreimage(encodedProposal).signAndSend(alith, { nonce: nonce++ });
+    await executeProposalWithCouncil(api, encodedHash);
+};
+export const fastFowardToNextEvent = async (context) => {
+    const [entry] = await context.pjsApi.query.scheduler.agenda.entries();
+    const [key, _] = entry;
+    if (key.isEmpty) {
+        throw new Error("No items in scheduler.agenda");
+    }
+    const decodedKey = key.toHuman();
+    const desiredHeight = Number(decodedKey[0].valueOf().replaceAll(",", ""));
+    const currentHeight = (await context.pjsApi.rpc.chain.getHeader()).number.toNumber();
+    console.log(`⏩️ Current height: ${currentHeight}, desired height: ${desiredHeight}, jumping ${desiredHeight - currentHeight + 1} blocks`);
+    await context.jumpBlocks?.(desiredHeight - currentHeight + 1);
+};

package/dist/cli/lib/handlers/index.d.ts

@@ -0,0 +1,5 @@
+export * from "../../../foundations/chopsticks/handler.js";
+export * from "../../../foundations/dev/handler.js";
+export * from "../../../foundations/read-only/handler.js";
+export * from "../../../foundations/zombie/handler.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/lib/handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/handlers/index.ts"],"names":[],"mappings":"AACA,2DAA2D;AAC3D,oDAAoD;AACpD,0DAA0D;AAC1D,uDAAuD"}

package/dist/cli/lib/handlers/index.js

@@ -0,0 +1,5 @@
+// Re-export from foundations
+export * from "../../../foundations/chopsticks/handler.js";
+export * from "../../../foundations/dev/handler.js";
+export * from "../../../foundations/read-only/handler.js";
+export * from "../../../foundations/zombie/handler.js";

package/dist/cli/lib/repoDefinitions/index.d.ts

@@ -0,0 +1,6 @@
+import type { RepoSpec } from "../../../api/types/index.js";
+export declare function allRepos(): RepoSpec[];
+export declare function allReposAsync(): Promise<RepoSpec[]>;
+export declare function standardRepos(): RepoSpec[];
+export default allRepos;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/lib/repoDefinitions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/repoDefinitions/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,oCAAoC;AAM5D,wBAAgB,QAAQ,eAKvB;AAED,wBAAsB,aAAa,wBAKlC;AAED,wBAAgB,aAAa,eAG5B;AAED,eAAe,QAAQ,CAAC"}

package/dist/cli/lib/repoDefinitions/index.js

@@ -0,0 +1,21 @@
+import mb from "./moonbeam.js";
+import pd from "./polkadot.js";
+import ts from "./tanssi.js";
+import { importAsyncConfig, importJsonConfig } from "../configReader.js";
+export function allRepos() {
+    const defaultRepos = [mb, pd, ts];
+    const globalConfig = importJsonConfig();
+    const importedRepos = globalConfig.additionalRepos ? globalConfig.additionalRepos : [];
+    return [...defaultRepos, ...importedRepos];
+}
+export async function allReposAsync() {
+    const defaultRepos = [mb, pd, ts];
+    const globalConfig = await importAsyncConfig();
+    const importedRepos = globalConfig.additionalRepos || [];
+    return [...defaultRepos, ...importedRepos];
+}
+export function standardRepos() {
+    const defaultRepos = [mb, pd, ts];
+    return [...defaultRepos];
+}
+export default allRepos;

package/dist/cli/lib/repoDefinitions/moonbeam.d.ts

@@ -0,0 +1,4 @@
+import type { RepoSpec } from "../../../api/types/index.js";
+declare const repo: RepoSpec;
+export default repo;
+//# sourceMappingURL=moonbeam.d.ts.map

package/dist/cli/lib/repoDefinitions/moonbeam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moonbeam.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/repoDefinitions/moonbeam.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,oCAAoC;AAE5D,QAAA,MAAM,IAAI,EAAE,QA4BX,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/cli/lib/repoDefinitions/moonbeam.js

@@ -0,0 +1,30 @@
+const repo = {
+    name: "moonbeam",
+    binaries: [
+        {
+            name: "moonbeam",
+            defaultArgs: [
+                "--no-hardware-benchmarks",
+                "--no-telemetry",
+                "--reserved-only",
+                "--rpc-cors=all",
+                "--unsafe-rpc-external",
+                "--unsafe-force-node-key-generation",
+                "--no-grandpa",
+                "--sealing=manual",
+                "--force-authoring",
+                "--database=paritydb",
+                "--no-prometheus",
+                "--alice",
+                "--chain=moonbase-dev",
+                "--tmp",
+            ],
+        },
+        { name: "moonbase-runtime" },
+        { name: "moonbeam-runtime" },
+        { name: "moonriver-runtime" },
+    ],
+    ghAuthor: "moonbeam-foundation",
+    ghRepo: "moonbeam",
+};
+export default repo;

package/dist/cli/lib/repoDefinitions/polkadot.d.ts

@@ -0,0 +1,4 @@
+import type { RepoSpec } from "../../../api/types/index.js";
+declare const repo: RepoSpec;
+export default repo;
+//# sourceMappingURL=polkadot.d.ts.map

package/dist/cli/lib/repoDefinitions/polkadot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polkadot.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/repoDefinitions/polkadot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,oCAAoC;AAE5D,QAAA,MAAM,IAAI,EAAE,QASX,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/cli/lib/repoDefinitions/polkadot.js

@@ -0,0 +1,11 @@
+const repo = {
+    name: "polkadot",
+    binaries: [
+        { name: "polkadot" },
+        { name: "polkadot-prepare-worker" },
+        { name: "polkadot-execute-worker" },
+    ],
+    ghAuthor: "paritytech",
+    ghRepo: "polkadot-sdk",
+};
+export default repo;

package/dist/cli/lib/repoDefinitions/tanssi.d.ts

@@ -0,0 +1,4 @@
+import type { RepoSpec } from "../../../api/types/index.js";
+declare const repo: RepoSpec;
+export default repo;
+//# sourceMappingURL=tanssi.d.ts.map

package/dist/cli/lib/repoDefinitions/tanssi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tanssi.d.ts","sourceRoot":"","sources":["../../../../src/cli/lib/repoDefinitions/tanssi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,oCAAoC;AAE5D,QAAA,MAAM,IAAI,EAAE,QAYX,CAAC;AACF,eAAe,IAAI,CAAC"}

package/dist/cli/lib/repoDefinitions/tanssi.js

@@ -0,0 +1,14 @@
+const repo = {
+    name: "tanssi",
+    binaries: [
+        {
+            name: "tanssi-node",
+            defaultArgs: ["--dev", "--sealing=manual", "--no-hardware-benchmarks"],
+        },
+        { name: "container-chain-template-simple-node" },
+        { name: "container-chain-template-frontier-node" },
+    ],
+    ghAuthor: "moondance-labs",
+    ghRepo: "tanssi",
+};
+export default repo;

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

@@ -0,0 +1,2 @@
+export declare function customDevRpcRequest(method: string, params?: any[]): Promise<any>;
+//# sourceMappingURL=rpcFunctions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rpcFunctions.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/rpcFunctions.ts"],"names":[],"mappings":"AAIA,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,GAAG,EAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CA6B1F"}