I am attempting to write a very simple merkle-tree implementation in Java.
I am using the values of the txids in block 170 on the bitcoin blockchain for reference, so I can see what the correct result should be.
The txids corresponding with that block are as follows:
b1fea52486ce0c62bb442b530a3f0132b826c74e473d1f2c220bfa78111c5082
f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16
It is my understanding that bitcoin's merkle-tree implementation works the following way:
- split the transactions in the block up into pairs
- byte-swap the txids
- concatenate the txids
- double hash the concatenated pairs
With a caveat being:
If there's no additional pairs of txids, concatenate the result of the first pair after double hashing with itself and repeat
My code is within a switch statement which looks like this:
case "test merkle root": {
// txid A
String A = "b1fea52486ce0c62bb442b530a3f0132b826c74e473d1f2c220bfa78111c5082";
// txid A byte-swapped
String A_little = MainChain.swapEndianness(A);
// txid B
String B = "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16";
// txid B byte-swapped
String B_little = MainChain.swapEndianness(B);
// txid A + B concatenated
String AB_little = A_little + B_little;
// double hash of byte-swapped concatenated A+B
String ABdoubleHash = SHA256.generateSHA256Hash(SHA256.generateSHA256Hash(AB_little));
// double hash concatenated with itself
String ABAB_little = ABdoubleHash + ABdoubleHash;
// double hash of self-concatenated double-hashed txid
String merkleRootLittleEndian = SHA256.generateSHA256Hash(SHA256.generateSHA256Hash(ABAB_little));
// print result byte-swapped back to big-endian
System.out.println("Merkle root: " + MainChain.swapEndianness(merkleRootLittleEndian));
}
The swapEndianness method I wrote is not a true 'byte level' swap, and instead just changes the order of the String, it looks like this:
public static String swapEndianness(String hash) {
char[] hashAsCharArray = hash.toCharArray();
StringBuilder sb = new StringBuilder();
for (int i = hash.length() - 1; i > 0; i-=2) {
sb.append(hashAsCharArray[i - 1]);
sb.append(hashAsCharArray[i]);
}
return sb.toString();
}
The expected result for the merkle root of these two txid's is:
7dac2c5666815c17a3b36427de37bb9d2e2c5ccec3f8633eb91a4205cb4c10ff
However, the result I end up with is:
3b40cab1157838cc41b08e27641f65d245957ab07b3504d94bc2d355abaed06c
Am I not getting the result I am expecting because I am cheating when I do the byte-swap, because I am missing a step, or because I have an error in my code (or some combination of these)? Any help would be appreciated!
You're not understanding what a byte[] is in Java. The strings in your example are "hex" representations of a byte[]. See How do I initialize a byte array in Java?
public class MerkleTree {
static MessageDigest digest;
public static void main(String[] args) throws NoSuchAlgorithmException {
digest = MessageDigest.getInstance("SHA-256");
new MerkleTree().run();
}
private void run() {
// txid A
byte[] A = hexStringToByteArray("b1fea52486ce0c62bb442b530a3f0132b826c74e473d1f2c220bfa78111c5082");
System.out.println(Arrays.toString(A));
// txid A byte-swapped
byte[] A_little = swapEndianness(A);
System.out.println(Arrays.toString(A_little));
// txid B
byte[] B = hexStringToByteArray("f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16");
System.out.println(Arrays.toString(B));
// txid B byte-swapped
byte[] B_little = swapEndianness(B);
System.out.println(Arrays.toString(B_little));
// txid A + B concatenated
byte[] AB_little = Arrays.copyOf(A_little, A_little.length + B_little.length);
System.arraycopy(B_little, 0, AB_little, A_little.length, B_little.length);
System.out.println(Arrays.toString(AB_little));
// double hash of byte-swapped concatenated A+B
byte[] ABdoubleHash = SHA256(SHA256(AB_little));
System.out.println(Arrays.toString(ABdoubleHash));
// print result byte-swapped back to big-endian
byte[] result = swapEndianness(ABdoubleHash);
System.out.println(Arrays.toString(result));
System.out.println(getHex(result));
}
byte[] swapEndianness(byte[] hash) {
byte[] result = new byte[hash.length];
for (int i = 0; i < hash.length; i++) {
result[i] = hash[hash.length-i-1];
}
return result;
}
byte[] SHA256(byte[] obytes) {
return digest.digest(obytes);
}
byte[] hexStringToByteArray(String s) {
int len = s.length();
byte[] data = new byte[len / 2];
for (int i = 0; i < len; i += 2) {
data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
+ Character.digit(s.charAt(i+1), 16));
}
return data;
}
private static final String HEXES = "0123456789abcdef";
String getHex(byte[] raw) {
final StringBuilder hex = new StringBuilder(2 * raw.length);
for (final byte b : raw) {
hex.append(HEXES.charAt((b & 0xF0) >> 4)).append(HEXES.charAt((b & 0x0F)));
}
return hex.toString();
}
}
Finally, refer to Java code To convert byte to Hexadecimal
EDIT: This would be a little better on the resources since you often want to do this sort of thing a lot.
// txid A byte-swapped
byte[] A = swapEndianness(
hexStringToByteArray("b1fea52486ce0c62bb442b530a3f0132b826c74e473d1f2c220bfa78111c5082")
);
// txid B byte-swapped
byte[] B = swapEndianness(
hexStringToByteArray("f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16")
);
// txid A + B concatenated
byte[] AB = Arrays.copyOf(A, A.length + B.length);
System.arraycopy(B, 0, AB, A.length, B.length);
// print result byte-swapped back to big-endian
String result = getHex(swapEndianness(SHA256(SHA256(AB))));
System.out.println(result);
}
byte[] swapEndianness(byte[] hash) {
for (int i = 0; i < hash.length/2; i++) {
byte t = hash[hash.length-i-1];
hash[hash.length-i-1] = hash[i];
hash[i] = t;
}
return hash;
}