hash

Documentation

Overview

Package hash contains wrappers for Neo hashing algorithms.

It also implements Merkle tree.

Index

• func CalcMerkleRoot(hashes []util.Uint256) util.Uint256
• func Checksum(data []byte) []byte
• func DoubleSha256(data []byte) util.Uint256
• func Hash160(data []byte) util.Uint160
• func NetSha256(net uint32, hh Hashable) util.Uint256
• func RipeMD160(data []byte) util.Uint160
• func Sha256(data []byte) util.Uint256
• type Hashable
• type MerkleTree
  • func NewMerkleTree(hashes []util.Uint256) (*MerkleTree, error)
  • func (t *MerkleTree) Root() util.Uint256
• type MerkleTreeNode
  • func (n *MerkleTreeNode) IsLeaf() bool
  • func (n *MerkleTreeNode) IsRoot() bool

Functions

func CalcMerkleRoot

func CalcMerkleRoot(hashes []util.Uint256) util.Uint256

CalcMerkleRoot calculcates Merkle root hash value for a given slice of hashes. It doesn't create a full MerkleTree structure and it uses given slice as a scratchpad, so it will destroy its contents in the process. But it's much more memory efficient if you only need root hash value, while NewMerkleTree would make 3*N allocations for N hashes, this function will only make 4. It also is an error to call this function for zero-length hashes slice, the function will panic.

func Checksum

func Checksum(data []byte) []byte

Checksum returns the checksum for a given piece of data using sha256 twice as the hash algorithm.

func DoubleSha256

func DoubleSha256(data []byte) util.Uint256

DoubleSha256 performs sha256 twice on the given data.

func Hash160

func Hash160(data []byte) util.Uint160

Hash160 performs sha256 and then ripemd160 on the given data.

func NetSha256

func NetSha256(net uint32, hh Hashable) util.Uint256

NetSha256 calculates network-specific hash of Hashable item that can then be signed/verified.

func RipeMD160

func RipeMD160(data []byte) util.Uint160

RipeMD160 performs the RIPEMD160 hash algorithm on the given data.

func Sha256

func Sha256(data []byte) util.Uint256

Sha256 hashes the incoming byte slice using the sha256 algorithm.

Types

type Hashable

type Hashable interface {
	Hash() util.Uint256
}

Hashable represents an object which can be hashed. Usually these objects are io.Serializable and signable. They tend to cache the hash inside for effectiveness, providing this accessor method. Anything that can be identified with a hash can then be signed and verified.

type MerkleTree

type MerkleTree struct {
	// contains filtered or unexported fields
}

MerkleTree implementation.

func NewMerkleTree

func NewMerkleTree(hashes []util.Uint256) (*MerkleTree, error)

NewMerkleTree returns new MerkleTree object.

func (*MerkleTree) Root

func (t *MerkleTree) Root() util.Uint256

Root returns the computed root hash of the MerkleTree.

type MerkleTreeNode

type MerkleTreeNode struct {
	// contains filtered or unexported fields
}

MerkleTreeNode represents a node in the MerkleTree.

func (*MerkleTreeNode) IsLeaf

func (n *MerkleTreeNode) IsLeaf() bool

IsLeaf returns whether this node is a leaf node or not.

func (*MerkleTreeNode) IsRoot

func (n *MerkleTreeNode) IsRoot() bool

IsRoot returns whether this node is a root node or not.