glueby 1.0.0 → 1.1.0

data/lib/glueby/contract/token.rb

@@ -43,6 +43,10 @@ module Glueby
     # token.amount(wallet: alice)
     # => 100
     #
+    # Issue with metadata / Get metadata
+    # token = Token.issue!(issuer: alice, amount: 100, metadata: 'metadata')
+    # token.metadata
+    # => "metadata"
     class Token
       include Glueby::Contract::TxBuilder
       extend Glueby::Contract::TxBuilder
@@ -57,22 +61,24 @@ module Glueby
         # @param token_type [TokenTypes]
         # @param amount [Integer]
         # @param split [Integer] The tx outputs should be split by specified number.
+        # @param fee_estimator [Glueby::Contract::FeeEstimator]
+        # @param metadata [String] The data to be stored in blockchain.
         # @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 [InvalidSplit] if split is greater than 1 for NFT token.
-        # @raise [UnspportedTokenType] if token is not supported.
-        def issue!(issuer:, token_type: Tapyrus::Color::TokenTypes::REISSUABLE, amount: 1, split: 1)
+        # @raise [UnsupportedTokenType] if token is not supported.
+        def issue!(issuer:, token_type: Tapyrus::Color::TokenTypes::REISSUABLE, amount: 1, split: 1, fee_estimator: FeeEstimator::Fixed.new, metadata: nil)
           raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
           raise Glueby::Contract::Errors::InvalidSplit if token_type == Tapyrus::Color::TokenTypes::NFT && split > 1
 
           txs, color_id = case token_type
                          when Tapyrus::Color::TokenTypes::REISSUABLE
-                           issue_reissuable_token(issuer: issuer, amount: amount, split: split)
+                           issue_reissuable_token(issuer: issuer, amount: amount, split: split, fee_estimator: fee_estimator, metadata: metadata)
                          when Tapyrus::Color::TokenTypes::NON_REISSUABLE
-                           issue_non_reissuable_token(issuer: issuer, amount: amount, split: split)
+                           issue_non_reissuable_token(issuer: issuer, amount: amount, split: split, fee_estimator: fee_estimator, metadata: metadata)
                          when Tapyrus::Color::TokenTypes::NFT
-                           issue_nft_token(issuer: issuer)
+                           issue_nft_token(issuer: issuer, metadata: metadata)
                          else
                            raise Glueby::Contract::Errors::UnsupportedTokenType
                          end
@@ -84,10 +90,35 @@ module Glueby
           Glueby::AR::SystemInformation.use_only_finalized_utxo?
         end
 
+        # Sign to pay-to-contract output.
+        #
+        # @param issuer [Glueby::Walelt] Issuer of the token
+        # @param tx [Tapyrus::Tx] The transaction to be signed with metadata
+        # @param funding_tx [Tapyrus::Tx] The funding transaction that has pay-to-contract output in its first output
+        # @param payment_base [String] The public key used to generate pay to contract public key
+        # @param metadata [String] Data that represents token metadata
+        # @return [Tapyrus::Tx] signed tx
+        def sign_to_p2c_output(issuer, tx, funding_tx, payment_base, metadata)
+          utxo = { txid: funding_tx.txid, vout: 0, script_pubkey: funding_tx.outputs[0].script_pubkey.to_hex }
+          issuer.internal_wallet.sign_to_pay_to_contract_address(tx, utxo, payment_base, metadata)
+        end
+
         private
 
