glueby 0.4.2 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbaba6627d1c34e6a2de2a3861016995481ad53163764a057c25fca123a8750b
-  data.tar.gz: 209020a3b503ac44cc9d4ef51e95d7ce71f17af59b92ffe3bb4863b4ae750604
+  metadata.gz: 37c10a4359a509cd4f86c35726161717bde07bc1ce459e19b0ba4c053e8dba86
+  data.tar.gz: 3cd0124ed69e0f34d1adf4ff5ed26005979689befc163c970b104245f267a479
 SHA512:
-  metadata.gz: 559e4f224359df179cafc4f20c19f3f7c9723f6411103532ad6fd7d9727b5063c369b44e4e6c7872bc49d9355ec0cedd4f720c195302546cab7a5e5b429f6676
-  data.tar.gz: b4a4a1641820f23513ea56e1c240db966bcb9b0d62fd463d54f08e09f454125cdca4a087bc8db8c9b0181cd867ee667ec1b2bf5fbe1b95329541b3dd5fe2538b
+  metadata.gz: 68729802e9bcb1a51148c12daa1e1565180c300d43cc811c2c512056804ad2fb8cd0bd8dd0e0d915e19da2177b3a47a941a4911ce7f6376a47f598edade087fe
+  data.tar.gz: 902c5c0cf87cb940c9619e5f9af95367187a009ddc01d74a6604c22d8e9df9e50dec50df24455c6fb2f0a1a9020869e4d619bd879802739ba04118bf600fab6a

data/README.md

