monacoin-openassets-ruby 0.1.3

data/lib/openassets/protocol/output_type.rb

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

data/lib/openassets/protocol/transaction_output.rb

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

data/lib/openassets/provider.rb

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

data/lib/openassets/provider/api_error.rb

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

data/lib/openassets/provider/bitcoin_core_provider.rb

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

data/lib/openassets/provider/block_chain_provider_base.rb

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

data/lib/openassets/send_asset_param.rb

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

data/lib/openassets/send_bitcoin_param.rb

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

data/lib/openassets/transaction.rb

@@ -0,0 +1,12 @@
+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 :InsufficientAssetQuantityError, 'openassets/transaction/insufficient_asset_quantity_error'
+    autoload :DustOutputError, 'openassets/transaction/dust_output_error'
+  end
+end

data/lib/openassets/transaction/dust_output_error.rb

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

data/lib/openassets/transaction/insufficient_asset_quantity_error.rb

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

data/lib/openassets/transaction/insufficient_funds_error.rb

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

data/lib/openassets/transaction/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