glueby 0.2.0 → 0.4.2

data/lib/generators/glueby/contract/templates/timestamp_table.rb.erb

@@ -1,6 +1,6 @@
 class CreateTimestamp < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :timestamps<%= table_options %> do |t|
+    create_table :glueby_timestamps<%= table_options %> do |t|
       t.string   :txid
       t.integer  :status
       t.string   :content_hash

data/lib/generators/glueby/contract/templates/utxo_table.rb.erb

@@ -1,15 +1,16 @@
 class CreateUtxo < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :utxos<%= table_options %> do |t|
+    create_table :glueby_utxos<%= table_options %> do |t|
       t.string     :txid
       t.integer    :index
       t.bigint     :value
       t.string     :script_pubkey
+      t.string     :label, index: true
       t.integer    :status
       t.belongs_to :key, null: true
       t.timestamps
     end
 
-    add_index :utxos, [:txid, :index], unique: true
+    add_index :glueby_utxos, [:txid, :index], unique: true
   end
 end

data/lib/generators/glueby/contract/templates/wallet_table.rb.erb

@@ -1,10 +1,10 @@
 class CreateWallet < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :wallets<%= table_options %> do |t|
+    create_table :glueby_wallets<%= table_options %> do |t|
       t.string :wallet_id
       t.timestamps
     end
 
-    add_index :wallets, [:wallet_id], unique: true
+    add_index :glueby_wallets, [:wallet_id], unique: true
   end
 end

data/lib/glueby.rb

@@ -6,17 +6,34 @@ module Glueby
   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'
 
-  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"
-      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

data/lib/glueby/active_record.rb

@@ -0,0 +1,8 @@
+
+require 'active_record'
+
+module Glueby
+  module AR
+    autoload :SystemInformation, 'glueby/active_record/system_information'
+  end
+end

data/lib/glueby/active_record/system_information.rb

@@ -0,0 +1,15 @@
+module Glueby
+  module AR
+    class SystemInformation < ::ActiveRecord::Base
+
+      def self.synced_block_height
+        SystemInformation.find_by(info_key: "synced_block_number")
+      end
+
+      def int_value
+        info_value.to_i
+      end
+
+    end
+  end
+end

data/lib/glueby/block_syncer.rb

@@ -0,0 +1,98 @@
+module Glueby
+  # You can use BlockSyncer when you need to synchronize the state of
+  # an application with the state of a blockchain. When BlockSyncer
+  # detects the generation of a new block, it executes the registered
+  # syncer code on a block-by-block or transaction-by-transaction basis.
+  # By using this, an application can detect that the issued transaction
+  # has been captured in  blocks, receive a new remittance, and so on.
+  #
+  # # Syncer logic registration
+  #
+  # For registration, create a class that implements the method that performs
+  # synchronization processing and registers it in BlockSyncer. Implement
+  # methods with the following name in that class.
+  #
+  # Method name        | Arguments             | Call conditions
+  # ------------------ | --------------------- | ------------------------------
+  # block_sync (block) | block: Tapyrus::Block | When a new block is created
+  # block_tx (tx)      | tx: Tapyrus::Tx       | When a new block is created, it is executed for each tx contained in that block.
+  #
+  # @example Register a synchronous logic
+  #   class Syncer
+  #     def block_sync (block)
+  #       # sync a block
+  #     end
+  #
+  #     def tx_sync (tx)
+  #       # sync a tx
+  #     end
+  #   end
+  #   BlockSyncer.register_syncer(Syncer)
+  #
+  # @example Unregister the synchronous logic
+  #   BlockSyncer.unregister_syncer(Syncer)
+  #
+  # # Run BlockSyncer
+  #
+  # Run the `glueby: block_syncer: start` rake task periodically with a program
+  # for periodic execution such as cron. If it detects the generation of a new
+  # block when it is executed, the synchronization process will be executed.
+  # Determine the execution interval according to the requirements of the application.
+  class BlockSyncer
+    # @!attribute [r] height
+    #   @return [Integer] The block height to be synced
+    attr_reader :height
+
+    class << self
+      # @!attribute r syncers
+      #   @return [Array<Class>] The syncer classes that is registered
+      attr_reader :syncers
+
+      # Register syncer class
+      # @param [Class] syncer The syncer to be registered.
+      def register_syncer(syncer)
+        @syncers ||= []
+        @syncers << syncer
+      end
+
+      # Unregister syncer class
+      # @param [Class] syncer The syncer to be unregistered.
+      def unregister_syncer(syncer)
+        @syncers ||= []
+        @syncers.delete(syncer)
+      end
+    end
+
+    # @param [Integer] height The block height to be synced in the instance
+    def initialize(height)
+      @height = height
+    end
+
+    # Run a block synchronization
+    def run
+      return if self.class.syncers.nil?
+
+      self.class.syncers.each do |syncer|
+        instance = syncer.new
+        instance.block_sync(block) if instance.respond_to?(:block_sync)
+
+        if instance.respond_to?(:tx_sync)
+          block.transactions.each { |tx| instance.tx_sync(tx) }
+        end
+      end
+    end
+
+    private
+
+    def block
+      @block ||= begin
+                   block = Glueby::Internal::RPC.client.getblock(block_hash, 0)
+                   Tapyrus::Block.parse_from_payload(block.htb)
+                 end
+    end
+
+    def block_hash
+      @block_hash ||= Glueby::Internal::RPC.client.getblockhash(height)
+    end
+  end
+end

