bitcoin-ruby 0.0.1 → 0.0.2

data/lib/bitcoin/storage/sequel.rb

@@ -1,335 +0,0 @@
-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

data/spec/bitcoin/fixtures/0d0affb5964abe804ffe85e53f1dbb9f29e406aa3046e2db04fba240e63c7fdd.json

@@ -1,27 +0,0 @@
-{
-  "hash":"0d0affb5964abe804ffe85e53f1dbb9f29e406aa3046e2db04fba240e63c7fdd",
-  "ver":1,
-  "vin_sz":1,
-  "vout_sz":2,
-  "lock_time":0,
-  "size":224,
-  "in":[
-    {
-      "prev_out":{
-        "hash":"477fff140b363ec2cc51f3a65c0c58eda38f4d41f04a295bbd62babf25e4c590",
-        "n":0
-      },
-      "scriptSig":"30450220668828280473923647f2fb99450578a18f81e92358d94c933b7033b4370448b8022100cfbce6723163c907b3b86777f0698cc29ea5f89d0fce657a3894afcb1c717da501 033be10bdc7ff38235cf469449147636c4e0e49aacdd0a25af4109cbebd361e0d2"
-    }
-  ],
-  "out":[
-    {
-      "value":"0.02900000",
-      "scriptPubKey":"OP_DUP OP_HASH160 2758fcf332b5df477ec6d877d3b72526b827202b OP_EQUALVERIFY OP_CHECKSIG"
-    },
-    {
-      "value":"0.01000000",
-      "scriptPubKey":"51c387bb5c66d1e9d4d054fd96d0844eecf3b664 OP_NOP2 OP_DROP"
-    }
-  ]
-}

data/spec/bitcoin/fixtures/477fff140b363ec2cc51f3a65c0c58eda38f4d41f04a295bbd62babf25e4c590.json

@@ -1,27 +0,0 @@
-{
-  "hash":"477fff140b363ec2cc51f3a65c0c58eda38f4d41f04a295bbd62babf25e4c590",
-  "ver":1,
-  "vin_sz":1,
-  "vout_sz":2,
-  "lock_time":0,
-  "size":224,
-  "in":[
-    {
-      "prev_out":{
-        "hash":"458b9f6cf2d931d72e246d5ca3d7773069430322a0a1a41653d23a5a3cc3e7ea",
-        "n":1
-      },
-      "scriptSig":"304502205b910ff27919bb4b81847e17e19848a8148373b5d84856e8a0798395c1a4df6e022100a9300a11b37b52997726dab17851914151bd647ca053d60a013b8e0ad42d1c6e01 02b2e1e38d1b15170212a852f68045979d790814a139ed57bffba3763f75e18808"
-    }
-  ],
-  "out":[
-    {
-      "value":"0.03950000",
-      "scriptPubKey":"OP_DUP OP_HASH160 c39c8d989dfdd7fde0ee80be36113c5abcefcb9c OP_EQUALVERIFY OP_CHECKSIG"
-    },
-    {
-      "value":"0.01000000",
-      "scriptPubKey":"64d63d835705618da2111ca3194f22d067187cf2 OP_NOP2 OP_DROP"
-    }
-  ]
-}

data/spec/bitcoin/reorg_spec.rb

