partner_api 0.11.2

data/lib/gemini_api/transfer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module GeminiApi
+  Transfer = Struct.new(
+    :type,
+    :status,
+    :timestampms,
+    :eid,
+    :advance_eid,
+    :currency,
+    :amount,
+    :fee_amount,
+    :fee_currency,
+    :method,
+    :tx_hash,
+    :withdrawal_id,
+    :output_idx,
+    :destination,
+    :purpose,
+    :raw_data,
+    keyword_init: true
+  ) do
+    def self.build(raw_data)
+      new(
+        type: raw_data['type'],
+        status: raw_data['status'],
+        timestampms: raw_data['timestampms'],
+        eid: raw_data['eid'],
+        advance_eid: raw_data['advanceEid'],
+        currency: raw_data['currency'],
+        amount: raw_data['amount'],
+        fee_amount: raw_data['feeAmount'],
+        fee_currency: raw_data['feeCurrency'],
+        method: raw_data['method'],
+        tx_hash: raw_data['txHash'],
+        withdrawal_id: raw_data['withdrawalId'],
+        output_idx: raw_data['outputIdx'],
+        destination: raw_data['destination'],
+        purpose: raw_data['purpose'],
+        raw_data: raw_data
+      )
+    end
+  end
+end

data/lib/gemini_api.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'dry-configurable'
+require 'gemini_api/client'
+
+module GeminiApi
+  extend Dry::Configurable
+
+  setting :instrumentation, default: -> (action:, tenant_id: nil, &block) { block.call }
+  setting :logger, default: Logger.new($stdout, level: :info)
+  setting :base_url, constructor: proc { |value| URI.parse(value) }
+  setting :api_key
+  setting :api_secret
+  setting :default_headers, default: -> { {} }
+  setting :default_parameters, default: -> { {} }
+end

data/lib/partner_api/endpoints/base.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'dry-monads'
+require 'hanami/utils/hash'
+require 'http'
+require 'openssl'
+
+require 'partner_api/utils/hash'
+require 'partner_api/utils/read_cert'
+require 'partner_api/errors'
+
+module PartnerApi
+  module Endpoints
+    class Base
+      include Dry::Monads[:result]
+
+      def call
+        config.logger.info(**logging_params.merge(class: self.class.name))
+
+        response = config.instrumentation.call(action: self.class.name) do
+          client.request(method, url, **request_options)
+        end
+
+        if successful?(response)
+          Success(decode(response))
+        else
+          Failure(decode_error(response))
+        end
+      rescue HTTP::Error, OpenSSL::SSL::SSLError => e
+        raise Errors::ConnectionError, e.message
+      end
+
+      private
+
+      def client
+        @client ||= HTTP::Client.new(**connection_options)
+          .use(logging: { logger: config.logger })
+      end
+
+      def logging_params
+        raise NotImplementedError
+      end
+
+      # To be implemented by concrete end-point class.
+      #
+      def connection_options
+        raise NotImplementedError
+      end
+
+      # To be implemented by concrete end-point class.
+      #
+      def method
+        raise NotImplementedError
+      end
+
+      def url
+        config.base_url.dup.tap { |uri| uri.path = path }
+      end
+
+      # To be implemented by concrete end-point class.
+      #
+      def path
+        raise NotImplementedError
+      end
+
+      def request_options
+        {
+          headers: combined_headers,
+          body: JSON.dump(combined_payload)
+        }
+      end
+
+      def default_headers
+        {}
+      end
+
+      def default_parameters
+        {}
+      end
+
+      def combined_headers
+        Utils::Hash.deep_merge(
+          default_headers,
+          Hanami::Utils::Hash.deep_stringify(config.default_headers.call),
+          Hanami::Utils::Hash.deep_stringify(headers)
+        )
+      end
+
+      def combined_payload
+        Utils::Hash.deep_merge(
+          default_parameters,
+          Hanami::Utils::Hash.deep_stringify(config.default_parameters.call),
+          Hanami::Utils::Hash.deep_stringify(parameters)
+        )
+      end
+
+      # To be implemented by concrete end-point class.
+      #
+      def headers
+        {}
+      end
+
+      # To be implemented by concrete end-point class.
+      #
+      def parameters
+        {}
+      end
+
+      # To be implemented by concrete end-point class.
+      #
+      def successful?(response)
+        raise NotImplementedError
+      end
+
+      # To be implemented by concrete end-point class.
+      #
+      def decode(response)
+        raise NotImplementedError
+      end
+
+      # To be implemented by concrete end-point class.
+      #
+      def decode_error(response)
+        raise NotImplementedError
+      end
+    end
+
+    module Initializer
+      def self.prepended(klass)
+        klass.class_eval do
+          def self.call(config, **params)
+            new(config, **params).call
+          end
+        end
+      end
+
+      def initialize(config, **params)
+        @config = config
+
+        if params.empty?
+          super()
+        else
+          super(**params)
+        end
+      end
+
+      private
+
+      attr_reader :config
+    end
+  end
+end

