bitcoin-ruby 0.0.7 → 0.0.8

data/lib/bitcoin/protocol/reject.rb

@@ -0,0 +1,38 @@
+# encoding: ascii-8bit
+
+module Bitcoin
+module Protocol
+
+  class Reject < Struct.new(:message, :ccode, :reason, :data)
+    CCODE_TABLE = {
+      0x01 => :malformed,
+      0x10 => :invalid,
+      0x11 => :obsolete,
+      0x12 => :duplicate,
+      0x40 => :nonstandard,
+      0x41 => :dust,
+      0x42 => :insufficientfee,
+      0x43 => :checkpoint,
+    }
+
+    def self.parse(payload)
+      message, payload = Bitcoin::Protocol.unpack_var_string(payload)
+      ccode,   payload = payload.unpack("Ca*")
+      reason,  payload = Bitcoin::Protocol.unpack_var_string(payload)
+      data =   payload
+
+      code = CCODE_TABLE[ccode] || ccode
+      new(message, code, reason, data)
+    end
+
+    def tx_hash
+      message == "tx" && self[:data].reverse.bth
+    end
+
+    def block_hash
+      message == "block" && self[:data].reverse.bth
+    end
+  end
+
+end
+end

data/lib/bitcoin/protocol/tx.rb

@@ -67,13 +67,25 @@ module Bitcoin
 
         @ver = buf.read(4).unpack("V")[0]
 
+        return false if buf.eof?
+
         in_size = Protocol.unpack_var_int_from_io(buf)
         @in = []
-        in_size.times{ @in << TxIn.from_io(buf) }
+        in_size.times{
+          break if buf.eof?
+          @in << TxIn.from_io(buf)
+        }
+
+        return false if buf.eof?
 
         out_size = Protocol.unpack_var_int_from_io(buf)
         @out = []
-        out_size.times{ @out << TxOut.from_io(buf) }
+        out_size.times{
+          break if buf.eof?
+          @out << TxOut.from_io(buf)
+        }
+
+        return false if buf.eof?
 
         @lock_time = buf.read(4).unpack("V")[0]
 
@@ -225,6 +237,7 @@ module Bitcoin
           'in'  =>  @in.map{|i| i.to_hash(options) },
           'out' => @out.map{|o| o.to_hash(options) }
         }
+        h['nid'] = normalized_hash  if options[:with_nid]
         h
       end
 
@@ -240,7 +253,7 @@ module Bitcoin
       end
 
       # parse ruby hash (see also #to_hash)
-      def self.from_hash(h)
+      def self.from_hash(h, do_raise=true)
         tx = new(nil)
         tx.ver, tx.lock_time = (h['ver'] || h['version']), h['lock_time']
         ins  = h['in']  || h['inputs']
@@ -248,6 +261,9 @@ module Bitcoin
         ins .each{|input|   tx.add_in  TxIn.from_hash(input)   }
         outs.each{|output|  tx.add_out TxOut.from_hash(output) }
         tx.instance_eval{ @hash = hash_from_payload(@payload = to_payload) }
+        unless h['hash'] == tx.hash
+          raise "Tx hash mismatch! Claimed: #{h['hash']}, Actual: #{tx.hash}" if do_raise
+        end
         tx
       end
 

data/lib/bitcoin/protocol/txin.rb

@@ -6,7 +6,9 @@ module Bitcoin
     class TxIn
 
       # previous output hash
-      attr_accessor :prev_out
+      attr_accessor :prev_out_hash
+      alias :prev_out :prev_out_hash
+      def prev_out=(hash); @prev_out_hash = hash; end
 
       # previous output index
       attr_accessor :prev_out_index
@@ -29,7 +31,7 @@ module Bitcoin
       COINBASE_INDEX = 0xffffffff
 
       def initialize *args
-        @prev_out, @prev_out_index, @script_sig_length,
+        @prev_out_hash, @prev_out_index, @script_sig_length,
         @script_sig, @sequence = *args
         @script_sig_length ||= 0
         @script_sig ||= ''
@@ -38,7 +40,7 @@ module Bitcoin
 
       # compare to another txout
       def ==(other)
