Package org.bitcoinj.core

Class Sha256Hash

java.lang.Object
org.bitcoinj.core.Sha256Hash
All Implemented Interfaces:
Serializable, Comparable<Sha256Hash>
public class Sha256Hash extends Object implements Serializable, Comparable<Sha256Hash>
A Sha256Hash wraps a byte[] so that equals(java.lang.Object) and hashCode() work correctly, allowing it to be used as a key in a map. It also checks that the length is correct (equal to LENGTH) and provides a bit more type safety.

Given that Sha256Hash instances can be created using wrapReversed(byte[]) or twiceOf(byte[]) or by wrapping raw bytes, there is no guarantee that if two Sha256Hash instances are found equal (via equals(Object)) that their preimages would be the same (even in the absence of a hash collision.)

See Also:

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final int
    LENGTH
     
    static final Sha256Hash
    ZERO_HASH
     

  • Method Summary

    Modifier and Type
    Method
    Description
    int
    compareTo(Sha256Hash other)
     
    boolean
    equals(Object o)
     
    byte[]
    getBytes()
    Returns the internal byte array, without defensively copying.
    byte[]
    getReversedBytes()
    Returns a reversed copy of the internal byte array.
    static byte[]
    hash(byte[] input)
    Calculates the SHA-256 hash of the given bytes.
    static byte[]
    hash(byte[] input, int offset, int length)
    Calculates the SHA-256 hash of the given byte range.
    int
    hashCode()
    Returns the last four bytes of the wrapped hash.
    static byte[]
    hashTwice(byte[] input)
    Calculates the SHA-256 hash of the given bytes, and then hashes the resulting hash again.
    static byte[]
    hashTwice(byte[] input1, byte[] input2)
    Calculates the hash of hash on the given chunks of bytes.
    static byte[]
    hashTwice(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[]
    hashTwice(byte[] input1, int offset1, int length1, byte[] input2, int offset2, int length2)
    Calculates the hash of hash on the given byte ranges.
    static MessageDigest
    newDigest()
    Returns a new SHA-256 MessageDigest instance.
    static Sha256Hash
    of(byte[] contents)
    Creates a new instance containing the calculated (one-time) hash of the given bytes.
    static Sha256Hash
    of(File file)
    Creates a new instance containing the calculated (one-time) hash of the given file's contents.
    BigInteger
    toBigInteger()
    Returns the bytes interpreted as a positive integer.
    String
    toString()
     
    static Sha256Hash
    twiceOf(byte[] contents)
    Creates a new instance containing the hash of the calculated hash of the given bytes.
    static Sha256Hash
    twiceOf(byte[] content1, byte[] content2)
    Creates a new instance containing the hash of the calculated hash of the given bytes.
    static Sha256Hash
    wrap(byte[] rawHashBytes)
    Creates a new instance that wraps the given hash value.
    static Sha256Hash
    wrap(String hexString)
    Creates a new instance that wraps the given hash value (represented as a hex string).
    static Sha256Hash
    wrapReversed(byte[] rawHashBytes)
    Creates a new instance that wraps the given hash value, but with byte order reversed.

    Methods inherited from class java.lang.Object

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

  • Field Details

  • Method Details

    • wrap

      public static Sha256Hash wrap(byte[] rawHashBytes)
      Creates a new instance that wraps the given hash value.
      Parameters:
      rawHashBytes - the raw hash bytes to wrap
      Returns:
      a new instance
      Throws:
      IllegalArgumentException - if the given array length is not exactly 32

    • wrap

      public static Sha256Hash wrap(String hexString)
      Creates a new instance that wraps the given hash value (represented as a hex string).
      Parameters:
      hexString - a hash value represented as a hex string
      Returns:
      a new instance
      Throws:
      IllegalArgumentException - if the given string is not a valid hex string, or if it does not represent exactly 32 bytes

    • wrapReversed

      public static Sha256Hash wrapReversed(byte[] rawHashBytes)
      Creates a new instance that wraps the given hash value, but with byte order reversed.
      Parameters:
      rawHashBytes - the raw hash bytes to wrap
      Returns:
      a new instance
      Throws:
      IllegalArgumentException - if the given array length is not exactly 32

    • of

      public static Sha256Hash of(byte[] contents)
      Creates a new instance containing the calculated (one-time) hash of the given bytes.
      Parameters:
      contents - the bytes on which the hash value is calculated
      Returns:
      a new instance containing the calculated (one-time) hash

    • twiceOf

      public static Sha256Hash twiceOf(byte[] contents)
      Creates a new instance containing the hash of the calculated hash of the given bytes.
      Parameters:
      contents - the bytes on which the hash value is calculated
      Returns:
      a new instance containing the calculated (two-time) hash

    • twiceOf

      public static Sha256Hash twiceOf(byte[] content1, byte[] content2)
      Creates a new instance containing the hash of the calculated hash of the given bytes.
      Parameters:
      content1 - first bytes on which the hash value is calculated
      content2 - second bytes on which the hash value is calculated
      Returns:
      a new instance containing the calculated (two-time) hash

    • of

      public static Sha256Hash of(File file) throws IOException
      Creates a new instance containing the calculated (one-time) hash of the given file's contents. The file contents are read fully into memory, so this method should only be used with small files.
      Parameters:
      file - the file on which the hash value is calculated
      Returns:
      a new instance containing the calculated (one-time) hash
      Throws:
      IOException - if an error occurs while reading the file

    • newDigest

      public static MessageDigest newDigest()
      Returns a new SHA-256 MessageDigest instance. This is a convenience method which wraps the checked exception that can never occur with a RuntimeException.
      Returns:
      a new SHA-256 MessageDigest instance

    • hash

      public static byte[] hash(byte[] input)
      Calculates the SHA-256 hash of the given bytes.
      Parameters:
      input - the bytes to hash
      Returns:
      the hash (in big-endian order)

    • hash

      public static byte[] hash(byte[] input, int offset, int length)
      Calculates the SHA-256 hash of the given byte range.
      Parameters:
      input - the array containing the bytes to hash
      offset - the offset within the array of the bytes to hash
      length - the number of bytes to hash
      Returns:
      the hash (in big-endian order)

    • hashTwice

      public static byte[] hashTwice(byte[] input)
      Calculates the SHA-256 hash of the given bytes, and then hashes the resulting hash again.
      Parameters:
      input - the bytes to hash
      Returns:
      the double-hash (in big-endian order)

    • hashTwice

      public static byte[] hashTwice(byte[] input1, byte[] input2)
      Calculates the hash of hash on the given chunks of bytes. This is equivalent to concatenating the two chunks and then passing the result to hashTwice(byte[]).

    • hashTwice

      public static byte[] hashTwice(byte[] input, int offset, int length)
      Calculates the SHA-256 hash of the given byte range, and then hashes the resulting hash again.
      Parameters:
      input - the array containing the bytes to hash
      offset - the offset within the array of the bytes to hash
      length - the number of bytes to hash
      Returns:
      the double-hash (in big-endian order)

    • hashTwice

      public static byte[] hashTwice(byte[] input1, int offset1, int length1, byte[] input2, int offset2, int length2)
      Calculates the hash of hash on the given byte ranges. This is equivalent to concatenating the two ranges and then passing the result to hashTwice(byte[]).

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Returns the last four bytes of the wrapped hash. This should be unique enough to be a suitable hash code even for blocks, where the goal is to try and get the first bytes to be zeros (i.e. the value as a big integer lower than the target value).
      Overrides:
      hashCode in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • toBigInteger

      public BigInteger toBigInteger()
      Returns the bytes interpreted as a positive integer.

    • getBytes

      public byte[] getBytes()
      Returns the internal byte array, without defensively copying. Therefore do NOT modify the returned array.

    • getReversedBytes

      public byte[] getReversedBytes()
      Returns a reversed copy of the internal byte array.

    • compareTo

      public int compareTo(Sha256Hash other)
      Specified by:
      compareTo in interface Comparable<Sha256Hash>