data/lib/glueby/configuration.rb

@@ -0,0 +1,62 @@
+module Glueby
+  # Global configuration on runtime
+  #
+  # The global configuration treats configurations for all modules in Glueby.
+  #
+  # @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
+  class Configuration
+
+    attr_reader :fee_provider_bears
+    alias_method :fee_provider_bears?, :fee_provider_bears
+
+    def initialize
+      @fee_provider_bears = false
+    end
+
+    # Specify wallet adapter.
+    # @param [Symbol] adapter - The adapter type :activerecord or :core is currently supported.
+    def wallet_adapter=(adapter)
+      case adapter
+      when :core
+        Glueby::Internal::Wallet.wallet_adapter = Glueby::Internal::Wallet::TapyrusCoreWalletAdapter.new
+      when :activerecord
+        Glueby::Internal::Wallet.wallet_adapter = Glueby::Internal::Wallet::ActiveRecordWalletAdapter.new
+      else
+        raise 'Not implemented'
+      end
+    end
+
+    # Specify connection information to Tapyrus Core RPC.
+    # @param [Hash] config
+    # @option config [String] :schema - http or https
+    # @option config [String] :host - The host of the RPC endpoint
+    # @option config [Integer] :port - The port of the RPC endpoint
+    # @Option config [String] :user - The user for Basic Authorization of the RPC endpoint
+    # @Option config [String] :password - The password for Basic Authorization of the RPC endpoint
+    def rpc_config=(config)
+      Glueby::Internal::RPC.configure(config)
+    end
+
+    # Use This to enable to use FeeProvider to supply inputs for fees on each transaction that is created on Glueby.
+    def fee_provider_bears!
+      @fee_provider_bears = true
+    end
+
+    # Use This to disable to use FeeProvider
+    def disable_fee_provider_bears!
+      @fee_provider_bears = false
+    end
+
+    # Specify FeeProvider configuration.
+    # @param [Hash] config
+    # @option config [Integer] :fixed_fee - The fee that Fee Provider pays on each transaction.
+    # @option config [Integer] :utxo_pool_size - Fee Provider tries to keep the number of utxo in utxo pool as this size using `glueby:fee_provider:manage_utxo_pool` rake task
+    def fee_provider_config=(config)
+      FeeProvider.configure(config)
+    end
+  end
+end

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/contract/active_record.rb

@@ -3,6 +3,7 @@ require 'active_record'
 module Glueby
   module Contract
     module AR
+      autoload :ReissuableToken, 'glueby/contract/active_record/reissuable_token'
       autoload :Timestamp, 'glueby/contract/active_record/timestamp'
     end
   end

data/lib/glueby/contract/active_record/reissuable_token.rb

@@ -0,0 +1,26 @@
+module Glueby
+  module Contract
+    module AR
+      class ReissuableToken < ::ActiveRecord::Base
+
+        # Get the script_pubkey corresponding to the color_id in Tapyrus::Script format
+        # @param [String] color_id
+        # @return [Tapyrus::Script]
+        def self.script_pubkey(color_id)
+          script_pubkey = Glueby::Contract::AR::ReissuableToken.where(color_id: color_id).pluck(:script_pubkey).first
+          if script_pubkey
+            Tapyrus::Script.parse_from_payload(script_pubkey.htb)
+          end
+        end
+
+        # Check if the color_id is already stored
+        # @param [String] color_id
+        # @return [Boolean]
+        def self.saved?(color_id)
+          Glueby::Contract::AR::ReissuableToken.where(color_id: color_id).exists?
+        end
+
+      end
+    end
+  end
+end

data/lib/glueby/contract/fee_estimator.rb

@@ -0,0 +1,38 @@
+module Glueby
+  module Contract
+    module FeeEstimator
+      # @param [Tapyrus::Tx] tx - The target tx
+      # @return fee by tapyrus(not TPC).
+      def fee(tx)
+        return 0 if Glueby.configuration.fee_provider_bears?
+        estimate_fee(tx)
+      end
+
+      private
+
+      # @private
+      # @abstract Override in subclasses. This is would be implemented an actual estimation logic.
+      # @param [Tapyrus::Tx] tx - The target tx
+      # @return fee by tapyrus(not TPC).
+      def estimate_fee(tx)
+        raise NotImplementedError
+      end
+    end
+
+    class FixedFeeEstimator
+      include FeeEstimator
+
+      def initialize(fixed_fee: 10_000)
+        @fixed_fee = fixed_fee
+      end
+
+      private
+
+      # @private
+      # @return fee by tapyrus(not TPC).
+      def estimate_fee(_tx)
+        @fixed_fee
+      end
+    end
+  end
+end

