tapyrus 0.1.0

data/lib/tapyrus/rpc/request_handler.rb

@@ -0,0 +1,150 @@
+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[: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_payload.bth
+        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.addresses.first 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 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 tapyrus address for receiving payments.
+      def getnewaddress(account_name)
+        node.wallet.generate_new_address(account_name)
+      end
+
+    end
+
+  end
+end

data/lib/tapyrus/rpc/tapyrus_core_client.rb

@@ -0,0 +1,72 @@
+require 'rest-client'
+
+module Tapyrus
+  module RPC
+
+    # Client implementation for RPC to Bitcoin Core.
+    #
+    # [Usage]
+    # config = {schema: 'http', host: 'localhost', port: 18332, user: 'xxx', password: 'yyy'}
+    # client = Tapyrus::RPC::BitcoinCoreClient.new(config)
+    #
+    # You can execute the CLI command supported by Bitcoin Core as follows:
+    #
+    # client.listunspent
+    # client.getblockchaininfo
+    #
+    class TapyrusCoreClient
+
+      attr_reader :config
+
+      # @param [Hash] config a configuration required to connect to Bitcoin Core.
+      def initialize(config)
+        @config = config
+
+        commands = request(:help).split("\n").inject([]) do |memo_ary, line|
+          if !line.empty? && !line.start_with?('==')
+            memo_ary << line.split(' ').first.to_sym
+          end
+          memo_ary
+        end
+        TapyrusCoreClient.class_eval do
+          commands.each do |command|
+            define_method(command) do |*params|
+              request(command, *params)
+            end
+          end
+        end
+      end
+
+      private
+
+      def server_url
+        url = "#{config[:schema]}://#{config[:user]}:#{config[:password]}@#{config[:host]}:#{config[:port]}"
+        if !config[:wallet].nil? && !config[:wallet].empty?
+          url += "/wallet/#{config[:wallet]}"
+        end
+        url
+      end
+
+      def request(command, *params)
+        data = {
+            :method => command,
+            :params => params,
+            :id => 'jsonrpc'
+        }
+        post(server_url, @config[:timeout], @config[:open_timeout], data.to_json, content_type: :json) do |respdata, request, result|
+          raise result.message if !result.kind_of?(Net::HTTPSuccess) && respdata.empty?
+          response = JSON.parse(respdata.gsub(/\\u([\da-fA-F]{4})/) { [$1].pack('H*').unpack('n*').pack('U*').encode('ISO-8859-1').force_encoding('UTF-8') })
+          raise response['error'] if response['error']
+          response['result']
+        end
+      end
+
+      def post(url, timeout, open_timeout, payload, headers={}, &block)
+        RestClient::Request.execute(method: :post, url: url, timeout: timeout,
+                                    open_timeout: open_timeout, payload: payload, headers: headers, &block)
+      end
+
+    end
+
+  end
+end

data/lib/tapyrus/rpc.rb

@@ -0,0 +1,7 @@
+module Tapyrus
+  module RPC
+    autoload :HttpServer, 'tapyrus/rpc/http_server'
+    autoload :RequestHandler, 'tapyrus/rpc/request_handler'
+    autoload :TapyrusCoreClient, 'tapyrus/rpc/tapyrus_core_client'
+  end
+end

data/lib/tapyrus/script/multisig.rb

@@ -0,0 +1,92 @@
+module Tapyrus
+
+  # utility for multisig
+  module Multisig
+    include Tapyrus::Opcodes
+
+    def self.prefix
+      [OP_0].pack("C*")
+    end
+
+    # generate input script sig spending a multisig output script.
+    # returns a raw binary script sig of the form:
+    #  OP_0 <sig> [<sig> ...]
+    # @param [[String]] array of signatures
+    # @return [String] script_sig for multisig
+    def self.to_multisig_script_sig(*sigs)
+      hash_type = sigs.last.is_a?(Numeric) ? sigs.pop : SIGHASH_TYPE[:all]
+      sigs.reverse.inject(prefix) { |joined, sig| add_sig_to_multisig_script_sig(sig, joined, hash_type) }
+    end
+
+    # take a multisig script sig (or p2sh multisig script sig) and add
+    # another signature to it after the OP_0. Used to sign a tx by
+    # multiple parties. Signatures must be in the same order as the
+    # pubkeys in the output script being redeemed.
+    def self.add_sig_to_multisig_script_sig(sig_to_add, script_sig, hash_type = SIGHASH_TYPE[:all])
+      signature = sig_to_add + [hash_type].pack("C*")
+      offset = script_sig.empty? ? 0 : 1
+      script_sig.insert(offset, Tapyrus::Script.pack_pushdata(signature))
+    end
+
+    # generate input script sig spending a p2sh-multisig output script.
+    # returns a raw binary script sig of the form:
+    #  OP_0 <sig> [<sig> ...] <redeem_script>
+    # @param [Script] redeem_script
+    # @param [[String]] array of signatures
+    # @return [String] script_sig for multisig
+    def self.to_p2sh_multisig_script_sig(redeem_script, *sigs)
+      to_multisig_script_sig(*sigs.flatten) + Tapyrus::Script.pack_pushdata(redeem_script)
+    end
+
+    # Sort signatures in the given +script_sig+ according to the order of pubkeys in
+    # the redeem script. Also needs the +sig_hash+ to match signatures to pubkeys.
+    # @param [String] signature for multisig.
+    # @param [String] sig_hash to be signed.
+    # @return [String] sorted sig_hash.
+    def self.sort_p2sh_multisig_signatures(script_sig, sig_hash)
+      script = Tapyrus::Script.parse_from_payload(script_sig)
+      redeem_script = Tapyrus::Script.parse_from_payload(script.chunks[-1].pushed_data)
+      pubkeys = redeem_script.get_multisig_pubkeys
+
+      # find the pubkey for each signature by trying to verify it
+      sigs = Hash[script.chunks[1...-1].map.with_index do |sig, idx|
+        sig = sig.pushed_data
+        pubkey = pubkeys.map do |key|
+          Tapyrus::Key.new(pubkey: key.bth).verify(sig, sig_hash) ? key : nil
+        end.compact.first
+        raise "Key for signature ##{idx} not found in redeem script!"  unless pubkey
+        [pubkey, sig]
+      end]
+
+      prefix + pubkeys.map { |k| sigs[k] ? Tapyrus::Script.pack_pushdata(sigs[k]) : nil }.join +
+        Tapyrus::Script.pack_pushdata(script.chunks[-1].pushed_data)
+    end
+
+    def self.add_sig_to_multisig_script_witness(sig_to_add, script_witness, hash_type = SIGHASH_TYPE[:all])
+      signature = sig_to_add + [hash_type].pack("C*")
+      script_witness.stack << signature
+    end
+
+    # Sort signatures in the given +script_witness+ according to the order of pubkeys in
+    # the redeem script. Also needs the +sig_hash+ to match signatures to pubkeys.
+    # @param [ScriptWitness] script_witness for multisig.
+    # @param [String] sig_hash to be signed.
+    def self.sort_witness_multisig_signatures(script_witness, sig_hash)
+      redeem_script = Tapyrus::Script.parse_from_payload(script_witness.stack[-1])
+      pubkeys = redeem_script.get_multisig_pubkeys
+      sigs = Hash[script_witness.stack[1...-1].map.with_index do |sig, idx|
+        pubkey = pubkeys.map do |key|
+          Tapyrus::Key.new(pubkey: key.bth).verify(sig, sig_hash) ? key : nil
+        end.compact.first
+        raise "Key for signature ##{idx} not found in redeem script!"  unless pubkey
+        [pubkey, sig]
+      end]
+      script_witness.stack.clear
+      script_witness.stack << ''
+      pubkeys.each do |pubkey|
+        script_witness.stack << sigs[pubkey] if sigs[pubkey]
+      end
+      script_witness.stack << redeem_script.to_payload
+    end
+  end
+end