Message: fold bitcoinSerialize() into bitcoinSerializeToStream()

core/src/main/java/org/bitcoinj/core/AddressMessage.java

@@ -39,7 +39,7 @@ public abstract class AddressMessage extends Message {
             return;
         stream.write(VarInt.of(addresses.size()).encode());
         for (PeerAddress addr : addresses) {
-            addr.bitcoinSerialize(stream);
+            addr.bitcoinSerializeToStream(stream);
         }
     }
 

core/src/main/java/org/bitcoinj/core/Block.java

@@ -321,52 +321,16 @@ public class Block extends Message {
 
         stream.write(VarInt.of(transactions.size()).encode());
         for (Transaction tx : transactions) {
-            tx.bitcoinSerialize(stream);
+            tx.bitcoinSerializeToStream(stream);
         }
     }
 
-    /**
-     * Special handling to check if we have a valid byte array for both header
-     * and transactions
-     */
-    @Override
-    public byte[] bitcoinSerialize() {
-        ByteArrayOutputStream stream = new ByteArrayOutputStream(length == UNKNOWN_LENGTH ? HEADER_SIZE + guessTransactionsLength() : length);
-        try {
-            writeHeader(stream);
-            writeTransactions(stream);
-        } catch (IOException e) {
-            // Cannot happen, we are serializing to a memory stream.
-        }
-        return stream.toByteArray();
-    }
-
     @Override
     protected void bitcoinSerializeToStream(OutputStream stream) throws IOException {
         writeHeader(stream);
-        // We may only have enough data to write the header.
         writeTransactions(stream);
     }
 
-    /**
-     * 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 ByteArrayOutputStream.  If the size is under the
-     * real value the only penalty is resizing of the underlying byte array.
-     */
-    private int guessTransactionsLength() {
-        if (transactions == null)
-            return 0;
-        int len = VarInt.sizeOf(transactions.size());
-        for (Transaction tx : transactions) {
-            // 255 is just a guess at an average tx length
-            len += tx.length == UNKNOWN_LENGTH ? 255 : tx.length;
-        }
-        return len;
-    }
-
     @Override
     protected void unCache() {
         // Since we have alternate uncache methods to use internally this will only ever be called by a child

core/src/main/java/org/bitcoinj/core/EmptyMessage.java

@@ -50,12 +50,4 @@ public abstract class EmptyMessage extends Message {
     @Override
     protected void parse() throws ProtocolException {
     }
-
-    /* (non-Javadoc)
-      * @see Message#bitcoinSerialize()
-      */
-    @Override
-    public byte[] bitcoinSerialize() {
-        return new byte[0];
-    }
 }

core/src/main/java/org/bitcoinj/core/Message.java

@@ -186,16 +186,6 @@ public abstract class Message {
         return buf;
     }
 
-    /**
-     * Serialize this message to the provided OutputStream using the bitcoin wire format.
-     *
-     * @param stream
-     * @throws IOException
-     */
-    public final void bitcoinSerialize(OutputStream stream) throws IOException {
-        bitcoinSerializeToStream(stream);
-    }
-
     /**
      * Serializes this message to the provided stream. If you just want the raw bytes use bitcoinSerialize().
      */

core/src/main/java/org/bitcoinj/core/Transaction.java

@@ -1553,11 +1553,11 @@ public class Transaction extends ChildMessage {
         // txin_count, txins
         stream.write(VarInt.of(inputs.size()).encode());
         for (TransactionInput in : inputs)
-            in.bitcoinSerialize(stream);
+            in.bitcoinSerializeToStream(stream);
         // txout_count, txouts
         stream.write(VarInt.of(outputs.size()).encode());
         for (TransactionOutput out : outputs)
-            out.bitcoinSerialize(stream);
+            out.bitcoinSerializeToStream(stream);
         // script_witnisses
         if (useSegwit) {
             for (TransactionInput in : inputs) {

core/src/main/java/org/bitcoinj/core/TransactionInput.java

@@ -172,7 +172,7 @@ public class TransactionInput extends ChildMessage {
 
     @Override
     protected void bitcoinSerializeToStream(OutputStream stream) throws IOException {
-        outpoint.bitcoinSerialize(stream);
+        outpoint.bitcoinSerializeToStream(stream);
         stream.write(VarInt.of(scriptBytes.length).encode());
         stream.write(scriptBytes);
         ByteUtils.writeUint32LE(sequence, stream);

core/src/test/java/org/bitcoinj/core/BlockTest.java

@@ -356,16 +356,6 @@ public class BlockTest {
 
                 stream.write(VarInt.of(Integer.MAX_VALUE).encode());
             }
-
-            @Override
-            public byte[] bitcoinSerialize() {
-                ByteArrayOutputStream baos = new ByteArrayOutputStream();
-                try {
-                    bitcoinSerializeToStream(baos);
-                } catch (IOException e) {
-                }
-                return baos.toByteArray();
-            }
         };
         byte[] serializedBlock = block.bitcoinSerialize();
         try {

core/src/test/java/org/bitcoinj/core/FullBlockTestGenerator.java

@@ -1228,7 +1228,7 @@ public class FullBlockTestGenerator {
             checkState(VarInt.ofBytes(varIntBytes, 0).intValue() == b64Original.block.getTransactions().size());
 
             for (Transaction transaction : b64Original.block.getTransactions())
-                transaction.bitcoinSerialize(stream);
+                transaction.bitcoinSerializeToStream(stream);
             b64 = params.getSerializer().makeBlock(ByteBuffer.wrap(stream.toByteArray()));
 
             // The following checks are checking to ensure block serialization functions in the way needed for this test

core/src/test/java/org/bitcoinj/core/TransactionTest.java

@@ -727,12 +727,12 @@ public class TransactionTest {
             long inputsSize = hackInputsSize ? Integer.MAX_VALUE : getInputs().size();
             stream.write(VarInt.of(inputsSize).encode());
             for (TransactionInput in : getInputs())
-                in.bitcoinSerialize(stream);
+                in.bitcoinSerializeToStream(stream);
             // txout_count, txouts
             long outputsSize = hackOutputsSize ? Integer.MAX_VALUE : getOutputs().size();
             stream.write(VarInt.of(outputsSize).encode());
             for (TransactionOutput out : getOutputs())
-                out.bitcoinSerialize(stream);
+                out.bitcoinSerializeToStream(stream);
             // script_witnisses
             if (useSegwit) {
                 for (TransactionInput in : getInputs()) {