monacoin-ruby 0.1.2 → 0.1.3

data/lib/bitcoin/litecoin.rb

@@ -0,0 +1,83 @@
+require 'openssl'
+
+module Litecoin
+  module Scrypt
+
+    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)
+    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"
+  secret_bytes = [secret_hex].pack("H*")
+ 
+  begin
+    require "scrypt"
+    hash = SCrypt::Engine.__sc_crypt(secret_bytes, secret_bytes, 1024, 1, 1, 32)
+    p hash.reverse.unpack("H*")[0] == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806"
+  rescue LoadError
+    puts "scrypt gem not found, using native scrypt"
+    p Litecoin::Scrypt.scrypt_1024_1_1_256_sp(secret_bytes).reverse.unpack("H*")[0] == "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806"
+  end
+
+  require 'benchmark'
+  Benchmark.bmbm{|x|
+    x.report("v1"){ SCrypt::Engine.__sc_crypt(secret_bytes, secret_bytes, 1024, 1, 1, 32).reverse.unpack("H*") rescue nil }
+    x.report("v2"){ Litecoin::Scrypt.scrypt_1024_1_1_256_sp(secret_bytes).reverse.unpack("H*")[0] }
+  }
+end

data/lib/bitcoin/logger.rb

@@ -0,0 +1,86 @@
+# encoding: ascii-8bit
+
+begin
+  require 'log4r'
+  # monkey-patch Log4r to accept level names as symbols
+  class Log4r::Logger
+    def level= l = 0
+      _level = l.is_a?(Fixnum) ? l : Log4r::LNAMES.index(l.to_s.upcase)
+      Log4r::Log4rTools.validate_level(_level)
+      @level = _level
+      LoggerFactory.define_methods(self)
+      Log4r::Logger.log_internal {"Logger '#{@fullname}' set to #{LNAMES[@level]}"}
+      @level
+    end
+  end
+rescue LoadError
+end
+
+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)
+        @name, @level = name, :info
+      end
+
+      def level= level
+        @level = level.is_a?(Fixnum) ? LEVELS[level] : level.to_sym
+      end
+
+      LEVELS.each do |level|
+        define_method(level) do |*msg, &block|
+          return  if LEVELS.index(level.to_sym) < LEVELS.index(@level.to_sym)
+          msg = block ? block.call : msg.join
+          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
+    class LogWrapper
+      def initialize(name, log); @name, @log = name, log; end
+      def method_missing(m, *a, &blk)
+        @log.send(m, *a, &proc{ "#{@name} #{blk.call}" })
+      end
+    end
+
+    # create a logger with given +name+. if log4r is installed, the logger
+    # will have a stdout and a fileout outputter to `log/<name>.log`.
+    # 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 => "#{dir}/#{name}.log")  if dir
+      else
+        @log = Bitcoin::Logger::Logger.new(name)
+      end
+      @log
+    end
+
+  end
+end

data/lib/bitcoin/protocol.rb

