openassets 1.0.0

data/lib/openassets/protocol/output_type.rb

@@ -0,0 +1,27 @@
+# Transaction output type enum
+module OpenAssets
+  module Protocol
+    module OutputType
+      UNCOLORED = 0
+      MARKER_OUTPUT = 1
+      ISSUANCE = 2
+      TRANSFER = 3
+
+      # get all enum.
+      def self.all
+        self.constants.map{|name|self.const_get(name)}
+      end
+
+      def self.output_type_label(type)
+        case type
+          when UNCOLORED then 'uncolored'
+          when MARKER_OUTPUT then 'marker'
+          when ISSUANCE then 'issuance'
+          when TRANSFER then 'transfer'
+          else 'uncolored'
+        end
+      end
+
+    end
+  end
+end

data/lib/openassets/protocol/transaction_output.rb

@@ -0,0 +1,136 @@
+module OpenAssets
+  module Protocol
+
+    # Represents a transaction output and its asset ID and asset quantity.
+    class TransactionOutput
+
+      include OpenAssets::Util
+
+      attr_accessor :value
+      attr_accessor :script
+      attr_accessor :asset_id
+      attr_accessor :asset_quantity
+      attr_accessor :output_type
+
+      attr_accessor :account
+      attr_accessor :metadata
+      attr_accessor :asset_definition_url
+      attr_accessor :asset_definition
+
+
+      # @param [Integer] value The satoshi value of the output.
+      # @param [Bitcoin::Script] script The script controlling redemption of the output.
+      # @param [String] asset_id The asset ID of the output.
+      # @param [Integer] asset_quantity The asset quantity of the output.
+      # @param [OpenAssets::Transaction::OutPutType] output_type The type of the output.
+      def initialize(value, script, asset_id = nil, asset_quantity = 0, output_type = OutputType::UNCOLORED, metadata = '')
+        raise ArgumentError, "invalid output_type : #{output_type}" unless OutputType.all.include?(output_type)
+        raise ArgumentError, "invalid asset_quantity. asset_quantity should be unsignd integer. " unless asset_quantity.between?(0, MarkerOutput::MAX_ASSET_QUANTITY)
+        @value = value
+        @script = script
+        @asset_id = asset_id
+        @asset_quantity = asset_quantity
+        @output_type = output_type
+        @metadata = metadata
+        load_asset_definition_url
+      end
+
+      # calculate asset amount.
+      # asset amount is the value obtained by converting the asset quantity to the unit of divisibility that are defined in the Asset definition file.
+      def asset_amount
+        d = divisibility
+        d > 0 ? (@asset_quantity.to_f / (10 ** d)).to_f : @asset_quantity
+      end
+
+      # get divisibility defined by asset definition file.
+      def divisibility
+        return 0 if !valid_asset_definition? || @asset_definition.divisibility.nil?
+        @asset_definition.divisibility
+      end
+
+      # Verify proof of authenticity.
+      def proof_of_authenticity
+        valid_asset_definition? ? @asset_definition.proof_of_authenticity : false
+      end
+
+      # convert to hash object.
+      def to_hash
+        {
+            'address' =>  address,
+            'oa_address' => oa_address,
+            'script' => @script.to_payload.bth,
+            'script_type' => script_type,
+            'amount' => satoshi_to_coin(@value),
+            'asset_id' => @asset_id,
+            'asset_quantity' => @asset_quantity.to_s,
+            'asset_amount' => asset_amount.to_s,
+            'account' => @account,
+            'asset_definition_url' => @asset_definition_url,
+            'proof_of_authenticity' => proof_of_authenticity,
+            'output_type' => OpenAssets::Protocol::OutputType.output_type_label(@output_type)
+        }
+      end
+
+      def address
+        return @script.addresses.first if @script.p2pkh? || @script.p2sh? || @script.p2wpkh? || @script.p2wsh?
+        nil # TODO Bitcoin::Script#to_addr after it enable
+      end
+
+      def oa_address
+        a = address
+        return nil if a.nil?
+        address_to_oa_address(a)
+      end
+
+      # get pubkey script type
+      def script_type
+        return 'pubkeyhash' if script.p2pkh?
+        return 'scripthash' if script.p2sh?
+        return 'nulldata' if script.standard_op_return?
+        return 'multisig' if script.multisig?
+        return 'witness_v0_keyhash' if script.p2wpkh?
+        return 'witness_v0_scripthash' if script.p2wsh?
+        'nonstandard'
+      end
+
+      private
+
+      @@definition_cache = {}
+
+      # get Asset definition url that is included metadata.
+      def load_asset_definition_url
+        @asset_definition_url = ''
+        return if @metadata.nil? || @metadata.length == 0
+        if @metadata.start_with?('u=')
+          @asset_definition = load_asset_definition(metadata_url)
+          if valid_asset_definition?
+            @asset_definition_url = metadata_url
+          else
+            @asset_definition_url = "The asset definition is invalid. #{metadata_url}"
+          end
+        else
+          @asset_definition_url = 'Invalid metadata format.'
+        end
+      end
+
+      def metadata_url
+        unless @metadata.nil?
+           @metadata.slice(2..-1)
+        end
+      end
+
+      def valid_asset_definition?
+        !@asset_definition.nil? && @asset_definition.include_asset_id?(@asset_id)
+      end
+
+      def load_asset_definition(url)
+        unless @@definition_cache.has_key?(url)
+          loader = AssetDefinitionLoader.new(metadata_url)
+          @@definition_cache[url] = loader.load_definition
+        end
+        @@definition_cache[url]
+      end
+    end
+
+  end
+end

