bitcoinrb-grpc 0.1.0

data/lib/bitcoin/grpc/grpc_services_pb.rb

@@ -0,0 +1,26 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: bitcoin/grpc/grpc.proto for package 'bitcoin.grpc'
+
+require 'grpc'
+require 'bitcoin/grpc/grpc_pb'
+
+module Bitcoin
+  module Grpc
+    module Blockchain
+      class Service
+
+        include GRPC::GenericService
+
+        self.marshal_class_method = :encode
+        self.unmarshal_class_method = :decode
+        self.service_name = 'bitcoin.grpc.Blockchain'
+
+        rpc :WatchTxConfirmed, WatchTxConfirmedRequest, stream(WatchTxConfirmedResponse)
+        rpc :WatchUtxo, WatchUtxoRequest, stream(WatchUtxoResponse)
+        rpc :WatchToken, WatchTokenRequest, stream(WatchTokenResponse)
+      end
+
+      Stub = Service.rpc_stub_class
+    end
+  end
+end

data/lib/bitcoin/grpc/oap_service.rb

@@ -0,0 +1,28 @@
+require 'jsonclient'
+
+module Bitcoin
+  module Grpc
+    module OapService
+      def self.outputs_with_open_asset_id(tx_hash)
+        client = JSONClient.new
+        client.debug_dev = STDOUT
+
+        response = client.get("#{oae_url}#{tx_hash.rhex}?format=json")
+        response.body['outputs']
+      rescue RuntimeError => _
+        nil
+      end
+
+      def self.oae_url
+        case
+        when Bitcoin.chain_params.mainnet?
+          'https://www.oaexplorer.com/tx/'
+        when Bitcoin.chain_params.testnet?
+          'https://testnet.oaexplorer.com/tx/'
+        when Bitcoin.chain_params.regtest?
+          'http://localhost:9292/tx/'
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/grpc/server.rb

@@ -0,0 +1,113 @@
+module Bitcoin
+  module Grpc
+    class Server < Bitcoin::Grpc::Blockchain::Service
+      def self.run(spv)
+        addr = "0.0.0.0:8080"
+        s = GRPC::RpcServer.new
+        s.add_http2_port(addr, :this_port_is_insecure)
+        s.handle(new(spv))
+        s.run_till_terminated
+      end
+
+      attr_reader :spv, :utxo_handler, :asset_handler, :publisher, :logger
+
+      def initialize(spv)
+        @spv = spv
+        @publisher = Bitcoin::Wallet::Publisher.spawn(:publisher)
+        @utxo_handler = Bitcoin::Wallet::UtxoHandler.spawn(:utxo_handler, spv, publisher)
+        @asset_handler = Bitcoin::Wallet::AssetHandler.spawn(:asset_handler, spv, publisher)
+        @logger = Bitcoin::Logger.create(:debug)
+      end
+
+      def watch_tx_confirmed(request, call)
+        logger.info("watch_tx_confirmed: #{request}")
+        utxo_handler << request
+        channel = Concurrent::Channel.new
+        Receiver.spawn(:receiver, channel, publisher, [Bitcoin::Grpc::EventTxConfirmed])
+        ResponseEnum.new(request, channel, WatchTxConfirmedResponseBuilder).each
+      end
+
+      def watch_utxo(request, call)
+        logger.info("watch_utxo: #{request}")
+        utxo_handler << request
+        channel = Concurrent::Channel.new
+        Receiver.spawn(:receiver, channel, publisher, [Bitcoin::Grpc::EventUtxoRegistered, Bitcoin::Grpc::EventUtxoSpent])
+        ResponseEnum.new(request, channel, WatchUtxoResponseBuilder).each
+      end
+
+      def watch_token(request, call)
+        logger.info("watch_token: #{request}")
+        utxo_handler << request
+        channel = Concurrent::Channel.new
+        Receiver.spawn(:receiver, channel, publisher, [Bitcoin::Grpc::EventTokenIssued, Bitcoin::Grpc::EventTokenTransfered])
+        ResponseEnum.new(request, channel, WatchTokenResponseBuilder).each
+      end
+    end
+
+    class WatchTxConfirmedResponseBuilder
+      def self.build(event)
+        case event
+        when Bitcoin::Grpc::EventTxConfirmed
+          Bitcoin::Grpc::WatchTxConfirmedResponse.new(confirmed: event)
+        end
+      end
+    end
+
+    class WatchUtxoResponseBuilder
+      def self.build(event)
+        case event
+        when Bitcoin::Grpc::EventUtxoRegistered
+          Bitcoin::Grpc::WatchUtxoResponse.new(registered: event)
+        when Bitcoin::Grpc::EventUtxoSpent
+          Bitcoin::Grpc::WatchUtxoResponse.new(spent: event)
+        end
+      end
+    end
+
+    class WatchTokenResponseBuilder
+      def self.build(event)
+        case event
+        when Bitcoin::Grpc::EventTokenIssued
+          Bitcoin::Grpc::WatchTokenResponse.new(issued: event)
+        when Bitcoin::Grpc::EventTokenTransfered
+          Bitcoin::Grpc::WatchTokenResponse.new(transfered: event)
+        when Bitcoin::Grpc::EventTokenBurned
+          Bitcoin::Grpc::WatchTokenResponse.new(burned: event)
+        end
+      end
+    end
+
+    class Receiver < Concurrent::Actor::Context
+      include Concurrent::Concern::Logging
+
+      attr_reader :channel
+      def initialize(channel, publisher, classes)
+        @channel = channel
+        classes.each {|c| publisher << [:subscribe, c] }
+      end
+      def on_message(message)
+        log(::Logger::DEBUG, "Receiver#on_message:#{message}")
+        channel << message
+      end
+    end
+
+    class ResponseEnum
+      attr_reader :req, :channel, :wrapper_classs, :logger
+
+      def initialize(req, channel, wrapper_classs)
+        @req = req
+        @channel = channel
+        @wrapper_classs = wrapper_classs
+        @logger = Bitcoin::Logger.create(:debug)
+      end
+
+      def each
+        logger.info("ResponseEnum#each")
+        return enum_for(:each) unless block_given?
+        loop do
+          yield wrapper_classs.build(channel.take)
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/grpc/version.rb

