bitcoinrb 0.1.1 → 0.1.2

data/lib/bitcoin/network/message_handler.rb

@@ -0,0 +1,192 @@
+module Bitcoin
+  module Network
+
+    # P2P message handler used by peer connection class.
+    module MessageHandler
+
+      # handle p2p message.
+      def handle(message)
+        logger.info "handle message #{message.bth}"
+        begin
+          parse(message)
+        rescue Bitcoin::Message::Error => e
+          logger.error("invalid header magic. #{e.message}")
+          close
+        end
+      end
+
+      def parse(message)
+        @message += message
+        command, payload, rest = parse_header
+        return unless command
+
+        handle_command(command, payload)
+        @message = ""
+        parse(rest) if rest && rest.bytesize > 0
+      end
+
+      def parse_header
+        head_magic = Bitcoin.chain_params.magic_head
+        return if @message.nil? || @message.size < MESSAGE_HEADER_SIZE
+
+        magic, command, length, checksum = @message.unpack('a4A12Va4')
+        raise Bitcoin::Message::Error, "invalid header magic. #{magic.bth}" unless magic.bth == head_magic
+
+        payload = @message[MESSAGE_HEADER_SIZE...(MESSAGE_HEADER_SIZE + length)]
+        return if payload.size < length
+        raise Bitcoin::Message::Error, "header checksum mismatch. #{checksum.bth}" unless Bitcoin.double_sha256(payload)[0...4] == checksum
+
+        rest = @message[(MESSAGE_HEADER_SIZE + length)..-1]
+        [command, payload, rest]
+      end
+
+      def handle_command(command, payload)
+        logger.info("[#{addr}] process command #{command}. payload = #{payload.bth}")
+        case command
+          when Bitcoin::Message::Version::COMMAND
+            on_version(Bitcoin::Message::Version.parse_from_payload(payload))
+          when Bitcoin::Message::VerAck::COMMAND
+            on_ver_ack
+          when Bitcoin::Message::GetAddr::COMMAND
+            on_get_addr
+          when Bitcoin::Message::Addr::COMMAND
+            on_addr(Bitcoin::Message::Addr.parse_from_payload(payload))
+          when Bitcoin::Message::SendHeaders::COMMAND
+            on_send_headers
+          when Bitcoin::Message::FeeFilter::COMMAND
+            on_fee_filter(Bitcoin::Message::FeeFilter.parse_from_payload(payload))
+          when Bitcoin::Message::Ping::COMMAND
+            on_ping(Bitcoin::Message::Ping.parse_from_payload(payload))
+          when Bitcoin::Message::Pong::COMMAND
+            on_pong(Bitcoin::Message::Pong.parse_from_payload(payload))
+          when Bitcoin::Message::GetHeaders::COMMAND
+            on_get_headers(Bitcoin::Message::GetHeaders.parse_from_payload(payload))
+          when Bitcoin::Message::Headers::COMMAND
+            on_headers(Bitcoin::Message::Headers.parse_from_payload(payload))
+          when Bitcoin::Message::Block::COMMAND
+            on_block(Bitcoin::Message::Block.parse_from_payload(payload))
+          when Bitcoin::Message::Tx::COMMAND
+            on_tx(Bitcoin::Message::Tx.parse_from_payload(payload))
+          when Bitcoin::Message::NotFound::COMMAND
+            on_not_found(Bitcoin::Message::NotFound.parse_from_payload(payload))
+          when Bitcoin::Message::MemPool::COMMAND
+            on_mem_pool
+          when Bitcoin::Message::Reject::COMMAND
+            on_reject(Bitcoin::Message::Reject.parse_from_payload(payload))
+          when Bitcoin::Message::SendCmpct::COMMAND
+            on_send_cmpct(Bitcoin::Message::SendCmpct.parse_from_payload(payload))
+          when Bitcoin::Message::Inv::COMMAND
+            on_inv(Bitcoin::Message::Inv.parse_from_payload(payload))
+          else
+            logger.warn("unsupported command received. #{command}")
+            close("with command #{command}")
+        end
+      end
+
+      def send_message(msg)
+        logger.info "send message #{msg.class::COMMAND}"
+        send_data(msg.to_pkt)
+      end
+
+      # start handshake
+      def begin_handshake
+        logger.info "begin handshake with #{addr}"
+        ver = Bitcoin::Message::Version.new(remote_addr: addr, start_height: 0) # TODO use start_height in wallet
+        send_message(ver)
+      end
+
+      def handshake_done
+        logger.info 'handshake finished.'
+        @connected = true
+        post_handshake
+      end
+
+      def on_version(version)
+        logger.info("receive version message. #{version.build_json}")
+        @version = version
+        send_message(Bitcoin::Message::VerAck.new)
+      end
+
+      def on_ver_ack
+        logger.info('receive verack message.')
+        handshake_done
+      end
+
+      def on_get_addr
+        logger.info('receive getaddr message.')
+      end
+
+      def on_addr(addr)
+        logger.info("receive addr message. #{addr.build_json}")
+        # TODO
+      end
+
+      def on_send_headers
+        logger.info('receive sendheaders message.')
+        @sendheaders = true
+      end
+
+      def on_fee_filter(fee_filter)
+        logger.info("receive feefilter message. #{fee_filter.build_json}")
+        @fee_rate = fee_filter.fee_rate
+      end
+
+      def on_ping(ping)
+        logger.info("receive ping message. #{ping.build_json}")
+        send_message(ping.to_response)
+      end
+
+      def on_pong(pong)
+        logger.info("receive pong message. #{pong.build_json}")
+        # TODO calculate response
+      end
+
+      def on_get_headers(headers)
+        logger.info("receive getheaders message. #{headers.build_json}")
+        # TODO
+      end
+
+      def on_headers(headers)
+        logger.info("receive headers message. #{headers.build_json}")
+        # TODO
+      end
+
+      def on_block(block)
+        logger.info("receive block message. #{block.build_json}")
+        # TODO
+      end
+
+      def on_tx(tx)
+        logger.info("receive tx message. #{tx.build_json}")
+        # TODO
+      end
+
+      def on_not_found(not_found)
+        logger.info("receive notfound message. #{not_found.build_json}")
+        # TODO
+      end
+
+      def on_mem_pool
+        logger.info('receive mempool message.')
+        # TODO return mempool tx
+      end
+
+      def on_reject(reject)
+        logger.warn("receive reject message. #{reject.build_json}")
+        # TODO
+      end
+
+      def on_send_cmpct(cmpct)
+        logger.info("receive sendcmpct message. #{cmpct.build_json}")
+        # TODO if mode is high and version is 1, relay block with cmpctblock message
+      end
+
+      def on_inv(inv)
+        logger.info("receive inv message. #{inv.build_json}")
+        # TODO
+      end
+
+
+    end
+  end
+end

