bitcoin-ruby 0.0.4 → 0.0.5

data/.gitignore

@@ -12,3 +12,4 @@ coverage/
 *.conf
 *.db
 .rbx/
+/vendor

data/README.rdoc

@@ -206,9 +206,9 @@ lib/bitcoin/network/node.rb for examples.
 
 === Storage / Database backends
 
-There is support for multiple database backends, but currently the only stable one is
-the Bitcoin::Storage::Backends::SequelStore backend. All backends implement the interface
-defined in Bitcoin::Storage::Backends::StoreBase and return Bitcoin::Storage::Models.
+There is support for different storage backends. Each backend can be used with
+sqlite, postgres or mysql. All backends implement the interface defined in
+Bitcoin::Storage::Backends::StoreBase and return Bitcoin::Storage::Models.
 
  store = Bitcoin::Storage.sequel(:db => "sqlite://bitcoin.db") # in-memory db
  store.get_head #=> block
@@ -217,8 +217,7 @@ defined in Bitcoin::Storage::Backends::StoreBase and return Bitcoin::Storage::Mo
  txouts.first.type #=> :pubkey
  txouts.first.get_address #=> "15yN7NPEpu82sHhB6TzCW5z5aXoamiKeGy"
 
-See Bitcoin::Storage::Backends::StoreBase, Bitcoin::Storage::Backends::SequelStore
-and Bitcoin::Storage::Models for details.
+See also STORAGE, Bitcoin::Storage::Backends::UtxoStore, Bitcoin::Storage::Backends::SequelStore and Bitcoin::Storage::Backends::DummyStore for details.
 
 == Documentation
 

data/doc/CONFIG.rdoc

@@ -38,7 +38,7 @@ from the +all+ category (ie. +bitcoin_wallet+ loads +all+ and +wallet+).
 == Default Values
 
  all:
-   network: bitcoin                       # network identifier ("bitcoin" or "testnet")
+   network: bitcoin                       # network identifier ("bitcoin", "testnet3", "namecoin")
    command: "127.0.0.1:9999"              # IP:Port to listen for incomming command connections
    listen: "0.0.0.0:8332"                 # IP:Port to listen for incoming peer connections
    connect: ""                            # List of IP:Port,IP:Port of nodes to connect to

data/doc/STORAGE.rdoc

@@ -1,13 +1,25 @@
 = Storage
 
-There is support for different storage backends, currently the `sequel` backend is the most stable and should work with `sqlite` and `postgres` databases. see Bitcoin::Storage
+There is support for different storage backends, currently there are two. Each backend can be used with sqlite, postgres or mysql.
 
 == Backends
 
+=== UTXO
+
+The `utxo` backend stores only the minimum amount of information needed to validate new blocks, namely the `Unspent TX Outputs`. So it can be used to independently validate the whole blockchain as it goes, but it cannot query old data or serve blocks to peers. There is however a way to tell it specific addresses for which it will keep the history (the ones in your wallet).
+
+=== Sequel
+
+The `sequel` backend stores the whole blockchain into a fully normalized SQL DB. It can be used to run arbitrary queries on the blockchain data, but the database gets huge and it takes a very long time to do an initial sync.
+
+It is used to run http://webbtc.com and there are also postgres dumps to get you started faster on http://dumps.webbtc.com.
+
+
+== Config
+
 For examples that require storage backends, you can specify them using
 a string containing the backend name and a configuration string.
-The default backend is +sequel::sqlite://bitcoin.db+ which is a sqlite database
-called +bitcoin.db+ in the current directory
+The default backend is +utxo::sqlite:~/.bitcoin-ruby/<network>blocks.db+, which is a sqlite database called +blocks.db+ in a directory named after the network you're using, inside your homedir.
 
  sequel::sqlite:/ # in-memory
  sequel::sqlite://bitcoin.db
@@ -18,4 +30,4 @@ called +bitcoin.db+ in the current directory
 == Custom Backends
 
 To implement a custom backend you need to inherit from Bitcoin::Storage::Backends::StoreBase
-and implement the methods defined there.
+and implement the methods defined there. When returning blocks/tx, you should wrap them in Bitcoin::Storage::Models objects. See the `dummy` backend for a simple example.

data/lib/bitcoin.rb

@@ -495,7 +495,7 @@ module Bitcoin
       :privkey_version => "ef",
       :default_port => 18333,
       :max_money => 21_000_000 * COIN,
-      :dns_seeds => [ "testseed.bitcoin.interesthings.de" ],
+      :dns_seeds => [ ],
       :genesis_hash => "00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008",
       :proof_of_work_limit => 0x1d07fff8,
       :alert_pubkeys => ["04302390343f91cc401d56d68b123028bf52e5fca1939df127f63c6467cdf9c8e2c14b61104cf817d0b780da337893ecc4aaff1309e536162dabbdb45200ca2b0a"],

