@cardano-sdk/e2e 0.14.0 → 0.14.2

package/src/tools/multi-delegation-data-gen/utils/config.ts

@@ -0,0 +1,112 @@
+import convict from 'convict';
+import dotenv from 'dotenv';
+import path from 'path';
+
+dotenv.config({ path: path.join(__dirname, '../../../../.env') });
+
+convict.addFormat({
+  coerce: (val) => Number.parseInt(val, 10),
+  name: 'number',
+  validate(val) {
+    if (Number.isNaN(Number.parseInt(val)) || !Number.isInteger(val) || val < 0) {
+      throw new TypeError('Must be a positive integer value');
+    }
+  }
+});
+
+convict.addFormat({
+  name: 'weights',
+  validate(values) {
+    for (const val of values) {
+      if (Number.isNaN(Number.parseFloat(val)) || val < 0) throw new TypeError('Weights must be positive numbers');
+    }
+  }
+});
+
+export type ValueTransferConfig = {
+  amount: { max: number; min: number };
+  count: { max: number; min: number };
+  period: number;
+};
+
+export const configLoader = convict({
+  iterations: {
+    default: 10,
+    doc: 'How many iterations will be executed before stopping the test.',
+    format: 'number'
+  },
+  stakeDistribution: {
+    default: [1], // 100 % to the first stake index.
+    doc: 'The distribution of stake between stake indices. This distribution is expressed in weights',
+    format: 'weights',
+    nullable: false
+  },
+  startingFunds: {
+    default: 1_000_000_000, // 1000 ADA
+    doc: 'Starting funds of the newly created wallet.',
+    format: 'number',
+    nullable: false
+  },
+  utxoIn: {
+    amount: {
+      max: {
+        default: 1_000_000, // 1 ADA
+        doc: 'The maximum amount of the input (inclusive)',
+        format: 'number'
+      },
+      min: {
+        default: 1_000_000, // 1 ADA
+        doc: 'The minimum amount of the input (inclusive)',
+        format: 'number'
+      }
+    },
+    count: {
+      max: {
+        default: 1,
+        doc: 'The maximum number of inputs to be generated at each transaction',
+        format: 'number'
+      },
+      min: {
+        default: 1,
+        doc: 'The minimum number of inputs to be generated at each transaction',
+        format: 'number'
+      }
+    },
+    period: {
+      default: 0,
+      doc: 'How frequently the wallet will receive inputs.',
+      format: 'number'
+    }
+  },
+  utxoOut: {
+    amount: {
+      max: {
+        default: 1_000_000, // 1 ADA
+        doc: 'The maximum amount of the output (inclusive)',
+        format: 'number'
+      },
+      min: {
+        default: 1_000_000, // 1 ADA
+        doc: 'The minimum amount of the output (inclusive)',
+        format: 'number'
+      }
+    },
+    count: {
+      max: {
+        default: 1,
+        doc: 'The maximum number of outputs to be generated at each transaction',
+        format: 'number'
+      },
+      min: {
+        default: 1,
+        doc: 'The minimum number of outputs to be generated at each transaction',
+        format: 'number'
+      }
+    },
+    period: {
+      default: 0,
+      doc: 'How frequently the wallet will generate outputs.',
+      format: 'number'
+    }
+  }
+});

package/src/tools/multi-delegation-data-gen/utils/files.ts

@@ -0,0 +1,73 @@
+import * as fs from 'fs';
+import path from 'path';
+
+export enum Paths {
+  StakeDistribution = 'stake-distribution.csv',
+  WalletUtxos = 'utxos'
+}
+
+/**
+ * Functions to create/delete and read/write files and folders.
+ */
+export const Files = {
+  /**
+   * This method is intended to concatenate individual strings into a single string that represents a file path.
+   *
+   * @param paths An array of parts of the path.
+   */
+  combine(paths: Array<string>): string {
+    return path.join(...paths);
+  },
+  /**
+   * Creates a new folder if it doesn't exist.
+   *
+   * @param dir The directory to be created.
+   * @param recursive set to true if more than one nested directory is present in the path.
+   */
+  createFolder(dir: string, recursive?: boolean) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive });
+    }
+  },
+  /**
+   * Deletes a file or directory.
+   *
+   * @param filePath the path of a file or folder.
+   * @param recursive set to true if you want to perform a recursive delete.
+   */
+  delete(filePath: string, recursive?: boolean) {
+    if (!fs.existsSync(filePath)) {
+      return;
+    }
+
+    fs.rmSync(filePath, { recursive });
+  },
+  /**
+   * Writes content to a file.
+   *
+   * @param filePath The path of the file.
+   */
+  readFile(filePath: string): Uint8Array {
+    if (!fs.existsSync(filePath)) {
+      throw new Error('File not found.');
+    }
+
+    return fs.readFileSync(filePath);
+  },
+
+  /**
+   * Writes content to a file.
+   *
+   * @param filePath The path of the file.
+   * @param content The content to be written.
+   * @param append true if the content must be appended; otherwise; the original contents will be erased.
+   */
+  writeFile(filePath: string, content: string | Uint8Array, append?: boolean) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      this.createFolder(dir, true);
+    }
+
+    return append ? fs.appendFileSync(filePath, content) : fs.writeFileSync(filePath, content);
+  }
+};

