// Copyright (c) 2022 The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <node/mempool_args.h>

#include <kernel/mempool_limits.h>

#include <kernel/mempool_options.h>

#include <common/args.h>

#include <common/messages.h>

#include <consensus/amount.h>

#include <kernel/chainparams.h>

#include <logging.h>

#include <policy/feerate.h>

#include <policy/policy.h>

#include <tinyformat.h>

#include <util/moneystr.h>

#include <util/translation.h>

#include <chrono>

#include <memory>

using common::AmountErrMsg;

using kernel::MemPoolLimits;

using kernel::MemPoolOptions;

namespace {

void ApplyArgsManOptions(const ArgsManager& argsman, MemPoolLimits& mempool_limits)

{

    mempool_limits.ancestor_count = argsman.GetIntArg("-limitancestorcount", mempool_limits.ancestor_count);

    if (auto vkb = argsman.GetIntArg("-limitancestorsize")) mempool_limits.ancestor_size_vbytes = *vkb * 1'000;

  Branch (33:14): [True: 0, False: 22.1k]

    mempool_limits.descendant_count = argsman.GetIntArg("-limitdescendantcount", mempool_limits.descendant_count);

    if (auto vkb = argsman.GetIntArg("-limitdescendantsize")) mempool_limits.descendant_size_vbytes = *vkb * 1'000;

  Branch (37:14): [True: 0, False: 22.1k]

}

}

util::Result<void> ApplyArgsManOptions(const ArgsManager& argsman, const CChainParams& chainparams, MemPoolOptions& mempool_opts)

{

    mempool_opts.check_ratio = argsman.GetIntArg("-checkmempool", mempool_opts.check_ratio);

    if (auto mb = argsman.GetIntArg("-maxmempool")) mempool_opts.max_size_bytes = *mb * 1'000'000;

  Branch (45:14): [True: 22.1k, False: 0]

    if (auto hours = argsman.GetIntArg("-mempoolexpiry")) mempool_opts.expiry = std::chrono::hours{*hours};

  Branch (47:14): [True: 0, False: 22.1k]

    // incremental relay fee sets the minimum feerate increase necessary for replacement in the mempool

    // and the amount the mempool min fee increases above the feerate of txs evicted due to mempool limiting.

    if (const auto arg{argsman.GetArg("-incrementalrelayfee")}) {

  Branch (51:20): [True: 0, False: 22.1k]

        if (std::optional<CAmount> inc_relay_fee = ParseMoney(*arg)) {

  Branch (52:36): [True: 0, False: 0]

            mempool_opts.incremental_relay_feerate = CFeeRate{inc_relay_fee.value()};

        } else {

            return util::Error{AmountErrMsg("incrementalrelayfee", *arg)};

        }

    }

    if (const auto arg{argsman.GetArg("-minrelaytxfee")}) {

  Branch (59:20): [True: 0, False: 22.1k]

        if (std::optional<CAmount> min_relay_feerate = ParseMoney(*arg)) {

  Branch (60:36): [True: 0, False: 0]

            // High fee check is done afterward in CWallet::Create()

            mempool_opts.min_relay_feerate = CFeeRate{min_relay_feerate.value()};

        } else {

            return util::Error{AmountErrMsg("minrelaytxfee", *arg)};

        }

    } else if (mempool_opts.incremental_relay_feerate > mempool_opts.min_relay_feerate) {

  Branch (66:16): [True: 0, False: 22.1k]

        // Allow only setting incremental fee to control both

        mempool_opts.min_relay_feerate = mempool_opts.incremental_relay_feerate;

        LogPrintf("Increasing minrelaytxfee to %s to match incrementalrelayfee\n", mempool_opts.min_relay_feerate.ToString());

    }

    // Feerate used to define dust.  Shouldn't be changed lightly as old

    // implementations may inadvertently create non-standard transactions

    if (const auto arg{argsman.GetArg("-dustrelayfee")}) {

  Branch (74:20): [True: 0, False: 22.1k]

        if (std::optional<CAmount> parsed = ParseMoney(*arg)) {

  Branch (75:36): [True: 0, False: 0]

            mempool_opts.dust_relay_feerate = CFeeRate{parsed.value()};

        } else {

            return util::Error{AmountErrMsg("dustrelayfee", *arg)};

        }

    }

    mempool_opts.permit_bare_multisig = argsman.GetBoolArg("-permitbaremultisig", DEFAULT_PERMIT_BAREMULTISIG);

    if (argsman.GetBoolArg("-datacarrier", DEFAULT_ACCEPT_DATACARRIER)) {

  Branch (84:9): [True: 22.1k, False: 0]

        mempool_opts.max_datacarrier_bytes = argsman.GetIntArg("-datacarriersize", MAX_OP_RETURN_RELAY);

    } else {

        mempool_opts.max_datacarrier_bytes = std::nullopt;

    }

    mempool_opts.require_standard = !argsman.GetBoolArg("-acceptnonstdtxn", DEFAULT_ACCEPT_NON_STD_TXN);

    if (!chainparams.IsTestChain() && !mempool_opts.require_standard) {

  Branch (91:9): [True: 0, False: 22.1k]
  Branch (91:39): [True: 0, False: 0]

        return util::Error{Untranslated(strprintf("acceptnonstdtxn is not currently supported for %s chain", chainparams.GetChainTypeString()))};

    }

    mempool_opts.persist_v1_dat = argsman.GetBoolArg("-persistmempoolv1", mempool_opts.persist_v1_dat);

    ApplyArgsManOptions(argsman, mempool_opts.limits);

    return {};

}