data/lib/bitcoin/builder.rb

@@ -209,8 +209,8 @@ module Bitcoin
       end
 
       # previous transaction that contains the output we want to use.
-      def prev_out tx
-        @prev_out = tx
+      def prev_out tx, idx = nil
+        @prev_out, @prev_out_index = tx, idx
       end
 
       # index of the output in the #prev_out transaction.

data/lib/bitcoin/network/node.rb

@@ -402,7 +402,7 @@ module Bitcoin::Network
             end
           end
         rescue Bitcoin::Validation::ValidationError
-          @log.warn { "ValiationError storing #{obj[0]} #{obj[1].hash}: #{$!.message}" }
+          @log.warn { "ValidationError storing #{obj[0]} #{obj[1].hash}: #{$!.message}" }
           # File.open("./validation_error_#{obj[0]}_#{obj[1].hash}.bin", "w") {|f|
           #   f.write(obj[1].to_payload) }
           # EM.stop

data/lib/bitcoin/protocol.rb

@@ -83,6 +83,15 @@ module Bitcoin
       [(0...size).map{ i, payload = unpack_var_int(payload); i }, payload]
     end
 
+    def self.unpack_boolean(payload)
+      bdata, payload = payload.unpack("Ca*")
+      [ (bdata == 0 ? false : true), payload ]
+    end
+
+    def self.pack_boolean(b)
+      (b == true) ? [0xFF].pack("C") : [0x00].pack("C")
+    end
+
     BINARY = Encoding.find('ASCII-8BIT')
 
     def self.pkt(command, payload)

data/lib/bitcoin/protocol/block.rb

@@ -138,6 +138,10 @@ module Bitcoin
         h
       end
 
+      def size
+        payload.bytesize
+      end
+
       def hextarget
         Bitcoin.decode_compact_bits(@bits)
       end

data/lib/bitcoin/protocol/parser.rb

@@ -4,10 +4,15 @@ module Bitcoin
   module Protocol
 
     class Parser
+      attr_reader :stats
 
       def initialize(handler=nil)
         @h = handler || Handler.new
         @buf = ""
+        @stats = {
+          'total_packets' => 0,
+          'total_bytes' => 0
+        }
       end
 
       def log
@@ -69,6 +74,9 @@ module Bitcoin
       end
 
       def process_pkt(command, payload)
+        @stats['total_packets'] += 1
+        @stats['total_bytes'] += payload.bytesize
+        @stats[command] ? (@stats[command] += 1) : @stats[command] = 1
         case command
         when 'tx';       @h.on_tx( Tx.new(payload) )
         when 'block';    @h.on_block( Block.new(payload) )

data/lib/bitcoin/protocol/tx.rb

@@ -219,6 +219,10 @@ module Bitcoin
         @validator ||= Bitcoin::Validation::Tx.new(self, store, block)
       end
 
+      def size
+        payload.bytesize
+      end
+
       DEFAULT_BLOCK_PRIORITY_SIZE = 27000
 
       def minimum_relay_fee; calculate_minimum_fee(allow_free=true, :relay); end

data/lib/bitcoin/protocol/txout.rb

@@ -43,6 +43,10 @@ module Bitcoin
 
       alias :parse_payload :parse_data
 
+      def get_script
+        @script_cache || Bitcoin::Script.new(@pk_script)
+      end
+
       def to_payload
         [@value].pack("Q") << Protocol.pack_var_int(@pk_script_length) << @pk_script
       end
@@ -52,7 +56,7 @@ module Bitcoin
       end
 
       def to_hash(options = {})
-        script = Bitcoin::Script.new(@pk_script)
+        script = get_script
         h = { 'value' => "%.8f" % (@value / 100000000.0),
           'scriptPubKey' => script.to_string }
         h["address"] = script.get_address  if script.is_hash160? && options[:with_address]

data/lib/bitcoin/protocol/version.rb

@@ -19,7 +19,8 @@ module Bitcoin
           :to         => "127.0.0.1:8333",
           :nonce      => Bitcoin::Protocol::Uniq,
           :user_agent => "/bitcoin-ruby:#{Bitcoin::VERSION}/",
-          :last_block => 0 # 188617
+          :last_block => 0, # 188617
+          :relay      => true # BIP0037
         }.merge( opts.reject{|k,v| v == nil } )
       end
 
@@ -30,7 +31,8 @@ module Bitcoin
           pack_address_field(@fields[:to]),
           @fields.values_at(:nonce).pack("Q"),
           Protocol.pack_var_string(@fields[:user_agent]),
