glueby 0.1.0 → 0.2.0

data/lib/glueby/contract/token.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Glueby
+  module Contract
+    # This class represents custom token issued by application user.
+    # Application users can
+    # - issue their own tokens.
+    # - send to other users.
+    # - make the tokens disable.
+    #
+    # Examples:
+    #
+    # alice = Glueby::Wallet.create
+    # bob = Glueby::Wallet.create
+    #
+    # Issue
+    # token = Token.issue!(issuer: alice, amount: 100)
+    # token.amount(wallet: alice)
+    # => 100
+    #
+    # Send
+    # token.transfer!(sender: alice, receiver: bob, amount: 1)
+    # token.amount(wallet: alice)
+    # => 99
+    # token.amount(wallet: bob)
+    # => 1
+    #
+    # Burn
+    # token.burn!(sender: alice, amount: 10)
+    # token.amount(wallet: alice)
+    # => 89
+    # token.burn!(sender: alice)
+    # token.amount(wallet: alice)
+    # => 0
+    #
+    # Reissue
+    # token.reissue!(issuer: alice, amount: 100)
+    # token.amount(wallet: alice)
+    # => 100
+    #
+    class Token
+      include Glueby::Contract::TxBuilder
+      extend Glueby::Contract::TxBuilder
+
+      class << self
+        # Issue new token with specified amount and token type.
+        # REISSUABLE token can be reissued with #reissue! method, and
+        # NON_REISSUABLE and NFT token can not.
+        # Amount is set to 1 when the token type is NFT
+        #
+        # @param issuer [Glueby::Wallet]
+        # @param token_type [TokenTypes]
+        # @param amount [Integer]
+        # @return [Token] token
+        # @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
+                         when Tapyrus::Color::TokenTypes::REISSUABLE
+                           issue_reissuable_token(issuer: issuer, amount: amount)
+                         when Tapyrus::Color::TokenTypes::NON_REISSUABLE
+                           issue_non_reissuable_token(issuer: issuer, amount: amount)
+                         when Tapyrus::Color::TokenTypes::NFT
+                           issue_nft_token(issuer: issuer)
+                         else
+                           raise Glueby::Contract::Errors::UnsupportedTokenType
+                         end
+          txs.each { |tx| issuer.internal_wallet.broadcast(tx) }
+          new(color_id: color_id, script_pubkey: script_pubkey)
+        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)
+          script_pubkey = funding_tx.outputs.first.script_pubkey
+          color_id = Tapyrus::Color::ColorIdentifier.reissuable(script_pubkey)
+          [[funding_tx, tx], color_id, script_pubkey]
+        end
+
+        def issue_non_reissuable_token(issuer:, amount:)
+          tx = create_issue_tx_for_non_reissuable_token(issuer: issuer, amount: amount)
+          out_point = tx.inputs.first.out_point
+          color_id = Tapyrus::Color::ColorIdentifier.non_reissuable(out_point)
+          [[tx], color_id, nil]
+        end
+
+        def issue_nft_token(issuer:)
+          tx = create_issue_tx_for_nft_token(issuer: issuer)
+          out_point = tx.inputs.first.out_point
+          color_id = Tapyrus::Color::ColorIdentifier.nft(out_point)
+          [[tx], color_id, nil]
+        end
+      end
+
+      attr_reader :color_id
+
+      # Re-issue the token with specified amount.
+      # A wallet can issue the token only when it is REISSUABLE token.
+      # @param issuer [Glueby::Wallet]
+      # @param amount [Integer]
+      # @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.
+      # @raise [UnknownScriptPubkey] when token is reissuable but it doesn't know script pubkey to issue token.
+      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) }
+      end
+
+      # Send the token to other wallet
+      #
+      # @param sender [Glueby::Wallet] wallet to send this token
+      # @param receiver [Glueby::Wallet] wallet to receive this token
+      # @param amount [Integer]
+      # @return [Token] receiver token
+      # @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.
+      def transfer!(sender:, receiver:, amount: 1)
+        raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
+
+        tx = create_transfer_tx(color_id: color_id, sender: sender, receiver: receiver, amount: amount)
+        sender.internal_wallet.broadcast(tx)
+      end
+
+      # Burn token
+      # If amount is not specified or 0, burn all token associated with the wallet.
+      #
+      # @param sender [Glueby::Wallet] wallet to send this token
+      # @param amount [Integer]
+      # @raise [InsufficientFunds] if wallet does not have enough TPC to send transaction.
+      # @raise [InsufficientTokens] if wallet does not have enough token to send transaction.
+      # @raise [InvalidAmount] if amount is not positive integer.
+      def burn!(sender:, amount: 0)
+        raise Glueby::Contract::Errors::InvalidAmount unless amount.positive?
+
+        tx = create_burn_tx(color_id: color_id, sender: sender, amount: amount)
+        sender.internal_wallet.broadcast(tx)
+      end
+
+      # Return balance of token in the specified wallet.
+      # @param wallet [Glueby::Wallet]
+      # @return [Integer] amount of utxo value associated with this token.
+      def amount(wallet:)
+        # collect utxo associated with this address
+        utxos = wallet.internal_wallet.list_unspent
+        _, results = collect_colored_outputs(utxos, color_id)
+        results.sum { |result| result[:amount] }
+      end
+
+      # Return token type
+      # @return [Tapyrus::Color::TokenTypes]
+      def token_type
+        color_id.type
+      end
+
+      # Return serialized payload
+      # @return [String] payload
+      def to_payload
+        payload = +''
+        payload << @color_id.to_payload
+        payload << @script_pubkey.to_payload if @script_pubkey
+      end
+
+      # Restore token from payload
+      # @param payload [String]
+      # @return [Glueby::Contract::Token]
+      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)
+      end
+
+      def initialize(color_id:, script_pubkey:nil)
+        @color_id = color_id
+        @script_pubkey = script_pubkey
+      end
+    end
+  end
+end

