bitcoinrb 1.12.0 → 1.12.1

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

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