bitcoin-ruby 0.0.18 → 0.0.19

data/spec/bitcoin/bloom_filter_spec.rb

@@ -1,23 +0,0 @@
-require_relative 'spec_helper.rb'
-
-#
-# following test cases are borrowed from
-# https://github.com/bitcoinj/bitcoinj/blob/master/core/src/test/java/org/bitcoinj/core/BloomFilterTest.java
-#
-describe 'Bloom Filter' do
-  before do
-    @filter = Bitcoin::BloomFilter.new(3, 0.01, 2147483649)
-
-    @filter.add_data('99108ad8ed9bb6274d3980bab5a85c048f0950c8'.htb)
-    @filter.add_data('b5a2c786d9ef4658287ced5914b37a1b4aa32eee'.htb)
-    @filter.add_data('b9300670b4c5366e95b2699e8b18bc75e5f729c5'.htb)
-  end
-  it "#contains?" do
-    @filter.contains?('99108ad8ed9bb6274d3980bab5a85c048f0950c8'.htb).should == true
-    @filter.contains?('19108ad8ed9bb6274d3980bab5a85c048f0950c8'.htb).should == false
-    @filter.contains?('b5a2c786d9ef4658287ced5914b37a1b4aa32eee'.htb).should == true
-  end
-  it "#filter" do
-    @filter.filter.bth.should == 'ce4299'
-  end
-end

data/spec/bitcoin/builder_spec.rb