@@ -0,0 +1,189 @@
+# encoding: ascii-8bit
+
+require 'socket'
+require 'digest/sha2'
+require 'json'
+
+module Bitcoin
+  module Protocol
+
+    # bitcoin/src/main.h
+    MAX_INV_SZ = 50000
+
+    # BIP 0031, pong message, is enabled for all versions AFTER this one
+    BIP0031_VERSION = 60000
+
+    autoload :ScriptWitness, 'bitcoin/protocol/script_witness'
+    autoload :TxIn,          'bitcoin/protocol/txin'
+    autoload :TxOut,         'bitcoin/protocol/txout'
+    autoload :Tx,            'bitcoin/protocol/tx'
+    autoload :Block,         'bitcoin/protocol/block'
+    autoload :Addr,          'bitcoin/protocol/address'
+    autoload :Alert,         'bitcoin/protocol/alert'
+    autoload :Reject,        'bitcoin/protocol/reject'
+    autoload :Version,       'bitcoin/protocol/version'
+    autoload :AuxPow,        'bitcoin/protocol/aux_pow'
+    autoload :PartialMerkleTree,  'bitcoin/protocol/partial_merkle_tree'
+
+    autoload :Handler, 'bitcoin/protocol/handler'
+    autoload :Parser,  'bitcoin/protocol/parser'
+
+    Uniq = rand(0xffffffffffffffff)
+
+    # var_int refers to https://en.bitcoin.it/wiki/Protocol_specification#Variable_length_integer and is what Satoshi called "CompactSize"
+    # BitcoinQT has later added even more compact format called CVarInt to use in its local block storage. CVarInt is not implemented here.
+    def self.unpack_var_int(payload)
+      case payload.unpack("C")[0] # TODO add test cases
+      when 0xfd; payload.unpack("xva*")
+      when 0xfe; payload.unpack("xVa*")
+      when 0xff; payload.unpack("xQa*") # TODO add little-endian version of Q
+      else;      payload.unpack("Ca*")
+      end
+    end
+
+    def self.unpack_var_int_from_io(io)
+      uchar = io.read(1).unpack("C")[0]
+      case uchar
+      when 0xfd; io.read(2).unpack("v")[0]
+      when 0xfe; io.read(4).unpack("V")[0]
+      when 0xff; io.read(8).unpack("Q")[0]
+      else;      uchar
+      end
+    end
+
+    def self.pack_var_int(i)
+      if    i <  0xfd;                [      i].pack("C")
+      elsif i <= 0xffff;              [0xfd, i].pack("Cv")
+      elsif i <= 0xffffffff;          [0xfe, i].pack("CV")
+      elsif i <= 0xffffffffffffffff;  [0xff, i].pack("CQ")
+      else raise "int(#{i}) too large!"
+      end
+    end
+
+    def self.unpack_var_string(payload)
+      size, payload = unpack_var_int(payload)
+      size > 0 ? (string, payload = payload.unpack("a#{size}a*")) : [nil, payload]
+    end
+
+    def self.unpack_var_string_from_io(buf)
+      size = unpack_var_int_from_io(buf)
+      size > 0 ? buf.read(size) : nil
+    end
+
+    def self.pack_var_string(payload)
+      pack_var_int(payload.bytesize) + payload
+    end
+
+    def self.unpack_var_string_array(payload) # unpacks set<string>
+      buf = StringIO.new(payload)
+      size = unpack_var_int_from_io(buf)
+      return [nil, buf.read] if size == 0
+      strings = []
+      size.times{
+        break if buf.eof?
+        strings << unpack_var_string_from_io(buf)
+      }
+      [strings, buf.read]
+    end
+
+    def self.unpack_var_int_array(payload) # unpacks set<int>
+      buf = StringIO.new(payload)
+      size =  unpack_var_int_from_io(buf)
+      return [nil, buf.read] if size == 0
+      ints = []
+      size.times{
+        break if buf.eof?
+        ints << unpack_var_int_from_io(buf)
+      }
+      [ints, buf.read]
+    end
+
+    def self.unpack_boolean(payload)
+      bdata, payload = payload.unpack("Ca*")
+      [ (bdata == 0 ? false : true), payload ]
+    end
+
+    def self.pack_boolean(b)
+      (b == true) ? [0xFF].pack("C") : [0x00].pack("C")
+    end
+
+    BINARY = Encoding.find('ASCII-8BIT')
+
+    def self.pkt(command, payload)
+      cmd      = command.ljust(12, "\x00")[0...12]
+      length   = [payload.bytesize].pack("V")
+      checksum = Digest::SHA256.digest(Digest::SHA256.digest(payload))[0...4]
+      pkt      = "".force_encoding(BINARY)
+      pkt << Bitcoin.network[:magic_head].force_encoding(BINARY) << cmd.force_encoding(BINARY) << length << checksum << payload.force_encoding(BINARY)
+    end
+
+    def self.version_pkt(from_id, from=nil, to=nil, last_block=nil, time=nil, user_agent=nil, version=nil)
+      opts = if from_id.is_a?(Hash)
+        from_id
+      else
+        STDERR.puts "Bitcoin::Protocol.version_pkt - API deprecated. please change it soon.."
+        {
+          :nonce => from_id, :from => from, :to => to, :last_block => last_block,
+          :time => time, :user_agent => user_agent, :version => version
+        }
+      end
+      version = Protocol::Version.new(opts)
+      version.to_pkt
+    end
+
+    def self.ping_pkt(nonce = rand(0xffffffff))
+      pkt("ping", [nonce].pack("Q"))
+    end
+
+    def self.pong_pkt(nonce)
+      pkt("pong", [nonce].pack("Q"))
+    end
+
+    def self.verack_pkt
+      pkt("verack", "")
+    end
+
+    TypeLookup = Hash[:tx, 1, :block, 2, :filtered_block, 3, nil, 0]
+
+    def self.getdata_pkt(type, hashes)
+      return if hashes.size > MAX_INV_SZ
+      t = [ TypeLookup[type] ].pack("V")
+      pkt("getdata", pack_var_int(hashes.size) + hashes.map{|hash| t + hash[0..32].reverse }.join)
+    end
+
+    def self.inv_pkt(type, hashes)
+      return if hashes.size > MAX_INV_SZ
+      t = [ TypeLookup[type] ].pack("V")
+      pkt("inv", pack_var_int(hashes.size) + hashes.map{|hash| t + hash[0..32].reverse }.join)
+    end
+
+    DEFAULT_STOP_HASH = "00"*32
+
+    def self.locator_payload(version, locator_hashes, stop_hash)
+      [
+        [version].pack("V"),
+        pack_var_int(locator_hashes.size),
+        locator_hashes.map{|l| l.htb_reverse }.join,
+        stop_hash.htb_reverse
+      ].join
+    end
+
+    def self.getblocks_pkt(version, locator_hashes, stop_hash=DEFAULT_STOP_HASH)
+      pkt "getblocks",  locator_payload(version, locator_hashes, stop_hash)
+    end
+
+    def self.getheaders_pkt(version, locator_hashes, stop_hash=DEFAULT_STOP_HASH)
+      pkt "getheaders", locator_payload(version, locator_hashes, stop_hash)
+    end
+
+    def self.headers_pkt(version, blocks)
+      pkt "headers", [pack_var_int(blocks.size), blocks.map{|block| block.block_header}.join].join
+    end
+
+    def self.read_binary_file(path)
+      File.open(path, 'rb'){|f| f.read }
+    end
+  end
+
+  P = Protocol
+end

