bitcoinrb 0.3.1 → 0.7.0

data/lib/bitcoin/message/merkle_block.rb

@@ -20,7 +20,7 @@ module Bitcoin
         m = new
         buf = StringIO.new(payload)
         m.header = Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
-        m.tx_count = buf.read(4).unpack('V').first
+        m.tx_count = buf.read(4).unpack1('V')
         hash_count = Bitcoin.unpack_var_int_from_io(buf)
         hash_count.times do
           m.hashes << buf.read(32).bth

data/lib/bitcoin/message/network_addr.rb

@@ -1,10 +1,16 @@
 require 'ipaddr'
+require 'base32'
 
 module Bitcoin
   module Message
 
+    NETWORK_ID = {ipv4: 0x01, ipv6: 0x02, tor_v2: 0x03, tor_v3: 0x04, i2p: 0x05, cjdns: 0x06}
+    INTERNAL_IN_IPV6_PREFIX = "fd6b:88c0:8724"
+
     class NetworkAddr
 
+      TYPE = {legacy: 0x01, addr_v2: 0x02}
+
       # unix time.
       # Nodes advertising their own IP address set this to the current time.
       # Nodes advertising IP addresses they’ve connected to set this to the last time they connected to that node.
@@ -14,47 +20,164 @@ module Bitcoin
       # The services the node advertised in its version message.
       attr_accessor :services
 
-      attr_accessor :ip_addr # IPAddr
+      attr_accessor :net # network ID that defined by BIP-155
+
+      # Network address. The interpretation depends on networkID.
+      # If ipv4 or ipv6 this field is a IPAddr object, otherwise hex string.
+      attr_accessor :addr
 
       attr_accessor :port
 
       attr_reader :skip_time
 
-      def initialize(ip: '127.0.0.1', port: Bitcoin.chain_params.default_port, services: DEFAULT_SERVICE_FLAGS, time: Time.now.to_i)
+      def initialize(ip: '127.0.0.1', port: Bitcoin.chain_params.default_port,
+                     services: DEFAULT_SERVICE_FLAGS, time: Time.now.to_i, net: NETWORK_ID[:ipv4])
         @time = time
-        @ip_addr = IPAddr.new(ip)
         @port = port
         @services = services
+        @net = net
+        case net
+        when NETWORK_ID[:ipv4], NETWORK_ID[:ipv6]
+          @addr = IPAddr.new(ip) if ip
+        end
       end
 
-      def self.parse_from_payload(payload)
-        buf = payload.is_a?(String) ? StringIO.new(payload) : payload
-        has_time = buf.size > 26
-        addr = new(time: nil)
-        addr.time = buf.read(4).unpack('V').first if has_time
-        addr.services = buf.read(8).unpack('Q').first
-        addr.ip_addr = IPAddr::new_ntoh(buf.read(16))
-        addr.port = buf.read(2).unpack('n').first
-        addr
+      # Parse addr payload
+      # @param [String] payload payload of addr
+      # @param [Integer] type Address format type
+      # @return [NetworkAddr]
+      def self.parse_from_payload(payload, type: TYPE[:legacy])
+        case type
+        when TYPE[:legacy]
+          load_legacy_payload(payload)
+        when TYPE[:addr_v2]
+          load_addr_v2_payload(payload)
+        else
+          raise Bitcoin::Message::Error, "Unknown type: #{type}."
+        end
       end
 
       def self.local_addr
         addr = new
-        addr.ip_addr = IPAddr.new('127.0.0.1')
+        addr.addr = IPAddr.new('127.0.0.1')
         addr.port = Bitcoin.chain_params.default_port
         addr.services = DEFAULT_SERVICE_FLAGS
         addr
       end
 
-      def ip
-        ip_addr.ipv4_mapped? ? ip_addr.native : ip_addr.to_s
+      # Show addr string. e.g 127.0.0.1
+      def addr_string
+        case net
+        when NETWORK_ID[:ipv4]
+          addr.native
+        when NETWORK_ID[:ipv6]
+          if addr.to_s.start_with?(INTERNAL_IN_IPV6_PREFIX)
+            Base32.encode(addr.hton[6..-1]).downcase.delete('=') + ".internal"
+          else
+            addr.to_s
+          end
+        when NETWORK_ID[:tor_v2]
+          Base32.encode(addr.htb).downcase + ".onion"
+        when NETWORK_ID[:tor_v3]
+          # TORv3 onion_address = base32(PUBKEY | CHECKSUM | VERSION) + ".onion"
+          pubkey = addr.htb
+          checksum = OpenSSL::Digest.new('SHA3-256').digest('.onion checksum' + pubkey + "\x03")
+          Base32.encode(pubkey + checksum[0...2] + "\x03").downcase + ".onion"
+        when NETWORK_ID[:i2p]
+          Base32.encode(addr.htb).downcase.delete('=') + ".b32.i2p"
+        when NETWORK_ID[:cjdns]
+          addr.to_s
+        end
+      end
+
+      def to_payload(skip_time = false, type: TYPE[:legacy])
+        case type
+        when TYPE[:legacy]
+          legacy_payload(skip_time)
+        when TYPE[:addr_v2]
+          v2_payload
+        else
+          raise Bitcoin::Message::Error, "Unknown type: #{type}."
+        end
       end
 
