bitcoinrb 1.12.0 → 1.13.0

data/lib/bitcoin/network/peer.rb

@@ -1,228 +0,0 @@
-module Bitcoin
-  module Network
-
-    # remote peer class.
-    class Peer
-
-      # Interval for pinging peers.
-      PING_INTERVAL = 2 * 60
-
-      attr_reader :logger
-      attr_accessor :id
-      attr_accessor :local_version
-      attr_accessor :last_send
-      attr_accessor :last_recv
-      attr_accessor :bytes_sent
-      attr_accessor :bytes_recv
-      attr_accessor :conn_time
-      attr_accessor :last_ping
-      attr_accessor :last_ping_nonce
-      attr_accessor :last_pong
-      attr_accessor :min_ping
-      attr_accessor :outbound # TODO need implements to accept inbound connection
-      attr_accessor :best_hash
-      attr_accessor :best_height
-      # remote peer info
-      attr_reader :host
-      attr_reader :port
-      # remote peer connection
-      attr_accessor :conn
-      attr_accessor :connected
-      attr_accessor :primary
-      # parent pool
-      attr_reader :pool
-      attr_reader :chain
-      attr_accessor :fee_rate
-
-      def initialize(host, port, pool, configuration)
-        @host = host
-        @port = port
-        @pool = pool
-        @chain = pool.chain
-        @connected = false
-        @primary = false
-        @logger = Bitcoin::Logger.create(:debug)
-        @outbound = true
-        @best_hash = -1
-        @best_height = -1
-        @min_ping = -1
-        @bytes_sent = 0
-        @bytes_recv = 0
-        @relay = configuration.conf[:relay]
-        current_height = @chain.latest_block.height
-        remote_addr = Bitcoin::Message::NetworkAddr.new(ip: host, port: port, time: nil)
-        @local_version = Bitcoin::Message::Version.new(remote_addr: remote_addr, start_height: current_height, relay: @relay)
-      end
-
-      def connect
-        self.conn ||= EM.connect(host, port, Bitcoin::Network::Connection, self)
-      end
-
-      def connected?
-        @connected
-      end
-
-      def outbound?
-        @outbound
-      end
-
-      def addr
-        "#{host}:#{port}"
-      end
-
-      # calculate ping-pong time.
-      def ping_time
-        last_pong ? (last_pong - last_ping) / 1e6 : -1
-      end
-
-      # set last pong
-      def last_pong=(time)
-        @last_pong = time
-        @min_ping = ping_time if min_ping == -1 || ping_time < min_ping
-      end
-
-      def post_handshake
-        @connected = true
-        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
-      def start_block_header_download
-        logger.info("[#{addr}] start block header download.")
-        get_headers = Bitcoin::Message::GetHeaders.new(
-            Bitcoin.chain_params.protocol_version, [chain.latest_block.block_hash])
-        conn.send_message(get_headers)
-      end
-
-      # broadcast tx.
-      def broadcast_tx(tx)
-        conn.send_message(Bitcoin::Message::Tx.new(tx, support_witness?))
-      end
-
-      # check the remote peer support witness.
-      def support_witness?
-        return false unless remote_version
-        remote_version.services & Bitcoin::Message::SERVICE_FLAGS[:witness] > 0
-      end
-
-      # check the remote peer supports compact block.
-      def support_cmpct?
-        return false if remote_version.version < Bitcoin::Message::VERSION[:compact]
-        return true unless local_version.services & Bitcoin::Message::SERVICE_FLAGS[:witness] > 0
-        return false unless support_witness?
-        remote_version.version >= Bitcoin::Message::VERSION[:compact_witness]
-      end
-
-      # get peer's block type.
-      def block_type
-        Bitcoin::Message::Inventory::MSG_FILTERED_BLOCK # TODO need other implementation
-      end
-
-      # get remote peer's version message.
-      # @return [Bitcoin::Message::Version]
-      def remote_version
-        conn.version
-      end
-
-      # Whether to try and download blocks and transactions from this peer.
-      def primary?
-        primary
-      end
-
-      # handle headers message
-      # @params [Bitcoin::Message::Headers]
-      def handle_headers(headers)
-        headers.headers.each do |header|
-          break unless header.valid?
-          entry = chain.append_header(header)
-          next unless entry
-          @best_hash = entry.block_hash
-          @best_height = entry.height
-        end
-        pool.changed
-        pool.notify_observers(:header, {hash: @best_hash, height: @best_height})
-        start_block_header_download if headers.headers.size > 0 # next header download
-      end
-
-      # handle error
-      def handle_error(e)
-        pool.handle_error(e)
-      end
-
-      def unbind
-        pool.handle_close_peer(self)
-      end
-
-      # close peer connection.
-      def close(msg = '')
-        conn.close(msg)
-      end
-
-      # generate Bitcoin::Message::NetworkAddr object from this peer info.
-      # @return [Bitcoin::Message::NetworkAddr]
-      def to_network_addr
-        v = remote_version
-        Bitcoin::Message::NetworkAddr.new(ip: host, port: port, services: v.services, time: v.timestamp)
-      end
-
-      # send +addr+ message to remote peer
-      def send_addrs
-        addrs = pool.peers.select{|p|p != self}.map(&:to_network_addr)
-        conn.send_message(Bitcoin::Message::Addr.new(addrs))
-      end
-
-      # handle block inv message.
-      def handle_block_inv(hashes)
-        getdata = Bitcoin::Message::GetData.new(
-            hashes.map{|h|Bitcoin::Message::Inventory.new(block_type, h)})
-        conn.send_message(getdata)
-      end
-
-      def handle_tx(tx)
-        pool.changed
-        pool.notify_observers(:tx, tx)
-      end
-
-      def handle_merkle_block(merkle_block)
-        pool.changed
-        pool.notify_observers(:merkleblock, merkle_block)
-      end
-
-      # send ping message.
-      def send_ping
-        ping = Bitcoin::Message::Ping.new
-        @last_ping = Time.now.to_i
-        @last_pong = -1
-        @last_ping_nonce = ping.nonce
-        conn.send_message(ping)
-      end
-
-      # send filterload message.
-      def send_filter_load(bloom)
-        filter_load = Bitcoin::Message::FilterLoad.new(
-            bloom, Bitcoin::Message::FilterLoad::BLOOM_UPDATE_ALL)
-        conn.send_message(filter_load)
-      end
-
-      # send filteradd message.
-      def send_filter_add(element)
-        filter_add = Bitcoin::Message::FilterAdd.new(element)
-        conn.send_message(filter_add)
-      end
-
-      # send filterclear message.
-      def send_filter_clear
-        filter_clear = Bitcoin::Message::FilterClear.new
-        conn.send_message(filter_clear)
-      end
-    end
-  end
-end