@@ -27,6 +27,10 @@ Glueby has below features.
    FeeProvider module can bear payments of sender's fees. You should provide funds for fees to FeeProvider before use.  
    See how to set up at [Use fee provider mode](#use-fee-provider-mode)
 
+5. Utxo Provider
+   The UtxoProvider allows users to create a variety of transactions without having to manage the TPCs they hold in their wallets.
+   See more details at [Use utxo provider](#use-utxo-provider)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -223,6 +227,9 @@ Glueby.configure do |config|
   config.wallet_adapter = :activerecord
   config.rpc_config = { schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass' }
 end
+
+# Uncomment next line when using timestamp feature
+# Glueby::BlockSyncer.register_syncer(Glueby::Contract::Timestamp::Syncer)
 ```
 
 If you use timestamp feature, use `glueby:contract:timestamp` generator.
@@ -293,6 +300,7 @@ Glueby.configure do |config|
     # The fee that Fee Provider pays on each transaction.
     fixed_fee: 1000,
     # Fee Provider tries to keep the number of utxo in utxo pool as this size using `glueby:fee_provider:manage_utxo_pool` rake task
+    # This size should not be greater than 2000.
     utxo_pool_size: 20 
   }
 end
@@ -365,6 +373,77 @@ Configuration:
   utxo_pool_size = 20
 ```
 
+## Use Utxo Provider
+
+UtxoProvider will pay TPC on behalf of the user.
+
+TPCs are required to create transactions in many cases where Glueby is used, such as issuing tokens or recording timestamps.
+However, on the other hand, each user may not want to fund or manage TPCs.
+
+The UtxoProvider allows users to create a variety of transactions without having to manage the TPCs they hold in their wallets.
+
+### Set up Utxo Provider
+
+1. Configure using Glueby.configure
+
+```ruby
+Glueby.configure do |config|
+  # using Utxo Provider
+  config.enable_utxo_provider!
+
+  # If not using Utxo Provider and each wallet manages TPCs by itself (Default behavior)
+  # config.disable_utxo_provider!
+
+  config.utxo_provider_config = {
+    # The amount that each utxo in utxo pool posses.
+    default_value: 1_000,
+    # The number of utxos in utxo pool. This size should not be greater than 2000.
+    utxo_pool_size: 20
+  }
+end
+```
+
+2. Deposit TPC into Utxo Provider's wallet
+
+Get an address from the wallet, and send enough TPCs to the address.
+
+```
+$ bundle exec rake glueby:utxo_provider:address
+mqYTLdLCUCCZkTkcpbVx1GqpvV1gK4euRD
+```
+
+3. Manage UTXO pool
+
+Run the rake task `glueby:utxo_provider:manage_utxo_pool`
+This rake task tries to split UTOXs up to `utxo_pool_size`. If the pool has more than `utxo_pool_size` UTXOs, it does nothing
+
+```
+$ bundle exec rake glueby:utxo_provider:manage_utxo_pool
+
+Status: Ready
+TPC amount: 4_999_990_000
+UTXO pool size: 20
+
+Configuration:
+  default_value = 1_000
+  utxo_pool_size = 20
+```
+
+If you want to get the status information, you can use the `status` task.
+
+```
+$ bundle exec rake glueby:utxo_provider:status
+Status: Ready  q
+TPC amount: 4_999_990_000
+UTXO pool size: 20
+
+Configuration:
+  default_value = 1_000
+  utxo_pool_size = 20
+
+```
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/glueby.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency 'tapyrus', '>= 0.2.9'
-  spec.add_runtime_dependency 'activerecord'
+  spec.add_runtime_dependency 'activerecord', '~> 6.1.3'
   spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'rails', '~> 6.1.3'
 end

data/lib/generators/glueby/contract/templates/initializer.rb.erb

@@ -3,3 +3,6 @@ Glueby.configure do |config|
   config.wallet_adapter = :activerecord
   config.rpc_config = { schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass' }
 end
+
+# Uncomment next line when using timestamp feature
+# Glueby::BlockSyncer.register_syncer(Glueby::Contract::Timestamp::Syncer)

data/lib/glueby/configuration.rb

@@ -10,11 +10,17 @@ module Glueby
   #     end
   class Configuration
 
-    attr_reader :fee_provider_bears
+    attr_reader :fee_provider_bears, :use_utxo_provider
     alias_method :fee_provider_bears?, :fee_provider_bears
+    alias_method :use_utxo_provider?, :use_utxo_provider
+
+    module Errors
+      class InvalidConfiguration < StandardError; end
+    end
 
     def initialize
       @fee_provider_bears = false
+      @use_utxo_provider = false
     end
 
     # Specify wallet adapter.
@@ -54,9 +60,27 @@ module Glueby
     # Specify FeeProvider configuration.
     # @param [Hash] config
     # @option config [Integer] :fixed_fee - The fee that Fee Provider pays on each transaction.
-    # @option config [Integer] :utxo_pool_size - Fee Provider tries to keep the number of utxo in utxo pool as this size using `glueby:fee_provider:manage_utxo_pool` rake task
+    # @option config [Integer] :utxo_pool_size - Fee Provider tries to keep the number of utxo in utxo pool as this size using `glueby:fee_provider:manage_utxo_pool` rake task. this size should not be greater than 2000.
     def fee_provider_config=(config)
       FeeProvider.configure(config)
     end
+
+    # Enable UtxoProvider feature
+    def enable_utxo_provider!
+      @use_utxo_provider = true
+    end
+
+    # Disable UtxoProvider feature
+    def disable_utxo_provider!
+      @use_utxo_provider = false
+    end
+
+    # Set UtxoProvider configuration
+    # @param [Hash] config
+    # @option config [Integer] :default_value - The fee that Fee Provider pays on each transaction.
+    # @option config [Integer] :utxo_pool_size - Utxo Provider tries to keep the number of utxo in utxo pool as this size using `glueby:utxo_provider:manage_utxo_pool` rake task. this size should not be greater than 2000.
+    def utxo_provider_config=(config)
+      UtxoProvider.configure(config)
+    end
   end
 end

data/lib/glueby/contract/timestamp.rb

@@ -16,30 +16,45 @@ module Glueby
         include Glueby::Internal::Wallet::TapyrusCoreWalletAdapter::Util
         module_function
 
-        def create_tx(wallet, prefix, data, fee_estimator)
-          tx = Tapyrus::Tx.new
-          tx.outputs << Tapyrus::TxOut.new(value: 0, script_pubkey: create_script(prefix, data))
-  
-          fee = fee_estimator.fee(dummy_tx(tx))
-          sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee)
-          fill_input(tx, outputs)
-  
-          fill_change_tpc(tx, wallet, sum - fee)
-          wallet.internal_wallet.sign_tx(tx)
-        end
-  
-        def create_payload(prefix, data)
-          payload = +''
-          payload << prefix
-          payload << data
-          payload
-        end
+        def create_txs(wallet, prefix, data, fee_estimator, utxo_provider)
+          txb = Tapyrus::TxBuilder.new
+          txb.data(prefix + data)
+          fee = fee_estimator.fee(dummy_tx(txb.build))
+          if utxo_provider
+            script_pubkey = Tapyrus::Script.parse_from_addr(wallet.internal_wallet.receive_address)
+            funding_tx, index = utxo_provider.get_utxo(script_pubkey, fee)
+            txb.add_utxo({
+              script_pubkey: funding_tx.outputs[index].script_pubkey,
+              txid: funding_tx.txid,
+              index: index,
+              value: funding_tx.outputs[index].value
+            })
+          else
+            sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee)
+            outputs.each do |utxo|
+              txb.add_utxo({
+                script_pubkey: Tapyrus::Script.parse_from_payload(utxo[:script_pubkey].htb),
+                txid: utxo[:txid],
+                index: utxo[:vout],
+                value: utxo[:amount]
+              })
+            end
+          end
+
+          prev_txs = if funding_tx
+            output = funding_tx.outputs.first
+            [{
+              txid: funding_tx.txid,
+              vout: 0,
+              scriptPubKey: output.script_pubkey.to_hex,
+              amount: output.value
+            }]
+          else
+            []
+          end
 
-        def create_script(prefix, data)
-          script = Tapyrus::Script.new
-          script << Tapyrus::Script::OP_RETURN
-          script << create_payload(prefix, data)
-          script
+          txb.fee(fee).change_address(wallet.internal_wallet.change_address)
+          [funding_tx, wallet.internal_wallet.sign_tx(txb.build, prev_txs)]
         end
 
         def get_transaction(tx)
@@ -63,13 +78,15 @@ module Glueby
         content:,
         prefix: '',
         fee_estimator: Glueby::Contract::FixedFeeEstimator.new,
-        digest: :sha256
+        digest: :sha256,
+        utxo_provider: nil
       )
         @wallet = wallet
         @content = content
         @prefix = prefix
         @fee_estimator = fee_estimator
         @digest = digest
+        @utxo_provider = utxo_provider
       end
 
       # broadcast to Tapyrus Core
@@ -79,7 +96,8 @@ module Glueby
       def save!
         raise Glueby::Contract::Errors::TxAlreadyBroadcasted if @txid
 
-        @tx = create_tx(@wallet, @prefix, digest_content, @fee_estimator)
+        funding_tx, @tx = create_txs(@wallet, @prefix, digest_content, @fee_estimator, @utxo_provider)
+        @wallet.internal_wallet.broadcast(funding_tx) if funding_tx
         @txid = @wallet.internal_wallet.broadcast(@tx)
       end
 

data/lib/glueby/contract/token.rb

@@ -80,7 +80,8 @@ module Glueby
         private
 
         def issue_reissuable_token(issuer:, amount:)
-          funding_tx = create_funding_tx(wallet: issuer)
+          utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
+          funding_tx = create_funding_tx(wallet: issuer, utxo_provider: utxo_provider)
           script_pubkey = funding_tx.outputs.first.script_pubkey
           color_id = Tapyrus::Color::ColorIdentifier.reissuable(script_pubkey)
 
@@ -96,21 +97,37 @@ module Glueby
         end
 
         def issue_non_reissuable_token(issuer:, amount:)
-          tx = create_issue_tx_for_non_reissuable_token(issuer: issuer, amount: 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
+          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 = issuer.internal_wallet.broadcast(tx)
 
           out_point = tx.inputs.first.out_point
           color_id = Tapyrus::Color::ColorIdentifier.non_reissuable(out_point)
-          [[tx], color_id]
+          if funding_tx
+            [[funding_tx, tx], color_id]
+          else
+            [[tx], color_id]
+          end
         end
 
         def issue_nft_token(issuer:)
-          tx = create_issue_tx_for_nft_token(issuer: 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 = issuer.internal_wallet.broadcast(funding_tx) if funding_tx
+
+          tx = create_issue_tx_for_nft_token(funding_tx: funding_tx, issuer: issuer)
           tx = issuer.internal_wallet.broadcast(tx)
 
           out_point = tx.inputs.first.out_point
           color_id = Tapyrus::Color::ColorIdentifier.nft(out_point)
-          [[tx], color_id]
+          if funding_tx
+            [[funding_tx, tx], color_id]
+          else
+            [[tx], color_id]
+          end
         end
       end
 
@@ -128,9 +145,10 @@ module Glueby
       def reissue!(issuer:, amount:)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
         raise Glueby::Contract::Errors::InvalidTokenType unless token_type == Tapyrus::Color::TokenTypes::REISSUABLE
+        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)
+          funding_tx = create_funding_tx(wallet: issuer, script: @script_pubkey, utxo_provider: utxo_provider)
           funding_tx = issuer.internal_wallet.broadcast(funding_tx)
           tx = create_reissue_tx(funding_tx: funding_tx, issuer: issuer, amount: amount, color_id: color_id)
           tx = issuer.internal_wallet.broadcast(tx)
@@ -153,7 +171,11 @@ module Glueby
       def transfer!(sender:, receiver_address:, amount: 1)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-        tx = create_transfer_tx(color_id: color_id, sender: sender, receiver_address: receiver_address, amount: amount)
+        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 = 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)
         sender.internal_wallet.broadcast(tx)
         [color_id, tx]
       end
@@ -169,7 +191,11 @@ module Glueby
       def burn!(sender:, amount: 0)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-        tx = create_burn_tx(color_id: color_id, sender: sender, amount: amount)
+        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 = 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)
         sender.internal_wallet.broadcast(tx)
       end
 