data/lib/glueby/contract/tx_builder.rb

@@ -1,46 +1,212 @@
+# frozen_string_literal: true
+
 module Glueby
   module Contract
     module TxBuilder
-      # collect outputs in results so that sum of them exceeds up to the specified amount.
-      # @param [Array] results of listunspent
-      # @param [Numeric] amount
-      # @return [(Numeric, Array)] sum value of outputs and outputs
-      # @raise [InsufficientFunds] if result of listunspent is not enough to pay the specified amount
-      def collect_outputs(results, amount)
-        results.inject([0, []]) do |sum, output|
-          new_sum = sum[0] + (output['amount'] * 100_000_000)
-          new_outputs = sum[1] << output
-          return [new_sum, new_outputs] if new_sum >= amount
+      def receive_address(wallet:)
+        wallet.receive_address
+      end
 
-          [new_sum, new_outputs]
+      # Create new public key, and new transaction that sends TPC to it
+      def create_funding_tx(wallet:, amount:, script: nil, fee_provider: FixedFeeProvider.new)
+        tx = Tapyrus::Tx.new
+        fee = fee_provider.fee(dummy_tx(tx))
+
+        sum, outputs = wallet.internal_wallet.collect_uncolored_outputs(fee + 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)
+
+        fill_change_tpc(tx, wallet, sum - fee - amount)
+        wallet.internal_wallet.sign_tx(tx)
+      end
+
+      def create_issue_tx_for_reissuable_token(funding_tx:, issuer:, amount:, fee_provider: FixedFeeProvider.new)
+        tx = Tapyrus::Tx.new
+
+        out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
+        tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+        output = funding_tx.outputs.first
+
+        receiver_script = Tapyrus::Script.parse_from_payload(output.script_pubkey.to_payload)
+        color_id = Tapyrus::Color::ColorIdentifier.reissuable(receiver_script)
+        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))
+        fill_change_tpc(tx, issuer, output.value - fee)
+        prev_txs = [{
+          txid: funding_tx.txid,
+          vout: 0,
+          scriptPubKey: output.script_pubkey.to_hex,
+          amount: output.value
+        }]
+        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)
+      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)
+      end
+
+      def create_issue_tx_from_out_point(token_type:, issuer:, amount:, fee_provider: FixedFeeProvider.new)
+        tx = Tapyrus::Tx.new
+
+        fee = fee_provider.fee(dummy_issue_tx_from_out_point)
+        sum, outputs = issuer.internal_wallet.collect_uncolored_outputs(fee)
+        fill_input(tx, outputs)
+
+        out_point = tx.inputs.first.out_point
+        color_id = case token_type
+        when Tapyrus::Color::TokenTypes::NON_REISSUABLE
+          Tapyrus::Color::ColorIdentifier.non_reissuable(out_point)
+        when Tapyrus::Color::TokenTypes::NFT
+          Tapyrus::Color::ColorIdentifier.nft(out_point)
+        else
+          raise Glueby::Contract::Errors::UnsupportedTokenType  
         end
