sequence-sdk 0.0.1

data/lib/chain/connection.rb

@@ -0,0 +1,206 @@
+require 'json'
+require 'net/http'
+require 'net/https'
+require 'openssl'
+require 'thread'
+
+require_relative './batch_response'
+require_relative './errors'
+require_relative './version'
+
+module Chain
+  class Connection
+
+    # Parameters to the retry exponential backoff function.
+    MAX_RETRIES = 10
+    RETRY_BASE_DELAY_MS = 40
+    RETRY_MAX_DELAY_MS = 4000
+
+    NETWORK_ERRORS = [
+      InvalidRequestIDError,
+      SocketError,
+      EOFError,
+      IOError,
+      Timeout::Error,
+      Errno::ECONNABORTED,
+      Errno::ECONNRESET,
+      Errno::ETIMEDOUT,
+      Errno::EHOSTUNREACH,
+      Errno::ECONNREFUSED,
+    ]
+
+    def initialize(opts)
+      @opts = opts
+      @url = URI(@opts[:url])
+      @access_token = @opts[:access_token] || @url.userinfo
+      @http_mutex = Mutex.new
+    end
+
+    # Returns a copy of the configuration options
+    def opts
+      @opts.dup
+    end
+
+    def request(path, body = {})
+      _request_with_retries(path, body)[:body]
+    end
+
+    def batch_request(path, body = {}, &translate)
+      res = _request_with_retries(path, body)
+      body = res[:body]
+      response = res[:response]
+
+      successes = {}
+      errors = {}
+
+      body.each_with_index do |item, i|
+        if !!item['code']
+          errors[i] = APIError.new(item, response)
+        else
+          if translate
+            successes[i] = translate.call(item)
+          else
+            successes[i] = item
+          end
+        end
+      end
+
+      BatchResponse.new(
+        successes: successes,
+        errors: errors,
+        response: response,
+      )
+    end
+
+    def singleton_batch_request(path, body = {}, &translate)
+      batch = batch_request(path, body, &translate)
+
+      if batch.size != 1
+        raise "Invalid response, expected a single response object but got #{batch.items.size}"
+      end
+
+      raise batch.errors.values.first if batch.errors.size == 1
+
+      batch.successes.values.first
+    end
+
+    private
+
+    def _request_with_retries(path, body)
+      attempts = 0
+
+      begin
+        attempts += 1
+
+        # If this is a retry and not the first attempt, sleep before making the
+        # retry request.
+        sleep(backoff_delay(attempts)) if attempts > 1
+
+        _single_request(path, body)
+      rescue *NETWORK_ERRORS => e
+        raise e if attempts > MAX_RETRIES
+        retry
+      rescue APIError => e
+        raise e if attempts > MAX_RETRIES
+        retry if e.retriable?
+        raise e
+      end
+    end
+
+    def _single_request(path, body)
+      @http_mutex.synchronize do
+        # Timeout configuration
+        [:open_timeout, :read_timeout, :ssl_timeout].each do |k|
+          next unless @opts.key?(k)
+          http.send "#{k}=", @opts[k]
+        end
+
+        full_path = @url.request_uri.chomp('/')
+        full_path += (path[0] == '/') ? path : '/' + path
+
+        req = Net::HTTP::Post.new(full_path)
+        req['Accept'] = 'application/json'
+        req['Content-Type'] = 'application/json'
+        req['User-Agent'] = 'chain-sdk-ruby/' + Chain::VERSION
+        req.body = JSON.dump(body)
+
+        if @access_token
+          user, pass = @access_token.split(':')
+          req.basic_auth(user, pass)
+        end
+
+        response = http.request(req)
+
+        req_id = response['Chain-Request-ID']
+        unless req_id.is_a?(String) && req_id.size > 0
+          raise InvalidRequestIDError.new(response)
+        end
+
+        status = Integer(response.code)
+        parsed_body = nil
+
+        if status != 204 # No Content
+          begin
+            parsed_body = JSON.parse(response.body)
+          rescue JSON::JSONError
+            raise JSONError.new(req_id, response)
+          end
+        end
+
+        if status / 100 != 2
+          klass = status == 401 ? UnauthorizedError : APIError
+          raise klass.new(parsed_body, response)
+        end
+
+        {body: parsed_body, response: response}
+      end
+    end
+
+    private
+
+    MILLIS_TO_SEC = 0.001
+
+    def backoff_delay(attempt)
+      max = RETRY_BASE_DELAY_MS * 2**(attempt-1)
+      max = [max, RETRY_MAX_DELAY_MS].min
+      millis = rand(max) + 1
+      millis * MILLIS_TO_SEC
+    end
+
+    def http
+      return @http if @http
+
+      args = [@url.host, @url.port]
+
+      # Proxy configuration
+      if @opts.key?(:proxy_addr)
+        args += [@opts[:proxy_addr], @opts[:proxy_port]]
+        if @opts.key?(:proxy_user)
+          args += [@opts[:proxy_user], @opts[:proxy_pass]]
+        end
+      end
+
+      @http = Net::HTTP.new(*args)
+
+      @http.set_debug_output($stdout) if ENV['DEBUG']
+      if @url.scheme == 'https'
+        @http.use_ssl = true
+        @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        if @opts.key?(:ssl_params)
+          ssl_params = @opts[:ssl_params]
+          if ssl_params.key?(:ca_file)
+            @http.ca_file = ssl_params[:ca_file]
+          end
+          if ssl_params.key?(:cert)
+            @http.cert = ssl_params[:cert]
+          end
+          if ssl_params.key?(:key)
+            @http.key = ssl_params[:key]
+          end
+        end
+      end
+
+      @http
+    end
+  end
+end

