pow-testgiver support

crypto/util/pow-miner.cpp

@@ -0,0 +1,214 @@
+#include "common/bigint.hpp"
+#include "common/refint.h"
+#include "block/block.h"
+#include "td/utils/benchmark.h"
+#include "td/utils/filesystem.h"
+#include "vm/boc.h"
+#include "openssl/digest.hpp"
+#include <openssl/sha.h>
+#include <iostream>
+#include <thread>
+#include <cstdlib>
+#include <getopt.h>
+
+#include "Miner.h"
+
+const char* progname;
+
+int usage() {
+  std::cerr
+      << "usage: " << progname
+      << " [-v][-B][-w<threads>] [-t<timeout>] <my-address> <pow-seed> <pow-complexity> <iterations> [<miner-addr> "
+         "<output-ext-msg-boc>]\n"
+         "Outputs a valid <rdata> value for proof-of-work testgiver after computing at most <iterations> hashes "
+         "or terminates with non-zero exit code\n";
+  std::exit(2);
+}
+
+td::RefInt256 parse_bigint(std::string str, int bits) {
+  int len = (int)str.size();
+  auto num = td::make_refint();
+  auto& x = num.write();
+  if (len >= 3 && str[0] == '0' && str[1] == 'x') {
+    if (x.parse_hex(str.data() + 2, len - 2) != len - 2) {
+      return {};
+    }
+  } else if (!len || x.parse_dec(str.data(), len) != len) {
+    return {};
+  }
+  return x.unsigned_fits_bits(bits) ? std::move(num) : td::RefInt256{};
+}
+
+td::RefInt256 parse_bigint_chk(std::string str, int bits) {
+  auto x = parse_bigint(std::move(str), bits);
+  if (x.is_null()) {
+    std::cerr << "fatal: `" << str << "` is not an integer" << std::endl;
+    usage();
+  }
+  return x;
+}
+
+void parse_addr(std::string str, block::StdAddress& addr) {
+  if (!addr.parse_addr(str) || (addr.workchain != -1 && addr.workchain != 0)) {
+    std::cerr << "fatal: `" << str.c_str() << "` is not a valid blockchain address" << std::endl;
+    usage();
+  }
+}
+
+bool make_boc = false;
+std::string boc_filename;
+block::StdAddress miner_address;
+
+int verbosity = 0;
+std::atomic<td::uint64> hashes_computed{0};
+td::Timestamp start_at;
+
+void print_stats() {
+  auto passed = td::Timestamp::now().at() - start_at.at();
+  if (passed < 1e-9) {
+    passed = 1;
+  }
+  std::cerr << "[ hashes computed: " << hashes_computed << " ]" << std::endl;
+  std::cerr << "[ speed: " << static_cast<double>(hashes_computed) / passed << " hps ]" << std::endl;
+}
+
+int found(td::Slice data) {
+  for (unsigned i = 0; i < data.size(); i++) {
+    printf("%02X", data.ubegin()[i]);
+  }
+  printf("\n");
+  if (make_boc) {
+    vm::CellBuilder cb;
+    td::Ref<vm::Cell> ext_msg, body;
+    CHECK(cb.store_bytes_bool(data)                              // body
+          && cb.finalize_to(body)                                // -> body
+          && cb.store_long_bool(0x44, 7)                         // ext_message_in$10 ...
+          && cb.store_long_bool(miner_address.workchain, 8)      // workchain
+          && cb.store_bytes_bool(miner_address.addr.as_slice())  // miner addr
+          && cb.store_long_bool(1, 6)                            // amount:Grams ...
+          && cb.store_ref_bool(std::move(body))                  // body:^Cell
+          && cb.finalize_to(ext_msg));
+    auto boc = vm::std_boc_serialize(std::move(ext_msg), 2).move_as_ok();
+    std::cerr << "Saving " << boc.size() << " bytes of serialized external message into file `" << boc_filename << "`"
+              << std::endl;
+    td::write_file(boc_filename, boc).ensure();
+  }
+  if (verbosity > 0) {
+    print_stats();
+  }
+  std::exit(0);
+  return 0;
+}
+
+void miner(const ton::Miner::Options& options) {
+  auto res = ton::Miner::run(options);
+  if (res) {
+    found(res.value());
+  }
+}
+
+class MinerBench : public td::Benchmark {
+ public:
+  std::string get_description() const override {
+    return "Miner";
+  }
+
+  void run(int n) override {
+    ton::Miner::Options options;
+    options.my_address.parse_addr("EQDU86V5wyPrLd4nQ0RHPcCLPZq_y1O5wFWyTsMw63vjXTOv");
+    std::fill(options.seed.begin(), options.seed.end(), 0xa7);
+    std::fill(options.complexity.begin(), options.complexity.end(), 0);
+    options.max_iterations = n;
+    CHECK(!ton::Miner::run(options));
+  }
+};
+
+int main(int argc, char* const argv[]) {
+  ton::Miner::Options options;
+
+  progname = argv[0];
+  int i, threads = 0;
+  bool bounce = false, benchmark = false;
+  while ((i = getopt(argc, argv, "bnvw:t:Bh")) != -1) {
+    switch (i) {
+      case 'v':
+        ++verbosity;
+        break;
+      case 'w':
+        threads = atoi(optarg);
+        CHECK(threads > 0 && threads <= 128);
+        break;
+      case 't': {
+        int timeout = atoi(optarg);
+        CHECK(timeout > 0);
+        options.expire_at = td::Timestamp::in(timeout);
+        break;
+      }
+      case 'B':
+        benchmark = true;
+        break;
+      case 'b':
+        bounce = true;
+        break;
+      case 'n':
+        bounce = false;
+        break;
+      case 'h':
+        return usage();
+      default:
+        std::cerr << "unknown option" << std::endl;
+        return usage();
+    }
+  }
+  if (benchmark && argc == optind) {
+    td::bench(MinerBench());
+    return 0;
+  }
+
+  if (argc != optind + 4 && argc != optind + 6) {
+    return usage();
+  }
+
+  parse_addr(argv[optind], options.my_address);
+  options.my_address.bounceable = bounce;
+  CHECK(parse_bigint_chk(argv[optind + 1], 128)->export_bytes(options.seed.data(), 16, false));
+
+  auto cmplx = parse_bigint_chk(argv[optind + 2], 256);
+  CHECK(cmplx->export_bytes(options.complexity.data(), 32, false));
+  CHECK(!cmplx->unsigned_fits_bits(256 - 62));
+  td::BigInt256 bigpower, hrate;
+  bigpower.set_pow2(256).mod_div(*cmplx, hrate);
+  long long hash_rate = hrate.to_long();
+  options.max_iterations = parse_bigint_chk(argv[optind + 3], 50)->to_long();
+  if (argc == optind + 6) {
+    make_boc = true;
+    parse_addr(argv[optind + 4], miner_address);
+    boc_filename = argv[optind + 5];
+  }
+
+  if (verbosity >= 2) {
+    std::cerr << "[ expected required hashes for success: " << hash_rate << " ]" << std::endl;
+  }
+  if (benchmark) {
+    td::bench(MinerBench());
+  }
+
+  start_at = td::Timestamp::now();
+
+  options.hashes_computed = &hashes_computed;
+  // may invoke several miner threads
+  if (threads <= 0) {
+    miner(options);
+  } else {
+    std::vector<std::thread> T;
+    for (int i = 0; i < threads; i++) {
+      T.emplace_back(miner, options);
+    }
+    for (auto& thr : T) {
+      thr.join();
+    }
+  }
+  if (verbosity > 0) {
+    print_stats();
+  }
+}