cryptoprocessing 0.6.1

data/lib/cryptoprocessing/client/callbacks.rb

@@ -0,0 +1,39 @@
+require 'cryptoprocessing/models/callback'
+
+module Cryptoprocessing
+  class Client
+    module Callbacks
+      # Callback list
+      #
+      # @param [String] account_id
+      # @return [Array<Cryptoprocessing::Callback>]
+      # @see https://api.cryptoprocessing.io/#e8bbf0e7-38e7-3e98-17f5-04733f419242
+      def callbacks(account_id, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        get("/v1/#{currency}/accounts/#{account_id}/callback", options) do |resp|
+          out = resp.data['addresses'].map { |item| Cryptoprocessing::Callback.new(self, item) }
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+
+      # Create callback
+      #
+      # @param [String] account_id
+      # @param [String] address URL for callback
+      # @return [Cryptoprocessing::Callback]
+      # @see https://api.cryptoprocessing.io/#62b671c8-ba1c-5101-37a8-1ddf3dafb758
+      def create_callback(account_id, address, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        options[:address] = address
+        post("/v1/#{currency}/accounts/#{account_id}/callback", options) do |resp|
+          out = Cryptoprocessing::Callback.new(self, resp.body.merge(options))
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+    end
+  end
+end

data/lib/cryptoprocessing/client/coinbase_wallet.rb

@@ -0,0 +1,45 @@
+module Cryptoprocessing
+  class Client
+    ##
+    # Mimic Coinbase Wallet Client
+    #
+    module CoinbaseWallet
+      ##
+      #
+      #
+      def primary_account
+
+      end
+
+      # ##
+      # #
+      # #
+      # def create_address(options)
+      #   @client.create_address(options)
+      # end
+
+      ##
+      #
+      #
+      def address_transactions(account_uid, address_uid, params = {})
+        list_transactions = []
+
+        @client.address_transactions(account_uid, address_uid) do |data, resp|
+          data.each do |tx|
+            if tx['confirmations_count'] > 3 && tx['type'] == 'send'
+              list_transactions.append(tx)
+            end
+          end
+        end
+        list_transactions
+      end
+
+      ##
+      #
+      #
+      def accounts
+        []
+      end
+    end
+  end
+end

data/lib/cryptoprocessing/client/net_response.rb

@@ -0,0 +1,100 @@
+require 'cryptoprocessing/client/api_response'
+require 'cryptoprocessing/client/api_errors'
+
+module Cryptoprocessing
+  # Net-Http response object
+  class NetHTTPResponse < APIResponse
+    def body
+      JSON.parse(@response.body) rescue {}
+    end
+
+    def body=(body)
+      @response.body = body.to_json
+    end
+
+    def data
+      body
+    end
+
+    def headers
+      out = @response.to_hash.map do |key, val|
+        [key.upcase.gsub('_', '-'), val.count == 1 ? val.first : val]
+      end
+      out.to_h
+    end
+
+    def status
+      @response.code.to_i
+    end
+  end
+
+  def self.check_response_status(resp)
+    if resp.status == 200 && resp.body.kind_of?(Array)
+      return
+    end
+
+    (resp.body['warnings'] || []).each do |warning|
+      message = "WARNING: #{warning['message']}"
+      message += " (#{warning['url']})" if warning["url"]
+      $stderr.puts message
+    end
+
+    # OAuth2 errors
+    if resp.status >= 400 && resp.body['error']
+      raise Cryptoprocessing::APIError, resp.body['error_description']
+    end
+
+    # Regular errors
+    if resp.body['errors']
+      case resp.status
+      when 400
+        case resp.body['errors'].first['id']
+        when 'param_required' then
+          raise ParamRequiredError, format_error(resp)
+        when 'invalid_request' then
+          raise InvalidRequestError, format_error(resp)
+        when 'personal_details_required' then
+          raise PersonalDetailsRequiredError, format_error(resp)
+        end
+        raise BadRequestError, format_error(resp)
+      when 401
+        case resp.body['errors'].first['id']
+        when 'authentication_error' then
+          raise AuthenticationError, format_error(resp)
+        when 'unverified_email' then
+          raise UnverifiedEmailError, format_error(resp)
+        when 'invalid_token' then
+          raise InvalidTokenError, format_error(resp)
+        when 'revoked_token' then
+          raise RevokedTokenError, format_error(resp)
+        when 'expired_token' then
+          raise ExpiredTokenError, format_error(resp)
+        end
+        raise AuthenticationError, format_error(resp)
+      when 402 then
+        raise TwoFactorRequiredError, format_error(resp)
+      when 403 then
+        raise InvalidScopeError, format_error(resp)
+      when 404 then
+        raise NotFoundError, format_error(resp)
+      when 422 then
+        raise ValidationError, format_error(resp)
+      when 429 then
+        raise RateLimitError, format_error(resp)
+      when 500 then
+        raise InternalServerError, format_error(resp)
+      when 503 then
+        raise ServiceUnavailableError, format_error(resp)
+      end
+    end
+
+    # API errors
+    if resp.body['status'] == 'fail'
+      raise Cryptoprocessing::APIError, resp.body['message']
+    end
+
+    if resp.status > 400
+      raise Cryptoprocessing::APIError, "[#{resp.status}] #{resp.body}"
+    end
+  end
+end

data/lib/cryptoprocessing/client/trackers.rb

@@ -0,0 +1,37 @@
+require 'cryptoprocessing/models/tracker'
+
+module Cryptoprocessing
+  class Client
+    module Trackers
+      # Tracking address list
+      #
+      # @param [String] account_id
+      # @see https://api.cryptoprocessing.io/#bb7723d0-761b-46cd-f6ed-9ca2699f47df
+      def trackers(account_id, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        get("/v1/#{currency}/accounts/#{account_id}/tracing/address", options) do |resp|
+          out = resp.data['addresses'].map { |item| Cryptoprocessing::Tracker.new(self, item) }
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+
+      # Add address for tracking
+      #
+      # @param [String] account_id
+      # @param [String] address
+      # @see https://api.cryptoprocessing.io/#bb7723d0-761b-46cd-f6ed-9ca2699f47df
+      def create_tracker(account_id, address, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        options[:address] = address
+        post("/v1/#{currency}/accounts/#{account_id}/tracing/address", options) do |resp|
+          out = Cryptoprocessing::Tracker.new(self, resp.data.merge(options))
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+    end
+  end
+end

data/lib/cryptoprocessing/client/transactions.rb

@@ -0,0 +1,90 @@
+require 'cryptoprocessing/models/transaction'
+
+module Cryptoprocessing
+  class Client
+    # @see https://api.cryptoprocessing.io/#c42e8a72-9e11-c074-22ef-4fc9a70a1a8f
+    module Transactions
+      TRANSACTION_SEND_TYPE = 'send'
+      TRANSACTION_SEND_TYPE_RAW = 'sendraw'
+
+      TRANSACTION_FEE_FASTEST = 'fastestFee'
+      TRANSACTION_FEE_HALF_HOUR = 'halfHourFee'
+      TRANSACTION_FEE_HOUR = 'hourFee'
+
+      # List transactions
+      #
+      # список транзакций
+      #
+      # @param [String] account_id
+      # @return [Array<Cryptoprocessing::Transaction>] A list of transactions
+      # @see https://api.cryptoprocessing.io/#690f04ca-cc2b-750b-17c6-4cc290a65d98
+      def transactions(account_id, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        get("/v1/#{currency}/accounts/#{account_id}/transactions", options) do |resp|
+          out = resp.data['transactions'].map { |item| Cryptoprocessing::Transaction.new(self, item) }
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+
+      # List transactions filtered by address
+      #
+      # @param [String] account_id
+      # @param [String] address
+      # @return [Array<Cryptoprocessing::Transaction>] A list of transactions
+      # @see https://api.cryptoprocessing.io/#0e6e0dbc-1c1b-23db-dc54-a3b36ed276d8
+      def transactions_by_address(account_id, address, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        get("/v1/#{currency}/accounts/#{account_id}/transactions/address/#{address}", options) do |resp|
+          out = resp.data.map { |item| Cryptoprocessing::Transaction.new(self, item) }
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+
+      # Send raw transaction signed transaction to the blockchain
+      #
+      # Отсылаем в блокчейн сырую подписанную транзакцию
+      #
+      # @param [String] raw_transaction_id
+      # @return [Cryptoprocessing::Transaction]
+      # @see https://api.cryptoprocessing.io/#655161a4-f6ff-6764-1667-8fb039912546
+      def send_raw_transaction(raw_transaction_id, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        options[:type] = TRANSACTION_SEND_TYPE_RAW
+        options[:raw_transaction_id] = raw_transaction_id
+        post("/v1/#{currency}/sendrawtx", options) do |resp|
+          out = Cryptoprocessing::Transaction.new(self, resp.data.merge(options))
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+
+      # Create transaction
+      #
+      # Создаем транзакцию
+      #
+      # @param [String] account_id
+      # @return [Cryptoprocessing::Transaction]
+      # @see https://api.cryptoprocessing.io/#8dd94a75-4b09-588e-c9ad-c9cb5f165d72
+      def create_transaction(account_id, options = {})
+        out = nil
+        currency = if options[:currency] then options[:currency] else blockchain_type end
+        options[:type] = TRANSACTION_SEND_TYPE
+        options[:fee] = options[:fee] || TRANSACTION_FEE_FASTEST
+        options[:from_] = options[:from]
+        options[:to_] = options[:to]
+        options.delete(:from)
+        options.delete(:to)
+        post("/v1/#{currency}/accounts/#{account_id}/transactions", options) do |resp|
+          out = Cryptoprocessing::Transaction.new(self, resp.data.merge(options))
+          yield(out, resp) if block_given?
+        end
+        out
+      end
+    end
+  end
+end

data/lib/cryptoprocessing/configurable.rb

@@ -0,0 +1,73 @@
+module Cryptoprocessing
+
+  # Configuration options for {Client}, defaulting to values
+  # in {Default}
+  module Configurable
+    # @!attribute [w] access_token
+    #   @return [String] Access token for authentication
+    attr_accessor :access_token, :blockchain_type, :user_agent
+    # @!attribute api_endpoint
+    #   @return [String] Base URL for API requests.
+    attr_writer :email, :password, :api_endpoint, :api_namespace
+
+    class << self
+      # List of configurable keys for {Cryptoprocessing::Client}
+      # @return [Array] of option keys
+      def keys
+        @keys ||= [
+            :access_token,
+            :api_endpoint,
+            :api_namespace,
+            :blockchain_type,
+            :email,
+            :password,
+            :user_agent
+        ]
+      end
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      Cryptoprocessing::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Cryptoprocessing::Default.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+    # Compares client options to a Hash of requested options
+    #
+    # @param opts [Hash] Options to compare with current client options
+    # @return [Boolean]
+    def same_options?(opts)
+      opts.hash == options.hash
+    end
+
+    def blockchain_type
+      @blockchain_type
+    end
+
+    def api_endpoint
+      File.join(@api_endpoint, '')
+    end
+
+    def api_namespace
+      File.join(@api_namespace, '')
+    end
+
+    def netrc?
+      !!@netrc
+    end
+
+    private
+
+    def options
+      Hash[Cryptoprocessing::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+  end
+end

data/lib/cryptoprocessing/connection.rb

@@ -0,0 +1,140 @@
+require 'net/http'
+require 'json/ext'
+require 'cryptoprocessing/version'
+require 'cryptoprocessing/client/net_response'
+
+module Cryptoprocessing
+  module Connection
+
+    def endpoint
+      api_endpoint
+    end
+
+    # @return [Net::HTTP]
+    def agent
+      base_uri = URI.parse(endpoint)
+      @agent = Net::HTTP.new(base_uri.host, base_uri.port)
+      @agent.use_ssl = true if base_uri.scheme == 'https'
+      # @agent.cert_store = self.class.whitelisted_certificates
+      @agent.ssl_version = :TLSv1
+      @agent
+    end
+
+    ##
+    # @param [String] method
+    # @param [String] path
+    # @param [String] body
+    # @param [String] headers
+    def request(method, path, body = nil, headers = {})
+      # Prepend configured namespace
+      path = "#{@api_namespace}#{path}"
+
+      case method
+      when 'GET' then
+        req = Net::HTTP::Get.new(path)
+      when 'PUT' then
+        req = Net::HTTP::Put.new(path)
+      when 'POST' then
+        req = Net::HTTP::Post.new(path)
+      when 'DELETE' then
+        req = Net::HTTP::Delete.new(path)
+      else
+        raise
+      end
+
+      req.body = body
+
+      # All requests with JSON encoded body
+      req['Content-Type'] = 'application/json'
+
+      # Set User Agent to Gem name and version
+      req['User-Agent'] = user_agent
+
+      auth_headers(method, path, body).each do |key, val|
+        req[key] = val
+      end
+      headers.each do |key, val|
+        req[key] = val
+      end
+
+      resp = agent.request(req)
+      out = Cryptoprocessing::NetHTTPResponse.new(resp)
+      Cryptoprocessing::check_response_status(out)
+      yield(out) if block_given?
+      out.data
+    end
+
+    def auth_headers(method, path, body)
+      {:Authorization => "Bearer #{@access_token}"}
+    end
+
+    def reset_agent
+      @agent = nil
+    end
+
+    ##
+    # HTTP GET method
+    #
+    # @param [String] path
+    def get(path, params = {})
+      uri = path
+      if params.count > 0
+        uri += "?#{URI.encode_www_form(params)}"
+      end
+
+      headers = {}
+
+      request('GET', uri, nil, headers) do |resp|
+        if params[:fetch_all] == true &&
+            resp.body.has_key?('pagination') &&
+            resp.body['pagination']['next_uri'] != nil
+          params[:starting_after] = resp.body['data'].last['id']
+          get(path, params) do |page|
+            body = resp.body
+            body['data'] += page.data
+            resp.body = body
+            yield(resp) if block_given?
+          end
+        else
+          yield(resp) if block_given?
+        end
+      end
+    end
+
+    ##
+    # HTTP PUT method
+    #
+    # @param [String] path
+    def put(path, params)
+      headers = {}
+
+      request('PUT', path, params.to_json, headers) do |resp|
+        yield(resp) if block_given?
+      end
+    end
+
+    ##
+    # HTTP POST method
+    #
+    # @param [String] path
+    def post(path, params)
+      headers = {}
+
+      request('POST', path, params.to_json, headers) do |resp|
+        yield(resp) if block_given?
+      end
+    end
+
+    ##
+    # HTTP DELETE method
+    #
+    # @param [String] path
+    def delete(path, params)
+      headers = {}
+
+      request('DELETE', path, nil, headers) do |resp|
+        yield(resp) if block_given?
+      end
+    end
+  end
+end