glueby 0.6.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd80045038551e7ffc41a613fb67401f3675c79098222e335359209070ff280a
-  data.tar.gz: f966a44bb7de60429e91d39681f63c6b827dbcb8806700cbfe6b5e961f013b2d
+  metadata.gz: e2f53ca4e5784495dc9ddc7669bc021985614b3719205247c42005ec5d12a5c4
+  data.tar.gz: d5bb0540f3db7cf5ccdb96d4487ff627c4090f69e8719f746badae31689f864d
 SHA512:
-  metadata.gz: 4e443a845c4d65eeba06c83d40617497b984f8a0c158e54debb1ac82d762af53ebba8073e8fc18855f93816370dc8969657bec8d8e95d5990df3fe50c9c7471a
-  data.tar.gz: 2c5f2670b48f6a1149052b239d89c626c323e21f222bd2deb201074b96d54ac935080624cb92a2399414aed03de44258a41da5b0fc4ecc5221d854ef201c06de
+  metadata.gz: 037ac4f566439facb0971a34c086bb128afd4b00566b7ab0f9013d4b4c357082c88a620eb8262221a245586429387228811e940077868b254b1ec82d155de8ab
+  data.tar.gz: 9a031d6505750f550abe9948ff977cd01f4fbcad8ab9b733f0b322101cc77d9856c6d2e3f633e61c9e49b4657dc7f286db1abdd4df0511cedf96dba9c27a2d3d

data/lib/glueby/active_record/system_information.rb

@@ -3,7 +3,25 @@ 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
+
+      # 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
+
+      # 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
 
       def int_value

data/lib/glueby/constants.rb

@@ -0,0 +1,4 @@
+module Glueby
+  # The minimum limit of transaction output value to avoid to be recognized as a dust output.
+  DUST_LIMIT = 600
+end

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

@@ -2,7 +2,10 @@ module Glueby
   module Contract
     module AR
       class Timestamp < ::ActiveRecord::Base
+        include Glueby::GluebyLogger
         include Glueby::Contract::Timestamp::Util
+        include Glueby::Contract::TxBuilder
+
         enum status: { init: 0, unconfirmed: 1, confirmed: 2 }
         enum timestamp_type: { simple: 0, trackable: 1 }
 
@@ -21,6 +24,33 @@ module Glueby
         def latest
           trackable?
         end
+
+        # Broadcast and save timestamp
+        # @param [Glueby::Contract::FixedFeeEstimator] fee_estimator
+        # @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 = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
+          wallet = Glueby::Wallet.load(wallet_id)
+          funding_tx, tx, p2c_address, payment_base = create_txs(wallet, prefix, content_hash, fee_estimator, utxo_provider, type: timestamp_type.to_sym)
+          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
+          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
+          true
+        rescue => e
+          logger.error("failed to broadcast (id=#{id}, reason=#{e.message})")
+          errors.add(:base, "failed to broadcast (id=#{id}, reason=#{e.message})")
+          false
+        end
       end
     end
   end

data/lib/glueby/contract/errors.rb

@@ -4,6 +4,7 @@ module Glueby
       class InsufficientFunds < StandardError; end
       class InsufficientTokens < StandardError; end
       class InvalidAmount < StandardError; end
+      class InvalidSplit < StandardError; end
       class InvalidTokenType < StandardError; end
       class InvalidTimestampType < StandardError; end
       class TxAlreadyBroadcasted < StandardError; end

data/lib/glueby/contract/fee_estimator.rb

@@ -22,6 +22,8 @@ module Glueby
     class FixedFeeEstimator
       include FeeEstimator
 
+      attr_reader :fixed_fee
+
       class << self
         attr_accessor :default_fixed_fee
       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,11 +80,14 @@ 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:)
-          utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
-          funding_tx = create_funding_tx(wallet: issuer, utxo_provider: utxo_provider)
+        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)
 
@@ -90,18 +96,17 @@ module Glueby
             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:)
-          utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
-          funding_tx = create_funding_tx(wallet: issuer, utxo_provider: utxo_provider) if 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
@@ -114,8 +119,7 @@ module Glueby
         end
 
         def issue_nft_token(issuer:)
-          utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
-          funding_tx = create_funding_tx(wallet: issuer, utxo_provider: utxo_provider) if 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)
@@ -137,20 +141,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
-        utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
 
         if validate_reissuer(wallet: issuer)
-          funding_tx = create_funding_tx(wallet: issuer, script: @script_pubkey, utxo_provider: utxo_provider)
+          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]
@@ -171,11 +175,43 @@ module Glueby
       def transfer!(sender:, receiver_address:, amount: 1)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-        utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
