@moonsong-labs/moonwall-cli
Version:
Testing framework for the Moon family of projects
198 lines (188 loc) • 8.05 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/internal/devModeHelpers.ts
var devModeHelpers_exports = {};
__export(devModeHelpers_exports, {
createDevBlock: () => createDevBlock,
devForkToFinalizedHead: () => devForkToFinalizedHead
});
module.exports = __toCommonJS(devModeHelpers_exports);
// src/lib/contextHelpers.ts
var import_api_augment3 = require("@moonbeam-network/api-augment");
var import_moonwall_util2 = require("@moonsong-labs/moonwall-util");
// src/lib/globalContext.ts
var import_api_augment2 = require("@moonbeam-network/api-augment");
// src/internal/providers.ts
var import_moonbeam_types_bundle = require("moonbeam-types-bundle");
var import_api = require("@polkadot/api");
var import_web3 = require("web3");
var import_web3_providers_ws = require("web3-providers-ws");
var import_ethers = require("ethers");
var import_debug = __toESM(require("debug"), 1);
var import_chalk = __toESM(require("chalk"), 1);
var import_moonwall_util = require("@moonsong-labs/moonwall-util");
var debug = (0, import_debug.default)("global:providers");
// src/internal/localNode.ts
var import_chalk2 = __toESM(require("chalk"), 1);
var import_debug2 = __toESM(require("debug"), 1);
var debugNode = (0, import_debug2.default)("global:node");
// src/lib/configReader.ts
var import_api_augment = require("@moonbeam-network/api-augment");
// src/lib/globalContext.ts
var import_debug3 = __toESM(require("debug"), 1);
var debugSetup = (0, import_debug3.default)("global:context");
// src/lib/contextHelpers.ts
var import_vitest = require("vitest");
var import_debug4 = __toESM(require("debug"), 1);
var debug2 = (0, import_debug4.default)("context");
function filterAndApply(events, section, methods, onFound) {
return events.filter(({ event }) => section === event.section && methods.includes(event.method)).map((record) => onFound(record));
}
function getDispatchError({
event: {
data: [dispatchError]
}
}) {
return dispatchError;
}
function extractError(events = []) {
return filterAndApply(events, "system", ["ExtrinsicFailed"], getDispatchError)[0];
}
// src/internal/devModeHelpers.ts
var import_moonwall_util3 = require("@moonsong-labs/moonwall-util");
var import_debug5 = __toESM(require("debug"), 1);
var import_promises = require("timers/promises");
var import_vitest2 = require("vitest");
var import_chalk3 = __toESM(require("chalk"), 1);
var debug3 = (0, import_debug5.default)("DevTest");
async function devForkToFinalizedHead(context) {
const api = context.providers.find(({ type }) => type == "moon").api;
const finalizedHead = context.genesis;
await api.rpc.engine.createBlock(true, true, finalizedHead);
while (true) {
const newHead = (await api.rpc.chain.getFinalizedHead()).toString();
if (newHead == finalizedHead) {
await (0, import_promises.setTimeout)(100);
} else {
context.genesis = newHead;
break;
}
}
}
async function createDevBlock(context, transactions, options = { allowFailures: true }) {
const results = [];
const api = context.getSubstrateApi();
const txs = transactions == void 0 ? [] : Array.isArray(transactions) ? transactions : [transactions];
for await (const call of txs) {
if (typeof call == "string") {
results.push({
type: "eth",
hash: (await (0, import_moonwall_util3.customWeb3Request)(context.web3(), "eth_sendRawTransaction", [call])).result
});
} else if (call.isSigned) {
const tx = api.tx(call);
debug3(
`- Signed: ${tx.method.section}.${tx.method.method}(${tx.args.map((d) => d.toHuman()).join("; ")}) [ nonce: ${tx.nonce}]`
);
results.push({
type: "sub",
hash: (await call.send()).toString()
});
} else {
const tx = api.tx(call);
debug3(
`- Unsigned: ${tx.method.section}.${tx.method.method}(${tx.args.map((d) => d.toHuman()).join("; ")}) [ nonce: ${tx.nonce}]`
);
results.push({
type: "sub",
hash: (await call.signAndSend(import_moonwall_util3.alith)).toString()
});
}
}
const { parentHash, finalize } = options;
const blockResult = await (0, import_moonwall_util3.createAndFinalizeBlock)(api, parentHash, finalize);
if (results.length == 0) {
return {
block: blockResult,
result: null
};
}
const allRecords = await (await api.at(blockResult.hash)).query.system.events();
const blockData = await api.rpc.chain.getBlock(blockResult.hash);
const result = results.map((result2) => {
const extrinsicIndex = result2.type == "eth" ? allRecords.find(
({ phase, event: { section, method, data } }) => phase.isApplyExtrinsic && section == "ethereum" && method == "Executed" && data[2].toString() == result2.hash
)?.phase?.asApplyExtrinsic?.toNumber() : blockData.block.extrinsics.findIndex((ext) => ext.hash.toHex() == result2.hash);
const events = allRecords.filter(
({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.toNumber() === extrinsicIndex
);
const failure = extractError(events);
return {
extrinsic: extrinsicIndex >= 0 ? blockData.block.extrinsics[extrinsicIndex] : null,
events,
error: failure && (failure.isModule && api.registry.findMetaError(failure.asModule) || { name: failure.toString() }),
successful: extrinsicIndex !== void 0 && !failure,
hash: result2.hash
};
});
if (results.find((r) => r.type == "eth")) {
await (0, import_promises.setTimeout)(2);
}
const actualEvents = result.flatMap((resp) => resp.events);
if (options.expectEvents && options.expectEvents.length > 0) {
const match = options.expectEvents.every((eEvt) => {
const found = actualEvents.map((aEvt) => eEvt.is(aEvt.event)).reduce((acc, curr) => acc || curr, false);
if (!found) {
options.logger ? options.logger(
`Event ${import_chalk3.default.bgWhiteBright.blackBright(eEvt.meta.name)} not present in block`
) : console.error(
`Event ${import_chalk3.default.bgWhiteBright.blackBright(eEvt.meta.name)} not present in block`
);
}
return found;
});
(0, import_vitest2.assert)(match, "Expected events not present in block");
}
if (!options.allowFailures) {
actualEvents.forEach((event) => {
(0, import_vitest2.assert)(
!api.events.system.ExtrinsicFailed.is(event.event),
"ExtrinsicFailed event detected, enable 'allowFailures' if this is expected."
);
});
}
return {
block: blockResult,
result: Array.isArray(transactions) ? result : result[0]
};
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
createDevBlock,
devForkToFinalizedHead
});