data/lib/bitcoin/network/peer_discovery.rb

@@ -1,42 +0,0 @@
-module Bitcoin
-  module Network
-
-    class PeerDiscovery
-
-      attr_reader :logger, :configuration
-
-      def initialize(configuration)
-        @logger = Bitcoin::Logger.create(:debug)
-        @configuration = configuration
-      end
-
-      # get peer addresses, from DNS seeds.
-      def peers
-        # TODO add find from previous connected peer at first.
-        (find_from_dns_seeds + seeds).uniq
-      end
-
-      private
-
-      def dns_seeds
-        Bitcoin.chain_params.dns_seeds || []
-      end
-
-      def seeds
-        [*configuration.conf[:connect]]
-      end
-
-      def find_from_dns_seeds
-        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
-          rescue SocketError => e
-            logger.error "SocketError occurred when load DNS seed: #{seed}, error: #{e.message}"
-            nil
-          end
-        }.flatten.compact
-      end
-    end
-  end
-end

data/lib/bitcoin/network/pool.rb

@@ -1,135 +0,0 @@
-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
-      include Observable
-
-      attr_reader :peers # active peers
-      attr_reader :pending_peers # currently connecting peer
-      attr_reader :node
-      attr_reader :chain
-      attr_reader :max_outbound
-      attr_reader :logger
-      attr_reader :peer_discovery
-      attr_accessor :started
-      attr_reader :mutex
-
-      def initialize(node, chain, configuration)
-        @node = node
-        @peers = []
-        @pending_peers = []
-        @max_outbound = MAX_OUTBOUND_CONNECTIONS
-        @chain = chain
-        @logger = Bitcoin::Logger.create(:debug)
-        @configuration = configuration
-        @peer_discovery = PeerDiscovery.new(configuration)
-        @started = false
-        @mutex = Mutex.new
-      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
-
-        connect(addr_list)
-
-        @started = true
-      end
-
-      # detect new peer connection.
-      def handle_new_peer(peer)
-        logger.debug "connected new peer #{peer.addr}."
-        mutex.synchronize do
-          peer.id = allocate_peer_id
-          unless peers.find(&:primary?)
-            peer.primary = true
-            peer.start_block_header_download
-          end
-          peers << peer
-        end
-        pending_peers.delete(peer)
-        filter_load(peer) if node.wallet
-      end
-
-      def handle_close_peer(peer)
-        return unless started
-        peers.delete(peer)
-        pending_peers.delete(peer)
-        addr_list = peer_discovery.peers - peers.map(&:host) - pending_peers.map(&:host) - [peer.host]
-        connect(addr_list)
-      end
-
-      # terminate peers.
-      def terminate
-        peers.each { |peer| peer.close('terminate') }
-        pending_peers.each { |peer| peer.close('terminate') }
-        @peers = []
-        @started = false
-      end
-
-      # broadcast tx to connecting peer.
-      def broadcast(tx)
-        peers.each { |peer| peer.broadcast_tx(tx) }
-      end
-
-      # new bloom filter.
-      def filter_load(peer)
-        peer.send_filter_load(node.bloom)
-      end
-
-      # add element to bloom filter.
-      def filter_add(element)
-        peers.each { |peer| peer.send_filter_add(element) }
-      end
-
-      # clear bloom filter.
-      def filter_clear
-        peers.each { |peer| peer.send_filter_clear }
-      end
-
-      def handle_error(e)
-        terminate
-      end
-
-      private
-
-      # get primary peer
-      def primary_peer
-        peers.find(&:primary?)
-      end
-
-      # allocate new peer id
-      def allocate_peer_id
-        id = 0
-        until peers.empty? || peers.find{|p|p.id == id}.nil?
-          id += 1
-        end
-        id
-      end
-
-      def connect(addr_list)
-        port = Bitcoin.chain_params.default_port
-
-        EM::Iterator.new(addr_list, Bitcoin::PARALLEL_THREAD).each do |ip, iter|
-          if pending_peers.size + peers.size < MAX_OUTBOUND_CONNECTIONS
-            peer = Peer.new(ip, port, self, @configuration)
-            pending_peers << peer
-            peer.connect
-            iter.next
-          end
-        end
-      end
-    end
-  end
-end