data/lib/openassets/provider.rb

@@ -0,0 +1,7 @@
+module OpenAssets
+  module Provider
+    autoload :BlockChainProviderBase, 'openassets/provider/block_chain_provider_base'
+    autoload :BitcoinCoreProvider, 'openassets/provider/bitcoin_core_provider'
+    autoload :ApiError, 'openassets/provider/api_error'
+  end
+end

data/lib/openassets/provider/api_error.rb

@@ -0,0 +1,9 @@
+module OpenAssets
+  module Provider
+
+    class ApiError < OpenAssets::Error
+
+    end
+
+  end
+end

data/lib/openassets/provider/bitcoin_core_provider.rb

@@ -0,0 +1,103 @@
+require 'rest-client'
+
+module OpenAssets
+  module Provider
+
+    # The implementation of BlockChain provider using Bitcoin Core.
+    class BitcoinCoreProvider < BlockChainProviderBase
+
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+
+        commands = request(:help).split("\n").inject([]) do |memo_ary, line|
+          if !line.empty? && !line.start_with?('==')
+            memo_ary << line.split(' ').first.to_sym
+          end
+          memo_ary
+        end
+        BitcoinCoreProvider.class_eval do
+          commands.each do |command|
+            define_method(command) do |*params|
+              request(command, *params)
+            end
+          end
+        end
+      end
+
+      # Get an array of unspent transaction outputs belonging to this wallet.
+      # @param [Array] addresses If present, only outputs which pay an address in this array will be returned.
+      # @param [Integer] min The minimum number of confirmations the transaction containing an output must have in order to be returned. Default is 1.
+      # @param [Integer] max The maximum number of confirmations the transaction containing an output may have in order to be returned. Default is 9999999.
+      def list_unspent(addresses = [], min = 1 , max = 9999999)
+        listunspent(min, max, addresses)
+      end
+
+      # Get raw transaction.
+      # @param [String] transaction_hash The transaction hash.
+      # @param [String] verbose Whether to get the serialized or decoded transaction. 0: serialized transaction (Default). 1: decode transaction.
+      # @return [String] (if verbose=0)—the serialized transaction. (if verbose=1)—the decoded transaction. (if transaction not found)—nil.
+      def get_transaction(transaction_hash, verbose = 0)
+        begin
+          getrawtransaction(transaction_hash, verbose)
+        rescue OpenAssets::Provider::ApiError => e
+          nil
+        end
+      end
+
+      # Signs a transaction in the serialized transaction format using private keys.
+      # @param [String] tx The serialized format transaction.
+      # @return [Bitcoin::Tx] The signed transaction.
+      def sign_transaction(tx)
+        signed_tx = respond_to?(:signrawtransactionwithwallet) ? signrawtransactionwithwallet(tx) : signrawtransaction(tx)
+        raise OpenAssets::Error, 'Could not sign the transaction.' unless signed_tx['complete']
+        Bitcoin::Tx.parse_from_payload(signed_tx['hex'].htb)
+      end
+
+      # Validates a transaction and broadcasts it to the peer-to-peer network.
+      # @param [String] tx The serialized format transaction.
+      # @return [String] The TXID or error message.
+      def send_transaction(tx)
+        sendrawtransaction(tx)
+      end
+
+      # Adds an address or pubkey script to the wallet without the associated private key, allowing you to watch for transactions affecting that address or pubkey script without being able to spend any of its outputs.
+      # @param [String] address Either a P2PKH or P2SH address encoded in base58check, or a pubkey script encoded as hex.
+      def import_address(address)
+        importaddress(address)
+      end
+
+      def request(command, *params)
+        data = {
+            :method => command,
+            :params => params,
+            :id => 'jsonrpc'
+        }
+        post(server_url, @config[:timeout], @config[:open_timeout], data.to_json, content_type: :json) do |respdata, request, result|
+          raise ApiError, result.message if !result.kind_of?(Net::HTTPSuccess) && respdata.empty?
+          response = JSON.parse(respdata.gsub(/\\u([\da-fA-F]{4})/) { [$1].pack('H*').unpack('n*').pack('U*').encode('ISO-8859-1').force_encoding('UTF-8') })
+          raise ApiError, response['error'] if response['error']
+          response['result']
+        end
+      end
+
+      private
+
+      def server_url
+        url = "#{@config[:schema]}://"
+        url.concat "#{@config[:user]}:#{@config[:password]}@"
+        url.concat "#{@config[:host]}:#{@config[:port]}"
+        if !@config[:wallet].nil? && !@config[:wallet].empty?
+          url.concat "/wallet/#{@config[:wallet]}"
+        end
+        url
+      end
+
+      def post(url, timeout, open_timeout, payload, headers={}, &block)
+        RestClient::Request.execute(:method => :post, :url => url, :timeout => timeout, :open_timeout => open_timeout, :payload => payload, :headers => headers, &block)
+      end
+
+    end
+  end
+end

