cryptopay-ruby 0.1.0

data/lib/cryptopay/authentication.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cryptopay
+  class Authentication
+    def initialize(api_key:, api_secret:)
+      @api_key = api_key
+      @api_secret = api_secret
+    end
+
+    def sign(request)
+      signature_string = [
+        request.method.to_s.upcase,
+        request.body.nil? ? '' : Digest::MD5.hexdigest(request.body),
+        request.content_type,
+        request.date,
+        request.path
+      ].join("\n")
+
+      signature = Base64.strict_encode64(OpenSSL::HMAC.digest('sha1', api_secret, signature_string))
+
+      request.add_header('Authorization', "HMAC #{api_key}:#{signature}")
+
+      request
+    end
+
+    private
+
+    attr_reader :api_key, :api_secret
+  end
+end

data/lib/cryptopay/callbacks.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Cryptopay
+  class Callbacks
+    def initialize(secret)
+      @secret = secret
+    end
+
+    # Verifies callback body and builds Callback object
+    # @param body [String] Raw request body string
+    # @param signature [String] Value of the X-Cryptopay-Signature header
+    # @return [Object] Callback
+    def verify(body, signature)
+      expected_signature = OpenSSL::HMAC.hexdigest('SHA256', secret, body)
+
+      equals = secure_compare(signature, expected_signature)
+      raise(SignatureVerificationError, 'Signature mismatch') unless equals
+
+      data = JSON.parse(body, symbolize_names: true)
+      Callback.build_from_hash(data)
+    end
+
+    private
+
+    attr_reader :secret
+
+    # Constant-time comparison algorithm to prevent timing attacks
+    def secure_compare(str1, str2)
+      return false if str1.empty? || str2.empty? || str1.bytesize != str2.bytesize
+
+      l = str1.unpack("C#{str1.bytesize}")
+
+      res = 0
+      str2.each_byte { |byte| res |= byte ^ l.shift }
+      res.zero?
+    end
+  end
+end

data/lib/cryptopay/client.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Cryptopay
+  class Client
+    attr_reader :invoices,
+                :rates,
+                :coin_withdrawals,
+                :channels,
+                :accounts,
+                :transactions,
+                :exchange_transfers,
+                :customers,
+                :risks,
+                :callbacks
+
+    def initialize(&block)
+      config = Config.new(&block)
+      connection = Connection.new(config)
+
+      setup_apis(connection)
+
+      @callbacks = Callbacks.new(config.callback_secret)
+    end
+
+    private
+
+    def setup_apis(connection)
+      @invoices = Invoices.new(connection)
+      @rates = Rates.new(connection)
+      @coin_withdrawals = CoinWithdrawals.new(connection)
+      @channels = Channels.new(connection)
+      @accounts = Accounts.new(connection)
+      @transactions = Transactions.new(connection)
+      @exchange_transfers = ExchangeTransfers.new(connection)
+      @customers = Customers.new(connection)
+      @risks = Risks.new(connection)
+    end
+  end
+end

data/lib/cryptopay/config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Cryptopay
+  class Config
+    # Cryptopay API Base URL
+    attr_accessor :api_url
+
+    # Cryptopay API Key
+    attr_accessor :api_key
+
+    # Cryptopay API Secret
+    attr_accessor :api_secret
+
+    # Cryptopay callback secret
+    attr_accessor :callback_secret
+
+    # Optional proc yeilding the Faraday builder
+    attr_accessor :faraday_builder
+
+    # The Faraday adapter to be used. Net::HTTP by default
+    attr_accessor :faraday_adapter
+
+    def initialize
+      yield(self)
+
+      validate!
+    end
+
+    private
+
+    def validate!
+      errors = validate
+      return if errors.empty?
+
+      raise(ArgumentError, errors.join("\n"))
+    end
+
+    def validate
+      errors = []
+
+      errors << 'Missing "api_url" in Cryptopay config' if api_url.nil?
+      errors << 'Missing "api_key" in Cryptopay config' if api_key.nil?
+      errors << 'Missing "api_secret" in Cryptopay config' if api_secret.nil?
+
+      errors
+    end
+  end
+end

data/lib/cryptopay/connection.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Cryptopay
+  class Connection
+    def initialize(config)
+      @config = config
+      @auth = Authentication.new(api_key: config.api_key, api_secret: config.api_secret)
+      @faraday = setup_faraday
+    end
+
+    def call(req, return_type:)
+      auth.sign(req)
+
+      res = run_request(req)
+      body = JSON.parse(res.body, symbolize_names: true)
+
+      return_type.build_from_hash(body)
+    end
+
+    private
+
+    attr_reader :config, :auth, :faraday
+
+    def run_request(req)
+      res = faraday.run_request(req.method, req.path, req.body, req.headers)
+      check_error(res)
+    rescue Faraday::Error => e
+      raise(ConnectionError, e)
+    end
+
+    def setup_faraday
+      adapter = config.faraday_adapter || Faraday.default_adapter
+
+      @connection = Faraday.new(url: config.api_url) do |f|
+        config.faraday_builder&.call(f)
+
+        f.adapter(*adapter)
+      end
+    end
+
+    def check_error(res)
+      error = Error.from_response(res)
+      raise(error) if error
+
+      res
+    end
+  end
+end

