@zombienet/orchestrator
Version:
ZombieNet aim to be a testing framework for substrate based blockchains, providing a simple cli tool that allow users to spawn and test ephemeral Substrate based networks
127 lines (126 loc) • 6.21 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateKeyFromSeed = generateKeyFromSeed;
exports.generateKeyForNode = generateKeyForNode;
exports.generateKeystoreFiles = generateKeystoreFiles;
const api_1 = require("@polkadot/api");
const util_1 = require("@polkadot/util");
const util_crypto_1 = require("@polkadot/util-crypto");
const utils_1 = require("@zombienet/utils");
const fs_1 = __importDefault(require("fs"));
function nameCase(string) {
return string.charAt(0).toUpperCase() + string.slice(1);
}
function generateKeyFromSeed(seed) {
return __awaiter(this, void 0, void 0, function* () {
yield (0, util_crypto_1.cryptoWaitReady)();
const sr_keyring = new api_1.Keyring({ type: "sr25519" });
return sr_keyring.createFromUri(`//${seed}`);
});
}
function generateKeyForNode(nodeName) {
return __awaiter(this, void 0, void 0, function* () {
yield (0, util_crypto_1.cryptoWaitReady)();
const mnemonic = (0, util_crypto_1.mnemonicGenerate)();
const seed = nodeName
? `//${nameCase(nodeName)}`
: (0, util_1.u8aToHex)((0, util_crypto_1.mnemonicToMiniSecret)(mnemonic));
const sr_keyring = new api_1.Keyring({ type: "sr25519" });
const sr_account = sr_keyring.createFromUri(`${seed}`);
const sr_stash = sr_keyring.createFromUri(`${seed}//stash`);
const ed_keyring = new api_1.Keyring({ type: "ed25519" });
const ed_account = ed_keyring.createFromUri(`${seed}`);
const ec_keyring = new api_1.Keyring({ type: "ecdsa" });
const ec_account = ec_keyring.createFromUri(`${seed}`);
// return the needed info
return {
seed,
mnemonic,
sr_account: {
address: sr_account.address,
publicKey: (0, util_1.u8aToHex)(sr_account.publicKey),
},
sr_stash: {
address: sr_stash.address,
publicKey: (0, util_1.u8aToHex)(sr_stash.publicKey),
},
ed_account: {
address: ed_account.address,
publicKey: (0, util_1.u8aToHex)(ed_account.publicKey),
},
ec_account: {
publicKey: (0, util_1.u8aToHex)(ec_account.publicKey),
},
};
});
}
function generateKeystoreFiles(node_1, path_1) {
return __awaiter(this, arguments, void 0, function* (node, path, isAssetHubPolkadot = false) {
var _a;
const keystoreDir = `${path}/keystore`;
yield (0, utils_1.makeDir)(keystoreDir);
const paths = [];
let keystore_key_types = {};
const default_keystore_key_types = {
aura: isAssetHubPolkadot
? node.accounts.ed_account.publicKey
: node.accounts.sr_account.publicKey,
babe: node.accounts.sr_account.publicKey,
imon: node.accounts.sr_account.publicKey,
gran: node.accounts.ed_account.publicKey,
audi: node.accounts.sr_account.publicKey,
asgn: node.accounts.sr_account.publicKey,
para: node.accounts.sr_account.publicKey,
beef: node.accounts.ec_account.publicKey,
nmbs: node.accounts.sr_account.publicKey, // Nimbus
rand: node.accounts.sr_account.publicKey, // Randomness (Moonbeam)
rate: node.accounts.ed_account.publicKey, // Equilibrium rate module
mixn: node.accounts.sr_account.publicKey, // Mixnet
bcsv: node.accounts.sr_account.publicKey, // BlockchainSrvc (StorageHub)
ftsv: node.accounts.ed_account.publicKey, // FileTransferSrvc (StorageHub)
};
// 2 ways keys can be defined:
(_a = node.keystoreKeyTypes) === null || _a === void 0 ? void 0 : _a.forEach((key_spec) => {
// short: by only 4 letter key type with defaulted scheme e.g. "audi", if default scheme doesn't exist it is "ed"
if (key_spec.length === 4) {
keystore_key_types[key_spec] =
default_keystore_key_types[key_spec] ||
node.accounts.sr_account.publicKey;
}
// long: 4 letter key type with scheme separated by underscore e.g. "audi_sr"
const [key_type, key_scheme] = key_spec.split("_");
if (key_type.length === 4) {
if (key_scheme === "ed") {
keystore_key_types[key_type] = node.accounts.ed_account.publicKey;
}
else if (key_scheme === "ec") {
keystore_key_types[key_type] = node.accounts.ec_account.publicKey;
}
else if (key_scheme === "sr") {
keystore_key_types[key_type] = node.accounts.sr_account.publicKey;
}
}
});
if (Object.keys(keystore_key_types).length === 0)
keystore_key_types = default_keystore_key_types;
for (const [k, v] of Object.entries(keystore_key_types)) {
const filename = Buffer.from(k).toString("hex") + v.replace(/^0x/, "");
const keystoreFilePath = `${keystoreDir}/${filename}`;
paths.push(keystoreFilePath);
yield fs_1.default.promises.writeFile(keystoreFilePath, `"${node.accounts.seed}"`);
}
return paths;
});
}