bitcoin-ruby 0.0.5 → 0.0.6

data/lib/bitcoin/validation.rb

@@ -1,25 +1,17 @@
 # encoding: ascii-8bit
 
+# Validates blocks and transactions before they are accepted into the local blockchain.
+# There are two modes of validation, "syntax" and "context". "syntax" validates everything
+# that can be validated without access to the rest of the blockchain, for example that the
+# block hash matches the claimed difficulty, and the tx hashes add up to the given merkle
+# root, etc. The "context" rules include the checks that need to cross-reference data
+# against the local database, like comparing the difficulty target to the last blocks, or
+# checking for doublespends. (Suggestions for better names for these modes are welcome!)
+# Everything accepted into the local storage should at least be syntax-validated, but it
+# should be possible to skip context-validation when the current block is already known,
+# for example when checkpoints are used.
 module Bitcoin::Validation
-
-  # maximum size of a block (in bytes)
-  MAX_BLOCK_SIZE = 1_000_000
-
-  # maximum number of signature operations in a block
-  MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE / 50
-
-  # maximum integer value
-  INT_MAX = 0xffffffff
-
-  # number of confirmations required before coinbase tx can be spent
-  COINBASE_MATURITY = 100
-
-  # interval (in blocks) for difficulty retarget
-  RETARGET = 2016
-
-  # interval (in blocks) for mining reward reduction
-  REWARD_DROP = 210_000
-
+    
   class ValidationError < StandardError
   end
 
@@ -38,6 +30,11 @@ module Bitcoin::Validation
       RULES[:context] -= [:difficulty, :coinbase_value]
     end
 
+    if Bitcoin.litecoin?
+      RULES[:syntax] -= [:bits]
+      RULES[:syntax] += [:scrypt_bits]
+    end
+
     # validate block rules. +opts+ are:
     # rules:: which rulesets to validate (default: [:syntax, :context])
     # raise_errors:: whether to raise ValidationError on failure (default: false)
@@ -82,6 +79,13 @@ module Bitcoin::Validation
       actual <= expected || [actual, expected]
     end
 
+    # check that block hash matches claimed bits using Scrypt hash
+    def scrypt_bits
+      actual = block.recalc_block_scrypt_hash.to_i(16)
+      expected = Bitcoin.decode_compact_bits(block.bits).to_i(16)
+      actual <= expected || [actual, expected]
+    end
+
     # check that block time is not greater than max
     def max_timestamp
       time, max = block.time, Time.now.to_i + 2*60*60
@@ -102,7 +106,7 @@ module Bitcoin::Validation
 
     # check that coinbase value is valid; no more than reward + fees
     def coinbase_value
-      reward = ((50.0 / (2 ** (store.get_depth / REWARD_DROP.to_f).floor)) * 1e8).to_i
+      reward = ((50.0 / (2 ** (store.get_depth / Bitcoin::REWARD_DROP.to_f).floor)) * 1e8).to_i
       fees = 0
       block.tx[1..-1].map.with_index do |t, idx|
         val = tx_validators[idx]
@@ -127,7 +131,7 @@ module Bitcoin::Validation
 
     # check that bits satisfy required difficulty
     def difficulty
-      return true  if Bitcoin.network_name == :testnet3
+      return true  if Bitcoin.network[:no_difficulty] == true
       block.bits == next_bits_required || [block.bits, next_bits_required]
     end
 
@@ -146,8 +150,11 @@ module Bitcoin::Validation
       block.time > min_time || [block.time, min_time]
     end
 
-    # check transactions
+    # Run all syntax checks on transactions
     def transactions_syntax
+      # check if there are no double spends within this block
+      return false if block.tx.map(&:in).flatten.map {|i| [i.prev_out, i.prev_out_index] }.uniq! != nil
+
       tx_validators.all?{|v|
         begin
           v.validate(rules: [:syntax], raise_errors: true)
@@ -158,6 +165,7 @@ module Bitcoin::Validation
       }
     end
 