data/lib/chain/constants.rb

@@ -0,0 +1,3 @@
+module Chain
+  MAX_BLOCK_HEIGHT = (2 ** 63) - 1
+end

data/lib/chain/dev_utils.rb

@@ -0,0 +1,14 @@
+require 'securerandom'
+
+require_relative './client_module'
+
+module Chain
+  class DevUtils
+    class ClientModule < Chain::ClientModule
+      # Deletes all data in the ledger. (development ledgers only)
+      def reset
+        client.conn.request('/reset', client_token: SecureRandom.uuid)
+      end
+    end
+  end
+end

data/lib/chain/errors.rb

@@ -0,0 +1,80 @@
+module Chain
+
+  # Base class for all errors raised by the Chain SDK.
+  class BaseError < StandardError; end
+
+  # InvalidRequestIDError arises when an HTTP response is received, but it does
+  # not contain headers that are included in all Chain API responses. This
+  # could arise due to a badly-configured proxy, or other upstream network
+  # issues.
+  class InvalidRequestIDError < BaseError
+    attr_accessor :response
+
+    def initialize(response)
+      super "Response HTTP header field Chain-Request-ID is unset. There may be network issues. Please check your local network settings."
+      self.response = response
+    end
+  end
+
+  # JSONError should be very rare, and will only arise if there is a bug in the
+  # Chain API, or if the upstream server is spoofing common Chain API response
+  # headers.
+  class JSONError < BaseError
+    attr_accessor :request_id
+    attr_accessor :response
+
+    def initialize(request_id, response)
+      super "Error decoding JSON response. Request-ID: #{request_id}"
+      self.request_id = request_id
+      self.response = response
+    end
+  end
+
+  # APIError describes errors that are codified by the Chain API. They have
+  # an error code, a message, and an optional detail field that provides
+  # additional context for the error.
+  class APIError < BaseError
+    RETRIABLE_STATUS_CODES = [
+      408, # Request Timeout
+      429, # Too Many Requests
+      500, # Internal Server Error
+      502, # Bad Gateway
+      503, # Service Unavailable
+      504, # Gateway Timeout
+      509, # Bandwidth Limit Exceeded
+    ]
+
+    attr_accessor :code, :chain_message, :detail, :data, :temporary, :request_id, :response
+
+    def initialize(body, response)
+      self.code = body['code']
+      self.chain_message = body['message']
+      self.detail = body['detail']
+      self.temporary = body['temporary']
+
+      self.response = response
+      self.request_id = response['Chain-Request-ID'] if response
+
+      super self.class.format_error_message(code, chain_message, detail, request_id)
+    end
+
+    def retriable?
+      temporary || (response && RETRIABLE_STATUS_CODES.include?(Integer(response.code)))
+    end
+
+    def self.format_error_message(code, message, detail, request_id)
+      tokens = []
+      tokens << "Code: #{code}" if code.is_a?(String) && code.size > 0
+      tokens << "Message: #{message}"
+      tokens << "Detail: #{detail}" if detail.is_a?(String) && detail.size > 0
+      tokens << "Request-ID: #{request_id}"
+      tokens.join(' ')
+    end
+  end
+
+  # UnauthorizedError is a special case of APIError, and is raised when the
+  # response status code is 401. This is a common error case, so a discrete
+  # exception type is provided for convenience.
+  class UnauthorizedError < APIError; end
+
+end

