From 93cc0ac9c54e09662d9760810e26c030dd920e30 Mon Sep 17 00:00:00 2001
From: Sean Gilligan <sean@msgilligan.com>
Date: Wed, 22 Jun 2022 05:56:24 -0700
Subject: [PATCH] org.bitcoinj.base: move Sha256Hash and byte/math Utils
 members to `base`

* move o.b.core.Sha256Hash to o.b.base.Sha256Hash
* move byte and math utility methods from o.b.core.Utils to a new
  o.b.base.ByteUtils class
---
 .../bitcoinj/{core => base}/Sha256Hash.java   |  13 +-
 .../org/bitcoinj/base/utils/ByteUtils.java    | 359 ++++++++++++++++++
 .../org/bitcoinj/core/AbstractBlockChain.java |   1 +
 .../main/java/org/bitcoinj/core/Base58.java   |   5 +-
 .../org/bitcoinj/core/BitcoinSerializer.java  |  10 +-
 .../main/java/org/bitcoinj/core/Block.java    |  24 +-
 .../java/org/bitcoinj/core/BlockChain.java    |   1 +
 .../java/org/bitcoinj/core/BlockLocator.java  |   1 +
 .../java/org/bitcoinj/core/BloomFilter.java   |  12 +-
 .../org/bitcoinj/core/CheckpointManager.java  |   1 +
 .../main/java/org/bitcoinj/core/ECKey.java    |  34 +-
 .../org/bitcoinj/core/FeeFilterMessage.java   |   3 +-
 .../java/org/bitcoinj/core/FilteredBlock.java |   2 +
 .../bitcoinj/core/FullPrunedBlockChain.java   |   1 +
 .../org/bitcoinj/core/GetBlocksMessage.java   |   5 +-
 .../org/bitcoinj/core/GetDataMessage.java     |   2 +
 .../org/bitcoinj/core/GetHeadersMessage.java  |   2 +
 .../java/org/bitcoinj/core/InventoryItem.java |   2 +
 .../java/org/bitcoinj/core/ListMessage.java   |   3 +-
 .../main/java/org/bitcoinj/core/Message.java  |   8 +-
 .../org/bitcoinj/core/NetworkParameters.java  |   1 +
 .../org/bitcoinj/core/PartialMerkleTree.java  |  13 +-
 .../src/main/java/org/bitcoinj/core/Peer.java |   1 +
 .../java/org/bitcoinj/core/PeerAddress.java   |  11 +-
 .../src/main/java/org/bitcoinj/core/Ping.java |   4 +-
 .../src/main/java/org/bitcoinj/core/Pong.java |   4 +-
 .../org/bitcoinj/core/PrunedException.java    |   2 +
 .../java/org/bitcoinj/core/RejectMessage.java |   2 +
 .../java/org/bitcoinj/core/StoredBlock.java   |   3 +-
 .../bitcoinj/core/StoredUndoableBlock.java    |   2 +
 .../java/org/bitcoinj/core/Transaction.java   |   8 +-
 .../org/bitcoinj/core/TransactionBag.java     |   1 +
 .../bitcoinj/core/TransactionConfidence.java  |   1 +
 .../org/bitcoinj/core/TransactionInput.java   |   4 +-
 .../bitcoinj/core/TransactionOutPoint.java    |   4 +-
 .../org/bitcoinj/core/TransactionOutput.java  |   6 +-
 .../core/TransactionOutputChanges.java        |  10 +-
 .../org/bitcoinj/core/TransactionWitness.java |   3 +-
 .../org/bitcoinj/core/TxConfidenceTable.java  |   1 +
 .../src/main/java/org/bitcoinj/core/UTXO.java |  18 +-
 .../org/bitcoinj/core/UnknownMessage.java     |   4 +-
 .../main/java/org/bitcoinj/core/Utils.java    | 339 +----------------
 .../main/java/org/bitcoinj/core/VarInt.java   |  13 +-
 .../org/bitcoinj/core/VersionMessage.java     |  17 +-
 .../core/listeners/NewBestBlockListener.java  |   2 +-
 .../TransactionReceivedInBlockListener.java   |   2 +-
 .../org/bitcoinj/crypto/BIP38PrivateKey.java  |   8 +-
 .../org/bitcoinj/crypto/DeterministicKey.java |  15 +-
 .../org/bitcoinj/crypto/HDKeyDerivation.java  |   9 +-
 .../org/bitcoinj/crypto/MnemonicCode.java     |   4 +-
 .../jni/NativeBlockChainListener.java         |   2 +-
 .../org/bitcoinj/net/discovery/SeedPeers.java |   4 +-
 .../params/AbstractBitcoinNetParams.java      |   8 +-
 .../org/bitcoinj/params/MainNetParams.java    |   6 +-
 .../org/bitcoinj/params/RegTestParams.java    |   6 +-
 .../org/bitcoinj/params/SigNetParams.java     |   6 +-
 .../org/bitcoinj/params/TestNet3Params.java   |   6 +-
 .../org/bitcoinj/params/UnitTestParams.java   |   3 +-
 .../main/java/org/bitcoinj/script/Script.java |  33 +-
 .../org/bitcoinj/script/ScriptBuilder.java    |   2 +-
 .../java/org/bitcoinj/script/ScriptChunk.java |   8 +-
 .../org/bitcoinj/script/ScriptPattern.java    |   6 +-
 .../signers/CustomTransactionSigner.java      |   2 +-
 .../java/org/bitcoinj/store/BlockStore.java   |   2 +-
 .../store/DatabaseFullPrunedBlockStore.java   |   8 +-
 .../bitcoinj/store/FullPrunedBlockStore.java  |   2 +-
 .../org/bitcoinj/store/MemoryBlockStore.java  |   2 +-
 .../store/MemoryFullPrunedBlockStore.java     |   2 +-
 .../store/PostgresFullPrunedBlockStore.java   |  10 +-
 .../org/bitcoinj/store/SPVBlockStore.java     |   2 +-
 .../org/bitcoinj/testing/FakeTxBuilder.java   |   2 +-
 .../org/bitcoinj/utils/BlockFileLoader.java   |   4 +-
 .../wallet/DeterministicKeyChain.java         |   5 +-
 .../bitcoinj/wallet/DeterministicSeed.java    |   2 +-
 .../org/bitcoinj/wallet/MarriedKeyChain.java  |   4 +-
 .../main/java/org/bitcoinj/wallet/Wallet.java |   2 +-
 .../wallet/WalletProtobufSerializer.java      |   2 +-
 .../bitcoinj/base/utils/ByteUtilsTest.java    | 235 ++++++++++++
 .../bitcoinj/core/AddressV1MessageTest.java   |   2 +-
 .../bitcoinj/core/AddressV2MessageTest.java   |   2 +-
 .../core/Base58DecodeToBigIntegerTest.java    |   3 +-
 .../bitcoinj/core/BitcoinSerializerTest.java  |   5 +-
 .../bitcoinj/core/BitcoindComparisonTool.java |   1 +
 .../org/bitcoinj/core/BlockChainTest.java     |   1 +
 .../java/org/bitcoinj/core/BlockTest.java     |  12 +-
 .../org/bitcoinj/core/BloomFilterTest.java    |   2 +-
 .../org/bitcoinj/core/ChainSplitTest.java     |   1 +
 .../java/org/bitcoinj/core/ECKeyTest.java     |  18 +-
 .../bitcoinj/core/FullBlockTestGenerator.java |  16 +-
 .../org/bitcoinj/core/LegacyAddressTest.java  |   7 +-
 .../org/bitcoinj/core/ParseByteCacheTest.java |   7 +-
 .../org/bitcoinj/core/PeerAddressTest.java    |   5 +-
 .../core/PrefixedChecksummedBytesTest.java    |   2 +-
 .../org/bitcoinj/core/SegwitAddressTest.java  |  13 +-
 .../bitcoinj/core/SendHeadersMessageTest.java |   2 +-
 .../bitcoinj/core/TransactionInputTest.java   |   1 +
 .../org/bitcoinj/core/TransactionTest.java    |   5 +-
 .../bitcoinj/core/TransactionWitnessTest.java |   7 +-
 .../bitcoinj/core/TxConfidenceTableTest.java  |   1 +
 .../test/java/org/bitcoinj/core/UTXOTest.java |   1 +
 .../java/org/bitcoinj/core/UtilsTest.java     | 210 ----------
 .../org/bitcoinj/core/VersionMessageTest.java |   2 +-
 .../java/org/bitcoinj/crypto/BIP32Test.java   |   2 +-
 .../crypto/ChildKeyDerivationTest.java        |   4 +-
 .../bitcoinj/crypto/HDKeyDerivationTest.java  |  20 +-
 .../java/org/bitcoinj/crypto/HDUtilsTest.java |   2 +-
 .../bitcoinj/crypto/KeyCrypterScryptTest.java |  24 +-
 .../org/bitcoinj/crypto/MnemonicCodeTest.java |   2 +-
 .../crypto/MnemonicCodeVectorsTest.java       |   2 +-
 .../java/org/bitcoinj/script/ScriptTest.java  |   8 +-
 .../org/bitcoinj/store/SPVBlockStoreTest.java |   2 +-
 .../store/WalletProtobufSerializerTest.java   |   7 +-
 .../testing/KeyChainTransactionSigner.java    |   2 +-
 .../wallet/DefaultRiskAnalysisTest.java       |   6 +-
 .../wallet/DeterministicKeyChainTest.java     |   2 +-
 .../bitcoinj/wallet/KeyChainGroupTest.java    |   2 +-
 .../java/org/bitcoinj/wallet/WalletTest.java  |   7 +-
 .../org/bitcoinj/examples/FetchBlock.java     |   1 +
 .../bitcoinj/examples/FetchTransactions.java  |   1 +
 .../bitcoinj/examples/GenerateLowSTests.java  |   4 +-
 ...FilteredBlockAndPartialMerkleTreeTest.java |  10 +-
 .../java/org/bitcoinj/core/PeerGroupTest.java |   1 +
 .../test/java/org/bitcoinj/core/PeerTest.java |   2 +-
 .../org/bitcoinj/tools/BuildCheckpoints.java  |   1 +
 .../org/bitcoinj/wallettool/WalletTool.java   |  10 +-
 125 files changed, 989 insertions(+), 836 deletions(-)
 rename core/src/main/java/org/bitcoinj/{core => base}/Sha256Hash.java (96%)
 create mode 100644 core/src/main/java/org/bitcoinj/base/utils/ByteUtils.java
 create mode 100644 core/src/test/java/org/bitcoinj/base/utils/ByteUtilsTest.java

diff --git a/core/src/main/java/org/bitcoinj/core/Sha256Hash.java b/core/src/main/java/org/bitcoinj/base/Sha256Hash.java
similarity index 96%
rename from core/src/main/java/org/bitcoinj/core/Sha256Hash.java
rename to core/src/main/java/org/bitcoinj/base/Sha256Hash.java
index eac7e3e1a..7ef1040ac 100644
--- a/core/src/main/java/org/bitcoinj/core/Sha256Hash.java
+++ b/core/src/main/java/org/bitcoinj/base/Sha256Hash.java
@@ -15,10 +15,11 @@
  * limitations under the License.
  */
 
-package org.bitcoinj.core;
+package org.bitcoinj.base;
 
 import com.google.common.io.ByteStreams;
 import com.google.common.primitives.Ints;
