示例#1
0
        protected void AdjustLength(int newArraySize, int adjustment)
        {
            if (Length == UnknownLength)
            {
                return;
            }

            // Our own length is now unknown if we have an unknown length adjustment.
            if (adjustment == UnknownLength)
            {
                Length = UnknownLength;
                return;
            }

            Length += adjustment;

            // Check if we will need more bytes to encode the length prefix.
            if (newArraySize == 1)
            {
                Length++;
            }                          // The assumption here is we never call adjustLength with the same arraySize as before.
            else if (newArraySize != 0)
            {
                Length += VarInt.SizeInBytesOf((ulong)newArraySize) - VarInt.SizeInBytesOf((ulong)(newArraySize - 1));
            }
        }
示例#2
0
        /**
         * Used only in creation of the genesis block.
         */
        TransactionInput(NetworkParameters params, Transaction parentTransaction, byte[] scriptBytes)
        {
            super(params);
            this.scriptBytes       = scriptBytes;
            this.outpoint          = new TransactionOutPoint(params, NO_SEQUENCE, (Transaction)null);
            this.sequence          = NO_SEQUENCE;
            this.parentTransaction = parentTransaction;

            length = 40 + (scriptBytes == null ? 1 : VarInt.SizeInBytesOf(scriptBytes.Length) + scriptBytes.length);
        }
示例#3
0
        /// <summary>
        /// Provides a reasonable guess at the byte length of the transactions part of the block.
        /// The returned value will be accurate in 99% of cases and in those cases where not will probably slightly oversize.
        /// This is used to preallocate the underlying byte array for a Stream.
        /// If the size is under the real value the only penalty is resizing of the underlying byte array.
        /// </summary>
        /// <returns></returns>
        private int guessTransactionsLength()
        {
            if (transactionBytesValid)
            {
                return(Bytes.Length - HeaderSize);
            }

            if (Transactions == null)
            {
                return(0);
            }

            int len = VarInt.SizeInBytesOf((ulong)Transactions.Count);

            foreach (Transaction tx in Transactions)
            {
                len += tx.MessageSize == UnknownLength?255:tx.MessageSize;
            }                                                                           // 255 is just a guess at an average tx length
            return(len);
        }
示例#4
0
        /// <summary>
        /// <exception cref="ProtocolException"/>
        /// </summary>
        private void parseTransactions()
        {
            if (transactionsParsed)
            {
                return;
            }

            Cursor = Offset + HeaderSize;
            optimalEncodingMessageSize = HeaderSize;

            if (Bytes.Length == Cursor)
            {
                // This message is just a header, it has no transactions.
                transactionsParsed    = true;
                transactionBytesValid = false;
                return;
            }

            ulong numTransactions = ReadVarInt().Value;

            optimalEncodingMessageSize += VarInt.SizeInBytesOf(numTransactions);

            Transactions = new List <Transaction>((int)numTransactions);
            for (ulong i = 0; i < numTransactions; i++)
            {
                Transaction tx = new Transaction(Parameters, Bytes, Cursor, this, ParseLazy, ParseRetain, UnknownLength);
                Transactions.Add(tx);
                Cursor += tx.MessageSize;
                optimalEncodingMessageSize += tx.OptimalEncodingMessageSize;
            }

            // No need to set length here. If length was not provided then it should be set at the end of parseLight().
            // If this is a genuine lazy parse then length must have been provided to the constructor.
            transactionsParsed    = true;
            transactionBytesValid = ParseRetain;
        }