data/lib/chain/key.rb

@@ -0,0 +1,46 @@
+require_relative './client_module'
+require_relative './connection'
+require_relative './query'
+require_relative './response_object'
+
+module Chain
+  class Key < ResponseObject
+    # @!attribute [r] alias
+    # User specified, unique identifier of the key.
+    # @return [String]
+    attrib :alias
+
+    # @!attribute [r] id
+    # Unique identifier of the key, based on the public key material itself.
+    # @return [String]
+    attrib :id
+
+    class ClientModule < Chain::ClientModule
+
+      # Creates a key object.
+      # @param [Hash] opts Parameters for MockHSM key creation.
+      # @option opts [String] alias User specified, unique identifier.
+      # @return [Key]
+      def create(opts = {})
+        Key.new(client.conn.request('create-key', opts))
+      end
+
+      # @param [Hash] opts Filtering information
+      # @option opts [Array<String>] aliases Optional list of requested aliases, max 200.
+      # @return [Query]
+      def query(opts = {})
+        Query.new(client, opts)
+      end
+    end
+
+    class Query < Chain::Query
+      def fetch(query)
+        client.conn.request('list-keys', query)
+      end
+
+      def translate(obj)
+        Key.new(obj)
+      end
+    end
+  end
+end

data/lib/chain/page.rb

@@ -0,0 +1,25 @@
+require_relative './response_object'
+
+module Chain
+  class Page < ResponseObject
+    # @!attribute [r] items
+    # List of items.
+    # @return [Array]
+    attrib :items
+
+    # @!attribute [r] next
+    # Query object to request next page of items
+    # @return [Hash]
+    attrib :next
+
+    # @!attribute [r] last_page
+    # Indicator of whether there are more pages to load
+    # @return [Boolean]
+    attrib :last_page
+
+    def initialize(raw_attribs, translate)
+      super(raw_attribs)
+      @items = @items.map { |i| translate.call(i) }
+    end
+  end
+end

data/lib/chain/query.rb

@@ -0,0 +1,79 @@
+require_relative './page'
+
+module Chain
+  class Query
+    include ::Enumerable
+
+    # @return [Client]
+    attr_reader :client
+
+    # @return [Hash]
+    attr_reader :query
+
+    def initialize(client, query = {})
+      @client = client
+      @query = query
+    end
+
+    # Iterate through objects in response, fetching the next page of results
+    # from the API as needed.
+    #
+    # Implements required method
+    # {https://ruby-doc.org/core/Enumerable.html Enumerable#each}.
+    # @return [void]
+    def each
+      pages.each do |page|
+        page.items.each do |item, index|
+          yield item
+        end
+      end
+    end
+
+    def pages
+      PageQuery.new(client, query, method(:fetch), method(:translate))
+    end
+
+    # @abstract
+    def fetch(query)
+      raise NotImplementedError
+    end
+
+    # Overwrite to translate API response data to a different Ruby object.
+    # @abstract
+    def translate(response_object)
+      raise NotImplementedError
+    end
+
+    alias_method :all, :to_a
+
+    class PageQuery
+      include ::Enumerable
+
+      def initialize(client, query, fetch, translate)
+        @client = client
+        @query = query
+        @fetch = fetch
+        @translate = translate
+      end
+
+      def each
+        page = nil
+
+        loop do
+          page = Page.new(@fetch.call(@query), @translate)
+          @query = page.next
+
+          yield page
+
+          break if page.last_page
+
+          # The second predicate (empty?) *should* be redundant, but we check it
+          # anyway as a defensive measure.
+          break if page.items.empty?
+        end
+      end
+
+      alias_method :all, :to_a
+    end
+  end
+end

