glueby 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 165b5d6b9fc1cfae9bb7ba852632a0f099ef356bcb52fe0a9937b2c2d1289b51
-  data.tar.gz: 6d1a3b9cc1c3668a40ce11920af51cb8af8fc9d94163e43eca295a40d48889f0
+  metadata.gz: 5cae8a0e06be77affdb1895724a26137b5fde2bab8cc27fb73d9aa45f2c351c5
+  data.tar.gz: 2cc677f69e1cc1ad3e6468662e476b4bd5082b0e765f15f44b6b63426b2663f9
 SHA512:
-  metadata.gz: d7d6f4cf39f9b2c4580d1360817baa960bf72fe77075a038a7784b2f9191bb0cb9925c27d8b697c5d0a75e0d0bc31d35cfda14e3a88e18da88dba09e38aa5246
-  data.tar.gz: 691dd9cec6eb183f537c70efab553bd9224bea93fe21da6cb8ce2afea14549e74bd02fa8e73dd3518703b6b390f217d0b02ad3d85649b8eea4e6b6583c1fd196
+  metadata.gz: 3e0a80b28635f37a37b4d37eac3fc3bc697bfb3ce580a8c481c60e40fe7776bfcfcb24720d33771e5d73d19c745d03afbee7b380dedd3d0ec51b7258bbb9363b
+  data.tar.gz: fd3d0edae5b99212cea7e4a710dd8f52173e1b707617beb881e7f9715afac575e76d5abc18b291f7defa62c7acb4c4e5772163a0953126a2f3fcfeb6a72aa953

data/README.md

