bitcoinrb 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f25b7f5ff1de3882b880e49e858f3b49bf8c13a
-  data.tar.gz: 2a04f3a090503ffdc15d337b351c839d68b33929
+  metadata.gz: 3af358507bac7836acb65b028e77391acc664890
+  data.tar.gz: a9bcb5f19f17b9a2ecd1e5c0a43b3aa29c0329ec
 SHA512:
-  metadata.gz: abbfff02611cb216dc843414bc7e8e9f4e9799a72314ebc3f165f6b100fa2e2d77843975b77bca8ccce3d23d7fb749eb12c62f881ac7f3635840bb68eedb9791
-  data.tar.gz: a0a3fd06f7120bdff5c04375e1ab4214d3e962256d96f4c5f9a48811eeb5227ad602bd7ff2283c117219d3bb4d880dd529a9b0fde1567cc2ef03d2a9b2106cfd
+  metadata.gz: 32e8a8c8d0a1a80ec3ffcfa373f41a5d0987d83da9616a568acb5f9982bcc25a91b406f2163242e6e45d43c0f956e47913d4a280c821cc7f724da7836192b235
+  data.tar.gz: b476e81be5caff178b14161f0873d770c91795d59b0e0b518fcc68b8f138b525c023002b3ab3846e5ae24a9b46d61eff3ff0a32fb1b37aea4386c08ade25296e

data/exe/bitcoinrbd

@@ -1,30 +1,36 @@
 #!/usr/bin/env ruby
 require 'thor'
 require 'bitcoin'
-require 'bitcoin/node/spv'
+require 'daemon_spawn'
+
+class BitcoinDaemon < DaemonSpawn::Base
+
+  def start(args)
+    puts "Bitcoinrb daemon start : #{Time.now}"
+    conf = Bitcoin::Node::Configuration.new(network: args.first[:network])
+    node = Bitcoin::Node::SPV.new(conf)
+    node.run
+  end
+
+end
 
 class Bitcoinrbd < Thor
 
-  option :mode, default: 'spv'
-  option :network, default: 'mainnet'
-  desc 'start', 'start bitcoinrbd daemon process'
+  class_option :network, aliases: '-n', default: :mainnet
+
+  desc 'start', 'start bitcoinrb daemon.'
   def start
-    raise ArgumentError, 'currently only support spv mode.' unless options[:mode] == 'spv'
-    Bitcoin.chain_params = network.to_sym
+    network = options['network'] ? options['network'].to_sym : :mainnet
+    Bitcoin.chain_params = network
     FileUtils.mkdir_p(Bitcoin.base_dir)
-    execute_daemon(['start'])
+    execute_daemon(['start', network: network])
   end
 
-  option :mode, default: 'spv'
-  option :network, default: 'mainnet'
-  desc 'stop', 'start bitcoinrbd daemon process'
-  def stop
-    execute_daemon(['stop'])
-  end
+  private
 
   def execute_daemon(cmd_args)
