glueby 0.3.0 → 0.4.0

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

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

data/lib/glueby/contract/fee_estimator.rb

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

data/lib/glueby/contract/payment.rb

@@ -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.rb

@@ -14,11 +14,11 @@ module Glueby
         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 +50,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 +60,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 +77,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

@@ -55,14 +55,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 +72,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 +119,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 +127,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 +145,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 +154,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 +188,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 +209,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

data/lib/glueby/contract/tx_builder.rb

@@ -3,26 +3,29 @@
 module Glueby
   module Contract
     module TxBuilder
+      # The amount of output in funding tx for Reissuable token.
+      FUNDING_TX_AMOUNT = 10_000
+
       def receive_address(wallet:)
         wallet.receive_address
       end
 
       # Create new public key, and new transaction that sends TPC to it
-      def create_funding_tx(wallet:, amount:, script: nil, fee_provider: FixedFeeProvider.new)
+      def create_funding_tx(wallet:, script: nil, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
 
-        sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee + amount)
+        sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee + FUNDING_TX_AMOUNT)
         fill_input(tx, outputs)
 
         receiver_script = script ? script : Tapyrus::Script.parse_from_addr(wallet.internal_wallet.receive_address)
-        tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_script)
+        tx.outputs << Tapyrus::TxOut.new(value: FUNDING_TX_AMOUNT, script_pubkey: receiver_script)
 
-        fill_change_tpc(tx, wallet, sum - fee - amount)
+        fill_change_tpc(tx, wallet, sum - fee - FUNDING_TX_AMOUNT)
         wallet.internal_wallet.sign_tx(tx)
       end
 
-      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_provider: FixedFeeProvider.new)
+      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -34,7 +37,7 @@ module Glueby
         receiver_colored_script = receiver_script.add_color(color_id)
         tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
         prev_txs = [{
           txid: funding_tx.txid,
@@ -45,18 +48,18 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_issue_tx_for_non_reissuable_token(issuer:, amount:, fee_provider: FixedFeeProvider.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NON_REISSUABLE, issuer: issuer, amount: amount, fee_provider: fee_provider)
+      def create_issue_tx_for_non_reissuable_token(issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
+        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NON_REISSUABLE, issuer: issuer, amount: amount, fee_estimator: fee_estimator)
       end
 
-      def create_issue_tx_for_nft_token(issuer:, fee_provider: FixedFeeProvider.new)
-        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NFT, issuer: issuer, amount: 1, fee_provider: fee_provider)
+      def create_issue_tx_for_nft_token(issuer:, fee_estimator: FixedFeeEstimator.new)
+        create_issue_tx_from_out_point(token_type: Tapyrus::Color::TokenTypes::NFT, issuer: issuer, amount: 1, fee_estimator: fee_estimator)
       end
 
-      def create_issue_tx_from_out_point(token_type:, issuer:, amount:, fee_provider: FixedFeeProvider.new)
+      def create_issue_tx_from_out_point(token_type:, issuer:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
-        fee = fee_provider.fee(dummy_issue_tx_from_out_point)
+        fee = fee_estimator.fee(dummy_issue_tx_from_out_point)
         sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee)
         fill_input(tx, outputs)
 
@@ -78,7 +81,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx)
       end
 
