Need save change.

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

Author: Markuu-s

core/miner/storage_fsm/commit_batcher.hpp

@@ -11,13 +11,14 @@
 namespace fc::mining {
   using CommitCallback = std::function<void(const outcome::result<CID> &)>;
   using api::FullNodeApi;
+  using primitives::sector::AggregateSealVerifyInfo;
   using primitives::sector::RegisteredSealProof;
   using sector_storage::Proof;
   using types::SectorInfo;
 
   struct AggregateInput {
     Proof proof;
-    // Info info;
+    AggregateSealVerifyInfo info;
     RegisteredSealProof spt;
   };
 

core/miner/storage_fsm/impl/commit_batcher_impl.cpp

@@ -7,14 +7,22 @@
 #include "commit_batcher_impl.hpp"
 #include <iterator>
 #include "vm/actor/builtin/v5/miner/miner_actor.hpp"
+#include "vm/actor/builtin/v6/monies.hpp"
 
 namespace fc::mining {
-  using fc::primitives::ActorId;
-  using primitives::BigInt;
+  using api::kPushNoSpec;
+  using fc::BytesIn;
+  using fc::proofs::ProofEngine;
+  using primitives::ActorId;
+  using primitives::go::bigdiv;
   using primitives::sector::AggregateSealVerifyInfo;
+  using primitives::sector::AggregateSealVerifyProofAndInfos;
+  using primitives::tipset::TipsetCPtr;
+  using vm::actor::MethodParams;
   using vm::actor::builtin::types::miner::kChainFinality;
   using vm::actor::builtin::types::miner::SectorPreCommitOnChainInfo;
   using vm::actor::builtin::v5::miner::ProveCommitAggregate;
+  using vm::actor::builtin::v6::miner::AggregateProveCommitNetworkFee;
 
   CommitBatcherImpl::CommitBatcherImpl(
       const std::chrono::milliseconds &max_time,
@@ -74,21 +82,24 @@ namespace fc::mining {
     }
     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;
+    std::vector<BytesIn> proofs;
     proofs.reserve(total);
 
+    std::vector<AggregateSealVerifyInfo> infos;
+    infos.reserve(total);
+
     BigInt collateral = 0;
 
     for (const auto &[sector_number, pair_storage] : union_storage_for_send) {
       OUTCOME_TRY(sc, getSectorCollateral(sector_number, head->key));
       collateral = collateral + sc;
 
       params.sectors.insert(sector_number);
+      infos.push_back(pair_storage.aggregate_input.info);
     }
 
     for (const auto &[sector_number, pair_storage] : union_storage_for_send) {
@@ -98,28 +109,56 @@ namespace fc::mining {
     const ActorId mid = miner_address_.getId();
     // TODO maybe long (AggregateSealProofs)
 
-    // TODO params.proof = proof_->AggregateSealProofs(); // OUTCOME_TRY
-    OUTCOME_TRY(a, proof_->AggregateSealProofs());
-
-    auto enc = codec::cbor::encode(params);
+    AggregateSealVerifyProofAndInfos aggregate_seal =
+        AggregateSealVerifyProofAndInfos{
+            .miner = mid,
+            .seal_proof =
+                union_storage_for_send[infos[0].number].aggregate_input.spt,
+            .aggregate_proof = arp_,
+            .proof = proofs[infos[0].number],  // TODO is it correct?
+            .infos = infos};
+
+    OUTCOME_TRY(proof_->aggregateSealProofs(aggregate_seal, proofs));
+    // need:    std::vector<gsl::span<const uint8_t>>
+    // proofs:  std::vector<std::vector<uint8_t>>
+    // proof:   std::vector<uint8_t>
+    // BytesIn: gsl::span<const uint8_t>;
+
+    // proofs: std::vector<std::vector<uint8_t>>
+    auto b = gsl::make_span(proofs);
+    params.proof = aggregate_seal.proof;
+    OUTCOME_TRY(enc, codec::cbor::encode(params));
     OUTCOME_TRY(mi, api_->StateMinerInfo(miner_address_, head->key));
 
-    // 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(ts, api_->ChainGetTipSet(head->key));
+    const BigInt bf = ts->blks[0].parent_base_fee;
 
-    // TODO OUTCOME_TRY(bf, api_->ChainBaseFee(head));
     OUTCOME_TRY(nv, api_->StateNetworkVersion(head->key));
+
+    TokenAmount agg_fee_raw = AggregateProveCommitNetworkFee(infos.size(), bf);
+
+    TokenAmount agg_fee = bigdiv(agg_fee_raw * agg_fee_num_, agg_fee_den_);
+    TokenAmount need_funds = collateral + agg_fee;
+    TokenAmount good_funds = max_fee + need_funds;
+
+    OUTCOME_TRY(address, address_selector_(mi, good_funds, need_funds, api_));
+    OUTCOME_TRY(mcid,
+                api_->MpoolPushMessage(
+                    vm::message::UnsignedMessage(miner_address_,
+                                                 address,
+                                                 0,
+                                                 need_funds,
+                                                 max_fee,
+                                                 {},
+                                                 ProveCommitAggregate::Number,
+                                                 MethodParams{enc}),
+                    kPushNoSpec));
+
+    cutoff_start_ = std::chrono::system_clock::now();
+    return mcid.getCid();
   }
 
   void CommitBatcherImpl::setCommitCutoff(const ChainEpoch &current_epoch,

core/miner/storage_fsm/impl/commit_batcher_impl.hpp

@@ -8,15 +8,23 @@
 #include "miner/storage_fsm/commit_batcher.hpp"
 
 namespace fc::mining {
-
+  using api::MinerInfo;
   using libp2p::basic::Scheduler;
+  using primitives::BigInt;
   using primitives::SectorNumber;
   using primitives::address::Address;
+  using primitives::sector::RegisteredAggregationProof;
   using primitives::tipset::Tipset;
   using primitives::tipset::TipsetKey;
   using proofs::ProofEngine;
   using types::FeeConfig;
 
+  using AddressSelector = std::function<outcome::result<Address>(
+      const MinerInfo &miner_info,
+      const TokenAmount &good_funds,
+      const TokenAmount &need_funds,
+      const std::shared_ptr<FullNodeApi> &api)>;
+
   class CommitBatcherImpl : public CommitBatcher {
    public:
     struct PairStorage {
@@ -51,6 +59,11 @@ namespace fc::mining {
     std::shared_ptr<FeeConfig> fee_config_;
     std::shared_ptr<ProofEngine> proof_;
     std::mutex mutex_storage_;
+    AddressSelector address_selector_;
+
+    const BigInt agg_fee_num_ = BigInt(110);
+    const BigInt agg_fee_den_ = BigInt(100);
+    const RegisteredAggregationProof arp_ = RegisteredAggregationProof(0);
 
     void sendCallbacks();
 

core/vm/actor/builtin/v6/monies.hpp

@@ -0,0 +1,26 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+namespace fc::vm::actor::builtin::v6::miner {
+  using primitives::BigInt;
+
+  const BigInt kEstimatedSingleProveCommitGasUsage = 49299973;
+  const BigInt kEstimatedSinglePreCommitGasUsage = 16433324;
+  const BigInt kBatchDiscountNumerator = 1;
+  const BigInt kBatchDiscountDenominator = 20;
+  const BigInt kBatchBalancer = 5 * kOneNanoFil;
+
+  TokenAmount AggregateProveCommitNetworkFee(uint64_t aggregate_size,
+                                             const TokenAmount &base_fee) {
+    const TokenAmount effectiveGasFee = std::max(base_fee, kBatchBalancer);
+    const TokenAmount networkFeeNum =
+        effectiveGasFee * kEstimatedSinglePreCommitGasUsage * aggregate_size
+        * kBatchDiscountNumerator;
+    return bigdiv(networkFeeNum, kBatchDiscountDenominator);
+  }
+
+}  // namespace fc::vm::actor::builtin::v6::miner