-          @fields.values_at(:last_block).pack("V")
+          @fields.values_at(:last_block).pack("V"),
+          Protocol.pack_boolean(@fields[:relay]) # Satoshi 0.8.6 doesn't send this but it does respect it
         ].join
       end
 
@@ -42,12 +44,13 @@ module Bitcoin
         version, services, timestamp, to, from, nonce, payload = payload.unpack("VQQa26a26Qa*")
         to, from = unpack_address_field(to), unpack_address_field(from)
         user_agent, payload = Protocol.unpack_var_string(payload)
-        last_block = payload.unpack("V")[0]
+        last_block, payload = payload.unpack("Va*")
+        relay, payload = unpack_relay_field(version, payload)
 
         @fields = {
          :version => version, :services => services, :time => timestamp,
          :from => from, :to => to, :nonce => nonce,
-         :user_agent => user_agent.to_s, :last_block => last_block
+         :user_agent => user_agent.to_s, :last_block => last_block, :relay => relay
         }
         self
       end
@@ -66,6 +69,11 @@ module Bitcoin
         [[1].pack("Q"), "\x00"*10, "\xFF\xFF",  host, port].join
       end
 
+      # BIP0037: this field starts with version 70001 and is allowed to be missing, defaults to true
+      def unpack_relay_field(version, payload)
+        ( version >= 70001 and payload ) ? Protocol.unpack_boolean(payload) : [ true, nil ]
+      end
+
       def uptime
         @fields[:time] - Time.now.tv_sec
       end

data/lib/bitcoin/script.rb

@@ -100,6 +100,7 @@ class Bitcoin::Script
   OP_LSHIFT = 152
   OP_RSHIFT = 153
 
+  OP_INVALIDOPCODE = 0xff
 
   OPCODES = Hash[*constants.grep(/^OP_/).map{|i| [const_get(i), i.to_s] }.flatten]
   OPCODES[0] = "0"
@@ -447,7 +448,7 @@ class Bitcoin::Script
 
   # is this a multisig tx
   def is_multisig?
-    return false  if @chunks.size > 6 || @chunks.size < 4
+    return false  if @chunks.size > 6 || @chunks.size < 4 || !@chunks[-2].is_a?(Fixnum)
     @chunks[-1] == OP_CHECKMULTISIG and get_multisig_pubkeys.all?{|c| c.is_a?(String) }
   end
 
@@ -475,6 +476,7 @@ class Bitcoin::Script
   # get the hash160 for this hash160 or pubkey script
   def get_hash160
     return @chunks[2..-3][0].unpack("H*")[0]  if is_hash160?
+    return @chunks[-2].unpack("H*")[0]        if is_p2sh?
     return Bitcoin.hash160(get_pubkey)        if is_pubkey?
   end
 
@@ -498,11 +500,16 @@ class Bitcoin::Script
     }.compact
   end
 
+  def get_p2sh_address
+    Bitcoin.hash160_to_p2sh_address(get_hash160)
+  end
+
   # get all addresses this script corresponds to (if possible)
   def get_addresses
     return [get_pubkey_address]    if is_pubkey?
     return [get_hash160_address]   if is_hash160?
     return get_multisig_addresses  if is_multisig?
+    return [get_p2sh_address]      if is_p2sh?
     []
   end
 

data/lib/bitcoin/storage/dummy/dummy_store.rb

@@ -102,7 +102,8 @@ module Bitcoin::Storage::Backends
 
     def wrap_block(block)
       return nil  unless block
-      data = {:id => @blk.index(block), :depth => @blk.index(block), :work => @blk.index(block), :chain => 0}
+      data = { id: @blk.index(block), depth: @blk.index(block),
+        work: @blk.index(block), chain: MAIN, size: block.size }
       blk = Bitcoin::Storage::Models::Block.new(self, data)
       [:ver, :prev_block, :mrkl_root, :time, :bits, :nonce].each do |attr|
         blk.send("#{attr}=", block.send(attr))
@@ -117,7 +118,8 @@ module Bitcoin::Storage::Backends
     def wrap_tx(transaction)
       return nil  unless transaction
       blk = @blk.find{|b| b.tx.include?(transaction)}
-      data = {:id => transaction.hash, :blk_id => @blk.index(blk)}
+      data = { id: transaction.hash, blk_id: @blk.index(blk),
+        size: transaction.size }
       tx = Bitcoin::Storage::Models::Tx.new(self, data)
       tx.ver = transaction.ver
       tx.lock_time = transaction.lock_time
@@ -130,7 +132,7 @@ module Bitcoin::Storage::Backends
     def wrap_txin(input)
       return nil  unless input
       tx = @tx.values.find{|t| t.in.include?(input)}