data/lib/glueby/contract/tx_builder.rb

@@ -11,18 +11,32 @@ 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)
-        tx = Tapyrus::Tx.new
-        fee = fee_estimator.fee(dummy_tx(tx))
-
-        sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee + FUNDING_TX_AMOUNT)
-        fill_input(tx, outputs)
-
-        receiver_script = script ? script : Tapyrus::Script.parse_from_addr(wallet.internal_wallet.receive_address)
-        tx.outputs << Tapyrus::TxOut.new(value: FUNDING_TX_AMOUNT, script_pubkey: receiver_script)
-
-        fill_change_tpc(tx, wallet, sum - fee - FUNDING_TX_AMOUNT)
-        wallet.internal_wallet.sign_tx(tx)
+      def create_funding_tx(wallet:, script: nil, fee_estimator: FixedFeeEstimator.new, utxo_provider: nil)
+        if utxo_provider
+          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)
+          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)
+          outputs.each do |utxo|
+            txb.add_utxo({
+              script_pubkey: Tapyrus::Script.parse_from_payload(utxo[:script_pubkey].htb),
+              txid: utxo[:txid],
+              index: utxo[:vout],
+              value: utxo[:amount]
+            })
+          end
+  
+          receiver_address = script ? script.addresses.first : wallet.internal_wallet.receive_address
+          tx = txb.pay(receiver_address, FUNDING_TX_AMOUNT)
+            .change_address(wallet.internal_wallet.change_address)
+            .fee(fee)
+            .build
+          wallet.internal_wallet.sign_tx(tx)
+        end
       end
 
       def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
