tapyrus 0.3.9 → 0.4.0

data/lib/tapyrus/network/pool.rb

@@ -1,135 +0,0 @@
-module Tapyrus
-  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 = Tapyrus::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
-        id += 1 until peers.empty? || peers.find { |p| p.id == id }.nil?
-        id
-      end
-
-      def connect(addr_list)
-        port = Tapyrus.chain_params.default_port
-
-        EM::Iterator
-          .new(addr_list, Tapyrus::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/tapyrus/network.rb

@@ -1,11 +0,0 @@
-require "eventmachine"
-
-module Tapyrus
-  module Network
-    autoload :MessageHandler, "tapyrus/network/message_handler"
-    autoload :Connection, "tapyrus/network/connection"
-    autoload :Pool, "tapyrus/network/pool"
-    autoload :Peer, "tapyrus/network/peer"
-    autoload :PeerDiscovery, "tapyrus/network/peer_discovery"
-  end
-end

data/lib/tapyrus/node/cli.rb

@@ -1,114 +0,0 @@
-require "net/http"
-require "thor"
-require "json"
-
-module Tapyrus
-  module Node
-    class CLI < Thor
-      class_option :network, aliases: "-n", default: :prod
-
-      desc "getblockchaininfo", "Returns an object containing various state info regarding blockchain processing."
-      def getblockchaininfo
-        request("getblockchaininfo")
-      end
-
-      desc "stop", "Stop Tapyrus 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 Tapyrus address for receiving payments."
-      def getnewaddress(account)
-        request("getnewaddress", account)
-      end
-
-      private
-
-      def config
-        opts = {}
-        opts[:network] = options["network"] if options["network"]
-        @conf ||= Tapyrus::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/tapyrus/node/configuration.rb

@@ -1,36 +0,0 @@
-require "iniparse"
-
-module Tapyrus
-  module Node
-    class Configuration
-      attr_reader :conf
-
-      def initialize(opts = {})
-        # TODO apply configuration file.
-        opts[:network] = :prod unless opts[:network]
-        opts[:relay] = false unless opts[:relay]
-        Tapyrus.chain_params = opts[:network]
-
-        begin
-          ini_file = IniParse.parse(File.read("#{Tapyrus.base_dir}/tapyrusrb.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
-        Tapyrus.chain_params.default_port - 1
-      end
-
-      def server_url
-        "http://#{host}:#{port}"
-      end
-    end
-  end
-end

data/lib/tapyrus/node/spv.rb

@@ -1,78 +0,0 @@
-module Tapyrus
-  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
-
-      def initialize(configuration)
-        @chain = Tapyrus::Store::SPVChain.new
-        @configuration = configuration
-        @pool = Tapyrus::Network::Pool.new(self, @chain, @configuration)
-        @logger = Tapyrus::Logger.create(:debug)
-        @running = false
-        @wallet = Tapyrus::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', Tapyrus.chain_params.default_port, Tapyrus::Network::InboundConnector, self)
-          pool.start
-          @server = Tapyrus::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 = Tapyrus::BloomFilter.create_filter(512, 0.01)
-        wallet.watch_targets.each { |t| bloom.add(t.htb) } if wallet
-      end
-    end
-  end
-end

data/lib/tapyrus/node.rb

@@ -1,7 +0,0 @@
-module Tapyrus
-  module Node
-    autoload :SPV, "tapyrus/node/spv"
-    autoload :CLI, "tapyrus/node/cli"
-    autoload :Configuration, "tapyrus/node/configuration"
-  end
-end

data/lib/tapyrus/rpc/http_server.rb

@@ -1,64 +0,0 @@
-require "evma_httpserver"
-require "json"
-
-module Tapyrus
-  module RPC
-    # Tapyrusrb RPC server.
-    class HttpServer < EM::Connection
-      include EM::HttpServer
-      include RequestHandler
-
-      attr_reader :node
-      attr_accessor :logger
-
-      def initialize(node)
-        @node = node
-        @logger = Tapyrus::Logger.create(:debug)
-      end
-
-      def post_init
-        super
-        logger.debug "start http server."
-      end
-
-      def self.run(node, port = 8332)
-        EM.start_server("0.0.0.0", port, HttpServer, node)
-      end
-
-      # process http request.
-      def process_http_request
-        operation =
-          proc do
-            command, args = parse_json_params
-            logger.debug("process http request. command = #{command}")
-            begin
-              send(command, *args).to_json
-            rescue Exception => e
-              e
-            end
-          end
-        callback =
-          proc do |result|
-            response = EM::DelegatedHttpResponse.new(self)
-            if result.is_a?(Exception)
-              response.status = 500
-              response.content = result.message
-            else
-              response.status = 200
-              response.content = result
-            end
-            response.content_type "application/json"
-            response.send_response
-          end
-        EM.defer(operation, callback)
-      end
-
-      # parse request parameter.
-      # @return [Array] the array of command and args
-      def parse_json_params
-        params = JSON.parse(@http_post_content)
-        [params["method"], params["params"]]
-      end
-    end
-  end
-end

data/lib/tapyrus/rpc/request_handler.rb

@@ -1,146 +0,0 @@
-module Tapyrus
-  module RPC
-    # RPC server's request handler.
-    module RequestHandler
-      # Returns an object containing various state info regarding blockchain processing.
-      def getblockchaininfo
-        h = {}
-        h[:chain] = Tapyrus.chain_params.network
-        best_block = node.chain.latest_block
-        h[:headers] = best_block.height
-        h[:bestblockhash] = best_block.header.block_id
-        h[:mediantime] = node.chain.mtp(best_block.block_hash)
-        h
-      end
-
-      # shutdown node
-      def stop
-        node.shutdown
-      end
-
-      # get block header information.
-      # @param [String] block_id block hash(big endian)
-      def getblockheader(block_id, verbose)
-        block_hash = block_id.rhex
-        entry = node.chain.find_entry_by_hash(block_hash)
-        raise ArgumentError.new("Block not found") unless entry
-        if verbose
-          {
-            hash: block_id,
-            height: entry.height,
-            features: entry.header.features,
-            featuresHex: entry.header.features.to_even_length_hex.ljust(8, "0"),
-            merkleroot: entry.header.merkle_root.rhex,
-            immutablemerkleroot: entry.header.im_merkle_root.rhex,
-            time: entry.header.time,
-            mediantime: node.chain.mtp(block_hash),
-            xfield_type: entry.header.x_field_type,
-            xfield: entry.header.x_field,
-            proof: entry.header.proof,
-            previousblockhash: entry.prev_hash.rhex,
-            nextblockhash: node.chain.next_hash(block_hash).rhex
-          }
-        else
-          entry.header.to_hex
-        end
-      end
-
-      # Returns connected peer information.
-      def getpeerinfo
-        node.pool.peers.map do |peer|
-          local_addr = "#{peer.remote_version.remote_addr.ip}:18333"
-          {
-            id: peer.id,
-            addr: "#{peer.host}:#{peer.port}",
-            addrlocal: local_addr,
-            services: peer.remote_version.services.to_even_length_hex.rjust(16, "0"),
-            relaytxes: peer.remote_version.relay,
-            lastsend: peer.last_send,
-            lastrecv: peer.last_recv,
-            bytessent: peer.bytes_sent,
-            bytesrecv: peer.bytes_recv,
-            conntime: peer.conn_time,
-            pingtime: peer.ping_time,
-            minping: peer.min_ping,
-            version: peer.remote_version.version,
-            subver: peer.remote_version.user_agent,
-            inbound: !peer.outbound?,
-            startingheight: peer.remote_version.start_height,
-            best_hash: peer.best_hash,
-            best_height: peer.best_height
-          }
-        end
-      end
-
-      # broadcast transaction
-      def sendrawtransaction(hex_tx)
-        tx = Tapyrus::Tx.parse_from_payload(hex_tx.htb)
-
-        # TODO check wether tx is valid
-        node.broadcast(tx)
-        tx.txid
-      end
-
-      # decode tx data.
-      def decoderawtransaction(hex_tx)
-        begin
-          Tapyrus::Tx.parse_from_payload(hex_tx.htb).to_h
-        rescue Exception
-          raise ArgumentError.new("TX decode failed")
-        end
-      end
-
-      # decode script data.
-      def decodescript(hex_script)
-        begin
-          script = Tapyrus::Script.parse_from_payload(hex_script.htb)
-          h = script.to_h
-          h.delete(:hex)
-          h[:p2sh] = script.to_p2sh.to_addr unless script.p2sh?
-          h
-        rescue Exception
-          raise ArgumentError.new("Script decode failed")
-        end
-      end
-
-      # wallet api
-
-      # create wallet
-      def createwallet(wallet_id = 1, wallet_path_prefix = Tapyrus::Wallet::Base.default_path_prefix)
-        wallet = Tapyrus::Wallet::Base.create(wallet_id, wallet_path_prefix)
-        node.wallet = wallet unless node.wallet
-        { wallet_id: wallet.wallet_id, mnemonic: wallet.master_key.mnemonic }
-      end
-
-      # get wallet list.
-      def listwallets(wallet_path_prefix = Tapyrus::Wallet::Base.default_path_prefix)
-        Tapyrus::Wallet::Base.wallet_paths(wallet_path_prefix)
-      end
-
-      # get current wallet information.
-      def getwalletinfo
-        node.wallet ? node.wallet.to_h : {}
-      end
-
-      # get the list of current Wallet accounts.
-      def listaccounts
-        return {} unless node.wallet
-        accounts = {}
-        node.wallet.accounts.each { |a| accounts[a.name] = node.wallet.get_balance(a) }
-        accounts
-      end
-
-      # encrypt wallet.
-      def encryptwallet(passphrase)
-        return nil unless node.wallet
-        node.wallet.encrypt(passphrase)
-        "The wallet 'wallet_id: #{node.wallet.wallet_id}' has been encrypted."
-      end
-
-      # create new tapyrus address for receiving payments.
-      def getnewaddress(account_name)
-        node.wallet.generate_new_address(account_name)
-      end
-    end
-  end
-end