monacoin-openassets-ruby 0.1.3

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new("spec")
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "openassets"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/monacoin-openassets

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "openassets"
+require 'optparse'
+require 'json'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: openassets [options] [command]"
+
+  opts.on("-c PATH", "--config PATH", "config load path") do |path|
+    options[:config] = path
+  end
+  opts.on("-e", "--env", "load config from ENV variablse") do |env|
+    options[:env] = env
+  end
+  opts.on("-v", "--verbose", "verbose output") do |v|
+    options[:verbose] = v
+  end
+end.parse!
+
+puts "Welcome to OpenAssets\n\n"
+if options[:env]
+  rpc = {
+    :host			=> ENV['OA_RPC_HOST']			|| 'localhost',
+    :port			=> ENV['OA_RPC_PORT']			|| 8332,
+    :user			=> ENV['OA_RPC_USER']			|| '',
+    :password => ENV['OA_RPC_PASSWORD'] || '',
+    :schema		=> ENV['OA_RPC_SCHEMA']   || 'http'
+  }
+  config = {
+    :network	    => ENV['OA_NETWORK'] || 'mainnet',
+    :provider     => 'bitcoind',
+    :cache        => ENV['OA_CACHE'] || 'cache.db',
+    :dust_limit   => (ENV['OA_DUST_LIMIT'] || 600).to_i,
+    :default_fees => (ENV['OA_DEFAULT_FEES'] || 10000).to_i,
+    :rpc					=> rpc
+  }
+elsif options[:config]
+  if !File.exists?(options[:config])
+    puts "File not found: #{options[:config]}"
+    exit(1)
+  end
+  config = JSON.parse(File.read(options[:config]), {symbolize_names: true})
+end
+
+if options[:verbose]
+  puts "using config:"
+  puts config.inspect
+end
+$oa = $api = OpenAssets::Api.new(config)
+
+command = ARGV.shift
+
+if command == 'console'
+  require "irb"
+  puts "API is available as $oa:"
+  IRB.start
+  puts "bye, bye"
+elsif command && $oa.respond_to?(command)
+  puts "running command '#{command}'"
+  puts $oa.send(command, *ARGV).inspect
+else
+  puts "use 'openassets --help' for help"
+end

data/lib/monacoin-openassets.rb

@@ -0,0 +1,23 @@
+require 'bitcoin'
+require 'leb128'
+
+module OpenAssets
+
+  autoload :Protocol, 'openassets/protocol'
+  autoload :Transaction, 'openassets/transaction'
+  autoload :VERSION, 'openassets/version'
+  autoload :Util, 'openassets/util'
+  autoload :MethodFilter, 'openassets/medhod_filter'
+  autoload :Api, 'openassets/api'
+  autoload :Provider, 'openassets/provider'
+  autoload :Error, 'openassets/error'
+  autoload :SendAssetParam, 'openassets/send_asset_param'
+  autoload :SendBitcoinParam, 'openassets/send_bitcoin_param'
+  autoload :Cache, 'openassets/cache'
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  extend Util
+end

data/lib/openassets/api.rb

