bitcoin-ruby 0.0.1 → 0.0.2

data/lib/bitcoin/storage/{dummy.rb → dummy/dummy_store.rb}

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin::Storage::Backends
   class DummyStore < StoreBase
 
@@ -12,29 +14,21 @@ module Bitcoin::Storage::Backends
       @blk, @tx = [], {}
     end
 
-    def store_block(blk)
-      return false  unless blk
+    def persist_block(blk, chain, depth, prev_work = 0)
+      return [depth, chain]  unless blk && chain == 0
       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
+      [depth, chain]
     end
 
-    def store_tx(tx)
+    def store_tx(tx, validate = true)
       if @tx.keys.include?(tx.hash)
         log.info { "Tx already stored; skipping" }
         return tx
@@ -99,7 +93,7 @@ module Bitcoin::Storage::Backends
       txouts.map {|o| wrap_txout(o) }
     end
 
-    def get_txouts_for_hash160(hash160)
+    def get_txouts_for_hash160(hash160, unconfirmed = false)
       @tx.values.map(&:out).flatten.map {|o|
         o = wrap_txout(o)
         o.hash160 == hash160 ? o : nil
@@ -108,7 +102,7 @@ module Bitcoin::Storage::Backends
 
     def wrap_block(block)
       return nil  unless block
-      data = {:id => @blk.index(block), :depth => @blk.index(block)}
+      data = {:id => @blk.index(block), :depth => @blk.index(block), :work => @blk.index(block), :chain => 0}
       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))

data/lib/bitcoin/storage/models.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 # StorageModels defines objects that are returned from storage.
 # These objects inherit from their Bitcoin::Protocol counterpart
 # and add some additional data and methods.
@@ -12,19 +14,20 @@ 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
+    attr_reader :store, :id, :depth, :chain, :work
 
     def initialize store, data
       @store = store
       @id = data[:id]
       @depth = data[:depth]
       @chain = data[:chain]
+      @work = data[:work]
       @tx = []
     end
 
     # get the block this one builds upon
     def get_prev_block
-      @store.get_block(hth(@prev_block))
+      @store.get_block(@prev_block.reverse_hth)
     end
 
     # get the block that builds upon this one
@@ -80,7 +83,7 @@ module Bitcoin::Storage::Models
 
     # get the previous output referenced by this input
     def get_prev_out
-      prev_tx = @store.get_tx(@prev_out.reverse.unpack("H*")[0])
+      prev_tx = @store.get_tx(@prev_out.reverse_hth)
       return nil  unless prev_tx
       prev_tx.out[@prev_out_index]
     end
@@ -101,7 +104,7 @@ module Bitcoin::Storage::Models
     end
 
     def hash160
-      Bitcoin::Script.new(@pk_script).get_hash160
+      script.get_hash160
     end
 
     # get the transaction this output is in
@@ -112,20 +115,30 @@ module Bitcoin::Storage::Models
     # get the next input that references this output
     def get_next_in
       @store.get_txin_for_txout(get_tx.hash, @tx_idx)
+    rescue
+      nil
     end
 
     # get all addresses this txout corresponds to (if possible)
     def get_address
-      Bitcoin::Script.new(@pk_script).get_address
+      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
+      script.get_addresses
+    end
+
+    def get_namecoin_name
+      @store.get_name_by_txout_id(@id)
     end
 
     def type
-      Bitcoin::Script.new(@pk_script).type
+      script.type
+    end
+
+    def script
+      @_script = Bitcoin::Script.new(@pk_script)
     end
 
   end

data/lib/bitcoin/storage/{sequel_store/sequel_migrations.rb → sequel/migrations.rb}

@@ -1,26 +1,32 @@
+# encoding: ascii-8bit
+
 module Bitcoin::Storage::Backends::SequelMigrations
 
   def migrate
+    binary = @db.database_type == :postgres ? :bytea : :blob
+
     unless @db.tables.include?(:blk)
       @db.create_table :blk do
         primary_key :id
