bitcoin-ruby 0.0.1 → 0.0.2

data/spec/bitcoin/script/script_spec.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 require_relative '../spec_helper.rb'
 require 'bitcoin/script'
 
@@ -24,10 +26,70 @@ describe 'Bitcoin::Script' do
       Script.new(SCRIPT[1]).to_string.should ==
         "304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901"
 
-      Script.new([123].pack("C")).to_string.should == "(opcode 123)"
-      Script.new([176].pack("C")).to_string.should == "OP_EVAL"
-
+      #Script.new([123].pack("C")).to_string.should == "(opcode 123)"
+      Script.new([176].pack("C")).to_string.should == "OP_NOP1"
       Script.from_string("1 OP_DROP 2").to_string.should == "1 OP_DROP 2"
+
+      Script.from_string("4b").to_string.should == "4b"
+      Script.from_string("4b").to_payload.should == "\x01\x4b"
+      Script.from_string("ff").to_string.should == "ff"
+      Script.from_string("ff").to_payload.should == "\x01\xff"
+      Script.from_string("ffff").to_string.should == "ffff"
+
+      Script.from_string( "ff"*(Script::OP_PUSHDATA1-1) ).to_payload[0]   .should == [Script::OP_PUSHDATA1-1].pack("C*")
+      Script.from_string( "ff"*Script::OP_PUSHDATA1     ).to_payload[0..1].should == [Script::OP_PUSHDATA1, Script::OP_PUSHDATA1].pack("C*")
+      Script.from_string( "ff"*(Script::OP_PUSHDATA1+1) ).to_payload[0..1].should == [Script::OP_PUSHDATA1, Script::OP_PUSHDATA1+1].pack("C*")
+      Script.from_string( "ff"*0xff                     ).to_payload[0..1].should == [Script::OP_PUSHDATA1, 0xff].pack("C*")
+      Script.from_string( "ff"*(0xff+1)                 ).to_payload[0..2].should == [Script::OP_PUSHDATA2, 0x00, 0x01].pack("C*")
+      Script.from_string( "ff"*0xffff                   ).to_payload[0..2].should == [Script::OP_PUSHDATA2, 0xff, 0xff].pack("C*")
+      Script.from_string( "ff"*(0xffff+1)               ).to_payload[0..4].should == [Script::OP_PUSHDATA4, 0x00, 0x00, 0x01, 0x00].pack("C*")
+
+      Script.from_string("16").to_string.should == "16"
+      Script::OP_2_16.include?(Script.from_string("16").chunks.first).should == true
+      Script.from_string("16").to_payload.should == "\x60"
+      Script.new("\x60").to_string.should == "16"
+
+      Script.from_string("0:1:16").to_string.should == "0:1:16"
+      Script::OP_2_16.include?(Script.from_string("0:1:16").chunks.first).should == false
+      Script.from_string("0:1:16").to_payload.should == "\x01\x16"
+      Script.new("\x01\x16").to_string.should == "0:1:16"
+
+      Script.new("\x4d\x01\x00\x02").to_string.should == "77:1:02"
+      Script.from_string("77:1:02").to_payload.should == "\x4d\x01\x00\x02"
+      Script.from_string("77:1:01").to_string.should == "77:1:01"
+      Script.from_string("77:2:0101").to_string.should == "77:2:0101"
+      Script.from_string("78:1:01").to_string.should == "78:1:01"
+      Script.from_string("78:2:0101").to_string.should == "78:2:0101"
+      Script.new("\x4e\x01\x00\x00\x00\x02").to_string.should == "78:1:02"
+      Script.from_string("78:1:02").to_payload.should == "\x4e\x01\x00\x00\x00\x02"
+
+      Script.new("\x4d\x01\x00").to_string.should == "77:1:"
+      Script.from_string("77:1:").to_payload.should == "\x4d\x01\x00"
+
+      [ # mainnet tx: ebc9fa1196a59e192352d76c0f6e73167046b9d37b8302b6bb6968dfd279b767 outputs
+        ["\x01",                        "238:1:01",            true],
+        ["\x02\x01",                    "238:2:0201",          true],
+        ["L",                           "238:1:4c",            true],
+        ["L\x02\x01",                   "76:2:01",              nil],
+        ["M",                           "238:1:4d",            true],
+        ["M\xff\xff\x01",               "238:4:4dffff01",      true],
+        ["N",                           "238:1:4e",            true],
+        ["N\xff\xff\xff\xff\x01",       "238:6:4effffffff01",  true],
+      ].each{|payload,string,parse_invalid|
+        Script.new(payload).to_string.should == string
+        Script.new(payload).instance_eval{ @parse_invalid }.should == parse_invalid
+        Script.from_string(string).to_payload == payload
+      }
+
+      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"
+
+      # found in testnet3 block 0000000000ac85bb2530a05a4214a387e6be02b22d3348abc5e7a5d9c4ce8dab transactions
+      Script.new("\xff\xff\xff\xff").to_string.should == "(opcode-255) (opcode-255) (opcode-255) (opcode-255)"
+      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.from_string(Script.new("\xff\xff\xff").to_string).raw.should == "\xFF\xFF\xFF"
     end
 
     it 'Script#binary_from_string' do