-      def to_payload(skip_time = false)
+      # Load addr payload with legacy format.
+      def self.load_legacy_payload(payload)
+        buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+        has_time = buf.size > 26
+        addr = NetworkAddr.new(time: nil)
+        addr.time = buf.read(4).unpack1('V') if has_time
+        addr.services = buf.read(8).unpack1('Q')
+        addr.addr = IPAddr::new_ntoh(buf.read(16))
+        addr.port = buf.read(2).unpack1('n')
+        addr
+      end
+
+      # Load addr payload with addr v2 format.
+      def self.load_addr_v2_payload(payload)
+        buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+        addr = NetworkAddr.new(time: buf.read(4).unpack1('V'))
+        addr.services = Bitcoin.unpack_var_int_from_io(buf)
+        addr.net = buf.read(1).unpack1('C')
+        raise Bitcoin::Message::Error, "Unknown network id: #{addr.net}" unless NETWORK_ID.value?(addr.net)
+        addr_len = Bitcoin.unpack_var_int_from_io(buf)
+        addr.addr = case addr.net 
+                    when NETWORK_ID[:ipv4]
+                      raise Bitcoin::Message::Error, "Invalid IPv4 address." unless addr_len == 4
+                      IPAddr::new_ntoh(buf.read(addr_len))
+                    when NETWORK_ID[:ipv6]
+                      raise Bitcoin::Message::Error, "Invalid IPv6 address." unless addr_len == 16
+                      a = IPAddr::new_ntoh(buf.read(addr_len))
+                      raise Bitcoin::Message::Error, "Invalid IPv6 address." if a.ipv4_mapped?
+                      a
+                    when NETWORK_ID[:tor_v2]
+                      raise Bitcoin::Message::Error, "Invalid Tor v2 address." unless addr_len == 10
+                      buf.read(addr_len).bth
+                    when NETWORK_ID[:tor_v3]
+                      raise Bitcoin::Message::Error, "Invalid Tor v3 address." unless addr_len == 32
+                      buf.read(addr_len).bth
+                    when NETWORK_ID[:i2p]
+                      raise Bitcoin::Message::Error, "Invalid I2P address." unless addr_len == 32
+                      buf.read(addr_len).bth
+                    when NETWORK_ID[:cjdns]
+                      raise Bitcoin::Message::Error, "Invalid CJDNS address." unless addr_len == 16
+                      a = IPAddr::new_ntoh(buf.read(addr_len))
+                      raise Bitcoin::Message::Error, "Invalid CJDNS address." unless a.to_s.start_with?('fc00:')
+                      a
+                    end
+        addr.port = buf.read(2).unpack1('n')
+        addr
+      end
+
+      def legacy_payload(skip_time)
         p = ''
         p << [time].pack('V') unless skip_time
-        addr = ip_addr.ipv4? ? ip_addr.ipv4_mapped : ip_addr
-        p << [services].pack('Q') << addr.hton << [port].pack('n')
+        ip = addr.ipv4? ? addr.ipv4_mapped : addr
+        p << [services].pack('Q') << ip.hton << [port].pack('n')
+      end
+
+      def v2_payload
+        p = [time].pack('V')
+        p << Bitcoin.pack_var_int(services)
+        p << [net].pack('C')
+        case net
+        when NETWORK_ID[:ipv4]
+          p << Bitcoin.pack_var_int(4)
+          p << addr.to_i.to_s(16).htb
+        when NETWORK_ID[:ipv6]
+          p << Bitcoin.pack_var_int(16)
+          p << addr.hton
+        when NETWORK_ID[:tor_v2]
+          p << Bitcoin.pack_var_int(10)
+        when NETWORK_ID[:tor_v3]
+          p << Bitcoin.pack_var_int(32)
+        when NETWORK_ID[:i2p]
+          p << Bitcoin.pack_var_int(32)
+        when NETWORK_ID[:cjdns]
+          p << Bitcoin.pack_var_int(16)
+        end
+        p << [port].pack('n')
+        p
       end
 
     end

data/lib/bitcoin/message/ping.rb

