Novacoin/CTxIn.cs

   1 \feff/**
   2  *  Novacoin classes library
   3  *  Copyright (C) 2015 Alex D. (balthazar.ad@gmail.com)
   4
   5  *  This program is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU Affero General Public License as
   7  *  published by the Free Software Foundation, either version 3 of the
   8  *  License, or (at your option) any later version.
   9
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU Affero General Public License for more details.
  14
  15  *  You should have received a copy of the GNU Affero General Public License
  16  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 using System;
  20 using System.Text;
  21 using System.Collections.Generic;
  22
  23 namespace Novacoin
  24 {
  25         /// <summary>
  26         /// Transaction input.
  27         /// </summary>
  28         public class CTxIn
  29         {
  30         /// <summary>
  31         /// Previous input data
  32         /// </summary>
  33         public COutPoint prevout;
  34
  35                 /// <summary>
  36                 /// First half of script, signatures for the scriptPubKey
  37                 /// </summary>
  38         public CScript scriptSig;
  39
  40                 /// <summary>
  41                 /// Transaction variant number, irrelevant if nLockTime isn't specified. Its value is 0xffffffff by default.
  42                 /// </summary>
  43         public uint nSequence = uint.MaxValue;
  44
  45         /// <summary>
  46         /// Initialize new CTxIn instance as copy of another one.
  47         /// </summary>
  48         /// <param name="i">CTxIn instance.</param>
  49         public CTxIn(CTxIn i)
  50         {
  51             prevout = new COutPoint(i.prevout);
  52             scriptSig = i.scriptSig;
  53             nSequence = i.nSequence;
  54         }
  55
  56         /// <summary>
  57         /// Initialize an empty instance of CTxIn class
  58         /// </summary>
  59         public CTxIn()
  60         {
  61             prevout = new COutPoint();
  62             scriptSig = new CScript();
  63         }
  64
  65         /// <summary>
  66         /// Read vin list from byte sequence.
  67         /// </summary>
  68         /// <param name="wBytes">Reference to byte sequence</param>
  69         /// <returns>Inputs array</returns>
  70         public static CTxIn[] ReadTxInList(ref ByteQueue wBytes)
  71         {
  72             // Get amount
  73             int nInputs = (int)wBytes.GetVarInt();
  74             var vin = new CTxIn[nInputs];
  75
  76             for (int nIndex = 0; nIndex < nInputs; nIndex++)
  77             {
  78                 // Fill inputs array
  79                 vin[nIndex] = new CTxIn();
  80                 vin[nIndex].prevout = new COutPoint(wBytes.Get(36));
  81                 vin[nIndex].scriptSig = new CScript(wBytes.Get((int)wBytes.GetVarInt()));
  82                 vin[nIndex].nSequence = BitConverter.ToUInt32(wBytes.Get(4), 0);
  83             }
  84
  85             // Return inputs array
  86             return vin;
  87         }
  88
  89         /// <summary>
  90         /// Serialized size
  91         /// </summary>
  92         public int Size
  93         {
  94             get {
  95                 int nSize = 40; // COutPoint, nSequence
  96                 nSize += VarInt.GetEncodedSize(scriptSig.Size);
  97                 nSize += scriptSig.Size;
  98
  99                 return nSize;
 100             }
 101         }
 102
 103         /// <summary>
 104         /// Get raw bytes representation of our input.
 105         /// </summary>
 106         /// <returns>Byte sequence.</returns>
 107         public static implicit operator byte[] (CTxIn input)
 108         {
 109             var inputBytes = new List<byte>();
 110
 111             inputBytes.AddRange((byte[])input.prevout); // prevout
 112
 113             var s = (byte[])input.scriptSig;
 114             inputBytes.AddRange(VarInt.EncodeVarInt(s.Length)); // scriptSig length
 115             inputBytes.AddRange(s); // scriptSig
 116             inputBytes.AddRange(BitConverter.GetBytes(input.nSequence)); // Sequence
 117
 118             return inputBytes.ToArray();
 119         }
 120
 121
 122         public bool IsFinal
 123         {
 124             get { return (nSequence == uint.MaxValue); }
 125         }
 126         public override string ToString ()
 127                 {
 128                         StringBuilder sb = new StringBuilder ();
 129
 130             sb.AppendFormat("CTxIn(");
 131             sb.Append(prevout.ToString());
 132
 133             if(prevout.IsNull)
 134             {
 135                 sb.AppendFormat(", coinbase={0}", Interop.ToHex((byte[])scriptSig));
 136             }
 137             else
 138             {
 139                 sb.AppendFormat(", scriptsig={0}", scriptSig.ToString());
 140             }
 141
 142             if (nSequence != uint.MaxValue)
 143             {
 144                 sb.AppendFormat(", nSequence={0}", nSequence);
 145             }
 146
 147             sb.Append(")");
 148
 149
 150             return sb.ToString ();
 151                 }
 152
 153         }
 154 }
 155