glueby 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d128fa095b1dacb936a8a9ff3306b750d3cf258133f6fa469ccaf9d4d830c08
-  data.tar.gz: 0a0496a04b1a6b86d3f2790555ac832094cb2a809ea10262f0641520dc7cb96b
+  metadata.gz: fbaba6627d1c34e6a2de2a3861016995481ad53163764a057c25fca123a8750b
+  data.tar.gz: 209020a3b503ac44cc9d4ef51e95d7ce71f17af59b92ffe3bb4863b4ae750604
 SHA512:
-  metadata.gz: '07178bc49443f227073442e2d5e767e2350a1b363f72b1041b6f2feb2a6a7a413399617c97017acf73537d49e57f10d0aecb7439a8524a7c80691ccaf0620ce6'
-  data.tar.gz: 86d4f463995f258d3ab3496206eabc97af77f16554705f61db69c339efc146d876375cda34bf8a17425954bf51ad6c1699eb19f37676e54401c57e5026bec597
+  metadata.gz: 559e4f224359df179cafc4f20c19f3f7c9723f6411103532ad6fd7d9727b5063c369b44e4e6c7872bc49d9355ec0cedd4f720c195302546cab7a5e5b429f6676
+  data.tar.gz: b4a4a1641820f23513ea56e1c240db966bcb9b0d62fd463d54f08e09f454125cdca4a087bc8db8c9b0181cd867ee667ec1b2bf5fbe1b95329541b3dd5fe2538b

data/README.md

@@ -1,9 +1,31 @@
 # Glueby [![Ruby](https://github.com/chaintope/glueby/actions/workflows/ruby.yml/badge.svg)](https://github.com/chaintope/glueby/actions/workflows/ruby.yml) [![Gem Version](https://badge.fury.io/rb/glueby.svg)](https://badge.fury.io/rb/glueby) [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)
 
