openassets-ruby 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa13af5ba17c13c7516e29819722ffc2a7a69766
+  data.tar.gz: d94cc426ab8af56d2e0967f415323c67de17a6f7
+SHA512:
+  metadata.gz: 3ebf299dbc652bffa5299bb23ab2cf32862f78cdadfcb010adf8d6a013a680d62b397fac19703de464612fa041ab01fd91959943414c65c9af04b869b3e07b20
+  data.tar.gz: d338cb28973172b73696a1acef698028d54904fef2fdebe7e5148478eff2acea596f65218c185808c35e1f76157b26d651b382347a11a7e991f80cad9831de32

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+*.iml

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+openassets-ruby

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in openassets-ruby.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 HAW International Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 azuchi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# openassets-ruby
+The implementation of the Open Assets Protocol for Ruby.
+
+## Configuration
+
+Initialize the connection information to the Bitcoin Core server.
+
+```ruby
+require 'openassets'
+
+api = OpenAssets::Api.new({:network => 'mainnet',
+                     :provider => 'bitcoind',
+                     :dust_limit => 600,
+                     :rpc => {:user => 'xxx', :password => 'xxx', :schema => 'http', :port => 8332, :host => 'localhost'}})                      
+```
+
+## API
+
+Currently openassets-ruby support the following API.   
+(The other API is in development. ex, send_asset)
+
+* **list_unspent**  
+Returns an array of unspent transaction outputs, argument with the asset ID and quantity of each output.
+  ```ruby
+  # get all unspent outputs in the wallet.
+  api.list_unspent
+  
+  # specify th open asset address.
+  api.list_unspent(['akTfC7D825Cse4NvFiLCy7vr3B6x2Mpq8t6'])
+  ``` 
+
+* **get_balance**  
+Returns the balance in both bitcoin and colored coin assets for all of the addresses available in your Bitcoin Core wallet.
+  ```ruby
+  # get all balance in the wallet.
+  api.get_balance
+  
+  # specify the open asset address.
+  api.get_balance('akTfC7D825Cse4NvFiLCy7vr3B6x2Mpq8t6')
+  ``` 
+  
+* **issue_asset**  
+Creates a transaction for issuing an asset.
+  ```ruby
+  # issue asset
+  # api.issue_asset(<issuer open asset address>, <issuing asset quantity>, <metadata>, <to open asset address>, <fees (The fess in satoshis for the transaction. use 10000 satoshi if specified nil)>, <mode=('broadcast', 'signed', 'unsigned')>)
+
+  # example
+  address = 'akEJwzkzEFau4t2wjbXoMs7MwtZkB8xixmH'
+  api.issue_asset(address, 150, 'u=https://goo.gl/bmVEuw', address, nil, 'broadcast')
+  ``` 
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2015 HAW International Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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/lib/openassets/api.rb

