monacoin-ruby 0.1.2 → 0.1.3

data/lib/bitcoin/protocol/aux_pow.rb

@@ -0,0 +1,123 @@
+# encoding: ascii-8bit
+
+module Bitcoin
+  module Protocol
+
+    # Auxiliary Proof-of-Work for merge-mined blockchains
+    # See https://en.bitcoin.it/wiki/Merged_mining_specification.
+    #
+    # The AuxPow contains all data needed to verify that the child
+    # block was included in the parents coinbase transaction, and
+    # the parent satisfies the difficulty target.
+    #
+    # It encodes the +parent_block+ header, and its +coinbase_tx+.
+    # The +coinbase_branch+ and +coinbase_index+ can be used to recalculate
+    # the parent blocks merkle root and prove the coinbase transaction is
+    # really included in it.
+    # The +chain_branch+ and +chain_index+ are used to link the child block
+    # to the merkle root contained in the +coinbase_tx+. (So there can be
+    # more than one merge-mined chain)
+    #
+    # TODO: decode merged-mining data from +coinbase_tx+
+    class AuxPow
+
+      # Coinbase transaction of the parent block, linking to the child block
+      attr_accessor :coinbase_tx
+
+      # Hash of the parent block header
+      attr_accessor :block_hash
+
+      # Merkle branch linking the +coinbase_tx+ to the +parent_block+
+      attr_accessor :coinbase_branch
+
+      # Index of the +coinbase_tx+ in the parent blocks merkle tree
+      attr_accessor :coinbase_index
+
+      # Merkle branch linking the child block to the +coinbase_tx+
+      attr_accessor :chain_branch
+
+      # Index of the child block in the chain merkle tree
+      attr_accessor :chain_index
+
+      # Parent block header
+      attr_accessor :parent_block
+
+      def initialize(data)
+        parse_data (data) if data
+      end
+
+      def parse_data(data)
+        buf = StringIO.new(data)
+        parse_data_from_io(buf)
+        buf.eof? ? '' : buf.read
+      end
+
+      def parse_data_from_io(data)
+        @coinbase_tx = P::Tx.new(nil)
+        @coinbase_tx.parse_data_from_io(data)
+
+        @block_hash = data.read(32)
+        coinbase_branch_count = P.unpack_var_int_from_io(data)
+        @coinbase_branch = []
+        coinbase_branch_count.times{
+          break if data.eof?
+          @coinbase_branch << data.read(32).reverse.hth
+        }
+        @coinbase_index = data.read(4).unpack("I")[0]
+
+        @chain_branch = []
+        chain_branch_count = P.unpack_var_int_from_io(data)
+        chain_branch_count.times{
+          break if data.eof?
+          @chain_branch << data.read(32).reverse.hth
+        }
+
+        @chain_index = data.read(4).unpack("I")[0]
+        block = data.read(80)
+        @parent_block = P::Block.new(block)
+
+        data
+      end
+
+
+      def to_payload
+        payload = @coinbase_tx.to_payload
+        payload << @block_hash
+        payload << P.pack_var_int(@coinbase_branch.count)
+        payload << @coinbase_branch.map(&:htb).map(&:reverse).join
+        payload << [@coinbase_index].pack("I")
+        payload << P.pack_var_int(@chain_branch.count)
+        payload << @chain_branch.map(&:htb).map(&:reverse).join
+        payload << [@chain_index].pack("I")
+        payload << @parent_block.to_payload
+        payload
+      end
+
+      def self.from_hash h
+        aux_pow = new(nil)
+        aux_pow.instance_eval do
+          @coinbase_tx = P::Tx.from_hash(h['coinbase_tx'])
+          @block_hash = h['block_hash'].htb
+          @coinbase_branch = h['coinbase_branch']
+          @coinbase_index = h['coinbase_index']
+          @chain_branch = h['chain_branch']
+          @chain_index = h['chain_index']
+          @parent_block = P::Block.from_hash(h['parent_block'])
+        end
+        aux_pow
+      end
+
+      def to_hash
+        { 'coinbase_tx' => @coinbase_tx.to_hash,
+          'block_hash' => @block_hash.hth,
+          'coinbase_branch' => @coinbase_branch,
+          'coinbase_index' => @coinbase_index,
+          'chain_branch' => @chain_branch,
+          'chain_index' => @chain_index,
+          'parent_block' => @parent_block.to_hash }
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/protocol/block.rb