@@ -45,8 +107,8 @@ describe 'Bitcoin::Script' do
 
       Script.from_string("0 OP_DROP 2 3 4").to_string.should == "0 OP_DROP 2 3 4"
 
-      Script.from_string("OP_EVAL").to_string.should == "OP_EVAL"
-      Script.from_string("OP_NOP1").to_string.should == "OP_EVAL" # test opcodes_alias table
+      Script.from_string("OP_EVAL").to_string.should == "OP_NOP1"
+      Script.from_string("OP_NOP1").to_string.should == "OP_NOP1" # test opcodes_alias table
       Script.from_string("OP_NOP").to_string.should == "OP_NOP"
       Script.from_string("1").to_string.should == "1"
 
@@ -56,6 +118,9 @@ describe 'Bitcoin::Script' do
         Bitcoin::Script.binary_from_string(script) == Bitcoin::Script.binary_from_string( Bitcoin::Script.from_string(script).to_string )
       }.should == true
 
+      #Script.from_string("-100").to_string.should == "OP_NOP"
+      #Script.from_string("100").to_string.should == "100"
+
       proc{ Script.from_string("OP_NOP OP_UNKOWN") }.should.raise(Script::ScriptOpcodeError).message.should == "OP_UNKOWN not defined!"
     end
   end
@@ -101,6 +166,10 @@ describe 'Bitcoin::Script' do
         "1B6k6g1d2L975i7beAbiBRxfBWhxomPxvy"]
       Script.new(SCRIPT[4]).get_multisig_addresses.should == [
         "1F2Nnyn7niMcheiYhkHrkc18aDxEkFowy5", "1EE7JGimkV7QqyHwXDJvk3b1yEN4ZUWeqx"]
+
+      # from tx 274f8be3b7b9b1a220285f5f71f61e2691dd04df9d69bb02a8b3b85f91fb1857, second pubkey has invalid encoding.
+      output = "1 0351efb6e91a31221652105d032a2508275f374cea63939ad72f1b1e02f477da78 00f2b7816db49d55d24df7bdffdbc1e203b424e8cd39f5651ab938e5e4a193569e 2 OP_CHECKMULTISIG"
+      Bitcoin::Script.from_string(output).get_multisig_addresses.should == ["1NdB761LmTmrJixxp93nz7pEiCx5cKPW44"]
     end
 
     it "#get_address" do
@@ -109,9 +178,9 @@ describe 'Bitcoin::Script' do
       Script.new(SCRIPT[1]).get_address.should == nil
       Script.new(SCRIPT[2]).get_address.should ==
         "139k1g5rtTsL4aGZbcASH3Fv3fUh9yBEdW"
-      Script.new(SCRIPT[3]).get_address.should == 
+      Script.new(SCRIPT[3]).get_address.should ==
         "1JiaVc3N3U3CwwcLtzNX1Q4eYfeYxVjtuj"
-      Script.new(SCRIPT[4]).get_address.should == 
+      Script.new(SCRIPT[4]).get_address.should ==
         "1F2Nnyn7niMcheiYhkHrkc18aDxEkFowy5"
     end
 
@@ -198,7 +267,7 @@ describe 'Bitcoin::Script' do
     it "should generate p2sh script" do
       address = "3CkxTG25waxsmd13FFgRChPuGYba3ar36B"
       hash160 = Bitcoin.hash160_from_address address