data/lib/bitcoin/network.rb

@@ -1,13 +0,0 @@
-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/cli.rb

@@ -1,122 +0,0 @@
-require 'net/http'
-require 'thor'
-require 'json'
-
-module Bitcoin
-  module Node
-
-    class CLI < Thor
-
-      class_option :network, aliases: '-n', default: :mainnet
-
-      desc 'decodepsbt <base64 psbt string>', "Return a JSON object representing the serialized, base64-encoded partially signed Bitcoin transaction."
-      def decodepsbt(base64)
-        psbt = Bitcoin::PSBT::Tx.parse_from_base64(base64)
-        puts JSON.pretty_generate(psbt.to_h)
-      end
-
-      desc 'getblockchaininfo', 'Returns an object containing various state info regarding blockchain processing.'
-      def getblockchaininfo
-        request('getblockchaininfo')
-      end
-
-      desc 'stop', 'Stop Bitcoin server.'
-      def stop
-        request('stop')
-      end
-
-      desc 'getblockheader "hash" ( verbose )', 'If verbose is false, returns a string that is serialized, hex-encoded data for blockheader "hash". If verbose is true, returns an Object with information about blockheader <hash>.'
-      def getblockheader(hash, verbose = true)
-        verbose = verbose.is_a?(String) ? (verbose == 'true') : verbose
-        request('getblockheader', hash, verbose)
-      end
-
-      desc 'getpeerinfo', 'Returns data about each connected network node as a json array of objects.'
-      def getpeerinfo
-        request('getpeerinfo')
-      end
-
-      desc 'decoderawtransaction "hexstring"', 'Return a JSON object representing the serialized, hex-encoded transaction.'
-      def decoderawtransaction(hexstring)
-        request('decoderawtransaction', hexstring)
-      end
-
-      desc 'decodescript "hexstring"', 'Decode a hex-encoded script.'
-      def decodescript(hexstring)
-        request('decodescript', hexstring)
-      end
-
-      # wallet cli
-
-      desc 'sendrawtransaction', 'Submits raw transaction (serialized, hex-encoded) to local node and network.'
-      def sendrawtransaction(hex_tx)
-        request('sendrawtransaction', hex_tx)
-      end
-
-      desc 'createwallet "wallet_id"', 'Create new HD wallet. It returns an error if an existing wallet_id is specified. '
-      def createwallet(wallet_id)
-        request('createwallet', wallet_id)
-      end
-
-      desc 'listwallets', 'Returns a list of currently loaded wallets. For full information on the wallet, use "getwalletinfo"'
-      def listwallets
-        request('listwallets')
-      end
-
-      desc 'getwalletinfo', 'Returns an object containing various wallet state info.'
-      def getwalletinfo
-        request('getwalletinfo')
-      end
-
-      desc 'listaccounts', '[WIP]Returns Object that has account names as keys, account balances as values.'
-      def listaccounts
-        request('listaccounts')
-      end
-
-      desc 'encryptwallet "passphrase"', 'Encrypts the wallet with "passphrase". This is for first time encryption.After this, any calls that interact with private keys such as sending or signing will require the passphrase to be set prior the making these calls.'
-      def encryptwallet(passhphrase)
-        request('encryptwallet', passhphrase)
-      end
-
-      desc 'getnewaddress "account"', 'Returns a new Bitcoin address for receiving payments.'
-      def getnewaddress(account)
-        request('getnewaddress', account)
-      end
-
-      private
-
-      def config
-        opts = {}
-        opts[:network] = options['network'] if options['network']
-        @conf ||= Bitcoin::Node::Configuration.new(opts)
-      end
-
-      def request(command, *params)
-        data = {
-            :method => command,
-            :params => params,
-            :id => 'jsonrpc'
-        }
-        begin
-          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
-        end
-      end
-
-    end
-  end
-end