+    # Run all context checks on transactions
     def transactions_context
       tx_validators.all?{|v|
         begin
@@ -169,21 +177,42 @@ module Bitcoin::Validation
       }
     end
 
+    # Get validators for all tx objects in the current block
     def tx_validators
-      @tx_validators ||= block.tx[1..-1].map {|tx| tx.validator(store, block) }
+      @tx_validators ||= block.tx[1..-1].map {|tx| tx.validator(store, block, self)}
+    end
+
+    # Fetch all prev_txs that will be needed for validation
+    # Used for optimization in tx validators
+    def prev_txs_hash
+      @prev_tx_hash ||= (
+        inputs = block.tx[1..-1].map {|tx| tx.in }.flatten
+        txs = store.get_txs(inputs.map{|i| i.prev_out.reverse_hth })
+        Hash[*txs.map {|tx| [tx.hash, tx] }.flatten]
+      )
+    end
+
+    # Fetch all prev_outs that already have a next_in, i.e. are already spent.
+    def spent_outs_txins
+      @spent_outs_txins ||= (
+        next_ins = store.get_txins_for_txouts(block.tx[1..-1].map(&:in).flatten.map.with_index {|txin, idx| [txin.prev_out.reverse_hth, txin.prev_out_index] })
+        # Only returns next_ins that are in blocks in the main chain
+        next_ins.select {|i| store.get_block_id_for_tx_id(i.tx_id) }
+      )
     end
 
     def next_bits_required
-      index = (prev_block.depth + 1) / RETARGET
+      retarget = (Bitcoin.network[:retarget_interval] || Bitcoin::RETARGET_INTERVAL)
+      index = (prev_block.depth + 1) / retarget  
       max_target = Bitcoin.decode_compact_bits(Bitcoin.network[:proof_of_work_limit]).to_i(16)
       return Bitcoin.network[:proof_of_work_limit]  if index == 0
-      return prev_block.bits  if (prev_block.depth + 1) % RETARGET != 0
+      return prev_block.bits  if (prev_block.depth + 1) % retarget != 0
       last = store.db[:blk][hash: prev_block.hash.htb.blob]
       first = store.db[:blk][hash: last[:prev_hash].blob]
-      (RETARGET-2).times { first = store.db[:blk][hash: first[:prev_hash].blob] }
+      (retarget - 2).times { first = store.db[:blk][hash: first[:prev_hash].blob] }
 
       nActualTimespan = last[:time] - first[:time]
-      nTargetTimespan = RETARGET * 600
+      nTargetTimespan = retarget * 600
 
       nActualTimespan = [nActualTimespan, nTargetTimespan/4].max
       nActualTimespan = [nActualTimespan, nTargetTimespan*4].min
@@ -202,11 +231,11 @@ module Bitcoin::Validation
   end
 
   class Tx
-    attr_accessor :tx, :store, :error
+    attr_accessor :tx, :store, :error, :block_validator
 
     RULES = {
       syntax: [:hash, :lists, :max_size, :output_values, :inputs, :lock_time, :standard],
-      context: [:prev_out, :signatures, :spent, :input_values, :output_sum]
+      context: [:prev_out, :signatures, :not_spent, :input_values, :output_sum]
     }
 
     # validate tx rules. +opts+ are:
@@ -236,10 +265,14 @@ module Bitcoin::Validation
       "b3c19d78b4953b694717a47d9852f8ea1ccd4cf93a45ba2e43a0f97d7cdb2655"
     ]
 
-    # setup new validator for given +tx+, validating context with +store+.
-    # also needs the +block+ to find prev_outs for chains of tx inside one block.
-    def initialize tx, store, block = nil
+    # Setup new validator for given +tx+, validating context with +store+.
+    # Also needs the +block+ that includes the tx to be validated, to find
+    # prev_outs for chains of txs inside the block.
+    # Optionally accepts the validator object for the block, to optimize fetching
+    # prev_txs and checking for doublespends.
+    def initialize(tx, store, block = nil, block_validator = nil)
       @tx, @store, @block, @errors = tx, store, block, []