-      Script.to_p2sh_script(hash160).should == 
+      Script.to_p2sh_script(hash160).should ==
         Script.from_string("OP_HASH160 #{hash160} OP_EQUAL").raw
     end
 
@@ -210,21 +279,38 @@ describe 'Bitcoin::Script' do
 
       address = "3CkxTG25waxsmd13FFgRChPuGYba3ar36B"
       hash160 = Bitcoin.hash160_from_address address
-      Script.to_p2sh_script(hash160).should == 
+      Script.to_p2sh_script(hash160).should ==
         Script.from_string("OP_HASH160 #{hash160} OP_EQUAL").raw
     end
 
   end
 
   describe "generate script sigs" do
+    before do
+      @sig = '3045022062437a8f60651cd968137355775fa8bdb83d4ca717fdbc08bf9868a051e0542f022100f5cd626c15ef0de0803ddf299e8895743e7ff484d6335874edfe086ee0a08fec'.htb
+    end
 
     it "should generate pubkey script sig" do
-      sig = ["3045022062437a8f60651cd968137355775fa8bdb83d4ca717fdbc08bf9868a051e0542f022100f5cd626c15ef0de0803ddf299e8895743e7ff484d6335874edfe086ee0a08fec"].pack("H*")
-      pub = ["04bc3e2b520d4be3e2651f2ba554392ea31edd69d2081186ab98acda3c4bf45e41a5f6e093277b774b5893347e38ffafce2b9e82226e6e0b378cf79b8c2eed983c"].pack("H*")
-      Script.to_pubkey_script_sig(sig, pub)
-        .should == ["483045022062437a8f60651cd968137355775fa8bdb83d4ca717fdbc08bf9868a051e0542f022100f5cd626c15ef0de0803ddf299e8895743e7ff484d6335874edfe086ee0a08fec014104bc3e2b520d4be3e2651f2ba554392ea31edd69d2081186ab98acda3c4bf45e41a5f6e093277b774b5893347e38ffafce2b9e82226e6e0b378cf79b8c2eed983c"].pack("H*")
+      pub = '04bc3e2b520d4be3e2651f2ba554392ea31edd69d2081186ab98acda3c4bf45e41a5f6e093277b774b5893347e38ffafce2b9e82226e6e0b378cf79b8c2eed983c'.htb
+      expected_script = '483045022062437a8f60651cd968137355775fa8bdb83d4ca717fdbc08bf9868a051e0542f022100f5cd626c15ef0de0803ddf299e8895743e7ff484d6335874edfe086ee0a08fec014104bc3e2b520d4be3e2651f2ba554392ea31edd69d2081186ab98acda3c4bf45e41a5f6e093277b774b5893347e38ffafce2b9e82226e6e0b378cf79b8c2eed983c'.htb
+
+      Script.to_pubkey_script_sig(@sig, pub).should == expected_script
     end
 
+    it "should accept a compressed public key as input" do
+      pub = '02bc3e2b520d4be3e2651f2ba554392ea31edd69d2081186ab98acda3c4bf45e41'.htb
+      expected_script = '483045022062437a8f60651cd968137355775fa8bdb83d4ca717fdbc08bf9868a051e0542f022100f5cd626c15ef0de0803ddf299e8895743e7ff484d6335874edfe086ee0a08fec012102bc3e2b520d4be3e2651f2ba554392ea31edd69d2081186ab98acda3c4bf45e41'.htb
+
+      Script.to_pubkey_script_sig(@sig, pub).should == expected_script
+    end
+    it "should reject an improperly encoding public key" do
+      # Not binary encoded, like it's supposed to be.
+      pub = '02bc3e2b520d4be3e2651f2ba554392ea31edd69d2081186ab98acda3c4bf45e41'
+
+      lambda {
+        Script.to_pubkey_script_sig(@sig, pub)
+      }.should.raise
+    end
   end
 
   it '#run' do
@@ -241,6 +327,19 @@ describe 'Bitcoin::Script' do
       .run.should == false
 
     Script.from_string("1 OP_DROP 2").run.should == true