-        def issue_reissuable_token(issuer:, amount:, split: 1)
-          funding_tx = create_funding_tx(wallet: issuer, only_finalized: only_finalized?)
+        def create_p2c_address(wallet, metadata)
+          p2c_address, payment_base = wallet.internal_wallet.create_pay_to_contract_address(metadata)
+          script = Tapyrus::Script.parse_from_addr(p2c_address)
+          [script, p2c_address, payment_base]
+        end
+
+        def issue_reissuable_token(issuer:, amount:, split: 1, fee_estimator:, metadata: nil)
+          script, p2c_address, payment_base = create_p2c_address(issuer, metadata) if metadata
+
+          # For reissuable token, we need funding transaction for every issuance.
+          # To make it easier for API users to understand whether a transaction is a new issue or a reissue, 
+          # when Token.issue! is executed, a new address is created and tpc is sent to it to ensure that it is a new issue, 
+          # and a transaction is created using that UTXO as input to create a new color_id. 
+          funding_tx = create_funding_tx(wallet: issuer, script: script, only_finalized: only_finalized?)
           script_pubkey = funding_tx.outputs.first.script_pubkey
           color_id = Tapyrus::Color::ColorIdentifier.reissuable(script_pubkey)
 
@@ -99,41 +130,82 @@ module Glueby
             # 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)
 
-            tx = create_issue_tx_for_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount, split: split)
+            tx = create_issue_tx_for_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount, split: split, fee_estimator: fee_estimator)
+            if metadata
+              Glueby::Contract::AR::TokenMetadata.create!(
+                color_id: color_id.to_hex,
+                metadata: metadata,
+                p2c_address: p2c_address,
+                payment_base: payment_base
+              )
+              tx = sign_to_p2c_output(issuer, tx, funding_tx, payment_base, metadata)
+            end
             tx = issuer.internal_wallet.broadcast(tx)
             [[funding_tx, tx], color_id]
           end
         end
 
-        def issue_non_reissuable_token(issuer:, amount:, split: 1)
-          funding_tx = create_funding_tx(wallet: issuer, only_finalized: only_finalized?) if Glueby.configuration.use_utxo_provider?
-          funding_tx = issuer.internal_wallet.broadcast(funding_tx) if funding_tx
+        def issue_non_reissuable_token(issuer:, amount:, split: 1, fee_estimator:, metadata: nil)
+          script, p2c_address, payment_base = create_p2c_address(issuer, metadata) if metadata
+          funding_tx = create_funding_tx(wallet: issuer, script: script, only_finalized: only_finalized?) if Glueby.configuration.use_utxo_provider? || script
+          if funding_tx
+            ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+              funding_tx = issuer.internal_wallet.broadcast(funding_tx)
+            end
+          end
 
-          tx = create_issue_tx_for_non_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount, split: split)
-          tx = issuer.internal_wallet.broadcast(tx)
+          ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+            tx = create_issue_tx_for_non_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount, split: split, fee_estimator: fee_estimator)
+            out_point = tx.inputs.first.out_point
+            color_id = Tapyrus::Color::ColorIdentifier.non_reissuable(out_point)
+            if metadata
+              Glueby::Contract::AR::TokenMetadata.create!(
+                color_id: color_id.to_hex,
+                metadata: metadata,
+                p2c_address: p2c_address,
+                payment_base: payment_base
+              )
+              tx = sign_to_p2c_output(issuer, tx, funding_tx, payment_base, metadata)
+            end
+            tx = issuer.internal_wallet.broadcast(tx)
 
-          out_point = tx.inputs.first.out_point
-          color_id = Tapyrus::Color::ColorIdentifier.non_reissuable(out_point)
-          if funding_tx
-            [[funding_tx, tx], color_id]
-          else
-            [[tx], color_id]
+            if funding_tx
+              [[funding_tx, tx], color_id]
+            else
+              [[tx], color_id]
+            end
           end
         end
 
-        def issue_nft_token(issuer:)
-          funding_tx = create_funding_tx(wallet: issuer, only_finalized: only_finalized?) if Glueby.configuration.use_utxo_provider?
-          funding_tx = issuer.internal_wallet.broadcast(funding_tx) if funding_tx
+        def issue_nft_token(issuer:, metadata: nil)
+          script, p2c_address, payment_base = create_p2c_address(issuer, metadata) if metadata
+          funding_tx = create_funding_tx(wallet: issuer, script: script, only_finalized: only_finalized?) if Glueby.configuration.use_utxo_provider? || script
+          if funding_tx
+            ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+              funding_tx = issuer.internal_wallet.broadcast(funding_tx)
+            end
+          end
 
