bitcoin-ruby 0.0.1

data/lib/bitcoin/storage/dummy.rb

@@ -0,0 +1,164 @@
+module Bitcoin::Storage::Backends
+  class DummyStore < StoreBase
+
+    attr_accessor :blk, :tx
+
+    def initialize *args
+      reset
+      super(*args)
+    end
+
+    def reset
+      @blk, @tx = [], {}
+    end
+
+    def store_block(blk)
+      return false  unless blk
+      if block = get_block(blk.hash)
+        log.info { "Block already stored; skipping" }
+        return false
+      end
+
+      prev_block = get_block(Bitcoin::hth(blk.prev_block.reverse))
+      unless prev_block
+        unless blk.hash == Bitcoin.network[:genesis_hash]
+          log.warn { "INVALID BLOCK: #{blk.hash}" }
+          return false
+        end
+      end
+
+      blk.tx.each {|tx| store_tx(tx) }
+      @blk << blk
+
+      log.info { "NEW HEAD: #{blk.hash} DEPTH: #{get_depth}" }
+      get_depth
+    end
+
+    def store_tx(tx)
+      if @tx.keys.include?(tx.hash)
+        log.info { "Tx already stored; skipping" }
+        return tx
+      end
+      @tx[tx.hash] = tx
+    end
+
+    def has_block(blk_hash)
+      !!get_block(blk_hash)
+    end
+
+    def has_tx(tx_hash)
+      !!get_tx(tx_hash)
+    end
+
+    def get_depth
+      @blk.size - 1
+    end
+
+    def get_head
+      wrap_block(@blk[-1])
+    end
+
+    def get_block_by_depth(depth)
+      wrap_block(@blk[depth])
+    end
+
+    def get_block_by_prev_hash(hash)
+      wrap_block(@blk.find {|blk| blk.prev_block == [hash].pack("H*").reverse})
+    end
+
+    def get_block(blk_hash)
+      wrap_block(@blk.find {|blk| blk.hash == blk_hash})
+    end
+
+    def get_block_by_id(blk_id)
+      wrap_block(@blk[blk_id])
+    end
+
+    def get_block_by_tx(tx_hash)
+      wrap_block(@blk.find {|blk| blk.tx.map(&:hash).include?(tx_hash) })
+    end
+
+    def get_tx(tx_hash)
+      transaction = @tx[tx_hash]
+      return nil  unless transaction
+      wrap_tx(transaction)
+    end
+
+    def get_tx_by_id(tx_id)
+      wrap_tx(@tx[tx_id])
+    end
+
+    def get_txin_for_txout(tx_hash, txout_idx)
+      txin = @tx.values.map(&:in).flatten.find {|i| i.prev_out_index == txout_idx &&
+        i.prev_out == [tx_hash].pack("H*").reverse }
+      wrap_txin(txin)
+    end
+
+    def get_txouts_for_pk_script(script)
+      txouts = @tx.values.map(&:out).flatten.select {|o| o.pk_script == script}
+      txouts.map {|o| wrap_txout(o) }
+    end
+
+    def get_txouts_for_hash160(hash160)
+      @tx.values.map(&:out).flatten.map {|o|
+        o = wrap_txout(o)
+        o.hash160 == hash160 ? o : nil
+      }.compact
+    end
+
+    def wrap_block(block)
+      return nil  unless block
+      data = {:id => @blk.index(block), :depth => @blk.index(block)}
+      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))
+      end
+      block.tx.each do |tx|
+        blk.tx << get_tx(tx.hash)
+      end
+      blk.recalc_block_hash
+      blk
+    end
+
+    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)}
+      tx = Bitcoin::Storage::Models::Tx.new(self, data)
+      tx.ver = transaction.ver
+      tx.lock_time = transaction.lock_time
+      transaction.in.each {|i| tx.add_in(wrap_txin(i))}
+      transaction.out.each {|o| tx.add_out(wrap_txout(o))}
+      tx.hash = tx.hash_from_payload(tx.to_payload)
+      tx
+    end
+
+    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)}
+      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))
+      end
+      txin
+    end
+
+    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 }
+      txout = Bitcoin::Storage::Models::TxOut.new(self, data)
+      [:value, :pk_script_length, :pk_script].each do |attr|
+        txout.send("#{attr}=", output.send(attr))
+      end
+      txout
+    end
+
+    def to_s
+      "DummyStore"
+    end
+
+  end
+end