@@ -0,0 +1,5 @@
+module Bitcoin
+  module Grpc
+    VERSION = "0.1.0"
+  end
+end

data/lib/bitcoin/wallet/asset_feature.rb

@@ -0,0 +1,132 @@
+module Bitcoin
+  module Wallet
+    module AssetFeature
+      module AssetType
+        OPEN_ASSETS = 1
+      end
+
+      KEY_PREFIX = {
+        asset_out_point: 'ao', # key: out_point, value AssetOutput
+        asset_script_pubkey: 'as',     # key: asset_type, script_pubkey and out_point, value AssetOutput
+        asset_height: 'ah',    # key: asset_type, block_height and out_point, value AssetOutput
+      }
+
+      def save_token(asset_type, asset_id, asset_quantity, utxo)
+        logger.info("UtxoDB#save_token:#{[asset_type, asset_id, asset_quantity, utxo.inspect]}")
+        level_db.batch do
+          asset_output = Bitcoin::Grpc::AssetOutput.new(
+            asset_type: [asset_type].pack('C'),
+            asset_id: asset_id,
+            asset_quantity: asset_quantity,
+            tx_hash: utxo.tx_hash,
+            index: utxo.index,
+            block_height: utxo.block_height
+          )
+          out_point = Bitcoin::OutPoint.new(utxo.tx_hash, utxo.index)
+          payload = asset_output.to_proto.bth
+
+          # out_point
+          key = KEY_PREFIX[:asset_out_point] + out_point.to_payload.bth
+          return if level_db.contains?(key)
+          level_db.put(key, payload)
+
+          # script_pubkey
+          if utxo.script_pubkey
+            key = KEY_PREFIX[:asset_script_pubkey] + [asset_type].pack('C').bth + utxo.script_pubkey + out_point.to_payload.bth
+            level_db.put(key, payload)
+          end
+
+          # block_height
+          key = KEY_PREFIX[:asset_height] + [asset_type].pack('C').bth + [utxo.block_height].pack('N').bth + out_point.to_payload.bth
+          level_db.put(key, payload)
+          return asset_output
+        end
+      end
+
+      def delete_token(utxo)
+        logger.info("UtxoDB#delete_token:#{utxo.inspect}")
+        level_db.batch do
+          out_point = Bitcoin::OutPoint.new(utxo.tx_hash, utxo.index)
+
+          key = KEY_PREFIX[:asset_out_point] + out_point.to_payload.bth
+          return unless level_db.contains?(key)
+          asset_output = Bitcoin::Grpc::AssetOutput.decode(level_db.get(key).htb)
+          level_db.delete(key)
+
+          if utxo.script_pubkey
+            key = KEY_PREFIX[:asset_script_pubkey] + asset_output.asset_type.bth + utxo.script_pubkey + out_point.to_payload.bth
+            level_db.delete(key)
+          end
+
+          key = KEY_PREFIX[:asset_height] + asset_output.asset_type.bth + [utxo.block_height].pack('N').bth + out_point.to_payload.bth
+          level_db.delete(key)
+          return asset_output
+        end
+      end
+
+      def list_unspent_assets(asset_type, asset_id, current_block_height: 9999999, min: 0, max: 9999999, addresses: nil)
+        raise NotImplementedError.new("asset_type should not be nil.") unless asset_type
+        raise ArgumentError.new('asset_id should not be nil') unless asset_id
+
+        if addresses
+          list_unspent_assets_by_addresses(asset_type, asset_id, current_block_height, min: min, max: max, addresses: addresses)
+        else
+          list_unspent_assets_by_block_height(asset_type, asset_id, current_block_height, min: min, max: max)
+        end
+      end
+
+      def list_unspent_assets_in_account(asset_type, asset_id, account, current_block_height: 9999999, min: 0 , max: 9999999)
+        return [] unless account
+        script_pubkeys = account.watch_targets.map { |t| Bitcoin::Script.to_p2wpkh(t).to_payload.bth }
+        list_unspent_assets_by_script_pubkeys(asset_type, asset_id, current_block_height, min: min, max: max, script_pubkeys: script_pubkeys)
+      end
+
+      def get_asset_balance(asset_type, asset_id, account, current_block_height: 9999999, min: 0, max: 9999999, addresses: nil)
+        raise NotImplementedError.new("asset_type should not be nil.") unless asset_type
+        raise ArgumentError.new('asset_id should not be nil') unless asset_id
+
+        list_unspent_assets_in_account(asset_type, asset_id, account, current_block_height: current_block_height, min: min, max: max).sum { |u| u.asset_quantity }
+      end
+
+      def list_uncolored_unspent_in_account(account, current_block_height: 9999999, min: 0, max: 9999999)
+        utxos = list_unspent_in_account(account, current_block_height: current_block_height, min: min, max: max)
+        utxos.delete_if do |utxo|
+          out_point = Bitcoin::OutPoint.new(utxo.tx_hash, utxo.index)
+          level_db.contains?(KEY_PREFIX[:asset_out_point] + out_point.to_payload.bth)
+        end
+      end
+
+      private
+
+      def assets_between(from, to, asset_id)
+        level_db.each(from: from, to: to)
+          .map { |k, v| Bitcoin::Grpc::AssetOutput.decode(v.htb) }
+          .select {|asset| asset.asset_id == asset_id }
+      end
+
+      def list_unspent_assets_by_block_height(asset_type, asset_id, current_block_height, min: 0, max: 9999999)
+        max_height = [current_block_height - min, 0].max
+        min_height = [current_block_height - max, 0].max
+
+        from = KEY_PREFIX[:asset_height] + [asset_type, min_height].pack('CN').bth + '000000000000000000000000000000000000000000000000000000000000000000000000'
+        to = KEY_PREFIX[:asset_height] + [asset_type, max_height].pack('CN').bth + 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+        assets_between(from, to, asset_id)
+      end
+
+      def list_unspent_assets_by_addresses(asset_type, asset_id, current_block_height, min: 0, max: 9999999, addresses: [])
+        script_pubkeys = addresses.map { |a| Bitcoin::Script.parse_from_addr(a).to_payload.bth }
+        list_unspent_assets_by_script_pubkeys(asset_type, asset_id, current_block_height, min: min, max: max, script_pubkeys: script_pubkeys)
+      end
+
+      def list_unspent_assets_by_script_pubkeys(asset_type, asset_id, current_block_height, min: 0, max: 9999999, script_pubkeys: [])
+        max_height = current_block_height - min
+        min_height = current_block_height - max
+        script_pubkeys.map do |key|
+          from = KEY_PREFIX[:asset_script_pubkey] + [asset_type].pack('C').bth + key + '000000000000000000000000000000000000000000000000000000000000000000000000'
+          to = KEY_PREFIX[:asset_script_pubkey] + [asset_type].pack('C').bth + key + 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+          assets_between(from, to, asset_id).with_height(min_height, max_height)
+        end.flatten
+      end
+    end
+  end
+end