data/lib/partner_api/errors.rb

@@ -0,0 +1,18 @@
+module PartnerApi
+  module Errors
+    class Error < StandardError; end
+
+    # Used to re-wrap connection errors from http.rb.
+    #
+    class ConnectionError < Error; end
+
+    class RequestError < Error
+      attr_reader :code
+
+      def initialize(code: nil, message:)
+        @code = code
+        super(message)
+      end
+    end
+  end
+end

data/lib/partner_api/utils/hash.rb

@@ -0,0 +1,21 @@
+module PartnerApi
+  module Utils
+    class Hash
+      # This a simplify version of deep merging
+      #
+      # In case both conflict items are hash, continue to merge recursively.
+      # Otherwise, prioritize the hash in later order
+      def self.deep_merge(*hashes)
+        hashes.inject({}) do |result, hash|
+          result.merge(hash) do |_key, item_1, item_2|
+            if item_1.is_a?(::Hash) && item_2.is_a?(::Hash)
+              deep_merge(item_1, item_2)
+            else
+              item_2 || item_1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/partner_api/utils/read_cert.rb

@@ -0,0 +1,38 @@
+module PartnerApi
+  module Utils
+    class ReadCert
+      # A workaround for this issue related to OpenSSL
+      # https://github.com/ruby/openssl/issues/254
+      CERT_PATTERN = /-----BEGIN CERTIFICATE-----(?:.|\n)+?-----END CERTIFICATE-----/
+
+      def initialize(public_certs, private_key)
+        @certs = public_certs.scan(CERT_PATTERN)
+        @private_key = private_key
+      end
+
+      def ssl_context
+        OpenSSL::SSL::SSLContext.new(:TLSv1_2).tap do |ctx|
+          ctx.set_params(
+            cert: cert,
+            key: OpenSSL::PKey::RSA.new(private_key),
+            extra_chain_cert: extra_chain_cert
+          )
+        end
+      end
+
+      private
+
+      attr_reader :certs, :private_key
+
+      def cert
+        OpenSSL::X509::Certificate.new(certs.first)
+      end
+
+      def extra_chain_cert
+        return [] if certs.length < 2
+
+        certs[1..-1].map { |cert| OpenSSL::X509::Certificate.new(cert) }
+      end
+    end
+  end
+end

data/lib/vma_api/client.rb

@@ -0,0 +1,33 @@
+require 'hanami/utils/string'
+require 'hanami/utils/class'
+
+require 'vma_api/endpoints/access_token'
+require 'vma_api/endpoints/refresh_token'
+require 'vma_api/endpoints/client_credentials'
+require 'vma_api/endpoints/revoke_token'
+
+module VmaApi
+  class Client
+    def self.endpoint(name)
+      define_method(name) do |**args|
+        klass_name = Hanami::Utils::String.classify(name)
+        endpoint_klass = Hanami::Utils::Class.load!("VmaApi::Endpoints::#{klass_name}")
+
+        endpoint_klass.(config, **args)
+      end
+    end
+
+    endpoint :access_token
+    endpoint :refresh_token
+    endpoint :client_credentials
+    endpoint :revoke_token
+
+    def initialize(config: VmaApi.config)
+      @config = config
+    end
+
+    private
+
+    attr_reader :config
+  end
+end

data/lib/vma_api/configuration.rb

