glueby 0.2.0 → 0.4.2

data/lib/glueby/contract/timestamp/syncer.rb

@@ -0,0 +1,13 @@
+module Glueby
+  module Contract
+    class Timestamp
+      class Syncer
+        def block_sync(block)
+          Glueby::Contract::AR::Timestamp
+            .where(txid: block.transactions.map(&:txid), status: :unconfirmed)
+            .update_all(status: :confirmed)
+        end
+      end
+    end
+  end
+end

data/lib/glueby/contract/token.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'active_record'
 
 module Glueby
   module Contract
@@ -13,13 +14,17 @@ module Glueby
     # alice = Glueby::Wallet.create
     # bob = Glueby::Wallet.create
     #
+    # Use `Glueby::Internal::Wallet#receive_address` to generate the address of bob
+    # bob.internal_wallet.receive_address
+    # => '1CY6TSSARn8rAFD9chCghX5B7j4PKR8S1a'
+    #
     # Issue
     # token = Token.issue!(issuer: alice, amount: 100)
     # token.amount(wallet: alice)
     # => 100
     #
     # Send
-    # token.transfer!(sender: alice, receiver: bob, amount: 1)
+    # token.transfer!(sender: alice, receiver_address: '1CY6TSSARn8rAFD9chCghX5B7j4PKR8S1a', amount: 1)
     # token.amount(wallet: alice)
     # => 99
     # token.amount(wallet: bob)
@@ -51,14 +56,14 @@ module Glueby
         # @param issuer [Glueby::Wallet]
         # @param token_type [TokenTypes]
         # @param amount [Integer]
-        # @return [Token] token
+        # @return [Array<token, Array<tx>>] Tuple of tx array and token object
         # @raise [InsufficientFunds] if wallet does not have enough TPC to send transaction.
         # @raise [InvalidAmount] if amount is not positive integer.
         # @raise [UnspportedTokenType] if token is not supported.
         def issue!(issuer:, token_type: Tapyrus::Color::TokenTypes::REISSUABLE, amount: 1)
           raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-          txs, color_id, script_pubkey = case token_type
+          txs, color_id = case token_type
                          when Tapyrus::Color::TokenTypes::REISSUABLE
                            issue_reissuable_token(issuer: issuer, amount: amount)
                          when Tapyrus::Color::TokenTypes::NON_REISSUABLE
@@ -68,33 +73,44 @@ module Glueby
                          else
                            raise Glueby::Contract::Errors::UnsupportedTokenType
                          end
-          txs.each { |tx| issuer.internal_wallet.broadcast(tx) }
-          new(color_id: color_id, script_pubkey: script_pubkey)
+
+          [new(color_id: color_id), txs]
         end
 
         private
 
         def issue_reissuable_token(issuer:, amount:)
-          estimated_fee = FixedFeeProvider.new.fee(Tapyrus::Tx.new)
-          funding_tx = create_funding_tx(wallet: issuer, amount: estimated_fee)
-          tx = create_issue_tx_for_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount)
+          funding_tx = create_funding_tx(wallet: issuer)
           script_pubkey = funding_tx.outputs.first.script_pubkey
           color_id = Tapyrus::Color::ColorIdentifier.reissuable(script_pubkey)
-          [[funding_tx, tx], color_id, script_pubkey]
+
+          ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+            # Store the script_pubkey for reissue the token.
+            Glueby::Contract::AR::ReissuableToken.create!(color_id: color_id.to_hex, script_pubkey: script_pubkey.to_hex)
+
+            funding_tx = issuer.internal_wallet.broadcast(funding_tx)
+            tx = create_issue_tx_for_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount)
+            tx = issuer.internal_wallet.broadcast(tx)
+            [[funding_tx, tx], color_id]
+          end
         end
 
         def issue_non_reissuable_token(issuer:, amount:)
           tx = create_issue_tx_for_non_reissuable_token(issuer: issuer, amount: amount)
+          tx = issuer.internal_wallet.broadcast(tx)
+
           out_point = tx.inputs.first.out_point
           color_id = Tapyrus::Color::ColorIdentifier.non_reissuable(out_point)