@@ -1,129 +0,0 @@
-require_relative 'spec_helper'
-
-include Bitcoin::Builder
-
-describe "reorg" do
-
-  def create_block prev, store = true
-    block = blk do |b|
-      b.prev_block prev
-      b.tx do |t|
-        t.input {|i| i.coinbase }
-        t.output do |o|
-          o.value 5000000000
-          o.script {|s| s.type :address; s.recipient Bitcoin::Key.generate.addr }
-        end
-      end
-    end
-    @store.store_block(block)  if store
-    block
-  end
-
-  def balance addr
-    @store.get_balance(Bitcoin.hash160_from_address(addr))
-  end
-
-  before do
-    Bitcoin.network = :testnet
-    @store = Bitcoin::Storage.sequel(:db => "sqlite:/")
-    @store.log.level = :warn
-    @block0 = Bitcoin::Protocol::Block.new(fixtures_file('testnet/block_0.bin'))
-    @store.store_block(@block0)
-  end
-
-  it "should reorg a single side block" do
-    @store.get_head.should == @block0
-
-    block1 = create_block @block0.hash
-    @store.get_head.should == block1
-
-    block2_0 = create_block block1.hash
-    @store.get_head.should == block2_0
-
-    block2_1 = create_block block1.hash
-    @store.get_head.should == block2_0
-
-    block3 = create_block block2_1.hash
-    @store.get_head.should == block3
-    @store.get_block_by_depth(2).hash.should == block2_1.hash
-  end
-
-  it "should reorg two side blocks" do
-    block1 = create_block @block0.hash
-    @store.get_head.should == block1
-
-    block2_0 = create_block block1.hash
-    @store.get_head.should == block2_0
-
-    block2_1 = create_block block1.hash
-    @store.get_head.should == block2_0
-
-    block3_1 = create_block block2_1.hash
-    @store.get_head.should == block3_1
-
-    block3_0 = create_block block2_0.hash
-    @store.get_head.should == block3_1
-
-    block4 = create_block block3_0.hash
-    @store.get_head.should == block4
-  end
-
-  it "should reconnect orphans" do
-    blocks = [@block0]
-    3.times { blocks << create_block(blocks.last.hash, false) }
-
-    {
-      [0, 1, 2, 3] => [0, 1, 2, 3],
-      [0, 1, 3, 2] => [0, 1, 1, 3],
-      [0, 3, 2, 1] => [0, 0, 0, 3],
-      [0, 3, 1, 2] => [0, 0, 1, 3],
-      [0, 2, 3, 1] => [0, 0, 0, 3],
-    }.each do |order, result|
-      @store.reset
-      order.each_with_index do |n, i|
-        @store.store_block(blocks[n])
-        @store.get_head.should == blocks[result[i]]
-      end
-    end
-
-    i = 3; (0..i).to_a.permutation.each do |order|
-      @store.reset
-      order.each {|n| @store.store_block(blocks[n]) }
-      @store.get_head.should == blocks[i]
-    end
-  end
-
-  it "should handle existing blocks" do
-    Bitcoin.network = :testnet
-    blocks = [@block0]
-    3.times { blocks << create_block(blocks.last.hash, false) }
-    3.times do
-      @store.store_block(blocks[1]).should == [1, 0]
-      @store.store_block(blocks[2]).should == [2, 0]
-      @store.get_head.should == blocks[2]
-    end
-  end
-
-  # see https://bitcointalk.org/index.php?topic=46370.0
-  it "should pass reorg unit tests" do
-    Bitcoin.network = :bitcoin
-    @store.import "./spec/bitcoin/fixtures/reorg/blk_0_to_4.dat"
-    @store.get_depth.should == 4
-    @store.get_head.hash.should =~ /000000002f264d65040/
-    balance("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa").should == 10000000000
-    balance("1NiEGXeURREqqMjCvjCeZn6SwEBZ9AdVet").should == 0
-    balance("1KXFNhNtrRMfgbdiQeuJqnfD7dR4PhniyJ").should == 5000000000
-    balance("1JyMKvPHkrCQd8jQrqTR1rBsAd1VpRhTiE").should == 10000000000
-    @store.import "./spec/bitcoin/fixtures/reorg/blk_3A.dat"
-    @store.import "./spec/bitcoin/fixtures/reorg/blk_4A.dat"
-    @store.get_head.hash.should =~ /000000002f264d65040/
-    @store.import "./spec/bitcoin/fixtures/reorg/blk_5A.dat"
-    @store.get_depth.should == 5
-    @store.get_head.hash.should =~ /00000000195f85184e7/
-    balance("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa").should == 15000000000
-    balance("1NiEGXeURREqqMjCvjCeZn6SwEBZ9AdVet").should == 1000000000
-    balance("1KXFNhNtrRMfgbdiQeuJqnfD7dR4PhniyJ").should == 0
-    balance("1JyMKvPHkrCQd8jQrqTR1rBsAd1VpRhTiE").should == 14000000000
-  end
-
-end