ssv-keys
Version:
CLI Tool for splitting a validator key into a predefined threshold of shares via Shamir-Secret-Sharing (SSS), and encrypt them with a set of operator keys.
394 lines (369 loc) • 11.5 kB
text/typescript
import prompts from "prompts";
import { ArgumentParser, SubParser } from "argparse";
import { BaseAction } from "./actions/BaseAction";
const ordinalSuffixOf = (i: number): string => {
const j = i % 10,
k = i % 100;
if (j == 1 && k != 11) {
return i + "st";
}
if (j == 2 && k != 12) {
return i + "nd";
}
if (j == 3 && k != 13) {
return i + "rd";
}
return i + "th";
};
export class BaseCommand extends ArgumentParser {
/**
* List of all supported command actions.
* @protected
*/
protected actions: any[] = [];
protected actionParsers: any = {};
protected subParserOptions = {
title: "Actions",
description: "Possible actions",
help: 'To get more detailed help: "<action> --help". ',
};
/**
* Argparse sub parser to hold all the command actions options.
* @protected
*/
protected subParsers: SubParser | undefined;
protected interactive = false;
protected useAction: string | undefined;
/**
* @param interactive if the command should be interactive instead of classic CLI
* @param options argparse options
*/
constructor(interactive = false, options = undefined) {
super(options);
this.interactive = interactive;
}
/**
* Add actions sub-parsers.
*/
addActionsSubParsers(): ArgumentParser {
this.subParsers = this.add_subparsers(this.subParserOptions);
for (const action of this.actions) {
const actionOptions = action.options;
const actionParser: ArgumentParser = this.subParsers.add_parser(
actionOptions.action
);
for (const argument of actionOptions.arguments) {
actionParser.add_argument(
argument.arg1,
argument.arg2,
argument.options
);
}
actionParser.set_defaults({
func: (args: any) => {
const executable = new action();
return executable.setArgs(args).execute();
},
});
this.actionParsers[actionOptions.action] = actionParser;
}
return this;
}
/**
* Interactively ask user for action
*/
async askAction(): Promise<string> {
// Skip asking action
if (this.useAction) {
return this.useAction;
}
const response = await prompts({
type: "select",
name: "action",
message: `Select action`,
choices: this.actions.map((action: BaseAction) => {
return {
title: action.options.description || "",
value: action.options.action || "",
};
}),
});
return response.action;
}
/**
* Pre-fill all values from arguments of executable
* @param selectedAction
* @param clearProcessArgs
*/
prefillFromArguments(
selectedAction: string,
clearProcessArgs?: boolean
): Record<string, any> {
const actionArguments = this.getArgumentsForAction(selectedAction);
const parser = new ArgumentParser();
const [, args] = parser.parse_known_args();
const parsedArgs: Record<string, any> = {};
for (const arg of args) {
const argData = arg.split("=");
// Find short arg1 and replace with long arg2
for (const argument of actionArguments) {
if (argData[0] === argument.arg1) {
argData[0] = argument.arg2;
break;
}
}
const argumentName = this.sanitizeArgument(argData[0]);
parsedArgs[argumentName] = String(argData[1]).trim();
}
parsedArgs["action"] = selectedAction;
prompts.override(parsedArgs);
if (clearProcessArgs) {
process.argv = [process.argv[0], process.argv[1]];
}
return parsedArgs;
}
isPrefillFromArrayExists(
dataIndex: number,
promptOptions: any,
preFilledValues: Record<string, any>
): boolean {
return !!preFilledValues[promptOptions.name]?.split(",")[dataIndex];
}
/**
* Pre-fill prompts from array data on specific index
* @param dataIndex
* @param argument
* @param promptOptions
* @param preFilledValues
*/
prefillFromArrayData(
dataIndex: number,
argument: any,
promptOptions: any,
preFilledValues: Record<string, any>
) {
let preFilledValue =
preFilledValues[promptOptions.name].split(",")[dataIndex];
if (argument.interactive.options.type === "number") {
preFilledValue = parseFloat(preFilledValue);
if (String(preFilledValue).endsWith(".0")) {
preFilledValue = parseInt(String(preFilledValue), 10);
}
}
const override = {
...preFilledValues,
[promptOptions.name]: preFilledValue,
};
prompts.override(override);
}
async ask(
promptOptions: any,
extraOptions: any,
required?: boolean
): Promise<any> {
let response: Record<string, any> = {};
response = await prompts(promptOptions, extraOptions);
while (required && !response[promptOptions.name]) {
if (Object.keys(response).indexOf(promptOptions.name) === -1) {
process.exit(1);
}
response = await prompts(promptOptions, extraOptions);
}
return response[promptOptions.name];
}
/**
* Interactively ask user for action to execute, and it's arguments.
* Populate process.argv with user input.
*/
async executeInteractive(): Promise<any> {
// Ask for action
const selectedAction = await this.askAction();
if (!selectedAction) {
process.exit(1);
}
const preFilledValues = this.prefillFromArguments(selectedAction, true);
process.argv.push(selectedAction);
const processedArguments: any = {};
const actionArguments = this.getArgumentsForAction(selectedAction);
const multi: any = {};
for (const argument of actionArguments) {
if (!argument.interactive) continue;
const promptOptions = this.getPromptOptions(argument);
if (processedArguments[promptOptions.name]) {
continue;
}
processedArguments[promptOptions.name] = true;
const message = promptOptions.message;
const extraOptions = { onSubmit: promptOptions.onSubmit };
let isRepeatable = !!argument.interactive?.repeat;
if (!isRepeatable) {
multi[promptOptions.name] = multi[promptOptions.name] || [];
multi[promptOptions.name].push(
await this.ask(promptOptions, extraOptions)
);
}
let repeatCount = 0;
while (isRepeatable) {
// Build pre-filled value for parent repeat
if (preFilledValues[promptOptions.name]) {
this.prefillFromArrayData(
repeatCount,
argument,
promptOptions,
preFilledValues
);
}
promptOptions.message = `${message}`.replace(
"{{index}}",
`${ordinalSuffixOf(repeatCount + 1)}`
);
multi[promptOptions.name] = multi[promptOptions.name] || [];
multi[promptOptions.name].push(
await this.ask(promptOptions, extraOptions)
);
// Processing "repeatWith".
// For cases when some parameters are relative to each other and should be
// asked from user in a relative way.
let filledAsParent = false;
for (const extraArgumentName of argument.interactive.repeatWith) {
const extraArgument = this.findArgumentByName(
extraArgumentName,
actionArguments
);
if (!extraArgument) {
continue;
}
// Build extra argument options
const extraArgumentPromptOptions =
this.getPromptOptions(extraArgument);
const extraArgumentMessage = extraArgumentPromptOptions.message;
const extraArgumentOptions = {
onSubmit: extraArgumentPromptOptions.onSubmit,
};
// Build pre-filled value for child repeat
if (preFilledValues[extraArgumentPromptOptions.name]) {
this.prefillFromArrayData(
repeatCount,
extraArgument,
extraArgumentPromptOptions,
preFilledValues
);
}
extraArgumentPromptOptions.message =
`${extraArgumentMessage}`.replace(
"{{index}}",
`${ordinalSuffixOf(repeatCount + 1)}`
);
// Prompt extra argumen
multi[extraArgumentPromptOptions.name] =
multi[extraArgumentPromptOptions.name] || [];
multi[extraArgumentPromptOptions.name].push(
await this.ask(extraArgumentPromptOptions, extraArgumentOptions)
);
processedArguments[extraArgumentPromptOptions.name] = true;
if (
preFilledValues[promptOptions.name] &&
preFilledValues[promptOptions.name].split(",").length ===
multi[extraArgumentPromptOptions.name].length
) {
filledAsParent = true;
}
}
if (filledAsParent) {
isRepeatable = false;
} else if (
!this.isPrefillFromArrayExists(
repeatCount + 1,
promptOptions,
preFilledValues
)
) {
isRepeatable = (
await prompts({
type: "confirm",
name: "value",
message: argument.interactive?.repeat,
initial: true,
})
).value;
}
repeatCount++;
}
// if end of repeat logic, need to validate the list if validator exists
if (argument.interactive?.repeat && argument.interactive?.validateList) {
argument.interactive?.validateList(multi[promptOptions.name]);
}
}
for (const argumentName of Object.keys(multi)) {
process.argv.push(
`--${argumentName.replace(/(_)/gi, "-")}=${multi[argumentName].join(
","
)}`
);
}
}
/**
* Find argument in list of arguments by its arg2 value.
* @param extraArgumentName
* @param actionArguments
*/
findArgumentByName(extraArgumentName: string, actionArguments: any[]): any {
for (const argument of actionArguments) {
if (extraArgumentName === argument.arg2) {
return argument;
}
}
return null;
}
/**
* Returns list of arguments for selected user action
* @param userAction
*/
getArgumentsForAction(userAction: string): any {
for (const action of this.actions) {
if (action.options.action === userAction) {
return action.options.arguments;
}
}
return null;
}
/**
* Make an argument name useful for the flow
* @param arg
* @protected
*/
protected sanitizeArgument(arg: string): string {
return arg.replace(/^(--)/gi, "").replace(/(-)/gi, "_").trim();
}
/**
* Compile final prompt options
* @param argument
*/
getPromptOptions(argument: any): any {
const message =
argument.interactive?.options?.message || argument.options.help;
return {
...(argument.interactive?.options || {}),
type: argument.interactive?.options?.type || "text",
name: this.sanitizeArgument(argument.arg2),
message,
onSubmit: argument.interactive.onSubmit || undefined,
};
}
async execute(): Promise<any> {
// Interactive execution
if (this.interactive) {
await this.executeInteractive();
}
// Non-interactive execution
// Add actions
this.addActionsSubParsers();
// Execute action
const args = this.parse_args();
if (!args.func) {
this.print_help();
return;
}
return args.func(args);
}
}