glueby 0.4.0 → 0.4.4

data/lib/glueby/internal/wallet/active_record/utxo.rb

@@ -1,50 +1,51 @@
-# frozen_string_literal: true
-
-module Glueby
-  module Internal
-    class Wallet
-      module AR
-        class Utxo < ::ActiveRecord::Base
-          belongs_to :key
-
-          validates :txid, uniqueness: { scope: :index, case_sensitive: false }
-
-          enum status: { init: 0, broadcasted: 1, finalized: 2 }
-
-          def color_id
-            script = Tapyrus::Script.parse_from_payload(script_pubkey.htb)
-            script.color_id&.to_hex
-          end
-
-          # Delete utxo spent by specified tx.
-          #
-          # @param [Tapyrus::Tx] the spending tx
-          def self.destroy_for_inputs(tx)
-            tx.inputs.each do |input|
-              Utxo.destroy_by(txid: input.out_point.txid, index: input.out_point.index)
-            end
-          end
-
-          # Create utxo or update utxo for tx outputs
-          # if there is no key for script pubkey in an output, utxo for the output is not created.
-          #
-          # @param [Tapyrus::Tx] tx
-          def self.create_or_update_for_outputs(tx, status: :finalized)
-            tx.outputs.each.with_index do |output, index|
-              key = Key.key_for_output(output)
-              next unless key
-
-              utxo = Utxo.find_or_initialize_by(txid: tx.txid, index: index)
-              utxo.update!(
-                script_pubkey: output.script_pubkey.to_hex,
-                value: output.value,
-                status: status,
-                key: key
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Glueby
+  module Internal
+    class Wallet
+      module AR
+        class Utxo < ::ActiveRecord::Base
+          belongs_to :key
+
+          validates :txid, uniqueness: { scope: :index, case_sensitive: false }
+
+          enum status: { init: 0, broadcasted: 1, finalized: 2 }
+
+          def color_id
+            script = Tapyrus::Script.parse_from_payload(script_pubkey.htb)
+            script.color_id&.to_hex
+          end
+
+          # Delete utxo spent by specified tx.
+          #
+          # @param [Tapyrus::Tx] the spending tx
+          def self.destroy_for_inputs(tx)
+            tx.inputs.each do |input|
+              Utxo.destroy_by(txid: input.out_point.txid, index: input.out_point.index)
+            end
+          end
+
+          # Create utxo or update utxo for tx outputs
+          # if there is no key for script pubkey in an output, utxo for the output is not created.
+          #
+          # @param [Tapyrus::Tx] tx
+          def self.create_or_update_for_outputs(tx, status: :finalized)
+            tx.outputs.each.with_index do |output, index|
+              key = Key.key_for_output(output)
+              next unless key
+
+              utxo = Utxo.find_or_initialize_by(txid: tx.txid, index: index)
+              utxo.update!(
+                label: key.label,
+                script_pubkey: output.script_pubkey.to_hex,
+                value: output.value,
+                status: status,
+                key: key
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glueby/internal/wallet/active_record_wallet_adapter/syncer.rb

@@ -0,0 +1,14 @@
+module Glueby
+  module Internal
+    class Wallet
+      class ActiveRecordWalletAdapter
+        class Syncer
+          def tx_sync(tx)
+            Glueby::Internal::Wallet::AR::Utxo.destroy_for_inputs(tx)
+            Glueby::Internal::Wallet::AR::Utxo.create_or_update_for_outputs(tx)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glueby/internal/wallet/active_record_wallet_adapter.rb

@@ -1,143 +1,151 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-
-module Glueby
-  module Internal
-    class Wallet
-      # ActiveRecordWalletAdapter
-      #
-      # This class represents a wallet adapter that use Active Record to manage wallet and utxos.
-      # To use this wallet adapter, you should do the following steps:
-      #
-      # (1) Generate migrations for wallets, keys, utxos tables.
-      # The generator `glueby:contract:wallet_adapter` is available for migration.
-      # ```
-      # rails g glueby:contract:wallet_adapter
-      # ```
-      # this generator generates 3 files to create tables used by ActiveRecordWalletAdatper.
-      # then, migrate them
-      # ```
-      # $ rails db:migrate
-      # ```
-      #
-      # (2) Add configuration for activerecord
-      # ```
-      # config = {adapter: 'activerecord', schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass'}
-      # Glueby::Wallet.configure(config)
-      # ```
-      #
-      # (3) Generate wallet and receive address
-      # ```
-      # alice_wallet = Glueby::Wallet.create
-      # address = alice_wallet.internal_wallet.receive_address
-      # ```
-      # `Glueby::Internal::Wallet#receive_address` returns Base58 encoded Tapyrus address like '1CY6TSSARn8rAFD9chCghX5B7j4PKR8S1a'.
-      #
-      # (4) Send TPC to created address and import into wallet.
-      # In general, ActiveRecordWalletAdapter handle only utxos generated by glueby.
-      # So, to start to use wallet, some external utxo should be imported  into the wallet first.
-      # This step should be done by external transaction without Glueby::Wallet, such as 'sendtoaddress' or 'generatetoaddress' RPC command of Tapyrus Core
-      # ```
-      # $ tapyrus-cli sendtoaddress 1CY6TSSARn8rAFD9chCghX5B7j4PKR8S1a 1
-      # 1740af9f65ffd8537bdd06ccfa911bf1f4d6833222807d29c99d72b47838917d
-      # ```
-      #
-      # then, import into wallet by rake task `glueby:contract:wallet_adapter:import_tx` or `glueby:contract:wallet_adapter:import_block`
-      # ```
-      # $ rails "glueby:contract:wallet_adapter:import_tx[1740af9f65ffd8537bdd06ccfa911bf1f4d6833222807d29c99d72b47838917d]""
-      # ```
-      #
-      # (5) You are ready to use ActiveRecordWalletAdatper, check `Glueby::Internal::Wallet#list_unspent` or `Glueby::Wallet#balances`
-      # ```
-      # alice_wallet = Glueby::Wallet.create
-      # alice_wallet.balances
-      # ```
-      class ActiveRecordWalletAdapter < AbstractWalletAdapter
-        def create_wallet(wallet_id = nil)
-          wallet_id = SecureRandom.hex(16) unless wallet_id
-          begin
-            AR::Wallet.create!(wallet_id: wallet_id)
-          rescue ActiveRecord::RecordInvalid => _
-            raise Errors::WalletAlreadyCreated, "wallet_id '#{wallet_id}' is already exists"
-          end
-          wallet_id
-        end
-
-        def delete_wallet(wallet_id)
-          AR::Wallet.destroy_by(wallet_id: wallet_id)
-        end
-
-        def load_wallet(wallet_id)
-          raise Errors::WalletNotFound, "Wallet #{wallet_id} does not found" unless AR::Wallet.where(wallet_id: wallet_id).exists?
-        end
-
-        def unload_wallet(wallet_id)
-        end
-
-        def wallets
-          AR::Wallet.all.map(&:wallet_id).sort
-        end
-
-        def balance(wallet_id, only_finalized = true)
-          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          utxos = wallet.utxos
-          utxos = utxos.where(status: :finalized) if only_finalized
-          utxos.sum(&:value)
-        end
-
-        def list_unspent(wallet_id, only_finalized = true)
-          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          utxos = wallet.utxos
-          utxos = utxos.where(status: :finalized) if only_finalized
-          utxos.map do |utxo|
-            {
-              txid: utxo.txid,
-              vout: utxo.index,
-              script_pubkey: utxo.script_pubkey,
-              color_id: utxo.color_id,
-              amount: utxo.value,
-              finalized: utxo.status == 'finalized'
-            }
-          end
-        end
-
-        def sign_tx(wallet_id, tx, prevtxs = [], sighashtype: Tapyrus::SIGHASH_TYPE[:all])
-          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          wallet.sign(tx, prevtxs, sighashtype: sighashtype)
-        end
-
-        def broadcast(wallet_id, tx)
-          ::ActiveRecord::Base.transaction do
-            AR::Utxo.destroy_for_inputs(tx)
-            AR::Utxo.create_or_update_for_outputs(tx, status: :broadcasted)
-            Glueby::Internal::RPC.client.sendrawtransaction(tx.to_hex)
-          end
-        end
-
-        def receive_address(wallet_id)
-          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          key = wallet.keys.create(purpose: :receive)
-          key.address
-        end
-
-        def change_address(wallet_id)
-          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          key = wallet.keys.create(purpose: :change)
-          key.address
-        end
-
-        def create_pubkey(wallet_id)
-          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          key = wallet.keys.create(purpose: :receive)
-          Tapyrus::Key.new(pubkey: key.public_key)
-        end
-
-        def get_addresses(wallet_id)
-          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          wallet.keys.map(&:address)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Glueby
+  module Internal
+    class Wallet
+      # ActiveRecordWalletAdapter
+      #
+      # This class represents a wallet adapter that use Active Record to manage wallet and utxos.
+      # To use this wallet adapter, you should do the following steps:
+      #
+      # (1) Generate migrations for wallets, keys, utxos tables.
+      # The generator `glueby:contract:wallet_adapter` is available for migration.
+      # ```
+      # rails g glueby:contract:wallet_adapter
+      # ```
+      # this generator generates 3 files to create tables used by ActiveRecordWalletAdatper.
+      # then, migrate them
+      # ```
+      # $ rails db:migrate
+      # ```
+      #
+      # (2) Add configuration for activerecord
+      # ```
+      # config = {adapter: 'activerecord', schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass'}
+      # Glueby::Wallet.configure(config)
+      # ```
+      #
+      # (3) Generate wallet and receive address
+      # ```
+      # alice_wallet = Glueby::Wallet.create
+      # address = alice_wallet.internal_wallet.receive_address
+      # ```
+      # `Glueby::Internal::Wallet#receive_address` returns Base58 encoded Tapyrus address like '1CY6TSSARn8rAFD9chCghX5B7j4PKR8S1a'.
+      #
+      # (4) Send TPC to created address and import into wallet.
+      # In general, ActiveRecordWalletAdapter handle only utxos generated by glueby.
+      # So, to start to use wallet, some external utxo should be imported  into the wallet first.
+      # This step should be done by external transaction without Glueby::Wallet, such as 'sendtoaddress' or 'generatetoaddress' RPC command of Tapyrus Core
+      # ```
+      # $ tapyrus-cli sendtoaddress 1CY6TSSARn8rAFD9chCghX5B7j4PKR8S1a 1
+      # 1740af9f65ffd8537bdd06ccfa911bf1f4d6833222807d29c99d72b47838917d
+      # ```
+      #
+      # then, import into wallet by rake task `glueby:contract:wallet_adapter:import_tx` or `glueby:contract:wallet_adapter:import_block`
+      # ```
+      # $ rails "glueby:contract:wallet_adapter:import_tx[1740af9f65ffd8537bdd06ccfa911bf1f4d6833222807d29c99d72b47838917d]""
+      # ```
+      #
+      # (5) You are ready to use ActiveRecordWalletAdatper, check `Glueby::Internal::Wallet#list_unspent` or `Glueby::Wallet#balances`
+      # ```
+      # alice_wallet = Glueby::Wallet.create
+      # alice_wallet.balances
+      # ```
+      class ActiveRecordWalletAdapter < AbstractWalletAdapter
+
+        autoload :Syncer, 'glueby/internal/wallet/active_record_wallet_adapter/syncer'
+
+        def create_wallet(wallet_id = nil)
+          wallet_id = SecureRandom.hex(16) unless wallet_id
+          begin
+            AR::Wallet.create!(wallet_id: wallet_id)
+          rescue ActiveRecord::RecordInvalid => _
+            raise Errors::WalletAlreadyCreated, "wallet_id '#{wallet_id}' is already exists"
+          end
+          wallet_id
+        end
+
+        def delete_wallet(wallet_id)
+          AR::Wallet.destroy_by(wallet_id: wallet_id)
+        end
+
+        def load_wallet(wallet_id)
+          raise Errors::WalletNotFound, "Wallet #{wallet_id} does not found" unless AR::Wallet.where(wallet_id: wallet_id).exists?
+        end
+
+        def unload_wallet(wallet_id)
+        end
+
+        def wallets
+          AR::Wallet.all.map(&:wallet_id).sort
+        end
+
+        def balance(wallet_id, only_finalized = true)
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          utxos = wallet.utxos
+          utxos = utxos.where(status: :finalized) if only_finalized
+          utxos.sum(&:value)
+        end
+
+        def list_unspent(wallet_id, only_finalized = true, label = nil)
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          utxos = wallet.utxos
+          utxos = utxos.where(status: :finalized) if only_finalized
+          utxos = utxos.where(label: label) if label && (label != :unlabeled)
+          utxos = utxos.where(label: nil) if label == :unlabeled
+          utxos.map do |utxo|
+            {
+              txid: utxo.txid,
+              vout: utxo.index,
+              script_pubkey: utxo.script_pubkey,
+              color_id: utxo.color_id,
+              amount: utxo.value,
+              finalized: utxo.status == 'finalized'
+            }
+          end
+        end
+
+        def sign_tx(wallet_id, tx, prevtxs = [], sighashtype: Tapyrus::SIGHASH_TYPE[:all])
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          wallet.sign(tx, prevtxs, sighashtype: sighashtype)
+        end
+
+        def broadcast(wallet_id, tx, &block)
+          ::ActiveRecord::Base.transaction do
+            AR::Utxo.destroy_for_inputs(tx)
+            AR::Utxo.create_or_update_for_outputs(tx, status: :broadcasted)
+            block.call(tx) if block
+            Glueby::Internal::RPC.client.sendrawtransaction(tx.to_hex)
+          end
+        end
+
+        def receive_address(wallet_id, label = nil)
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          key = wallet.keys.create(purpose: :receive, label: label)
+          key.address
+        end
+
+        def change_address(wallet_id)
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          key = wallet.keys.create(purpose: :change)
+          key.address
+        end
+
+        def create_pubkey(wallet_id)
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          key = wallet.keys.create(purpose: :receive)
+          Tapyrus::Key.new(pubkey: key.public_key)
+        end
+
+        def get_addresses(wallet_id, label = nil)
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          keys = wallet.keys
+          keys = keys.where(label: label) if label
+          keys.map(&:address)
+        end
+      end
+    end
+  end
+end

data/lib/glueby/internal/wallet/tapyrus_core_wallet_adapter.rb

@@ -1,183 +1,186 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-require 'bigdecimal'
-
-module Glueby
-  module Internal
-    class Wallet
-      class TapyrusCoreWalletAdapter < AbstractWalletAdapter
-        module Util
-          module_function
-
-          # Convert TPC to tapyrus. 1 TPC is 10**8 tapyrus.
-          # @param [String] tpc
-          # @return [Integer] tapyrus
-          #
-          # Example) "0.00000010" to 10.
-          def tpc_to_tapyrus(tpc)
-            (BigDecimal(tpc) * 10**8).to_i
-          end
-        end
-
-        include Glueby::Internal::Wallet::TapyrusCoreWalletAdapter::Util
-
-        WALLET_PREFIX = 'wallet-'
-        ADDRESS_TYPE = 'legacy'
-
-        RPC_WALLET_ERROR_ERROR_CODE = -4 # Unspecified problem with wallet (key not found etc.)
-        RPC_WALLET_NOT_FOUND_ERROR_CODE = -18 # Invalid wallet specified
-
-        def create_wallet(wallet_id = nil)
-          wallet_id = SecureRandom.hex(16) unless wallet_id
-          begin
-            RPC.client.createwallet(wallet_name(wallet_id))
-          rescue Tapyrus::RPC::Error => ex
-            if ex.rpc_error['code'] == RPC_WALLET_ERROR_ERROR_CODE && /Wallet wallet-wallet already exists\./ =~ ex.rpc_error['message']
-              raise Errors::WalletAlreadyCreated, "Wallet #{wallet_id} has been already created."
-            else
-              raise ex
-            end
-          end
-
-          wallet_id
-        end
-
-        # On TapyrusCoreWallet, there are no way to delete real wallet via RPC.
-        # So, here just unload.
-        def delete_wallet(wallet_id)
-          unload_wallet(wallet_id)
-        end
-
-        def load_wallet(wallet_id)
-          RPC.client.loadwallet(wallet_name(wallet_id))
-        rescue Tapyrus::RPC::Error => ex
-          if ex.rpc_error['code'] == RPC_WALLET_ERROR_ERROR_CODE && /Duplicate -wallet filename specified/ =~ ex.rpc_error['message']
-            raise Errors::WalletAlreadyLoaded, "Wallet #{wallet_id} has been already loaded."
-          elsif ex.rpc_error['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
-            raise Errors::WalletNotFound, "Wallet #{wallet_id} does not found"
-          else
-            raise ex
-          end
-        end
-
-        def unload_wallet(wallet_id)
-          RPC.client.unloadwallet(wallet_name(wallet_id))
-        end
-
-        def wallets
-          RPC.client.listwallets.map do |wallet_name|
-            match = /\A#{WALLET_PREFIX}(?<wallet_id>[0-9A-Fa-f]{32})\z/.match(wallet_name)
-            next unless match
-
-            match[:wallet_id]
-          end.compact
-        end
-
-        def balance(wallet_id, only_finalized = true)
-          perform_as(wallet_id) do |client|
-            confirmed = tpc_to_tapyrus(client.getbalance)
-            return confirmed if only_finalized
-
-            confirmed + tpc_to_tapyrus(client.getunconfirmedbalance)
-          end
-        end
-
-        def list_unspent(wallet_id, only_finalized = true)
-          perform_as(wallet_id) do |client|
-            min_conf = only_finalized ? 1 : 0
-            res = client.listunspent(min_conf)
-
-            res.map do |i|
-              script = Tapyrus::Script.parse_from_payload(i['scriptPubKey'].htb)
-              color_id = if script.cp2pkh? || script.cp2sh?
-                Tapyrus::Color::ColorIdentifier.parse_from_payload(script.chunks[0].pushed_data).to_hex
-              end
-              {
-                txid: i['txid'],
-                vout: i['vout'],
-                script_pubkey: i['scriptPubKey'],
-                color_id: color_id,
-                amount: tpc_to_tapyrus(i['amount']),
-                finalized: i['confirmations'] != 0
-              }
-            end
-          end
-        end
-
-        def sign_tx(wallet_id, tx, prevtxs = [], sighashtype: Tapyrus::SIGHASH_TYPE[:all])
-          perform_as(wallet_id) do |client|
-            res = client.signrawtransactionwithwallet(tx.to_hex, prevtxs, encode_sighashtype(sighashtype))
-            if res['complete']
-              Tapyrus::Tx.parse_from_payload(res['hex'].htb)
-            else
-              raise res['errors'].to_json
-            end
-          end
-        end
-
-        def broadcast(wallet_id, tx)
-          perform_as(wallet_id) do |client|
-            client.sendrawtransaction(tx.to_hex)
-          end
-        end
-
-        def receive_address(wallet_id)
-          perform_as(wallet_id) do |client|
-            client.getnewaddress('', ADDRESS_TYPE)
-          end
-        end
-
-        def change_address(wallet_id)
-          perform_as(wallet_id) do |client|
-            client.getrawchangeaddress(ADDRESS_TYPE)
-          end
-        end
-
-        def create_pubkey(wallet_id)
-          perform_as(wallet_id) do |client|
-            address = client.getnewaddress('', ADDRESS_TYPE)
-            info = client.getaddressinfo(address)
-            Tapyrus::Key.new(pubkey: info['pubkey'])
-          end
-        end
-
-        private
-
-        def perform_as(wallet_id)
-          RPC.perform_as(wallet_name(wallet_id)) do |client|
-            begin
-              yield(client)
-            rescue Tapyrus::RPC::Error => ex
-              if ex.rpc_error['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
-                raise Errors::WalletUnloaded, "The wallet #{wallet_id} is unloaded. You should load before use it."
-              else
-                raise ex
-              end
-            end
-          end
-        end
-
-        def wallet_name(wallet_id)
-          "#{WALLET_PREFIX}#{wallet_id}"
-        end
-
-        def encode_sighashtype(sighashtype)
-          type = case sighashtype & (~(Tapyrus::SIGHASH_TYPE[:anyonecanpay]))
-                 when Tapyrus::SIGHASH_TYPE[:all] then 'ALL'
-                 when Tapyrus::SIGHASH_TYPE[:none] then 'NONE'
-                 when Tapyrus::SIGHASH_TYPE[:single] then 'SIGNLE'
-                 else
-                   raise Errors::InvalidSighashType, "Invalid sighash type '#{sighashtype}'"
-                 end
-
-          if sighashtype & Tapyrus::SIGHASH_TYPE[:anyonecanpay] == 0x80
-            type += '|ANYONECANPAY'
-          end
-
-          type
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'bigdecimal'
+
+module Glueby
+  module Internal
+    class Wallet
+      class TapyrusCoreWalletAdapter < AbstractWalletAdapter
+        module Util
+          module_function
+
+          # Convert TPC to tapyrus. 1 TPC is 10**8 tapyrus.
+          # @param [String] tpc
+          # @return [Integer] tapyrus
+          #
+          # Example) "0.00000010" to 10.
+          def tpc_to_tapyrus(tpc)
+            (BigDecimal(tpc) * 10**8).to_i
+          end
+        end
+
+        include Glueby::Internal::Wallet::TapyrusCoreWalletAdapter::Util
+
+        WALLET_PREFIX = 'wallet-'
+
+        RPC_WALLET_ERROR_ERROR_CODE = -4 # Unspecified problem with wallet (key not found etc.)
+        RPC_WALLET_NOT_FOUND_ERROR_CODE = -18 # Invalid wallet specified
+
+        def create_wallet(wallet_id = nil)
+          wallet_id = SecureRandom.hex(16) unless wallet_id
+          begin
+            RPC.client.createwallet(wallet_name(wallet_id))
+          rescue Tapyrus::RPC::Error => ex
+            if ex.rpc_error && ex.rpc_error['code'] == RPC_WALLET_ERROR_ERROR_CODE && /Wallet wallet-#{wallet_id} already exists\./ =~ ex.rpc_error['message']
+              raise Errors::WalletAlreadyCreated, "Wallet #{wallet_id} has been already created."
+            else
+              raise ex
+            end
+          end
+
+          wallet_id
+        end
+
+        # On TapyrusCoreWallet, there are no way to delete real wallet via RPC.
+        # So, here just unload.
+        def delete_wallet(wallet_id)
+          unload_wallet(wallet_id)
+        end
+
+        def load_wallet(wallet_id)
+          RPC.client.loadwallet(wallet_name(wallet_id))
+        rescue Tapyrus::RPC::Error => ex
+          if ex.rpc_error && ex.rpc_error['code'] == RPC_WALLET_ERROR_ERROR_CODE && /Duplicate -wallet filename specified/ =~ ex.rpc_error['message']
+            raise Errors::WalletAlreadyLoaded, "Wallet #{wallet_id} has been already loaded."
+          elsif ex.rpc_error && ex.rpc_error['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
+            raise Errors::WalletNotFound, "Wallet #{wallet_id} does not found"
+          else
+            raise ex
+          end
+        end
+
+        def unload_wallet(wallet_id)
+          RPC.client.unloadwallet(wallet_name(wallet_id))
+        end
+
+        def wallets
+          RPC.client.listwallets.map do |wallet_name|
+            match = /\A#{WALLET_PREFIX}(?<wallet_id>[0-9A-Fa-f]{32})\z/.match(wallet_name)
+            next unless match
+
+            match[:wallet_id]
+          end.compact
+        end
+
+        def balance(wallet_id, only_finalized = true)
+          perform_as(wallet_id) do |client|
+            confirmed = tpc_to_tapyrus(client.getbalance)
+            return confirmed if only_finalized
+
+            confirmed + tpc_to_tapyrus(client.getunconfirmedbalance)
+          end
+        end
+
+        def list_unspent(wallet_id, only_finalized = true, label = nil)
+          perform_as(wallet_id) do |client|
+            min_conf = only_finalized ? 1 : 0
+            res = client.listunspent(min_conf)
+
+            res = res.filter { |i| i['label'] == label } if label && (label != :unlabeled)
+            res = res.filter { |i| i['label'] == "" } if label == :unlabeled
+ 
+            res.map do |i|
+              script = Tapyrus::Script.parse_from_payload(i['scriptPubKey'].htb)
+              color_id = if script.cp2pkh? || script.cp2sh?
+                Tapyrus::Color::ColorIdentifier.parse_from_payload(script.chunks[0].pushed_data).to_hex
+              end
+              {
+                txid: i['txid'],
+                vout: i['vout'],
+                script_pubkey: i['scriptPubKey'],
+                color_id: color_id,
+                amount: tpc_to_tapyrus(i['amount']),
+                finalized: i['confirmations'] != 0
+              }
+            end
+          end
+        end
+
+        def sign_tx(wallet_id, tx, prevtxs = [], sighashtype: Tapyrus::SIGHASH_TYPE[:all])
+          perform_as(wallet_id) do |client|
+            res = client.signrawtransactionwithwallet(tx.to_hex, prevtxs, encode_sighashtype(sighashtype))
+            if res['complete']
+              Tapyrus::Tx.parse_from_payload(res['hex'].htb)
+            else
+              raise res['errors'].to_json
+            end
+          end
+        end
+
+        def broadcast(wallet_id, tx, &block)
+          perform_as(wallet_id) do |client|
+            block.call(tx) if block
+            client.sendrawtransaction(tx.to_hex)
+          end
+        end
+
+        def receive_address(wallet_id, label = nil)
+          perform_as(wallet_id) do |client|
+            client.getnewaddress(label || '')
+          end
+        end
+
+        def change_address(wallet_id)
+          perform_as(wallet_id) do |client|
+            client.getrawchangeaddress
+          end
+        end
+
+        def create_pubkey(wallet_id)
+          perform_as(wallet_id) do |client|
+            address = client.getnewaddress('')
+            info = client.getaddressinfo(address)
+            Tapyrus::Key.new(pubkey: info['pubkey'])
+          end
+        end
+
+        private
+
+        def perform_as(wallet_id)
+          RPC.perform_as(wallet_name(wallet_id)) do |client|
+            begin
+              yield(client)
+            rescue Tapyrus::RPC::Error => ex
+              if ex.rpc_error && ex.rpc_error['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
+                raise Errors::WalletUnloaded, "The wallet #{wallet_id} is unloaded. You should load before use it."
+              else
+                raise ex
+              end
+            end
+          end
+        end
+
+        def wallet_name(wallet_id)
+          "#{WALLET_PREFIX}#{wallet_id}"
+        end
+
+        def encode_sighashtype(sighashtype)
+          type = case sighashtype & (~(Tapyrus::SIGHASH_TYPE[:anyonecanpay]))
+                 when Tapyrus::SIGHASH_TYPE[:all] then 'ALL'
+                 when Tapyrus::SIGHASH_TYPE[:none] then 'NONE'
+                 when Tapyrus::SIGHASH_TYPE[:single] then 'SIGNLE'
+                 else
+                   raise Errors::InvalidSighashType, "Invalid sighash type '#{sighashtype}'"
+                 end
+
+          if sighashtype & Tapyrus::SIGHASH_TYPE[:anyonecanpay] == 0x80
+            type += '|ANYONECANPAY'
+          end
+
+          type
+        end
+      end
+    end
+  end
+end