glueby 0.4.1 → 0.5.0

data/lib/glueby/contract/tx_builder.rb

@@ -11,18 +11,32 @@ module Glueby
       end
 
       # Create new public key, and new transaction that sends TPC to it
-      def create_funding_tx(wallet:, script: nil, fee_estimator: FixedFeeEstimator.new)
-        tx = Tapyrus::Tx.new
-        fee = fee_estimator.fee(dummy_tx(tx))
-
-        sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee + FUNDING_TX_AMOUNT)
-        fill_input(tx, outputs)
-
-        receiver_script = script ? script : Tapyrus::Script.parse_from_addr(wallet.internal_wallet.receive_address)
-        tx.outputs << Tapyrus::TxOut.new(value: FUNDING_TX_AMOUNT, script_pubkey: receiver_script)
-
-        fill_change_tpc(tx, wallet, sum - fee - FUNDING_TX_AMOUNT)
-        wallet.internal_wallet.sign_tx(tx)
+      def create_funding_tx(wallet:, script: nil, fee_estimator: FixedFeeEstimator.new, utxo_provider: nil)
+        if utxo_provider
+          script_pubkey = script ? script : Tapyrus::Script.parse_from_addr(wallet.internal_wallet.receive_address)
+          funding_tx, _index = utxo_provider.get_utxo(script_pubkey, FUNDING_TX_AMOUNT)
+          utxo_provider.wallet.sign_tx(funding_tx)
+        else
+          txb = Tapyrus::TxBuilder.new
+          fee = fee_estimator.fee(dummy_tx(txb.build))
+
+          sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee + FUNDING_TX_AMOUNT)
+          outputs.each do |utxo|
+            txb.add_utxo({
+              script_pubkey: Tapyrus::Script.parse_from_payload(utxo[:script_pubkey].htb),
+              txid: utxo[:txid],
+              index: utxo[:vout],
+              value: utxo[:amount]
+            })
+          end
+  
+          receiver_address = script ? script.addresses.first : wallet.internal_wallet.receive_address
+          tx = txb.pay(receiver_address, FUNDING_TX_AMOUNT)
+            .change_address(wallet.internal_wallet.change_address)
+            .fee(fee)
+            .build
+          wallet.internal_wallet.sign_tx(tx)
+        end
       end
 
       def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
@@ -48,21 +62,27 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_issue_tx_for_non_reissuable_token(issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NON_REISSUABLE, issuer: issuer, amount: amount, fee_estimator: fee_estimator)
+      def create_issue_tx_for_non_reissuable_token(funding_tx: nil, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
+        create_issue_tx_from_out_point(funding_tx: funding_tx, token_type: Tapyrus::Color::TokenTypes::NON_REISSUABLE, issuer: issuer, amount: amount, fee_estimator: fee_estimator)
       end
 
-      def create_issue_tx_for_nft_token(issuer:, fee_estimator: FixedFeeEstimator.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NFT, issuer: issuer, amount: 1, fee_estimator: fee_estimator)
+      def create_issue_tx_for_nft_token(funding_tx: nil, issuer:, fee_estimator: FixedFeeEstimator.new)
+        create_issue_tx_from_out_point(funding_tx: funding_tx, token_type: Tapyrus::Color::TokenTypes::NFT, issuer: issuer, amount: 1, fee_estimator: fee_estimator)
       end
 
-      def create_issue_tx_from_out_point(token_type:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
+      def create_issue_tx_from_out_point(funding_tx: nil, token_type:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         fee = fee_estimator.fee(dummy_issue_tx_from_out_point)
-        sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee)
-        fill_input(tx, outputs)
-
+        sum = if funding_tx
+          out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
+          tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+          funding_tx.outputs.first.value
+        else
+          sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee)
+          fill_input(tx, outputs)
+          sum
+        end
         out_point = tx.inputs.first.out_point
         color_id = case token_type
         when Tapyrus::Color::TokenTypes::NON_REISSUABLE
@@ -78,7 +98,18 @@ module Glueby
         tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
 
         fill_change_tpc(tx, issuer, sum - fee)
-        issuer.internal_wallet.sign_tx(tx)
+        prev_txs = if funding_tx
+          output = funding_tx.outputs.first
+          [{
+            txid: funding_tx.txid,
+            vout: 0,
+            scriptPubKey: output.script_pubkey.to_hex,
+            amount: output.value
+          }]
+        else
+          []
+        end
+        issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
       def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_estimator: FixedFeeEstimator.new)
