pbft WIP(8) block commission (fees) go into PBFT contract. Restored block balance formula.

Author: valdok

core/block_validation.cpp

@@ -247,47 +247,40 @@ namespace beam
 	{
 		const auto& r = Rules::get();
 
-		AmountBig::Number subsTotal;
+		AmountBig::Number subsidy = Zero;
 
 		bool bPbft = (Rules::Consensus::Pbft == r.m_Consensus);
 		if (bPbft)
-			subsTotal = m_Stats.m_Fee; // the value subtracted from the circulation
+		{
+			if (m_Stats.m_Coinbase != Zero)
+				Exc::Fail("Coinbase in pbft");
+		}
 		else
 		{
-			r.get_Emission(subsTotal, m_Height);
+			r.get_Emission(subsidy, m_Height);
 			m_Sigma = -m_Sigma;
+
+			AmountBig::AddTo(m_Sigma, subsidy);
 		}
 
-		AmountBig::AddTo(m_Sigma, subsTotal);
 		TestSigma();
 
-		if (!m_Params.m_bAllowUnsignedOutputs)
+		if (!m_Params.m_bAllowUnsignedOutputs && !bPbft)
 		{
 			bool bHasEnoughLocked = true;
 			bool bShortRange = (m_Height.m_Max - m_Height.m_Min < r.Maturity.Coinbase); // All the supposed coinbase UTXOs must be included (i.e. couldn't be spent and cut-through)
 
-			if (bPbft)
-			{
-				if (bShortRange)
-					bHasEnoughLocked = (m_Stats.m_Coinbase == Zero);
-
-				// for long range we don't really know which part of the coinbase could be spent already, hence we omit this verification
-			}
+			if (bShortRange)
+				bHasEnoughLocked = (m_Stats.m_Coinbase == subsidy);
 			else
 			{
-				if (bShortRange)
-					bHasEnoughLocked = (m_Stats.m_Coinbase == subsTotal);
-				else
-				{
-					// calculate the minimum coinbase value that's supposed still to be locked
-					HeightRange hr;
-					hr.m_Min = m_Height.m_Max - r.Maturity.Coinbase;
-					hr.m_Max = m_Height.m_Max;
-					r.get_Emission(subsTotal, hr);
+				// calculate the minimum coinbase value that's supposed still to be locked
+				HeightRange hr;
+				hr.m_Min = m_Height.m_Max - r.Maturity.Coinbase;
+				hr.m_Max = m_Height.m_Max;
+				r.get_Emission(subsidy, hr);
 
-					bHasEnoughLocked = (m_Stats.m_Coinbase >= subsTotal);
-
-				}
+				bHasEnoughLocked = (m_Stats.m_Coinbase >= subsidy);
 			}
 
 			if (!bHasEnoughLocked)

node/node.cpp

@@ -4597,6 +4597,11 @@ const Block::Pbft::State::IValidatorSet* Node::Processor::get_Validators()
 	return &get_ParentObj().m_Validator.m_ValidatorSet;
 }
 
+TxKernel::Ptr Node::Processor::GeneratePbftRewardKernel(Amount fees, ECC::Scalar::Native& sk)
+{
+	return get_ParentObj().m_Validator.GeneratePbftRewardKernel(fees, sk);
+}
+
 void Node::Server::OnAccepted(io::TcpStream::Ptr&& newStream, int errorCode)
 {
 	if (newStream)
@@ -6114,6 +6119,31 @@ void Node::Validator::OnContractVarChange(const Blob& key, const Blob& val, bool
 	pV->m_Flags = vd.m_Flags;
 }
 
+TxKernel::Ptr Node::Validator::GeneratePbftRewardKernel(Amount fees, ECC::Scalar::Native& sk)
+{
+	if (!m_cid)
+		return nullptr; // shouldn't happen though
+
+	using namespace Shaders::PBFT;
+
+	auto pKrn = std::make_unique<TxKernelContractInvoke>();
+	pKrn->m_Cid = *m_cid;
+	pKrn->m_iMethod = Method::AddReward::s_iMethod;
+
+	pKrn->m_Args.resize(sizeof(Method::AddReward));
+	auto& r = *(Method::AddReward*) &pKrn->m_Args.front();
+	r.m_Amount = ByteOrder::to_le(fees);
+
+	pKrn->m_Height.m_Min = get_ParentObj().m_Processor.m_Cursor.m_hh.m_Height + m_iRound + 1;
+
+	ECC::Point::Native ptFunds = ECC::Context::get().H * fees;
+
+	sk = get_ParentObj().m_Keys.m_Validator.m_sk;
+	pKrn->Sign(&sk, 1, ptFunds, nullptr);
+
+	return pKrn;
+}
+
 bool Node::Validator::ValidatorSet::EnumValidators(ITarget& x) const
 {
 	for (const auto& v : m_mapValidators)

node/node.h

@@ -264,6 +264,7 @@ struct Node
 		void OnContractVarChange(const Blob& key, const Blob& val, bool bTemporary) override;
 		void OnContractStoreReset() override;
 		const Block::Pbft::State::IValidatorSet* get_Validators() override;
+		TxKernel::Ptr GeneratePbftRewardKernel(Amount fees, ECC::Scalar::Native& sk) override;
 
 		void Stop();
 
@@ -810,6 +811,7 @@ struct Node
 		void SendState(Peer&) const;
 		void OnContractVarChange(const Blob& key, const Blob& val, bool bTemporary);
 		void OnContractStoreReset();
+		TxKernel::Ptr GeneratePbftRewardKernel(Amount fees, ECC::Scalar::Native& sk);
 
 		uint64_t get_RefTime_ms() const;
 

node/processor.cpp

@@ -562,6 +562,11 @@ const Block::Pbft::State::IValidatorSet* NodeProcessor::get_Validators()
 	return nullptr;
 }
 
+TxKernel::Ptr NodeProcessor::GeneratePbftRewardKernel(Amount fees, ECC::Scalar::Native& sk)
+{
+	return nullptr;
+}
+
 NodeProcessor::CongestionCache::TipCongestion* NodeProcessor::CongestionCache::Find(const NodeDB::StateID& sid)
 {
 	TipCongestion* pRet = nullptr;
@@ -7297,27 +7302,41 @@ size_t NodeProcessor::GenerateNewBlockInternal(BlockContext& bc, BlockInterpretC
 		}
 	}
 
-	if (Rules::Consensus::Pbft != r.m_Consensus)
+	if (!m_nReserveBlockSizeForFees)
 	{
-		// estimate the size of the fees UTXO
-		if (!m_nSizeUtxoComissionUpperLimit)
+		SerializerSizeCounter ssc2;
+
+		if (Rules::Consensus::Pbft != r.m_Consensus)
 		{
+			// size of extra UTXO
 			Output outp;
 			outp.m_pConfidential.reset(new ECC::RangeProof::Confidential);
 			ZeroObject(*outp.m_pConfidential);
 			outp.m_pAsset = std::make_unique<Asset::Proof>();
 			outp.m_pAsset->InitArrays(r.CA.m_ProofCfg);
 			outp.m_pAsset->m_Begin = static_cast<Asset::ID>(-1);
 
-			SerializerSizeCounter ssc2;
 			ssc2 & outp;
-			m_nSizeUtxoComissionUpperLimit = ssc2.m_Counter.m_Value;
+		}
+		else
+		{
+			// size of extra kernel
+			TxKernelContractInvoke krn;
+			krn.m_Height.m_Min = MaxHeight;
+			krn.m_Commitment = Zero;
+			ZeroObject(krn.m_Signature);
+			krn.m_iMethod = std::numeric_limits<uint32_t>::max();
+			krn.m_Args.resize(100); // excessive
+
+			ssc2 & krn;
 		}
 
-		if (bc.m_Fees)
-			ssc.m_Counter.m_Value += m_nSizeUtxoComissionUpperLimit;
+		m_nReserveBlockSizeForFees = ssc2.m_Counter.m_Value;
 	}
 
+	if (bc.m_Fees)
+		ssc.m_Counter.m_Value += m_nReserveBlockSizeForFees;
+
 	const size_t nSizeMax = r.MaxBodySize;
 	if (ssc.m_Counter.m_Value > nSizeMax)
 	{
@@ -7351,8 +7370,8 @@ size_t NodeProcessor::GenerateNewBlockInternal(BlockContext& bc, BlockInterpretC
 
 
 		size_t nSizeNext = ssc.m_Counter.m_Value + nSize;
-		if (!bc.m_Fees && feesNext && (Rules::Consensus::Pbft != r.m_Consensus))
-			nSizeNext += m_nSizeUtxoComissionUpperLimit;
+		if (!bc.m_Fees && feesNext)
+			nSizeNext += m_nReserveBlockSizeForFees;
 
 		if (nSizeNext > nSizeMax)
 			break;
@@ -7383,8 +7402,8 @@ size_t NodeProcessor::GenerateNewBlockInternal(BlockContext& bc, BlockInterpretC
 			continue; // huge fees are unsupported
 
 		size_t nSizeNext = ssc.m_Counter.m_Value + x.m_Profit.m_Stats.m_Size;
-		if (!bc.m_Fees && feesNext && (Rules::Consensus::Pbft != r.m_Consensus))
-			nSizeNext += m_nSizeUtxoComissionUpperLimit;
+		if (!bc.m_Fees && feesNext)
+			nSizeNext += m_nReserveBlockSizeForFees;
 
 		if (nSizeNext > nSizeMax)
 		{
@@ -7434,24 +7453,42 @@ size_t NodeProcessor::GenerateNewBlockInternal(BlockContext& bc, BlockInterpretC
 
 	if (BlockContext::Mode::Assemble != bc.m_Mode)
 	{
-		if (bc.m_Fees && (Rules::Consensus::Pbft != r.m_Consensus))
+		if (bc.m_Fees)
 		{
+			// make size estimation more precise
+			size_t n0 = ssc.m_Counter.m_Value;
+			ssc.m_Counter.m_Value -= m_nReserveBlockSizeForFees;
+
+			if (Rules::Consensus::Pbft != r.m_Consensus)
 			{
-				Asset::Proof::Params::Override po(get_AidMax());
-				bb.AddFees(bc.m_Fees, pOutp);
+				{
+					Asset::Proof::Params::Override po(get_AidMax());
+					bb.AddFees(bc.m_Fees, pOutp);
+				}
+
+				if (!HandleBlockElement(*pOutp, bic))
+					return 0;
+
+				ssc & (*pOutp);
+				bc.m_Block.m_vOutputs.push_back(std::move(pOutp));
 			}
+			else
+			{
+				pKrn = GeneratePbftRewardKernel(bc.m_Fees, bb.m_Offset);
+				if (!pKrn)
+					return 0;
 
-			if (!HandleBlockElement(*pOutp, bic))
-				return 0;
+				if (!HandleBlockElement(*pKrn, bic))
+					return 0;
+
+				yas::detail::SaveKrn(ssc, *pKrn, false);
+
+				bc.m_Block.m_vKernels.push_back(std::move(pKrn));
+			}
 
-			// make size estimation more precise
-			size_t n0 = ssc.m_Counter.m_Value;
-			ssc.m_Counter.m_Value -= m_nSizeUtxoComissionUpperLimit;
-			ssc& (*pOutp);
 			assert(ssc.m_Counter.m_Value <= n0);
 			(n0); // suppress 'unused' warning in release build
 
-			bc.m_Block.m_vOutputs.push_back(std::move(pOutp));
 		}
 
 		bb.m_Offset = -bb.m_Offset;

node/processor.h

@@ -129,7 +129,7 @@ class NodeProcessor
 
 	Mapped m_Mapped;
 
-	size_t m_nSizeUtxoComissionUpperLimit = 0;
+	size_t m_nReserveBlockSizeForFees = 0;
 
 	struct InputAux {
 		TxoID m_ID = 0;
@@ -592,6 +592,7 @@ class NodeProcessor
 	virtual void OnContractVarChange(const Blob& key, const Blob& val, bool bTemporary);
 	virtual void OnContractStoreReset();
 	virtual const Block::Pbft::State::IValidatorSet* get_Validators();
+	virtual TxKernel::Ptr GeneratePbftRewardKernel(Amount fees, ECC::Scalar::Native& sk);
 
 	struct MyExecutor
 		:public Executor