@@ -0,0 +1,24 @@
+require 'dry-configurable'
+
+module VmaApi
+  class Configuration
+    include Dry::Configurable
+
+    setting :logger, default: Logger.new(STDOUT, level: :info)
+
+    setting :base_url
+    setting :client_id
+    setting :client_secret
+
+    setting :auth_base_url
+    setting :auth_client_id
+    setting :auth_client_secret
+
+    setting :subscription_key
+    setting :system_id
+
+    setting :default_parameters, default: -> { {} }
+    setting :default_headers, default: -> { {} }
+    setting :instrumentation, default: -> (action:, tenant_id: nil, &block) { block.call }
+  end
+end

data/lib/vma_api/endpoint.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'partner_api/endpoints/base'
+require 'vma_api/failure_response'
+
+module VmaApi
+  class Endpoint < PartnerApi::Endpoints::Base
+
+    private
+
+    # VMA at time of writing this does not need mTLS or proxies
+    #
+    def connection_options
+      {}
+    end
+
+    def successful?(response)
+      response.status.success? && response.parse["code"].nil?
+    end
+
+    def decode_error(response)
+      FailureResponse.new(response)
+    end
+
+    def logging_params
+      { request_id: request_id }
+    end
+  end
+end

data/lib/vma_api/endpoints/access_token.rb

@@ -0,0 +1,60 @@
+require 'vma_api/endpoint'
+
+module VmaApi
+  module Endpoints
+    class AccessToken < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      AUTH_TOKEN = 'authToken'.freeze
+
+      def initialize(short_token:, request_id: SecureRandom.uuid)
+        @short_token = short_token
+        @request_id = request_id
+      end
+
+      private
+
+      attr_reader :short_token, :request_id
+
+      def url
+        URI.parse(config.auth_base_url).tap { |uri| uri.path = path }
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json',
+          'Ocp-Apim-Subscription-Key': config.subscription_key,
+          'Request-Id': request_id,
+          'Timestamp': Time.now.utc.iso8601,
+          'Sending-System-Version': SYSTEM_VERSION,
+          'Sending-System-Id': config.system_id,
+          'Initiating-System-Version': SYSTEM_VERSION,
+          'Initiating-System-Id': config.system_id,
+          'Ocp-Apim-Trace': 'true'
+        }
+      end
+
+      def method
+        'POST'
+      end
+
+      def path
+        '/customerIdentity/v1.0/token'
+      end
+
+      def parameters
+        {
+          client_id: config.auth_client_id,
+          client_secret: config.auth_client_secret,
+          track_token: short_token,
+          credentials_type: AUTH_TOKEN
+        }
+      end
+
+      def decode(response)
+        response.parse.dig('access_token')
+      end
+    end
+  end
+end

data/lib/vma_api/endpoints/client_credentials.rb

@@ -0,0 +1,60 @@
+require 'vma_api/endpoint'
+
+module VmaApi
+  module Endpoints
+    class ClientCredentials < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      VMA_CLIENT_CREDENTIALS = 'client_credentials'.freeze
+
+      def initialize(tenant_id:, resource:, request_id: SecureRandom.uuid)
+        @tenant_id = tenant_id
+        @resource = resource
+        @request_id = request_id
+      end
+
+      private
+
+      attr_reader :tenant_id, :resource, :request_id
+
+      def url
+        URI.parse(config.base_url).tap { |uri| uri.path = path }
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/x-www-form-urlencoded',
+          'Request-Id' => request_id
+        }
+      end
+
+      def method
+        'POST'
+      end
+
+      def path
+        "/#{tenant_id}/oauth2/token"
+      end
+
+      def parameters
+        {
+          client_id: config.client_id,
+          client_secret: config.client_secret,
+          grant_type: VMA_CLIENT_CREDENTIALS,
+          resource: resource
+        }
+      end
+
+      def decode(response)
+        response.parse.dig('access_token')
+      end
+
+      def request_options
+        {
+          headers: combined_headers,
+          form: combined_payload
+        }
+      end
+    end
+  end
+end

data/lib/vma_api/endpoints/refresh_token.rb