-          [[tx], color_id, nil]
+          [[tx], color_id]
         end
 
         def issue_nft_token(issuer:)
           tx = create_issue_tx_for_nft_token(issuer: issuer)
+          tx = issuer.internal_wallet.broadcast(tx)
+
           out_point = tx.inputs.first.out_point
           color_id = Tapyrus::Color::ColorIdentifier.nft(out_point)
-          [[tx], color_id, nil]
+          [[tx], color_id]
         end
       end
 
@@ -104,6 +120,7 @@ module Glueby
       # A wallet can issue the token only when it is REISSUABLE token.
       # @param issuer [Glueby::Wallet]
       # @param amount [Integer]
+      # @return [Array<String, tx>] Tuple of color_id and tx object
       # @raise [InsufficientFunds] if wallet does not have enough TPC to send transaction.
       # @raise [InvalidAmount] if amount is not positive integer.
       # @raise [InvalidTokenType] if token is not reissuable.
@@ -111,28 +128,34 @@ module Glueby
       def reissue!(issuer:, amount:)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
         raise Glueby::Contract::Errors::InvalidTokenType unless token_type == Tapyrus::Color::TokenTypes::REISSUABLE
-        raise Glueby::Contract::Errors::UnknownScriptPubkey unless @script_pubkey
 
-        estimated_fee = FixedFeeProvider.new.fee(Tapyrus::Tx.new)
-        funding_tx = create_funding_tx(wallet: issuer, amount: estimated_fee, script: @script_pubkey)
-        tx = create_reissue_tx(funding_tx: funding_tx, issuer: issuer, amount: amount, color_id: color_id)
-        [funding_tx, tx].each { |tx| issuer.internal_wallet.broadcast(tx) }
+        if validate_reissuer(wallet: issuer)
+          funding_tx = create_funding_tx(wallet: issuer, script: @script_pubkey)
+          funding_tx = issuer.internal_wallet.broadcast(funding_tx)
+          tx = create_reissue_tx(funding_tx: funding_tx, issuer: issuer, amount: amount, color_id: color_id)
+          tx = issuer.internal_wallet.broadcast(tx)
+
+          [color_id, tx]
+        else
+          raise Glueby::Contract::Errors::UnknownScriptPubkey
+        end
       end
 
       # Send the token to other wallet
       #
       # @param sender [Glueby::Wallet] wallet to send this token
-      # @param receiver [Glueby::Wallet] wallet to receive this token
+      # @param receiver_address [String] address to receive this token
       # @param amount [Integer]
-      # @return [Token] receiver token
+      # @return [Array<String, tx>] Tuple of color_id and tx object
       # @raise [InsufficientFunds] if wallet does not have enough TPC to send transaction.
       # @raise [InsufficientTokens] if wallet does not have enough token to send.
       # @raise [InvalidAmount] if amount is not positive integer.
-      def transfer!(sender:, receiver:, amount: 1)
+      def transfer!(sender:, receiver_address:, amount: 1)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-        tx = create_transfer_tx(color_id: color_id, sender: sender, receiver: receiver, amount: amount)
+        tx = create_transfer_tx(color_id: color_id, sender: sender, receiver_address: receiver_address, amount: amount)
         sender.internal_wallet.broadcast(tx)
+        [color_id, tx]
       end
 
       # Burn token
@@ -166,12 +189,19 @@ module Glueby
         color_id.type
       end
 
+      # Return the script_pubkey of the token from ActiveRecord
+      # @return [String] script_pubkey
+      def script_pubkey
+        @script_pubkey ||= Glueby::Contract::AR::ReissuableToken.script_pubkey(@color_id.to_hex)
+      end
+
       # Return serialized payload
       # @return [String] payload
       def to_payload
         payload = +''
         payload << @color_id.to_payload
-        payload << @script_pubkey.to_payload if @script_pubkey
+        payload << @script_pubkey.to_payload if script_pubkey
+        payload
       end
 
       # Restore token from payload
@@ -180,14 +210,36 @@ module Glueby
       def self.parse_from_payload(payload)
         color_id, script_pubkey = payload.unpack('a33a*')
         color_id = Tapyrus::Color::ColorIdentifier.parse_from_payload(color_id)