-    Bitcoin::Nodes::SPV.spawn!({working_dir: Bitcoin.base_dir,
-                                     log_file: "#{Bitcoin.base_dir}/bitcoinrbd.log",
+    BitcoinDaemon.spawn!({working_dir: Bitcoin.base_dir,
+                                     log_file: "#{Bitcoin.base_dir}/log/bitcoinrbd.log",
                                      pid_file: "#{Bitcoin.base_dir}/bitcoinrbd.pid",
                                      sync_log: true,
                                      singleton: true}, cmd_args)

data/lib/bitcoin/chain_params.rb

@@ -24,6 +24,7 @@ module Bitcoin
     attr_reader :proof_of_work_limit
     attr_reader :dns_seeds
     attr_reader :genesis
+    attr_reader :bip44_coin_type
 
     # mainnet genesis
     def self.mainnet

data/lib/bitcoin/chainparams/mainnet.yml

@@ -30,3 +30,4 @@ genesis:
   bits: 0x1d00ffff
   version: 1
   prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"
+bip44_coin_type: 0

data/lib/bitcoin/chainparams/regtest.yml

@@ -25,4 +25,5 @@ genesis:
   nonce: 2
   bits: 0x207fffff
   version: 1
-  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"
+  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"
+bip44_coin_type: 1

data/lib/bitcoin/chainparams/testnet.yml

@@ -29,4 +29,5 @@ genesis:
   nonce: 414098458
   bits: 0x1d00ffff
   version: 1
-  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"
+  prev_hash: "0000000000000000000000000000000000000000000000000000000000000000"
+bip44_coin_type: 1

data/lib/bitcoin/ext_key.rb

@@ -64,6 +64,10 @@ module Bitcoin
       key.pubkey
     end
 
+    def hash160
+      Bitcoin.hash160(pub)
+    end
+
     # get address
     def addr
       key.to_p2pkh
@@ -84,6 +88,11 @@ module Bitcoin
       identifier.slice(0..7)
     end
 
+    # whether hardened key.
+    def hardened?
+      number >= 2**31
+    end
+
     # derive new key
     def derive(number)
       new_key = ExtKey.new
@@ -139,6 +148,10 @@ module Bitcoin
       pubkey
     end
 
+    def hash160
+      Bitcoin.hash160(pub)
+    end
+
     # get address
     def addr
       Bitcoin::Key.new(pubkey: pubkey).to_p2pkh
@@ -171,6 +184,11 @@ module Bitcoin
       Base58.encode(hex)
     end
 
+    # whether hardened key.
+    def hardened?
+      number >= 2**31
+    end
+
     # derive child key
     def derive(number)
       new_key = ExtPubkey.new

data/lib/bitcoin/network/message_handler.rb

@@ -107,6 +107,7 @@ module Bitcoin
       end
 
       def handshake_done
+        return unless @incomming_handshake && @outgoing_handshake
         logger.info 'handshake finished.'
         @connected = true
         post_handshake
@@ -116,10 +117,13 @@ module Bitcoin
         logger.info("receive version message. #{version.build_json}")
         @version = version
         send_message(Bitcoin::Message::VerAck.new)
+        @incomming_handshake = true
+        handshake_done
       end
 
       def on_ver_ack
         logger.info('receive verack message.')
+        @outgoing_handshake = true
         handshake_done
       end
 

data/lib/bitcoin/node/cli.rb

@@ -35,6 +35,16 @@ module Bitcoin
         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
+
       private
 
       def config
@@ -53,8 +63,12 @@ module Bitcoin
           RestClient::Request.execute(method: :post, url: config.server_url, payload: data.to_json,
                                       headers: {content_type: :json}) do |response, request, result|
             return false if !result.kind_of?(Net::HTTPSuccess) && response.empty?
-            json = JSON.parse(response.to_str)
-            puts JSON.pretty_generate(json)
+            begin
+              json = JSON.parse(response.to_str)
+              puts JSON.pretty_generate(json)
+            rescue Exception
+              puts response.to_str
+            end
           end
         rescue Exception => e
           puts e.message

data/lib/bitcoin/rpc/http_server.rb

@@ -31,13 +31,22 @@ module Bitcoin
         operation = proc {
           command, args = parse_json_params
           logger.debug("process http request. command = #{command}")
-          send(command, *args).to_json
+          begin
+            send(command, *args).to_json
+          rescue Exception => e
+            e
+          end
         }
         callback = proc{ |result|
           response = EM::DelegatedHttpResponse.new(self)
-          response.status = 200
+          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.content = result
           response.send_response
         }
         EM.defer(operation, callback)

data/lib/bitcoin/rpc/request_handler.rb

@@ -78,6 +78,20 @@ module Bitcoin
         tx.txid
       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
+
     end
 
   end

data/lib/bitcoin/script/script.rb

@@ -413,8 +413,7 @@ module Bitcoin
       return nil unless p2pkh?
       hash160 = chunks[2].pushed_data.bth
       return nil unless hash160.htb.bytesize == 20
-      hex = Bitcoin.chain_params.address_version + hash160
-      Bitcoin.encode_base58_address(hex)
+      Bitcoin.encode_base58_address(hash160, Bitcoin.chain_params.address_version)
     end
 
     # generate p2wpkh address. if script dose not p2wpkh, return nil.
@@ -427,8 +426,7 @@ module Bitcoin
       return nil unless p2sh?
       hash160 = chunks[1].pushed_data.bth
       return nil unless hash160.htb.bytesize == 20
-      hex = Bitcoin.chain_params.p2sh_version + hash160
-      Bitcoin.encode_base58_address(hex)
+      Bitcoin.encode_base58_address(hash160, Bitcoin.chain_params.p2sh_version)
     end
 
     # generate p2wsh address. if script dose not p2wsh, return nil.

data/lib/bitcoin/util.rb

@@ -82,12 +82,9 @@ module Bitcoin
       Digest::RMD160.hexdigest(Digest::SHA256.digest(hex.htb))
     end
 
-    def encode_base58_address(hex)
-      Base58.encode(hex + calc_checksum(hex))
-    end
-
-    def decode_base58_address(addr)
-      Base58.decode(addr)
+    def encode_base58_address(hex, addr_version)
+      base = addr_version + hex
+      Base58.encode(base + calc_checksum(base))
     end
 
     def calc_checksum(hex)

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/bitcoin/wallet/account.rb

@@ -9,12 +9,12 @@ module Bitcoin
       attr_reader :purpose # either 44 or 49
       attr_reader :index # BIP-44 index
       attr_reader :name # account name
-      attr_accessor :receive_depth # receive address depth
-      attr_accessor :change_depth # change address depth
+      attr_accessor :receive_depth # receive address depth(address index)
+      attr_accessor :change_depth # change address depth(address index)
       attr_accessor :lookahead
       attr_accessor :wallet
 
-      def initialize(purpose = PURPOSE_TYPE[:legacy], index = 0, name = '')
+      def initialize(purpose = PURPOSE_TYPE[:nested_witness], index = 0, name = '')
         @purpose = purpose
         @index = index
         @name = name
@@ -46,22 +46,20 @@ module Bitcoin
       end
 
       def init
-        lookahead.times do |index|
-          derive_receive(index)
-          derive_change(index)
-        end
+        @receive_depth = lookahead
+        @change_depth = lookahead
         @index = wallet.accounts.size
         save
       end
 
       # derive receive key
-      def derive_receive(index)
-        derive(0, index)
+      def derive_receive(address_index)
+        derive_path(0, address_index)
       end
 
       # derive change key
-      def derive_change(index)
-        derive(1, index)
+      def derive_change(address_index)
+        derive_path(1, address_index)
       end
 
       # save this account payload to database.
@@ -69,11 +67,27 @@ module Bitcoin
         wallet.db.save_account(self)
       end
 
+      # get the list of derived keys for receive key.
+      def derived_receive_keys
+        receive_depth.times.map{|i|derive_key(0,i)}
+      end
+
+      # get the list of derived keys for change key.
+      def derived_change_keys
+        receive_depth.times.map{|i|derive_key(1,i)}
+      end
+
       private
 
-      # derive key
-      def derive(branch, index)
+      def derive_key(branch, address_index)
+        account_key.derive(branch).derive(address_index)
+      end
 
+      def account_key
+        return @cached_account_key if @cached_account_key
+        coin_type = Bitcoin.chain_params.bip44_coin_type
+        # m / purpose' / coin_type' / account_index'
+        @cached_account_key = wallet.master_key.key.derive(2**31 + purpose).derive(2**31 + coin_type).derive(2**31 + index)
       end
 
     end

data/lib/bitcoin/wallet/base.rb

@@ -6,8 +6,9 @@ module Bitcoin
 
       attr_accessor :wallet_id
       attr_reader :db
+      attr_reader :path
 
-      DEFAULT_PATH_PREFIX = "#{Bitcoin.base_dir}/db/wallet"
+      DEFAULT_PATH_PREFIX = "#{Bitcoin.base_dir}/db/wallet/"
 
       # Create new wallet. If wallet already exist, throw error.
       # The wallet generates a seed using SecureRandom and store to db at initialization.
@@ -21,6 +22,7 @@ module Bitcoin
         raise RuntimeError, 'the seed already exist.' if w.db.registered_master?
         master = Bitcoin::Wallet::MasterKey.generate
         w.db.register_master_key(master)
+        w.create_account('Default')
         w
       end
 
@@ -31,12 +33,22 @@ module Bitcoin
         self.new(wallet_id, path_prefix)
       end
 
+      # get wallets path
+      # @return [Array] Array of paths for each wallet dir.
+      def self.wallet_paths(path_prefix = DEFAULT_PATH_PREFIX)
+        Dir.glob("#{path_prefix}wallet*/")
+      end
+
       # get account list based on BIP-44
       def accounts
-        db.accounts.map{|raw| Account.parse_from_payload(raw)}
+        db.accounts.map do |raw|
+          a = Account.parse_from_payload(raw)
+          a.wallet = self
+          a
+        end
       end
 
-      def create_account(purpose = Account::PURPOSE_TYPE[:legacy], index = 0, name)
+      def create_account(purpose = Account::PURPOSE_TYPE[:nested_witness], index = 0, name)
         account = Account.new(purpose, index, name)
         account.wallet = self
         account.init
@@ -69,12 +81,13 @@ module Bitcoin
       private
 
       def initialize(wallet_id, path_prefix)
-        @db = Bitcoin::Wallet::DB.new("#{path_prefix}_#{wallet_id}")
+        @path = "#{path_prefix}wallet#{wallet_id}/"
+        @db = Bitcoin::Wallet::DB.new(@path)
         @wallet_id = wallet_id
       end
 
       def self.exist?(wallet_id, path_prefix)
-        path = "#{path_prefix}_#{wallet_id}"
+        path = "#{path_prefix}wallet#{wallet_id}"
         Dir.exist?(path)
       end
 

data/lib/bitcoin/wallet/master_key.rb

@@ -21,7 +21,7 @@ module Bitcoin
       # generate new master key.
       # @return Bitcoin::Wallet::MasterKey
       def self.generate
-        entropy = SecureRandom.hex(16)
+        entropy = SecureRandom.hex(32)
         mnemonic = Bitcoin::Mnemonic.new('english')
         self.recover_from_words(mnemonic.to_mnemonic(entropy))
       end
@@ -42,6 +42,7 @@ module Bitcoin
         flag, payload = unpack_var_int(payload)
         raise 'encrypted flag is invalid.' unless [0, 1].include?(flag)
         salt, payload = unpack_var_string(payload)
+        salt = '' unless salt
         seed, payload = unpack_var_string(payload)
         self.new(seed.bth, salt: salt.bth, encrypted: flag == 1)
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-02 00:00:00.000000000 Z
+date: 2017-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -373,7 +373,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: "[WIP]The implementation of Bitcoin Protocol for Ruby."