-          tx = create_issue_tx_for_nft_token(funding_tx: funding_tx, issuer: issuer)
-          tx = issuer.internal_wallet.broadcast(tx)
+          ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+            tx = create_issue_tx_for_nft_token(funding_tx: funding_tx, issuer: issuer)
+            out_point = tx.inputs.first.out_point
+            color_id = Tapyrus::Color::ColorIdentifier.nft(out_point)
+            if metadata
+              Glueby::Contract::AR::TokenMetadata.create!(
+                color_id: color_id.to_hex,
+                metadata: metadata,
+                p2c_address: p2c_address,
+                payment_base: payment_base
+              )
+              tx = sign_to_p2c_output(issuer, tx, funding_tx, payment_base, metadata)
+            end
+            tx = issuer.internal_wallet.broadcast(tx)
 
-          out_point = tx.inputs.first.out_point
-          color_id = Tapyrus::Color::ColorIdentifier.nft(out_point)
-          if funding_tx
-            [[funding_tx, tx], color_id]
-          else
-            [[tx], color_id]
+            if funding_tx
+              [[funding_tx, tx], color_id]
+            else
+              [[tx], color_id]
+            end
           end
         end
       end
@@ -145,25 +217,28 @@ module Glueby
       # @param issuer [Glueby::Wallet]
       # @param amount [Integer]
       # @param split [Integer]
+      # @param fee_estimator [Glueby::Contract::FeeEstimator]
       # @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.
       # @raise [UnknownScriptPubkey] when token is reissuable but it doesn't know script pubkey to issue token.
-      def reissue!(issuer:, amount:, split: 1)
+      def reissue!(issuer:, amount:, split: 1, fee_estimator: FeeEstimator::Fixed.new)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
         raise Glueby::Contract::Errors::InvalidTokenType unless token_type == Tapyrus::Color::TokenTypes::REISSUABLE
 
-        if validate_reissuer(wallet: issuer)
-          funding_tx = create_funding_tx(wallet: issuer, script: @script_pubkey, only_finalized: only_finalized?)
-          funding_tx = issuer.internal_wallet.broadcast(funding_tx)
-          tx = create_reissue_tx(funding_tx: funding_tx, issuer: issuer, amount: amount, color_id: color_id, split: split)
-          tx = issuer.internal_wallet.broadcast(tx)
+        token_metadata = Glueby::Contract::AR::TokenMetadata.find_by(color_id: color_id.to_hex)
+        raise Glueby::Contract::Errors::UnknownScriptPubkey unless valid_reissuer?(wallet: issuer, token_metadata: token_metadata)
 
-          [color_id, tx]
-        else
-          raise Glueby::Contract::Errors::UnknownScriptPubkey
+        funding_tx = create_funding_tx(wallet: issuer, script: @script_pubkey, only_finalized: only_finalized?)
+        funding_tx = issuer.internal_wallet.broadcast(funding_tx)
+        tx = create_reissue_tx(funding_tx: funding_tx, issuer: issuer, amount: amount, color_id: color_id, split: split, fee_estimator: fee_estimator)
+        if token_metadata
+          tx = Token.sign_to_p2c_output(issuer, tx, funding_tx, token_metadata.payment_base, token_metadata.metadata)
         end
+        tx = issuer.internal_wallet.broadcast(tx)
+
+        [color_id, tx]
       end
 
       # Send the token to other wallet
@@ -171,23 +246,21 @@ module Glueby
       # @param sender [Glueby::Wallet] wallet to send this token
       # @param receiver_address [String] address to receive this token
       # @param amount [Integer]
