glueby 0.3.0 → 0.4.0

data/lib/glueby/fee_provider/tasks.rb

@@ -0,0 +1,136 @@
+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)
+      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
+
+      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/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.rb

@@ -36,8 +36,13 @@ module Glueby
       class << self
         attr_writer :wallet_adapter
 
-        def create
-          new(wallet_adapter.create_wallet)
+        def create(wallet_id = nil)
+          begin
+            wallet_id = wallet_adapter.create_wallet(wallet_id)
+          rescue Errors::WalletAlreadyCreated => _
+            # Ignore when wallet is already created.
+          end
+          new(wallet_id)
         end
 
         def load(wallet_id)
@@ -77,12 +82,27 @@ module Glueby
         wallet_adapter.delete_wallet(id)
       end
 
-      def sign_tx(tx, prev_txs = [])
-        wallet_adapter.sign_tx(id, tx, prev_txs)
+      # @param [Tapyrus::Tx] tx The tx that is signed
+      # @param [Array<Hash>] prev_txs An array of hash that represents unbroadcasted transaction outputs used by signing tx
+      #   @option prev_txs [String] :txid
+      #   @option prev_txs [Integer] :vout
+      #   @option prev_txs [String] :scriptPubkey
+      #   @option prev_txs [Integer] :amount
+      # @param [Boolean] for_fee_provider_input The flag to notify whether the caller is FeeProvider and called for signing a input that is by FeeProvider.
+      def sign_tx(tx, prev_txs = [], for_fee_provider_input: false)
+        sighashtype = Tapyrus::SIGHASH_TYPE[:all]
+
+        if !for_fee_provider_input && Glueby.configuration.fee_provider_bears?
+          sighashtype |= Tapyrus::SIGHASH_TYPE[:anyonecanpay]
+        end
+
+        wallet_adapter.sign_tx(id, tx, prev_txs, sighashtype: sighashtype)
       end
 
       def broadcast(tx)
+        tx = FeeProvider.provide(tx) if Glueby.configuration.fee_provider_bears?
         wallet_adapter.broadcast(id, tx)
+        tx
       end
 
       def receive_address
@@ -112,6 +132,10 @@ module Glueby
         raise Glueby::Contract::Errors::InsufficientFunds
       end
 
+      def get_addresses
+        wallet_adapter.get_addresses(id)
+      end
+
       private
 
       def wallet_adapter

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
@@ -83,10 +86,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
 
@@ -125,6 +130,16 @@ 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.
+        # @return [Array<String>] array of P2PKH address
+        def get_addresses(wallet_id)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
       end
     end
   end

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

@@ -13,13 +13,16 @@ module Glueby
 
           # @param [Tapyrus::Tx] tx
           # @param [Array] prevtxs array of outputs
-          def sign(tx, prevtxs = [])
+          # @param [Integer] sighashtype
+          def sign(tx, prevtxs = [], sighashtype: Tapyrus::SIGHASH_TYPE[:all])
+            validate_sighashtype!(sighashtype)
+
             tx.inputs.each.with_index do |input, index|
               script_pubkey = script_for_input(input, prevtxs)
               next unless script_pubkey
               key = Key.key_for_script(script_pubkey)
               next unless key
-              sign_tx_for_p2pkh(tx, index, key, script_pubkey)
+              sign_tx_for_p2pkh(tx, index, key, script_pubkey, sighashtype)
             end
             tx
           end
@@ -30,9 +33,9 @@ module Glueby
 
           private
 
-          def sign_tx_for_p2pkh(tx, index, key, script_pubkey)
-            sighash = tx.sighash_for_input(index, script_pubkey)
-            sig = key.sign(sighash) + [Tapyrus::SIGHASH_TYPE[:all]].pack('C')
+          def sign_tx_for_p2pkh(tx, index, key, script_pubkey, sighashtype)
+            sighash = tx.sighash_for_input(index, script_pubkey, hash_type: sighashtype)
+            sig = key.sign(sighash) + [sighashtype].pack('C')
             script_sig = Tapyrus::Script.parse_from_payload(Tapyrus::Script.pack_pushdata(sig) + Tapyrus::Script.pack_pushdata(key.public_key.htb))
             tx.inputs[index].script_sig = script_sig
           end
@@ -47,6 +50,13 @@ module Glueby
               Tapyrus::Script.parse_from_payload(output[:scriptPubKey].htb) if output
             end
           end
+
+          def validate_sighashtype!(sighashtype)
+            hash_type = sighashtype & (~(Tapyrus::SIGHASH_TYPE[:anyonecanpay]))
+            if hash_type < Tapyrus::SIGHASH_TYPE[:all] || hash_type > Tapyrus::SIGHASH_TYPE[:single]
+              raise Errors::InvalidSighashType, "Invalid sighash type '#{sighashtype}'"
+            end
+          end
         end
       end
     end

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

@@ -54,9 +54,13 @@ module Glueby
       # alice_wallet.balances
       # ```
       class ActiveRecordWalletAdapter < AbstractWalletAdapter
-        def create_wallet
-          wallet_id = SecureRandom.hex(16)
-          wallet = AR::Wallet.create(wallet_id: wallet_id)
+        def create_wallet(wallet_id = nil)
+          wallet_id = SecureRandom.hex(16) unless wallet_id
+          begin
+            AR::Wallet.create!(wallet_id: wallet_id)
+          rescue ActiveRecord::RecordInvalid => _
+            raise Errors::WalletAlreadyCreated, "wallet_id '#{wallet_id}' is already exists"
+          end
           wallet_id
         end
 