data/lib/openassets/provider/block_chain_provider_base.rb

@@ -0,0 +1,22 @@
+module OpenAssets
+  module Provider
+
+    # The base class providing access to the Blockchain.
+    class BlockChainProviderBase
+
+      def list_unspent(addresses = [], min = 1 , max = 9999999)
+        raise NotImplementedError
+      end
+
+      def get_transaction(transaction_hash, verbose = 0)
+        raise NotImplementedError
+      end
+
+      def sign_transaction(tx)
+        raise NotImplementedError
+      end
+
+    end
+
+  end
+end

data/lib/openassets/send_asset_param.rb

@@ -0,0 +1,17 @@
+module OpenAssets
+
+    class SendAssetParam
+      attr_accessor :asset_id
+      attr_accessor :amount
+      attr_accessor :to
+      attr_accessor :from
+
+      def initialize(asset_id, amount, to, from = nil)
+        @asset_id = asset_id
+        @amount = amount
+        @to = to
+        @from = from
+      end
+    end
+
+end

data/lib/openassets/send_bitcoin_param.rb

@@ -0,0 +1,13 @@
+module OpenAssets
+
+    class SendBitcoinParam
+      attr_accessor :amount
+      attr_accessor :to
+
+      def initialize(amount, to)
+        @amount = amount
+        @to = to
+      end
+    end
+
+end

data/lib/openassets/transaction.rb

@@ -0,0 +1,11 @@
+module OpenAssets
+  module Transaction
+    autoload :TransactionBuilder, 'openassets/transaction/transaction_builder'
+    autoload :TransferParameters, 'openassets/transaction/transfer_parameters'
+    autoload :SpendableOutput, 'openassets/transaction/spendable_output'
+    autoload :TransactionBuildError, 'openassets/transaction/transaction_build_error'
+    autoload :InsufficientFundsError, 'openassets/transaction/insufficient_funds_error'
+    autoload :InsufficientAssetQuantityError, 'openassets/transaction/insufficient_asset_quantity_error'
+    autoload :DustOutputError, 'openassets/transaction/dust_output_error'
+  end
+end