@@ -0,0 +1,423 @@
+# encoding: ascii-8bit
+
+module OpenAssets
+
+  class Api
+
+    include Util
+    include MethodFilter
+
+    before_filter :change_network, {:include => [:list_unspent, :get_balance, :issue_asset, :send_asset, :send_assets, :send_bitcoin, :send_bitcoins]}
+
+    attr_reader :config
+    attr_reader :provider
+    attr_reader :tx_cache
+    attr_reader :output_cache
+
+    def initialize(config = nil)
+      @config = {:network => 'mainnet',
+                 :provider => 'bitcoind', :cache => 'cache.db',
+                 :dust_limit => 600, :default_fees => 10000, :min_confirmation => 1, :max_confirmation => 9999999,
+                 :rpc => {:host => 'localhost', :port => 8332 , :user => '', :password => '', :wallet => '',
+                          :schema => 'https', :timeout => 60, :open_timeout => 60}}
+      if config
+        @config.update(config)
+      end
+      OpenAssets.configuration = @config
+      if @config[:provider] == 'bitcoind'
+        @provider = Provider::BitcoinCoreProvider.new(@config[:rpc])
+      else
+        raise OpenAssets::Error, 'specified unsupported provider.'
+      end
+      @tx_cache = Cache::TransactionCache.new(@config[:cache])
+      @output_cache = Cache::OutputCache.new(@config[:cache])
+      change_network
+    end
+
+    def provider
+      @provider
+    end
+
+    def is_testnet?
+      @config[:network] == 'testnet'
+    end
+
+    # get UTXO for colored coins.
+    # @param [Array] oa_address_list Obtain the balance of this open assets address only, or all addresses if unspecified.
+    # @return [Array] Return array of the unspent information Hash.
+    def list_unspent(oa_address_list = [])
+      btc_address_list = oa_address_list.map { |oa_address| oa_address_to_address(oa_address)}
+      outputs = get_unspent_outputs(btc_address_list)
+      result = outputs.map{|out| out.to_hash}
+      result
+    end
+
+    # Returns the balance in both bitcoin and colored coin assets for all of the addresses available in your Bitcoin Core wallet.
+    # @param [String] address The open assets address. if unspecified nil.
+    def get_balance(address = nil)
+      outputs = get_unspent_outputs(address.nil? ? [] : [oa_address_to_address(address)])
+      colored_outputs = outputs.map{|o|o.output}
+      sorted_outputs = colored_outputs.sort_by { |o|o.script.to_string}
+      groups = sorted_outputs.group_by{|o| o.script.to_string}
+      result = groups.map{|k, v|
+        btc_address = script_to_address(v[0].script)
+        sorted_script_outputs = v.sort_by{|o|o.asset_id unless o.asset_id}
+        group_assets = sorted_script_outputs.group_by{|o|o.asset_id}.select{|k,v| !k.nil?}
+        assets = group_assets.map{|asset_id, outputs|
+          {
+              'asset_id' => asset_id,
+              'quantity' => outputs.inject(0) { |sum, o| sum + o.asset_quantity }.to_s,
+              'amount' => outputs.inject(0) { |sum, o| sum + o.asset_amount }.to_s,
+              'asset_definition_url' => outputs[0].asset_definition_url,
+              'proof_of_authenticity' => outputs[0].proof_of_authenticity
+          }
+        }
+        {
+            'address' => btc_address,
+            'oa_address' => btc_address.nil? ? nil : address_to_oa_address(btc_address),
+            'value' => satoshi_to_coin(v.inject(0) { |sum, o|sum +  o.value}),
+            'assets' => assets,
+            'account' => v[0].account
+        }
+      }
+      address.nil? ? result : result.select{|r|r['oa_address'] == address}
+    end
+
+    # Creates a transaction for issuing an asset.
+    # @param[String] from The open asset address to issue the asset from.
+    # @param[Integer] amount The amount of asset units to issue.
+    # @param[String] to The open asset address to send the asset to; if unspecified, the assets are sent back to the issuing address.
+    # @param[String] metadata The metadata to embed in the transaction. The asset definition pointer defined by this metadata.
+    # @param[Integer] fees The fess in satoshis for the transaction.
+    # @param[String] mode Specify the following mode.
+    # 'broadcast' (default) for signing and broadcasting the transaction,
+    # 'signed' for signing the transaction without broadcasting,
+    # 'unsigned' for getting the raw unsigned transaction without broadcasting"""='broadcast'
+    # @param[Integer] output_qty The number of divides the issue output. Default value is 1.
+    # Ex. amount = 125 and output_qty = 2, asset quantity = [62, 63] and issue TxOut is two.
+    # @return[Bitcoin::Protocol::Tx] The Bitcoin::Protocol::Tx object.
+    def issue_asset(from, amount, metadata = nil, to = nil, fees = nil, mode = 'broadcast', output_qty = 1)
+      to = from if to.nil?
+      colored_outputs = get_unspent_outputs([oa_address_to_address(from)])
+      issue_param = OpenAssets::Transaction::TransferParameters.new(colored_outputs, to, from, amount, output_qty)
+      tx = create_tx_builder.issue_asset(issue_param, metadata, fees.nil? ? @config[:default_fees]: fees)
+      tx = process_transaction(tx, mode)
+      tx
+    end
+
+    # Creates a transaction for sending an asset from an address to another.
+    # @param[String] from The open asset address to send the asset from.
+    # @param[String] asset_id The asset ID identifying the asset to send.
+    # @param[Integer] amount The amount of asset units to send.
+    # @param[String] to The open asset address to send the asset to.
+    # @param[Integer] fees The fess in satoshis for the transaction.
+    # @param[String] mode 'broadcast' (default) for signing and broadcasting the transaction,
+    # 'signed' for signing the transaction without broadcasting,
+    # 'unsigned' for getting the raw unsigned transaction without broadcasting"""='broadcast'
+    # @return[Bitcoin::Protocol:Tx] The resulting transaction.
+    def send_asset(from, asset_id, amount, to, fees = nil, mode = 'broadcast', output_qty = 1)
+      colored_outputs = get_unspent_outputs([oa_address_to_address(from)])
+      asset_transfer_spec = OpenAssets::Transaction::TransferParameters.new(colored_outputs, to, from, amount, output_qty)
+      tx = create_tx_builder.transfer_asset(asset_id, asset_transfer_spec, from, fees.nil? ? @config[:default_fees]: fees)
+      tx = process_transaction(tx, mode)
+      tx
+    end
+
+    # Creates a transaction for sending multiple asset from an address to another.
+    # @param[String] from The open asset address to send the asset from when send_asset_param hasn't from.
+    # to send the bitcoins from, if needed. where to send bitcoin change, if any.
+    # @param[Array[OpenAssets::SendAssetParam]] send_asset_params The send Asset information(asset_id, amount, to, from).
+    # @param[Integer] fees The fess in satoshis for the transaction.
+    # @param[String] mode 'broadcast' (default) for signing and broadcasting the transaction,
+    # 'signed' for signing the transaction without broadcasting,
+    # 'unsigned' for getting the raw unsigned transaction without broadcasting"""='broadcast'
+    # @return[Bitcoin::Protocol:Tx] The resulting transaction.
+    def send_assets(from, send_asset_params, fees = nil, mode = 'broadcast')
+      transfer_specs = send_asset_params.map{ |param|
+        colored_outputs = get_unspent_outputs([oa_address_to_address(param.from || from)])
+        [param.asset_id, OpenAssets::Transaction::TransferParameters.new(colored_outputs, param.to, param.from || from, param.amount)]
+      }
+      btc_transfer_spec = OpenAssets::Transaction::TransferParameters.new(
+          get_unspent_outputs([oa_address_to_address(from)]), nil, oa_address_to_address(from), 0)
+      tx = create_tx_builder.transfer_assets(transfer_specs, btc_transfer_spec, fees.nil? ? @config[:default_fees]: fees)
+      tx = process_transaction(tx, mode)
+      tx
+    end
+
+    # Creates a transaction for sending bitcoins from an address to another.
+    # @param[String] from The address to send the bitcoins from.
+    # @param[Integer] amount The amount of satoshis to send.
+    # @param[String] to The address to send the bitcoins to.
+    # @param[Integer] fees The fess in satoshis for the transaction.
+    # @param[String] mode 'broadcast' (default) for signing and broadcasting the transaction,
+    # 'signed' for signing the transaction without broadcasting,
+    # 'unsigned' for getting the raw unsigned transaction without broadcasting"""='broadcast'
+    # @param [Integer] output_qty The number of divides the issue output. Default value is 1.
+    # Ex. amount = 125 and output_qty = 2, asset quantity = [62, 63] and issue TxOut is two.
+    # @return[Bitcoin::Protocol:Tx] The resulting transaction.
+    def send_bitcoin(from, amount, to, fees = nil, mode = 'broadcast', output_qty = 1)
+      validate_address([from, to])
+      colored_outputs = get_unspent_outputs([from])
+      btc_transfer_spec = OpenAssets::Transaction::TransferParameters.new(colored_outputs, to, from, amount, output_qty)
+      tx = create_tx_builder.transfer_btc(btc_transfer_spec, fees.nil? ? @config[:default_fees]: fees)
+      process_transaction(tx, mode)
+    end
+
+    # Creates a transaction for sending multiple bitcoins from an address to others.
+    # @param[String] from The address to send the bitcoins from.
+    # @param[Array[OpenAssets::SendBitcoinParam]] send_params The send information(amount of satoshis and to).
+    # @param[Integer] fees The fees in satoshis for the transaction.
+    # @param[String] mode 'broadcast' (default) for signing and broadcasting the transaction,
+    # 'signed' for signing the transaction without broadcasting,
+    # 'unsigned' for getting the raw unsigned transaction without broadcasting"""='broadcast'
+    # @return[Bitcoin::Protocol:Tx] The resulting transaction.
+    def send_bitcoins(from, send_params, fees = nil, mode = 'broadcast')
+      colored_outputs = get_unspent_outputs([from])
+      btc_transfer_specs = send_params.map{|param|
+        OpenAssets::Transaction::TransferParameters.new(colored_outputs, param.to, from, param.amount)
+      }
+      tx = create_tx_builder.transfer_btcs(btc_transfer_specs, fees.nil? ? @config[:default_fees]: fees)
+      tx = process_transaction(tx, mode)
+      tx
+    end
+
+
+    # Creates a transaction for burn asset.
+    # @param[String] oa_address The open asset address to burn asset.
+    # @param[String] asset_id The asset ID identifying the asset to burn.
+    # @param[Integer] fees The fess in satoshis for the transaction.
+    # @param[String] mode 'broadcast' (default) for signing and broadcasting the transaction,
+    # 'signed' for signing the transaction without broadcasting,
+    # 'unsigned' for getting the raw unsigned transaction without broadcasting"""='broadcast'
+    def burn_asset(oa_address, asset_id, fees = nil, mode = 'broadcast')
+      unspents = get_unspent_outputs([oa_address_to_address(oa_address)])
+      tx = create_tx_builder.burn_asset(unspents, asset_id, fees.nil? ? @config[:default_fees]: fees)
+      process_transaction(tx, mode)
+    end
+
+    # Get unspent outputs.
+    # @param [Array] addresses The array of Bitcoin address.
+    # @return [Array[OpenAssets::Transaction::SpendableOutput]] The array of unspent outputs.
+    def get_unspent_outputs(addresses)
+      validate_address(addresses)
+      unspent = provider.list_unspent(addresses, @config[:min_confirmation], @config[:max_confirmation])
+      result = unspent.map{|item|
+        output_result = get_output(item['txid'], item['vout'])
+        output_result.account = item['account']
+        output = OpenAssets::Transaction::SpendableOutput.new(
+          OpenAssets::Transaction::OutPoint.new(item['txid'], item['vout']), output_result)
+        output.confirmations = item['confirmations']
+        output.spendable = item['spendable']
+        output.solvable = item['solvable']
+        output
+      }
+      result
+    end
+
+    def get_output(txid, output_index)
+      if output_cache
+        cached = output_cache.get(txid, output_index)
+        return cached unless cached.nil?
+      end
+      decode_tx = load_cached_tx(txid)
+      tx = Bitcoin::Protocol::Tx.new(decode_tx.htb)
+      colored_outputs = get_color_outputs_from_tx(tx)
+      colored_outputs.each_with_index { |o, index| output_cache.put(txid, index, o)} if output_cache
+      colored_outputs[output_index]
+    end
+
+    def get_color_outputs_from_tx(tx)
+      unless tx.is_coinbase?
+        tx.outputs.each_with_index { |out, i|
+          marker_output_payload = OpenAssets::Protocol::MarkerOutput.parse_script(out.pk_script)
+          unless marker_output_payload.nil?
+            marker_output = OpenAssets::Protocol::MarkerOutput.deserialize_payload(marker_output_payload)
+            prev_outs = tx.inputs.map {|input|get_output(input.previous_output, input.prev_out_index)}
+            asset_ids = compute_asset_ids(prev_outs, i, tx, marker_output.asset_quantities)
+            return asset_ids unless asset_ids.nil?
+          end
+        }
+      end
+      tx.outputs.map{|out| OpenAssets::Protocol::TransactionOutput.new(out.value, out.parsed_script, nil, 0, OpenAssets::Protocol::OutputType::UNCOLORED)}
+    end
+
+    # Get tx outputs.
+    # @param[String] txid Transaction ID.
+    # @param[Boolean] use_cache If specified true use cache.(default value is false)
+    # @return[Array] Return array of the transaction output Hash with coloring information.
+    def get_outputs_from_txid(txid, use_cache = false)
+      tx = get_tx(txid, use_cache)
+      outputs = get_color_outputs_from_tx(tx)
+      outputs.map.with_index{|out, i|out.to_hash.merge({'txid' => tx.hash, 'vout' => i})}
+    end
+
+    # Get tx. (This method returns plain Bitcoin::Protocol::Tx object, so it not contains open asset information.)
+    # @param[String] txid Transaction ID.
+    # @return[Bitcoin::Protocol::Tx] Return the Bitcoin::Protocol::Tx.
+    def get_tx(txid, use_cache = true)
+      decode_tx = use_cache ? load_cached_tx(txid) : load_tx(txid)
+      Bitcoin::Protocol::Tx.new(decode_tx.htb)
+    end
+
+    private
+    # @param [Array[OpenAssets::Protocol::TransactionOutput] prev_outs The outputs referenced by the inputs of the transaction.
+    # @param [Integer] marker_output_index The position of the marker output in the transaction.
+    # @param [Bitcoin::Protocol::Tx] tx The transaction.
+    # @param [Array[OpenAssets::Protocol::TransactionOutput]] asset_quantities The list of asset quantities of the outputs.
+    def compute_asset_ids(prev_outs, marker_output_index, tx, asset_quantities)
+      outputs = tx.outputs
+      return nil if asset_quantities.length > outputs.length - 1 || prev_outs.length == 0
+      result = []
+
+      marker_output = outputs[marker_output_index]
+
+      # Add the issuance outputs
+      issuance_asset_id = script_to_asset_id(prev_outs[0].script.to_payload.bth)
+
+      for i in (0..marker_output_index-1)
+        value = outputs[i].value
+        script = outputs[i].parsed_script
+        if i < asset_quantities.length && asset_quantities[i] > 0
+          payload = OpenAssets::Protocol::MarkerOutput.parse_script(marker_output.parsed_script.to_payload)
+          metadata = OpenAssets::Protocol::MarkerOutput.deserialize_payload(payload).metadata
+          if (metadata.nil? || metadata.length == 0) && prev_outs[0].script.is_p2sh?
+            metadata = parse_issuance_p2sh_pointer(tx.in[0].script_sig)
+          end
+          metadata = '' unless metadata
+          output = OpenAssets::Protocol::TransactionOutput.new(value, script, issuance_asset_id, asset_quantities[i], OpenAssets::Protocol::OutputType::ISSUANCE, metadata)
+        else
+          output = OpenAssets::Protocol::TransactionOutput.new(value, script, nil, 0, OpenAssets::Protocol::OutputType::ISSUANCE)
+        end
+        result << output
+      end
+
+      # Add the marker output
+      result << OpenAssets::Protocol::TransactionOutput.new(marker_output.value, marker_output.parsed_script, nil, 0, OpenAssets::Protocol::OutputType::MARKER_OUTPUT)
+
+      # remove invalid marker
+      remove_outputs = []
+      for i in (marker_output_index + 1)..(outputs.length-1)
+        marker_output_payload = OpenAssets::Protocol::MarkerOutput.parse_script(outputs[i].pk_script)
+        unless marker_output_payload.nil?
+          remove_outputs << outputs[i]
+          result << OpenAssets::Protocol::TransactionOutput.new(
+              outputs[i].value, outputs[i].parsed_script, nil, 0, OpenAssets::Protocol::OutputType::MARKER_OUTPUT)
+          next
+        end
+      end
+      remove_outputs.each{|o|outputs.delete(o)}
+
+      # Add the transfer outputs
+      input_enum = prev_outs.each
+      input_units_left = 0
+      index = 0
+      for i in (marker_output_index + 1)..(outputs.length-1)
+        output_asset_quantity = (i <= asset_quantities.length) ? asset_quantities[i-1] : 0
+        output_units_left = output_asset_quantity
+        asset_id,metadata = nil
+        while output_units_left > 0
+          index += 1
+          if input_units_left == 0
+            begin
+            current_input = input_enum.next
+            input_units_left = current_input.asset_quantity
+            rescue StopIteration => e
+              return nil
+            end
+          end
+          unless current_input.asset_id.nil?
+            progress = [input_units_left, output_units_left].min
+            output_units_left -= progress
+            input_units_left -= progress
+            if asset_id.nil?
+              # This is the first input to map to this output
+              asset_id = current_input.asset_id
+              metadata = current_input.metadata
+            elsif asset_id != current_input.asset_id
+              return nil
+            end
+          end
+        end
+        result << OpenAssets::Protocol::TransactionOutput.new(outputs[i].value, outputs[i].parsed_script,
+                                                              asset_id, output_asset_quantity, OpenAssets::Protocol::OutputType::TRANSFER, metadata)
+      end
+      result
+    end
+
+    def process_transaction(tx, mode)
+      if mode == 'broadcast' || mode == 'signed'
+        # sign the transaction
+        signed_tx = provider.sign_transaction(tx.to_payload.bth)
+        if mode == 'broadcast'
+          puts provider.send_transaction(signed_tx.to_payload.bth)
+        end
+        signed_tx
+      else
+        tx
+      end
+    end
+
+    def change_network
+      case @config[:network]
+        when 'testnet'
+          Bitcoin.network = :testnet3
+        when 'regtest'
+          Bitcoin.network = :regtest
+        when 'litecoin'
+          Bitcoin.network = :litecoin
+        when 'litecoin_testnet'
+          Bitcoin.network = :litecoin_testnet
+        when 'monacoin'
+          Bitcoin.network = :monacoin
+        when 'monacoin_testnet'
+          Bitcoin.network = :monacoin_testnet
+        else
+          Bitcoin.network = :bitcoin
+      end
+    end
+
+    def create_tx_builder
+      if @config[:default_fees] == :auto
+        # Estimate a transaction fee rate (satoshis/KB) if fee is specified by :auto
+        efr = coin_to_satoshi(provider.estimatefee(1).to_s).to_i
+        if efr < 0
+          # Negative efr means "estimatefee" of bitcoin-api returns false
+          # In this case, use default minimum fees rate (10_000 satoshis/KB)
+          efr = 10_000
+        end
+        OpenAssets::Transaction::TransactionBuilder.new(@config[:dust_limit], efr)
+      else
+        # If fee is specified by a fixed value (or the default value)
+        OpenAssets::Transaction::TransactionBuilder.new(@config[:dust_limit])
+      end
+
+    end
+
+    def load_tx(txid)
+      decode_tx = provider.get_transaction(txid, 0)
+      raise OpenAssets::Transaction::TransactionBuildError, "txid #{txid} could not be retrieved." if decode_tx.nil?
+      decode_tx
+    end
+
+    def load_cached_tx(txid)
+      return load_tx(txid) unless tx_cache
+      decode_tx = tx_cache.get(txid)
+      if decode_tx.nil?
+        decode_tx = load_tx(txid)
+        tx_cache.put(txid, decode_tx)
+      end
+      decode_tx
+    end
+
+    # parse issuance p2sh which contains asset definition pointer
+    def parse_issuance_p2sh_pointer(script_sig)
+      script = Bitcoin::Script.new(script_sig).chunks.last
+      redeem_script = Bitcoin::Script.new(script)
+      return nil unless redeem_script.chunks[1] == Bitcoin::Script::OP_DROP
+      asset_def = to_bytes(redeem_script.chunks[0].to_s.bth)[0..-1].map{|x|x.to_i(16).chr}.join
+      asset_def && asset_def.start_with?('u=') ? asset_def : nil
+    end
+
+  end
+
+end