+      @block_validator = block_validator
     end
 
     # check that tx hash matches data
@@ -255,7 +288,7 @@ module Bitcoin::Validation
 
     # check that tx size doesn't exceed MAX_BLOCK_SIZE.
     def max_size
-      tx.to_payload.bytesize <= MAX_BLOCK_SIZE || [tx.to_payload.bytesize, MAX_BLOCK_SIZE]
+      tx.to_payload.bytesize <= Bitcoin::MAX_BLOCK_SIZE || [tx.to_payload.bytesize, Bitcoin::MAX_BLOCK_SIZE]
     end
 
     # check that total output value doesn't exceed MAX_MONEY.
@@ -272,7 +305,7 @@ module Bitcoin::Validation
 
     # check that lock_time doesn't exceed INT_MAX
     def lock_time
-      tx.lock_time <= INT_MAX || [tx.lock_time, INT_MAX]
+      tx.lock_time <= Bitcoin::UINT32_MAX || [tx.lock_time, Bitcoin::UINT32_MAX]
     end
 
     # check that min_size is at least 86 bytes
@@ -308,16 +341,23 @@ module Bitcoin::Validation
       sigs.all? || sigs.map.with_index {|s, i| s ? nil : i }.compact
     end
 
-    # check that none of the prev_outs are already spent in the main chain
-    def spent
-      spent = tx.in.map.with_index {|txin, idx|
-        next false  if @block && @block.tx.include?(prev_txs[idx])
-        next false  unless next_in = prev_txs[idx].out[txin.prev_out_index].get_next_in
-        next false  unless next_tx = next_in.get_tx
-        next false  unless next_block = next_tx.get_block
-        next_block.chain == Bitcoin::Storage::Backends::StoreBase::MAIN
-      }
-      spent.none? || spent.map.with_index {|s, i| s ? i : nil }
+    # check that none of the prev_outs are already spent in the main chain or in the current block
+    def not_spent
+      # if we received cached spents, use it
+      return block_validator.spent_outs_txins.empty? if block_validator
+
+      # find all spent txouts
+      next_ins = store.get_txins_for_txouts(tx.in.map.with_index {|txin, idx| [txin.prev_out.reverse_hth, txin.prev_out_index] })
+
+      # no txouts found spending these txins, we can safely return true
+      return true if next_ins.empty?
+
+      # there were some txouts spending these txins, verify that they are not on the main chain
+      next_ins.select! {|i| i.get_tx.blk_id } # blk_id is only set for tx in the main chain
+      return true if next_ins.empty?
+
+      # now we know some txouts are already spent, return tx_idxs for debugging purposes
+      return next_ins.map {|i| i.get_prev_out.tx_idx }
     end
 
     # check that the total input value doesn't exceed MAX_MONEY
@@ -341,18 +381,9 @@ module Bitcoin::Validation
     # only returns tx that are in a block in the main chain or the current block.
     def prev_txs
       @prev_txs ||= tx.in.map {|i|
-        prev_tx = store.get_tx(i.prev_out.reverse_hth)
-        next prev_tx  if store.class.name =~ /UtxoStore/ && prev_tx
-        next nil  if !prev_tx && !@block
-
-        if store.class.name =~ /SequelStore/
-          block = store.db[:blk][id: prev_tx.blk_id]  if prev_tx
-          next prev_tx  if block && block[:chain] == 0
-        else
-          next prev_tx  if prev_tx && prev_tx.get_block && prev_tx.get_block.chain == 0
-        end
-        next  nil if !@block
-        @block.tx.find {|t| t.binary_hash == i.prev_out }
+        prev_tx = block_validator ? block_validator.prev_txs_hash[i.prev_out.reverse_hth] : store.get_tx(i.prev_out.reverse_hth)
+        next prev_tx if prev_tx && prev_tx.blk_id # blk_id is set only if it's in the main chain
+        @block.tx.find {|t| t.binary_hash == i.prev_out } if @block
       }.compact
     end
 

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/bitcoin/bitcoin_spec.rb

