bitcoinrb-grpc 0.1.0

data/lib/bitcoin/wallet/utxo_db.rb

@@ -0,0 +1,163 @@
+module Bitcoin
+  module Wallet
+    class UtxoDB
+      include Bitcoin::Wallet::AssetFeature
+
+      KEY_PREFIX = {
+        out_point: 'o',        # key: out_point(tx_hash and index), value: Utxo
+        script: 's',           # key: script_pubkey and out_point(tx_hash and index), value: Utxo
+        height: 'h',           # key: block_height and out_point, value: Utxo
+        tx_hash: 't',          # key: tx_hash of transaction, value: [block_height, tx_index]
+        block: 'b',            # key: block_height and tx_index, value: tx_hash
+        tx_payload: 'p',            # key: tx_hash, value: Tx
+      }
+
+      attr_reader :level_db, :logger
+
+      def initialize(path = "#{Bitcoin.base_dir}/db/utxo")
+        FileUtils.mkdir_p(path)
+        @level_db = ::LevelDB::DB.new(path)
+        @logger = Bitcoin::Logger.create(:debug)
+      end
+
+      def close
+        level_db.close
+      end
+
+      def save_tx(tx_hash, tx_payload)
+        level_db.batch do
+          # tx_hash -> [block_height, tx_index]
+          key = KEY_PREFIX[:tx_payload] + tx_hash
+          level_db.put(key, tx_payload)
+        end
+      end
+
+      def save_tx_position(tx_hash, block_height, tx_index)
+        logger.info("UtxoDB#save_tx:#{[tx_hash, block_height, tx_index]}")
+        level_db.batch do
+          # tx_hash -> [block_height, tx_index]
+          key = KEY_PREFIX[:tx_hash] + tx_hash
+          level_db.put(key, [block_height, tx_index].pack('N2').bth)
+
+          # block_hash and tx_index -> tx_hash
+          key = KEY_PREFIX[:block] + [block_height, tx_index].pack('N2').bth
+          level_db.put(key, tx_hash)
+        end
+      end
+
+      # @return [block_height, tx_index, tx_payload]
+      def get_tx(tx_hash)
+        key = KEY_PREFIX[:tx_hash] + tx_hash
+        return [] unless level_db.contains?(key)
+        block_height, tx_index = level_db.get(key).htb.unpack('N2')
+        key = KEY_PREFIX[:tx_payload] + tx_hash
+        tx_payload = level_db.get(key)
+        [block_height, tx_index, tx_payload]
+      end
+
+      def save_utxo(out_point, value, script_pubkey, block_height)
+        logger.info("UtxoDB#save_utxo:#{[out_point, value, script_pubkey, block_height]}")
+        level_db.batch do
+          utxo = Bitcoin::Grpc::Utxo.new(tx_hash: out_point.txid.rhex, index: out_point.index, block_height: block_height, value: value, script_pubkey: script_pubkey)
+          payload = utxo.to_proto.bth
+
+          # out_point
+          key = KEY_PREFIX[:out_point] + out_point.to_payload.bth
+          return if level_db.contains?(key)
+          level_db.put(key, payload)
+
+          # script_pubkey
+          if script_pubkey
+            key = KEY_PREFIX[:script] + script_pubkey + out_point.to_payload.bth
+            level_db.put(key, payload)
+          end
+
+          # block_height
+          key = KEY_PREFIX[:height] + [block_height].pack('N').bth + out_point.to_payload.bth
+          level_db.put(key, payload)
+          return utxo
+        end
+      end
+
+      def delete_utxo(out_point)
+        level_db.batch do
+          key = KEY_PREFIX[:out_point] + out_point.to_payload.bth
+          return unless level_db.contains?(key)
+          utxo = Bitcoin::Grpc::Utxo.decode(level_db.get(key).htb)
+          level_db.delete(key)
+
+          if utxo.script_pubkey
+            key = KEY_PREFIX[:script] + utxo.script_pubkey + out_point.to_payload.bth
+            level_db.delete(key)
+          end
+
+          key = KEY_PREFIX[:height] + [utxo.block_height].pack('N').bth + out_point.to_payload.bth
+          level_db.delete(key)
+          return utxo
+        end
+      end
+
+      def get_utxo(out_point)
+        level_db.batch do
+          key = KEY_PREFIX[:out_point] + out_point.to_payload.bth
+          return unless level_db.contains?(key)
+          return Bitcoin::Grpc::Utxo.decode(level_db.get(key).htb)
+        end
+      end
+
+      def list_unspent(current_block_height: 9999999, min: 0, max: 9999999, addresses: nil)
+        if addresses
+          list_unspent_by_addresses(current_block_height, min: min, max: max, addresses: addresses)
+        else
+          list_unspent_by_block_height(current_block_height, min: min, max: max)
+        end
+      end
+
+      def list_unspent_in_account(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_by_script_pubkeys(current_block_height, min: min, max: max, script_pubkeys: script_pubkeys)
+      end
+
+      def get_balance(account, current_block_height: 9999999, min: 0, max: 9999999)
+        list_unspent_in_account(account, current_block_height: current_block_height, min: min, max: max).sum { |u| u.value }
+      end
+
+      private
+
+      def utxos_between(from, to)
+        level_db.each(from: from, to: to).map { |k, v| Bitcoin::Grpc::Utxo.decode(v.htb) }
+      end
+
+      class ::Array
+        def with_height(min, max)
+          select { |u| u.block_height >= min && u.block_height <= max }
+        end
+      end
+
+      def list_unspent_by_block_height(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[:height] + [min_height].pack('N').bth + '000000000000000000000000000000000000000000000000000000000000000000000000'
+        to = KEY_PREFIX[:height] + [max_height].pack('N').bth + 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+        utxos_between(from, to)
+      end
+
+      def list_unspent_by_addresses(current_block_height, min: 0, max: 9999999, addresses: [])
+        script_pubkeys = addresses.map { |a| Bitcoin::Script.parse_from_addr(a).to_payload.bth }
+        list_unspent_by_script_pubkeys(current_block_height, min: min, max: max, script_pubkeys: script_pubkeys)
+      end
+
+      def list_unspent_by_script_pubkeys(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[:script] + key + '000000000000000000000000000000000000000000000000000000000000000000000000'
+          to = KEY_PREFIX[:script] + key + 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+          utxos_between(from, to).with_height(min_height, max_height)
+        end.flatten
+      end
+    end
+  end
+end

data/lib/bitcoin/wallet/utxo_handler.rb

@@ -0,0 +1,90 @@
+module Bitcoin
+  module Wallet
+    class UtxoHandler < Concurrent::Actor::Context
+      attr_reader :watchings, :spv, :utxo_db, :publisher
+
+      def initialize(spv, publisher)
+        @watchings = []
+        @spv = spv
+        @spv.add_observer(self)
+
+        @utxo_db = spv.wallet.utxo_db
+        @publisher = publisher
+      end
+
+      def update(event, data)
+        send(event, data)
+      end
+
+      def on_message(message)
+        case message
+        when Bitcoin::Grpc::WatchTxConfirmedRequest
+          spv.filter_add(message.tx_hash)
+          watchings << message
+        when :watchings
+          watchings
+        end
+      end
+
+      private
+
+      def tx(data)
+        tx = data.tx
+        block_height = spv.chain.latest_block.height
+        watch_targets = spv.wallet.watch_targets
+
+        tx.outputs.each_with_index do |output, index|
+          next unless watch_targets.find { |target| output.script_pubkey == Bitcoin::Script.to_p2wpkh(target) }
+          out_point = Bitcoin::OutPoint.new(tx.tx_hash, index)
+          utxo = utxo_db.save_utxo(out_point, output.value, output.script_pubkey.to_payload.bth, block_height)
+          publisher << Bitcoin::Grpc::EventUtxoRegistered.new(tx_hash: tx.tx_hash, tx_payload: tx.to_payload.bth, utxo: utxo) if utxo
+        end
+
+        tx.inputs.each do |input|
+          utxo = utxo_db.delete_utxo(input.out_point)
+          publisher << Bitcoin::Grpc::EventUtxoSpent.new(tx_hash: tx.tx_hash, tx_payload: tx.to_payload.bth, utxo: utxo) if utxo
+        end
+
+        utxo_db.save_tx(tx.tx_hash, tx.to_payload.bth)
+
+        publisher << Bitcoin::Grpc::WatchAssetIdAssignedRequest.new(tx_hash: tx.tx_hash, tx_payload: tx.to_payload.bth) if tx.colored?
+      end
+
+      def merkleblock(data)
+        block_height = spv.chain.latest_block.height
+        tree = Bitcoin::MerkleTree.build_partial(data.tx_count, data.hashes, Bitcoin.byte_to_bit(data.flags.htb))
+        tx_blockhash = data.header.block_hash
+
+        log(::Logger::DEBUG, "UtxoHandler#merkleblock:#{data.hashes}")
+
+        watchings
+          .select { |item| item.is_a? Bitcoin::Grpc::WatchTxConfirmedRequest }
+          .select { |item| data.hashes.include?(item.tx_hash) }
+          .each do |item|
+            tx_index = tree.find_node(item.tx_hash).index
+            log(::Logger::DEBUG, "UtxoHandler#merkleblock:#{[tx_index]}")
+            next unless tx_index
+            utxo_db.save_tx_position(item.tx_hash, block_height, tx_index)
+          end
+      end
+
+      def header(data)
+        log(::Logger::DEBUG, "UtxoHandler#header:#{[data, watchings]}")
+        block_height = data[:height]
+        watchings.select do |item|
+          case item
+          when Bitcoin::Grpc::WatchTxConfirmedRequest
+            height, tx_index, tx_payload = utxo_db.get_tx(item.tx_hash)
+            log(::Logger::DEBUG, "UtxoHandler#header:#{[height, tx_index]}")
+            next unless (height || tx_index)
+            if block_height >= height + item.confirmations
+              publisher << Bitcoin::Grpc::EventTxConfirmed.new(tx_hash: item.tx_hash, tx_payload: tx_payload, block_height: height, tx_index: tx_index, confirmations: item.confirmations)
+              watchings.delete(item)
+            end
+          else
+          end
+        end
+      end
+    end
+  end
+end

data/lib/extensions/bitcoin/rpc/request_handler.rb

@@ -0,0 +1,99 @@
+module Bitcoin
+  module RPC
+    module RequestHandler
+      def listunspent(min = 0, max = 999999, addresses: nil)
+        height = node.chain.latest_block.height
+        utxos = node.wallet.list_unspent(current_block_height: height, min: min, max: max, addresses: addresses)
+        utxos.map do |u|
+          {
+            tx_hash: u.tx_hash,
+            index: u.index,
+            value: u.value,
+            script_pubkey: u.script_pubkey,
+            confirmations: height - u.block_height
+          }
+        end
+      end
+
+      def listunspentinaccount(account_name, min = 0, max = 999999)
+        height = node.chain.latest_block.height
+        utxos = node.wallet.list_unspent(account_name: account_name, current_block_height: height, min: min, max: max)
+        utxos.map do |u|
+          {
+            tx_hash: u.tx_hash,
+            index: u.index,
+            value: u.value,
+            script_pubkey: u.script_pubkey,
+            confirmations: height - u.block_height
+          }
+        end
+      end
+
+      def listuncoloredunspentinaccount(account_name, min = 0, max = 999999)
+        height = node.chain.latest_block.height
+        utxos = node.wallet.list_uncolored_unspent(account_name: account_name, current_block_height: height, min: min, max: max)
+        utxos.map do |u|
+          {
+            tx_hash: u.tx_hash,
+            index: u.index,
+            value: u.value,
+            script_pubkey: u.script_pubkey,
+            confirmations: height - u.block_height
+          }
+        end
+      end
+
+      def listcoloredunspentinaccount(account_name, asset_type = Bitcoin::Wallet::AssetFeature::AssetType::OPEN_ASSETS , asset_id = nil, min = 0, max = 999999)
+        height = node.chain.latest_block.height
+        assets = node.wallet.list_unspent_assets_in_account(asset_type, asset_id, account_name: account_name, current_block_height: height, min: min, max: max).map do |asset|
+          out_point = Bitcoin::OutPoint.new(asset.tx_hash, asset.index)
+          utxo = node.wallet.utxo_db.get_utxo(out_point)
+          next unless utxo
+          [asset, utxo]
+        end.compact
+        assets = assets.map do |(asset, utxo)|
+          {
+            tx_hash: utxo.tx_hash,
+            index: utxo.index,
+            value: utxo.value,
+            asset_type: asset.asset_type,
+            asset_id: asset.asset_id,
+            asset_quantity: asset.asset_quantity,
+            script_pubkey: utxo.script_pubkey,
+            confirmations: height - utxo.block_height
+          }
+        end
+      end
+
+      def getbalance(account_name)
+        node.wallet.get_balance(account_name)
+      end
+
+      def getassetbalance(account_name, asset_type = Bitcoin::Wallet::AssetFeature::AssetType::OPEN_ASSETS , asset_id = nil)
+        node.wallet.get_asset_balance(asset_type, asset_id, account_name: account_name)
+      end
+
+      # create new bitcoin address for receiving payments.
+      def getnewaddress(account_name)
+        address = node.wallet.generate_new_address(account_name)
+        script = Bitcoin::Script.parse_from_addr(address)
+        pubkey_hash = script.witness_data[1].bth
+        node.filter_add(pubkey_hash)
+        address
+      end
+
+      def createaccount(account_name)
+        account = node.wallet.create_account(Bitcoin::Wallet::Account::PURPOSE_TYPE[:native_segwit], account_name)
+        account.to_h
+      rescue
+        {}
+      end
+
+      def signrawtransaction(account_name, payload)
+        tx = Bitcoin::Tx.parse_from_payload(payload.htb)
+        signed_tx = Bitcoin::Wallet::Signer.sign(node, account_name, tx)
+        { hex: signed_tx.to_payload.bth }
+      end
+    end
+  end
+end

data/lib/extensions/bitcoin/tx.rb

@@ -0,0 +1,11 @@
+module Bitcoin
+  class Tx
+    def colored?
+      open_assets?
+    end
+
+    def open_assets?
+      !outputs.find(&:open_assets_marker?).nil?
+    end
+  end
+end

data/lib/extensions/bitcoin/wallet/base.rb

@@ -0,0 +1,50 @@
+module Bitcoin
+  module Wallet
+    class Base
+      attr_reader :utxo_db
+
+      def get_balance(account_name)
+        account = find_account(account_name)
+        return 0 unless account
+        utxo_db.get_balance(account)
+      end
+
+      def list_unspent(account_name: nil, current_block_height: 9999999, min: 0, max: 9999999, addresses: nil)
+        if account_name
+          account = find_account(account_name)
+          return [] unless account
+          utxo_db.list_unspent_in_account(account, current_block_height: current_block_height, min: min, max: max)
+        else
+          utxo_db.list_unspent(current_block_height: current_block_height, min: min, max: max, addresses: addresses)
+        end
+      end
+
+      def list_uncolored_unspent(account_name: nil, current_block_height: 9999999, min: 0, max: 9999999)
+        account = find_account(account_name)
+        return [] unless account
+        utxo_db.list_uncolored_unspent_in_account(account, current_block_height: current_block_height, min: min, max: max)
+      end
+
+      def get_asset_balance(asset_type, asset_id, account_name: nil, current_block_height: 9999999, min: 0, max: 9999999)
+        account = find_account(account_name)
+        return 0 unless account
+        utxo_db.get_asset_balance(asset_type, asset_id, account, current_block_height: current_block_height, min: min, max: max)
+      end
+
+      def list_unspent_assets_in_account(asset_type, asset_id, account_name: nil, current_block_height: 9999999, min: 0, max: 9999999)
+        account = find_account(account_name)
+        return [] unless account
+        utxo_db.list_unspent_assets_in_account(asset_type, asset_id, account, current_block_height: current_block_height, min: min, max: max)
+      end
+
+      private
+
+      def initialize(wallet_id, path_prefix)
+        @path = "#{path_prefix}wallet#{wallet_id}/"
+        @db = Bitcoin::Wallet::DB.new(@path)
+        @wallet_id = wallet_id
+        @utxo_db = Bitcoin::Wallet::UtxoDB.new("#{path_prefix}utxo#{wallet_id}/")
+      end
+    end
+  end
+end

data/proto/bitcoin/grpc/grpc.proto

@@ -0,0 +1,97 @@
+syntax = "proto3";
+
+package bitcoin.grpc;
+
+
+service Blockchain {
+  rpc WatchTxConfirmed(WatchTxConfirmedRequest) returns (stream WatchTxConfirmedResponse);
+  rpc WatchUtxo(WatchUtxoRequest) returns (stream WatchUtxoResponse);
+  rpc WatchToken(WatchTokenRequest) returns (stream WatchTokenResponse);
+}
+
+message WatchTxConfirmedRequest {
+  string tx_hash = 1;
+  uint32 confirmations = 2;
+}
+
+message WatchTxConfirmedResponse {
+  oneof event {
+    EventTxConfirmed confirmed = 1;
+  }
+}
+
+message WatchUtxoRequest {
+}
+
+message WatchUtxoResponse {
+  oneof event {
+    EventUtxoRegistered registered = 1;
+    EventUtxoSpent spent = 2;
+  }
+}
+
+message WatchTokenRequest {
+  bytes asset_type = 1;
+}
+
+message WatchTokenResponse {
+  oneof event {
+    EventTokenIssued issued = 1;
+    EventTokenTransfered transfered = 2;
+    EventTokenBurned burned = 3;
+  }
+}
+
+message WatchAssetIdAssignedRequest {
+  string tx_hash = 1;
+  string tx_payload = 2;
+}
+
+message EventTxConfirmed {
+  string tx_hash = 1;
+  string tx_payload = 2;
+  uint32 block_height = 3;
+  uint32 tx_index = 4;
+  uint32 confirmations = 5;
+}
+
+message EventUtxoRegistered {
+  string tx_hash = 1;
+  string tx_payload = 2;
+  Utxo utxo = 3;
+}
+
+message EventUtxoSpent {
+  string tx_hash = 1;
+  string tx_payload = 2;
+  Utxo utxo = 3;
+}
+
+message EventTokenIssued {
+  AssetOutput asset = 1;
+}
+
+message EventTokenTransfered {
+  AssetOutput asset = 2;
+}
+
+message EventTokenBurned {
+  AssetOutput asset = 3;
+}
+
+message Utxo {
+  string tx_hash = 1;
+  uint32 index = 2;
+  uint32 block_height = 3;
+  uint64 value = 4;
+  string script_pubkey = 5;
+}
+
+message AssetOutput {
+  bytes asset_type = 1;
+  string asset_id = 2;
+  uint64 asset_quantity = 3;
+  string tx_hash = 4;
+  uint32 index = 5;
+  uint32 block_height = 6;
+}