data/lib/bitcoin/network/peer.rb

@@ -0,0 +1,55 @@
+module Bitcoin
+  module Network
+
+    # remote peer class.
+    class Peer
+
+      # remote peer info
+      attr_reader :host
+      attr_reader :port
+      # remote peer connection
+      attr_accessor :conn
+      attr_accessor :connected
+      # parent pool
+      attr_reader :pool
+      attr_accessor :fee_rate
+
+      def initialize(host, port, pool)
+        @host = host
+        @port = port
+        @pool = pool
+        @connected = false
+      end
+
+      def connect
+        self.conn ||= EM.connect(host, port, Bitcoin::Network::Connection, self)
+      end
+
+      def connected?
+        @connected
+      end
+
+      def addr
+        "#{host}:#{port}"
+      end
+
+      def post_handshake
+        @connected = true
+        pool.handle_new_peer(self)
+      end
+
+      # broadcast tx.
+      def broadcast_tx(tx)
+        send_message(Bitcoin::Message::Tx.new(tx, ))
+      end
+
+      # check the remote peer support segwit.
+      def support_segwit?
+        return false unless conn.version
+        conn.version.services & Bitcoin::Message::SERVICE_FLAGS[:witness] > 0
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/network/peer_discovery.rb

@@ -0,0 +1,34 @@
+module Bitcoin
+  module Network
+
+    class PeerDiscovery
+
+      attr_reader :logger
+
+      def initialize
+        @logger = Bitcoin::Logger.create(:debug)
+      end
+
+      # get peer addresses, from DNS seeds.
+      def peers
+        # TODO add find from previous connected peer at first.
+        find_from_dns_seeds
+      end
+
+      private
+
+      def find_from_dns_seeds
+        logger.debug 'discover peer address from DNS seeds.'
+        Bitcoin.chain_params.dns_seeds.map {|seed|
+          begin
+            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}"
+          end
+        }.flatten
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/network/pool.rb