+import org.bitcoinj.base.utils.ByteUtils;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -67,7 +68,7 @@ public class Sha256Hash implements Comparable<Sha256Hash> {
      *         hex string, or if it does not represent exactly 32 bytes
      */
     public static Sha256Hash wrap(String hexString) {
-        return wrap(Utils.HEX.decode(hexString));
+        return wrap(ByteUtils.HEX.decode(hexString));
     }
 
     /**
@@ -78,7 +79,7 @@ public class Sha256Hash implements Comparable<Sha256Hash> {
      * @throws IllegalArgumentException if the given array length is not exactly 32
      */
     public static Sha256Hash wrapReversed(byte[] rawHashBytes) {
-        return wrap(Utils.reverseBytes(rawHashBytes));
+        return wrap(ByteUtils.reverseBytes(rawHashBytes));
     }
 
     /**
@@ -236,14 +237,14 @@ public class Sha256Hash implements Comparable<Sha256Hash> {
 
     @Override
     public String toString() {
-        return Utils.HEX.encode(bytes);
+        return ByteUtils.HEX.encode(bytes);
     }
 
     /**
      * Returns the bytes interpreted as a positive integer.
      */
     public BigInteger toBigInteger() {
-        return Utils.bytesToBigInteger(bytes);
+        return ByteUtils.bytesToBigInteger(bytes);
     }
 
     /**
@@ -257,7 +258,7 @@ public class Sha256Hash implements Comparable<Sha256Hash> {
      * Returns a reversed copy of the internal byte array.
      */
     public byte[] getReversedBytes() {
-        return Utils.reverseBytes(bytes);
+        return ByteUtils.reverseBytes(bytes);
     }
 
     @Override
diff --git a/core/src/main/java/org/bitcoinj/base/utils/ByteUtils.java b/core/src/main/java/org/bitcoinj/base/utils/ByteUtils.java
new file mode 100644
index 000000000..03f253cd5
--- /dev/null
+++ b/core/src/main/java/org/bitcoinj/base/utils/ByteUtils.java
@@ -0,0 +1,359 @@
+/*
+ * Copyright by the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.bitcoinj.base.utils;
+
+import com.google.common.io.BaseEncoding;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.math.BigInteger;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+/**
+ * Utility methods for bit, byte, and integer manipulation and conversion. Most of these were moved here
+ * from {@code org.bitcoinj.core.Utils}.
+ */
+public class ByteUtils {
+    /** Hex encoding used throughout the framework. Use with HEX.encode(byte[]) or HEX.decode(CharSequence). */
+    public static final BaseEncoding HEX = BaseEncoding.base16().lowerCase();
+    // 00000001, 00000010, 00000100, 00001000, ...
+    private static final int[] bitMask = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
+
+    /**
+     * <p>
+     * The regular {@link BigInteger#toByteArray()} includes the sign bit of the number and
+     * might result in an extra byte addition. This method removes this extra byte.
+     * </p>
+     * <p>
+     * Assuming only positive numbers, it's possible to discriminate if an extra byte
+     * is added by checking if the first element of the array is 0 (0000_0000).
+     * Due to the minimal representation provided by BigInteger, it means that the bit sign
+     * is the least significant bit 0000_000<b>0</b> .
+     * Otherwise the representation is not minimal.
+     * For example, if the sign bit is 0000_00<b>0</b>0, then the representation is not minimal due to the rightmost zero.
+     * </p>
+     * This is the antagonist to {@link #bytesToBigInteger(byte[])}.
+     * @param b the integer to format into a byte array
+     * @param numBytes the desired size of the resulting byte array
+     * @return numBytes byte long array.
+     */
+    public static byte[] bigIntegerToBytes(BigInteger b, int numBytes) {
+        checkArgument(b.signum() >= 0, "b must be positive or zero");
+        checkArgument(numBytes > 0, "numBytes must be positive");
+        byte[] src = b.toByteArray();
+        byte[] dest = new byte[numBytes];
+        boolean isFirstByteOnlyForSign = src[0] == 0;
+        int length = isFirstByteOnlyForSign ? src.length - 1 : src.length;
+        checkArgument(length <= numBytes, "The given number does not fit in " + numBytes);
+        int srcPos = isFirstByteOnlyForSign ? 1 : 0;
+        int destPos = numBytes - length;
+        System.arraycopy(src, srcPos, dest, destPos, length);
+        return dest;
+    }
+
+    /**
+     * Converts an array of bytes into a positive BigInteger. This is the antagonist to
+     * {@link #bigIntegerToBytes(BigInteger, int)}.
+     *
+     * @param bytes to convert into a BigInteger
+     * @return the converted BigInteger
+     */
+    public static BigInteger bytesToBigInteger(byte[] bytes) {
+        return new BigInteger(1, bytes);
+    }
+
+    /** Write 2 bytes to the byte array (starting at the offset) as unsigned 16-bit integer in little endian format. */
+    public static void uint16ToByteArrayLE(int val, byte[] out, int offset) {
+        out[offset] = (byte) (0xFF & val);
+        out[offset + 1] = (byte) (0xFF & (val >> 8));
+    }
+
+    /** Write 4 bytes to the byte array (starting at the offset) as unsigned 32-bit integer in little endian format. */
+    public static void uint32ToByteArrayLE(long val, byte[] out, int offset) {
+        out[offset] = (byte) (0xFF & val);
+        out[offset + 1] = (byte) (0xFF & (val >> 8));
+        out[offset + 2] = (byte) (0xFF & (val >> 16));
+        out[offset + 3] = (byte) (0xFF & (val >> 24));
+    }
+
+    /** Write 4 bytes to the byte array (starting at the offset) as unsigned 32-bit integer in big endian format. */
+    public static void uint32ToByteArrayBE(long val, byte[] out, int offset) {
+        out[offset] = (byte) (0xFF & (val >> 24));
+        out[offset + 1] = (byte) (0xFF & (val >> 16));
+        out[offset + 2] = (byte) (0xFF & (val >> 8));
+        out[offset + 3] = (byte) (0xFF & val);
+    }
+
+    /** Write 8 bytes to the byte array (starting at the offset) as signed 64-bit integer in little endian format. */
+    public static void int64ToByteArrayLE(long val, byte[] out, int offset) {
+        out[offset] = (byte) (0xFF & val);
+        out[offset + 1] = (byte) (0xFF & (val >> 8));
+        out[offset + 2] = (byte) (0xFF & (val >> 16));
+        out[offset + 3] = (byte) (0xFF & (val >> 24));
+        out[offset + 4] = (byte) (0xFF & (val >> 32));
+        out[offset + 5] = (byte) (0xFF & (val >> 40));
+        out[offset + 6] = (byte) (0xFF & (val >> 48));
+        out[offset + 7] = (byte) (0xFF & (val >> 56));
+    }
+
+    /** Write 2 bytes to the output stream as unsigned 16-bit integer in little endian format. */
+    public static void uint16ToByteStreamLE(int val, OutputStream stream) throws IOException {
+        stream.write((int) (0xFF & val));
+        stream.write((int) (0xFF & (val >> 8)));
+    }
+
+    /** Write 2 bytes to the output stream as unsigned 16-bit integer in big endian format. */
+    public static void uint16ToByteStreamBE(int val, OutputStream stream) throws IOException {
+        stream.write((int) (0xFF & (val >> 8)));
+        stream.write((int) (0xFF & val));
+    }
+
+    /** Write 4 bytes to the output stream as unsigned 32-bit integer in little endian format. */
+    public static void uint32ToByteStreamLE(long val, OutputStream stream) throws IOException {
+        stream.write((int) (0xFF & val));
+        stream.write((int) (0xFF & (val >> 8)));
+        stream.write((int) (0xFF & (val >> 16)));
+        stream.write((int) (0xFF & (val >> 24)));
+    }
+
+    /** Write 4 bytes to the output stream as unsigned 32-bit integer in big endian format. */
+    public static void uint32ToByteStreamBE(long val, OutputStream stream) throws IOException {
+        stream.write((int) (0xFF & (val >> 24)));
+        stream.write((int) (0xFF & (val >> 16)));
+        stream.write((int) (0xFF & (val >> 8)));
+        stream.write((int) (0xFF & val));
+    }
+
+    /** Write 8 bytes to the output stream as signed 64-bit integer in little endian format. */
+    public static void int64ToByteStreamLE(long val, OutputStream stream) throws IOException {
+        stream.write((int) (0xFF & val));
+        stream.write((int) (0xFF & (val >> 8)));
+        stream.write((int) (0xFF & (val >> 16)));
+        stream.write((int) (0xFF & (val >> 24)));
+        stream.write((int) (0xFF & (val >> 32)));
+        stream.write((int) (0xFF & (val >> 40)));
+        stream.write((int) (0xFF & (val >> 48)));
+        stream.write((int) (0xFF & (val >> 56)));
+    }
+
+    /** Write 8 bytes to the output stream as unsigned 64-bit integer in little endian format. */
+    public static void uint64ToByteStreamLE(BigInteger val, OutputStream stream) throws IOException {
+        byte[] bytes = val.toByteArray();
+        if (bytes.length > 8) {
+            throw new RuntimeException("Input too large to encode into a uint64");
+        }
+        bytes = reverseBytes(bytes);
+        stream.write(bytes);
+        if (bytes.length < 8) {
+            for (int i = 0; i < 8 - bytes.length; i++)
+                stream.write(0);
+        }
+    }
+
+    /** Parse 2 bytes from the byte array (starting at the offset) as unsigned 16-bit integer in little endian format. */
+    public static int readUint16(byte[] bytes, int offset) {
+        return (bytes[offset] & 0xff) |
+                ((bytes[offset + 1] & 0xff) << 8);
+    }
+
+    /** Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in little endian format. */
+    public static long readUint32(byte[] bytes, int offset) {
+        return (bytes[offset] & 0xffl) |
+                ((bytes[offset + 1] & 0xffl) << 8) |
+                ((bytes[offset + 2] & 0xffl) << 16) |
+                ((bytes[offset + 3] & 0xffl) << 24);
+    }
+
+    /** Parse 8 bytes from the byte array (starting at the offset) as signed 64-bit integer in little endian format. */
+    public static long readInt64(byte[] bytes, int offset) {
+        return (bytes[offset] & 0xffl) |
+               ((bytes[offset + 1] & 0xffl) << 8) |
+               ((bytes[offset + 2] & 0xffl) << 16) |
+               ((bytes[offset + 3] & 0xffl) << 24) |
+               ((bytes[offset + 4] & 0xffl) << 32) |
+               ((bytes[offset + 5] & 0xffl) << 40) |
+               ((bytes[offset + 6] & 0xffl) << 48) |
+               ((bytes[offset + 7] & 0xffl) << 56);
+    }
+
+    /** Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in big endian format. */
+    public static long readUint32BE(byte[] bytes, int offset) {
+        return ((bytes[offset] & 0xffl) << 24) |
+                ((bytes[offset + 1] & 0xffl) << 16) |
+                ((bytes[offset + 2] & 0xffl) << 8) |
+                (bytes[offset + 3] & 0xffl);
+    }
+
+    /** Parse 2 bytes from the byte array (starting at the offset) as unsigned 16-bit integer in big endian format. */
+    public static int readUint16BE(byte[] bytes, int offset) {
+        return ((bytes[offset] & 0xff) << 8) |
+                (bytes[offset + 1] & 0xff);
+    }
+
+    /** Parse 2 bytes from the stream as unsigned 16-bit integer in little endian format. */
+    public static int readUint16FromStream(InputStream is) {
+        try {
+            return (is.read() & 0xff) |
+                    ((is.read() & 0xff) << 8);
+        } catch (IOException x) {
+            throw new RuntimeException(x);
+        }
+    }
+
+    /** Parse 4 bytes from the stream as unsigned 32-bit integer in little endian format. */
+    public static long readUint32FromStream(InputStream is) {
+        try {
+            return (is.read() & 0xffl) |
+                    ((is.read() & 0xffl) << 8) |
+                    ((is.read() & 0xffl) << 16) |
+                    ((is.read() & 0xffl) << 24);
+        } catch (IOException x) {
+            throw new RuntimeException(x);
+        }
+    }
+
+    /**
+     * Returns a copy of the given byte array in reverse order.
+     */
+    public static byte[] reverseBytes(byte[] bytes) {
+        // We could use the XOR trick here but it's easier to understand if we don't. If we find this is really a
+        // performance issue the matter can be revisited.
+        byte[] buf = new byte[bytes.length];
+        for (int i = 0; i < bytes.length; i++)
+            buf[i] = bytes[bytes.length - 1 - i];
+        return buf;
+    }
+
+    /**
+     * MPI encoded numbers are produced by the OpenSSL BN_bn2mpi function. They consist of
+     * a 4 byte big endian length field, followed by the stated number of bytes representing
+     * the number in big endian format (with a sign bit).
+     * @param hasLength can be set to false if the given array is missing the 4 byte length field
+     */
+    public static BigInteger decodeMPI(byte[] mpi, boolean hasLength) {
+        byte[] buf;
+        if (hasLength) {
+            int length = (int) readUint32BE(mpi, 0);
+            buf = new byte[length];
+            System.arraycopy(mpi, 4, buf, 0, length);
+        } else
+            buf = mpi;
+        if (buf.length == 0)
+            return BigInteger.ZERO;
+        boolean isNegative = (buf[0] & 0x80) == 0x80;
+        if (isNegative)
+            buf[0] &= 0x7f;
+        BigInteger result = new BigInteger(buf);
+        return isNegative ? result.negate() : result;
+    }
+
+    /**
+     * MPI encoded numbers are produced by the OpenSSL BN_bn2mpi function. They consist of
+     * a 4 byte big endian length field, followed by the stated number of bytes representing
+     * the number in big endian format (with a sign bit).
+     * @param includeLength indicates whether the 4 byte length field should be included
+     */
+    public static byte[] encodeMPI(BigInteger value, boolean includeLength) {
+        if (value.equals(BigInteger.ZERO)) {
+            if (!includeLength)
+                return new byte[] {};
+            else
+                return new byte[] {0x00, 0x00, 0x00, 0x00};
+        }
+        boolean isNegative = value.signum() < 0;
+        if (isNegative)
+            value = value.negate();
+        byte[] array = value.toByteArray();
+        int length = array.length;
+        if ((array[0] & 0x80) == 0x80)
+            length++;
+        if (includeLength) {
+            byte[] result = new byte[length + 4];
+            System.arraycopy(array, 0, result, length - array.length + 3, array.length);
+            uint32ToByteArrayBE(length, result, 0);
+            if (isNegative)
+                result[4] |= 0x80;
+            return result;
+        } else {
+            byte[] result;
+            if (length != array.length) {
+                result = new byte[length];
+                System.arraycopy(array, 0, result, 1, array.length);
+            }else
+                result = array;
+            if (isNegative)
+                result[0] |= 0x80;
+            return result;
+        }
+    }
+
+    /**
+     * <p>The "compact" format is a representation of a whole number N using an unsigned 32 bit number similar to a
+     * floating point format. The most significant 8 bits are the unsigned exponent of base 256. This exponent can
+     * be thought of as "number of bytes of N". The lower 23 bits are the mantissa. Bit number 24 (0x800000) represents
+     * the sign of N. Therefore, N = (-1^sign) * mantissa * 256^(exponent-3).</p>
+     *
+     * <p>Satoshi's original implementation used BN_bn2mpi() and BN_mpi2bn(). MPI uses the most significant bit of the
+     * first byte as sign. Thus 0x1234560000 is compact 0x05123456 and 0xc0de000000 is compact 0x0600c0de. Compact
+     * 0x05c0de00 would be -0x40de000000.</p>
+     *
+     * <p>Bitcoin only uses this "compact" format for encoding difficulty targets, which are unsigned 256bit quantities.
+     * Thus, all the complexities of the sign bit and using base 256 are probably an implementation accident.</p>
+     */
+    public static BigInteger decodeCompactBits(long compact) {
+        int size = ((int) (compact >> 24)) & 0xFF;
+        byte[] bytes = new byte[4 + size];
+        bytes[3] = (byte) size;
+        if (size >= 1) bytes[4] = (byte) ((compact >> 16) & 0xFF);
+        if (size >= 2) bytes[5] = (byte) ((compact >> 8) & 0xFF);
+        if (size >= 3) bytes[6] = (byte) (compact & 0xFF);
+        return decodeMPI(bytes, true);
+    }
+
+    /**
+     * @see #decodeCompactBits(long)
+     */
+    public static long encodeCompactBits(BigInteger value) {
+        long result;
+        int size = value.toByteArray().length;
+        if (size <= 3)
+            result = value.longValue() << 8 * (3 - size);
+        else
+            result = value.shiftRight(8 * (size - 3)).longValue();
+        // The 0x00800000 bit denotes the sign.
+        // Thus, if it is already set, divide the mantissa by 256 and increase the exponent.
+        if ((result & 0x00800000L) != 0) {
+            result >>= 8;
+            size++;
+        }
+        result |= size << 24;
+        result |= value.signum() == -1 ? 0x00800000 : 0;
+        return result;
+    }
+
+    /** Checks if the given bit is set in data, using little endian (not the same as Java native big endian) */
+    public static boolean checkBitLE(byte[] data, int index) {
+        return (data[index >>> 3] & bitMask[7 & index]) != 0;
+    }
+
+    /** Sets the given bit in data to one, using little endian (not the same as Java native big endian) */
+    public static void setBitLE(byte[] data, int index) {
+        data[index >>> 3] |= bitMask[7 & index];
+    }
+}
diff --git a/core/src/main/java/org/bitcoinj/core/AbstractBlockChain.java b/core/src/main/java/org/bitcoinj/core/AbstractBlockChain.java
index 875a31cdd..d59639a22 100644
--- a/core/src/main/java/org/bitcoinj/core/AbstractBlockChain.java
+++ b/core/src/main/java/org/bitcoinj/core/AbstractBlockChain.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import com.google.common.base.Preconditions;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.listeners.NewBestBlockListener;
 import org.bitcoinj.core.listeners.ReorganizeListener;
 import org.bitcoinj.core.listeners.TransactionReceivedInBlockListener;
diff --git a/core/src/main/java/org/bitcoinj/core/Base58.java b/core/src/main/java/org/bitcoinj/core/Base58.java
index 9718aa3f7..ee057fa75 100644
--- a/core/src/main/java/org/bitcoinj/core/Base58.java
+++ b/core/src/main/java/org/bitcoinj/core/Base58.java
@@ -17,6 +17,9 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
+
 import java.math.BigInteger;
 import java.util.Arrays;
 
@@ -156,7 +159,7 @@ public class Base58 {
     }
     
     public static BigInteger decodeToBigInteger(String input) throws AddressFormatException {
-        return Utils.bytesToBigInteger(decode(input));
+        return ByteUtils.bytesToBigInteger(decode(input));
     }
 
     /**
diff --git a/core/src/main/java/org/bitcoinj/core/BitcoinSerializer.java b/core/src/main/java/org/bitcoinj/core/BitcoinSerializer.java
index 749ff58f5..e364616e0 100644
--- a/core/src/main/java/org/bitcoinj/core/BitcoinSerializer.java
+++ b/core/src/main/java/org/bitcoinj/core/BitcoinSerializer.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -29,9 +31,9 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 
-import static org.bitcoinj.core.Utils.HEX;
-import static org.bitcoinj.core.Utils.readUint32;
-import static org.bitcoinj.core.Utils.uint32ToByteArrayBE;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.readUint32;
+import static org.bitcoinj.base.utils.ByteUtils.uint32ToByteArrayBE;
 
 /**
  * <p>Methods to serialize and de-serialize messages to the Bitcoin network format as defined in
@@ -128,7 +130,7 @@ public class BitcoinSerializer extends MessageSerializer {
             header[4 + i] = (byte) (name.codePointAt(i) & 0xFF);
         }
 
-        Utils.uint32ToByteArrayLE(message.length, header, 4 + COMMAND_LEN);
+        ByteUtils.uint32ToByteArrayLE(message.length, header, 4 + COMMAND_LEN);
 
         byte[] hash = Sha256Hash.hashTwice(message);
         System.arraycopy(hash, 0, header, 4 + COMMAND_LEN + 4, 4);
diff --git a/core/src/main/java/org/bitcoinj/core/Block.java b/core/src/main/java/org/bitcoinj/core/Block.java
index e6820b87d..f7c693ff8 100644
--- a/core/src/main/java/org/bitcoinj/core/Block.java
+++ b/core/src/main/java/org/bitcoinj/core/Block.java
@@ -20,6 +20,8 @@ package org.bitcoinj.core;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.internal.InternalUtils;
 import org.bitcoinj.params.AbstractBitcoinNetParams;
 import org.bitcoinj.script.Script;
@@ -43,7 +45,7 @@ import java.util.Locale;
 
 import static com.google.common.base.Preconditions.checkState;
 import static org.bitcoinj.base.Coin.FIFTY_COINS;
-import static org.bitcoinj.core.Sha256Hash.hashTwice;
+import static org.bitcoinj.base.Sha256Hash.hashTwice;
 
 /**
  * <p>A block is a group of transactions, and is one of the fundamental data structures of the Bitcoin system.
@@ -285,14 +287,14 @@ public class Block extends Message {
     // A script containing the difficulty bits and the following message:
     //
     //   "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks"
-    private static final byte[] genesisTxInputScriptBytes = Utils.HEX.decode
+    private static final byte[] genesisTxInputScriptBytes = ByteUtils.HEX.decode
                 ("04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73");
 
     private static final byte[] genesisTxScriptPubKeyBytes;
     static {
         ByteArrayOutputStream scriptPubKeyBytes = new ByteArrayOutputStream();
         try {
-            Script.writeBytes(scriptPubKeyBytes, Utils.HEX.decode
+            Script.writeBytes(scriptPubKeyBytes, ByteUtils.HEX.decode
                     ("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"));
         } catch (IOException e) {
             throw new RuntimeException(e); // Cannot happen.
@@ -316,12 +318,12 @@ public class Block extends Message {
             return;
         }
         // fall back to manual write
-        Utils.uint32ToByteStreamLE(version, stream);
+        ByteUtils.uint32ToByteStreamLE(version, stream);
         stream.write(prevBlockHash.getReversedBytes());
         stream.write(getMerkleRoot().getReversedBytes());
-        Utils.uint32ToByteStreamLE(time, stream);
-        Utils.uint32ToByteStreamLE(difficultyTarget, stream);
-        Utils.uint32ToByteStreamLE(nonce, stream);
+        ByteUtils.uint32ToByteStreamLE(time, stream);
+        ByteUtils.uint32ToByteStreamLE(difficultyTarget, stream);
+        ByteUtils.uint32ToByteStreamLE(nonce, stream);
     }
 
     private void writeTransactions(OutputStream stream) throws IOException {
@@ -554,7 +556,7 @@ public class Block extends Message {
      * is thrown.
      */
     public BigInteger getDifficultyTargetAsInteger() throws VerificationException {
-        BigInteger target = Utils.decodeCompactBits(difficultyTarget);
+        BigInteger target = ByteUtils.decodeCompactBits(difficultyTarget);
         if (target.signum() <= 0 || target.compareTo(params.maxTarget) > 0)
             throw new VerificationException("Difficulty target is bad: " + target.toString());
         return target;
@@ -696,9 +698,9 @@ public class Block extends Message {
                 // The right hand node can be the same as the left hand, in the case where we don't have enough
                 // transactions.
                 int right = Math.min(left + 1, levelSize - 1);
-                byte[] leftBytes = Utils.reverseBytes(tree.get(levelOffset + left));
-                byte[] rightBytes = Utils.reverseBytes(tree.get(levelOffset + right));
-                tree.add(Utils.reverseBytes(hashTwice(leftBytes, rightBytes)));
+                byte[] leftBytes = ByteUtils.reverseBytes(tree.get(levelOffset + left));
+                byte[] rightBytes = ByteUtils.reverseBytes(tree.get(levelOffset + right));
+                tree.add(ByteUtils.reverseBytes(hashTwice(leftBytes, rightBytes)));
             }
             // Move to the next level.
             levelOffset += levelSize;
diff --git a/core/src/main/java/org/bitcoinj/core/BlockChain.java b/core/src/main/java/org/bitcoinj/core/BlockChain.java
index 37659181c..027365130 100644
--- a/core/src/main/java/org/bitcoinj/core/BlockChain.java
+++ b/core/src/main/java/org/bitcoinj/core/BlockChain.java
@@ -17,6 +17,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.store.BlockStore;
 import org.bitcoinj.store.BlockStoreException;
 import org.bitcoinj.store.MemoryBlockStore;
diff --git a/core/src/main/java/org/bitcoinj/core/BlockLocator.java b/core/src/main/java/org/bitcoinj/core/BlockLocator.java
index 85edb78b1..6cd88ac6c 100644
--- a/core/src/main/java/org/bitcoinj/core/BlockLocator.java
+++ b/core/src/main/java/org/bitcoinj/core/BlockLocator.java
@@ -16,6 +16,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.internal.InternalUtils;
 
 import java.util.Collections;
diff --git a/core/src/main/java/org/bitcoinj/core/BloomFilter.java b/core/src/main/java/org/bitcoinj/core/BloomFilter.java
index 76784e470..635dca1a4 100644
--- a/core/src/main/java/org/bitcoinj/core/BloomFilter.java
+++ b/core/src/main/java/org/bitcoinj/core/BloomFilter.java
@@ -18,6 +18,8 @@
 package org.bitcoinj.core;
 
 import com.google.common.base.MoreObjects;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.script.Script;
 import org.bitcoinj.script.ScriptChunk;
 import org.bitcoinj.script.ScriptPattern;
@@ -161,8 +163,8 @@ public class BloomFilter extends Message {
     protected void bitcoinSerializeToStream(OutputStream stream) throws IOException {
         stream.write(new VarInt(data.length).encode());
         stream.write(data);
-        Utils.uint32ToByteStreamLE(hashFuncs, stream);
-        Utils.uint32ToByteStreamLE(nTweak, stream);
+        ByteUtils.uint32ToByteStreamLE(hashFuncs, stream);
+        ByteUtils.uint32ToByteStreamLE(nTweak, stream);
         stream.write(nFlags);
     }
 
@@ -231,7 +233,7 @@ public class BloomFilter extends Message {
      */
     public synchronized boolean contains(byte[] object) {
         for (int i = 0; i < hashFuncs; i++) {
-            if (!Utils.checkBitLE(data, murmurHash3(data, nTweak, i, object)))
+            if (!ByteUtils.checkBitLE(data, murmurHash3(data, nTweak, i, object)))
                 return false;
         }
         return true;
@@ -240,7 +242,7 @@ public class BloomFilter extends Message {
     /** Insert the given arbitrary data into the filter */
     public synchronized void insert(byte[] object) {
         for (int i = 0; i < hashFuncs; i++)
-            Utils.setBitLE(data, murmurHash3(data, nTweak, i, object));
+            ByteUtils.setBitLE(data, murmurHash3(data, nTweak, i, object));
     }
 
     /** Inserts the given key and equivalent hashed form (for the address). */
@@ -322,7 +324,7 @@ public class BloomFilter extends Message {
             Transaction tx = txns.get(i);
             txHashes.add(tx.getTxId());
             if (applyAndUpdate(tx)) {
-                Utils.setBitLE(bits, i);
+                ByteUtils.setBitLE(bits, i);
                 matched.add(tx);
             }
         }
diff --git a/core/src/main/java/org/bitcoinj/core/CheckpointManager.java b/core/src/main/java/org/bitcoinj/core/CheckpointManager.java
index 42bd669ef..c38ea3b24 100644
--- a/core/src/main/java/org/bitcoinj/core/CheckpointManager.java
+++ b/core/src/main/java/org/bitcoinj/core/CheckpointManager.java
@@ -20,6 +20,7 @@ import com.google.common.hash.HashCode;
 import com.google.common.hash.Hasher;
 import com.google.common.hash.Hashing;
 import com.google.common.io.BaseEncoding;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.store.BlockStore;
 import org.bitcoinj.store.BlockStoreException;
 import org.bitcoinj.store.FullPrunedBlockStore;
diff --git a/core/src/main/java/org/bitcoinj/core/ECKey.java b/core/src/main/java/org/bitcoinj/core/ECKey.java
index 5eae9c4f4..1a761f9bb 100644
--- a/core/src/main/java/org/bitcoinj/core/ECKey.java
+++ b/core/src/main/java/org/bitcoinj/core/ECKey.java
@@ -24,6 +24,8 @@ import com.google.common.primitives.UnsignedBytes;
 import org.bitcoin.NativeSecp256k1;
 import org.bitcoin.NativeSecp256k1Util;
 import org.bitcoin.Secp256k1Context;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.crypto.EncryptableItem;
 import org.bitcoinj.crypto.EncryptedData;
 import org.bitcoinj.crypto.KeyCrypter;
@@ -232,7 +234,7 @@ public class ECKey implements EncryptableItem {
      * public key is compressed.
      */
     public static ECKey fromPrivate(byte[] privKeyBytes) {
-        return fromPrivate(Utils.bytesToBigInteger(privKeyBytes));
+        return fromPrivate(ByteUtils.bytesToBigInteger(privKeyBytes));
     }
 
     /**
@@ -240,7 +242,7 @@ public class ECKey implements EncryptableItem {
      * @param compressed Determines whether the resulting ECKey will use a compressed encoding for the public key.
      */
     public static ECKey fromPrivate(byte[] privKeyBytes, boolean compressed) {
-        return fromPrivate(Utils.bytesToBigInteger(privKeyBytes), compressed);
+        return fromPrivate(ByteUtils.bytesToBigInteger(privKeyBytes), compressed);
     }
 
     /**
@@ -261,7 +263,7 @@ public class ECKey implements EncryptableItem {
     public static ECKey fromPrivateAndPrecalculatedPublic(byte[] priv, byte[] pub) {
         checkNotNull(priv);
         checkNotNull(pub);
-        return new ECKey(Utils.bytesToBigInteger(priv), new LazyECPoint(CURVE.getCurve(), pub));
+        return new ECKey(ByteUtils.bytesToBigInteger(priv), new LazyECPoint(CURVE.getCurve(), pub));
     }
 
     /**
@@ -359,7 +361,7 @@ public class ECKey implements EncryptableItem {
 
     /**
      * Returns public key bytes from the given private key. To convert a byte array into a BigInteger,
-     * use {@link Utils#bytesToBigInteger(byte[])}
+     * use {@link ByteUtils#bytesToBigInteger(byte[])}
      */
     public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) {
         ECPoint point = publicPointFromPrivate(privKey);
@@ -368,7 +370,7 @@ public class ECKey implements EncryptableItem {
 
     /**
      * Returns public key point from the given private key. To convert a byte array into a BigInteger,
-     * use {@link Utils#bytesToBigInteger(byte[])}
+     * use {@link ByteUtils#bytesToBigInteger(byte[])}
      */
     public static ECPoint publicPointFromPrivate(BigInteger privKey) {
         /*
@@ -577,7 +579,7 @@ public class ECKey implements EncryptableItem {
             try {
                 byte[] signature = NativeSecp256k1.sign(
                         input.getBytes(),
-                        Utils.bigIntegerToBytes(privateKeyForSigning, 32)
+                        ByteUtils.bigIntegerToBytes(privateKeyForSigning, 32)
                 );
                 return ECDSASignature.decodeFromDER(signature);
             } catch (NativeSecp256k1Util.AssertFailException e) {
@@ -715,7 +717,7 @@ public class ECKey implements EncryptableItem {
         else if (encoded.length == 65 && encoded[0] == 0x04)
             return false;
         else
-            throw new IllegalArgumentException(Utils.HEX.encode(encoded));
+            throw new IllegalArgumentException(ByteUtils.HEX.encode(encoded));
     }
 
     private static ECKey extractKeyFromASN1(byte[] asn1privkey) {
@@ -741,7 +743,7 @@ public class ECKey implements EncryptableItem {
                     "Input is of wrong version");
 
             byte[] privbits = ((ASN1OctetString) seq.getObjectAt(1)).getOctets();
-            BigInteger privkey = Utils.bytesToBigInteger(privbits);
+            BigInteger privkey = ByteUtils.bytesToBigInteger(privbits);
 
             ASN1TaggedObject pubkey = (ASN1TaggedObject) seq.getObjectAt(3);
             checkArgument(pubkey.getTagNo() == 1, "Input has 'publicKey' with bad tag number");
@@ -788,8 +790,8 @@ public class ECKey implements EncryptableItem {
         int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
         byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
         sigData[0] = (byte)headerByte;
-        System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
-        System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
+        System.arraycopy(ByteUtils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
+        System.arraycopy(ByteUtils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
         return new String(Base64.encode(sigData), StandardCharsets.UTF_8);
     }
 
@@ -820,8 +822,8 @@ public class ECKey implements EncryptableItem {
         //                  0x1D = second key with even y, 0x1E = second key with odd y
         if (header < 27 || header > 34)
             throw new SignatureException("Header byte out of range: " + header);
-        BigInteger r = Utils.bytesToBigInteger(Arrays.copyOfRange(signatureEncoded, 1, 33));
-        BigInteger s = Utils.bytesToBigInteger(Arrays.copyOfRange(signatureEncoded, 33, 65));
+        BigInteger r = ByteUtils.bytesToBigInteger(Arrays.copyOfRange(signatureEncoded, 1, 33));
+        BigInteger s = ByteUtils.bytesToBigInteger(Arrays.copyOfRange(signatureEncoded, 33, 65));
         ECDSASignature sig = new ECDSASignature(r, s);
         byte[] messageBytes = formatMessageForSigning(message);
         // Note that the C++ code doesn't actually seem to specify any character encoding. Presumably it's whatever
@@ -952,7 +954,7 @@ public class ECKey implements EncryptableItem {
      * @throws org.bitcoinj.core.ECKey.MissingPrivateKeyException if the private key bytes are missing/encrypted.
      */
     public byte[] getPrivKeyBytes() {
-        return Utils.bigIntegerToBytes(getPrivKey(), 32);
+        return ByteUtils.bigIntegerToBytes(getPrivKey(), 32);
     }
 
     /**
@@ -1165,11 +1167,11 @@ public class ECKey implements EncryptableItem {
     }
 
     public String getPrivateKeyAsHex() {
-        return Utils.HEX.encode(getPrivKeyBytes());
+        return ByteUtils.HEX.encode(getPrivKeyBytes());
     }
 
     public String getPublicKeyAsHex() {
-        return Utils.HEX.encode(pub.getEncoded());
+        return ByteUtils.HEX.encode(pub.getEncoded());
     }
 
     public String getPrivateKeyAsWiF(NetworkParameters params) {
@@ -1214,7 +1216,7 @@ public class ECKey implements EncryptableItem {
         if (!isCompressed())
             builder.append("  UNCOMPRESSED");
         builder.append("  hash160:");
-        builder.append(Utils.HEX.encode(getPubKeyHash()));
+        builder.append(ByteUtils.HEX.encode(getPubKeyHash()));
         if (creationTimeSeconds > 0)
             builder.append("  creationTimeSeconds:").append(creationTimeSeconds).append(" [")
                     .append(Utils.dateTimeFormat(creationTimeSeconds * 1000)).append("]");
diff --git a/core/src/main/java/org/bitcoinj/core/FeeFilterMessage.java b/core/src/main/java/org/bitcoinj/core/FeeFilterMessage.java
index bd164b5d1..aa283f19f 100644
--- a/core/src/main/java/org/bitcoinj/core/FeeFilterMessage.java
+++ b/core/src/main/java/org/bitcoinj/core/FeeFilterMessage.java
@@ -17,6 +17,7 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.utils.ByteUtils;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -40,7 +41,7 @@ public class FeeFilterMessage extends Message {
     @Override
     protected void bitcoinSerializeToStream(OutputStream stream) throws IOException {
         super.bitcoinSerializeToStream(stream);
-        Utils.uint64ToByteStreamLE(BigInteger.valueOf(feeRate.value), stream);
+        ByteUtils.uint64ToByteStreamLE(BigInteger.valueOf(feeRate.value), stream);
     }
 
     @Override
diff --git a/core/src/main/java/org/bitcoinj/core/FilteredBlock.java b/core/src/main/java/org/bitcoinj/core/FilteredBlock.java
index 25c7df8a8..ce36cc4a5 100644
--- a/core/src/main/java/org/bitcoinj/core/FilteredBlock.java
+++ b/core/src/main/java/org/bitcoinj/core/FilteredBlock.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Collections;
diff --git a/core/src/main/java/org/bitcoinj/core/FullPrunedBlockChain.java b/core/src/main/java/org/bitcoinj/core/FullPrunedBlockChain.java
index 692cb1f8d..95a9c664c 100644
--- a/core/src/main/java/org/bitcoinj/core/FullPrunedBlockChain.java
+++ b/core/src/main/java/org/bitcoinj/core/FullPrunedBlockChain.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.params.AbstractBitcoinNetParams;
 import org.bitcoinj.script.Script;
 import org.bitcoinj.script.Script.VerifyFlag;
diff --git a/core/src/main/java/org/bitcoinj/core/GetBlocksMessage.java b/core/src/main/java/org/bitcoinj/core/GetBlocksMessage.java
index 914adf6c0..a62c0ef7f 100644
--- a/core/src/main/java/org/bitcoinj/core/GetBlocksMessage.java
+++ b/core/src/main/java/org/bitcoinj/core/GetBlocksMessage.java
@@ -17,6 +17,9 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
+
 import java.io.IOException;
 import java.io.OutputStream;
 
@@ -74,7 +77,7 @@ public class GetBlocksMessage extends Message {
     @Override
     protected void bitcoinSerializeToStream(OutputStream stream) throws IOException {
         // Version, for some reason.
-        Utils.uint32ToByteStreamLE(serializer.getProtocolVersion(), stream);
+        ByteUtils.uint32ToByteStreamLE(serializer.getProtocolVersion(), stream);
         // Then a vector of block hashes. This is actually a "block locator", a set of block
         // identifiers that spans the entire chain with exponentially increasing gaps between
         // them, until we end up at the genesis block. See CBlockLocator::Set()
diff --git a/core/src/main/java/org/bitcoinj/core/GetDataMessage.java b/core/src/main/java/org/bitcoinj/core/GetDataMessage.java
index 2019f6c04..ff102fed7 100644
--- a/core/src/main/java/org/bitcoinj/core/GetDataMessage.java
+++ b/core/src/main/java/org/bitcoinj/core/GetDataMessage.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+
 /**
  * <p>Represents the "getdata" P2P network message, which requests the contents of blocks or transactions given their
  * hashes.</p>
diff --git a/core/src/main/java/org/bitcoinj/core/GetHeadersMessage.java b/core/src/main/java/org/bitcoinj/core/GetHeadersMessage.java
index 35f8ab59e..573026d95 100644
--- a/core/src/main/java/org/bitcoinj/core/GetHeadersMessage.java
+++ b/core/src/main/java/org/bitcoinj/core/GetHeadersMessage.java
@@ -16,6 +16,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+
 /**
  * <p>The "getheaders" command is structurally identical to "getblocks", but has different meaning. On receiving this
  * message a Bitcoin node returns matching blocks up to the limit, but without the bodies. It is useful as an
diff --git a/core/src/main/java/org/bitcoinj/core/InventoryItem.java b/core/src/main/java/org/bitcoinj/core/InventoryItem.java
index 9b017b332..df7f99b84 100644
--- a/core/src/main/java/org/bitcoinj/core/InventoryItem.java
+++ b/core/src/main/java/org/bitcoinj/core/InventoryItem.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+
 import java.util.Objects;
 
 public class InventoryItem {
diff --git a/core/src/main/java/org/bitcoinj/core/ListMessage.java b/core/src/main/java/org/bitcoinj/core/ListMessage.java
index 0928eefd9..91dc770ce 100644
--- a/core/src/main/java/org/bitcoinj/core/ListMessage.java
+++ b/core/src/main/java/org/bitcoinj/core/ListMessage.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import com.google.common.base.MoreObjects;
+import org.bitcoinj.base.utils.ByteUtils;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -99,7 +100,7 @@ public abstract class ListMessage extends Message {
         stream.write(new VarInt(items.size()).encode());
         for (InventoryItem i : items) {
             // Write out the type code.
-            Utils.uint32ToByteStreamLE(i.type.code, stream);
+            ByteUtils.uint32ToByteStreamLE(i.type.code, stream);
             // And now the hash.
             stream.write(i.hash.getReversedBytes());
         }
diff --git a/core/src/main/java/org/bitcoinj/core/Message.java b/core/src/main/java/org/bitcoinj/core/Message.java
index c72fd7a03..f084e69e6 100644
--- a/core/src/main/java/org/bitcoinj/core/Message.java
+++ b/core/src/main/java/org/bitcoinj/core/Message.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -271,7 +273,7 @@ public abstract class Message {
 
     protected long readUint32() throws ProtocolException {
         try {
-            long u = Utils.readUint32(payload, cursor);
+            long u = ByteUtils.readUint32(payload, cursor);
             cursor += 4;
             return u;
         } catch (ArrayIndexOutOfBoundsException e) {
@@ -281,7 +283,7 @@ public abstract class Message {
 
     protected long readInt64() throws ProtocolException {
         try {
-            long u = Utils.readInt64(payload, cursor);
+            long u = ByteUtils.readInt64(payload, cursor);
             cursor += 8;
             return u;
         } catch (ArrayIndexOutOfBoundsException e) {
@@ -291,7 +293,7 @@ public abstract class Message {
 
     protected BigInteger readUint64() throws ProtocolException {
         // Java does not have an unsigned 64 bit type. So scrape it off the wire then flip.
-        return new BigInteger(Utils.reverseBytes(readBytes(8)));
+        return new BigInteger(ByteUtils.reverseBytes(readBytes(8)));
     }
 
     protected VarInt readVarInt() throws ProtocolException {
diff --git a/core/src/main/java/org/bitcoinj/core/NetworkParameters.java b/core/src/main/java/org/bitcoinj/core/NetworkParameters.java
index c4335b5f8..ffa115cd9 100644
--- a/core/src/main/java/org/bitcoinj/core/NetworkParameters.java
+++ b/core/src/main/java/org/bitcoinj/core/NetworkParameters.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.RegTestParams;
 import org.bitcoinj.params.SigNetParams;
diff --git a/core/src/main/java/org/bitcoinj/core/PartialMerkleTree.java b/core/src/main/java/org/bitcoinj/core/PartialMerkleTree.java
index ceb2aea7a..dc8799eb1 100644
--- a/core/src/main/java/org/bitcoinj/core/PartialMerkleTree.java
+++ b/core/src/main/java/org/bitcoinj/core/PartialMerkleTree.java
@@ -18,6 +18,9 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
+
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.ArrayList;
@@ -25,9 +28,9 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 
-import static org.bitcoinj.core.Utils.checkBitLE;
-import static org.bitcoinj.core.Utils.reverseBytes;
-import static org.bitcoinj.core.Utils.uint32ToByteStreamLE;
+import static org.bitcoinj.base.utils.ByteUtils.checkBitLE;
+import static org.bitcoinj.base.utils.ByteUtils.reverseBytes;
+import static org.bitcoinj.base.utils.ByteUtils.uint32ToByteStreamLE;
 
 /**
  * <p>A data structure that contains proofs of block inclusion for one or more transactions, in an efficient manner.</p>
@@ -99,7 +102,7 @@ public class PartialMerkleTree extends Message {
         byte[] bits = new byte[(int)Math.ceil(bitList.size() / 8.0)];
         for (int i = 0; i < bitList.size(); i++)
             if (bitList.get(i))
-                Utils.setBitLE(bits, i);
+                ByteUtils.setBitLE(bits, i);
         return new PartialMerkleTree(params, bits, hashes, allLeafHashes.size());
     }
 
@@ -136,7 +139,7 @@ public class PartialMerkleTree extends Message {
         boolean parentOfMatch = false;
         // Is this node a parent of at least one matched hash?
         for (int p = pos << height; p < (pos+1) << height && p < allLeafHashes.size(); p++) {
-            if (Utils.checkBitLE(includeBits, p)) {
+            if (ByteUtils.checkBitLE(includeBits, p)) {
                 parentOfMatch = true;
                 break;
             }
diff --git a/core/src/main/java/org/bitcoinj/core/Peer.java b/core/src/main/java/org/bitcoinj/core/Peer.java
index ca637ced0..718182fba 100644
--- a/core/src/main/java/org/bitcoinj/core/Peer.java
+++ b/core/src/main/java/org/bitcoinj/core/Peer.java
@@ -22,6 +22,7 @@ import com.google.common.base.Strings;
 import com.google.common.base.Throwables;
 import net.jcip.annotations.GuardedBy;
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.listeners.BlocksDownloadedEventListener;
 import org.bitcoinj.core.listeners.ChainDownloadStartedEventListener;
 import org.bitcoinj.core.listeners.GetDataEventListener;
diff --git a/core/src/main/java/org/bitcoinj/core/PeerAddress.java b/core/src/main/java/org/bitcoinj/core/PeerAddress.java
index a7f0773f1..561ee4bdc 100644
--- a/core/src/main/java/org/bitcoinj/core/PeerAddress.java
+++ b/core/src/main/java/org/bitcoinj/core/PeerAddress.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import com.google.common.io.BaseEncoding;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bouncycastle.jcajce.provider.digest.SHA3;
 
 import java.io.IOException;
@@ -52,7 +53,7 @@ public class PeerAddress extends ChildMessage {
     private long time;
 
     private static final BaseEncoding BASE32 = BaseEncoding.base32().lowerCase();
-    private static final byte[] ONIONCAT_PREFIX = Utils.HEX.decode("fd87d87eeb43");
+    private static final byte[] ONIONCAT_PREFIX = ByteUtils.HEX.decode("fd87d87eeb43");
 
     /**
      * Construct a peer address from a serialized payload.
@@ -130,7 +131,7 @@ public class PeerAddress extends ChildMessage {
             throw new IllegalStateException("invalid protocolVersion: " + protocolVersion);
 
         if (protocolVersion >= 1) {
-            Utils.uint32ToByteStreamLE(time, stream);
+            ByteUtils.uint32ToByteStreamLE(time, stream);
         }
         if (protocolVersion == 2) {
             stream.write(new VarInt(services.longValue()).encode());
@@ -172,7 +173,7 @@ public class PeerAddress extends ChildMessage {
                 throw new IllegalStateException();
             }
         } else {
-            Utils.uint64ToByteStreamLE(services, stream);  // nServices.
+            ByteUtils.uint64ToByteStreamLE(services, stream);  // nServices.
             if (addr != null) {
                 // Java does not provide any utility to map an IPv4 address into IPv6 space, so we have to do it by
                 // hand.
@@ -199,7 +200,7 @@ public class PeerAddress extends ChildMessage {
             }
         }
         // And write out the port. Unlike the rest of the protocol, address and port is in big endian byte order.
-        Utils.uint16ToByteStreamBE(port, stream);
+        ByteUtils.uint16ToByteStreamBE(port, stream);
     }
 
     @Override
@@ -271,7 +272,7 @@ public class PeerAddress extends ChildMessage {
                 hostname = null;
             }
         }
-        port = Utils.readUint16BE(payload, cursor);
+        port = ByteUtils.readUint16BE(payload, cursor);
         cursor += 2;
         length += 2;
     }
diff --git a/core/src/main/java/org/bitcoinj/core/Ping.java b/core/src/main/java/org/bitcoinj/core/Ping.java
index 0a7f74b0b..7ed4b2741 100644
--- a/core/src/main/java/org/bitcoinj/core/Ping.java
+++ b/core/src/main/java/org/bitcoinj/core/Ping.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
+
 import java.io.IOException;
 import java.io.OutputStream;
 
@@ -51,7 +53,7 @@ public class Ping extends Message {
     @Override
     public void bitcoinSerializeToStream(OutputStream stream) throws IOException {
         if (hasNonce)
-            Utils.int64ToByteStreamLE(nonce, stream);
+            ByteUtils.int64ToByteStreamLE(nonce, stream);
     }
 
     @Override
diff --git a/core/src/main/java/org/bitcoinj/core/Pong.java b/core/src/main/java/org/bitcoinj/core/Pong.java
index d5a170dd9..979a969f4 100644
--- a/core/src/main/java/org/bitcoinj/core/Pong.java
+++ b/core/src/main/java/org/bitcoinj/core/Pong.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
+
 import java.io.IOException;
 import java.io.OutputStream;
 
@@ -46,7 +48,7 @@ public class Pong extends Message {
     
     @Override
     public void bitcoinSerializeToStream(OutputStream stream) throws IOException {
-        Utils.int64ToByteStreamLE(nonce, stream);
+        ByteUtils.int64ToByteStreamLE(nonce, stream);
     }
     
     /** Returns the nonce sent by the remote peer. */
diff --git a/core/src/main/java/org/bitcoinj/core/PrunedException.java b/core/src/main/java/org/bitcoinj/core/PrunedException.java
index df67dafde..5e6ca1fdc 100644
--- a/core/src/main/java/org/bitcoinj/core/PrunedException.java
+++ b/core/src/main/java/org/bitcoinj/core/PrunedException.java
@@ -18,6 +18,8 @@ package org.bitcoinj.core;
 
 // TODO: Rename PrunedException to something like RequiredDataWasPrunedException
 
+import org.bitcoinj.base.Sha256Hash;
+
 /**
  * PrunedException is thrown in cases where a fully verifying node has deleted (pruned) old block data that turned
  * out to be necessary for handling a re-org. Normally this should never happen unless you're playing with the testnet
diff --git a/core/src/main/java/org/bitcoinj/core/RejectMessage.java b/core/src/main/java/org/bitcoinj/core/RejectMessage.java
index 901935e77..3d1e62676 100644
--- a/core/src/main/java/org/bitcoinj/core/RejectMessage.java
+++ b/core/src/main/java/org/bitcoinj/core/RejectMessage.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
diff --git a/core/src/main/java/org/bitcoinj/core/StoredBlock.java b/core/src/main/java/org/bitcoinj/core/StoredBlock.java
index b9588ee35..a2c78c1b3 100644
--- a/core/src/main/java/org/bitcoinj/core/StoredBlock.java
+++ b/core/src/main/java/org/bitcoinj/core/StoredBlock.java
@@ -16,6 +16,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.store.BlockStore;
 import org.bitcoinj.store.BlockStoreException;
 
@@ -142,7 +143,7 @@ public class StoredBlock {
     public static StoredBlock deserializeCompact(NetworkParameters params, ByteBuffer buffer) throws ProtocolException {
         byte[] chainWorkBytes = new byte[StoredBlock.CHAIN_WORK_BYTES];
         buffer.get(chainWorkBytes);
-        BigInteger chainWork = Utils.bytesToBigInteger(chainWorkBytes);
+        BigInteger chainWork = ByteUtils.bytesToBigInteger(chainWorkBytes);
         int height = buffer.getInt();  // +4 bytes
         byte[] header = new byte[Block.HEADER_SIZE + 1];    // Extra byte for the 00 transactions length.
         buffer.get(header, 0, Block.HEADER_SIZE);
diff --git a/core/src/main/java/org/bitcoinj/core/StoredUndoableBlock.java b/core/src/main/java/org/bitcoinj/core/StoredUndoableBlock.java
index 22474af39..6b8d71b15 100644
--- a/core/src/main/java/org/bitcoinj/core/StoredUndoableBlock.java
+++ b/core/src/main/java/org/bitcoinj/core/StoredUndoableBlock.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+
 import java.util.List;
 
 /**
diff --git a/core/src/main/java/org/bitcoinj/core/Transaction.java b/core/src/main/java/org/bitcoinj/core/Transaction.java
index 6960e376e..8e0fed598 100644
--- a/core/src/main/java/org/bitcoinj/core/Transaction.java
+++ b/core/src/main/java/org/bitcoinj/core/Transaction.java
@@ -21,6 +21,8 @@ import com.google.common.base.MoreObjects;
 import com.google.common.collect.Lists;
 import com.google.common.math.IntMath;
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.TransactionConfidence.ConfidenceType;
 import org.bitcoinj.crypto.TransactionSignature;
 import org.bitcoinj.script.Script;
@@ -59,8 +61,8 @@ import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
 import static org.bitcoinj.core.NetworkParameters.ProtocolVersion.WITNESS_VERSION;
-import static org.bitcoinj.core.Utils.uint32ToByteStreamLE;
-import static org.bitcoinj.core.Utils.uint64ToByteStreamLE;
+import static org.bitcoinj.base.utils.ByteUtils.uint32ToByteStreamLE;
+import static org.bitcoinj.base.utils.ByteUtils.uint64ToByteStreamLE;
 
 /**
  * <p>A transaction represents the movement of coins from some addresses to some other addresses. It can also represent
@@ -942,7 +944,7 @@ public class Transaction extends ChildMessage {
      * @return raw transaction in hex format
      */
     public String toHexString() {
-        return Utils.HEX.encode(unsafeBitcoinSerialize());
+        return ByteUtils.HEX.encode(unsafeBitcoinSerialize());
     }
 
     /**
diff --git a/core/src/main/java/org/bitcoinj/core/TransactionBag.java b/core/src/main/java/org/bitcoinj/core/TransactionBag.java
index 8f6b4b3ec..e0e186d80 100644
--- a/core/src/main/java/org/bitcoinj/core/TransactionBag.java
+++ b/core/src/main/java/org/bitcoinj/core/TransactionBag.java
@@ -17,6 +17,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.script.Script;
 import org.bitcoinj.wallet.Wallet;
 import org.bitcoinj.wallet.WalletTransaction;
diff --git a/core/src/main/java/org/bitcoinj/core/TransactionConfidence.java b/core/src/main/java/org/bitcoinj/core/TransactionConfidence.java
index a6649915e..9e9f09f7b 100644
--- a/core/src/main/java/org/bitcoinj/core/TransactionConfidence.java
+++ b/core/src/main/java/org/bitcoinj/core/TransactionConfidence.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import com.google.common.collect.Iterators;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.utils.ListenableCompletableFuture;
 import org.bitcoinj.utils.ListenerRegistration;
 import org.bitcoinj.utils.Threading;
diff --git a/core/src/main/java/org/bitcoinj/core/TransactionInput.java b/core/src/main/java/org/bitcoinj/core/TransactionInput.java
index 4a9b3a159..9eaf885f3 100644
--- a/core/src/main/java/org/bitcoinj/core/TransactionInput.java
+++ b/core/src/main/java/org/bitcoinj/core/TransactionInput.java
@@ -18,6 +18,8 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.internal.InternalUtils;
 import org.bitcoinj.script.Script;
 import org.bitcoinj.script.ScriptException;
@@ -173,7 +175,7 @@ public class TransactionInput extends ChildMessage {
         outpoint.bitcoinSerialize(stream);
         stream.write(new VarInt(scriptBytes.length).encode());
         stream.write(scriptBytes);
-        Utils.uint32ToByteStreamLE(sequence, stream);
+        ByteUtils.uint32ToByteStreamLE(sequence, stream);
     }
 
     /**
diff --git a/core/src/main/java/org/bitcoinj/core/TransactionOutPoint.java b/core/src/main/java/org/bitcoinj/core/TransactionOutPoint.java
index 25c090f9d..3cc9b4324 100644
--- a/core/src/main/java/org/bitcoinj/core/TransactionOutPoint.java
+++ b/core/src/main/java/org/bitcoinj/core/TransactionOutPoint.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.script.Script;
 import org.bitcoinj.script.ScriptError;
 import org.bitcoinj.script.ScriptException;
@@ -106,7 +108,7 @@ public class TransactionOutPoint extends ChildMessage {
     @Override
     protected void bitcoinSerializeToStream(OutputStream stream) throws IOException {
         stream.write(hash.getReversedBytes());
-        Utils.uint32ToByteStreamLE(index, stream);
+        ByteUtils.uint32ToByteStreamLE(index, stream);
     }
 
     /**
diff --git a/core/src/main/java/org/bitcoinj/core/TransactionOutput.java b/core/src/main/java/org/bitcoinj/core/TransactionOutput.java
index b615c7fa4..635a541eb 100644
--- a/core/src/main/java/org/bitcoinj/core/TransactionOutput.java
+++ b/core/src/main/java/org/bitcoinj/core/TransactionOutput.java
@@ -18,6 +18,8 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.script.Script;
 import org.bitcoinj.script.ScriptBuilder;
 import org.bitcoinj.script.ScriptException;
@@ -153,7 +155,7 @@ public class TransactionOutput extends ChildMessage {
     @Override
     protected void bitcoinSerializeToStream(OutputStream stream) throws IOException {
         checkNotNull(scriptBytes);
-        Utils.int64ToByteStreamLE(value, stream);
+        ByteUtils.int64ToByteStreamLE(value, stream);
         // TODO: Move script serialization into the Script class, where it belongs.
         stream.write(new VarInt(scriptBytes.length).encode());
         stream.write(scriptBytes);
@@ -348,7 +350,7 @@ public class TransactionOutput extends ChildMessage {
                     || ScriptPattern.isP2SH(script))
                 buf.append(" to ").append(script.getToAddress(params));
             else if (ScriptPattern.isP2PK(script))
-                buf.append(" to pubkey ").append(Utils.HEX.encode(ScriptPattern.extractKeyFromP2PK(script)));
+                buf.append(" to pubkey ").append(ByteUtils.HEX.encode(ScriptPattern.extractKeyFromP2PK(script)));
             else if (ScriptPattern.isSentToMultisig(script))
                 buf.append(" to multisig");
             else
diff --git a/core/src/main/java/org/bitcoinj/core/TransactionOutputChanges.java b/core/src/main/java/org/bitcoinj/core/TransactionOutputChanges.java
index 0fd7a47ab..ae86abbac 100644
--- a/core/src/main/java/org/bitcoinj/core/TransactionOutputChanges.java
+++ b/core/src/main/java/org/bitcoinj/core/TransactionOutputChanges.java
@@ -16,6 +16,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -38,12 +40,12 @@ public class TransactionOutputChanges {
     }
     
     public TransactionOutputChanges(InputStream in) throws IOException {
-        int numOutsCreated = (int) Utils.readUint32FromStream(in);
+        int numOutsCreated = (int) ByteUtils.readUint32FromStream(in);
         txOutsCreated = new LinkedList<>();
         for (int i = 0; i < numOutsCreated; i++)
             txOutsCreated.add(UTXO.fromStream(in));
         
-        int numOutsSpent = (int) Utils.readUint32FromStream(in);
+        int numOutsSpent = (int) ByteUtils.readUint32FromStream(in);
         txOutsSpent = new LinkedList<>();
         for (int i = 0; i < numOutsSpent; i++)
             txOutsSpent.add(UTXO.fromStream(in));
@@ -51,13 +53,13 @@ public class TransactionOutputChanges {
 
     public void serializeToStream(OutputStream bos) throws IOException {
         int numOutsCreated = txOutsCreated.size();
-        Utils.uint32ToByteStreamLE(numOutsCreated, bos);
+        ByteUtils.uint32ToByteStreamLE(numOutsCreated, bos);
         for (UTXO output : txOutsCreated) {
             output.serializeToStream(bos);
         }
         
         int numOutsSpent = txOutsSpent.size();
-        Utils.uint32ToByteStreamLE(numOutsSpent, bos);
+        ByteUtils.uint32ToByteStreamLE(numOutsSpent, bos);
         for (UTXO output : txOutsSpent) {
             output.serializeToStream(bos);
         }
diff --git a/core/src/main/java/org/bitcoinj/core/TransactionWitness.java b/core/src/main/java/org/bitcoinj/core/TransactionWitness.java
index ed6035757..b5a0cebf6 100644
--- a/core/src/main/java/org/bitcoinj/core/TransactionWitness.java
+++ b/core/src/main/java/org/bitcoinj/core/TransactionWitness.java
@@ -14,6 +14,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.internal.InternalUtils;
 import org.bitcoinj.crypto.TransactionSignature;
 import org.bitcoinj.script.Script;
@@ -94,7 +95,7 @@ public class TransactionWitness {
             } else if (push.length == 0) {
                 stringPushes.add("EMPTY");
             } else {
-                stringPushes.add(Utils.HEX.encode(push));
+                stringPushes.add(ByteUtils.HEX.encode(push));
             }
         }
         return InternalUtils.SPACE_JOINER.join(stringPushes);
diff --git a/core/src/main/java/org/bitcoinj/core/TxConfidenceTable.java b/core/src/main/java/org/bitcoinj/core/TxConfidenceTable.java
index a34aa9783..c3ccf6c80 100644
--- a/core/src/main/java/org/bitcoinj/core/TxConfidenceTable.java
+++ b/core/src/main/java/org/bitcoinj/core/TxConfidenceTable.java
@@ -16,6 +16,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.utils.Threading;
 
 import javax.annotation.Nullable;
diff --git a/core/src/main/java/org/bitcoinj/core/UTXO.java b/core/src/main/java/org/bitcoinj/core/UTXO.java
index cfc39e56d..dce89750d 100644
--- a/core/src/main/java/org/bitcoinj/core/UTXO.java
+++ b/core/src/main/java/org/bitcoinj/core/UTXO.java
@@ -18,6 +18,8 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.script.Script;
 
 import java.io.EOFException;
@@ -144,13 +146,13 @@ public class UTXO {
     }
 
     public void serializeToStream(OutputStream bos) throws IOException {
-        Utils.uint64ToByteStreamLE(BigInteger.valueOf(value.value), bos);
+        ByteUtils.uint64ToByteStreamLE(BigInteger.valueOf(value.value), bos);
         byte[] scriptBytes = script.getProgram();
-        Utils.uint32ToByteStreamLE(scriptBytes.length, bos);
+        ByteUtils.uint32ToByteStreamLE(scriptBytes.length, bos);
         bos.write(scriptBytes);
         bos.write(hash.getBytes());
-        Utils.uint32ToByteStreamLE(index, bos);
-        Utils.uint32ToByteStreamLE(height, bos);
+        ByteUtils.uint32ToByteStreamLE(index, bos);
+        ByteUtils.uint32ToByteStreamLE(height, bos);
         bos.write(new byte[] { (byte)(coinbase ? 1 : 0) });
     }
 
@@ -158,9 +160,9 @@ public class UTXO {
         byte[] valueBytes = new byte[8];
         if (in.read(valueBytes, 0, 8) != 8)
             throw new EOFException();
-        Coin value = Coin.valueOf(Utils.readInt64(valueBytes, 0));
+        Coin value = Coin.valueOf(ByteUtils.readInt64(valueBytes, 0));
 
-        int scriptBytesLength = (int) Utils.readUint32FromStream(in);
+        int scriptBytesLength = (int) ByteUtils.readUint32FromStream(in);
         byte[] scriptBytes = new byte[scriptBytesLength];
         if (in.read(scriptBytes) != scriptBytesLength)
             throw new EOFException();
@@ -174,9 +176,9 @@ public class UTXO {
         byte[] indexBytes = new byte[4];
         if (in.read(indexBytes) != 4)
             throw new EOFException();
-        long index = Utils.readUint32(indexBytes, 0);
+        long index = ByteUtils.readUint32(indexBytes, 0);
 
-        int height = (int) Utils.readUint32FromStream(in);
+        int height = (int) ByteUtils.readUint32FromStream(in);
 
         byte[] coinbaseByte = new byte[1];
         in.read(coinbaseByte);
diff --git a/core/src/main/java/org/bitcoinj/core/UnknownMessage.java b/core/src/main/java/org/bitcoinj/core/UnknownMessage.java
index b8ed9e766..9b1b6d461 100644
--- a/core/src/main/java/org/bitcoinj/core/UnknownMessage.java
+++ b/core/src/main/java/org/bitcoinj/core/UnknownMessage.java
@@ -17,6 +17,8 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
+
 /**
  * <p>Instances of this class are not safe for use by multiple threads.</p>
  */
@@ -31,6 +33,6 @@ public class UnknownMessage extends EmptyMessage {
 
     @Override
     public String toString() {
-        return "Unknown message [" + name + "]" + (payload == null ? "" : ": " + Utils.HEX.encode(payload));
+        return "Unknown message [" + name + "]" + (payload == null ? "" : ": " + ByteUtils.HEX.encode(payload));
     }
 }
diff --git a/core/src/main/java/org/bitcoinj/core/Utils.java b/core/src/main/java/org/bitcoinj/core/Utils.java
index 2a13064ad..f3555b414 100644
--- a/core/src/main/java/org/bitcoinj/core/Utils.java
+++ b/core/src/main/java/org/bitcoinj/core/Utils.java
@@ -19,16 +19,13 @@ package org.bitcoinj.core;
 
 import com.google.common.base.Joiner;
 import com.google.common.base.Splitter;
-import com.google.common.io.BaseEncoding;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.internal.InternalUtils;
 import org.bouncycastle.crypto.digests.RIPEMD160Digest;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.math.BigInteger;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
@@ -38,8 +35,6 @@ import java.util.Locale;
 import java.util.TimeZone;
 import java.util.regex.Pattern;
 
-import static com.google.common.base.Preconditions.checkArgument;
-
 /**
  * A collection of various utility methods that are helpful for working with the Bitcoin protocol.
  * To enable debug logging from the library, run with -Dbitcoinj.logging=true on your command line.
@@ -60,9 +55,6 @@ public class Utils {
     @Deprecated
     public static final Splitter WHITESPACE_SPLITTER = Splitter.on(Pattern.compile("\\s+"));
 
-    /** Hex encoding used throughout the framework. Use with HEX.encode(byte[]) or HEX.decode(CharSequence). */
-    public static final BaseEncoding HEX = BaseEncoding.base16().lowerCase();
-
     /**
      * Max initial size of variable length arrays and ArrayLists that could be attacked.
      * Avoids this attack: Attacker sends a msg indicating it will contain a huge number (eg 2 billion) elements (eg transaction inputs) and
@@ -72,211 +64,6 @@ public class Utils {
 
     private static final Logger log = LoggerFactory.getLogger(Utils.class);
 
-    /**
-     * <p>
-     * The regular {@link BigInteger#toByteArray()} includes the sign bit of the number and
-     * might result in an extra byte addition. This method removes this extra byte.
-     * </p>
-     * <p>
-     * Assuming only positive numbers, it's possible to discriminate if an extra byte
-     * is added by checking if the first element of the array is 0 (0000_0000).
-     * Due to the minimal representation provided by BigInteger, it means that the bit sign
-     * is the least significant bit 0000_000<b>0</b> .
-     * Otherwise the representation is not minimal.
-     * For example, if the sign bit is 0000_00<b>0</b>0, then the representation is not minimal due to the rightmost zero.
-     * </p>
-     * This is the antagonist to {@link #bytesToBigInteger(byte[])}.
-     * @param b the integer to format into a byte array
-     * @param numBytes the desired size of the resulting byte array
-     * @return numBytes byte long array.
-     */
-    public static byte[] bigIntegerToBytes(BigInteger b, int numBytes) {
-        checkArgument(b.signum() >= 0, "b must be positive or zero");
-        checkArgument(numBytes > 0, "numBytes must be positive");
-        byte[] src = b.toByteArray();
-        byte[] dest = new byte[numBytes];
-        boolean isFirstByteOnlyForSign = src[0] == 0;
-        int length = isFirstByteOnlyForSign ? src.length - 1 : src.length;
-        checkArgument(length <= numBytes, "The given number does not fit in " + numBytes);
-        int srcPos = isFirstByteOnlyForSign ? 1 : 0;
-        int destPos = numBytes - length;
-        System.arraycopy(src, srcPos, dest, destPos, length);
-        return dest;
-    }
-
-    /**
-     * Converts an array of bytes into a positive BigInteger. This is the antagonist to
-     * {@link #bigIntegerToBytes(BigInteger, int)}.
-     *
-     * @param bytes to convert into a BigInteger
-     * @return the converted BigInteger
-     */
-    public static BigInteger bytesToBigInteger(byte[] bytes) {
-        return new BigInteger(1, bytes);
-    }
-
-    /** Write 2 bytes to the byte array (starting at the offset) as unsigned 16-bit integer in little endian format. */
-    public static void uint16ToByteArrayLE(int val, byte[] out, int offset) {
-        out[offset] = (byte) (0xFF & val);
-        out[offset + 1] = (byte) (0xFF & (val >> 8));
-    }
-
-    /** Write 4 bytes to the byte array (starting at the offset) as unsigned 32-bit integer in little endian format. */
-    public static void uint32ToByteArrayLE(long val, byte[] out, int offset) {
-        out[offset] = (byte) (0xFF & val);
-        out[offset + 1] = (byte) (0xFF & (val >> 8));
-        out[offset + 2] = (byte) (0xFF & (val >> 16));
-        out[offset + 3] = (byte) (0xFF & (val >> 24));
-    }
-
-    /** Write 4 bytes to the byte array (starting at the offset) as unsigned 32-bit integer in big endian format. */
-    public static void uint32ToByteArrayBE(long val, byte[] out, int offset) {
-        out[offset] = (byte) (0xFF & (val >> 24));
-        out[offset + 1] = (byte) (0xFF & (val >> 16));
-        out[offset + 2] = (byte) (0xFF & (val >> 8));
-        out[offset + 3] = (byte) (0xFF & val);
-    }
-
-    /** Write 8 bytes to the byte array (starting at the offset) as signed 64-bit integer in little endian format. */
-    public static void int64ToByteArrayLE(long val, byte[] out, int offset) {
-        out[offset] = (byte) (0xFF & val);
-        out[offset + 1] = (byte) (0xFF & (val >> 8));
-        out[offset + 2] = (byte) (0xFF & (val >> 16));
-        out[offset + 3] = (byte) (0xFF & (val >> 24));
-        out[offset + 4] = (byte) (0xFF & (val >> 32));
-        out[offset + 5] = (byte) (0xFF & (val >> 40));
-        out[offset + 6] = (byte) (0xFF & (val >> 48));
-        out[offset + 7] = (byte) (0xFF & (val >> 56));
-    }
-
-    /** Write 2 bytes to the output stream as unsigned 16-bit integer in little endian format. */
-    public static void uint16ToByteStreamLE(int val, OutputStream stream) throws IOException {
-        stream.write((int) (0xFF & val));
-        stream.write((int) (0xFF & (val >> 8)));
-    }
-
-    /** Write 2 bytes to the output stream as unsigned 16-bit integer in big endian format. */
-    public static void uint16ToByteStreamBE(int val, OutputStream stream) throws IOException {
-        stream.write((int) (0xFF & (val >> 8)));
-        stream.write((int) (0xFF & val));
-    }
-
-    /** Write 4 bytes to the output stream as unsigned 32-bit integer in little endian format. */
-    public static void uint32ToByteStreamLE(long val, OutputStream stream) throws IOException {
-        stream.write((int) (0xFF & val));
-        stream.write((int) (0xFF & (val >> 8)));
-        stream.write((int) (0xFF & (val >> 16)));
-        stream.write((int) (0xFF & (val >> 24)));
-    }
-
-    /** Write 4 bytes to the output stream as unsigned 32-bit integer in big endian format. */
-    public static void uint32ToByteStreamBE(long val, OutputStream stream) throws IOException {
-        stream.write((int) (0xFF & (val >> 24)));
-        stream.write((int) (0xFF & (val >> 16)));
-        stream.write((int) (0xFF & (val >> 8)));
-        stream.write((int) (0xFF & val));
-    }
-
-    /** Write 8 bytes to the output stream as signed 64-bit integer in little endian format. */
-    public static void int64ToByteStreamLE(long val, OutputStream stream) throws IOException {
-        stream.write((int) (0xFF & val));
-        stream.write((int) (0xFF & (val >> 8)));
-        stream.write((int) (0xFF & (val >> 16)));
-        stream.write((int) (0xFF & (val >> 24)));
-        stream.write((int) (0xFF & (val >> 32)));
-        stream.write((int) (0xFF & (val >> 40)));
-        stream.write((int) (0xFF & (val >> 48)));
-        stream.write((int) (0xFF & (val >> 56)));
-    }
-
-    /** Write 8 bytes to the output stream as unsigned 64-bit integer in little endian format. */
-    public static void uint64ToByteStreamLE(BigInteger val, OutputStream stream) throws IOException {
-        byte[] bytes = val.toByteArray();
-        if (bytes.length > 8) {
-            throw new RuntimeException("Input too large to encode into a uint64");
-        }
-        bytes = reverseBytes(bytes);
-        stream.write(bytes);
-        if (bytes.length < 8) {
-            for (int i = 0; i < 8 - bytes.length; i++)
-                stream.write(0);
-        }
-    }
-
-    /** Parse 2 bytes from the byte array (starting at the offset) as unsigned 16-bit integer in little endian format. */
-    public static int readUint16(byte[] bytes, int offset) {
-        return (bytes[offset] & 0xff) |
-                ((bytes[offset + 1] & 0xff) << 8);
-    }
-
-    /** Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in little endian format. */
-    public static long readUint32(byte[] bytes, int offset) {
-        return (bytes[offset] & 0xffl) |
-                ((bytes[offset + 1] & 0xffl) << 8) |
-                ((bytes[offset + 2] & 0xffl) << 16) |
-                ((bytes[offset + 3] & 0xffl) << 24);
-    }
-
-    /** Parse 8 bytes from the byte array (starting at the offset) as signed 64-bit integer in little endian format. */
-    public static long readInt64(byte[] bytes, int offset) {
-        return (bytes[offset] & 0xffl) |
-               ((bytes[offset + 1] & 0xffl) << 8) |
-               ((bytes[offset + 2] & 0xffl) << 16) |
-               ((bytes[offset + 3] & 0xffl) << 24) |
-               ((bytes[offset + 4] & 0xffl) << 32) |
-               ((bytes[offset + 5] & 0xffl) << 40) |
-               ((bytes[offset + 6] & 0xffl) << 48) |
-               ((bytes[offset + 7] & 0xffl) << 56);
-    }
-
-    /** Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in big endian format. */
-    public static long readUint32BE(byte[] bytes, int offset) {
-        return ((bytes[offset] & 0xffl) << 24) |
-                ((bytes[offset + 1] & 0xffl) << 16) |
-                ((bytes[offset + 2] & 0xffl) << 8) |
-                (bytes[offset + 3] & 0xffl);
-    }
-
-    /** Parse 2 bytes from the byte array (starting at the offset) as unsigned 16-bit integer in big endian format. */
-    public static int readUint16BE(byte[] bytes, int offset) {
-        return ((bytes[offset] & 0xff) << 8) |
-                (bytes[offset + 1] & 0xff);
-    }
-
-    /** Parse 2 bytes from the stream as unsigned 16-bit integer in little endian format. */
-    public static int readUint16FromStream(InputStream is) {
-        try {
-            return (is.read() & 0xff) |
-                    ((is.read() & 0xff) << 8);
-        } catch (IOException x) {
-            throw new RuntimeException(x);
-        }
-    }
-
-    /** Parse 4 bytes from the stream as unsigned 32-bit integer in little endian format. */
-    public static long readUint32FromStream(InputStream is) {
-        try {
-            return (is.read() & 0xffl) |
-                    ((is.read() & 0xffl) << 8) |
-                    ((is.read() & 0xffl) << 16) |
-                    ((is.read() & 0xffl) << 24);
-        } catch (IOException x) {
-            throw new RuntimeException(x);
-        }
-    }
-
-    /**
-     * Returns a copy of the given byte array in reverse order.
-     */
-    public static byte[] reverseBytes(byte[] bytes) {
-        // We could use the XOR trick here but it's easier to understand if we don't. If we find this is really a
-        // performance issue the matter can be revisited.
-        byte[] buf = new byte[bytes.length];
-        for (int i = 0; i < bytes.length; i++)
-            buf[i] = bytes[bytes.length - 1 - i];
-        return buf;
-    }
-
     /**
      * Calculates RIPEMD160(SHA256(input)). This is used in Address calculations.
      */
@@ -289,113 +76,6 @@ public class Utils {
         return out;
     }
 
-    /**
-     * MPI encoded numbers are produced by the OpenSSL BN_bn2mpi function. They consist of
-     * a 4 byte big endian length field, followed by the stated number of bytes representing
-     * the number in big endian format (with a sign bit).
-     * @param hasLength can be set to false if the given array is missing the 4 byte length field
-     */
-    public static BigInteger decodeMPI(byte[] mpi, boolean hasLength) {
-        byte[] buf;
-        if (hasLength) {
-            int length = (int) readUint32BE(mpi, 0);
-            buf = new byte[length];
-            System.arraycopy(mpi, 4, buf, 0, length);
-        } else
-            buf = mpi;
-        if (buf.length == 0)
-            return BigInteger.ZERO;
-        boolean isNegative = (buf[0] & 0x80) == 0x80;
-        if (isNegative)
-            buf[0] &= 0x7f;
-        BigInteger result = new BigInteger(buf);
-        return isNegative ? result.negate() : result;
-    }
-    
-    /**
-     * MPI encoded numbers are produced by the OpenSSL BN_bn2mpi function. They consist of
-     * a 4 byte big endian length field, followed by the stated number of bytes representing
-     * the number in big endian format (with a sign bit).
-     * @param includeLength indicates whether the 4 byte length field should be included
-     */
-    public static byte[] encodeMPI(BigInteger value, boolean includeLength) {
-        if (value.equals(BigInteger.ZERO)) {
-            if (!includeLength)
-                return new byte[] {};
-            else
-                return new byte[] {0x00, 0x00, 0x00, 0x00};
-        }
-        boolean isNegative = value.signum() < 0;
-        if (isNegative)
-            value = value.negate();
-        byte[] array = value.toByteArray();
-        int length = array.length;
-        if ((array[0] & 0x80) == 0x80)
-            length++;
-        if (includeLength) {
-            byte[] result = new byte[length + 4];
-            System.arraycopy(array, 0, result, length - array.length + 3, array.length);
-            uint32ToByteArrayBE(length, result, 0);
-            if (isNegative)
-                result[4] |= 0x80;
-            return result;
-        } else {
-            byte[] result;
-            if (length != array.length) {
-                result = new byte[length];
-                System.arraycopy(array, 0, result, 1, array.length);
-            }else
-                result = array;
-            if (isNegative)
-                result[0] |= 0x80;
-            return result;
-        }
-    }
-
-    /**
-     * <p>The "compact" format is a representation of a whole number N using an unsigned 32 bit number similar to a
-     * floating point format. The most significant 8 bits are the unsigned exponent of base 256. This exponent can
-     * be thought of as "number of bytes of N". The lower 23 bits are the mantissa. Bit number 24 (0x800000) represents
-     * the sign of N. Therefore, N = (-1^sign) * mantissa * 256^(exponent-3).</p>
-     *
-     * <p>Satoshi's original implementation used BN_bn2mpi() and BN_mpi2bn(). MPI uses the most significant bit of the
-     * first byte as sign. Thus 0x1234560000 is compact 0x05123456 and 0xc0de000000 is compact 0x0600c0de. Compact
-     * 0x05c0de00 would be -0x40de000000.</p>
-     *
-     * <p>Bitcoin only uses this "compact" format for encoding difficulty targets, which are unsigned 256bit quantities.
-     * Thus, all the complexities of the sign bit and using base 256 are probably an implementation accident.</p>
-     */
-    public static BigInteger decodeCompactBits(long compact) {
-        int size = ((int) (compact >> 24)) & 0xFF;
-        byte[] bytes = new byte[4 + size];
-        bytes[3] = (byte) size;
-        if (size >= 1) bytes[4] = (byte) ((compact >> 16) & 0xFF);
-        if (size >= 2) bytes[5] = (byte) ((compact >> 8) & 0xFF);
-        if (size >= 3) bytes[6] = (byte) (compact & 0xFF);
-        return decodeMPI(bytes, true);
-    }
-
-    /**
-     * @see Utils#decodeCompactBits(long)
-     */
-    public static long encodeCompactBits(BigInteger value) {
-        long result;
-        int size = value.toByteArray().length;
-        if (size <= 3)
-            result = value.longValue() << 8 * (3 - size);
-        else
-            result = value.shiftRight(8 * (size - 3)).longValue();
-        // The 0x00800000 bit denotes the sign.
-        // Thus, if it is already set, divide the mantissa by 256 and increase the exponent.
-        if ((result & 0x00800000L) != 0) {
-            result >>= 8;
-            size++;
-        }
-        result |= size << 24;
-        result |= value.signum() == -1 ? 0x00800000 : 0;
-        return result;
-    }
-
     /**
      * If non-null, overrides the return value of now().
      */
@@ -482,19 +162,6 @@ public class Utils {
         return iso8601.format(dateTime);
     }
 
-    // 00000001, 00000010, 00000100, 00001000, ...
-    private static final int[] bitMask = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
-    
-    /** Checks if the given bit is set in data, using little endian (not the same as Java native big endian) */
-    public static boolean checkBitLE(byte[] data, int index) {
-        return (data[index >>> 3] & bitMask[7 & index]) != 0;
-    }
-    
-    /** Sets the given bit in data to one, using little endian (not the same as Java native big endian) */
-    public static void setBitLE(byte[] data, int index) {
-        data[index >>> 3] |= bitMask[7 & index];
-    }
-
     private enum Runtime {
         ANDROID, OPENJDK, ORACLE_JAVA
     }
@@ -558,7 +225,7 @@ public class Utils {
     public static String toString(List<byte[]> stack) {
         List<String> parts = new ArrayList<>(stack.size());
         for (byte[] push : stack)
-            parts.add('[' + HEX.encode(push) + ']');
+            parts.add('[' + ByteUtils.HEX.encode(push) + ']');
         return InternalUtils.SPACE_JOINER.join(parts);
     }
 }
diff --git a/core/src/main/java/org/bitcoinj/core/VarInt.java b/core/src/main/java/org/bitcoinj/core/VarInt.java
index 0e4c13700..f10677234 100644
--- a/core/src/main/java/org/bitcoinj/core/VarInt.java
+++ b/core/src/main/java/org/bitcoinj/core/VarInt.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import com.google.common.primitives.Ints;
+import org.bitcoinj.base.utils.ByteUtils;
 
 /**
  * A variable-length encoded unsigned integer using Satoshi's encoding (a.k.a. "CompactSize").
@@ -48,13 +49,13 @@ public class VarInt {
             value = first;
             originallyEncodedSize = 1; // 1 data byte (8 bits)
         } else if (first == 253) {
-            value = Utils.readUint16(buf, offset + 1);
+            value = ByteUtils.readUint16(buf, offset + 1);
             originallyEncodedSize = 3; // 1 marker + 2 data bytes (16 bits)
         } else if (first == 254) {
-            value = Utils.readUint32(buf, offset + 1);
+            value = ByteUtils.readUint32(buf, offset + 1);
             originallyEncodedSize = 5; // 1 marker + 4 data bytes (32 bits)
         } else {
-            value = Utils.readInt64(buf, offset + 1);
+            value = ByteUtils.readInt64(buf, offset + 1);
             originallyEncodedSize = 9; // 1 marker + 8 data bytes (64 bits)
         }
     }
@@ -109,17 +110,17 @@ public class VarInt {
             case 3:
                 bytes = new byte[3];
                 bytes[0] = (byte) 253;
-                Utils.uint16ToByteArrayLE((int) value, bytes, 1);
+                ByteUtils.uint16ToByteArrayLE((int) value, bytes, 1);
                 return bytes;
             case 5:
                 bytes = new byte[5];
                 bytes[0] = (byte) 254;
-                Utils.uint32ToByteArrayLE(value, bytes, 1);
+                ByteUtils.uint32ToByteArrayLE(value, bytes, 1);
                 return bytes;
             default:
                 bytes = new byte[9];
                 bytes[0] = (byte) 255;
-                Utils.int64ToByteArrayLE(value, bytes, 1);
+                ByteUtils.int64ToByteArrayLE(value, bytes, 1);
                 return bytes;
         }
     }
diff --git a/core/src/main/java/org/bitcoinj/core/VersionMessage.java b/core/src/main/java/org/bitcoinj/core/VersionMessage.java
index f5ce3b402..89c531da1 100644
--- a/core/src/main/java/org/bitcoinj/core/VersionMessage.java
+++ b/core/src/main/java/org/bitcoinj/core/VersionMessage.java
@@ -17,6 +17,7 @@
 package org.bitcoinj.core;
 
 import com.google.common.net.InetAddresses;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.internal.InternalUtils;
 
 import javax.annotation.Nullable;
@@ -156,24 +157,24 @@ public class VersionMessage extends Message {
 
     @Override
     public void bitcoinSerializeToStream(OutputStream buf) throws IOException {
-        Utils.uint32ToByteStreamLE(clientVersion, buf);
-        Utils.uint32ToByteStreamLE(localServices, buf);
-        Utils.uint32ToByteStreamLE(localServices >> 32, buf);
-        Utils.uint32ToByteStreamLE(time, buf);
-        Utils.uint32ToByteStreamLE(time >> 32, buf);
+        ByteUtils.uint32ToByteStreamLE(clientVersion, buf);
+        ByteUtils.uint32ToByteStreamLE(localServices, buf);
+        ByteUtils.uint32ToByteStreamLE(localServices >> 32, buf);
+        ByteUtils.uint32ToByteStreamLE(time, buf);
+        ByteUtils.uint32ToByteStreamLE(time >> 32, buf);
         receivingAddr.bitcoinSerializeToStream(buf);
         fromAddr.bitcoinSerializeToStream(buf);
         // Next up is the "local host nonce", this is to detect the case of connecting
         // back to yourself. We don't care about this as we won't be accepting inbound
         // connections.
-        Utils.uint32ToByteStreamLE(0, buf);
-        Utils.uint32ToByteStreamLE(0, buf);
+        ByteUtils.uint32ToByteStreamLE(0, buf);
+        ByteUtils.uint32ToByteStreamLE(0, buf);
         // Now comes subVer.
         byte[] subVerBytes = subVer.getBytes(StandardCharsets.UTF_8);
         buf.write(new VarInt(subVerBytes.length).encode());
         buf.write(subVerBytes);
         // Size of known block chain.
-        Utils.uint32ToByteStreamLE(bestHeight, buf);
+        ByteUtils.uint32ToByteStreamLE(bestHeight, buf);
         if (clientVersion >= params.getProtocolVersionNum(NetworkParameters.ProtocolVersion.BLOOM_FILTER)) {
             buf.write(relayTxesBeforeFilter ? 1 : 0);
         }
diff --git a/core/src/main/java/org/bitcoinj/core/listeners/NewBestBlockListener.java b/core/src/main/java/org/bitcoinj/core/listeners/NewBestBlockListener.java
index 93eb04b2f..267c7bf3b 100644
--- a/core/src/main/java/org/bitcoinj/core/listeners/NewBestBlockListener.java
+++ b/core/src/main/java/org/bitcoinj/core/listeners/NewBestBlockListener.java
@@ -17,7 +17,7 @@
 package org.bitcoinj.core.listeners;
 
 import org.bitcoinj.core.AbstractBlockChain;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.VerificationException;
diff --git a/core/src/main/java/org/bitcoinj/core/listeners/TransactionReceivedInBlockListener.java b/core/src/main/java/org/bitcoinj/core/listeners/TransactionReceivedInBlockListener.java
index 3254f6027..5626f554f 100644
--- a/core/src/main/java/org/bitcoinj/core/listeners/TransactionReceivedInBlockListener.java
+++ b/core/src/main/java/org/bitcoinj/core/listeners/TransactionReceivedInBlockListener.java
@@ -18,7 +18,7 @@ package org.bitcoinj.core.listeners;
 
 import org.bitcoinj.core.BlockChain;
 import org.bitcoinj.core.FilteredBlock;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.VerificationException;
diff --git a/core/src/main/java/org/bitcoinj/crypto/BIP38PrivateKey.java b/core/src/main/java/org/bitcoinj/crypto/BIP38PrivateKey.java
index b59fb518a..787aa0c08 100644
--- a/core/src/main/java/org/bitcoinj/crypto/BIP38PrivateKey.java
+++ b/core/src/main/java/org/bitcoinj/crypto/BIP38PrivateKey.java
@@ -17,14 +17,14 @@
 package org.bitcoinj.crypto;
 
 import com.google.common.primitives.Bytes;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.AddressFormatException;
 import org.bitcoinj.core.Base58;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.PrefixedChecksummedBytes;
-import org.bitcoinj.core.Sha256Hash;
-import org.bitcoinj.core.Utils;
+import org.bitcoinj.base.Sha256Hash;
 import org.bouncycastle.crypto.generators.SCrypt;
 
 import javax.crypto.Cipher;
@@ -160,7 +160,7 @@ public class BIP38PrivateKey extends PrefixedChecksummedBytes {
                 checkState(hashBytes.length == 40);
                 passFactorBytes = Sha256Hash.hashTwice(hashBytes);
             }
-            BigInteger passFactor = Utils.bytesToBigInteger(passFactorBytes);
+            BigInteger passFactor = ByteUtils.bytesToBigInteger(passFactorBytes);
             ECKey k = ECKey.fromPrivate(passFactor, true);
 
             byte[] salt = Bytes.concat(addressHash, ownerEntropy);
@@ -186,7 +186,7 @@ public class BIP38PrivateKey extends PrefixedChecksummedBytes {
 
             byte[] seed = Bytes.concat(decrypted1, Arrays.copyOfRange(decrypted2, 8, 16));
             checkState(seed.length == 24);
-            BigInteger seedFactor = Utils.bytesToBigInteger(Sha256Hash.hashTwice(seed));
+            BigInteger seedFactor = ByteUtils.bytesToBigInteger(Sha256Hash.hashTwice(seed));
             checkState(passFactor.signum() >= 0);
             checkState(seedFactor.signum() >= 0);
             BigInteger priv = passFactor.multiply(seedFactor).mod(ECKey.CURVE.getN());
diff --git a/core/src/main/java/org/bitcoinj/crypto/DeterministicKey.java b/core/src/main/java/org/bitcoinj/crypto/DeterministicKey.java
index 9f96fec7c..071766467 100644
--- a/core/src/main/java/org/bitcoinj/crypto/DeterministicKey.java
+++ b/core/src/main/java/org/bitcoinj/crypto/DeterministicKey.java
@@ -19,11 +19,12 @@ package org.bitcoinj.crypto;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.MoreObjects;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Address;
 import org.bitcoinj.core.Base58;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.Utils;
 import org.bitcoinj.script.Script;
 import org.bouncycastle.crypto.params.KeyParameter;
@@ -40,7 +41,7 @@ import java.util.Objects;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 
 /**
  * A deterministic key is a node in a {@link DeterministicHierarchy}. As per
@@ -401,7 +402,7 @@ public class DeterministicKey extends ECKey {
             if (decryptedKey.length != 32)
                 throw new KeyCrypterException.InvalidCipherText(
                         "Decrypted key must be 32 bytes long, but is " + decryptedKey.length);
-            return Utils.bytesToBigInteger(decryptedKey);
+            return ByteUtils.bytesToBigInteger(decryptedKey);
         }
         // Otherwise we don't have it, but maybe we can figure it out from our parents. Walk up the tree looking for
         // the first key that has some encrypted private key data.
@@ -438,7 +439,7 @@ public class DeterministicKey extends ECKey {
 
     private BigInteger derivePrivateKeyDownwards(DeterministicKey cursor, byte[] parentalPrivateKeyBytes) {
         DeterministicKey downCursor = new DeterministicKey(cursor.childNumberPath, cursor.chainCode,
-                cursor.pub, Utils.bytesToBigInteger(parentalPrivateKeyBytes), cursor.parent);
+                cursor.pub, ByteUtils.bytesToBigInteger(parentalPrivateKeyBytes), cursor.parent);
         // Now we have to rederive the keys along the path back to ourselves. That path can be found by just truncating
         // our path with the length of the parents path.
         List<ChildNumber> path = childNumberPath.subList(cursor.getPath().size(), childNumberPath.size());
@@ -611,7 +612,7 @@ public class DeterministicKey extends ECKey {
         if (pub) {
             return new DeterministicKey(path, chainCode, new LazyECPoint(ECKey.CURVE.getCurve(), data), parent, depth, parentFingerprint);
         } else {
-            return new DeterministicKey(path, chainCode, Utils.bytesToBigInteger(data), parent, depth, parentFingerprint);
+            return new DeterministicKey(path, chainCode, ByteUtils.bytesToBigInteger(data), parent, depth, parentFingerprint);
         }
     }
 
@@ -661,7 +662,7 @@ public class DeterministicKey extends ECKey {
     @Override
     public String toString() {
         final MoreObjects.ToStringHelper helper = MoreObjects.toStringHelper(this).omitNullValues();
-        helper.add("pub", Utils.HEX.encode(pub.getEncoded()));
+        helper.add("pub", ByteUtils.HEX.encode(pub.getEncoded()));
         helper.add("chainCode", HEX.encode(chainCode));
         helper.add("path", getPathAsString());
         if (parent != null)
@@ -677,7 +678,7 @@ public class DeterministicKey extends ECKey {
     public void formatKeyWithAddress(boolean includePrivateKeys, @Nullable KeyParameter aesKey, StringBuilder builder,
             NetworkParameters params, Script.ScriptType outputScriptType, @Nullable String comment) {
         builder.append("  addr:").append(Address.fromKey(params, this, outputScriptType).toString());
-        builder.append("  hash160:").append(Utils.HEX.encode(getPubKeyHash()));
+        builder.append("  hash160:").append(ByteUtils.HEX.encode(getPubKeyHash()));
         builder.append("  (").append(getPathAsString());
         if (comment != null)
             builder.append(", ").append(comment);
diff --git a/core/src/main/java/org/bitcoinj/crypto/HDKeyDerivation.java b/core/src/main/java/org/bitcoinj/crypto/HDKeyDerivation.java
index 29766604f..2b48ce1e1 100644
--- a/core/src/main/java/org/bitcoinj/crypto/HDKeyDerivation.java
+++ b/core/src/main/java/org/bitcoinj/crypto/HDKeyDerivation.java
@@ -16,6 +16,7 @@
 
 package org.bitcoinj.crypto;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.Utils;
 import org.bouncycastle.math.ec.ECPoint;
@@ -85,7 +86,7 @@ public final class HDKeyDerivation {
      * @throws HDDerivationException if privKeyBytes is invalid (not between 0 and n inclusive).
      */
     public static DeterministicKey createMasterPrivKeyFromBytes(byte[] privKeyBytes, byte[] chainCode) throws HDDerivationException {
-        BigInteger priv = Utils.bytesToBigInteger(privKeyBytes);
+        BigInteger priv = ByteUtils.bytesToBigInteger(privKeyBytes);
         assertNonZero(priv, "Generated master key is invalid.");
         assertLessThanN(priv, "Generated master key is invalid.");
         return new DeterministicKey(HDPath.m(), chainCode, priv, null);
@@ -153,7 +154,7 @@ public final class HDKeyDerivation {
             throws HDDerivationException {
         RawKeyBytes rawKey = deriveChildKeyBytesFromPrivate(parent, childNumber);
         return new DeterministicKey(parent.getPath().extend(childNumber), rawKey.chainCode,
-                Utils.bytesToBigInteger(rawKey.keyBytes), parent);
+                ByteUtils.bytesToBigInteger(rawKey.keyBytes), parent);
     }
 
     public static RawKeyBytes deriveChildKeyBytesFromPrivate(DeterministicKey parent,
@@ -172,7 +173,7 @@ public final class HDKeyDerivation {
         checkState(i.length == 64, i.length);
         byte[] il = Arrays.copyOfRange(i, 0, 32);
         byte[] chainCode = Arrays.copyOfRange(i, 32, 64);
-        BigInteger ilInt = Utils.bytesToBigInteger(il);
+        BigInteger ilInt = ByteUtils.bytesToBigInteger(il);
         assertLessThanN(ilInt, "Illegal derived key: I_L >= n");
         final BigInteger priv = parent.getPrivKey();
         BigInteger ki = priv.add(ilInt).mod(ECKey.CURVE.getN());
@@ -203,7 +204,7 @@ public final class HDKeyDerivation {
         checkState(i.length == 64, i.length);
         byte[] il = Arrays.copyOfRange(i, 0, 32);
         byte[] chainCode = Arrays.copyOfRange(i, 32, 64);
-        BigInteger ilInt = Utils.bytesToBigInteger(il);
+        BigInteger ilInt = ByteUtils.bytesToBigInteger(il);
         assertLessThanN(ilInt, "Illegal derived key: I_L >= n");
 
         final BigInteger N = ECKey.CURVE.getN();
diff --git a/core/src/main/java/org/bitcoinj/crypto/MnemonicCode.java b/core/src/main/java/org/bitcoinj/crypto/MnemonicCode.java
index c6f170c0c..9bdd30a2b 100644
--- a/core/src/main/java/org/bitcoinj/crypto/MnemonicCode.java
+++ b/core/src/main/java/org/bitcoinj/crypto/MnemonicCode.java
@@ -18,7 +18,7 @@
 package org.bitcoinj.crypto;
 
 import com.google.common.base.Stopwatch;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.Utils;
 import org.bitcoinj.core.internal.InternalUtils;
 import org.slf4j.Logger;
@@ -37,7 +37,7 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 import static com.google.common.base.Preconditions.checkNotNull;
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 
 /**
  * A MnemonicCode object may be used to convert between binary seed values and
diff --git a/core/src/main/java/org/bitcoinj/jni/NativeBlockChainListener.java b/core/src/main/java/org/bitcoinj/jni/NativeBlockChainListener.java
index d4e19494a..b94e392b5 100644
--- a/core/src/main/java/org/bitcoinj/jni/NativeBlockChainListener.java
+++ b/core/src/main/java/org/bitcoinj/jni/NativeBlockChainListener.java
@@ -17,7 +17,7 @@
 package org.bitcoinj.jni;
 
 import org.bitcoinj.core.BlockChain;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.VerificationException;
diff --git a/core/src/main/java/org/bitcoinj/net/discovery/SeedPeers.java b/core/src/main/java/org/bitcoinj/net/discovery/SeedPeers.java
index 2d9b7b69b..8cc9e5625 100644
--- a/core/src/main/java/org/bitcoinj/net/discovery/SeedPeers.java
+++ b/core/src/main/java/org/bitcoinj/net/discovery/SeedPeers.java
@@ -16,8 +16,8 @@
 
 package org.bitcoinj.net.discovery;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Utils;
 
 import javax.annotation.Nullable;
 import java.net.InetAddress;
@@ -107,7 +107,7 @@ public class SeedPeers implements PeerDiscovery {
 
     private InetAddress convertAddress(int seed) throws UnknownHostException {
         byte[] v4addr = new byte[4];
-        Utils.uint32ToByteArrayLE(seed, v4addr, 0);
+        ByteUtils.uint32ToByteArrayLE(seed, v4addr, 0);
         return InetAddress.getByAddress(v4addr);
     }
 
diff --git a/core/src/main/java/org/bitcoinj/params/AbstractBitcoinNetParams.java b/core/src/main/java/org/bitcoinj/params/AbstractBitcoinNetParams.java
index cc9116253..83bc16b81 100644
--- a/core/src/main/java/org/bitcoinj/params/AbstractBitcoinNetParams.java
+++ b/core/src/main/java/org/bitcoinj/params/AbstractBitcoinNetParams.java
@@ -18,15 +18,15 @@
 package org.bitcoinj.params;
 
 import com.google.common.base.Stopwatch;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.BitcoinSerializer;
 import org.bitcoinj.core.Block;
 import org.bitcoinj.base.Coin;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionOutput;
-import org.bitcoinj.core.Utils;
 import org.bitcoinj.core.VerificationException;
 import org.bitcoinj.store.BlockStore;
 import org.bitcoinj.store.BlockStoreException;
@@ -146,7 +146,7 @@ public abstract class AbstractBitcoinNetParams extends NetworkParameters {
         if (timespan > targetTimespan * 4)
             timespan = targetTimespan * 4;
 
-        BigInteger newTarget = Utils.decodeCompactBits(prev.getDifficultyTarget());
+        BigInteger newTarget = ByteUtils.decodeCompactBits(prev.getDifficultyTarget());
         newTarget = newTarget.multiply(BigInteger.valueOf(timespan));
         newTarget = newTarget.divide(BigInteger.valueOf(targetTimespan));
 
@@ -161,7 +161,7 @@ public abstract class AbstractBitcoinNetParams extends NetworkParameters {
         // The calculated difficulty is to a higher precision than received, so reduce here.
         BigInteger mask = BigInteger.valueOf(0xFFFFFFL).shiftLeft(accuracyBytes * 8);
         newTarget = newTarget.and(mask);
-        long newTargetCompact = Utils.encodeCompactBits(newTarget);
+        long newTargetCompact = ByteUtils.encodeCompactBits(newTarget);
 
         if (newTargetCompact != receivedTargetCompact)
             throw new VerificationException("Network provided difficulty bits do not match what was calculated: " +
diff --git a/core/src/main/java/org/bitcoinj/params/MainNetParams.java b/core/src/main/java/org/bitcoinj/params/MainNetParams.java
index 01d15080a..77de5e5ea 100644
--- a/core/src/main/java/org/bitcoinj/params/MainNetParams.java
+++ b/core/src/main/java/org/bitcoinj/params/MainNetParams.java
@@ -17,9 +17,9 @@
 
 package org.bitcoinj.params;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Block;
-import org.bitcoinj.core.Sha256Hash;
-import org.bitcoinj.core.Utils;
+import org.bitcoinj.base.Sha256Hash;
 
 import static com.google.common.base.Preconditions.checkState;
 
@@ -39,7 +39,7 @@ public class MainNetParams extends AbstractBitcoinNetParams {
         id = ID_MAINNET;
 
         targetTimespan = TARGET_TIMESPAN;
-        maxTarget = Utils.decodeCompactBits(Block.STANDARD_MAX_DIFFICULTY_TARGET);
+        maxTarget = ByteUtils.decodeCompactBits(Block.STANDARD_MAX_DIFFICULTY_TARGET);
 
         port = 8333;
         packetMagic = 0xf9beb4d9L;
diff --git a/core/src/main/java/org/bitcoinj/params/RegTestParams.java b/core/src/main/java/org/bitcoinj/params/RegTestParams.java
index e909ca5f0..d5405e846 100644
--- a/core/src/main/java/org/bitcoinj/params/RegTestParams.java
+++ b/core/src/main/java/org/bitcoinj/params/RegTestParams.java
@@ -17,9 +17,9 @@
 
 package org.bitcoinj.params;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Block;
-import org.bitcoinj.core.Sha256Hash;
-import org.bitcoinj.core.Utils;
+import org.bitcoinj.base.Sha256Hash;
 
 import static com.google.common.base.Preconditions.checkState;
 
@@ -36,7 +36,7 @@ public class RegTestParams extends AbstractBitcoinNetParams {
         id = ID_REGTEST;
         
         targetTimespan = TARGET_TIMESPAN;
-        maxTarget = Utils.decodeCompactBits(Block.EASIEST_DIFFICULTY_TARGET);
+        maxTarget = ByteUtils.decodeCompactBits(Block.EASIEST_DIFFICULTY_TARGET);
         // Difficulty adjustments are disabled for regtest.
         // By setting the block interval for difficulty adjustments to Integer.MAX_VALUE we make sure difficulty never
         // changes.
diff --git a/core/src/main/java/org/bitcoinj/params/SigNetParams.java b/core/src/main/java/org/bitcoinj/params/SigNetParams.java
index 671a9c80b..97d8b31a1 100644
--- a/core/src/main/java/org/bitcoinj/params/SigNetParams.java
+++ b/core/src/main/java/org/bitcoinj/params/SigNetParams.java
@@ -16,9 +16,9 @@
 
 package org.bitcoinj.params;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Block;
-import org.bitcoinj.core.Sha256Hash;
-import org.bitcoinj.core.Utils;
+import org.bitcoinj.base.Sha256Hash;
 
 import static com.google.common.base.Preconditions.checkState;
 
@@ -41,7 +41,7 @@ public class SigNetParams extends AbstractBitcoinNetParams {
         id = ID_SIGNET;
 
         targetTimespan = TARGET_TIMESPAN;
-        maxTarget = Utils.decodeCompactBits(Block.EASIEST_DIFFICULTY_TARGET);
+        maxTarget = ByteUtils.decodeCompactBits(Block.EASIEST_DIFFICULTY_TARGET);
 
         port = 38333;
         packetMagic = 0x0a03cf40;
diff --git a/core/src/main/java/org/bitcoinj/params/TestNet3Params.java b/core/src/main/java/org/bitcoinj/params/TestNet3Params.java
index 72ca72acf..b49cdd39b 100644
--- a/core/src/main/java/org/bitcoinj/params/TestNet3Params.java
+++ b/core/src/main/java/org/bitcoinj/params/TestNet3Params.java
@@ -17,11 +17,11 @@
 
 package org.bitcoinj.params;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Block;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
-import org.bitcoinj.core.Utils;
 import org.bitcoinj.core.VerificationException;
 import org.bitcoinj.store.BlockStore;
 import org.bitcoinj.store.BlockStoreException;
@@ -48,7 +48,7 @@ public class TestNet3Params extends AbstractBitcoinNetParams {
         id = ID_TESTNET;
 
         targetTimespan = TARGET_TIMESPAN;
-        maxTarget = Utils.decodeCompactBits(Block.STANDARD_MAX_DIFFICULTY_TARGET);
+        maxTarget = ByteUtils.decodeCompactBits(Block.STANDARD_MAX_DIFFICULTY_TARGET);
 
         port = 18333;
         packetMagic = 0x0b110907;
diff --git a/core/src/main/java/org/bitcoinj/params/UnitTestParams.java b/core/src/main/java/org/bitcoinj/params/UnitTestParams.java
index 91c29f215..fc181aee0 100644
--- a/core/src/main/java/org/bitcoinj/params/UnitTestParams.java
+++ b/core/src/main/java/org/bitcoinj/params/UnitTestParams.java
@@ -17,6 +17,7 @@
 
 package org.bitcoinj.params;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Block;
 import org.bitcoinj.core.Utils;
 
@@ -34,7 +35,7 @@ public class UnitTestParams extends AbstractBitcoinNetParams {
         id = ID_UNITTESTNET;
 
         targetTimespan = 200000000;  // 6 years. Just a very big number.
-        maxTarget = Utils.decodeCompactBits(Block.EASIEST_DIFFICULTY_TARGET);
+        maxTarget = ByteUtils.decodeCompactBits(Block.EASIEST_DIFFICULTY_TARGET);
         interval = 10;
         subsidyDecreaseBlockCount = 100;
 
diff --git a/core/src/main/java/org/bitcoinj/script/Script.java b/core/src/main/java/org/bitcoinj/script/Script.java
index 3e373dc3c..ed56a077d 100644
--- a/core/src/main/java/org/bitcoinj/script/Script.java
+++ b/core/src/main/java/org/bitcoinj/script/Script.java
@@ -19,6 +19,7 @@
 
 package org.bitcoinj.script;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Address;
 import org.bitcoinj.base.Coin;
 import org.bitcoinj.core.ECKey;
@@ -26,7 +27,7 @@ import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.ProtocolException;
 import org.bitcoinj.core.SegwitAddress;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.SignatureDecodeException;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionInput;
@@ -338,12 +339,12 @@ public class Script {
             } else if (opcode == OP_PUSHDATA2) {
                 // Read a short, then read that many bytes of data.
                 if (bis.available() < 2) throw new ScriptException(ScriptError.SCRIPT_ERR_UNKNOWN_ERROR, "Unexpected end of script");
-                dataToRead = Utils.readUint16FromStream(bis);
+                dataToRead = ByteUtils.readUint16FromStream(bis);
             } else if (opcode == OP_PUSHDATA4) {
                 // Read a uint32, then read that many bytes of data.
                 // Though this is allowed, because its value cannot be > 520, it should never actually be used
                 if (bis.available() < 4) throw new ScriptException(ScriptError.SCRIPT_ERR_UNKNOWN_ERROR, "Unexpected end of script");
-                dataToRead = Utils.readUint32FromStream(bis);
+                dataToRead = ByteUtils.readUint32FromStream(bis);
             }
 
             ScriptChunk chunk;
@@ -437,7 +438,7 @@ public class Script {
             os.write(buf);
         } else if (buf.length < 65536) {
             os.write(OP_PUSHDATA2);
-            Utils.uint16ToByteStreamLE(buf.length, os);
+            ByteUtils.uint16ToByteStreamLE(buf.length, os);
             os.write(buf);
         } else {
             throw new RuntimeException("Unimplemented");
@@ -610,7 +611,7 @@ public class Script {
             }
         }
 
-        throw new IllegalStateException("Could not find matching key for signature on " + hash.toString() + " sig " + Utils.HEX.encode(signatureBytes));
+        throw new IllegalStateException("Could not find matching key for signature on " + hash.toString() + " sig " + ByteUtils.HEX.encode(signatureBytes));
     }
 
 
@@ -787,9 +788,9 @@ public class Script {
             } else if (opcode == OP_PUSHDATA1) {
                 additionalBytes = (0xFF & inputScript[cursor]) + 1;
             } else if (opcode == OP_PUSHDATA2) {
-                additionalBytes = Utils.readUint16(inputScript, cursor) + 2;
+                additionalBytes = ByteUtils.readUint16(inputScript, cursor) + 2;
             } else if (opcode == OP_PUSHDATA4) {
-                additionalBytes = (int) Utils.readUint32(inputScript, cursor) + 4;
+                additionalBytes = (int) ByteUtils.readUint32(inputScript, cursor) + 4;
             }
             if (!skip) {
                 try {
@@ -866,7 +867,7 @@ public class Script {
             }
         }
 
-        return Utils.decodeMPI(Utils.reverseBytes(chunk), false);
+        return ByteUtils.decodeMPI(ByteUtils.reverseBytes(chunk), false);
     }
 
     /** @deprecated use {@link ScriptPattern#isOpReturn(Script)} */
@@ -978,7 +979,7 @@ public class Script {
 
                 // OP_0 is no opcode
                 case OP_1NEGATE:
-                    stack.add(Utils.reverseBytes(Utils.encodeMPI(BigInteger.ONE.negate(), false)));
+                    stack.add(ByteUtils.reverseBytes(ByteUtils.encodeMPI(BigInteger.ONE.negate(), false)));
                     break;
                 case OP_1:
                 case OP_2:
@@ -996,7 +997,7 @@ public class Script {
                 case OP_14:
                 case OP_15:
                 case OP_16:
-                    stack.add(Utils.reverseBytes(Utils.encodeMPI(BigInteger.valueOf(decodeFromOpN(opcode)), false)));
+                    stack.add(ByteUtils.reverseBytes(ByteUtils.encodeMPI(BigInteger.valueOf(decodeFromOpN(opcode)), false)));
                     break;
                 case OP_NOP:
                     break;
@@ -1087,7 +1088,7 @@ public class Script {
                         stack.add(stack.getLast());
                     break;
                 case OP_DEPTH:
-                    stack.add(Utils.reverseBytes(Utils.encodeMPI(BigInteger.valueOf(stack.size()), false)));
+                    stack.add(ByteUtils.reverseBytes(ByteUtils.encodeMPI(BigInteger.valueOf(stack.size()), false)));
                     break;
                 case OP_DROP:
                     if (stack.size() < 1)
@@ -1152,7 +1153,7 @@ public class Script {
                 case OP_SIZE:
                     if (stack.size() < 1)
                         throw new ScriptException(ScriptError.SCRIPT_ERR_INVALID_STACK_OPERATION, "Attempted OP_SIZE on an empty stack");
-                    stack.add(Utils.reverseBytes(Utils.encodeMPI(BigInteger.valueOf(stack.getLast().length), false)));
+                    stack.add(ByteUtils.reverseBytes(ByteUtils.encodeMPI(BigInteger.valueOf(stack.getLast().length), false)));
                     break;
                 case OP_EQUAL:
                     if (stack.size() < 2)
@@ -1205,7 +1206,7 @@ public class Script {
                         throw new AssertionError("Unreachable");
                     }
                     
-                    stack.add(Utils.reverseBytes(Utils.encodeMPI(numericOPnum, false)));
+                    stack.add(ByteUtils.reverseBytes(ByteUtils.encodeMPI(numericOPnum, false)));
                     break;
                 case OP_ADD:
                 case OP_SUB:
@@ -1296,7 +1297,7 @@ public class Script {
                         throw new RuntimeException("Opcode switched at runtime?");
                     }
                     
-                    stack.add(Utils.reverseBytes(Utils.encodeMPI(numericOPresult, false)));
+                    stack.add(ByteUtils.reverseBytes(ByteUtils.encodeMPI(numericOPresult, false)));
                     break;
                 case OP_NUMEQUALVERIFY:
                     if (stack.size() < 2)
@@ -1314,9 +1315,9 @@ public class Script {
                     BigInteger OPWITHINnum2 = castToBigInteger(stack.pollLast(), verifyFlags.contains(VerifyFlag.MINIMALDATA));
                     BigInteger OPWITHINnum1 = castToBigInteger(stack.pollLast(), verifyFlags.contains(VerifyFlag.MINIMALDATA));
                     if (OPWITHINnum2.compareTo(OPWITHINnum1) <= 0 && OPWITHINnum1.compareTo(OPWITHINnum3) < 0)
-                        stack.add(Utils.reverseBytes(Utils.encodeMPI(BigInteger.ONE, false)));
+                        stack.add(ByteUtils.reverseBytes(ByteUtils.encodeMPI(BigInteger.ONE, false)));
                     else
-                        stack.add(Utils.reverseBytes(Utils.encodeMPI(BigInteger.ZERO, false)));
+                        stack.add(ByteUtils.reverseBytes(ByteUtils.encodeMPI(BigInteger.ZERO, false)));
                     break;
                 case OP_RIPEMD160:
                     if (stack.size() < 1)
diff --git a/core/src/main/java/org/bitcoinj/script/ScriptBuilder.java b/core/src/main/java/org/bitcoinj/script/ScriptBuilder.java
index 545041072..681084688 100644
--- a/core/src/main/java/org/bitcoinj/script/ScriptBuilder.java
+++ b/core/src/main/java/org/bitcoinj/script/ScriptBuilder.java
@@ -22,7 +22,7 @@ import org.bitcoinj.core.Address;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.SegwitAddress;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.Utils;
 import org.bitcoinj.crypto.TransactionSignature;
diff --git a/core/src/main/java/org/bitcoinj/script/ScriptChunk.java b/core/src/main/java/org/bitcoinj/script/ScriptChunk.java
index 4874c6528..061e22404 100644
--- a/core/src/main/java/org/bitcoinj/script/ScriptChunk.java
+++ b/core/src/main/java/org/bitcoinj/script/ScriptChunk.java
@@ -17,7 +17,7 @@
 
 package org.bitcoinj.script;
 
-import org.bitcoinj.core.Utils;
+import org.bitcoinj.base.utils.ByteUtils;
 
 import javax.annotation.Nullable;
 import java.io.ByteArrayOutputStream;
@@ -120,11 +120,11 @@ public class ScriptChunk {
             } else if (opcode == OP_PUSHDATA2) {
                 checkState(data.length <= 0xFFFF);
                 stream.write(OP_PUSHDATA2);
-                Utils.uint16ToByteStreamLE(data.length, stream);
+                ByteUtils.uint16ToByteStreamLE(data.length, stream);
             } else if (opcode == OP_PUSHDATA4) {
                 checkState(data.length <= Script.MAX_SCRIPT_ELEMENT_SIZE);
                 stream.write(OP_PUSHDATA4);
-                Utils.uint32ToByteStreamLE(data.length, stream);
+                ByteUtils.uint32ToByteStreamLE(data.length, stream);
             } else {
                 throw new RuntimeException("Unimplemented");
             }
@@ -165,7 +165,7 @@ public class ScriptChunk {
     public String toString() {
         if (data == null)
             return getOpCodeName(opcode);
-        return String.format("%s[%s]", getPushDataName(opcode), Utils.HEX.encode(data));
+        return String.format("%s[%s]", getPushDataName(opcode), ByteUtils.HEX.encode(data));
     }
 
     @Override
diff --git a/core/src/main/java/org/bitcoinj/script/ScriptPattern.java b/core/src/main/java/org/bitcoinj/script/ScriptPattern.java
index 6ea0ee23e..c8e53b01a 100644
--- a/core/src/main/java/org/bitcoinj/script/ScriptPattern.java
+++ b/core/src/main/java/org/bitcoinj/script/ScriptPattern.java
@@ -17,10 +17,10 @@
 
 package org.bitcoinj.script;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.SegwitAddress;
-import org.bitcoinj.core.Sha256Hash;
-import org.bitcoinj.core.Utils;
+import org.bitcoinj.base.Sha256Hash;
 
 import java.util.Arrays;
 import java.util.List;
@@ -261,7 +261,7 @@ public class ScriptPattern {
         return chunks.size() > 0 && chunks.get(0).equalsOpCode(ScriptOpCodes.OP_RETURN);
     }
 
-    private static final byte[] SEGWIT_COMMITMENT_HEADER = Utils.HEX.decode("aa21a9ed");
+    private static final byte[] SEGWIT_COMMITMENT_HEADER = ByteUtils.HEX.decode("aa21a9ed");
 
     /**
      * Returns whether this script matches the pattern for a segwit commitment (in an output of the coinbase
diff --git a/core/src/main/java/org/bitcoinj/signers/CustomTransactionSigner.java b/core/src/main/java/org/bitcoinj/signers/CustomTransactionSigner.java
index e447b4218..8309a4d3a 100644
--- a/core/src/main/java/org/bitcoinj/signers/CustomTransactionSigner.java
+++ b/core/src/main/java/org/bitcoinj/signers/CustomTransactionSigner.java
@@ -18,7 +18,7 @@
 package org.bitcoinj.signers;
 
 import org.bitcoinj.core.ECKey;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionInput;
 import org.bitcoinj.core.TransactionOutput;
diff --git a/core/src/main/java/org/bitcoinj/store/BlockStore.java b/core/src/main/java/org/bitcoinj/store/BlockStore.java
index 26bd41b78..200854842 100644
--- a/core/src/main/java/org/bitcoinj/store/BlockStore.java
+++ b/core/src/main/java/org/bitcoinj/store/BlockStore.java
@@ -18,7 +18,7 @@ package org.bitcoinj.store;
 
 import org.bitcoinj.core.BlockChain;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 
 /**
diff --git a/core/src/main/java/org/bitcoinj/store/DatabaseFullPrunedBlockStore.java b/core/src/main/java/org/bitcoinj/store/DatabaseFullPrunedBlockStore.java
index 51191c37d..466571495 100644
--- a/core/src/main/java/org/bitcoinj/store/DatabaseFullPrunedBlockStore.java
+++ b/core/src/main/java/org/bitcoinj/store/DatabaseFullPrunedBlockStore.java
@@ -18,6 +18,7 @@
 
 package org.bitcoinj.store;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Address;
 import org.bitcoinj.core.Block;
 import org.bitcoinj.base.Coin;
@@ -25,14 +26,13 @@ import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.ProtocolException;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.StoredUndoableBlock;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionOutputChanges;
 import org.bitcoinj.core.UTXO;
 import org.bitcoinj.core.UTXOProviderException;
-import org.bitcoinj.core.Utils;
 import org.bitcoinj.core.VerificationException;
 import org.bitcoinj.script.Script;
 import org.bitcoinj.script.Script.ScriptType;
@@ -684,7 +684,7 @@ public abstract class DatabaseFullPrunedBlockStore implements FullPrunedBlockSto
                 txOutChanges = bos.toByteArray();
             } else {
                 int numTxn = undoableBlock.getTransactions().size();
-                Utils.uint32ToByteStreamLE(numTxn, bos);
+                ByteUtils.uint32ToByteStreamLE(numTxn, bos);
                 for (Transaction tx : undoableBlock.getTransactions())
                     tx.bitcoinSerialize(bos);
                 transactions = bos.toByteArray();
@@ -812,7 +812,7 @@ public abstract class DatabaseFullPrunedBlockStore implements FullPrunedBlockSto
             byte[] transactions = results.getBytes(2);
             StoredUndoableBlock block;
             if (txOutChanges == null) {
-                int numTxn = (int) Utils.readUint32(transactions, 0);
+                int numTxn = (int) ByteUtils.readUint32(transactions, 0);
                 int offset = 4;
                 List<Transaction> transactionList = new LinkedList<>();
                 for (int i = 0; i < numTxn; i++) {
diff --git a/core/src/main/java/org/bitcoinj/store/FullPrunedBlockStore.java b/core/src/main/java/org/bitcoinj/store/FullPrunedBlockStore.java
index 5428c54b3..65e709270 100644
--- a/core/src/main/java/org/bitcoinj/store/FullPrunedBlockStore.java
+++ b/core/src/main/java/org/bitcoinj/store/FullPrunedBlockStore.java
@@ -16,7 +16,7 @@
 
 package org.bitcoinj.store;
 
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.StoredUndoableBlock;
 import org.bitcoinj.core.UTXO;
diff --git a/core/src/main/java/org/bitcoinj/store/MemoryBlockStore.java b/core/src/main/java/org/bitcoinj/store/MemoryBlockStore.java
index fd033fe4f..9f98a2071 100644
--- a/core/src/main/java/org/bitcoinj/store/MemoryBlockStore.java
+++ b/core/src/main/java/org/bitcoinj/store/MemoryBlockStore.java
@@ -18,7 +18,7 @@ package org.bitcoinj.store;
 
 import org.bitcoinj.core.Block;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.VerificationException;
 
diff --git a/core/src/main/java/org/bitcoinj/store/MemoryFullPrunedBlockStore.java b/core/src/main/java/org/bitcoinj/store/MemoryFullPrunedBlockStore.java
index 471d78d4c..cea2da3fc 100644
--- a/core/src/main/java/org/bitcoinj/store/MemoryFullPrunedBlockStore.java
+++ b/core/src/main/java/org/bitcoinj/store/MemoryFullPrunedBlockStore.java
@@ -21,7 +21,7 @@ import org.bitcoinj.core.Address;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.StoredUndoableBlock;
 import org.bitcoinj.core.Transaction;
diff --git a/core/src/main/java/org/bitcoinj/store/PostgresFullPrunedBlockStore.java b/core/src/main/java/org/bitcoinj/store/PostgresFullPrunedBlockStore.java
index 5344d157b..3ea796fcc 100644
--- a/core/src/main/java/org/bitcoinj/store/PostgresFullPrunedBlockStore.java
+++ b/core/src/main/java/org/bitcoinj/store/PostgresFullPrunedBlockStore.java
@@ -18,12 +18,12 @@
 
 package org.bitcoinj.store;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Address;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.StoredUndoableBlock;
 import org.bitcoinj.core.Transaction;
-import org.bitcoinj.core.Utils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -186,7 +186,7 @@ public class PostgresFullPrunedBlockStore extends DatabaseFullPrunedBlockStore {
                 txOutChanges = bos.toByteArray();
             } else {
                 int numTxn = undoableBlock.getTransactions().size();
-                Utils.uint32ToByteStreamLE(numTxn, bos);
+                ByteUtils.uint32ToByteStreamLE(numTxn, bos);
                 for (Transaction tx : undoableBlock.getTransactions())
                     tx.bitcoinSerialize(bos);
                 transactions = bos.toByteArray();
@@ -199,7 +199,7 @@ public class PostgresFullPrunedBlockStore extends DatabaseFullPrunedBlockStore {
 
         try {
             if (log.isDebugEnabled())
-                log.debug("Looking for undoable block with hash: " + Utils.HEX.encode(hashBytes));
+                log.debug("Looking for undoable block with hash: " + ByteUtils.HEX.encode(hashBytes));
 
             PreparedStatement findS = conn.get().prepareStatement(SELECT_UNDOABLEBLOCKS_EXISTS_SQL);
             findS.setBytes(1, hashBytes);
@@ -217,7 +217,7 @@ public class PostgresFullPrunedBlockStore extends DatabaseFullPrunedBlockStore {
                 s.setBytes(3, hashBytes);
 
                 if (log.isDebugEnabled())
-                    log.debug("Updating undoable block with hash: " + Utils.HEX.encode(hashBytes));
+                    log.debug("Updating undoable block with hash: " + ByteUtils.HEX.encode(hashBytes));
 
                 if (transactions == null) {
                     s.setBytes(1, txOutChanges);
@@ -238,7 +238,7 @@ public class PostgresFullPrunedBlockStore extends DatabaseFullPrunedBlockStore {
             s.setInt(2, height);
 
             if (log.isDebugEnabled())
-                log.debug("Inserting undoable block with hash: " + Utils.HEX.encode(hashBytes)  + " at height " + height);
+                log.debug("Inserting undoable block with hash: " + ByteUtils.HEX.encode(hashBytes)  + " at height " + height);
 
             if (transactions == null) {
                 s.setBytes(3, txOutChanges);
diff --git a/core/src/main/java/org/bitcoinj/store/SPVBlockStore.java b/core/src/main/java/org/bitcoinj/store/SPVBlockStore.java
index da751b3a5..a349316cc 100644
--- a/core/src/main/java/org/bitcoinj/store/SPVBlockStore.java
+++ b/core/src/main/java/org/bitcoinj/store/SPVBlockStore.java
@@ -19,7 +19,7 @@ package org.bitcoinj.store;
 import org.bitcoinj.core.Block;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.ProtocolException;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.utils.Threading;
 import org.slf4j.Logger;
diff --git a/core/src/main/java/org/bitcoinj/testing/FakeTxBuilder.java b/core/src/main/java/org/bitcoinj/testing/FakeTxBuilder.java
index 3da481210..4c01252ce 100644
--- a/core/src/main/java/org/bitcoinj/testing/FakeTxBuilder.java
+++ b/core/src/main/java/org/bitcoinj/testing/FakeTxBuilder.java
@@ -26,7 +26,7 @@ import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.MessageSerializer;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.ProtocolException;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionConfidence;
diff --git a/core/src/main/java/org/bitcoinj/utils/BlockFileLoader.java b/core/src/main/java/org/bitcoinj/utils/BlockFileLoader.java
index a5deef74e..d31a6269b 100644
--- a/core/src/main/java/org/bitcoinj/utils/BlockFileLoader.java
+++ b/core/src/main/java/org/bitcoinj/utils/BlockFileLoader.java
@@ -16,10 +16,10 @@
 
 package org.bitcoinj.utils;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Block;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.ProtocolException;
-import org.bitcoinj.core.Utils;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -156,7 +156,7 @@ public class BlockFileLoader implements Iterable<Block>, Iterator<Block> {
                 }
                 byte[] bytes = new byte[4];
                 currentFileStream.read(bytes, 0, 4);
-                long size = Utils.readUint32BE(Utils.reverseBytes(bytes), 0);
+                long size = ByteUtils.readUint32BE(ByteUtils.reverseBytes(bytes), 0);
                 bytes = new byte[(int) size];
                 currentFileStream.read(bytes, 0, (int) size);
                 try {
diff --git a/core/src/main/java/org/bitcoinj/wallet/DeterministicKeyChain.java b/core/src/main/java/org/bitcoinj/wallet/DeterministicKeyChain.java
index aa71ae799..854355997 100644
--- a/core/src/main/java/org/bitcoinj/wallet/DeterministicKeyChain.java
+++ b/core/src/main/java/org/bitcoinj/wallet/DeterministicKeyChain.java
@@ -19,6 +19,7 @@ package org.bitcoinj.wallet;
 import com.google.common.base.MoreObjects;
 import com.google.common.base.Stopwatch;
 import com.google.protobuf.ByteString;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.BloomFilter;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.NetworkParameters;
@@ -907,7 +908,7 @@ public class DeterministicKeyChain implements EncryptableKeyChain {
                     boolean isMarried = !isFollowingKey && !chains.isEmpty() && chains.get(chains.size() - 1).isFollowing();
                     // If this has a private key but no seed, then all we know is the spending key H
                     if (seed == null && key.hasSecretBytes()) {
-                        DeterministicKey accountKey = new DeterministicKey(path, chainCode, pubkey, Utils.bytesToBigInteger(key.getSecretBytes().toByteArray()), null);
+                        DeterministicKey accountKey = new DeterministicKey(path, chainCode, pubkey, ByteUtils.bytesToBigInteger(key.getSecretBytes().toByteArray()), null);
                         accountKey.setCreationTimeSeconds(key.getCreationTimestamp() / 1000);
                         chain = factory.makeSpendingKeyChain(accountKey, isMarried, outputScriptType);
                         isSpendingKey = true;
@@ -934,7 +935,7 @@ public class DeterministicKeyChain implements EncryptableKeyChain {
                 DeterministicKey detkey;
                 if (key.hasSecretBytes()) {
                     // Not encrypted: private key is available.
-                    final BigInteger priv = Utils.bytesToBigInteger(key.getSecretBytes().toByteArray());
+                    final BigInteger priv = ByteUtils.bytesToBigInteger(key.getSecretBytes().toByteArray());
                     detkey = new DeterministicKey(path, chainCode, pubkey, priv, parent);
                 } else {
                     if (key.hasEncryptedData()) {
diff --git a/core/src/main/java/org/bitcoinj/wallet/DeterministicSeed.java b/core/src/main/java/org/bitcoinj/wallet/DeterministicSeed.java
index a011dfa37..4285cd6f1 100644
--- a/core/src/main/java/org/bitcoinj/wallet/DeterministicSeed.java
+++ b/core/src/main/java/org/bitcoinj/wallet/DeterministicSeed.java
@@ -36,7 +36,7 @@ import java.util.Objects;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 
 /**
  * Holds the seed bytes for the BIP32 deterministic wallet algorithm, inside a
diff --git a/core/src/main/java/org/bitcoinj/wallet/MarriedKeyChain.java b/core/src/main/java/org/bitcoinj/wallet/MarriedKeyChain.java
index 559f7d53f..c40ce4d4f 100644
--- a/core/src/main/java/org/bitcoinj/wallet/MarriedKeyChain.java
+++ b/core/src/main/java/org/bitcoinj/wallet/MarriedKeyChain.java
@@ -18,10 +18,10 @@ package org.bitcoinj.wallet;
 
 import com.google.common.collect.Lists;
 import com.google.protobuf.ByteString;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.BloomFilter;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Utils;
 import org.bitcoinj.crypto.ChildNumber;
 import org.bitcoinj.crypto.DeterministicKey;
 import org.bitcoinj.crypto.KeyCrypter;
@@ -250,7 +250,7 @@ public class MarriedKeyChain extends DeterministicKeyChain {
         builder.append("  addr:");
         builder.append(script.getToAddress(params));
         builder.append("  hash160:");
-        builder.append(Utils.HEX.encode(script.getPubKeyHash()));
+        builder.append(ByteUtils.HEX.encode(script.getPubKeyHash()));
         if (script.getCreationTimeSeconds() > 0)
             builder.append("  creationTimeSeconds:").append(script.getCreationTimeSeconds());
         builder.append('\n');
diff --git a/core/src/main/java/org/bitcoinj/wallet/Wallet.java b/core/src/main/java/org/bitcoinj/wallet/Wallet.java
index d83995eeb..9d0343211 100644
--- a/core/src/main/java/org/bitcoinj/wallet/Wallet.java
+++ b/core/src/main/java/org/bitcoinj/wallet/Wallet.java
@@ -40,7 +40,7 @@ import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.Peer;
 import org.bitcoinj.core.PeerFilterProvider;
 import org.bitcoinj.core.PeerGroup;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionBag;
diff --git a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
index bf8b1f18a..ce0b2e18d 100644
--- a/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
+++ b/core/src/main/java/org/bitcoinj/wallet/WalletProtobufSerializer.java
@@ -24,7 +24,7 @@ import com.google.protobuf.WireFormat;
 import org.bitcoinj.base.Coin;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.PeerAddress;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionConfidence;
 import org.bitcoinj.core.TransactionConfidence.ConfidenceType;
diff --git a/core/src/test/java/org/bitcoinj/base/utils/ByteUtilsTest.java b/core/src/test/java/org/bitcoinj/base/utils/ByteUtilsTest.java
new file mode 100644
index 000000000..9362ee612
--- /dev/null
+++ b/core/src/test/java/org/bitcoinj/base/utils/ByteUtilsTest.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright by the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.bitcoinj.base.utils;
+
+import org.junit.Test;
+
+import java.math.BigInteger;
+import java.util.Random;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class ByteUtilsTest {
+
+    @Test
+    public void testReverseBytes() {
+        assertArrayEquals(new byte[]{1, 2, 3, 4, 5}, ByteUtils.reverseBytes(new byte[]{5, 4, 3, 2, 1}));
+        assertArrayEquals(new byte[]{0}, ByteUtils.reverseBytes(new byte[]{0}));
+        assertArrayEquals(new byte[]{}, ByteUtils.reverseBytes(new byte[]{}));
+    }
+
+    @Test
+    public void compactEncoding() {
+        assertEquals(new BigInteger("1234560000", 16), ByteUtils.decodeCompactBits(0x05123456L));
+        assertEquals(new BigInteger("c0de000000", 16), ByteUtils.decodeCompactBits(0x0600c0de));
+        assertEquals(0x05123456L, ByteUtils.encodeCompactBits(new BigInteger("1234560000", 16)));
+        assertEquals(0x0600c0deL, ByteUtils.encodeCompactBits(new BigInteger("c0de000000", 16)));
+        // UnitTest difficulty
+        assertEquals(new BigInteger("7fffff0000000000000000000000000000000000000000000000000000000000", 16), ByteUtils.decodeCompactBits(0x207fFFFFL));
+        assertEquals(0x207fFFFFL, ByteUtils.encodeCompactBits(new BigInteger("7fffff0000000000000000000000000000000000000000000000000000000000", 16)));
+        // MainNet starting difficulty
+        assertEquals(new BigInteger("00000000FFFF0000000000000000000000000000000000000000000000000000", 16), ByteUtils.decodeCompactBits(0x1d00ffffL));
+        assertEquals(0x1d00ffffL, ByteUtils.encodeCompactBits(new BigInteger("00000000FFFF0000000000000000000000000000000000000000000000000000", 16)));
+    }
+
+    @Test
+    public void bigIntegerToBytes_roundTrip() {
+        int ITERATIONS = 100;
+        int LENGTH = 32;
+        Random rnd = new Random();
+        byte[] bytes = new byte[LENGTH];
+
+        for (int i = 0; i < ITERATIONS; i++) {
+            rnd.nextBytes(bytes);
+            BigInteger bi = ByteUtils.bytesToBigInteger(bytes);
+            assertArrayEquals(ByteUtils.HEX.encode(bytes), bytes, ByteUtils.bigIntegerToBytes(bi, LENGTH));
+        }
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void bigIntegerToBytes_convertNegativeNumber() {
+        BigInteger b = BigInteger.valueOf(-1);
+        ByteUtils.bigIntegerToBytes(b, 32);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void bigIntegerToBytes_convertWithNegativeLength() {
+        BigInteger b = BigInteger.valueOf(10);
+        ByteUtils.bigIntegerToBytes(b, -1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void bigIntegerToBytes_convertWithZeroLength() {
+        BigInteger b = BigInteger.valueOf(10);
+        ByteUtils.bigIntegerToBytes(b, 0);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void bigIntegerToBytes_insufficientLength() {
+        BigInteger b = BigInteger.valueOf(0b1000__0000_0000);   // base 2
+        ByteUtils.bigIntegerToBytes(b, 1);
+    }
+
+    @Test
+    public void bigIntegerToBytes_convertZero() {
+        BigInteger b = BigInteger.valueOf(0);
+        byte[] expected = new byte[]{0b0000_0000};
+        byte[] actual = ByteUtils.bigIntegerToBytes(b, 1);
+        assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void bigIntegerToBytes_singleByteSignFit() {
+        BigInteger b = BigInteger.valueOf(0b0000_1111);
+        byte[] expected = new byte[]{0b0000_1111};
+        byte[] actual = ByteUtils.bigIntegerToBytes(b, 1);
+        assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void bigIntegerToBytes_paddedSingleByte() {
+        BigInteger b = BigInteger.valueOf(0b0000_1111);
+        byte[] expected = new byte[]{0, 0b0000_1111};
+        byte[] actual = ByteUtils.bigIntegerToBytes(b, 2);
+        assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void bigIntegerToBytes_singleByteSignDoesNotFit() {
+        BigInteger b = BigInteger.valueOf(0b1000_0000);     // 128 (2-compl does not fit in one byte)
+        byte[] expected = new byte[]{-128};                 // -128 == 1000_0000 (compl-2)
+        byte[] actual = ByteUtils.bigIntegerToBytes(b, 1);
+        assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void testReadUint16() {
+        assertEquals(258L, ByteUtils.readUint16(new byte[]{2, 1}, 0));
+        assertEquals(258L, ByteUtils.readUint16(new byte[]{2, 1, 3, 4}, 0));
+        assertEquals(772L, ByteUtils.readUint16(new byte[]{1, 2, 4, 3}, 2));
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint16ThrowsException1() {
+        ByteUtils.readUint16(new byte[]{1}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint16ThrowsException2() {
+        ByteUtils.readUint16(new byte[]{1, 2, 3}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint16ThrowsException3() {
+        ByteUtils.readUint16(new byte[]{1, 2, 3}, -1);
+    }
+
+    @Test
+    public void testReadUint32() {
+        assertEquals(258L, ByteUtils.readUint32(new byte[]{2, 1, 0, 0}, 0));
+        assertEquals(258L, ByteUtils.readUint32(new byte[]{2, 1, 0, 0, 3, 4}, 0));
+        assertEquals(772L, ByteUtils.readUint32(new byte[]{1, 2, 4, 3, 0, 0}, 2));
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint32ThrowsException1() {
+        ByteUtils.readUint32(new byte[]{1, 2, 3}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint32ThrowsException2() {
+        ByteUtils.readUint32(new byte[]{1, 2, 3, 4, 5}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint32ThrowsException3() {
+        ByteUtils.readUint32(new byte[]{1, 2, 3, 4, 5}, -1);
+    }
+
+    @Test
+    public void testReadInt64() {
+        assertEquals(258L, ByteUtils.readInt64(new byte[]{2, 1, 0, 0, 0, 0, 0, 0}, 0));
+        assertEquals(258L, ByteUtils.readInt64(new byte[]{2, 1, 0, 0, 0, 0, 0, 0, 3, 4}, 0));
+        assertEquals(772L, ByteUtils.readInt64(new byte[]{1, 2, 4, 3, 0, 0, 0, 0, 0, 0}, 2));
+        assertEquals(-1L, ByteUtils.readInt64(new byte[]{-1, -1, -1, -1, -1, -1, -1, -1}, 0));
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadInt64ThrowsException1() {
+        ByteUtils.readInt64(new byte[]{1, 2, 3, 4, 5, 6, 7}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadInt64ThrowsException2() {
+        ByteUtils.readInt64(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadInt64ThrowsException3() {
+        ByteUtils.readInt64(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9}, -1);
+    }
+
+    @Test
+    public void testReadUInt32BE() {
+        assertEquals(258L, ByteUtils.readUint32BE(new byte[]{0, 0, 1, 2}, 0));
+        assertEquals(258L, ByteUtils.readUint32BE(new byte[]{0, 0, 1, 2, 3, 4}, 0));
+        assertEquals(772L, ByteUtils.readUint32BE(new byte[]{1, 2, 0, 0, 3, 4}, 2));
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint32BEThrowsException1() {
+        ByteUtils.readUint32BE(new byte[]{1, 2, 3}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint32BEThrowsException2() {
+        ByteUtils.readUint32BE(new byte[]{1, 2, 3, 4, 5}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint32BEThrowsException3() {
+        ByteUtils.readUint32BE(new byte[]{1, 2, 3, 4, 5}, -1);
+    }
+
+    @Test
+    public void testReadUint16BE() {
+        assertEquals(258L, ByteUtils.readUint16BE(new byte[]{1, 2}, 0));
+        assertEquals(258L, ByteUtils.readUint16BE(new byte[]{1, 2, 3, 4}, 0));
+        assertEquals(772L, ByteUtils.readUint16BE(new byte[]{0, 0, 3, 4}, 2));
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint16BEThrowsException1() {
+        ByteUtils.readUint16BE(new byte[]{1}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint16BEThrowsException2() {
+        ByteUtils.readUint16BE(new byte[]{1, 2, 3}, 2);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void testReadUint16BEThrowsException3() {
+        ByteUtils.readUint16BE(new byte[]{1, 2, 3}, -1);
+    }
+
+    @Test
+    public void testDecodeMPI() {
+        assertEquals(BigInteger.ZERO, ByteUtils.decodeMPI(new byte[]{}, false));
+    }
+}
diff --git a/core/src/test/java/org/bitcoinj/core/AddressV1MessageTest.java b/core/src/test/java/org/bitcoinj/core/AddressV1MessageTest.java
index f773e4284..b7f59a44e 100644
--- a/core/src/test/java/org/bitcoinj/core/AddressV1MessageTest.java
+++ b/core/src/test/java/org/bitcoinj/core/AddressV1MessageTest.java
@@ -23,7 +23,7 @@ import java.net.Inet4Address;
 import java.net.Inet6Address;
 import java.util.List;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
diff --git a/core/src/test/java/org/bitcoinj/core/AddressV2MessageTest.java b/core/src/test/java/org/bitcoinj/core/AddressV2MessageTest.java
index 321998962..52777c173 100644
--- a/core/src/test/java/org/bitcoinj/core/AddressV2MessageTest.java
+++ b/core/src/test/java/org/bitcoinj/core/AddressV2MessageTest.java
@@ -23,7 +23,7 @@ import java.net.Inet4Address;
 import java.net.Inet6Address;
 import java.util.List;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
diff --git a/core/src/test/java/org/bitcoinj/core/Base58DecodeToBigIntegerTest.java b/core/src/test/java/org/bitcoinj/core/Base58DecodeToBigIntegerTest.java
index cc49b4448..a4b3ad1b4 100644
--- a/core/src/test/java/org/bitcoinj/core/Base58DecodeToBigIntegerTest.java
+++ b/core/src/test/java/org/bitcoinj/core/Base58DecodeToBigIntegerTest.java
@@ -17,6 +17,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -26,6 +27,6 @@ public class Base58DecodeToBigIntegerTest {
     @Test
     public void testDecodeToBigInteger() {
         byte[] input = Base58.decode("129");
-        assertEquals(Utils.bytesToBigInteger(input), Base58.decodeToBigInteger("129"));
+        assertEquals(ByteUtils.bytesToBigInteger(input), Base58.decodeToBigInteger("129"));
     }
 }
diff --git a/core/src/test/java/org/bitcoinj/core/BitcoinSerializerTest.java b/core/src/test/java/org/bitcoinj/core/BitcoinSerializerTest.java
index 229422a56..efeaa1909 100644
--- a/core/src/test/java/org/bitcoinj/core/BitcoinSerializerTest.java
+++ b/core/src/test/java/org/bitcoinj/core/BitcoinSerializerTest.java
@@ -17,6 +17,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.TestNet3Params;
 import org.junit.Test;
@@ -28,7 +29,7 @@ import java.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
 import java.util.Arrays;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -160,7 +161,7 @@ public class BitcoinSerializerTest {
         Block block = headersMessage.getBlockHeaders().get(0);
         assertEquals("00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048", block.getHashAsString());
         assertNotNull(block.transactions);
-        assertEquals("0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098", Utils.HEX.encode(block.getMerkleRoot().getBytes()));
+        assertEquals("0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098", ByteUtils.HEX.encode(block.getMerkleRoot().getBytes()));
 
         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
         serializer.serialize(headersMessage, byteArrayOutputStream);
diff --git a/core/src/test/java/org/bitcoinj/core/BitcoindComparisonTool.java b/core/src/test/java/org/bitcoinj/core/BitcoindComparisonTool.java
index 591831694..b8205db4b 100644
--- a/core/src/test/java/org/bitcoinj/core/BitcoindComparisonTool.java
+++ b/core/src/test/java/org/bitcoinj/core/BitcoindComparisonTool.java
@@ -19,6 +19,7 @@ package org.bitcoinj.core;
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.Iterables;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.net.NioClient;
 import org.bitcoinj.params.RegTestParams;
 import org.bitcoinj.store.BlockStoreException;
diff --git a/core/src/test/java/org/bitcoinj/core/BlockChainTest.java b/core/src/test/java/org/bitcoinj/core/BlockChainTest.java
index 4e12f155a..8b00b1c2d 100644
--- a/core/src/test/java/org/bitcoinj/core/BlockChainTest.java
+++ b/core/src/test/java/org/bitcoinj/core/BlockChainTest.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.TestNet3Params;
 import org.bitcoinj.params.UnitTestParams;
diff --git a/core/src/test/java/org/bitcoinj/core/BlockTest.java b/core/src/test/java/org/bitcoinj/core/BlockTest.java
index 68323712f..da3186d5d 100644
--- a/core/src/test/java/org/bitcoinj/core/BlockTest.java
+++ b/core/src/test/java/org/bitcoinj/core/BlockTest.java
@@ -19,6 +19,8 @@ package org.bitcoinj.core;
 
 import com.google.common.io.ByteStreams;
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.AbstractBlockChain.NewBlockType;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.TestNet3Params;
@@ -39,7 +41,7 @@ import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.List;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -331,12 +333,12 @@ public class BlockTest {
         Block block = new Block(UNITTEST, 1, Sha256Hash.ZERO_HASH, Sha256Hash.ZERO_HASH, 1, 1, 1, new ArrayList<Transaction>()) {
             @Override
             protected void bitcoinSerializeToStream(OutputStream stream) throws IOException {
-                Utils.uint32ToByteStreamLE(getVersion(), stream);
+                ByteUtils.uint32ToByteStreamLE(getVersion(), stream);
                 stream.write(getPrevBlockHash().getReversedBytes());
                 stream.write(getMerkleRoot().getReversedBytes());
-                Utils.uint32ToByteStreamLE(getTimeSeconds(), stream);
-                Utils.uint32ToByteStreamLE(getDifficultyTarget(), stream);
-                Utils.uint32ToByteStreamLE(getNonce(), stream);
+                ByteUtils.uint32ToByteStreamLE(getTimeSeconds(), stream);
+                ByteUtils.uint32ToByteStreamLE(getDifficultyTarget(), stream);
+                ByteUtils.uint32ToByteStreamLE(getNonce(), stream);
 
                 stream.write(new VarInt(Integer.MAX_VALUE).encode());
             }
diff --git a/core/src/test/java/org/bitcoinj/core/BloomFilterTest.java b/core/src/test/java/org/bitcoinj/core/BloomFilterTest.java
index 1dde07bf9..328c1bf14 100644
--- a/core/src/test/java/org/bitcoinj/core/BloomFilterTest.java
+++ b/core/src/test/java/org/bitcoinj/core/BloomFilterTest.java
@@ -22,7 +22,7 @@ import org.bitcoinj.wallet.KeyChainGroup;
 import org.bitcoinj.wallet.Wallet;
 import org.junit.Test;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
diff --git a/core/src/test/java/org/bitcoinj/core/ChainSplitTest.java b/core/src/test/java/org/bitcoinj/core/ChainSplitTest.java
index 4a9bb9d35..5fd5a643a 100644
--- a/core/src/test/java/org/bitcoinj/core/ChainSplitTest.java
+++ b/core/src/test/java/org/bitcoinj/core/ChainSplitTest.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.TransactionConfidence.ConfidenceType;
 import org.bitcoinj.params.UnitTestParams;
 import org.bitcoinj.script.Script;
diff --git a/core/src/test/java/org/bitcoinj/core/ECKeyTest.java b/core/src/test/java/org/bitcoinj/core/ECKeyTest.java
index 62cb794d6..272ee9c6f 100644
--- a/core/src/test/java/org/bitcoinj/core/ECKeyTest.java
+++ b/core/src/test/java/org/bitcoinj/core/ECKeyTest.java
@@ -18,6 +18,8 @@
 package org.bitcoinj.core;
 
 import com.google.common.collect.Lists;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.ECKey.ECDSASignature;
 import org.bitcoinj.crypto.EncryptedData;
 import org.bitcoinj.crypto.KeyCrypter;
@@ -45,8 +47,8 @@ import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 import static com.google.common.base.Preconditions.checkNotNull;
-import static org.bitcoinj.core.Utils.HEX;
-import static org.bitcoinj.core.Utils.reverseBytes;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.reverseBytes;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -104,7 +106,7 @@ public class ECKeyTest {
     public void testSignatures() throws Exception {
         // Test that we can construct an ECKey from a private key (deriving the public from the private), then signing
         // a message with it.
-        BigInteger privkey = Utils.bytesToBigInteger(HEX.decode("180cb41c7c600be951b5d3d0a7334acc7506173875834f7a6c4c786a28fcbb19"));
+        BigInteger privkey = ByteUtils.bytesToBigInteger(HEX.decode("180cb41c7c600be951b5d3d0a7334acc7506173875834f7a6c4c786a28fcbb19"));
         ECKey key = ECKey.fromPrivate(privkey);
         byte[] output = key.sign(Sha256Hash.ZERO_HASH).encodeToDER();
         assertTrue(key.verify(Sha256Hash.ZERO_HASH.getBytes(), output));
@@ -203,8 +205,8 @@ public class ECKeyTest {
             ECKey key = new ECKey();
             ECKey key1 = DumpedPrivateKey.fromBase58(TESTNET,
                     key.getPrivateKeyEncoded(TESTNET).toString()).getKey();
-            assertEquals(Utils.HEX.encode(key.getPrivKeyBytes()),
-                    Utils.HEX.encode(key1.getPrivKeyBytes()));
+            assertEquals(ByteUtils.HEX.encode(key.getPrivKeyBytes()),
+                    ByteUtils.HEX.encode(key1.getPrivKeyBytes()));
         }
     }
 
@@ -321,7 +323,7 @@ public class ECKeyTest {
     public void testEncryptedCreate() {
         ECKey unencryptedKey = new ECKey();
         byte[] originalPrivateKeyBytes = checkNotNull(unencryptedKey.getPrivKeyBytes());
-        log.info("Original private key = " + Utils.HEX.encode(originalPrivateKeyBytes));
+        log.info("Original private key = " + ByteUtils.HEX.encode(originalPrivateKeyBytes));
         EncryptedData encryptedPrivateKey = keyCrypter.encrypt(unencryptedKey.getPrivKeyBytes(), keyCrypter.deriveKey(PASSWORD1));
         ECKey encryptedKey = ECKey.fromEncrypted(encryptedPrivateKey, keyCrypter, unencryptedKey.getPubKey());
         assertTrue(encryptedKey.isEncrypted());
@@ -478,7 +480,7 @@ public class ECKeyTest {
         // We dump failed data to error log because this test is not expected to be deterministic
         ECKey key = new ECKey();
         if (!ECKey.isPubKeyCanonical(key.getPubKey())) {
-            log.error(Utils.HEX.encode(key.getPubKey()));
+            log.error(ByteUtils.HEX.encode(key.getPubKey()));
             fail();
         }
 
@@ -488,7 +490,7 @@ public class ECKeyTest {
         byte[] encodedSig = Arrays.copyOf(sigBytes, sigBytes.length + 1);
         encodedSig[sigBytes.length] = Transaction.SigHash.ALL.byteValue();
         if (!TransactionSignature.isEncodingCanonical(encodedSig)) {
-            log.error(Utils.HEX.encode(sigBytes));
+            log.error(ByteUtils.HEX.encode(sigBytes));
             fail();
         }
     }
diff --git a/core/src/test/java/org/bitcoinj/core/FullBlockTestGenerator.java b/core/src/test/java/org/bitcoinj/core/FullBlockTestGenerator.java
index 8708a328d..3df31e42e 100644
--- a/core/src/test/java/org/bitcoinj/core/FullBlockTestGenerator.java
+++ b/core/src/test/java/org/bitcoinj/core/FullBlockTestGenerator.java
@@ -18,6 +18,8 @@ package org.bitcoinj.core;
 
 import com.google.common.base.Preconditions;
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Transaction.SigHash;
 import org.bitcoinj.crypto.TransactionSignature;
 import org.bitcoinj.script.Script;
@@ -184,11 +186,11 @@ public class FullBlockTestGenerator {
             public boolean add(Rule element) {
                 if (outStream != null && element instanceof BlockAndValidity) {
                     try {
-                        Utils.uint32ToByteStreamBE(params.getPacketMagic(), outStream);
+                        ByteUtils.uint32ToByteStreamBE(params.getPacketMagic(), outStream);
                         byte[] block = ((BlockAndValidity)element).block.bitcoinSerialize();
                         byte[] length = new byte[4];
-                        Utils.uint32ToByteArrayBE(block.length, length, 0);
-                        outStream.write(Utils.reverseBytes(length));
+                        ByteUtils.uint32ToByteArrayBE(block.length, length, 0);
+                        outStream.write(ByteUtils.reverseBytes(length));
                         outStream.write(block);
                         ((BlockAndValidity)element).block = null;
                     } catch (IOException e) {
@@ -1214,8 +1216,8 @@ public class FullBlockTestGenerator {
 
             byte[] varIntBytes = new byte[9];
             varIntBytes[0] = (byte) 255;
-            Utils.uint32ToByteArrayLE((long)b64Original.block.getTransactions().size(), varIntBytes, 1);
-            Utils.uint32ToByteArrayLE(((long)b64Original.block.getTransactions().size()) >>> 32, varIntBytes, 5);
+            ByteUtils.uint32ToByteArrayLE((long)b64Original.block.getTransactions().size(), varIntBytes, 1);
+            ByteUtils.uint32ToByteArrayLE(((long)b64Original.block.getTransactions().size()) >>> 32, varIntBytes, 5);
             stream.write(varIntBytes);
             checkState(new VarInt(varIntBytes, 0).intValue() == b64Original.block.getTransactions().size());
 
@@ -1373,7 +1375,7 @@ public class FullBlockTestGenerator {
             Arrays.fill(outputScript, (byte) OP_CHECKSIG);
             // If we push an element that is too large, the CHECKSIGs after that push are still counted
             outputScript[Block.MAX_BLOCK_SIGOPS - sigOps] = OP_PUSHDATA4;
-            Utils.uint32ToByteArrayLE(Script.MAX_SCRIPT_ELEMENT_SIZE + 1, outputScript, Block.MAX_BLOCK_SIGOPS - sigOps + 1);
+            ByteUtils.uint32ToByteArrayLE(Script.MAX_SCRIPT_ELEMENT_SIZE + 1, outputScript, Block.MAX_BLOCK_SIGOPS - sigOps + 1);
             tx.addOutput(new TransactionOutput(params, tx, SATOSHI, outputScript));
             addOnlyInputToTransaction(tx, b73);
             b73.addTransaction(tx);
@@ -1439,7 +1441,7 @@ public class FullBlockTestGenerator {
             Arrays.fill(outputScript, (byte) OP_CHECKSIG);
             // If we push an element that is filled with CHECKSIGs, they (obviously) arent counted
             outputScript[Block.MAX_BLOCK_SIGOPS - sigOps] = OP_PUSHDATA4;
-            Utils.uint32ToByteArrayLE(Block.MAX_BLOCK_SIGOPS, outputScript, Block.MAX_BLOCK_SIGOPS - sigOps + 1);
+            ByteUtils.uint32ToByteArrayLE(Block.MAX_BLOCK_SIGOPS, outputScript, Block.MAX_BLOCK_SIGOPS - sigOps + 1);
             tx.addOutput(new TransactionOutput(params, tx, SATOSHI, outputScript));
             addOnlyInputToTransaction(tx, b76);
             b76.addTransaction(tx);
diff --git a/core/src/test/java/org/bitcoinj/core/LegacyAddressTest.java b/core/src/test/java/org/bitcoinj/core/LegacyAddressTest.java
index 60c016d69..27859642e 100644
--- a/core/src/test/java/org/bitcoinj/core/LegacyAddressTest.java
+++ b/core/src/test/java/org/bitcoinj/core/LegacyAddressTest.java
@@ -19,6 +19,7 @@ package org.bitcoinj.core;
 
 import nl.jqno.equalsverifier.EqualsVerifier;
 import nl.jqno.equalsverifier.Warning;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.Networks;
 import org.bitcoinj.params.TestNet3Params;
@@ -33,7 +34,7 @@ import java.io.InputStreamReader;
 import java.util.Arrays;
 import java.util.List;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertTrue;
@@ -68,10 +69,10 @@ public class LegacyAddressTest {
     @Test
     public void decoding() {
         LegacyAddress a = LegacyAddress.fromBase58(TESTNET, "n4eA2nbYqErp7H6jebchxAN59DmNpksexv");
-        assertEquals("fda79a24e50ff70ff42f7d89585da5bd19d9e5cc", Utils.HEX.encode(a.getHash()));
+        assertEquals("fda79a24e50ff70ff42f7d89585da5bd19d9e5cc", ByteUtils.HEX.encode(a.getHash()));
 
         LegacyAddress b = LegacyAddress.fromBase58(MAINNET, "17kzeh4N8g49GFvdDzSf8PjaPfyoD1MndL");
-        assertEquals("4a22c3c4cbb31e4d03b15550636762bda0baf85a", Utils.HEX.encode(b.getHash()));
+        assertEquals("4a22c3c4cbb31e4d03b15550636762bda0baf85a", ByteUtils.HEX.encode(b.getHash()));
     }
 
     @Test
diff --git a/core/src/test/java/org/bitcoinj/core/ParseByteCacheTest.java b/core/src/test/java/org/bitcoinj/core/ParseByteCacheTest.java
index e1a9eb08c..9c47803f2 100644
--- a/core/src/test/java/org/bitcoinj/core/ParseByteCacheTest.java
+++ b/core/src/test/java/org/bitcoinj/core/ParseByteCacheTest.java
@@ -17,6 +17,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.UnitTestParams;
 import org.bitcoinj.script.Script;
@@ -31,7 +32,7 @@ import java.nio.ByteBuffer;
 
 import static org.bitcoinj.base.Coin.COIN;
 import static org.bitcoinj.base.Coin.valueOf;
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.bitcoinj.testing.FakeTxBuilder.createFakeBlock;
 import static org.bitcoinj.testing.FakeTxBuilder.createFakeTx;
 import static org.junit.Assert.assertArrayEquals;
@@ -449,8 +450,8 @@ public class ParseByteCacheTest {
         if (sup.length < sub.length)
             return false;       
         
-        String superstring = Utils.HEX.encode(sup);
-        String substring = Utils.HEX.encode(sub);
+        String superstring = ByteUtils.HEX.encode(sup);
+        String substring = ByteUtils.HEX.encode(sub);
         
         int ind = superstring.indexOf(substring);
         
diff --git a/core/src/test/java/org/bitcoinj/core/PeerAddressTest.java b/core/src/test/java/org/bitcoinj/core/PeerAddressTest.java
index cd6153c37..40f8811e7 100644
--- a/core/src/test/java/org/bitcoinj/core/PeerAddressTest.java
+++ b/core/src/test/java/org/bitcoinj/core/PeerAddressTest.java
@@ -17,13 +17,14 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.params.MainNetParams;
 import org.junit.Test;
 
 import java.math.BigInteger;
 import java.net.InetAddress;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
@@ -48,7 +49,7 @@ public class PeerAddressTest {
         MessageSerializer serializer = MAINNET.getDefaultSerializer().withProtocolVersion(0);
         PeerAddress pa = new PeerAddress(MAINNET, InetAddress.getByName(null), 8333, BigInteger.ZERO,
                 serializer);
-        assertEquals("000000000000000000000000000000000000ffff7f000001208d", Utils.HEX.encode(pa.bitcoinSerialize()));
+        assertEquals("000000000000000000000000000000000000ffff7f000001208d", ByteUtils.HEX.encode(pa.bitcoinSerialize()));
         assertEquals(26, pa.length);
     }
 
diff --git a/core/src/test/java/org/bitcoinj/core/PrefixedChecksummedBytesTest.java b/core/src/test/java/org/bitcoinj/core/PrefixedChecksummedBytesTest.java
index f69239bed..d59e3c99f 100644
--- a/core/src/test/java/org/bitcoinj/core/PrefixedChecksummedBytesTest.java
+++ b/core/src/test/java/org/bitcoinj/core/PrefixedChecksummedBytesTest.java
@@ -26,7 +26,7 @@ import org.easymock.Mock;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.replay;
 import static org.junit.Assert.assertEquals;
diff --git a/core/src/test/java/org/bitcoinj/core/SegwitAddressTest.java b/core/src/test/java/org/bitcoinj/core/SegwitAddressTest.java
index 3b6fd81ba..41883923b 100644
--- a/core/src/test/java/org/bitcoinj/core/SegwitAddressTest.java
+++ b/core/src/test/java/org/bitcoinj/core/SegwitAddressTest.java
@@ -19,6 +19,7 @@ package org.bitcoinj.core;
 import com.google.common.base.MoreObjects;
 import nl.jqno.equalsverifier.EqualsVerifier;
 import nl.jqno.equalsverifier.Warning;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.TestNet3Params;
 import org.bitcoinj.script.Script;
@@ -54,7 +55,7 @@ public class SegwitAddressTest {
 
         assertEquals(MAINNET, address.params);
         assertEquals("0014751e76e8199196d454941c45d1b3a323f1433bd6",
-                Utils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
+                ByteUtils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
         assertEquals(ScriptType.P2WPKH, address.getOutputScriptType());
         assertEquals(bech32.toLowerCase(Locale.ROOT), address.toBech32());
         assertEquals(bech32.toLowerCase(Locale.ROOT), address.toString());
@@ -68,7 +69,7 @@ public class SegwitAddressTest {
 
         assertEquals(MAINNET, address.params);
         assertEquals("00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262",
-                Utils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
+                ByteUtils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
         assertEquals(ScriptType.P2WSH, address.getOutputScriptType());
         assertEquals(bech32.toLowerCase(Locale.ROOT), address.toBech32());
         assertEquals(bech32.toLowerCase(Locale.ROOT), address.toString());
@@ -82,7 +83,7 @@ public class SegwitAddressTest {
 
         assertEquals(TESTNET, address.params);
         assertEquals("0014751e76e8199196d454941c45d1b3a323f1433bd6",
-                Utils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
+                ByteUtils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
         assertEquals(ScriptType.P2WPKH, address.getOutputScriptType());
         assertEquals(bech32.toLowerCase(Locale.ROOT), address.toBech32());
         assertEquals(bech32.toLowerCase(Locale.ROOT), address.toString());
@@ -96,7 +97,7 @@ public class SegwitAddressTest {
 
         assertEquals(TESTNET, address.params);
         assertEquals("00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262",
-                Utils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
+                ByteUtils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
         assertEquals(ScriptType.P2WSH, address.getOutputScriptType());
         assertEquals(bech32.toLowerCase(Locale.ROOT), address.toBech32());
         assertEquals(bech32.toLowerCase(Locale.ROOT), address.toString());
@@ -109,10 +110,10 @@ public class SegwitAddressTest {
 
             assertEquals(valid.expectedParams, address.params);
             assertEquals(valid.expectedScriptPubKey,
-                    Utils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
+                    ByteUtils.HEX.encode(ScriptBuilder.createOutputScript(address).getProgram()));
             assertEquals(valid.address.toLowerCase(Locale.ROOT), address.toBech32());
             if (valid.expectedWitnessVersion == 0) {
-                Script expectedScriptPubKey = new Script(Utils.HEX.decode(valid.expectedScriptPubKey));
+                Script expectedScriptPubKey = new Script(ByteUtils.HEX.decode(valid.expectedScriptPubKey));
                 assertEquals(address, SegwitAddress.fromHash(valid.expectedParams,
                         ScriptPattern.extractHashFromP2WH(expectedScriptPubKey)));
             }
diff --git a/core/src/test/java/org/bitcoinj/core/SendHeadersMessageTest.java b/core/src/test/java/org/bitcoinj/core/SendHeadersMessageTest.java
index b5c8f69f7..8886b5156 100644
--- a/core/src/test/java/org/bitcoinj/core/SendHeadersMessageTest.java
+++ b/core/src/test/java/org/bitcoinj/core/SendHeadersMessageTest.java
@@ -21,7 +21,7 @@ import org.junit.Test;
 
 import java.nio.ByteBuffer;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertTrue;
 
 public class SendHeadersMessageTest {
diff --git a/core/src/test/java/org/bitcoinj/core/TransactionInputTest.java b/core/src/test/java/org/bitcoinj/core/TransactionInputTest.java
index b74fe97f4..0754f5d26 100644
--- a/core/src/test/java/org/bitcoinj/core/TransactionInputTest.java
+++ b/core/src/test/java/org/bitcoinj/core/TransactionInputTest.java
@@ -18,6 +18,7 @@ package org.bitcoinj.core;
 
 import com.google.common.collect.Lists;
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.params.UnitTestParams;
 import org.bitcoinj.script.Script;
 import org.bitcoinj.script.ScriptBuilder;
diff --git a/core/src/test/java/org/bitcoinj/core/TransactionTest.java b/core/src/test/java/org/bitcoinj/core/TransactionTest.java
index abc479f8e..7cd78482a 100644
--- a/core/src/test/java/org/bitcoinj/core/TransactionTest.java
+++ b/core/src/test/java/org/bitcoinj/core/TransactionTest.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.TransactionConfidence.ConfidenceType;
 import org.bitcoinj.crypto.TransactionSignature;
 import org.bitcoinj.params.TestNet3Params;
@@ -46,8 +47,8 @@ import java.util.concurrent.Executors;
 import java.util.function.IntFunction;
 import java.util.stream.Stream;
 
-import static org.bitcoinj.core.Utils.HEX;
-import static org.bitcoinj.core.Utils.uint32ToByteStreamLE;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.uint32ToByteStreamLE;
 import static org.easymock.EasyMock.createMock;
 import static org.easymock.EasyMock.replay;
 import static org.junit.Assert.assertEquals;
diff --git a/core/src/test/java/org/bitcoinj/core/TransactionWitnessTest.java b/core/src/test/java/org/bitcoinj/core/TransactionWitnessTest.java
index a5d66f2e1..b22887e97 100644
--- a/core/src/test/java/org/bitcoinj/core/TransactionWitnessTest.java
+++ b/core/src/test/java/org/bitcoinj/core/TransactionWitnessTest.java
@@ -14,6 +14,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.crypto.TransactionSignature;
 import org.bitcoinj.script.Script;
 import org.bouncycastle.util.encoders.Hex;
@@ -33,9 +34,9 @@ public class TransactionWitnessTest {
         assertEquals("", w2.toString());
 
         TransactionWitness w3 = new TransactionWitness(3);
-        w3.setPush(0, Utils.HEX.decode("123aaa"));
-        w3.setPush(1, Utils.HEX.decode("123bbb"));
-        w3.setPush(3, Utils.HEX.decode("123ccc"));
+        w3.setPush(0, ByteUtils.HEX.decode("123aaa"));
+        w3.setPush(1, ByteUtils.HEX.decode("123bbb"));
+        w3.setPush(3, ByteUtils.HEX.decode("123ccc"));
         assertEquals("123aaa 123bbb EMPTY 123ccc", w3.toString());
     }
 
diff --git a/core/src/test/java/org/bitcoinj/core/TxConfidenceTableTest.java b/core/src/test/java/org/bitcoinj/core/TxConfidenceTableTest.java
index b1a56af3b..261f074be 100644
--- a/core/src/test/java/org/bitcoinj/core/TxConfidenceTableTest.java
+++ b/core/src/test/java/org/bitcoinj/core/TxConfidenceTableTest.java
@@ -16,6 +16,7 @@
 
 package org.bitcoinj.core;
 
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.params.UnitTestParams;
 import org.bitcoinj.testing.FakeTxBuilder;
 import org.bitcoinj.utils.BriefLogFormatter;
diff --git a/core/src/test/java/org/bitcoinj/core/UTXOTest.java b/core/src/test/java/org/bitcoinj/core/UTXOTest.java
index 3eb8aed0b..dfa213ca5 100644
--- a/core/src/test/java/org/bitcoinj/core/UTXOTest.java
+++ b/core/src/test/java/org/bitcoinj/core/UTXOTest.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.script.ScriptBuilder;
 import org.junit.Test;
 
diff --git a/core/src/test/java/org/bitcoinj/core/UtilsTest.java b/core/src/test/java/org/bitcoinj/core/UtilsTest.java
index cffee6f5f..9e2df995e 100644
--- a/core/src/test/java/org/bitcoinj/core/UtilsTest.java
+++ b/core/src/test/java/org/bitcoinj/core/UtilsTest.java
@@ -20,114 +20,20 @@ package org.bitcoinj.core;
 
 import org.junit.Test;
 
-import java.math.BigInteger;
 import java.util.Date;
-import java.util.Random;
 
-import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 public class UtilsTest {
 
-    @Test
-    public void testReverseBytes() {
-        assertArrayEquals(new byte[]{1, 2, 3, 4, 5}, Utils.reverseBytes(new byte[]{5, 4, 3, 2, 1}));
-        assertArrayEquals(new byte[]{0}, Utils.reverseBytes(new byte[]{0}));
-        assertArrayEquals(new byte[]{}, Utils.reverseBytes(new byte[]{}));
-    }
-
-    @Test
-    public void compactEncoding() {
-        assertEquals(new BigInteger("1234560000", 16), Utils.decodeCompactBits(0x05123456L));
-        assertEquals(new BigInteger("c0de000000", 16), Utils.decodeCompactBits(0x0600c0de));
-        assertEquals(0x05123456L, Utils.encodeCompactBits(new BigInteger("1234560000", 16)));
-        assertEquals(0x0600c0deL, Utils.encodeCompactBits(new BigInteger("c0de000000", 16)));
-        // UnitTest difficulty
-        assertEquals(new BigInteger("7fffff0000000000000000000000000000000000000000000000000000000000", 16), Utils.decodeCompactBits(0x207fFFFFL));
-        assertEquals(0x207fFFFFL, Utils.encodeCompactBits(new BigInteger("7fffff0000000000000000000000000000000000000000000000000000000000", 16)));
-        // MainNet starting difficulty
-        assertEquals(new BigInteger("00000000FFFF0000000000000000000000000000000000000000000000000000", 16), Utils.decodeCompactBits(0x1d00ffffL));
-        assertEquals(0x1d00ffffL, Utils.encodeCompactBits(new BigInteger("00000000FFFF0000000000000000000000000000000000000000000000000000", 16)));
-    }
-
     @Test
     public void dateTimeFormat() {
         assertEquals("2014-11-16T10:54:33Z", Utils.dateTimeFormat(1416135273781L));
         assertEquals("2014-11-16T10:54:33Z", Utils.dateTimeFormat(new Date(1416135273781L)));
     }
 
-    @Test
-    public void bigIntegerToBytes_roundTrip() {
-        int ITERATIONS = 100;
-        int LENGTH = 32;
-        Random rnd = new Random();
-        byte[] bytes = new byte[LENGTH];
-
-        for (int i = 0; i < ITERATIONS; i++) {
-            rnd.nextBytes(bytes);
-            BigInteger bi = Utils.bytesToBigInteger(bytes);
-            assertArrayEquals(Utils.HEX.encode(bytes), bytes, Utils.bigIntegerToBytes(bi, LENGTH));
-        }
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void bigIntegerToBytes_convertNegativeNumber() {
-        BigInteger b = BigInteger.valueOf(-1);
-        Utils.bigIntegerToBytes(b, 32);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void bigIntegerToBytes_convertWithNegativeLength() {
-        BigInteger b = BigInteger.valueOf(10);
-        Utils.bigIntegerToBytes(b, -1);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void bigIntegerToBytes_convertWithZeroLength() {
-        BigInteger b = BigInteger.valueOf(10);
-        Utils.bigIntegerToBytes(b, 0);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void bigIntegerToBytes_insufficientLength() {
-        BigInteger b = BigInteger.valueOf(0b1000__0000_0000);   // base 2
-        Utils.bigIntegerToBytes(b, 1);
-    }
-
-    @Test
-    public void bigIntegerToBytes_convertZero() {
-        BigInteger b = BigInteger.valueOf(0);
-        byte[] expected = new byte[]{0b0000_0000};
-        byte[] actual = Utils.bigIntegerToBytes(b, 1);
-        assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void bigIntegerToBytes_singleByteSignFit() {
-        BigInteger b = BigInteger.valueOf(0b0000_1111);
-        byte[] expected = new byte[]{0b0000_1111};
-        byte[] actual = Utils.bigIntegerToBytes(b, 1);
-        assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void bigIntegerToBytes_paddedSingleByte() {
-        BigInteger b = BigInteger.valueOf(0b0000_1111);
-        byte[] expected = new byte[]{0, 0b0000_1111};
-        byte[] actual = Utils.bigIntegerToBytes(b, 2);
-        assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void bigIntegerToBytes_singleByteSignDoesNotFit() {
-        BigInteger b = BigInteger.valueOf(0b1000_0000);     // 128 (2-compl does not fit in one byte)
-        byte[] expected = new byte[]{-128};                 // -128 == 1000_0000 (compl-2)
-        byte[] actual = Utils.bigIntegerToBytes(b, 1);
-        assertArrayEquals(expected, actual);
-    }
-
     @Test
     public void runtime() {
         // This test assumes it is run within a Java runtime for desktop computers.
@@ -135,122 +41,6 @@ public class UtilsTest {
         assertFalse(Utils.isAndroidRuntime());
     }
 
-    @Test
-    public void testReadUint16() {
-        assertEquals(258L, Utils.readUint16(new byte[]{2, 1}, 0));
-        assertEquals(258L, Utils.readUint16(new byte[]{2, 1, 3, 4}, 0));
-        assertEquals(772L, Utils.readUint16(new byte[]{1, 2, 4, 3}, 2));
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint16ThrowsException1() {
-        Utils.readUint16(new byte[]{1}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint16ThrowsException2() {
-        Utils.readUint16(new byte[]{1, 2, 3}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint16ThrowsException3() {
-        Utils.readUint16(new byte[]{1, 2, 3}, -1);
-    }
-
-    @Test
-    public void testReadUint32() {
-        assertEquals(258L, Utils.readUint32(new byte[]{2, 1, 0, 0}, 0));
-        assertEquals(258L, Utils.readUint32(new byte[]{2, 1, 0, 0, 3, 4}, 0));
-        assertEquals(772L, Utils.readUint32(new byte[]{1, 2, 4, 3, 0, 0}, 2));
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint32ThrowsException1() {
-        Utils.readUint32(new byte[]{1, 2, 3}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint32ThrowsException2() {
-        Utils.readUint32(new byte[]{1, 2, 3, 4, 5}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint32ThrowsException3() {
-        Utils.readUint32(new byte[]{1, 2, 3, 4, 5}, -1);
-    }
-
-    @Test
-    public void testReadInt64() {
-        assertEquals(258L, Utils.readInt64(new byte[]{2, 1, 0, 0, 0, 0, 0, 0}, 0));
-        assertEquals(258L, Utils.readInt64(new byte[]{2, 1, 0, 0, 0, 0, 0, 0, 3, 4}, 0));
-        assertEquals(772L, Utils.readInt64(new byte[]{1, 2, 4, 3, 0, 0, 0, 0, 0, 0}, 2));
-        assertEquals(-1L, Utils.readInt64(new byte[]{-1, -1, -1, -1, -1, -1, -1, -1}, 0));
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadInt64ThrowsException1() {
-        Utils.readInt64(new byte[]{1, 2, 3, 4, 5, 6, 7}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadInt64ThrowsException2() {
-        Utils.readInt64(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadInt64ThrowsException3() {
-        Utils.readInt64(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9}, -1);
-    }
-
-    @Test
-    public void testReadUInt32BE() {
-        assertEquals(258L, Utils.readUint32BE(new byte[]{0, 0, 1, 2}, 0));
-        assertEquals(258L, Utils.readUint32BE(new byte[]{0, 0, 1, 2, 3, 4}, 0));
-        assertEquals(772L, Utils.readUint32BE(new byte[]{1, 2, 0, 0, 3, 4}, 2));
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint32BEThrowsException1() {
-        Utils.readUint32BE(new byte[]{1, 2, 3}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint32BEThrowsException2() {
-        Utils.readUint32BE(new byte[]{1, 2, 3, 4, 5}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint32BEThrowsException3() {
-        Utils.readUint32BE(new byte[]{1, 2, 3, 4, 5}, -1);
-    }
-
-    @Test
-    public void testReadUint16BE() {
-        assertEquals(258L, Utils.readUint16BE(new byte[]{1, 2}, 0));
-        assertEquals(258L, Utils.readUint16BE(new byte[]{1, 2, 3, 4}, 0));
-        assertEquals(772L, Utils.readUint16BE(new byte[]{0, 0, 3, 4}, 2));
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint16BEThrowsException1() {
-        Utils.readUint16BE(new byte[]{1}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint16BEThrowsException2() {
-        Utils.readUint16BE(new byte[]{1, 2, 3}, 2);
-    }
-
-    @Test(expected = ArrayIndexOutOfBoundsException.class)
-    public void testReadUint16BEThrowsException3() {
-        Utils.readUint16BE(new byte[]{1, 2, 3}, -1);
-    }
-
-    @Test
-    public void testDecodeMPI() {
-        assertEquals(BigInteger.ZERO, Utils.decodeMPI(new byte[]{}, false));
-    }
-
     @Test
     public void testRollMockClock() {
         Utils.setMockClock(25200);
diff --git a/core/src/test/java/org/bitcoinj/core/VersionMessageTest.java b/core/src/test/java/org/bitcoinj/core/VersionMessageTest.java
index 704a3e1e0..daec16898 100644
--- a/core/src/test/java/org/bitcoinj/core/VersionMessageTest.java
+++ b/core/src/test/java/org/bitcoinj/core/VersionMessageTest.java
@@ -22,7 +22,7 @@ import org.junit.Test;
 
 import java.net.InetAddress;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
diff --git a/core/src/test/java/org/bitcoinj/crypto/BIP32Test.java b/core/src/test/java/org/bitcoinj/crypto/BIP32Test.java
index 3d66a2f52..a97da77fe 100644
--- a/core/src/test/java/org/bitcoinj/crypto/BIP32Test.java
+++ b/core/src/test/java/org/bitcoinj/crypto/BIP32Test.java
@@ -28,7 +28,7 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertEquals;
 
 /**
diff --git a/core/src/test/java/org/bitcoinj/crypto/ChildKeyDerivationTest.java b/core/src/test/java/org/bitcoinj/crypto/ChildKeyDerivationTest.java
index 9dc999fb0..a6ce52aba 100644
--- a/core/src/test/java/org/bitcoinj/crypto/ChildKeyDerivationTest.java
+++ b/core/src/test/java/org/bitcoinj/crypto/ChildKeyDerivationTest.java
@@ -19,14 +19,14 @@ package org.bitcoinj.crypto;
 
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.TestNet3Params;
 import org.bitcoinj.params.UnitTestParams;
 import org.bouncycastle.crypto.params.KeyParameter;
 import org.junit.Test;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
diff --git a/core/src/test/java/org/bitcoinj/crypto/HDKeyDerivationTest.java b/core/src/test/java/org/bitcoinj/crypto/HDKeyDerivationTest.java
index 0361101dc..8c46afc47 100644
--- a/core/src/test/java/org/bitcoinj/crypto/HDKeyDerivationTest.java
+++ b/core/src/test/java/org/bitcoinj/crypto/HDKeyDerivationTest.java
@@ -17,7 +17,7 @@
 package org.bitcoinj.crypto;
 
 
-import org.bitcoinj.core.Utils;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.crypto.HDKeyDerivation.PublicDeriveMode;
 import org.bouncycastle.crypto.params.KeyParameter;
 import org.junit.Test;
@@ -50,7 +50,7 @@ public class HDKeyDerivationTest {
         assertFalse(parent.isEncrypted());
 
         DeterministicKey fromPrivate = HDKeyDerivation.deriveChildKeyFromPrivate(parent, CHILD_NUMBER);
-        assertEquals(EXPECTED_CHILD_CHAIN_CODE, Utils.HEX.encode(fromPrivate.getChainCode()));
+        assertEquals(EXPECTED_CHILD_CHAIN_CODE, ByteUtils.HEX.encode(fromPrivate.getChainCode()));
         assertEquals(EXPECTED_CHILD_PRIVATE_KEY, fromPrivate.getPrivateKeyAsHex());
         assertEquals(EXPECTED_CHILD_PUBLIC_KEY, fromPrivate.getPublicKeyAsHex());
         assertFalse(fromPrivate.isPubKeyOnly());
@@ -58,7 +58,7 @@ public class HDKeyDerivationTest {
 
         DeterministicKey fromPublic = HDKeyDerivation.deriveChildKeyFromPublic(parent, CHILD_NUMBER,
                 PublicDeriveMode.NORMAL);
-        assertEquals(EXPECTED_CHILD_CHAIN_CODE, Utils.HEX.encode(fromPublic.getChainCode()));
+        assertEquals(EXPECTED_CHILD_CHAIN_CODE, ByteUtils.HEX.encode(fromPublic.getChainCode()));
         assertEquals(EXPECTED_CHILD_PRIVATE_KEY, fromPublic.getPrivateKeyAsHex());
         assertEquals(EXPECTED_CHILD_PUBLIC_KEY, fromPublic.getPublicKeyAsHex());
         assertFalse(fromPublic.isPubKeyOnly());
@@ -66,7 +66,7 @@ public class HDKeyDerivationTest {
 
         DeterministicKey fromPublicWithInversion = HDKeyDerivation.deriveChildKeyFromPublic(parent, CHILD_NUMBER,
                 PublicDeriveMode.WITH_INVERSION);
-        assertEquals(EXPECTED_CHILD_CHAIN_CODE, Utils.HEX.encode(fromPublicWithInversion.getChainCode()));
+        assertEquals(EXPECTED_CHILD_CHAIN_CODE, ByteUtils.HEX.encode(fromPublicWithInversion.getChainCode()));
         assertEquals(EXPECTED_CHILD_PRIVATE_KEY, fromPublicWithInversion.getPrivateKeyAsHex());
         assertEquals(EXPECTED_CHILD_PUBLIC_KEY, fromPublicWithInversion.getPublicKeyAsHex());
         assertFalse(fromPublicWithInversion.isPubKeyOnly());
@@ -89,14 +89,14 @@ public class HDKeyDerivationTest {
 
         DeterministicKey fromPublic = HDKeyDerivation.deriveChildKeyFromPublic(parent, CHILD_NUMBER,
                 PublicDeriveMode.NORMAL);
-        assertEquals(EXPECTED_CHILD_CHAIN_CODE, Utils.HEX.encode(fromPublic.getChainCode()));
+        assertEquals(EXPECTED_CHILD_CHAIN_CODE, ByteUtils.HEX.encode(fromPublic.getChainCode()));
         assertEquals(EXPECTED_CHILD_PUBLIC_KEY, fromPublic.getPublicKeyAsHex());
         assertTrue(fromPublic.isPubKeyOnly());
         assertFalse(fromPublic.isEncrypted());
 
         DeterministicKey fromPublicWithInversion = HDKeyDerivation.deriveChildKeyFromPublic(parent, CHILD_NUMBER,
                 PublicDeriveMode.WITH_INVERSION);
-        assertEquals(EXPECTED_CHILD_CHAIN_CODE, Utils.HEX.encode(fromPublicWithInversion.getChainCode()));
+        assertEquals(EXPECTED_CHILD_CHAIN_CODE, ByteUtils.HEX.encode(fromPublicWithInversion.getChainCode()));
         assertEquals(EXPECTED_CHILD_PUBLIC_KEY, fromPublicWithInversion.getPublicKeyAsHex());
         assertTrue(fromPublicWithInversion.isPubKeyOnly());
         assertFalse(fromPublicWithInversion.isEncrypted());
@@ -119,23 +119,23 @@ public class HDKeyDerivationTest {
 
         DeterministicKey fromPublic = HDKeyDerivation.deriveChildKeyFromPublic(parent, CHILD_NUMBER,
                 PublicDeriveMode.NORMAL);
-        assertEquals(EXPECTED_CHILD_CHAIN_CODE, Utils.HEX.encode(fromPublic.getChainCode()));
+        assertEquals(EXPECTED_CHILD_CHAIN_CODE, ByteUtils.HEX.encode(fromPublic.getChainCode()));
         assertEquals(EXPECTED_CHILD_PUBLIC_KEY, fromPublic.getPublicKeyAsHex());
         assertTrue(fromPublic.isPubKeyOnly());
         assertTrue(fromPublic.isEncrypted());
         fromPublic = fromPublic.decrypt(AES_KEY);
-        assertEquals(EXPECTED_CHILD_CHAIN_CODE, Utils.HEX.encode(fromPublic.getChainCode()));
+        assertEquals(EXPECTED_CHILD_CHAIN_CODE, ByteUtils.HEX.encode(fromPublic.getChainCode()));
         assertEquals(EXPECTED_CHILD_PRIVATE_KEY, fromPublic.getPrivateKeyAsHex());
         assertEquals(EXPECTED_CHILD_PUBLIC_KEY, fromPublic.getPublicKeyAsHex());
 
         DeterministicKey fromPublicWithInversion = HDKeyDerivation.deriveChildKeyFromPublic(parent, CHILD_NUMBER,
                 PublicDeriveMode.WITH_INVERSION);
-        assertEquals(EXPECTED_CHILD_CHAIN_CODE, Utils.HEX.encode(fromPublicWithInversion.getChainCode()));
+        assertEquals(EXPECTED_CHILD_CHAIN_CODE, ByteUtils.HEX.encode(fromPublicWithInversion.getChainCode()));
         assertEquals(EXPECTED_CHILD_PUBLIC_KEY, fromPublicWithInversion.getPublicKeyAsHex());
         assertTrue(fromPublicWithInversion.isPubKeyOnly());
         assertTrue(fromPublicWithInversion.isEncrypted());
         fromPublicWithInversion = fromPublicWithInversion.decrypt(AES_KEY);
-        assertEquals(EXPECTED_CHILD_CHAIN_CODE, Utils.HEX.encode(fromPublicWithInversion.getChainCode()));
+        assertEquals(EXPECTED_CHILD_CHAIN_CODE, ByteUtils.HEX.encode(fromPublicWithInversion.getChainCode()));
         assertEquals(EXPECTED_CHILD_PRIVATE_KEY, fromPublicWithInversion.getPrivateKeyAsHex());
         assertEquals(EXPECTED_CHILD_PUBLIC_KEY, fromPublicWithInversion.getPublicKeyAsHex());
     }
diff --git a/core/src/test/java/org/bitcoinj/crypto/HDUtilsTest.java b/core/src/test/java/org/bitcoinj/crypto/HDUtilsTest.java
index f20c56d9e..46ee0e5b0 100644
--- a/core/src/test/java/org/bitcoinj/crypto/HDUtilsTest.java
+++ b/core/src/test/java/org/bitcoinj/crypto/HDUtilsTest.java
@@ -19,7 +19,7 @@ package org.bitcoinj.crypto;
 
 import org.junit.Test;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
diff --git a/core/src/test/java/org/bitcoinj/crypto/KeyCrypterScryptTest.java b/core/src/test/java/org/bitcoinj/crypto/KeyCrypterScryptTest.java
index 5ab05c038..e544b5ebe 100644
--- a/core/src/test/java/org/bitcoinj/crypto/KeyCrypterScryptTest.java
+++ b/core/src/test/java/org/bitcoinj/crypto/KeyCrypterScryptTest.java
@@ -17,7 +17,7 @@
 
 package org.bitcoinj.crypto;
 
-import org.bitcoinj.core.Utils;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.junit.Before;
 import org.junit.Test;
 import org.slf4j.Logger;
@@ -59,9 +59,9 @@ public class KeyCrypterScryptTest {
 
         // Decrypt.
         byte[] reborn = keyCrypter.decrypt(data, keyCrypter.deriveKey(PASSWORD1));
-        log.debug("Original: " + Utils.HEX.encode(TEST_BYTES1));
-        log.debug("Reborn  : " + Utils.HEX.encode(reborn));
-        assertEquals(Utils.HEX.encode(TEST_BYTES1), Utils.HEX.encode(reborn));
+        log.debug("Original: " + ByteUtils.HEX.encode(TEST_BYTES1));
+        log.debug("Reborn  : " + ByteUtils.HEX.encode(reborn));
+        assertEquals(ByteUtils.HEX.encode(TEST_BYTES1), ByteUtils.HEX.encode(reborn));
     }
 
     /**
@@ -83,7 +83,7 @@ public class KeyCrypterScryptTest {
             assertNotNull(data);
 
             byte[] reconstructedPlainBytes = keyCrypter.decrypt(data,keyCrypter.deriveKey(password));
-            assertEquals(Utils.HEX.encode(plainText.getBytes()), Utils.HEX.encode(reconstructedPlainBytes));
+            assertEquals(ByteUtils.HEX.encode(plainText.getBytes()), ByteUtils.HEX.encode(reconstructedPlainBytes));
         }
     }
 
@@ -118,13 +118,13 @@ public class KeyCrypterScryptTest {
         // Encrypt bytes.
         EncryptedData data = keyCrypter.encrypt(TEST_BYTES1, keyCrypter.deriveKey(PASSWORD1));
         assertNotNull(data);
-        log.debug("\nEncrypterDecrypterTest: cipherBytes = \nlength = " + data.encryptedBytes.length + "\n---------------\n" + Utils.HEX.encode(data.encryptedBytes) + "\n---------------\n");
+        log.debug("\nEncrypterDecrypterTest: cipherBytes = \nlength = " + data.encryptedBytes.length + "\n---------------\n" + ByteUtils.HEX.encode(data.encryptedBytes) + "\n---------------\n");
 
         byte[] rebornPlainBytes = keyCrypter.decrypt(data, keyCrypter.deriveKey(PASSWORD1));
 
-        log.debug("Original: " + Utils.HEX.encode(TEST_BYTES1));
-        log.debug("Reborn1 : " + Utils.HEX.encode(rebornPlainBytes));
-        assertEquals(Utils.HEX.encode(TEST_BYTES1), Utils.HEX.encode(rebornPlainBytes));
+        log.debug("Original: " + ByteUtils.HEX.encode(TEST_BYTES1));
+        log.debug("Reborn1 : " + ByteUtils.HEX.encode(rebornPlainBytes));
+        assertEquals(ByteUtils.HEX.encode(TEST_BYTES1), ByteUtils.HEX.encode(rebornPlainBytes));
     }
 
     @Test
@@ -142,9 +142,9 @@ public class KeyCrypterScryptTest {
 
             byte[] rebornPlainBytes = keyCrypter.decrypt(data, keyCrypter.deriveKey(PASSWORD1));
 
-            log.debug("Original: (" + i + ") " + Utils.HEX.encode(plainBytes));
-            log.debug("Reborn1 : (" + i + ") " + Utils.HEX.encode(rebornPlainBytes));
-            assertEquals(Utils.HEX.encode(plainBytes), Utils.HEX.encode(rebornPlainBytes));
+            log.debug("Original: (" + i + ") " + ByteUtils.HEX.encode(plainBytes));
+            log.debug("Reborn1 : (" + i + ") " + ByteUtils.HEX.encode(rebornPlainBytes));
+            assertEquals(ByteUtils.HEX.encode(plainBytes), ByteUtils.HEX.encode(rebornPlainBytes));
         }
     }
 }
diff --git a/core/src/test/java/org/bitcoinj/crypto/MnemonicCodeTest.java b/core/src/test/java/org/bitcoinj/crypto/MnemonicCodeTest.java
index b514b141f..1258e5e23 100644
--- a/core/src/test/java/org/bitcoinj/crypto/MnemonicCodeTest.java
+++ b/core/src/test/java/org/bitcoinj/crypto/MnemonicCodeTest.java
@@ -24,7 +24,7 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.bitcoinj.core.internal.InternalUtils.WHITESPACE_SPLITTER;
 import static org.junit.Assert.assertEquals;
 
diff --git a/core/src/test/java/org/bitcoinj/crypto/MnemonicCodeVectorsTest.java b/core/src/test/java/org/bitcoinj/crypto/MnemonicCodeVectorsTest.java
index f7f7d81b0..829a1d40c 100644
--- a/core/src/test/java/org/bitcoinj/crypto/MnemonicCodeVectorsTest.java
+++ b/core/src/test/java/org/bitcoinj/crypto/MnemonicCodeVectorsTest.java
@@ -27,7 +27,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.bitcoinj.core.internal.InternalUtils.SPACE_JOINER;
 import static org.bitcoinj.core.internal.InternalUtils.WHITESPACE_SPLITTER;
 import static org.junit.Assert.assertEquals;
diff --git a/core/src/test/java/org/bitcoinj/script/ScriptTest.java b/core/src/test/java/org/bitcoinj/script/ScriptTest.java
index 901c33f0a..2e1a70df4 100644
--- a/core/src/test/java/org/bitcoinj/script/ScriptTest.java
+++ b/core/src/test/java/org/bitcoinj/script/ScriptTest.java
@@ -21,6 +21,7 @@ package org.bitcoinj.script;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.Lists;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Address;
 import org.bitcoinj.base.Coin;
 import org.bitcoinj.core.Context;
@@ -31,14 +32,13 @@ import org.bitcoinj.core.MessageSerializer;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.ProtocolException;
 import org.bitcoinj.core.SegwitAddress;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.Transaction.SigHash;
 import org.bitcoinj.core.TransactionInput;
 import org.bitcoinj.core.TransactionOutPoint;
 import org.bitcoinj.core.TransactionOutput;
 import org.bitcoinj.core.UnsafeByteArrayOutputStream;
-import org.bitcoinj.core.Utils;
 import org.bitcoinj.core.VerificationException;
 import org.bitcoinj.crypto.TransactionSignature;
 import org.bitcoinj.params.MainNetParams;
@@ -65,7 +65,7 @@ import java.util.Map;
 import java.util.Set;
 
 import static org.bitcoinj.core.Transaction.SERIALIZE_TRANSACTION_NO_WITNESS;
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.bitcoinj.script.ScriptOpCodes.OP_0;
 import static org.bitcoinj.script.ScriptOpCodes.OP_INVALIDOPCODE;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -275,7 +275,7 @@ public class ScriptTest {
                 if (val >= -1 && val <= 16)
                     out.write(Script.encodeToOpN((int)val));
                 else
-                    Script.writeBytes(out, Utils.reverseBytes(Utils.encodeMPI(BigInteger.valueOf(val), false)));
+                    Script.writeBytes(out, ByteUtils.reverseBytes(ByteUtils.encodeMPI(BigInteger.valueOf(val), false)));
             } else if (w.matches("^0x[0-9a-fA-F]*$")) {
                 // Raw hex data, inserted NOT pushed onto stack:
                 out.write(HEX.decode(w.substring(2).toLowerCase()));
diff --git a/core/src/test/java/org/bitcoinj/store/SPVBlockStoreTest.java b/core/src/test/java/org/bitcoinj/store/SPVBlockStoreTest.java
index d9f8ce6a0..26ff0fbf9 100644
--- a/core/src/test/java/org/bitcoinj/store/SPVBlockStoreTest.java
+++ b/core/src/test/java/org/bitcoinj/store/SPVBlockStoreTest.java
@@ -23,7 +23,7 @@ import org.bitcoinj.core.Block;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.Utils;
 import org.bitcoinj.params.UnitTestParams;
diff --git a/core/src/test/java/org/bitcoinj/store/WalletProtobufSerializerTest.java b/core/src/test/java/org/bitcoinj/store/WalletProtobufSerializerTest.java
index ac4d0c1a9..a51ba85c7 100644
--- a/core/src/test/java/org/bitcoinj/store/WalletProtobufSerializerTest.java
+++ b/core/src/test/java/org/bitcoinj/store/WalletProtobufSerializerTest.java
@@ -19,6 +19,7 @@ package org.bitcoinj.store;
 
 import com.google.common.io.ByteStreams;
 import com.google.protobuf.ByteString;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Address;
 import org.bitcoinj.core.Block;
 import org.bitcoinj.core.BlockChain;
@@ -29,7 +30,7 @@ import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.NetworkParameters;
 import org.bitcoinj.core.PeerAddress;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.Transaction.Purpose;
 import org.bitcoinj.core.TransactionConfidence;
@@ -383,7 +384,7 @@ public class WalletProtobufSerializerTest {
 
     @Test
     public void roundtripVersionTwoTransaction() throws Exception {
-        Transaction tx = new Transaction(UNITTEST, Utils.HEX.decode(
+        Transaction tx = new Transaction(UNITTEST, ByteUtils.HEX.decode(
                 "0200000001d7902864af9310420c6e606b814c8f89f7902d40c130594e85df2e757a7cc301070000006b483045022100ca1757afa1af85c2bb014382d9ce411e1628d2b3d478df9d5d3e9e93cb25dcdd02206c5d272b31a23baf64e82793ee5c816e2bbef251e733a638b630ff2331fc83ba0121026ac2316508287761befbd0f7495ea794b396dbc5b556bf276639f56c0bd08911feffffff0274730700000000001976a91456da2d038a098c42390c77ef163e1cc23aedf24088ac91062300000000001976a9148ebf3467b9a8d7ae7b290da719e61142793392c188ac22e00600"));
         assertEquals(tx.getVersion(), 2);
         assertEquals(tx.getTxId().toString(), "0321b1413ed9048199815bd6bc2650cab1a9e8d543f109a42c769b1f18df4174");
@@ -480,7 +481,7 @@ public class WalletProtobufSerializerTest {
     @Test
     public void storeWitnessTransactions() throws Exception {
         // 3 inputs, inputs 0 and 2 have witnesses but not input 1
-        Transaction tx = new Transaction(UNITTEST, Utils.HEX.decode(
+        Transaction tx = new Transaction(UNITTEST, ByteUtils.HEX.decode(
                 "02000000000103fc8a5bea59392369e8a1b635395e507a5cbaeffd926e6967a00d17c669aef1d3010000001716001403c80a334ed6a92cf400d8c708522ea0d6fa5593ffffffffc0166d2218a2613b5384fc2c31238b1b6fa337080a1384220734e1bfd3629d3f0100000000ffffffffc0166d2218a2613b5384fc2c31238b1b6fa337080a1384220734e1bfd3629d3f0200000000ffffffff01a086010000000000220020eb72e573a9513d982a01f0e6a6b53e92764db81a0c26d2be94c5fc5b69a0db7d02473044022048e895b7af715303ce273a2be03d6110ed69b5700679f4f036000f8ba6eddd2802205f780423fcce9b3632ed41681b0a86f5d123766b71f303558c39c1be5fe43e2601210259eb16169df80dbe5856d082a226d84a97d191c895f8046c3544df525028a874000220c0166d2218a2613b5384fc2c31238b1b6fa337080a1384220734e1bfd3629d3f20c0166d2218a2613b5384fc2c31238b1b6fa337080a1384220734e1bfd3629d3f00000000"));
         assertTrue(tx.hasWitnesses());
         assertEquals(tx.getTxId().toString(), "1c687396f4710f26206dbdd8bf07a28c76398be6750226ddfaf05a1a80d30034");
diff --git a/core/src/test/java/org/bitcoinj/testing/KeyChainTransactionSigner.java b/core/src/test/java/org/bitcoinj/testing/KeyChainTransactionSigner.java
index 18b14465a..c47f74917 100644
--- a/core/src/test/java/org/bitcoinj/testing/KeyChainTransactionSigner.java
+++ b/core/src/test/java/org/bitcoinj/testing/KeyChainTransactionSigner.java
@@ -16,7 +16,7 @@
 
 package org.bitcoinj.testing;
 
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.crypto.ChildNumber;
 import org.bitcoinj.crypto.DeterministicKey;
 import org.bitcoinj.crypto.HDPath;
diff --git a/core/src/test/java/org/bitcoinj/wallet/DefaultRiskAnalysisTest.java b/core/src/test/java/org/bitcoinj/wallet/DefaultRiskAnalysisTest.java
index 483496d53..718273e1f 100644
--- a/core/src/test/java/org/bitcoinj/wallet/DefaultRiskAnalysisTest.java
+++ b/core/src/test/java/org/bitcoinj/wallet/DefaultRiskAnalysisTest.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.wallet;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.Context;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.NetworkParameters;
@@ -25,7 +26,6 @@ import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionConfidence;
 import org.bitcoinj.core.TransactionInput;
 import org.bitcoinj.core.TransactionOutput;
-import org.bitcoinj.core.Utils;
 import org.bitcoinj.crypto.TransactionSignature;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.script.Script;
@@ -192,7 +192,7 @@ public class DefaultRiskAnalysisTest {
                 DefaultRiskAnalysis.isInputStandard(new TransactionInput(MAINNET, null, scriptHighS.getProgram())));
 
         // This is a real transaction. Its signatures S component is "low".
-        Transaction tx1 = new Transaction(MAINNET, Utils.HEX.decode(
+        Transaction tx1 = new Transaction(MAINNET, ByteUtils.HEX.decode(
                 "010000000200a2be4376b7f47250ad9ad3a83b6aa5eb6a6d139a1f50771704d77aeb8ce76c010000006a4730440220055723d363cd2d4fe4e887270ebdf5c4b99eaf233a5c09f9404f888ec8b839350220763c3794d310b384ce86decfb05787e5bfa5d31983db612a2dde5ffec7f396ae012102ef47e27e0c4bdd6dc83915f185d972d5eb8515c34d17bad584a9312e59f4e0bcffffffff52239451d37757eeacb86d32864ec1ee6b6e131d1e3fee6f1cff512703b71014030000006b483045022100ea266ac4f893d98a623a6fc0e6a961cd5a3f32696721e87e7570a68851917e75022056d75c3b767419f6f6cb8189a0ad78d45971523908dc4892f7594b75fd43a8d00121038bb455ca101ebbb0ecf7f5c01fa1dcb7d14fbf6b7d7ea52ee56f0148e72a736cffffffff0630b15a00000000001976a9146ae477b690cf85f21c2c01e2c8639a5c18dc884e88ac4f260d00000000001976a91498d08c02ab92a671590adb726dddb719695ee12e88ac65753b00000000001976a9140b2eb4ba6d364c82092f25775f56bc10cd92c8f188ac65753b00000000001976a914d1cb414e22081c6ba3a935635c0f1d837d3c5d9188ac65753b00000000001976a914df9d137a0d279471a2796291874c29759071340b88ac3d753b00000000001976a91459f5aa4815e3aa8e1720e8b82f4ac8e6e904e47d88ac00000000"));
         assertEquals("2a1c8569b2b01ebac647fb94444d1118d4d00e327456a3c518e40d47d72cd5fe", tx1.getTxId().toString());
 
@@ -200,7 +200,7 @@ public class DefaultRiskAnalysisTest {
 
         // This tx is the same as the above, except for a "high" S component on the signature of input 1.
         // It was part of the Oct 2015 malleability attack.
-        Transaction tx2 = new Transaction(MAINNET, Utils.HEX.decode(
+        Transaction tx2 = new Transaction(MAINNET, ByteUtils.HEX.decode(
                 "010000000200a2be4376b7f47250ad9ad3a83b6aa5eb6a6d139a1f50771704d77aeb8ce76c010000006a4730440220055723d363cd2d4fe4e887270ebdf5c4b99eaf233a5c09f9404f888ec8b839350220763c3794d310b384ce86decfb05787e5bfa5d31983db612a2dde5ffec7f396ae012102ef47e27e0c4bdd6dc83915f185d972d5eb8515c34d17bad584a9312e59f4e0bcffffffff52239451d37757eeacb86d32864ec1ee6b6e131d1e3fee6f1cff512703b71014030000006c493046022100ea266ac4f893d98a623a6fc0e6a961cd5a3f32696721e87e7570a68851917e75022100a928a3c4898be60909347e765f52872a613d8aada66c57a8c8791316d2f298710121038bb455ca101ebbb0ecf7f5c01fa1dcb7d14fbf6b7d7ea52ee56f0148e72a736cffffffff0630b15a00000000001976a9146ae477b690cf85f21c2c01e2c8639a5c18dc884e88ac4f260d00000000001976a91498d08c02ab92a671590adb726dddb719695ee12e88ac65753b00000000001976a9140b2eb4ba6d364c82092f25775f56bc10cd92c8f188ac65753b00000000001976a914d1cb414e22081c6ba3a935635c0f1d837d3c5d9188ac65753b00000000001976a914df9d137a0d279471a2796291874c29759071340b88ac3d753b00000000001976a91459f5aa4815e3aa8e1720e8b82f4ac8e6e904e47d88ac00000000"));
         assertEquals("dbe4147cf89b89fd9fa6c8ce6a3e2adecb234db094ec88301ae09073ca17d61d", tx2.getTxId().toString());
         assertFalse(ECKey.ECDSASignature
diff --git a/core/src/test/java/org/bitcoinj/wallet/DeterministicKeyChainTest.java b/core/src/test/java/org/bitcoinj/wallet/DeterministicKeyChainTest.java
index 7cc17a560..73ec66818 100644
--- a/core/src/test/java/org/bitcoinj/wallet/DeterministicKeyChainTest.java
+++ b/core/src/test/java/org/bitcoinj/wallet/DeterministicKeyChainTest.java
@@ -23,7 +23,7 @@ import org.bitcoinj.core.BloomFilter;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.Utils;
 import org.bitcoinj.crypto.ChildNumber;
 import org.bitcoinj.crypto.DeterministicKey;
diff --git a/core/src/test/java/org/bitcoinj/wallet/KeyChainGroupTest.java b/core/src/test/java/org/bitcoinj/wallet/KeyChainGroupTest.java
index da88e01e3..dbe05839b 100644
--- a/core/src/test/java/org/bitcoinj/wallet/KeyChainGroupTest.java
+++ b/core/src/test/java/org/bitcoinj/wallet/KeyChainGroupTest.java
@@ -21,7 +21,7 @@ import org.bitcoinj.core.Address;
 import org.bitcoinj.core.BloomFilter;
 import org.bitcoinj.core.ECKey;
 import org.bitcoinj.core.NetworkParameters;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.Utils;
 import org.bitcoinj.crypto.DeterministicKey;
 import org.bitcoinj.crypto.KeyCrypterException;
diff --git a/core/src/test/java/org/bitcoinj/wallet/WalletTest.java b/core/src/test/java/org/bitcoinj/wallet/WalletTest.java
index b2f4fd34a..324b79a80 100644
--- a/core/src/test/java/org/bitcoinj/wallet/WalletTest.java
+++ b/core/src/test/java/org/bitcoinj/wallet/WalletTest.java
@@ -18,6 +18,7 @@
 package org.bitcoinj.wallet;
 
 import com.google.common.collect.Lists;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.AbstractBlockChain;
 import org.bitcoinj.core.Address;
 import org.bitcoinj.core.Block;
@@ -28,7 +29,7 @@ import org.bitcoinj.core.InsufficientMoneyException;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.core.PeerAddress;
 import org.bitcoinj.core.SegwitAddress;
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.StoredBlock;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionConfidence;
@@ -100,7 +101,7 @@ import static org.bitcoinj.base.Coin.MILLICOIN;
 import static org.bitcoinj.base.Coin.SATOSHI;
 import static org.bitcoinj.base.Coin.ZERO;
 import static org.bitcoinj.base.Coin.valueOf;
-import static org.bitcoinj.core.Utils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
 import static org.bitcoinj.testing.FakeTxBuilder.createFakeBlock;
 import static org.bitcoinj.testing.FakeTxBuilder.createFakeTx;
 import static org.bitcoinj.testing.FakeTxBuilder.createFakeTxWithoutChangeAddress;
@@ -3363,7 +3364,7 @@ public class WalletTest extends TestWithWallet {
 
     @Test
     public void createBasicWithKeys() {
-        ECKey key = ECKey.fromPrivate(Utils.HEX.decode("00905b93f990267f4104f316261fc10f9f983551f9ef160854f40102eb71cffdcc"));
+        ECKey key = ECKey.fromPrivate(ByteUtils.HEX.decode("00905b93f990267f4104f316261fc10f9f983551f9ef160854f40102eb71cffdcc"));
         Wallet wallet = Wallet.createBasic(UNITTEST);
         wallet.importKey(key);
         assertEquals(1, wallet.getImportedKeys().size());
diff --git a/examples/src/main/java/org/bitcoinj/examples/FetchBlock.java b/examples/src/main/java/org/bitcoinj/examples/FetchBlock.java
index 8f9924833..100a1bb80 100644
--- a/examples/src/main/java/org/bitcoinj/examples/FetchBlock.java
+++ b/examples/src/main/java/org/bitcoinj/examples/FetchBlock.java
@@ -17,6 +17,7 @@
 
 package org.bitcoinj.examples;
 
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.*;
 import org.bitcoinj.net.discovery.DnsDiscovery;
 import org.bitcoinj.params.TestNet3Params;
diff --git a/examples/src/main/java/org/bitcoinj/examples/FetchTransactions.java b/examples/src/main/java/org/bitcoinj/examples/FetchTransactions.java
index a8024cc62..34b8502cb 100644
--- a/examples/src/main/java/org/bitcoinj/examples/FetchTransactions.java
+++ b/examples/src/main/java/org/bitcoinj/examples/FetchTransactions.java
@@ -17,6 +17,7 @@
 
 package org.bitcoinj.examples;
 
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.*;
 import org.bitcoinj.params.TestNet3Params;
 import org.bitcoinj.store.BlockStore;
diff --git a/examples/src/main/java/org/bitcoinj/examples/GenerateLowSTests.java b/examples/src/main/java/org/bitcoinj/examples/GenerateLowSTests.java
index 218d31b1a..2c523e330 100644
--- a/examples/src/main/java/org/bitcoinj/examples/GenerateLowSTests.java
+++ b/examples/src/main/java/org/bitcoinj/examples/GenerateLowSTests.java
@@ -25,6 +25,7 @@ import java.util.EnumSet;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.LegacyAddress;
 import org.bitcoinj.base.Coin;
 import org.bitcoinj.core.ECKey;
@@ -33,7 +34,6 @@ import org.bitcoinj.core.SignatureDecodeException;
 import org.bitcoinj.core.Transaction;
 import org.bitcoinj.core.TransactionInput;
 import org.bitcoinj.core.TransactionOutput;
-import org.bitcoinj.core.Utils;
 import org.bitcoinj.core.VerificationException;
 import org.bitcoinj.crypto.TransactionSignature;
 import org.bitcoinj.params.MainNetParams;
@@ -167,7 +167,7 @@ public class GenerateLowSTests {
                 // Data chunk
                 buf.append("0x")
                     .append(Integer.toString(chunk.opcode, 16)).append(" 0x")
-                    .append(Utils.HEX.encode(chunk.data));
+                    .append(ByteUtils.HEX.encode(chunk.data));
             } else {
                 buf.append(chunk.toString());
             }
diff --git a/integration-test/src/test/java/org/bitcoinj/core/FilteredBlockAndPartialMerkleTreeTest.java b/integration-test/src/test/java/org/bitcoinj/core/FilteredBlockAndPartialMerkleTreeTest.java
index a1d551584..9b8c481ad 100644
--- a/integration-test/src/test/java/org/bitcoinj/core/FilteredBlockAndPartialMerkleTreeTest.java
+++ b/integration-test/src/test/java/org/bitcoinj/core/FilteredBlockAndPartialMerkleTreeTest.java
@@ -18,6 +18,8 @@
 package org.bitcoinj.core;
 
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.TransactionConfidence.ConfidenceType;
 import org.bitcoinj.store.MemoryBlockStore;
 import org.bitcoinj.testing.FakeTxBuilder;
@@ -40,8 +42,8 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 
-import static org.bitcoinj.core.Utils.HEX;
-import static org.bitcoinj.core.Utils.uint32ToByteStreamLE;
+import static org.bitcoinj.base.utils.ByteUtils.HEX;
+import static org.bitcoinj.base.utils.ByteUtils.uint32ToByteStreamLE;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -136,8 +138,8 @@ public class FilteredBlockAndPartialMerkleTreeTest extends TestWithPeerGroup {
         hashes.add(numAsHash(9));
         hashes.add(numAsHash(10));
         byte[] includeBits = new byte[2];
-        Utils.setBitLE(includeBits, 9);
-        Utils.setBitLE(includeBits, 10);
+        ByteUtils.setBitLE(includeBits, 9);
+        ByteUtils.setBitLE(includeBits, 10);
         PartialMerkleTree pmt = PartialMerkleTree.buildFromLeaves(UNITTEST, includeBits, hashes);
         List<Sha256Hash> matchedHashes = new ArrayList<>();
         pmt.getTxnHashAndMerkleRoot(matchedHashes);
diff --git a/integration-test/src/test/java/org/bitcoinj/core/PeerGroupTest.java b/integration-test/src/test/java/org/bitcoinj/core/PeerGroupTest.java
index 21db7fd41..78b134e3c 100644
--- a/integration-test/src/test/java/org/bitcoinj/core/PeerGroupTest.java
+++ b/integration-test/src/test/java/org/bitcoinj/core/PeerGroupTest.java
@@ -20,6 +20,7 @@ package org.bitcoinj.core;
 import com.google.common.base.Stopwatch;
 import com.google.common.collect.Lists;
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.listeners.DownloadProgressTracker;
 import org.bitcoinj.core.listeners.PeerConnectedEventListener;
 import org.bitcoinj.core.listeners.PeerDisconnectedEventListener;
diff --git a/integration-test/src/test/java/org/bitcoinj/core/PeerTest.java b/integration-test/src/test/java/org/bitcoinj/core/PeerTest.java
index a63f9e432..eb250e7ef 100644
--- a/integration-test/src/test/java/org/bitcoinj/core/PeerTest.java
+++ b/integration-test/src/test/java/org/bitcoinj/core/PeerTest.java
@@ -19,11 +19,11 @@ package org.bitcoinj.core;
 import com.google.common.collect.Lists;
 import com.google.common.util.concurrent.Uninterruptibles;
 import org.bitcoinj.base.Coin;
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.listeners.BlocksDownloadedEventListener;
 import org.bitcoinj.core.listeners.PreMessageReceivedEventListener;
 import org.bitcoinj.params.TestNet3Params;
 import org.bitcoinj.script.Script;
-import org.bitcoinj.testing.FakeTxBuilder;
 import org.bitcoinj.testing.InboundMessageQueuer;
 import org.bitcoinj.testing.TestWithNetworkConnections;
 import org.bitcoinj.utils.Threading;
diff --git a/tools/src/main/java/org/bitcoinj/tools/BuildCheckpoints.java b/tools/src/main/java/org/bitcoinj/tools/BuildCheckpoints.java
index 8163c6d25..009536d06 100644
--- a/tools/src/main/java/org/bitcoinj/tools/BuildCheckpoints.java
+++ b/tools/src/main/java/org/bitcoinj/tools/BuildCheckpoints.java
@@ -17,6 +17,7 @@
 
 package org.bitcoinj.tools;
 
+import org.bitcoinj.base.Sha256Hash;
 import org.bitcoinj.core.*;
 import org.bitcoinj.net.discovery.DnsDiscovery;
 import org.bitcoinj.store.BlockStore;
diff --git a/wallettool/src/main/java/org/bitcoinj/wallettool/WalletTool.java b/wallettool/src/main/java/org/bitcoinj/wallettool/WalletTool.java
index 3bcbaa0e9..dc421a55f 100644
--- a/wallettool/src/main/java/org/bitcoinj/wallettool/WalletTool.java
+++ b/wallettool/src/main/java/org/bitcoinj/wallettool/WalletTool.java
@@ -17,7 +17,8 @@
 
 package org.bitcoinj.wallettool;
 
-import org.bitcoinj.core.Sha256Hash;
+import org.bitcoinj.base.Sha256Hash;
+import org.bitcoinj.base.utils.ByteUtils;
 import org.bitcoinj.core.TransactionOutput;
 import org.bitcoinj.crypto.*;
 import org.bitcoinj.params.RegTestParams;
@@ -104,7 +105,6 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.LogManager;
-import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -569,7 +569,7 @@ public class WalletTool implements Callable<Integer> {
     }
 
     private static ByteString bytesToHex(ByteString bytes) {
-        return ByteString.copyFrom(Utils.HEX.encode(bytes.toByteArray()).getBytes());
+        return ByteString.copyFrom(ByteUtils.HEX.encode(bytes.toByteArray()).getBytes());
     }
 
     private void marry() {
@@ -1160,7 +1160,7 @@ public class WalletTool implements Callable<Integer> {
                     System.err.println("Could not understand --privkey as either WIF, hex or base58: " + privKeyStr);
                     return;
                 }
-                key = ECKey.fromPrivate(Utils.bytesToBigInteger(decode));
+                key = ECKey.fromPrivate(ByteUtils.bytesToBigInteger(decode));
             }
             if (pubKeyStr != null) {
                 // Give the user a hint.
@@ -1221,7 +1221,7 @@ public class WalletTool implements Callable<Integer> {
      */
     private byte[] parseAsHexOrBase58(String data) {
         try {
-            return Utils.HEX.decode(data);
+            return ByteUtils.HEX.decode(data);
         } catch (Exception e) {
             // Didn't decode as hex, try base58.
             try {