@@ -103,7 +134,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_transfer_tx(color_id:, sender:, receiver_address:, amount:, fee_estimator: FixedFeeEstimator.new)
+      def create_transfer_tx(funding_tx:nil, color_id:, sender:, receiver_address:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
@@ -117,14 +148,32 @@ module Glueby
         fill_change_token(tx, sender, sum_token - amount, color_id)
 
         fee = fee_estimator.fee(dummy_tx(tx))
-        sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee)
-        fill_input(tx, outputs)
+        sum_tpc = if funding_tx
+          out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
+          tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+          funding_tx.outputs.first.value
+        else
+          sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee)
+          fill_input(tx, outputs)
+          sum_tpc
+        end
 
         fill_change_tpc(tx, sender, sum_tpc - fee)
-        sender.internal_wallet.sign_tx(tx)
+        prev_txs = if funding_tx
+          output = funding_tx.outputs.first
+          [{
+            txid: funding_tx.txid,
+            vout: 0,
+            scriptPubKey: output.script_pubkey.to_hex,
+            amount: output.value
+          }]
+        else
+          []
+        end
+        sender.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_burn_tx(color_id:, sender:, amount: 0, fee_estimator: FixedFeeEstimator.new)
+      def create_burn_tx(funding_tx:nil, color_id:, sender:, amount: 0, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
@@ -135,12 +184,30 @@ module Glueby
 
         fee = fee_estimator.fee(dummy_tx(tx))
 
-        dust = 600 # in case that the wallet has output which has just fee amount.
-        sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee + dust)
-        fill_input(tx, outputs)
+        sum_tpc = if funding_tx
+          out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
+          tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+          funding_tx.outputs.first.value
+        else
+          dust = 600 # in case that the wallet has output which has just fee amount.
+          sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee + dust)
+          fill_input(tx, outputs)
+          sum_tpc
+        end
 
         fill_change_tpc(tx, sender, sum_tpc - fee)
-        sender.internal_wallet.sign_tx(tx)
+        prev_txs = if funding_tx
+          output = funding_tx.outputs.first
+          [{
+            txid: funding_tx.txid,
+            vout: 0,
+            scriptPubKey: output.script_pubkey.to_hex,
+            amount: output.value
+          }]
+        else
+          []
+        end
+        sender.internal_wallet.sign_tx(tx, prev_txs)
       end
 
       def fill_input(tx, outputs)

data/lib/glueby/fee_provider/tasks.rb

@@ -44,7 +44,7 @@ module Glueby
                 .fee(fee_provider.fixed_fee)
                 .build
         tx = wallet.sign_tx(tx)
-        wallet.broadcast(tx)
+        wallet.broadcast(tx, without_fee_provider: true)
       ensure
         status
       end
@@ -80,6 +80,11 @@ module Glueby
         EOS
       end
 
+      # Show the address of Fee Provider 
+      def print_address
+        puts wallet.receive_address
+      end
+
       private
 
       def check_wallet_amount!

data/lib/glueby/fee_provider.rb

@@ -8,6 +8,7 @@ module Glueby
     WALLET_ID = 'FEE_PROVIDER_WALLET'
     DEFAULT_FIXED_FEE = 1000
     DEFAULT_UTXO_POOL_SIZE = 20
+    MAX_UTXO_POOL_SIZE = 2_000
 
     attr_reader :fixed_fee, :utxo_pool_size, :wallet,
 