@@ -1,375 +0,0 @@
-# encoding: ascii-8bit
-
-require_relative 'spec_helper'
-
-include Bitcoin::Builder
-
-describe "Bitcoin::Builder" do
-
-  before do
-    Bitcoin.network = :spec
-    @keys = 5.times.map { Bitcoin::Key.generate }
-    @target = target = "00".ljust(64, 'f')
-    @genesis = create_block("00"*32, false)
-    @block = create_block(@genesis.hash, false, [], @keys[0])
-  end
-
-  it "should build blocks" do
-    block = build_block(@target) do |b|
-      b.prev_block @block.hash
-
-      b.tx do |t|
-        t.input {|i| i.coinbase "foobar" }
-
-        t.output do |o|
-          o.value 5000000000
-
-          o.script do |s|
-            s.type :address
-            s.recipient @keys[0].addr
-          end
-        end
-      end
-    end
-
-    block.hash[0..1].should == "00"
-    block.ver.should == 1
-    block.prev_block.should == @block.binary_hash.reverse
-    block.tx.size.should == 1
-    tx = block.tx[0]
-    tx.in.size.should == 1
-    tx.out.size.should == 1
-    tx.in[0].script_sig.should == ["foobar"].pack("H*")
-
-    tx.out[0].value.should == 5000000000
-  end
-
-  it "should build transactions with in/outputs and signatures" do
-    tx = build_tx do |t|
-      t.input do |i|
-        i.prev_out @block.tx[0]
-        i.prev_out_index 0
-        i.signature_key @keys[0]
-      end
-
-      t.output do |o|
-        o.value 123
-
-        o.script do |s|
-          s.type :address
-          s.recipient @keys[1].addr
-        end
-      end
-    end
-
-    tx.in[0].prev_out.reverse_hth.should == block.tx[0].hash
-    tx.in[0].prev_out_index.should == 0
-    Bitcoin::Script.new(tx.in[0].script_sig).chunks[1].unpack("H*")[0].should == @keys[0].pub
-
-    tx.out[0].value.should == 123
-    script = Bitcoin::Script.new(tx.out[0].pk_script)
-    script.type.should == :hash160
-    script.get_address.should == @keys[1].addr
-
-    tx.verify_input_signature(0, block.tx[0]).should == true
-
-
-    # check shortcuts also work
-    tx2 = build_tx do |t|
-      t.input {|i| i.prev_out @block.tx[0], 0; i.signature_key @keys[0] }
-      t.output {|o| o.value 123; o.script {|s| s.recipient @keys[1].addr } }
-      t.output {|o| o.to @keys[1].addr; o.value 321 }
-      t.output {|o| o.to "deadbeef", :op_return }
-    end
-    tx2.in[0].prev_out.should == tx.in[0].prev_out
-    tx2.in[0].prev_out_index.should == tx.in[0].prev_out_index
-    tx2.out[0].value.should == tx.out[0].value
-    tx2.out[0].pk_script.should == tx.out[0].pk_script
-    Bitcoin::Script.new(tx2.out[0].pk_script).to_string.should ==
-      "OP_DUP OP_HASH160 #{@keys[1].hash160} OP_EQUALVERIFY OP_CHECKSIG"
-    Bitcoin::Script.new(tx2.out[0].pk_script).to_string.should ==
-      "OP_DUP OP_HASH160 #{@keys[1].hash160} OP_EQUALVERIFY OP_CHECKSIG"
-    tx2.out[2].value.should == 0
-  end
-
-  it "should build transactions with p2wpkh signatures" do
-    key = Bitcoin::Key.new('619c335025c7f4012e556c2a58b2506e30b8511b53ade95ea316fd8c3286feb9')
-    script_pubkey = '00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1'.htb
-    tx = build_tx do |t|
-      t.input do |i|
-        i.prev_out '8ac60eb9575db5b2d987e29f301b5b819ea83a5c6579d282d189cc04b8e151ef', 1, script_pubkey, 600000000
-        i.signature_key key
-      end
-    end
-    tx.verify_witness_input_signature(0, script_pubkey, 600000000).should == true
-  end
-
-  it "should allow txin.prev_out as tx or hash" do
-    prev_tx = @block.tx[0]
-    tx1 = build_tx do |t|
-      t.input {|i| i.prev_out prev_tx, 0 }
-    end
-    tx2 = build_tx do |t|
-      t.input {|i| i.prev_out prev_tx.hash, 0, prev_tx.out[0].pk_script }
-    end
-    tx1.in[0].should == tx2.in[0]
-  end
-
-  it "should provide tx#output shortcut" do
-    tx1 = build_tx {|t| t.output(123, @keys[1].addr) }
-    tx1.should == build_tx do |t|
-      t.output {|o| o.value 123; o.to @keys[1].addr }
-    end
-
-    tx2 = build_tx {|t| t.output(123, @keys[1].pub, :pubkey) }
-    tx2.should == build_tx do |t|
-      t.output {|o| o.value 123; o.to @keys[1].pub, :pubkey }
-    end
-  end
-
-  it "should provide txout#to shortcut" do
-    tx1 = build_tx do |t|
-      t.output {|o| o.value 123; o.to @keys[1].addr }
-    end
-    tx2 = build_tx do |t|
-      t.output {|o| o.value 123
-        o.script {|s| s.recipient @keys[1].addr } }
-    end
-    tx1.out[0].should == tx2.out[0]
-  end
-
-  it "should build unsigned transactions and add the signature hash" do
-    tx = build_tx do |t|
-      t.input do |i|
-        i.prev_out @block.tx[0]
-        i.prev_out_index 0
-        # no signature key
-      end
-      t.output do |o|
-        o.value 123
-        o.script {|s| s.recipient @keys[1].addr }
-      end
-    end
-
-    tx.is_a?(Bitcoin::P::Tx).should == true
-    tx.in[0].sig_hash.should != nil
-  end
-
-  it "should build unsigned multisig transactions and add the signature hash" do
-    tx1 = build_tx do |t|
-      t.input {|i| i.prev_out(@block.tx[0], 0); i.signature_key(@keys[0]) }
-      t.output do |o|
-        o.value 123
-        o.to [2, *@keys[0..2].map(&:pub)], :multisig
-      end
-    end
-
-    tx2 = build_tx do |t|
-      t.input do |i|
-        i.prev_out tx1, 0
-        i.signature_key @keys[0]
-      end
-      t.output {|o| o.value 123; o.to @keys[0].addr }
-    end
-
-    tx2.is_a?(Bitcoin::P::Tx).should == true
-    tx2.in[0].sig_hash.should != nil
-  end
-
-  it "should build unsigned p2sh multisig transactions and add the signature hash" do
-    tx1 = build_tx do |t|
-      t.input {|i| i.prev_out(@block.tx[0], 0); i.signature_key(@keys[0]) }
-      t.output do |o|
-        o.value 123
-        o.to [2, *@keys[0..2].map(&:pub)], :p2sh_multisig
-      end
-    end
-
-    tx2 = build_tx do |t|
-      t.input do |i|
-        i.prev_out tx1, 0
-        i.signature_key @keys[0]
-        i.redeem_script tx1.out[0].redeem_script
-      end
-      t.output {|o| o.value 123; o.to @keys[0].addr }
-    end
-
-    tx2.is_a?(Bitcoin::P::Tx).should == true
-    tx2.in[0].sig_hash.should != nil
-  end
-
-  it "should add change output" do
-    change_address = Bitcoin::Key.generate.addr
-    tx = build_tx(input_value: @block.tx[0].out.map(&:value).inject(:+),
-                  change_address: change_address) do |t|
-      t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @keys[0] }
-      t.output {|o| o.value 12345; o.script {|s| s.recipient @keys[1].addr } }
-    end
-    tx.out.count.should == 2
-    tx.out.last.value.should == 50e8 - 12345
-    Bitcoin::Script.new(tx.out.last.pk_script).get_address.should == change_address
-  end
-
-  it "should add change output and leave fee" do
-    change_address = Bitcoin::Key.generate.addr
-    tx = build_tx(input_value: @block.tx[0].out.map(&:value).inject(:+),
-                  change_address: change_address, leave_fee: true) do |t|
-      t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @keys[0] }
-      t.output {|o| o.value 12345; o.script {|s| s.recipient @keys[1].addr } }
-    end
-    tx.out.count.should == 2
-    tx.out.last.value.should == 50e8 - 12345 - Bitcoin.network[:min_tx_fee]
-    Bitcoin::Script.new(tx.out.last.pk_script).get_address.should == change_address
-
-    tx = build_tx(input_value: @block.tx[0].out.map(&:value).inject(:+),
-                  change_address: change_address, leave_fee: true) do |t|
-      t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @keys[0] }
-      49.times { t.output {|o| o.value 1e8; o.script {|s| s.recipient @keys[1].addr } } }
-      t.output {|o| o.value(1e8 - 10000); o.script {|s| s.recipient @keys[1].addr } }
-    end
-    tx.out.size.should == 50
-    tx.out.map(&:value).inject(:+).should == 50e8 - 10000
-  end
-
-  it "randomize_outputs should not modify output values or fees" do
-    change_address = Bitcoin::Key.generate.addr
-    tx = build_tx(input_value: @block.tx[0].out.map(&:value).inject(:+),
-                  change_address: change_address, leave_fee: true) do |t|
-      t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @keys[0] }
-      t.output {|o| o.value 12345; o.script {|s| s.recipient @keys[1].addr } }
-      t.randomize_outputs
-    end
-
-    tx.out.count.should == 2
-    tx.out.last.value.should == 50e8 - 12345 - Bitcoin.network[:min_tx_fee]
-    Bitcoin::Script.new(tx.out.last.pk_script).get_address.should == change_address
-
-    tx = build_tx(input_value: @block.tx[0].out.map(&:value).inject(:+),
-                  change_address: change_address, leave_fee: true) do |t|
-      t.input {|i| i.prev_out @block.tx[0]; i.prev_out_index 0; i.signature_key @keys[0] }
-      49.times { t.output {|o| o.value 1e8; o.script {|s| s.recipient @keys[1].addr } } }
-      t.output {|o| o.value(1e8 - 10000); o.script {|s| s.recipient @keys[1].addr } }
-      t.randomize_outputs
-    end
-    tx.out.size.should == 50
-    tx.out.map(&:value).inject(:+).should == 50e8 - 10000
-  end
-
-  it "should build op_return output" do
-    builder = TxOutBuilder.new
-    builder.to "deadbeef", :op_return
-    builder.txout.parsed_script.to_string.should == "OP_RETURN deadbeef"
-  end
-
-  it "should build op_return script" do
-    s = script {|s| s.type :op_return; s.recipient "deadbeef" }
-    Bitcoin::Script.new(s).to_string.should == "OP_RETURN deadbeef"
-  end
-
-  it "should build address script" do
-    key = Bitcoin::Key.generate
-    s = script {|s| s.type :address; s.recipient key.addr }
-    Bitcoin::Script.new(s).to_string.should ==
-      "OP_DUP OP_HASH160 #{Bitcoin.hash160_from_address(key.addr)} OP_EQUALVERIFY OP_CHECKSIG"
-  end
-
-  it "should build pubkey script" do
-    key = Bitcoin::Key.generate
-    s = script {|s| s.type :pubkey; s.recipient key.pub }
-    Bitcoin::Script.new(s).to_string.should == "#{key.pub} OP_CHECKSIG"
-  end
-
-  it "should build multisig script" do
-    keys = 3.times.map { Bitcoin::Key.generate }
-    s = script {|s| s.type :multisig; s.recipient 1, keys[0].pub, keys[1].pub }
-    Bitcoin::Script.new(s).to_string.should == "1 #{keys[0].pub} #{keys[1].pub} 2 OP_CHECKMULTISIG"
-  end
-
-  it "should build and spend multisig output" do
-    tx1 = build_tx do |t|
-      t.input {|i| i.prev_out(@block.tx[0], 0); i.signature_key(@keys[0]) }
-      t.output do |o|
-        o.value 123
-        o.to [2, *@keys[0..2].map(&:pub)], :multisig
-      end
-    end
-
-    Bitcoin::Script.new(tx1.out[0].pk_script).to_string.should ==
-      "2 #{@keys[0..2].map(&:pub).join(' ')} 3 OP_CHECKMULTISIG"
-
-    tx2 = build_tx do |t|
-      t.input do |i|
-        i.prev_out tx1, 0
-        i.signature_key @keys[0..1]
-      end
-      t.output {|o| o.value 123; o.to @keys[0].addr }
-    end
-
-    tx2.verify_input_signature(0, tx1).should == true
-  end
-
-  it "should build and spend p2sh multisig output" do
-    tx1 = build_tx do |t|
-      t.input {|i| i.prev_out(@block.tx[0], 0); i.signature_key(@keys[0]) }
-      t.output do |o|
-        o.value 123
-        o.to [2, *@keys[0..2].map(&:pub)], :p2sh_multisig
-      end
-    end
-
-    Bitcoin::Script.new(tx1.out[0].pk_script).to_string.should ==
-      "OP_HASH160 #{Bitcoin.hash160(tx1.out[0].redeem_script.hth)} OP_EQUAL"
-
-    tx2 = build_tx do |t|
-      t.input do |i|
-        i.prev_out tx1, 0
-        # provide 2 required keys for signing
-        i.signature_key @keys[0..1]
-        # provide the redeem script from the previous output
-        i.redeem_script tx1.out[0].redeem_script
-      end
-
-      t.output {|o| o.value 123; o.to @keys[0].addr }
-    end
-
-    script = Bitcoin::Script.new(tx2.in[0].script_sig, tx1.out[0].pk_script)
-    # check script execution is valid
-    script.run { true }.should == true
-    # check signatures are valid
-    tx2.verify_input_signature(0, tx1).should == true
-  end
-
-  it "should build and sign bcash transaction" do
-    tx = build_tx do |t|
-      t.input do |i|
-        prev_tx = @block.tx[0]
-        utxo = prev_tx.out[0]
-        i.prev_out prev_tx.hash, 0, utxo.script, utxo.amount, 0
-        i.signature_key @keys[0]
-      end
-
-      t.output do |o|
-        o.value 4999900000
-
-        o.script do |s|
-          s.type :address
-          s.recipient @keys[1].addr
-        end
-      end
-    end
-
-    tx.in[0].prev_out.reverse_hth.should == block.tx[0].hash
-    tx.in[0].prev_out_index.should == 0
-    Bitcoin::Script.new(tx.in[0].script_sig).chunks[1].unpack("H*")[0].should == @keys[0].pub
-    tx.out[0].value.should == 4999900000
-
-    script = Bitcoin::Script.new(tx.out[0].pk_script)
-    script.type.should == :hash160
-    script.get_address.should == @keys[1].addr
-
-    tx.verify_input_signature(0, block.tx[0], Time.now.to_i, {fork_id: 0}).should == true
-    Bitcoin::Script.new(tx.out[0].pk_script).to_string.should ==
-      "OP_DUP OP_HASH160 #{@keys[1].hash160} OP_EQUALVERIFY OP_CHECKSIG"
-  end
-
-end