@@ -14,7 +14,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        new(payload.unpack('Q').first)
+        new(payload.unpack1('Q'))
       end
 
       def to_payload

data/lib/bitcoin/message/pong.rb

@@ -14,7 +14,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        new(payload.unpack('Q').first)
+        new(payload.unpack1('Q'))
       end
 
       def to_payload

data/lib/bitcoin/message/send_addr_v2.rb

@@ -0,0 +1,13 @@
+module Bitcoin
+  module Message
+    class SendAddrV2 < Base
+
+      COMMAND = 'sendaddrv2'
+
+      def to_payload
+        ''
+      end
+
+    end
+  end
+end

data/lib/bitcoin/message/send_cmpct.rb

@@ -21,8 +21,8 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        mode = buf.read(1).unpack('c').first
-        version = buf.read(8).unpack('Q').first
+        mode = buf.read(1).unpack1('c')
+        version = buf.read(8).unpack1('Q')
         new(mode, version)
       end
 

data/lib/bitcoin/message/version.rb

@@ -64,6 +64,13 @@ module Bitcoin
         ( version >= 70001 && payload ) ? unpack_boolean(payload) : [ true, nil ]
       end
 
+      # Check whether +service_flag+ support this version.
+      # @param [Integer] service_flag the service flags.
+      # @return [Boolean] whether support +service_flag+
+      def support?(service_flag)
+        (services & service_flag) != 0
+      end
+
     end
   end
 end

data/lib/bitcoin/mnemonic.rb

@@ -6,11 +6,11 @@ module Bitcoin
 
     WORD_DIR = "#{__dir__}/mnemonic/wordlist"
 
-    attr_reader :word_list
+    attr_reader :language
 
-    def initialize(word_list)
-      raise ArgumentError, 'specified language is not supported.' unless Mnemonic.word_lists.include?(word_list)
-      @word_list = word_list
+    def initialize(language)
+      raise ArgumentError, 'specified language is not supported.' unless Mnemonic.word_lists.include?(language)
+      @language = language
     end
 
     # get support language list
@@ -39,7 +39,7 @@ module Bitcoin
     # @return [Array] the array of mnemonic word.
     def to_mnemonic(entropy)
       raise ArgumentError, 'entropy is empty.' if entropy.nil? || entropy.empty?
-      e = entropy.htb.unpack('B*').first
+      e = entropy.htb.unpack1('B*')
       seed = e + checksum(e)
       mnemonic_index = seed.chars.each_slice(11).map{|i|i.join.to_i(2)}
       word_master = load_words
@@ -61,7 +61,7 @@ module Bitcoin
     # @param [String] entropy an entropy with bit string format
     # @return [String] an entropy checksum with bit string format
     def checksum(entropy)
-      b = Bitcoin.sha256([entropy].pack('B*')).unpack('B*').first
+      b = Bitcoin.sha256([entropy].pack('B*')).unpack1('B*')
       b.slice(0, (entropy.length/32))
     end
 
@@ -69,7 +69,7 @@ module Bitcoin
 
     # load word list contents
     def load_words
-      File.readlines("#{WORD_DIR}/#{word_list}.txt").map(&:strip)
+      File.readlines("#{WORD_DIR}/#{language}.txt").map(&:strip)
     end
 
   end

data/lib/bitcoin/network/peer.rb

@@ -83,10 +83,15 @@ module Bitcoin
 
       def post_handshake
         @connected = true
-        pool.handle_new_peer(self)
-        # require remote peer to use headers message instead fo inv message.
-        conn.send_message(Bitcoin::Message::SendHeaders.new)
-        EM.add_periodic_timer(PING_INTERVAL) {send_ping}
+        if remote_version.support?(Bitcoin::Message::SERVICE_FLAGS[:bloom])
+          pool.handle_new_peer(self)
+          # require remote peer to use headers message instead fo inv message.
+          conn.send_message(Bitcoin::Message::SendHeaders.new)
+          EM.add_periodic_timer(PING_INTERVAL) {send_ping}
+        else
+          close("peer does not support NODE_BLOOM.")
+          pool.pending_peers.delete(self)
+        end
       end
 
       # start block header download

data/lib/bitcoin/network/peer_discovery.rb

@@ -30,7 +30,7 @@ module Bitcoin
         logger.debug 'discover peer address from DNS seeds.'
         dns_seeds.map { |seed|
           begin
-            Socket.getaddrinfo(seed, Bitcoin.chain_params.default_port).map{|a|a[2]}.uniq
+            Socket.getaddrinfo("#{seed}", Bitcoin.chain_params.default_port).map{|a|a[2]}.uniq
           rescue SocketError => e
             logger.error "SocketError occurred when load DNS seed: #{seed}, error: #{e.message}"
             nil

data/lib/bitcoin/node/cli.rb

@@ -1,4 +1,4 @@
-require 'rest-client'
+require 'net/http'
 require 'thor'
 require 'json'
 
@@ -92,15 +92,19 @@ module Bitcoin
             :id => 'jsonrpc'
         }
         begin