-        raise Glueby::Contract::Errors::InsufficientFunds
+
+        receiver_script = Tapyrus::Script.parse_from_addr(issuer.internal_wallet.receive_address)
+        receiver_colored_script = receiver_script.add_color(color_id)
+        tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
+
+        fill_change_tpc(tx, issuer, sum - fee)
+        issuer.internal_wallet.sign_tx(tx)
+      end
+
+      def create_reissue_tx(funding_tx:, issuer:, amount:, color_id:, fee_provider: FixedFeeProvider.new)
+        tx = Tapyrus::Tx.new
+
+        out_point = Tapyrus::OutPoint.from_txid(funding_tx.txid, 0)
+        tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
+        output = funding_tx.outputs.first
+
+        receiver_script = Tapyrus::Script.parse_from_payload(output.script_pubkey.to_payload)
+        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))
+        fill_change_tpc(tx, issuer, output.value - fee)
+        prev_txs = [{
+          txid: funding_tx.txid,
+          vout: 0,
+          scriptPubKey: output.script_pubkey.to_hex,
+          amount: output.value
+        }]
+        issuer.internal_wallet.sign_tx(tx, prev_txs)
+      end
+
+      def create_transfer_tx(color_id:, sender:, receiver:, amount:, fee_provider: FixedFeeProvider.new)
+        tx = Tapyrus::Tx.new
+
+        utxos = sender.internal_wallet.list_unspent
+        sum_token, outputs = collect_colored_outputs(utxos, color_id, amount)
+        fill_input(tx, outputs)
+
+        receiver_script = Tapyrus::Script.parse_from_addr(receiver.internal_wallet.receive_address)
+        receiver_colored_script = receiver_script.add_color(color_id)
+        tx.outputs << Tapyrus::TxOut.new(value: amount, script_pubkey: receiver_colored_script)
+
+        fill_change_token(tx, sender, sum_token - amount, color_id)
+
+        fee = fee_provider.fee(dummy_tx(tx))
+        sum_tpc, outputs = sender.internal_wallet.collect_uncolored_outputs(fee)
+        fill_input(tx, outputs)
+
+        fill_change_tpc(tx, sender, sum_tpc - fee)
+        sender.internal_wallet.sign_tx(tx)
+      end
+
+      def create_burn_tx(color_id:, sender:, amount: 0, fee_provider: FixedFeeProvider.new)
+        tx = Tapyrus::Tx.new
+
+        utxos = sender.internal_wallet.list_unspent
+        sum_token, outputs = collect_colored_outputs(utxos, color_id, amount)
+        fill_input(tx, outputs)
+
+        fill_change_token(tx, sender, sum_token - amount, color_id) if amount.positive?
+
+        fee = fee_provider.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)
+        fill_input(tx, outputs)
+
+        fill_change_tpc(tx, sender, sum_tpc - fee)
+        sender.internal_wallet.sign_tx(tx)
       end
 
-      # Add inputs to tx
-      # @param [Tapyrus::Tx] tx
-      # @param [Array] outputs provided as result of listunspent and extracted by #collect_outputs methods
-      # @return [Tapyrus::Tx] tx which has enough amount in inputs.
       def fill_input(tx, outputs)
         outputs.each do |output|
-          out_point = Tapyrus::OutPoint.new(output['txid'].rhex, output['vout'])
+          out_point = Tapyrus::OutPoint.new(output[:txid].rhex, output[:vout])
           tx.inputs << Tapyrus::TxIn.new(out_point: out_point)
         end