data/spec/bitcoin/contracthash_spec.rb

@@ -1,45 +0,0 @@
-# encoding: ascii-8bit
-
-require_relative 'spec_helper.rb'
-
-# https://github.com/aalness/contracthashtool-ruby
-# ruby port of https://github.com/Blockstream/contracthashtool
-
-describe 'Bitcoin::ContractHash' do
-  it 'should generate and claim' do
-    Bitcoin::network = :testnet3
-
-    # Example parameters from the original tool's usage().
-
-    redeem_script_template = '5121038695b28f1649c711aedb1fec8df54874334cfb7ddf31ba3132a94d00bdc9715251ae'
-    payee_address = 'mqWkEAFeQdrQvyaWNRn5vijPJeiQAjtxL2'
-    nonce_hex = '3a11be476485a6273fad4a0e09117d42'
-    private_key_wif = 'cMcpaCT6pHkyS4347i4rSmecaQtLiu1eH28NWmBiePn8bi6N4kzh'
-
-    # Someone wanting to send funds to the sidechain would call this
-    # to calculate a P2SH address to send to. They would then send the
-    # MDFs (mutually distrusting functionaries) the target address
-    # and nonce so they are able to locate the subsequent transaction.
-    # The caller would then send the desired amount of coin to the P2SH
-    # address to initiate the peg protocol.
-
-    nonce, redeem_script, p2sh_address = Bitcoin::ContractHash.generate(redeem_script_template, payee_address, nonce_hex)
-
-    nonce.should == "3a11be476485a6273fad4a0e09117d42"
-    p2sh_address.should == "2MvGPFfDXbJZyH79u187VNZbuCgyRBhcdsw"
-    redeem_script.should == "512102944aba05d40d8df1724f8ab2f5f3a58d052d26aedc93e175534cb782becc8ff751ae"
-
-    # Each MDF would call this to derive a private key to redeem the
-    # locked transaction.
-
-    key = Bitcoin::ContractHash.claim(private_key_wif, payee_address, nonce)
-    key.to_base58.should == "cSBD8yM62R82RfbugiGK8Lui9gdMB81NtZBckxe5YxRsDSKySwHK"
-
-    # Verify homomorphic derivation was successful.
-
-    signature = key.sign_message(message="derp")
-    script = Bitcoin::Script.new([redeem_script].pack("H*"))
-    pubkey = Bitcoin::Key.new(nil, script.get_multisig_pubkeys.first.unpack("H*").first)
-    pubkey.verify_message(signature, message).should == true
-  end
-end