-        @prev_out == other.prev_out &&
+        @prev_out_hash == other.prev_out_hash &&
           @prev_out_index == other.prev_out_index &&
           @script_sig == other.script_sig &&
           @sequence == other.sequence
@@ -63,18 +65,22 @@ module Bitcoin
       end
 
       def parse_data_from_io(buf)
-        @prev_out, @prev_out_index = buf.read(36).unpack("a32V")
+        @prev_out_hash, @prev_out_index = buf.read(36).unpack("a32V")
         @script_sig_length = Protocol.unpack_var_int_from_io(buf)
         @script_sig = buf.read(@script_sig_length)
         @sequence = buf.read(4)
       end
 
+      def parsed_script
+        @parsed_script ||= Bitcoin::Script.new(script_sig)
+      end
+
       def to_payload(script=@script_sig, sequence=@sequence)
-        [@prev_out, @prev_out_index].pack("a32V") << Protocol.pack_var_int(script.bytesize) << script << (sequence || DEFAULT_SEQUENCE)
+        [@prev_out_hash, @prev_out_index].pack("a32V") << Protocol.pack_var_int(script.bytesize) << script << (sequence || DEFAULT_SEQUENCE)
       end
 
       def to_hash(options = {})
-        t = { 'prev_out'  => { 'hash' => @prev_out.reverse_hth, 'n' => @prev_out_index } }
+        t = { 'prev_out'  => { 'hash' => @prev_out_hash.reverse_hth, 'n' => @prev_out_index } }
         if coinbase?
           t['coinbase']  = @script_sig.unpack("H*")[0]
         else # coinbase tx
@@ -103,12 +109,12 @@ module Bitcoin
 
       # previous output in hex
       def previous_output
-        @prev_out.reverse_hth
+        @prev_out_hash.reverse_hth
       end
 
       # check if input is coinbase
       def coinbase?
-        (@prev_out_index == COINBASE_INDEX) && (@prev_out == NULL_HASH)
+        (@prev_out_index == COINBASE_INDEX) && (@prev_out_hash == NULL_HASH)
       end
 
       # set script_sig and script_sig_length

data/lib/bitcoin/script.rb

@@ -663,7 +663,7 @@ class Bitcoin::Script
         Bitcoin::Key.new(nil, pub.unpack("H*")[0]).addr
       rescue OpenSSL::PKey::ECError, OpenSSL::PKey::EC::Point::Error
       end
-    }.compact
+    }
   end
 
   def get_p2sh_address
@@ -827,6 +827,11 @@ class Bitcoin::Script
     @chunks[0] - 80
   end
 
+  def get_keys_provided
+    return false  unless is_multisig?
+    @chunks[-2] - 80
+  end
+
   # This matches CScript::GetSigOpCount(bool fAccurate)
   # Note: this does not cover P2SH script which is to be unserialized
   #       and checked explicitly when validating blocks.

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/bitcoin/bitcoin_spec.rb

@@ -447,6 +447,10 @@ describe 'Bitcoin Address/Hash160/PubKey' do
           Bitcoin.verify_message(s['address'], s['signature'], s['message']).should == true
         }
       }
+
+      Bitcoin.network = :testnet3
+      Bitcoin.verify_message("mwPVMbZQgkpwJJt2YP3sLSgbEBQw3FWZSc", "H5GER0Nz+L7TPZMQzXtv0hnLSsyfPok9lkdHIv01vksREpEpOhTPTonU1xvyPAOIIKhU3++Ol+LaWKWmsfyxDXk=", "A"*500).should == true
+      Bitcoin.network = :bitcoin
     end
   rescue LoadError
   end

data/spec/bitcoin/builder_spec.rb

@@ -103,6 +103,17 @@ describe "Bitcoin::Builder" do
     tx1.in[0].should == tx2.in[0]
   end
 
+  it "should provide tx#output shortcut" do
+    tx1 = build_tx {|t| t.output(123, @keys[1].addr) }
+    tx1.should == build_tx do |t|
+      t.output {|o| o.value 123; o.to @keys[1].addr }
+    end
+
+    tx2 = build_tx {|t| t.output(123, @keys[1].pub, :pubkey) }
+    tx2.should == build_tx do |t|
+      t.output {|o| o.value 123; o.to @keys[1].pub, :pubkey }
+    end
+  end
 
   it "should provide txout#to shortcut" do
     tx1 = build_tx do |t|

