glueby 0.4.4 → 0.6.0

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

@@ -1,141 +1,141 @@
-module Glueby
-  class FeeProvider
-    class Tasks
-      attr_reader :fee_provider
-
-      STATUS = {
-        # FeeProvider is ready to pay fees.
-        ready: 'Ready',
-        # FeeProvider is ready to pay fees, but it doesn't have enough amount to fill the UTXO pool by UTXOs which is for paying fees.
-        insufficient_amount: 'Insufficient Amount',
-        # FeeProvider is not ready to pay fees. It has no UTXOs for paying fee and amounts.
-        not_ready: 'Not Ready'
-      }
-
-      def initialize
-        @fee_provider = Glueby::FeeProvider.new
-      end
-
-      # Create UTXOs for paying fee from TPC amount of the wallet FeeProvider has. Then show the status.
-      #
-      # About the UTXO Pool
-      # FeeProvider have the UTXO pool. the pool is manged to keep some number of UTXOs that have fixed fee value. The
-      # value is configurable by :fixed_fee. 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 = [fee_provider.utxo_pool_size - current_utxo_pool_size, 0].max
-        can_create = (sum - fee_provider.fixed_fee) / fee_provider.fixed_fee
-        fee_outputs_count_to_be_created = [shortage, can_create].min
-
-        return if fee_outputs_count_to_be_created == 0
-
-        fee_outputs_count_to_be_created.times do
-          txb.pay(address, fee_provider.fixed_fee)
-        end
-
-        tx = txb.change_address(address)
-                .fee(fee_provider.fixed_fee)
-                .build
-        tx = wallet.sign_tx(tx)
-        wallet.broadcast(tx, without_fee_provider: true)
-      ensure
-        status
-      end
-
-      # Show the status of the UTXO pool
-      def status
-        status = :ready
-
-        if current_utxo_pool_size < fee_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 fee to FeeProvider. 
-               FeeProvider needs #{value_to_fill_utxo_pool} tapyrus at least for paying 20 transaction fees. 
-               FeeProvider wallet's address is '#{wallet.receive_address}'
-            2. Then create UTXOs for paying in UTXO pool with 'rake glueby:fee_provider:manage_utxo_pool'
-            MESSAGE
-          else
-            message = "Please create UTXOs for paying in UTXO pool with 'rake glueby:fee_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:
-          fixed_fee = #{delimit(fee_provider.fixed_fee)}
-          utxo_pool_size = #{delimit(fee_provider.utxo_pool_size)}
-        EOS
-      end
-
-      # Show the address of Fee Provider 
-      def address
-        puts wallet.receive_address
-      end
-
-      private
-
-      def check_wallet_amount!
-        if tpc_amount < fee_provider.fixed_fee
-          raise InsufficientTPC, <<~MESSAGE
-            FeeProvider has insufficient TPC to create fee outputs to fill the UTXO pool.
-            1. Please replenishment TPC which is for paying fee to FeeProvider. FeeProvider needs #{fee_provider.utxo_pool_size * fee_provider.fixed_fee} tapyrus at least. FeeProvider wallet's address is '#{wallet.receive_address}'
-            2. Then create UTXOs for paying in UTXO pool with 'rake glueby:fee_provider:manage_utxo_pool'
-          MESSAGE
-        end
-      end
-
-      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] == fee_provider.fixed_fee
-
-          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]
-          }
-          return [new_sum, new_outputs] if new_sum >= value_to_fill_utxo_pool
-
-          [new_sum, new_outputs]
-        end
-      end
-
-      def current_utxo_pool_size
-        wallet
-          .list_unspent(false)
-          .count { |o| !o[:color_id] && o[:amount] == fee_provider.fixed_fee }
-      end
-
-      def value_to_fill_utxo_pool
-        fee_provider.fixed_fee * (fee_provider.utxo_pool_size + 1) #  +1 is for paying fee
-      end
-
-      def wallet
-        fee_provider.wallet
-      end
-
-      def delimit(num)
-        num.to_s.reverse.scan(/.{1,3}/).join('_').reverse
-      end
-    end
-  end
+module Glueby
+  class FeeProvider
+    class Tasks
+      attr_reader :fee_provider
+
+      STATUS = {
+        # FeeProvider is ready to pay fees.
+        ready: 'Ready',
+        # FeeProvider is ready to pay fees, but it doesn't have enough amount to fill the UTXO pool by UTXOs which is for paying fees.
+        insufficient_amount: 'Insufficient Amount',
+        # FeeProvider is not ready to pay fees. It has no UTXOs for paying fee and amounts.
+        not_ready: 'Not Ready'
+      }
+
+      def initialize
+        @fee_provider = Glueby::FeeProvider.new
+      end
+
+      # Create UTXOs for paying fee from TPC amount of the wallet FeeProvider has. Then show the status.
+      #
+      # About the UTXO Pool
+      # FeeProvider have the UTXO pool. the pool is manged to keep some number of UTXOs that have fixed fee value. The
+      # value is configurable by :fixed_fee. 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 = [fee_provider.utxo_pool_size - current_utxo_pool_size, 0].max
+        can_create = (sum - fee_provider.fixed_fee) / fee_provider.fixed_fee
+        fee_outputs_count_to_be_created = [shortage, can_create].min
+
+        return if fee_outputs_count_to_be_created == 0
+
+        fee_outputs_count_to_be_created.times do
+          txb.pay(address, fee_provider.fixed_fee)
+        end
+
+        tx = txb.change_address(address)
+                .fee(fee_provider.fixed_fee)
+                .build
+        tx = wallet.sign_tx(tx)
+        wallet.broadcast(tx, without_fee_provider: true)
+      ensure
+        status
+      end
+
+      # Show the status of the UTXO pool
+      def status
+        status = :ready
+
+        if current_utxo_pool_size < fee_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 fee to FeeProvider. 
+               FeeProvider needs #{value_to_fill_utxo_pool} tapyrus at least for paying 20 transaction fees. 
+               FeeProvider wallet's address is '#{wallet.receive_address}'
+            2. Then create UTXOs for paying in UTXO pool with 'rake glueby:fee_provider:manage_utxo_pool'
+            MESSAGE
+          else
+            message = "Please create UTXOs for paying in UTXO pool with 'rake glueby:fee_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:
+          fixed_fee = #{delimit(fee_provider.fixed_fee)}
+          utxo_pool_size = #{delimit(fee_provider.utxo_pool_size)}
+        EOS
+      end
+
+      # Show the address of Fee Provider 
+      def print_address
+        puts wallet.receive_address
+      end
+
+      private
+
+      def check_wallet_amount!
+        if tpc_amount < fee_provider.fixed_fee
+          raise InsufficientTPC, <<~MESSAGE
+            FeeProvider has insufficient TPC to create fee outputs to fill the UTXO pool.
+            1. Please replenishment TPC which is for paying fee to FeeProvider. FeeProvider needs #{fee_provider.utxo_pool_size * fee_provider.fixed_fee} tapyrus at least. FeeProvider wallet's address is '#{wallet.receive_address}'
+            2. Then create UTXOs for paying in UTXO pool with 'rake glueby:fee_provider:manage_utxo_pool'
+          MESSAGE
+        end
+      end
+
+      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] == fee_provider.fixed_fee
+
+          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]
+          }
+          return [new_sum, new_outputs] if new_sum >= value_to_fill_utxo_pool
+
+          [new_sum, new_outputs]
+        end
+      end
+
+      def current_utxo_pool_size
+        wallet
+          .list_unspent(false)
+          .count { |o| !o[:color_id] && o[:amount] == fee_provider.fixed_fee }
+      end
+
+      def value_to_fill_utxo_pool
+        fee_provider.fixed_fee * (fee_provider.utxo_pool_size + 1) #  +1 is for paying fee
+      end
+
+      def wallet
+        fee_provider.wallet
+      end
+
+      def delimit(num)
+        num.to_s.reverse.scan(/.{1,3}/).join('_').reverse
+      end
+    end
+  end
 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