data/lib/bitcoin/node/configuration.rb

@@ -1,40 +0,0 @@
-require 'iniparse'
-
-module Bitcoin
-  module Node
-    class Configuration
-
-      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]
-        opts[:relay] = false unless opts[:relay]
-        Bitcoin.chain_params = opts[:network]
-
-        begin
-          ini_file = IniParse.parse(File.read("#{Bitcoin.base_dir}/bitcoinrb.conf"))
-          @conf = Hash[ ini_file.to_h['__anonymous__'].map{|k,v| [k.to_sym, v] } ]
-        rescue => e
-          @conf = {}
-        end
-        @conf.merge!(opts)
-      end
-
-      def host
-        'localhost'
-      end
-
-      def port
-        Bitcoin.chain_params.default_port - 1
-      end
-
-      def server_url
-        "http://#{host}:#{port}"
-      end
-
-    end
-  end
-end

data/lib/bitcoin/node/spv.rb

@@ -1,87 +0,0 @@
-module Bitcoin
-  module Node
-
-    # SPV class
-    class SPV
-
-      attr_reader :chain
-      attr_reader :pool
-      attr_reader :logger
-      attr_accessor :running
-      attr_reader :configuration
-      attr_accessor :server
-      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
-        @pool = Bitcoin::Network::Pool.new(self, @chain, @configuration)
-        @logger = Bitcoin::Logger.create(:debug)
-        @running = false
-        @wallet = Bitcoin::Wallet::Base.current_wallet
-        # TODO : optimize bloom filter parameters
-        setup_filter
-      end
-
-      # open the node.
-      def run
-        # TODO need process running check.
-        return if running
-        logger.debug 'SPV node start running.'
-        EM.run do
-          # EM.start_server('0.0.0.0', Bitcoin.chain_params.default_port, Bitcoin::Network::InboundConnector, self)
-          pool.start
-          @server = Bitcoin::RPC::HttpServer.run(self, configuration.port)
-        end
-      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_hex}"
-      end
-
-      # add filter element to bloom filter.
-      # [String] element. the hex string of txid, public key, public key hash or outpoint.
-      def filter_add(element)
-        bloom.add(element)
-        pool.filter_add(element)
-      end
-
-      # clear bloom filter.
-      def filter_clear
-        pool.filter_clear
-      end
-
-      def add_observer(observer)
-        pool.add_observer(observer)
-      end
-
-      def delete_observer(observer)
-        pool.delete_observer(observer)
-      end
-
-      private
-
-      def setup_filter
-        @bloom = Bitcoin::BloomFilter.create_filter(512, 0.01)
-        wallet.watch_targets.each{|t|bloom.add(t.htb)} if wallet
-      end
-    end
-  end
-end

data/lib/bitcoin/node.rb

@@ -1,7 +0,0 @@
-module Bitcoin
-  module Node
-    autoload :SPV, 'bitcoin/node/spv'
-    autoload :CLI, 'bitcoin/node/cli'
-    autoload :Configuration, 'bitcoin/node/configuration'
-  end
-end