X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=Novacoin%2FCBlock.cs;h=e8f220799ab111a28ca5a76f5137046dc0cb9a92;hb=624ac1021490395614a0cbee619c79860c22061a;hp=82a8b88fb2339511b41bec38bbeaebb2c4b13c2d;hpb=5dbcc039601f59dda25f856dcf2f6fa13e9c72aa;p=NovacoinLibrary.git

diff --git a/Novacoin/CBlock.cs b/Novacoin/CBlock.cs
index 82a8b88..e8f2207 100644
--- a/Novacoin/CBlock.cs
+++ b/Novacoin/CBlock.cs
@@ -1,14 +1,63 @@
-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 <http://www.gnu.org/licenses/>.
+ */
+
+using System;
 using System.Text;
 using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.IO;
+using System.Numerics;
 
 namespace Novacoin
 {
-	/// <summary>
-	/// Represents the block. Block consists of header, transaction array and header signature.
-	/// </summary>
-	public class CBlock
+    [Serializable]
+    public class BlockException : Exception
+    {
+        public BlockException()
+        {
+        }
+
+        public BlockException(string message)
+                : base(message)
+        {
+        }
+
+        public BlockException(string message, Exception inner)
+                : base(message, inner)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Represents the block. Block consists of header, transaction array and header signature.
+    /// </summary>
+    public class CBlock
 	{
+        /// <summary>
+        /// Maximum block size is 1Mb.
+        /// </summary>
+        public const uint nMaxBlockSize = 1000000;
+
+        /// <summary>
+        /// Sanity threshold for amount of sigops.
+        /// </summary>
+        public const uint nMaxSigOps = 20000;
+
 		/// <summary>
 		/// Block header.
 		/// </summary>
@@ -19,39 +68,55 @@ namespace Novacoin
 		/// </summary>
 		public CTransaction[] vtx;
 
-		/// <summary>
-		/// Block header signature.
-		/// </summary>
-		public byte[] signature;
+        /// <summary>
+        /// Block header signature.
+        /// </summary>
+        public byte[] signature = new byte[0];
 
+        /// <summary>
+        /// Copy constructor.
+        /// </summary>
+        /// <param name="b">CBlock instance.</param>
         public CBlock(CBlock b)
         {
             header = new CBlockHeader(b.header);
+            vtx = new CTransaction[b.vtx.Length];
 
             for (int i = 0; i < b.vtx.Length; i++)
             {
                 vtx[i] = new CTransaction(b.vtx[i]);
             }
 
+            signature = new byte[b.signature.Length];
             b.signature.CopyTo(signature, 0);
         }
 
         /// <summary>
         /// Parse byte sequence and initialize new block instance
         /// </summary>
-        /// <param name="blockBytes"></param>
-		public CBlock (IList<byte> blockBytes)
+        /// <param name="blockBytes">Bytes sequence.</param>
+		public CBlock (byte[] blockBytes)
 		{
-            ByteQueue wBytes = new ByteQueue(blockBytes);
+            try
+            {
+                var stream = new MemoryStream(blockBytes);
+                var reader = new BinaryReader(stream);
+
+                // Fill the block header fields
+                header = new CBlockHeader(ref reader);               
 
-            // Fill the block header fields
-            header = new CBlockHeader(wBytes.Get(80));
+                // Parse transactions list
+                vtx = CTransaction.ReadTransactionsList(ref reader);
 
-            // Parse transactions list
-            vtx = CTransaction.ReadTransactionsList(ref wBytes);
+                // Read block signature
+                signature = reader.ReadBytes((int)VarInt.ReadVarInt(ref reader));
 
-            // Read block signature
-            signature = wBytes.Get((int)wBytes.GetVarInt());
+                reader.Close();
+            }
+            catch (Exception e)
+            {
+                throw new BlockException("Deserialization failed", e);
+            }
 		}
 
         public CBlock()
@@ -62,47 +127,395 @@ namespace Novacoin
             vtx = new CTransaction[0];
         }
 
+        public bool CheckBlock(bool fCheckPOW = true, bool fCheckMerkleRoot = true, bool fCheckSig = true)
+        {
+            var uniqueTX = new List<uint256>(); // tx hashes
+            uint nSigOps = 0; // total sigops
+
+            // Basic sanity checkings
+            if (vtx.Length == 0 || Size > nMaxBlockSize)
+            {
+                return false;
+            }
+
+            bool fProofOfStake = IsProofOfStake;
+
+            // First transaction must be coinbase, the rest must not be
+            if (!vtx[0].IsCoinBase)
+            {
+                return false;
+            }
+
+            if (!vtx[0].CheckTransaction())
+            {
+                return false;
+            }
+
+            uniqueTX.Add(vtx[0].Hash);
+            nSigOps += vtx[0].LegacySigOpCount;
+
+            if (fProofOfStake)
+            {
+                // Proof-of-STake related checkings. Note that we know here that 1st transactions is coinstake. We don't need 
+                //   check the type of 1st transaction because it's performed earlier by IsProofOfStake()
+
+                // nNonce must be zero for proof-of-stake blocks
+                if (header.nNonce != 0)
+                {
+                    return false;
+                }
+
+                // Coinbase output should be empty if proof-of-stake block
+                if (vtx[0].vout.Length != 1 || !vtx[0].vout[0].IsEmpty)
+                {
+                    return false;
+                }
+
+                // Check coinstake timestamp
+                if (header.nTime != vtx[1].nTime)
+                {
+                    return false;
+                }
+
+                // Check proof-of-stake block signature
+                if (fCheckSig && !SignatureOK)
+                {
+                    return false;
+                }
+
+                if (!vtx[1].CheckTransaction())
+                {
+                    return false;
+                }
+
+                uniqueTX.Add(vtx[1].Hash);
+                nSigOps += vtx[1].LegacySigOpCount;
+            }
+            else
+            {
+                // Check proof of work matches claimed amount
+                if (fCheckPOW && !CheckProofOfWork(header.Hash, header.nBits))
+                {
+                    return false;
+                }
+
+                // Check timestamp
+                if (header.nTime > NetInfo.FutureDrift(NetInfo.GetAdjustedTime()))
+                {
+                    return false;
+                }
+
+                // Check coinbase timestamp
+                if (header.nTime < NetInfo.PastDrift(vtx[0].nTime))
+                {
+                    return false;
+                }
+            }
+
+            // Iterate all transactions starting from second for proof-of-stake block 
+            //    or first for proof-of-work block
+            for (int i = fProofOfStake ? 2 : 1; i < vtx.Length; i++)
+            {
+                var tx = vtx[i];
+
+                // Reject coinbase transactions at non-zero index
+                if (tx.IsCoinBase)
+                {
+                    return false;
+                }
+
+                // Reject coinstake transactions at index != 1
+                if (tx.IsCoinStake)
+                {
+                    return false;
+                }
+
+                // Check transaction timestamp
+                if (header.nTime < tx.nTime)
+                {
+                    return false;
+                }
+
+                // Check transaction consistency
+                if (!tx.CheckTransaction())
+                {
+                    return false;
+                }
+
+                // Add transaction hash into list of unique transaction IDs
+                uniqueTX.Add(tx.Hash);
+
+                // Calculate sigops count
+                nSigOps += tx.LegacySigOpCount;
+            }
+
+            // Check for duplicate txids. 
+            if (uniqueTX.Count != vtx.Length)
+            {
+                return false;
+            }
+
+            // Reject block if validation would consume too much resources.
+            if (nSigOps > nMaxSigOps)
+            {
+                return false;
+            }
+
+            // Check merkle root
+            if (fCheckMerkleRoot && hashMerkleRoot != header.merkleRoot)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        private bool CheckProofOfWork(uint256 hash, uint nBits)
+        {
+            uint256 nTarget = new uint256();
+            nTarget.Compact = nBits;
+
+            // Check range
+            if (nTarget > NetInfo.nProofOfWorkLimit)
+            {
+                // nBits below minimum work
+                return false; 
+            }
+
+            // Check proof of work matches claimed amount
+            if (hash > nTarget)
+            {
+                //  hash doesn't match nBits
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Is this a Proof-of-Stake block?
+        /// </summary>
+        public bool IsProofOfStake
+        {
+            get
+            {
+                return (vtx.Length > 1 && vtx[1].IsCoinStake);
+            }
+        }
+
+        /// <summary>
+        /// Was this signed correctly?
+        /// </summary>
+        public bool SignatureOK
+        {
+            get
+            {
+                if (IsProofOfStake)
+                {
+                    if (signature.Length == 0)
+                    {
+                        return false; // No signature
+                    }
+
+                    txnouttype whichType;
+                    IList<byte[]> solutions;
+
+                    if (!ScriptCode.Solver(vtx[1].vout[1].scriptPubKey, out whichType, out solutions))
+                    {
+                        return false; // No solutions found
+                    }
+
+                    if (whichType == txnouttype.TX_PUBKEY)
+                    {
+                        CPubKey pubkey;
+
+                        try
+                        {
+                            pubkey = new CPubKey(solutions[0]);
+                        }
+                        catch (Exception)
+                        {
+                            return false; // Error while loading public key
+                        }
+
+                        return pubkey.VerifySignature(header.Hash, signature);
+                    }
+                }
+                else
+                {
+                    // Proof-of-Work blocks have no signature
+
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
         /// <summary>
-        /// Convert current instance into sequence of bytes
+        /// Get instance as sequence of bytes
         /// </summary>
         /// <returns>Byte sequence</returns>
-        public IList<byte> Bytes 
+        public static implicit operator byte[] (CBlock b)
+        {
+            var stream = new MemoryStream();
+            var writer = new BinaryWriter(stream);
+
+            writer.Write(b.header);
+            writer.Write(VarInt.EncodeVarInt(b.vtx.LongLength));
+
+            foreach (var tx in b.vtx)
+            {
+                writer.Write(tx);
+            }
+
+            writer.Write(VarInt.EncodeVarInt(b.signature.LongLength));
+            writer.Write(b.signature);
+
+            var resultBytes = stream.ToArray();
+
+            writer.Close();
+
+            return resultBytes;
+        }
+
+        /// <summary>
+        /// Serialized size
+        /// </summary>
+        public int Size
         {
             get
             {
-                List<byte> r = new List<byte>();
+                int nSize = 80 + VarInt.GetEncodedSize(vtx.Length); // CBlockHeader + NumTx
+
+                foreach (var tx in vtx)
+                {
+                    nSize += tx.Size;
+                }
+
+                nSize += VarInt.GetEncodedSize(signature.Length) + signature.Length;
+
+                return nSize;
+            }
+        }
+
+        /// <summary>
+        /// Get transaction offset inside block.
+        /// </summary>
+        /// <param name="nTx">Transaction index.</param>
+        /// <returns>Offset in bytes from the beginning of block header.</returns>
+        public int GetTxOffset(int nTx)
+        {
+            Contract.Requires<ArgumentException>(nTx >= 0 && nTx < vtx.Length, "Transaction index you've specified is incorrect.");
+
+            int nOffset = 80 + VarInt.GetEncodedSize(vtx.Length); // CBlockHeader + NumTx
+
+            for (int i = 0; i < nTx; i++)
+            {
+                nOffset += vtx[i].Size;
+            }
 
-                r.AddRange(header.Bytes);
-                r.AddRange(VarInt.EncodeVarInt(vtx.LongLength)); // transactions count
+            return nOffset;
+        }
+
+        /// <summary>
+        /// Merkle root
+        /// </summary>
+        public uint256 hashMerkleRoot
+        {
+            get {
+                
+                var merkleTree = new List<byte>();
 
-                foreach (CTransaction tx in vtx)
+                foreach (var tx in vtx)
                 {
-                    r.AddRange(tx.Bytes);
+                    merkleTree.AddRange(CryptoUtils.ComputeHash256(tx));
                 }
 
-                r.AddRange(VarInt.EncodeVarInt(signature.LongLength));
-                r.AddRange(signature);
+                int levelOffset = 0;
+                for (int nLevelSize = vtx.Length; nLevelSize > 1; nLevelSize = (nLevelSize + 1) / 2)
+                {
+                    for (int nLeft = 0; nLeft < nLevelSize; nLeft += 2)
+                    {
+                        int nRight = Math.Min(nLeft + 1, nLevelSize - 1);
+
+                        var left = merkleTree.GetRange((levelOffset + nLeft) * 32, 32).ToArray();
+                        var right = merkleTree.GetRange((levelOffset + nRight) * 32, 32).ToArray();
+
+                        merkleTree.AddRange(CryptoUtils.ComputeHash256(ref left, ref right));
+                    }
+                    levelOffset += nLevelSize;
+                }
 
-                return r;
+                return (merkleTree.Count == 0) ? 0 : (uint256)merkleTree.GetRange(merkleTree.Count-32, 32).ToArray();
             }
         }
 
         public override string ToString()
         {
-            StringBuilder sb = new StringBuilder();
+            var sb = new StringBuilder();
 
             sb.AppendFormat("CBlock(\n header={0},\n", header.ToString());
 
-            foreach(CTransaction tx in vtx)
+            foreach(var tx in vtx)
             {
-                sb.AppendFormat("{0},\n", tx.ToString());
+                sb.AppendFormat("{0}", tx.ToString());
             }
 
-            sb.AppendFormat("signature={0})\n", Interop.ToHex(signature));
+            if (IsProofOfStake)
+            {
+                sb.AppendFormat(", signature={0}, signatureOK={1}\n", Interop.ToHex(signature), SignatureOK);
+            }
+
+            sb.Append(")");
             
-            // TODO
             return sb.ToString();
         }
-	}
+
+        /// <summary>
+        /// Calculate proof-of-work reward.
+        /// </summary>
+        /// <param name="nBits">Packed difficulty representation.</param>
+        /// <param name="nFees">Amount of fees.</param>
+        /// <returns>Reward value.</returns>
+        public static ulong GetProofOfWorkReward(uint nBits, ulong nFees)
+        {
+            // NovaCoin: subsidy is cut in half every 64x multiply of PoW difficulty
+            // A reasonably continuous curve is used to avoid shock to market
+            // (nSubsidyLimit / nSubsidy) ** 6 == bnProofOfWorkLimit / bnTarget
+            //
+            // Human readable form:
+            //
+            // nSubsidy = 100 / (diff ^ 1/6)
+            //
+            // Please note that we're using bisection to find an approximate solutuion
+
+            BigInteger bnSubsidyLimit = NetInfo.nMaxMintProofOfWork;
+
+            uint256 nTarget = 0;
+            nTarget.Compact = nBits;
+
+            BigInteger bnTarget = new BigInteger(nTarget);
+            BigInteger bnTargetLimit = new BigInteger(NetInfo.nProofOfWorkLimit);
+
+            BigInteger bnLowerBound = CTransaction.nCent;
+            BigInteger bnUpperBound = bnSubsidyLimit;
+
+            while (bnLowerBound + CTransaction.nCent <= bnUpperBound)
+            {
+                BigInteger bnMidValue = (bnLowerBound + bnUpperBound) / 2;
+                if (bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnMidValue * bnTargetLimit > bnSubsidyLimit * bnSubsidyLimit * bnSubsidyLimit * bnSubsidyLimit * bnSubsidyLimit * bnSubsidyLimit * bnTarget)
+                    bnUpperBound = bnMidValue;
+                else
+                    bnLowerBound = bnMidValue;
+            }
+
+            ulong nSubsidy = (ulong)bnUpperBound;
+            nSubsidy = (nSubsidy / CTransaction.nCent) * CTransaction.nCent;
+
+
+            return Math.Min(nSubsidy, NetInfo.nMaxMintProofOfWork) + nFees;
+        }
+    }
 }