bitcoin-ruby 0.0.14 → 0.0.15

data/lib/bitcoin/builder.rb

@@ -237,7 +237,7 @@ module Bitcoin
         @tx.in[i].sig_address = Script.new(@prev_script).get_address  if @prev_script
       end
 
-      def get_script_sig(inc)
+      def get_script_sig(inc, hash_type)
         if inc.has_multiple_keys?
           # multiple keys given, generate signature for each one
           sigs = inc.sign(@sig_hash)
@@ -251,7 +251,7 @@ module Bitcoin
         else
           # only one key given, generate signature and script_sig
           sig = inc.sign(@sig_hash)
-          script_sig = Script.to_signature_pubkey_script(sig, [inc.key.pub].pack("H*"))
+          script_sig = Script.to_signature_pubkey_script(sig, [inc.key.pub].pack("H*"), hash_type)
         end
         return script_sig
       end
@@ -268,13 +268,28 @@ module Bitcoin
           sig_script = inc.instance_eval { @redeem_script }
           sig_script ||= @prev_script
 
+          hash_type = if inc.prev_out_forkid
+            Script::SIGHASH_TYPE[:all] | Script::SIGHASH_TYPE[:forkid]
+          else
+            Script::SIGHASH_TYPE[:all]
+          end
+
           # when a sig_script was found, generate the sig_hash to be signed
           if sig_script
             script = Script.new(sig_script)
             if script.is_witness_v0_keyhash?
               @sig_hash = @tx.signature_hash_for_witness_input(i, sig_script, inc.value)
             else
-              @sig_hash = @tx.signature_hash_for_input(i, sig_script)
+              @sig_hash = if inc.prev_out_forkid
+                @tx.signature_hash_for_input(
+                  i,
+                  sig_script,
+                  hash_type,
+                  inc.value,
+                  inc.prev_out_forkid)
+              else
+                @tx.signature_hash_for_input(i, sig_script)
+              end
             end
           end
 
@@ -285,10 +300,12 @@ module Bitcoin
               @tx.in[i].script_witness.stack << inc.sign(@sig_hash) + [Script::SIGHASH_TYPE[:all]].pack("C")
               @tx.in[i].script_witness.stack << inc.key.pub.htb
             else
-              @tx.in[i].script_sig = get_script_sig(inc)
+              @tx.in[i].script_sig = get_script_sig(inc, hash_type)
             end
             # double-check that the script_sig is valid to spend the given prev_script
-            raise "Signature error"  if @prev_script && !@tx.verify_input_signature(i, @prev_script)
+            if @prev_script && !inc.prev_out_forkid && !@tx.verify_input_signature(i, @prev_script)
+              raise "Signature error"
+            end
           elsif inc.has_multiple_keys?
             raise "Keys missing for multisig signing"
           else
@@ -329,7 +346,7 @@ module Bitcoin
     #
     # If you want to spend a multisig output, just provide an array of keys to #signature_key.
     class TxInBuilder
-      attr_reader :prev_tx, :prev_script, :redeem_script, :key, :coinbase_data, :prev_out_value
+      attr_reader :prev_tx, :prev_script, :redeem_script, :key, :coinbase_data, :prev_out_value, :prev_out_forkid
 
       def initialize
         @txin = P::TxIn.new
@@ -341,7 +358,8 @@ module Bitcoin
       # You can either pass the transaction, or just the tx hash.
       # If you pass only the hash, you need to pass the previous outputs
       # +script+ separately if you want the txin to be signed.
-      def prev_out tx, idx = nil, script = nil, prev_value = nil
+      def prev_out tx, idx = nil, script = nil, prev_value = nil, prev_forkid = nil
+        @prev_out_forkid = prev_forkid
         if tx.is_a?(Bitcoin::P::Tx)
           @prev_tx = tx
           @prev_out_hash = tx.binary_hash

data/lib/bitcoin/ffi/secp256k1.rb

@@ -134,7 +134,7 @@ module Bitcoin
 
         internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
         result = secp256k1_ec_pubkey_create(context, internal_pubkey, seckey)
