bitcoin-ruby 0.0.1 → 0.0.2

data/spec/bitcoin/storage/storage_spec.rb

@@ -0,0 +1,337 @@
+# encoding: ascii-8bit
+
+require_relative '../spec_helper'
+
+include Bitcoin
+include Bitcoin::Storage
+include Bitcoin::Storage::Backends
+include Bitcoin::Builder
+include Bitcoin::Validation
+
+[ { :name => :dummy },
+  { :name => :utxo, :db => 'sqlite:/', :index_all_addrs => true },
+  { :name => :sequel, :db => 'sqlite:/' } ].each do |configuration|
+
+  describe "Bitcoin::Storage::Backends::#{configuration[:name].capitalize}Store" do
+
+    before do
+      class Bitcoin::Validation::Block; def difficulty; true; end; end
+      Bitcoin.network[:proof_of_work_limit] = Bitcoin.encode_compact_bits("ff"*32)
+
+      Bitcoin::network = :testnet
+      @store = Bitcoin::Storage.send(configuration[:name], configuration)
+      def @store.in_sync?; true; end
+      @store.reset
+      @store.log.level = 4
+
+      @store.store_block(P::Block.new(fixtures_file('testnet/block_0.bin')))
+      @store.store_block(P::Block.new(fixtures_file('testnet/block_1.bin')))
+      @store.store_block(P::Block.new(fixtures_file('testnet/block_2.bin')))
+      @store.store_block(P::Block.new(fixtures_file('testnet/block_3.bin')))
+
+      unless @store.class.name =~ /UtxoStore/
+        @store.store_tx(P::Tx.new(fixtures_file('rawtx-01.bin')), false)
+        @store.store_tx(P::Tx.new(fixtures_file('rawtx-02.bin')), false)
+      end
+
+      @blk = P::Block.new(fixtures_file('testnet/block_4.bin'))
+      @tx = P::Tx.new(fixtures_file('rawtx-03.bin'))
+    end
+
+    after do
+      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
+
+    it "should get backend name" do
+      @store.backend_name.should == configuration[:name].to_s
+    end
+
+    it "should get depth" do
+      @store.get_depth.should == 3
+    end
+
+    it "should report depth as -1 if store is empty" do
+      @store.reset
+      @store.get_depth.should == -1
+    end
+
+    it "should get head" do
+      @store.get_head
+        .should == @store.get_block("0000000098932356a236718829dd9e3eb0f9143317ab921333b1a203de336de4")
+    end
+
+    it "should get locator" do
+      @store.get_locator.should == [
+        "0000000098932356a236718829dd9e3eb0f9143317ab921333b1a203de336de4",
+        "000000037b21cac5d30fc6fda2581cf7b2612908aed2abbcc429c45b0557a15f",
+        "000000033cc282bc1fa9dcae7a533263fd7fe66490f550d80076433340831604",
+        "00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008"]
+    end
+
+    it "should not store if there is no prev block" do
+      @store.reset
+      @store.store_block(@blk).should == [0, 2]
+      @store.get_depth.should == -1
+    end
+
+    it "should check whether block is already stored" do
+      @store.has_block(@blk.hash).should == false
+      @store.store_block(@blk)
+      @store.has_block(@blk.hash).should == true
+    end
+
+    it "should get block by depth" do
+      @store.get_block_by_depth(0).hash.should ==
+        P::Block.new(fixtures_file('testnet/block_0.bin')).hash
+      @store.get_block_by_depth(1).hash.should ==
+        P::Block.new(fixtures_file('testnet/block_1.bin')).hash
+      @store.get_block_by_depth(2).hash.should ==
+        P::Block.new(fixtures_file('testnet/block_2.bin')).hash
+    end
+
+    it "should store and retrieve all relevant block data for hash/json serialization" do
+      (0..2).each do |i|
+        expected = P::Block.new(fixtures_file("testnet/block_#{i}.bin")).to_hash
+        @store.get_block_by_depth(i).to_hash.should == expected
+      end
+    end
+
+    it "should get block by hash" do
+      @store.get_block(
+        "00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008").hash
+        .should == P::Block.new(fixtures_file('testnet/block_0.bin')).hash
+      @store.get_block(
+        "000000033cc282bc1fa9dcae7a533263fd7fe66490f550d80076433340831604").hash
+        .should == P::Block.new(fixtures_file('testnet/block_1.bin')).hash
+      @store.get_block(
+        "000000037b21cac5d30fc6fda2581cf7b2612908aed2abbcc429c45b0557a15f").hash
+        .should == P::Block.new(fixtures_file('testnet/block_2.bin')).hash
+    end
+
+    it "should not get block" do
+      @store.get_block("nonexistant").should == nil
+    end
+
+    it "should get block depth" do
+      @store.get_block("00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008")
+        .depth.should == 0
+      @store.get_block("000000033cc282bc1fa9dcae7a533263fd7fe66490f550d80076433340831604")
+        .depth.should == 1
+      @store.get_block("000000037b21cac5d30fc6fda2581cf7b2612908aed2abbcc429c45b0557a15f")
+        .depth.should == 2
+    end
+
+    it "should get prev block" do
+      @store.get_block("00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008")
+        .get_prev_block.should == nil
+      @store.get_block("000000033cc282bc1fa9dcae7a533263fd7fe66490f550d80076433340831604")
+        .get_prev_block.should ==
+        @store.get_block("00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008")
+    end
+
+    it "should get next block" do
+      @store.get_block("0000000098932356a236718829dd9e3eb0f9143317ab921333b1a203de336de4")
+        .get_next_block.should == nil
+      @store.get_block("00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008")
+        .get_next_block.should ==
+        @store.get_block("000000033cc282bc1fa9dcae7a533263fd7fe66490f550d80076433340831604")
+    end
+
+    it "should get block for tx" do
+      @store.store_block(@blk)
+      @store.get_block_by_tx(@blk.tx[0].hash).should == @blk
+    end
+
+    # TODO calling .is_a? on @store breaks it (?!?)
+    if @store.class.name =~ /SequelStore/
+      describe :transactions do
+
+        it "should store tx" do
+          @store.store_tx(@tx, false).should != false
+        end
+        
+        it "should not store tx if already stored and return existing id" do
+          id = @store.store_tx(@tx, false)
+          @store.store_tx(@tx, false).should == id
+        end
+
+        it "should check if tx is already stored" do
+          @store.has_tx(@tx.hash).should == false
+          @store.store_tx(@tx, false)
+          @store.has_tx(@tx.hash).should == true
+        end
+
+        it "should store hash160 for txout" do
+          @store.store_tx(@tx, false)
+          @store.get_tx(@tx.hash).out[0].hash160
+            .should == "3129d7051d509424d23d533fa2d5258977e822e3"
+        end
+
+        it "should get tx" do
+          @store.store_tx(@tx, false)
+          @store.get_tx(@tx.hash).should == @tx
+        end
+
+        it "should not get tx" do
+          @store.get_tx("nonexistant").should == nil
+        end
+
+        it "should get the position for a given tx" do
+          @store.store_block(@blk)
+          result = @store.get_idx_from_tx_hash(@blk.tx[0].hash)
+          result.should == 0
+        end
+
+        it "should get tx for txin" do
+          @store.store_tx(@tx, false)
+          @store.get_tx(@tx.hash).in[0].get_tx.should == @tx
+        end
+
+        it "should get prev out for txin" do
+          tx = P::Tx.new(fixtures_file('rawtx-f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16.bin'))
+          outpoint_tx = P::Tx.new(fixtures_file('rawtx-0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9.bin'))
+          @store.store_tx(outpoint_tx, false)
+          @store.store_tx(tx, false)
+          @store.get_tx(tx.hash).in[0].get_prev_out.should == outpoint_tx.out[0]
+        end
+
+        it "should get tx for txout" do
+          @store.store_tx(@tx, false)
+          @store.get_tx(@tx.hash).out[0].get_tx.should == @tx
+        end
+
+        it "should get next in for txin" do
+          tx = P::Tx.new(fixtures_file('rawtx-f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16.bin'))
+          outpoint_tx = P::Tx.new(fixtures_file('rawtx-0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9.bin'))
+          @store.store_tx(outpoint_tx, false)
+          @store.store_tx(tx, false)
+          @store.get_tx(outpoint_tx.hash).out[0].get_next_in.should == tx.in[0]
+        end
+
+        it "should store multisig tx and index hash160's" do
+          *keys = Bitcoin::Key.generate, Bitcoin::Key.generate
+          pk_script = Bitcoin::Script.to_multisig_script(1, keys[0].pub, keys[1].pub)
+          txout = P::TxOut.new(1000, pk_script)
+          @store.store_txout(0, txout, 0)
+          keys.each do |key|
+            hash160 = Bitcoin.hash160(key.pub)
+            txouts = @store.get_txouts_for_hash160(hash160, true)
+            txouts.size.should == 1
+            txouts[0].pk_script.should == txout.pk_script
+          end
+        end
+
+        it "should index output script type" do
+          @store.store_tx(@tx, false)
+          @store.get_tx(@tx.hash).out.first.type.should == :hash160
+        end
+
+      end
+    end
+
+
+    describe :txouts do
+
+      before do
+        @key = Key.generate
+        @key2 = Key.generate
+        @store.store_block(@blk)
+        blk = create_block @blk.hash, true, [], @key
+        @block = create_block blk.hash, true, [->(t) {
+          create_tx(t, blk.tx.first, 0, [[50, @key2]]) }], @key
+      end
+
+      it "should get block for tx" do
+        @store.get_tx(@block.tx[1].hash).get_block.hash.should == @block.hash
+      end
+
+      it "should get txouts for pk script" do
+        script = @blk.tx[0].out[0].pk_script
+        @store.get_txouts_for_pk_script(script)
+          .should == [@blk.tx[0].out[0]]
+      end
+
+      it "should get txouts for hash160" do
+        @store.get_txouts_for_hash160(@key2.hash160, true)
+          .should == [@block.tx[1].out[0]]
+      end
+
+      it "should get txouts for address" do
+        @store.get_txouts_for_address(@key2.addr, true)
+          .should == [@block.tx[1].out[0]]
+      end
+
+      it "should get balance for address" do
+        @store.get_balance(@key.addr).should == 0
+        @store.get_balance(@key2.hash160).should == 50
+      end
+
+    end
+
+    describe "validation" do
+
+      before do
+        @key = Bitcoin::Key.generate
+        @store.store_block @blk
+        @block = create_block @blk.hash, false, [], @key
+        @tx = build_tx {|t| create_tx(t, @block.tx.first, 0, [[50, @key]]) }
+        @tx.instance_eval { @in = [] }
+      end
+
+      it "should validate blocks" do
+        @block.tx << @tx
+        -> { @store.store_block(@block) }.should
+          .raise(ValidationError).message.should =~ /mrkl_root/
+      end
+
+      it "should validate transactions for blocks added to main chain" do
+        @store.store_block(@block)
+        block = create_block @block.hash, false, [->(tx) {
+            create_tx(tx, @block.tx.first, 0, [[50, @key]]) }], @key
+        block.tx.last.in[0].prev_out_index = 5
+        -> { @store.store_block(block) }.should
+          .raise(ValidationError).message.should =~ /transactions_syntax/
+      end
+
+      it "should not validate transactions for blocks added to a side or orphan chain" do
+        @store.store_block(@block)
+        block = create_block @blk.hash, false, [->(tx) {
+            create_tx(tx, @block.tx.first, 0, [[50, @key]]) }], @key
+        @store.store_block(block).should == [5, 1]
+      end
+
+      if @store.class.name =~ /Sequel/
+
+        it "should validate transactions" do
+          @store.store_block @block
+          -> { @store.store_tx(@tx, true) }.should.raise(ValidationError)
+        end
+
+
+        it "should validate transactions for new main blocks on reorg" do
+          @store.store_block(@block)
+          block = create_block @blk.hash, true, [->(tx) {
+              create_tx(tx, @block.tx.first, 0, [[50, @key]]) }], @key
+          block2 = create_block block.hash, false, [], @key
+          -> { @store.store_block(block2) }.should
+            .raise(ValidationError).message.should =~ /transactions_context/
+        end
+
+      end
+
+      it "should skip validation" do
+        @store.config[:skip_validation] = true
+        @block.tx << @tx
+        @store.store_block(@block).should == [5, 0]
+      end
+
+    end
+
+  end
+
+end