-      data = {:tx_id => tx.hash, :tx_idx => tx.in.index(input)}
+      data = { tx_id: tx.hash, tx_idx: tx.in.index(input)}
       txin = Bitcoin::Storage::Models::TxIn.new(self, data)
       [:prev_out, :prev_out_index, :script_sig_length, :script_sig, :sequence].each do |attr|
         txin.send("#{attr}=", input.send(attr))
@@ -141,8 +143,8 @@ module Bitcoin::Storage::Backends
     def wrap_txout(output)
       return nil  unless output
       tx = @tx.values.find{|t| t.out.include?(output)}
-      data = {:tx_id => tx.hash, :tx_idx => tx.out.index(output),
-        :hash160 => Bitcoin::Script.new(output.pk_script).get_hash160 }
+      data = {tx_id: tx.hash, tx_idx: tx.out.index(output),
+        hash160: Bitcoin::Script.new(output.pk_script).get_hash160 }
       txout = Bitcoin::Storage::Models::TxOut.new(self, data)
       [:value, :pk_script_length, :pk_script].each do |attr|
         txout.send("#{attr}=", output.send(attr))

data/lib/bitcoin/storage/models.rb

@@ -14,7 +14,7 @@ module Bitcoin::Storage::Models
   class Block < Bitcoin::Protocol::Block
 
     attr_accessor :ver, :prev_block, :mrkl_root, :time, :bits, :nonce, :tx
-    attr_reader :store, :id, :depth, :chain, :work
+    attr_reader :store, :id, :depth, :chain, :work, :size
 
     def initialize store, data
       @store = store
@@ -22,6 +22,7 @@ module Bitcoin::Storage::Models
       @depth = data[:depth]
       @chain = data[:chain]
       @work = data[:work]
+      @size = data[:size]
       @tx = []
     end
 
@@ -35,25 +36,38 @@ module Bitcoin::Storage::Models
       @store.get_block_by_prev_hash(@hash)
     end
 
+    def total_out
+      @total_out ||= tx.inject(0){ |m,t| m + t.total_out }
+    end
+
+    def total_in
+      @total_in ||= tx.inject(0){ |m,t| m + t.total_in }
+    end
+
+    def total_fee
+      @total_fee ||= tx.inject(0){ |m,t| m + t.fee }
+    end
   end
 
   # Transaction retrieved from storage. (see Bitcoin::Protocol::Tx)
   class Tx < Bitcoin::Protocol::Tx
 
     attr_accessor :ver, :lock_time, :hash
-    attr_reader :store, :id, :blk_id
+    attr_reader :store, :id, :blk_id, :size, :idx
 
     def initialize store, data
       @store = store
       @id = data[:id]
       @blk_id = data[:blk_id]
+      @size = data[:size]
+      @idx  = data[:idx]
       super(nil)
     end
 
     # get the block this transaction is in
     def get_block
       return nil  unless @blk_id
-      @store.get_block_by_id(@blk_id)
+      @block ||= @store.get_block_by_id(@blk_id)
     end
 
     # get the number of blocks that confirm this tx in the main chain
@@ -61,6 +75,21 @@ module Bitcoin::Storage::Models
       return 0  unless get_block
       @store.get_head.depth - get_block.depth + 1
     end
+
+    def total_out
+      @total_out ||= self.out.inject(0){ |e, o| e + o.value }
+    end
+
+    # if tx_in is coinbase, set in value as total_out, fee could be 0
+    def total_in
+      @total_in ||= self.in.inject(0){ |m, input|
+        m + (input.coinbase? ? total_out : (input.get_prev_out.try(:value) || 0))
+      }
+    end
+
+    def fee
+      @fee ||= total_in - total_out
+    end
   end
 
   # Transaction input retrieved from storage. (see Bitcoin::Protocol::TxIn
@@ -77,15 +106,16 @@ module Bitcoin::Storage::Models
 
     # get the transaction this input is in
     def get_tx
-
-      @store.get_tx_by_id(@tx_id)
+      @tx ||= @store.get_tx_by_id(@tx_id)
     end
 
     # get the previous output referenced by this input
     def get_prev_out
-      prev_tx = @store.get_tx(@prev_out.reverse_hth)
-      return nil  unless prev_tx
-      prev_tx.out[@prev_out_index]
+      @prev_tx_out ||= begin
+        prev_tx = @store.get_tx(@prev_out.reverse_hth)
+        return nil  unless prev_tx
+        prev_tx.out[@prev_out_index]
+      end
     end
 
   end
@@ -109,7 +139,7 @@ module Bitcoin::Storage::Models
 
     # get the transaction this output is in
     def get_tx