data/lib/cryptopay/encoder.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Cryptopay
+  class Encoder
+    def initialize(name:, attribute_map:, types:, nullables:)
+      @name = name
+      @attribute_map = attribute_map
+      @types = types
+      @nullables = nullables
+    end
+
+    def sanitize(attributes)
+      attributes.each_with_object({}) do |(k, v), h|
+        unless attribute_map.key?(k.to_sym)
+          raise(
+            ArgumentError,
+            "`#{k}` is not a valid attribute in `#{name}`. " \
+            "Please check the name to make sure it's valid. List of attributes: " + attribute_map.keys.inspect
+          )
+        end
+
+        h[k.to_sym] = v
+      end
+    end
+
+    def build_from_hash(data)
+      types.each_with_object({}) do |(key, type), attributes|
+        value = data[attribute_map[key]]
+
+        if value.nil?
+          attributes[key] = nil if nullables.include?(key)
+        elsif type =~ /\AArray<(.*)>/i
+          attributes[key] = value.map { |v| _deserialize(Regexp.last_match(1), v) }
+        else
+          attributes[key] = _deserialize(type, value)
+        end
+      end
+    end
+
+    def to_hash(attributes)
+      attribute_map.each_with_object({}) do |(attr, param), hash|
+        value = attributes[attr]
+        if value.nil?
+          nullable = nullables.include?(attr)
+
+          # Skip non-nullable attributes with nil values
+          next unless nullable
+
+          # Skip nullable attributes which was not explicitly set
+          next unless attributes.key?(attr)
+        end
+
+        hash[param] = _to_hash(value)
+      end
+    end
+
+    private
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else
+        klass = Cryptopay.const_get(type)
+        klass.build_from_hash(value)
+      end
+    end
+
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to?(:to_hash)
+        value.to_hash
+      else
+        value
+      end
+    end
+
+    attr_reader :name, :attribute_map, :types, :nullables
+  end
+end

data/lib/cryptopay/errors.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Cryptopay
+  class Error < StandardError
+    def self.from_response(res)
+      case res.status
+      when 400..499
+        ClientError.from_response(res)
+      when 500..599
+        ServerError.from_response(res)
+      end
+    end
+  end
+
+  class ClientError < Error
+    def self.from_response(res)
+      new("Status #{res.status}: #{res.body}")
+    end
+  end
+
+  class ServerError < Error
+    def self.from_response(res)
+      new("Status #{res.status}: #{res.body}")
+    end
+  end
+
+  class ConnectionError < Error
+  end
+
+  class SignatureVerificationError < Error
+  end
+end

data/lib/cryptopay/models/account.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class Account
+    ENCODER = Encoder.new(
+      name: 'Cryptopay::Account',
+      attribute_map: {
+        'id': :id,
+        'currency': :currency,
+        'balance': :balance,
+        'project_id': :project_id
+      },
+      types: {
+        'id': :String,
+        'currency': :String,
+        'balance': :Decimal,
+        'project_id': :String
+      },
+      nullables: []
+    )
+    private_constant :ENCODER
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      @attributes = ENCODER.sanitize(attributes)
+    end
+
+    def id
+      @attributes[:id]
+    end
+
+    def currency
+      @attributes[:currency]
+    end
+
+    def balance
+      @attributes[:balance]
+    end
+
+    def project_id
+      @attributes[:project_id]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def invalid_properties
+      properties = []
+
+      properties.push('invalid value for "id", id cannot be nil.') if id.nil?
+
+      properties.push('invalid value for "currency", currency cannot be nil.') if currency.nil?
+
+      properties.push('invalid value for "balance", balance cannot be nil.') if balance.nil?
+
+      properties.push('invalid value for "project_id", project_id cannot be nil.') if project_id.nil?
+
+      properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      invalid_properties.empty?
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Cryptopay::Account] Returns the model itself
+    def self.build_from_hash(data)
+      attributes = ENCODER.build_from_hash(data)
+      new(attributes)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      ENCODER.to_hash(@attributes)
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}> JSON: " + JSON.pretty_generate(to_hash)
+    end
+  end
+end