data/lib/bitcoin/storage/models.rb

@@ -0,0 +1,133 @@
+# StorageModels defines objects that are returned from storage.
+# These objects inherit from their Bitcoin::Protocol counterpart
+# and add some additional data and methods.
+#
+# * Bitcoin::Storage::Models::Block
+# * Bitcoin::Storage::Models::Tx
+# * Bitcoin::Storage::Models::TxIn
+# * Bitcoin::Storage::Models::TxOut
+module Bitcoin::Storage::Models
+
+  # Block retrieved from storage. (see Bitcoin::Protocol::Block)
+  class Block < Bitcoin::Protocol::Block
+
+    attr_accessor :ver, :prev_block, :mrkl_root, :time, :bits, :nonce, :tx
+    attr_reader :store, :id, :depth, :chain
+
+    def initialize store, data
+      @store = store
+      @id = data[:id]
+      @depth = data[:depth]
+      @chain = data[:chain]
+      @tx = []
+    end
+
+    # get the block this one builds upon
+    def get_prev_block
+      @store.get_block(hth(@prev_block))
+    end
+
+    # get the block that builds upon this one
+    def get_next_block
+      @store.get_block_by_prev_hash(@hash)
+    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
+
+    def initialize store, data
+      @store = store
+      @id = data[:id]
+      @blk_id = data[:blk_id]
+      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)
+    end
+
+    # get the number of blocks that confirm this tx in the main chain
+    def confirmations
+      return 0  unless get_block
+      @store.get_head.depth - get_block.depth + 1
+    end
+  end
+
+  # Transaction input retrieved from storage. (see Bitcoin::Protocol::TxIn
+  class TxIn < Bitcoin::Protocol::TxIn
+
+    attr_reader :store, :id, :tx_id, :tx_idx
+
+    def initialize store, data
+      @store = store
+      @id = data[:id]
+      @tx_id = data[:tx_id]
+      @tx_idx = data[:tx_idx]
+    end
+
+    # get the transaction this input is in
+    def get_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.unpack("H*")[0])
+      return nil  unless prev_tx
+      prev_tx.out[@prev_out_index]
+    end
+
+  end
+
+  # Transaction output retrieved from storage. (see Bitcoin::Protocol::TxOut)
+  class TxOut < Bitcoin::Protocol::TxOut
+
+    attr_reader :store, :id, :tx_id, :tx_idx, :type
+
+    def initialize store, data
+      @store = store
+      @id = data[:id]
+      @tx_id = data[:tx_id]
+      @tx_idx = data[:tx_idx]
+      @type = data[:type]
+    end
+
+    def hash160
+      Bitcoin::Script.new(@pk_script).get_hash160
+    end
+
+    # get the transaction this output is in
+    def get_tx
+      @store.get_tx_by_id(@tx_id)
+    end
+
+    # get the next input that references this output
+    def get_next_in
+      @store.get_txin_for_txout(get_tx.hash, @tx_idx)
+    end
+
+    # get all addresses this txout corresponds to (if possible)
+    def get_address
+      Bitcoin::Script.new(@pk_script).get_address
+    end
+
+    # get the single address this txout corresponds to (first for multisig tx)
+    def get_addresses
+      Bitcoin::Script.new(@pk_script).get_addresses
+    end
+
+    def type
+      Bitcoin::Script.new(@pk_script).type
+    end
+
+  end
+
+end

data/lib/bitcoin/storage/sequel.rb