@@ -48,21 +62,27 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_issue_tx_for_non_reissuable_token(issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NON_REISSUABLE, issuer: issuer, amount: amount, fee_estimator: fee_estimator)
+      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)
       end
 
-      def create_issue_tx_for_nft_token(issuer:, fee_estimator: FixedFeeEstimator.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NFT, issuer: issuer, amount: 1, fee_estimator: fee_estimator)
+      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)
       end
 
-      def create_issue_tx_from_out_point(token_type:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
+      def create_issue_tx_from_out_point(funding_tx: nil, token_type:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         fee = fee_estimator.fee(dummy_issue_tx_from_out_point)
-        sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee)
-        fill_input(tx, outputs)
-
+        sum = if funding_tx
+          out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
+          tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+          funding_tx.outputs.first.value
+        else
+          sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee)
+          fill_input(tx, outputs)
+          sum
+        end
         out_point = tx.inputs.first.out_point
         color_id = case token_type
         when Tapyrus::Color::TokenTypes::NON_REISSUABLE
@@ -78,7 +98,18 @@ module Glueby
         tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
 
         fill_change_tpc(tx, issuer, sum - fee)
-        issuer.internal_wallet.sign_tx(tx)
+        prev_txs = if funding_tx
+          output = funding_tx.outputs.first
+          [{
+            txid: funding_tx.txid,
+            vout: 0,
+            scriptPubKey: output.script_pubkey.to_hex,
+            amount: output.value
+          }]
+        else
+          []
+        end
+        issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
       def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_estimator: FixedFeeEstimator.new)
@@ -103,7 +134,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_transfer_tx(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)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
@@ -117,14 +148,32 @@ module Glueby
         fill_change_token(tx, sender, sum_token - amount, color_id)
 
         fee = fee_estimator.fee(dummy_tx(tx))
-        sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee)
-        fill_input(tx, outputs)
+        sum_tpc = if funding_tx
+          out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
+          tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+          funding_tx.outputs.first.value
+        else
+          sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee)
+          fill_input(tx, outputs)
+          sum_tpc
+        end
 
         fill_change_tpc(tx, sender, sum_tpc - fee)
-        sender.internal_wallet.sign_tx(tx)
+        prev_txs = if funding_tx
+          output = funding_tx.outputs.first
+          [{
+            txid: funding_tx.txid,
+            vout: 0,
+            scriptPubKey: output.script_pubkey.to_hex,
+            amount: output.value
+          }]
+        else
+          []
+        end
+        sender.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_burn_tx(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)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
@@ -135,12 +184,30 @@ module Glueby
 
         fee = fee_estimator.fee(dummy_tx(tx))
 
-        dust = 600 # in case that the wallet has output which has just fee amount.
-        sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee + dust)
-        fill_input(tx, outputs)
+        sum_tpc = if funding_tx
+          out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
+          tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+          funding_tx.outputs.first.value
+        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)
+          fill_input(tx, outputs)
+          sum_tpc
+        end
 
         fill_change_tpc(tx, sender, sum_tpc - fee)
-        sender.internal_wallet.sign_tx(tx)
+        prev_txs = if funding_tx
+          output = funding_tx.outputs.first
+          [{
+            txid: funding_tx.txid,
+            vout: 0,
+            scriptPubKey: output.script_pubkey.to_hex,
+            amount: output.value
+          }]
+        else
+          []
+        end
+        sender.internal_wallet.sign_tx(tx, prev_txs)
       end
 
       def fill_input(tx, outputs)

data/lib/glueby/fee_provider/tasks.rb