-        raise "error creating pubkey" unless result
+        raise "error creating pubkey" unless result == 1
 
         pubkey, pubkey_len = FFI::MemoryPointer.new(:uchar, 65), FFI::MemoryPointer.new(:uint64)
         result = if compressed
@@ -144,7 +144,7 @@ module Bitcoin
           pubkey_len.put_uint64(0, 65)
           secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_UNCOMPRESSED)
         end
-        raise "error serialize pubkey" unless result || pubkey_len.read_uint64 > 0
+        raise "error serialize pubkey" unless (result == 1) || pubkey_len.read_uint64 > 0
 
         [ seckey.read_string(32), pubkey.read_string(pubkey_len.read_uint64) ]
       end
@@ -158,7 +158,7 @@ module Bitcoin
     def self.sign(data, priv_key)
       with_context do |context|
         seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
-        raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey)
+        raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey) == 1
 
         internal_signature = FFI::MemoryPointer.new(:uchar, 64)
         msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
@@ -173,7 +173,7 @@ module Bitcoin
 
         signature, signature_len = FFI::MemoryPointer.new(:uchar, 72), FFI::MemoryPointer.new(:uint64).put_uint64(0, 72)
         result = secp256k1_ecdsa_signature_serialize_der(context, signature, signature_len, internal_signature)
-        raise "secp256k1_ecdsa_signature_serialize_der failed" unless result
+        raise "secp256k1_ecdsa_signature_serialize_der failed" unless result == 1
 
         signature.read_string(signature_len.read_uint64)
       end
@@ -186,13 +186,13 @@ module Bitcoin
         pubkey = FFI::MemoryPointer.new(:uchar, pub_key.bytesize).put_bytes(0, pub_key)
         internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
         result = secp256k1_ec_pubkey_parse(context, internal_pubkey, pubkey, pubkey.size)
-        return false unless result
+        return false unless result == 1
 
         signature = FFI::MemoryPointer.new(:uchar, sig.bytesize).put_bytes(0, sig)
         internal_signature = FFI::MemoryPointer.new(:uchar, 64)
         result = secp256k1_ecdsa_signature_parse_der(context, internal_signature, signature, signature.size)
         #result = ecdsa_signature_parse_der_lax(context, internal_signature, signature, signature.size)
-        return false unless result
+        return false unless result == 1
 
         # libsecp256k1's ECDSA verification requires lower-S signatures, which have not historically been enforced in Bitcoin, so normalize them first.
         secp256k1_ecdsa_signature_normalize(context, internal_signature, internal_signature)
@@ -200,14 +200,14 @@ module Bitcoin
         msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
         result = secp256k1_ecdsa_verify(context, internal_signature, msg32, internal_pubkey)
 
-        return result ? true : false
+        return result == 1
       end
     end
 
     def self.sign_compact(message, priv_key, compressed=true)
       with_context do |context|
         seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
-        raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey)
+        raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey) == 1
 
         msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, message)
         internal_recoverable_signature = FFI::MemoryPointer.new(:uchar, 65)
@@ -223,7 +223,7 @@ module Bitcoin
 
         recoverable_signature = FFI::MemoryPointer.new(:uchar, 64)
         result = secp256k1_ecdsa_recoverable_signature_serialize_compact(context, recoverable_signature, rec_id, internal_recoverable_signature)
-        raise "secp256k1_ecdsa_recoverable_signature_serialize_compact failed" unless result
+        raise "secp256k1_ecdsa_recoverable_signature_serialize_compact failed" unless result == 1
         raise "secp256k1_ecdsa_recoverable_signature_serialize_compact failed" unless rec_id.read_int != -1
 
         header = [27 + rec_id.read_int + (compressed ? 4 : 0)].pack("C")
@@ -248,15 +248,15 @@ module Bitcoin
 
         internal_recoverable_signature = FFI::MemoryPointer.new(:uchar, 65)
         result = secp256k1_ecdsa_recoverable_signature_parse_compact(context, internal_recoverable_signature, recoverable_signature, recid)