data/lib/chain/response_object.rb

@@ -0,0 +1,116 @@
+require 'json'
+require 'time'
+
+module Chain
+  class ResponseObject
+    def initialize(raw_attribs)
+      raw_attribs.each do |k, v|
+        next unless self.class.has_attrib?(k)
+        self[k] = self.class.translate(k, v) unless v.nil?
+      end
+    end
+
+    def to_h
+      self.class.attrib_opts.keys.reduce({}) do |memo, name|
+        memo[name] = instance_variable_get("@#{name}")
+        memo
+      end
+    end
+
+    def to_json(opts = nil)
+      h = to_h.reduce({}) do |memo, (k, v)|
+        memo[k] = self.class.detranslate(k, v)
+        memo
+      end
+
+      h.to_json
+    end
+
+    def [](attrib_name)
+      attrib_name = attrib_name.to_sym
+      raise KeyError.new("key not found: #{attrib_name}") unless self.class.attrib_opts.key?(attrib_name)
+
+      instance_variable_get "@#{attrib_name}"
+    end
+
+    def []=(attrib_name, value)
+      attrib_name = attrib_name.to_sym
+      raise KeyError.new("key not found: #{attrib_name}") unless self.class.attrib_opts.key?(attrib_name)
+
+      instance_variable_set "@#{attrib_name}", value
+    end
+
+    # @!visibility private
+    def self.attrib_opts
+      @attrib_opts ||= {}
+    end
+
+    # @!visibility private
+    def self.attrib(attrib_name, opts = {}, &translate)
+      opts[:translate] = translate
+      attrib_opts[attrib_name.to_sym] = opts
+      attr_accessor attrib_name
+    end
+
+    # @!visibility private
+    def self.has_attrib?(attrib_name)
+      attrib_opts.key?(attrib_name.to_sym)
+    end
+
+    # @!visibility private
+    def self.translate(attrib_name, raw_value)
+      attrib_name = attrib_name.to_sym
+      opts = attrib_opts[attrib_name]
+
+      return Time.parse(raw_value) if opts[:rfc3339_time]
+      return raw_value if opts[:translate].nil?
+
+      begin
+        opts[:translate].call raw_value
+      rescue => e
+        raise TranslateError.new(attrib_name, raw_value, e)
+      end
+    end
+
+    # @!visibility private
+    def self.detranslate(attrib_name, raw_value)
+      opts = attrib_opts.fetch(attrib_name, {})
+
+      if opts[:rfc3339_time]
+        begin
+          return raw_value.to_datetime.rfc3339
+        rescue => e
+          raise DetranslateError.new(attrib_name, raw_value, e)
+        end
+      end
+
+      raw_value
+    end
+
+    class TranslateError < StandardError
+      attr_reader :attrib_name
+      attr_reader :raw_value
+      attr_reader :source
+
+      def initialize(attrib_name, raw_value, source)
+        super "Error translating attrib #{attrib_name}: #{source}"
+        @attrib_name = attrib_name
+        @raw_value = raw_value
+        @source = source
+      end
+    end
+
+    class DetranslateError < StandardError
+      attr_reader :attrib_name
+      attr_reader :raw_value
+      attr_reader :source
+
+      def initialize(attrib_name, raw_value, source)
+        super "Error de-translating attrib #{attrib_name}: #{source}"
+        @attrib_name = attrib_name
+        @raw_value = raw_value
+        @source = source
+      end
+    end
+  end
+end

data/lib/chain/stats.rb

@@ -0,0 +1,31 @@
+require_relative './client_module'
+require_relative './response_object'
+require_relative './query'
+
+module Chain
+  class Stats < ResponseObject
+
+    # @!attribute [r] asset_count
+    # Total number of assets in the ledger.
+    # @return [Integer]
+    attrib :asset_count
+
+    # @!attribute [r] account_count
+    # Total number of accounts in the ledger.
+    # @return [Integer]
+    attrib :account_count
+
+    # @!attribute [r] tx_count
+    # Total number of transactions in the ledger.
+    # @return [Integer]
+    attrib :tx_count
+
+    class ClientModule < Chain::ClientModule
+      # @return [Stats]
+      def get
+        Stats.new(client.conn.request('stats'))
+      end
+    end
+
+  end
+end