@@ -65,6 +69,7 @@ module Glueby
         end
 
         def load_wallet(wallet_id)
+          raise Errors::WalletNotFound, "Wallet #{wallet_id} does not found" unless AR::Wallet.where(wallet_id: wallet_id).exists?
         end
 
         def unload_wallet(wallet_id)
@@ -97,9 +102,9 @@ module Glueby
           end
         end
 
-        def sign_tx(wallet_id, tx, prevtxs = [])
+        def sign_tx(wallet_id, tx, prevtxs = [], sighashtype: Tapyrus::SIGHASH_TYPE[:all])
           wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          wallet.sign(tx, prevtxs)
+          wallet.sign(tx, prevtxs, sighashtype: sighashtype)
         end
 
         def broadcast(wallet_id, tx)
@@ -127,6 +132,11 @@ module Glueby
           key = wallet.keys.create(purpose: :receive)
           Tapyrus::Key.new(pubkey: key.public_key)
         end
+
+        def get_addresses(wallet_id)
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          wallet.keys.map(&:address)
+        end
       end
     end
   end

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

@@ -5,6 +5,9 @@ module Glueby
         class ShouldInitializeWalletAdapter < StandardError; end
         class WalletUnloaded < StandardError; end
         class WalletAlreadyLoaded < StandardError; end
+        class WalletAlreadyCreated < StandardError; end
+        class WalletNotFound < StandardError; end
+        class InvalidSighashType < StandardError; end
       end
     end
   end

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

@@ -28,9 +28,18 @@ module Glueby
         RPC_WALLET_ERROR_ERROR_CODE = -4 # Unspecified problem with wallet (key not found etc.)
         RPC_WALLET_NOT_FOUND_ERROR_CODE = -18 # Invalid wallet specified
 
-        def create_wallet
-          wallet_id = SecureRandom.hex(16)
-          RPC.client.createwallet(wallet_name(wallet_id))
+        def create_wallet(wallet_id = nil)
+          wallet_id = SecureRandom.hex(16) unless wallet_id
+          begin
+            RPC.client.createwallet(wallet_name(wallet_id))
+          rescue Tapyrus::RPC::Error => ex
+            if ex.rpc_error['code'] == RPC_WALLET_ERROR_ERROR_CODE && /Wallet wallet-wallet already exists\./ =~ ex.rpc_error['message']
+              raise Errors::WalletAlreadyCreated, "Wallet #{wallet_id} has been already created."
+            else
+              raise ex
+            end
+          end
+
           wallet_id
         end
 
@@ -42,10 +51,11 @@ module Glueby
 
         def load_wallet(wallet_id)
           RPC.client.loadwallet(wallet_name(wallet_id))
-        rescue RuntimeError => ex
-          json = JSON.parse(ex.message)
-          if json.is_a?(Hash) && json['code'] == RPC_WALLET_ERROR_ERROR_CODE && /Duplicate -wallet filename specified/ =~ ex.message
+        rescue Tapyrus::RPC::Error => ex
+          if ex.rpc_error['code'] == RPC_WALLET_ERROR_ERROR_CODE && /Duplicate -wallet filename specified/ =~ ex.rpc_error['message']
             raise Errors::WalletAlreadyLoaded, "Wallet #{wallet_id} has been already loaded."
+          elsif ex.rpc_error['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
+            raise Errors::WalletNotFound, "Wallet #{wallet_id} does not found"
           else
             raise ex
           end
@@ -95,9 +105,9 @@ module Glueby
           end
         end
 
-        def sign_tx(wallet_id, tx, prevtxs = [])
+        def sign_tx(wallet_id, tx, prevtxs = [], sighashtype: Tapyrus::SIGHASH_TYPE[:all])
           perform_as(wallet_id) do |client|
-            res = client.signrawtransactionwithwallet(tx.to_hex, prevtxs)
+            res = client.signrawtransactionwithwallet(tx.to_hex, prevtxs, encode_sighashtype(sighashtype))
             if res['complete']
               Tapyrus::Tx.parse_from_payload(res['hex'].htb)
             else
@@ -138,9 +148,8 @@ module Glueby
           RPC.perform_as(wallet_name(wallet_id)) do |client|
             begin
               yield(client)
-            rescue RuntimeError => ex
-              json = JSON.parse(ex.message)
-              if json.is_a?(Hash) && json['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
+            rescue Tapyrus::RPC::Error => ex
+              if ex.rpc_error['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
                 raise Errors::WalletUnloaded, "The wallet #{wallet_id} is unloaded. You should load before use it."
               else
                 raise ex
@@ -152,6 +161,22 @@ module Glueby
         def wallet_name(wallet_id)
           "#{WALLET_PREFIX}#{wallet_id}"
         end
+
+        def encode_sighashtype(sighashtype)
+          type = case sighashtype & (~(Tapyrus::SIGHASH_TYPE[:anyonecanpay]))
+                 when Tapyrus::SIGHASH_TYPE[:all] then 'ALL'
+                 when Tapyrus::SIGHASH_TYPE[:none] then 'NONE'
+                 when Tapyrus::SIGHASH_TYPE[:single] then 'SIGNLE'
+                 else
+                   raise Errors::InvalidSighashType, "Invalid sighash type '#{sighashtype}'"
+                 end
+
+          if sighashtype & Tapyrus::SIGHASH_TYPE[:anyonecanpay] == 0x80
+            type += '|ANYONECANPAY'
+          end
+
+          type
+        end
       end
     end
   end

data/lib/glueby/version.rb

@@ -1,3 +1,3 @@
 module Glueby
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end