glueby 0.4.4 → 0.6.0

data/lib/glueby/internal/wallet.rb

@@ -1,162 +1,164 @@
-module Glueby
-  module Internal
-    # # Glueby::Internal::Wallet
-    #
-    # This module provides the way to deal about wallet that includes key management, address management, getting UTXOs.
-    #
-    # ## How to use
-    #
-    # First, you need to configure which wallet implementation is used in Glueby::Internal::Wallet. For now, below wallets are
-    # supported.
-    #
-    # * [Tapyrus Core](https://github.com/chaintope/tapyrus-core)
-    #
-    # Here shows an example to use Tapyrus Core wallet.
-    #
-    # ```ruby
-    # # Setup Tapyrus Core RPC connection
-    # config = {schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass'}
-    # Glueby::Internal::RPC.configure(config)
-    #
-    # # Setup wallet adapter
-    # Glueby::Internal::Wallet.wallet_adapter = Glueby::Internal::Wallet::TapyrusCoreWalletAdapter.new
-    #
-    # # Create wallet
-    # wallet = Glueby::Internal::Wallet.create
-    # wallet.balance # => 0
-    # wallet.list_unspent
-    # ```
-    class Wallet
-      autoload :AbstractWalletAdapter, 'glueby/internal/wallet/abstract_wallet_adapter'
-      autoload :AR, 'glueby/internal/wallet/active_record'
-      autoload :TapyrusCoreWalletAdapter, 'glueby/internal/wallet/tapyrus_core_wallet_adapter'
-      autoload :ActiveRecordWalletAdapter, 'glueby/internal/wallet/active_record_wallet_adapter'
-      autoload :Errors, 'glueby/internal/wallet/errors'
-
-      class << self
-        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)
-          begin
-            wallet_adapter.load_wallet(wallet_id)
-          rescue Errors::WalletAlreadyLoaded => _
-            # Ignore when wallet is already loaded.
-          end
-          new(wallet_id)
-        end
-
-        def wallets
-          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`.'
-        end
-      end
-
-      attr_reader :id
-
-      def initialize(wallet_id)
-        @id = wallet_id
-      end
-
-      def balance(only_finalized = true)
-        wallet_adapter.balance(id, only_finalized)
-      end
-
-      # @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
-
-      # @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
-
-      # 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?
-        wallet_adapter.broadcast(id, tx, &block)
-        tx
-      end
-
-      def receive_address(label = nil)
-        wallet_adapter.receive_address(id, label)
-      end
-
-      def change_address
-        wallet_adapter.change_address(id)
-      end
-
-      def create_pubkey
-        wallet_adapter.create_pubkey(id)
-      end
-
-      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]
-
-          new_sum = sum[0] + output[:amount]
-          new_outputs = sum[1] << output
-          return [new_sum, new_outputs] if new_sum >= amount
-
-          [new_sum, new_outputs]
-        end
-        raise Glueby::Contract::Errors::InsufficientFunds
-      end
-
-      def get_addresses(label = nil)
-        wallet_adapter.get_addresses(id, label)
-      end
-
-      private
-
-      def wallet_adapter
-        self.class.wallet_adapter
-      end
-    end
-  end
-end
+module Glueby
+  module Internal
+    # # Glueby::Internal::Wallet
+    #
+    # This module provides the way to deal about wallet that includes key management, address management, getting UTXOs.
+    #
+    # ## How to use
+    #
+    # First, you need to configure which wallet implementation is used in Glueby::Internal::Wallet. For now, below wallets are
+    # supported.
+    #
+    # * [Tapyrus Core](https://github.com/chaintope/tapyrus-core)
+    #
+    # Here shows an example to use Tapyrus Core wallet.
+    #
+    # ```ruby
+    # # Setup Tapyrus Core RPC connection
+    # config = {schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass'}
+    # Glueby::Internal::RPC.configure(config)
+    #
+    # # Setup wallet adapter
+    # Glueby::Internal::Wallet.wallet_adapter = Glueby::Internal::Wallet::TapyrusCoreWalletAdapter.new
+    #
+    # # Create wallet
+    # wallet = Glueby::Internal::Wallet.create
+    # wallet.balance # => 0
+    # wallet.list_unspent
+    # ```
+    class Wallet
+      autoload :AbstractWalletAdapter, 'glueby/internal/wallet/abstract_wallet_adapter'
+      autoload :AR, 'glueby/internal/wallet/active_record'
+      autoload :TapyrusCoreWalletAdapter, 'glueby/internal/wallet/tapyrus_core_wallet_adapter'
+      autoload :ActiveRecordWalletAdapter, 'glueby/internal/wallet/active_record_wallet_adapter'
+      autoload :Errors, 'glueby/internal/wallet/errors'
+
+      class << self
+        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)
+          begin
+            wallet_adapter.load_wallet(wallet_id)
+          rescue Errors::WalletAlreadyLoaded => _
+            # Ignore when wallet is already loaded.
+          end
+          new(wallet_id)
+        end
+
+        def wallets
+          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`.'
+        end
+      end
+
+      attr_reader :id
+
+      def initialize(wallet_id)
+        @id = wallet_id
+      end
+
+      def balance(only_finalized = true)
+        wallet_adapter.balance(id, only_finalized)
+      end
+
+      # @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 nil or :unlabeled, only unlabeled UTXOs will be returned.
+      #                    - If label=:all, all UTXOs will be returned.
+      def list_unspent(only_finalized = true, label = :unlabeled)
+        label = :unlabeled unless label
+        wallet_adapter.list_unspent(id, only_finalized, label)
+      end
+
+      def delete
+        wallet_adapter.delete_wallet(id)
+      end
+
+      # @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
+
+      # 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?
+        wallet_adapter.broadcast(id, tx, &block)
+        tx
+      end
+
+      def receive_address(label = nil)
+        wallet_adapter.receive_address(id, label)
+      end
+
+      def change_address
+        wallet_adapter.change_address(id)
+      end
+
+      def create_pubkey
+        wallet_adapter.create_pubkey(id)
+      end
+
+      def collect_uncolored_outputs(amount, label = nil, only_finalized = true, shuffle = false)
+        utxos = list_unspent(only_finalized, label)
+        utxos.shuffle! if shuffle
+
+        utxos.inject([0, []]) do |sum, output|
+          next sum if output[:color_id]
+
+          new_sum = sum[0] + output[:amount]
+          new_outputs = sum[1] << output
+          return [new_sum, new_outputs] if new_sum >= amount
+
+          [new_sum, new_outputs]
+        end
+        raise Glueby::Contract::Errors::InsufficientFunds
+      end
+
+      def get_addresses(label = nil)
+        wallet_adapter.get_addresses(id, label)
+      end
+
+      private
+
+      def wallet_adapter
+        self.class.wallet_adapter
+      end
+    end
+  end
+end

data/lib/glueby/railtie.rb

@@ -1,10 +1,11 @@
-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
+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"
+      load "tasks/glueby/utxo_provider.rake"
+    end
+  end
 end

data/lib/glueby/utxo_provider/tasks.rb

@@ -0,0 +1,135 @@
+module Glueby
+  class UtxoProvider
+    class Tasks
+      include Glueby::Contract::TxBuilder
+
+      attr_reader :utxo_provider
+
+      STATUS = {
+        # UtxoProvider is ready to pay tpcs.
+        ready: 'Ready',
+        # UtxoProvider is ready to pay tpcs, but it doesn't have enough amount to fill the UTXO pool by UTXOs which is for paying tpcs.
+        insufficient_amount: 'Insufficient Amount',
+        # UtxoProvider is not ready to pay tpcs. It has no UTXOs for paying amounts.
+        not_ready: 'Not Ready'
+      }
+
+      def initialize
+        @utxo_provider = Glueby::UtxoProvider.new
+      end
+
+      # Create UTXOs for paying tpc
+      #
+      # UtxoProvider have the UTXO pool. the pool is manged to keep some number of UTXOs that have fixed value. The
+      # value is configurable by :default_value. 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 = [utxo_provider.utxo_pool_size - current_utxo_pool_size, 0].max
+        return if shortage == 0
+
+        added_outputs = 0
+        shortage.times do
+          fee = utxo_provider.fee_estimator.fee(dummy_tx(txb.build))
+          break if (sum - fee) < utxo_provider.default_value
+          txb.pay(address, utxo_provider.default_value)
+          sum -= utxo_provider.default_value
+          added_outputs += 1
+        end
+
+        return if added_outputs == 0
+
+        fee = utxo_provider.fee_estimator.fee(dummy_tx(txb.build))
+        tx = txb.change_address(address)
+                .fee(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 < utxo_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 tpc to UtxoProvider. 
+              UtxoProvider needs #{value_to_fill_utxo_pool} tapyrus in UTXO pool. 
+              UtxoProvider wallet's address is '#{wallet.receive_address}'
+            2. Then create UTXOs for paying in UTXO pool with 'rake glueby:utxo_provider:manage_utxo_pool'
+            MESSAGE
+          else
+            message = "Please create UTXOs for paying in UTXO pool with 'rake glueby:utxo_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:
+          default_value = #{delimit(utxo_provider.default_value)}
+          utxo_pool_size = #{delimit(utxo_provider.utxo_pool_size)}
+        EOS
+      end
+
+      # Show the address of Utxo Provider 
+      def print_address
+        puts wallet.receive_address
+      end
+
+      private
+
+      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] == utxo_provider.default_value
+
+          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]
+          }
+          [new_sum, new_outputs]
+        end
+      end
+
+      def current_utxo_pool_size
+        wallet
+          .list_unspent(false)
+          .count { |o| !o[:color_id] && o[:amount] == utxo_provider.default_value }
+      end
+
+      def value_to_fill_utxo_pool
+        utxo_provider.default_value * utxo_provider.utxo_pool_size
+      end
+
+      def wallet
+        utxo_provider.wallet
+      end
+
+      def delimit(num)
+        num.to_s.reverse.scan(/.{1,3}/).join('_').reverse
+      end
+    end
+  end
+end

data/lib/glueby/utxo_provider.rb

@@ -0,0 +1,85 @@
+module Glueby
+  class UtxoProvider
+    include Glueby::Contract::TxBuilder
+
+    autoload :Tasks, 'glueby/utxo_provider/tasks'
+
+    WALLET_ID = 'UTXO_PROVIDER_WALLET'
+    DEFAULT_VALUE = 1_000
+    DEFAULT_UTXO_POOL_SIZE = 20
+    MAX_UTXO_POOL_SIZE = 2_000
+
+    class << self
+      attr_reader :config
+
+      # @param [Hash] config
+      # @option config [Integer] :default_value 
+      # @option opts [Integer] :utxo_pool_size
+      # @option opts [Glueby::Contract::FeeEstimator] :fee_estimator
+      def configure(config)
+        @config = config
+      end
+    end
+
+    def initialize
+      @wallet = load_wallet
+      validate_config!
+      @fee_estimator = (UtxoProvider.config && UtxoProvider.config[:fee_estimator]) || Glueby::Contract::FixedFeeEstimator.new
+      @default_value = (UtxoProvider.config && UtxoProvider.config[:default_value]) || DEFAULT_VALUE
+      @utxo_pool_size = (UtxoProvider.config && UtxoProvider.config[:utxo_pool_size]) || DEFAULT_UTXO_POOL_SIZE
+    end
+
+    attr_reader :wallet, :fee_estimator, :default_value, :utxo_pool_size 
+
+    # Provide a UTXO
+    # @param [Tapyrus::Script] script_pubkey The script to be provided
+    # @param [Integer] value The tpc amount to be provided
+    # @return [Array<(Tapyrus::Tx, Integer)>]
+    #  The tx that has a UTXO to be provided in its outputs.
+    #  The output index in the tx to indicate the place of a provided UTXO.
+    # @raise [Glueby::Contract::Errors::InsufficientFunds] if provider does not have any utxo which has specified value.
+    def get_utxo(script_pubkey, value = DEFAULT_VALUE)
+      txb = Tapyrus::TxBuilder.new
+      txb.pay(script_pubkey.addresses.first, value)
+
+      fee = fee_estimator.fee(dummy_tx(txb.build))
+      # The outputs need to be shuffled so that no utxos are spent twice as possible.
+      sum, outputs = wallet.collect_uncolored_outputs(fee + value, nil, true, true)
+
+      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
+
+      txb.fee(fee).change_address(wallet.change_address)
+
+      tx = txb.build
+      signed_tx = wallet.sign_tx(tx)
+      [signed_tx, 0]
+    end
+
+    private
+
+    # Create wallet for provider
+    def load_wallet
+      begin
+        Glueby::Internal::Wallet.load(WALLET_ID)
+      rescue Glueby::Internal::Wallet::Errors::WalletNotFound => _
+        Glueby::Internal::Wallet.create(WALLET_ID)
+      end
+    end
+
+    def validate_config!
+      if UtxoProvider.config
+        utxo_pool_size = UtxoProvider.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

data/lib/glueby/version.rb

@@ -1,3 +1,3 @@
-module Glueby
-  VERSION = "0.4.4"
-end
+module Glueby
+  VERSION = "0.6.0"
+end

data/lib/glueby.rb

@@ -1,39 +1,40 @@
-require "glueby/version"
-require 'tapyrus'
-
-module Glueby
-  autoload :Contract, 'glueby/contract'
-  autoload :Generator, 'glueby/generator'
-  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'
-
-  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
+require "glueby/version"
+require 'tapyrus'
+
+module Glueby
+  autoload :Contract, 'glueby/contract'
+  autoload :Generator, 'glueby/generator'
+  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'
+  autoload :UtxoProvider, 'glueby/utxo_provider'
+
+  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