• Home
• com.weavechain
• api
• 1.1
• source code
• MerkleTree.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.weavechain.core.data.MerkleTree Maven / Gradle / Ivy

package com.weavechain.core.data;

import com.weavechain.core.encoding.Utils;
import com.weavechain.core.encrypt.Hash;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.bitcoinj.base.Base58;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;

@AllArgsConstructor
public class MerkleTree implements HashTree {

    //TODO: maybe add order randomization and leaf splitting (most likely should be app specific)

    static final Logger logger = LoggerFactory.getLogger(MerkleTree.class);

    private static final String DEFAULT_HASH = Hash.SHA256;

    private static final byte[] NULL_HASH = new byte[0];

    private final List> hashes = new ArrayList<>();

    private final List> sums = new ArrayList<>();

    private boolean hasRawData;

    @Getter
    private String rootHash;

    private String digest = null;

    private static boolean hashTwice = false;

    private static final Map> messageDigest = Utils.newConcurrentHashMap();

    public static String hash(String data, String digest) {
        return Base58.encode(hash(data.getBytes(StandardCharsets.UTF_8), digest));
    }

    public static String digestMapping(String digest) {
        return digest != null ? digest : DEFAULT_HASH;
    }

    @Override
    public Object put(Object key, Object value) {
        throw new IllegalArgumentException("Not implemented");
    }

    public static byte[] hash(byte[] data, String digest) {
        MessageDigest md = messageDigest.computeIfAbsent(digestMapping(digest), (d) -> ThreadLocal.withInitial(() -> {
            try {
                return MessageDigest.getInstance(d);
            } catch (NoSuchAlgorithmException e) {
                logger.error("Failed message digest initialization", e);
                return null;
            }
        })).get();

        if (hashTwice) {
            data = hash(data, md);
        }

        return hash(data, md);
    }

    private static byte[] hash(byte[] data, MessageDigest md) {
        if (md != null) {
            md.reset();
            md.update(data);
            return md.digest();
        } else {
            return null;
        }
    }

    public static byte[] hash2(byte[] data1, byte[] data2, String digest) {
        byte[] data = new byte[data1.length + data2.length];
        System.arraycopy(data1, 0, data, 0, data1.length);
        System.arraycopy(data2, 0, data, data1.length, data2.length);
        return hash(data, digest);
    }

    public static byte[] hash2sum(byte[] data1, byte[] data2, BigDecimal v1, BigDecimal v2, String digest) {
        byte[] h1 = mergeBytes(data1, v1);
        byte[] h2 = mergeBytes(data2, v2);

        byte[] data = new byte[h1.length + h2.length];
        System.arraycopy(h1, 0, data, 0, h1.length);
        System.arraycopy(h2, 0, data, h1.length, h2.length);
        return hash(data, digest);
    }

    private static byte[] mergeBytes(byte[] data, BigDecimal v) {
        byte[] vbytes = v.unscaledValue().toByteArray();
        byte[] result = new byte[data.length + vbytes.length];
        System.arraycopy(data, 0, result, 0, data.length);
        System.arraycopy(vbytes, 0, result, data.length, vbytes.length);
        return result;
    }

    public static String hash2(String hash1, String hash2, String digest) {
        byte[] left = Base58.decode(hash1);
        byte[] right = Base58.decode(hash2);
        return Base58.encode(hash2(left, right, digest));
    }

    public static String hash2(String hashes, String digest) {
        String[] h = hashes.split(",");
        if (h.length == 2) {
            byte[] left = Base58.decode(h[0]);
            byte[] right = Base58.decode(h[1]);
            return Base58.encode(hash2(left, right, digest));
        } else {
            return null;
        }
    }

    public static MerkleTree createTree(String hashes, String digest) {
        MerkleTree result = new MerkleTree(false, null, digest);
        String[] data = hashes.split(";");

        for (String item : data) {
            String[] row = item.split(",");
            result.hashes.add(List.of(row));

            if (row.length == 1) {
                result.rootHash = row[0];
            }
        }

        return result;
    }

    public static MerkleTree createTree(byte[] dataHashes, String digest) throws IOException {
        MerkleTree result = new MerkleTree(false, null, null);
        ByteArrayInputStream input = new ByteArrayInputStream(dataHashes);

        int len = Hash.getHashLength(digest);
        List