-        column :hash, :bytea, :null => false, :unique => true, :index => true
+        column :hash, binary, :null => false, :unique => true, :index => true
         column :depth, :int, :null => false, :index => true
         column :version, :bigint, :null => false
-        column :prev_hash, :bytea, :null => false, :index => true
-        column :mrkl_root, :bytea, :null => false
+        column :prev_hash, binary, :null => false, :index => true
+        column :mrkl_root, binary, :null => false
         column :time, :bigint, :null => false
         column :bits, :bigint, :null => false
         column :nonce, :bigint, :null => false
         column :blk_size, :int, :null => false
         column :chain, :int, :null => false
+        column :work, binary, :index => true
+        column :aux_pow, binary
       end
     end
 
     unless @db.tables.include?(:tx)
       @db.create_table :tx do
         primary_key :id
-        column :hash, :bytea, :null => false, :unique => true, :index => true
+        column :hash, binary, :null => false, :unique => true, :index => true
         column :version, :bigint, :null => false
         column :lock_time, :bigint, :null => false
         column :coinbase, :bool, :null => false
@@ -41,8 +47,8 @@ module Bitcoin::Storage::Backends::SequelMigrations
         primary_key :id
         column :tx_id, :int, :null => false, :index => true
         column :tx_idx, :int, :null => false
-        column :script_sig, :bytea, :null => false
-        column :prev_out, :bytea, :null => false, :index => true
+        column :script_sig, binary, :null => false
+        column :prev_out, binary, :null => false, :index => true
         column :prev_out_index, :bigint, :null => false
         column :sequence, :bigint, :null => false
       end
@@ -53,7 +59,7 @@ module Bitcoin::Storage::Backends::SequelMigrations
         primary_key :id
         column :tx_id, :int, :null => false, :index => true
         column :tx_idx, :int, :null => false
-        column :pk_script, :bytea, :null => false, :index => true
+        column :pk_script, binary, :null => false
         column :value, :bigint
         column :type, :int, :null => false, :index => true
       end
@@ -79,6 +85,15 @@ module Bitcoin::Storage::Backends::SequelMigrations
         "(SELECT 1 FROM blk_tx WHERE blk_tx.tx_id = tx.id)" +
         "ORDER BY tx.id DESC")
     end
+
+    unless @db.tables.include?(:names)
+      @db.create_table :names do
+        column :txout_id, :int, :null => false, :index => true
+        column :hash, binary, :index => true
+        column :name, binary, :index => true
+        column :value, binary
+      end
+    end
   end
 
 end

data/lib/bitcoin/storage/sequel/migrations/001_base_schema.rb

@@ -0,0 +1,52 @@
+Sequel.migration do
+
+
+  up do
+
+    $stdout.puts "Running migration #{__FILE__}"
+
+    binary = adapter_scheme == :postgres ? :bytea : :varchar
+
+    alter_table :schema_info do
+      add_column :magic, :varchar # network magic-head
+      add_column :backend, :varchar # storage backend
+    end
+
+    next  if tables.include?(:blk)
+
+    create_table :blk do
+      primary_key :id
+      column :hash, binary, :null => false, :unique => true, :index => true
+      column :depth, :int, :null => false, :index => true
+      column :version, :bigint, :null => false
+      column :prev_hash, binary, :null => false, :index => true
+      column :mrkl_root, binary, :null => false
+      column :time, :bigint, :null => false
+      column :bits, :bigint, :null => false
+      column :nonce, :bigint, :null => false
+      column :blk_size, :int, :null => false
+      column :chain, :int, :null => false
+      column :work, binary, :index => true
+      column :aux_pow, binary
+    end
+
+    create_table :addr do
+      primary_key :id
+      column :hash160, String, :null => false, :index => true
+    end
+
+    create_table :addr_txout do
+      column :addr_id, :int, :null => false, :index => true
+      column :txout_id, :int, :null => false, :index => true
+    end
+
+    create_table :names do
+      column :txout_id, :int, :null => false, :index => true
+      column :hash, binary, :index => true
+      column :name, binary, :index => true
+      column :value, binary
+    end
+
+  end
+
+end

data/lib/bitcoin/storage/sequel/migrations/002_tx.rb

@@ -0,0 +1,50 @@
+Sequel.migration do
+
+  up do
+
+    $stdout.puts "Running migration #{__FILE__}"
+
+    next  if tables.include?(:tx)
+
+    create_table :tx do
+      primary_key :id
+      column :hash, :varchar, :null => false, :unique => true, :index => true
+      column :version, :bigint, :null => false
+      column :lock_time, :bigint, :null => false
+      column :coinbase, :bool, :null => false
+      column :tx_size, :int, :null => false
+    end
+
+    create_table :blk_tx do
+      column :blk_id, :int, :null => false, :index => true
+      column :tx_id, :int, :null => false, :index => true
+      column :idx, :int, :null => false
+    end
+
+    create_table :txin do
+      primary_key :id
+      column :tx_id, :int, :null => false, :index => true
+      column :tx_idx, :int, :null => false
+      column :script_sig, :varchar, :null => false
+      column :prev_out, :varchar, :null => false, :index => true
+      column :prev_out_index, :bigint, :null => false
+      column :sequence, :bigint, :null => false
+    end
+
+    create_table :txout do
+      primary_key :id
+      column :tx_id, :int, :null => false, :index => true
+      column :tx_idx, :int, :null => false
+      column :pk_script, (@db.adapter_scheme == :postgres ? :bytea : :blob), :null => false
+      column :value, :bigint
+      column :type, :int, :null => false, :index => true
+    end
+
+    create_view(:unconfirmed,
+      "SELECT * FROM tx WHERE NOT EXISTS " +
+      "(SELECT 1 FROM blk_tx WHERE blk_tx.tx_id = tx.id)" +
+      "ORDER BY tx.id DESC")
+
+  end
+
+end

data/lib/bitcoin/storage/sequel/migrations/003_change_txin_script_sig_to_blob.rb

@@ -0,0 +1,18 @@
+Sequel.migration do
+
+  up do
+
+    $stdout.puts "Running migration #{__FILE__}"
+
+    if adapter_scheme == :postgres
+      add_column :txin, :tmp_script_sig, :bytea
+      self[:txin].where.update("tmp_script_sig = script_sig::bytea")
+      drop_column :txin, :script_sig
+      add_column :txin, :script_sig, :bytea
+      self[:txin].where.update("script_sig = tmp_script_sig")
+      drop_column :txin, :tmp_script_sig
+    end
+
+  end
+
+end

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