-        return nil unless result
+        return nil unless result == 1
 
         internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
         result = secp256k1_ecdsa_recover(context, internal_pubkey, internal_recoverable_signature, msg32)
-        return nil unless result
+        return nil unless result == 1
 
         pubkey, pubkey_len = FFI::MemoryPointer.new(:uchar, 65), FFI::MemoryPointer.new(:uint64).put_uint64(0, 65)
         result = secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, flag)
-        raise "error serialize pubkey" unless result || pubkey_len.read_uint64 > 0
+        raise "error serialize pubkey" unless (result == 1) || pubkey_len.read_uint64 > 0
 
         pubkey.read_string(pubkey_len.read_uint64)
       end

data/lib/bitcoin/protocol/txout.rb

@@ -9,7 +9,7 @@ module Bitcoin
       attr_accessor :value
 
       # pk_script output Script
-      attr_accessor :pk_script, :pk_script_length
+      attr_reader :pk_script, :pk_script_length
 
       # p2sh redeem script (optional, not included in the serialized binary format)
       attr_accessor :redeem_script
@@ -39,6 +39,7 @@ module Bitcoin
 
       # parse raw binary data for transaction output
       def parse_data_from_io(buf)
+        clear_parsed_script_cache
         @value = buf.read(8).unpack("Q")[0]
         @pk_script_length = Protocol.unpack_var_int_from_io(buf)
         @pk_script = buf.read(@pk_script_length)
@@ -50,6 +51,10 @@ module Bitcoin
         @parsed_script ||= Bitcoin::Script.new(pk_script)
       end
 
+      def clear_parsed_script_cache
+        remove_instance_variable(:@parsed_script) if defined?(@parsed_script)
+      end
+
       def to_payload
         [@value].pack("Q") << Protocol.pack_var_int(@pk_script_length) << @pk_script
       end
@@ -73,6 +78,7 @@ module Bitcoin
 
       # set pk_script and pk_script_length
       def pk_script=(pk_script)
+        clear_parsed_script_cache
         @pk_script_length, @pk_script = pk_script.bytesize, pk_script
       end
 

data/lib/bitcoin/script.rb

@@ -599,19 +599,19 @@ class Bitcoin::Script
     @chunks[0] == OP_RETURN && @chunks.size <= 2
   end
 
-  # is this a witness script(witness_v0_keyhash or witness_v0_scripthash)
+  # is this a witness script
   def is_witness?
-    is_witness_v0_keyhash? || is_witness_v0_scripthash?
+    @chunks.length == 2 && (0..16).include?(@chunks[0]) && @chunks[1].is_a?(String)
   end
 
   # is this a witness pubkey script
   def is_witness_v0_keyhash?
-    @chunks.length == 2 &&@chunks[0] == 0 && @chunks[1].is_a?(String) && @chunks[1].bytesize == 20
+    is_witness? && @chunks[0] == 0 && @chunks[1].bytesize == 20
   end
 
   # is this a witness script hash
   def is_witness_v0_scripthash?
-    @chunks.length == 2 &&@chunks[0] == 0 && @chunks[1].is_a?(String) && @chunks[1].bytesize == 32
+    is_witness? && @chunks[0] == 0 && @chunks[1].bytesize == 32
   end
 
   # Verify the script is only pushing data onto the stack
@@ -731,6 +731,12 @@ class Bitcoin::Script
     return [get_hash160_address]   if is_hash160?
     return get_multisig_addresses  if is_multisig?
     return [get_p2sh_address]      if is_p2sh?
+
+    if is_witness_v0_keyhash? || is_witness_v0_scripthash?
+      program_hex = chunks[1].unpack("H*").first
+      return Bitcoin.encode_segwit_address(0, program_hex)
+    end
+
     []
   end
 
@@ -762,20 +768,28 @@ class Bitcoin::Script
     [ ["a9",   "14",   p2sh, "87"].join ].pack("H*")
   end
 