-        script_pubkey = Tapyrus::Script.parse_from_payload(script_pubkey) if script_pubkey
-        new(color_id: color_id, script_pubkey: script_pubkey)
+        if color_id.type == Tapyrus::Color::TokenTypes::REISSUABLE
+          raise ArgumentError, 'script_pubkey should not be empty' if script_pubkey.empty?
+          script_pubkey = Tapyrus::Script.parse_from_payload(script_pubkey)
+          Glueby::Contract::AR::ReissuableToken.create!(color_id: color_id.to_hex, script_pubkey: script_pubkey.to_hex)
+        end
+        new(color_id: color_id)
       end
 
-      def initialize(color_id:, script_pubkey:nil)
+      # Generate Token Instance
+      # @param color_id [String]
+      def initialize(color_id:)
         @color_id = color_id
-        @script_pubkey = script_pubkey
+      end
+
+      private
+
+      # Verify that wallet is the issuer of the reissuable token
+      #　reutrn [Boolean]
+      def validate_reissuer(wallet:)
+        addresses = wallet.internal_wallet.get_addresses
+        addresses.each do |address|
+          decoded_address = Tapyrus.decode_base58_address(address)
+          pubkey_hash_from_address = decoded_address[0]
+          pubkey_hash_from_script = Tapyrus::Script.parse_from_payload(script_pubkey.chunks[2])
+          if pubkey_hash_from_address == pubkey_hash_from_script.to_s
+            return true
+          end
+        end
+        false
       end
     end
   end
-end
+end

data/lib/glueby/contract/tx_builder.rb

@@ -3,26 +3,29 @@
 module Glueby
   module Contract
     module TxBuilder
+      # The amount of output in funding tx for Reissuable token.
+      FUNDING_TX_AMOUNT = 10_000
+
       def receive_address(wallet:)
         wallet.receive_address
       end
 
       # Create new public key, and new transaction that sends TPC to it
-      def create_funding_tx(wallet:, amount:, script: nil, fee_provider: FixedFeeProvider.new)
+      def create_funding_tx(wallet:, script: nil, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
 
-        sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee + amount)
+        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: amount, script_pubkey: receiver_script)
+        tx.outputs << Tapyrus::TxOut.new(value: FUNDING_TX_AMOUNT, script_pubkey: receiver_script)
 
-        fill_change_tpc(tx, wallet, sum - fee - amount)
+        fill_change_tpc(tx, wallet, sum - fee - FUNDING_TX_AMOUNT)
         wallet.internal_wallet.sign_tx(tx)
       end
 
-      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_provider: FixedFeeProvider.new)
+      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -34,7 +37,7 @@ module Glueby
         receiver_colored_script = receiver_script.add_color(color_id)
         tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
         prev_txs = [{
           txid: funding_tx.txid,
@@ -45,18 +48,18 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_issue_tx_for_non_reissuable_token(issuer:, amount:, fee_provider: FixedFeeProvider.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NON_REISSUABLE, issuer: issuer, amount: amount, fee_provider: fee_provider)
+      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)
       end
 
-      def create_issue_tx_for_nft_token(issuer:, fee_provider: FixedFeeProvider.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NFT, issuer: issuer, amount: 1, fee_provider: fee_provider)
+      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)
       end
 
-      def create_issue_tx_from_out_point(token_type:, issuer:, amount:, fee_provider: FixedFeeProvider.new)
+      def create_issue_tx_from_out_point(token_type:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
-        fee = fee_provider.fee(dummy_issue_tx_from_out_point)
+        fee = fee_estimator.fee(dummy_issue_tx_from_out_point)
         sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee)
         fill_input(tx, outputs)
 
@@ -78,7 +81,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx)
       end
 