@@ -24,6 +24,44 @@ describe 'Bitcoin Address/Hash160/PubKey' do
       .should == "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
   end
 
+  it 'bitcoin-address from pubkey' do
+    Bitcoin::network = :testnet
+    Bitcoin.pubkey_to_address("029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4")
+      .should == "mu6vSuyvpVxvDAJyZczjxaU56pXLNBSf9C"
+    Bitcoin.pubkey_to_address("049e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4b82314814017e4e9b06a0fd8e01772bb410cb1c36cfc2d03079c315bc7494b86")
+    .should == "n4bZ82i9SdLj6YauPn3PPKFRhQHMZrdaPq"
+
+    Bitcoin::network = :bitcoin
+    Bitcoin.pubkey_to_address("029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4")
+    .should == "1Eay9rtx1UXfS3qMr42N8fFkEpvdR2euvg"
+    Bitcoin.pubkey_to_address("049e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4b82314814017e4e9b06a0fd8e01772bb410cb1c36cfc2d03079c315bc7494b86")
+    .should == "1Q5bpydAdbuUKS7HgD51ZQ36qQgeiN8cBE"
+  end
+
+  it 'bitcoin p2sh multisig address from pubkeys' do
+    Bitcoin::network = :testnet
+    address, redeem_script = Bitcoin.pubkeys_to_p2sh_multisig_address(2, "029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4",
+                                                                      "0299acf23a65c31fe02052d7474769529c21612b1afa56cc149747fe63867592ec")
+    address.should == "2NGaiH7MNYWhsWPQKudZEvy8KnoWPfuGPg1"
+    redeem_script.hth.should == "52" + # OP_2
+                                "21" + "029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4" + # pubkey.bytesize + pubkey
+                                "21" + "0299acf23a65c31fe02052d7474769529c21612b1afa56cc149747fe63867592ec" + # pubkey.bytesize + pubkey
+                                "52" +  # OP_2
+                                "ae"    # OP_CHECKMULTISIG
+
+    Bitcoin::network = :bitcoin
+    address, redeem_script = Bitcoin.pubkeys_to_p2sh_multisig_address(2, "029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4",
+                                                                      "0299acf23a65c31fe02052d7474769529c21612b1afa56cc149747fe63867592ec",
+                                                                      "020b16a7227f873ac68cf3140f1101d2eda5acb28bf3e7d546409139caf25142e4")
+    address.should == "38eiL6Jac27TVAu83wj81Miso9rXiVqgcP"
+    redeem_script.hth.should == "52" + # OP_2
+                                "21" + "029e31ccb7308c2525d542024b8119a3ab3767933e82aedd1471f9c714d998d1b4" + # pubkey.bytesize + pubkey
+                                "21" + "0299acf23a65c31fe02052d7474769529c21612b1afa56cc149747fe63867592ec" + # pubkey.bytesize + pubkey
+                                "21" + "020b16a7227f873ac68cf3140f1101d2eda5acb28bf3e7d546409139caf25142e4" + # pubkey.bytesize + pubkey
+                                "53" +  # OP_3
+                                "ae"    # OP_CHECKMULTISIG
+  end
+
   it 'bitcoin p2sh address from bitcoin-hash160' do
     Bitcoin::network = :testnet
     Bitcoin.hash160_to_p2sh_address("d11e2f2f385efeecd30f867f1d55c0bc8a27f29e")

data/spec/bitcoin/builder_spec.rb

@@ -85,6 +85,29 @@ describe "Bitcoin::Builder" do
     tx2.out[0].pk_script.should == tx.out[0].pk_script
   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 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|
@@ -102,6 +125,106 @@ describe "Bitcoin::Builder" do
     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 address script" do
     key = Bitcoin::Key.generate
     s = script {|s| s.type :address; s.recipient key.addr }
@@ -121,4 +244,58 @@ describe "Bitcoin::Builder" do
     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