package/src/tools/multi-delegation-data-gen/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './config';
+export * from './files';
+export * from './utils';
+export * from './terminal-progress-monitor';

package/src/tools/multi-delegation-data-gen/utils/terminal-progress-monitor.ts

@@ -0,0 +1,147 @@
+import chalk from 'chalk';
+import cliSpinners from 'cli-spinners';
+import ora from 'ora';
+
+/**
+ * The task result.
+ */
+export enum TaskResult {
+  Success = 0,
+  Fail = 1,
+  Warning = 2,
+  Info = 3,
+  None = 4
+}
+
+/**
+ * Tracks progress of tasks in the terminal.
+ */
+export class TerminalProgressMonitor {
+  #currentTask: ora.Ora | null = null;
+
+  /**
+   * Starts tracking a new task. it will display a spinner while the ask is being tracked.
+   *
+   * Only one task can be tracked at a time. If you have a current track task, this
+   * method will throw.
+   *
+   * @param message The message of the task.
+   */
+  startTask(message: string) {
+    if (this.#currentTask) throw new Error('Only one task can be tracked at a time');
+
+    this.#currentTask = ora({
+      spinner: cliSpinners.dots,
+      text: message
+    });
+
+    this.#currentTask.start();
+  }
+
+  /**
+   * Ends the tracking of the current task.
+   *
+   * @param message The result message to be displayed.
+   * @param result The task result.
+   */
+  endTask(message: string, result: TaskResult) {
+    if (!this.#currentTask) return;
+
+    switch (result) {
+      case TaskResult.Fail:
+        this.#currentTask.fail(chalk.red(message));
+        break;
+      case TaskResult.Info:
+        this.#currentTask.info(message);
+        break;
+      case TaskResult.Success:
+        this.#currentTask.succeed(message);
+        break;
+      case TaskResult.Warning:
+        this.#currentTask.warn(chalk.yellow(message));
+        break;
+      default:
+      case TaskResult.None:
+        this.#currentTask.stop();
+    }
+
+    this.#currentTask = null;
+  }
+
+  /**
+   * Gets whether the monitor is currently tracking a task.
+   *
+   * @returns true if it is tracking a task; otherwise; false.
+   */
+  isTrackingTask(): boolean {
+    return !!this.#currentTask;
+  }
+
+  /**
+   * Adds a info log entry to the monitor.
+   *
+   * @param message The result message to be displayed.
+   */
+  logInfo(message: string) {
+    this.log(message, TaskResult.Info);
+  }
+
+  /**
+   * Adds a warning log entry to the monitor.
+   *
+   * @param message The result message to be displayed.
+   */
+  logWarning(message: string) {
+    this.log(message, TaskResult.Warning);
+  }
+
+  /**
+   * Adds a warning log entry to the monitor.
+   *
+   * @param message The result message to be displayed.
+   */
+  logFailure(message: string) {
+    this.log(message, TaskResult.Fail);
+  }
+
+  /**
+   * Adds a success log entry to the monitor.
+   *
+   * @param message The result message to be displayed.
+   */
+  logSuccess(message: string) {
+    this.log(message, TaskResult.Success);
+  }
+
+  /**
+   * Logs a message into the monitor.
+   *
+   * @param message The result message to be displayed.
+   * @param result The task result.
+   */
+  private log(message: string, result: TaskResult) {
+    if (this.#currentTask) throw new Error('Cant log in the monitor while a task is being tracked');
+
+    const task = ora({
+      spinner: cliSpinners.dots,
+      text: message
+    });
+
+    switch (result) {
+      case TaskResult.Fail:
+        task.fail(chalk.red(message));
+        break;
+      case TaskResult.Info:
+        task.info(message);
+        break;
+      case TaskResult.Success:
+        task.succeed(message);
+        break;
+      case TaskResult.Warning:
+        task.warn(chalk.yellow(message));
+        break;
+      default:
+      case TaskResult.None:
+    }
+  }
+}