monacoin-openassets-ruby 0.1.3

data/lib/openassets/transaction/spendable_output.rb

@@ -0,0 +1,38 @@
+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
+
+      # @param [OpenAssets::Transaction::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.hash, '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,319 @@
+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::Protocol::Tx.new
+        inputs.each { |spendable|
+          script_sig = spendable.output.script.to_binary
+          tx_in = Bitcoin::Protocol::TxIn.from_hex_hash(spendable.out_point.hash, spendable.out_point.index)
+          tx_in.script_sig = script_sig
+          tx.add_in(tx_in)
+        }
+        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.add_out(create_colored_output(issue_address))
+        }
+        tx.add_out(create_marker_output(asset_quantities, metadata))
+        tx.add_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::Protocol: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::Protocol: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::Protocol: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::Protocol: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::Protocol::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|
+          script_sig = o.output.script.to_binary
+          tx_in = Bitcoin::Protocol::TxIn.from_hex_hash(o.out_point.hash, o.out_point.index)
+          tx_in.script_sig = script_sig
+          tx.add_in(tx_in)
+        }
+        tx.add_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::Protocol::TxOut] colored output
+      def create_colored_output(address)
+        Bitcoin::Protocol::TxOut.new(@amount, Bitcoin::Script.new(Bitcoin::Script.to_address_script(address)).to_payload)
+      end
+
+      # create marker output.
+      # @param [Array] asset_quantities asset_quantity array.
+      # @param [String] metadata
+      # @return [Bitcoin::Protocol::TxOut] the marker output.
+      def create_marker_output(asset_quantities, metadata = '')
+        script = OpenAssets::Protocol::MarkerOutput.new(asset_quantities, metadata).build_script
+        Bitcoin::Protocol::TxOut.new(0, script.to_payload)
+      end
+
+      # create an uncolored output.
+      # @param [String] address: The Bitcoin address.
+      # @param [Integer] value: The satoshi value of the output.
+      # @return [Bitcoin::Protocol::TxOut] an uncolored output.
+      def create_uncolored_output(address, value)
+        raise DustOutputError if value < @amount
+        Bitcoin::Protocol::TxOut.new(value, Bitcoin::Script.new(Bitcoin::Script.to_address_script(address)).to_payload)
+      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::Protocol: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::Protocol::Tx.new
+        # for all inputs (vin fields), add sigs to the same transaction
+        inputs.flatten.each{|i|
+          script_sig = i.output.script.to_binary
+          tx_in = Bitcoin::Protocol::TxIn.from_hex_hash(i.out_point.hash, i.out_point.index)
+          tx_in.script_sig = script_sig
+          tx.add_in(tx_in)
+        }
+
+        outputs.each{|o|tx.add_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

data/lib/openassets/transaction/transfer_parameters.rb

@@ -0,0 +1,41 @@
+module OpenAssets
+  module Transaction
+
+    # The value object of a bitcoin or asset transfer.
+    class TransferParameters
+
+      attr_accessor :unspent_outputs
+      attr_accessor :amount
+      attr_accessor :change_script
+      attr_accessor :to_script
+      attr_accessor :output_qty
+
+      # initialize
+      # @param [Array[OpenAssets::Transaction::SpendableOutput]] unspent_outputs Array of the unspent outputs available for the transaction.
+      # @param [String] to_script the output script to which to send the assets or bitcoins.
+      # @param [String] change_script the output script to which to send any remaining change.
+      # @param [Integer] amount The asset quantity or amount of the satoshi sent in the transaction.
+      def initialize(unspent_outputs, to_script, change_script, amount, output_qty = 1)
+        @unspent_outputs = unspent_outputs
+        @to_script = to_script
+        @change_script = change_script
+        @amount = amount
+        @output_qty = output_qty
+      end
+
+      def split_output_amount
+        split_amounts = []
+        output_qty.times{|index|
+          if index == output_qty - 1
+            value = amount / output_qty + amount % output_qty
+          else
+            value = amount / output_qty
+          end
+          split_amounts << value
+        }
+        split_amounts
+      end
+    end
+
+  end
+end

data/lib/openassets/util.rb

@@ -0,0 +1,173 @@
+require 'bigdecimal'
+module OpenAssets
+  module Util
+    extend ::Bitcoin::Util
+    include ::Bitcoin::Util
+
+    # namespace of Open Asset
+    OA_NAMESPACE = 19
+
+    # version byte for Open Assets Address
+    OA_VERSION_BYTE = 23
+    OA_VERSION_BYTE_TESTNET = 115
+
+    # convert bitcoin address to open assets address
+    # @param [String] btc_address The Bitcoin address.
+    # @return [String] The Open Assets Address.
+    def address_to_oa_address(btc_address)
+      btc_hex = decode_base58(btc_address)
+      btc_hex = '0' +btc_hex if btc_hex.size==47
+      address = btc_hex[0..-9] # bitcoin address without checksum
+      named_addr = OA_NAMESPACE.to_s(16) + address
+      oa_checksum = checksum(named_addr)
+      encode_base58(named_addr + oa_checksum)
+    end
+
+    # convert open assets address to bitcoin address
+    # @param [String] oa_address The Open Assets Address.
+    # @return [String] The Bitcoin address.
+    def oa_address_to_address(oa_address)
+      decode_address = decode_base58(oa_address)
+      btc_addr = decode_address[2..-9]
+      btc_checksum = checksum(btc_addr)
+      encode_base58(btc_addr + btc_checksum)
+    end
+
+    # generate asset ID from public key.
+    def generate_asset_id(pub_key)
+      pubkey_hash_to_asset_id(hash160(pub_key))
+    end
+
+    def pubkey_hash_to_asset_id(pubkey_hash)
+      # gen P2PKH script hash
+      # P2PKH script = OP_DUP OP_HASH160 <PubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
+      # （76=OP_DUP, a9=OP_HASH160, 14=Bytes to push, 88=OP_EQUALVERIFY, ac=OP_CHECKSIG）
+      hash_to_asset_id(hash160(["76", "a9", "14", pubkey_hash, "88", "ac"].join))
+    end
+
+    def script_to_asset_id(script)
+      hash_to_asset_id(hash160(script))
+    end
+
+    def hash_to_asset_id(hash)
+      hash = oa_version_byte.to_s(16) + hash # add version byte to script hash
+      encode_base58(hash + checksum(hash)) # add checksum & encode
+    end
+
+    # LEB128 encode
+    def encode_leb128(value)
+      LEB128.encode_unsigned(value).read.bth
+    end
+
+    # LEB128 decode
+    def decode_leb128(value)
+      results = []
+      sio = StringIO.new
+      value.htb.each_byte{|b|
+        sio.putc(b)
+        if b < 128
+          results << LEB128.decode_unsigned(sio)
+          sio = StringIO.new
+        end
+      }
+      results
+    end
+
+    def to_bytes(string)
+      string.each_char.each_slice(2).map{|v|v.join}
+    end
+
+    # Convert satoshi to coin.
+    # @param [Integer] satoshi The amount of satoshi unit.
+    # @return [String] The amount of coin.
+    def satoshi_to_coin(satoshi)
+      "%.8f" % (satoshi / 100000000.0)
+    end
+
+    # Convert coin unit to satoshi.
+    # @param [String] coin The amount of bitcoin
+    # @return [String] The amount of satoshi.
+    def coin_to_satoshi(coin)
+      BigDecimal(coin) * BigDecimal(100000000)
+    end
+
+    # Get address from script.
+    # @param [Bitcoin::Script] script The output script.
+    # @return [String] The Bitcoin address. if the script dose not contains address, return nil.
+    def script_to_address(script)
+      return script.get_pubkey_address    if script.is_pubkey?
+      return script.get_hash160_address   if script.is_hash160?
+      return script.get_multisig_addresses  if script.is_multisig?
+      return script.get_p2sh_address      if script.is_p2sh?
+      nil
+    end
+
+    # validate bitcoin address
+    def validate_address(addresses)
+      addresses.each{|a|
+        raise ArgumentError, "#{a} is invalid bitcoin address. " unless valid_address?(a)
+      }
+    end
+
+    # validate asset ID
+    def valid_asset_id?(asset_id)
+      return false if asset_id.nil? || asset_id.length != 34
+      decoded = decode_base58(asset_id)
+      return false if  decoded[0,2].to_i(16) != oa_version_byte
+      p2pkh_script_hash = decoded[2..-9]
+      address = hash160_to_address(p2pkh_script_hash)
+      valid_address?(address)
+    end
+
+    # read variable integer
+    # @param [String] data reading data
+    # @param [Integer] offset the position when reading from data.
+    # @return [[Integer, Integer]]  decoded integer value and the reading byte length.
+    # https://en.bitcoin.it/wiki/Protocol_documentation#Variable_length_integer
+    def read_var_integer(data, offset = 0)
+      raise ArgumentError, "data is nil." unless data
+      packed = [data].pack('H*')
+      return [nil, 0] if packed.bytesize < 1+offset
+      bytes = packed.bytes[offset..(offset + 9)] # 9 is variable integer max storage length.
+      first_byte = bytes[0]
+      if first_byte < 0xfd
+        [first_byte, offset + 1]
+      elsif first_byte == 0xfd
+        [calc_var_integer_val(bytes[1..2]), offset + 3]
+      elsif first_byte == 0xfe
+        [calc_var_integer_val(bytes[1..4]), offset + 5]
+      elsif first_byte == 0xff
+        [calc_var_integer_val(bytes[1..8]), offset + 9]
+      end
+    end
+
+    # read leb128 value
+    # @param [String] data reading data
+    # @param [Integer] offset start position when reading from data.
+    # @return [[Integer, Integer]]  decoded integer value and the reading byte length.
+    def read_leb128(data, offset = 0)
+      bytes = [data].pack('H*').bytes
+      result = 0
+      shift = 0
+      while true
+        return [nil, offset] if bytes.length < 1 + offset
+        byte = bytes[offset..(offset + 1)][0]
+        result |= (byte & 0x7f) << shift
+        break if byte & 0x80 == 0
+        shift += 7
+        offset += 1
+      end
+      [result, offset + 1]
+    end
+
+    private
+    def oa_version_byte
+      Bitcoin.network[:address_version] == "6f" ? OA_VERSION_BYTE_TESTNET : OA_VERSION_BYTE
+    end
+
+    def calc_var_integer_val(byte_array)
+      byte_array.each_with_index.inject(0){|sum, pair| pair[1] == 0 ? pair[0] : sum + pair[0]*(256**pair[1])}
+    end
+    
+  end
+end