@@ -81,7 +81,7 @@ module Glueby
       end
 
       # Show the address of Fee Provider 
-      def address
+      def print_address
         puts wallet.receive_address
       end
 

data/lib/glueby/fee_provider.rb

@@ -8,6 +8,7 @@ module Glueby
     WALLET_ID = 'FEE_PROVIDER_WALLET'
     DEFAULT_FIXED_FEE = 1000
     DEFAULT_UTXO_POOL_SIZE = 20
+    MAX_UTXO_POOL_SIZE = 2_000
 
     attr_reader :fixed_fee, :utxo_pool_size, :wallet,
 
@@ -33,6 +34,7 @@ module Glueby
                   Internal::Wallet.create(WALLET_ID)
                 end
 
+      validate_config!
       @fixed_fee = (FeeProvider.config && FeeProvider.config[:fixed_fee]) || DEFAULT_FIXED_FEE
       @utxo_pool_size = (FeeProvider.config && FeeProvider.config[:utxo_pool_size]) || DEFAULT_UTXO_POOL_SIZE
     end
@@ -69,5 +71,14 @@ module Glueby
     def get_signature(script_sig)
       script_sig.chunks.first.pushed_data
     end
+
+    def validate_config!
+      if FeeProvider.config
+        utxo_pool_size = FeeProvider.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
+      end
+    end
   end
 end

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

@@ -72,6 +72,8 @@ module Glueby
         # @param [Boolean] only_finalized - The UTXOs includes only finalized UTXO value if it
         #                                   is true. Default is true.
         # @param [String] label - Label for filtering UTXOs
+        #                       - If label is nil or :unlabeled, only unlabeled UTXOs will be returned.
+        #                       - If label=:all, it will return all utxos
         # @return [Array of UTXO]
         #
         # ## The UTXO structure
@@ -101,8 +103,10 @@ module Glueby
         #
         # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
         # @param [Tapyrus::Tx] tx - The transaction to be broadcasterd.
+        # @yield Option. If a block given, the block is called before actual broadcasting.
+        #   @yieldparam [Tapyrus::Tx] tx - The tx that is going to be broadcasted as is.
         # @return [String] txid
-        def broadcast(wallet_id, tx)
+        def broadcast(wallet_id, tx, &block)
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         end
 

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

@@ -93,8 +93,15 @@ module Glueby
           wallet = AR::Wallet.find_by(wallet_id: wallet_id)
           utxos = wallet.utxos
           utxos = utxos.where(status: :finalized) if only_finalized
-          utxos = utxos.where(label: label) if label && (label != :unlabeled)
-          utxos = utxos.where(label: nil) if label == :unlabeled
+
+          if [:unlabeled, nil].include?(label)
+            utxos = utxos.where(label: nil)
+          elsif label && (label != :all)
+            utxos = utxos.where(label: label)
+          else
+            utxos
+          end
+
           utxos.map do |utxo|
             {
               txid: utxo.txid,
@@ -102,7 +109,8 @@ module Glueby
               script_pubkey: utxo.script_pubkey,
               color_id: utxo.color_id,
               amount: utxo.value,
-              finalized: utxo.status == 'finalized'
+              finalized: utxo.status == 'finalized',
+              label: utxo.label
             }
           end
         end
@@ -112,10 +120,11 @@ module Glueby
           wallet.sign(tx, prevtxs, sighashtype: sighashtype)
         end
 
-        def broadcast(wallet_id, tx)
+        def broadcast(wallet_id, tx, &block)
           ::ActiveRecord::Base.transaction do
             AR::Utxo.destroy_for_inputs(tx)
             AR::Utxo.create_or_update_for_outputs(tx, status: :broadcasted)
+            block.call(tx) if block
             Glueby::Internal::RPC.client.sendrawtransaction(tx.to_hex)
           end
         end

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

@@ -23,7 +23,6 @@ module Glueby
         include Glueby::Internal::Wallet::TapyrusCoreWalletAdapter::Util
 
         WALLET_PREFIX = 'wallet-'
-        ADDRESS_TYPE = 'legacy'
 
         RPC_WALLET_ERROR_ERROR_CODE = -4 # Unspecified problem with wallet (key not found etc.)
         RPC_WALLET_NOT_FOUND_ERROR_CODE = -18 # Invalid wallet specified
@@ -83,14 +82,21 @@ module Glueby
           end
         end
 
+        # If label=nil, it will return unlabeled utxos to protect labeled utxos for specific purpose
+        # If label=:all, it will return all utxos
         def list_unspent(wallet_id, only_finalized = true, label = nil)
           perform_as(wallet_id) do |client|
             min_conf = only_finalized ? 1 : 0
             res = client.listunspent(min_conf)
 