data/lib/bitcoin/protocol/address.rb

@@ -0,0 +1,50 @@
+# encoding: ascii-8bit
+
+module Bitcoin
+  module Protocol
+
+    class Addr < Struct.new(:time, :service, :ip, :port)
+
+      # # IP Address / Port
+      # attr_reader :ip, :port
+
+      # # Time the node was last active
+      # attr_reader :time
+
+      # # Services supported by this node
+      # attr_reader :service
+
+      # create addr from raw binary +data+
+      def initialize(data = nil)
+        if data
+          self[:time], self[:service], self[:ip], self[:port] = data.unpack("VQx12a4n")
+          self[:ip] = ip.unpack("C*").join(".")
+        else
+          self[:time], self[:service] = Time.now.to_i, 1
+          self[:ip], self[:port] = "127.0.0.1", Bitcoin.network[:default_port]
+        end
+      end
+
+      # is this address alive?
+      def alive?
+        (Time.now.tv_sec-7200) <= self[:time]
+      end
+
+      def to_payload
+        ip = self[:ip].split(".").map(&:to_i)
+        [ time, service, ("\x00"*10)+"\xff\xff", *ip, port ].pack("VQa12C4n")
+      end
+
+      def string
+        "#{self[:ip]}:#{self[:port]}"
+      end
+
+      def self.pkt(*addrs)
+        addrs = addrs.select{|i| i.is_a?(Bitcoin::Protocol::Addr) && i.ip =~ /^\d+\.\d+\.\d+\.\d+$/ }
+        length = Bitcoin::Protocol.pack_var_int(addrs.size)
+        Bitcoin::Protocol.pkt("addr", length + addrs.map(&:to_payload).join)
+      end
+    end
+
+  end
+end

data/lib/bitcoin/protocol/alert.rb

@@ -0,0 +1,46 @@
+# encoding: ascii-8bit
+
+module Bitcoin
+module Protocol
+
+  class Alert < Struct.new(:version, :relay_until, :expiration, :id, :cancel, :set_cancel,
+                           :min_ver, :max_ver, :set_sub_ver, :priority, :comment, :status_bar, :reserved)
+
+    attr_accessor :payload, :signature
+
+    def initialize(values, alert_payload=nil, alert_signature=nil)
+      @payload, @signature = alert_payload, alert_signature
+      super(*values)
+    end
+
+    def valid_signature?
+      return false unless @payload && @signature
+      hash = Digest::SHA256.digest(Digest::SHA256.digest(@payload))
+      Bitcoin.network[:alert_pubkeys].any?{|public_key| Bitcoin.verify_signature(hash, @signature, public_key) }
+    end
+
+
+    def self.parse(payload)
+      count,             payload = Bitcoin::Protocol.unpack_var_int(payload)
+      alert_payload,     payload = payload.unpack("a#{count}a*")
+      count,             payload = Bitcoin::Protocol.unpack_var_int(payload)
+      alert_signature,   payload = payload.unpack("a#{count}a*")
+
+      version, relay_until, expiration, id, cancel, payload = alert_payload.unpack("VQQVVa*")
+
+      set_cancel,        payload = Bitcoin::Protocol.unpack_var_int_array(payload)
+      min_ver, max_ver,  payload = payload.unpack("VVa*")
+      set_sub_ver,       payload = Bitcoin::Protocol.unpack_var_string_array(payload)
+      priority,          payload = payload.unpack("Va*")
+      comment,           payload = Bitcoin::Protocol.unpack_var_string(payload)
+      status_bar,        payload = Bitcoin::Protocol.unpack_var_string(payload)
+      reserved,          payload = Bitcoin::Protocol.unpack_var_string(payload)
+
+      values = [ version, relay_until, expiration, id, cancel, set_cancel, min_ver, max_ver, set_sub_ver, priority, comment, status_bar, reserved ]
+
+      new(values, alert_payload, alert_signature)
+    end
+  end
+
+end
+end