fixes and readme (#528)

Signed-off-by: turuslan <[email protected]>

Author: turuslan

CMakeLists.txt

@@ -18,8 +18,8 @@ set(
 
 include("cmake/Hunter/init.cmake")
 HunterGate(
-    URL "https://github.com/soramitsu/soramitsu-hunter/archive/tags/v0.23.257-soramitsu13.tar.gz"
-    SHA1 "8c88d8bac2dee771926b84a6e28642a267f88ea8"
+    URL  "https://github.com/soramitsu/soramitsu-hunter/archive/tags/v0.23.257-soramitsu16.tar.gz"
+    SHA1 "64a1180e8cbeb98d2cfd786bfb725dcdc81d8fa9"
     LOCAL
 )
 
@@ -125,3 +125,5 @@ if (TESTING)
   enable_testing()
   add_subdirectory(test)
 endif ()
+
+install(TARGETS fuhon-node fuhon-miner)

README.md

@@ -20,160 +20,109 @@ You can also read about lotus minimal requirements in [filecoin-docs](https://do
 
 All C++ dependencies are managed using [Hunter](https://github.com/cpp-pm/hunter).
 It uses cmake to download required libraries and do not require downloading and installing packages manually.
-Target C++ compilers are:
-* GCC 7.4
-* Clang 6.0.1
-* AppleClang 11.0
-
-### Rust Installation
-
-C++ Filecoin implementation uses Rust libraries as dependencies for BLS providers.
-All you need to build these targets successfully - is Rust lang installed to your `${HOME}/.cargo/bin`.
-
-You can do it manually following the instructions from [rust-lang.org](https://www.rust-lang.org/tools/install) or any other way.
-
-Otherwise, CMake would not be able to compile Rust-related targets and will produce a warning about that during configuration.
-
-### CodeStyle
-
-We follow [CppCoreGuidelines](https://github.com/isocpp/CppCoreGuidelines).
-
-Please use clang-format 11.0.0 with provided [.clang-format](.clang-format) file to autoformat the code.
-
-## Maintenance
-
-Maintainers: @zuiris, @turuslan, @Elestrias, @ortyomka, @wer1st, @Alexey-N-Chernyshov
-
-Tickets: Can be opened in GitHub Issues.
-
-
-# Cpp-Filecoin install and setup guide
-## Fuhon node establishing
-There are 2 ways of getting  an executable version of filecoin node or miner. The First is to get executables by [downloading](https://github.com/filecoin-project/cpp-filecoin/releases "cpp-filecoin releases"). The second is to build executables by yourself, see **Advanced building**. To begin running a node you will need `node` executable.
-
-1. To configure a node you also need to make:
-* **configuration file**
-  example `config.cfg`:
-
-     ```
-     bootstrap=<enter your peer here>
-     drand-server=api.drand.sh
-     drand-pubkey=868f005eb8e6e4ca0a47c8a77ceaa5309a47978a7c71bc5cce96366b5d7a569937c529eeda66c7293784a9402801af31
-     drand-genesis-time=1595431050
-     drand-period=30
-     ```
-* **genesis file** - this is a special pre-set file with the initial block, which will configure the initial state of your node, sets network parameters like sector size, recalls time, e.t.c and defines miner-list with the first network miner.
-
-you also can download that [snapshots](https://fil-chain-snapshots-fallback.s3.amazonaws.com/mainnet/minimal_finality_stateroots_latest.car "snapshots store") for a less time-assuming connection and synchronization to the popular filecoin networks.
-More about snapshot management [here](https://docs.filecoin.io/get-started/lotus/chain/#restoring-a-custom-snapshot "snapshot documentation").
-2. After all the preparations you can launch a node:
-*  link working directory, which will be a storage for all node-associated files. It can be done with `--repo` flag
-*  One more important linking is configuration and genesis files, you can pass paths to them with `--config CONFIG_FILE` and `--genesis GENESIS_FILE` respectively.
-*  For specifying peers listening port you need to pass `--port PORT` flag
-*  In case you want to specify api port for a node + miner configuration or multi-node configuration,  you can do that with `--api API_PORT`
-*  Example of the command: `node_exec --repo path_to_node_repo --genesis genesis.car --config config.cfg  --port 8080 --api 1235`
-
-## Lotus-CLI establishing
-### User approach:
-1. Download [lotus executable](https://github.com/filecoin-project/lotus/releases/ "lotus releases")
-2. You can use CLI client with your node by linking it with `--repo <path to your node working directory>` flag,
-   more about lotus-CLI flags will be covered in **Work with Lotus-CLI**
 
-### Advanced approach:
-1. clone [lotus repository](https://github.com/filecoin-project/lotus "lotus project")
-2. build lotus cli client with command: `make build`
-3. In case you want to connect to interopnet, build lotus with `make interopnet`
-## Work with Lotus-CLI
-
-1. For proper miner work you will need a bls wallet, which can be made with lotus-cli by using the following command: `$lotus --repo REPO wallet new bls`, after the execution of this command you will revive the public address of your new account, and a private key in `<repo of your working node>/keystore`.
-2. Also, you may need to put some Filecoins on your account from other addresses you may have, and you can do it  with `lotus --repo REPO send --from SENDER_ADDRESS DISTANATION_ADDRESS`
-
-3. In case you want to get some Filecoins, you can buy them on stocks with the usage of your public address.
-
-4. Other advanced commands you may find in [filecoin-docs about lotus CLI](https://docs.filecoin.io/get-started/lotus/installation/#interact-with-the-daemon "lotus CLI documentation").
-## Fuhon miner establishing
-To start mining at first you need to configure and run Fuhon or Lotus node. Before all make sure that your node had successfully **connected** and updated to the current **block height** (actual network block number). Also, your node's api port should be opened for connection.
-
-To provide wallet functions and oracle information be sure to run lotus-cli at first. You can find how to do it in **Lotus-CLI establishing**.
-
-Once all the needed  modules will be started, you can continue with the miner configuration.
-
-1. Create miner work directory (f.e. `$mkdir miner`)
-2. Download [miner executable](https://github.com/filecoin-project/cpp-filecoin/releases "executables releases") and put it in work directory
-   3.Copy proof parameters json file with command: `cp /<path to cpp-filecoin>/core/proofs/parameters.json MINER_REPO/proof-params.json`
-4. Run your miner with ` --repo REPO --miner-repo MINER_REPO --owner PUBLIC_ADRESS --miner-api MINER_API_PORT --sector-size SECTOR_SIZE`
+Target C++ compilers are:
+* GCC 9.3.0
+* Clang 9.0.1
+* AppleClang 12.0.0
+
+### Lotus CLI
+`fuhon-node` supports subset of `lotus` CLI commands.  
+You may download [pre-built binaries](https://github.com/filecoin-project/lotus/releases) or build [lotus](https://github.com/filecoin-project/lotus) from source.  
+Lotus CLI [introduction](https://docs.filecoin.io/get-started/lotus/installation/#interact-with-the-daemon).
+
+### Rust
+[filecoin-ffi](https://github.com/filecoin-project/filecoin-ffi) provides pre-built binaries for some platforms.  
+If they are unavailable, you need Rust compiler to build them.  
+Rust [installation instruction](https://www.rust-lang.org/tools/install).
+
+## Build
+```sh
+# clone project
+git clone --recursive https://github.com/filecoin-project/cpp-filecoin
+# configure cmake
+cmake cpp-filecoin -B cpp-filecoin/build
+# build and install fuhon-node and fuhon-miner
+cmake --build cpp-filecoin/build --target install
+# check that fuhon-node and fuhon-miner are now available
+fuhon-node --help
+fuhon-miner --help
+```
 
-## Advanced Building
-This approach allows you to build our project with your modifications,
-but be sure that your realization follows consensus rules.
+## Usage
 
-1. clone [funon-filecoin project](https://github.com/filecoin-project/cpp-filecoin "cpp-filecoin project")
+### Interopnet node
 
-2. go to `./cpp-filecoin` directory
+Create the following `fuhon-interopnet/config.cfg` file
+```properties
+# use interopnet profile, corresponds to "make interopnet" lotus target
+profile=interopnet
 
-3. run `$git submodule update --init --recursive`
+# enable debug logs to see sync progress
+log=d
 
-4. To finish your building you may also want to add your GitHub token, In such case you need to set up two environment variables:
-```
-GITHUB_HUNTER_USERNAME=<github account name>
-GITHUB_HUNTER_TOKEN=<github token>
+# bootstrap peers from https://github.com/filecoin-project/lotus/blob/master/build/bootstrap/interopnet.pi
+bootstrap=/dns4/bootstrap-0.interop.fildev.network/tcp/1347/p2p/12D3KooWLGPq9JL1xwL6gHok7HSNxtK1Q5kyfg4Hk69ifRPghn4i
+bootstrap=/dns4/bootstrap-1.interop.fildev.network/tcp/1347/p2p/12D3KooWFYS1f31zafv8mqqYu8U3hEqYvaZ6avWzYU3BmZdpyH3h
 ```
-To generate GitHub token follow the [instructions](https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line). Make sure `read:packages` and `write:packages` permissions are granted.
 
-5. At this stage you will need a build directory, which can be created with `mkdir BUILD_REPO`
-   
-6. Build cmake with the following command: `cmake . -B BUILD_DIR`
+Start node
+```sh
+fuhon-node --repo fuhon-interopnet --genesis cpp-filecoin/core/node/main/interopnet.car
+# you can omit --genesis flag after first run
+fuhon-node --repo fuhon-interopnet
+```
 
-7. build targets: node - for node executable, miner_main- for miner executable.
-   example: `cmake --build BUILD_DIR --target node miner_main`
+To use lotus CLI add `--repo` flag
+```sh
+lotus --repo fuhon-interopnet net peers
+```
 
-8. First time build will likely take a long time. However, you can cache binaries to [hunter-binary-cache].
+### Mainnet node (from snapshot)
 
-9. Node executable can be found at: `<build_repository>/core/node/main`.
-10. Miner executable can be found at:
-   `<build_repository>/core/miner/main`
-11.The next steps are similar to common miner and node establishing which can be found at **Fuhon node establishing** and **Fuhon miner establishing**
+Download mainnet snapshot ([docs](https://docs.filecoin.io/get-started/lotus/chain)).
+```sh
+LATEST_SNAPSHOT=$(curl -sI https://fil-chain-snapshots-fallback.s3.amazonaws.com/mainnet/minimal_finality_stateroots_latest.car | perl -ne '/x-amz-website-redirect-location:\s(.+\.car)/ && print $1')
+curl -o mainnet-snapshot.car $LATEST_SNAPSHOT
+```
 
-## Configuration Lotus-Fuhon
-### Lotus-node and Fuhon-miner
-1. To start up a lotus node at first you need to get a [lotus executable](https://github.com/filecoin-project/lotus/releases/ "lotus releases")
-2. You can run your lotus node with the next command: `$lotus --repo REPO daemon --genesis genesis.car --profile bootstrapper`, more about running lotus software can be found in [filecoin-docs](https://docs.filecoin.io/get-started/lotus/installation "lotus filecoin documentation").
-3. Fuhon-miner establishing is described in **Fuhon miner establishing**
-### Fuhon-node and Lotus-miner
-1. Establishing a Fuhon node is described in **Fuhon node establishing**
-2. Lotus miner can be established in the following way:
-   - to begin with you need your own bls wallet(described in **Working with Lotus-CLI**)
-   - init your miner with the command: `lotus-miner --repo REPO --miner-repo MINER_REPO init --nosync --owner BLS_WALLET_ADDR --sector-size SECTOR_SIZE`
-   - to know more about lotus software establishing, read [filecoin-docs](https://docs.filecoin.io/get-started/lotus/installation/#minimal-requirements "lotus establishing guide")
+Create following `fuhon-mainnet/config.cfg` file
+```properties
+# use downloaded snapshot file (do not delete that file)
+use-snapshot=mainnet-snapshot.car
 
-## Docker configuration
-    Will be soon!
+# bootstrap peers from https://github.com/filecoin-project/lotus/blob/master/build/bootstrap/mainnet.pi
+bootstrap=/dns4/node.glif.io/tcp/1235/p2p/12D3KooWBF8cpp65hp2u9LK5mh19x67ftAam84z9LsfaquTDSBpt
+```
 
-## Your new Filecoin network start
+Start node (first run may take some time)
+```sh
+fuhon-node --repo fuhon-mainnet --genesis cpp-filecoin/core/node/main/mainnet.car
+```
 
-To run a new filecoin network, you should run at least one node, and a miner (miners are a representation of the network power, so the more miners connected and sealed, the more power your network will have). In this guide, we will consider a network of two nodes and two miners(genesis and common ones)
+### Docker-compose example
 
-1. To run the first node you will need to generate a new genesis file which will be an initial instruction for all new connected nodes.
-   This can be done with lotus-seed tools:
-   - Clone  [lotus repository](https://github.com/filecoin-project/lotus "lotus project")
+```sh
+docker-compose up
+```
 
-   - build lotus-seed with `$make lotus-seed` or `make debug` - for debug version initiation,
-     or `make 2k` for a version with 2 KiB sector size  or `make interopnet` for interopnet version.
+## CodeStyle
 
-   - Generate genesis and preseal. Ensure lotus-seed was built in the previous step and run script node `$genesis.js DIR 1` to generate genesis. `DIR` - directory where genesis and presealed sectors will be generated, 1 - number of sectors for a miner. In case your lotus executables lay in a custom directory or script can not find them, you can link lotus target with `LOTUS=/<path to your lotus executable>/lotus node genesis.js <directory where results will be> <sealing sectors upper bound>`
+We follow [CppCoreGuidelines](https://github.com/isocpp/CppCoreGuidelines).
 
-2. Run your node-1 with new genesis file as it was done in chapter **Fuhon node establishing**
+Please use clang-format 11.0.0 with provided [.clang-format](.clang-format) file to autoformat the code.
 
-3. Run your node-2 as the 1st one, but be sure to open api port on it with `--api API_PORT`
+## Maintenance
 
-4. Connect node-2 to node-1 by commands:
-   `addr=$(lotus --repo REPO1 net listen | grep 127.0.0.1)`
-   `lotus --repo REPO2 net connect $addr`t
+Maintainers: @zuiris, @turuslan, @Elestrias, @ortyomka, @wer1st, @Alexey-N-Chernyshov
 
-5. After generating a new genesis file, you will also receive genesis.json with declared miners list, these are addresses of the initial miners.
+Tickets: Can be opened in GitHub Issues.
 
-6. To start miner that is declared in genesis file (step 5) you can use chapter **Fuhon miner establishing** but with some major changes.
-   You will also need the following flags to be provided:   `--genesis-miner`, `--actor ACTOR`, `--pre-sealed-sectors PRESEAL_DIR`, `--pre-sealed-metadata PRESEAL_JSON`.
+## Hunter cache upload
 
-7. To start a new miner just follow the steps declared in **Fuhon miner establishing**, or you can run lotus miner using [filecoin-docs](https://docs.filecoin.io/get-started/lotus/installation/#minimal-requirements "lotus establishing guide")
-8. After two nodes will be connected and your miner will work, a new filecoin network starting to exist, since that moment you can share your peers to invite new participants. 
+If you have access and want to upload to [hunter-binary-cache](https://github.com/soramitsu/hunter-binary-cache), you need to add your GitHub token with `read:packages` and `write:packages` permissions.  
+To generate GitHub token follow the [instructions](https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line).
+```sh
+export GITHUB_HUNTER_USERNAME=<github account name>
+export GITHUB_HUNTER_TOKEN=<github token>
+```

cmake/Hunter/config.cmake

@@ -17,8 +17,8 @@ hunter_config(
 )
 
 hunter_config(libp2p
-    URL https://github.com/soramitsu/cpp-libp2p/archive/b6de6a91eeeb23bcb1eefeb4a99f1bdcda3d86bd.tar.gz
-    SHA1 fa41c751cab65f8e3ee2e62df9dceb4894ee2e9a
+    URL https://github.com/soramitsu/cpp-libp2p/archive/3587bdcef771d6ca93b3f00bb26a6603653bdb5f.tar.gz
+    SHA1 45ae022b61dac3fb5396cfa1eb89cbc41e9a3b43
     CMAKE_ARGS TESTING=OFF EXAMPLES=OFF EXPOSE_MOCKS=ON
     KEEP_PACKAGE_SOURCES
     )

cmake/dependencies.cmake

@@ -4,7 +4,6 @@
 # https://docs.hunter.sh/en/latest/packages/pkg/GTest.html
 hunter_add_package(GTest)
 find_package(GTest CONFIG REQUIRED)
-find_package(GMock CONFIG REQUIRED)
 
 hunter_add_package(libarchive)
 find_package(libarchive CONFIG REQUIRED)

cmake/functions.cmake

@@ -9,8 +9,7 @@ function(addtest test_name)
   add_executable(${test_name} ${ARGN})
   addtest_part(${test_name} ${ARGN})
   target_link_libraries(${test_name}
-      GTest::main
-      GMock::main
+      GTest::gmock_main
       )
   file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/xunit)
   set(xml_output "--gtest_output=xml:${CMAKE_BINARY_DIR}/xunit/xunit-${test_name}.xml")

core/miner/main/CMakeLists.txt

@@ -3,10 +3,10 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-add_executable(miner_main
+add_executable(fuhon-miner
     main.cpp
     )
-target_link_libraries(miner_main
+target_link_libraries(fuhon-miner
     Boost::program_options
     filecoin_config
     clock
@@ -33,3 +33,6 @@ target_link_libraries(miner_main
 
     miner_actor_state
     )
+set_target_properties(fuhon-miner PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+    )

core/miner/main/main.cpp

@@ -50,9 +50,9 @@
 #include "storage/ipfs/impl/datastore_leveldb.hpp"
 #include "storage/leveldb/leveldb.hpp"
 #include "storage/piece/impl/piece_storage_impl.hpp"
+#include "vm/actor/builtin/types/market/deal_info_manager/impl/deal_info_manager_impl.hpp"
 #include "vm/actor/builtin/v0/miner/miner_actor.hpp"
 #include "vm/actor/builtin/v0/storage_power/storage_power_actor.hpp"
-#include "vm/actor/builtin/types/market/deal_info_manager/impl/deal_info_manager_impl.hpp"
 
 namespace fc {
   using boost::asio::io_context;
@@ -137,6 +137,7 @@ namespace fc {
 
     po::options_description desc("Fuhon miner options");
     auto option{desc.add_options()};
+    option("help,h", "print usage message");
     option("miner-repo", po::value(&config.repo_path)->required());
     option("repo", po::value(&raw.node_repo));
     option("miner-api", po::value(&config.api_port)->default_value(2345));
@@ -156,6 +157,10 @@ namespace fc {
 
     po::variables_map vm;
     po::store(parse_command_line(argc, argv, desc), vm);
+    if (vm.count("help") != 0) {
+      std::cerr << desc << std::endl;
+      exit(EXIT_SUCCESS);
+    }
     po::notify(vm);
     boost::filesystem::create_directories(config.repo_path);
     std::ifstream config_file{config.join("config.cfg")};

core/node/main/CMakeLists.txt

@@ -49,10 +49,12 @@ target_link_libraries(node_builder
     miner_types
     )
 
-add_executable(node
+add_executable(fuhon-node
     main.cpp
     )
-
-target_link_libraries(node
+target_link_libraries(fuhon-node
     node_builder
     )
+set_target_properties(fuhon-node PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+    )

core/node/main/builder.cpp

@@ -160,13 +160,13 @@ namespace fc::node {
       snapshot_key->getCbor(snapshot_cids);
       if (!config.snapshot) {
         log()->warn(
-            "snapshot was imported before, but snapshot argument is missing");
+            "snapshot was used before, but snapshot argument is missing");
       }
     }
     if (config.snapshot) {
       auto roots{storage::car::readHeader(*config.snapshot).value()};
       if (!snapshot_cids.empty() && snapshot_cids != roots) {
-        log()->error("another snapshot already imported");
+        log()->error("another snapshot already used");
         exit(EXIT_FAILURE);
       }
       // TODO(turuslan): max memory
@@ -175,7 +175,7 @@ namespace fc::node {
       o.ipld = o.ipld_cids;
       if (snapshot_cids.empty()) {
         snapshot_cids = roots;
-        log()->info("snapshot imported");
+        log()->info("snapshot is ready to use");
         snapshot_key->setCbor(snapshot_cids);
       }
     }