data/spec/bitcoin/dogecoin_spec.rb

@@ -139,19 +139,19 @@ describe 'Bitcoin::Dogecoin' do
     block = P::Block.new(data)
     aux_pow = block.aux_pow
     aux_pow.nil?.should == false
-    aux_pow.mrkl_index.should == 0
+    aux_pow.coinbase_index.should == 0
 
-    parent_block_merkle_root = Bitcoin.mrkl_branch_root(aux_pow.branch.map(&:reverse_hth), aux_pow.tx.hash, aux_pow.mrkl_index)
+    parent_block_merkle_root = Bitcoin.mrkl_branch_root(aux_pow.coinbase_branch, aux_pow.coinbase_tx.hash, aux_pow.coinbase_index)
     parent_block_merkle_root.should == aux_pow.parent_block.mrkl_root.reverse.unpack("H*")[0]
 
     # Find the merged mining header in the coinbase input script
     merged_mining_header = "\xfa\xbemm"
-    script = aux_pow.tx.in[0].script
+    script = aux_pow.coinbase_tx.in[0].script
     header_idx = script.index(merged_mining_header)
 
     header_idx.should == 4
     
-    chain_merkle_root = Bitcoin.mrkl_branch_root(aux_pow.aux_branch.map(&:reverse_hth), block_hash, aux_pow.aux_index)
+    chain_merkle_root = Bitcoin.mrkl_branch_root(aux_pow.chain_branch, block_hash, aux_pow.chain_index)
     
     # Drop everything up to the merged mining data
     script = script.slice(header_idx + merged_mining_header.length, chain_merkle_root.length / 2 + 8)
@@ -160,7 +160,7 @@ describe 'Bitcoin::Dogecoin' do
     chain_merkle_root.should == tx_root_hash
 
     merkle_branch_size = script.slice(chain_merkle_root.length / 2, 4).unpack("V")[0]
-    merkle_branch_size.should == (1 << aux_pow.aux_branch.length)
+    merkle_branch_size.should == (1 << aux_pow.chain_branch.length)
 
     # Choose a pseudo-random slot in the chain merkle tree
     # but have it be fixed for a size/nonce/chain combination.
@@ -170,7 +170,7 @@ describe 'Bitcoin::Dogecoin' do
     rand += Bitcoin.network[:auxpow_chain_id]
     rand = rand * 1103515245 + 12345
 
-    aux_pow.aux_index.should == (rand % merkle_branch_size)
+    aux_pow.chain_index.should == (rand % merkle_branch_size)
   end
 
 end

data/spec/bitcoin/protocol/addr_spec.rb

@@ -10,8 +10,9 @@ describe 'Bitcoin::Protocol::Parser (addr)' do
       .split(" ").join].pack("H*")
 
     class Addr_Handler < Bitcoin::Protocol::Handler
-      attr_reader :addr
+      attr_reader :addr, :err
       def on_addr(addr); (@addr ||= []) << addr; end
+      def on_error(*err); (@err ||= []) << err; end
     end
 
     parser = Bitcoin::Protocol::Parser.new( handler = Addr_Handler.new )
@@ -24,6 +25,14 @@ describe 'Bitcoin::Protocol::Parser (addr)' do
     ]
   end
 
+  it "parses broken address packet" do
+    pkt = ["01 00 00 00 00".split(" ").join].pack("H*")
+    parser = Bitcoin::Protocol::Parser.new( handler = Addr_Handler.new )
+    parser.parse_addr(pkt).should == nil
+    handler.addr.should == nil
+    handler.err.should == [[:addr, pkt[1..-1]]]
+  end
+
 end
 
 describe 'Bitcoin::Protocol::Addr' do
@@ -69,4 +78,5 @@ describe 'Bitcoin::Protocol::Addr' do
     Bitcoin::Protocol::Addr.pkt(addr).should ==
       Bitcoin::Protocol.pkt("addr", "\x01" + addr.to_payload)
   end
+
 end

data/spec/bitcoin/protocol/aux_pow_spec.rb

