Utils (bitcoinj 0.14 API)

java.lang.Object
- org.bitcoinj.core.Utils

```
public class Utils
extends Object
```
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.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`BITCOIN_SIGNED_MESSAGE_HEADER` The string that prefixes all text messages signed using Bitcoin keys.
`static byte[]`	`BITCOIN_SIGNED_MESSAGE_HEADER_BYTES`
`static BaseEncoding`	`HEX` Hex encoding used throughout the framework.
`static Date`	`mockTime` If non-null, overrides the return value of now().

Constructor Summary

Constructors
Constructor and Description

Utils()

Constructors
Constructor and Description
`Utils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static byte[]`	`appendByte(byte[] bytes, byte b)` Creates a copy of bytes and appends b to the end of it
`static byte[]`	`bigIntegerToBytes(BigInteger b, int numBytes)` The regular `BigInteger.toByteArray()` method isn't quite what we often need: it appends a leading zero to indicate that the number is positive and may need padding.
`static boolean`	`checkBitLE(byte[] data, int index)` Checks if the given bit is set in data, using little endian (not the same as Java native big endian)
`static InputStream`	`closeUnchecked(InputStream stream)`
`static OutputStream`	`closeUnchecked(OutputStream stream)`
`static byte[]`	`copyOf(byte[] in, int length)`
`static long`	`currentTimeMillis()` Returns the current time in milliseconds since the epoch, or a mocked out equivalent.
`static long`	`currentTimeSeconds()`
`static String`	`dateTimeFormat(Date dateTime)` Formats a given date+time value to an ISO 8601 string.
`static String`	`dateTimeFormat(long dateTime)` Formats a given date+time value to an ISO 8601 string.
`static BigInteger`	`decodeCompactBits(long compact)` The "compact" format is a representation of a whole number N using an unsigned 32 bit number similar to a floating point format.
`static BigInteger`	`decodeMPI(byte[] mpi, boolean hasLength)` MPI encoded numbers are produced by the OpenSSL BN_bn2mpi function.
`static long`	`encodeCompactBits(BigInteger value)`
`static byte[]`	`encodeMPI(BigInteger value, boolean includeLength)` MPI encoded numbers are produced by the OpenSSL BN_bn2mpi function.
`static void`	`finishMockSleep()` Let the sleeping thread pass the synchronization point any number of times.
`static byte[]`	`formatMessageForSigning(String message)` Given a textual message, returns a byte buffer formatted as follows:
`static String`	`getResourceAsString(URL url)` Reads and joins together with LF char (\n) all the lines from given file.
`static void`	`int64ToByteStreamLE(long val, OutputStream stream)`
`static boolean`	`isAndroidRuntime()`
`static boolean`	`isLessThanOrEqualToUnsigned(long n1, long n2)` Work around lack of unsigned types in Java.
`static boolean`	`isLessThanUnsigned(long n1, long n2)` Work around lack of unsigned types in Java.
`static boolean`	`isWindows()`
`static <T> String`	`join(Iterable<T> items)` Returns a string containing the string representation of the given items, delimited by a single space character.
`static int`	`maxOfMostFreq(int... items)`
`static int`	`maxOfMostFreq(List<Integer> items)`
`static Date`	`now()` Returns the current time, or a mocked out equivalent.
`static byte[]`	`parseAsHexOrBase58(String data)` Attempts to parse the given string as arbitrary-length hex or base58 and then return the results, or null if neither parse was successful.
`static void`	`passMockSleep()` Let sleeping thread pass the synchronization point.
`static long`	`readInt64(byte[] bytes, int offset)` Parse 8 bytes from the byte array (starting at the offset) as signed 64-bit integer in little endian format.
`static int`	`readUint16BE(byte[] bytes, int offset)` Parse 2 bytes from the byte array (starting at the offset) as unsigned 16-bit integer in big endian format.
`static long`	`readUint32(byte[] bytes, int offset)` Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in little endian format.
`static long`	`readUint32BE(byte[] bytes, int offset)` Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in big endian format.
`static byte[]`	`reverseBytes(byte[] bytes)` Returns a copy of the given byte array in reverse order.
`static byte[]`	`reverseDwordBytes(byte[] bytes, int trimLength)` Returns a copy of the given byte array with the bytes of each double-word (4 bytes) reversed.
`static Date`	`rollMockClock(int seconds)` Advances (or rewinds) the mock clock by the given number of seconds.
`static Date`	`rollMockClockMillis(long millis)` Advances (or rewinds) the mock clock by the given number of milliseconds.
`static void`	`setBitLE(byte[] data, int index)` Sets the given bit in data to one, using little endian (not the same as Java native big endian)
`static void`	`setMockClock()` Sets the mock clock to the current time.
`static void`	`setMockClock(long mockClockSeconds)` Sets the mock clock to the given time (in seconds).
`static void`	`setMockSleep(boolean isEnable)` Enable or disable mock sleep.
`static byte[]`	`sha256hash160(byte[] input)` Calculates RIPEMD160(SHA256(input)).
`static void`	`sleep(long millis)` Sleep for a span of time, or mock sleep if enabled
`static byte[]`	`toBytes(CharSequence str, String charsetName)` Encodes the given string into a sequence of bytes using the named charset.
`static String`	`toString(byte[] bytes, String charsetName)` Constructs a new String by decoding the given bytes using the specified charset.
`static void`	`uint32ToByteArrayBE(long val, byte[] out, int offset)`
`static void`	`uint32ToByteArrayLE(long val, byte[] out, int offset)`
`static void`	`uint32ToByteStreamLE(long val, OutputStream stream)`
`static void`	`uint64ToByteArrayLE(long val, byte[] out, int offset)`
`static void`	`uint64ToByteStreamLE(BigInteger val, OutputStream stream)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - BITCOIN_SIGNED_MESSAGE_HEADER
```
public static final String BITCOIN_SIGNED_MESSAGE_HEADER
```
    The string that prefixes all text messages signed using Bitcoin keys.
    
    See Also:
    
    Constant Field Values
  - BITCOIN_SIGNED_MESSAGE_HEADER_BYTES
```
public static final byte[] BITCOIN_SIGNED_MESSAGE_HEADER_BYTES
```
  - HEX
```
public static final BaseEncoding HEX
```
    Hex encoding used throughout the framework. Use with HEX.encode(byte[]) or HEX.decode(CharSequence).
  - mockTime
```
public static volatile Date mockTime
```
    If non-null, overrides the return value of now().
- Constructor Detail
  - Utils
```
public Utils()
```
- Method Detail
  - bigIntegerToBytes
```
public static byte[] bigIntegerToBytes(BigInteger b,
                                       int numBytes)