@@ -0,0 +1,229 @@
+# encoding: ascii-8bit
+
+module OpenAssets
+
+  class Api
+
+    include OpenAssets::Util
+
+    attr_reader :config
+    attr_reader :provider
+    attr_reader :cache
+
+    def initialize(config = nil)
+      @cache = {}
+      @config = {:network => 'mainnet',
+                 :provider => 'bitcoind',
+                 :dust_limit => 600, :default_fees => 10000,
+                 :rpc => { :host => 'localhost', :port => 8332 , :user => '', :password => '', :schema => 'https'}}
+      if config
+        @config.update(config)
+      end
+      if @config[:provider] == 'bitcoind'
+        @provider = Provider::BitcoinCoreProvider.new(@config[:rpc])
+      else
+        raise StandardError, 'specified unsupported provider.'
+      end
+    end
+
+    def provider
+      @provider
+    end
+
+    def is_testnet?
+      @config[:network] == 'testnet'
+    end
+
+    # get UTXO for colored coins.
+    # @param [Array] oa_address 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 = [])
+      outputs = get_unspent_outputs([])
+      result = outputs.map {|out|
+        address = script_to_address(out.output.script)
+        script = out.output.script.to_payload.bth
+        {
+          'txid' => out.out_point.hash,
+          'vout' =>  out.out_point.index,
+          'address' =>  address,
+          'oa_address' => address.nil? ? nil : address_to_oa_address(address),
+          'script' => script,
+          'amount' => satoshi_to_coin(out.output.value),
+          'confirmations' => out.confirmations,
+          'asset_id' => out.output.asset_id,
+          'asset_quantity' => out.output.asset_quantity.to_s
+        }
+      }
+      oa_address.empty? ? result : result.select{|r|oa_address.include?(r['oa_address'])}
+    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
+          }
+        }
+        {
+            '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
+        }
+      }
+      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'
+    def issue_asset(from, amount, metadata = nil, to = nil, fees = nil, mode = 'broadcast')
+      to = from if to.nil?
+      builder = OpenAssets::Transaction::TransactionBuilder.new(@config[:dust_limit])
+      colored_outputs = get_unspent_outputs([oa_address_to_address(from)])
+      issue_param = OpenAssets::Transaction::TransferParameters.new(colored_outputs, to, from, amount)
+      tx = builder.issue_asset(issue_param, metadata, fees.nil? ? @config[:default_fees]: fees)
+      tx = process_transaction(tx, mode)
+      tx
+    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)
+      result = unspent.map{|item|
+        output_result = get_output(item['txid'], item['vout'])
+        output = OpenAssets::Transaction::SpendableOutput.new(
+          OpenAssets::Transaction::OutPoint.new(item['txid'], item['vout']), output_result)
+        output.confirmations = item['confirmations']
+        output
+      }
+      result
+    end
+
+    def get_output(txid, output_index)
+      cached_output = @cache[txid + output_index.to_s]
+      return cached_output if cached_output
+      decode_tx = provider.get_transaction(txid, 0)
+      raise OpenAssets::Transaction::TransactionBuildError, "txid #{txid} could not be retrieved." if decode_tx.nil?
+      tx = Bitcoin::Protocol::Tx.new(decode_tx.htb)
+      colored_outputs = get_color_transaction(tx)
+      colored_outputs.each_with_index { |o, index | @cache[txid + index.to_s] = o}
+      colored_outputs[output_index]
+    end
+
+    def get_color_transaction(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)
+            inputs = tx.inputs.map {|input|
+              get_output(input.previous_output, input.prev_out_index)
+            }
+            asset_ids = compute_asset_ids(inputs, i, tx.outputs, 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
+
+    private
+    # @param [Array[OpenAssets::Protocol::TransactionOutput] inputs The outputs referenced by the inputs of the transaction.
+    # @param [Integer] marker_output_index The position of the marker output in the transaction.
+    # @param [Array[Bitcoin::Protocol::TxOUt]] outputs The outputs of the transaction.
+    # @param [Array[Integer]] asset_quantities The list of asset quantities of the outputs.
+    def compute_asset_ids(inputs, marker_output_index, outputs, asset_quantities)
+      return nil if asset_quantities.length > outputs.length - 1 || inputs.length == 0
+      result = []
+
+      # Add the issuance outputs
+      issuance_asset_id = pubkey_hash_to_asset_id(inputs[0].script.get_hash160)
+
+      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
+          output = OpenAssets::Protocol::TransactionOutput.new(value, script, issuance_asset_id, asset_quantities[i], OpenAssets::Protocol::OutputType::ISSUANCE)
+        else
+          output = OpenAssets::Protocol::TransactionOutput.new(value, script, nil, 0, OpenAssets::Protocol::OutputType::ISSUANCE)
+        end
+        result << output
+      end
+
+      # Add the marker output
+      marker_output = outputs[marker_output_index]
+      result << OpenAssets::Protocol::TransactionOutput.new(marker_output.value, marker_output.parsed_script, nil, 0, OpenAssets::Protocol::OutputType::MARKER_OUTPUT)
+
+      # Add the transfer outputs
+      input_enum = inputs.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 = 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
+            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)
+      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
+
+  end
+
+end

data/lib/openassets/error.rb

@@ -0,0 +1,5 @@
+module OpenAssets
+  class Error < StandardError
+
+  end
+end

data/lib/openassets/protocol/marker_output.rb