data/lib/openassets/transaction/dust_output_error.rb

@@ -0,0 +1,10 @@
+module OpenAssets
+  module Transaction
+
+    # The value of an output would be too small, and the output would be considered as dust.
+    class DustOutputError < TransactionBuildError
+
+    end
+
+  end
+end

data/lib/openassets/transaction/insufficient_asset_quantity_error.rb

@@ -0,0 +1,7 @@
+module OpenAssets
+  module Transaction
+    # An insufficient amount of assets is available.
+    class InsufficientAssetQuantityError < TransactionBuildError
+    end
+  end
+end

data/lib/openassets/transaction/insufficient_funds_error.rb

@@ -0,0 +1,10 @@
+module OpenAssets
+  module Transaction
+
+    # An insufficient amount of bitcoins is available.
+    class InsufficientFundsError < TransactionBuildError
+
+    end
+
+  end
+end

data/lib/openassets/transaction/spendable_output.rb

@@ -0,0 +1,39 @@
+module OpenAssets
+  module Transaction
+
+    # A transaction output with information about the asset ID and asset quantity associated to it.
+    class SpendableOutput
+
+      # An object that can be used to locate the output.
+      attr_accessor :out_point
+      # The actual output object.
+      attr_accessor :output
+
+      attr_accessor :confirmations
+      attr_accessor :spendable
+      attr_accessor :solvable
+
+      # initialize
+      # @param [Bitcoin::OutPoint] out_point
+      # @param [OpenAssets::Protocol::TransactionOutput] output
+      def initialize(out_point, output)
+        @out_point = out_point
+        @output = output
+        @confirmations = nil
+        @solvable = nil
+        @spendable = nil
+      end
+
+      # convert to hash.
+      def to_hash
+        return {} if @output.nil?
+        h = {'txid' => @out_point.txid, 'vout' => @out_point.index, 'confirmations' => @confirmations}.merge(@output.to_hash)
+        h['solvable'] = @solvable unless @solvable.nil?
+        h['spendable'] = @spendable unless @spendable.nil?
+        h
+      end
+
+    end
+
+  end
+end

data/lib/openassets/transaction/transaction_build_error.rb

@@ -0,0 +1,9 @@
+module OpenAssets
+  module Transaction
+
+    class TransactionBuildError < OpenAssets::Error
+
+    end
+
+  end
+end

data/lib/openassets/transaction/transaction_builder.rb