@@ -0,0 +1,74 @@
+module Bitcoin
+
+  module Network
+
+    # Time between pings automatically sent out for latency probing and keepalive (in seconds).
+    PING_INTERVAL = 2 * 60
+    # Time after which to disconnect, after waiting for a ping response (or inactivity).
+    TIMEOUT_INTERVAL = 20 * 60
+    # Maximum number of automatic outgoing nodes
+    MAX_OUTBOUND_CONNECTIONS = 4
+
+    # peer pool class.
+    class Pool
+
+      attr_reader :peers # active peers
+      attr_reader :pending_peers # currently connecting peer
+      attr_reader :chain
+      attr_reader :max_outbound
+      attr_reader :logger
+      attr_reader :peer_discovery
+      attr_accessor :started
+
+      def initialize
+        @peers = []
+        @pending_peers = []
+        @max_outbound = MAX_OUTBOUND_CONNECTIONS
+        @chain = Bitcoin::Node::SPVBlockChain.new
+        @logger = Bitcoin::Logger.create(:debug)
+        @peer_discovery = PeerDiscovery.new
+        @started = false
+      end
+
+      # connecting other peers and begin network activity.
+      def start
+        raise 'Cannot start a peer pool twice.' if started
+        logger.debug 'Start connecting other pears.'
+        addr_list = peer_discovery.peers
+        port = Bitcoin.chain_params.default_port
+        Parallel.map(addr_list, in_processes: 3) do |ip|
+          if peers.size < MAX_OUTBOUND_CONNECTIONS
+            EM.run do
+              peer = Peer.new(ip, port, self)
+              pending_peers << peer
+              peer.connect
+            end
+          end
+        end
+        @started = true
+      end
+
+      # detect new peer connection.
+      def handle_new_peer(peer)
+        logger.debug "connected new peer #{peer.addr}"
+        peers << peer
+        pending_peers.delete(peer)
+      end
+
+      # terminate peers.
+      def terminate
+        peers.each {|peer| peer.close('terminate')}
+        @peers = []
+        @started = false
+      end
+
+      def broadcast(tx)
+        peers.each {|peer| peer.broadcast(tx) }
+      end
+
+      private
+
+    end
+
+  end
+end

data/lib/bitcoin/network.rb

@@ -0,0 +1,14 @@
+require 'parallel'
+require 'eventmachine'
+
+module Bitcoin
+  module Network
+
+    autoload :MessageHandler, 'bitcoin/network/message_handler'
+    autoload :Connection, 'bitcoin/network/connection'
+    autoload :Pool, 'bitcoin/network/pool'
+    autoload :Peer, 'bitcoin/network/peer'
+    autoload :PeerDiscovery, 'bitcoin/network/peer_discovery'
+
+  end
+end

data/lib/bitcoin/node/spv.rb

@@ -0,0 +1,39 @@
+module Bitcoin
+  module Node
+
+    # SPV class
+    class SPV
+
+      attr_reader :pool
+      attr_reader :logger
+      attr_accessor :running
+
+      def initialize
+        @pool = Bitcoin::Network::Pool.new
+        @logger = Bitcoin::Logger.create(:debug)
+        @running = false
+      end
+
+      # open the node.
+      def run
+        return if running
+        logger.debug 'SPV node start running.'
+        pool.start
+      end
+
+      # close the node.
+      def shutdown
+        pool.terminate
+        logger.debug 'SPV node shutdown.'
+      end
+
+      # broadcast a transaction
+      def broadcast(tx)
+        pool.broadcast(tx)
+        logger.debug "broadcast tx: #{tx.to_payload.bth}"
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/node/spv_block_chain.rb