+  # generate pay-to-witness output script for given +witness_version+ and
+  # +witness_program+. returns a raw binary script of the form:
+  # <witness_version> <witness_program>
+  def self.to_witness_script(witness_version, witness_program_hex)
+    return nil unless (0..16).include?(witness_version)
+    return nil unless witness_program_hex
+    version = witness_version != 0 ? 0x50 + witness_version : 0 # 0x50 for OP_1.. codes
+    [version].pack('C') + pack_pushdata(witness_program_hex.htb)
+  end
+
   # generate p2wpkh tx for given +address+. returns a raw binary script of the form:
   # 0 <hash160>
   def self.to_witness_hash160_script(hash160)
     return nil  unless hash160
-    #  witness ver  length  hash160
-    [ ["00",         "14",  hash160].join ].pack("H*")
+    to_witness_script(0, hash160)
   end
 
   # generate p2wsh output script for given +p2sh+ sha256. returns a raw binary script of the form:
   # 0 <p2sh>
   def self.to_witness_p2sh_script(p2sh)
     return nil  unless p2sh
-    #  witness ver  length  sha256
-    [ [ "00",        "20",   p2sh].join].pack("H*")
+    to_witness_script(0, p2sh)
   end
 
   # generate hash160 or p2sh output script, depending on the type of the given +address+.
@@ -785,6 +799,9 @@ class Bitcoin::Script
     case Bitcoin.address_type(address)
     when :hash160; to_hash160_script(hash160)
     when :p2sh;    to_p2sh_script(hash160)
+    when :witness_v0_keyhash, :witness_v0_scripthash
+      witness_version, witness_program_hex = Bitcoin.decode_segwit_address(address)
+      to_witness_script(witness_version, witness_program_hex)
     end
   end
 

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.0.14"
+  VERSION = "0.0.15"
 end

data/spec/bitcoin/bech32_spec.rb