-      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_provider: FixedFeeProvider.new)
+      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
@@ -89,7 +92,7 @@ module Glueby
         receiver_colored_script = receiver_script.add_color(color_id)
         tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
         fill_change_tpc(tx, issuer, output.value - fee)
         prev_txs = [{
           txid: funding_tx.txid,
@@ -100,7 +103,7 @@ module Glueby
         issuer.internal_wallet.sign_tx(tx, prev_txs)
       end
 
-      def create_transfer_tx(color_id:, sender:, receiver_address:, amount:, fee_provider: FixedFeeProvider.new)
+      def create_transfer_tx(color_id:, sender:, receiver_address:, amount:, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
@@ -113,7 +116,7 @@ module Glueby
 
         fill_change_token(tx, sender, sum_token - amount, color_id)
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
         sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee)
         fill_input(tx, outputs)
 
@@ -121,7 +124,7 @@ module Glueby
         sender.internal_wallet.sign_tx(tx)
       end
 
-      def create_burn_tx(color_id:, sender:, amount: 0, fee_provider: FixedFeeProvider.new)
+      def create_burn_tx(color_id:, sender:, amount: 0, fee_estimator: FixedFeeEstimator.new)
         tx = Tapyrus::Tx.new
 
         utxos = sender.internal_wallet.list_unspent
@@ -130,7 +133,7 @@ module Glueby
 
         fill_change_token(tx, sender, sum_token - amount, color_id) if amount.positive?
 
-        fee = fee_provider.fee(dummy_tx(tx))
+        fee = fee_estimator.fee(dummy_tx(tx))
 
         dust = 600 # in case that the wallet has output which has just fee amount.
         sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee + dust)

data/lib/glueby/fee_provider.rb

@@ -0,0 +1,73 @@
+module Glueby
+  class FeeProvider
+
+    autoload :Tasks, 'glueby/fee_provider/tasks'
+
+    class NoUtxosInUtxoPool < StandardError; end
+
+    WALLET_ID = 'FEE_PROVIDER_WALLET'
+    DEFAULT_FIXED_FEE = 1000
+    DEFAULT_UTXO_POOL_SIZE = 20
+
+    attr_reader :fixed_fee, :utxo_pool_size, :wallet,
+
+    class << self
+      attr_reader :config
+
+      # @param [Hash] config
+      # @option config [Integer] :fixed_fee The amount of fee which FeeProvider would provide to the txs
+      # @option opts [Integer] :utxo_pool_size The number of UTXOs in UTXO pool that is managed by FeeProvider
+      def configure(config)
+        @config = config
+      end
+
+      def provide(tx)
+        new.provide(tx)
+      end
+    end
+
+    def initialize
+      @wallet = begin
+                  Internal::Wallet.load(WALLET_ID)
+                rescue Internal::Wallet::Errors::WalletNotFound => _
+                  Internal::Wallet.create(WALLET_ID)
+                end
+
+      @fixed_fee = (FeeProvider.config && FeeProvider.config[:fixed_fee]) || DEFAULT_FIXED_FEE
+      @utxo_pool_size = (FeeProvider.config && FeeProvider.config[:utxo_pool_size]) || DEFAULT_UTXO_POOL_SIZE
+    end
+
+    # 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::FeeProvider::NoUtxosInUtxoPool] If there are no UTXOs for paying fee in FeeProvider's UTXO pool
+    def provide(tx)
+      tx.inputs.each do |txin|
+        sig = get_signature(txin.script_sig)
+        unless sig[-1].unpack1('C') & Tapyrus::SIGHASH_TYPE[:anyonecanpay] == Tapyrus::SIGHASH_TYPE[:anyonecanpay]
+          raise ArgumentError, 'All the signatures that the tx inputs has should have ANYONECANPAY flag.'
+        end
+      end
+
+      utxo = utxo_for_fee
+      out_point = Tapyrus::OutPoint.new(utxo[:txid].rhex, utxo[:vout])
+      tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+
+      wallet.sign_tx(tx, for_fee_provider_input: true)
+    end
+
+    private
+
+    def utxo_for_fee
+      utxo = wallet.list_unspent.select { |o| !o[:color_id] && o[:amount] == fixed_fee }.sample
+      raise NoUtxosInUtxoPool, 'No UTXOs in Fee Provider UTXO pool. UTXOs should be created with "glueby:fee_provider:manage_utxo_pool" rake task' unless utxo
+      utxo
+    end
+
+    # Get Signature from P2PKH or CP2PKH script sig
+    def get_signature(script_sig)
+      script_sig.chunks.first.pushed_data
+    end
+  end
+end