Bitcoin Forum

0000000150c549978a44e3ef671a4ed3f5b922195ebde0fbbccfdb5900e6827000000000c8a03dfb42fa04d47e9fbfd3e6afcb3d0df2b516eb86f4e64d09fe53cc397b6c4de61f4c1c069652a228e13d000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000

000000000055825d01acc3dcc80d02671c2e75ab5b692940446e9b8615ea3824

irb(main):038:0> str
=> "0000000150c549978a44e3ef671a4ed3f5b922195ebde0fbbccfdb5900e6827000000000c8a03dfb42fa04d47e9fbfd3e6afcb3d0df2b516eb86f4e64d09fe53cc397b6c4de61f4c1c069652a228e13d000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000"

irb(main):039:0> stripped = str[0,160]
=> "0000000150c549978a44e3ef671a4ed3f5b922195ebde0fbbccfdb5900e6827000000000c8a03dfb42fa04d47e9fbfd3e6afcb3d0df2b516eb86f4e64d09fe53cc397b6c4de61f4c1c069652a228e13d"
irb(main):040:0> stripped.length
=> 160

irb(main):042:0> binary_data = stripped.to_a.pack("H*")
=> "\000\000\000\001P▒I\227\212D▒▒g\032N▒▒\271\"\031^\275▒▒▒▒Y\000▒p\000\000\000\000Ƞ=▒B▒▒~\237\277▒▒\257▒=\r▒▒\206▒▒M  \376S▒9{lM▒L\034\006\226R\242(\341="

irb(main):043:0> first_pass = (Digest::SHA2.new << binary_data).digest
=> "\025\\2\245▒ҏ\260\211\016D/▒ 0TM$T\aç=▒X\"\251▒▒+\001\276"

irb(main):044:0> second_pass = (Digest::SHA2.new << first_pass).digest
=> "\276▒*{▒`h▒▒S▒4\230\254h\004n▒▒G\234;^\a\207M;5\016\250t"

irb(main):045:0> second_pass.unpack("H*")
=> ["bef9bc2a7b896068f9c253f23498ac68046ec9f5479c3b5e07874d3b350ea874"]

b = BlockHeader.new(solution)
b.block_hash
=> "000000afbcd21..."

