glueby 0.10.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 374ec643c65f210f1ecc1f35951ead50b86beaf9298a404a3cd21d0c3b0f1872
-  data.tar.gz: 3b4c3a5780e06ca072b4b8b08839210a927a67af42a00ad9557926820ffefada
+  metadata.gz: 959a9d1dfbdea6b4b18e969b07399a9228fce31e80c7defcb9c393b71df1607b
+  data.tar.gz: efe95c4c0ef08692d30fb1ff9dfeeea13d777f809d71f19d329b9b50d4406a31
 SHA512:
-  metadata.gz: b101685ebba2023302b266abe49603842d05af674e71e5b6c993539a01587c313033ef927f015de619c28f7e60986e51379cf32aac25a69b80dc903881ae51b3
-  data.tar.gz: 2e437e7403b573d7018727766da166d64cac78147d95bb355f46284d1cb65a2ba36115d578c7fa29c6d6e488e2fdd9914f504e06c3fe346f962cbb1938700145
+  metadata.gz: 66f61489f313fcaf4c3fe22486cd2e13307a9b9ab78e9a47a1f61e60928d65455b0691c52f3e3461930f052d41e53c7c5a5f57ff7eab12ed52b95025c89e52ba
+  data.tar.gz: 744f83c4d6211e7643f21f53d823490cc9e0235bd318f603c1b1a08e8cfda70d1e23a328287457b3591dc57ed9079e8b47ac150f546b5c56576c3228bf98d58a

data/README.md

@@ -445,9 +445,9 @@ Configuration:
 
 ## Other configurations
 
-### Default fixed fee for the FixedFeeEstimator
+### Default fixed fee for the FeeEstimator::Fixed
 
-The architecture of Glueby accepts any fee estimation strategies for paying transactions fee. However, we officially support only one strategy: the fixed fee strategy.
+The architecture of Glueby accepts any fee estimation strategies for paying transactions fee. However, we officially support only one strategy: the fixed fee strategy to contract transactions.
 It just returns a fixed fee value without any estimation.
 Here provides a configuration to modify the default fixed fee value it returns like this:
 