@@ -0,0 +1,160 @@
+# encoding: ascii-8bit
+
+require_relative 'spec_helper'
+
+describe Bitcoin::Bech32 do
+  before do
+    Bitcoin.network = :bitcoin
+
+    @invalid_address_enc = [
+      ["BC", 0, 20],
+      ["bc", 0, 21],
+      ["bc", 17, 32],
+      ["bc", 1, 1],
+      ["bc", 16, 41],
+    ]
+
+    @valid_address = [
+        [
+            "BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4",
+            22, [
+                0x00, 0x14, 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54,
+                0x94, 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
+            ]
+        ],
+        [
+            "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7",
+            34, [
+                0x00, 0x20, 0x18, 0x63, 0x14, 0x3c, 0x14, 0xc5, 0x16, 0x68, 0x04,
+                0xbd, 0x19, 0x20, 0x33, 0x56, 0xda, 0x13, 0x6c, 0x98, 0x56, 0x78,
+                0xcd, 0x4d, 0x27, 0xa1, 0xb8, 0xc6, 0x32, 0x96, 0x04, 0x90, 0x32,
+                0x62
+            ]
+        ],
+        [
+            "bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k7grplx",
+            42, [
+                0x51, 0x28, 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54,
+                0x94, 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6,
+                0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54, 0x94, 0x1c,
+                0x45, 0xd1, 0xb3, 0xa3, 0x23, 0xf1, 0x43, 0x3b, 0xd6
+            ]
+        ],
+        [
+            "BC1SW50QA3JX3S",
+            4, [
+               0x60, 0x02, 0x75, 0x1e
+            ]
+        ],
+        [
+            "bc1zw508d6qejxtdg4y5r3zarvaryvg6kdaj",
+            18, [
+                0x52, 0x10, 0x75, 0x1e, 0x76, 0xe8, 0x19, 0x91, 0x96, 0xd4, 0x54,
+                0x94, 0x1c, 0x45, 0xd1, 0xb3, 0xa3, 0x23
+            ]
+        ],
+        [
+            "tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy",
+            34, [
+                0x00, 0x20, 0x00, 0x00, 0x00, 0xc4, 0xa5, 0xca, 0xd4, 0x62, 0x21,
+                0xb2, 0xa1, 0x87, 0x90, 0x5e, 0x52, 0x66, 0x36, 0x2b, 0x99, 0xd5,
+                0xe9, 0x1c, 0x6c, 0xe2, 0x4d, 0x16, 0x5d, 0xab, 0x93, 0xe8, 0x64,
+                0x33
+            ]
+        ]
+    ]
+
+		@valid_checksum = [
+				"A12UEL5L",
+				"an83characterlonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1tt5tgs",
+				"abcdef1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw",
+				"11qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqc8247j",
+				"split1checkupstagehandshakeupstreamerranterredcaperred2y9e3w",
+		]
+
+		@invalid_checksum = [
+				" 1nwldj5",
+				"\x7f""1axkwrx",
+				"an84characterslonghumanreadablepartthatcontainsthenumber1andtheexcludedcharactersbio1569pvx",
+				"pzry9x0s0muk",
+				"1pzry9x0s0muk",
+				"x1b4n0q5v",
+				"li1dgmt3",
+				"de1lg7wt\xff",
+		]
+
+		@invalid_address = [
+				"tc1qw508d6qejxtdg4y5r3zarvary0c5xw7kg3g4ty",
+				"bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t5",
+				"BC13W508D6QEJXTDG4Y5R3ZARVARY0C5XW7KN40WF2",
+				"bc1rw5uspcuh",
+				"bc10w508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kw5rljs90",
+				"BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P",
+				"tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sL5k7",
+				"bc1zw508d6qejxtdg4y5r3zarvaryvqyzf3du",
+				"tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3pjxtptv",
+				"bc1gmk9yu",
+		]
+  end
+
+  describe '#decode and #encode' do
+    it "test vectors" do
+      @valid_checksum.each do |testdata|
+        hrp, data = Bitcoin::Bech32.decode(testdata)
+        newdata = Bitcoin::Bech32.encode(hrp, data)
+        newdata.should == testdata.downcase
+      end
+
+      @invalid_checksum.each do |testdata|
+        hrp, data = Bitcoin::Bech32.decode(testdata)
+        hrp.should == nil
+      end
+
+      @valid_address.each do |testdata, _, _|
+        hrp, data = Bitcoin::Bech32.decode(testdata)
+        newdata = Bitcoin::Bech32.encode(hrp, data)
+        newdata.should == testdata.downcase
+      end
+    end
+  end
+
+  describe '#decode_segwit_address and #encode_segwit_address' do
+    it "test vectors" do
+			@valid_address.each do |testaddress, _, testscript|
+				Bitcoin.network = :bitcoin
+				version, program = Bitcoin.decode_segwit_address(testaddress)
+				if version.nil?
+					Bitcoin.network = :testnet3
+					version, program = Bitcoin.decode_segwit_address(testaddress)
+				end
+				version.should != nil
+
+        script = Bitcoin::Script.to_witness_script(version, program)
+        script.should == testscript.pack("C*")
+
+        newaddress = Bitcoin.encode_segwit_address(version, program)
+        newaddress.should != nil
+        newaddress.should == testaddress.downcase
+			end
+
+			@invalid_address.each do |testaddress|
+				Bitcoin.network = :bitcoin
+				version, program = Bitcoin.decode_segwit_address(testaddress)
+				if version.nil?
+					Bitcoin.network = :testnet3
+					version, program = Bitcoin.decode_segwit_address(testaddress)
+				end
+				version.should == nil
+      end
+
+			Bitcoin.network = :bitcoin
+      @invalid_address_enc.each do |testhrp, testversion, testlength|
+			  Bitcoin.network[:bech32_hrp] = testhrp
+        program_hex = Array.new(testlength){ 0 }.pack("C*").unpack("H*").first
+        newaddress = Bitcoin.encode_segwit_address(testversion, program_hex)
+        newaddress.should == nil
+      end
+    end
+  end
+
+end