data/spec/bitcoin/dogecoin_spec.rb

@@ -1,176 +0,0 @@
-# encoding: ascii-8bit
-
-require_relative 'spec_helper.rb'
-require 'bitcoin/script'
-
-include Bitcoin
-include Bitcoin::Builder
-
-describe 'Bitcoin::Dogecoin' do
-  it 'validate dogecoin-address' do
-
-    Bitcoin::network = :dogecoin_testnet
-
-    # Testnet address
-    Bitcoin.valid_address?("nUtMFED5VRg5xuj9QCrNFt9mVPFDXo7TTE").should == true
-    # Livenet address
-    Bitcoin.valid_address?("DSpgzjPyfQB6ZzeSbMWpaZiTTxGf2oBCs4").should == false
-    # Broken address
-    Bitcoin.valid_address?("DRjyUS2uuieEPkhZNdQz8hE5YycxVEqSXA").should == false
-
-    Bitcoin::network = :dogecoin
-
-    # Testnet address
-    Bitcoin.valid_address?("nUtMFED5VRg5xuj9QCrNFt9mVPFDXo7TTE").should == false
-    # Livenet address
-    Bitcoin.valid_address?("DSpgzjPyfQB6ZzeSbMWpaZiTTxGf2oBCs4").should == true
-    # Broken address
-    Bitcoin.valid_address?("DRjyUS2uuieEPkhZNdQz8hE5YycxVEqSXA").should == false
-  end
-
-  it 'should calculate retarget difficulty' do
-    Bitcoin::network = :dogecoin
-
-    prev_height = 239
-    prev_block_time = 1386475638 # Block 239
-    prev_block_bits = 0x1e0ffff0
-    last_retarget_time = 1386474927 # Block 1
-    new_difficulty = Bitcoin.block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
-    new_difficulty.to_s(16).should == 0x1e00ffff.to_s(16)
-
-    prev_height = 479
-    prev_block_time = 1386475840
-    prev_block_bits = 0x1e0fffff
-    last_retarget_time = 1386475638 # Block 239
-    new_difficulty = Bitcoin.block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
-    new_difficulty.to_s(16).should == 0x1e00ffff.to_s(16)
-
-    prev_height = 9_599
-    prev_block_time = 1386954113
-    prev_block_bits = 0x1c1a1206
-    last_retarget_time = 1386942008 # Block 9359
-    new_difficulty = Bitcoin.block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
-    new_difficulty.to_s(16).should == 0x1c15ea59.to_s(16)
-
-    # First hard-fork at 145,000, which applies to block 145,001 onwards
-    prev_height = 145_000
-    prev_block_time = 1395094679
-    prev_block_bits = 0x1b499dfd
-    last_retarget_time = 1395094427
-    new_difficulty = Bitcoin.block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
-    new_difficulty.to_s(16).should == 0x1b671062.to_s(16)
-
-    # Test case for correct rounding of modulated time - by default C++ and Ruby do not
-    # necessarily round identically
-    prev_height = 145_001
-    prev_block_time = 1395094727
-    prev_block_bits = 0x1b671062
-    last_retarget_time = 1395094679
-    new_difficulty = Bitcoin.block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
-    new_difficulty.to_s(16).should == 0x1b6558a4.to_s(16)
-
-    # Test the second hard-fork at 371,337 as well
-    prev_height = 371336
-    prev_block_time = 1410464569
-    prev_block_bits = 0x1b2fdf75
-    last_retarget_time = 1410464445
-    new_difficulty = Bitcoin.block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
-    new_difficulty.to_s(16).should == 0x1b364184.to_s(16)
-
-    prev_height = 408_596
-    prev_block_time = 1412800112
-    prev_block_bits = 0x1b033d8b
-    last_retarget_time = 1412799989 # Block 408,595
-    new_difficulty = Bitcoin.block_new_target(prev_height, prev_block_time, prev_block_bits, last_retarget_time)
-    new_difficulty.to_s(16).should == 0x1b039e52.to_s(16)
-  end
-
-  it 'should calculate reward upper bounds' do
-    Bitcoin::network = :dogecoin
-
-    Bitcoin.block_creation_reward(99000).should == 1000000 * COIN # Note this is the maximum possible, not actual reward
-    Bitcoin.block_creation_reward(144999).should == 500000 * COIN
-    Bitcoin.block_creation_reward(145000).should == 250000 * COIN # Hard-forked to remove random rewards
-    Bitcoin.block_creation_reward(199999).should == 250000 * COIN
-    Bitcoin.block_creation_reward(299999).should == 125000 * COIN
-    Bitcoin.block_creation_reward(399999).should == 62500 * COIN
-    Bitcoin.block_creation_reward(499999).should == 31250 * COIN
-    Bitcoin.block_creation_reward(599999).should == 15625 * COIN
-    Bitcoin.block_creation_reward(600000).should == 10000 * COIN
-    Bitcoin.block_creation_reward(700000).should == 10000 * COIN
-  end
-
-  it 'should calculate merkle root from AuxPoW transaction branch' do
-    # Taken directly from Dogecoin block #403,931
-
-    # Branch stored as bytes to reflect how data is stored in AuxPow class
-    branch = [
-      "\xbe\x07\x90\x78\x86\x93\x99\xfa\xcc\xaa\x76\x4c\x10\xe9\xdf\x6e\x99\x81\x70\x17\x59\xad\x18\xe1\x37\x24\xd9\xca\x58\x83\x13\x48",
-      "\x5f\x5b\xfb\x2c\x79\x54\x17\x78\x49\x9c\xab\x95\x6a\x10\x38\x87\x14\x7f\x2a\xb5\xd4\xa7\x17\xf3\x2f\x9e\xee\xbd\x29\xe1\xf8\x94",
-      "\xd8\xc6\xfe\x42\xca\x25\x07\x61\x59\xcd\x12\x1a\x5e\x20\xc4\x8c\x1b\xc5\x3a\xb9\x07\x30\x08\x3e\x44\xa3\x34\x56\x6e\xa6\xbb\xcb"
-    ]
-    mrkl_index = 0
-    target = "089b911f5e471c0e1800f3384281ebec5b372fbb6f358790a92747ade271ccdf" # Coinbase TX ID
-    Bitcoin.mrkl_branch_root(branch.map(&:hth), target, mrkl_index).should == "f29cd14243ed542d9a0b495efcb9feca1b208bb5b717dc5ac04f068d2fef595a"
-  end
-
-  it 'should calculate merkle root from AuxPoW branch' do
-    # Taken directly from Dogecoin block #403,931
-
-    # Branch stored as bytes to reflect how data is stored in AuxPow class
-    aux_branch = [
-      "\x47\xa0\x22\x8b\x06\xc9\x36\x8f\x96\xc5\xf0\x4e\xb1\x09\xf8\x2c\xef\x36\xda\xe7\xc1\xbf\x25\x4c\x1a\x3f\x78\x61\x5e\xb0\xbe\x83",
-      "\xee\x67\xde\x31\x75\x76\x58\xdd\xd7\x40\x3e\x1a\x35\xd9\xc0\x6a\x5a\x13\xe6\x68\x98\x44\x3b\x45\x8c\xd6\xa7\x1b\x66\x27\x41\x6c",
-      "\xab\x9e\xf9\xbd\xa0\x2c\xad\x27\x90\xef\x9b\xb7\xc9\xa0\x7f\xe1\x79\x1a\x9d\x5a\xe0\x43\x09\xc0\xe9\x06\x48\x19\x19\x4c\x28\x31",
-      "\xff\x51\x61\x01\x80\xf6\x4d\x33\xa8\xc1\xba\x1d\xd9\xa9\xd0\x40\x48\x88\xc9\x6e\xaf\xd1\x57\x03\x64\x35\x8b\xbe\x99\x8f\x2d\xfe",
-      "\x9e\xe4\x18\x36\x7c\x3b\xce\x06\x5e\x7c\x01\x61\x29\x6e\xaa\x0d\x54\x96\xf9\x0f\x8b\x7b\x24\xeb\xf7\x2c\xc4\xba\xa5\x60\x9a\x1f",
-      "\x0b\x35\xf3\x73\x10\xe1\xde\x3f\xa4\xe1\x37\x7c\x02\x12\x62\x20\xe1\x64\xfa\x59\xec\xfe\xdc\xf4\x71\x4e\x61\xad\x74\xcc\x4b\x08"
-    ]
-    aux_mrkl_index = 56
-    target = "0c836b86991631d34a8a68054e2f62db919b39d1ee43c27ab3344d6aa82fa609" # Block hash
-    Bitcoin.mrkl_branch_root(aux_branch.map(&:hth), target, aux_mrkl_index).should == "ce3040fdb7e37484f6a1ca4f8f5da81e6b7e404ec91102315a233e03a0c39c95" # Merkle root in coinbase script
-  end
-
-  it 'parse AuxPoW' do
-    Bitcoin::network = :dogecoin
-
-    block_hash = "60323982f9c5ff1b5a954eac9dc1269352835f47c2c5222691d80f0d50dcf053"
-    data = fixtures_file("dogecoin-block-#{block_hash}.bin")
-    block = P::Block.new(data)
-    aux_pow = block.aux_pow
-    aux_pow.nil?.should == false
-    aux_pow.coinbase_index.should == 0
-
-    parent_block_merkle_root = Bitcoin.mrkl_branch_root(aux_pow.coinbase_branch, aux_pow.coinbase_tx.hash, aux_pow.coinbase_index)
-    parent_block_merkle_root.should == aux_pow.parent_block.mrkl_root.reverse.unpack("H*")[0]
-
-    # Find the merged mining header in the coinbase input script
-    merged_mining_header = "\xfa\xbemm"
-    script = aux_pow.coinbase_tx.in[0].script
-    header_idx = script.index(merged_mining_header)
-
-    header_idx.should == 4
-    
-    chain_merkle_root = Bitcoin.mrkl_branch_root(aux_pow.chain_branch, block_hash, aux_pow.chain_index)
-    
-    # Drop everything up to the merged mining data
-    script = script.slice(header_idx + merged_mining_header.length, chain_merkle_root.length / 2 + 8)
-
-    tx_root_hash = script.slice(0, chain_merkle_root.length / 2).unpack("H*")[0]
-    chain_merkle_root.should == tx_root_hash
-
-    merkle_branch_size = script.slice(chain_merkle_root.length / 2, 4).unpack("V")[0]
-    merkle_branch_size.should == (1 << aux_pow.chain_branch.length)
-
-    # Choose a pseudo-random slot in the chain merkle tree
-    # but have it be fixed for a size/nonce/chain combination.
-    nonce = script.slice(chain_merkle_root.length / 2 + 4, 4).unpack("V")[0]
-    rand = nonce
-    rand = rand * 1103515245 + 12345
-    rand += Bitcoin.network[:auxpow_chain_id]
-    rand = rand * 1103515245 + 12345
-
-    aux_pow.chain_index.should == (rand % merkle_branch_size)
-  end
-
-end