```
    The regular BigInteger.toByteArray() method isn't quite what we often need: it appends a leading zero to indicate that the number is positive and may need padding.
    
    Parameters:
    
    b - the integer to format into a byte array
    
    numBytes - the desired size of the resulting byte array
    
    Returns:
    
    numBytes byte long array.
  - uint32ToByteArrayBE
```
public static void uint32ToByteArrayBE(long val,
                                       byte[] out,
                                       int offset)
```
  - uint32ToByteArrayLE
```
public static void uint32ToByteArrayLE(long val,
                                       byte[] out,
                                       int offset)
```
  - uint64ToByteArrayLE
```
public static void uint64ToByteArrayLE(long val,
                                       byte[] out,
                                       int offset)
```
  - uint32ToByteStreamLE
```
public static void uint32ToByteStreamLE(long val,
                                        OutputStream stream)
                                 throws IOException
```
    Throws:
    
    IOException
  - int64ToByteStreamLE
```
public static void int64ToByteStreamLE(long val,
                                       OutputStream stream)
                                throws IOException
```
    Throws:
    
    IOException
  - uint64ToByteStreamLE
```
public static void uint64ToByteStreamLE(BigInteger val,
                                        OutputStream stream)
                                 throws IOException
```
    Throws:
    
    IOException
  - isLessThanUnsigned
```
public static boolean isLessThanUnsigned(long n1,
                                         long n2)
```
    Work around lack of unsigned types in Java.
  - isLessThanOrEqualToUnsigned
```
public static boolean isLessThanOrEqualToUnsigned(long n1,
                                                  long n2)
```
    Work around lack of unsigned types in Java.
  - reverseBytes
```
public static byte[] reverseBytes(byte[] bytes)
```
    Returns a copy of the given byte array in reverse order.
  - reverseDwordBytes
```
public static byte[] reverseDwordBytes(byte[] bytes,
                                       int trimLength)
```
    Returns a copy of the given byte array with the bytes of each double-word (4 bytes) reversed.
    
    Parameters:
    
    bytes - length must be divisible by 4.
    
    trimLength - trim output to this length. If positive, must be divisible by 4.
  - readUint32
```
public static long readUint32(byte[] bytes,
                              int offset)
```
    Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in little endian format.
  - readInt64
```
public static long readInt64(byte[] bytes,
                             int offset)
```
    Parse 8 bytes from the byte array (starting at the offset) as signed 64-bit integer in little endian format.
  - readUint32BE
```
public static long readUint32BE(byte[] bytes,
                                int offset)
```
    Parse 4 bytes from the byte array (starting at the offset) as unsigned 32-bit integer in big endian format.
  - readUint16BE
```
public static int readUint16BE(byte[] bytes,
                               int offset)
```
    Parse 2 bytes from the byte array (starting at the offset) as unsigned 16-bit integer in big endian format.
  - sha256hash160
```
public static byte[] sha256hash160(byte[] input)
```
    Calculates RIPEMD160(SHA256(input)). This is used in Address calculations.
  - decodeMPI
```
public static BigInteger decodeMPI(byte[] mpi,
                                   boolean hasLength)
```
    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).
    
    Parameters:
    
    hasLength - can be set to false if the given array is missing the 4 byte length field
  - encodeMPI
```
public static byte[] encodeMPI(BigInteger value,
                               boolean includeLength)
```
    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).
    
    Parameters:
    
    includeLength - indicates whether the 4 byte length field should be included
  - decodeCompactBits
```
public static BigInteger decodeCompactBits(long compact)
```
    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).
    
    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.
    
    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.
  - encodeCompactBits
```
public static long encodeCompactBits(BigInteger value)
```
    See Also:
    
    decodeCompactBits(long)
  - rollMockClock
```
public static Date rollMockClock(int seconds)
```
    Advances (or rewinds) the mock clock by the given number of seconds.
  - rollMockClockMillis
```
public static Date rollMockClockMillis(long millis)
```
    Advances (or rewinds) the mock clock by the given number of milliseconds.
  - setMockClock
```
public static void setMockClock()
```
    Sets the mock clock to the current time.
  - setMockClock
```
public static void setMockClock(long mockClockSeconds)
```
    Sets the mock clock to the given time (in seconds).
  - now
```
public static Date now()
```
    Returns the current time, or a mocked out equivalent.
  - currentTimeMillis
```
public static long currentTimeMillis()
```
    Returns the current time in milliseconds since the epoch, or a mocked out equivalent.
  - currentTimeSeconds
```
public static long currentTimeSeconds()
```
  - dateTimeFormat
```
public static String dateTimeFormat(Date dateTime)
```
    Formats a given date+time value to an ISO 8601 string.
    
    Parameters:
    
    dateTime - value to format, as a Date
  - dateTimeFormat
```
public static String dateTimeFormat(long dateTime)
```
    Formats a given date+time value to an ISO 8601 string.
    
    Parameters:
    
    dateTime - value to format, unix time (ms)
  - join
```
public static <T> String join(Iterable<T> items)
```
    Returns a string containing the string representation of the given items, delimited by a single space character.
    
    Type Parameters:
    
    T - the item type
    
    Parameters:
    
    items - the items to join
    
    Returns:
    
    the joined space-delimited string
  - copyOf
```
public static byte[] copyOf(byte[] in,
                            int length)
```
  - appendByte
```
public static byte[] appendByte(byte[] bytes,
                                byte b)
```
    Creates a copy of bytes and appends b to the end of it
  - toString
```
public static String toString(byte[] bytes,
                              String charsetName)
```
    Constructs a new String by decoding the given bytes using the specified charset.
    This is a convenience method which wraps the checked exception with a RuntimeException. The exception can never occur given the charsets US-ASCII, ISO-8859-1, UTF-8, UTF-16, UTF-16LE or UTF-16BE.
    
    Parameters:
    
    bytes - the bytes to be decoded into characters
    
    charsetName - the name of a supported charset
    
    Returns:
    
    the decoded String
  - toBytes
```
public static byte[] toBytes(CharSequence str,
                             String charsetName)
```
    Encodes the given string into a sequence of bytes using the named charset.
    This is a convenience method which wraps the checked exception with a RuntimeException. The exception can never occur given the charsets US-ASCII, ISO-8859-1, UTF-8, UTF-16, UTF-16LE or UTF-16BE.
    
    Parameters:
    
    str - the string to encode into bytes
    
    charsetName - the name of a supported charset
    
    Returns:
    
    the encoded bytes
  - parseAsHexOrBase58
```
public static byte[] parseAsHexOrBase58(String data)
```
    Attempts to parse the given string as arbitrary-length hex or base58 and then return the results, or null if neither parse was successful.
  - isWindows
```
public static boolean isWindows()
```
  - formatMessageForSigning
```
public static byte[] formatMessageForSigning(String message)
```
    Given a textual message, returns a byte buffer formatted as follows:
    [24] "Bitcoin Signed Message:\n" [message.length as a varint] message
  - checkBitLE
```
public static boolean checkBitLE(byte[] data,
                                 int index)
```
    Checks if the given bit is set in data, using little endian (not the same as Java native big endian)
  - setBitLE
```
public static void setBitLE(byte[] data,
                            int index)
```
    Sets the given bit in data to one, using little endian (not the same as Java native big endian)
  - sleep
```
public static void sleep(long millis)
```
    Sleep for a span of time, or mock sleep if enabled
  - setMockSleep
```
public static void setMockSleep(boolean isEnable)
```
    Enable or disable mock sleep. If enabled, set mock time to current time.
  - passMockSleep
```
public static void passMockSleep()
```
    Let sleeping thread pass the synchronization point.
  - finishMockSleep
```
public static void finishMockSleep()
```
    Let the sleeping thread pass the synchronization point any number of times.
  - isAndroidRuntime
```
public static boolean isAndroidRuntime()
```
  - maxOfMostFreq
```
public static int maxOfMostFreq(int... items)
```
  - maxOfMostFreq
```
public static int maxOfMostFreq(List<Integer> items)
```
  - getResourceAsString
```
public static String getResourceAsString(URL url)
                                  throws IOException
```
    Reads and joins together with LF char (\n) all the lines from given file. It's assumed that file is in UTF-8.
    
    Throws:
    
    IOException
  - closeUnchecked
```
public static InputStream closeUnchecked(InputStream stream)
```
  - closeUnchecked
```
public static OutputStream closeUnchecked(OutputStream stream)
```

Class Utils

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BITCOIN_SIGNED_MESSAGE_HEADER

BITCOIN_SIGNED_MESSAGE_HEADER_BYTES

HEX

mockTime

Constructor Detail

Utils

Method Detail

bigIntegerToBytes

uint32ToByteArrayBE

uint32ToByteArrayLE

uint64ToByteArrayLE

uint32ToByteStreamLE

int64ToByteStreamLE

uint64ToByteStreamLE

isLessThanUnsigned

isLessThanOrEqualToUnsigned

reverseBytes

reverseDwordBytes

readUint32

readInt64

readUint32BE

readUint16BE

sha256hash160

decodeMPI

encodeMPI

decodeCompactBits

encodeCompactBits

rollMockClock

rollMockClockMillis

setMockClock

setMockClock

now

currentTimeMillis

currentTimeSeconds

dateTimeFormat

dateTimeFormat

join

copyOf

appendByte

toString

toBytes

parseAsHexOrBase58

isWindows

formatMessageForSigning

checkBitLE

setBitLE

sleep

setMockSleep

passMockSleep

finishMockSleep

isAndroidRuntime

maxOfMostFreq

maxOfMostFreq

getResourceAsString

closeUnchecked

closeUnchecked