@@ -17,14 +17,14 @@ describe Bitcoin::Protocol::AuxPow do
     @aux_pow.should != nil
     @aux_pow.block_hash.hth.should ==
       "b42124fd99e67ddabe52ebbfcb30a82b8c74268a320b3c5e2311000000000000"
-    @aux_pow.branch.map(&:hth).should == [
-      "6d4febe909ffec61fb8e7bf24ef4444f070f74b208502285528a9686ba792fc2",
-      "d052728459450cec6ff81072c6bd3ec2fd186eaadb09429da7cab0be73646999",
-      "64c5e7e42a6cde585602fdfda6d7e5d9232db2c176a49278268cec09f3cfcb20",
-      "4e9406d6ce9ef751242bb9a63e7c2009746b3736c356ed5d738dadd6937531e4" ]
-    @aux_pow.mrkl_index.should == 0
-    @aux_pow.aux_branch.should == []
-    @aux_pow.aux_index.should == 0
+    @aux_pow.coinbase_branch.should == [
+      "c22f79ba86968a5285225008b2740f074f44f44ef27b8efb61ecff09e9eb4f6d",
+      "99696473beb0caa79d4209dbaa6e18fdc23ebdc67210f86fec0c4559847252d0",
+      "20cbcff309ec8c267892a476c1b22d23d9e5d7a6fdfd025658de6c2ae4e7c564",
+      "e4317593d6ad8d735ded56c336376b7409207c3ea6b92b2451f79eced606944e" ]
+    @aux_pow.coinbase_index.should == 0
+    @aux_pow.chain_branch.should == []
+    @aux_pow.chain_index.should == 0
     @aux_pow.parent_block.hash.should ==
       "00000000000011235e3c0b328a26748c2ba830cbbfeb52beda7de699fd2421b4"
   end
@@ -42,4 +42,4 @@ describe Bitcoin::Protocol::AuxPow do
     P::Block.from_json(@blk.to_json).to_payload.should == @data
   end
 
-  end
+end

data/spec/bitcoin/protocol/block_spec.rb

@@ -128,6 +128,7 @@ describe 'Bitcoin::Protocol::Block' do
       block = Block.from_json(fixtures_file('rawblock-0.json'))
       h = block.to_hash
       h['tx'][0]['ver'] = 2
+      h['tx'][0]['hash'] = "5ea04451af738d113f0ae8559225b7f893f186f099d88c72230a5e19c0bb830d"
       -> { Block.from_hash(h) }.should.raise(Exception)
         .message.should.include?("Block merkle root mismatch!")
     end

data/spec/bitcoin/protocol/inv_spec.rb

@@ -5,12 +5,12 @@ require_relative '../spec_helper.rb'
 describe 'Bitcoin::Protocol::Parser - Inventory Vectors' do
 
   class Test_Handler < Bitcoin::Protocol::Handler
-    attr_reader :tx_inv
-    attr_reader :block_inv
+    attr_reader :tx_inv, :block_inv, :err
     def on_inv_transaction(hash); (@tx_inv ||= []) << hash.hth; end
     def on_get_transaction(hash); (@tx_inv ||= []) << hash.hth; end
     def on_inv_block(hash); (@block_inv ||= []) << hash.hth; end
     def on_get_block(hash); (@block_inv ||= []) << hash.hth; end
+    def on_error(*err); (@err ||= []) << err; end
   end
 
 
@@ -123,4 +123,12 @@ describe 'Bitcoin::Protocol::Parser - Inventory Vectors' do
     }
   end
 
+  it 'parses broken inv packet' do
+    pkt = [("01 00 00 00 00" + " 00"*32).split(" ").join].pack("H*")
+    parser = Bitcoin::Protocol::Parser.new( handler = Test_Handler.new )
+    parser.parse_inv(pkt).should == nil
+    handler.tx_inv.should == nil
+    handler.err.should == [[:parse_inv, pkt[1..-1]]]
+  end
+
 end

data/spec/bitcoin/protocol/parser_spec.rb