@@ -0,0 +1,335 @@
+Bitcoin.require_dependency :sequel, message:
+  "Note: You will also need an adapter for your database like sqlite3, mysql2, postgresql"
+require 'bitcoin/storage/sequel_store/sequel_migrations'
+
+module Bitcoin::Storage::Backends
+
+  # Storage backend using Sequel to connect to arbitrary SQL databases.
+  # Inherits from StoreBase and implements its interface.
+  class SequelStore < StoreBase
+
+
+    # possible script types
+    SCRIPT_TYPES = [:unknown, :pubkey, :hash160, :multisig, :p2sh]
+
+    # sequel database connection
+    attr_accessor :db
+
+    include Bitcoin::Storage::Backends::SequelMigrations
+
+    # create sequel store with given +config+
+    def initialize config, *args
+      @config = config
+      connect
+      super config, *args
+    end
+
+    # connect to database
+    def connect
+      {:sqlite => "sqlite3", :postgres => "pg", :mysql => "mysql",
+      }.each do |adapter, name|
+        if @config[:db].split(":").first == adapter.to_s
+          Bitcoin.require_dependency name, gem: name
+        end
+      end
+
+      @db = Sequel.connect(@config[:db])
+      migrate
+    end
+
+    # reset database; delete all data
+    def reset
+      [:blk, :blk_tx, :tx, :txin, :txout].each {|table| @db[table].delete}
+    end
+
+    # persist given block +blk+ to storage.
+    def persist_block blk, chain, depth
+      @db.transaction do
+        attrs = {
+          :hash => htb(blk.hash).to_sequel_blob,
+          :depth => depth,
+          :chain => chain,
+          :version => blk.ver,
+          :prev_hash => blk.prev_block.reverse.to_sequel_blob,
+          :mrkl_root => blk.mrkl_root.reverse.to_sequel_blob,
+          :time => blk.time,
+          :bits => blk.bits,
+          :nonce => blk.nonce,
+          :blk_size => blk.to_payload.bytesize,
+        }
+        existing = @db[:blk].filter(:hash => htb(blk.hash).to_sequel_blob)
+        if existing.any?
+          existing.update attrs
+        else
+          block_id = @db[:blk].insert(attrs)
+          blk.tx.each_with_index do |tx, idx|
+            tx_id = store_tx(tx)
+            raise "Error saving tx #{tx.hash} in block #{blk.hash}"  unless tx_id
+            @db[:blk_tx].insert({
+                :blk_id => block_id,
+                :tx_id => tx_id,
+                :idx => idx,
+              })
+          end
+        end
+        begin
+          @db[:blk].where(:prev_hash => htb(blk.hash).to_sequel_blob, :chain => ORPHAN).each do |b|
+            log.debug { "re-org orphan #{hth(b[:hash])}" }
+            begin
+              store_block(get_block(hth(b[:hash])))
+            rescue SystemStackError
+              EM.defer { store_block(get_block(hth(b[:hash]))) }  if EM.reactor_running?
+            end
+          end
+        rescue
+          p $!
+        end
+        log.info { "block #{blk.hash} (#{depth}, #{['main', 'side', 'orphan'][chain]})" } 
+        return depth, chain
+      end
+    end
+
+    # update +attrs+ for block with given +hash+.
+    def update_blocks updates
+      @db.transaction do
+        updates.each do |blocks, attrs|
+          @db[:blk].filter(:hash => blocks.map{|h| htb(h).to_sequel_blob}).update(attrs)
+        end
+      end
+    end
+
+    # store transaction +tx+
+    def store_tx(tx)
+      @log.debug { "Storing tx #{tx.hash} (#{tx.to_payload.bytesize} bytes)" }
+      @db.transaction do
+        transaction = @db[:tx][:hash => htb(tx.hash).to_sequel_blob]
+        return transaction[:id]  if transaction
+        tx_id = @db[:tx].insert({
+            :hash => htb(tx.hash).to_sequel_blob,
+            :version => tx.ver,
+            :lock_time => tx.lock_time,
+            :coinbase => tx.in.size==1 && tx.in[0].coinbase?,
+            :tx_size => tx.payload.bytesize,
+          })
+        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_id
+      end
+    rescue
+      @log.warn { "Error storing tx: #{$!}" }
+    end
+
+    # store input +txin+
+    def store_txin(tx_id, txin, idx)
+      @db[:txin].insert({
+          :tx_id => tx_id,
+          :tx_idx => idx,
+          :script_sig => txin.script_sig.to_sequel_blob,
+          :prev_out => txin.prev_out.to_sequel_blob,
+          :prev_out_index => txin.prev_out_index,
+          :sequence => txin.sequence.unpack("I")[0],
+        })
+    end
+
+    # store output +txout+
+    def store_txout(tx_id, txout, idx)
+      script = Bitcoin::Script.new(txout.pk_script)
+      txout_id = @db[:txout].insert({
+          :tx_id => tx_id,
+          :tx_idx => idx,
+          :pk_script => txout.pk_script.to_sequel_blob,
+          :value => txout.value,
+          :type => SCRIPT_TYPES.index(script.type)
+        })
+      if script.is_hash160? || script.is_pubkey?
+        store_addr(txout_id, script.get_hash160)
+      elsif script.is_multisig?
+        script.get_multisig_pubkeys.map do |pubkey|
+          store_addr(txout_id, Bitcoin.hash160(pubkey.unpack("H*")[0]))
+        end
+      end
+      txout_id
+    end
+
+    # store address +hash160+
+    def store_addr(txout_id, hash160)
+      addr = @db[:addr][:hash160 => hash160]
+      addr_id = addr[:id]  if addr
+      addr_id ||= @db[:addr].insert({:hash160 => hash160})
+      @db[:addr_txout].insert({:addr_id => addr_id, :txout_id => txout_id})
+    end
+
+    # check if block +blk_hash+ exists
+    def has_block(blk_hash)
+      !!@db[:blk].where(:hash => htb(blk_hash).to_sequel_blob).get(1)
+    end
+
+    # check if transaction +tx_hash+ exists
+    def has_tx(tx_hash)
+      !!@db[:tx].where(:hash => htb(tx_hash).to_sequel_blob).get(1)
+    end
+
+    # get head block (highest block from the MAIN chain)
+    def get_head
+      wrap_block(@db[:blk].filter(:chain => MAIN).order(:depth).last)
+    end
+
+    # get depth of MAIN chain
+    def get_depth
+      return -1  unless get_head
+      @db[:blk][:hash => htb(get_head.hash).to_sequel_blob][:depth]
+    end
+
+    # get block for given +blk_hash+
+    def get_block(blk_hash)
+      wrap_block(@db[:blk][:hash => htb(blk_hash).to_sequel_blob])
+    end
+
+    # get block by given +depth+
+    def get_block_by_depth(depth)
+      wrap_block(@db[:blk][:depth => depth, :chain => MAIN])
+    end
+
+    # get block by given +prev_hash+
+    def get_block_by_prev_hash(prev_hash)
+      wrap_block(@db[:blk][:prev_hash => htb(prev_hash).to_sequel_blob])
+    end
+
+    # get block by given +tx_hash+
+    def get_block_by_tx(tx_hash)
+      tx = @db[:tx][:hash => htb(tx_hash).to_sequel_blob]
+      return nil  unless tx
+      parent = @db[:blk_tx][:tx_id => tx[:id]]
+      return nil  unless parent
+      wrap_block(@db[:blk][:id => parent[:blk_id]])
+    end
+
+    # get block by given +id+
+    def get_block_by_id(block_id)
+      wrap_block(@db[:blk][:id => block_id])
+    end
+
+    # get transaction for given +tx_hash+
+    def get_tx(tx_hash)
+      wrap_tx(@db[:tx][:hash => htb(tx_hash).to_sequel_blob])
+    end
+
+    # get transaction by given +tx_id+
+    def get_tx_by_id(tx_id)
+      wrap_tx(@db[:tx][:id => tx_id])
+    end
+
+    # get corresponding Models::TxIn for the txout in transaction
+    # +tx_hash+ with index +txout_idx+
+    def get_txin_for_txout(tx_hash, txout_idx)
+      tx_hash = htb(tx_hash).reverse.to_sequel_blob
+      wrap_txin(@db[:txin][:prev_out => tx_hash, :prev_out_index => txout_idx])
+    end
+
+    # get corresponding Models::TxOut for +txin+
+    def get_txout_for_txin(txin)
+      tx = @db[:tx][:hash => txin.prev_out.reverse.to_sequel_blob]
+      return nil  unless tx
+      wrap_txout(@db[:txout][:tx_idx => txin.prev_out_index, :tx_id => tx[:id]])
+    end
+
+    # get all Models::TxOut matching given +script+
+    def get_txouts_for_pk_script(script)
+      txouts = @db[:txout].filter(:pk_script => script.to_sequel_blob).order(:id)
+      txouts.map{|txout| wrap_txout(txout)}
+    end
+
+    # get all Models::TxOut matching given +hash160+
+    def get_txouts_for_hash160(hash160, unconfirmed = false)
+      addr = @db[:addr][:hash160 => hash160]
+      return []  unless addr
+      txouts = @db[:addr_txout].where(:addr_id => addr[:id])
+        .map{|t| @db[:txout][:id => t[:txout_id]] }
+        .map{|o| wrap_txout(o) }
+      unless unconfirmed
+        txouts.select!{|o| o.get_tx.get_block.chain == MAIN rescue false }
+      end
+      txouts
+    end
+
+    # get all unconfirmed Models::TxOut
+    def get_unconfirmed_tx
+      @db[:unconfirmed].map{|t| wrap_tx(t)}
+    end
+
+    # wrap given +block+ into Models::Block
+    def wrap_block(block)
+      return nil  unless block
+
+      data = {:id => block[:id], :depth => block[:depth], :chain => block[:chain]}
+      blk = Bitcoin::Storage::Models::Block.new(self, data)
+
+      blk.ver = block[:version]
+      blk.prev_block = block[:prev_hash].reverse
+      blk.mrkl_root = block[:mrkl_root].reverse
+      blk.time = block[:time].to_i
+      blk.bits = block[:bits]
+      blk.nonce = block[:nonce]
+      parents = db[:blk_tx].filter(:blk_id => block[:id])
+        .order(:idx) rescue []
+      parents.each do |parent|
+        transaction = db[:tx][:id => parent[:tx_id]]
+        blk.tx << wrap_tx(transaction)
+      end
+
+      blk.recalc_block_hash
+      blk
+    end
+
+    # wrap given +transaction+ into Models::Transaction
+    def wrap_tx(transaction)
+      return nil  unless transaction
+
+      parents = @db[:blk_tx].where(:tx_id => transaction[:id])
+      parent = parents.map{|m|@db[:blk][:id => m[:blk_id]]}.sort_by {|b| b[:chain]}.first
+      block_id = parent ? parent[:id] : nil
+      data = {:id => transaction[:id], :blk_id => block_id}
+      tx = Bitcoin::Storage::Models::Tx.new(self, data)
+
+      inputs = db[:txin].filter(:tx_id => transaction[:id]).order(:tx_idx)
+      inputs.each { |i| tx.add_in(wrap_txin(i)) }
+
+      outputs = db[:txout].filter(:tx_id => transaction[:id]).order(:tx_idx)
+      outputs.each { |o| tx.add_out(wrap_txout(o)) }
+      tx.ver = transaction[:version]
+      tx.lock_time = transaction[:lock_time]
+      tx.hash = tx.hash_from_payload(tx.to_payload)
+      tx
+    end
+
+    # wrap given +input+ into Models::TxIn
+    def wrap_txin(input)
+      return nil  unless input
+      data = {:id => input[:id], :tx_id => input[:tx_id], :tx_idx => input[:tx_idx]}
+      txin = Bitcoin::Storage::Models::TxIn.new(self, data)
+      txin.prev_out = input[:prev_out]
+      txin.prev_out_index = input[:prev_out_index]
+      txin.script_sig_length = input[:script_sig].bytesize
+      txin.script_sig = input[:script_sig]
+      txin.sequence = [input[:sequence]].pack("I")
+      txin
+    end
+
+    # wrap given +output+ into Models::TxOut
+    def wrap_txout(output)
+      return nil  unless output
+      data = {:id => output[:id], :tx_id => output[:tx_id], :tx_idx => output[:tx_idx],
+        :hash160 => output[:hash160], :type => SCRIPT_TYPES[output[:type]]}
+      txout = Bitcoin::Storage::Models::TxOut.new(self, data)
+      txout.value = output[:value]
+      txout.pk_script = output[:pk_script]
+      txout
+    end
+
+
+    def hth(bin); bin.unpack("H*")[0]; end
+    def htb(hex); [hex].pack("H*"); end
+
+  end
+
+end