+      # @param fee_estimator [Glueby::Contract::FeeEstimator]
       # @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_address:, amount: 1)
+      def transfer!(sender:, receiver_address:, amount: 1, fee_estimator: FeeEstimator::Fixed.new)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-        funding_tx = create_funding_tx(wallet: sender, only_finalized: only_finalized?) if Glueby.configuration.use_utxo_provider?
-        funding_tx = sender.internal_wallet.broadcast(funding_tx) if funding_tx
-
         tx = create_transfer_tx(
-          funding_tx: funding_tx,
           color_id: color_id,
           sender: sender,
           receiver_address: receiver_address,
           amount: amount,
-          only_finalized: only_finalized?
+          only_finalized: only_finalized?,
+          fee_estimator: fee_estimator
         )
         sender.internal_wallet.broadcast(tx)
         [color_id, tx]
@@ -197,23 +270,22 @@ module Glueby
       #
       # @param sender [Glueby::Wallet] wallet to send this token
       # @param receivers [Array<Hash>] array of hash, which keys are :address and :amount
+      # @param fee_estimator [Glueby::Contract::FeeEstimator]
       # @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 multi_transfer!(sender:, receivers:)
+      def multi_transfer!(sender:, receivers:, fee_estimator: FeeEstimator::Fixed.new)
         receivers.each do |r|
           raise Glueby::Contract::Errors::InvalidAmount unless r[:amount].positive?
         end
-        funding_tx = create_funding_tx(wallet: sender, only_finalized: only_finalized?) if Glueby.configuration.use_utxo_provider?
-        funding_tx = sender.internal_wallet.broadcast(funding_tx) if funding_tx
 
         tx = create_multi_transfer_tx(
-          funding_tx: funding_tx,
           color_id: color_id,
           sender: sender,
           receivers: receivers,
-          only_finalized: only_finalized?
+          only_finalized: only_finalized?,
+          fee_estimator: fee_estimator
         )
         sender.internal_wallet.broadcast(tx)
         [color_id, tx]
@@ -224,33 +296,17 @@ module Glueby
       #
       # @param sender [Glueby::Wallet] wallet to send this token
       # @param amount [Integer]
+      # @param fee_estimator [Glueby::Contract::FeeEstimator]
       # @raise [InsufficientFunds] if wallet does not have enough TPC to send transaction.
       # @raise [InsufficientTokens] if wallet does not have enough token to send transaction.
       # @raise [InvalidAmount] if amount is not positive integer.
-      def burn!(sender:, amount: 0)
+      def burn!(sender:, amount: 0, fee_estimator: FeeEstimator::Fixed.new)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
         balance = sender.balances(only_finalized?)[color_id.to_hex]
         raise Glueby::Contract::Errors::InsufficientTokens unless balance
         raise Glueby::Contract::Errors::InsufficientTokens if balance < amount
 
-        burn_all_amount_flag = true if balance - amount == 0
-
-        utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
-        if utxo_provider
-          funding_tx = create_funding_tx(
-            wallet: sender,
-            # When it burns all the amount of the color id, burn tx is not going to be have any output
-            # because change outputs is not necessary. Transactions needs one output at least.
-            # At that time, set true to this option to get more value to be created change output to
-            # the tx.
-            need_value_for_change_output: burn_all_amount_flag,
-            only_finalized: only_finalized?
-          )
-        end
-
-        funding_tx = sender.internal_wallet.broadcast(funding_tx) if funding_tx
-
-        tx = create_burn_tx(funding_tx: funding_tx, color_id: color_id, sender: sender, amount: amount, only_finalized: only_finalized?)
+        tx = create_burn_tx(color_id: color_id, sender: sender, amount: amount, only_finalized: only_finalized?, fee_estimator: fee_estimator)
         sender.internal_wallet.broadcast(tx)
       end
 
@@ -264,6 +320,31 @@ module Glueby
         results.sum { |result| result[:amount] }
       end
 