@@ -0,0 +1,15 @@
+module Bitcoin
+  module Node
+
+    class SPVBlockChain
+
+      attr_reader :block_store
+
+      def initialize(block_store = Bitcoin::Store::SPVBlockStore.new)
+        @block_store = block_store
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/node.rb

@@ -0,0 +1,6 @@
+module Bitcoin
+  module Node
+    autoload :SPV, 'bitcoin/node/spv'
+    autoload :SPVBlockChain, 'bitcoin/node/spv_block_chain'
+  end
+end

data/lib/bitcoin/script/script.rb

@@ -159,6 +159,11 @@ module Bitcoin
           (chunks.size == 1 || chunks[1].opcode <= OP_16)
     end
 
+    def op_return_data
+      return nil unless op_return?
+      chunks[1].pushed_data
+    end
+
     # whether data push only script which dose not include other opcode
     def push_only?
       chunks.each do |c|
@@ -184,6 +189,14 @@ module Bitcoin
       false
     end
 
+    # get witness commitment
+    def witness_commitment
+      return nil if !op_return? || op_return_data.bytesize < 36
+      buf = StringIO.new(op_return_data)
+      return nil unless buf.read(4).bth == WITNESS_COMMITMENT_HEADER
+      buf.read(32).bth
+    end
+
     # If this script is witness program, return its script code,
     # otherwise returns the self payload. ScriptInterpreter does not use this.
     def to_script_code(skip_separator_index = 0)

data/lib/bitcoin/store/spv_block_store.rb

@@ -0,0 +1,11 @@
+module Bitcoin
+
+  module Store
+
+    class SPVBlockStore
+
+    end
+
+  end
+
+end

data/lib/bitcoin/store.rb

@@ -0,0 +1,7 @@
+module Bitcoin
+  module Store
+
+    autoload :SPVBlockStore, 'bitcoin/store/spv_block_store'
+
+  end
+end

data/lib/bitcoin/tx.rb

@@ -71,6 +71,17 @@ module Bitcoin
       Bitcoin.double_sha256(to_payload).reverse.bth
     end
 
+    # get the witness commitment of coinbase tx.
+    # if this tx does not coinbase or not have commitment, return nil.
+    def witness_commitment
+      return nil unless coinbase_tx?
+      outputs.each do |output|
+        commitment = output.script_pubkey.witness_commitment
+        return commitment if commitment
+      end
+      nil
+    end
+
     def to_payload
       witness? ? serialize_witness_format : serialize_old_format
     end

data/lib/bitcoin/tx_out.rb

@@ -3,6 +3,8 @@ module Bitcoin
   # transaction output
   class TxOut
 
+    include OpenAssets::MarkerOutput
+
     attr_accessor :value
     attr_accessor :script_pubkey
 

data/lib/bitcoin/validation.rb

@@ -6,47 +6,69 @@ module Bitcoin
     def check_tx(tx, state)
       # Basic checks that don't depend on any context
       if tx.inputs.empty?
-        return state.DoS(10, reject_code: Message::Reject::CODE_INVALID, reject_resoin: 'bad-txns-vin-empty')
+        return state.DoS(10, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vin-empty')
       end
 
       if tx.outputs.empty?
-        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_resoin: 'bad-txns-vout-empty')
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vout-empty')
       end
 
       # Size limits (this doesn't take the witness into account, as that hasn't been checked for malleability)
       if tx.serialize_old_format.bytesize * Bitcoin::WITNESS_SCALE_FACTOR > Bitcoin::MAX_BLOCK_WEIGHT
-        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_resoin: 'bad-txns-oversize')
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-oversize')
       end
 
       # Check for negative or overflow output values
       amount = 0
       tx.outputs.each do |o|
-        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_resoin: 'bad-txns-vout-negative') if o.value < 0
-        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_resoin: 'bad-txns-vout-toolarge') if MAX_MONEY < o.value
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vout-negative') if o.value < 0
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vout-toolarge') if MAX_MONEY < o.value
         amount += o.value