data/lib/cryptopay/models/account_list_result.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class AccountListResult
+    ENCODER = Encoder.new(
+      name: 'Cryptopay::AccountListResult',
+      attribute_map: {
+        'data': :data
+      },
+      types: {
+        'data': :'Array<Account>'
+      },
+      nullables: []
+    )
+    private_constant :ENCODER
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      @attributes = ENCODER.sanitize(attributes)
+    end
+
+    def data
+      @attributes[:data]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def invalid_properties
+      properties = []
+
+      properties.push('invalid value for "data", data cannot be nil.') if data.nil?
+
+      data&.each_with_index do |item, index|
+        item.invalid_properties.each do |prop|
+          properties.push("invalid value for \"data.#{index}\": #{prop}")
+        end
+      end
+
+      properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      invalid_properties.empty?
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Cryptopay::AccountListResult] Returns the model itself
+    def self.build_from_hash(data)
+      attributes = ENCODER.build_from_hash(data)
+      new(attributes)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      ENCODER.to_hash(@attributes)
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}> JSON: " + JSON.pretty_generate(to_hash)
+    end
+  end
+end

data/lib/cryptopay/models/callback.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  module Callback
+    DISCRIMINATOR_NAME = :type
+    private_constant :DISCRIMINATOR_NAME
+
+    # Builds the object
+    # @param [Mixed] Data to be matched against the list of oneOf items
+    # @return [Cryptopay::ChannelPaymentCallback, Cryptopay::CoinWithdrawalCallback, Cryptopay::InvoiceCallback, nil] Returns the model or nil
+    def self.build_from_hash(data)
+      case data[DISCRIMINATOR_NAME]
+      when 'ChannelPayment'
+        ChannelPaymentCallback.build_from_hash(data)
+      when 'CoinWithdrawal'
+        CoinWithdrawalCallback.build_from_hash(data)
+      when 'Invoice'
+        InvoiceCallback.build_from_hash(data)
+      end
+    end
+  end
+end

data/lib/cryptopay/models/channel.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# Auto-generated file
+# DO NOT EDIT
+
+module Cryptopay
+  class Channel
+    ENCODER = Encoder.new(
+      name: 'Cryptopay::Channel',
+      attribute_map: {
+        'id': :id,
+        'status': :status,
+        'name': :name,
+        'description': :description,
+        'pay_currency': :pay_currency,
+        'receiver_currency': :receiver_currency,
+        'address': :address,
+        'project_id': :project_id,
+        'custom_id': :custom_id,
+        'customer_id': :customer_id,
+        'uri': :uri,
+        'hosted_page_url': :hosted_page_url
+      },
+      types: {
+        'id': :String,
+        'status': :ChannelStatus,
+        'name': :String,
+        'description': :String,
+        'pay_currency': :String,
+        'receiver_currency': :String,
+        'address': :String,
+        'project_id': :String,
+        'custom_id': :String,
+        'customer_id': :String,
+        'uri': :String,
+        'hosted_page_url': :String
+      },
+      nullables: %i[
+        description
+        custom_id
+        customer_id
+      ]
+    )
+    private_constant :ENCODER
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      @attributes = ENCODER.sanitize(attributes)
+    end
+
+    def id
+      @attributes[:id]
+    end
+
+    def status
+      @attributes[:status]
+    end
+
+    def name
+      @attributes[:name]
+    end
+
+    def description
+      @attributes[:description]
+    end
+
+    def pay_currency
+      @attributes[:pay_currency]
+    end
+
+    def receiver_currency
+      @attributes[:receiver_currency]
+    end
+
+    def address
+      @attributes[:address]
+    end
+
+    def project_id
+      @attributes[:project_id]
+    end
+
+    def custom_id
+      @attributes[:custom_id]
+    end
+
+    def customer_id
+      @attributes[:customer_id]
+    end
+
+    def uri
+      @attributes[:uri]
+    end
+
+    def hosted_page_url
+      @attributes[:hosted_page_url]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def invalid_properties
+      properties = []
+
+      properties.push('invalid value for "id", id cannot be nil.') if id.nil?
+
+      properties.push('invalid value for "status", status cannot be nil.') if status.nil?
+
+      if !status.nil? && !%w[enabled disabled].include?(status)
+        properties.push('invalid value for status, must be one of "enabled", "disabled"')
+      end
+
+      properties.push('invalid value for "name", name cannot be nil.') if name.nil?
+
+      properties.push('invalid value for "pay_currency", pay_currency cannot be nil.') if pay_currency.nil?
+
+      if receiver_currency.nil?
+        properties.push('invalid value for "receiver_currency", receiver_currency cannot be nil.')
+      end
+
+      properties.push('invalid value for "address", address cannot be nil.') if address.nil?
+
+      properties.push('invalid value for "project_id", project_id cannot be nil.') if project_id.nil?
+
+      properties.push('invalid value for "uri", uri cannot be nil.') if uri.nil?
+
+      properties.push('invalid value for "hosted_page_url", hosted_page_url cannot be nil.') if hosted_page_url.nil?
+
+      properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      invalid_properties.empty?
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Cryptopay::Channel] Returns the model itself
+    def self.build_from_hash(data)
+      attributes = ENCODER.build_from_hash(data)
+      new(attributes)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      ENCODER.to_hash(@attributes)
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)}> JSON: " + JSON.pretty_generate(to_hash)
+    end
+  end
+end