-      @store.get_tx_by_id(@tx_id)
+      @tx ||= @store.get_tx_by_id(@tx_id)
     end
 
     # get the next input that references this output

data/lib/bitcoin/storage/sequel/sequel_store.rb

@@ -77,7 +77,7 @@ module Bitcoin::Storage::Backends
           txout_ids = @db[:txout].insert_multiple(new_tx.map.with_index {|tx, tx_idx|
             tx, _ = *tx
             tx.out.map.with_index {|txout, txout_idx|
-              script_type, a, n = *parse_script(txout, txout_i)
+              script_type, a, n = *parse_script(txout, txout_i, tx.hash)
               addrs += a; names += n; txout_i += 1
               txout_data(new_tx_ids[tx_idx], txout, txout_idx, script_type) } }.flatten)
 
@@ -107,7 +107,7 @@ module Bitcoin::Storage::Backends
     end
 
     # parse script and collect address/txout mappings to index
-    def parse_script txout, i
+    def parse_script txout, i, tx_hash = ""
       addrs, names = [], []
 
       script = Bitcoin::Script.new(txout.pk_script) rescue nil
@@ -122,11 +122,12 @@ module Bitcoin::Storage::Backends
           addrs << [i, script.get_hash160]
           names << [i, script]
         else
-          log.warn { "Unknown script type"}# #{tx.hash}:#{txout_idx}" }
+          log.info { "Unknown script type in #{tx_hash}:#{i}" }
+          log.debug { script.to_string }
         end
         script_type = SCRIPT_TYPES.index(script.type)
       else
-        log.error { "Error parsing script"}# #{tx.hash}:#{txout_idx}" }
+        log.error { "Error parsing script #{tx_hash}:#{i}" }
         script_type = SCRIPT_TYPES.index(:unknown)
       end
       [script_type, addrs, names]
@@ -170,7 +171,7 @@ module Bitcoin::Storage::Backends
         return transaction[:id]  if transaction
         tx_id = @db[:tx].insert(tx_data(tx))
         tx.in.each_with_index {|i, idx| store_txin(tx_id, i, idx)}
-        tx.out.each_with_index {|o, idx| store_txout(tx_id, o, idx)}
+        tx.out.each_with_index {|o, idx| store_txout(tx_id, o, idx, tx.hash)}
         tx_id
       end
     end
@@ -197,8 +198,8 @@ module Bitcoin::Storage::Backends
     end
 
     # store output +txout+
-    def store_txout(tx_id, txout, idx)
-      script_type, addrs, names = *parse_script(txout, idx)
+    def store_txout(tx_id, txout, idx, tx_hash = "")
+      script_type, addrs, names = *parse_script(txout, idx, tx_hash)
       txout_id = @db[:txout].insert(txout_data(tx_id, txout, idx, script_type))
       persist_addrs addrs.map {|i, h| [txout_id, h] }
       names.each {|i, script| store_name(script, txout_id) }
@@ -345,7 +346,7 @@ module Bitcoin::Storage::Backends
     def wrap_block(block)
       return nil  unless block
 
-      data = {:id => block[:id], :depth => block[:depth], :chain => block[:chain], :work => block[:work].to_i, :hash => block[:hash].hth}
+      data = {:id => block[:id], :depth => block[:depth], :chain => block[:chain], :work => block[:work].to_i, :hash => block[:hash].hth, :size => block[:blk_size]}
       blk = Bitcoin::Storage::Models::Block.new(self, data)
 
       blk.ver = block[:version]
@@ -371,7 +372,7 @@ module Bitcoin::Storage::Backends
       block_id ||= @db[:blk_tx].join(:blk, id: :blk_id)
         .where(tx_id: transaction[:id], chain: 0).first[:blk_id] rescue nil
 
-      data = {id: transaction[:id], blk_id: block_id}
+      data = {id: transaction[:id], blk_id: block_id, size: transaction[:tx_size], idx: transaction[:idx]}
       tx = Bitcoin::Storage::Models::Tx.new(self, data)
 
       inputs = db[:txin].filter(:tx_id => transaction[:id]).order(:tx_idx)
@@ -431,6 +432,22 @@ module Bitcoin::Storage::Backends
       log.info { "Last #{count} blocks are consistent." }
     end
 
+    # get total received of +address+ address
+    def get_received(address)
+      return 0 unless Bitcoin.valid_address?(address)
+
+      txouts = get_txouts_for_address(address)
+      return 0 unless txouts.any?
+
+      txouts.inject(0){ |m, out| m + out.value }
+
+      # total = 0
+      # txouts.each do |txout|
+      #   tx = txout.get_tx
+      #   total += txout.value
+      # end
+    end
+
   end
 
 end

