bitcoinrb 1.12.0 → 1.13.0

data/lib/bitcoin/rpc/http_server.rb

@@ -1,84 +0,0 @@
-require 'evma_httpserver'
-require 'json'
-
-module Bitcoin
-  module RPC
-
-    # Bitcoinrb RPC server.
-    class HttpServer < EM::Connection
-      include EM::HttpServer
-      include RequestHandler
-
-      SUPPORTED_COMMANDS = %w[
-        getblockchaininfo
-        stop
-        getblockheader
-        getpeerinfo
-        sendrawtransaction
-        decoderawtransaction
-        decodescript
-        createwallet
-        listwallets
-        getwalletinfo
-        listaccounts
-        encryptwallet
-        getnewaddress
-      ].freeze
-
-      attr_reader :node
-      attr_accessor :logger
-
-      def initialize(node)
-        @node = node
-        @logger = Bitcoin::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 {
-          command, args = parse_json_params
-          logger.debug("process http request. command = #{command}")
-          unless SUPPORTED_COMMANDS.include?(command)
-            raise ArgumentError, "Unsupported method: #{command}"
-          end
-          begin
-            send(command, *args).to_json
-          rescue Exception => e
-            e
-          end
-        }
-        callback = proc{ |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
-        }
-        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/bitcoin/rpc/request_handler.rb

@@ -1,150 +0,0 @@
-module Bitcoin
-  module RPC
-
-    # RPC server's request handler.
-    module RequestHandler
-
-      # Returns an object containing various state info regarding blockchain processing.
-      def getblockchaininfo
-        h = {}
-        h[:chain] = Bitcoin.chain_params.network
-        best_block = node.chain.latest_block
-        h[:headers] = best_block.height
-        h[:bestblockhash] = best_block.header.block_id
-        h[:chainwork] = best_block.header.work
-        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,
-              version: entry.header.version,
-              versionHex: entry.header.version.to_even_length_hex,
-              merkleroot: entry.header.merkle_root.rhex,
-              time: entry.header.time,
-              mediantime: node.chain.mtp(block_hash),
-              nonce: entry.header.nonce,
-              bits: entry.header.bits.to_even_length_hex,
-              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.addr_string}: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 = Bitcoin::Tx.parse_from_payload(hex_tx.htb, strict: true)
-        # TODO check wether tx is valid
-        node.broadcast(tx)
-        tx.txid
-      end
-
-      # decode tx data.
-      def decoderawtransaction(hex_tx)
-        begin
-          Bitcoin::Tx.parse_from_payload(hex_tx.htb, strict: true ).to_h
-        rescue Exception
-          raise ArgumentError.new('TX decode failed')
-        end
-      end
-
-      # decode script data.
-      def decodescript(hex_script)
-        begin
-          script = Bitcoin::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 = Bitcoin::Wallet::Base.default_path_prefix)
-        wallet = Bitcoin::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 = Bitcoin::Wallet::Base.default_path_prefix)
-        Bitcoin::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 do |a|
-          accounts[a.name] = node.wallet.get_balance(a)
-        end
-        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 bitcoin address for receiving payments.
-      def getnewaddress(account_name)
-        node.wallet.generate_new_address(account_name)
-      end
-
-    end
-
-  end
-end

data/lib/bitcoin/store/chain_entry.rb

@@ -1,68 +0,0 @@
-module Bitcoin
-  module Store
-
-    # wrap a block header object with extra data.
-    class ChainEntry
-      include Bitcoin::HexConverter
-
-      attr_reader :header
-      attr_reader :height
-
-      # @param [Bitcoin::BlockHeader] header a block header.
-      # @param [Integer] height a block height.
-      def initialize(header, height)
-        @header = header
-        @height = height
-      end
-
-      # get database key
-      def key
-        Bitcoin::Store::KEY_PREFIX[:entry] + header.block_hash
-      end
-
-      def hash
-        header.hash
-      end
-
-      # block hash
-      def block_hash
-        header.block_hash
-      end
-
-      # previous block hash
-      def prev_hash
-        header.prev_hash
-      end
-
-      # whether genesis block
-      def genesis?
-        Bitcoin.chain_params.genesis_block.header == header
-      end
-
-      # @param [String] payload a payload with binary format.
-      def self.parse_from_payload(payload)
-        buf = StringIO.new(payload)
-        len = Bitcoin.unpack_var_int_from_io(buf)
-        height = buf.read(len).reverse.bth.to_i(16)
-        new(Bitcoin::BlockHeader.parse_from_payload(buf.read(80)), height)
-      end
-
-      # build next block +StoredBlock+ instance.
-      # @param [Bitcoin::BlockHeader] next_block a next block candidate header.
-      # @return [Bitcoin::Store::ChainEntry] a next stored block (not saved).
-      def build_next_block(next_block)
-        ChainEntry.new(next_block, height + 1)
-      end
-
-      # generate payload
-      def to_payload
-        height_value = height.to_even_length_hex
-        height_value = height_value.htb.reverse
-        Bitcoin.pack_var_int(height_value.bytesize) + height_value + header.to_payload
-      end
-
-    end
-
-  end
-
-end

data/lib/bitcoin/store/db/level_db.rb