@@ -0,0 +1,285 @@
+# encoding: ascii-8bit
+
+module Bitcoin
+  module Protocol
+
+    class Block
+
+      BLOCK_VERSION_DEFAULT     = (1 << 0)
+      BLOCK_VERSION_AUXPOW      = (1 << 8)
+      BLOCK_VERSION_CHAIN_START = (1 << 16)
+      BLOCK_VERSION_CHAIN_END   = (1 << 30)
+
+      # block hash
+      attr_accessor :hash
+
+      # previous block hash
+      attr_accessor :prev_block_hash
+      alias :prev_block :prev_block_hash
+      def prev_block=(hash); @prev_block_hash = hash; end
+
+      # transactions (Array of Tx)
+      attr_accessor :tx
+
+      # merkle root
+      attr_accessor :mrkl_root
+
+      # block generation time
+      attr_accessor :time
+
+      # difficulty target bits
+      attr_accessor :bits
+
+      # nonce (number counted when searching for block hash matching target)
+      attr_accessor :nonce
+
+      # version (usually 1)
+      attr_accessor :ver
+
+      # raw protocol payload
+      attr_accessor :payload
+
+      # AuxPow linking the block to a merge-mined chain
+      attr_accessor :aux_pow
+
+      attr_reader :partial_merkle_tree
+
+      alias :transactions :tx
+
+      # compare to another block
+      def ==(other)
+        @hash == other.hash
+      end
+
+      def binary_hash
+        [@hash].pack("H*")
+      end
+
+      def prev_block_hex
+        @prev_block_hex ||= @prev_block_hash.reverse.unpack("H*")[0]
+      end
+
+      # create block from raw binary +data+
+      def initialize(data=nil)
+        @tx = []
+        parse_data_from_io(data) if data
+      end
+
+      # parse raw binary data
+      def parse_data(data)
+        buf = parse_data_from_io(data)
+        buf.eof? ? true : buf.read
+      end
+
+      # parse raw binary data
+      def parse_data_from_io(buf, header_only=false)
+        buf = buf.is_a?(String) ? StringIO.new(buf) : buf
+        @ver, @prev_block_hash, @mrkl_root, @time, @bits, @nonce = buf.read(80).unpack("Va32a32VVV")
+        recalc_block_hash
+
+        if Bitcoin.network[:auxpow_chain_id] != nil && (@ver & BLOCK_VERSION_AUXPOW) > 0
+          @aux_pow = AuxPow.new(nil)
+          @aux_pow.parse_data_from_io(buf)
+        end
+
+        return buf if buf.eof?
+
+        if header_only == :filtered
+          @tx_count = buf.read(4).unpack("V")[0]
+
+          nhashes = Protocol.unpack_var_int_from_io(buf)
+          hashes = []
+          nhashes.times do
+            hashes << buf.read(256 / 8)
+          end
+
+          nflags = Protocol.unpack_var_int_from_io(buf)
+          flags = buf.read(nflags)
+
+          @partial_merkle_tree = PartialMerkleTree.new(@tx_count, hashes, flags)
+          @partial_merkle_tree.set_value
+
+          return buf
+        end
+
+        tx_size = Protocol.unpack_var_int_from_io(buf)
+        @tx_count = tx_size
+        return buf if header_only
+
+        tx_size.times{
+          break if payload == true
+          return buf if buf.eof?
+
+          t = Tx.new(nil)
+          payload = t.parse_data_from_io(buf)
+          @tx << t
+        }
+
+        @payload = to_payload
+        buf
+      end
+
+      # recalculate the block hash
+      def recalc_block_hash
+        @hash = Bitcoin.block_hash(@prev_block_hash.reverse_hth, @mrkl_root.reverse_hth, @time, @bits, @nonce, @ver)
+      end
+
+      def recalc_block_scrypt_hash
+        @scrypt_hash = Bitcoin.block_scrypt_hash(@prev_block_hash.reverse_hth, @mrkl_root.reverse_hth, @time, @bits, @nonce, @ver)
+      end
+
+      def recalc_mrkl_root
+        @mrkl_root = if partial_merkle_tree
+          partial_merkle_tree.root.value.htb_reverse
+        else
+          Bitcoin.hash_mrkl_tree( @tx.map(&:hash) ).last.htb_reverse
+        end
+      end
+
+      # verify mrkl tree
+      def verify_mrkl_root
+        if partial_merkle_tree
+          partial_merkle_tree.valid_tree?(@mrkl_root.reverse_hth)
+        else
+          @mrkl_root.reverse_hth == Bitcoin.hash_mrkl_tree( @tx.map(&:hash) ).last
+        end
+      end
+
+      def tx_hashes
+        if partial_merkle_tree
+          partial_merkle_tree.tx_hashes
+        else
+          @tx.map(&:hash)
+        end
+      end
+
+      # get the block header info
+      # [<version>, <prev_block>, <merkle_root>, <time>, <bits>, <nonce>, <txcount>, <size>]
+      def header_info
+        [@ver, @prev_block_hash.reverse_hth, @mrkl_root.reverse_hth, Time.at(@time), @bits, @nonce, @tx.size, @payload.size]
+      end
+
+      # convert to raw binary format
+      def to_payload
+        head = [@ver, @prev_block_hash, @mrkl_root, @time, @bits, @nonce].pack("Va32a32VVV")
+        head << @aux_pow.to_payload  if @aux_pow
+        return head if @tx.size == 0
+        head << Protocol.pack_var_int(@tx.size)
+        @tx.each{|tx| head << tx.to_payload }
+        head
+      end
+
+      # convert to ruby hash (see also #from_hash)
+      def to_hash(options = {})
+        h = {
+          'hash' => @hash, 'ver' => @ver,
+          'prev_block' => @prev_block_hash.reverse_hth, 'mrkl_root' => @mrkl_root.reverse_hth,
+          'time' => @time, 'bits' => @bits, 'nonce' => @nonce,
+          'n_tx' => @tx.size, 'size' => (@payload||to_payload).bytesize,
+          'tx' => @tx.map{|i| i.to_hash(options) },
+          'mrkl_tree' => Bitcoin.hash_mrkl_tree( @tx.map{|i| i.hash } )
+        }
+        h['aux_pow'] = @aux_pow.to_hash  if @aux_pow
+        h
+      end
+
+      def size
+        payload.bytesize
+      end
+
+      def hextarget
+        Bitcoin.decode_compact_bits(@bits)
+      end
+
+      def decimaltarget
+        Bitcoin.decode_compact_bits(@bits).to_i(16)
+      end
+
+      def difficulty
+        Bitcoin.block_difficulty(@bits)
+      end
+
+      # introduced in block version 2 by BIP_0034
+      # blockchain height as seen by the block itself.
+      # do not trust this value, instead verify with chain storage.
+      def bip34_block_height(height=nil)
+        return nil unless @ver >= 2
+        if height # generate height binary
+          buf = [height].pack("V").gsub(/\x00+$/,"")
+          [buf.bytesize, buf].pack("Ca*")
+        else
+          coinbase = @tx.first.inputs.first.script_sig
+          coinbase[1..coinbase[0].ord].ljust(4, "\x00").unpack("V").first
+        end
+      rescue
+        nil
+      end
+
+      # convert to json representation as seen in the block explorer.
+      # (see also #from_json)
+      def to_json(options = {:space => ''}, *a)
+        JSON.pretty_generate( to_hash(options), options )
+      end
+
+      # write json representation to a file
+      # (see also #to_json)
+      def to_json_file(path)
+        File.open(path, 'wb'){|f| f.print to_json; }
+      end
+
+      # parse ruby hash (see also #to_hash)
+      def self.from_hash(h, do_raise=true)
+        blk = new(nil)
+        blk.instance_eval{
+          @ver, @time, @bits, @nonce = h.values_at('ver', 'time', 'bits', 'nonce')
+          @prev_block_hash, @mrkl_root = h.values_at('prev_block', 'mrkl_root').map{|i| i.htb_reverse }
+          unless h['hash'] == recalc_block_hash
+            raise "Block hash mismatch! Claimed: #{h['hash']}, Actual: #{@hash}" if do_raise
+          end
+          @aux_pow = AuxPow.from_hash(h['aux_pow'])  if h['aux_pow']
+          h['tx'].each{|tx| @tx << Tx.from_hash(tx, do_raise) }
+          if h['tx'].any?
+            (raise "Block merkle root mismatch! Block: #{h['hash']}"  unless verify_mrkl_root) if do_raise
+          end
+        }
+        blk
+      end
+
+      # convert ruby hash to raw binary
+      def self.binary_from_hash(h); from_hash(h).to_payload; end
+
+      # parse json representation (see also #to_json)
+      def self.from_json(json_string); from_hash( JSON.load(json_string) ); end
+
+      # convert json representation to raw binary
+      def self.binary_from_json(json_string); from_json(json_string).to_payload; end
+
+      # convert header to json representation.
+      def header_to_json(options = {:space => ''})
+        h = to_hash
+        %w[tx mrkl_tree].each{|k| h.delete(k) }
+        JSON.pretty_generate( h, options )
+      end
+
+      # block header binary output
+      def block_header
+        [@ver, @prev_block_hash, @mrkl_root, @time, @bits, @nonce, Protocol.pack_var_int(0)].pack("Va32a32VVVa*")
+      end
+
+      # read binary block from a file
+      def self.from_file(path); new( Bitcoin::Protocol.read_binary_file(path) ); end
+
+      # read json block from a file
+      def self.from_json_file(path); from_json( Bitcoin::Protocol.read_binary_file(path) ); end
+
+      # get the (statistical) amount of work that was needed to generate this block.
+      def block_work
+        target = Bitcoin.decode_compact_bits(@bits).to_i(16)
+        return 0 if target <= 0
+        (2**256) / (target + 1)
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/protocol/handler.rb

@@ -0,0 +1,43 @@
+# encoding: ascii-8bit
+
+module Bitcoin
+  module Protocol
+
+    class Handler
+      def on_inv_transaction(hash)
+        p ['inv transaction', hash.hth]
+      end
+
+      def on_inv_block(hash)
+        p ['inv block', hash.hth]
+      end
+
+      def on_get_transaction(hash)
+        p ['get transaction', hash.hth]
+      end
+
+      def on_get_block(hash)
+        p ['get block', hash.hth]
+      end
+
+      def on_addr(addr)
+        p ['addr', addr, addr.alive?]
+      end
+
+      def on_tx(tx)
+        p ['tx', tx]
+      end
+
+      def on_block(block)
+        #p ['block', block]
+        puts block.to_json
+      end
+
+      def on_error(message, payload)
+        p ['error', message, payload]
+      end
+
+    end
+
+  end
+end