data/lib/bitcoin/storage/storage.rb

@@ -181,7 +181,7 @@ module Bitcoin::Storage
           else
             depth = prev_block ? prev_block.depth + 1 : 0
             log.debug { "=> orphan (#{depth})" }
-            return [0, 2]  unless in_sync?
+            return [0, 2]  unless (in_sync? || Bitcoin.network_name =~ /testnet/)
             return persist_block(blk, ORPHAN, depth)
           end
         end
@@ -419,7 +419,12 @@ module Bitcoin::Storage
           File.open(filename) do |file|
             until file.eof?
               magic = file.read(4)
-              raise "invalid network magic"  unless Bitcoin.network[:magic_head] == magic
+
+              # bitcoind pads the ends of the block files so that it doesn't
+              # have to reallocate space on every new block.
+              break if magic == "\0\0\0\0"
+              raise "invalid network magic" unless Bitcoin.network[:magic_head] == magic
+
               size = file.read(4).unpack("L")[0]
               blk = Bitcoin::P::Block.new(file.read(size))
               depth, chain = new_block(blk)

data/lib/bitcoin/storage/utxo/migrations/003_update_indices.rb

@@ -0,0 +1,14 @@
+Sequel.migration do
+  up do
+    @log.info { "Running migration #{__FILE__}" }
+
+    alter_table :utxo do
+      # This is used when deleting spent uxto rows
+      add_index([:tx_hash, :tx_idx])
+
+      # These don't seem to be necessary
+      drop_index :tx_idx
+      drop_index :value
+    end
+  end
+end

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/bitcoin/builder_spec.rb

@@ -72,6 +72,17 @@ describe "Bitcoin::Builder" do
     script.get_address.should == @keys[1].addr
 
     tx.verify_input_signature(0, block.tx[0]).should == true
+
+
+    # check shortcuts also work
+    tx2 = build_tx do |t|
+      t.input {|i| i.prev_out @block.tx[0], 0; i.signature_key @keys[0] }
+      t.output {|o| o.value 123; o.script {|s| s.recipient @keys[1].addr } }
+    end
+    tx2.in[0].prev_out.should == tx.in[0].prev_out
+    tx2.in[0].prev_out_index.should == tx.in[0].prev_out_index
+    tx2.out[0].value.should == tx.out[0].value
+    tx2.out[0].pk_script.should == tx.out[0].pk_script
   end
 
   it "should build unsigned transactions and add the signature hash" do

data/spec/bitcoin/protocol/version_spec.rb

@@ -27,7 +27,8 @@ describe 'Bitcoin::Protocol::Parser (version)' do
       :to          => "127.0.0.1:57802",
       :nonce       => 12576309328653329813,
       :user_agent  => "/bitcoin-qt:0.6.0/",
-      :last_block  => 46722
+      :last_block  => 46722,
+      :relay       => true
     }
 
     pkt = [
@@ -47,7 +48,8 @@ describe 'Bitcoin::Protocol::Parser (version)' do
       :to          => "127.0.0.1:1234",
       :nonce       => 8210299263586646091,
       :user_agent  => '',
-      :last_block  => 250
+      :last_block  => 250,
+      :relay       => true
     }
   end
 
@@ -72,7 +74,36 @@ describe 'Bitcoin::Protocol::Parser (version)' do
       :from       => "127.0.0.1:1234",
       :nonce      => 123,
       :user_agent => "/bitcoin-ruby:#{Bitcoin::VERSION}/",
-      :last_block => 188617
+      :last_block => 188617,
+      :relay      => true
+    }
+  end
+
+  # check that we support sending and receiving of the BIP0037 fRelay flag
+  it 'creates spv enabled version packets' do
+    version = Bitcoin::Protocol::Version.new({
+      :time       => 1337,
+      :from       => "127.0.0.1:8333",
+      :to         => "127.0.0.1:1234",
+      :nonce      => 123,
+      :last_block => 188617,
+      :relay      => false
+    })
+
+    parser = Bitcoin::Protocol::Parser.new( handler = Version_Handler.new )
+    parser.parse( version.to_pkt )
+
+    pkt = handler.pkt
+    pkt.fields.should == {
+      :version    => Bitcoin.network[:protocol_version],
+      :services   => Bitcoin::Protocol::Version::NODE_NETWORK,
+      :time       => 1337,
+      :to         => "127.0.0.1:8333",
+      :from       => "127.0.0.1:1234",
+      :nonce      => 123,
+      :user_agent => "/bitcoin-ruby:#{Bitcoin::VERSION}/",
+      :last_block => 188617,
+      :relay      => false
     }
   end
 

data/spec/bitcoin/script/script_spec.rb

