Package org.bitcoinj.base

Class Sha256Hash

java.lang.Object
org.bitcoinj.base.Sha256Hash
All Implemented Interfaces:
Comparable<Sha256Hash>
public class Sha256Hash extends Object implements 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.)

  • 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()
    Deprecated.
    use serialize()
    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.
    static Sha256Hash
    read(ByteBuffer buf)
    Create a new instance by reading from the given buffer.
    byte[]
    serialize()
    Allocates a byte array and writes the hash into it, in reversed order.
    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.
    ByteBuffer
    write(ByteBuffer buf)
    Write hash into the given buffer.

    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

    • read

      public static Sha256Hash read(ByteBuffer buf) throws BufferUnderflowException
      Create a new instance by reading from the given buffer.
      Parameters:
      buf - buffer to read from
      Returns:
      a new instance
      Throws:
      BufferUnderflowException - if the read hash extends beyond the remaining bytes of the buffer

    • 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.

    • serialize

      public byte[] serialize()
      Allocates a byte array and writes the hash into it, in reversed order.
      Returns:
      byte array containing the hash

    • getReversedBytes

      @Deprecated public byte[] getReversedBytes()
      Deprecated.
      use serialize()

    • write

      public ByteBuffer write(ByteBuffer buf) throws BufferOverflowException
      Write hash into the given buffer.
      Parameters:
      buf - buffer to write into
      Returns:
      the buffer
      Throws:
      BufferOverflowException - if the hash doesn't fit the remaining buffer

    • compareTo

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