glueby 0.3.0 → 0.4.3

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

@@ -32,11 +32,11 @@ module Glueby
       extend Glueby::Contract::TxBuilder
 
       class << self
-        def transfer(sender:, receiver_address:, 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)
@@ -44,13 +44,13 @@ module Glueby
           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/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/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
 

data/lib/glueby/contract/token.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'active_record'
 
 module Glueby
   module Contract
@@ -55,14 +56,14 @@ module Glueby
         # @param issuer [Glueby::Wallet]
         # @param token_type [TokenTypes]
         # @param amount [Integer]
-        # @return [Token] token
+        # @return [Array<token, Array<tx>>] Tuple of tx array and token object
         # @raise [InsufficientFunds] if wallet does not have enough TPC to send transaction.
         # @raise [InvalidAmount] if amount is not positive integer.
         # @raise [UnspportedTokenType] if token is not supported.
         def issue!(issuer:, token_type: Tapyrus::Color::TokenTypes::REISSUABLE, amount: 1)
           raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
 
-          txs, color_id, script_pubkey = case token_type
+          txs, color_id = case token_type
                          when Tapyrus::Color::TokenTypes::REISSUABLE
                            issue_reissuable_token(issuer: issuer, amount: amount)
                          when Tapyrus::Color::TokenTypes::NON_REISSUABLE
@@ -72,33 +73,44 @@ module Glueby
                          else
                            raise Glueby::Contract::Errors::UnsupportedTokenType
                          end
-          txs.each { |tx| issuer.internal_wallet.broadcast(tx) }
-          new(color_id: color_id, script_pubkey: script_pubkey)
+
+          [new(color_id: color_id), txs]
         end
 
         private
 
         def issue_reissuable_token(issuer:, amount:)
-          estimated_fee = FixedFeeProvider.new.fee(Tapyrus::Tx.new)
-          funding_tx = create_funding_tx(wallet: issuer, amount: estimated_fee)
-          tx = create_issue_tx_for_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount)
+          funding_tx = create_funding_tx(wallet: issuer)
           script_pubkey = funding_tx.outputs.first.script_pubkey
           color_id = Tapyrus::Color::ColorIdentifier.reissuable(script_pubkey)
-          [[funding_tx, tx], color_id, script_pubkey]
+
+          ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+            # Store the script_pubkey for reissue the token.
+            Glueby::Contract::AR::ReissuableToken.create!(color_id: color_id.to_hex, script_pubkey: script_pubkey.to_hex)
+
+            funding_tx = issuer.internal_wallet.broadcast(funding_tx)
+            tx = create_issue_tx_for_reissuable_token(funding_tx: funding_tx, issuer: issuer, amount: amount)
+            tx = issuer.internal_wallet.broadcast(tx)
+            [[funding_tx, tx], color_id]
+          end
         end
 
         def issue_non_reissuable_token(issuer:, amount:)
           tx = create_issue_tx_for_non_reissuable_token(issuer: issuer, amount: amount)
+          tx = issuer.internal_wallet.broadcast(tx)
+
           out_point = tx.inputs.first.out_point
           color_id = Tapyrus::Color::ColorIdentifier.non_reissuable(out_point)
-          [[tx], color_id, nil]
+          [[tx], color_id]
         end
 
         def issue_nft_token(issuer:)
           tx = create_issue_tx_for_nft_token(issuer: issuer)
+          tx = issuer.internal_wallet.broadcast(tx)
+
           out_point = tx.inputs.first.out_point
           color_id = Tapyrus::Color::ColorIdentifier.nft(out_point)
-          [[tx], color_id, nil]
+          [[tx], color_id]
         end
       end
 
@@ -108,6 +120,7 @@ module Glueby
       # A wallet can issue the token only when it is REISSUABLE token.
       # @param issuer [Glueby::Wallet]
       # @param amount [Integer]
+      # @return [Array<String, tx>] Tuple of color_id and tx object
       # @raise [InsufficientFunds] if wallet does not have enough TPC to send transaction.
       # @raise [InvalidAmount] if amount is not positive integer.
       # @raise [InvalidTokenType] if token is not reissuable.
@@ -115,12 +128,17 @@ module Glueby
       def reissue!(issuer:, amount:)
         raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
         raise Glueby::Contract::Errors::InvalidTokenType unless token_type == Tapyrus::Color::TokenTypes::REISSUABLE
