Added sendBatch.

Signed-off-by: Markuu-s <[email protected]>

Author: Markuu-s

core/api/full_node/node_api.hpp

@@ -463,6 +463,13 @@ namespace fc::api {
                const Address &,
                const TokenAmount &)
 
+    API_METHOD(ChainBaseFee,
+               jwt::kWritePermission,
+               TokenAmount,
+               Address,
+               SectorNumber,
+               TipsetKey)
+
     API_METHOD(MinerCreateBlock,
                jwt::kWritePermission,
                BlockWithCids,
@@ -787,6 +794,7 @@ namespace fc::api {
     visitNet(a, f);
     visitWallet(a, f);
     f(a.BeaconGetEntry);
+    f(a.ChainBaseFee);
     f(a.ChainGetBlock);
     f(a.ChainGetBlockMessages);
     f(a.ChainGetGenesis);

core/miner/storage_fsm/commit_batcher.hpp

@@ -21,6 +21,7 @@ namespace fc::mining {
     RegisteredSealProof spt;
   };
 
+
   class CommitBatcher {
    public:
     virtual ~CommitBatcher() = default;

core/miner/storage_fsm/impl/commit_batcher_impl.cpp

@@ -6,9 +6,17 @@
 #pragma once
 #include "commit_batcher_impl.hpp"
 #include <iterator>
+#include "vm/actor/builtin/v5/miner/miner_actor.hpp"
 
 namespace fc::mining {
   using vm::actor::builtin::types::miner::kChainFinality;
+  using PairStorage = CommitBatcherImpl::UnionStorage::PairStorage;
+  using fc::primitives::ActorId;
+  using primitives::BigInt;
+  using primitives::sector::AggregateSealVerifyInfo;
+  using vm::actor::builtin::types::miner::SectorPreCommitOnChainInfo;
+  using vm::actor::builtin::v5::miner::ProveCommitAggregate;
+  namespace vm::actor::builtin::types::miner::SectorPreCommitOnChainInfo;
 
   CommitBatcherImpl::CommitBatcherImpl(
       const std::chrono::milliseconds &max_time,
@@ -25,36 +33,91 @@ namespace fc::mining {
       const AggregateInput &aggregate_input,
       const CommitCallback &callback) {
     const SectorNumber &sector_number = sector_info.sector_number;
+    OUTCOME_TRY(head, api_->ChainHead());
 
-    /*
-     * TODO batch_storage_ and callbacks_ may union DONE
-     */
-    union_storage_.push(sector_number, aggregate_input, callback);
-
-    // setPreCommitCutoff(head->epoch(), sector_info); TODO same precommit DONE
+    union_storage_.push(sector_number, PairStorage(aggregate_input, callback));
 
     if (union_storage_.size() >= max_size_callback_) {
       sendCallbacks();
     }
+    // Вынести мьютексы
+    setCommitCutoff(head->epoch(), sector_info);
+
     return outcome::success();
   }
 
   void CommitBatcherImpl::forceSend() {}
 
   void CommitBatcherImpl::sendCallbacks() {
-    UnionStorage temp_union_storage(std::move(union_storage_));
-    const auto maybe_result = sendBatch();
-    for (const auto &[key, pair_storage] : temp_union_storage) {
+    UnionStorage union_storage_for_send_(std::move(union_storage_));
+    const auto maybe_result = sendBatch(union_storage_for_send_);
+    for (const auto &[key, pair_storage] : union_storage_for_send_) {
       pair_storage.commit_callback(maybe_result);
-    } // TODO does it work? because I didn`t iterator++
+    }
 
     cutoff_start_ = std::chrono::system_clock::now();
     closest_cutoff_ = max_delay_;
 
     handle_.reschedule(max_delay_).value();
   }
 
-  outcome::result<CID> CommitBatcherImpl::sendBatch() {}
+  outcome::result<CID> CommitBatcherImpl::sendBatch(
+      UnionStorage &union_storage_for_send) {
+    if (not union_storage_for_send.size()) {
+      cutoff_start_ = std::chrono::system_clock::now();
+      return ERROR_TEXT("Empty Batcher");
+    }
+    OUTCOME_TRY(head, api_->ChainHead());
+
+    // TODO ?
+    const size_t total = union_storage_for_send.size();
+
+    ProveCommitAggregate::Params params;
+
+    std::vector<std::vector<uint8_t>> proofs;
+    proofs.reserve(total);
+
+    BigInt collateral = 0;
+
+    for (const auto &[sector_number, pair_storage] : union_storage_for_send) {
+
+
+      TokenAmount sc = getSectorCollateral(head, sector_number, *head.get());
+      collateral = collateral + sc;
+
+      params.sectors.insert(sector_number);
+    }
+
+
+
+    for (const auto &[sector_number, pair_storage] : union_storage_for_send) {
+      proofs.push_back(
+          pair_storage.aggregate_input.proof);
+    }
+
+    const ActorId mid = miner_address_.getId();
+    // TODO maybe long (AggregateSealProofs)
+    params.proof = proof_->AggregateSealProofs(); // OUTCOME_TRY
+
+    // TODO CBOR::ENCODE params
+
+    // BigDiv usage вместо /(обычное деление)
+
+    const TokenAmount max_fee =
+        fee_config_->max_commit_batch_gas_fee.FeeForSector(proofs.size());
+
+    /*
+     * API_METHOD(StateMinerInfo,
+     * jwt::kReadPermission,
+     * MinerInfo,
+     * const Address &,
+     * const TipsetKey &)
+     */
+    // OTCOME_TRY(mi, api_->StateMinerInfo());
+
+    OUTCOME_TRY(bf, api_->ChainBaseFee(head));
+    OUTCOME_TRY(nv, api_->StateNetworkVersion(/*NetworkVersion*/, head));
+  }
 
   void CommitBatcherImpl::setCommitCutoff(const ChainEpoch &current_epoch,
                                           const SectorInfo &sector_info) {
@@ -87,34 +150,38 @@ namespace fc::mining {
     }
   }
 
-  void CommitBatcherImpl::UnionStorage::push(
+  TokenAmount CommitBatcherImpl::getSectorCollateral(
+      std::shared_ptr<const Tipset> &head,
       const SectorNumber &sector_number,
-      const AggregateInput &aggregate_input,
-      const CommitCallback &commit_callback) {
-    push(sector_number, PairStorage(aggregate_input, commit_callback));
+      const TipsetKey &tip_set_key) {
+    OUTCOME_TRY(pci,
+                api_->StateSectorPreCommitInfo(
+                    miner_address_, sector_number, tip_set_key));
+    OUTCOME_TRY(collateral,
+                api_->StateMinerInitialPledgeCollateral(
+                    miner_address_, head->key, pci.info, tip_set_key));
+
+    collateral = collateral + pci.PreCommitDeposit;
+    collateral = max(0, collateral);
+
+    return collateral;
   }
 
-  void CommitBatcherImpl::UnionStorage::push(
-      const SectorNumber &sector_number,
-      const CommitCallback &commit_callback,
-      const AggregateInput &aggregate_input) {
-    push(sector_number, PairStorage(aggregate_input, commit_callback));
-  }
   void CommitBatcherImpl::UnionStorage::push(const SectorNumber &sector_number,
                                              const PairStorage &pair_storage) {
     std::unique_lock<std::mutex> locker(mutex_);
     storage_[sector_number] = pair_storage;
   }
 
-
-
   CommitBatcherImpl::UnionStorage::UnionStorage(
       CommitBatcherImpl::UnionStorage &&union_storage1) {
-    std::unique_lock<std::mutex> locker(mutex_);
+    std::unique_lock<std::mutex> locker(union_storage1.mutex_);
     storage_.insert(std::make_move_iterator(union_storage1.storage_.begin()),
                     std::make_move_iterator(union_storage1.storage_.end()));
   }
-  size_t CommitBatcherImpl::UnionStorage::size() const {
+
+  size_t CommitBatcherImpl::UnionStorage::size()  {
+    std::unique_lock<std::mutex> locker(mutex_);
     return storage_.size();
   }
 
@@ -123,11 +190,6 @@ namespace fc::mining {
       const CommitCallback &commit_callback)
       : aggregate_input(aggregate_input), commit_callback(commit_callback) {}
 
-  CommitBatcherImpl::UnionStorage::PairStorage::PairStorage(
-      const CommitCallback &commit_callback,
-      const AggregateInput &aggregate_input)
-      : aggregate_input(aggregate_input), commit_callback(commit_callback) {}
-
   std::map<SectorNumber, CommitBatcherImpl::UnionStorage::PairStorage>::iterator
   CommitBatcherImpl::UnionStorage::begin() {
     return storage_.begin();
@@ -137,4 +199,9 @@ namespace fc::mining {
   CommitBatcherImpl::UnionStorage::end() {
     return storage_.end();
   }
+
+  PairStorage CommitBatcherImpl::UnionStorage::get(const int index) {
+    std::unique_lock<std::mutex> locker(mutex_);
+    return storage_[index];
+  }
 }  // namespace fc::mining

core/miner/storage_fsm/impl/commit_batcher_impl.hpp

@@ -11,10 +11,14 @@ namespace fc::mining {
 
   using libp2p::basic::Scheduler;
   using primitives::SectorNumber;
+  using primitives::address::Address;
+  using primitives::tipset::Tipset;
+  using primitives::tipset::TipsetKey;
+  using types::FeeConfig;
+  using proofs::ProofEngine;
 
   class CommitBatcherImpl : public CommitBatcher {
    public:
-
     class UnionStorage {
      public:
       UnionStorage() = default;
@@ -30,21 +34,14 @@ namespace fc::mining {
 
         PairStorage(const AggregateInput &aggregate_input,
                     const CommitCallback &commit_callback);
-
-        PairStorage(const CommitCallback &commit_callback,
-                    const AggregateInput &aggregate_input);
       };
 
       void push(const SectorNumber &sector_number,
-                const AggregateInput &aggregate_input,
-                const CommitCallback &commit_callback);
-      void push(const SectorNumber &sector_number,
-                const CommitCallback &commit_callback,
-                const AggregateInput &aggregate_input);
-      void push(const SectorNumber &sector_number,
-                const PairStorage &pair_storage); // TODO make one push
+                const PairStorage &pair_storage);
+
+      size_t size();
 
-      size_t size() const;
+      PairStorage get(const int index);
 
       std::map<SectorNumber, PairStorage>::iterator begin();
       std::map<SectorNumber, PairStorage>::iterator end();
@@ -53,22 +50,15 @@ namespace fc::mining {
       std::mutex mutex_;
 
       std::map<SectorNumber, PairStorage> storage_;
-    };
+    }; // TODO вынести PairStorage и удалить UnionStorage. storage_;
 
     CommitBatcherImpl(const std::chrono::milliseconds &max_time,
                       const size_t &max_size_callback,
                       const std::shared_ptr<Scheduler> &scheduler);
 
-    /*
-     * 1) Должен уметь отправлять информацию за время, которую ему задали
-     * NEW 2) Должен уметь отправлять информацию за размер, которую ему задали
-     * (например 10 коммитов макс вместимость мы должны его отправлять)
-     * 3) После любой отправки время отправки батчера заводится снова (
-     * скедлинг, хэндлер)
-     */
     outcome::result<void> addCommit(const SectorInfo &sector_info,
                                     const AggregateInput &aggregate_input,
-                                    const CommitCallback &callBack);
+                                    const CommitCallback &callBack) override;
 
     void forceSend() override;
 
@@ -84,11 +74,17 @@ namespace fc::mining {
     size_t max_size_callback_;
     UnionStorage union_storage_;
     std::shared_ptr<FullNodeApi> api_;
+    Address miner_address_;
+    std::shared_ptr<FeeConfig> fee_config_;
+    std::shared_ptr<ProofEngine> proof_;
 
     void sendCallbacks();
 
-    outcome::result<CID> sendBatch();
+    outcome::result<CID> sendBatch(UnionStorage &union_storage_for_send);
 
+    TokenAmount getSectorCollateral(std::shared_ptr<const Tipset> &head,
+                                    const SectorNumber &sector_number,
+                                    const TipsetKey &tip_set_key);
   };
 
 }  // namespace fc::mining

core/miner/storage_fsm/types.hpp

@@ -222,6 +222,7 @@ namespace fc::mining::types {
 
     // maxBatchFee = maxBase + maxPerSector * nSectors
     BatchConfing max_precommit_batch_gas_fee;
+    BatchConfing max_commit_batch_gas_fee;
 
     // TODO (Ruslan Gilvanov): TokenAmount max_terminate_gas_fee,
     // max_window_poSt_gas_fee, max_publish_deals_fee,