@@ -457,6 +457,11 @@ Glueby.configure do |config|
 end
 ```
 
+## Error handling
+
+Glueby has base error classes like `Glueby::Error` and `Glueby::ArgumentError`.
+`Glueby::Error` is the base class for the all errors that are raises in the glueby.
+`Glueby::ArgumentError` is the error class for argument errors in public contracts. This notifies the arguments is something wrong to glueby library user-side.
 
 ## Development
 

data/glueby.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'tapyrus', '>= 0.2.9'
+  spec.add_runtime_dependency 'tapyrus', '>= 0.2.13'
   spec.add_runtime_dependency 'activerecord', '~> 6.1.3'
   spec.add_development_dependency 'sqlite3'
   spec.add_development_dependency 'rails', '~> 6.1.3'

data/lib/glueby/active_record/system_information.rb

@@ -3,13 +3,100 @@ module Glueby
     class SystemInformation < ::ActiveRecord::Base
 
       def self.synced_block_height
-        SystemInformation.find_by(info_key: "synced_block_number")
+        find_by(info_key: "synced_block_number")
+      end
+
+      # Return if wallet allows to use only finalized utxo.
+      # @return [Boolean] true if wallet allows to use only finalized utxo, otherwise false.
+      def self.use_only_finalized_utxo?
+        find_by(info_key: "use_only_finalized_utxo")&.int_value != 0
+      end
+
+
+      # Set use_only_finalized_utxo
+      # @param [Boolean] status status of whether to use only finalized utxo
+      def self.set_use_only_finalized_utxo(status)
+        current = find_by(info_key: "use_only_finalized_utxo")
+        if current
+          current.update!(info_value: boolean_to_string(status))
+        else
+          create!(
+            info_key: "use_only_finalized_utxo", 
+            info_value: boolean_to_string(status)
+          )
+        end
+      end
+
+      # Return default value of the utxo provider
+      # @return [Integer] default value of utxo provider
+      def self.utxo_provider_default_value
+        find_by(info_key: "utxo_provider_default_value")&.int_value
+      end
+
+      # Set utxo_provider_default_value
+      # @param [Integer] value default value for utxo provider
+      def self.set_utxo_provider_default_value(value)
+        current = find_by(info_key: "utxo_provider_default_value")
+        if current
+          current.update!(info_value: value)
+        else
+          create!(
+            info_key: "utxo_provider_default_value", 
+            info_value: value
+          )
+        end
+      end
+
+      # Return pool size of the utxo provider
+      # @return [Integer] pool size of utxo provider
+      def self.utxo_provider_pool_size
+        find_by(info_key: "utxo_provider_pool_size")&.int_value
+      end
+
+      # Set utxo_provider_pool_size
+      # @param [Integer] size pool size of the utxo provider
+      def self.set_utxo_provider_pool_size(size)
+        current = find_by(info_key: "utxo_provider_pool_size")
+        if current
+          current.update!(info_value: size)
+        else
+          create!(
+            info_key: "utxo_provider_pool_size", 
+            info_value: size
+          )
+        end
+      end
+
+      # If return timestamp is to be executed immediately
+      # @return [Boolean] true status of broadcast_on_background
+      def self.broadcast_on_background?
+        find_by(info_key: "broadcast_on_background")&.int_value != 0
+      end
+
+      # Set the status of broadcast_on_background
+      # @param [Boolean] status status of broadcast_on_background
+      def self.set_broadcast_on_background(status)
+        current = find_by(info_key: "broadcast_on_background")
+        if current
+         current.update!(info_value: boolean_to_string(status))
+        else
+          create!(
+            info_key: "broadcast_on_background", 
+            info_value: boolean_to_string(status)
+          )
+        end
       end
 
       def int_value
         info_value.to_i
       end
 
+      private
+
+      def self.boolean_to_string(status)
+        status ? "1" : "0"
+      end
+
     end
   end
 end

data/lib/glueby/configuration.rb

@@ -15,7 +15,7 @@ module Glueby
     alias_method :use_utxo_provider?, :use_utxo_provider
 
     module Errors
-      class InvalidConfiguration < StandardError; end
+      class InvalidConfiguration < Error; end
     end
 
     def initialize

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

@@ -35,16 +35,16 @@ module Glueby
           if funding_tx
             ::ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
               wallet.internal_wallet.broadcast(funding_tx)
-              logger.info("funding tx was broadcasted(id=#{id}, funding_tx.txid=#{funding_tx.txid})")
             end
+            logger.info("funding tx was broadcasted(id=#{id}, funding_tx.txid=#{funding_tx.txid})")
           end
           ::ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
             wallet.internal_wallet.broadcast(tx) do |tx|
               assign_attributes(txid: tx.txid, status: :unconfirmed, p2c_address: p2c_address, payment_base: payment_base)
               save!
             end
-            logger.info("timestamp tx was broadcasted (id=#{id}, txid=#{tx.txid})")
           end
+          logger.info("timestamp tx was broadcasted (id=#{id}, txid=#{tx.txid})")
           true
         rescue => e
           logger.error("failed to broadcast (id=#{id}, reason=#{e.message})")

data/lib/glueby/contract/errors.rb

@@ -1,15 +1,18 @@
 module Glueby
   module Contract
     module Errors
-      class InsufficientFunds < StandardError; end
-      class InsufficientTokens < StandardError; end
-      class InvalidAmount < StandardError; end
-      class InvalidTokenType < StandardError; end
-      class InvalidTimestampType < StandardError; end
-      class TxAlreadyBroadcasted < StandardError; end
-      class UnsupportedTokenType < StandardError; end
-      class UnknownScriptPubkey < StandardError; end
-      class UnsupportedDigestType < StandardError; end
+      class InsufficientFunds < Error; end
+      class InsufficientTokens < Error; end
+      class TxAlreadyBroadcasted < Error; end
+
+      # Argument Errors
+      class InvalidAmount < ArgumentError; end
+      class InvalidSplit < ArgumentError; end
+      class InvalidTokenType < ArgumentError; end
+      class InvalidTimestampType < ArgumentError; end
+      class UnsupportedTokenType < ArgumentError; end
+      class UnknownScriptPubkey < ArgumentError; end
+      class UnsupportedDigestType < ArgumentError; end
     end
   end
 end

data/lib/glueby/contract/token.rb

@@ -56,18 +56,21 @@ module Glueby
         # @param issuer [Glueby::Wallet]
         # @param token_type [TokenTypes]
         # @param amount [Integer]
+        # @param split [Integer] The tx outputs should be split by specified number.
         # @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)
+        def issue!(issuer:, token_type: Tapyrus::Color::TokenTypes::REISSUABLE, amount: 1, split: 1)
           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)
+                           issue_reissuable_token(issuer: issuer, amount: amount, split: split)
                          when Tapyrus::Color::TokenTypes::NON_REISSUABLE
-                           issue_non_reissuable_token(issuer: issuer, amount: amount)
+                           issue_non_reissuable_token(issuer: issuer, amount: amount, split: split)
                          when Tapyrus::Color::TokenTypes::NFT
                            issue_nft_token(issuer: issuer)
                          else
@@ -77,29 +80,36 @@ module Glueby
           [new(color_id: color_id), txs]
         end
 
+        def only_finalized?
+          Glueby::AR::SystemInformation.use_only_finalized_utxo?
+        end
+
         private
 
-        def issue_reissuable_token(issuer:, amount:)
-          funding_tx = create_funding_tx(wallet: issuer)
+        def issue_reissuable_token(issuer:, amount:, split: 1)
+          funding_tx = create_funding_tx(wallet: issuer, only_finalized: only_finalized?)
           script_pubkey = funding_tx.outputs.first.script_pubkey
           color_id = Tapyrus::Color::ColorIdentifier.reissuable(script_pubkey)
 
+          ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+            funding_tx = issuer.internal_wallet.broadcast(funding_tx)
+          end
+
           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 = create_issue_tx_for_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount, split: split)
             tx = issuer.internal_wallet.broadcast(tx)
             [[funding_tx, tx], color_id]
           end
         end
 
-        def issue_non_reissuable_token(issuer:, amount:)
-          funding_tx = create_funding_tx(wallet: issuer) if Glueby.configuration.use_utxo_provider?
+        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
 
-          tx = create_issue_tx_for_non_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount)
+          tx = create_issue_tx_for_non_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount, split: split)
           tx = issuer.internal_wallet.broadcast(tx)
 
           out_point = tx.inputs.first.out_point
@@ -112,7 +122,7 @@ module Glueby
         end
 
         def issue_nft_token(issuer:)
-          funding_tx = create_funding_tx(wallet: issuer) if Glueby.configuration.use_utxo_provider?
+          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
 
           tx = create_issue_tx_for_nft_token(funding_tx: funding_tx, issuer: issuer)
@@ -134,19 +144,20 @@ module Glueby
       # A wallet can issue the token only when it is REISSUABLE token.
       # @param issuer [Glueby::Wallet]
       # @param amount [Integer]
+      # @param split [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.
       # @raise [UnknownScriptPubkey] when token is reissuable but it doesn't know script pubkey to issue token.
-      def reissue!(issuer:, amount:)
+      def reissue!(issuer:, amount:, split: 1)
         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)
+          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)
+          tx = create_reissue_tx(funding_tx: funding_tx, issuer: issuer, amount: amount, color_id: color_id, split: split)
           tx = issuer.internal_wallet.broadcast(tx)
 
           [color_id, tx]
@@ -167,10 +178,17 @@ module Glueby
       def transfer!(sender:, receiver_address:, amount: 1)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-        funding_tx = create_funding_tx(wallet: sender) if Glueby.configuration.use_utxo_provider?
+        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)
+        tx = create_transfer_tx(
+          funding_tx: funding_tx,
+          color_id: color_id,
+          sender: sender,
+          receiver_address: receiver_address,
+          amount: amount,
+          only_finalized: only_finalized?
+        )
         sender.internal_wallet.broadcast(tx)
         [color_id, tx]
       end
@@ -187,10 +205,16 @@ module Glueby
         receivers.each do |r|
           raise Glueby::Contract::Errors::InvalidAmount unless r[:amount].positive?
         end
-        funding_tx = create_funding_tx(wallet: sender) if Glueby.configuration.use_utxo_provider?
+        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)
+        tx = create_multi_transfer_tx(
+          funding_tx: funding_tx,
+          color_id: color_id,
+          sender: sender,
+          receivers: receivers,
+          only_finalized: only_finalized?
+        )
         sender.internal_wallet.broadcast(tx)
         [color_id, tx]
       end
@@ -205,7 +229,7 @@ module Glueby
       # @raise [InvalidAmount] if amount is not positive integer.
       def burn!(sender:, amount: 0)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
-        balance = sender.balances[color_id.to_hex]
+        balance = sender.balances(only_finalized?)[color_id.to_hex]
         raise Glueby::Contract::Errors::InsufficientTokens unless balance
         raise Glueby::Contract::Errors::InsufficientTokens if balance < amount
 
@@ -219,13 +243,14 @@ module Glueby
             # 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
+            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)
+        tx = create_burn_tx(funding_tx: funding_tx, color_id: color_id, sender: sender, amount: amount, only_finalized: only_finalized?)
         sender.internal_wallet.broadcast(tx)
       end
 
@@ -234,7 +259,7 @@ module Glueby
       # @return [Integer] amount of utxo value associated with this token.
       def amount(wallet:)
         # collect utxo associated with this address
-        utxos = wallet.internal_wallet.list_unspent
+        utxos = wallet.internal_wallet.list_unspent(only_finalized?)
         _, results = collect_colored_outputs(utxos, color_id)
         results.sum { |result| result[:amount] }
       end
@@ -282,6 +307,10 @@ module Glueby
 
       private
 
+      def only_finalized?
+        @only_finalized ||= Token.only_finalized?
+      end
+
       # Verify that wallet is the issuer of the reissuable token
       #　reutrn [Boolean]
       def validate_reissuer(wallet:)

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)
+      def create_funding_tx(wallet:, script: nil, fee_estimator: FixedFeeEstimator.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)
@@ -17,8 +17,8 @@ module Glueby
         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(need_value_for_change_output: need_value_for_change_output))
+          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|
             txb.add_utxo({
               script_pubkey: Tapyrus::Script.parse_from_payload(utxo[:script_pubkey].htb),
@@ -37,7 +37,7 @@ module Glueby
         end
       end
 
-      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
+      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, split: 1, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -47,7 +47,8 @@ module Glueby
         receiver_script = Tapyrus::Script.parse_from_payload(output.script_pubkey.to_payload)
         color_id = Tapyrus::Color::ColorIdentifier.reissuable(receiver_script)
         receiver_colored_script = receiver_script.add_color(color_id)
-        tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
+
+        add_split_output(tx, amount, split, receiver_colored_script)
 
         fee = fee_estimator.fee(dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
@@ -60,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:, 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)
+      def create_issue_tx_for_non_reissuable_token(funding_tx: nil, issuer:, amount:, split: 1, fee_estimator: FixedFeeEstimator.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)
-        create_issue_tx_from_out_point(funding_tx: funding_tx, 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, 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:, fee_estimator: FixedFeeEstimator.new)
+      def create_issue_tx_from_out_point(funding_tx: nil, token_type:, issuer:, amount:, split: 1, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
         tx = Tapyrus::Tx.new
 
         fee = fee_estimator.fee(dummy_issue_tx_from_out_point)
@@ -77,7 +78,7 @@ module Glueby
           tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
           funding_tx.outputs.first.value
         else
-          sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee)
+          sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee, nil, only_finalized)
           fill_input(tx, outputs)
           sum
         end
@@ -93,7 +94,7 @@ module Glueby
 
         receiver_script = Tapyrus::Script.parse_from_addr(issuer.internal_wallet.receive_address)
         receiver_colored_script = receiver_script.add_color(color_id)
-        tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
+        add_split_output(tx, amount, split, receiver_colored_script)
 
         fill_change_tpc(tx, issuer, sum - fee)
         prev_txs = if funding_tx
@@ -110,7 +111,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_estimator: FixedFeeEstimator.new)
+      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, split: 1, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -119,7 +120,7 @@ module Glueby
 
         receiver_script = Tapyrus::Script.parse_from_payload(output.script_pubkey.to_payload)
         receiver_colored_script = receiver_script.add_color(color_id)
-        tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
+        add_split_output(tx, amount, split, receiver_colored_script)
 
         fee = fee_estimator.fee(dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
@@ -132,16 +133,23 @@ 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)
+      def create_transfer_tx(funding_tx:nil, color_id:, sender:, receiver_address:, amount:, fee_estimator: FixedFeeEstimator.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, fee_estimator: fee_estimator)
+        create_multi_transfer_tx(
+          funding_tx: funding_tx,
+          color_id: color_id,
+          sender: sender,
+          receivers: receivers,
+          fee_estimator: fee_estimator,
+          only_finalized: only_finalized
+        )
       end
 
-      def create_multi_transfer_tx(funding_tx:nil, color_id:, sender:, receivers:, fee_estimator: FixedFeeEstimator.new)
+      def create_multi_transfer_tx(funding_tx:nil, color_id:, sender:, receivers:, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
         tx = Tapyrus::Tx.new
 
         amount = receivers.reduce(0) { |sum, r| sum + r[:amount].to_i }
-        utxos = sender.internal_wallet.list_unspent
+        utxos = sender.internal_wallet.list_unspent(only_finalized)
         sum_token, outputs = collect_colored_outputs(utxos, color_id, amount)
         fill_input(tx, outputs)
 
@@ -159,7 +167,7 @@ module Glueby
           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)
+          sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee, nil, only_finalized)
           fill_input(tx, outputs)
           sum_tpc
         end
@@ -179,10 +187,10 @@ 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)
+      def create_burn_tx(funding_tx:nil, color_id:, sender:, amount: 0, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
         tx = Tapyrus::Tx.new
 
-        utxos = sender.internal_wallet.list_unspent
+        utxos = sender.internal_wallet.list_unspent(only_finalized)
         sum_token, outputs = collect_colored_outputs(utxos, color_id, amount)
         fill_input(tx, outputs)
 
@@ -195,7 +203,7 @@ module Glueby
           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 + DUST_LIMIT)
+          sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee + DUST_LIMIT, nil, only_finalized)
           fill_input(tx, outputs)
           sum_tpc
         end
@@ -215,6 +223,17 @@ module Glueby
         sender.internal_wallet.sign_tx(tx, prev_txs)
       end
 
+      def add_split_output(tx, amount, split, script_pubkey)
+        if amount < split
+          split = amount
+          value = 1
+        else
+          value = (amount/split).to_i
+        end
+        (split - 1).times { tx.outputs << Tapyrus::TxOut.new(value: value, script_pubkey: script_pubkey) }
+        tx.outputs << Tapyrus::TxOut.new(value: amount - value * (split - 1), script_pubkey: script_pubkey)
+      end
+
       def fill_input(tx, outputs)
         outputs.each do |output|
           out_point = Tapyrus::OutPoint.new(output[:txid].rhex, output[:vout])

data/lib/glueby/fee_provider.rb

@@ -3,7 +3,7 @@ module Glueby
 
     autoload :Tasks, 'glueby/fee_provider/tasks'
 
-    class NoUtxosInUtxoPool < StandardError; end
+    class NoUtxosInUtxoPool < Error; end
 
     WALLET_ID = 'FEE_PROVIDER_WALLET'
     DEFAULT_FIXED_FEE = 1000
@@ -42,7 +42,7 @@ module Glueby
     # 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::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|

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

@@ -2,12 +2,12 @@ module Glueby
   module Internal
     class Wallet
       module Errors
-        class ShouldInitializeWalletAdapter < StandardError; end
-        class WalletUnloaded < StandardError; end
-        class WalletAlreadyLoaded < StandardError; end
-        class WalletAlreadyCreated < StandardError; end
-        class WalletNotFound < StandardError; end
-        class InvalidSighashType < StandardError; end
+        class ShouldInitializeWalletAdapter < Error; end
+        class WalletUnloaded < Error; end
+        class WalletAlreadyLoaded < Error; end
+        class WalletAlreadyCreated < Error; end
+        class WalletNotFound < Error; end
+        class InvalidSighashType < Error; end
       end
     end
   end

data/lib/glueby/utxo_provider/tasks.rb

@@ -30,14 +30,14 @@ module Glueby
 
         utxos.each { |utxo| txb.add_utxo(utxo) }
 
-        shortage = [utxo_provider.utxo_pool_size - current_utxo_pool_size, 0].max
+        shortage = [utxo_provider.utxo_pool_size - utxo_provider.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)
+          txb.pay(utxo_provider.address, utxo_provider.default_value)
           sum -= utxo_provider.default_value
           added_outputs += 1
         end
@@ -45,11 +45,11 @@ module Glueby
         return if added_outputs == 0
 
         fee = utxo_provider.fee_estimator.fee(dummy_tx(txb.build))
-        tx = txb.change_address(address)
+        tx = txb.change_address(utxo_provider.address)
                 .fee(fee)
                 .build
-        tx = wallet.sign_tx(tx)
-        wallet.broadcast(tx)
+        tx = utxo_provider.wallet.sign_tx(tx)
+        utxo_provider.wallet.broadcast(tx)
       ensure
         status
       end
@@ -58,13 +58,13 @@ module Glueby
       def status
         status = :ready
 
-        if current_utxo_pool_size < utxo_provider.utxo_pool_size
-          if tpc_amount < value_to_fill_utxo_pool
+        if utxo_provider.current_utxo_pool_size < utxo_provider.utxo_pool_size
+          if utxo_provider.tpc_amount < utxo_provider.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 '#{address}'
+              UtxoProvider needs #{utxo_provider.value_to_fill_utxo_pool} tapyrus in UTXO pool. 
+              UtxoProvider wallet's address is '#{utxo_provider.address}'
             2. Then create UTXOs for paying in UTXO pool with 'rake glueby:utxo_provider:manage_utxo_pool'
             MESSAGE
           else
@@ -72,12 +72,12 @@ module Glueby
           end
         end
 
-        status = :not_ready if current_utxo_pool_size == 0
+        status = :not_ready if utxo_provider.current_utxo_pool_size == 0
 
         puts <<~EOS
         Status: #{STATUS[status]}
-        TPC amount: #{delimit(tpc_amount)}
-        UTXO pool size: #{delimit(current_utxo_pool_size)}
+        TPC amount: #{delimit(utxo_provider.tpc_amount)}
+        UTXO pool size: #{delimit(utxo_provider.current_utxo_pool_size)}
         #{"\n" if message}#{message}
         Configuration:
           default_value = #{delimit(utxo_provider.default_value)}
@@ -87,17 +87,13 @@ module Glueby
 
       # Show the address of Utxo Provider 
       def print_address
-        puts address
+        puts utxo_provider.address
       end
 
       private
 
-      def tpc_amount
-        wallet.balance(false)
-      end
-
       def collect_outputs
-        wallet.list_unspent.inject([0, []]) do |sum, output|
+        utxo_provider.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]
@@ -105,34 +101,16 @@ module Glueby
             txid: output[:txid],
             script_pubkey: output[:script_pubkey],
             value: output[:amount],
-            index: output[:vout] ,
+            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
-
-      def address
-        @address ||= wallet.get_addresses.first || wallet.receive_address
-      end
     end
   end
 end

data/lib/glueby/utxo_provider.rb

@@ -25,11 +25,9 @@ module Glueby
       @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 
+    attr_reader :wallet, :fee_estimator, :address
 
     # Provide a UTXO
     # @param [Tapyrus::Script] script_pubkey The script to be provided
@@ -62,6 +60,42 @@ module Glueby
       [signed_tx, 0]
     end
 
+    def default_value
+      @default_value ||=
+        (
+          Glueby::AR::SystemInformation.utxo_provider_default_value ||
+            (UtxoProvider.config && UtxoProvider.config[:default_value]) ||
+            DEFAULT_VALUE
+        )
+    end
+
+    def utxo_pool_size
+      @utxo_pool_size ||=
+        (
+          Glueby::AR::SystemInformation.utxo_provider_pool_size ||
+            (UtxoProvider.config && UtxoProvider.config[:utxo_pool_size]) ||
+            DEFAULT_UTXO_POOL_SIZE
+        )
+    end
+
+    def tpc_amount
+      wallet.balance(false)
+    end
+
+    def current_utxo_pool_size
+      wallet
+        .list_unspent(false)
+        .count { |o| !o[:color_id] && o[:amount] == default_value }
+    end
+
+    def address
+      @address ||= wallet.get_addresses.first || wallet.receive_address
+    end
+
+    def value_to_fill_utxo_pool
+      default_value * utxo_pool_size
+    end
+
     private
 
     # Create wallet for provider
@@ -74,7 +108,7 @@ module Glueby
     end
 
     def collect_uncolored_outputs(wallet, amount)
-      utxos = wallet.list_unspent.select { |o| !o[:color_id] && o[:amount] == @default_value }
+      utxos = wallet.list_unspent.select { |o| !o[:color_id] && o[:amount] == default_value }
       utxos.shuffle!
 
       utxos.inject([0, []]) do |sum, output|
@@ -88,11 +122,8 @@ module Glueby
     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
+      if !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

data/lib/glueby/version.rb

@@ -1,3 +1,3 @@
 module Glueby
-  VERSION = "0.7.0"
+  VERSION = "0.9.0"
 end

data/lib/glueby.rb

@@ -48,4 +48,9 @@ module Glueby
   def self.configure
     yield configuration if block_given?
   end
+
+  # Base error classes. These error classes must be used as a super class in all error classes that is defined and
+  # raised in glueby library.
+  class Error < StandardError; end
+  class ArgumentError < Error; end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glueby
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - azuchi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-25 00:00:00.000000000 Z
+date: 2022-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tapyrus
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.9
+        version: 0.2.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.9
+        version: 0.2.13
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement