bitcoin-ruby 0.0.1 → 0.0.2

data/lib/bitcoin/gui/addr_view.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin::Gui
   class AddrView < TreeView
 

data/lib/bitcoin/gui/conn_view.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin::Gui
   class ConnView < TreeView
     def initialize gui

data/lib/bitcoin/gui/connection.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin::Gui
 
   class Bitcoin::Network::CommandClient

data/lib/bitcoin/gui/em_gtk.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 require "monitor"
 
 module Gtk

data/lib/bitcoin/gui/gui.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 require_relative "em_gtk.rb"
 require_relative "helpers.rb"
 require_relative "tree_view.rb"

data/lib/bitcoin/gui/helpers.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin::Gui::Helpers
 
   def display_tx tx_hash

data/lib/bitcoin/gui/tree_view.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin::Gui
   class TreeView
 

data/lib/bitcoin/gui/tx_view.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin::Gui
   class TxView < TreeView
 

data/lib/bitcoin/key.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 module Bitcoin
 
   # Elliptic Curve key as used in bitcoin.
@@ -15,10 +17,11 @@ module Bitcoin
     # See also #to_base58
     def self.from_base58(str)
       hex = Bitcoin.decode_base58(str)
-      version, key, checksum = hex.unpack("a2a64a8")
+      compressed = hex.size == 76
+      version, key, flag, checksum = hex.unpack("a2a64a#{compressed ? 2 : 0}a8")
       raise "Invalid version"   unless version == Bitcoin.network[:privkey_version]
-      raise "Invalid checksum"  unless Bitcoin.checksum(version + key) == checksum
-      new(key)
+      raise "Invalid checksum"  unless Bitcoin.checksum(version + key + flag) == checksum
+      key = new(key, nil, compressed)
     end
 
     def == other
@@ -29,8 +32,9 @@ module Bitcoin
     #  Bitcoin::Key.new
     #  Bitcoin::Key.new(privkey)
     #  Bitcoin::Key.new(nil, pubkey)
-    def initialize privkey = nil, pubkey = nil
+    def initialize privkey = nil, pubkey = nil, compressed = false
       @key = Bitcoin.bitcoin_elliptic_curve
+      @pubkey_compressed = pubkey ? self.class.is_compressed_pubkey?(pubkey) : compressed
       set_priv(privkey)  if privkey
       set_pub(pubkey)  if pubkey
     end
@@ -55,16 +59,29 @@ module Bitcoin
     # In case the key was initialized with only
     # a private key, the public key is regenerated.
     def pub
-      unless @key.public_key
-        if @key.private_key
-          set_pub(Bitcoin::OpenSSL_EC.regenerate_key(priv)[1])
-        else
-          return nil
-        end
-      end
+      @pubkey_compressed ? pub_compressed : pub_uncompressed
+    end
+
+    def pub_compressed
+      regenerate_pubkey unless @key.public_key
+      return nil        unless @key.public_key
+      @key.public_key.group.point_conversion_form = :compressed
+      hex = @key.public_key.to_hex.rjust(66, '0')
+      @key.public_key.group.point_conversion_form = :uncompressed
+      hex
+    end
+
+    def pub_uncompressed
+      regenerate_pubkey unless @key.public_key
+      return nil        unless @key.public_key
+      @key.public_key.group.point_conversion_form = :uncompressed
       @key.public_key.to_hex.rjust(130, '0')
     end
 
+    def compressed
+      @pubkey_compressed
+    end
+
     # Set the public key (in hex).
     def pub= pub
       set_pub(pub)
@@ -94,10 +111,53 @@ module Bitcoin
       @key.dsa_verify_asn1(data, sig)
     end
 
+
+    def sign_message(message)
+      Bitcoin.sign_message(priv, pub, message)['signature']
+    end
+
+    def verify_message(signature, message)
+      Bitcoin.verify_message(addr, signature, message)
+    end
+
+    def self.verify_message(address, signature, message)
+      Bitcoin.verify_message(address, signature, message)
+    end
+
+    # Thanks to whoever wrote http://pastebin.com/bQtdDzHx
+    # for help with compact signatures
+    #
+    # Given +data+ and a compact signature (65 bytes, base64-encoded to
+    # a larger string), recover the public components of the key whose
+    # private counterpart validly signed +data+.
+    #
+    # If the signature validly signed +data+, create a new Key
+    # having the signing public key and address. Otherwise return nil.
+    #
+    # Be sure to check that the returned Key matches the one you were
+    # expecting! Otherwise you are merely checking that *someone* validly
+    # signed the data.
+    def self.recover_compact_signature_to_key(data, signature_base64)
+      signature = signature_base64.unpack("m0")[0]
+      return nil if signature.size != 65
+
+      version = signature.unpack('C')[0]
+      return nil if version < 27 or version > 34
+ 
+      compressed = (version >= 31) ? (version -= 4; true) : false
+
+      hash = Bitcoin.bitcoin_signed_message_hash(data)
+      pub_hex = Bitcoin::OpenSSL_EC.recover_public_key_from_signature(hash, signature, version-27, compressed)
+      return nil unless pub_hex
+
+      Key.new(nil, pub_hex)
+    end
+
     # Export private key to base58 format.
     # See also Key.from_base58
     def to_base58
       data = Bitcoin.network[:privkey_version] + priv
+      data += "01"  if @pubkey_compressed
       hex  = data + Bitcoin.checksum(data)
       Bitcoin.int_to_base58( hex.to_i(16) )
     end
@@ -106,6 +166,7 @@ module Bitcoin
 
     # Regenerate public key from the private key.
     def regenerate_pubkey
+      return nil unless @key.private_key
       set_pub(Bitcoin::OpenSSL_EC.regenerate_key(priv)[1])
     end
 
@@ -116,9 +177,14 @@ module Bitcoin
 
     # Set +pub+ as the new public key (converting from hex).
     def set_pub(pub)
+      @pubkey_compressed ||= self.class.is_compressed_pubkey?(pub)
       @key.public_key = OpenSSL::PKey::EC::Point.from_hex(@key.group, pub)
     end
 
+    def self.is_compressed_pubkey?(pub)
+      ["02","03"].include?(pub[0..1])
+    end
+
   end
 
 end

data/lib/bitcoin/litecoin.rb

@@ -0,0 +1,81 @@
+require 'openssl'
+
+module Litecoin
+  module Scrypt
+
+    def scrypt_1024_1_1_256(input)
+      input = [input].pack("H*") if input.bytesize == 160
+      #scrypt_1024_1_1_256_sp(input, scratchpad = Array.new(131072 + 63){ 0 })
+      scrypt_1024_1_1_256_sp(input)
+    end
+
+    def scrypt_1024_1_1_256_sp(input, scratchpad=[])
+      b = pbkdf2_sha256(input, input, 1, 128)
+      x = b.unpack("V*")
+      v = scratchpad
+
+      1024.times{|i|
+        v[(i*32)...((i*32)+32)] = x.dup
+        xor_salsa8(x, x, 0, 16)
+        xor_salsa8(x, x, 16, 0)
+      }
+
+      1024.times{|i|
+        j = 32 * (x[16] & 1023)
+        32.times{|k| x[k] ^= v[j+k] }
+        xor_salsa8(x, x, 0, 16)
+        xor_salsa8(x, x, 16, 0)
+      }
+
+      pbkdf2_sha256(input, x.pack("V*"), 1, 32).reverse.unpack("H*")[0]
+    end
+
+    def pbkdf2_sha256(pass, salt, c=1, dk_len=128)
+      raise "pbkdf2_sha256: wrong length." if pass.bytesize != 80 or ![80,128].include?(salt.bytesize)
+      raise "pbkdf2_sha256: wrong dk length." if ![128,32].include?(dk_len)
+      OpenSSL::PKCS5.pbkdf2_hmac(pass, salt, iter=c, dk_len, OpenSSL::Digest::SHA256.new)
+    end
+
+    def rotl(a, b)
+      a &= 0xffffffff; ((a << b) | (a >> (32 - b))) & 0xffffffff
+    end
+
+    def xor_salsa8(a, b, a_offset, b_offset)
+      x = 16.times.map{|n| a[a_offset+n] ^= b[b_offset+n] }
+
+      4.times{
+        [
+          [4, 0, 12, 7], [9, 5, 1, 7],  [14, 10, 6, 7], [3, 15, 11, 7],
+          [8, 4, 0, 9], [13, 9, 5, 9],  [2, 14, 10, 9], [7, 3, 15, 9],
+          [12, 8, 4, 13], [1, 13, 9, 13],  [6, 2, 14, 13], [11, 7, 3, 13],
+          [0, 12, 8, 18], [5, 1, 13, 18],  [10, 6, 2, 18], [15, 11, 7, 18],
+
+          [1, 0, 3, 7], [6, 5, 4, 7],  [11, 10, 9, 7], [12, 15, 14, 7],
+          [2, 1, 0, 9], [7, 6, 5, 9],  [8, 11, 10, 9], [13, 12, 15, 9],
+          [3, 2, 1, 13], [4, 7, 6, 13],  [9, 8, 11, 13], [14, 13, 12, 13],
+          [0, 3, 2, 18], [5, 4, 7, 18],  [10, 9, 8, 18], [15, 14, 13, 18]
+        ].each{|i|
+          x[ i[0] ] ^= rotl(x[ i[1] ] + x[ i[2] ], i[3])
+        }
+      }
+
+      16.times{|n| a[a_offset+n] = (a[a_offset+n] + x[n]) & 0xffffffff }
+      true
+    end
+
+    extend self
+  end
+end
+
+
+if $0 == __FILE__
+  secret_hex = "020000004c1271c211717198227392b029a64a7971931d351b387bb80db027f270411e398a07046f7d4a08dd815412a8712f874a7ebf0507e3878bd24e20a3b73fd750a667d2f451eac7471b00de6659"
+  p Litecoin::Scrypt.scrypt_1024_1_1_256(secret_hex) == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806"
+
+  require 'benchmark'
+  secret_bytes = [secret_hex].pack("H*")
+  Benchmark.bmbm{|x|
+    #x.report("v1"){ p Litecoin::Scrypt.scrypt_1024_1_1_256_sp_old(secret_bytes) == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806" }
+    x.report("v2"){ p Litecoin::Scrypt.scrypt_1024_1_1_256_sp(secret_bytes) == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806" }
+  }
+end

data/lib/bitcoin/logger.rb

@@ -1,3 +1,5 @@
+# encoding: ascii-8bit
+
 if Bitcoin.require_dependency :log4r, exit: false
   # monkey-patch Log4r to accept level names as symbols
   class Log4r::Logger
@@ -16,9 +18,22 @@ module Bitcoin
   # this is a very simple logger that is used if log4r is not available
   module Logger
 
+    module TimeLogger
+
+      def time message
+        time = Time.now
+        res = yield
+        debug { message % (Time.now - time) }
+        res
+      end
+
+    end
+
     class Logger
       LEVELS = [:debug, :info, :warn, :error, :fatal]
 
+      include TimeLogger
+
       attr_accessor :level
 
       def initialize(name)
@@ -36,6 +51,7 @@ module Bitcoin
           puts "#{level.to_s.upcase.ljust(5)} #{@name}: #{msg}"
         end
       end
+
     end
 
     # wrap a logger and prepend a special name in front of the messages
@@ -51,10 +67,13 @@ module Bitcoin
     # otherwise, the internal dummy logger is used which only logs to stdout.
     def self.create name, level = :info
       if defined?(Log4r)
+        dir = "log"
+        FileUtils.mkdir_p(dir) rescue dir = nil
         @log = Log4r::Logger.new(name.to_s)
+        @log.extend(TimeLogger)
         @log.level = level
         @log.outputters << Log4r::Outputter.stdout
-        @log.outputters << Log4r::FileOutputter.new("fout", :filename => "log/#{name}.log")
+        @log.outputters << Log4r::FileOutputter.new("fout", :filename => "#{dir}/#{name}.log")  if dir
       else
         @log = Bitcoin::Logger::Logger.new(name)
       end

data/lib/bitcoin/namecoin.rb

@@ -0,0 +1,279 @@
+# encoding: ascii-8bit
+
+# This module includes (almost) everything necessary to add namecoin support
+# to bitcoin-ruby. When switching to a :namecoin network, it will load its
+# functionality into the Script class and the Storage backend.
+# The only things not included here should be parsing the AuxPow, which is
+# done in Protocol::Block directly, and passing the txout to #store_name from
+# the storage backend.
+module Bitcoin::Namecoin
+
+  def self.load
+    Bitcoin::Script.class_eval { include Script }
+    Bitcoin::Storage::Backends::StoreBase.class_eval { include Storage::Backend }
+    Bitcoin::Storage::Models.class_eval { include Storage::Models }
+  end
+
+  # name_new must have 12 confirmations before corresponding name_firstupdate is valid.
+  FIRSTUPDATE_LIMIT = 12
+
+  # number of blocks after which a name expires.
+  EXPIRATION_DEPTH = 36000
+
+  # Namecoin-specific Script methods for parsing and creating of namecoin scripts,
+  # as well as methods to extract address, name_hash, name and value.
+  module Script
+
+    def self.included(base)
+      base.constants.each {|c| const_set(c, base.const_get(c)) unless constants.include?(c) }
+      base.class_eval do
+
+        # get the hash160 for this hash160, namecoin or pubkey script
+        def get_hash160
+          return @chunks[2..-3][0].unpack("H*")[0]  if is_hash160?
+          return @chunks[-3].unpack("H*")[0]        if is_namecoin?
+          return Bitcoin.hash160(get_pubkey)        if is_pubkey?
+        end
+
+        # get all addresses this script corresponds to (if possible)
+        def get_addresses
+          return [get_pubkey_address]    if is_pubkey?
+          return [get_hash160_address]   if is_hash160? || is_namecoin?
+          return get_multisig_addresses  if is_multisig?
+        end
+
+        # get type of this tx
+        def type
+          if is_name_new?;            :name_new
+          elsif is_name_firstupdate?; :name_firstupdate
+          elsif is_name_update?;      :name_update
+          elsif is_hash160?;          :hash160
+          elsif is_pubkey?;           :pubkey
+          elsif is_multisig?;         :multisig
+          elsif is_p2sh?;             :p2sh
+          else;                       :unknown
+          end
+        end
+
+        # is namecoin name_new script
+        # OP_1 name_hash OP_2DROP <hash160_script>
+        def is_name_new?
+          return false  if @chunks.size < 8
+          [-8, -6, -5, -4, -2, -1].map {|i| @chunks[i] } ==
+            [OP_1, OP_2DROP, OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG]
+        end
+
+        # is namecoin name_firstupdate script
+        # OP_2 name rand value OP_2DROP OP_2DROP <hash160_script>
+        def is_name_firstupdate?
+          return false  if @chunks.size < 11
+          [-11, -7, -6, -5, -4, -2, -1].map {|i| @chunks[i] } ==
+            [82, OP_2DROP, OP_2DROP, OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG]
+        end
+
+        # is namecoin name_update script
+        # OP_3 name value OP_2DROP OP_DROP <hash160_script>
+        def is_name_update?
+          return false  if @chunks.size < 10
+          [-10, -7, -6, -5, -4, -2, -1].map {|i| @chunks[i] } ==
+            [83, OP_2DROP, OP_DROP, OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG]
+        end
+
+        # is any kind of namecoin script
+        def is_namecoin?
+          is_name_new? || is_name_firstupdate? || is_name_update?
+        end
+
+        # get the name_hash of a namecoin name_new script
+        def get_namecoin_hash
+          return @chunks[-7].hth  if is_name_new?
+          if is_name_firstupdate?
+            name = @chunks[-10].to_s.hth
+            rand = @chunks[-9].to_s.hth
+            return Bitcoin.hash160(rand + name)
+          end
+        rescue
+          nil
+        end
+
+        # get the name of a namecoin name_firstupdate or name_update script
+        def get_namecoin_name
+          return @chunks[-10]  if is_name_firstupdate?
+          return @chunks[-9]  if is_name_update?
+        end
+
+        # get the value of a namecoin name_firstupdate or name_update script
+        def get_namecoin_value
+          @chunks[-8]  if is_name_firstupdate? || is_name_update?
+        end
+
+        # generate name_new tx for given +name+ and +address+.
+        # the +caller+ should be the object that creates the script.
+        # it gets the used random value passed to #set_rand.
+        # OP_1 name_hash OP_2DROP <hash160_script>
+        def self.to_name_new_script(caller, name, address)
+          rand = rand(2**64).to_s(16).rjust(16, '0')
+          name_hash = Bitcoin.hash160(rand + name.unpack("H*")[0])
+          caller.set_rand rand # TODO: this is still ugly
+          [ [ "51", "14",   name_hash, "6d" ].join ].pack("H*") + to_address_script(address)
+        end
+
+        # generate name_firstupdate tx for given +name+, +rand+, +value+ and +address+.
+        # OP_2 name rand value OP_2DROP OP_2DROP <hash160_script>
+        def self.to_name_firstupdate_script(name, rand, value, address)
+          [ [ "52", name.bytesize.to_s(16).rjust(2, '0'), name.hth,
+              rand.htb.bytesize.to_s(16).rjust(2, '0'), rand,
+              value.bytesize.to_s(16).rjust(2, '0'), value.hth,
+              "6d", "6d" ].join ].pack("H*") + to_address_script(address)
+        end
+
+        # generate name_update script for given +name+, +value+ and +address+.
+        # OP_3 name value OP_2DROP OP_DROP <hash160_script>
+        def self.to_name_update_script(name, value, address)
+          [ [ "53", name.bytesize.to_s(16).rjust(2, '0'), name.hth,
+              value.bytesize.to_s(16).rjust(2, '0'), value.hth,
+              "6d", "75" ].join ].pack("H*") + to_address_script(address)
+        end
+
+      end
+    end
+
+  end
+
+  # Namecoin-specific storage methods.
+  # The storage backend only needs to check txout scripts with #is_namecoin? and
+  # pass them to #store_name.
+  # TODO: move rules into Validation
+  module Storage
+
+    module Backend
+
+      def self.included(base)
+        base.constants.each {|c| const_set(c, base.const_get(c)) unless constants.include?(c) }
+        base.class_eval do
+
+          # if this is a namecoin script, update the names index
+          def store_name(script, txout_id)
+            if script.type == :name_new
+              log.debug { "name_new #{script.get_namecoin_hash}" }
+              @db[:names].insert({
+                :txout_id => txout_id,
+                :hash => script.get_namecoin_hash })
+            elsif script.type == :name_firstupdate
+              name_hash = script.get_namecoin_hash
+              name_new = @db[:names].where(:hash => name_hash).order(:txout_id).first
+              if self.class.name =~ /UtxoStore/
+                txout = @db[:utxo][id: name_new[:txout_id]] if name_new
+                blk = @db[:blk][id: txout[:blk_id]]  if txout
+              else
+                txout = @db[:txout][id: name_new[:txout_id]] if name_new
+                tx = @db[:tx][id: txout[:tx_id]] if txout
+                blk_tx = @db[:blk_tx][tx_id: tx[:id]]  if tx
+                blk = @db[:blk][id: blk_tx[:blk_id]] if blk_tx
+              end
+
+              unless name_new && blk && blk[:chain] == 0
+                log.debug { "name_new not found: #{name_hash}" }
+                return nil
+              end
+
+              unless blk[:depth] <= get_depth - Bitcoin::Namecoin::FIRSTUPDATE_LIMIT
+                log.debug { "name_new not yet valid: #{name_hash}" }
+                return nil
+              end
+
+              log.debug { "#{script.type}: #{script.get_namecoin_name}" }
+              @db[:names].where(:txout_id => name_new[:txout_id], :name => nil).update({
+                :name => script.get_namecoin_name.to_s.to_sequel_blob })
+              @db[:names].insert({
+                :txout_id => txout_id,
+                :hash => name_hash,
+                :name => script.get_namecoin_name.to_s.to_sequel_blob,
+                :value => script.get_namecoin_value.to_s.to_sequel_blob })
+            elsif script.type == :name_update
+              log.debug { "#{script.type}: #{script.get_namecoin_name}" }
+              @db[:names].insert({
+                :txout_id => txout_id,
+                :name => script.get_namecoin_name.to_s.to_sequel_blob,
+                :value => script.get_namecoin_value.to_s.to_sequel_blob })
+            end
+          end
+
+          def name_show name
+            names = @db[:names].where(:name => name.to_sequel_blob).order(:txout_id).reverse
+            return nil  unless names.any?
+            wrap_name(names.first)
+          end
+          alias :get_name :name_show
+
+          def name_history name
+            history = @db[:names].where(:name => name.to_sequel_blob)
+              .where("value IS NOT NULL").order(:txout_id).map {|n| wrap_name(n) }
+            history.select! {|n| n.get_tx.blk_id }  unless self.class.name =~ /Utxo/ 
+            history
+          end
+
+          def get_name_by_txout_id txout_id
+            wrap_name(@db[:names][:txout_id => txout_id])
+          end
+
+          def wrap_name(data)
+            return nil  unless data
+            Bitcoin::Storage::Models::Name.new(self, data)
+          end
+
+        end
+      end
+
+    end
+
+    module Models
+
+      class Name
+
+        attr_reader :store, :txout_id, :hash, :name, :value
+
+        def initialize store, data
+          @store = store
+          @txout_id = data[:txout_id]
+          @hash = data[:hash]
+          @name = data[:name]
+          @value = data[:value]
+        end
+
+        def get_txout
+          if @txout_id.is_a?(Array)
+            @store.get_tx(@txout_id[0]).out[@txout_id[1]]
+          else
+            @store.get_txout_by_id(@txout_id)
+          end
+        end
+
+        def get_address
+          get_txout.get_address
+        end
+
+        def get_tx
+          get_txout.get_tx rescue nil
+        end
+
+        def get_block
+          get_tx.get_block rescue nil
+        end
+
+        def expires_in
+          Namecoin::EXPIRATION_DEPTH - (@store.get_depth - get_block.depth) rescue nil
+        end
+
+        def to_json(opts = {})
+          JSON.pretty_generate({ name: @name, value: @value, txid: get_tx.hash,
+                                 address: get_address, expires_in: expires_in }, opts)
+        end
+
+      end
+
+    end
+
+  end
+
+end