data/lib/bitcoin/wallet/asset_handler.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Bitcoin
+  module Wallet
+    class AssetHandler < Concurrent::Actor::RestartingContext
+      attr_reader :utxo_db, :publisher
+
+      def initialize(spv, publisher)
+        publisher << [:subscribe, Bitcoin::Grpc::EventUtxoSpent]
+        publisher << [:subscribe, Bitcoin::Grpc::WatchAssetIdAssignedRequest]
+        @publisher = publisher
+        @utxo_db = spv.wallet.utxo_db
+        @logger = Bitcoin::Logger.create(:debug)
+      end
+
+      def on_message(message)
+        case message
+        when Bitcoin::Grpc::EventUtxoSpent
+          tx = Bitcoin::Tx.parse_from_payload(message.tx_payload.htb)
+          log(::Logger::DEBUG, "tx=#{tx}, open_assets?=#{tx.open_assets?}")
+          utxo_db.delete_token(message.utxo) if tx.open_assets?
+        when Bitcoin::Grpc::WatchAssetIdAssignedRequest
+          tx = Bitcoin::Tx.parse_from_payload(message.tx_payload.htb)
+          log(::Logger::DEBUG, "tx=#{tx}, open_assets?=#{tx.open_assets?}")
+          case
+          when tx.open_assets?
+            outputs = Bitcoin::Grpc::OapService.outputs_with_open_asset_id(message.tx_hash)
+            if outputs
+              outputs.each do |output|
+                asset_id = output['asset_id']
+                asset_quantity = output['asset_quantity']
+                oa_output_type = output['oa_output_type']
+                next unless asset_id
+                out_point = Bitcoin::OutPoint.new(tx.tx_hash, output['n'])
+                utxo = utxo_db.get_utxo(out_point)
+                next unless utxo
+                asset_output = utxo_db.save_token(AssetFeature::AssetType::OPEN_ASSETS, asset_id, asset_quantity, utxo)
+                next unless asset_output
+                if oa_output_type == 'issuance'
+                  publisher << Bitcoin::Grpc::EventTokenIssued.new(asset: asset_output)
+                else
+                  publisher << Bitcoin::Grpc::EventTokenTransfered.new(asset: asset_output)
+                end
+              end
+            else
+              task = Concurrent::TimerTask.new(execution_interval: 60) do
+                self << message
+                task.shutdown
+              end
+              task.execute
+            end
+          else
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/wallet/publisher.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Bitcoin
+  module Wallet
+    class Publisher < Concurrent::Actor::RestartingContext
+      attr_reader :receivers
+
+      def initialize
+        @receivers = {}
+      end
+
+      def on_message(message)
+        case message
+        when :unsubscribe
+          receivers.each { |receiver| receiver.delete(envelope.sender) }
+        when Array
+          if message[0] == :subscribe
+            if envelope.sender.is_a? Concurrent::Actor::Reference
+              receivers[message[1].name] ||= []
+              receivers[message[1].name] << envelope.sender
+            end
+          elsif message[0] == :subscribe?
+            receivers[message[1].name]&.include?(envelope.sender)
+          else
+          end
+        else
+          receivers[message&.class&.name]&.each { |r| r << message }
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/wallet/signer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Bitcoin
+  module Wallet
+    module Signer
+      def self.sign(node, account_name, tx)
+        account = find_account(node, account_name)
+        return unless account
+
+        tx.inputs.each.with_index do |input, index|
+          spec = input_spec(node, account, tx, index)
+          next unless spec
+          sign_tx_for_p2wpkh(tx, index, spec[0], spec[1])
+        end
+        tx
+      end
+
+      private
+
+      def self.input_spec(node, account, tx, index)
+        input = tx.inputs[index]
+        return unless input
+        utxo = node.wallet.utxo_db.get_utxo(input.out_point)
+        return unless utxo
+        script_pubkey = utxo.script_pubkey
+        keys = account.watch_targets
+        key = nil
+        (0..account.receive_depth + 1).reverse_each do |key_index|
+          path = [account.path, 0, key_index].join('/')
+          temp_key = node.wallet.master_key.derive(path).key
+          if to_p2wpkh(temp_key).to_payload.bth == script_pubkey
+            key = temp_key
+            break
+          end
+        end
+        unless key
+          (0..account.change_depth + 1).reverse_each do |key_index|
+            path = [account.path, 1, key_index].join('/')
+            temp_key = node.wallet.master_key.derive(path).key
+            if to_p2wpkh(temp_key).to_payload.bth == script_pubkey
+              key = temp_key
+              break
+            end
+          end
+        end
+        return unless key
+        [key, utxo.value]
+      end
+
+      def self.find_account(node, account_name)
+        node.wallet.accounts.find{|a| a.name == account_name}
+      end
+
+      def self.sign_tx_for_p2wpkh(tx, index, key, amount)
+        sig = to_sighash(tx, index, key, amount)
+        tx.inputs[index].script_witness = Bitcoin::ScriptWitness.new.tap do |witness|
+          witness.stack << sig << key.pubkey.htb
+        end
+      end
+
+      def self.to_sighash(tx, index, key, amount)
+        sighash = tx.sighash_for_input(index, to_p2wpkh(key), amount: amount, sig_version: :witness_v0)
+        key.sign(sighash) + [Bitcoin::SIGHASH_TYPE[:all]].pack('C')
+      end
+
+      def self.to_p2wpkh(key)
+        Bitcoin::Script.to_p2wpkh(Bitcoin.hash160(key.pubkey))
+      end
+    end
+  end
+end