X-Git-Url: https://git.novaco.in/?p=NovacoinLibrary.git;a=blobdiff_plain;f=Novacoin%2FCTransaction.cs;h=e0630aacc4ba5d21b91575fcc3aa18e2fb0ac018;hp=292a3f4a12081cb898e7d95a37fa1add876e9c9f;hb=45e1fafb7ee2f8024000bf470367849a5eb78261;hpb=c5c813f88fd93f2360d503f7165cdbcc97189459 diff --git a/Novacoin/CTransaction.cs b/Novacoin/CTransaction.cs index 292a3f4..e0630aa 100644 --- a/Novacoin/CTransaction.cs +++ b/Novacoin/CTransaction.cs @@ -1,226 +1,687 @@ -using System; +/** + * Novacoin classes library + * Copyright (C) 2015 Alex D. (balthazar.ad@gmail.com) + + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +using System; using System.Text; using System.Collections.Generic; +using System.IO; +using System.Diagnostics.Contracts; +using System.Numerics; namespace Novacoin { - /// - /// Represents the transaction. Any transaction must provide one input and one output at least. - /// - public class CTransaction - { - /// - /// Version of transaction schema. - /// - public uint nVersion = 1; - - /// - /// Transaction timestamp. - /// - public uint nTime = 0; - - /// - /// Array of transaction inputs - /// - public CTxIn[] inputs; - - /// - /// Array of transaction outputs - /// - public CTxOut[] outputs; - - /// - /// Block height or timestamp when transaction is final - /// - public uint nLockTime = 0; + [Serializable] + public class TransactionConstructorException : Exception + { + public TransactionConstructorException() + { + } + + public TransactionConstructorException(string message) + : base(message) + { + } + + public TransactionConstructorException(string message, Exception inner) + : base(message, inner) + { + } + } + + /// + /// Represents the transaction. + /// + public class CTransaction + { + /// + /// One cent = 10000 satoshis. + /// + public const ulong nCent = 10000; + + /// + /// One coin = 1000000 satoshis. + /// + public const ulong nCoin = 1000000; + + /// + /// Sanity checking threshold. + /// + public const ulong nMaxMoney = 2000000000 * nCoin; + + public const ulong nMinTxFee = nCent / 10; + public const ulong nMinRelayTxFee = nCent / 50; + public const ulong nMinTxoutAmount = nCent / 100; + + /// + /// Maximum transaction size is 250Kb + /// + public const uint nMaxTxSize = 250000; + + public enum MinFeeMode + { + GMF_BLOCK, + GMF_RELAY, + GMF_SEND, + } + + /// + /// Version of transaction schema. + /// + public uint nVersion; + + /// + /// Transaction timestamp. + /// + public uint nTime; + + /// + /// Array of transaction inputs + /// + public CTxIn[] vin; + + /// + /// Array of transaction outputs + /// + public CTxOut[] vout; + + /// + /// Block height or timestamp when transaction is final + /// + public uint nLockTime; /// /// Initialize an empty instance /// public CTransaction() { + // Initialize empty input and output arrays. Please note that such + // configuration is not valid for real transaction, you have to supply + // at least one input and one output. + nVersion = 1; + nTime = 0; + vin = new CTxIn[0]; + vout = new CTxOut[0]; + nLockTime = 0; } /// - /// Parse byte sequence and initialize new instance of CTransaction + /// Initialize new instance as a copy of another transaction /// - /// - public CTransaction (IList txBytes) - { - WrappedList wBytes = new WrappedList(txBytes); - - nVersion = Interop.LEBytesToUInt32(wBytes.GetItems(4)); - nTime = Interop.LEBytesToUInt32(wBytes.GetItems(4)); + /// Transaction to copy from + public CTransaction(CTransaction tx) + { + nVersion = tx.nVersion; + nTime = tx.nTime; - int nInputs = (int)VarInt.ReadVarInt(ref wBytes); - inputs = new CTxIn[nInputs]; + vin = new CTxIn[tx.vin.Length]; - for (int nCurrentInput = 0; nCurrentInput < nInputs; nCurrentInput++) + for (int i = 0; i < vin.Length; i++) { - // Fill inputs array - inputs[nCurrentInput] = new CTxIn(); + vin[i] = new CTxIn(tx.vin[i]); + } + + vout = new CTxOut[tx.vout.Length]; - inputs[nCurrentInput].txID = new Hash256(wBytes.GetItems(32)); - inputs[nCurrentInput].n = Interop.LEBytesToUInt32(wBytes.GetItems(4)); - inputs[nCurrentInput].scriptSig = wBytes.GetItems((int)VarInt.ReadVarInt(ref wBytes)); - inputs[nCurrentInput].nSequence = Interop.LEBytesToUInt32(wBytes.GetItems(4)); + for (int i = 0; i < vout.Length; i++) + { + vout[i] = new CTxOut(tx.vout[i]); } - int nOutputs = (int)VarInt.ReadVarInt(ref wBytes); - outputs = new CTxOut[nOutputs]; + nLockTime = tx.nLockTime; + } - for (int nCurrentOutput = 0; nCurrentOutput < nOutputs; nCurrentOutput++) + /// + /// Attempts to execute all transaction scripts and validate the results. + /// + /// Checking result. + public bool VerifyScripts() + { + if (IsCoinBase) { - // Fill outputs array - outputs[nCurrentOutput] = new CTxOut(); - outputs[nCurrentOutput].nValue = Interop.LEBytesToUInt64(wBytes.GetItems(8)); - outputs[nCurrentOutput].scriptPubKey = wBytes.GetItems((int)VarInt.ReadVarInt(ref wBytes)); + return true; } - nLockTime = Interop.LEBytesToUInt32(wBytes.GetItems(4)); - } + TxOutItem txOutCursor = null; + for (int i = 0; i < vin.Length; i++) + { + var outpoint = vin[i].prevout; + + if (!CBlockStore.Instance.GetTxOutCursor(outpoint, ref txOutCursor)) + return false; + + if (!ScriptCode.VerifyScript(vin[i].scriptSig, txOutCursor.scriptPubKey, this, i, (int)scriptflag.SCRIPT_VERIFY_P2SH, 0)) + return false; + } + + return true; + } /// - /// Parse transactions array which is encoded in the block body. + /// Calculate amount of signature operations without trying to properly evaluate P2SH scripts. /// - /// Bytes sequence - /// Transactions array - public static CTransaction[] ParseTransactionsList(ref WrappedList wTxBytes) + public uint LegacySigOpCount + { + get + { + uint nSigOps = 0; + foreach (var txin in vin) + { + nSigOps += txin.scriptSig.GetSigOpCount(false); + } + foreach (var txout in vout) + { + nSigOps += txout.scriptPubKey.GetSigOpCount(false); + } + + return nSigOps; + } + } + + /// + /// Basic sanity checkings + /// + /// Checking result + public bool CheckTransaction() { - CTransaction[] tx; - - // Read amount of transactions - int nTransactions = (int) VarInt.ReadVarInt(ref wTxBytes); - tx = new CTransaction[nTransactions]; + if (Size > nMaxTxSize || vin.Length == 0 || vout.Length == 0) + { + return false; + } + + // Check for empty or overflow output values + ulong nValueOut = 0; + for (int i = 0; i < vout.Length; i++) + { + CTxOut txout = vout[i]; + if (txout.IsEmpty && !IsCoinBase && !IsCoinStake) + { + // Empty outputs aren't allowed for user transactions. + return false; + } + + nValueOut += txout.nValue; + if (!MoneyRange(nValueOut)) + { + return false; + } + } - for (int nTx = 0; nTx < nTransactions; nTx++) + // Check for duplicate inputs + var InOutPoints = new List(); + foreach (var txin in vin) { - // Fill the transactions array - tx[nTx] = new CTransaction(); + if (InOutPoints.IndexOf(txin.prevout) != -1) + { + // Duplicate input. + return false; + } + InOutPoints.Add(txin.prevout); + } - tx[nTx].nVersion = Interop.LEBytesToUInt32(wTxBytes.GetItems(4)); - tx[nTx].nTime = Interop.LEBytesToUInt32(wTxBytes.GetItems(4)); + if (IsCoinBase) + { + if (vin[0].scriptSig.Size < 2 || vin[0].scriptSig.Size > 100) + { + // Script size is invalid + return false; + } + } + else + { + foreach (var txin in vin) + { + if (txin.prevout.IsNull) + { + // Null input in non-coinbase transaction. + return false; + } + } + } - int nInputs = (int)VarInt.ReadVarInt(ref wTxBytes); - tx[nTx].inputs = new CTxIn[nInputs]; + return true; + } + + public bool IsFinal(uint nBlockHeight = 0, uint nBlockTime = 0) + { + // Time based nLockTime + if (nLockTime == 0) + { + return true; + } + if (nBlockHeight == 0) + { + nBlockHeight = uint.MaxValue; // TODO: stupid stub here, should be best height instead. + } + if (nBlockTime == 0) + { + nBlockTime = NetInfo.GetAdjustedTime(); + } + if (nLockTime < (nLockTime < NetInfo.nLockTimeThreshold ? nBlockHeight : nBlockTime)) + { + return true; + } + foreach (var txin in vin) + { + if (!txin.IsFinal) + { + return false; + } + } + return true; + } + + /// + /// Parse byte sequence and initialize new instance of CTransaction + /// + /// Byte sequence + public CTransaction(byte[] txBytes) + { + try + { + var stream = new MemoryStream(txBytes); + var reader = new BinaryReader(stream); + + nVersion = reader.ReadUInt32(); + nTime = reader.ReadUInt32(); + + int nInputs = (int)VarInt.ReadVarInt(ref reader); + vin = new CTxIn[nInputs]; for (int nCurrentInput = 0; nCurrentInput < nInputs; nCurrentInput++) { // Fill inputs array - tx[nTx].inputs[nCurrentInput] = new CTxIn(); + vin[nCurrentInput] = new CTxIn(); + + vin[nCurrentInput].prevout = new COutPoint(reader.ReadBytes(36)); + + int nScriptSigLen = (int)VarInt.ReadVarInt(ref reader); + vin[nCurrentInput].scriptSig = new CScript(reader.ReadBytes(nScriptSigLen)); - tx[nTx].inputs[nCurrentInput].txID = new Hash256(wTxBytes.GetItems(32)); - tx[nTx].inputs[nCurrentInput].n = Interop.LEBytesToUInt32(wTxBytes.GetItems(4)); - tx[nTx].inputs[nCurrentInput].scriptSig = wTxBytes.GetItems((int)VarInt.ReadVarInt(ref wTxBytes)); - tx[nTx].inputs[nCurrentInput].nSequence = Interop.LEBytesToUInt32(wTxBytes.GetItems(4)); + vin[nCurrentInput].nSequence = reader.ReadUInt32(); } - int nOutputs = (int)VarInt.ReadVarInt(ref wTxBytes); - tx[nTx].outputs = new CTxOut[nOutputs]; + int nOutputs = (int)VarInt.ReadVarInt(ref reader); + vout = new CTxOut[nOutputs]; for (int nCurrentOutput = 0; nCurrentOutput < nOutputs; nCurrentOutput++) { // Fill outputs array - tx[nTx].outputs[nCurrentOutput] = new CTxOut(); - tx[nTx].outputs[nCurrentOutput].nValue = Interop.LEBytesToUInt64(wTxBytes.GetItems(8)); - tx[nTx].outputs[nCurrentOutput].scriptPubKey = wTxBytes.GetItems((int)VarInt.ReadVarInt(ref wTxBytes)); + vout[nCurrentOutput] = new CTxOut(); + vout[nCurrentOutput].nValue = reader.ReadUInt64(); + + int nScriptPKLen = (int)VarInt.ReadVarInt(ref reader); + vout[nCurrentOutput].scriptPubKey = new CScript(reader.ReadBytes(nScriptPKLen)); } - tx[nTx].nLockTime = Interop.LEBytesToUInt32(wTxBytes.GetItems(4)); + nLockTime = reader.ReadUInt32(); } + catch (Exception e) + { + throw new TransactionConstructorException("Deserialization failed", e); + } + } - return tx; + /// + /// Serialized size + /// + public uint Size + { + get + { + uint nSize = 12; // nVersion, nTime, nLockLime + + nSize += VarInt.GetEncodedSize(vin.Length); + nSize += VarInt.GetEncodedSize(vout.Length); + + foreach (var input in vin) + { + nSize += input.Size; + } + + foreach (var output in vout) + { + nSize += output.Size; + } + + return nSize; + } } - IList ToBytes() + /// + /// Read transactions array which is encoded in the block body. + /// + /// Bytes sequence + /// Transactions array + internal static CTransaction[] ReadTransactionsList(ref BinaryReader reader) { - List resultBytes = new List(); + try + { + // Read amount of transactions + int nTransactions = (int)VarInt.ReadVarInt(ref reader); + var tx = new CTransaction[nTransactions]; - // Typical transaction example: - // - // 01000000 -- version - // 78b4c953 -- timestamp - // 06 -- amount of txins - // 340d96b77ec4ee9d42b31cadc2fab911e48d48c36274d516f226d5e85bbc512c -- txin hash - // 01000000 -- txin outnumber - // 6b -- txin scriptSig length - // 483045022100c8df1fc17b6ea1355a39b92146ec67b3b53565e636e028010d3a8a87f6f805f202203888b9b74df03c3960773f2a81b2dfd1efb08bb036a8f3600bd24d5ed694cd5a0121030dd13e6d3c63fa10cc0b6bf968fbbfcb9a988b333813b1f22d04fa60e344bc4c -- txin scriptSig - // ffffffff -- txin nSequence - // 364c640420de8fa77313475970bf09ce4d0b1f8eabb8f1d6ea49d90c85b202ee -- txin hash - // 01000000 -- txin outnumber - // 6b -- txin scriptSig length - // 483045022100b651bf3a6835d714d2c990c742136d769258d0170c9aac24803b986050a8655b0220623651077ff14b0a9d61e30e30f2c15352f70491096f0ec655ae1c79a44e53aa0121030dd13e6d3c63fa10cc0b6bf968fbbfcb9a988b333813b1f22d04fa60e344bc4c -- txin scriptSig - // ffffffff -- txin nSequence - // 7adbd5f2e521f567bfea2cb63e65d55e66c83563fe253464b75184a5e462043d -- txin hash - // 00000000 -- txin outnumber - // 6a -- txin scriptSig length - // 4730440220183609f2b995993acc9df241aff722d48b9a731b0cd376212934565723ed81f00220737e7ce75ef39bdc061d0dcdba3ee24e43b899696a7c96803cee0a79e1f78ecb0121030dd13e6d3c63fa10cc0b6bf968fbbfcb9a988b333813b1f22d04fa60e344bc4c -- txin scriptSig - // ffffffff -- txin nSequence - // 999eb03e00a41c2f9fde8865a554ceebbc48d30f4c8ba22dd88da8c9b46fa920 -- txin hash - // 03000000 -- txin outnumber - // 6b -- txin scriptSig length - // 483045022100ec1ab104ef086ba79b0f2611ebf1bfdd22a7a1020f6630fa1c6707546626e0db022056093d4048a999392185ccc735ef736a5497bd68f60b42e6c0c93ba770b54d010121030dd13e6d3c63fa10cc0b6bf968fbbfcb9a988b333813b1f22d04fa60e344bc4c -- txin scriptSig - // ffffffff -- txin nSequence - // c0543b86be257ddd85b014a76718a70fab9eaa3c477460e4ca187094d86f369c -- txin hash - // 05000000 -- txin outnumber - // 69 -- txin scriptSig length - // 463043021f24275c72f952043174daf01d7f713f878625f0522124a3cab48a0a2e12604202201b47742e6697b0ebdd1e4ba49c74baf142a0228ad0e0ee847488994c9dce78470121030dd13e6d3c63fa10cc0b6bf968fbbfcb9a988b333813b1f22d04fa60e344bc4c -- txin scriptSig - // ffffffff -- txin nSequence - // e1793d4519147782293dd1db6d90e461265d91db2cc6889c37209394d42ad10d -- txin hash - // 05000000 -- txin outnumber - // 6a -- txin scriptSig length - // 473044022018a0c3d73b2765d75380614ab36ee8e3c937080894a19166128b1e3357b208fb0220233c9609985f535547381431526867ad0255ec4969afe5c360544992ed6b3ed60121030dd13e6d3c63fa10cc0b6bf968fbbfcb9a988b333813b1f22d04fa60e344bc4c -- txin scriptSig - // ffffffff -- txin nSequence - // 02 -- amount of txouts - // e542000000000000 -- txout value - // 19 -- scriptPubKey length - // 76a91457d84c814b14bd86bf32f106b733baa693db7dc788ac -- scriptPubKey - // 409c000000000000 -- txout value - // 19 -- scriptPubKey length - // 76a91408c8768d5d6bf7c1d9609da4e766c3f1752247b188ac -- scriptPubKey - // 00000000 -- lock time - - resultBytes.AddRange(Interop.LEBytes(nVersion)); - resultBytes.AddRange(Interop.LEBytes(nTime)); - resultBytes.AddRange(VarInt.EncodeVarInt(inputs.LongLength)); - - foreach(CTxIn input in inputs) - { - resultBytes.AddRange(input.ToBytes()); - } - - resultBytes.AddRange(VarInt.EncodeVarInt(outputs.LongLength)); - - foreach(CTxOut output in outputs) - { - resultBytes.AddRange(output.ToBytes()); - } - - resultBytes.AddRange(Interop.LEBytes(nLockTime)); + for (int nTx = 0; nTx < nTransactions; nTx++) + { + // Fill the transactions array + tx[nTx] = new CTransaction(); + + tx[nTx].nVersion = reader.ReadUInt32(); + tx[nTx].nTime = reader.ReadUInt32(); + + // Inputs array + tx[nTx].vin = CTxIn.ReadTxInList(ref reader); + + // outputs array + tx[nTx].vout = CTxOut.ReadTxOutList(ref reader); + + tx[nTx].nLockTime = reader.ReadUInt32(); + } + + return tx; + + } + catch (Exception e) + { + throw new TransactionConstructorException("Deserialization failed", e); + } + } + + public bool IsCoinBase + { + get { return (vin.Length == 1 && vin[0].prevout.IsNull && vout.Length >= 1); } + } + + public bool IsCoinStake + { + get + { + return (vin.Length > 0 && (!vin[0].prevout.IsNull) && vout.Length >= 2 && vout[0].IsEmpty); + } + } + + /// + /// Transaction hash + /// + public uint256 Hash + { + get { return CryptoUtils.ComputeHash256(this); } + } + + /// + /// Amount of novacoins spent by this transaction. + /// + public ulong nValueOut + { + get + { + ulong nValueOut = 0; + foreach (var txout in vout) + { + nValueOut += txout.nValue; + Contract.Assert(MoneyRange(txout.nValue) && MoneyRange(nValueOut)); + } + return nValueOut; + } + } + + /// + /// A sequence of bytes, which corresponds to the current state of CTransaction. + /// + public static implicit operator byte[] (CTransaction tx) + { + var stream = new MemoryStream(); + var writer = new BinaryWriter(stream); + + writer.Write(tx.nVersion); + writer.Write(tx.nTime); + writer.Write(VarInt.EncodeVarInt(tx.vin.LongLength)); + + foreach (var input in tx.vin) + { + writer.Write(input); + } + + writer.Write(VarInt.EncodeVarInt(tx.vout.LongLength)); + + foreach (var output in tx.vout) + { + writer.Write(output); + } + + writer.Write(tx.nLockTime); + var resultBytes = stream.ToArray(); + writer.Close(); return resultBytes; } public override string ToString() { - StringBuilder sb = new StringBuilder(); + var sb = new StringBuilder(); sb.AppendFormat("CTransaction(\n nVersion={0},\n nTime={1},\n", nVersion, nTime); - foreach (CTxIn txin in inputs) + foreach (var txin in vin) { - sb.AppendFormat(" {0},\n", txin.ToString()); + sb.AppendFormat(" {0},\n", txin); } - foreach (CTxOut txout in outputs) + foreach (var txout in vout) { - sb.AppendFormat(" {0},\n", txout.ToString()); + sb.AppendFormat(" {0},\n", txout); } - sb.AppendFormat("nLockTime={0})\n", nLockTime); + sb.AppendFormat("\nnLockTime={0}\n)", nLockTime); return sb.ToString(); } - } -} + public static bool MoneyRange(ulong nValue) { return (nValue <= nMaxMoney); } + + /// + /// Get total sigops. + /// + /// Inputs map. + /// Amount of sigops. + public uint GetP2SHSigOpCount(ref Dictionary inputs) + { + if (IsCoinBase) + { + return 0; + } + + uint nSigOps = 0; + for (var i = 0; i < vin.Length; i++) + { + var prevout = GetOutputFor(vin[i], ref inputs); + if (prevout.scriptPubKey.IsPayToScriptHash) + { + nSigOps += prevout.scriptPubKey.GetSigOpCount(vin[i].scriptSig); + } + } + + return nSigOps; + } + + /// + /// Get sum of inputs spent by this transaction. + /// + /// Reference to innputs map. + /// Sum of inputs. + public ulong GetValueIn(ref Dictionary inputs) + { + if (IsCoinBase) + { + return 0; + } + + ulong nResult = 0; + for (int i = 0; i < vin.Length; i++) + { + nResult += GetOutputFor(vin[i], ref inputs).nValue; + } + + return nResult; + } + + /// + /// Helper method to find output in the map. + /// + /// Transaction input. + /// eference to inuts map. + /// Parent output. + private CTxOut GetOutputFor(CTxIn input, ref Dictionary inputs) + { + if (!inputs.ContainsKey(input.prevout)) + { + throw new Exception("No such input"); + } + + var outItem = inputs[input.prevout]; + + return new CTxOut(outItem.nValue, outItem.scriptPubKey); + } + + /// + /// Calculate coin*age. + /// + /// Note, only those coins meeting minimum age requirement counts. + /// + /// Inputs set. + /// Coin age calculation result. + /// Result + public bool GetCoinAge(ref Dictionary inputs, out ulong nCoinAge) + { + BigInteger bnCentSecond = 0; // coin age in the unit of cent-seconds + nCoinAge = 0; + + if (IsCoinBase) + { + // Nothing spent by coinbase, coinage is always zero. + return true; + } + + for( var i = 0; i nTime) + { + continue; // only count coins meeting min age requirement + } + + ulong nValueIn = input.nValue; + bnCentSecond += new BigInteger(nValueIn) * (nTime - merkleItem.nTime) / nCent; + } + + BigInteger bnCoinDay = bnCentSecond * nCent / nCoin / (24 * 60 * 60); + nCoinAge = (ulong)bnCoinDay; + + return true; + } + + public ulong GetMinFee(uint nBlockSize, bool fAllowFree, MinFeeMode mode) + { + ulong nMinTxFee = CTransaction.nMinTxFee, nMinRelayTxFee = CTransaction.nMinRelayTxFee; + uint nBytes = Size; + + if (IsCoinStake) + { + // Enforce 0.01 as minimum fee for old approach or coinstake + nMinTxFee = nCent; + nMinRelayTxFee = nCent; + + if (nTime < NetInfo.nStakeValidationSwitchTime) + { + // Enforce zero size for compatibility with old blocks. + nBytes = 0; + } + } + + // Base fee is either nMinTxFee or nMinRelayTxFee + ulong nBaseFee = (mode == MinFeeMode.GMF_RELAY) ? nMinRelayTxFee : nMinTxFee; + + uint nNewBlockSize = nBlockSize + nBytes; + ulong nMinFee = (1 + (ulong)nBytes / 1000) * nBaseFee; + + if (fAllowFree) + { + if (nBlockSize == 1) + { + // Transactions under 1K are free + if (nBytes < 1000) + nMinFee = 0; + } + else + { + // Free transaction area + if (nNewBlockSize < 27000) + nMinFee = 0; + } + } + + // To limit dust spam, require additional MIN_TX_FEE/MIN_RELAY_TX_FEE for + // each non empty output which is less than 0.01 + // + // It's safe to ignore empty outputs here, because these inputs are allowed + // only for coinbase and coinstake transactions. + foreach (var txout in vout) + { + if (txout.nValue < nCent && !txout.IsEmpty) + { + nMinFee += nBaseFee; + } + } + + var nMaxBlockSizeGen = CBlock.nMaxBlockSize / 2; + + // Raise the price as the block approaches full + if (nBlockSize != 1 && nNewBlockSize >= nMaxBlockSizeGen / 2) + { + if (nNewBlockSize >= nMaxBlockSizeGen) + { + return nMaxMoney; + } + + nMinFee *= nMaxBlockSizeGen / (nMaxBlockSizeGen - nNewBlockSize); + } + + if (!MoneyRange(nMinFee)) + { + nMinFee = nMaxMoney; + } + + return nMinFee; + } + } +}