+Glueby is a smart contract library on the [Tapyrus blockchain](https://github.com/chaintope/tapyrus-core). This is 
+designed as you can use without any deep blockchain understanding.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/glueby`. To experiment with that code, run `bin/console` for an interactive prompt.
+## Features
 
-TODO: Delete this and the text above, and describe your gem
+Glueby has below features.
+
+1. Wallet
+   You can manage wallets for application users. This wallet feature is a foundation of Contracts below to specify tx
+   sender and so on.  
+   You can choose two sorts of wallet implementation :activerecord and :core. :activerecord is implemented using
+   ActiveRecord on RDB. :core uses the wallet that bundled with Tapyrus Core.
+   
+2. Contracts  
+   You can use some smart contracts easily  
+   - [Timestamp](#Timestamp): Record any data as a timestamp to a tapyrus blockchain.
+   - [Payment](./lib/glueby/contract/payment.rb): Transfer TPC.
+   - [Token](./lib/glueby/contract/token.rb): Issue, transfer and burn colored coin.
+
+3. Sync blocks with your application   
+   You can use BlockSyncer when you need to synchronize the state of an application with the state of a blockchain.  
+   See more details at [BlockSyncer](./lib/glueby/block_syncer.rb).
+
+4. Take over tx sender's fees  
+   FeeProvider module can bear payments of sender's fees. You should provide funds for fees to FeeProvider before use.  
+   See how to set up at [Use fee provider mode](#use-fee-provider-mode)
 
 ## Installation
 
@@ -21,13 +43,95 @@ Or install it yourself as:
 
     $ gem install glueby
 
-## Usage
+### Setup for Ruby on Rails application development
 
-Glueby has below features.
+1. Add this line to your application's Gemfile
+
+    ```ruby
+    gem 'glueby'
+    ```
+
+    and then execute 
+    
+        $ bundle install
+
+2. Run installation rake task
+
+        $ rails glueby:contract:install
+
+3. Run Tapyrus Core as dev mode
+
+    We recommend to run as a Docker container. 
+    Docker image is here.
+
+    * [tapyus/tapyrusd](https://hub.docker.com/repository/docker/tapyrus/tapyrusd)
+
+    Starts tapryusd container
+
+        $ docker run -d --name 'tapyrus_node_dev' -p 12381:12381 -e GENESIS_BLOCK_WITH_SIG='0100000000000000000000000000000000000000000000000000000000000000000000002b5331139c6bc8646bb4e5737c51378133f70b9712b75548cb3c05f9188670e7440d295e7300c5640730c4634402a3e66fb5d921f76b48d8972a484cc0361e66ef74f45e012103af80b90d25145da28c583359beb47b21796b2fe1a23c1511e443e7a64dfdb27d40e05f064662d6b9acf65ae416379d82e11a9b78cdeb3a316d1057cd2780e3727f70a61f901d10acbe349cd11e04aa6b4351e782c44670aefbe138e99a5ce75ace01010000000100000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0100f2052a010000001976a91445d405b9ed450fec89044f9b7a99a4ef6fe2cd3f88ac00000000' tapyrus/tapyrusd:edge
+
+4. Modify the glueby configuration
+
+    ```ruby
+    # Use tapyrus dev network
+    Tapyrus.chain_params = :dev
+    Glueby.configure do |config|
+      config.wallet_adapter = :activerecord
+      # Modify rpc connection info in config/initializers/glueby.rb that is created in step 3.
+      config.rpc_config = { schema: 'http', host: '127.0.0.1', port: 12381, user: 'rpcuser', password: 'rpcpassword' }
+    end
+    ```
+
+5. Generate db migration files for wallet feature
+
+    These are essential if you use `config.wallet_adapter = :activerecord` configuration. 
+
+        $ rails g glueby:contract:block_syncer
+        $ rails g glueby:contract:wallet_adapter
+
+    If you want to use reissuable token or timestamp, you need to do below generators.
+
+        $ rails g glueby:contract:reissuable_token
+        $ rails g glueby:contract:timestamp
+
+    Then, run the migrations.
+
+        $ rails db:migrate
+
+### Provide initial TPC (Tapyrus Coin) to wallets
+
+To use contracts, wallets need to have TPC and it can be provided from coinbase tx.
+
+1. Create a wallet and get receive address 
+
+    ```ruby
+    wallet = Glueby::Wallet.create
+    wallet.balances # => {}
+    address = wallet.internal_wallet.receive_address
+    puts address
+    ```
+
+2. Generate a block
+
+    Set an address you got in previous step to `[Your address]`
+
+        $ docker exec tapyrus_node_dev tapyrus-cli -conf=/etc/tapyrus/tapyrus.conf generatetoaddress 1 "[Your address]" "cUJN5RVzYWFoeY8rUztd47jzXCu1p57Ay8V7pqCzsBD3PEXN7Dd4"
+
+3. Sync blocks if you use `:activerecord` wallet adapter
+
+    You don't need to do this if you are using `:core` wallet_adapter.
+
+        $ rails glueby:contract:block_syncer:start
+
+   Here the wallet created in step 1 have 50 TPC and you can see like this:
+
+    ```ruby
+    wallet.balances # =>  {""=>5000000000}
+    ```
 
-- [Timestamp](#Timestamp)
+    TPC amount is shown as tapyrus unit. 1 TPC = 100000000 tapyrus.
 
-### Timestamp
+## Timestamp
 
 ```ruby
 
@@ -99,7 +203,7 @@ We can see the timestamp transaction using getrawblockchain command
 }
 ```
 
-#### Rails support
+### Rails support
 
 Glueby supports ruby on rails integration.
 
@@ -155,11 +259,10 @@ bin/rails glueby:contract:timestamp:create
 broadcasted (id=1, txid=8d602ca8ebdd50fa70b5ee6bc6351965b614d0a4843adacf9f43fedd7112fbf4)
 ```
 
-Run `glueby:contract:timestamp:confirm` task to confirm the transaction and update status(unconfirmed -> confirmded).
+Run `glueby:block_syncer:start` task to confirm the transaction and update status(unconfirmed -> confirmded).
 
 ```
-bin/rails glueby:contract:timestamp:confirm
-confirmed (id=1, txid=8d602ca8ebdd50fa70b5ee6bc6351965b614d0a4843adacf9f43fedd7112fbf4)
+bin/rails glueby:block_syncer:start
 ```
 
 ## Use fee provider mode

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