+
+    # 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.run.should == true
+
+    # mainnet tx: 61a078472543e9de9247446076320499c108b52307d8d0fafbe53b5c4e32acc4 redeeming output from 5342c96b946ea2c5e497de5dbf7762021f94aba2c8222c17ed28492fdbb4a6d9
+    script = Bitcoin::Script.from_string("16cfb9bc7654ef1d7723e5c2722fc0c3d505045e OP_SIZE OP_DUP 1 OP_GREATERTHAN OP_VERIFY OP_NEGATE OP_HASH256 OP_HASH160 OP_SHA256 OP_SHA1 OP_RIPEMD160 OP_EQUAL")
+    script.run.should == true
+
+    # mainnet tx: 340aa9f72206d600b7e89c9137e4d2d77a920723f83e34707ff452121fd48492 redeeming output from f2d72a7bf22e29e3f2dc721afbf0a922860f81db9fc7eb397937f9d7e87cc438
+    script = Bitcoin::Script.from_string("027ce87f6f41dd4d7d874b40889f7df6b288f77f OP_DEPTH OP_HASH256 OP_HASH160 OP_SHA256 OP_SHA1 OP_RIPEMD160 OP_EQUAL")
+    script.run.should == true
   end
 
 end

data/spec/bitcoin/spec_helper.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 $: << File.expand_path(File.join(File.dirname(__FILE__), '/../../lib'))
 
 begin
@@ -23,8 +25,74 @@ def fixtures_file(relative_path)
   Bitcoin::Protocol.read_binary_file( File.join(basedir, relative_path) )
 end
 
+include Bitcoin::Builder
+
+# create block for given +prev+ block
+# if +store+ is true, save it to @store
+# accepts an array of +tx+ callbacks
+def create_block prev, store = true, tx = [], key = Bitcoin::Key.new, coinbase_value = 50e8, opts = {}
+  opts[:bits] ||= Bitcoin.network[:proof_of_work_limit]
+  block = build_block(Bitcoin.decode_compact_bits(opts[:bits])) do |b|
+    b.time opts[:time]  if opts[:time]
+    b.prev_block prev
+    b.tx do |t|
+      t.input {|i| i.coinbase }
+      t.output {|o| o.value coinbase_value; o.script {|s| s.recipient key.addr } }
+    end
+    tx.each {|cb| b.tx {|t| cb.call(t) } }
+  end
+  @store.store_block(block)  if store
+  block
+end
+
+# create transaction given builder +tx+
+# +outputs+ is an array of [value, key] pairs
+def create_tx(tx, prev_tx, prev_out_index, outputs)
+  tx.input {|i| i.prev_out prev_tx; i.prev_out_index prev_out_index; i.signature_key @key }
+  outputs.each do |value, key|
+    tx.output {|o| o.value value; o.script {|s| s.recipient key.addr } }
+  end
+end
+
+# create a chain of +n+ blocks, based on +prev_hash+ block.
+# influence chain properties via options:
+#  time: start time all other times are based on
+#  interval: time between blocks
+#  bits: target bits each block must match
+def create_blocks prev_hash, n, opts = {}
+  interval = opts[:interval] || 600
+  time = opts[:time] || Time.now.to_i
+  bits = opts[:bits] || 553713663
+  block = @store.get_block(prev_hash)
+  n.times do |i|
+    block = create_block block.hash, true, [], @key, 50e8, {
+      time: time += interval, bits: bits }
+    # block = @store.get_block(block.hash)
+    # puts "#{i} #{block.hash[0..8]} #{block.prev_block.reverse_hth[0..8]} #{Time.at(block.time).strftime('%Y-%m-%d %H:%M:%S')} c: #{block.chain} b: #{block.bits} n: #{block.nonce} w: #{block.work}"
+  end
+  block
+end
+
+
 Bitcoin::network = :bitcoin
 
+Bitcoin::NETWORKS[:spec] = {
+  :project => :bitcoin,
+  :magic_head => "spec",
+  :address_version => "6f",
+  :p2sh_version => "c4",
+  :privkey_version => "ef",
+  :default_port => 48333,
+  :protocol_version => 70001,
+  :max_money => 21_000_000 * 100_000_000,
+  :dns_seeds => [],
+  :genesis_hash => "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943",
+  :proof_of_work_limit => 553713663,
+  :alert_pubkeys => [],
+  :known_nodes => [],
+  :checkpoints => {}
+}
+
 begin
   require 'bacon'
 rescue LoadError

data/spec/bitcoin/storage/reorg_spec.rb