+      # Return metadata for this token
+      # @return [String] metadata. if token is not associated with metadata, return nil
+      def metadata
+        token_metadata&.metadata
+      end
+
+      # Return pay to contract address
+      # @return [String] p2c_address. if token is not associated with metadata, return nil
+      def p2c_address
+        token_metadata&.p2c_address
+      end
+
+      # Return public key used to generate pay to contract address
+      # @return [String] payment_base. if token is not associated with metadata, return nil
+      def payment_base
+        token_metadata&.payment_base
+      end
+
+      # Return Glueby::Contract::AR::TokenMetadata instance for this token
+      # @return [Glueby::Contract::AR::TokenMetadata]
+      def token_metadata
+        return @token_metadata if defined? @token_metadata
+        @token_metadata = Glueby::Contract::AR::TokenMetadata.find_by(color_id: color_id.to_hex)
+      end
+
       # Return token type
       # @return [Tapyrus::Color::TokenTypes]
       def token_type
@@ -312,18 +393,18 @@ module Glueby
       end
 
       # 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
+      # @param wallet [Glueby::Wallet]
+      # @param token_metadata [Glueby::Contract::AR::TokenMetadata] metadata to be stored in blockchain as p2c address
+      # @return [Boolean] true if the wallet is the issuer of this token
+      def valid_reissuer?(wallet:, token_metadata: nil)
+        return false unless script_pubkey&.p2pkh?
+        address = if token_metadata
+            payment_base = Tapyrus::Key.new(pubkey: token_metadata.payment_base, key_type: Tapyrus::Key::TYPES[:compressed])
+            payment_base.to_p2pkh
+          else
+            script_pubkey.to_addr
           end
-        end
-        false
+        wallet.internal_wallet.has_address?(address)
       end
     end
   end

data/lib/glueby/contract/tx_builder.rb

@@ -8,16 +8,16 @@ module Glueby
       end
 
       # Create new public key, and new transaction that sends TPC to it
-      def create_funding_tx(wallet:, script: nil, fee_estimator: FeeEstimator::Fixed.new, need_value_for_change_output: false, only_finalized: true)
+      def create_funding_tx(wallet:, script: nil, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
         if Glueby.configuration.use_utxo_provider?
-          utxo_provider = UtxoProvider.new
+          utxo_provider = UtxoProvider.instance
           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(need_value_for_change_output: need_value_for_change_output))