@@ -0,0 +1,60 @@
+require 'vma_api/endpoint'
+
+module VmaApi
+  module Endpoints
+    class RefreshToken < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      REFRESH_TOKEN = 'refreshToken'.freeze
+
+      def initialize(refresh_token:, request_id: SecureRandom.uuid)
+        @refresh_token = refresh_token
+        @request_id = request_id
+      end
+
+      private
+
+      attr_reader :refresh_token, :request_id
+
+      def url
+        URI.parse(config.auth_base_url).tap { |uri| uri.path = path }
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json',
+          'Ocp-Apim-Subscription-Key': config.subscription_key,
+          'Request-Id': request_id,
+          'Timestamp': Time.now.utc.iso8601,
+          'Sending-System-Version': SYSTEM_VERSION,
+          'Sending-System-Id': config.system_id,
+          'Initiating-System-Version': SYSTEM_VERSION,
+          'Initiating-System-Id': config.system_id,
+          'Ocp-Apim-Trace': 'true'
+        }
+      end
+
+      def method
+        'POST'
+      end
+
+      def path
+        '/customerIdentity/v1.0/token'
+      end
+
+      def parameters
+        {
+          client_id: config.auth_client_id,
+          client_secret: config.auth_client_secret,
+          refresh_token: refresh_token,
+          credentials_type: REFRESH_TOKEN
+        }
+      end
+
+      def decode(response)
+        response.parse.dig('access_token')
+      end
+    end
+  end
+end

data/lib/vma_api/endpoints/revoke_token.rb

@@ -0,0 +1,55 @@
+require 'vma_api/endpoint'
+
+module VmaApi
+  module Endpoints
+    class RevokeToken < Endpoint
+      prepend PartnerApi::Endpoints::Initializer
+
+      def initialize(token:, request_id: SecureRandom.uuid)
+        @token = token
+        @request_id = request_id
+      end
+
+      private
+
+      attr_reader :token, :request_id
+
+      def url
+        URI.parse(config.auth_base_url).tap { |uri| uri.path = path }
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json',
+          'Ocp-Apim-Subscription-Key': config.subscription_key,
+          'Request-Id': request_id,
+          'Timestamp': Time.now.utc.iso8601,
+          'Sending-System-Version': SYSTEM_VERSION,
+          'Sending-System-Id': config.system_id,
+          'Initiating-System-Version': SYSTEM_VERSION,
+          'Initiating-System-Id': config.system_id,
+          'Ocp-Apim-Trace': 'true'
+        }
+      end
+
+      def method
+        'POST'
+      end
+
+      def path
+        '/customerIdentity/v1.0/revoke'
+      end
+
+      def parameters
+        {
+          client_id: config.auth_client_id,
+          client_secret: config.auth_client_secret,
+          token: token
+        }
+      end
+
+      def decode(_response); end
+    end
+  end
+end

data/lib/vma_api/failure_response.rb

@@ -0,0 +1,42 @@
+require 'partner_api/errors'
+
+module VmaApi
+  class FailureResponse
+    def initialize(response)
+      @response = response
+    end
+
+    def errors
+      if json?
+        parsed_response = response.parse
+        [PartnerApi::Errors::RequestError.new(code: parsed_response['code'], message: parsed_response['message'])]
+      else
+        [PartnerApi::Errors::RequestError.new(message: "Invalid Response: #{body}")]
+      end
+    end
+
+    def error
+      errors.first
+    end
+
+    def status
+      response.status
+    end
+
+    def body
+      response.body
+    end
+
+    def headers
+      response.headers.to_h
+    end
+
+    private
+
+    attr_reader :response
+
+    def json?
+      response.content_type.mime_type == 'application/json'
+    end
+  end
+end

data/lib/vma_api.rb

@@ -0,0 +1,20 @@
+require 'forwardable'
+require 'concurrent-ruby'
+
+require 'vma_api/client'
+require 'vma_api/configuration'
+
+module VmaApi
+  extend self
+  extend Forwardable
+
+  SYSTEM_VERSION = 'v1.0'.freeze
+
+  @configurations = Concurrent::Hash.new
+
+  def_delegators 'configuration(:default)', :config, :configure
+
+  def configuration(key)
+    @configurations[key] ||= Configuration.new
+  end
+end