ssv-keys
Version:
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.
319 lines (294 loc) • 10.7 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();
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);
}
}