-            res = res.filter { |i| i['label'] == label } if label && (label != :unlabeled)
-            res = res.filter { |i| i['label'] == "" } if label == :unlabeled
- 
+            if [:unlabeled, nil].include?(label)
+              res = res.filter { |i| i['label'] == "" }
+            elsif label && (label != :all)
+              res = res.filter { |i| i['label'] == label }
+            else
+              res
+            end
+
             res.map do |i|
               script = Tapyrus::Script.parse_from_payload(i['scriptPubKey'].htb)
               color_id = if script.cp2pkh? || script.cp2sh?
@@ -102,7 +108,8 @@ module Glueby
                 script_pubkey: i['scriptPubKey'],
                 color_id: color_id,
                 amount: tpc_to_tapyrus(i['amount']),
-                finalized: i['confirmations'] != 0
+                finalized: i['confirmations'] != 0,
+                label: i['label']
               }
             end
           end
@@ -119,27 +126,28 @@ module Glueby
           end
         end
 
-        def broadcast(wallet_id, tx)
+        def broadcast(wallet_id, tx, &block)
           perform_as(wallet_id) do |client|
+            block.call(tx) if block
             client.sendrawtransaction(tx.to_hex)
           end
         end
 
         def receive_address(wallet_id, label = nil)
           perform_as(wallet_id) do |client|
-            client.getnewaddress(label || '', ADDRESS_TYPE)
+            client.getnewaddress(label || '')
           end
         end
 
         def change_address(wallet_id)
           perform_as(wallet_id) do |client|
-            client.getrawchangeaddress(ADDRESS_TYPE)
+            client.getrawchangeaddress
           end
         end
 
         def create_pubkey(wallet_id)
           perform_as(wallet_id) do |client|
-            address = client.getnewaddress('', ADDRESS_TYPE)
+            address = client.getnewaddress('')
             info = client.getaddressinfo(address)
             Tapyrus::Key.new(pubkey: info['pubkey'])
           end

data/lib/glueby/internal/wallet.rb

@@ -84,9 +84,10 @@ module Glueby
 
       # @param only_finalized [Boolean] The flag to get a UTXO with status only finalized
       # @param label [String] This label is used to filtered the UTXOs with labeled if a key or Utxo is labeled.
-      #                    - If label is not specified (label=nil), all UTXOs will be returned.
-      #                    - If label=:unlabeled, only unlabeled UTXOs will be returned.
-      def list_unspent(only_finalized = true, label = nil)
+      #                    - If label is nil or :unlabeled, only unlabeled UTXOs will be returned.
+      #                    - If label=:all, all UTXOs will be returned.
+      def list_unspent(only_finalized = true, label = :unlabeled)
+        label = :unlabeled unless label
         wallet_adapter.list_unspent(id, only_finalized, label)
       end
 
@@ -117,10 +118,7 @@ module Glueby
       # @param [Proc] block The block that is called before broadcasting. It can be used to handle tx that is modified by FeeProvider.
       def broadcast(tx, without_fee_provider: false, &block)
         tx = FeeProvider.provide(tx) if !without_fee_provider && Glueby.configuration.fee_provider_bears?
-
-        block.call(tx) if block
-
-        wallet_adapter.broadcast(id, tx)
+        wallet_adapter.broadcast(id, tx, &block)
         tx
       end
 
@@ -136,8 +134,9 @@ module Glueby
         wallet_adapter.create_pubkey(id)
       end
 
-      def collect_uncolored_outputs(amount, label = nil)
-        utxos = list_unspent(true, label)
+      def collect_uncolored_outputs(amount, label = nil, only_finalized = true, shuffle = false)
+        utxos = list_unspent(only_finalized, label)
+        utxos.shuffle! if shuffle
 
         utxos.inject([0, []]) do |sum, output|
           next sum if output[:color_id]

data/lib/glueby/railtie.rb

@@ -1,14 +1,11 @@
 module Glueby
   class Railtie < ::Rails::Railtie
-    initializer "glueby.register_syncers" do
-      BlockSyncer.register_syncer(Contract::Timestamp::Syncer)
-    end
-
     rake_tasks do
       load "tasks/glueby/contract.rake"
       load "tasks/glueby/contract/timestamp.rake"
       load "tasks/glueby/block_syncer.rake"
       load "tasks/glueby/fee_provider.rake"
+      load "tasks/glueby/utxo_provider.rake"
     end
   end
 end

data/lib/glueby/utxo_provider/tasks.rb

