glueby 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2f53ca4e5784495dc9ddc7669bc021985614b3719205247c42005ec5d12a5c4
-  data.tar.gz: d5bb0540f3db7cf5ccdb96d4487ff627c4090f69e8719f746badae31689f864d
+  metadata.gz: 53718ece4b629ff6474c139b047e08c4803739cb992b61aa4f49c10ca96bc90f
+  data.tar.gz: 774199828793ab8c00c3b5d3a501ffa5e265395e7e036407d7ef0edd7f798998
 SHA512:
-  metadata.gz: 037ac4f566439facb0971a34c086bb128afd4b00566b7ab0f9013d4b4c357082c88a620eb8262221a245586429387228811e940077868b254b1ec82d155de8ab
-  data.tar.gz: 9a031d6505750f550abe9948ff977cd01f4fbcad8ab9b733f0b322101cc77d9856c6d2e3f633e61c9e49b4657dc7f286db1abdd4df0511cedf96dba9c27a2d3d
+  metadata.gz: 89cb7a6e1a9573bd840811bf75da2d83f9a77eaf1d265e0ba617093e788eeb785f23d80ea67e934714f2773565d26065a4a3daa56bc8d544cc13d2bbd66f3049
+  data.tar.gz: d1616df8862ede1f1046119f321b22faf8dd7f6193d4a14ca7a38388d60c6f9e5ac97408480b4c38c2d817036424aeba9f2c50574c655b7ac7f9f3e0522a0cac

data/README.md