irb(main):005:0> bh = BlockHeader.new('0000000150c549978a44e3ef671a4ed3f5b922195ebde0fbbccfdb5900e6827000000000c8a03dfb42fa04d47e9fbfd3e6afcb3d0df2b516eb86f4e64d09fe53cc397b6c4de61f4c1c069652a228e13d000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000')
=> #<BlockHeader:0x7f5395de54a0 @raw="0000000150c549978a44e3ef671a4ed3f5b922195ebde0fbbccfdb5900e6827000000000c8a03dfb42fa04d47e9fbfd3e6afcb3d0df2b516eb86f4e64d09fe53cc397b6c4de61f4c1c069652a228e13d">           
irb(main):008:0> bh.hash
=> "000000000055825d01acc3dcc80d02671c2e75ab5b692940446e9b8615ea3824"
irb(main):009:0> bh.previous_block
=> "0000000000e68270bccfdb595ebde0fbf5b92219671a4ed38a44e3ef50c54997"
irb(main):010:0> bh.nonce
=> 2720588093
irb(main):011:0> bh.timestamp
=> 1306926924
irb(main):012:0> bh.version
=> 1
irb(main):013:0> bh.merkle_root
=> "cc397b6c4d09fe53eb86f4e60df2b516e6afcb3d7e9fbfd342fa04d4c8a03dfb"
irb(main):014:0> bh.bits
=> 470193746

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;

    public class Block
    {
        private static DateTime UTC_ORIGIN = new DateTime(1970, 1, 1, 0, 0, 0, 0);
        private static HashAlgorithm SHA256provider = Environment.OSVersion.Version.Major >= 6 ? new SHA256CryptoServiceProvider() : SHA256.Create();

        public string Solution { get; private set; }
        public long Version { get; private set; }
        public long Header { get; private set; }
        public string PreviousBlockHash { get; private set; }
        public string MerkleRoot { get; private set; }
        public DateTime TimeStamp { get; private set; }
        public long Bits { get; private set; }
        public long Nonce { get; private set; }

        private string computedBlockHash = string.Empty;
        public string BlockHash
        {
            get
            {
                // Lazy-load this when required since this is a CPU-intensive operation
                if (string.IsNullOrEmpty(this.computedBlockHash))
                {
                    this.computedBlockHash = ComputeBlockHash(this.GenerateHashableString());
                }

                return this.computedBlockHash;
            }
        }

        public Block(string solution)
        {
            this.Solution = solution;
            this.Construct();
        }

        private void Construct()
        {
            string raw = this.Solution.Substring(0, 160);

            Version = Convert.ToInt64(raw.Substring(0, 8), 16);                         // @version ||= @raw[0, 8].hex
            PreviousBlockHash = SwitchHexStringEndianness(raw.Substring(8, 64));        // @previous_block ||= switch_endianness(@raw[8, 64])
            MerkleRoot = SwitchHexStringEndianness(raw.Substring(72, 64));              // @merkle_root ||= switch_endianness(@raw[72, 64])
            TimeStamp = FromUnixTimestamp(Convert.ToInt64(raw.Substring(136, 8), 16));  // @timestamp ||= @raw[136, 8].hex
            Bits = Convert.ToInt64(raw.Substring(144, 8), 16);                          // @bits ||= @raw[144, 8].hex
            Nonce = Convert.ToInt64(raw.Substring(152, 8), 16);                         // @nonce ||= @raw[152, 8].hex
        }

        public override string ToString()
        {
            StringBuilder retBldr = new StringBuilder("Block:" + Environment.NewLine);
            retBldr.AppendFormat("Solution={0}{1}", this.Solution, Environment.NewLine);
            retBldr.AppendFormat("Version={0}{1}", this.Version, Environment.NewLine);
            retBldr.AppendFormat("PreviousBlockHash={0}{1}", this.PreviousBlockHash, Environment.NewLine);
            retBldr.AppendFormat("MerkleRoot={0}{1}", this.MerkleRoot, Environment.NewLine);
            retBldr.AppendFormat("TimeStamp={0}{1}", this.TimeStamp, Environment.NewLine);
            retBldr.AppendFormat("Bits={0}{1}", this.Bits, Environment.NewLine);
            retBldr.AppendFormat("Nonce={0}{1}", this.Nonce, Environment.NewLine);
            retBldr.AppendLine();
            retBldr.AppendFormat("BlockHash={0}{1}", this.BlockHash, Environment.NewLine);

            return retBldr.ToString();
        }

        private string GenerateHashableString()
        {
            return ReverseBytesInBinaryString(string.Format("{0:X8}", this.Version))
                    + ReverseBytesInBinaryString(this.PreviousBlockHash)
                    + ReverseBytesInBinaryString(this.MerkleRoot)
                    + ReverseBytesInBinaryString(string.Format("{0:X8}", ConvertToUnixTimestamp(this.TimeStamp)))
                    + ReverseBytesInBinaryString(string.Format("{0:X8}", this.Bits))
                    + ReverseBytesInBinaryString(string.Format("{0:X8}", this.Nonce));
        }


        private static string SwitchHexStringEndianness(string str)
        {
            string result = "";
            while (str.Length > 0)
            {
                result += str.Substring(str.Length - 8);
                str = str.Substring(0, str.Length - 8);
            }
            return result;
        }

        private static string ComputeBlockHash(string hashableString)
        {
            byte[] bytes = ConvertHexStringToBinary(hashableString);

            string hex = BytesToHexString(SHA256provider.ComputeHash(SHA256provider.ComputeHash(bytes)));
            return ReverseBytesInBinaryString(hex);
        }

        private static string BytesToHexString(byte[] a)
        {
            StringBuilder sb = new StringBuilder(a.Length * 2 + 2);
            foreach (byte b in a)
            {
                sb.AppendFormat("{0:X2}", b);
            }
            return sb.ToString().ToLower();
        }

        private static string ReverseBytesInBinaryString(string str)
        {
            return ConvertBinaryToHexString(ConvertHexStringToBinary(str));
        }

        private static string ConvertBinaryToHexString(byte[] bytes)
        {
            // Reverse the endianness of the byte array
            Array.Reverse(bytes);
            return BytesToHexString(bytes);
        }

        private static byte[] ConvertHexStringToBinary(string str)
        {
            List<byte> items = new List<byte>();
            for (int i = 0; i < str.Length / 2; i++)
            {
                items.Add(Convert.ToByte(str.Substring(i * 2, 2), 16));
            }
            return items.ToArray();
        }
        
        private static DateTime FromUnixTimestamp(long timestamp)
        {
            return UTC_ORIGIN.AddSeconds((double)timestamp);
        }

        private static long ConvertToUnixTimestamp(DateTime date)
        {
            TimeSpan diff = date - UTC_ORIGIN;
            return (long)diff.TotalSeconds; // Reminder: will truncate fractional seconds
        }
    }

                Block b = new Block("solution string");
                Console.WriteLine(b.ToString());

irb
irb(main):001:0> load "./block_header.rb"
=> true
irb(main):003:0> b = BlockHeader.new("000000010b362ab3ec365c55dce00249fb087cb90ebf2208c4e97aa60022678a00000000616eb864ec5d0265277b564b916219818bad92cce0d52af9e3e748306af986384e206c1a1c00824f2a78f6a6000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
=> #<BlockHeader:0x7f47cd9cba78 @raw="000000010b362ab3ec365c55dce00249fb087cb90ebf2208c4e97aa60022678a00000000616eb864ec5d0265277b564b916219818bad92cce0d52af9e3e748306af986384e206c1a1c00824f2a78f6a6">
irb(main):006:0> b.block_hash
=> "00000000001b2ff1c57142a9d90592ea3be28fe747da10a889c90afc03ab6e7b"