@@ -0,0 +1,135 @@
+module Glueby
+  class UtxoProvider
+    class Tasks
+      include Glueby::Contract::TxBuilder
+
+      attr_reader :utxo_provider
+
+      STATUS = {
+        # UtxoProvider is ready to pay tpcs.
+        ready: 'Ready',
+        # UtxoProvider is ready to pay tpcs, but it doesn't have enough amount to fill the UTXO pool by UTXOs which is for paying tpcs.
+        insufficient_amount: 'Insufficient Amount',
+        # UtxoProvider is not ready to pay tpcs. It has no UTXOs for paying amounts.
+        not_ready: 'Not Ready'
+      }
+
+      def initialize
+        @utxo_provider = Glueby::UtxoProvider.new
+      end
+
+      # Create UTXOs for paying tpc
+      #
+      # UtxoProvider have the UTXO pool. the pool is manged to keep some number of UTXOs that have fixed value. The
+      # value is configurable by :default_value. This method do the management to the pool.
+      def manage_utxo_pool
+        txb = Tapyrus::TxBuilder.new
+
+        sum, utxos = collect_outputs
+        return if utxos.empty?
+
+        utxos.each { |utxo| txb.add_utxo(utxo) }
+        address = wallet.receive_address
+
+        shortage = [utxo_provider.utxo_pool_size - 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)
+          sum -= utxo_provider.default_value
+          added_outputs += 1
+        end
+
+        return if added_outputs == 0
+
+        fee = utxo_provider.fee_estimator.fee(dummy_tx(txb.build))
+        tx = txb.change_address(address)
+                .fee(fee)
+                .build
+        tx = wallet.sign_tx(tx)
+        wallet.broadcast(tx)
+      ensure
+        status
+      end
+
+      # Show the status of the UTXO pool
+      def status
+        status = :ready
+
+        if current_utxo_pool_size < utxo_provider.utxo_pool_size
+          if tpc_amount < value_to_fill_utxo_pool
+            status = :insufficient_amount
+            message = <<~MESSAGE
+            1. Please replenishment TPC which is for paying tpc to UtxoProvider. 
+              UtxoProvider needs #{value_to_fill_utxo_pool} tapyrus in UTXO pool. 
+              UtxoProvider wallet's address is '#{wallet.receive_address}'
+            2. Then create UTXOs for paying in UTXO pool with 'rake glueby:utxo_provider:manage_utxo_pool'
+            MESSAGE
+          else
+            message = "Please create UTXOs for paying in UTXO pool with 'rake glueby:utxo_provider:manage_utxo_pool'\n"
+          end
+        end
+
+        status = :not_ready if current_utxo_pool_size == 0
+
+        puts <<~EOS
+        Status: #{STATUS[status]}
+        TPC amount: #{delimit(tpc_amount)}
+        UTXO pool size: #{delimit(current_utxo_pool_size)}
+        #{"\n" if message}#{message}
+        Configuration:
+          default_value = #{delimit(utxo_provider.default_value)}
+          utxo_pool_size = #{delimit(utxo_provider.utxo_pool_size)}
+        EOS
+      end
+
+      # Show the address of Utxo Provider 
+      def print_address
+        puts wallet.receive_address
+      end
+
+      private
+
+      def tpc_amount
+        wallet.balance(false)
+      end
+
+      def collect_outputs
+        wallet.list_unspent.inject([0, []]) do |sum, output|
+          next sum if output[:color_id] || output[:amount] == utxo_provider.default_value
+
+          new_sum = sum[0] + output[:amount]
+          new_outputs = sum[1] << {
+            txid: output[:txid],
+            script_pubkey: output[:script_pubkey],
+            value: output[:amount],
+            index: output[:vout] ,
+            finalized: output[:finalized]
+          }
+          [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
+    end
+  end
+end

data/lib/glueby/utxo_provider.rb

@@ -0,0 +1,85 @@
+module Glueby
+  class UtxoProvider
+    include Glueby::Contract::TxBuilder
+
+    autoload :Tasks, 'glueby/utxo_provider/tasks'
+
+    WALLET_ID = 'UTXO_PROVIDER_WALLET'
+    DEFAULT_VALUE = 1_000
+    DEFAULT_UTXO_POOL_SIZE = 20
+    MAX_UTXO_POOL_SIZE = 2_000
+
+    class << self
+      attr_reader :config
+
+      # @param [Hash] config
+      # @option config [Integer] :default_value 
+      # @option opts [Integer] :utxo_pool_size
+      # @option opts [Glueby::Contract::FeeEstimator] :fee_estimator
+      def configure(config)
+        @config = config
+      end
+    end
+
+    def initialize
+      @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 
+
+    # Provide a UTXO
+    # @param [Tapyrus::Script] script_pubkey The script to be provided
+    # @param [Integer] value The tpc amount to be provided
+    # @return [Array<(Tapyrus::Tx, Integer)>]
+    #  The tx that has a UTXO to be provided in its outputs.
+    #  The output index in the tx to indicate the place of a provided UTXO.
+    # @raise [Glueby::Contract::Errors::InsufficientFunds] if provider does not have any utxo which has specified value.
+    def get_utxo(script_pubkey, value = DEFAULT_VALUE)
+      txb = Tapyrus::TxBuilder.new
+      txb.pay(script_pubkey.addresses.first, value)
+
+      fee = fee_estimator.fee(dummy_tx(txb.build))
+      # The outputs need to be shuffled so that no utxos are spent twice as possible.
+      sum, outputs = wallet.collect_uncolored_outputs(fee + value, nil, true, true)
+
+      outputs.each do |utxo|
+        txb.add_utxo({
+          script_pubkey: Tapyrus::Script.parse_from_payload(utxo[:script_pubkey].htb),
+          txid: utxo[:txid],
+          index: utxo[:vout],
+          value: utxo[:amount]
+        })
+      end
+
+      txb.fee(fee).change_address(wallet.change_address)
+
+      tx = txb.build
+      signed_tx = wallet.sign_tx(tx)
+      [signed_tx, 0]
+    end
+
+    private
+
+    # Create wallet for provider
+    def load_wallet
+      begin
+        Glueby::Internal::Wallet.load(WALLET_ID)
+      rescue Glueby::Internal::Wallet::Errors::WalletNotFound => _
+        Glueby::Internal::Wallet.create(WALLET_ID)
+      end
+    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
+      end
+    end
+  end
+end

data/lib/glueby/version.rb

@@ -1,3 +1,3 @@
 module Glueby
-  VERSION = "0.4.2"
+  VERSION = "0.5.1"
 end

data/lib/glueby.rb

@@ -10,6 +10,7 @@ module Glueby
   autoload :FeeProvider, 'glueby/fee_provider'
   autoload :Configuration, 'glueby/configuration'
   autoload :BlockSyncer, 'glueby/block_syncer'
+  autoload :UtxoProvider, 'glueby/utxo_provider'
 
   if defined? ::Rails::Railtie
     require 'glueby/railtie'

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

@@ -8,15 +8,22 @@ 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 = create_txs(wallet, t.prefix, t.content_hash, Glueby::Contract::FixedFeeEstimator.new, utxo_provider)
+              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 = Glueby::Wallet.load(t.wallet_id)
-                tx = create_tx(wallet, t.prefix, t.content_hash, Glueby::Contract::FixedFeeEstimator.new)
                 wallet.internal_wallet.broadcast(tx) do |tx|
                   t.update(txid: tx.txid, status: :unconfirmed)
                 end
-                puts "broadcasted (id=#{t.id}, txid=#{tx.txid})"
+                puts "timestamp tx was broadcasted (id=#{t.id}, txid=#{tx.txid})"
               end
             rescue => e
               puts "failed to broadcast (id=#{t.id}, reason=#{e.message})"

data/lib/tasks/glueby/fee_provider.rake

@@ -12,7 +12,7 @@ namespace :glueby do
 
     desc 'Show the address of the Glueby::FeeProvider'
     task :address, [] => [:environment] do |_, _|
-      Glueby::FeeProvider::Tasks.new.address
+      Glueby::FeeProvider::Tasks.new.print_address
     end
   end
 end

data/lib/tasks/glueby/utxo_provider.rake

@@ -0,0 +1,18 @@
+namespace :glueby do
+  namespace :utxo_provider do
+    desc 'Manage the UTXO pool in Glueby::UtxoProvider. Creates outputs for paying utxo if the outputs is less than configured pool size by :utxo_pool_size'
+    task :manage_utxo_pool, [] => [:environment] do |_, _|
+      Glueby::UtxoProvider::Tasks.new.manage_utxo_pool
+    end
+
+    desc 'Show the status of the UTXO pool in Glueby::UtxoProvider'
+    task :status, [] => [:environment] do |_, _|
+      Glueby::UtxoProvider::Tasks.new.status
+    end
+
+    desc 'Show the address of the Glueby::UtxoProvider'
+    task :address, [] => [:environment] do |_, _|
+      Glueby::UtxoProvider::Tasks.new.print_address
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glueby
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.1
 platform: ruby
 authors:
 - azuchi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-15 00:00:00.000000000 Z
+date: 2021-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tapyrus
@@ -28,16 +28,16 @@ dependencies:
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 6.1.3
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.1.3
 description: A Ruby library of smart contracts that can be used on Tapyrus.
 email:
 - azuchi@chaintope.com
@@ -117,12 +131,15 @@ files:
 - lib/glueby/internal/wallet/errors.rb
 - lib/glueby/internal/wallet/tapyrus_core_wallet_adapter.rb
 - lib/glueby/railtie.rb
+- lib/glueby/utxo_provider.rb
+- lib/glueby/utxo_provider/tasks.rb
 - lib/glueby/version.rb
 - lib/glueby/wallet.rb
 - lib/tasks/glueby/block_syncer.rake
 - lib/tasks/glueby/contract.rake
 - lib/tasks/glueby/contract/timestamp.rake
 - lib/tasks/glueby/fee_provider.rake
+- lib/tasks/glueby/utxo_provider.rake
 homepage: https://github.com/chaintope/glueby
 licenses:
 - MIT