@@ -33,6 +34,7 @@ module Glueby
                   Internal::Wallet.create(WALLET_ID)
                 end
 
+      validate_config!
       @fixed_fee = (FeeProvider.config && FeeProvider.config[:fixed_fee]) || DEFAULT_FIXED_FEE
       @utxo_pool_size = (FeeProvider.config && FeeProvider.config[:utxo_pool_size]) || DEFAULT_UTXO_POOL_SIZE
     end
@@ -69,5 +71,14 @@ module Glueby
     def get_signature(script_sig)
       script_sig.chunks.first.pushed_data
     end
+
+    def validate_config!
+      if FeeProvider.config
+        utxo_pool_size = FeeProvider.config[:utxo_pool_size]
+        if utxo_pool_size && (!utxo_pool_size.is_a?(Integer) || utxo_pool_size > MAX_UTXO_POOL_SIZE)
+          raise Glueby::Configuration::Errors::InvalidConfiguration, "utxo_pool_size(#{utxo_pool_size}) should not be greater than #{MAX_UTXO_POOL_SIZE}"
+        end
+      end
+    end
   end
 end

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

@@ -101,8 +101,10 @@ module Glueby
         #
         # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
         # @param [Tapyrus::Tx] tx - The transaction to be broadcasterd.
+        # @yield Option. If a block given, the block is called before actual broadcasting.
+        #   @yieldparam [Tapyrus::Tx] tx - The tx that is going to be broadcasted as is.
         # @return [String] txid
-        def broadcast(wallet_id, tx)
+        def broadcast(wallet_id, tx, &block)
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         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

@@ -54,6 +54,9 @@ module Glueby
       # 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
@@ -90,7 +93,8 @@ module Glueby
           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
+          utxos = utxos.where(label: label) if label && (label != :unlabeled)
+          utxos = utxos.where(label: nil) if label == :unlabeled
           utxos.map do |utxo|
             {
               txid: utxo.txid,
@@ -108,17 +112,18 @@ module Glueby
           wallet.sign(tx, prevtxs, sighashtype: sighashtype)
         end
 
-        def broadcast(wallet_id, tx)
+        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 = wallet.keys.create(purpose: :receive, label: label)
           key.address
         end
 

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

@@ -23,7 +23,6 @@ module Glueby
         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
@@ -33,7 +32,7 @@ module Glueby
           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']
+            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
@@ -52,9 +51,9 @@ module Glueby
         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']
+          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['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
+          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
@@ -88,7 +87,8 @@ module Glueby
             min_conf = only_finalized ? 1 : 0
             res = client.listunspent(min_conf)
 
-            res = res.filter { |i| i['label'] == label } if label
+            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)
@@ -118,27 +118,28 @@ module Glueby
           end
         end
 
-        def broadcast(wallet_id, tx)
+        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 || '', ADDRESS_TYPE)
+            client.getnewaddress(label || '')
           end
         end
 
         def change_address(wallet_id)
           perform_as(wallet_id) do |client|
-            client.getrawchangeaddress(ADDRESS_TYPE)
+            client.getrawchangeaddress
           end
         end
 
         def create_pubkey(wallet_id)
           perform_as(wallet_id) do |client|
-            address = client.getnewaddress('', ADDRESS_TYPE)
+            address = client.getnewaddress('')
             info = client.getaddressinfo(address)
             Tapyrus::Key.new(pubkey: info['pubkey'])
           end
@@ -151,7 +152,7 @@ module Glueby
             begin
               yield(client)
             rescue Tapyrus::RPC::Error => ex