@@ -457,6 +457,11 @@ Glueby.configure do |config|
 end
 ```
 
+## Error handling
+
+Glueby has base error classes like `Glueby::Error` and `Glueby::ArgumentError`.
+`Glueby::Error` is the base class for the all errors that are raises in the glueby.
+`Glueby::ArgumentError` is the error class for argument errors in public contracts. This notifies the arguments is something wrong to glueby library user-side.
 
 ## Development
 

data/glueby.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'tapyrus', '>= 0.2.9'
+  spec.add_runtime_dependency 'tapyrus', '>= 0.2.13'
   spec.add_runtime_dependency 'activerecord', '~> 6.1.3'
   spec.add_development_dependency 'sqlite3'
   spec.add_development_dependency 'rails', '~> 6.1.3'

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

@@ -9,6 +9,10 @@ class CreateTimestamp < ActiveRecord::Migration<%= migration_version %>
       t.integer  :timestamp_type, null: false, default: 0
       t.string   :p2c_address
       t.string   :payment_base
+      t.bigint   :prev_id
+      t.boolean  :latest, null: false, default: true
     end
+
+    add_index :glueby_timestamps, [:prev_id], unique: true
   end
 end

data/lib/glueby/active_record/system_information.rb

@@ -12,22 +12,91 @@ module Glueby
         find_by(info_key: "use_only_finalized_utxo")&.int_value != 0
       end
 
+
+      # Set use_only_finalized_utxo
+      # @param [Boolean] status status of whether to use only finalized utxo
+      def self.set_use_only_finalized_utxo(status)
+        current = find_by(info_key: "use_only_finalized_utxo")
+        if current
+          current.update!(info_value: boolean_to_string(status))
+        else
+          create!(
+            info_key: "use_only_finalized_utxo", 
+            info_value: boolean_to_string(status)
+          )
+        end
+      end
+
       # Return default value of the utxo provider
       # @return [Integer] default value of utxo provider
       def self.utxo_provider_default_value
         find_by(info_key: "utxo_provider_default_value")&.int_value
       end
 
+      # Set utxo_provider_default_value
+      # @param [Integer] value default value for utxo provider
+      def self.set_utxo_provider_default_value(value)
+        current = find_by(info_key: "utxo_provider_default_value")
+        if current
+          current.update!(info_value: value)
+        else
+          create!(
+            info_key: "utxo_provider_default_value", 
+            info_value: value
+          )
+        end
+      end
+
       # Return pool size of the utxo provider
       # @return [Integer] pool size of utxo provider
       def self.utxo_provider_pool_size
         find_by(info_key: "utxo_provider_pool_size")&.int_value
       end
 
+      # Set utxo_provider_pool_size
+      # @param [Integer] size pool size of the utxo provider
+      def self.set_utxo_provider_pool_size(size)
+        current = find_by(info_key: "utxo_provider_pool_size")
+        if current
+          current.update!(info_value: size)
+        else
+          create!(
+            info_key: "utxo_provider_pool_size", 
+            info_value: size
+          )
+        end
+      end
+
+      # If return timestamp is to be executed immediately
+      # @return [Boolean] true status of broadcast_on_background
+      def self.broadcast_on_background?
+        find_by(info_key: "broadcast_on_background")&.int_value != 0
+      end
+
+      # Set the status of broadcast_on_background
+      # @param [Boolean] status status of broadcast_on_background
+      def self.set_broadcast_on_background(status)
+        current = find_by(info_key: "broadcast_on_background")
+        if current
+         current.update!(info_value: boolean_to_string(status))
+        else
+          create!(
+            info_key: "broadcast_on_background", 
+            info_value: boolean_to_string(status)
+          )
+        end
+      end
+
       def int_value
         info_value.to_i
       end
 
+      private
+
+      def self.boolean_to_string(status)
+        status ? "1" : "0"
+      end
+
     end
   end
 end

data/lib/glueby/configuration.rb

@@ -15,7 +15,7 @@ module Glueby
     alias_method :use_utxo_provider?, :use_utxo_provider
 
     module Errors
-      class InvalidConfiguration < StandardError; end
+      class InvalidConfiguration < Error; end
     end
 
     def initialize

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

@@ -3,53 +3,179 @@ module Glueby
     module AR
       class Timestamp < ::ActiveRecord::Base
         include Glueby::GluebyLogger
-        include Glueby::Contract::Timestamp::Util
-        include Glueby::Contract::TxBuilder
 
         enum status: { init: 0, unconfirmed: 1, confirmed: 2 }
         enum timestamp_type: { simple: 0, trackable: 1 }
 
+        attr_reader :tx
+
+        belongs_to :prev, class_name: 'Glueby::Contract::AR::Timestamp'
+
+        class << self
+          def digest_content(content, digest)
+            case digest&.downcase
+            when :sha256
+              Tapyrus.sha256(content).bth
+            when :double_sha256
+              Tapyrus.double_sha256(content).bth
+            when :none
+              content
+            else
+              raise Glueby::Contract::Errors::UnsupportedDigestType
+            end
+          end
+        end
+
         # @param [Hash] attributes attributes which consist of:
         # - wallet_id
         # - content
         # - prefix(optional)
         # - timestamp_type(optional)
+        # @raise [Glueby::ArgumentError] If the timestamp_type is not in :simple or :trackable
         def initialize(attributes = nil)
-          @content_hash = Tapyrus.sha256(attributes[:content]).bth
-          super(wallet_id: attributes[:wallet_id], content_hash: @content_hash,
-                prefix: attributes[:prefix] ? attributes[:prefix] : '', status: :init, timestamp_type: attributes[:timestamp_type] || :simple)
+          # Set content_hash from :content attribute
+          content_hash = Timestamp.digest_content(attributes[:content], attributes[:digest] || :sha256)
+          super(
+            wallet_id: attributes[:wallet_id],
+            content_hash: content_hash,
+            prefix: attributes[:prefix] ? attributes[:prefix] : '',
+            status: :init,
+            timestamp_type: attributes[:timestamp_type] || :simple,
+            prev_id: attributes[:prev_id]
+          )
+        rescue ::ArgumentError => e
+          raise Glueby::ArgumentError, e.message
         end
 
         # Return true if timestamp type is 'trackable' and output in timestamp transaction has not been spent yet, otherwise return false.
-        def latest
-          trackable?
+        def latest?
+          trackable? && attributes['latest']
+        end
+        alias_method :latest, :latest?
+
+        # Returns a UTXO that corresponds to the timestamp
+        # @return [Hash] UTXO
+        #   - [String] script_pubkey A script pubkey hex string
+        #   - [String] txid A txid
+        #   - [Integer] vout An index of the tx
+        #   - [Integer] amount A value of
+        def utxo
+          {
+            script_pubkey: Tapyrus::Script.parse_from_addr(p2c_address).to_hex,
+            txid: txid,
+            vout: Contract::Timestamp::TxBuilder::PAY_TO_CONTRACT_INPUT_INDEX,
+            amount: Glueby::Contract::Timestamp::P2C_DEFAULT_VALUE
+          }
         end
 
         # Broadcast and save timestamp
         # @param [Glueby::Contract::FixedFeeEstimator] fee_estimator
+        # @param [Glueby::UtxoProvider] utxo_provider
         # @return true if tapyrus transactions were broadcasted and the timestamp was updated successfully, otherwise false.
-        def save_with_broadcast(fee_estimator: Glueby::Contract::FixedFeeEstimator.new)
-          utxo_provider = Glueby::UtxoProvider.new if Glueby.configuration.use_utxo_provider?
-          wallet = Glueby::Wallet.load(wallet_id)
-          funding_tx, tx, p2c_address, payment_base = create_txs(wallet, prefix, content_hash, fee_estimator, utxo_provider, type: timestamp_type.to_sym)
+        def save_with_broadcast(fee_estimator: Glueby::Contract::FixedFeeEstimator.new, utxo_provider: nil)
+          save_with_broadcast!(fee_estimator: fee_estimator, utxo_provider: utxo_provider)
+        rescue Errors::FailedToBroadcast, Errors::PrevTimestampNotFound, Errors::PrevTimestampIsNotTrackable => e
+          logger.error("failed to broadcast (id=#{id}, reason=#{e.message})")
+          false
+        end
+
+        # Broadcast and save timestamp, and it raises errors
+        # @param [Glueby::Contract::FixedFeeEstimator] fee_estimator
+        # @param [Glueby::UtxoProvider] utxo_provider
+        # @return true if tapyrus transactions were broadcasted and the timestamp was updated successfully
+        # @raise [Glueby::Contract::Errors::FailedToBroadcast] If the broadcasting is failure
+        # @raise [Glueby::Contract::Errors::PrevTimestampNotFound] If it is not available that the timestamp record which correspond with the prev_id attribute
+        # @raise [Glueby::Contract::Errors::PrevTimestampIsNotTrackable] If the timestamp record by prev_id is not trackable
+        def save_with_broadcast!(fee_estimator: Glueby::Contract::FixedFeeEstimator.new, utxo_provider: nil)
+          utxo_provider = Glueby::UtxoProvider.new if !utxo_provider && Glueby.configuration.use_utxo_provider?
+
+          funding_tx, tx, p2c_address, payment_base = create_txs(fee_estimator, utxo_provider)
+
           if funding_tx
             ::ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
               wallet.internal_wallet.broadcast(funding_tx)
-              logger.info("funding tx was broadcasted(id=#{id}, funding_tx.txid=#{funding_tx.txid})")
             end
+            logger.info("funding tx was broadcasted(id=#{id}, funding_tx.txid=#{funding_tx.txid})")
           end
           ::ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
             wallet.internal_wallet.broadcast(tx) do |tx|
               assign_attributes(txid: tx.txid, status: :unconfirmed, p2c_address: p2c_address, payment_base: payment_base)
+              @tx = tx
               save!
+
+              if update_trackable?
+                prev.latest = false
+                prev.save!
+              end
             end
-            logger.info("timestamp tx was broadcasted (id=#{id}, txid=#{tx.txid})")
           end
+          logger.info("timestamp tx was broadcasted (id=#{id}, txid=#{tx.txid})")
           true
-        rescue => e
-          logger.error("failed to broadcast (id=#{id}, reason=#{e.message})")
+        rescue ActiveRecord::RecordInvalid,
+               Tapyrus::RPC::Error,
+               Internal::Wallet::Errors::WalletAlreadyLoaded,
+               Internal::Wallet::Errors::WalletNotFound,
+               Errors::InsufficientFunds => e
           errors.add(:base, "failed to broadcast (id=#{id}, reason=#{e.message})")
-          false
+          raise Errors::FailedToBroadcast, "failed to broadcast (id=#{id}, reason=#{e.message})"
+        end
+
+        private
+
+        def wallet
+          @wallet ||= Glueby::Wallet.load(wallet_id)
+        end
+
+        def create_txs(fee_estimator, utxo_provider)
+          builder = builder_class.new(wallet, fee_estimator)
+
+          if builder.instance_of?(Contract::Timestamp::TxBuilder::UpdatingTrackable)
+            unless prev
+              message = "The previous timestamp(id: #{prev_id}) not found."
+              errors.add(:prev_id, message)
+              raise Errors::PrevTimestampNotFound, message
+            end
+
+            unless prev.trackable?
+              message = "The previous timestamp(id: #{prev_id}) type must be trackable"
+              errors.add(:prev_id, message)
+              raise Errors::PrevTimestampIsNotTrackable, message
+            end
+
+            builder.set_prev_timestamp_info(
+              timestamp_utxo: prev.utxo,
+              payment_base: prev.payment_base,
+              prefix: prev.prefix,
+              data: prev.content_hash
+            )
+          end
+
+          tx = builder.set_data(prefix, content_hash)
+                      .set_inputs(utxo_provider)
+                      .build
+
+          if builder.instance_of?(Contract::Timestamp::TxBuilder::Simple)
+            [builder.funding_tx, tx, nil, nil]
+          else
+            [builder.funding_tx, tx, builder.p2c_address, builder.payment_base]
+          end
+        end
+
+        def builder_class
+          case timestamp_type.to_sym
+          when :simple
+            Contract::Timestamp::TxBuilder::Simple
+          when :trackable
+            if prev_id
+              Contract::Timestamp::TxBuilder::UpdatingTrackable
+            else
+              Contract::Timestamp::TxBuilder::Trackable
+            end
+          end
+        end
+
+        def update_trackable?
+          trackable? && prev_id
         end
       end
     end

data/lib/glueby/contract/errors.rb

@@ -1,16 +1,22 @@
 module Glueby
   module Contract
     module Errors
-      class InsufficientFunds < StandardError; end
-      class InsufficientTokens < StandardError; end
-      class InvalidAmount < StandardError; end
-      class InvalidSplit < StandardError; end
-      class InvalidTokenType < StandardError; end
-      class InvalidTimestampType < StandardError; end
-      class TxAlreadyBroadcasted < StandardError; end
-      class UnsupportedTokenType < StandardError; end
-      class UnknownScriptPubkey < StandardError; end
-      class UnsupportedDigestType < StandardError; end
+      class InsufficientFunds < Error; end
+      class InsufficientTokens < Error; end
+      class TxAlreadyBroadcasted < Error; end
+      class FailedToBroadcast < Error; end
+
+      # Argument Errors
+      class ArgumentError < ArgumentError; end
+      class InvalidAmount < ArgumentError; end
+      class InvalidSplit < ArgumentError; end
+      class InvalidTokenType < ArgumentError; end
+      class InvalidTimestampType < ArgumentError; end
+      class UnsupportedTokenType < ArgumentError; end
+      class UnknownScriptPubkey < ArgumentError; end
+      class UnsupportedDigestType < ArgumentError; end
+      class PrevTimestampNotFound < ArgumentError; end
+      class PrevTimestampIsNotTrackable < ArgumentError; end
     end
   end
 end

data/lib/glueby/contract/timestamp/tx_builder/simple.rb

@@ -0,0 +1,97 @@
+module Glueby
+  module Contract
+    class Timestamp
+      module TxBuilder
+        # The simple Timestamp method
+        class Simple
+          include Glueby::Contract::TxBuilder
+
+          attr_reader :funding_tx
+
+          def initialize(wallet, fee_estimator)
+            @wallet = wallet
+            @fee_estimator = fee_estimator
+
+            @txb = Tapyrus::TxBuilder.new
+            @prev_txs = []
+          end
+
+          def build
+            @txb.fee(fee).change_address(@wallet.internal_wallet.change_address)
+            sign_tx
+          end
+
+          def set_data(prefix, data)
+            @prefix = prefix
+            @data = data
+
+            @txb.data(prefix + data)
+            self
+          end
+
+          def set_inputs(utxo_provider)
+            if utxo_provider
+              script_pubkey = Tapyrus::Script.parse_from_addr(@wallet.internal_wallet.receive_address)
+              @funding_tx, index = utxo_provider.get_utxo(script_pubkey, fee)
+
+              utxo = {
+                script_pubkey: @funding_tx.outputs[index].script_pubkey.to_hex,
+                txid: @funding_tx.txid,
+                vout: index,
+                amount: funding_tx.outputs[index].value
+              }
+
+              @txb.add_utxo(to_tapyrusrb_utxo_hash(utxo))
+              @prev_txs << to_sign_tx_utxo_hash(utxo)
+            else
+              _, outputs = @wallet.internal_wallet.collect_uncolored_outputs(fee)
+              outputs.each do |utxo|
+                @txb.add_utxo(to_tapyrusrb_utxo_hash(utxo))
+              end
+            end
+            self
+          end
+
+          private
+
+          def fee
+            @fee ||= @fee_estimator.fee(dummy_tx(@txb.build))
+          end
+
+          def sign_tx
+            # General signing process skips signing to p2c inputs because no key of the p2c address in the wallet.
+            @wallet.internal_wallet.sign_tx(@txb.build, @prev_txs)
+          end
+
+          # @param utxo
+          # @option utxo [String] :txid The txid
+          # @option utxo [Integer] :vout The index of the output in the tx
+          # @option utxo [Integer] :amount The value of the output
+          # @option utxo [String] :script_pubkey The hex string of the script pubkey
+          def to_tapyrusrb_utxo_hash(utxo)
+            {
+              script_pubkey: Tapyrus::Script.parse_from_payload(utxo[:script_pubkey].htb),
+              txid: utxo[:txid],
+              index: utxo[:vout],
+              value: utxo[:amount]
+            }
+          end
+
+          # @param utxo
+          # @option utxo [String] :txid The txid
+          # @option utxo [Integer] :vout The index of the output in the tx
+          # @option utxo [Integer] :amount The value of the output
+          # @option utxo [String] :script_pubkey The hex string of the script pubkey
+          def to_sign_tx_utxo_hash(utxo)
+            {
+              scriptPubKey: utxo[:script_pubkey],
+              txid: utxo[:txid],
+              vout: utxo[:vout],
+              amount: utxo[:amount]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glueby/contract/timestamp/tx_builder/trackable.rb

@@ -0,0 +1,23 @@
+module Glueby
+  module Contract
+    class Timestamp
+      module TxBuilder
+        class Trackable < Simple
+          attr_reader :p2c_address, :payment_base
+
+          # @override
+          def set_data(prefix, data)
+            @prefix = prefix
+            @data = data
+
+            # Create a new trackable timestamp
+            @p2c_address, @payment_base = @wallet.internal_wallet
+                                                 .create_pay_to_contract_address([prefix, data].join)
+            @txb.pay(p2c_address, P2C_DEFAULT_VALUE)
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glueby/contract/timestamp/tx_builder/updating_trackable.rb

@@ -0,0 +1,28 @@
+module Glueby
+  module Contract
+    class Timestamp
+      module TxBuilder
+        class UpdatingTrackable < Trackable
+          def set_prev_timestamp_info(timestamp_utxo:, payment_base:, prefix:, data:)
+            @prev_timestamp_utxo = timestamp_utxo
+            @prev_payment_base = payment_base
+            @prev_prefix = prefix
+            @prev_data = data
+            @txb.add_utxo(to_tapyrusrb_utxo_hash(@prev_timestamp_utxo))
+          end
+
+          def sign_tx
+            tx = super
+            # Generates signature for the remain p2c input.
+            @wallet.internal_wallet.sign_to_pay_to_contract_address(
+              tx,
+              @prev_timestamp_utxo,
+              @prev_payment_base,
+              [@prev_prefix, @prev_data].join
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Glueby
+  module Contract
+    class Timestamp
+      module TxBuilder
+        autoload :Simple, 'glueby/contract/timestamp/tx_builder/simple'
+        autoload :Trackable, 'glueby/contract/timestamp/tx_builder/trackable'
+        autoload :UpdatingTrackable, 'glueby/contract/timestamp/tx_builder/updating_trackable'
+
+        # A transaction input to update trackable timestamp must placed at this index in the tx inputs.
+        PAY_TO_CONTRACT_INPUT_INDEX = 0
+      end
+    end
+  end
+end

data/lib/glueby/contract/timestamp.rb

@@ -8,87 +8,16 @@ module Glueby
     #
     # Storing timestamp transaction to the blockchain enables everyone to verify that the data existed at that time and a user signed it.
     class Timestamp
-      include Glueby::Contract::TxBuilder
-      
       P2C_DEFAULT_VALUE = 1_000
 
       autoload :Syncer, 'glueby/contract/timestamp/syncer'
-
-      module Util
-        include Glueby::Internal::Wallet::TapyrusCoreWalletAdapter::Util
-        module_function
-
-        # @param [Glueby::Wallet] wallet
-        # @param [Array] contents The data to be used for generating pay-to-contract address
-        # @return [pay-to-contract address, public key used for generating address]
-        def create_pay_to_contract_address(wallet, contents: nil)
-          pubkey = wallet.internal_wallet.create_pubkey.pubkey
-          # Calculate P + H(P || contents)G
-          group = ECDSA::Group::Secp256k1
-          p = Tapyrus::Key.new(pubkey: pubkey).to_point # P
-          commitment = Tapyrus.sha256(p.to_hex(true).htb + contents.join).bth.to_i(16) % group.order # H(P || contents)
-          point = p + group.generator.multiply_by_scalar(commitment) # P + H(P || contents)G
-          [Tapyrus::Key.new(pubkey: point.to_hex(true)).to_p2pkh, pubkey] # [p2c address, P]
-        end
-
-        def create_txs(wallet, prefix, data, fee_estimator, utxo_provider, type: :simple)
-          txb = Tapyrus::TxBuilder.new
-          if type == :simple
-            txb.data(prefix + data)
-          elsif type == :trackable
-            p2c_address, payment_base = create_pay_to_contract_address(wallet, contents: [prefix, data])
-            txb.pay(p2c_address, P2C_DEFAULT_VALUE)
-          end
-
-          fee = fee_estimator.fee(dummy_tx(txb.build))
-          if utxo_provider
-            script_pubkey = Tapyrus::Script.parse_from_addr(wallet.internal_wallet.receive_address)
-            funding_tx, index = utxo_provider.get_utxo(script_pubkey, fee)
-            txb.add_utxo({
-              script_pubkey: funding_tx.outputs[index].script_pubkey,
-              txid: funding_tx.txid,
-              index: index,
-              value: funding_tx.outputs[index].value
-            })
-          else
-            sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee)
-            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
-          end
-
-          prev_txs = if funding_tx
-            output = funding_tx.outputs.first
-            [{
-              txid: funding_tx.txid,
-              vout: 0,
-              scriptPubKey: output.script_pubkey.to_hex,
-              amount: output.value
-            }]
-          else
-            []
-          end
-
-          txb.fee(fee).change_address(wallet.internal_wallet.change_address)
-          [funding_tx, wallet.internal_wallet.sign_tx(txb.build, prev_txs), p2c_address, payment_base]
-        end
-
-        def get_transaction(tx)
-          Glueby::Internal::RPC.client.getrawtransaction(tx.txid, 1)
-        end
-      end
-      include Glueby::Contract::Timestamp::Util
+      autoload :TxBuilder, 'glueby/contract/timestamp/tx_builder'
 
       attr_reader :tx, :txid
-
       # p2c_address and payment_base is used in `trackable` type
       attr_reader :p2c_address, :payment_base
 
+      # @param [Gleuby::Wallet] wallet The wallet that is sender of the timestamp transaction.
       # @param [String] content Data to be hashed and stored in blockchain.
       # @param [String] prefix prefix of op_return data
       # @param [Glueby::Contract::FeeEstimator] fee_estimator
@@ -99,6 +28,7 @@ module Glueby
       # @param [Symbol] timestamp_type
       # - :simple
       # - :trackable
+      # @param [Integer] prev_timestamp_id The id column of glueby_timestamps that will be updated by the timestamp that will be created
       # @raise [Glueby::Contract::Errors::UnsupportedDigestType] if digest is unsupported
       # @raise [Glueby::Contract::Errors::InvalidTimestampType] if timestamp_type is unsupported
       def initialize(
@@ -108,7 +38,8 @@ module Glueby
         fee_estimator: Glueby::Contract::FixedFeeEstimator.new,
         digest: :sha256,
         utxo_provider: nil,
-        timestamp_type: :simple
+        timestamp_type: :simple,
+        prev_timestamp_id: nil
       )
         @wallet = wallet
         @content = content
@@ -119,33 +50,46 @@ module Glueby
         @utxo_provider = utxo_provider
         raise Glueby::Contract::Errors::InvalidTimestampType, "#{timestamp_type} is invalid type, supported types are :simple, and :trackable." unless [:simple, :trackable].include?(timestamp_type)
         @timestamp_type = timestamp_type
+        @prev_timestamp_id = prev_timestamp_id
       end
 
       # broadcast to Tapyrus Core
       # @return [String] txid
-      # @raise [TxAlreadyBroadcasted] if tx has been broadcasted.
-      # @raise [InsufficientFunds] if result of listunspent is not enough to pay the specified amount
+      # @raise [Glueby::Contract::Errors::TxAlreadyBroadcasted] if tx has been broadcasted.
+      # @raise [Glueby::Contract::Errors::InsufficientFunds] if result of listunspent is not enough to pay the specified amount
       def save!
-        raise Glueby::Contract::Errors::TxAlreadyBroadcasted if @txid
+        raise Glueby::Contract::Errors::TxAlreadyBroadcasted if @ar
+
+        @ar = Glueby::Contract::AR::Timestamp.new(
+          wallet_id: @wallet.id,
+          prefix: @prefix,
+          content: @content,
+          timestamp_type: @timestamp_type,
+          digest: @digest,
+          prev_id: @prev_timestamp_id
+        )
+        @ar.save_with_broadcast!(fee_estimator: @fee_estimator, utxo_provider: @utxo_provider)
+        @ar.txid
+      end
 
-        funding_tx, @tx, @p2c_address, @payment_base = create_txs(@wallet, @prefix, digest_content, @fee_estimator, @utxo_provider, type: @timestamp_type)
-        @wallet.internal_wallet.broadcast(funding_tx) if funding_tx
-        @txid = @wallet.internal_wallet.broadcast(@tx)
+      def txid
+        raise Glueby::Error, 'The timestamp tx is not broadcasted yet.' unless @ar
+        @ar.txid
       end
 
-      private
+      def tx
+        raise Glueby::Error, 'The timestamp tx is not broadcasted yet.' unless @ar
+        @ar.tx
+      end
+
+      def p2c_address
+        raise Glueby::Error, 'The timestamp tx is not broadcasted yet.' unless @ar
+        @ar.p2c_address
+      end
 
-      def digest_content
-        case @digest&.downcase
-        when :sha256
-          Tapyrus.sha256(@content)
-        when :double_sha256
-          Tapyrus.double_sha256(@content)
-        when :none
-          @content
-        else
-          raise Glueby::Contract::Errors::UnsupportedDigestType
-        end
+      def payment_base
+        raise Glueby::Error, 'The timestamp tx is not broadcasted yet.' unless @ar
+        @ar.payment_base
       end
     end
   end

data/lib/glueby/contract/token.rb

@@ -91,11 +91,14 @@ module Glueby
           script_pubkey = funding_tx.outputs.first.script_pubkey
           color_id = Tapyrus::Color::ColorIdentifier.reissuable(script_pubkey)
 
+          ActiveRecord::Base.transaction(joinable: false, requires_new: true) do
+            funding_tx = issuer.internal_wallet.broadcast(funding_tx)
+          end
+
           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, split: split)
             tx = issuer.internal_wallet.broadcast(tx)
             [[funding_tx, tx], color_id]

data/lib/glueby/contract.rb

@@ -8,6 +8,5 @@ module Glueby
     autoload :Token, 'glueby/contract/token'
     autoload :TxBuilder, 'glueby/contract/tx_builder'
     autoload :AR, 'glueby/contract/active_record'
-    autoload :Wallet, 'glueby/contract/wallet'
   end
 end

data/lib/glueby/fee_provider.rb

@@ -3,7 +3,7 @@ module Glueby
 
     autoload :Tasks, 'glueby/fee_provider/tasks'
 
-    class NoUtxosInUtxoPool < StandardError; end
+    class NoUtxosInUtxoPool < Error; end
 
     WALLET_ID = 'FEE_PROVIDER_WALLET'
     DEFAULT_FIXED_FEE = 1000
@@ -42,7 +42,7 @@ module Glueby
     # Provide an input for fee to the tx.
     # @param [Tapyrus::Tx] tx - The tx that is provided fee as a input. It should be signed with ANYONECANPAY flag.
     # @return [Tapyrus::Tx]
-    # @raise [ArgumentError] If the signatures that the tx inputs has don't have ANYONECANPAY flag.
+    # @raise [Glueby::ArgumentError] If the signatures that the tx inputs has don't have ANYONECANPAY flag.
     # @raise [Glueby::FeeProvider::NoUtxosInUtxoPool] If there are no UTXOs for paying fee in FeeProvider's UTXO pool
     def provide(tx)
       tx.inputs.each do |txin|

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

@@ -148,6 +148,31 @@ module Glueby
         def get_addresses(wallet_id, label = nil)
           raise NotImplementedError, "You must implement #{self.class}##{__method__}"
         end
+
+        # Create and returns pay to contract address
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @param [String] contents - The data to be used for generating pay-to-contract address
+        # @return [String] pay to contract P2PKH address
+        def create_pay_to_contract_address(wallet_id, contents)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Sign to the pay to contract input
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @param [Tapyrus::Tx] tx - The tx that has pay to contract input in the inputs list
+        # @param [Hash] utxo - The utxo that indicates pay to contract output to be signed
+        # @option utxo [String] txid - Transaction id
+        # @option utxo [Integer] vout - Output index
+        # @option utxo [Integer] amount - The amount the output has
+        # @option utxo [String] script_pubkey - The script_pubkey hex string
+        # @param [String] payment_base - The public key that is used to generate pay to contract public key
+        # @param [String] contents - The data to be used for generating pay-to-contract address
+        # @param [Integer] sighashtype - The sighash flag for each signature that would be produced here.
+        # @return [Tapyrus::Tx]
+        # @raise [Glueby::Internal::Wallet::Errors::InvalidSighashType] when the specified sighashtype is invalid
+        def sign_to_pay_to_contract_address(wallet_id, tx, utxo, payment_base, contents, sighashtype: Tapyrus::SIGHASH_TYPE[:all])
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
       end
     end
   end

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

@@ -153,6 +153,51 @@ module Glueby
           keys = keys.where(label: label) if label
           keys.map(&:address)
         end
+
+        def create_pay_to_contract_address(wallet_id, contents)
+          # Calculate P + H(P || contents)G
+          group = ECDSA::Group::Secp256k1
+          pubkey = create_pubkey(wallet_id)
+          p = pubkey.to_point # P
+          commitment = create_pay_to_contract_commitment(pubkey, contents)
+          point = p + group.generator.multiply_by_scalar(commitment) # P + H(P || contents)G
+          [Tapyrus::Key.new(pubkey: point.to_hex(true)).to_p2pkh, pubkey.pubkey] # [p2c address, P]
+        end
+
+        def sign_to_pay_to_contract_address(wallet_id, tx, utxo, payment_base, contents)
+          key = create_pay_to_contract_private_key(wallet_id, payment_base, contents)
+          sighash = tx.sighash_for_input(utxo[:vout], Tapyrus::Script.parse_from_payload(utxo[:script_pubkey].htb))
+
+          sig = key.sign(sighash, algo: :schnorr) + [Tapyrus::SIGHASH_TYPE[:all]].pack('C')
+          script_sig = Tapyrus::Script.parse_from_payload(Tapyrus::Script.pack_pushdata(sig) + Tapyrus::Script.pack_pushdata(key.pubkey.htb))
+          tx.inputs[utxo[:vout]].script_sig = script_sig
+          tx
+        end
+
+        private
+
+        # Calculate commitment = H(P || contents)
+        # @param [Tapyrus::Key] pubkey The public key
+        # @param [String] contents
+        # @return Integer
+        def create_pay_to_contract_commitment(pubkey, contents)
+          group = ECDSA::Group::Secp256k1
+          p = pubkey.to_point # P
+          Tapyrus.sha256(p.to_hex(true).htb + contents).bth.to_i(16) % group.order # H(P || contents)
+        end
+
+        # @param [String] wallet_id
+        # @param [String] payment_base The public key hex string
+        # @param [String] contents
+        # @return [Tapyrus::Key] pay to contract private key
+        def create_pay_to_contract_private_key(wallet_id, payment_base, contents)
+          group = ECDSA::Group::Secp256k1
+          wallet = AR::Wallet.find_by(wallet_id: wallet_id)
+          ar_key = wallet.keys.where(public_key: payment_base).first
+          key = Tapyrus::Key.new(pubkey: payment_base)
+          commitment = create_pay_to_contract_commitment(key, contents)
+          Tapyrus::Key.new(priv_key: ((ar_key.private_key.to_i(16) + commitment) % group.order).to_even_length_hex) # K + commitment
+        end
       end
     end
   end

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

@@ -2,12 +2,12 @@ module Glueby
   module Internal
     class Wallet
       module Errors
-        class ShouldInitializeWalletAdapter < StandardError; end
-        class WalletUnloaded < StandardError; end
-        class WalletAlreadyLoaded < StandardError; end
-        class WalletAlreadyCreated < StandardError; end
-        class WalletNotFound < StandardError; end
-        class InvalidSighashType < StandardError; end
+        class ShouldInitializeWalletAdapter < Error; end
+        class WalletUnloaded < Error; end
+        class WalletAlreadyLoaded < Error; end
+        class WalletAlreadyCreated < Error; end
+        class WalletNotFound < Error; end
+        class InvalidSighashType < Error; end
       end
     end
   end

data/lib/glueby/internal/wallet.rb

@@ -154,6 +154,14 @@ module Glueby
         wallet_adapter.get_addresses(id, label)
       end
 
+      def create_pay_to_contract_address(contents)
+        wallet_adapter.create_pay_to_contract_address(id, contents)
+      end
+
+      def sign_to_pay_to_contract_address(tx, utxo, payment_base, contents)
+        wallet_adapter.sign_to_pay_to_contract_address(id, tx, utxo, payment_base, contents)
+      end
+
       private
 
       def wallet_adapter

data/lib/glueby/utxo_provider/tasks.rb

@@ -30,14 +30,14 @@ module Glueby
 
         utxos.each { |utxo| txb.add_utxo(utxo) }
 
-        shortage = [utxo_provider.utxo_pool_size - current_utxo_pool_size, 0].max
+        shortage = [utxo_provider.utxo_pool_size - utxo_provider.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)
+          txb.pay(utxo_provider.address, utxo_provider.default_value)
           sum -= utxo_provider.default_value
           added_outputs += 1
         end
@@ -45,11 +45,11 @@ module Glueby
         return if added_outputs == 0
 
         fee = utxo_provider.fee_estimator.fee(dummy_tx(txb.build))
-        tx = txb.change_address(address)
+        tx = txb.change_address(utxo_provider.address)
                 .fee(fee)
                 .build
-        tx = wallet.sign_tx(tx)
-        wallet.broadcast(tx)
+        tx = utxo_provider.wallet.sign_tx(tx)
+        utxo_provider.wallet.broadcast(tx)
       ensure
         status
       end
@@ -58,13 +58,13 @@ module Glueby
       def status
         status = :ready
 
-        if current_utxo_pool_size < utxo_provider.utxo_pool_size
-          if tpc_amount < value_to_fill_utxo_pool
+        if utxo_provider.current_utxo_pool_size < utxo_provider.utxo_pool_size
+          if utxo_provider.tpc_amount < utxo_provider.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 '#{address}'
+              UtxoProvider needs #{utxo_provider.value_to_fill_utxo_pool} tapyrus in UTXO pool. 
+              UtxoProvider wallet's address is '#{utxo_provider.address}'
             2. Then create UTXOs for paying in UTXO pool with 'rake glueby:utxo_provider:manage_utxo_pool'
             MESSAGE
           else
@@ -72,12 +72,12 @@ module Glueby
           end
         end
 
-        status = :not_ready if current_utxo_pool_size == 0
+        status = :not_ready if utxo_provider.current_utxo_pool_size == 0
 
         puts <<~EOS
         Status: #{STATUS[status]}
-        TPC amount: #{delimit(tpc_amount)}
-        UTXO pool size: #{delimit(current_utxo_pool_size)}
+        TPC amount: #{delimit(utxo_provider.tpc_amount)}
+        UTXO pool size: #{delimit(utxo_provider.current_utxo_pool_size)}
         #{"\n" if message}#{message}
         Configuration:
           default_value = #{delimit(utxo_provider.default_value)}
@@ -87,17 +87,13 @@ module Glueby
 
       # Show the address of Utxo Provider 
       def print_address
-        puts address
+        puts utxo_provider.address
       end
 
       private
 
-      def tpc_amount
-        wallet.balance(false)
-      end
-
       def collect_outputs
-        wallet.list_unspent.inject([0, []]) do |sum, output|
+        utxo_provider.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]
@@ -105,34 +101,16 @@ module Glueby
             txid: output[:txid],
             script_pubkey: output[:script_pubkey],
             value: output[:amount],
-            index: output[:vout] ,
+            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
-
-      def address
-        @address ||= wallet.get_addresses.first || wallet.receive_address
-      end
     end
   end
 end

data/lib/glueby/utxo_provider.rb

@@ -27,7 +27,7 @@ module Glueby
       @fee_estimator = (UtxoProvider.config && UtxoProvider.config[:fee_estimator]) || Glueby::Contract::FixedFeeEstimator.new
     end
 
-    attr_reader :wallet, :fee_estimator
+    attr_reader :wallet, :fee_estimator, :address
 
     # Provide a UTXO
     # @param [Tapyrus::Script] script_pubkey The script to be provided
@@ -78,6 +78,24 @@ module Glueby
         )
     end
 
+    def tpc_amount
+      wallet.balance(false)
+    end
+
+    def current_utxo_pool_size
+      wallet
+        .list_unspent(false)
+        .count { |o| !o[:color_id] && o[:amount] == default_value }
+    end
+
+    def address
+      @address ||= wallet.get_addresses.first || wallet.receive_address
+    end
+
+    def value_to_fill_utxo_pool
+      default_value * utxo_pool_size
+    end
+
     private
 
     # Create wallet for provider

data/lib/glueby/version.rb

@@ -1,3 +1,3 @@
 module Glueby
-  VERSION = "0.8.0"
+  VERSION = "0.10.0"
 end

data/lib/glueby.rb

@@ -48,4 +48,9 @@ module Glueby
   def self.configure
     yield configuration if block_given?
   end
+
+  # Base error classes. These error classes must be used as a super class in all error classes that is defined and
+  # raised in glueby library.
+  class Error < StandardError; end
+  class ArgumentError < Error; end
 end

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

@@ -4,7 +4,6 @@ module Glueby
       module Timestamp
         module_function
         extend Glueby::Contract::TxBuilder
-        extend Glueby::Contract::Timestamp::Util
 
         def create
           timestamps = Glueby::Contract::AR::Timestamp.where(status: :init)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glueby
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - azuchi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-28 00:00:00.000000000 Z
+date: 2022-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tapyrus
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.9
+        version: 0.2.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.9
+        version: 0.2.13
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -113,6 +113,10 @@ files:
 - lib/glueby/contract/payment.rb
 - lib/glueby/contract/timestamp.rb
 - lib/glueby/contract/timestamp/syncer.rb
+- lib/glueby/contract/timestamp/tx_builder.rb
+- lib/glueby/contract/timestamp/tx_builder/simple.rb
+- lib/glueby/contract/timestamp/tx_builder/trackable.rb
+- lib/glueby/contract/timestamp/tx_builder/updating_trackable.rb
 - lib/glueby/contract/token.rb
 - lib/glueby/contract/tx_builder.rb
 - lib/glueby/fee_provider.rb