glueby 0.3.0 → 0.4.3

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/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/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/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

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, only_finalized = true)
+        utxos = list_unspent(only_finalized, 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/railtie.rb

@@ -0,0 +1,10 @@
+module Glueby
+  class Railtie < ::Rails::Railtie
+    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"
+    end
+  end
+end

data/lib/glueby/version.rb

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

data/lib/glueby/wallet.rb

@@ -13,6 +13,7 @@ module Glueby
         new(Glueby::Internal::Wallet.load(wallet_id))
       end
 
+      # @deprecated - Use Glueby.configure instead
       def configure(config)
         case config[:adapter]
         when 'core'
@@ -32,8 +33,8 @@ module Glueby
     end
 
     # @return [HashMap] hash of balances which key is color_id or empty string, and value is amount
-    def balances
-      utxos = @internal_wallet.list_unspent
+    def balances(only_finalized = true)
+      utxos = @internal_wallet.list_unspent(only_finalized)
       utxos.inject({}) do |balances, output|
         key = output[:color_id] || ''
         balances[key] ||= 0

data/lib/glueby.rb

@@ -7,18 +7,33 @@ module Glueby
   autoload :Wallet, 'glueby/wallet'
   autoload :Internal, 'glueby/internal'
   autoload :AR, 'glueby/active_record'
+  autoload :FeeProvider, 'glueby/fee_provider'
+  autoload :Configuration, 'glueby/configuration'
+  autoload :BlockSyncer, 'glueby/block_syncer'
 
-  begin
-    class Railtie < ::Rails::Railtie
-      rake_tasks do
-        load "tasks/glueby/contract.rake"
-        load "tasks/glueby/contract/timestamp.rake"
-        load "tasks/glueby/contract/wallet_adapter.rake"
-        load "tasks/glueby/contract/block_syncer.rake"
-      end
-    end
-  rescue
-    # Rake task is unavailable
-    puts "Rake task is unavailable"
+  if defined? ::Rails::Railtie
+    require 'glueby/railtie'
+  end
+
+  # Add prefix to activerecord table names
+  def self.table_name_prefix
+    'glueby_'
+  end
+
+  # Returns the global [Configuration](RSpec/Core/Configuration) object.
+  def self.configuration
+    @configuration ||= Glueby::Configuration.new
+  end
+
+  # Yields the global configuration to a block.
+  # @yield [Configuration] global configuration
+  #
+  # @example
+  #     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
+  def self.configure
+    yield configuration if block_given?
   end
 end