-        tx
-      end
-
-      # Add output to tx, so that allow tx to return the change of the transaction.
-      # @param [Tapyrus::Tx] tx
-      # @param [Numeric] fee
-      # @param [Tapyrus::Script] script for change
-      # @param [Numeric] sum value of inputs
-      def fill_change_output(tx, fee, change_script, sum)
-        amount = fee + tx.outputs.map(&:value).sum
-        if amount.positive?
-          change = sum - amount
-          tx.outputs << Tapyrus::TxOut.new(value: change, script_pubkey: change_script)
+      end
+
+      def fill_change_tpc(tx, wallet, change)
+        return unless change.positive?
+
+        change_script = Tapyrus::Script.parse_from_addr(wallet.internal_wallet.change_address)
+        tx.outputs << Tapyrus::TxOut.new(value: change, script_pubkey: change_script)
+      end
+
+      def fill_change_token(tx, wallet, change, color_id)
+        return unless change.positive?
+
+        change_script = Tapyrus::Script.parse_from_addr(wallet.internal_wallet.change_address)
+        change_colored_script = change_script.add_color(color_id)
+        tx.outputs << Tapyrus::TxOut.new(value: change, script_pubkey: change_colored_script)
+      end
+
+      # Returns the set of utxos that satisfies the specified amount and has the specified color_id.
+      # if amount is not specified or 0, return all utxos with color_id
+      # @param results [Array] response of Glueby::Internal::Wallet#list_unspent
+      # @param color_id [Tapyrus::Color::ColorIdentifier] color identifier
+      # @param amount [Integer]
+      def collect_colored_outputs(results, color_id, amount = 0)
+        results = results.inject([0, []]) do |sum, output|
+          next sum unless output[:color_id] == color_id.to_hex
+
+          new_sum = sum[0] + output[:amount]
+          new_outputs = sum[1] << output
+          return [new_sum, new_outputs] if new_sum >= amount && amount.positive?
+
+          [new_sum, new_outputs]
         end
-        tx
+        raise Glueby::Contract::Errors::InsufficientTokens if amount.positive?
+
+        results
+      end
+
+      # Add dummy inputs and outputs to tx
+      def dummy_tx(tx)
+        dummy = Tapyrus::Tx.parse_from_payload(tx.to_payload)
+
+        # dummy input for tpc
+        out_point = Tapyrus::OutPoint.new('00' * 32, 0)
+        dummy.inputs << Tapyrus::TxIn.new(out_point: out_point)
+
+        # Add script_sig to all intpus
+        dummy.inputs.each do |input|
+          input.script_sig = Tapyrus::Script.parse_from_payload('000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'.htb)
+        end
+
+        # dummy output to return change
+        change_script = Tapyrus::Script.to_p2pkh('0000000000000000000000000000000000000000')
+        dummy.outputs << Tapyrus::TxOut.new(value: 0, script_pubkey: change_script)
+        dummy
+      end
+
+      # Add dummy inputs and outputs to tx for issue non-reissuable transaction and nft transaction
+      def dummy_issue_tx_from_out_point
+        tx = Tapyrus::Tx.new
+        receiver_colored_script = Tapyrus::Script.parse_from_payload('21c20000000000000000000000000000000000000000000000000000000000000000bc76a914000000000000000000000000000000000000000088ac'.htb)
+        tx.outputs << Tapyrus::TxOut.new(value: 0, script_pubkey: receiver_colored_script)
+        dummy_tx(tx)
       end
     end
   end

data/lib/glueby/generator.rb

@@ -0,0 +1,5 @@
+module Glueby
+  module Generator
+    autoload :MigrateGenerator, 'glueby/generator/migrate_generator'
+  end
+end

data/lib/glueby/generator/migrate_generator.rb

@@ -0,0 +1,38 @@
+module Glueby
+  module Generator
+    module MigrateGenerator
+      module ClassMethod
+        def next_migration_number(dirname)
+          # ::ActiveRecord::Migration.next_migration_number(number)
+          # ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+          next_migration_number = current_migration_number(dirname) + 1
+          ::ActiveRecord::Migration.next_migration_number(next_migration_number)
+        end
+      end
+
+      MYSQL_ADAPTERS = [
+        "ActiveRecord::ConnectionAdapters::MysqlAdapter",
+        "ActiveRecord::ConnectionAdapters::Mysql2Adapter"
+      ].freeze
+
+      def migration_version
+        major = ::Rails::VERSION::MAJOR
+        if major >= 5
+          "[#{major}.#{::Rails::VERSION::MINOR}]"
+        end
+      end
+
+      def mysql?
+        MYSQL_ADAPTERS.include?(::ActiveRecord::Base.connection.class.name)
+      end
+
+      def table_options
+        if mysql?
+          ', { options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci" }'
+        else
+          ""
+        end
+      end
+    end
+  end
+end