bitcoinrb 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a527d6ef43eda02e2ef56d64edb5da7dfa04a956
-  data.tar.gz: b1a7902b2be175f6f771ca3a418cbf869ab9dc7e
+  metadata.gz: c1508c7b3cad66796b7ef2bde7e744e478eb5f6c
+  data.tar.gz: 11c7f275b40ec3a70f5f55607ec4f8aee4ea0bd4
 SHA512:
-  metadata.gz: ec03a93f28a17efdd812eaf1dd13e3a3f5ad947393bd8e29e6040116558dd9bbfc193419cc1a69bd623b36c4bb141e5957010ec989fca9301d851b461a78f79a
-  data.tar.gz: bb41bbb4b43700e9a587e2e8d157a1ab7be358a14b9bd44ab349fdc19275c124e407ea9093f68b8cb218d61c0800efc348c8b4fbc202884ecb8e0ab0c3baa347
+  metadata.gz: '095ba38bc01e7ef0b83091f63c537f2ce06e0cd91645fcbc7988da05ff54ea25dcf85f9725782d3f5e16057b5c5777275e7ad12c77388e32153f37100c724bbb'
+  data.tar.gz: 5aa55097029750cf282dc23a1caa5702e1b21a942409adeac25836b083d59fc6994f72300fc76c8415c5d9f21f01b3af0b5d188a9ca035734971cbac0ffd03d3

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+bitcoinrbd.yml

data/bitcoinrb.gemspec

@@ -26,8 +26,12 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'daemon-spawn'
   spec.add_runtime_dependency 'thor'
   spec.add_runtime_dependency 'ffi'
+  spec.add_runtime_dependency 'parallel'
+  spec.add_runtime_dependency 'leb128', '~> 1.0.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'timecop'
 
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
 end

data/exe/bitcoinrb-cli

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'bitcoin/nodes/spv/cli'
+require 'bitcoin/node/spv/cli'
 
 Bitcoin::Nodes::SPV::CLI.start(ARGV)

data/exe/bitcoinrbd

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 require 'thor'
 require 'bitcoin'
-require 'bitcoin/nodes/spv/daemon'
+require 'bitcoin/node/spv'
 
 class Bitcoinrbd < Thor
 
@@ -10,40 +10,26 @@ class Bitcoinrbd < Thor
   desc 'start', 'start bitcoinrbd daemon process'
   def start
     raise ArgumentError, 'currently only support spv mode.' unless options[:mode] == 'spv'
-    execute_daemon(setup_base_dir(options[:network]), ['start'])
+    Bitcoin.chain_params = network.to_sym
+    FileUtils.mkdir_p(Bitcoin.base_dir)
+    execute_daemon(['start'])
   end
 
   option :mode, default: 'spv'
   option :network, default: 'mainnet'
   desc 'stop', 'start bitcoinrbd daemon process'
   def stop
-    execute_daemon(setup_base_dir(options[:network]), ['stop'])
+    execute_daemon(['stop'])
   end
 
