Sha256Hash (troncli 1.5.1 API)

java.lang.Object
- org.tron.common.crypto.Sha256Hash

All Implemented Interfaces:

Serializable, Comparable<Sha256Hash>
```
public class Sha256Hash
extends Object
implements Serializable, Comparable<Sha256Hash>
```
A Sha256Hash just wraps a byte[] so that equals and hashcode work correctly, allowing it to be used as keys in a map. It also checks that the length is correct and provides a bit more type safety.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static int LENGTH

static Sha256Hash ZERO_HASH

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

Constructor Summary

Constructors
Constructor and Description

Sha256Hash(byte[] rawHashBytes)
Deprecated.

Sha256Hash(long num, byte[] hash)

Sha256Hash(long num, Sha256Hash hash)

Constructors
Constructor and Description
`Sha256Hash(byte[] rawHashBytes)` Deprecated.
`Sha256Hash(long num, byte[] hash)`
`Sha256Hash(long num, Sha256Hash hash)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`int`	`compareTo(Sha256Hash other)`
`static Sha256Hash`	`create(byte[] contents)` Deprecated.
`static Sha256Hash`	`createDouble(byte[] contents)` Deprecated.
`boolean`	`equals(Object o)`
`long`	`getBlockNum()`
`byte[]`	`getBytes()` Returns the internal byte array, without defensively copying.
`com.google.protobuf.ByteString`	`getByteString()` For pb return ByteString.
`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[] 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`	`wrap(byte[] rawHashBytes)` Creates a new instance that wraps the given hash value.
`static Sha256Hash`	`wrap(com.google.protobuf.ByteString rawHashByteString)`

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

- Field Detail
  - LENGTH
```
public static final int LENGTH
```
    See Also:
    
    Constant Field Values
  - ZERO_HASH
```
public static final Sha256Hash ZERO_HASH
```
- Constructor Detail
  - Sha256Hash
```
public Sha256Hash(long num,
                  byte[] hash)
```
  - Sha256Hash
```
public Sha256Hash(long num,
                  Sha256Hash hash)
```
  - Sha256Hash
```
@Deprecated
public Sha256Hash(byte[] rawHashBytes)
```
    Deprecated.
    
    Use wrap(byte[]) instead.
- Method Detail
  - getBlockNum
```
public long getBlockNum()
```
  - 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(com.google.protobuf.ByteString rawHashByteString)
```
  - create
```
@Deprecated
public static Sha256Hash create(byte[] contents)
```
    Deprecated.
    
    Use of(byte[]) instead: this old name is ambiguous.
  - 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
  - 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
  - createDouble
```
@Deprecated
public static Sha256Hash createDouble(byte[] contents)
```
    Deprecated.
    
    Use twiceOf(byte[]) instead: this old name is ambiguous.
  - 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
  - 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[] 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
  - toString
```
public String toString()
```
    Overrides:
    
    toString 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
  - 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.
  - getByteString
```
public com.google.protobuf.ByteString getByteString()
```
    For pb return ByteString.
  - compareTo
```
public int compareTo(Sha256Hash other)
```
    Specified by:
    
    compareTo in interface Comparable<Sha256Hash>

Class Sha256Hash

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LENGTH

ZERO_HASH

Constructor Detail

Sha256Hash

Sha256Hash

Sha256Hash

Method Detail

getBlockNum

wrap

wrap

create

of

of

createDouble

twiceOf

newDigest

hash

hash

hashTwice

hashTwice

hashTwice

equals

toString

hashCode

toBigInteger

getBytes

getByteString

compareTo