-              if ex.rpc_error['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
+              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

data/lib/glueby/internal/wallet.rb

@@ -34,8 +34,6 @@ module Glueby
       autoload :Errors, 'glueby/internal/wallet/errors'
 
       class << self
-        attr_writer :wallet_adapter
-
         def create(wallet_id = nil)
           begin
             wallet_id = wallet_adapter.create_wallet(wallet_id)
@@ -58,6 +56,16 @@ module Glueby
           wallet_adapter.wallets.map { |id| new(id) }
         end
 
+        def wallet_adapter=(adapter)
+          if adapter.is_a?(ActiveRecordWalletAdapter)
+            BlockSyncer.register_syncer(ActiveRecordWalletAdapter::Syncer)
+          else
+            BlockSyncer.unregister_syncer(ActiveRecordWalletAdapter::Syncer)
+          end
+
+          @wallet_adapter = adapter
+        end
+
         def wallet_adapter
           @wallet_adapter or
             raise Errors::ShouldInitializeWalletAdapter, 'You should initialize wallet adapter using `Glueby::Internal::Wallet.wallet_adapter = some wallet adapter instance`.'
@@ -74,6 +82,10 @@ module Glueby
         wallet_adapter.balance(id, only_finalized)
       end
 
+      # @param only_finalized [Boolean] The flag to get a UTXO with status only finalized
+      # @param label [String] This label is used to filtered the UTXOs with labeled if a key or Utxo is labeled.
+      #                    - If label is not specified (label=nil), all UTXOs will be returned.
+      #                    - If label=:unlabeled, only unlabeled UTXOs will be returned.
       def list_unspent(only_finalized = true, label = nil)
         wallet_adapter.list_unspent(id, only_finalized, label)
       end
@@ -99,9 +111,13 @@ module Glueby
         wallet_adapter.sign_tx(id, tx, prev_txs, sighashtype: sighashtype)
       end
 
-      def broadcast(tx)
-        tx = FeeProvider.provide(tx) if Glueby.configuration.fee_provider_bears?
-        wallet_adapter.broadcast(id, tx)
+      # Broadcast a transaction via Tapyrus Core RPC
+      # @param [Tapyrus::Tx] tx The tx that would be broadcasted
+      # @option [Boolean] without_fee_provider The flag to avoid to use FeeProvider temporary.
+      # @param [Proc] block The block that is called before broadcasting. It can be used to handle tx that is modified by FeeProvider.
+      def broadcast(tx, without_fee_provider: false, &block)
+        tx = FeeProvider.provide(tx) if !without_fee_provider && Glueby.configuration.fee_provider_bears?
+        wallet_adapter.broadcast(id, tx, &block)
         tx
       end
 
@@ -117,8 +133,9 @@ module Glueby
         wallet_adapter.create_pubkey(id)
       end
 
-      def collect_uncolored_outputs(amount, label = nil)
-        utxos = list_unspent(true, label)
+      def collect_uncolored_outputs(amount, label = nil, only_finalized = true, shuffle = false)
+        utxos = list_unspent(only_finalized, label)
+        utxos.shuffle! if shuffle
 
         utxos.inject([0, []]) do |sum, output|
           next sum if output[:color_id]

data/lib/glueby/railtie.rb

@@ -0,0 +1,11 @@
+module Glueby
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load "tasks/glueby/contract.rake"
+      load "tasks/glueby/contract/timestamp.rake"
+      load "tasks/glueby/block_syncer.rake"
+      load "tasks/glueby/fee_provider.rake"
+      load "tasks/glueby/utxo_provider.rake"
+    end
+  end
+end

data/lib/glueby/utxo_provider/tasks.rb

@@ -0,0 +1,135 @@
+module Glueby
+  class UtxoProvider
+    class Tasks
+      include Glueby::Contract::TxBuilder
+
+      attr_reader :utxo_provider
+
+      STATUS = {
+        # UtxoProvider is ready to pay tpcs.
+        ready: 'Ready',
+        # UtxoProvider is ready to pay tpcs, but it doesn't have enough amount to fill the UTXO pool by UTXOs which is for paying tpcs.
+        insufficient_amount: 'Insufficient Amount',
+        # UtxoProvider is not ready to pay tpcs. It has no UTXOs for paying amounts.
+        not_ready: 'Not Ready'
+      }
+
+      def initialize
+        @utxo_provider = Glueby::UtxoProvider.new
+      end
+
+      # Create UTXOs for paying tpc
+      #
+      # UtxoProvider have the UTXO pool. the pool is manged to keep some number of UTXOs that have fixed value. The
+      # value is configurable by :default_value. This method do the management to the pool.
+      def manage_utxo_pool
+        txb = Tapyrus::TxBuilder.new
+
+        sum, utxos = collect_outputs
+        return if utxos.empty?
+
+        utxos.each { |utxo| txb.add_utxo(utxo) }
+        address = wallet.receive_address
+
+        shortage = [utxo_provider.utxo_pool_size - current_utxo_pool_size, 0].max
+        return if shortage == 0
+
+        added_outputs = 0
+        shortage.times do
+          fee = utxo_provider.fee_estimator.fee(dummy_tx(txb.build))
+          break if (sum - fee) < utxo_provider.default_value
+          txb.pay(address, utxo_provider.default_value)
+          sum -= utxo_provider.default_value
+          added_outputs += 1
+        end
+
+        return if added_outputs == 0
+
+        fee = utxo_provider.fee_estimator.fee(dummy_tx(txb.build))
+        tx = txb.change_address(address)
+                .fee(fee)
+                .build
+        tx = wallet.sign_tx(tx)
+        wallet.broadcast(tx)
+      ensure
+        status
+      end
+
+      # Show the status of the UTXO pool
+      def status
+        status = :ready
+
+        if current_utxo_pool_size < utxo_provider.utxo_pool_size
+          if tpc_amount < value_to_fill_utxo_pool
+            status = :insufficient_amount
+            message = <<~MESSAGE
+            1. Please replenishment TPC which is for paying tpc to UtxoProvider. 
+              UtxoProvider needs #{value_to_fill_utxo_pool} tapyrus in UTXO pool. 
+              UtxoProvider wallet's address is '#{wallet.receive_address}'
+            2. Then create UTXOs for paying in UTXO pool with 'rake glueby:utxo_provider:manage_utxo_pool'
+            MESSAGE
+          else
+            message = "Please create UTXOs for paying in UTXO pool with 'rake glueby:utxo_provider:manage_utxo_pool'\n"
+          end
+        end
+
+        status = :not_ready if current_utxo_pool_size == 0
+
+        puts <<~EOS
+        Status: #{STATUS[status]}
+        TPC amount: #{delimit(tpc_amount)}
+        UTXO pool size: #{delimit(current_utxo_pool_size)}
+        #{"\n" if message}#{message}
+        Configuration:
+          default_value = #{delimit(utxo_provider.default_value)}
+          utxo_pool_size = #{delimit(utxo_provider.utxo_pool_size)}
+        EOS
+      end
+
+      # Show the address of Utxo Provider 
+      def print_address
+        puts wallet.receive_address
+      end
+
+      private
+
+      def tpc_amount
+        wallet.balance(false)
+      end
+
+      def collect_outputs
+        wallet.list_unspent.inject([0, []]) do |sum, output|
+          next sum if output[:color_id] || output[:amount] == utxo_provider.default_value
+
+          new_sum = sum[0] + output[:amount]
+          new_outputs = sum[1] << {
+            txid: output[:txid],
+            script_pubkey: output[:script_pubkey],
+            value: output[:amount],
+            index: output[:vout] ,
+            finalized: output[:finalized]
+          }
+          [new_sum, new_outputs]
+        end
+      end
+
+      def current_utxo_pool_size
+        wallet
+          .list_unspent(false)
+          .count { |o| !o[:color_id] && o[:amount] == utxo_provider.default_value }
+      end
+
+      def value_to_fill_utxo_pool
+        utxo_provider.default_value * utxo_provider.utxo_pool_size
+      end
+
+      def wallet
+        utxo_provider.wallet
+      end
+
+      def delimit(num)
+        num.to_s.reverse.scan(/.{1,3}/).join('_').reverse
+      end
+    end
+  end
+end

data/lib/glueby/utxo_provider.rb

@@ -0,0 +1,85 @@
+module Glueby
+  class UtxoProvider
+    include Glueby::Contract::TxBuilder
+
+    autoload :Tasks, 'glueby/utxo_provider/tasks'
+
+    WALLET_ID = 'UTXO_PROVIDER_WALLET'
+    DEFAULT_VALUE = 1_000
+    DEFAULT_UTXO_POOL_SIZE = 20
+    MAX_UTXO_POOL_SIZE = 2_000
+
+    class << self
+      attr_reader :config
+
+      # @param [Hash] config
+      # @option config [Integer] :default_value 
+      # @option opts [Integer] :utxo_pool_size
+      # @option opts [Glueby::Contract::FeeEstimator] :fee_estimator
+      def configure(config)
+        @config = config
+      end
+    end
+
+    def initialize
+      @wallet = load_wallet
+      validate_config!
+      @fee_estimator = (UtxoProvider.config && UtxoProvider.config[:fee_estimator]) || Glueby::Contract::FixedFeeEstimator.new
+      @default_value = (UtxoProvider.config && UtxoProvider.config[:default_value]) || DEFAULT_VALUE
+      @utxo_pool_size = (UtxoProvider.config && UtxoProvider.config[:utxo_pool_size]) || DEFAULT_UTXO_POOL_SIZE
+    end
+
+    attr_reader :wallet, :fee_estimator, :default_value, :utxo_pool_size 
+
+    # Provide a UTXO
+    # @param [Tapyrus::Script] script_pubkey The script to be provided
+    # @param [Integer] value The tpc amount to be provided
+    # @return [Array<(Tapyrus::Tx, Integer)>]
+    #  The tx that has a UTXO to be provided in its outputs.
+    #  The output index in the tx to indicate the place of a provided UTXO.
+    # @raise [Glueby::Contract::Errors::InsufficientFunds] if provider does not have any utxo which has specified value.
+    def get_utxo(script_pubkey, value = DEFAULT_VALUE)
+      txb = Tapyrus::TxBuilder.new
+      txb.pay(script_pubkey.addresses.first, value)
+
+      fee = fee_estimator.fee(dummy_tx(txb.build))
+      # The outputs need to be shuffled so that no utxos are spent twice as possible.
+      sum, outputs = wallet.collect_uncolored_outputs(fee + value, nil, true, true)
+
+      outputs.each do |utxo|
+        txb.add_utxo({
+          script_pubkey: Tapyrus::Script.parse_from_payload(utxo[:script_pubkey].htb),
+          txid: utxo[:txid],
+          index: utxo[:vout],
+          value: utxo[:amount]
+        })
+      end
+
+      txb.fee(fee).change_address(wallet.change_address)
+
+      tx = txb.build
+      signed_tx = wallet.sign_tx(tx)
+      [signed_tx, 0]
+    end
+
+    private
+
+    # Create wallet for provider
+    def load_wallet
+      begin
+        Glueby::Internal::Wallet.load(WALLET_ID)
+      rescue Glueby::Internal::Wallet::Errors::WalletNotFound => _
+        Glueby::Internal::Wallet.create(WALLET_ID)
+      end
+    end
+
+    def validate_config!
+      if UtxoProvider.config
+        utxo_pool_size = UtxoProvider.config[:utxo_pool_size]
+        if utxo_pool_size && (!utxo_pool_size.is_a?(Integer) || utxo_pool_size > MAX_UTXO_POOL_SIZE)
+          raise Glueby::Configuration::Errors::InvalidConfiguration, "utxo_pool_size(#{utxo_pool_size}) should not be greater than #{MAX_UTXO_POOL_SIZE}"
+        end
+      end
+    end
+  end
+end