monacoin-ruby 0.1.2

data/spec/bitcoin/bloom_filter_spec.rb

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

@@ -0,0 +1,342 @@
+# 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
+
+end

data/spec/bitcoin/contracthash_spec.rb

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

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