@@ -12,6 +12,7 @@ describe 'Bitcoin::Script' do
     "76a91417977bca1b6287a5e6559c57ef4b6525e9d7ded688ac",
     "524104573b6e9f3a714440048a7b87d606bcbf9e45b8586e70a67a3665ea720c095658471a523e5d923f3f3e015626e7c900bd08560ddffeb17d33c5b52c96edb875954104039c2f4e413a26901e67ad4adbb6a4759af87bc16c7120459ecc9482fed3dd4a4502947f7b4c7782dcadc2bed513ed14d5e770452b97ae246ac2030f13b80a5141048b0f9d04e495c3c754f8c3c109196d713d0778882ef098f785570ee6043f8c192d8f84df43ebafbcc168f5d95a074dc4010b62c003e560abc163c312966b74b653ae", # multisig 2 of 3
     "5141040ee607b584b36e995f2e96dec35457dbb40845d0ce0782c84002134e816a6b8cbc65e9eed047ae05e10760e4113f690fd49ad73b86b04a1d7813d843f8690ace4104220a78f5f6741bb0739675c2cc200643516b02cfdfda5cba21edeaa62c0f954936b30dfd956e3e99af0a8e7665cff6ac5b429c54c418184c81fbcd4bde4088f552ae", # multisig 1 of 2