-          RestClient::Request.execute(method: :post, url: config.server_url, payload: data.to_json,
-                                      headers: {content_type: :json}) do |response, request, result|
-            return false if !result.kind_of?(Net::HTTPSuccess) && response.empty?
-            begin
-              json = JSON.parse(response.to_str)
-              puts JSON.pretty_generate(json)
-            rescue Exception
-              puts response.to_str
-            end
+          uri = URI.parse(config.server_url)
+          http = Net::HTTP.new(uri.hostname, uri.port)
+          http.use_ssl = uri.scheme === "https"
+          request = Net::HTTP::Post.new('/')
+          request.content_type = 'application/json'
+          request.body = data.to_json
+          response = http.request(request)
+          body = response.body
+          begin
+          json = JSON.parse(body.to_str)
+          puts JSON.pretty_generate(json)
+          rescue Exception
+            puts body.to_str
           end
         rescue Exception => e
           puts e.message

data/lib/bitcoin/node/configuration.rb

@@ -4,8 +4,10 @@ module Bitcoin
   module Node
     class Configuration
 
-      attr_reader :conf
+      attr_reader :conf # Hash
 
+      # initialize configuration
+      # @param [Hash] opts parameter for node.
       def initialize(opts = {})
         # TODO apply configuration file.
         opts[:network] = :mainnet unless opts[:network]

data/lib/bitcoin/node/spv.rb

@@ -13,6 +13,14 @@ module Bitcoin
       attr_accessor :wallet
       attr_accessor :bloom
 
+      # Initialize spv settings
+      # @param [Bitcoin::Node::Configuration] configuration configuration for spv.
+      #
+      # ```ruby
+      # config = Bitcoin::Node::Configuration.new(network: :mainnet)
+      # spv = Bitcoin::Node::SPV.new(config)
+      # spv.run
+      # ````
       def initialize(configuration)
         @chain = Bitcoin::Store::SPVChain.new
         @configuration = configuration
@@ -45,7 +53,7 @@ module Bitcoin
       # broadcast a transaction
       def broadcast(tx)
         pool.broadcast(tx)
-        logger.debug "broadcast tx: #{tx.to_payload.bth}"
+        logger.debug "broadcast tx: #{tx.to_hex}"
       end
 
       # add filter element to bloom filter.

data/lib/bitcoin/opcodes.rb

@@ -136,6 +136,8 @@ module Bitcoin
     OP_NOP9 = 0xb8
     OP_NOP10 = 0xb9
 
+    OP_CHECKSIGADD = 0xba # BIP 342 opcodes (Tapscript)
+
     # https://en.bitcoin.it/wiki/Script#Pseudo-words
     OP_PUBKEYHASH = 0xfd
     OP_PUBKEY = 0xfe
@@ -145,6 +147,9 @@ module Bitcoin
     OPCODES_MAP = Hash[*(constants.grep(/^OP_/) - [:OP_NOP2, :OP_NOP3, :OP_CHECKLOCKTIMEVERIFY, :OP_CHECKSEQUENCEVERIFY]).map { |c| [const_get(c), c.to_s] }.flatten]
     NAME_MAP = Hash[*constants.grep(/^OP_/).map { |c| [c.to_s, const_get(c)] }.flatten]
 
+    OP_SUCCESSES = [0x50, 0x62, 0x89, 0x8a, 0x8d, 0x8e, (0x7e..0x81).to_a,
+                    (0x83..0x86).to_a, (0x95..0x99).to_a, (0xbb..0xfe).to_a].flatten
+
     def opcode_to_name(opcode)
       return OPCODES_MAP[opcode].delete('OP_') if opcode == OP_0 || (opcode <= OP_16 && opcode >= OP_1)
       OPCODES_MAP[opcode]
@@ -156,7 +161,8 @@ module Bitcoin
     end
 
     # whether opcode is predefined opcode
-    def defined?(opcode)
+    def defined?(opcode, allow_success = false)
+      return true if allow_success && op_success?(opcode)
       !opcode_to_name(opcode).nil?
     end
 
@@ -174,5 +180,12 @@ module Bitcoin
       nil
     end
 
+    # Check whether +opcode+ is OP_SUCCESSx or not?
+    # @param [Integer] opcode an opcode.
+    # @return [Boolean] if +opcode+ is OP_SUCCESSx return true, otherwise false.
+    def op_success?(opcode)
+      OP_SUCCESSES.include?(opcode)
+    end
+
   end
 end