-        raise Glueby::Contract::Errors::UnknownScriptPubkey unless @script_pubkey
 
-        estimated_fee = FixedFeeProvider.new.fee(Tapyrus::Tx.new)
-        funding_tx = create_funding_tx(wallet: issuer, amount: estimated_fee, script: @script_pubkey)
-        tx = create_reissue_tx(funding_tx: funding_tx, issuer: issuer, amount: amount, color_id: color_id)
-        [funding_tx, tx].each { |tx| issuer.internal_wallet.broadcast(tx) }
+        if validate_reissuer(wallet: issuer)
+          funding_tx = create_funding_tx(wallet: issuer, script: @script_pubkey)
+          funding_tx = issuer.internal_wallet.broadcast(funding_tx)
+          tx = create_reissue_tx(funding_tx: funding_tx, issuer: issuer, amount: amount, color_id: color_id)
+          tx = issuer.internal_wallet.broadcast(tx)
+
+          [color_id, tx]
+        else
+          raise Glueby::Contract::Errors::UnknownScriptPubkey
+        end
       end
 
       # Send the token to other wallet
@@ -128,7 +146,7 @@ module Glueby
       # @param sender [Glueby::Wallet] wallet to send this token
       # @param receiver_address [String] address to receive this token
       # @param amount [Integer]
-      # @return [Token] receiver token
+      # @return [Array<String, tx>] Tuple of color_id and tx object
       # @raise [InsufficientFunds] if wallet does not have enough TPC to send transaction.
       # @raise [InsufficientTokens] if wallet does not have enough token to send.
       # @raise [InvalidAmount] if amount is not positive integer.
@@ -137,6 +155,7 @@ module Glueby
 
         tx = create_transfer_tx(color_id: color_id, sender: sender, receiver_address: receiver_address, amount: amount)
         sender.internal_wallet.broadcast(tx)
+        [color_id, tx]
       end
 
       # Burn token
@@ -170,12 +189,19 @@ module Glueby
         color_id.type
       end
 
+      # Return the script_pubkey of the token from ActiveRecord
+      # @return [String] script_pubkey
+      def script_pubkey
+        @script_pubkey ||= Glueby::Contract::AR::ReissuableToken.script_pubkey(@color_id.to_hex)
+      end
+
       # Return serialized payload
       # @return [String] payload
       def to_payload
         payload = +''
         payload << @color_id.to_payload
-        payload << @script_pubkey.to_payload if @script_pubkey
+        payload << @script_pubkey.to_payload if script_pubkey
+        payload
       end
 
       # Restore token from payload
@@ -184,14 +210,36 @@ module Glueby
       def self.parse_from_payload(payload)
         color_id, script_pubkey = payload.unpack('a33a*')
         color_id = Tapyrus::Color::ColorIdentifier.parse_from_payload(color_id)
-        script_pubkey = Tapyrus::Script.parse_from_payload(script_pubkey) if script_pubkey
-        new(color_id: color_id, script_pubkey: script_pubkey)
+        if color_id.type == Tapyrus::Color::TokenTypes::REISSUABLE
+          raise ArgumentError, 'script_pubkey should not be empty' if script_pubkey.empty?
+          script_pubkey = Tapyrus::Script.parse_from_payload(script_pubkey)
+          Glueby::Contract::AR::ReissuableToken.create!(color_id: color_id.to_hex, script_pubkey: script_pubkey.to_hex)
+        end
+        new(color_id: color_id)
       end
 
-      def initialize(color_id:, script_pubkey:nil)
+      # Generate Token Instance
+      # @param color_id [String]
+      def initialize(color_id:)
         @color_id = color_id
-        @script_pubkey = script_pubkey
+      end
+
+      private
+
+      # Verify that wallet is the issuer of the reissuable token
+      #　reutrn [Boolean]
+      def validate_reissuer(wallet:)
+        addresses = wallet.internal_wallet.get_addresses
+        addresses.each do |address|
+          decoded_address = Tapyrus.decode_base58_address(address)
+          pubkey_hash_from_address = decoded_address[0]
+          pubkey_hash_from_script = Tapyrus::Script.parse_from_payload(script_pubkey.chunks[2])
+          if pubkey_hash_from_address == pubkey_hash_from_script.to_s
+            return true
+          end
+        end
+        false
       end
     end
   end
-end
+end