-      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_provider: FixedFeeProvider.new)
+      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -89,7 +92,7 @@ module Glueby
         receiver_colored_script = receiver_script.add_color(color_id)
         tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
         prev_txs = [{
           txid: funding_tx.txid,
@@ -100,20 +103,20 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_transfer_tx(color_id:, sender:, receiver:, amount:, fee_provider: FixedFeeProvider.new)
+      def create_transfer_tx(color_id:, sender:, receiver_address:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
         sum_token, outputs = collect_colored_outputs(utxos, color_id, amount)
         fill_input(tx, outputs)
 
-        receiver_script = Tapyrus::Script.parse_from_addr(receiver.internal_wallet.receive_address)
+        receiver_script = Tapyrus::Script.parse_from_addr(receiver_address)
         receiver_colored_script = receiver_script.add_color(color_id)
         tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
 
         fill_change_token(tx, sender, sum_token - amount, color_id)
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
         sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee)
         fill_input(tx, outputs)
 
@@ -121,7 +124,7 @@ module Glueby
         sender.internal_wallet.sign_tx(tx)
       end
 
-      def create_burn_tx(color_id:, sender:, amount: 0, fee_provider: FixedFeeProvider.new)
+      def create_burn_tx(color_id:, sender:, amount: 0, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
@@ -130,7 +133,7 @@ module Glueby
 
         fill_change_token(tx, sender, sum_token - amount, color_id) if amount.positive?
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        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)

data/lib/glueby/fee_provider.rb

@@ -0,0 +1,73 @@
+module Glueby
+  class FeeProvider
+
+    autoload :Tasks, 'glueby/fee_provider/tasks'
+
+    class NoUtxosInUtxoPool < StandardError; end
+
+    WALLET_ID = 'FEE_PROVIDER_WALLET'
+    DEFAULT_FIXED_FEE = 1000
+    DEFAULT_UTXO_POOL_SIZE = 20
+
+    attr_reader :fixed_fee, :utxo_pool_size, :wallet,
+
+    class << self
+      attr_reader :config
+
+      # @param [Hash] config
+      # @option config [Integer] :fixed_fee The amount of fee which FeeProvider would provide to the txs
+      # @option opts [Integer] :utxo_pool_size The number of UTXOs in UTXO pool that is managed by FeeProvider
+      def configure(config)
+        @config = config
+      end
+
+      def provide(tx)
+        new.provide(tx)
+      end
+    end
+
+    def initialize
+      @wallet = begin
+                  Internal::Wallet.load(WALLET_ID)
+                rescue Internal::Wallet::Errors::WalletNotFound => _
+                  Internal::Wallet.create(WALLET_ID)
+                end
+
+      @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
+
+    # Provide an input for fee to the tx.
+    # @param [Tapyrus::Tx] tx - The tx that is provided fee as a input. It should be signed with ANYONECANPAY flag.
+    # @return [Tapyrus::Tx]
+    # @raise [ArgumentError] If the signatures that the tx inputs has don't have ANYONECANPAY flag.
+    # @raise [Glueby::FeeProvider::NoUtxosInUtxoPool] If there are no UTXOs for paying fee in FeeProvider's UTXO pool
+    def provide(tx)
+      tx.inputs.each do |txin|
+        sig = get_signature(txin.script_sig)
+        unless sig[-1].unpack1('C') & Tapyrus::SIGHASH_TYPE[:anyonecanpay] == Tapyrus::SIGHASH_TYPE[:anyonecanpay]
+          raise ArgumentError, 'All the signatures that the tx inputs has should have ANYONECANPAY flag.'
+        end
+      end
+
+      utxo = utxo_for_fee
+      out_point = Tapyrus::OutPoint.new(utxo[:txid].rhex, utxo[:vout])
+      tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+
+      wallet.sign_tx(tx, for_fee_provider_input: true)
+    end
+
+    private
+
+    def utxo_for_fee
+      utxo = wallet.list_unspent.select { |o| !o[:color_id] && o[:amount] == fixed_fee }.sample
+      raise NoUtxosInUtxoPool, 'No UTXOs in Fee Provider UTXO pool. UTXOs should be created with "glueby:fee_provider:manage_utxo_pool" rake task' unless utxo
+      utxo
+    end
+
+    # Get Signature from P2PKH or CP2PKH script sig
+    def get_signature(script_sig)
+      script_sig.chunks.first.pushed_data
+    end
+  end
+end

data/lib/glueby/fee_provider/tasks.rb

@@ -0,0 +1,141 @@
+module Glueby
+  class FeeProvider
+    class Tasks
+      attr_reader :fee_provider
+
+      STATUS = {
+        # FeeProvider is ready to pay fees.
+        ready: 'Ready',
+        # FeeProvider is ready to pay fees, but it doesn't have enough amount to fill the UTXO pool by UTXOs which is for paying fees.
+        insufficient_amount: 'Insufficient Amount',
+        # FeeProvider is not ready to pay fees. It has no UTXOs for paying fee and amounts.
+        not_ready: 'Not Ready'
+      }
+
+      def initialize
+        @fee_provider = Glueby::FeeProvider.new
+      end
+
+      # Create UTXOs for paying fee from TPC amount of the wallet FeeProvider has. Then show the status.
+      #
+      # About the UTXO Pool
+      # FeeProvider have the UTXO pool. the pool is manged to keep some number of UTXOs that have fixed fee value. The
+      # value is configurable by :fixed_fee. 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 = [fee_provider.utxo_pool_size - current_utxo_pool_size, 0].max
+        can_create = (sum - fee_provider.fixed_fee) / fee_provider.fixed_fee
+        fee_outputs_count_to_be_created = [shortage, can_create].min
+
+        return if fee_outputs_count_to_be_created == 0
+
+        fee_outputs_count_to_be_created.times do
+          txb.pay(address, fee_provider.fixed_fee)
+        end
+
+        tx = txb.change_address(address)
+                .fee(fee_provider.fixed_fee)
+                .build
+        tx = wallet.sign_tx(tx)
+        wallet.broadcast(tx, without_fee_provider: true)
+      ensure
+        status
+      end
+
+      # Show the status of the UTXO pool
+      def status
+        status = :ready
+
+        if current_utxo_pool_size < fee_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 fee to FeeProvider. 
+               FeeProvider needs #{value_to_fill_utxo_pool} tapyrus at least for paying 20 transaction fees. 
+               FeeProvider wallet's address is '#{wallet.receive_address}'
+            2. Then create UTXOs for paying in UTXO pool with 'rake glueby:fee_provider:manage_utxo_pool'
+            MESSAGE
+          else
+            message = "Please create UTXOs for paying in UTXO pool with 'rake glueby:fee_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:
+          fixed_fee = #{delimit(fee_provider.fixed_fee)}
+          utxo_pool_size = #{delimit(fee_provider.utxo_pool_size)}
+        EOS
+      end
+
+      # Show the address of Fee Provider 
+      def address
+        puts wallet.receive_address
+      end
+
+      private
+
+      def check_wallet_amount!
+        if tpc_amount < fee_provider.fixed_fee
+          raise InsufficientTPC, <<~MESSAGE
+            FeeProvider has insufficient TPC to create fee outputs to fill the UTXO pool.
+            1. Please replenishment TPC which is for paying fee to FeeProvider. FeeProvider needs #{fee_provider.utxo_pool_size * fee_provider.fixed_fee} tapyrus at least. FeeProvider wallet's address is '#{wallet.receive_address}'
+            2. Then create UTXOs for paying in UTXO pool with 'rake glueby:fee_provider:manage_utxo_pool'
+          MESSAGE
+        end
+      end
+
+      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] == fee_provider.fixed_fee
+
+          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]
+          }
+          return [new_sum, new_outputs] if new_sum >= value_to_fill_utxo_pool
+
+          [new_sum, new_outputs]
+        end
+      end
+
+      def current_utxo_pool_size
+        wallet
+          .list_unspent(false)
+          .count { |o| !o[:color_id] && o[:amount] == fee_provider.fixed_fee }
+      end
+
+      def value_to_fill_utxo_pool
+        fee_provider.fixed_fee * (fee_provider.utxo_pool_size + 1) #  +1 is for paying fee
+      end
+
+      def wallet
+        fee_provider.wallet
+      end
+
+      def delimit(num)
+        num.to_s.reverse.scan(/.{1,3}/).join('_').reverse
+      end
+    end
+  end
+end