@moonsong-labs/moonwall-util
Version:
Testing framework for the Moon family of projects
1,118 lines (1,105 loc) • 41 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/index.ts
var src_exports = {};
__export(src_exports, {
ALITH_ADDRESS: () => ALITH_ADDRESS,
ALITH_CONTRACT_ADDRESSES: () => ALITH_CONTRACT_ADDRESSES,
ALITH_GENESIS_FREE_BALANCE: () => ALITH_GENESIS_FREE_BALANCE,
ALITH_GENESIS_LOCK_BALANCE: () => ALITH_GENESIS_LOCK_BALANCE,
ALITH_GENESIS_RESERVE_BALANCE: () => ALITH_GENESIS_RESERVE_BALANCE,
ALITH_GENESIS_TRANSFERABLE_BALANCE: () => ALITH_GENESIS_TRANSFERABLE_BALANCE,
ALITH_PRIVATE_KEY: () => ALITH_PRIVATE_KEY,
ALITH_SESSION_ADDRESS: () => ALITH_SESSION_ADDRESS,
BALTATHAR_ADDRESS: () => BALTATHAR_ADDRESS,
BALTATHAR_PRIVATE_KEY: () => BALTATHAR_PRIVATE_KEY,
BALTATHAR_SESSION_ADDRESS: () => BALTATHAR_SESSION_ADDRESS,
BASE_PATH: () => BASE_PATH,
BINARY_PATH: () => BINARY_PATH,
BLOCK_TX_GAS_LIMIT: () => BLOCK_TX_GAS_LIMIT,
BLOCK_TX_LIMIT: () => BLOCK_TX_LIMIT,
CHARLETH_ADDRESS: () => CHARLETH_ADDRESS,
CHARLETH_PRIVATE_KEY: () => CHARLETH_PRIVATE_KEY,
CHARLETH_SESSION_ADDRESS: () => CHARLETH_SESSION_ADDRESS,
CONTRACT_PROXY_TYPE_ANY: () => CONTRACT_PROXY_TYPE_ANY,
CONTRACT_PROXY_TYPE_AUTHOR_MAPPING: () => CONTRACT_PROXY_TYPE_AUTHOR_MAPPING,
CONTRACT_PROXY_TYPE_BALANCES: () => CONTRACT_PROXY_TYPE_BALANCES,
CONTRACT_PROXY_TYPE_CANCEL_PROXY: () => CONTRACT_PROXY_TYPE_CANCEL_PROXY,
CONTRACT_PROXY_TYPE_GOVERNANCE: () => CONTRACT_PROXY_TYPE_GOVERNANCE,
CONTRACT_PROXY_TYPE_IDENTITY_JUDGEMENT: () => CONTRACT_PROXY_TYPE_IDENTITY_JUDGEMENT,
CONTRACT_PROXY_TYPE_NON_TRANSFER: () => CONTRACT_PROXY_TYPE_NON_TRANSFER,
CONTRACT_PROXY_TYPE_STAKING: () => CONTRACT_PROXY_TYPE_STAKING,
CONTRACT_RANDOMNESS_STATUS_DOES_NOT_EXISTS: () => CONTRACT_RANDOMNESS_STATUS_DOES_NOT_EXISTS,
CONTRACT_RANDOMNESS_STATUS_EXPIRED: () => CONTRACT_RANDOMNESS_STATUS_EXPIRED,
CONTRACT_RANDOMNESS_STATUS_PENDING: () => CONTRACT_RANDOMNESS_STATUS_PENDING,
CONTRACT_RANDOMNESS_STATUS_READY: () => CONTRACT_RANDOMNESS_STATUS_READY,
CUSTOM_SPEC_PATH: () => CUSTOM_SPEC_PATH,
DAYS: () => DAYS,
DEBUG_MODE: () => DEBUG_MODE,
DEFAULT_GENESIS_BALANCE: () => DEFAULT_GENESIS_BALANCE,
DEFAULT_GENESIS_MAPPING: () => DEFAULT_GENESIS_MAPPING,
DEFAULT_GENESIS_STAKING: () => DEFAULT_GENESIS_STAKING,
DISPLAY_LOG: () => DISPLAY_LOG,
DOROTHY_ADDRESS: () => DOROTHY_ADDRESS,
DOROTHY_PRIVATE_KEY: () => DOROTHY_PRIVATE_KEY,
ETHAN_ADDRESS: () => ETHAN_ADDRESS,
ETHAN_PRIVATE_KEY: () => ETHAN_PRIVATE_KEY,
ETHAPI_CMD: () => ETHAPI_CMD,
EXTRINSIC_BASE_WEIGHT: () => EXTRINSIC_BASE_WEIGHT,
EXTRINSIC_GAS_LIMIT: () => EXTRINSIC_GAS_LIMIT,
EthTester: () => EthTester,
FAITH_ADDRESS: () => FAITH_ADDRESS,
FAITH_PRIVATE_KEY: () => FAITH_PRIVATE_KEY,
FIVE_MINS: () => FIVE_MINS,
GAS_PER_SECOND: () => GAS_PER_SECOND,
GAS_PER_WEIGHT: () => GAS_PER_WEIGHT,
GERALD_ADDRESS: () => GERALD_ADDRESS,
GERALD_CONTRACT_ADDRESSES: () => GERALD_CONTRACT_ADDRESSES,
GERALD_PRIVATE_KEY: () => GERALD_PRIVATE_KEY,
GLMR: () => GLMR,
GOLIATH_ADDRESS: () => GOLIATH_ADDRESS,
GOLIATH_PRIVATE_KEY: () => GOLIATH_PRIVATE_KEY,
HOURS: () => HOURS,
MAX_BLOCK_WEIGHT: () => MAX_BLOCK_WEIGHT,
MICROGLMR: () => MICROGLMR,
MILLIGLMR: () => MILLIGLMR,
MINUTES: () => MINUTES,
MIN_GAS_PRICE: () => MIN_GAS_PRICE,
MIN_GLMR_DELEGATOR: () => MIN_GLMR_DELEGATOR,
MIN_GLMR_STAKING: () => MIN_GLMR_STAKING,
MOONBEAM_LOG: () => MOONBEAM_LOG,
ONE_HOURS: () => ONE_HOURS,
OVERRIDE_RUNTIME_PATH: () => OVERRIDE_RUNTIME_PATH,
PRECOMPILE_AUTHOR_MAPPING_ADDRESS: () => PRECOMPILE_AUTHOR_MAPPING_ADDRESS,
PRECOMPILE_BATCH_ADDRESS: () => PRECOMPILE_BATCH_ADDRESS,
PRECOMPILE_CALL_PERMIT_ADDRESS: () => PRECOMPILE_CALL_PERMIT_ADDRESS,
PRECOMPILE_COUNCIL_ADDRESS: () => PRECOMPILE_COUNCIL_ADDRESS,
PRECOMPILE_CROWDLOAN_REWARDS_ADDRESS: () => PRECOMPILE_CROWDLOAN_REWARDS_ADDRESS,
PRECOMPILE_DEMOCRACY_ADDRESS: () => PRECOMPILE_DEMOCRACY_ADDRESS,
PRECOMPILE_DISPATCH_ADDRESS: () => PRECOMPILE_DISPATCH_ADDRESS,
PRECOMPILE_NATIVE_ERC20_ADDRESS: () => PRECOMPILE_NATIVE_ERC20_ADDRESS,
PRECOMPILE_PARACHAIN_STAKING_ADDRESS: () => PRECOMPILE_PARACHAIN_STAKING_ADDRESS,
PRECOMPILE_PROXY_ADDRESS: () => PRECOMPILE_PROXY_ADDRESS,
PRECOMPILE_RANDOMNESS_ADDRESS: () => PRECOMPILE_RANDOMNESS_ADDRESS,
PRECOMPILE_RELAY_ENCODER_ADDRESS: () => PRECOMPILE_RELAY_ENCODER_ADDRESS,
PRECOMPILE_TECH_COMMITTEE_ADDRESS: () => PRECOMPILE_TECH_COMMITTEE_ADDRESS,
PRECOMPILE_TREASURY_COUNCIL_ADDRESS: () => PRECOMPILE_TREASURY_COUNCIL_ADDRESS,
PRECOMPILE_XCM_TRANSACTOR_ADDRESS_V1: () => PRECOMPILE_XCM_TRANSACTOR_ADDRESS_V1,
PRECOMPILE_XCM_TRANSACTOR_ADDRESS_V2: () => PRECOMPILE_XCM_TRANSACTOR_ADDRESS_V2,
PRECOMPILE_XCM_UTILS_ADDRESS: () => PRECOMPILE_XCM_UTILS_ADDRESS,
PRECOMPILE_XTOKENS_ADDRESS: () => PRECOMPILE_XTOKENS_ADDRESS,
PROPOSAL_AMOUNT: () => PROPOSAL_AMOUNT,
Perbill: () => Perbill,
Percent: () => Percent,
RELAY_BINARY_PATH: () => RELAY_BINARY_PATH,
RELAY_CHAIN_NODE_NAMES: () => RELAY_CHAIN_NODE_NAMES,
RELAY_LOG: () => RELAY_LOG,
RUNTIME_CONSTANTS: () => RUNTIME_CONSTANTS,
SPAWNING_TIME: () => SPAWNING_TIME,
SPECS_PATH: () => SPECS_PATH,
TARGET_FILL_AMOUNT: () => TARGET_FILL_AMOUNT,
TARGET_FILL_PERMILL: () => TARGET_FILL_PERMILL,
TEN_MINS: () => TEN_MINS,
THIRTY_MINS: () => THIRTY_MINS,
TREASURY_ACCOUNT: () => TREASURY_ACCOUNT,
TWO_HOURS: () => TWO_HOURS,
TWO_MINS: () => TWO_MINS,
VOTE_AMOUNT: () => VOTE_AMOUNT,
WASM_RUNTIME_OVERRIDES: () => WASM_RUNTIME_OVERRIDES,
WEIGHT_FEE: () => WEIGHT_FEE,
WEIGHT_PER_GAS: () => WEIGHT_PER_GAS,
ZERO_ADDRESS: () => ZERO_ADDRESS,
alith: () => alith,
alithSigner: () => alithSigner,
baltathar: () => baltathar,
calculateFeePortions: () => calculateFeePortions,
charleth: () => charleth,
checkBlockFinalized: () => checkBlockFinalized,
createAndFinalizeBlock: () => createAndFinalizeBlock,
customWeb3Request: () => customWeb3Request,
dorothy: () => dorothy,
ethan: () => ethan,
extractError: () => extractError,
extractInfo: () => extractInfo,
extractPreimageDeposit: () => extractPreimageDeposit,
extractWeight: () => extractWeight,
faith: () => faith,
fetchHistoricBlockNum: () => fetchHistoricBlockNum,
filterAndApply: () => filterAndApply,
generateKeyringPair: () => generateKeyringPair,
gerald: () => gerald,
getBlockArray: () => getBlockArray,
getBlockExtrinsic: () => getBlockExtrinsic,
getBlockTime: () => getBlockTime,
getDispatchError: () => getDispatchError,
getObjectMethods: () => getObjectMethods,
goliath: () => goliath,
isExtrinsicSuccessful: () => isExtrinsicSuccessful,
log: () => log,
mapExtrinsics: () => mapExtrinsics,
printEvents: () => printEvents,
printTokens: () => printTokens,
setupLogger: () => setupLogger,
sortObjectByKeys: () => sortObjectByKeys,
web3EthCall: () => web3EthCall,
xcAssetAbi: () => xcAssetAbi
});
module.exports = __toCommonJS(src_exports);
var import_api_augment7 = require("@moonbeam-network/api-augment");
// src/functions/block.ts
var import_moonbase = require("@moonbeam-network/api-augment/moonbase");
var import_bottleneck = __toESM(require("bottleneck"), 1);
var import_debug = __toESM(require("debug"), 1);
var debug = (0, import_debug.default)("test:blocks");
async function createAndFinalizeBlock(api, parentHash, finalize = false) {
const startTime = Date.now();
const block = parentHash ? await api.rpc.engine.createBlock(true, finalize, parentHash) : await api.rpc.engine.createBlock(true, finalize);
return {
duration: Date.now() - startTime,
hash: block.toJSON().hash
// toString doesn't work for block hashes
};
}
function calculateFeePortions(amount) {
const burnt = amount * 80n / 100n;
return { burnt, treasury: amount - burnt };
}
var getBlockExtrinsic = async (api, blockHash, section, method) => {
const apiAt = await api.at(blockHash);
const [{ block }, records] = await Promise.all([
api.rpc.chain.getBlock(blockHash),
apiAt.query.system.events()
]);
const extIndex = block.extrinsics.findIndex(
(ext) => ext.method.section == section && ext.method.method == method
);
const extrinsic = extIndex > -1 ? block.extrinsics[extIndex] : null;
const events = records.filter(({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(extIndex)).map(({ event }) => event);
const resultEvent = events.find(
(event) => event.section === "system" && (event.method === "ExtrinsicSuccess" || event.method === "ExtrinsicFailed")
);
return { block, extrinsic, events, resultEvent };
};
var getBlockTime = (signedBlock) => signedBlock.block.extrinsics.find((item) => item.method.section == "timestamp").method.args[0].toNumber();
var checkBlockFinalized = async (api, number) => {
return {
number,
finalized: (await api.rpc.moon.isBlockFinalized(await api.rpc.chain.getBlockHash(number))).isTrue
};
};
var fetchBlockTime = async (api, blockNum) => {
const hash = await api.rpc.chain.getBlockHash(blockNum);
const block = await api.rpc.chain.getBlock(hash);
return getBlockTime(block);
};
var fetchHistoricBlockNum = async (api, blockNumber, targetTime) => {
if (blockNumber <= 1) {
return 1;
}
const time = await fetchBlockTime(api, blockNumber);
if (time <= targetTime) {
return blockNumber;
}
return fetchHistoricBlockNum(
api,
blockNumber - Math.ceil((time - targetTime) / 3e4),
targetTime
);
};
var getBlockArray = async (api, timePeriod, limiter) => {
if (limiter == null) {
limiter = new import_bottleneck.default({ maxConcurrent: 10, minTime: 100 });
}
const finalizedHead = await limiter.schedule(() => api.rpc.chain.getFinalizedHead());
const signedBlock = await limiter.schedule(() => api.rpc.chain.getBlock(finalizedHead));
const lastBlockNumber = signedBlock.block.header.number.toNumber();
const lastBlockTime = getBlockTime(signedBlock);
const firstBlockTime = lastBlockTime - timePeriod;
debug(`Searching for the block at: ${new Date(firstBlockTime)}`);
const firstBlockNumber = await limiter.wrap(fetchHistoricBlockNum)(
api,
lastBlockNumber,
firstBlockTime
);
const length = lastBlockNumber - firstBlockNumber;
return Array.from({ length }, (_, i) => firstBlockNumber + i);
};
function extractWeight(weightV1OrV2) {
if ("isSome" in weightV1OrV2) {
const weight = weightV1OrV2.unwrap();
if ("refTime" in weight) {
return weight.refTime.unwrap();
}
return weight;
}
if ("refTime" in weightV1OrV2) {
return weightV1OrV2.refTime.unwrap();
}
return weightV1OrV2;
}
function extractPreimageDeposit(request) {
const deposit = "deposit" in request ? request.deposit : request;
if ("isSome" in deposit) {
return {
accountId: deposit.unwrap()[0].toHex(),
amount: deposit.unwrap()[1]
};
}
return {
accountId: deposit[0].toHex(),
amount: deposit[1]
};
}
function mapExtrinsics(extrinsics, records, fees) {
return extrinsics.map((extrinsic, index) => {
let dispatchError;
let dispatchInfo;
const events = records.filter(({ phase }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index)).map(({ event }) => {
if (event.section === "system") {
if (event.method === "ExtrinsicSuccess") {
dispatchInfo = event.data[0];
} else if (event.method === "ExtrinsicFailed") {
dispatchError = event.data[0];
dispatchInfo = event.data[1];
}
}
return event;
});
return { dispatchError, dispatchInfo, events, extrinsic, fee: fees ? fees[index] : void 0 };
});
}
// src/functions/common.ts
var import_api_augment = require("@moonbeam-network/api-augment");
var import_util = require("@polkadot/util");
function sortObjectByKeys(o) {
return Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {});
}
var Perthing = class {
unit;
perthing;
constructor(unit, numerator, denominator) {
if (!(numerator instanceof import_util.BN)) {
numerator = new import_util.BN(numerator.toString());
}
if (denominator && !(denominator instanceof import_util.BN)) {
denominator = new import_util.BN(denominator.toString());
}
this.unit = unit;
if (denominator) {
this.perthing = numerator.mul(unit).div(denominator);
} else {
this.perthing = numerator;
}
}
value() {
return this.perthing;
}
of(value) {
return this.divNearest(this.perthing.mul(value), this.unit);
}
ofCeil(value) {
return this.divCeil(this.perthing.mul(value), this.unit);
}
toString() {
return `${this.perthing.toString()}`;
}
divCeil(a, num) {
var dm = a.divmod(num);
if (dm.mod.isZero())
return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
}
divNearest(a, num) {
var dm = a.divmod(num);
if (dm.mod.isZero())
return dm.div;
var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod.cmp(half);
if (cmp <= 0 || r2 === new import_util.BN(1) && cmp === 0)
return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
}
};
var Perbill = class extends Perthing {
constructor(numerator, denominator) {
super(new import_util.BN(1e9), numerator, denominator);
}
};
var Percent = class extends Perthing {
constructor(numerator, denominator) {
super(new import_util.BN(100), numerator, denominator);
}
};
function getObjectMethods(obj) {
let properties = /* @__PURE__ */ new Set();
let currentObj = obj;
do {
Object.getOwnPropertyNames(currentObj).map((item) => properties.add(item));
} while (currentObj = Object.getPrototypeOf(currentObj));
return [...properties.keys()].filter(
(item) => typeof obj[item] === "function"
);
}
// src/functions/providers.ts
var import_api_augment4 = require("@moonbeam-network/api-augment");
// src/constants/accounts.ts
var import_api_augment3 = require("@moonbeam-network/api-augment");
var import_keyring = require("@polkadot/keyring");
// src/constants/chain.ts
var import_api_augment2 = require("@moonbeam-network/api-augment");
var SPECS_PATH = `./moonbeam-test-specs`;
var DEBUG_MODE = process.env.DEBUG_MODE || false;
var DISPLAY_LOG = process.env.MOONBEAM_LOG || false;
var MOONBEAM_LOG = process.env.MOONBEAM_LOG || "info";
var BASE_PATH = process.env.BASE_PATH;
var CUSTOM_SPEC_PATH = process.env.CUSTOM_SPEC_PATH;
var BINARY_PATH = process.env.BINARY_PATH || `../target/release/moonbeam`;
var RELAY_BINARY_PATH = process.env.RELAY_BINARY_PATH || `../target/release/polkadot`;
var RELAY_LOG = process.env.RELAY_LOG;
var OVERRIDE_RUNTIME_PATH = process.env["OVERRIDE_RUNTIME_PATH"] || void 0;
var SPAWNING_TIME = 2e4;
var ETHAPI_CMD = process.env.ETHAPI_CMD || "";
var WASM_RUNTIME_OVERRIDES = process.env.WASM_RUNTIME_OVERRIDES || "";
var RELAY_CHAIN_NODE_NAMES = [
"Alice",
"Bob",
"Charlie",
"Dave",
"Eve",
"Ferdie",
"One"
];
var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
var TREASURY_ACCOUNT = "0x6d6f646c70632f74727372790000000000000000";
var GLMR = 1000000000000000000n;
var MILLIGLMR = 1000000000000000n;
var MICROGLMR = 1000000000000n;
var DEFAULT_GENESIS_BALANCE = 2n ** 80n;
var DEFAULT_GENESIS_STAKING = 1000n * GLMR;
var DEFAULT_GENESIS_MAPPING = 100n * GLMR;
var PROPOSAL_AMOUNT = 1000n * GLMR;
var VOTE_AMOUNT = 10n * GLMR;
var MIN_GLMR_STAKING = 1000n * GLMR;
var MIN_GLMR_DELEGATOR = 1n * GLMR;
var GAS_PER_SECOND = 4e7;
var GAS_PER_WEIGHT = 1e6 / 40;
var BLOCK_TX_LIMIT = GAS_PER_SECOND * 0.5;
var BLOCK_TX_GAS_LIMIT = BLOCK_TX_LIMIT * 0.75;
var EXTRINSIC_BASE_WEIGHT = 25e7;
var EXTRINSIC_GAS_LIMIT = BLOCK_TX_GAS_LIMIT - BLOCK_TX_LIMIT * 0.1;
var WEIGHT_PER_GAS = 1000000000000n / 40000000n;
var MIN_GAS_PRICE = 10000000000n;
var PRECOMPILE_PARACHAIN_STAKING_ADDRESS = "0x0000000000000000000000000000000000000800";
var PRECOMPILE_CROWDLOAN_REWARDS_ADDRESS = "0x0000000000000000000000000000000000000801";
var PRECOMPILE_NATIVE_ERC20_ADDRESS = "0x0000000000000000000000000000000000000802";
var PRECOMPILE_DEMOCRACY_ADDRESS = "0x0000000000000000000000000000000000000803";
var PRECOMPILE_XTOKENS_ADDRESS = "0x0000000000000000000000000000000000000804";
var PRECOMPILE_RELAY_ENCODER_ADDRESS = "0x0000000000000000000000000000000000000805";
var PRECOMPILE_XCM_TRANSACTOR_ADDRESS_V1 = "0x0000000000000000000000000000000000000806";
var PRECOMPILE_AUTHOR_MAPPING_ADDRESS = "0x0000000000000000000000000000000000000807";
var PRECOMPILE_BATCH_ADDRESS = "0x0000000000000000000000000000000000000808";
var PRECOMPILE_RANDOMNESS_ADDRESS = "0x0000000000000000000000000000000000000809";
var PRECOMPILE_CALL_PERMIT_ADDRESS = "0x000000000000000000000000000000000000080a";
var PRECOMPILE_PROXY_ADDRESS = "0x000000000000000000000000000000000000080b";
var PRECOMPILE_XCM_UTILS_ADDRESS = "0x000000000000000000000000000000000000080c";
var PRECOMPILE_XCM_TRANSACTOR_ADDRESS_V2 = "0x000000000000000000000000000000000000080d";
var PRECOMPILE_COUNCIL_ADDRESS = "0x000000000000000000000000000000000000080e";
var PRECOMPILE_TECH_COMMITTEE_ADDRESS = "0x000000000000000000000000000000000000080f";
var PRECOMPILE_TREASURY_COUNCIL_ADDRESS = "0x0000000000000000000000000000000000000810";
var PRECOMPILE_DISPATCH_ADDRESS = "0x0000000000000000000000000000000000000401";
var MINUTES = 60 / 12;
var HOURS = MINUTES * 60;
var DAYS = HOURS * 24;
var TWO_MINS = 2 * 60 * 1e3;
var FIVE_MINS = 5 * 60 * 1e3;
var TEN_MINS = 10 * 60 * 1e3;
var THIRTY_MINS = 30 * 60 * 1e3;
var ONE_HOURS = 60 * 60 * 1e3;
var TWO_HOURS = 2 * 60 * 60 * 1e3;
var CONTRACT_RANDOMNESS_STATUS_DOES_NOT_EXISTS = 0;
var CONTRACT_RANDOMNESS_STATUS_PENDING = 1;
var CONTRACT_RANDOMNESS_STATUS_READY = 2;
var CONTRACT_RANDOMNESS_STATUS_EXPIRED = 3;
var CONTRACT_PROXY_TYPE_ANY = 0;
var CONTRACT_PROXY_TYPE_NON_TRANSFER = 1;
var CONTRACT_PROXY_TYPE_GOVERNANCE = 2;
var CONTRACT_PROXY_TYPE_STAKING = 3;
var CONTRACT_PROXY_TYPE_CANCEL_PROXY = 4;
var CONTRACT_PROXY_TYPE_BALANCES = 5;
var CONTRACT_PROXY_TYPE_AUTHOR_MAPPING = 6;
var CONTRACT_PROXY_TYPE_IDENTITY_JUDGEMENT = 7;
var MAX_BLOCK_WEIGHT = 5e11;
var TARGET_FILL_AMOUNT = (MAX_BLOCK_WEIGHT * 0.75 * 0.25 - EXTRINSIC_BASE_WEIGHT) / MAX_BLOCK_WEIGHT * 1e9;
var TARGET_FILL_PERMILL = 0.25 * 1e6;
var WEIGHT_FEE = 50n * 1000n;
var RUNTIME_CONSTANTS = {
MOONBASE: {
MIN_FEE_MULTIPLIER: "100000000000000000",
MAX_FEE_MULTIPLIER: "100000000000000000000000",
MIN_BASE_FEE_IN_WEI: "125000000",
MAX_BASE_FEE_IN_WEI: "125000000000000"
},
MOONRIVER: {
MIN_FEE_MULTIPLIER: "1000000000000",
MAX_FEE_MULTIPLIER: "100000000000000000",
MIN_BASE_FEE_IN_WEI: "",
MAX_BASE_FEE_IN_WEI: ""
},
MOONBEAM: {
MIN_FEE_MULTIPLIER: "1000000000000",
MAX_FEE_MULTIPLIER: "100000000000000000",
MIN_BASE_FEE_IN_WEI: "",
MAX_BASE_FEE_IN_WEI: ""
}
};
// src/constants/accounts.ts
var keyringEth = new import_keyring.Keyring({ type: "ethereum" });
var keyringEd25519 = new import_keyring.Keyring({ type: "ed25519" });
var keyringSr25519 = new import_keyring.Keyring({ type: "sr25519" });
var ALITH_ADDRESS = "0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac";
var ALITH_PRIVATE_KEY = "0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133";
var ALITH_SESSION_ADDRESS = "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d";
var ALITH_CONTRACT_ADDRESSES = [
"0xc01Ee7f10EA4aF4673cFff62710E1D7792aBa8f3",
"0x970951a12F975E6762482ACA81E57D5A2A4e73F4",
"0x3ed62137c5DB927cb137c26455969116BF0c23Cb",
"0x962c0940d72E7Db6c9a5F81f1cA87D8DB2B82A23",
"0x5CC307268a1393AB9A764A20DACE848AB8275c46",
"0xeAB4eEBa1FF8504c124D031F6844AD98d07C318f"
];
var BALTATHAR_ADDRESS = "0x3Cd0A705a2DC65e5b1E1205896BaA2be8A07c6e0";
var BALTATHAR_PRIVATE_KEY = "0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b";
var BALTATHAR_SESSION_ADDRESS = "0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48";
var CHARLETH_ADDRESS = "0x798d4Ba9baf0064Ec19eB4F0a1a45785ae9D6DFc";
var CHARLETH_PRIVATE_KEY = "0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b";
var CHARLETH_SESSION_ADDRESS = "0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22";
var DOROTHY_ADDRESS = "0x773539d4Ac0e786233D90A233654ccEE26a613D9";
var DOROTHY_PRIVATE_KEY = "0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68";
var ETHAN_ADDRESS = "0xFf64d3F6efE2317EE2807d223a0Bdc4c0c49dfDB";
var ETHAN_PRIVATE_KEY = "0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4";
var FAITH_ADDRESS = "0xC0F0f4ab324C46e55D02D0033343B4Be8A55532d";
var FAITH_PRIVATE_KEY = "0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df";
var GOLIATH_ADDRESS = "0x7BF369283338E12C90514468aa3868A551AB2929";
var GOLIATH_PRIVATE_KEY = "0x96b8a38e12e1a31dee1eab2fffdf9d9990045f5b37e44d8cc27766ef294acf18";
var GERALD_ADDRESS = "0x6Be02d1d3665660d22FF9624b7BE0551ee1Ac91b";
var GERALD_PRIVATE_KEY = "0x99B3C12287537E38C90A9219D4CB074A89A16E9CDB20BF85728EBD97C343E342";
var GERALD_CONTRACT_ADDRESSES = [
"0xC2Bf5F29a4384b1aB0C063e1c666f02121B6084a",
"0x5c4242beB94dE30b922f57241f1D02f36e906915",
"0x42e2EE7Ba8975c473157634Ac2AF4098190fc741",
"0xF8cef78E923919054037a1D03662bBD884fF4edf",
"0xe573BCA813c741229ffB2488F7856C6cAa841041",
"0xBb0CC0fb3e0c06725c67167501f850B4900D6DB5"
];
var ALITH_GENESIS_FREE_BALANCE = DEFAULT_GENESIS_BALANCE - DEFAULT_GENESIS_MAPPING;
var ALITH_GENESIS_LOCK_BALANCE = DEFAULT_GENESIS_STAKING;
var ALITH_GENESIS_RESERVE_BALANCE = DEFAULT_GENESIS_MAPPING;
var ALITH_GENESIS_TRANSFERABLE_BALANCE = ALITH_GENESIS_FREE_BALANCE - ALITH_GENESIS_LOCK_BALANCE;
var alith = keyringEth.addFromUri(ALITH_PRIVATE_KEY);
var baltathar = keyringEth.addFromUri(BALTATHAR_PRIVATE_KEY);
var charleth = keyringEth.addFromUri(CHARLETH_PRIVATE_KEY);
var dorothy = keyringEth.addFromUri(DOROTHY_PRIVATE_KEY);
var ethan = keyringEth.addFromUri(ETHAN_PRIVATE_KEY);
var faith = keyringEth.addFromUri(FAITH_PRIVATE_KEY);
var goliath = keyringEth.addFromUri(GOLIATH_PRIVATE_KEY);
var gerald = keyringEth.addFromUri(GERALD_PRIVATE_KEY);
var accountSeed = 1e4;
function generateKeyringPair(type = "ethereum") {
const privateKey = `0xDEADBEEF${(accountSeed++).toString(16).padStart(56, "0")}`;
if (type == "sr25519") {
return keyringSr25519.addFromUri(privateKey);
} else if (type == "ed25519") {
return keyringEd25519.addFromUri(privateKey);
}
return keyringEth.addFromUri(privateKey);
}
// src/functions/providers.ts
async function customWeb3Request(web3, method, params) {
return new Promise((resolve, reject) => {
web3.currentProvider.send(
{
jsonrpc: "2.0",
id: 1,
method,
params
},
(error, result) => {
if (error) {
reject(
`Failed to send custom request (${method} (${params.map((p) => {
const str = p.toString();
return str.length > 128 ? `${str.slice(0, 96)}...${str.slice(-28)}` : str;
}).join(",")})): ${error.message || error.toString()}`
);
}
resolve(result);
}
);
});
}
async function web3EthCall(web3, options) {
return await customWeb3Request(web3, "eth_call", [
{
from: options.from == void 0 ? options.from : alith.address,
value: options.value,
gas: options.gas == void 0 ? options.gas : 256e3,
gasPrice: options.gas == void 0 ? options.gas : `0x${MIN_GAS_PRICE}`,
to: options.to,
data: options.data
}
]);
}
// src/functions/logging.ts
var import_api_augment5 = require("@moonbeam-network/api-augment");
var import_debug2 = __toESM(require("debug"), 1);
function setupLogger(name) {
const debug2 = (0, import_debug2.default)(`test:${name}`);
import_debug2.default.enable("test:*");
import_debug2.default.log = console.info.bind(console);
return debug2;
}
function log(...msg) {
if (process.argv && process.argv[2] && process.argv[2] === "--printlogs") {
console.log(...msg);
}
}
var printTokens = (api, tokens, decimals = 2, pad = 9) => {
return `${(Math.ceil(Number(tokens / 10n ** BigInt(api.registry.chainDecimals[0] - decimals))) / 10 ** decimals).toString().padStart(pad)} ${api.registry.chainTokens[0]}`;
};
var printEvents = async (api, blockHash) => {
blockHash = blockHash != void 0 ? blockHash : (await api.rpc.chain.getBlockHash()).toString();
const apiAt = await api.at(blockHash);
const { block } = await api.rpc.chain.getBlock(blockHash);
const allRecords = await apiAt.query.system.events();
const txsWithEvents = mapExtrinsics(block.extrinsics, allRecords);
console.log(`===== Block #${block.header.number.toString()}: ${blockHash}`);
console.log(block.header.toHuman());
console.log(
txsWithEvents.map(
({ extrinsic, events }, i) => ` [${i}]: ${extrinsic.method.section.toString()}. ${extrinsic.method.method.toString()}
- 0x${Buffer.from(extrinsic.data).toString("hex")}
${events.map(
(event) => ` * ${event.section.toString()}.${event.method.toString()}:
${event.data.map((datum) => ` - ${datum.toHex()}`).join("\n")}`
).join("\n")}`
).join("\n")
);
};
// src/functions/contextHelpers.ts
var import_api_augment6 = require("@moonbeam-network/api-augment");
var import_ethers = require("ethers");
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 getDispatchInfo({ event: { data, method } }) {
return method === "ExtrinsicSuccess" ? data[0] : data[1];
}
function extractError(events = []) {
return filterAndApply(events, "system", ["ExtrinsicFailed"], getDispatchError)[0];
}
function isExtrinsicSuccessful(events = []) {
return filterAndApply(events, "system", ["ExtrinsicSuccess"], () => true).length > 0;
}
function extractInfo(events = []) {
return filterAndApply(
events,
"system",
["ExtrinsicFailed", "ExtrinsicSuccess"],
getDispatchInfo
)[0];
}
var alithSigner = (context) => {
const signer = new import_ethers.ethers.Wallet(ALITH_PRIVATE_KEY, context);
signer.connect(context);
return signer;
};
// src/functions/eth-tester.ts
var EthTester = class {
/**
* @name defaultType: Default type of Ethereum transaction
*/
defaultType;
/**
* @name defaultType: Default account to sign Ethereum transactions (usually sudo account)
*/
defaultAccount;
/**
* @name logger: Logger to use
*/
logger;
/**
* @name web3: Web3 instance
*/
web3;
/**
* @name constructor
* @param web3: Web3 instance
* @param privateKey: Private key of the default account
* @param logger: Logger to use
* @param type: Default type of Ethereum transaction
* @returns Web3Tester instance
* @description Creates a new Web3Tester instance
* @example
* const web3 = new Web3("http://localhost:9944");
* const web3Tester = new Web3Tester(web3, alith.privateKey, logger, "EIP1559");
* const rawTransaction = await web3Tester.genSignedTransfer({
* to: baltathar.address,
* value: web3.utils.toWei("1", "ether"),
* });
*/
constructor(web3, privateKey, logger, type = "Legacy") {
this.web3 = web3;
this.logger = logger;
this.defaultType = type;
this.defaultAccount = web3.eth.accounts.privateKeyToAccount(privateKey);
}
/**
* @name genSignedTransaction
* @param options: Transaction options
* @param txType: Type of Ethereum transaction
* @returns Signed transaction
* @description Generates a signed Ethereum transaction
* @example
* const rawTransaction = await web3Tester.genSignedTransaction({
* to: baltathar.address,
* to: authorMapping.address,
* data: authorMapping.encodeFunctionData("setKeys", [keys]),
* });
*/
genSignedTransaction = async (options, txType) => {
const type = txType || this.defaultType;
const isLegacy = type === "Legacy";
const isEip2930 = type === "EIP2930";
const isEip1559 = type === "EIP1559";
if (options.gasPrice && options.maxFeePerGas) {
throw new Error(`txn has both gasPrice and maxFeePerGas!`);
}
if (options.gasPrice && options.maxPriorityFeePerGas) {
throw new Error(`txn has both gasPrice and maxPriorityFeePerGas!`);
}
if (typeof options.gasPrice === "bigint") {
options.gasPrice = "0x" + options.gasPrice.toString(16);
}
if (typeof options.maxFeePerGas === "bigint") {
options.maxFeePerGas = "0x" + options.maxFeePerGas.toString(16);
}
if (typeof options.maxPriorityFeePerGas === "bigint") {
options.maxPriorityFeePerGas = "0x" + options.maxPriorityFeePerGas.toString(16);
}
let maxFeePerGas;
let maxPriorityFeePerGas;
if (options.gasPrice) {
maxFeePerGas = options.gasPrice;
maxPriorityFeePerGas = options.gasPrice;
} else {
maxFeePerGas = options.maxFeePerGas || BigInt(await this.web3.eth.getGasPrice());
maxPriorityFeePerGas = options.maxPriorityFeePerGas || 0;
}
const gasPrice = options.gasPrice !== void 0 ? options.gasPrice : "0x" + BigInt(await this.web3.eth.getGasPrice()).toString(16);
const value = options.value !== void 0 ? options.value : "0x00";
const from = options.from || this.defaultAccount.address;
const privateKey = options.privateKey !== void 0 ? options.privateKey : this.defaultAccount.privateKey;
let error;
const estimatedGas = await this.web3.eth.estimateGas({
from,
to: options.to,
data: options.data
}).catch((e) => {
error = e;
return 0;
});
const gas = options.gas || estimatedGas;
const accessList = options.accessList || [];
const nonce = options.nonce != null ? options.nonce : await this.web3.eth.getTransactionCount(from, "pending");
let data;
let rawTransaction;
if (isLegacy) {
data = {
from,
to: options.to,
value: value && value.toString(),
gasPrice,
gas,
nonce,
data: options.data
};
const tx = await this.web3.eth.accounts.signTransaction(data, privateKey);
rawTransaction = tx.rawTransaction;
} else {
const chainId = await this.web3.eth.getChainId();
if (isEip2930) {
data = {
from,
to: options.to,
value: value && value.toString(),
gasPrice,
gasLimit: gas,
nonce,
data: options.data,
accessList,
chainId,
type: 1
};
} else if (isEip1559) {
data = {
from,
to: options.to,
value: value && value.toString(),
maxFeePerGas,
maxPriorityFeePerGas,
gasLimit: gas,
nonce,
data: options.data,
accessList,
chainId,
type: 2
};
}
const tx = await this.web3.eth.accounts.signTransaction(data, privateKey);
rawTransaction = tx.rawTransaction;
}
this.logger(
`Tx [${/:([0-9]+)$/.exec(this.web3.currentProvider.host)?.[1]}] from: ${data.from.substr(0, 5) + "..." + data.from.substr(data.from.length - 3)}, ` + (data.to ? `to: ${data.to.substr(0, 5) + "..." + data.to.substr(data.to.length - 3)}, ` : "") + (data.value ? `value: ${data.value.toString()}, ` : "") + (data.gasPrice ? `gasPrice: ${data.gasPrice.toString()}, ` : "") + (data.maxFeePerGas ? `maxFeePerGas: ${data.maxFeePerGas.toString()}, ` : "") + (data.maxPriorityFeePerGas ? `maxPriorityFeePerGas: ${data.maxPriorityFeePerGas.toString()}, ` : "") + (data.accessList ? `accessList: ${data.accessList.toString()}, ` : "") + (data.gas ? `gas: ${data.gas.toString()}, ` : "") + (data.nonce ? `nonce: ${data.nonce.toString()}, ` : "") + (!data.data ? "" : `data: ${data.data.length < 50 ? data.data : data.data.substr(0, 5) + "..." + data.data.substr(data.data.length - 3)}, `) + (error ? `ERROR: ${error.toString()}, ` : "")
);
return rawTransaction;
};
/**
* @name genSignedTransfer
* @param to Address of the recipient
* @param value Amount of Wei to send
* @param options Transaction options
* @description Generates a signed Ethereum transactiosn
* @returns Signed transaction
*/
genSignedTransfer = async (to, value, options) => {
return await this.genSignedTransaction({
...options,
value: value.toString(),
to
});
};
/**
* @name sendSignedTransaction
* @description Sends a signed transaction, without waiting for it to be produced.
* @param rawTransaction Signed transaction
* @returns Transaction JSON RPC response
*/
sendSignedTransaction = async (rawTransaction) => {
return new Promise(async (resolve, reject) => {
if (typeof this.web3.currentProvider == "string") {
reject("Web3 provider is not a valid provider");
return;
}
this.web3.currentProvider.send(
{
jsonrpc: "2.0",
id: 1,
method: "eth_sendRawTransaction",
params: [await rawTransaction]
},
(error, result) => {
if (error) {
reject(`Failed to send signed transaction: ${error.message || error.toString()}`);
}
resolve(result);
}
);
});
};
};
// src/constants/smartContract.ts
var xcAssetAbi = [
{
anonymous: false,
inputs: [
{
indexed: true,
internalType: "address",
name: "owner",
type: "address"
},
{
indexed: true,
internalType: "address",
name: "spender",
type: "address"
},
{
indexed: false,
internalType: "uint256",
name: "value",
type: "uint256"
}
],
name: "Approval",
type: "event"
},
{
anonymous: false,
inputs: [
{ indexed: true, internalType: "address", name: "from", type: "address" },
{ indexed: true, internalType: "address", name: "to", type: "address" },
{
indexed: false,
internalType: "uint256",
name: "value",
type: "uint256"
}
],
name: "Transfer",
type: "event"
},
{
inputs: [
{ internalType: "address", name: "owner", type: "address" },
{ internalType: "address", name: "spender", type: "address" }
],
name: "allowance",
outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
stateMutability: "view",
type: "function"
},
{
inputs: [
{ internalType: "address", name: "spender", type: "address" },
{ internalType: "uint256", name: "value", type: "uint256" }
],
name: "approve",
outputs: [{ internalType: "bool", name: "", type: "bool" }],
stateMutability: "nonpayable",
type: "function"
},
{
inputs: [{ internalType: "address", name: "who", type: "address" }],
name: "balanceOf",
outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
stateMutability: "view",
type: "function"
},
{
inputs: [],
name: "decimals",
outputs: [{ internalType: "uint8", name: "", type: "uint8" }],
stateMutability: "view",
type: "function"
},
{
inputs: [],
name: "name",
outputs: [{ internalType: "string", name: "", type: "string" }],
stateMutability: "view",
type: "function"
},
{
inputs: [],
name: "symbol",
outputs: [{ internalType: "string", name: "", type: "string" }],
stateMutability: "view",
type: "function"
},
{
inputs: [],
name: "totalSupply",
outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
stateMutability: "view",
type: "function"
},
{
inputs: [
{ internalType: "address", name: "to", type: "address" },
{ internalType: "uint256", name: "value", type: "uint256" }
],
name: "transfer",
outputs: [{ internalType: "bool", name: "", type: "bool" }],
stateMutability: "nonpayable",
type: "function"
},
{
inputs: [
{ internalType: "address", name: "from", type: "address" },
{ internalType: "address", name: "to", type: "address" },
{ internalType: "uint256", name: "value", type: "uint256" }
],
name: "transferFrom",
outputs: [{ internalType: "bool", name: "", type: "bool" }],
stateMutability: "nonpayable",
type: "function"
}
];
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
ALITH_ADDRESS,
ALITH_CONTRACT_ADDRESSES,
ALITH_GENESIS_FREE_BALANCE,
ALITH_GENESIS_LOCK_BALANCE,
ALITH_GENESIS_RESERVE_BALANCE,
ALITH_GENESIS_TRANSFERABLE_BALANCE,
ALITH_PRIVATE_KEY,
ALITH_SESSION_ADDRESS,
BALTATHAR_ADDRESS,
BALTATHAR_PRIVATE_KEY,
BALTATHAR_SESSION_ADDRESS,
BASE_PATH,
BINARY_PATH,
BLOCK_TX_GAS_LIMIT,
BLOCK_TX_LIMIT,
CHARLETH_ADDRESS,
CHARLETH_PRIVATE_KEY,
CHARLETH_SESSION_ADDRESS,
CONTRACT_PROXY_TYPE_ANY,
CONTRACT_PROXY_TYPE_AUTHOR_MAPPING,
CONTRACT_PROXY_TYPE_BALANCES,
CONTRACT_PROXY_TYPE_CANCEL_PROXY,
CONTRACT_PROXY_TYPE_GOVERNANCE,
CONTRACT_PROXY_TYPE_IDENTITY_JUDGEMENT,
CONTRACT_PROXY_TYPE_NON_TRANSFER,
CONTRACT_PROXY_TYPE_STAKING,
CONTRACT_RANDOMNESS_STATUS_DOES_NOT_EXISTS,
CONTRACT_RANDOMNESS_STATUS_EXPIRED,
CONTRACT_RANDOMNESS_STATUS_PENDING,
CONTRACT_RANDOMNESS_STATUS_READY,
CUSTOM_SPEC_PATH,
DAYS,
DEBUG_MODE,
DEFAULT_GENESIS_BALANCE,
DEFAULT_GENESIS_MAPPING,
DEFAULT_GENESIS_STAKING,
DISPLAY_LOG,
DOROTHY_ADDRESS,
DOROTHY_PRIVATE_KEY,
ETHAN_ADDRESS,
ETHAN_PRIVATE_KEY,
ETHAPI_CMD,
EXTRINSIC_BASE_WEIGHT,
EXTRINSIC_GAS_LIMIT,
EthTester,
FAITH_ADDRESS,
FAITH_PRIVATE_KEY,
FIVE_MINS,
GAS_PER_SECOND,
GAS_PER_WEIGHT,
GERALD_ADDRESS,
GERALD_CONTRACT_ADDRESSES,
GERALD_PRIVATE_KEY,
GLMR,
GOLIATH_ADDRESS,
GOLIATH_PRIVATE_KEY,
HOURS,
MAX_BLOCK_WEIGHT,
MICROGLMR,
MILLIGLMR,
MINUTES,
MIN_GAS_PRICE,
MIN_GLMR_DELEGATOR,
MIN_GLMR_STAKING,
MOONBEAM_LOG,
ONE_HOURS,
OVERRIDE_RUNTIME_PATH,
PRECOMPILE_AUTHOR_MAPPING_ADDRESS,
PRECOMPILE_BATCH_ADDRESS,
PRECOMPILE_CALL_PERMIT_ADDRESS,
PRECOMPILE_COUNCIL_ADDRESS,
PRECOMPILE_CROWDLOAN_REWARDS_ADDRESS,
PRECOMPILE_DEMOCRACY_ADDRESS,
PRECOMPILE_DISPATCH_ADDRESS,
PRECOMPILE_NATIVE_ERC20_ADDRESS,
PRECOMPILE_PARACHAIN_STAKING_ADDRESS,
PRECOMPILE_PROXY_ADDRESS,
PRECOMPILE_RANDOMNESS_ADDRESS,
PRECOMPILE_RELAY_ENCODER_ADDRESS,
PRECOMPILE_TECH_COMMITTEE_ADDRESS,
PRECOMPILE_TREASURY_COUNCIL_ADDRESS,
PRECOMPILE_XCM_TRANSACTOR_ADDRESS_V1,
PRECOMPILE_XCM_TRANSACTOR_ADDRESS_V2,
PRECOMPILE_XCM_UTILS_ADDRESS,
PRECOMPILE_XTOKENS_ADDRESS,
PROPOSAL_AMOUNT,
Perbill,
Percent,
RELAY_BINARY_PATH,
RELAY_CHAIN_NODE_NAMES,
RELAY_LOG,
RUNTIME_CONSTANTS,
SPAWNING_TIME,
SPECS_PATH,
TARGET_FILL_AMOUNT,
TARGET_FILL_PERMILL,
TEN_MINS,
THIRTY_MINS,
TREASURY_ACCOUNT,
TWO_HOURS,
TWO_MINS,
VOTE_AMOUNT,
WASM_RUNTIME_OVERRIDES,
WEIGHT_FEE,
WEIGHT_PER_GAS,
ZERO_ADDRESS,
alith,
alithSigner,
baltathar,
calculateFeePortions,
charleth,
checkBlockFinalized,
createAndFinalizeBlock,
customWeb3Request,
dorothy,
ethan,
extractError,
extractInfo,
extractPreimageDeposit,
extractWeight,
faith,
fetchHistoricBlockNum,
filterAndApply,
generateKeyringPair,
gerald,
getBlockArray,
getBlockExtrinsic,
getBlockTime,
getDispatchError,
getObjectMethods,
goliath,
isExtrinsicSuccessful,
log,
mapExtrinsics,
printEvents,
printTokens,
setupLogger,
sortObjectByKeys,
web3EthCall,
xcAssetAbi
});