-  def execute_daemon(base_dir, cmd_args)
-    Bitcoin::Nodes::SPV::Daemon.spawn!({working_dir: base_dir,
-                                     log_file: "#{base_dir}/bitcoinrbd.log",
-                                     pid_file: "#{base_dir}/bitcoinrbd.pid",
+  def execute_daemon(cmd_args)
+    Bitcoin::Nodes::SPV.spawn!({working_dir: Bitcoin.base_dir,
+                                     log_file: "#{Bitcoin.base_dir}/bitcoinrbd.log",
+                                     pid_file: "#{Bitcoin.base_dir}/bitcoinrbd.pid",
                                      sync_log: true,
                                      singleton: true}, cmd_args)
   end
 
-  private
-
-  def setup_base_dir(network)
-    case network
-    when 'mainnet'
-      base_dir = Bitcoin.base_dir
-    when 'testnet'
-      base_dir = "#{Bitcoin.base_dir}/testnet3"
-    when 'regtest'
-      base_dir = "#{Bitcoin.base_dir}/regtest"
-    else
-      raise ArgumentError, 'Unsupported network specified.'
-    end
-    FileUtils.mkdir_p(base_dir)
-    base_dir
-  end
 end
 
 Bitcoinrbd.start(ARGV)

data/lib/bitcoin/block.rb

@@ -0,0 +1,66 @@
+module Bitcoin
+  class Block
+
+    attr_accessor :header
+    attr_accessor :transactions
+
+    def initialize(header, transactions = [])
+      @header = header
+      @transactions = transactions
+    end
+
+    # calculate block weight
+    def weight
+      stripped_size * (WITNESS_SCALE_FACTOR - 1) + size
+    end
+
+    # calculate total size (include witness data.)
+    def size
+      80 + Bitcoin.pack_var_int(transactions.size).bytesize +
+          transactions.inject(0){|sum, tx| sum + (tx.witness? ? tx.serialize_witness_format.bytesize : tx.serialize_old_format.bytesize)}
+    end
+
+    # calculate base size (not include witness data.)
+    def stripped_size
+      80 + Bitcoin.pack_var_int(transactions.size).bytesize +
+          transactions.inject(0){|sum, tx| sum + tx.serialize_old_format.bytesize}
+    end
+
+    # check the merkle root in the block header matches merkle root calculated from tx list.
+    def valid_merkle_root?
+      calculate_merkle_root == header.merkle_root
+    end
+
+    # calculate merkle root from tx list.
+    def calculate_merkle_root
+      Bitcoin::MerkleTree.build_from_leaf(transactions.map(&:txid)).merkle_root
+    end
+
+    # check the witness commitment in coinbase tx matches witness commitment calculated from tx list.
+    def valid_witness_commitment?
+      transactions[0].witness_commitment == calculate_witness_commitment
+    end
+
+    # calculate witness commitment from tx list.
+    def calculate_witness_commitment
+      wtxid_list = [COINBASE_WTXID]
+      wtxid_list.concat(transactions[1..-1].map{|tx| tx.wtxid})
+      reserved_value = transactions[0].inputs[0].script_witness.stack.map(&:bth).join
+      root_hash = Bitcoin::MerkleTree.build_from_leaf(wtxid_list).merkle_root
+      Digest::SHA256.digest(Digest::SHA256.digest(
+          [reserved_value + root_hash].pack('H*').reverse )).bth
+    end
+
+    # return this block height. block height is included in coinbase.
+    # if block version under 1, height does not include in coinbase, so return nil.
+    def height
+      return nil if header.version < 2
+      coinbase_tx = transactions[0]
+      return nil unless coinbase_tx.coinbase_tx?
+      buf = StringIO.new(coinbase_tx.inputs[0].script_sig.to_payload)
+      len = Bitcoin.unpack_var_int_from_io(buf)
+      buf.read(len).reverse.bth.to_i(16)
+    end
+
+  end
+end

data/lib/bitcoin/block_header.rb

@@ -7,7 +7,7 @@ module Bitcoin
     attr_accessor :version
     attr_accessor :prev_hash
     attr_accessor :merkle_root
-    attr_accessor :time
+    attr_accessor :time # unix timestamp
     attr_accessor :bits
     attr_accessor :nonce
 
@@ -30,6 +30,38 @@ module Bitcoin
       [version, prev_hash.htb.reverse, merkle_root.htb.reverse, time, bits, nonce].pack('Va32a32VVV')
     end
 
+    # compute difficulty target from bits.
+    def difficulty_target
+      exponent = ((bits >> 24) & 0xff)
+      mantissa = bits & 0x7fffff
+      mantissa *= -1 if (bits & 0x800000) > 0
+      (mantissa * 2 ** (8 * (exponent - 3)))
+    end
+
+    # evaluate block header
+    def valid?
+      valid_pow? && valid_timestamp?
+    end
+
+    # evaluate valid proof of work.
+    def valid_pow?
+      hash.hex < difficulty_target
+    end
+
+    # evaluate valid timestamp.
+    # https://en.bitcoin.it/wiki/Block_timestamp
+    def valid_timestamp?
+      time <= Time.now.to_i + Bitcoin::MAX_FUTURE_BLOCK_TIME
+    end
+
+    # compute chain work of this block.
+    # @return [Integer] a chain work.
+    def work
+      target = difficulty_target
+      return 0 if target < 1
+      (2**256) / (target + 1)
+    end
+
     private
 
     def calc_hash

data/lib/bitcoin/chain_params.rb

@@ -21,21 +21,21 @@ module Bitcoin
     attr_reader :target_spacing
     attr_reader :max_money
     attr_reader :bip34_height
-    attr_reader :genesis_hash
     attr_reader :proof_of_work_limit
     attr_reader :dns_seeds
+    attr_reader :genesis
 
-    # mainnet params
+    # mainnet genesis
     def self.mainnet
       YAML.load(File.open("#{__dir__}/chainparams/mainnet.yml"))
     end
 
-    # testnet params
+    # testnet genesis
     def self.testnet
       YAML.load(File.open("#{__dir__}/chainparams/testnet.yml"))
     end
 
-    # regtest params
+    # regtest genesis
     def self.regtest
       YAML.load(File.open("#{__dir__}/chainparams/regtest.yml"))
     end
@@ -52,6 +52,13 @@ module Bitcoin
       network == 'regtest'
     end
 
+    def genesis_block
+      header = Bitcoin::BlockHeader.new(
+          genesis['version'], genesis['prev_hash'], genesis['merkle_root'],
+          genesis['time'], genesis['bits'], genesis['nonce'])
+      Bitcoin::Block.new(header)
+    end
+
   end
 
 end

data/lib/bitcoin/chainparams/mainnet.yml

@@ -15,11 +15,18 @@ retarget_time: 1209600 # 2 weeks
 target_spacing: 600 # block interval
 max_money: 21000000
 bip34_height: 227931
-genesis_hash: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
 proof_of_work_limit: 0x1d00ffff
 dns_seeds:
   - "seed.bitcoin.sipa.be"
   - "dnsseed.bluematt.me"
   - "dnsseed.bitcoin.dashjr.org"
   - "seed.bitcoinstats.com"
-  - "seed.bitcoin.jonasschnelli.ch"
+  - "seed.bitcoin.jonasschnelli.ch"
+genesis:
+  hash: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
+  merkle_root: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
+  time: 1231006505
+  nonce: 2083236893
+  bits: 0x1d00ffff
+  version: 1
+  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"

data/lib/bitcoin/chainparams/regtest.yml

@@ -17,4 +17,12 @@ max_money: 21000000
 bip34_height: 0
 genesis_hash: "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
 proof_of_work_limit: 0x207fffff
-dns_seeds:
+dns_seeds:
+genesis:
+  hash: "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
+  merkle_root: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
+  time: 1296688602
+  nonce: 2
+  bits: 0x207fffff
+  version: 1
+  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"

data/lib/bitcoin/chainparams/testnet.yml

@@ -21,4 +21,12 @@ dns_seeds:
   - "testnet-seed.bitcoin.jonasschnelli.ch"
   - "seed.tbtc.petertodd.org"
   - "testnet-seed.bluematt.me"
-  - "testnet-seed.bitcoin.schildbach.de"
+  - "testnet-seed.bitcoin.schildbach.de"
+genesis:
+  hash: "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
+  merkle_root: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
+  time: 1296688602
+  nonce: 414098458
+  bits: 0x1d00ffff
+  version: 1
+  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"

data/lib/bitcoin/constants.rb

@@ -154,4 +154,17 @@ module Bitcoin
   ERRCODES_MAP = Hash[*constants.grep(/^SCRIPT_ERR_/).map { |c| [const_get(c), c.to_s] }.flatten]
   NAME_MAP = Hash[*constants.grep(/^SCRIPT_ERR_/).map { |c| [c.to_s, const_get(c)] }.flatten]
 
+  # witness commitment
+  WITNESS_COMMITMENT_HEADER = 'aa21a9ed'
+
+  COINBASE_WTXID = '00'* 32
+
+  # for message
+  MESSAGE_HEADER_SIZE = 24
+
+  # for peer
+  PARALLEL_THREAD = 3
+
+  # Maximum amount of time that a block timestamp is allowed to exceed the current network-adjusted time before the block will be accepted.
+  MAX_FUTURE_BLOCK_TIME = 2 * 60 * 60
 end

data/lib/bitcoin/ext_key.rb

@@ -17,11 +17,12 @@ module Bitcoin
     attr_accessor :parent_fingerprint
 
     # generate master key from seed.
+    # @params [String] seed a seed data with hex format.
     def self.generate_master(seed)
       ext_key = ExtKey.new
       ext_key.depth = ext_key.number = 0
       ext_key.parent_fingerprint = '00000000'
-      l = Bitcoin.hmac_sha512('Bitcoin seed', seed)
+      l = Bitcoin.hmac_sha512('Bitcoin seed', seed.htb)
       left = l[0..31].bth.to_i(16)
       raise 'invalid key' if left >= CURVE_ORDER || left == 0
       ext_key.key = Bitcoin::Key.new(priv_key: l[0..31].bth)

data/lib/bitcoin/merkle_tree.rb

@@ -52,69 +52,68 @@ module Bitcoin
       nodes.first
     end
 
-  end
-
-  # node of merkle tree
-  class Node
+    # node of merkle tree
+    class Node
 
-    attr_accessor :flag
-    attr_accessor :hash
-    attr_accessor :parent
-    attr_accessor :left
-    attr_accessor :right
+      attr_accessor :flag
+      attr_accessor :hash
+      attr_accessor :parent
+      attr_accessor :left
+      attr_accessor :right
 
-    def initialize(hash = nil)
-      @hash = hash
-    end
+      def initialize(hash = nil)
+        @hash = hash
+      end
 
-    def left=(node)
-      node.parent = self
-      @left = node
-    end
+      def left=(node)
+        node.parent = self
+        @left = node
+      end
 
-    def right=(node)
-      node.parent = self
-      @right = node
-    end
+      def right=(node)
+        node.parent = self
+        @right = node
+      end
 
-    def hash
-      return @hash if @hash
-      self.right = left.dup unless right
-      Digest::SHA256.digest(Digest::SHA256.digest(
-          [right.hash + left.hash].pack('H*').reverse )).reverse.bth
-    end
+      def hash
+        return @hash if @hash
+        self.right = left.dup unless right
+        Digest::SHA256.digest(Digest::SHA256.digest(
+            [right.hash + left.hash].pack('H*').reverse )).reverse.bth
+      end
 
-    def root?
-      parent.nil?
-    end
+      def root?
+        parent.nil?
+      end
 
-    def leaf?
-      right.nil? && left.nil?
-    end
+      def leaf?
+        right.nil? && left.nil?
+      end
 
-    def partial?
-      !flag.nil?
-    end
+      def partial?
+        !flag.nil?
+      end
 
-    def next_partial
-      return nil if root? && (flag.zero? || (left.partial? && right.partial?))
-      return parent.next_partial if flag.zero? || leaf?
-      return left unless left.partial?
-      self.right = left.dup unless right
-      right.partial? ? parent.next_partial : right
-    end
+      def next_partial
+        return nil if root? && (flag.zero? || (left.partial? && right.partial?))
+        return parent.next_partial if flag.zero? || leaf?
+        return left unless left.partial?
+        self.right = left.dup unless right
+        right.partial? ? parent.next_partial : right
+      end
 
-    # calculate the depth of this node in the tree.
-    def depth
-      d = 0
-      current_node = self
-      until current_node.root? do
-        current_node = current_node.parent
-        d += 1
+      # calculate the depth of this node in the tree.
+      def depth
+        d = 0
+        current_node = self
+        until current_node.root? do
+          current_node = current_node.parent
+          d += 1
+        end
+        d
       end
-      d
-    end
 
+    end
   end
 
 end

data/lib/bitcoin/message/block.rb

@@ -35,6 +35,11 @@ module Bitcoin
           transactions.map{|t|use_segwit ? t.to_payload : t.serialize_old_format}.join
       end
 
+      # generate Bitcoin::Block object.
+      def to_block
+        Bitcoin::Block.new(header, transactions)
+      end
+
     end
 
   end

data/lib/bitcoin/message.rb

@@ -1,7 +1,6 @@
 module Bitcoin
   module Message
 
-    autoload :Handler, 'bitcoin/message/handler'
     autoload :Base, 'bitcoin/message/base'
     autoload :Inventory, 'bitcoin/message/inventory'
     autoload :InventoriesParser, 'bitcoin/message/inventories_parser'
@@ -31,19 +30,20 @@ module Bitcoin
     autoload :Reject, 'bitcoin/message/reject'
     autoload :SendCmpct, 'bitcoin/message/send_cmpct'
 
-    HEADER_SIZE = 24
     USER_AGENT = "/bitcoinrb:#{Bitcoin::VERSION}/"
 
     SERVICE_FLAGS = {
         none: 0,
-        network: 1 << 0,  # the node is capable of serving the block chain. It is currently set by all Bitcoin Core nodes, and is unset by SPV clients or other peers that just want network services but don't provide them.
+        network: 1 << 0,  # the node is capable of serving the block chain. It is currently set by all Bitcoin Core node, and is unset by SPV clients or other peers that just want network services but don't provide them.
         # getutxo: 1 << 1, # BIP-64. not implemented in Bitcoin Core.
-        bloom: 1 << 2,    # the node is capable and willing to handle bloom-filtered connections. Bitcoin Core nodes used to support this by default, without advertising this bit, but no longer do as of protocol version 70011 (= NO_BLOOM_VERSION)
+        bloom: 1 << 2,    # the node is capable and willing to handle bloom-filtered connections. Bitcoin Core node used to support this by default, without advertising this bit, but no longer do as of protocol version 70011 (= NO_BLOOM_VERSION)
         witness: 1 << 3,  # the node can be asked for blocks and transactions including witness data.
         # xthin: 1 << 4 # support Xtreme Thinblocks. not implemented in Bitcoin Core
     }
 
-    DEFAULT_SERVICE_FLAGS = SERVICE_FLAGS[:network] | SERVICE_FLAGS[:bloom] | SERVICE_FLAGS[:witness]
+    # DEFAULT_SERVICE_FLAGS = SERVICE_FLAGS[:network] | SERVICE_FLAGS[:bloom] | SERVICE_FLAGS[:witness]
+
+    DEFAULT_SERVICE_FLAGS = SERVICE_FLAGS[:none] | SERVICE_FLAGS[:witness]
 
     DEFAULT_STOP_HASH = "00"*32
 

data/lib/bitcoin/network/connection.rb

@@ -0,0 +1,58 @@
+module Bitcoin
+
+  module Network
+
+    # Basic Bitcoin P2P connection class
+    class Connection < EM::Connection
+
+      include MessageHandler
+
+      attr_reader :peer, :logger
+
+      # remote peer version.
+      attr_accessor :version
+
+      # if true, this peer send new block announcements using a headers message rather than an inv message.
+      attr_accessor :sendheaders
+
+      # minimum fee(in satoshis per kilobyte) for relay tx
+      attr_accessor :fee_rate
+
+      def initialize(peer)
+        @peer = peer
+        @logger = Bitcoin::Logger.create(:debug)
+        @sendheaders = false
+        @attr_accessor = 0
+        @message = ''
+      end
+
+      def post_init
+        logger.info "connected. #{addr}"
+        begin_handshake
+      end
+
+      # handle receiving data from remote node.
+      def receive_data(data)
+        handle(data)
+      end
+
+      def post_handshake
+        peer.post_handshake
+      end
+
+      def addr
+        peer.addr
+      end
+
+      # close network connection.
+      def close(msg = '')
+        logger.info "close connection with #{addr}. #{msg}"
+        close_connection_after_writing
+        EM.stop
+      end
+
+    end
+
+  end
+
+end