@@ -0,0 +1,82 @@
+module OpenAssets
+  module Protocol
+
+    class MarkerOutput
+      include OpenAssets::Util
+      extend OpenAssets::Util
+
+      MAX_ASSET_QUANTITY = 2 ** 63 -1
+
+      # A tag indicating thath this transaction is an Open Assets transaction.
+      OAP_MARKER = "4f41"
+      # The major revision number of the Open Assets Protocol.(1=0x0100)
+      VERSION = "0100"
+
+      attr_accessor :asset_quantities
+      attr_accessor :metadata
+
+      # @param [Array] asset_quantities The asset quantity array
+      # @param [String] metadata The metadata in the marker output.
+      def initialize(asset_quantities, metadata)
+        @asset_quantities = asset_quantities
+        @metadata = metadata
+      end
+
+      # Serialize the marker output into a Open Assets Payload buffer.
+      # @return [String] The serialized payload.
+      def to_payload
+        payload = [OAP_MARKER, VERSION]
+        payload << Bitcoin::Protocol.pack_var_int(@asset_quantities.length).unpack("H*")
+        @asset_quantities.map{|q|payload << encode_leb128(q)}
+        payload << Bitcoin::Protocol.pack_var_int(@metadata.length).unpack("H*")
+        tmp = []
+        @metadata.bytes{|b| tmp << b.to_s(16)}
+        payload << tmp.join
+        payload.join
+      end
+
+      # Deserialize the marker output payload.
+      # @param [String] payload The Open Assets Payload.
+      # @return [OpenAssets::Protocol::MarkerOutput] The marker output object.
+      def self.deserialize_payload(payload)
+        payload = payload[8..-1] # exclude OAP_MARKER,VERSION
+        asset_quantity, payload = parse_asset_qty(payload)
+        list = to_bytes(payload).map{|x|(x.to_i(16)>=128 ? x : x+"|")}.join.split('|')[0..(asset_quantity - 1)].join
+        asset_quantities = decode_leb128(list)
+        meta = to_bytes(payload[list.size..-1])
+        metadata = meta[1..-1].map{|x|x.to_i(16).chr}.join
+        new(asset_quantities, metadata)
+      end
+
+      # Parses an output and returns the payload if the output matches the right pattern for a marker output,
+      # @param [Bitcoin::Script] output_script: The output script to be parsed.
+      # @return [String] The byte string of the marker output payload if the output fits the pattern, nil otherwise.
+      def self.parse_script(output_script)
+        data = Bitcoin::Script.new(output_script).get_op_return_data
+        return data if data.nil?
+        data.start_with?(OAP_MARKER) ? data : nil
+      end
+
+      # Creates an output script containing an OP_RETURN and a PUSHDATA from payload.
+      # @return [Bitcoin::Script] the output script.
+      def build_script
+        Bitcoin::Script.from_string("OP_RETURN #{to_payload}")
+      end
+
+      private
+      def self.parse_asset_qty(payload)
+        bytes = to_bytes(payload)
+        case bytes[0]
+          when "fd" then
+            [(bytes[1]+bytes[2]).to_i(16), payload[6..-1]]
+          when "fe" then
+            [(bytes[1]+bytes[2]+bytes[3]+bytes[4]).to_i(16),payload[10..-1]]
+          else
+            [bytes[0].to_i(16),payload[2..-1]]
+        end
+      end
+
+    end
+
+  end
+end

data/lib/openassets/protocol/output_type.rb

@@ -0,0 +1,17 @@
+# 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
+
+    end
+  end
+end

data/lib/openassets/protocol/transaction_output.rb

@@ -0,0 +1,29 @@
+module OpenAssets
+  module Protocol
+
+    # Represents a transaction output and its asset ID and asset quantity.
+    class TransactionOutput
+      attr_accessor :value
+      attr_accessor :script
+      attr_accessor :asset_id
+      attr_accessor :asset_quantity
+      attr_accessor :output_type
+
+      # @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)
+        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
+      end
+    end
+
+  end
+end

data/lib/openassets/protocol.rb

@@ -0,0 +1,7 @@
+module OpenAssets
+  module Protocol
+    autoload :MarkerOutput, 'openassets/protocol/marker_output'
+    autoload :TransactionOutput, 'openassets/protocol/transaction_output'
+    autoload :OutputType, 'openassets/protocol/output_type'
+  end
+end

data/lib/openassets/provider/api_error.rb

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

data/lib/openassets/provider/bitcoin_core_provider.rb

