@wavesenterprise/generator-cli/src/generator.ts

Waves Enterprise transactions generator CLI

import { create, MAINNET_CONFIG } from '@wavesenterprise/js-sdk'
import * as fs from "fs";
import { fork } from 'child_process';
import { IBroadcastOptions, IConfig } from "./interfaces";
import { TxGeneratorService } from "./services/TxGeneratorService";

export interface ISeed {
  phrase: string;
  keyPair: {
    publicKey: string;
    privateKey: string;
  }
}

const AccountsFileName = 'accounts.json'
const SignedTxsDir = 'signed_txs'
const TxsListFileName = 'txs_list.csv'

export class Generator {
  private wavesApi: any
  private txGeneratorService: any

  constructor(private config: IConfig) {
    this.config = config
    this.initWavesApi(config)
  }

  private initWavesApi (config: IConfig) {
    const { generator } = config
    const wavesApiConfig = {
      ...MAINNET_CONFIG,
      crypto: generator.crypto,
      networkByte: generator.networkByte.charCodeAt(0),
      grpcAddress: '51.178.69.186:6865' // node-0 51.178.69.186:6865, node-1 51.210.210.154:6865
    };
    const wavesApi = create({
      initialConfiguration: wavesApiConfig
    })

    this.wavesApi = wavesApi

    this.txGeneratorService = new TxGeneratorService(config, wavesApi)
  }

  private generateAccounts = () => {
    const { generator: { txsNumber } } = this.config
    return Array(txsNumber).fill(null).map(() => this.wavesApi.Seed.fromExistingPhrase('examples seed phrase'))
  }

  writeToDisk (accounts: ISeed[], signedTxs: any[]) {
    const { outputDir, generator: { txsFormat } } = this.config
    if (fs.existsSync(outputDir)) {
      // console.log(`Clear directory "${outputDir}"`)
      fs.rmdirSync(outputDir, { recursive: true });
    }
    fs.mkdirSync(outputDir);
    fs.mkdirSync(`${outputDir}/${SignedTxsDir}`);
    fs.writeFileSync(`${outputDir}/${AccountsFileName}`, JSON.stringify(accounts, null, 2))
    for(let i=0; i < signedTxs.length; i++) {
      const signedTx = signedTxs[i]
      if (txsFormat === 'grpc') {
        fs.writeFileSync(`${outputDir}/${SignedTxsDir}/${i}.txt`, Buffer.from(signedTx))
      } else {
        fs.writeFileSync(`${outputDir}/${SignedTxsDir}/${i}.json`, JSON.stringify(signedTx, null, 2))
      }
    }
    const txsList = signedTxs.map((_, index: number) => index).join('\r\n')
    fs.writeFileSync(`${outputDir}/${TxsListFileName}`, txsList)
  }

  public async start () {
    const { outputDir } = this.config

    const timeStart = Date.now()
    // console.time('generate_accounts')
    const accounts = this.generateAccounts()
    // console.timeEnd('generate_accounts')

    // console.time('sign_transactions')
    const signedTxs = await this.txGeneratorService.generateSignedTxs(accounts)
    // console.timeEnd('sign_transactions')

    this.writeToDisk(accounts, signedTxs)

    const timeElapsed = Date.now() - timeStart

    console.log('\nTransactions generation is complete')
    console.log(`Count: ${signedTxs.length}`)
    console.log(`Total time: ${timeElapsed} ms (~ ${Math.round( signedTxs.length / (timeElapsed / 1000))} txs/s)`)
    console.log(`Check "${outputDir}" directory`)
  }

  public async broadcast(options: IBroadcastOptions) {
    const { generator: { templates }, broadcast: { grpcAddresses } } = this.config
    if (!templates) {
      return false
    }

    for(let i = 0; i < grpcAddresses.length; i++) {
      const grpcAddress = grpcAddresses[i]
      const worker = fork(__dirname + '/worker');

      worker.send({
          id: "node_"+ i,
          config: this.config,
          options,
          grpcAddress
      })

      worker.on('message', (data: any) => {
        const { grpcAddress, message } = data
        console.log(`${grpcAddress}: ${message}`)
      });
    }
    console.log(`Created ${grpcAddresses.length} worker threads: ${grpcAddresses.map(addr => addr).join(', ')}`)
    console.log(`Broadcast started\n`)
  }
}