@@ -0,0 +1,50 @@
+# encoding: ascii-8bit
+
+require_relative '../spec_helper.rb'
+require 'minitest/mock'
+
+include Bitcoin::Protocol
+
+describe 'Bitcoin::Protocol::Parser' do
+
+
+  before {
+    @pkt= [
+        "f9 be b4 d9", # magic head
+        "69 6e 76 00 00 00 00 00 00 00 00 00", # command ("inv")
+        "49 00 00 00", # message length
+        "11 ea 1c 91", # checksum
+
+        "02", # n hashes
+        "01 00 00 00", # type (1=tx)
+        "e0 41 c2 38 f7 32 1a 68 0a 34 06 bf fd 72 12 e3 d1 2c b5 12 2a 8c 0b 52 76 de 82 30 b1 00 7a 42",
+        "01 00 00 00", # type (1=tx)
+        "33 00 09 71 a9 70 7b 6c 6d 6e 77 aa 2e ac 43 f3 e5 67 84 cb 61 b2 35 fb 8d fe e0 86 8b 40 7c f3"
+      ].map{|s| s.split(" ")}.flatten.join.htb
+    @handler = MiniTest::Mock.new }
+  after { @handler.verify }
+
+  it 'should call appropriate handler' do
+    @handler.expect(:on_inv_transaction, nil, [@pkt[29..60].reverse])
+    @handler.expect(:on_inv_transaction, nil, [@pkt[-32..-1].reverse])
+    Parser.new( @handler ).parse( @pkt ).should == ""
+  end
+
+  it 'should count total packets and bytes' do
+    parser = Parser.new
+    parser.parse @pkt
+    parser.stats.should == {"total_packets"=>1, "total_bytes"=>73, "total_errors" => 0, "inv"=>1}
+  end
+
+  it 'should call error handler for unknown command' do
+    @handler.expect(:on_error, nil, [:unknown_packet, ["foo", "626172"]])
+    Parser.new( @handler ).process_pkt('foo', "bar").should == nil
+  end
+
+  it 'should count total errors' do
+    parser = Parser.new
+    parser.process_pkt('foo', 'bar')
+    parser.stats['total_errors'].should == 1
+  end
+
+end

data/spec/bitcoin/protocol/reject.rb

@@ -0,0 +1,17 @@
+# encoding: ascii-8bit
+
+require_relative '../spec_helper.rb'
+
+describe 'Bitcoin::Protocol::Parser (reject)' do
+
+  it 'parses alert' do
+    payload = "\x02tx\x10\bcoinbase\xB5\x93\x84\x8D\x99\xF4\x1AE\xE9\xD2\x90T\x9919\xF0X %\xBBE\x19\x19\x86\xBC\r\x812\x7F\xC4\xEDN"
+
+    alert = Bitcoin::Protocol::Reject.parse(payload)
+    alert.message.should == "tx"
+    alert.ccode.should == :invalid
+    alert.reason.should == "coinbase"
+    alert.tx_hash.should == "4eedc47f32810dbc86191945bb252058f03931995490d2e9451af4998d8493b5"
+  end
+
+end

data/spec/bitcoin/protocol/tx_spec.rb

@@ -59,7 +59,7 @@ describe 'Tx' do
     script.chunks[0].bitcoin_pushdata = Bitcoin::Script::OP_PUSHDATA2
     script.chunks[0].bitcoin_pushdata_length = script.chunks[0].bytesize
     new_tx['in'][0]['scriptSig'] = script.to_string
-    new_tx = Bitcoin::P::Tx.from_hash(new_tx)
+    new_tx = Bitcoin::P::Tx.from_hash(new_tx, false)
 
     new_tx.hash.should != tx.hash
     new_tx.normalized_hash.size.should == 64
@@ -84,6 +84,10 @@ describe 'Tx' do
     tx.to_payload.should      == @payload[0]
     tx.to_hash.should == orig_tx.to_hash
     Tx.binary_from_hash( orig_tx.to_hash ).should == @payload[0]
+
+    h = orig_tx.to_hash.merge("ver" => 123)
+    -> { tx = Tx.from_hash(h) }.should.raise(Exception)
+      .message.should == "Tx hash mismatch! Claimed: 6e9dd16625b62cfcd4bf02edb89ca1f5a8c30c4b1601507090fb28e59f2d02b4, Actual: 395cd28c334ac84ed125ec5ccd5bc29eadcc96b79c337d0a87a19df64ea3b548"
   end
 
   it 'Tx.binary_from_hash' do