-        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_resoin: 'bad-txns-vout-toolarge') if MAX_MONEY < amount
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-vout-toolarge') if MAX_MONEY < amount
       end
 
       # Check for duplicate inputs - note that this check is slow so we skip it in CheckBlock
       out_points = tx.inputs.map{|i|i.out_point.to_payload}
       unless out_points.size == out_points.uniq.size
-        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_resoin: 'bad-txns-inputs-duplicate')
+        return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-inputs-duplicate')
       end
 
       if tx.coinbase_tx?
         if tx.inputs[0].script_sig.size < 2 || tx.inputs[0].script_sig.size > 100
-          return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_resoin: 'bad-cb-length')
+          return state.DoS(100, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-cb-length')
         end
       else
         tx.inputs.each do |i|
           if i.out_point.nil? || !i.out_point.valid?
-            return state.DoS(10, reject_code: Message::Reject::CODE_INVALID, reject_resoin: 'bad-txns-prevout-null')
+            return state.DoS(10, reject_code: Message::Reject::CODE_INVALID, reject_reason: 'bad-txns-prevout-null')
           end
         end
       end
       true
     end
 
+    # check proof of work
+    def check_block_header(header, state)
+      header.hash
+      header.bits
+
+    end
+
+    def check_block(block, state)
+      # check block header
+      return false unless check_block_header(block.header, state)
+
+      # check merkle root
+
+      # size limits
+
+      # first tx is coinbase?
+
+      # check tx count
+
+      # check sigop count
+    end
+
   end
 
   class ValidationState
@@ -67,9 +89,9 @@ module Bitcoin
       @corruption_possible = false
     end
 
-    def DoS(level, ret: false, reject_code: 0, reject_resoin: '', corruption_in: false, debug_message: '')
+    def DoS(level, ret: false, reject_code: 0, reject_reason: '', corruption_in: false, debug_message: '')
       @reject_code = reject_code
-      @reject_reason = reject_resoin
+      @reject_reason = reject_reason
       @corruption_possible = corruption_in
       @debug_message = debug_message
       return ret if mode == MODE[:error]

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/bitcoin.rb

@@ -5,14 +5,15 @@ require 'securerandom'
 require 'json'
 require 'bech32'
 require 'ffi'
+require_relative 'openassets'
 
 module Bitcoin
 
   autoload :Util, 'bitcoin/util'
   autoload :ChainParams, 'bitcoin/chain_params'
   autoload :Message, 'bitcoin/message'
-  autoload :Connection, 'bitcoin/connection'
   autoload :Logger, 'bitcoin/logger'
+  autoload :Block, 'bitcoin/block'
   autoload :BlockHeader, 'bitcoin/block_header'
   autoload :Tx, 'bitcoin/tx'
   autoload :Script, 'bitcoin/script/script'
@@ -27,11 +28,13 @@ module Bitcoin
   autoload :Key, 'bitcoin/key'
   autoload :ExtKey, 'bitcoin/ext_key'
   autoload :Opcodes, 'bitcoin/opcodes'
-  autoload :Node, 'bitcoin/nodes'
+  autoload :Node, 'bitcoin/node'
   autoload :Base58, 'bitcoin/base58'
   autoload :Secp256k1, 'bitcoin/secp256k1'
   autoload :Mnemonic, 'bitcoin/mnemonic'
   autoload :ValidationState, 'bitcoin/validation'
+  autoload :Network, 'bitcoin/network'
+  autoload :Store, 'bitcoin/store'
 
   require_relative 'bitcoin/constants'
 

data/lib/openassets/marker_output.rb

@@ -0,0 +1,14 @@
+module OpenAssets
+
+  module MarkerOutput
+
+    # whether this output is marker output for open assets.
+    def open_assets_marker?
+      return false unless script_pubkey.op_return?
+      payload = Payload.parse_from_payload(script_pubkey.op_return_data)
+      !payload.nil?
+    end
+
+  end
+
+end