data/spec/bitcoin/storage/validation_spec.rb

@@ -0,0 +1,261 @@
+# encoding: ascii-8bit
+
+require_relative '../spec_helper'
+
+include Bitcoin::Builder
+include Bitcoin::Storage
+include Bitcoin::Validation
+
+[ { :name => :utxo, :db => 'sqlite:/', :index_all_addrs => true },
+  { :name => :sequel, :db => 'sqlite:/' } ].each do |configuration|
+
+  describe "block rules (#{configuration[:name].capitalize}Store)" do
+
+  def balance addr
+    @store.get_balance(Bitcoin.hash160_from_address(addr))
+  end
+
+  before do
+    Bitcoin.network = :spec
+    @store = Bitcoin::Storage.send(configuration[:name], configuration)
+    @store.reset
+    @store.log.level = :warn
+    Bitcoin.network[:proof_of_work_limit] = Bitcoin.encode_compact_bits("f"*64)
+    @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
+    @block1 = create_block @block0.hash, true, [], @key
+    @store.get_head.should == @block1
+    @block = create_block @block1.hash, false
+  end
+
+  def check_block blk, error
+    b = blk.dup
+    if block_given?
+      yield(b); b.bits = Bitcoin.network[:proof_of_work_limit]; b.recalc_block_hash
+    end
+
+    validator = b.validator(@store)
+    validator.validate.should == false
+    validator.error.should == error
+  end
+
+  it "1. Check syntactic correctness" do
+    block = create_block @block1.hash, false
+    block.hash = "00" * 32
+    block.bits = Bitcoin.network[:proof_of_work_limit]
+    validator = block.validator(@store)
+    validator.validate.should == false
+    validator.error.should == [:hash, ["00"*32, block.hash]]
+  end
+
+  it "3. Transaction list must be non-empty" do
+    check_block(@block, [:tx_list, 0]) {|b| b.tx = [] }
+  end
+
+  it "4. Block hash must satisfy claimed nBits proof of work" do
+    @block.bits = Bitcoin.encode_compact_bits("0000#{"ff" * 30}")
+    @block.recalc_block_hash
+    target = Bitcoin.decode_compact_bits(block.bits).to_i(16)
+    check_block(@block, [:bits, [@block.hash.to_i(16), target]])
+  end
+
+  it "5. Block timestamp must not be more than two hours in the future" do
+    fake_time = (Time.now + 3 * 60 * 60).to_i
+    check_block(@block, [:max_timestamp, [fake_time, Time.now.to_i + 7200]]) {|b|
+      b.time = fake_time }
+  end
+
+  it "6. First transaction must be coinbase (i.e. only 1 input, with hash=0, n=-1), the rest must not be" do
+    block = create_block @block1.hash, false, [
+      ->(tx) { create_tx(tx, @block1.tx.first, 0, [[50, @key]]) } ], @key
+    check_block(block, [:coinbase, [0, 1]]) {|b| b.tx = b.tx.reverse }
+    check_block(block, [:coinbase, [1, 1]]) {|b| b.tx << b.tx[0] }
+  end
+
+  it "8. For the coinbase (first) transaction, scriptSig length must be 2-100" do
+    check_block(@block, [:coinbase_scriptsig, [1, 2, 100]]) {|b|
+      b.tx[0].in[0].script_sig = "\x01" }
+    check_block(@block, [:coinbase_scriptsig, [101, 2, 100]]) {|b|
+      b.tx[0].in[0].script_sig = "\x01" * 101 }
+  end
+
+  it "10. Verify Merkle hash" do
+    check_block(@block, [:mrkl_root, ["00"*32, @block.mrkl_root.reverse_hth]]) {|b|
+      b.mrkl_root = "\x00" * 32 }
+  end
+
+  it "12. Check that nBits value matches the difficulty rules" do
+    block = create_block @block1.hash, false, [], @key
+    Bitcoin.network[:proof_of_work_limit] = Bitcoin.encode_compact_bits("0000#{"ff"*30}")
+    validator = block.validator(@store)
+    validator.validate.should == false
+    validator.error.should == [:difficulty, [553713663, 520159231]]
+  end
+
+  it "13. Reject if timestamp is the median time of the last 11 blocks or before" do
+    prev_block = @block1
+    12.times do |i|
+      prev_block = create_block(prev_block.hash, false, [])
+      prev_block.time = Time.now.to_i - (12-i)
+      prev_block.recalc_block_hash
+      @store.store_block(prev_block).should == [i+2, 0]
+    end
+    block = create_block(prev_block.hash, false, [], @key)
+
+    fake_time = Time.now.to_i - 100
+    times = @store.db[:blk].where("depth > 2").map{|b|b[:time]}.sort
+    m, r = times.size.divmod(2)
+    min_time = (r == 0 ? times[m-1, 2].inject(:+) / 2.0 : times[m])
+    check_block(block, [:min_timestamp, [fake_time, min_time]]) {|b| b.time = fake_time }
+
+    fake_time = @store.get_block_by_depth(8).time
+    check_block(block, [:min_timestamp, [fake_time, fake_time]]) {|b| b.time = fake_time }
+    @store.store_block(block).should == [14, 0]
+  end
+
+  it "should allow chains of unconfirmed transactions" do
+    tx1 = build_tx {|t| create_tx(t, @block1.tx.first, 0, [[50, @key]]) }
+    tx2 = build_tx {|t| create_tx(t, tx1, 0, [[50, @key]]) }
+    block = create_block(@block1.hash, false, [], @key)
+    block.tx << tx1; block.tx << tx2
+    block.bits = Bitcoin.encode_compact_bits("f"*64)
+    block.mrkl_root = [Bitcoin.hash_mrkl_tree(block.tx.map(&:hash)).last].pack("H*").reverse
+    block.recalc_block_hash
+    @store.store_block(block).should == [2, 0]
+  end
+
+  it "should check coinbase output value" do
+    block2 = create_block(@block1.hash, false, [
+        ->(tx) { create_tx(tx, @block1.tx.first, 0, [[40e8, @key]])}
+      ], @key, 60e8)
+    @store.store_block(block2).should == [2, 0]
+
+    block3 = create_block(block2.hash, false, [], @key, 60e8)
+    -> { @store.store_block(block3) }.should.raise(ValidationError)
+
+    Bitcoin::Validation::REWARD_DROP = 2
+    block4 = create_block(block2.hash, false, [], @key, 50e8)
+    -> { @store.store_block(block4) }.should.raise(ValidationError)
+
+    block5 = create_block(block2.hash, false, [], @key, 25e8)
+    @store.store_block(block5).should == [3, 0]
+    Bitcoin::Validation::REWARD_DROP = 210_000
+  end
+
+end
+
+describe "transaction rules (#{configuration[:name].capitalize}Store)" do
+
+  before do
+    Bitcoin.network = :spec
+    @store = Bitcoin::Storage.send(configuration[:name], configuration)
+    @store.reset
+    @store.log.level = :warn
+
+    Bitcoin.network[:proof_of_work_limit] = Bitcoin.encode_compact_bits("f"*64)
+    @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
+    @block1 = create_block @block0.hash, true, [], @key
+    @store.get_head.should == @block1
+    @tx = build_tx {|t| create_tx(t, @block1.tx.first, 0, [[50, @key]]) }
+  end
+
+  def check_tx tx, error
+    t = tx.dup
+    yield(t) && t.instance_eval { @hash = generate_hash(to_payload) }  if block_given?
+    validator = t.validator(@store)
+    validator.validate.should == false
+    validator.error.should == error
+  end
+
+  it "should validate" do
+    validator = @tx.validator(@store)
+    validator.validate.should == true
+    validator.validate(raise_errors: true).should == true
+    hash = @tx.hash; @tx.instance_eval { @hash = "f"*64 }
+    validator = @tx.validator(@store)
+    validator.validate.should == false
+    validator.error.should == [:hash, ["f"*64, hash]]
+    -> { validator.validate(raise_errors: true) }.should.raise(ValidationError)
+  end
+
+  it "1. Check syntactic correctness" do
+    hash = @tx.hash; @tx.instance_eval { @hash = "ff"*32 }
+    validator = @tx.validator(@store)
+    validator.validate.should == false
+    validator.error.should == [:hash, ["ff"*32, hash]]
+  end
+
+  it "2. Make sure neither in or out lists are empty" do
+    check_tx(@tx, [:lists, [0, 1]]) {|tx| tx.instance_eval { @in = [] } }
+    check_tx(@tx, [:lists, [1, 0]]) {|tx| tx.instance_eval { @out = [] } }
+  end
+
+  it "3. Size in bytes < MAX_BLOCK_SIZE" do
+    max = Bitcoin::Validation::MAX_BLOCK_SIZE; Bitcoin::Validation::MAX_BLOCK_SIZE = 1000
+    check_tx(@tx, [:max_size, [@tx.payload.bytesize+978, 1000]]) {|tx|
+      tx.out[0].pk_script = "\x00" * 1001 }
+    Bitcoin::Validation::MAX_BLOCK_SIZE = max
+  end
+
+  it "4. Each output value, as well as the total, must be in legal money range" do
+    check_tx(@tx, [:output_values, [Bitcoin::network[:max_money] + 1, Bitcoin::network[:max_money]]]) {|tx|
+      tx.out[0].value = Bitcoin::network[:max_money] + 1 }
+  end
+
+  it "5. Make sure none of the inputs have hash=0, n=-1" do
+    check_tx(@tx, [:inputs, [0]]) do |tx|
+      tx.in.first.prev_out = "\x00"*32
+      tx.in.first.prev_out_index = 4294967295
+    end
+  end
+
+  it "6. Check that nLockTime <= INT_MAX, size in bytes >= 100, and sig opcount <= 2" do
+    check_tx(@tx, [:lock_time, [INT_MAX + 1, INT_MAX]]) {|tx| tx.lock_time = INT_MAX + 1 }
+    # TODO: validate sig opcount
+  end
+
+  # it "7. Reject 'nonstandard' transactions: scriptSig doing anything other than pushing numbers on the stack, or scriptPubkey not matching the two usual forms" do
+  #   check_tx(@tx, /standard/) {|tx| tx.out[0].pk_script = Bitcoin::Script.from_string("OP_ADD OP_DUP OP_DROP").raw }
+  # end
+
+  # it "9. Reject if any other tx in the pool uses the same transaction output as one used by this tx." do
+  # end
+
+  it "11. For each input, if we are using the nth output of the earlier transaction, but it has fewer than n+1 outputs, reject this transaction" do
+    check_tx(@tx, [:prev_out, [[@tx.in[0].prev_out.reverse_hth, 2]]]) {|tx| tx.in[0].prev_out_index = 2 }
+  end
+
+  it "13. Verify crypto signatures for each input; reject if any are bad" do
+    check_tx(@tx, [:signatures, [0]]) {|tx| @tx.in[0].script_sig[-1] = "\x00" }
+  end
+
+  it "14. For each input, if the referenced output has already been spent by a transaction in the main branch, reject this transaction" do
+    block2 = create_block(@block1.hash, true, [
+        ->(tx) {create_tx(tx, @block1.tx.first, 0, [[50, @key]])}], @key)
+    if @store.class.name =~ /Utxo/
+      check_tx(@tx, [:prev_out, [[@tx.in[0].prev_out.reverse_hth, 0]]])
+    else
+      check_tx(@tx, [:spent, [0]])
+    end
+  end
+  
+  it "15. Using the referenced output transactions to get input values, check that each input value, as well as the sum, are in legal money range" do
+    @store.db[@store.class.name =~ /Utxo/ ? :utxo : :txout].where(id: 2).update(value: 22e14)
+    check_tx(@tx, [:input_values, [22e14, 21e14]])
+  end
+
+  it "16. Reject if the sum of input values < sum of output values" do
+    tx = build_tx {|t| create_tx(t, @block1.tx.first, 0, [[100e8, @key]]) }
+    check_tx(tx, [:output_sum, [100e8, 50e8]])
+  end
+
+end
+
+end