data/lib/glueby/contract/payment.rb

@@ -11,6 +11,10 @@ module Glueby
     #                      or
     #            Glueby::Wallet.create
     #
+    # Use `Glueby::Internal::Wallet#receive_address` to generate the address of a receiver
+    # receiver.internal_wallet.receive_address
+    # => '1CY6TSSARn8rAFD9chCghX5B7j4PKR8S1a'
+    #
     # Balance of sender and receiver before send
     # sender.balances[""]
     # => 100_000(tapyrus)
@@ -18,7 +22,7 @@ module Glueby
     # => 0(tapyrus)
     #
     # Send
-    # Payment.transfer(sender: sender, receiver: receiver, amount: 10_000)
+    # Payment.transfer(sender: sender, receiver_address: '1CY6TSSARn8rAFD9chCghX5B7j4PKR8S1a', amount: 10_000)
     # sender.balances[""]
     # => 90_000
     # receiver.balances[""]
@@ -28,25 +32,25 @@ module Glueby
       extend Glueby::Contract::TxBuilder
 
       class << self
-        def transfer(sender:, receiver:, amount:, fee_provider: FixedFeeProvider.new)
+        def transfer(sender:, receiver_address:, amount:, fee_estimator: FixedFeeEstimator.new)
           raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
           tx = Tapyrus::Tx.new
-          dummy_fee = fee_provider.fee(dummy_tx(tx))
+          dummy_fee = fee_estimator.fee(dummy_tx(tx))
 
           sum, outputs = sender.internal_wallet.collect_uncolored_outputs(dummy_fee + amount)
           fill_input(tx, outputs)
 
-          receiver_script = Tapyrus::Script.parse_from_addr(receiver.internal_wallet.receive_address)
+          receiver_script = Tapyrus::Script.parse_from_addr(receiver_address)
           tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_script)
 
-          fee = fee_provider.fee(tx)
+          fee = fee_estimator.fee(tx)
 
           fill_change_tpc(tx, sender, sum - fee - amount)
 
           tx = sender.internal_wallet.sign_tx(tx)
 
-          Glueby::Internal::RPC.client.sendrawtransaction(tx.to_hex)
+          sender.internal_wallet.broadcast(tx)
         end
       end
     end

data/lib/glueby/contract/timestamp.rb

@@ -10,15 +10,17 @@ module Glueby
     class Timestamp
       include Glueby::Contract::TxBuilder
 
+      autoload :Syncer, 'glueby/contract/timestamp/syncer'
+
       module Util
         include Glueby::Internal::Wallet::TapyrusCoreWalletAdapter::Util
         module_function
 
-        def create_tx(wallet, prefix, data, fee_provider)
+        def create_tx(wallet, prefix, data, fee_estimator)
           tx = Tapyrus::Tx.new
           tx.outputs << Tapyrus::TxOut.new(value: 0, script_pubkey: create_script(prefix, data))
   
-          fee = fee_provider.fee(dummy_tx(tx))
+          fee = fee_estimator.fee(dummy_tx(tx))
           sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee)
           fill_input(tx, outputs)
   
@@ -50,7 +52,7 @@ module Glueby
 
       # @param [String] content Data to be hashed and stored in blockchain.
       # @param [String] prefix prefix of op_return data
-      # @param [Glueby::Contract::FeeProvider] fee_provider
+      # @param [Glueby::Contract::FeeEstimator] fee_estimator
       # @param [Symbol] digest type which select of:
       # - :sha256
       # - :double_sha256
@@ -60,13 +62,13 @@ module Glueby
         wallet:,
         content:,
         prefix: '',
-        fee_provider: Glueby::Contract::FixedFeeProvider.new,
+        fee_estimator: Glueby::Contract::FixedFeeEstimator.new,
         digest: :sha256
       )
         @wallet = wallet
         @content = content
         @prefix = prefix
-        @fee_provider = fee_provider
+        @fee_estimator = fee_estimator
         @digest = digest
       end
 
@@ -77,7 +79,7 @@ module Glueby
       def save!
         raise Glueby::Contract::Errors::TxAlreadyBroadcasted if @txid
 
-        @tx = create_tx(@wallet, @prefix, digest_content, @fee_provider)
+        @tx = create_tx(@wallet, @prefix, digest_content, @fee_estimator)
         @txid = @wallet.internal_wallet.broadcast(@tx)
       end