glueby 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cae8a0e06be77affdb1895724a26137b5fde2bab8cc27fb73d9aa45f2c351c5
-  data.tar.gz: 2cc677f69e1cc1ad3e6468662e476b4bd5082b0e765f15f44b6b63426b2663f9
+  metadata.gz: 53718ece4b629ff6474c139b047e08c4803739cb992b61aa4f49c10ca96bc90f
+  data.tar.gz: 774199828793ab8c00c3b5d3a501ffa5e265395e7e036407d7ef0edd7f798998
 SHA512:
-  metadata.gz: 3e0a80b28635f37a37b4d37eac3fc3bc697bfb3ce580a8c481c60e40fe7776bfcfcb24720d33771e5d73d19c745d03afbee7b380dedd3d0ec51b7258bbb9363b
-  data.tar.gz: fd3d0edae5b99212cea7e4a710dd8f52173e1b707617beb881e7f9715afac575e76d5abc18b291f7defa62c7acb4c4e5772163a0953126a2f3fcfeb6a72aa953
+  metadata.gz: 89cb7a6e1a9573bd840811bf75da2d83f9a77eaf1d265e0ba617093e788eeb785f23d80ea67e934714f2773565d26065a4a3daa56bc8d544cc13d2bbd66f3049
+  data.tar.gz: d1616df8862ede1f1046119f321b22faf8dd7f6193d4a14ca7a38388d60c6f9e5ac97408480b4c38c2d817036424aeba9f2c50574c655b7ac7f9f3e0522a0cac

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

@@ -3,35 +3,94 @@ 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)
@@ -41,15 +100,82 @@ module Glueby
           ::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
           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

@@ -4,8 +4,10 @@ module Glueby
       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
@@ -13,6 +15,8 @@ module Glueby
       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.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/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.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/version.rb

@@ -1,3 +1,3 @@
 module Glueby
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 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.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - azuchi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-02-17 00:00:00.000000000 Z
+date: 2022-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tapyrus
@@ -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