glueby 0.3.0 → 0.4.3

data/lib/glueby/contract/tx_builder.rb

@@ -3,26 +3,29 @@
 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:, amount:, script: nil, fee_provider: FixedFeeProvider.new)
+      def create_funding_tx(wallet:, script: nil, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
 
-        sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee + amount)
+        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: amount, script_pubkey: receiver_script)
+        tx.outputs << Tapyrus::TxOut.new(value: FUNDING_TX_AMOUNT, script_pubkey: receiver_script)
 
-        fill_change_tpc(tx, wallet, sum - fee - amount)
+        fill_change_tpc(tx, wallet, sum - fee - FUNDING_TX_AMOUNT)
         wallet.internal_wallet.sign_tx(tx)
       end
 
-      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_provider: FixedFeeProvider.new)
+      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -34,7 +37,7 @@ module Glueby
         receiver_colored_script = receiver_script.add_color(color_id)
         tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
         prev_txs = [{
           txid: funding_tx.txid,
@@ -45,18 +48,18 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_issue_tx_for_non_reissuable_token(issuer:, amount:, fee_provider: FixedFeeProvider.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NON_REISSUABLE, issuer: issuer, amount: amount, fee_provider: fee_provider)
+      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)
       end
 
-      def create_issue_tx_for_nft_token(issuer:, fee_provider: FixedFeeProvider.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NFT, issuer: issuer, amount: 1, fee_provider: fee_provider)
+      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)
       end
 
-      def create_issue_tx_from_out_point(token_type:, issuer:, amount:, fee_provider: FixedFeeProvider.new)
+      def create_issue_tx_from_out_point(token_type:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
-        fee = fee_provider.fee(dummy_issue_tx_from_out_point)
+        fee = fee_estimator.fee(dummy_issue_tx_from_out_point)
         sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee)
         fill_input(tx, outputs)
 
@@ -78,7 +81,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx)
       end
 