-        funding_tx = create_funding_tx(wallet: sender, utxo_provider: utxo_provider) if 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,
+          only_finalized: only_finalized?
+        )
+        sender.internal_wallet.broadcast(tx)
+        [color_id, tx]
+      end
+
+      # Send the tokens to multiple wallets
+      #
+      # @param sender [Glueby::Wallet] wallet to send this token
+      # @param receivers [Array<Hash>] array of hash, which keys are :address and :amount
+      # @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:)
+        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_transfer_tx(funding_tx: funding_tx, color_id: color_id, sender: sender, receiver_address: receiver_address, amount: amount)
+        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
@@ -190,12 +226,28 @@ 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(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?
-        funding_tx = create_funding_tx(wallet: sender, utxo_provider: utxo_provider) if 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)
+        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
 
@@ -204,7 +256,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
@@ -252,6 +304,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

@@ -3,24 +3,22 @@
 module Glueby
   module Contract
     module TxBuilder
-      # The amount of output in funding tx for Reissuable token.
-      FUNDING_TX_AMOUNT = 10_000
-
       def receive_address(wallet:)
         wallet.receive_address
       end
 
       # Create new public key, and new transaction that sends TPC to it
-      def create_funding_tx(wallet:, script: nil, fee_estimator: FixedFeeEstimator.new, utxo_provider: nil)
-        if utxo_provider
+      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)
-          funding_tx, _index = utxo_provider.get_utxo(script_pubkey, FUNDING_TX_AMOUNT)
+          funding_tx, _index = utxo_provider.get_utxo(script_pubkey, funding_tx_amount(need_value_for_change_output: need_value_for_change_output))
           utxo_provider.wallet.sign_tx(funding_tx)
         else
           txb = Tapyrus::TxBuilder.new
           fee = fee_estimator.fee(dummy_tx(txb.build))
-
-          sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee + FUNDING_TX_AMOUNT)
+          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),
@@ -31,7 +29,7 @@ module Glueby
           end
   
           receiver_address = script ? script.addresses.first : wallet.internal_wallet.receive_address
-          tx = txb.pay(receiver_address, FUNDING_TX_AMOUNT)
+          tx = txb.pay(receiver_address, funding_tx_amount)
             .change_address(wallet.internal_wallet.change_address)
             .fee(fee)
             .build
@@ -39,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)
@@ -49,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)
@@ -62,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)
@@ -79,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
@@ -95,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
@@ -112,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)
@@ -121,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)
@@ -134,16 +133,31 @@ 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,
+          only_finalized: only_finalized
+        )
+      end
+
+      def create_multi_transfer_tx(funding_tx:nil, color_id:, sender:, receivers:, fee_estimator: FixedFeeEstimator.new, only_finalized: true)
         tx = Tapyrus::Tx.new
 
-        utxos = sender.internal_wallet.list_unspent
+        amount = receivers.reduce(0) { |sum, r| sum + r[:amount].to_i }
+        utxos = sender.internal_wallet.list_unspent(only_finalized)
         sum_token, outputs = collect_colored_outputs(utxos, color_id, amount)
         fill_input(tx, outputs)
 
-        receiver_script = Tapyrus::Script.parse_from_addr(receiver_address)
-        receiver_colored_script = receiver_script.add_color(color_id)
-        tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
+        receivers.each do |r|
+          receiver_script = Tapyrus::Script.parse_from_addr(r[:address])
+          receiver_colored_script = receiver_script.add_color(color_id)
+          tx.outputs << Tapyrus::TxOut.new(value: r[:amount].to_i, script_pubkey: receiver_colored_script)
+        end
 
         fill_change_token(tx, sender, sum_token - amount, color_id)
 
@@ -153,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
@@ -173,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)
 
@@ -189,8 +203,7 @@ module Glueby
           tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
           funding_tx.outputs.first.value
         else
-          dust = 600 # in case that the wallet has output which has just fee amount.
-          sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee + dust)
+          sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee + DUST_LIMIT, nil, only_finalized)
           fill_input(tx, outputs)
           sum_tpc
         end
@@ -210,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])
@@ -220,7 +244,12 @@ module Glueby
       def fill_change_tpc(tx, wallet, change)
         return unless change.positive?
 