@@ -0,0 +1,436 @@
+# encoding: ascii-8bit
+
+Bitcoin.require_dependency :sequel, message:
+  "Note: You will also need an adapter for your database like sqlite3, mysql2, postgresql"
+
+module Bitcoin::Storage::Backends
+
+  # Storage backend using Sequel to connect to arbitrary SQL databases.
+  # Inherits from StoreBase and implements its interface.
+  class SequelStore < StoreBase
+
+    # sequel database connection
+    attr_accessor :db
+
+    DEFAULT_CONFIG = { mode: :full, cache_head: false }
+
+    # create sequel store with given +config+
+    def initialize config, *args
+      super config, *args
+    end
+
+    # connect to database
+    def connect
+      super
+    end
+
+    # reset database; delete all data
+    def reset
+      [:blk, :blk_tx, :tx, :txin, :txout, :addr, :addr_txout, :names].each {|table| @db[table].delete }
+      @head = nil
+    end
+
+    # persist given block +blk+ to storage.
+    def persist_block blk, chain, depth, prev_work = 0
+      @db.transaction do
+        attrs = {
+          :hash => blk.hash.htb.blob,
+          :depth => depth,
+          :chain => chain,
+          :version => blk.ver,
+          :prev_hash => blk.prev_block.reverse.blob,
+          :mrkl_root => blk.mrkl_root.reverse.blob,
+          :time => blk.time,
+          :bits => blk.bits,
+          :nonce => blk.nonce,
+          :blk_size => blk.to_payload.bytesize,
+          :work => (prev_work + blk.block_work).to_s
+        }
+        attrs[:aux_pow] = blk.aux_pow.to_payload.blob  if blk.aux_pow
+        existing = @db[:blk].filter(:hash => blk.hash.htb.blob)
+        if existing.any?
+          existing.update attrs
+          block_id = existing.first[:id]
+        else
+          block_id = @db[:blk].insert(attrs)
+          blk_tx, new_tx, addrs, names = [], [], [], []
+
+          # store tx
+          blk.tx.each.with_index do |tx, idx|
+            existing = @db[:tx][hash: tx.hash.htb.blob]
+            existing ? blk_tx[idx] = existing[:id] : new_tx << [tx, idx]
+          end
+          new_tx_ids = @db[:tx].insert_multiple(new_tx.map {|tx, _| tx_data(tx) })
+          new_tx_ids.each.with_index {|tx_id, idx| blk_tx[new_tx[idx][1]] = tx_id }
+
+          @db[:blk_tx].insert_multiple(blk_tx.map.with_index {|id, idx|
+            { blk_id: block_id, tx_id: id, idx: idx } })
+
+          # store txins
+          txin_ids = @db[:txin].insert_multiple(new_tx.map.with_index {|tx, tx_idx|
+            tx, _ = *tx
+            tx.in.map.with_index {|txin, txin_idx|
+              txin_data(new_tx_ids[tx_idx], txin, txin_idx) } }.flatten)
+
+          # store txouts
+          txout_i = 0
+          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)
+              addrs += a; names += n; txout_i += 1
+              txout_data(new_tx_ids[tx_idx], txout, txout_idx, script_type) } }.flatten)
+
+          # store addrs
+          persist_addrs addrs.map {|i, h| [txout_ids[i], h]}
+          names.each {|i, script| store_name(script, txout_ids[i]) }
+        end
+        @head = wrap_block(attrs.merge(id: block_id))  if chain == MAIN
+        @db[:blk].where(:prev_hash => blk.hash.htb.blob, :chain => ORPHAN).each do |b|
+          log.debug { "connecting orphan #{b[:hash].hth}" }
+          begin
+            store_block(get_block(b[:hash].hth))
+          rescue SystemStackError
+            EM.defer { store_block(get_block(b[:hash].hth)) }  if EM.reactor_running?
+          end
+        end
+        return depth, chain
+      end
+    end
+
+    def reorg new_side, new_main
+      @db.transaction do
+        @db[:blk].where(hash: new_side.map {|h| h.htb.blob }).update(chain: SIDE)
+        new_main.each {|b| get_block(b).validator(self).validate(raise_errors: true) }  unless @config[:skip_validation]
+        @db[:blk].where(hash: new_main.map {|h| h.htb.blob }).update(chain: MAIN)
+      end
+    end
+
+    # parse script and collect address/txout mappings to index
+    def parse_script txout, i
+      addrs, names = [], []
+
+      script = Bitcoin::Script.new(txout.pk_script) rescue nil
+      if script
+        if script.is_hash160? || script.is_pubkey?
+          addrs << [i, script.get_hash160]
+        elsif script.is_multisig?
+          script.get_multisig_pubkeys.map do |pubkey|
+            addrs << [i, Bitcoin.hash160(pubkey.unpack("H*")[0])]
+          end
+        elsif Bitcoin.namecoin? && script.is_namecoin?
+          addrs << [i, script.get_hash160]
+          names << [i, script]
+        else
+          log.warn { "Unknown script type"}# #{tx.hash}:#{txout_idx}" }
+        end
+        script_type = SCRIPT_TYPES.index(script.type)
+      else
+        log.error { "Error parsing script"}# #{tx.hash}:#{txout_idx}" }
+        script_type = SCRIPT_TYPES.index(:unknown)
+      end
+      [script_type, addrs, names]
+    end
+
+    # bulk-store addresses and txout mappings
+    def persist_addrs addrs
+      addr_txouts, new_addrs = [], []
+      addrs.group_by {|_, a| a }.each do |hash160, txouts|
+        if existing = @db[:addr][:hash160 => hash160]
+          txouts.each {|id, _| addr_txouts << [existing[:id], id] }
+        else
+          new_addrs << [hash160, txouts.map {|id, _| id }]
+        end
+      end
+      new_addr_ids = @db[:addr].insert_multiple(new_addrs.map {|hash160, txout_id|
+        { hash160: hash160 } })
+      new_addr_ids.each.with_index do |addr_id, idx|
+        new_addrs[idx][1].each do |txout_id|
+          addr_txouts << [addr_id, txout_id]
+        end
+      end
+      @db[:addr_txout].insert_multiple(addr_txouts.map {|addr_id, txout_id|
+        { addr_id: addr_id, txout_id: txout_id }})
+    end
+
+    # prepare transaction data for storage
+    def tx_data tx
+      { hash: tx.hash.htb.blob,
+        version: tx.ver, lock_time: tx.lock_time,
+        coinbase: tx.in.size == 1 && tx.in[0].coinbase?,
+        tx_size: tx.payload.bytesize }
+    end
+
+    # store transaction +tx+
+    def store_tx(tx, validate = true)
+      @log.debug { "Storing tx #{tx.hash} (#{tx.to_payload.bytesize} bytes)" }
+      tx.validator(self).validate(raise_errors: true)  if validate
+      @db.transaction do
+        transaction = @db[:tx][:hash => tx.hash.htb.blob]
+        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_id
+      end
+    end
+
+    # prepare txin data for storage
+    def txin_data tx_id, txin, idx
+      { tx_id: tx_id, tx_idx: idx,
+        script_sig: txin.script_sig.blob,
+        prev_out: txin.prev_out.blob,
+        prev_out_index: txin.prev_out_index,
+        sequence: txin.sequence.unpack("V")[0] }
+    end
+
+    # store input +txin+
+    def store_txin(tx_id, txin, idx)
+      @db[:txin].insert(txin_data(tx_id, txin, idx))
+    end
+
+    # prepare txout data for storage
+    def txout_data tx_id, txout, idx, script_type
+      { tx_id: tx_id, tx_idx: idx,
+        pk_script: txout.pk_script.blob,
+        value: txout.value, type: script_type }
+    end
+
+    # store output +txout+
+    def store_txout(tx_id, txout, idx)
+      script_type, addrs, names = *parse_script(txout, idx)
+      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) }
+      txout_id
+    end
+
+    # delete transaction
+    # TODO: also delete blk_tx mapping
+    def delete_tx(hash)
+      log.debug { "Deleting tx #{hash} since all its outputs are spent" }
+      @db.transaction do
+        tx = get_tx(hash)
+        tx.in.each {|i| @db[:txin].where(:id => i.id).delete }
+        tx.out.each {|o| @db[:txout].where(:id => o.id).delete }
+        @db[:tx].where(:id => tx.id).delete
+      end
+    end
+
+    # check if block +blk_hash+ exists
+    def has_block(blk_hash)
+      !!@db[:blk].where(:hash => blk_hash.htb.blob).get(1)
+    end
+
+    # check if transaction +tx_hash+ exists
+    def has_tx(tx_hash)
+      !!@db[:tx].where(:hash => tx_hash.htb.blob).get(1)
+    end
+
+    # get head block (highest block from the MAIN chain)
+    def get_head
+      (@config[:cache_head] && @head) ? @head :
+        @head = wrap_block(@db[:blk].filter(:chain => MAIN).order(:depth).last)
+    end
+
+    def get_head_hash
+      (@config[:cache_head] && @head) ? @head.hash :
+        @head = @db[:blk].filter(:chain => MAIN).order(:depth).last[:hash].hth
+    end
+
+    # get depth of MAIN chain
+    def get_depth
+      depth = (@config[:cache_head] && @head) ? @head.depth :
+        @depth = @db[:blk].filter(:chain => MAIN).order(:depth).last[:depth] rescue nil
+
+      return -1  unless depth
+      depth
+    end
+
+    # get block for given +blk_hash+
+    def get_block(blk_hash)
+      wrap_block(@db[:blk][:hash => blk_hash.htb.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 => prev_hash.htb.blob, :chain => MAIN])
+    end
+
+    # get block by given +tx_hash+
+    def get_block_by_tx(tx_hash)
+      tx = @db[:tx][:hash => tx_hash.htb.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 => tx_hash.htb.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 = tx_hash.htb_reverse.blob
+      wrap_txin(@db[:txin][:prev_out => tx_hash, :prev_out_index => txout_idx])
+    end
+
+    def get_txout_by_id(txout_id)
+      wrap_txout(@db[:txout][:id => txout_id])
+    end
+
+    # get corresponding Models::TxOut for +txin+
+    def get_txout_for_txin(txin)
+      tx = @db[:tx][:hash => txin.prev_out.reverse.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.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| @db[:blk][:id => o.get_tx.blk_id][:chain] == MAIN rescue false }
+      end
+      txouts
+    end
+
+    def get_txouts_for_name_hash(hash)
+      @db[:names].filter(hash: hash).map {|n| get_txout_by_id(n[:txout_id]) }
+    end
+
+    # get all unconfirmed Models::TxOut
+    def get_unconfirmed_tx
+      @db[:unconfirmed].map{|t| wrap_tx(t)}
+    end
+
+    # Grab the position of a tx in a given block
+    def get_idx_from_tx_hash(tx_hash)
+      tx = @db[:tx][:hash => tx_hash.htb.blob]
+      return nil  unless tx
+      parent = @db[:blk_tx][:tx_id => tx[:id]]
+      return nil  unless parent
+      return parent[:idx]
+    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], :work => block[:work].to_i, :hash => block[:hash].hth}
+      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]
+
+      blk.aux_pow = Bitcoin::P::AuxPow.new(block[:aux_pow])  if block[:aux_pow]
+
+      db[:blk_tx].filter(blk_id: block[:id]).join(:tx, id: :tx_id)
+        .order(:idx).each {|tx| blk.tx << wrap_tx(tx, block[:id]) }
+
+      blk.recalc_block_hash
+      blk
+    end
+
+    # wrap given +transaction+ into Models::Transaction
+    def wrap_tx(transaction, block_id = nil)
+      return nil  unless transaction
+
+      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}
+      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("V")
+      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
+
+    # check data consistency of the top +count+ blocks. validates that
+    # - the block hash computed from the stored data is the same
+    # - the prev_hash is the same as the previous blocks' hash
+    # - the merkle root computed from all transactions is correct
+    def check_consistency count = 1000
+      return  if get_depth < 1 || count <= 0
+      depth = get_depth
+      count = depth - 1  if count == -1
+      count = depth - 1  if count >= depth
+      log.info { "Checking consistency of last #{count} blocks..." }
+      prev_blk = get_block_by_depth(depth - count - 1)
+      (depth - count).upto(depth).each do |depth|
+        blk = get_block_by_depth(depth)
+        raise "Block hash #{blk.depth} invalid!"  unless blk.hash == blk.recalc_block_hash
+        raise "Prev hash #{blk.depth} invalid!"  unless blk.prev_block.reverse.hth == prev_blk.hash
+        raise "Merkle root #{blk.depth} invalid!"  unless blk.verify_mrkl_root
+        print "#{blk.hash} #{blk.depth} OK\r"
+        prev_blk = blk
+      end
+      log.info { "Last #{count} blocks are consistent." }
+    end
+
+  end
+
+end