/// <summary> /// Uses the checksum in the last 4 bytes of the decoded data to verify the rest are correct. The checksum is removed from the returned data. /// </summary> /// <exception cref="AddressFormatException">If the input is not base 58 or the checksum does not validate.</exception> public byte[] DecodeChecked(string input) { var tmp = Decode(input); if (tmp.Length < 4) { throw new AddressFormatException("Input too short"); } var checksum = new byte[4]; Array.Copy(tmp, tmp.Length - 4, checksum, 0, 4); var bytes = new byte[tmp.Length - 4]; Array.Copy(tmp, 0, bytes, 0, tmp.Length - 4); tmp = DoubleDigestSha256Helper.DoubleDigest(bytes); var hash = new byte[4]; Array.Copy(tmp, 0, hash, 0, 4); if (!hash.SequenceEqual(checksum)) { throw new AddressFormatException("Checksum does not validate"); } return(bytes); }
/////throws ClassNotFoundException, IOException //private void readObject(ObjectInputStream ois) //{ // ois.defaultReadObject(); // // This code is not actually necessary, as transient fields are initialized to the default value which is in // // this case null. However it clears out a FindBugs warning and makes it explicit what we're doing. // hash = null; //} private void parseHeader() { if (headerParsed) { return; } Cursor = Offset; Version = ReadUint32(); PreviousBlockHash = ReadHash(); MerkleRoot = ReadHash(); TimeSeconds = ReadUint32(); difficultyTarget = ReadUint32(); nonce = ReadUint32(); hash = new Sha256Hash(DoubleDigestSha256Helper.DoubleDigest(Bytes, Offset, Cursor).ReverseBytes()); headerParsed = true; headerBytesValid = ParseRetain; }
private List <byte[]> buildMerkleTree() { // The Merkle root is based on a tree of hashes calculated from the transactions: // // root // / \ // A B // / \ / \ // t1 t2 t3 t4 // // The tree is represented as a list: t1,t2,t3,t4,A,B,root where each // entry is a hash. // // The hashing algorithm is double SHA-256. The leaves are a hash of the serialized contents of the transaction. // The interior nodes are hashes of the concenation of the two child hashes. // // This structure allows the creation of proof that a transaction was included into a block without having to // provide the full block contents. Instead, you can provide only a Merkle branch. For example to prove tx2 was // in a block you can just provide tx2, the hash(tx1) and B. Now the other party has everything they need to // derive the root, which can be checked against the block header. These proofs aren't used right now but // will be helpful later when we want to download partial block contents. // // Note that if the number of transactions is not even the last tx is repeated to make it so (see // tx3 above). A tree with 5 transactions would look like this: // // root // / \ // 1 5 // / \ / \ // 2 3 4 4 // / \ / \ / \ // t1 t2 t3 t4 t5 t5 EnsureParsedTransactions(); List <byte[]> tree = new List <byte[]>(); // Start by adding all the hashes of the transactions as leaves of the tree. foreach (Transaction transaction in Transactions) { tree.Add(transaction.Hash.Bytes); } int levelOffset = 0; // Offset in the list where the currently processed level starts. // Step through each level, stopping when we reach the root (levelSize == 1). for (int levelSize = Transactions.Count; levelSize > 1; levelSize = (levelSize + 1) / 2) { // For each pair of nodes on that level: for (int left = 0; left < levelSize; left += 2) { // The right hand node can be the same as the left hand, in the case where we don't have enough transactions. int right = Math.Min(left + 1, levelSize - 1); byte[] leftBytes = tree[levelOffset + left].ReverseBytes(); byte[] rightBytes = tree[levelOffset + right].ReverseBytes(); tree.Add(DoubleDigestSha256Helper.DoubleDigestTwoBuffers(leftBytes, 0, 32, rightBytes, 0, 32).ReverseBytes()); } // Move to the next level. levelOffset += levelSize; } return(tree); }