+    "a9149471864495192e39f5f74574b6c8c513588a820487", # p2sh
   ].map{|s|[s].pack("H*")}
   PUBKEYS = [
     "04fb0123fe2c399981bc77d522e2ae3268d2ab15e9a84ae49338a4b1db3886a1ea04cdab955d81e9fa1fcb0c062cb9a5af1ad5dd5064f4afcca322402b07030ec2",
@@ -83,12 +84,12 @@ describe 'Bitcoin::Script' do
 
       Bitcoin::Script.from_string("(opcode-230) 4 1 2").to_string.should == "(opcode-230) 4 1 2"
       Bitcoin::Script.from_string("(opcode 230) 4 1 2").to_string.should == "(opcode-230) 4 1 2"
-      Bitcoin::Script.from_string("(opcode-65449) 4 1 2").to_string.should == "(opcode-255) OP_HASH160 4 1 2"
+      Bitcoin::Script.from_string("(opcode-65449) 4 1 2").to_string.should == "OP_INVALIDOPCODE OP_HASH160 4 1 2"
 
       # found in testnet3 block 0000000000ac85bb2530a05a4214a387e6be02b22d3348abc5e7a5d9c4ce8dab transactions
-      Script.new("\xff\xff\xff\xff").to_string.should == "(opcode-255) (opcode-255) (opcode-255) (opcode-255)"
+      Script.new("\xff\xff\xff\xff").to_string.should == "OP_INVALIDOPCODE OP_INVALIDOPCODE OP_INVALIDOPCODE OP_INVALIDOPCODE"
       Script.from_string(Script.new("\xff\xff\xff\xff").to_string).raw.should == "\xFF\xFF\xFF\xFF"
-      Script.new("\xff\xff\xff").to_string.should == "(opcode-255) (opcode-255) (opcode-255)"
+      Script.new("\xff\xff\xff").to_string.should == "OP_INVALIDOPCODE OP_INVALIDOPCODE OP_INVALIDOPCODE"
       Script.from_string(Script.new("\xff\xff\xff").to_string).raw.should == "\xFF\xFF\xFF"
     end
 
@@ -172,6 +173,11 @@ describe 'Bitcoin::Script' do
       Bitcoin::Script.from_string(output).get_multisig_addresses.should == ["1NdB761LmTmrJixxp93nz7pEiCx5cKPW44"]
     end
 
+    it "#get_p2sh_address" do
+      Script.new(SCRIPT[5]).get_p2sh_address.should ==
+        "3FDuvkgzsW7LpzL9RBjtjvL7bFXCEeZ7xi"
+    end
+
     it "#get_address" do
       Script.new(SCRIPT[0]).get_address.should ==
         "12cbQLTFMXRnSzktFkuoG3eHoMeFtpTu3S"
@@ -182,6 +188,8 @@ describe 'Bitcoin::Script' do
         "1JiaVc3N3U3CwwcLtzNX1Q4eYfeYxVjtuj"
       Script.new(SCRIPT[4]).get_address.should ==
         "1F2Nnyn7niMcheiYhkHrkc18aDxEkFowy5"
+      Script.new(SCRIPT[5]).get_address.should ==
+        "3FDuvkgzsW7LpzL9RBjtjvL7bFXCEeZ7xi"
     end
 
     it "#get_addresses" do
@@ -201,6 +209,7 @@ describe 'Bitcoin::Script' do
       Script.new(SCRIPT[2]).is_standard?.should == true
       Script.new(SCRIPT[3]).is_standard?.should == true
       Script.new(SCRIPT[4]).is_standard?.should == true
+      Script.new(SCRIPT[5]).is_standard?.should == true
     end
 
     it '#is_pubkey?' do
@@ -209,6 +218,7 @@ describe 'Bitcoin::Script' do
       Script.new(SCRIPT[2]).is_pubkey?.should == false
       Script.new(SCRIPT[3]).is_pubkey?.should == false
       Script.new(SCRIPT[4]).is_send_to_ip?.should == false
+      Script.new(SCRIPT[5]).is_pubkey?.should == false
     end
 
     it "#is_hash160?" do
@@ -217,6 +227,7 @@ describe 'Bitcoin::Script' do
       Script.new(SCRIPT[2]).is_hash160?.should == true
       Script.from_string("OP_DUP OP_HASH160 0 OP_EQUALVERIFY OP_CHECKSIG")
         .is_hash160?.should == false
+      Script.new(SCRIPT[5]).is_hash160?.should == false
     end
 
     it "#is_multisig?" do
@@ -226,6 +237,16 @@ describe 'Bitcoin::Script' do
       Script.new("OP_DUP OP_DROP 2 #{PUBKEYS[0..2].join(' ')} 3 OP_CHECKMULTISIG")
         .is_multisig?.should == false
       Script.new("OP_DROP OP_CHECKMULTISIG").is_multisig?.should == false
+      Script.from_string("d366fb5cbf048801b1bf0742bb0d873f65afb406f41756bd4a31865870f6a928 OP_DROP 2 02aae4b5cd593da83679a9c5cadad4c180c008a40dd3ed240cceb2933b9912da36 03a5aebd8b1b6eec06abc55fb13c72a9ed2143f9eed7d665970e38853d564bf1ab OP_CHECKMULTISIG").is_multisig?.should == false
+    end
+
+    it '#is_p2sh?' do
+      Script.new(SCRIPT[0]).is_p2sh?.should == false
+      Script.new(SCRIPT[1]).is_p2sh?.should == false
+      Script.new(SCRIPT[2]).is_p2sh?.should == false
+      Script.new(SCRIPT[3]).is_p2sh?.should == false
+      Script.new(SCRIPT[4]).is_p2sh?.should == false
+      Script.new(SCRIPT[5]).is_p2sh?.should == true
     end
 
     it "#type" do
@@ -234,6 +255,7 @@ describe 'Bitcoin::Script' do
       Script.new(SCRIPT[2]).type.should == :hash160
       Script.new(SCRIPT[3]).type.should == :multisig
       Script.new(SCRIPT[4]).type.should == :multisig
+      Script.new(SCRIPT[5]).type.should == :p2sh
     end
 
   end
@@ -330,7 +352,7 @@ describe 'Bitcoin::Script' do
 
     # testnet3 tx: 5dea81f9d9d2ea6d06ce23ff225d1e240392519017643f75c96fa2e4316d948a
     script = Script.new( ["0063bac0d0e0f0f1f2f3f3f4ff675168"].pack("H*") )
-    script.to_string.should == "0 OP_IF (opcode-186) (opcode-192) (opcode-208) (opcode-224) (opcode-240) (opcode-241) (opcode-242) (opcode-243) (opcode-243) (opcode-244) (opcode-255) OP_ELSE 1 OP_ENDIF"
+    script.to_string.should == "0 OP_IF (opcode-186) (opcode-192) (opcode-208) (opcode-224) (opcode-240) (opcode-241) (opcode-242) (opcode-243) (opcode-243) (opcode-244) OP_INVALIDOPCODE OP_ELSE 1 OP_ENDIF"
     script.run.should == true
 
     # mainnet tx: 61a078472543e9de9247446076320499c108b52307d8d0fafbe53b5c4e32acc4 redeeming output from 5342c96b946ea2c5e497de5dbf7762021f94aba2c8222c17ed28492fdbb4a6d9

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitcoin-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-10 00:00:00.000000000 Z
+date: 2014-01-23 00:00:00.000000000 Z
 dependencies: []
 description: This is a ruby library for interacting with the bitcoin protocol/network
 email:
@@ -98,6 +98,7 @@ files:
 - lib/bitcoin/storage/storage.rb
 - lib/bitcoin/storage/utxo/migrations/001_base_schema.rb
 - lib/bitcoin/storage/utxo/migrations/002_utxo.rb
+- lib/bitcoin/storage/utxo/migrations/003_update_indices.rb
 - lib/bitcoin/storage/utxo/utxo_store.rb
 - lib/bitcoin/validation.rb
 - lib/bitcoin/version.rb