@@ -1,98 +0,0 @@
-require 'leveldb-native'
-
-module Bitcoin
-  module Store
-    module DB
-
-      class LevelDB
-
-        attr_reader :db
-        attr_reader :logger
-
-        def initialize(path = "#{Bitcoin.base_dir}/db/spv")
-          # @logger = Bitcoin::Logger.create(:debug)
-          FileUtils.mkdir_p(path)
-          @db = ::LevelDBNative::DB.new(path)
-          # logger.debug 'Opened LevelDB successfully.'
-        end
-
-        # put data into LevelDB.
-        # @param [Object] key a key.
-        # @param [Object] value a value.
-        def put(key, value)
-          # logger.debug "put #{key} data"
-          db.put(key, value)
-        end
-
-        # get value from specified key.
-        # @param [Object] key a key.
-        # @return[Object] the stored value.
-        def get(key)
-          db.get(key)
-        end
-
-        # get best block hash.
-        def best_hash
-          db.get(KEY_PREFIX[:best])
-        end
-
-        # delete specified key data.
-        def delete(key)
-          db.delete(key)
-        end
-
-        # get block hash specified +height+
-        def get_hash_from_height(height)
-          db.get(height_key(height))
-        end
-
-        # get next block hash specified +hash+
-        def next_hash(hash)
-          db.get(KEY_PREFIX[:next] + hash)
-        end
-
-        # get entry payload
-        # @param [String] hash the hash with hex format.
-        # @return [String] the ChainEntry payload.
-        def get_entry_payload_from_hash(hash)
-          db.get(KEY_PREFIX[:entry] + hash)
-        end
-
-        def save_entry(entry)
-          db.batch do
-            db.put(entry.key ,entry.to_payload)
-            db.put(height_key(entry.height), entry.block_hash)
-            connect_entry(entry)
-          end
-        end
-
-        def close
-          db.close
-        end
-
-        private
-
-        # generate height key
-        def height_key(height)
-          height = height.to_even_length_hex
-          KEY_PREFIX[:height] + height.rhex
-        end
-
-        def connect_entry(entry)
-          unless entry.genesis?
-            tip_block = Bitcoin::Store::ChainEntry.parse_from_payload(get_entry_payload_from_hash(best_hash))
-            unless tip_block.block_hash == entry.prev_hash
-              raise "entry(#{entry.block_hash}) does not reference current best block hash(#{tip_block.block_hash})"
-            end
-            unless tip_block.height + 1 == entry.height
-              raise "block height is small than current best block."
-            end
-          end
-          db.put(KEY_PREFIX[:best], entry.block_hash)
-          db.put(KEY_PREFIX[:next] + entry.prev_hash, entry.block_hash)
-        end
-      end
-
-    end
-  end
-end

data/lib/bitcoin/store/db.rb

@@ -1,9 +0,0 @@
-module Bitcoin
-  module Store
-
-    module DB
-      autoload :LevelDB, 'bitcoin/store/db/level_db'
-    end
-
-  end
-end

data/lib/bitcoin/store/spv_chain.rb

@@ -1,101 +0,0 @@
-module Bitcoin
-
-  module Store
-
-    KEY_PREFIX = {
-        entry: 'e',   # key: block hash, value: Bitcoin::Store::ChainEntry payload
-        height: 'h',  # key: block height, value: block hash.
-        best: 'B',    # value: best block hash.
-        next: 'n'     # key: block hash, value: A hash of the next block of the specified hash
-    }
-
-    class SPVChain
-
-      attr_reader :db
-      attr_reader :logger
-
-      def initialize(db = Bitcoin::Store::DB::LevelDB.new)
-        @db = db # TODO multiple db switch
-        @logger = Bitcoin::Logger.create(:debug)
-        initialize_block
-      end
-
-      # get latest block in the store.
-      # @return[Bitcoin::Store::ChainEntry]
-      def latest_block
-        hash = db.best_hash
-        return nil unless hash
-        find_entry_by_hash(hash)
-      end
-
-      # find block entry with the specified height.
-      def find_entry_by_height(height)
-        find_entry_by_hash(db.get_hash_from_height(height))
-      end
-
-      # find block entry with the specified hash
-      def find_entry_by_hash(hash)
-        payload = db.get_entry_payload_from_hash(hash)
-        return nil unless payload
-        ChainEntry.parse_from_payload(payload)
-      end
-
-      # append block header to chain.
-      # @param [Bitcoin::BlockHeader] header a block header.
-      # @return [Bitcoin::Store::ChainEntry] appended block header entry.
-      def append_header(header)
-        logger.info("append header #{header.block_id}")
-        raise "this header is invalid. #{header.block_hash}" unless header.valid?
-        best_block = latest_block
-        current_height = best_block.height
-        if best_block.block_hash == header.prev_hash
-          entry = Bitcoin::Store::ChainEntry.new(header, current_height + 1)
-          db.save_entry(entry)
-          entry
-        else
-          unless find_entry_by_hash(header.block_hash)
-            # TODO implements recovery process
-            raise "header's previous hash(#{header.prev_hash}) does not match current best block's(#{best_block.block_hash})."
-          end
-        end
-      end
-
-      # get next block hash for specified +hash+
-      # @param [String] hash the block hash(little endian)
-      # @return [String] the next block hash. If it does not exist yet, return nil.
-      def next_hash(hash)
-        db.next_hash(hash)
-      end
-
-      # get median time past for specified block +hash+
-      # @param [String] hash the block hash.
-      # @return [Integer] the median time past value.
-      def mtp(hash)
-        time = []
-        Bitcoin::MEDIAN_TIME_SPAN.times do
-          entry = find_entry_by_hash(hash)
-          break unless entry
-
-          time << entry.header.time
-          hash = entry.header.prev_hash
-        end
-        time.sort!
-        time[time.size / 2]
-      end
-
-      private
-
-      # if database is empty, put genesis block.
-      def initialize_block
-        unless latest_block
-          block = Bitcoin.chain_params.genesis_block
-          genesis = ChainEntry.new(block.header, 0)
-          db.save_entry(genesis)
-        end
-      end
-
-    end
-
-  end
-
-end