bitcoin-ruby 0.0.6 → 0.0.7

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

@@ -1,179 +0,0 @@
-# encoding: ascii-8bit
-
-module Bitcoin::Storage::Backends
-  class DummyStore < StoreBase
-
-    attr_accessor :blk, :tx
-
-    def initialize *args
-      reset
-      super(*args)
-    end
-
-    def reset
-      @blk, @tx = [], {}
-    end
-
-    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
-
-      blk.tx.each {|tx| store_tx(tx) }
-      @blk << blk
-
-      log.info { "NEW HEAD: #{blk.hash} DEPTH: #{get_depth}" }
-      [depth, chain]
-    end
-
-    def store_tx(tx, validate = true)
-      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_idx_from_tx_hash(tx_hash)
-      return nil unless tx = get_tx(tx_hash)
-      return nil unless blk = tx.get_block
-      blk.tx.index tx
-    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_txout_for_txin(txin)
-      return nil unless tx = @tx[txin.prev_out.reverse_hth]
-      wrap_tx(tx).out[txin.prev_out_index]
-    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, type = :hash160, unconfirmed = false)
-      @tx.values.map(&:out).flatten.map {|o|
-        o = wrap_txout(o)
-        if o.parsed_script.is_multisig?
-          o.parsed_script.get_multisig_pubkeys.map{|pk| Bitcoin.hash160(pk.unpack("H*")[0])}.include?(hash160) ? o : nil
-        else
-          o.hash160 == hash160 && o.type == type ? o : nil
-        end
-      }.compact
-    end
-
-    def wrap_block(block)
-      return nil  unless block
-      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))
-      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),
-        size: transaction.size }
-      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: output.parsed_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
-
-    def check_consistency(*args)
-      log.warn { "Dummy store doesn't support consistency check" }
-    end
-
-
-  end
-end

data/lib/bitcoin/storage/models.rb

@@ -1,171 +0,0 @@
-# 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.
-#
-# * 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, :work, :size
-
-    def initialize store, data
-      @store = store
-      @id = data[:id]
-      @depth = data[:depth]
-      @chain = data[:chain]
-      @work = data[:work]
-      @size = data[:size]
-      @tx = []
-    end
-
-    # get the block this one builds upon
-    def get_prev_block
-      @store.get_block(@prev_block.reverse_hth)
-    end
-
-    # get the block that builds upon this one
-    def get_next_block
-      @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, :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
-      @block ||= @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
-
-    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
-  class TxIn < Bitcoin::Protocol::TxIn
-
-    attr_reader :store, :id, :tx_id, :tx_idx, :p2sh_type
-
-    def initialize store, data
-      @store = store
-      @id = data[:id]
-      @tx_id = data[:tx_id]
-      @tx_idx = data[:tx_idx]
-      @p2sh_type = data[:p2sh_type]
-    end
-
-    # get the transaction this input is in
-    def get_tx
-      @tx ||= @store.get_tx_by_id(@tx_id)
-    end
-
-    # get the previous output referenced by this input
-    def get_prev_out
-      @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
-
-  # 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
-      parsed_script.get_hash160
-    end
-
-    # get the transaction this output is in
-    def get_tx
-      @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
-      parsed_script.get_address
-    end
-
-    # get the single address this txout corresponds to (first for multisig tx)
-    def get_addresses
-      parsed_script.get_addresses
-    end
-
-    def get_namecoin_name
-      @store.get_name_by_txout_id(@id)
-    end
-
-    def type
-      parsed_script.type
-    end
-
-  end
-
-end

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

@@ -1,99 +0,0 @@
-# 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, 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
-    end
-
-    unless @db.tables.include?(:tx)
-      @db.create_table :tx do
-        primary_key :id
-        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
-        column :tx_size, :int, :null => false
-      end
-    end
-
-    unless @db.tables.include?(:blk_tx)
-      @db.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
-    end
-
-    unless @db.tables.include?(:txin)
-      @db.create_table :txin do
-        primary_key :id
-        column :tx_id, :int, :null => false, :index => true
-        column :tx_idx, :int, :null => false
-        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
-    end
-
-    unless @db.tables.include?(:txout)
-      @db.create_table :txout do
-        primary_key :id
-        column :tx_id, :int, :null => false, :index => true
-        column :tx_idx, :int, :null => false
-        column :pk_script, binary, :null => false
-        column :value, :bigint
-        column :type, :int, :null => false, :index => true
-      end
-    end
-
-    unless @db.tables.include?(:addr)
-      @db.create_table :addr do
-        primary_key :id
-        column :hash160, String, :null => false, :index => true
-      end
-    end
-
-    unless @db.tables.include?(:addr_txout)
-      @db.create_table :addr_txout do
-        column :addr_id, :int, :null => false, :index => true
-        column :txout_id, :int, :null => false, :index => true
-      end
-    end
-
-    unless @db.views.include?(:unconfirmed)
-      @db.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
-
-    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