-      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_provider: FixedFeeProvider.new)
+      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -89,7 +92,7 @@ module Glueby
         receiver_colored_script = receiver_script.add_color(color_id)
         tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
         prev_txs = [{
           txid: funding_tx.txid,
@@ -100,7 +103,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_transfer_tx(color_id:, sender:, receiver_address:, amount:, fee_provider: FixedFeeProvider.new)
+      def create_transfer_tx(color_id:, sender:, receiver_address:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
@@ -113,7 +116,7 @@ module Glueby
 
         fill_change_token(tx, sender, sum_token - amount, color_id)
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
         sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee)
         fill_input(tx, outputs)
 
@@ -121,7 +124,7 @@ module Glueby
         sender.internal_wallet.sign_tx(tx)
       end
 
-      def create_burn_tx(color_id:, sender:, amount: 0, fee_provider: FixedFeeProvider.new)
+      def create_burn_tx(color_id:, sender:, amount: 0, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
@@ -130,7 +133,7 @@ module Glueby
 
         fill_change_token(tx, sender, sum_token - amount, color_id) if amount.positive?
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        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)

data/lib/glueby/contract.rb

@@ -1,8 +1,8 @@
 module Glueby
   module Contract
     autoload :Errors, 'glueby/contract/errors'
-    autoload :FeeProvider, 'glueby/contract/fee_provider'
-    autoload :FixedFeeProvider, 'glueby/contract/fee_provider'
+    autoload :FeeEstimator, 'glueby/contract/fee_estimator'
+    autoload :FixedFeeEstimator, 'glueby/contract/fee_estimator'
     autoload :Payment, 'glueby/contract/payment'
     autoload :Timestamp, 'glueby/contract/timestamp'
     autoload :Token, 'glueby/contract/token'

data/lib/glueby/fee_provider/tasks.rb

@@ -0,0 +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
+end

data/lib/glueby/fee_provider.rb

@@ -0,0 +1,73 @@
+module Glueby
+  class FeeProvider
+
+    autoload :Tasks, 'glueby/fee_provider/tasks'
+
+    class NoUtxosInUtxoPool < StandardError; end
+
+    WALLET_ID = 'FEE_PROVIDER_WALLET'
+    DEFAULT_FIXED_FEE = 1000
+    DEFAULT_UTXO_POOL_SIZE = 20
+
+    attr_reader :fixed_fee, :utxo_pool_size, :wallet,
+
+    class << self
+      attr_reader :config
+
+      # @param [Hash] config
+      # @option config [Integer] :fixed_fee The amount of fee which FeeProvider would provide to the txs
+      # @option opts [Integer] :utxo_pool_size The number of UTXOs in UTXO pool that is managed by FeeProvider
+      def configure(config)
+        @config = config
+      end
+
+      def provide(tx)
+        new.provide(tx)
+      end
+    end
+
+    def initialize
+      @wallet = begin
+                  Internal::Wallet.load(WALLET_ID)
+                rescue Internal::Wallet::Errors::WalletNotFound => _
+                  Internal::Wallet.create(WALLET_ID)
+                end
+
+      @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
+
+    # Provide an input for fee to the tx.
+    # @param [Tapyrus::Tx] tx - The tx that is provided fee as a input. It should be signed with ANYONECANPAY flag.
+    # @return [Tapyrus::Tx]
+    # @raise [ArgumentError] If the signatures that the tx inputs has don't have ANYONECANPAY flag.
+    # @raise [Glueby::FeeProvider::NoUtxosInUtxoPool] If there are no UTXOs for paying fee in FeeProvider's UTXO pool
+    def provide(tx)
+      tx.inputs.each do |txin|
+        sig = get_signature(txin.script_sig)
+        unless sig[-1].unpack1('C') & Tapyrus::SIGHASH_TYPE[:anyonecanpay] == Tapyrus::SIGHASH_TYPE[:anyonecanpay]
+          raise ArgumentError, 'All the signatures that the tx inputs has should have ANYONECANPAY flag.'
+        end
+      end
+
+      utxo = utxo_for_fee
+      out_point = Tapyrus::OutPoint.new(utxo[:txid].rhex, utxo[:vout])
+      tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+
+      wallet.sign_tx(tx, for_fee_provider_input: true)
+    end
+
+    private
+
+    def utxo_for_fee
+      utxo = wallet.list_unspent.select { |o| !o[:color_id] && o[:amount] == fixed_fee }.sample
+      raise NoUtxosInUtxoPool, 'No UTXOs in Fee Provider UTXO pool. UTXOs should be created with "glueby:fee_provider:manage_utxo_pool" rake task' unless utxo
+      utxo
+    end
+
+    # Get Signature from P2PKH or CP2PKH script sig
+    def get_signature(script_sig)
+      script_sig.chunks.first.pushed_data
+    end
+  end
+end

data/lib/glueby/generator/migrate_generator.rb

@@ -28,7 +28,7 @@ module Glueby
 
       def table_options
         if mysql?
-          ', { options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci" }'
+          ', :options => "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci"'
         else
           ""
         end

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

@@ -7,8 +7,10 @@ module Glueby
       class AbstractWalletAdapter
         # Creates a new wallet inside the wallet component and returns `wallet_id`. The created
         # wallet is loaded from at first.
+        # @params [String] wallet_id - Option. The wallet id that if for the wallet to be created. If this is nil, wallet adapter generates it.
         # @return [String] wallet_id
-        def create_wallet
+        # @raise [Glueby::Internal::Wallet::Errors::WalletAlreadyCreated] when the specified wallet has been already created.
+        def create_wallet(wallet_id = nil)
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         end
 
@@ -32,6 +34,7 @@ module Glueby
         #
         # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
         # @raise [Glueby::Internal::Wallet::Errors::WalletAlreadyLoaded] when the specified wallet has been already loaded.
+        # @raise [Glueby::Internal::Wallet::Errors::WalletNotFound] when the specified wallet is not found.
         def load_wallet(wallet_id)
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         end
@@ -62,11 +65,13 @@ module Glueby
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         end
 
-        # Returns all the UTXOs that the wallet has.
+        # Returns the UTXOs that the wallet has.
+        # If label is specified, return UTXOs filtered with label
         #
         # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
         # @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
         # @return [Array of UTXO]
         #
         # ## The UTXO structure
@@ -75,7 +80,7 @@ module Glueby
         # - vout: [Integer] Output index
         # - amount: [Integer] Amount of the UTXO as tapyrus unit
         # - finalized: [Boolean] Whether the UTXO is finalized
-        def list_unspent(wallet_id, only_finalized = true)
+        def list_unspent(wallet_id, only_finalized = true, label = nil)
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         end
 
@@ -83,10 +88,12 @@ module Glueby
         #
         # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
         # @param [Tapyrus::Tx] tx - The transaction will be signed.
-        # @param [Array] prevtxs array of hash that represents unbroadcasted transaction outputs used by signing tx. 
+        # @param [Array] prevtxs - array of hash that represents unbroadcasted transaction outputs used by signing tx.
         #                Each hash has `txid`, `vout`, `scriptPubKey`, `amount` fields.
+        # @param [Integer] sighashtype - The sighash flag for each signature that would be produced here.
         # @return [Tapyrus::Tx]
-        def sign_tx(wallet_id, tx, prevtxs = [])
+        # @raise [Glueby::Internal::Wallet::Errors::InvalidSighashType] when the specified sighashtype is invalid
+        def sign_tx(wallet_id, tx, prevtxs = [], sighashtype: Tapyrus::SIGHASH_TYPE[:all])
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         end
 
@@ -102,8 +109,9 @@ module Glueby
         # Returns an address to receive coin.
         #
         # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @param [String] label The label associated with this address.
         # @return [String] P2PKH address
-        def receive_address(wallet_id)
+        def receive_address(wallet_id, label = nil)
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         end
 
@@ -125,6 +133,17 @@ module Glueby
         def create_pubkey(wallet_id)
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         end
+
+        # Returns an array of addresses
+        #
+        # This method is expected to return the list of addresses that wallet has.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @param [String] label The label to filter the addresses.
+        # @return [Array<String>] array of P2PKH address
+        def get_addresses(wallet_id, label = nil)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
       end
     end
   end

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

@@ -36,6 +36,7 @@ module Glueby
 
               utxo = Utxo.find_or_initialize_by(txid: tx.txid, index: index)
               utxo.update!(
+                label: key.label,
                 script_pubkey: output.script_pubkey.to_hex,
                 value: output.value,
                 status: status,