glueby 0.2.0 → 0.4.2

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

@@ -34,10 +34,13 @@ module Glueby
       autoload :Errors, 'glueby/internal/wallet/errors'
 
       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)
@@ -53,6 +56,16 @@ module Glueby
           wallet_adapter.wallets.map { |id| new(id) }
         end
 
+        def wallet_adapter=(adapter)
+          if adapter.is_a?(ActiveRecordWalletAdapter)
+            BlockSyncer.register_syncer(ActiveRecordWalletAdapter::Syncer)
+          else
+            BlockSyncer.unregister_syncer(ActiveRecordWalletAdapter::Syncer)
+          end
+
+          @wallet_adapter = adapter
+        end
+
         def wallet_adapter
           @wallet_adapter or
             raise Errors::ShouldInitializeWalletAdapter, 'You should initialize wallet adapter using `Glueby::Internal::Wallet.wallet_adapter = some wallet adapter instance`.'
@@ -69,24 +82,50 @@ module Glueby
         wallet_adapter.balance(id, only_finalized)
       end
 
-      def list_unspent(only_finalized = true)
-        wallet_adapter.list_unspent(id, only_finalized)
+      # @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)
+        wallet_adapter.list_unspent(id, only_finalized, label)
       end
 
       def delete
         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)
+      # Broadcast a transaction via Tapyrus Core RPC
+      # @param [Tapyrus::Tx] tx The tx that would be broadcasted
+      # @option [Boolean] without_fee_provider The flag to avoid to use FeeProvider temporary.
+      # @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)
+        tx
       end
 
-      def receive_address
-        wallet_adapter.receive_address(id)
+      def receive_address(label = nil)
+        wallet_adapter.receive_address(id, label)
       end
 
       def change_address
@@ -97,8 +136,8 @@ module Glueby
         wallet_adapter.create_pubkey(id)
       end
 
-      def collect_uncolored_outputs(amount)
-        utxos = list_unspent
+      def collect_uncolored_outputs(amount, label = nil)
+        utxos = list_unspent(true, label)
 
         utxos.inject([0, []]) do |sum, output|
           next sum if output[:color_id]
@@ -112,6 +151,10 @@ module Glueby
         raise Glueby::Contract::Errors::InsufficientFunds
       end
 
+      def get_addresses(label = nil)
+        wallet_adapter.get_addresses(id, label)
+      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
@@ -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,

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,16 @@ module Glueby
       # alice_wallet.balances
       # ```
       class ActiveRecordWalletAdapter < AbstractWalletAdapter
-        def create_wallet
-          wallet_id = SecureRandom.hex(16)
-          wallet = AR::Wallet.create(wallet_id: wallet_id)
+
+        autoload :Syncer, 'glueby/internal/wallet/active_record_wallet_adapter/syncer'
+
+        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 +72,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)
@@ -81,10 +89,12 @@ module Glueby
           utxos.sum(&:value)
         end
 
-        def list_unspent(wallet_id, only_finalized = true)
+        def list_unspent(wallet_id, only_finalized = true, label = nil)
           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
           utxos.map do |utxo|
             {
               txid: utxo.txid,
@@ -97,9 +107,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)
@@ -110,9 +120,9 @@ module Glueby
           end
         end
 
-        def receive_address(wallet_id)
+        def receive_address(wallet_id, label = nil)
           wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          key = wallet.keys.create(purpose: :receive)
+          key = wallet.keys.create(purpose: :receive, label: label)
           key.address
         end
 
@@ -127,6 +137,13 @@ module Glueby
           key = wallet.keys.create(purpose: :receive)
           Tapyrus::Key.new(pubkey: key.public_key)
         end
+
+        def get_addresses(wallet_id, label = nil)
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          keys = wallet.keys
+          keys = keys.where(label: label) if label
+          keys.map(&:address)
+        end
       end
     end
   end

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

@@ -0,0 +1,14 @@
+module Glueby
+  module Internal
+    class Wallet
+      class ActiveRecordWalletAdapter
+        class Syncer
+          def tx_sync(tx)
+            Glueby::Internal::Wallet::AR::Utxo.destroy_for_inputs(tx)
+            Glueby::Internal::Wallet::AR::Utxo.create_or_update_for_outputs(tx)
+          end
+        end
+      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 && ex.rpc_error['code'] == RPC_WALLET_ERROR_ERROR_CODE && /Wallet wallet-#{wallet_id} 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 && 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 && ex.rpc_error['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
+            raise Errors::WalletNotFound, "Wallet #{wallet_id} does not found"
           else
             raise ex
           end
@@ -73,11 +83,14 @@ module Glueby
           end
         end
 
-        def list_unspent(wallet_id, only_finalized = true)
+        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
+ 
             res.map do |i|
               script = Tapyrus::Script.parse_from_payload(i['scriptPubKey'].htb)
               color_id = if script.cp2pkh? || script.cp2sh?
@@ -95,9 +108,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
@@ -112,9 +125,9 @@ module Glueby
           end
         end
 
-        def receive_address(wallet_id)
+        def receive_address(wallet_id, label = nil)
           perform_as(wallet_id) do |client|
-            client.getnewaddress('', ADDRESS_TYPE)
+            client.getnewaddress(label || '', ADDRESS_TYPE)
           end
         end
 
@@ -138,9 +151,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 && 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 +164,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