monacoin-openassets-ruby 0.1.3

data/lib/openassets/cache.rb

@@ -0,0 +1,8 @@
+module OpenAssets
+  module Cache
+    autoload :SQLiteBase, 'openassets/cache/sqlite_base'
+    autoload :TransactionCache, 'openassets/cache/transaction_cache'
+    autoload :SSLCertificateCache, 'openassets/cache/ssl_certificate_cache'
+    autoload :OutputCache, 'openassets/cache/output_cache'
+  end
+end

data/lib/openassets/cache/output_cache.rb

@@ -0,0 +1,43 @@
+module OpenAssets
+  module Cache
+
+    # An object that can be used for caching coloring transaction output in a Sqlite database.
+    class OutputCache < SQLiteBase
+
+      def setup
+        db.execute <<-SQL
+          CREATE TABLE IF NOT EXISTS Output(
+                  TransactionHash BLOB,
+                  OutputIndex INT,
+                  Value BigInt,
+                  Script BLOB,
+                  AssetId BLOB,
+                  AssetQuantity INT,
+                  OutputType INT,
+                  Metadata BLOB,
+                  PRIMARY KEY (TransactionHash, OutputIndex))
+        SQL
+      end
+
+      # Get a cached transaction output
+      # @param[String] txid The transaction id.
+      # @param[Integer] index The index of the output in the transaction.
+      # @return[OpenAssets::Protocol::TransactionOutput] The output for the txid and index provided if it is found in the cache, or nil otherwise.
+      def get(txid, index)
+        rows = db.execute('SELECT Value,Script,AssetId,AssetQuantity,OutputType,Metadata FROM Output WHERE TransactionHash = ? AND OutputIndex = ?', [txid, index])
+        return nil if rows.empty?
+        script = Bitcoin::Script.from_string(rows[0][1])
+        OpenAssets::Protocol::TransactionOutput.new(rows[0][0], script, rows[0][2], rows[0][3], rows[0][4], rows[0][5])
+      end
+
+      # Put a transaction output
+      # @param[String] txid The transaction id.
+      # @param[Integer] index The index of the output in the transaction.
+      # @param[OpenAssets::Protocol::TransactionOutput] output The output to save.
+      def put(txid, index, output)
+        db.execute('INSERT INTO Output (TransactionHash, OutputIndex, Value,Script,AssetId,AssetQuantity,OutputType,Metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+                   [txid, index, output.value, output.script.to_string, output.asset_id, output.asset_quantity, output.output_type, output.metadata])
+      end
+    end
+  end
+end

data/lib/openassets/cache/sqlite_base.rb

@@ -0,0 +1,26 @@
+require 'sqlite3'
+
+module OpenAssets
+  module Cache
+
+    # The base class of SQLite3 cache implementation.
+    class SQLiteBase
+
+      attr_reader :db
+
+      # Initializes the connection to the database, and creates the table if needed.
+      # @param[String] path The path to the database file. Use ':memory:' for an in-memory database.
+      def initialize(path)
+        @db = SQLite3::Database.new path
+        setup
+      end
+
+      # Setup table ddl, implements by subclass.
+      def setup
+        raise StandardError.new('need setup method implementation.')
+      end
+
+    end
+
+  end
+end

data/lib/openassets/cache/ssl_certificate_cache.rb

@@ -0,0 +1,44 @@
+module OpenAssets
+  module Cache
+    class SSLCertificateCache < SQLiteBase
+
+      def initialize
+        path = OpenAssets.configuration ? OpenAssets.configuration[:cache] : ':memory:'
+        super(path)
+      end
+
+      def setup
+        db.execute <<-SQL
+          CREATE TABLE IF NOT EXISTS SslCertificate(
+                  Url TEXT,
+                  Subject TEXT,
+                  ExpireDate TEXT,
+                  PRIMARY KEY (Url))
+        SQL
+      end
+
+      # Return the subject value which defined by ssl certificate.
+      # @param[String] url The URL of asset definition file.
+      # @return[String] The subject value. If not found, return nil.
+      def get(url)
+        rows = db.execute('SELECT Subject,ExpireDate FROM SslCertificate WHERE Url = ?', [url])
+        return nil if rows.empty?
+        if rows[0][1].to_i < Time.now.to_i
+          db.execute('DELETE FROM SslCertificate where Url = ?', [url])
+          nil
+        else
+          rows[0][0]
+        end
+      end
+
+      # Saves a serialized transaction in cache.
+      # @param[String] url The URL of asset definition file.
+      # @param[String] subject The SSL Certificate subject value.
+      # @param[Time] expire_date The expire date of SSL Certificate.
+      def put(url, subject, expire_date)
+        db.execute('INSERT INTO SslCertificate (Url, Subject, ExpireDate) VALUES (?, ?, ?)', [url, subject, expire_date.to_i])
+      end
+
+    end
+  end
+end

data/lib/openassets/cache/transaction_cache.rb

@@ -0,0 +1,33 @@
+module OpenAssets
+  module Cache
+
+    # An object that can be used for caching serialized transaction in a Sqlite database.
+    class TransactionCache < SQLiteBase
+
+      def setup
+        db.execute <<-SQL
+          CREATE TABLE IF NOT EXISTS Tx(
+                  TransactionHash BLOB,
+                  SerializedTx BLOB,
+                  PRIMARY KEY (TransactionHash))
+        SQL
+      end
+
+      # Return the serialized transaction.
+      # @param[String] txid The transaction id.
+      # @return[String] The serialized transaction. If not found transaction, return nil.
+      def get(txid)
+        rows = db.execute('SELECT SerializedTx FROM Tx WHERE TransactionHash = ?', [txid])
+        rows.empty? ? nil : rows[0][0]
+      end
+
+      # Saves a serialized transaction in cache.
+      # @param[String] txid A transaction id.
+      # @param[String] serialized_tx A a hex-encoded serialized transaction.
+      def put(txid, serialized_tx)
+        db.execute('INSERT INTO Tx (TransactionHash, SerializedTx) VALUES (?, ?)', [txid, serialized_tx])
+      end
+    end
+
+  end
+end

data/lib/openassets/error.rb

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

data/lib/openassets/medhod_filter.rb

@@ -0,0 +1,55 @@
+module OpenAssets
+  module MethodFilter
+
+    module Filters
+
+      def before_filter(method, options = {})
+        @before_filters ||= {}
+        @before_filters[method] = options
+      end
+
+      def filtered_method?(method, options)
+        if options.has_key? :include
+          return true if options[:include].include? method.intern
+          false
+        elsif options.has_key? :exclude
+          return false if options[:exclude].include? method.intern
+          true
+        else
+          true
+        end
+      end
+
+      private
+      def method_added(name)
+        @before_filters ||= {}
+        @modified_methods ||= []
+        return if @modified_methods.include?(name)
+        return if @before_filters.include?(name)
+        return if /with_filters$/ =~ name.to_s
+        return if  /without_filters$/ =~ name.to_s
+        @modified_methods << name
+
+        name = name.to_s
+        alias_method( "#{name}_without_filters", name)
+        before_filters = @before_filters
+
+        define_method("#{name}_with_filters") do |*args|
+          before_filters.each do |filter_name, options|
+            method(filter_name).call if self.class.filtered_method?(name, options)
+          end
+          result = method("#{name}_without_filters").call(*args)
+          result
+        end
+
+        alias_method(name, "#{name}_with_filters")
+        @modified_methods.delete_if { |x| name == x }
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend(Filters)
+    end
+
+  end
+end

data/lib/openassets/protocol.rb

@@ -0,0 +1,10 @@
+module OpenAssets
+  module Protocol
+    autoload :MarkerOutput, 'openassets/protocol/marker_output'
+    autoload :TransactionOutput, 'openassets/protocol/transaction_output'
+    autoload :OutputType, 'openassets/protocol/output_type'
+    autoload :AssetDefinitionLoader, 'openassets/protocol/asset_definition_loader'
+    autoload :HttpAssetDefinitionLoader, 'openassets/protocol/http_asset_definition_loader'
+    autoload :AssetDefinition, 'openassets/protocol/asset_definition'
+  end
+end

data/lib/openassets/protocol/asset_definition.rb

@@ -0,0 +1,118 @@
+require 'rest-client'
+require 'httpclient'
+module OpenAssets
+  module Protocol
+
+    # The Definition of Open Asset
+    class AssetDefinition
+      include OpenAssets::MethodFilter
+
+      before_filter :clear_poa_cache, {:include => [:issuer=, :asset_definition_url=, :link_to_website=]}
+
+      attr_accessor :asset_definition_url
+
+      attr_accessor :asset_ids
+      attr_accessor :name_short
+      attr_accessor :name
+      attr_accessor :contract_url
+      attr_accessor :issuer
+      attr_accessor :description
+      attr_accessor :description_mime
+      attr_accessor :type
+      attr_accessor :divisibility
+      attr_accessor :link_to_website
+      attr_accessor :icon_url
+      attr_accessor :image_url
+      attr_accessor :version
+      attr_accessor :proof_of_authenticity
+
+      def initialize
+        @asset_ids = []
+        @version = '1.0'
+        @divisibility = 0
+      end
+
+      # Parse the JSON obtained from the json String, and create a AssetDefinition object.
+      # @param[String]
+      def self.parse_json(json)
+        parsed_json = JSON.parse(json)
+        definition = new
+        definition.asset_ids = parsed_json['asset_ids']
+        definition.name_short = parsed_json['name_short']
+        definition.name = parsed_json['name']
+        definition.contract_url = parsed_json['contract_url']
+        definition.issuer = parsed_json['issuer']
+        definition.description = parsed_json['description']
+        definition.description_mime = parsed_json['description_mime']
+        definition.type = parsed_json['type']
+        definition.divisibility = parsed_json['divisibility']
+        definition.link_to_website = parsed_json['link_to_website']
+        definition.icon_url = parsed_json['icon_url']
+        definition.image_url = parsed_json['image_url']
+        definition.version = parsed_json['version']
+        definition
+      end
+
+      def include_asset_id?(asset_id)
+        return false if asset_ids.nil? || asset_ids.empty?
+        asset_ids.include?(asset_id)
+      end
+
+      # Convert Asset Definition to json format.
+      def to_json
+        h = to_hash
+        h.delete('proof_of_authenticity')
+        h.to_json
+      end
+
+      def to_hash
+        instance_variables.inject({}) do |result, var|
+          key = var.to_s
+          key.slice!(0) if key.start_with?('@')
+          result.update(key => instance_variable_get(var))
+        end
+      end
+
+      # Check Proof of authenticity.
+      # SSL certificate subject matches issuer.
+      def proof_of_authenticity
+        @proof_of_authenticity ||= calc_proof_of_authenticity
+      end
+
+      private
+      def calc_proof_of_authenticity
+        result = false
+        if !asset_definition_url.nil? && link_to_website
+          subject = ssl_certificate_subject
+          return true if !subject.nil? && subject == issuer
+        end
+        result
+      end
+
+      def clear_poa_cache
+        @proof_of_authenticity = nil
+      end
+
+      def ssl_certificate_subject
+        cache = OpenAssets::Cache::SSLCertificateCache.new
+        subject = cache.get(asset_definition_url)
+        if subject.nil?
+          client = HTTPClient.new
+          client.redirect_uri_callback = ->(uri, res) {res.header['location'][0]}
+          response = client.get(asset_definition_url, :follow_redirect => true)
+          cert = response.peer_cert
+          unless cert.nil?
+            subjects = cert.subject.to_a
+            o = subjects.find{|x|x[0] == 'O'}
+            if !o.nil? && o.length > 2
+              subject = o[1]
+              cache.put(asset_definition_url, subject, cert.not_after)
+            end
+          end
+        end
+        subject
+      end
+    end
+
+  end
+end

data/lib/openassets/protocol/asset_definition_loader.rb

@@ -0,0 +1,43 @@
+module OpenAssets
+  module Protocol
+
+    class AssetDefinitionLoader
+      extend Bitcoin::Util
+      extend OpenAssets::Util
+
+      attr_reader :loader
+
+      def initialize(url)
+        if url.start_with?('http://') || url.start_with?('https://')
+          @loader = HttpAssetDefinitionLoader.new(url)
+        end
+      end
+
+      # load Asset Definition File
+      # @return[OpenAssets::Protocol::AssetDefinition] loaded asset definition object
+      def load_definition
+        @loader.load if @loader
+      end
+
+      # create redeem script of asset definition file using p2sh
+      # @param[String] url The asset definition url.
+      # @param[String] to The open asset address to send the asset to.
+      # @return[Bitcoin::Script] redeem script.
+      def self.create_pointer_redeem_script(url, to)
+        asset_def = "u=#{url}".bytes.map{|b|b.to_s(16)}.join
+        btc_addr = oa_address_to_address(to)
+        script = Bitcoin::Script.from_string("#{asset_def}")
+        Bitcoin::Script.new(script.append_opcode(Bitcoin::Script::OP_DROP).to_payload + Bitcoin::Script.to_address_script(btc_addr))
+      end
+
+      # create ps2s script which specify asset definition pointer
+      # @param[String] url The asset definition url.
+      # @param[String] to The open asset address to send the asset to.
+      # @return[Bitcoin::Script] p2sh script.
+      def self.create_pointer_p2sh(url, to)
+        redeem_script = create_pointer_redeem_script(url, to)
+        Bitcoin::Script.new(Bitcoin::Script.to_p2sh_script(hash160(redeem_script.to_payload.bth)))
+      end
+    end
+  end
+end

data/lib/openassets/protocol/http_asset_definition_loader.rb

@@ -0,0 +1,27 @@
+module OpenAssets
+  module Protocol
+
+    # Asset Definition loader for http or https uri scheme
+    class HttpAssetDefinitionLoader
+
+      attr_reader :url
+
+      def initialize(url)
+        @url = url
+      end
+
+      # load asset definition
+      def load
+        begin
+          definition = AssetDefinition.parse_json(RestClient::Request.execute(:method => :get, :url => url, :timeout => 10, :open_timeout => 10))
+          definition.asset_definition_url = url
+          definition
+        rescue => e
+          puts e
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/openassets/protocol/marker_output.rb

@@ -0,0 +1,128 @@
+require 'rest-client'
+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]
+        asset_quantity_count = Bitcoin::Protocol.pack_var_int(@asset_quantities.length).unpack("H*")
+        payload << sort_count(asset_quantity_count[0])
+        @asset_quantities.map{|q|payload << encode_leb128(q)}
+        @metadata ||= ''
+        metadata_length = Bitcoin::Protocol.pack_var_int(@metadata.length).unpack("H*")
+        payload << sort_count(metadata_length[0])
+        payload << @metadata.bytes.map{|b| sprintf("%02x", b)}.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)
+        return nil unless valid?(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.empty? ? '' : 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 valid?(data)
+      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
+
+      def sort_count(count)
+        bytes = to_bytes(count)
+        case bytes[0]
+          when "fd" then
+            tmp         = count[2..3]
+            count[2..3] = count[4..5]
+            count[4..5] = tmp
+            count
+          when "fe" then
+            tmp_1       = count[2..3]
+            tmp_2       = count[4..5]
+            count[2..3] = count[8..9]
+            count[8..9] = tmp_1
+            count[4..5] = count[6..7]
+            count[6..7] = tmp_2
+            count
+          else
+            count
+        end
+      end
+
+      # validate marker output format
+      # @param[String] data marker output data with start with 4f41
+      def self.valid?(data)
+        return false if data.nil?
+        # check open assets marker
+        return false unless data.start_with?(OAP_MARKER + VERSION)
+        # check asset quantity
+        offset = [OAP_MARKER + VERSION].pack('H*').length
+        count, offset = read_var_integer(data, offset)
+        return false unless count
+        # check metadata
+        count.times do
+          quantity, length = read_leb128(data, offset)
+          return false if quantity.nil? || (length - offset) > 9
+          offset = length
+        end
+        # check metadata
+        length, offset = read_var_integer(data, offset)
+        return false unless length
+        return false if [data].pack('H*').bytes.length < length + offset
+        true
+      end
+
+    end
+
+  end
+end