@@ -457,6 +457,19 @@ Glueby.configure do |config|
 end
 ```
 
+### Default fee rate for the FeeEstimator::Auto
+
+Glueby provide automate fee estimator `Glueby::Contract::FeeEstimator::Auto` that calculate minimum fee possible to broadcast from fee rate and tx size.
+This method can be used in UTXO provider's management task so far. In other place where creates txs is not tested with this yet.
+
+Here provides a configuration to modify the default fee rate it returns like this:
+
+```ruby
+Glueby.configure do |config|
+   config.default_fee_rate = 1_000
+end
+```
+
 ## Error handling
 
 Glueby has base error classes like `Glueby::Error` and `Glueby::ArgumentError`.

data/lib/glueby/configuration.rb

@@ -83,10 +83,16 @@ module Glueby
       UtxoProvider.configure(config)
     end
 
-    # Set default fixed fee to the FixedFeeEstimator
-    # @param [Integer] fee The default fee value in tapyrus to the FixedFeeEstimator
+    # Set default fixed fee to the FeeEstimator::Fixed
+    # @param [Integer] fee The default fee value in tapyrus to the FeeEstimator::Fixed
     def default_fixed_fee=(fee)
-      Contract::FixedFeeEstimator.default_fixed_fee = fee
+      Contract::FeeEstimator::Fixed.default_fixed_fee = fee
+    end
+
+    # Set default fee rate to the FeeEstimator::Auto
+    # @param [Integer] fee_rate The default fee rate in tapyrus/kB to the FeeEstimator::Auto
+    def default_fee_rate=(fee_rate)
+      Contract::FeeEstimator::Auto.default_fee_rate = fee_rate
     end
   end
 end

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

@@ -11,6 +11,8 @@ module Glueby
 
         belongs_to :prev, class_name: 'Glueby::Contract::AR::Timestamp', optional: true
 
+        validate :validate_prev
+
         class << self
           def digest_content(content, digest)
             case digest&.downcase
@@ -69,24 +71,29 @@ module Glueby
         end
 
         # Broadcast and save timestamp
-        # @param [Glueby::Contract::FixedFeeEstimator] fee_estimator
+        # @param [Glueby::Contract::FeeEstimator] fee_estimator
         # @param [Glueby::UtxoProvider] utxo_provider
         # @return true if tapyrus transactions were broadcasted and the timestamp was updated successfully, otherwise false.
-        def save_with_broadcast(fee_estimator: Glueby::Contract::FixedFeeEstimator.new, utxo_provider: nil)
+        def save_with_broadcast(fee_estimator: Glueby::Contract::FeeEstimator::Fixed.new, utxo_provider: nil)
           save_with_broadcast!(fee_estimator: fee_estimator, utxo_provider: utxo_provider)
-        rescue Errors::FailedToBroadcast, Errors::PrevTimestampNotFound, Errors::PrevTimestampIsNotTrackable => e
+        rescue Errors::FailedToBroadcast => e
           logger.error("failed to broadcast (id=#{id}, reason=#{e.message})")
           false
+        rescue Errors::ArgumentError => e
+          logger.info("failed to broadcast by argument error (id=#{id}, reason=#{e.message})")
+          false
         end
 
         # Broadcast and save timestamp, and it raises errors
-        # @param [Glueby::Contract::FixedFeeEstimator] fee_estimator
+        # @param [Glueby::Contract::FeeEstimator] fee_estimator
         # @param [Glueby::UtxoProvider] utxo_provider
         # @return true if tapyrus transactions were broadcasted and the timestamp was updated successfully
         # @raise [Glueby::Contract::Errors::FailedToBroadcast] If the broadcasting is failure
         # @raise [Glueby::Contract::Errors::PrevTimestampNotFound] If it is not available that the timestamp record which correspond with the prev_id attribute
         # @raise [Glueby::Contract::Errors::PrevTimestampIsNotTrackable] If the timestamp record by prev_id is not trackable
-        def save_with_broadcast!(fee_estimator: Glueby::Contract::FixedFeeEstimator.new, utxo_provider: nil)
+        # @raise [Glueby::Contract::Errors::PrevTimestampAlreadyUpdated] If the previous timestamp was already updated
+        def save_with_broadcast!(fee_estimator: Glueby::Contract::FeeEstimator::Fixed.new, utxo_provider: nil)
+          validate_prev!
           utxo_provider = Glueby::UtxoProvider.new if !utxo_provider && Glueby.configuration.use_utxo_provider?
 
           funding_tx, tx, p2c_address, payment_base = create_txs(fee_estimator, utxo_provider)
@@ -101,7 +108,7 @@ module Glueby
             wallet.internal_wallet.broadcast(tx) do |tx|
               assign_attributes(txid: tx.txid, status: :unconfirmed, p2c_address: p2c_address, payment_base: payment_base)
               @tx = tx
-              save!
+              save!(validate: false) # The validation is already executed at head of #save_with_broadcast!
 
               if update_trackable?
                 prev.latest = false
@@ -111,8 +118,7 @@ module Glueby
           end
           logger.info("timestamp tx was broadcasted (id=#{id}, txid=#{tx.txid})")
           true
-        rescue ActiveRecord::RecordInvalid,
-               Tapyrus::RPC::Error,
+        rescue Tapyrus::RPC::Error,
                Internal::Wallet::Errors::WalletAlreadyLoaded,
                Internal::Wallet::Errors::WalletNotFound,
                Errors::InsufficientFunds => e
@@ -130,18 +136,6 @@ module Glueby
           builder = builder_class.new(wallet, fee_estimator)
 
           if builder.instance_of?(Contract::Timestamp::TxBuilder::UpdatingTrackable)
-            unless prev
-              message = "The previous timestamp(id: #{prev_id}) not found."
-              errors.add(:prev_id, message)
-              raise Errors::PrevTimestampNotFound, message
-            end
-
-            unless prev.trackable?
-              message = "The previous timestamp(id: #{prev_id}) type must be trackable"
-              errors.add(:prev_id, message)
-              raise Errors::PrevTimestampIsNotTrackable, message
-            end
-
             builder.set_prev_timestamp_info(
               timestamp_utxo: prev.utxo,
               payment_base: prev.payment_base,
@@ -177,6 +171,41 @@ module Glueby
         def update_trackable?
           trackable? && prev_id
         end
+
+        def validate_prev
+          validate_prev!
+          true
+        rescue Errors::ArgumentError
+          false
+        end
+
+        def validate_prev!
+          if simple? && prev_id
+            message = "The previous timestamp(id: #{prev_id}) must be nil in simple timestamp"
+            errors.add(:prev_id, message)
+            raise Errors::UnnecessaryPrevTimestamp, message
+          end
+
+          return unless update_trackable?
+
+          unless prev
+            message = "The previous timestamp(id: #{prev_id}) not found."
+            errors.add(:prev_id, message)
+            raise Errors::PrevTimestampNotFound, message
+          end
+
+          unless prev.trackable?
+            message = "The previous timestamp(id: #{prev_id}) type must be trackable"
+            errors.add(:prev_id, message)
+            raise Errors::PrevTimestampIsNotTrackable, message
+          end
+
+          if new_record? && self.class.where(prev_id: prev_id).exists?
+            message = "The previous timestamp(id: #{prev_id}) was already updated"
+            errors.add(:prev_id, message)
+            raise Errors::PrevTimestampAlreadyUpdated, message
+          end
+        end
       end
     end
   end

data/lib/glueby/contract/errors.rb

@@ -17,6 +17,8 @@ module Glueby
       class UnsupportedDigestType < ArgumentError; end
       class PrevTimestampNotFound < ArgumentError; end
       class PrevTimestampIsNotTrackable < ArgumentError; end
+      class UnnecessaryPrevTimestamp < ArgumentError; end
+      class PrevTimestampAlreadyUpdated < ArgumentError; end
     end
   end
 end

data/lib/glueby/contract/fee_estimator/auto.rb

@@ -0,0 +1,34 @@
+module Glueby
+  module Contract
+    module FeeEstimator
+      # It calculates actual minimum fee to broadcast txs.
+      class Auto
+        include FeeEstimator
+
+        # This is same with Tapyrus Core's default min_relay_fee value.(tapyrus/kB)
+        DEFAULT_FEE_RATE = 1_000
+
+        # @!attribute [r] fee_rate
+        #  @return [Integer] the fee rate(tapyrus/kB) that is used actual fee calculation
+        attr_reader :fee_rate
+
+        class << self
+          # @!attribute [rw] default_fee_rate
+          #  @return [Integer] The global fee rate configuration. All instances use this value as the default.
+          attr_accessor :default_fee_rate
+        end
+
+        # @param [Integer] fee_rate
+        def initialize(fee_rate: Auto.default_fee_rate || DEFAULT_FEE_RATE)
+          @fee_rate = fee_rate
+        end
+
+        private
+
+        def estimate_fee(tx)
+          ((tx.to_payload.bytesize / 1000.0) * fee_rate).ceil
+        end
+      end
+    end
+  end
+end

data/lib/glueby/contract/fee_estimator/fixed.rb

@@ -0,0 +1,30 @@
+module Glueby
+  module Contract
+    module FeeEstimator
+      class Fixed
+        include FeeEstimator
+
+        # Default fee in tapyrus that is used if it is not configured
+        DEFAULT_FEE = 10_000
+
+        attr_reader :fixed_fee
+
+        class << self
+          attr_accessor :default_fixed_fee
+        end
+
+        def initialize(fixed_fee: Fixed.default_fixed_fee || DEFAULT_FEE)
+          @fixed_fee = fixed_fee
+        end
+
+        private
+
+        # @private
+        # @return fee by tapyrus(not TPC).
+        def estimate_fee(_tx)
+          @fixed_fee
+        end
+      end
+    end
+  end
+end

data/lib/glueby/contract/fee_estimator.rb

@@ -1,6 +1,9 @@
 module Glueby
   module Contract
     module FeeEstimator
+      autoload :Fixed, 'glueby/contract/fee_estimator/fixed'
+      autoload :Auto, 'glueby/contract/fee_estimator/auto'
+
       # @param [Tapyrus::Tx] tx - The target tx
       # @return fee by tapyrus(not TPC).
       def fee(tx)
@@ -8,37 +11,38 @@ module Glueby
         estimate_fee(tx)
       end
 
-      private
-
-      # @private
-      # @abstract Override in subclasses. This is would be implemented an actual estimation logic.
-      # @param [Tapyrus::Tx] tx - The target tx
-      # @return fee by tapyrus(not TPC).
-      def estimate_fee(tx)
-        raise NotImplementedError
-      end
-    end
-
-    class FixedFeeEstimator
-      include FeeEstimator
+      # Add dummy inputs and outputs to tx
+      def dummy_tx(tx)
+        dummy = Tapyrus::Tx.parse_from_payload(tx.to_payload)
 
-      attr_reader :fixed_fee
+        # dummy input for tpc
+        out_point = Tapyrus::OutPoint.new('00' * 32, 0)
+        dummy.inputs << Tapyrus::TxIn.new(out_point: out_point)
 
-      class << self
-        attr_accessor :default_fixed_fee
-      end
+        # Add script_sig to all intpus
+        dummy.inputs.each do |input|
+          input.script_sig = Tapyrus::Script.parse_from_payload('000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'.htb)
+        end
 
-      def initialize(fixed_fee: FixedFeeEstimator.default_fixed_fee || 10_000)
-        @fixed_fee = fixed_fee
+        # dummy output to return change
+        change_script = Tapyrus::Script.to_p2pkh('0000000000000000000000000000000000000000')
+        dummy.outputs << Tapyrus::TxOut.new(value: 0, script_pubkey: change_script)
+        dummy
       end
+      module_function :dummy_tx
 
       private
 
       # @private
+      # @abstract Override in subclasses. This is would be implemented an actual estimation logic.
+      # @param [Tapyrus::Tx] tx - The target tx
       # @return fee by tapyrus(not TPC).
-      def estimate_fee(_tx)
-        @fixed_fee
+      def estimate_fee(tx)
+        raise NotImplementedError
       end
     end
+
+    # Create alias name of FeeEstimator::Fixed class for backward compatibility
+    FixedFeeEstimator = FeeEstimator::Fixed
   end
 end

data/lib/glueby/contract/payment.rb

@@ -32,11 +32,11 @@ module Glueby
       extend Glueby::Contract::TxBuilder
 
       class << self
-        def transfer(sender:, receiver_address:, amount:, fee_estimator: FixedFeeEstimator.new)
+        def transfer(sender:, receiver_address:, amount:, fee_estimator: FeeEstimator::Fixed.new)
           raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
           tx = Tapyrus::Tx.new
-          dummy_fee = fee_estimator.fee(dummy_tx(tx))
+          dummy_fee = fee_estimator.fee(FeeEstimator.dummy_tx(tx))
 
           sum, outputs = sender.internal_wallet.collect_uncolored_outputs(dummy_fee + amount)
           fill_input(tx, outputs)

data/lib/glueby/contract/timestamp/tx_builder/simple.rb

@@ -55,7 +55,7 @@ module Glueby
           private
 
           def fee
-            @fee ||= @fee_estimator.fee(dummy_tx(@txb.build))
+            @fee ||= @fee_estimator.fee(FeeEstimator.dummy_tx(@txb.build))
           end
 
           def sign_tx

data/lib/glueby/contract/timestamp.rb

@@ -35,7 +35,7 @@ module Glueby
         wallet:,
         content:,
         prefix: '',
-        fee_estimator: Glueby::Contract::FixedFeeEstimator.new,
+        fee_estimator: Glueby::Contract::FeeEstimator::Fixed.new,
         digest: :sha256,
         utxo_provider: nil,
         timestamp_type: :simple,

data/lib/glueby/contract/tx_builder.rb

@@ -8,7 +8,7 @@ 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, need_value_for_change_output: false, only_finalized: true)
+      def create_funding_tx(wallet:, script: nil, fee_estimator: FeeEstimator::Fixed.new, need_value_for_change_output: false, only_finalized: true)
         if Glueby.configuration.use_utxo_provider?
           utxo_provider = UtxoProvider.new
           script_pubkey = script ? script : Tapyrus::Script.parse_from_addr(wallet.internal_wallet.receive_address)
@@ -16,7 +16,7 @@ module Glueby
           utxo_provider.wallet.sign_tx(funding_tx)
         else
           txb = Tapyrus::TxBuilder.new
-          fee = fee_estimator.fee(dummy_tx(txb.build))
+          fee = fee_estimator.fee(FeeEstimator.dummy_tx(txb.build))
           amount = fee + funding_tx_amount(need_value_for_change_output: need_value_for_change_output)
           sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(amount, nil, only_finalized)
           outputs.each do |utxo|
@@ -37,7 +37,7 @@ module Glueby
         end
       end
 
-      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, split: 1, fee_estimator: FixedFeeEstimator.new)
+      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, split: 1, fee_estimator: FeeEstimator::Fixed.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -50,7 +50,7 @@ module Glueby
 
         add_split_output(tx, amount, split, receiver_colored_script)
 
-        fee = fee_estimator.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(FeeEstimator.dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
         prev_txs = [{
           txid: funding_tx.txid,
@@ -61,15 +61,15 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_issue_tx_for_non_reissuable_token(funding_tx: nil, issuer:, amount:, split: 1, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
+      def create_issue_tx_for_non_reissuable_token(funding_tx: nil, issuer:, amount:, split: 1, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
         create_issue_tx_from_out_point(funding_tx: funding_tx, token_type: Tapyrus::Color::TokenTypes::NON_REISSUABLE, issuer: issuer, amount: amount, split: split, fee_estimator: fee_estimator, only_finalized: only_finalized)
       end
 
-      def create_issue_tx_for_nft_token(funding_tx: nil, issuer:, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
+      def create_issue_tx_for_nft_token(funding_tx: nil, issuer:, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
         create_issue_tx_from_out_point(funding_tx: funding_tx, token_type: Tapyrus::Color::TokenTypes::NFT, issuer: issuer, amount: 1, fee_estimator: fee_estimator, only_finalized: only_finalized)
       end
 
-      def create_issue_tx_from_out_point(funding_tx: nil, token_type:, issuer:, amount:, split: 1, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
+      def create_issue_tx_from_out_point(funding_tx: nil, token_type:, issuer:, amount:, split: 1, fee_estimator: FeeEstimator::Fixed.new, only_finalized: true)
         tx = Tapyrus::Tx.new
 
         fee = fee_estimator.fee(dummy_issue_tx_from_out_point)
@@ -111,7 +111,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, split: 1, fee_estimator: FixedFeeEstimator.new)
+      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, split: 1, fee_estimator: FeeEstimator::Fixed.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -122,7 +122,7 @@ module Glueby
         receiver_colored_script = receiver_script.add_color(color_id)
         add_split_output(tx, amount, split, receiver_colored_script)
 
-        fee = fee_estimator.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(FeeEstimator.dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
         prev_txs = [{
           txid: funding_tx.txid,
@@ -133,7 +133,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_transfer_tx(funding_tx:nil, color_id:, sender:, receiver_address:, amount:, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
+      def create_transfer_tx(funding_tx:nil, 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,
@@ -145,7 +145,7 @@ module Glueby
         )
       end
 
-      def create_multi_transfer_tx(funding_tx:nil, color_id:, sender:, receivers:, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
+      def create_multi_transfer_tx(funding_tx:nil, 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 }
@@ -161,7 +161,7 @@ module Glueby
 
         fill_change_token(tx, sender, sum_token - amount, color_id)
 
-        fee = fee_estimator.fee(dummy_tx(tx))
+        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)
@@ -187,7 +187,7 @@ module Glueby
         sender.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_burn_tx(funding_tx:nil, color_id:, sender:, amount: 0, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
+      def create_burn_tx(funding_tx:nil, 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)
@@ -196,7 +196,7 @@ module Glueby
 
         fill_change_token(tx, sender, sum_token - amount, color_id) if amount.positive?
 
-        fee = fee_estimator.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(FeeEstimator.dummy_tx(tx))
 
         sum_tpc = if funding_tx
           out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -281,45 +281,26 @@ module Glueby
         results
       end
 
-      # Add dummy inputs and outputs to tx
-      def dummy_tx(tx)
-        dummy = Tapyrus::Tx.parse_from_payload(tx.to_payload)
-
-        # dummy input for tpc
-        out_point = Tapyrus::OutPoint.new('00' * 32, 0)
-        dummy.inputs << Tapyrus::TxIn.new(out_point: out_point)
-
-        # Add script_sig to all intpus
-        dummy.inputs.each do |input|
-          input.script_sig = Tapyrus::Script.parse_from_payload('000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'.htb)
-        end
-
-        # dummy output to return change
-        change_script = Tapyrus::Script.to_p2pkh('0000000000000000000000000000000000000000')
-        dummy.outputs << Tapyrus::TxOut.new(value: 0, script_pubkey: change_script)
-        dummy
-      end
-
       # Add dummy inputs and outputs to tx for issue non-reissuable transaction and nft transaction
       def dummy_issue_tx_from_out_point
         tx = Tapyrus::Tx.new
         receiver_colored_script = Tapyrus::Script.parse_from_payload('21c20000000000000000000000000000000000000000000000000000000000000000bc76a914000000000000000000000000000000000000000088ac'.htb)
         tx.outputs << Tapyrus::TxOut.new(value: 0, script_pubkey: receiver_colored_script)
-        dummy_tx(tx)
+        FeeEstimator.dummy_tx(tx)
       end
 
       private
 
       # The amount of output in funding tx
-      # It returns same amount with FixedFeeEstimator's fixed fee. Because it is enough for paying fee for consumer
+      # 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
-          FixedFeeEstimator.new.fixed_fee + DUST_LIMIT
+          FeeEstimator::Fixed.new.fixed_fee + DUST_LIMIT
         else
-          FixedFeeEstimator.new.fixed_fee
+          FeeEstimator::Fixed.new.fixed_fee
         end
       end
     end

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

@@ -20,7 +20,7 @@ module Glueby
             tx.inputs.each.with_index do |input, index|
               script_pubkey = script_for_input(input, prevtxs)
               next unless script_pubkey
-              key = Key.key_for_script(script_pubkey)
+              key = keys.key_for_script(script_pubkey)
               next unless key
               sign_tx_for_p2pkh(tx, index, key, script_pubkey, sighashtype)
             end

data/lib/glueby/utxo_provider/tasks.rb

@@ -24,6 +24,7 @@ module Glueby
       # value is configurable by :default_value. This method do the management to the pool.
       def manage_utxo_pool
         txb = Tapyrus::TxBuilder.new
+        fee_estimator = utxo_provider.fee_estimator_for_manage
 
         sum, utxos = collect_outputs
         return if utxos.empty?
@@ -35,7 +36,7 @@ module Glueby
 
         added_outputs = 0
         shortage.times do
-          fee = utxo_provider.fee_estimator.fee(dummy_tx(txb.build))
+          fee = fee_estimator.fee(Contract::FeeEstimator.dummy_tx(txb.build))
           break if (sum - fee) < utxo_provider.default_value
           txb.pay(utxo_provider.address, utxo_provider.default_value)
           sum -= utxo_provider.default_value
@@ -44,7 +45,7 @@ module Glueby
 
         return if added_outputs == 0
 
-        fee = utxo_provider.fee_estimator.fee(dummy_tx(txb.build))
+        fee = fee_estimator.fee(Contract::FeeEstimator.dummy_tx(txb.build))
         tx = txb.change_address(utxo_provider.address)
                 .fee(fee)
                 .build

data/lib/glueby/utxo_provider.rb

@@ -16,6 +16,8 @@ module Glueby
       # @option config [Integer] :default_value 
       # @option opts [Integer] :utxo_pool_size
       # @option opts [Glueby::Contract::FeeEstimator] :fee_estimator
+      # @option opts [Glueby::Contract::FeeEstimator] :fee_estimator_for_manage It uses this estimator in glueby:utxo_provider:manage_utxo_pool rake task.
+      #                                                                         If it is nil, it uses same as :fee_estimator instead.
       def configure(config)
         @config = config
       end
@@ -24,10 +26,11 @@ module Glueby
     def initialize
       @wallet = load_wallet
       validate_config!
-      @fee_estimator = (UtxoProvider.config && UtxoProvider.config[:fee_estimator]) || Glueby::Contract::FixedFeeEstimator.new
+      @fee_estimator = (UtxoProvider.config && UtxoProvider.config[:fee_estimator]) || Glueby::Contract::FeeEstimator::Fixed.new
+      @fee_estimator_for_manage = UtxoProvider.config && UtxoProvider.config[:fee_estimator_for_manage] || @fee_estimator
     end
 
-    attr_reader :wallet, :fee_estimator, :address
+    attr_reader :wallet, :fee_estimator, :fee_estimator_for_manage, :address
 
     # Provide a UTXO
     # @param [Tapyrus::Script] script_pubkey The script to be provided
@@ -40,7 +43,7 @@ module Glueby
       txb = Tapyrus::TxBuilder.new
       txb.pay(script_pubkey.addresses.first, value)
 
-      fee = fee_estimator.fee(dummy_tx(txb.build))
+      fee = fee_estimator.fee(Contract::FeeEstimator.dummy_tx(txb.build))
       # The outputs need to be shuffled so that no utxos are spent twice as possible.
       sum, outputs = collect_uncolored_outputs(wallet, fee + value)
 

data/lib/glueby/version.rb

@@ -1,3 +1,3 @@
 module Glueby
-  VERSION = "0.10.1"
+  VERSION = "0.12.0"
 end

data/lib/tasks/glueby/contract/timestamp.rake

@@ -7,7 +7,7 @@ module Glueby
 
         def create
           timestamps = Glueby::Contract::AR::Timestamp.where(status: :init)
-          fee_estimator = Glueby::Contract::FixedFeeEstimator.new
+          fee_estimator = Glueby::Contract::FeeEstimator::Fixed.new
           timestamps.each { |t| t.save_with_broadcast(fee_estimator: fee_estimator) }
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glueby
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.12.0
 platform: ruby
 authors:
 - azuchi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-01 00:00:00.000000000 Z
+date: 2022-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tapyrus
@@ -110,6 +110,8 @@ files:
 - lib/glueby/contract/active_record/timestamp.rb
 - lib/glueby/contract/errors.rb
 - lib/glueby/contract/fee_estimator.rb
+- lib/glueby/contract/fee_estimator/auto.rb
+- lib/glueby/contract/fee_estimator/fixed.rb
 - lib/glueby/contract/payment.rb
 - lib/glueby/contract/timestamp.rb
 - lib/glueby/contract/timestamp/syncer.rb