+          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(FeeEstimator.dummy_tx(txb.build))
-          amount = fee + funding_tx_amount(need_value_for_change_output: need_value_for_change_output)
+          amount = fee + funding_tx_amount
           sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(amount, nil, only_finalized)
           outputs.each do |utxo|
             txb.add_utxo({
@@ -44,20 +44,39 @@ module Glueby
         tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
         output = funding_tx.outputs.first
 
-        receiver_script = Tapyrus::Script.parse_from_payload(output.script_pubkey.to_payload)
-        color_id = Tapyrus::Color::ColorIdentifier.reissuable(receiver_script)
+        receiver_script = Tapyrus::Script.parse_from_addr(issuer.internal_wallet.receive_address)
+        funding_script = Tapyrus::Script.parse_from_payload(output.script_pubkey.to_payload)
+        color_id = Tapyrus::Color::ColorIdentifier.reissuable(funding_script)
         receiver_colored_script = receiver_script.add_color(color_id)
 
         add_split_output(tx, amount, split, receiver_colored_script)
 
         fee = fee_estimator.fee(FeeEstimator.dummy_tx(tx))
-        fill_change_tpc(tx, issuer, output.value - fee)
+
         prev_txs = [{
           txid: funding_tx.txid,
           vout: 0,
           scriptPubKey: output.script_pubkey.to_hex,
           amount: output.value
         }]
+
+        if Glueby.configuration.use_utxo_provider?
+          utxo_provider = UtxoProvider.instance
+          tx, fee, input_amount, provided_utxos = utxo_provider.fill_inputs(
+            tx,
+            target_amount: 0,
+            current_amount: output.value,
+            fee_estimator: fee_estimator
+          )
+          prev_txs.concat(provided_utxos)
+        else
+          # TODO: Support the case of providing UTXOs from sender's wallet.
+          input_amount = output.value
+        end
+
+        fill_change_tpc(tx, issuer, input_amount - fee)
+
+        UtxoProvider.instance.wallet.sign_tx(tx, prev_txs) if Glueby.configuration.use_utxo_provider?
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
@@ -96,18 +115,32 @@ module Glueby
         receiver_colored_script = receiver_script.add_color(color_id)
         add_split_output(tx, amount, split, receiver_colored_script)
 
-        fill_change_tpc(tx, issuer, sum - fee)
         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
-          []
+                     output = funding_tx.outputs.first
+                     [{
+                       txid: funding_tx.txid,
+                       vout: 0,
+                       scriptPubKey: output.script_pubkey.to_hex,
+                       amount: output.value
+                     }]
+                   else
+                     []
+                   end
+
+        if Glueby.configuration.use_utxo_provider?
+          utxo_provider = UtxoProvider.instance
+          tx, fee, sum, provided_utxos = utxo_provider.fill_inputs(
+            tx,
+            target_amount: 0,
+            current_amount: sum,
+            fee_estimator: fee_estimator
+          )
+          prev_txs.concat(provided_utxos)
         end
+
+        fill_change_tpc(tx, issuer, sum - fee)
+
+        UtxoProvider.instance.wallet.sign_tx(tx, prev_txs) if Glueby.configuration.use_utxo_provider?
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
@@ -118,25 +151,42 @@ module Glueby
         tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
         output = funding_tx.outputs.first
 
-        receiver_script = Tapyrus::Script.parse_from_payload(output.script_pubkey.to_payload)
+        receiver_script = Tapyrus::Script.parse_from_addr(issuer.internal_wallet.receive_address)
         receiver_colored_script = receiver_script.add_color(color_id)
         add_split_output(tx, amount, split, receiver_colored_script)
 
         fee = fee_estimator.fee(FeeEstimator.dummy_tx(tx))
-        fill_change_tpc(tx, issuer, output.value - fee)
+
         prev_txs = [{
           txid: funding_tx.txid,
           vout: 0,
           scriptPubKey: output.script_pubkey.to_hex,
           amount: output.value
         }]
+
+        if Glueby.configuration.use_utxo_provider?
+          utxo_provider = UtxoProvider.instance
+          tx, fee, input_amount, provided_utxos = utxo_provider.fill_inputs(
+            tx,
+            target_amount: 0,
+            current_amount: output.value,
+            fee_estimator: fee_estimator
+          )
+          prev_txs.concat(provided_utxos)
+        else
+          # TODO: Support the case of providing UTXOs from sender's wallet.
+          input_amount = output.value
+        end
+
+        fill_change_tpc(tx, issuer, input_amount - fee)
+
+        UtxoProvider.instance.wallet.sign_tx(tx, prev_txs) if Glueby.configuration.use_utxo_provider?
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_transfer_tx(funding_tx:nil, color_id:, sender:, receiver_address:, amount:, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
+      def create_transfer_tx(color_id:, sender:, receiver_address:, amount:, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
         receivers = [{ address: receiver_address, amount: amount }]
         create_multi_transfer_tx(
-          funding_tx: funding_tx,
           color_id: color_id,
           sender: sender,
           receivers: receivers,
@@ -145,7 +195,7 @@ module Glueby
         )
       end
 
-      def create_multi_transfer_tx(funding_tx:nil, color_id:, sender:, receivers:, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
+      def create_multi_transfer_tx(color_id:, sender:, receivers:, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
         tx = Tapyrus::Tx.new
 
         amount = receivers.reduce(0) { |sum, r| sum + r[:amount].to_i }
@@ -162,32 +212,30 @@ module Glueby
         fill_change_token(tx, sender, sum_token - amount, color_id)
 
         fee = fee_estimator.fee(FeeEstimator.dummy_tx(tx))
-        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
+
+        # Fill inputs for paying fee
+        prev_txs = []
+        if Glueby.configuration.use_utxo_provider?
+          utxo_provider = UtxoProvider.instance
+          tx, fee, sum_tpc, provided_utxos = utxo_provider.fill_inputs(
+            tx,
+            target_amount: 0,
+            current_amount: 0,
+            fee_estimator: fee_estimator
+          )
+          prev_txs.concat(provided_utxos)
         else
+          # TODO: Support the case of increasing fee by adding multiple inputs
           sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee, nil, only_finalized)
           fill_input(tx, outputs)
-          sum_tpc
         end
 
         fill_change_tpc(tx, sender, sum_tpc - fee)
-        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
+        UtxoProvider.instance.wallet.sign_tx(tx, prev_txs) if Glueby.configuration.use_utxo_provider?
         sender.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_burn_tx(funding_tx:nil, color_id:, sender:, amount: 0, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
+      def create_burn_tx(color_id:, sender:, amount: 0, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent(only_finalized)
@@ -195,32 +243,27 @@ module Glueby
         fill_input(tx, outputs)
 
         fill_change_token(tx, sender, sum_token - amount, color_id) if amount.positive?
-
         fee = fee_estimator.fee(FeeEstimator.dummy_tx(tx))
 
-        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
+        provided_utxos = []
+        if Glueby.configuration.use_utxo_provider?
+          # When it burns all the amount of the color id, burn tx is not going to have any output
+          # because change outputs are not necessary, though such a transaction is not 'standard' and would be rejected by the Tapyrus node.
+          # UtxoProvider#fill_inputs method provides an extra output with a DUST_LIMIT value in this case
+          # , so that it created at least one output to the burn tx.
+          tx, fee, sum_tpc, provided_utxos = UtxoProvider.instance.fill_inputs(
+            tx,
+            target_amount: 0,
+            current_amount: 0,
+            fee_estimator: fee_estimator
+          )
         else
           sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee + DUST_LIMIT, nil, only_finalized)
           fill_input(tx, outputs)
-          sum_tpc
         end
-
         fill_change_tpc(tx, sender, sum_tpc - fee)
-        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)
+        UtxoProvider.instance.wallet.sign_tx(tx, provided_utxos) if Glueby.configuration.use_utxo_provider?
+        sender.internal_wallet.sign_tx(tx, provided_utxos)
       end
 
       def add_split_output(tx, amount, split, script_pubkey)
@@ -245,7 +288,7 @@ module Glueby
         return unless change.positive?
 
         if Glueby.configuration.use_utxo_provider?
-          change_script = Tapyrus::Script.parse_from_addr(UtxoProvider.new.wallet.change_address)
+          change_script = Tapyrus::Script.parse_from_addr(UtxoProvider.instance.wallet.change_address)
         else
           change_script = Tapyrus::Script.parse_from_addr(wallet.internal_wallet.change_address)
         end
@@ -294,14 +337,8 @@ module Glueby
       # The amount of output in funding tx
       # It returns same amount with FeeEstimator::Fixed's fixed fee. Because it is enough for paying fee for consumer
       # transactions of the funding transactions.
-      #
-      # @option [Boolean] need_value_for_change_output If it is true, adds more value than the fee for producing change output.
-      def funding_tx_amount(need_value_for_change_output: false)
-        if need_value_for_change_output
-          FeeEstimator::Fixed.new.fixed_fee + DUST_LIMIT
-        else
-          FeeEstimator::Fixed.new.fixed_fee
-        end
+      def funding_tx_amount
+        FeeEstimator::Fixed.new.fixed_fee
       end
     end
   end