@@ -0,0 +1,96 @@
+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
+      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)
+        request('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
+          request('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::Protocol::Tx] The signed transaction.
+      def sign_transaction(tx)
+        signed_tx = request('signrawtransaction', tx)
+        raise OpenAssets::Error, 'Could not sign the transaction.' unless signed_tx['complete']
+        Bitcoin::Protocol::Tx.new(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)
+        request('sendrawtransaction', tx)
+      end
+
+      private
+      # Convert decode tx string to Bitcion::Protocol::Tx
+      def decode_tx_to_btc_tx(tx)
+        hash = {
+          'version' => tx['version'],
+          'lock_time' => tx['locktime'],
+          'hex' => tx['hex'],
+          'txid' => tx['txid'],
+          'blockhash' => tx['blockhash'],
+          'confirmations' => tx['confirmations'],
+          'time' => tx['time'],
+          'blocktime' => tx['blocktime'],
+          'in' => tx['vin'].map{|input|
+            {'output_index' => input['vout'], 'previous_transaction_hash' => input['txid'], 'coinbase' => input['coinbase'],
+             'scriptSig' => input['scriptSig']['asm'], 'sequence' => input['sequence']}},
+          'out' => tx['vout'].map{|out|
+            {'amount' => out['value'], 'scriptPubKey' => out['scriptPubKey']['asm']}
+          }
+        }
+        Bitcoin::Protocol::Tx.from_hash(hash)
+      end
+
+      private
+      def server_url
+        url = "#{@config[:schema]}://"
+        url.concat "#{@config[:user]}:#{@config[:password]}@"
+        url.concat "#{@config[:host]}:#{@config[:port]}"
+        url
+      end
+
+      def request(command, *params)
+        data = {
+          :method => command,
+          :params => params,
+          :id => 'jsonrpc'
+        }
+        RestClient.post(server_url, data.to_json, content_type: :json) do |respdata, request, result|
+          response = JSON.parse(respdata)
+          raise ApiError, response['error'] if response['error']
+          response['result']
+        end
+      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/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/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_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/out_point.rb

@@ -0,0 +1,22 @@
+module OpenAssets
+  module Transaction
+
+    # The combination of a transaction hash and an index n into its vout
+    class OutPoint
+
+      attr_accessor :hash
+      attr_accessor :index
+
+      # @param [String] hash: 32 bytes transaction hash in vout.
+      # @param [Integer] index: index in vout.
+      def initialize(hash, index)
+        raise ArgumentError, 'hash must be exactly 32 bytes.' unless [hash].pack("H*").bytesize == 32
+        raise ArgumentError, 'index must be in range 0x0 to 0xffffffff.' unless index.between?(0x0, 0xffffffff)
+        @hash = hash
+        @index = index
+      end
+
+    end
+
+  end
+end

data/lib/openassets/transaction/spendable_output.rb

@@ -0,0 +1,24 @@
+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
+
+      # @param [OpenAssets::Transaction::OutPoint] out_point
+      # @param [OpenAssets::Protocol::TransactionOutput] output
+      def initialize(out_point, output)
+        @out_point = out_point
+        @output = output
+      end
+
+    end
+
+  end
+end

data/lib/openassets/transaction/transaction_build_error.rb

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

data/lib/openassets/transaction/transaction_builder.rb

@@ -0,0 +1,95 @@
+module OpenAssets
+  module Transaction
+
+    class TransactionBuilder
+      include OpenAssets::Util
+
+      # The minimum allowed output value.
+      attr_accessor :amount
+
+      def initialize(amount = 600)
+        @amount = amount
+      end
+
+      # issue 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 An unsigned transaction for issuing asset.
+      def issue_asset(issue_spec, metadata, fees)
+        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])
+        tx.add_out(create_colored_output(issue_address))
+        tx.add_out(create_marker_output([issue_spec.amount], metadata))
+        tx.add_out(create_uncolored_output(from_address, total_amount - @amount - fees))
+        tx
+      end
+
+      def transfer_assets
+
+      end
+
+      def transfer_btc
+
+      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
+
+      private
+      # create colored output.
+      # @param [String] address The Bitcoin address.
+      # @return [Bitcoin::Protocol::TxOut] colored output
+      def create_colored_output(address)
+        hash160 = Bitcoin.hash160_from_address(address)
+        Bitcoin::Protocol::TxOut.new(@amount,
+                                     Bitcoin::Script.new(Bitcoin::Script.to_hash160_script(hash160)).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
+        hash160 = Bitcoin.hash160_from_address(address)
+        Bitcoin::Protocol::TxOut.new(value, Bitcoin::Script.new(Bitcoin::Script.to_hash160_script(hash160)).to_payload)
+      end
+
+    end
+
+  end
+end

data/lib/openassets/transaction/transfer_parameters.rb

@@ -0,0 +1,27 @@
+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
+
+      # 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)
+        @unspent_outputs = unspent_outputs
+        @to_script = to_script
+        @change_script = change_script
+        @amount = amount
+      end
+
+    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 :OutPoint, 'openassets/transaction/out_point'
+    autoload :TransactionBuildError, 'openassets/transaction/transaction_build_error'
+    autoload :InsufficientFundsError, 'openassets/transaction/insufficient_funds_error'
+    autoload :DustOutputError, 'openassets/transaction/dust_output_error'
+  end
+end

data/lib/openassets/util.rb

@@ -0,0 +1,93 @@
+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
+
+    # 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(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）
+      script = hash160(["76", "a9", "14", hash, "88", "ac"].join)
+      script = OA_VERSION_BYTE.to_s(16) + script # add version byte to script hash
+      encode_base58(script + checksum(script)) # add checksum & encode
+    end
+
+    # LEB128 encode
+    def encode_leb128(value)
+      d7=->n{(n>>7)==0 ? [n] : d7[n>>7]+[127 & n]}
+      msb=->a{a0=a[0].to_s(16);[(a[0]< 16 ? "0"+a0 : a0)]+a[1..-1].map{|x|(x|128).to_s(16)}}
+      leb128=->n{msb[d7[n]].reverse.join}
+      leb128[value]
+    end
+
+    # LEB128 decode
+    def decode_leb128(value)
+      mbs = to_bytes(value).map{|x|(x.to_i(16)>=128 ? x : x+"|")}.join.split('|')
+      num=->a{(a.size==1 ? a[0] : (num[a[0..-2]]<<7)|a[-1])}
+      r7=->n{to_bytes(n).map{|x|(x.to_i(16))&127}}
+      mbs.map{|x|num[r7[x].reverse]}
+    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
+
+    # 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
+  end
+end

data/lib/openassets/version.rb

@@ -0,0 +1,3 @@
+module OpenAssets
+  VERSION = "0.1.1"
+end

data/lib/openassets.rb

@@ -0,0 +1,11 @@
+require 'bitcoin'
+module OpenAssets
+
+  autoload :Protocol, 'openassets/protocol'
+  autoload :Transaction, 'openassets/transaction'
+  autoload :VERSION, 'openassets/version'
+  autoload :Util, 'openassets/util'
+  autoload :Api, 'openassets/api'
+  autoload :Provider, 'openassets/provider'
+  autoload :Error, 'openassets/error'
+end

data/openassets-ruby.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'openassets/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "openassets-ruby"
+  spec.version       = OpenAssets::VERSION
+  spec.authors       = ["azuchi"]
+  spec.email         = ["azuchi@haw.co.jp"]
+
+  spec.summary       = %q{The implementation of the Open Assets Protocol for Ruby.}
+  spec.description   = %q{The implementation of the Open Assets Protocol for Ruby.}
+  spec.homepage      = "https://github.com/haw-itn/openassets-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency "bitcoin-ruby", "~> 0.0.7"
+  spec.add_runtime_dependency "ffi", "~>1.9.8"
+  spec.add_runtime_dependency "rest-client", "~>1.8.0"
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: openassets-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- azuchi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-08-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bitcoin-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.8
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The implementation of the Open Assets Protocol for Ruby.
+email:
+- azuchi@haw.co.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/openassets.rb
+- lib/openassets/api.rb
+- lib/openassets/error.rb
+- lib/openassets/protocol.rb
+- lib/openassets/protocol/marker_output.rb
+- lib/openassets/protocol/output_type.rb
+- lib/openassets/protocol/transaction_output.rb
+- lib/openassets/provider.rb
+- lib/openassets/provider/api_error.rb
+- lib/openassets/provider/bitcoin_core_provider.rb
+- lib/openassets/provider/block_chain_provider_base.rb
+- lib/openassets/transaction.rb
+- lib/openassets/transaction/dust_output_error.rb
+- lib/openassets/transaction/insufficient_funds_error.rb
+- lib/openassets/transaction/out_point.rb
+- lib/openassets/transaction/spendable_output.rb
+- lib/openassets/transaction/transaction_build_error.rb
+- lib/openassets/transaction/transaction_builder.rb
+- lib/openassets/transaction/transfer_parameters.rb
+- lib/openassets/util.rb
+- lib/openassets/version.rb
+- openassets-ruby.gemspec
+homepage: https://github.com/haw-itn/openassets-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: The implementation of the Open Assets Protocol for Ruby.
+test_files: []