@@ -0,0 +1,312 @@
+module OpenAssets
+  module Transaction
+
+    class TransactionBuilder
+      include OpenAssets::Util
+
+      # The minimum allowed output value.
+      attr_accessor :amount
+
+      # The estimated transaction fee rate (satoshis/KB).
+      attr_accessor :efr
+      
+      def initialize(amount = 600, efr = 10000)
+        @amount = amount
+        @efr = efr 
+      end
+
+      # Creates a transaction for issuing an asset.
+      # @param [TransferParameters] issue_spec The parameters of the issuance.
+      # @param [bytes] metadata The metadata to be embedded in the transaction.
+      # @param [Integer] fees The fees to include in the transaction.
+      # @return[Bitcoin:Protocol:Tx] An unsigned transaction for issuing asset.
+      def issue_asset(issue_spec, metadata, fees)
+        
+        if fees == :auto
+          # Calculate fees (assume that one vin and four vouts are wrote)
+          fees = calc_fee(1, 4)
+        end
+        
+        inputs, total_amount =
+            TransactionBuilder.collect_uncolored_outputs(issue_spec.unspent_outputs, 2 * @amount + fees)
+        tx = Bitcoin::Tx.new
+        inputs.each { |spendable|
+          tx.in << Bitcoin::TxIn.new(out_point: spendable.out_point, script_sig: spendable.output.script)
+        }
+        issue_address = oa_address_to_address(issue_spec.to_script)
+        from_address = oa_address_to_address(issue_spec.change_script)
+        validate_address([issue_address, from_address])
+        asset_quantities =[]
+        issue_spec.split_output_amount.each{|amount|
+          asset_quantities << amount
+          tx.out << create_colored_output(issue_address)
+        }
+        tx.out << create_marker_output(asset_quantities, metadata)
+        tx.out << create_uncolored_output(from_address, total_amount - @amount - fees)
+        tx
+      end
+
+      # Creates a transaction for sending an asset.
+      # @param[String] asset_id The ID of the asset being sent.
+      # @param[OpenAssets::Transaction::TransferParameters] asset_transfer_spec The parameters of the asset being transferred.
+      # @param[String] btc_change_script The script where to send bitcoin change, if any.
+      # @param[Integer] fees The fees to include in the transaction.
+      # @return[Bitcoin::Tx] The resulting unsigned transaction.
+      def transfer_asset(asset_id, asset_transfer_spec, btc_change_script, fees)
+        btc_transfer_spec = OpenAssets::Transaction::TransferParameters.new(
+            asset_transfer_spec.unspent_outputs, nil, oa_address_to_address(btc_change_script), 0)
+        transfer([[asset_id, asset_transfer_spec]], [btc_transfer_spec], fees)
+      end
+      
+      # Creates a transaction for sending assets to many.
+      # @param[Array[OpenAssets::Transaction::TransferParameters]] asset_transfer_spec The parameters of the asset being transferred.
+      # @param[OpenAssets::Transaction::TransferParameters] btc_transfer_spec The script where to send bitcoin change, if any.
+      # @param[Integer] fees The fees to include in the transaction.
+      # @return[Bitcoin::Tx] The resulting unsigned transaction.
+      def transfer_assets(transfer_specs, btc_transfer_spec, fees)
+        transfer(transfer_specs, [btc_transfer_spec], fees)
+      end
+
+      # Creates a transaction for sending bitcoins.
+      # @param[OpenAssets::Transaction::TransferParameters] btc_transfer_spec The parameters of the bitcoins being transferred.
+      # @param[Integer] fees The fees to include in the transaction.
+      # @return[Bitcoin::Tx] The resulting unsigned transaction.
+      def transfer_btc(btc_transfer_spec, fees)
+        transfer_btcs([btc_transfer_spec], fees)
+      end
+
+      # Creates a transaction for sending bitcoins to many.
+      # @param[Array[OpenAssets::Transaction::TransferParameters]] btc_transfer_specs The parameters of the bitcoins being transferred.
+      # @param[Integer] fees The fees to include in the transaction.
+      # @return[Bitcoin::Tx] The resulting unsigned transaction.
+      def transfer_btcs(btc_transfer_specs, fees)
+        transfer([], btc_transfer_specs, fees)
+      end
+      
+      # Create a transaction for burn asset
+      def burn_asset(unspents, asset_id, fee)
+
+        tx = Bitcoin::Tx.new
+        targets = unspents.select{|o|o.output.asset_id == asset_id}
+
+        if fee == :auto
+          # Calculate fees and otsuri (assume that one vout exists)
+          fee = calc_fee(targets.size, 1)
+        end
+        
+        raise TransactionBuildError.new('There is no asset.') if targets.length == 0
+        total_amount = targets.inject(0){|sum, o|o.output.value + sum}
+        otsuri = total_amount - fee
+        if otsuri < @amount
+          uncolored_outputs, uncolored_amount =
+            TransactionBuilder.collect_uncolored_outputs(unspents, @amount - otsuri)
+          targets = targets + uncolored_outputs
+          otsuri += uncolored_amount
+        end
+        targets.each{|o|
+          tx_in = Bitcoin::TxIn.new(out_point: o.out_point, script_sig: o.output.script)
+          tx.in << tx_in
+        }
+        tx.out << create_uncolored_output(targets[0].output.address, otsuri)
+        tx
+      end
+
+      # collect uncolored outputs in unspent outputs(contains colored output).
+      # @param [Array[OpenAssets::Transaction::SpendableOutput]] unspent_outputs The Array of available outputs.
+      # @param [Integer] amount The amount to collect.
+      # @return [Array] inputs, total_amount
+      def self.collect_uncolored_outputs(unspent_outputs, amount)
+        total_amount = 0
+        results = []
+        unspent_outputs.each do |output|
+          if output.output.asset_id.nil?
+            results << output
+            total_amount += output.output.value
+          end
+          return results, total_amount if total_amount >= amount
+        end
+        raise InsufficientFundsError
+      end
+
+      # Returns a list of colored outputs for the specified quantity.
+      # @param[Array[OpenAssets::Transaction::SpendableOutput]] unspent_outputs
+      # @param[String] asset_id The ID of the asset to collect.
+      # @param[Integer] asset_quantity The asset quantity to collect.
+      # @return[Array[OpenAssets::Transaction::SpendableOutput], int] A list of outputs, and the total asset quantity collected.
+      def self.collect_colored_outputs(unspent_outputs, asset_id, asset_quantity)
+        total_amount = 0
+        result = []
+        unspent_outputs.each do |output|
+          if output.output.asset_id == asset_id
+            result << output
+            total_amount += output.output.asset_quantity
+          end
+          return result, total_amount if total_amount >= asset_quantity
+        end
+        raise InsufficientAssetQuantityError
+      end
+
+      private
+      # create colored output.
+      # @param [String] address The Bitcoin address.
+      # @return [Bitcoin::TxOut] colored output
+      def create_colored_output(address)
+        Bitcoin::TxOut.new(value: @amount, script_pubkey: Bitcoin::Script.parse_from_addr(address))
+      end
+
+      # create marker output.
+      # @param [Array] asset_quantities asset_quantity array.
+      # @param [String] metadata
+      # @return [Bitcoin::TxOut] the marker output.
+      def create_marker_output(asset_quantities, metadata = '')
+        script = OpenAssets::Protocol::MarkerOutput.new(asset_quantities, metadata).build_script
+        Bitcoin::TxOut.new(value: 0, script_pubkey: script)
+      end
+
+      # create an uncolored output.
+      # @param [String] address: The Bitcoin address.
+      # @param [Integer] value: The satoshi value of the output.
+      # @return [Bitcoin::TxOut] an uncolored output.
+      def create_uncolored_output(address, value)
+        raise DustOutputError if value < @amount
+        Bitcoin::TxOut.new(value: value, script_pubkey: Bitcoin::Script.parse_from_addr(address))
+      end
+
+
+      # create a transaction
+      # @param[Array[OpenAssets::Transaction::TransferParameters]] asset_transfer_specs The parameters of the assets being transferred.
+      # @param[Array[OpenAssets::Transaction::TransferParameters]] btc_transfer_specs The parameters of the bitcoins being transferred.
+      # @param[Integer] fees The fees to include in the transaction.
+      # @return[Bitcoin::Tx] The resulting unsigned transaction.
+      def transfer(asset_transfer_specs, btc_transfer_specs, fees)
+        inputs = []     # vin field
+        outputs = []    # vout field
+        asset_quantities = []
+
+        # Only when assets are transferred
+        asset_based_specs = {}
+        asset_transfer_specs.each{|asset_id, transfer_spec|
+          asset_based_specs[asset_id] = {} unless asset_based_specs.has_key?(asset_id)
+          asset_based_specs[asset_id][transfer_spec.change_script] = [] unless asset_based_specs[asset_id].has_key?(transfer_spec.change_script)
+          asset_based_specs[asset_id][transfer_spec.change_script] << transfer_spec
+        }
+
+        asset_based_specs.each{|asset_id, address_based_specs|
+          address_based_specs.values.each{|transfer_specs|
+            transfer_amount = transfer_specs.inject(0){|sum, s| sum + s.amount}
+            colored_outputs, total_amount = TransactionBuilder.collect_colored_outputs(transfer_specs[0].unspent_outputs, asset_id, transfer_amount)
+            inputs = inputs + colored_outputs
+            transfer_specs.each{|spec|
+              # add asset transfer output
+              spec.split_output_amount.each {|amount|
+                outputs << create_colored_output(oa_address_to_address(spec.to_script))
+                asset_quantities << amount
+              }
+            }
+            # add the rest of the asset to the origin address
+            if total_amount > transfer_amount
+              outputs << create_colored_output(oa_address_to_address(transfer_specs[0].change_script))
+              asset_quantities << (total_amount - transfer_amount)
+            end
+          }
+        }
+        # End of asset settings
+
+        ## For bitcoins transfer
+        # Assume that there is one address from
+        utxo = btc_transfer_specs[0].unspent_outputs.dup
+
+        # Calculate rest of bitcoins in asset settings
+        # btc_excess = inputs(colored) total satoshi - outputs(transfer) total satoshi
+        btc_excess = inputs.inject(0) { |sum, i| sum + i.output.value } - outputs.inject(0){|sum, o| sum + o.value}
+
+        # Calculate total amount of bitcoins to send
+        btc_transfer_total_amount = btc_transfer_specs.inject(0) {|sum, b| sum + b.amount}
+
+        if fees == :auto 
+          fixed_fees = 0
+        else
+          fixed_fees = fees
+        end
+        
+        if btc_excess < btc_transfer_total_amount + fixed_fees
+          # When there does not exist enough bitcoins to send in the inputs
+          # assign new address (utxo) to the inputs (does not include output coins)
+          # CREATING INPUT (if needed)
+          uncolored_outputs, uncolored_amount =
+            TransactionBuilder.collect_uncolored_outputs(utxo, btc_transfer_total_amount + fixed_fees - btc_excess)
+          utxo = utxo - uncolored_outputs
+          inputs << uncolored_outputs
+          btc_excess += uncolored_amount
+        end
+
+        if fees == :auto
+          # Calculate fees and otsuri (the numbers of vins and vouts are known)
+          # +1 in the second term means "otsuri" vout, 
+          # and outputs size means the number of vout witn asset_id
+          fees = calc_fee(inputs.size, outputs.size + btc_transfer_specs.size + 1)
+        end
+        
+        otsuri = btc_excess - btc_transfer_total_amount - fees
+        
+        if otsuri > 0 && otsuri < @amount
+          # When there exists otsuri, but it is smaller than @amount (default is 600 satoshis)
+          # assign new address (utxo) to the input (does not include @amount - otsuri)
+          # CREATING INPUT (if needed)
+          uncolored_outputs, uncolored_amount =
+              TransactionBuilder.collect_uncolored_outputs(utxo, @amount - otsuri)
+          inputs << uncolored_outputs
+          otsuri += uncolored_amount
+        end
+
+        if otsuri > 0
+          # When there exists otsuri, write it to outputs
+          # CREATING OUTPUT
+          outputs << create_uncolored_output(btc_transfer_specs[0].change_script, otsuri)
+        end
+
+        btc_transfer_specs.each{|btc_transfer_spec|
+          if btc_transfer_spec.amount > 0
+            # Write output for bitcoin transfer by specifics of the argument
+            # CREATING OUTPUT
+            btc_transfer_spec.split_output_amount.each {|amount|
+              outputs << create_uncolored_output(btc_transfer_spec.to_script, amount)
+            }
+          end
+        }
+
+        # add marker output to outputs first.
+        unless asset_quantities.empty?
+          outputs.unshift(create_marker_output(asset_quantities))
+        end
+
+        # create a bitcoin transaction (assembling inputs and output into one transaction)
+        tx = Bitcoin::Tx.new
+        # for all inputs (vin fields), add sigs to the same transaction
+        inputs.flatten.each{|i|
+          tx_in = Bitcoin::TxIn.new(out_point: i.out_point, script_sig: i.output.script)
+          tx.in << tx_in
+        }
+
+        outputs.each{|o|tx.out << o}
+        
+        tx
+      end
+      
+      # Calculate a transaction fee
+      # @param [Integer] inputs_num: The number of vin fields.
+      # @param [Integer] outputs_num: The number of vout fields.
+      # @return [Integer] A transaction fee.
+      def calc_fee(inputs_num, outputs_num) 
+        # See http://bitcoinfees.com/ 
+        tx_size = 148 * inputs_num + 34 * outputs_num + 10
+        # See Bitcoin::tx.calculate_minimum_fee
+        fee = (1 + tx_size / 1_000) * @efr
+        
+        fee
+      end
+
+    end
+
+  end
+end