@@ -1,3 +1,5 @@
 # Edit configuration for connection to tapyrus core
-config = {adapter: 'core', schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass'}
-Glueby::Wallet.configure(config)
+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

data/lib/glueby.rb

@@ -9,27 +9,17 @@ module Glueby
   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
 
-  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"
-        load "tasks/glueby/fee_provider.rake"
-      end
-    end
-  rescue
-    # Rake task is unavailable
-    puts "Rake task is unavailable"
-  end
-
   # Returns the global [Configuration](RSpec/Core/Configuration) object.
   def self.configuration
     @configuration ||= Glueby::Configuration.new

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

@@ -10,6 +10,8 @@ module Glueby
     class Timestamp
       include Glueby::Contract::TxBuilder
 
+      autoload :Syncer, 'glueby/contract/timestamp/syncer'
+
       module Util
         include Glueby::Internal::Wallet::TapyrusCoreWalletAdapter::Util
         module_function

data/lib/glueby/contract/timestamp/syncer.rb

@@ -0,0 +1,13 @@
+module Glueby
+  module Contract
+    class Timestamp
+      class Syncer
+        def block_sync(block)
+          Glueby::Contract::AR::Timestamp
+            .where(txid: block.transactions.map(&:txid), status: :unconfirmed)
+            .update_all(status: :confirmed)
+        end
+      end
+    end
+  end
+end

data/lib/glueby/fee_provider/tasks.rb

@@ -44,7 +44,7 @@ module Glueby
                 .fee(fee_provider.fixed_fee)
                 .build
         tx = wallet.sign_tx(tx)
-        wallet.broadcast(tx)
+        wallet.broadcast(tx, without_fee_provider: true)
       ensure
         status
       end
@@ -80,6 +80,11 @@ module Glueby
         EOS
       end
 
+      # Show the address of Fee Provider 
+      def address
+        puts wallet.receive_address
+      end
+
       private
 
       def check_wallet_amount!

data/lib/glueby/internal/wallet.rb

@@ -34,8 +34,6 @@ module Glueby
       autoload :Errors, 'glueby/internal/wallet/errors'
 
       class << self
-        attr_writer :wallet_adapter
-
         def create(wallet_id = nil)
           begin
             wallet_id = wallet_adapter.create_wallet(wallet_id)
@@ -58,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`.'
@@ -74,6 +82,10 @@ module Glueby
         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
@@ -99,8 +111,15 @@ module Glueby
         wallet_adapter.sign_tx(id, tx, prev_txs, sighashtype: sighashtype)
       end
 
-      def broadcast(tx)
-        tx = FeeProvider.provide(tx) if Glueby.configuration.fee_provider_bears?
+      # 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

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

@@ -54,6 +54,9 @@ module Glueby
       # alice_wallet.balances
       # ```
       class ActiveRecordWalletAdapter < AbstractWalletAdapter
+
+        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
@@ -90,7 +93,8 @@ module Glueby
           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
+          utxos = utxos.where(label: label) if label && (label != :unlabeled)
+          utxos = utxos.where(label: nil) if label == :unlabeled
           utxos.map do |utxo|
             {
               txid: utxo.txid,
@@ -118,7 +122,7 @@ module Glueby
 
         def receive_address(wallet_id, label = nil)
           wallet = AR::Wallet.find_by(wallet_id: wallet_id)
-          key = wallet.keys.create(purpose: :receive, label: label || '')
+          key = wallet.keys.create(purpose: :receive, label: label)
           key.address
         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/tapyrus_core_wallet_adapter.rb

@@ -33,7 +33,7 @@ module Glueby
           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']
+            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
@@ -52,9 +52,9 @@ module Glueby
         def load_wallet(wallet_id)
           RPC.client.loadwallet(wallet_name(wallet_id))
         rescue Tapyrus::RPC::Error => ex
-          if ex.rpc_error['code'] == RPC_WALLET_ERROR_ERROR_CODE && /Duplicate -wallet filename specified/ =~ ex.rpc_error['message']
+          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['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
+          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
@@ -88,7 +88,8 @@ module Glueby
             min_conf = only_finalized ? 1 : 0
             res = client.listunspent(min_conf)
 
-            res = res.filter { |i| i['label'] == label } if label
+            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)
@@ -151,7 +152,7 @@ module Glueby
             begin
               yield(client)
             rescue Tapyrus::RPC::Error => ex
-              if ex.rpc_error['code'] == RPC_WALLET_NOT_FOUND_ERROR_CODE
+              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

data/lib/glueby/railtie.rb

@@ -0,0 +1,14 @@
+module Glueby
+  class Railtie < ::Rails::Railtie
+    initializer "glueby.register_syncers" do
+      BlockSyncer.register_syncer(Contract::Timestamp::Syncer)
+    end
+
+    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.4.1"
+  VERSION = "0.4.2"
 end

data/lib/tasks/glueby/block_syncer.rake

@@ -0,0 +1,29 @@
+namespace :glueby do
+  namespace :contract do
+    namespace :block_syncer do
+      desc '[Deprecated use glueby:block_syncer:start instead] sync block into database'
+      task :start, [] => [:environment] do |_, _|
+        puts '[Deprecated] glueby:contract:block_syncer:start is deprecated. Use \'glueby:block_syncer:start\''
+        Rake::Task['glueby:block_syncer:start'].execute
+      end
+    end
+  end
+end
+
+
+namespace :glueby do
+  namespace :block_syncer do
+    desc 'sync block into database'
+    task :start, [] => [:environment] do |_, _|
+      latest_block_num = Glueby::Internal::RPC.client.getblockcount
+      synced_block = Glueby::AR::SystemInformation.synced_block_height
+      (synced_block.int_value + 1..latest_block_num).each do |height|
+        ::ActiveRecord::Base.transaction do
+          Glueby::BlockSyncer.new(height).run
+          synced_block.update(info_value: height.to_s)
+        end
+        puts "success in synchronization (block height=#{height})"
+      end
+    end
+  end
+end

data/lib/tasks/glueby/contract/timestamp.rake

@@ -13,9 +13,9 @@ module Glueby
               ::ActiveRecord::Base.transaction do
                 wallet = Glueby::Wallet.load(t.wallet_id)
                 tx = create_tx(wallet, t.prefix, t.content_hash, Glueby::Contract::FixedFeeEstimator.new)
-                t.update(txid: tx.txid, status: :unconfirmed)
-
-                wallet.internal_wallet.broadcast(tx)
+                wallet.internal_wallet.broadcast(tx) do |tx|
+                  t.update(txid: tx.txid, status: :unconfirmed)
+                end
                 puts "broadcasted (id=#{t.id}, txid=#{tx.txid})"
               end
             rescue => e
@@ -23,23 +23,6 @@ module Glueby
             end
           end
         end
-
-        def confirm
-          timestamps = Glueby::Contract::AR::Timestamp.where(status: :unconfirmed)
-          timestamps.each do |t|
-            begin
-              ::ActiveRecord::Base.transaction do
-                tx = get_transaction(t)
-                if tx['confirmations'] &&  tx['confirmations'] > 0
-                  t.update(status: :confirmed)
-                  puts "confirmed (id=#{t.id}, txid=#{tx['txid']})"
-                end
-              end
-            rescue => e
-              puts "failed to confirm (id=#{t.id}, reason=#{e.message})"
-            end
-          end
-        end
       end
     end
   end
@@ -52,11 +35,6 @@ namespace :glueby do
       task :create, [] => [:environment] do |_, _|
         Glueby::Contract::Task::Timestamp.create
       end
-
-      desc 'confirm glueby timestamp tx'
-      task :confirm, [] => [:environment] do |_, _|
-        Glueby::Contract::Task::Timestamp.confirm
-      end
     end
   end
 end

data/lib/tasks/glueby/fee_provider.rake

@@ -9,5 +9,10 @@ namespace :glueby do
     task :status, [] => [:environment] do |_, _|
       Glueby::FeeProvider::Tasks.new.status
     end
+
+    desc 'Show the address of the Glueby::FeeProvider'
+    task :address, [] => [:environment] do |_, _|
+      Glueby::FeeProvider::Tasks.new.address
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glueby
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - azuchi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-30 00:00:00.000000000 Z
+date: 2021-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tapyrus
@@ -87,6 +87,7 @@ files:
 - lib/glueby.rb
 - lib/glueby/active_record.rb
 - lib/glueby/active_record/system_information.rb
+- lib/glueby/block_syncer.rb
 - lib/glueby/configuration.rb
 - lib/glueby/contract.rb
 - lib/glueby/contract/active_record.rb
@@ -96,6 +97,7 @@ files:
 - lib/glueby/contract/fee_estimator.rb
 - lib/glueby/contract/payment.rb
 - lib/glueby/contract/timestamp.rb
+- lib/glueby/contract/timestamp/syncer.rb
 - lib/glueby/contract/token.rb
 - lib/glueby/contract/tx_builder.rb
 - lib/glueby/fee_provider.rb
@@ -111,14 +113,15 @@ files:
 - lib/glueby/internal/wallet/active_record/utxo.rb
 - lib/glueby/internal/wallet/active_record/wallet.rb
 - lib/glueby/internal/wallet/active_record_wallet_adapter.rb
+- lib/glueby/internal/wallet/active_record_wallet_adapter/syncer.rb
 - lib/glueby/internal/wallet/errors.rb
 - lib/glueby/internal/wallet/tapyrus_core_wallet_adapter.rb
+- lib/glueby/railtie.rb
 - lib/glueby/version.rb
 - lib/glueby/wallet.rb
+- lib/tasks/glueby/block_syncer.rake
 - lib/tasks/glueby/contract.rake
-- lib/tasks/glueby/contract/block_syncer.rake
 - lib/tasks/glueby/contract/timestamp.rake
-- lib/tasks/glueby/contract/wallet_adapter.rake
 - lib/tasks/glueby/fee_provider.rake
 homepage: https://github.com/chaintope/glueby
 licenses:

data/lib/tasks/glueby/contract/block_syncer.rake

@@ -1,36 +0,0 @@
-module Glueby
-  module Contract
-    module Task
-      module BlockSyncer
-
-        def sync_block
-          latest_block_num = Glueby::Internal::RPC.client.getblockcount
-          synced_block = Glueby::AR::SystemInformation.synced_block_height
-          (synced_block.int_value + 1..latest_block_num).each do |i|
-            ::ActiveRecord::Base.transaction do
-              block_hash = Glueby::Internal::RPC.client.getblockhash(i)
-              import_block(block_hash)
-              synced_block.update(info_value: i.to_s)
-              puts "success in synchronization (block height=#{i.to_s})"
-            end
-          end
-        end 
-
-      end
-    end
-  end
-end
-
-namespace :glueby do
-  namespace :contract do
-    namespace :block_syncer do
-      include Glueby::Contract::Task::BlockSyncer
-
-      desc 'sync block into database'
-      task :start, [] => [:environment] do |_, _|
-        Glueby::Contract::Task::BlockSyncer.sync_block
-      end
-
-    end
-  end
-end

data/lib/tasks/glueby/contract/wallet_adapter.rake

@@ -1,42 +0,0 @@
-module Glueby
-  module Contract
-    module Task
-      module WalletAdapter
-        def import_block(block_hash)
-          block = Glueby::Internal::RPC.client.getblock(block_hash, 0)
-          block = Tapyrus::Block.parse_from_payload(block.htb)
-          block.transactions.each { |tx| import_tx(tx.txid) }
-        end
-
-        def import_tx(txid)
-          tx = Glueby::Internal::RPC.client.getrawtransaction(txid)
-          tx = Tapyrus::Tx.parse_from_payload(tx.htb)
-          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
-
-namespace :glueby do
-  namespace :contract do
-    namespace :wallet_adapter do
-      include Glueby::Contract::Task::WalletAdapter
-
-      desc 'import block into database'
-      task :import_block, [:block_hash] => [:environment] do |_, args|
-        block_hash = args[:block_hash]
-
-        ::ActiveRecord::Base.transaction { import_block(block_hash) }
-      end
-
-      desc 'import transaction into database'
-      task :import_tx, [:txid] => [:environment] do |_, args|
-        txid = args[:txid]
-
-        ::ActiveRecord::Base.transaction { import_tx(txid) }
-      end
-    end
-  end
-end