@@ -0,0 +1,199 @@
+# encoding: ascii-8bit
+
+require_relative '../spec_helper'
+
+include Bitcoin::Builder
+
+
+
+[ { :name => :utxo, :db => 'sqlite:/', :index_all_addrs => true },
+  { :name => :sequel, :db => 'sqlite:/' } ] .each do |configuration|
+
+  describe "reorg (#{configuration[:name].capitalize}Store)" do
+
+  def balance addr
+    @store.get_balance(Bitcoin.hash160_from_address(addr))
+  end
+
+  before do
+    Bitcoin.network = :testnet
+    @store = Bitcoin::Storage.send(configuration[:name], configuration)
+    @store.reset
+    def @store.in_sync?; true; end
+    @store.log.level = :warn
+    Bitcoin.network[:proof_of_work_limit] = Bitcoin.encode_compact_bits("ff"*32)
+    @key = Bitcoin::Key.generate
+    @block0 = create_block "00"*32, false, [], @key
+    Bitcoin.network[:genesis_hash] = @block0.hash
+    @store.store_block(@block0)
+    @store.get_head.should == @block0
+  end
+
+  it "should retarget" do
+    @store.reset
+    time = Time.now.to_i - 3000*600
+
+    Bitcoin::Validation::Block::RETARGET = 10
+
+    # create genesis block
+    block = create_block "00"*32, false, [], @key, 50e8, {time: time}
+    Bitcoin.network[:genesis_hash] = block.hash
+    @store.store_block(block)
+    time += 600
+
+    # create too fast blocks
+    block = create_blocks block.hash, 9, time: time, interval: 10
+    time += 90
+
+    -> { create_blocks block.hash, 1, time: time }
+      .should.raise(Bitcoin::Validation::ValidationError).message.should =~ /difficulty/
+
+    block = create_blocks block.hash, 1, time: time, bits: bits = 541065152
+    @store.get_head.should == block
+    time += 600
+
+    # create too slow blocks
+    block = create_blocks block.hash, 9, time: time, interval: 6000, bits: bits
+    time += 8*6000
+    -> { create_blocks block.hash, 1, time: time, bits: bits }
+      .should.raise(Bitcoin::Validation::ValidationError).message.should =~ /difficulty/
+
+    block = create_blocks block.hash, 1, bits: 553713663
+    @store.get_head.should == block
+  end
+
+  it "should reorg across a retargetting boundary correctly" do
+    @store.reset
+    time = Time.now.to_i - 3000*600
+
+    # create genesis block
+    block = create_block "00"*32, false, [], @key, 50e8, {time: time}
+    time += 600
+    Bitcoin.network[:genesis_hash] = block.hash
+    @store.store_block(block)
+
+    # create first regular block
+    split_block = create_blocks block.hash, 1, time: time
+    split_time = time + 600
+
+    # create branch A with target interval
+    block_a = create_blocks split_block.hash, 8, time: split_time
+    time_a = split_time + 8 * 600
+
+    # create branch B with faster-than-target interval
+    block_b = create_blocks split_block.hash, 8, time: split_time, interval: 60
+    time_b = split_time + 8 * 60
+
+    # create 2 blocks for branch A with regular difficulty
+    block_a = create_blocks block_a.hash, 2, time: time_a
+
+    # create 1 block for branch B at higher difficulty
+    block_b = create_blocks block_b.hash, 1, time: time_b, bits: 541568460
+
+    # check that shorter branch B has overtaken longer branch A due to more work
+    @store.get_head.hash.should == block_b.hash
+  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
+    next(true.should == true)  if @store.class.name =~ /Utxo/
+    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) }
+    blocks[1..-1].each.with_index {|b, idx| @store.store_block(b).should == [idx+1, 0] }
+    3.times {|i| @store.store_block(blocks[i]).should == [i] }
+    @store.get_head.should == blocks[-1]
+  end
+
+  # see https://bitcointalk.org/index.php?topic=46370.0
+  it "should pass reorg unit tests" do
+    class Bitcoin::Validation::Block; def difficulty; true; end; end
+    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
+    class Bitcoin::Validation::Block
+      def difficulty
+        return true  if Bitcoin.network_name == :testnet3
+        block.bits == next_bits_required || [block.bits, next_bits_required]
+      end
+    end
+  end
+
+end
+end