-        change_script = Tapyrus::Script.parse_from_addr(wallet.internal_wallet.change_address)
+        if Glueby.configuration.use_utxo_provider?
+          change_script = Tapyrus::Script.parse_from_addr(UtxoProvider.new.wallet.change_address)
+        else
+          change_script = Tapyrus::Script.parse_from_addr(wallet.internal_wallet.change_address)
+        end
+
         tx.outputs << Tapyrus::TxOut.new(value: change, script_pubkey: change_script)
       end
 
@@ -278,6 +307,21 @@ module Glueby
         tx.outputs << Tapyrus::TxOut.new(value: 0, script_pubkey: receiver_colored_script)
         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
+      # 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
+        else
+          FixedFeeEstimator.new.fixed_fee
+        end
+      end
     end
   end
 end

data/lib/glueby/utxo_provider/tasks.rb

@@ -29,7 +29,6 @@ module Glueby
         return if utxos.empty?
 
         utxos.each { |utxo| txb.add_utxo(utxo) }
-        address = wallet.receive_address
 
         shortage = [utxo_provider.utxo_pool_size - current_utxo_pool_size, 0].max
         return if shortage == 0
@@ -65,7 +64,7 @@ module Glueby
             message = <<~MESSAGE
             1. Please replenishment TPC which is for paying tpc to UtxoProvider. 
               UtxoProvider needs #{value_to_fill_utxo_pool} tapyrus in UTXO pool. 
-              UtxoProvider wallet's address is '#{wallet.receive_address}'
+              UtxoProvider wallet's address is '#{address}'
             2. Then create UTXOs for paying in UTXO pool with 'rake glueby:utxo_provider:manage_utxo_pool'
             MESSAGE
           else
@@ -88,7 +87,7 @@ module Glueby
 
       # Show the address of Utxo Provider 
       def print_address
-        puts wallet.receive_address
+        puts address
       end
 
       private
@@ -130,6 +129,10 @@ module Glueby
       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
 
     # Provide a UTXO
     # @param [Tapyrus::Script] script_pubkey The script to be provided
@@ -62,6 +60,24 @@ 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
+
     private
 
     # Create wallet for provider
@@ -74,7 +90,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 +104,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.6.2"
+  VERSION = "0.8.0"
 end

data/lib/glueby.rb

@@ -1,4 +1,5 @@
 require "glueby/version"
+require "glueby/constants"
 require 'tapyrus'
 
 module Glueby
@@ -16,6 +17,16 @@ module Glueby
     require 'glueby/railtie'
   end
 
+  module GluebyLogger
+    def logger
+      if defined?(Rails)
+        Rails.logger
+      else
+        Logger.new(STDOUT)
+      end
+    end
+  end
+
   # Add prefix to activerecord table names
   def self.table_name_prefix
     'glueby_'

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

@@ -8,27 +8,8 @@ module Glueby
 
         def create
           timestamps = Glueby::Contract::AR::Timestamp.where(status: :init)
-          utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
-          timestamps.each do |t|
-            begin
-              wallet = Glueby::Wallet.load(t.wallet_id)
-              funding_tx, tx, p2c_address, payment_base = create_txs(wallet, t.prefix, t.content_hash, Glueby::Contract::FixedFeeEstimator.new, utxo_provider, type: t.timestamp_type.to_sym)
-              if funding_tx
-                ::ActiveRecord::Base.transaction do
-                  wallet.internal_wallet.broadcast(funding_tx)
-                  puts "funding tx was broadcasted(id=#{t.id}, funding_tx.txid=#{funding_tx.txid})"
-                end
-              end
-              ::ActiveRecord::Base.transaction do
-                wallet.internal_wallet.broadcast(tx) do |tx|
-                  t.update(txid: tx.txid, status: :unconfirmed, p2c_address: p2c_address, payment_base: payment_base)
-                end
-                puts "timestamp tx was broadcasted (id=#{t.id}, txid=#{tx.txid})"
-              end
-            rescue => e
-              puts "failed to broadcast (id=#{t.id}, reason=#{e.message})"
-            end
-          end
+          fee_estimator = Glueby::Contract::FixedFeeEstimator.new
+          timestamps.each { |t| t.save_with_broadcast(fee_estimator: fee_estimator) }
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glueby
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.8.0
 platform: ruby
 authors:
 - azuchi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-15 00:00:00.000000000 Z
+date: 2022-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tapyrus
@@ -103,6 +103,7 @@ files:
 - lib/glueby/active_record/system_information.rb
 - lib/glueby/block_syncer.rb
 - lib/glueby/configuration.rb
+- lib/glueby/constants.rb
 - lib/glueby/contract.rb
 - lib/glueby/contract/active_record.rb
 - lib/glueby/contract/active_record/reissuable_token.rb