Utils (bitcoinj 0.12 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 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 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 byte[]`	`doubleDigest(byte[] input)` See `doubleDigest(byte[], int, int)`.
`static byte[]`	`doubleDigest(byte[] input, int offset, int length)` Calculates the SHA-256 hash of the given byte range, and then hashes the resulting hash again.
`static byte[]`	`doubleDigestTwoBuffers(byte[] input1, int offset1, int length1, byte[] input2, int offset2, int length2)` Calculates SHA256(SHA256(byte range 1 + byte range 2)).
`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 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)`
`static int`	`readUint16BE(byte[] bytes, int offset)`
`static long`	`readUint32(byte[] bytes, int offset)`
`static long`	`readUint32BE(byte[] bytes, int offset)`
`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 byte[]`	`singleDigest(byte[] input, int offset, int length)`
`static void`	`sleep(long millis)` Sleep for a span of time, or mock sleep if enabled
`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
  - doubleDigest
```
public static byte[] doubleDigest(byte[] input)
```
    See doubleDigest(byte[], int, int).
  - doubleDigest
```
public static byte[] doubleDigest(byte[] input,
                                  int offset,
                                  int length)
```
    Calculates the SHA-256 hash of the given byte range, and then hashes the resulting hash again. This is standard procedure in Bitcoin. The resulting hash is in big endian form.
  - singleDigest
```
public static byte[] singleDigest(byte[] input,
                                  int offset,
                                  int length)
```
  - doubleDigestTwoBuffers
```
public static byte[] doubleDigestTwoBuffers(byte[] input1,
                                            int offset1,
                                            int length1,
                                            byte[] input2,
                                            int offset2,
                                            int length2)
```
    Calculates SHA256(SHA256(byte range 1 + byte range 2)).
  - 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)
```
  - readInt64
```
public static long readInt64(byte[] bytes,
                             int offset)
```
  - readUint32BE
```
public static long readUint32BE(byte[] bytes,
                                int offset)
```
  - readUint16BE
```
public static int readUint16BE(byte[] bytes,
                               int offset)
```
  - 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()
```
  - 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
  - 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

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

doubleDigest

doubleDigest

singleDigest

doubleDigestTwoBuffers

isLessThanUnsigned

isLessThanOrEqualToUnsigned

reverseBytes

reverseDwordBytes

readUint32

readInt64

readUint32BE

readUint16BE

sha256hash160

decodeMPI

encodeMPI

decodeCompactBits

encodeCompactBits

rollMockClock

rollMockClockMillis

setMockClock

setMockClock

now

currentTimeMillis

currentTimeSeconds

copyOf

appendByte

parseAsHexOrBase58

isWindows

formatMessageForSigning

checkBitLE

setBitLE

sleep

setMockSleep

passMockSleep

finishMockSleep

isAndroidRuntime

maxOfMostFreq

maxOfMostFreq

getResourceAsString