coindcx-client 0.1.0

data/lib/coindcx/rest/spot/orders.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Spot
+      class Orders < BaseResource
+        def create(attributes)
+          validated_attributes = Contracts::OrderRequest.validate_spot_create!(attributes)
+          build_model(Models::Order, post("/exchange/v1/orders/create", auth: true, bucket: :spot_create_order, body: validated_attributes))
+        end
+
+        def create_many(orders:)
+          validated_orders = Contracts::OrderRequest.validate_spot_create_many!(orders)
+          build_models(
+            Models::Order,
+            post("/exchange/v1/orders/create_multiple", auth: true, bucket: :spot_create_order_multiple, body: { orders: validated_orders })
+          )
+        end
+
+        def fetch_status(attributes)
+          build_model(Models::Order, post("/exchange/v1/orders/status", auth: true, bucket: :spot_order_status, body: attributes))
+        end
+
+        def fetch_statuses(attributes)
+          build_models(
+            Models::Order,
+            post("/exchange/v1/orders/status_multiple", auth: true, bucket: :spot_order_status_multiple, body: attributes)
+          )
+        end
+
+        def list_active(attributes = {})
+          build_models(
+            Models::Order,
+            post("/exchange/v1/orders/active_orders", auth: true, bucket: :spot_active_order, body: attributes)
+          )
+        end
+
+        def count_active(attributes = {})
+          post("/exchange/v1/orders/active_orders_count", auth: true, bucket: :spot_active_order_count, body: attributes)
+        end
+
+        def list_trade_history(attributes = {})
+          build_models(Models::Trade, post("/exchange/v1/orders/trade_history", auth: true, bucket: :spot_trade_history, body: attributes))
+        end
+
+        def cancel(attributes)
+          build_model(Models::Order, post("/exchange/v1/orders/cancel", auth: true, bucket: :spot_cancel_order, body: attributes))
+        end
+
+        def cancel_many(attributes)
+          build_models(
+            Models::Order,
+            post("/exchange/v1/orders/cancel_by_ids", auth: true, bucket: :spot_cancel_multiple_by_id, body: attributes)
+          )
+        end
+
+        def cancel_all(attributes = {})
+          post("/exchange/v1/orders/cancel_all", auth: true, bucket: :spot_cancel_all, body: attributes)
+        end
+
+        def edit_price(attributes)
+          build_model(Models::Order, post("/exchange/v1/orders/edit", auth: true, bucket: :spot_edit_price, body: attributes))
+        end
+      end
+    end
+  end
+end

data/lib/coindcx/rest/transfers/facade.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Transfers
+      class Facade
+        def initialize(http_client:)
+          @http_client = http_client
+        end
+
+        def wallets
+          @wallets ||= Wallets.new(http_client: @http_client)
+        end
+      end
+    end
+  end
+end

data/lib/coindcx/rest/transfers/wallets.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Transfers
+      class Wallets < BaseResource
+        def transfer(source_wallet_type:, destination_wallet_type:, currency_short_name:, amount:, timestamp: nil)
+          validated_attributes = Contracts::WalletTransferRequest.validate_transfer!(
+            source_wallet_type: source_wallet_type,
+            destination_wallet_type: destination_wallet_type,
+            currency_short_name: currency_short_name,
+            amount: amount,
+            timestamp: timestamp
+          )
+          post(
+            "/exchange/v1/wallets/transfer",
+            auth: true,
+            bucket: :wallets_transfer,
+            body: validated_attributes
+          )
+        end
+
+        def sub_account_transfer(from_account_id:, to_account_id:, currency_short_name:, amount:, timestamp: nil)
+          post(
+            "/exchange/v1/wallets/sub_account_transfer",
+            auth: true,
+            bucket: :wallets_sub_account_transfer,
+            body: {
+              from_account_id: from_account_id,
+              to_account_id: to_account_id,
+              currency_short_name: currency_short_name,
+              amount: amount,
+              timestamp: timestamp
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/coindcx/rest/user/accounts.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module User
+      class Accounts < BaseResource
+        def list_balances(attributes = {})
+          build_models(Models::Balance, post("/exchange/v1/users/balances", auth: true, bucket: :user_balances, body: attributes))
+        end
+
+        def fetch_info(attributes = {})
+          post("/exchange/v1/users/info", auth: true, bucket: :user_info, body: attributes)
+        end
+      end
+    end
+  end
+end

data/lib/coindcx/rest/user/facade.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module User
+      class Facade
+        def initialize(http_client:)
+          @http_client = http_client
+        end
+
+        def accounts
+          @accounts ||= Accounts.new(http_client: @http_client)
+        end
+      end
+    end
+  end
+end

data/lib/coindcx/transport/circuit_breaker.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Transport
+    class CircuitBreaker
+      def initialize(threshold:, cooldown:, monotonic_clock: nil)
+        @threshold = threshold
+        @cooldown = cooldown
+        @monotonic_clock = monotonic_clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+        @states = {}
+        @mutex = Mutex.new
+      end
+
+      def guard(key, request_context:)
+        return yield if key.nil?
+
+        raise open_error(key, request_context) if open?(key)
+
+        yield.tap { record_success(key) }
+      rescue Errors::TransportError, Errors::UpstreamServerError, Errors::RetryableRateLimitError => e
+        record_failure(key)
+        raise e
+      end
+
+      private
+
+      attr_reader :threshold, :cooldown, :monotonic_clock
+
+      def open?(key)
+        state = @mutex.synchronize { @states[key] }
+        return false if state.nil?
+        return false if state.fetch(:failures) < threshold
+
+        monotonic_time < state.fetch(:opened_at) + cooldown
+      end
+
+      def record_success(key)
+        @mutex.synchronize { @states.delete(key) }
+      end
+
+      def record_failure(key)
+        @mutex.synchronize do
+          state = @states[key] || { failures: 0, opened_at: monotonic_time }
+          state[:failures] += 1
+          state[:opened_at] = monotonic_time if state[:failures] >= threshold
+          @states[key] = state
+        end
+      end
+
+      def open_error(key, request_context)
+        Errors::CircuitOpenError.new(
+          "CoinDCX circuit is open for #{key}",
+          category: :circuit_open,
+          code: "circuit_open",
+          request_context: request_context,
+          retryable: false
+        )
+      end
+
+      def monotonic_time
+        monotonic_clock.call
+      end
+    end
+  end
+end

data/lib/coindcx/transport/http_client.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "securerandom"
+
+module CoinDCX
+  module Transport
+    # rubocop:disable Metrics/ClassLength
+    class HttpClient
+      # rubocop:disable Metrics/MethodLength
+      def initialize(configuration:, stubs: nil, sleeper: Kernel, monotonic_clock: nil)
+        @configuration = configuration
+        @rate_limits = RateLimitRegistry.new(configuration.endpoint_rate_limits)
+        @logger = configuration.logger || Logging::NullLogger.new
+        @retry_policy = RetryPolicy.new(
+          max_retries: configuration.max_retries,
+          base_interval: configuration.retry_base_interval,
+          logger: @logger,
+          sleeper: sleeper
+        )
+        @circuit_breaker = CircuitBreaker.new(
+          threshold: configuration.circuit_breaker_threshold,
+          cooldown: configuration.circuit_breaker_cooldown,
+          monotonic_clock: monotonic_clock
+        )
+        @connections = {
+          api: build_connection(configuration.api_base_url, stubs),
+          public: build_connection(configuration.public_base_url, stubs)
+        }
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      attr_reader :configuration
+
+      def get(path, params: {}, body: {}, auth: false, base: :api, bucket: nil)
+        request(:get, path, params: params, body: body, auth: auth, base: base, bucket: bucket)
+      end
+
+      def post(path, body: {}, auth: false, base: :api, bucket: nil)
+        request(:post, path, params: {}, body: body, auth: auth, base: base, bucket: bucket)
+      end
+
+      def delete(path, body: {}, auth: false, base: :api, bucket: nil)
+        request(:delete, path, params: {}, body: body, auth: auth, base: base, bucket: bucket)
+      end
+
+      private
+
+      attr_reader :logger, :rate_limits, :retry_policy, :circuit_breaker
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def request(method, path, params:, body:, auth:, base:, bucket:)
+        policy = RequestPolicy.build(
+          configuration: configuration,
+          method: method,
+          path: path,
+          body: body,
+          auth: auth,
+          bucket: bucket
+        )
+        request_id = SecureRandom.uuid
+        started_at = monotonic_time
+        retries = 0
+        response_status = nil
+        context = request_context(
+          method: method,
+          path: path,
+          base: base,
+          request_id: request_id,
+          operation_name: policy.operation_name
+        )
+
+        enforce_idempotency_contract!(policy: policy, path: path, request_context: context)
+        rate_limits.throttle(policy.bucket, required: auth)
+
+        normalized_response = circuit_breaker.guard(policy.circuit_breaker_key, request_context: context) do
+          retry_policy.with_retries(context, policy: policy) do |attempts|
+            retries = attempts - 1
+            response = connection_for(base).public_send(method, path) do |request|
+              request.headers["Accept"] = "application/json"
+              request.headers["User-Agent"] = configuration.user_agent
+              request.options.timeout = configuration.read_timeout
+              request.options.open_timeout = configuration.open_timeout
+              apply_payload(request, method: method, params: params, body: body, auth: auth)
+            end
+
+            response_status = response.status.to_i
+            parse_response(
+              response,
+              path,
+              request_context: context,
+              policy: policy
+            )
+          end
+        end
+
+        log(
+          :info,
+          event: "api_call",
+          endpoint: path,
+          operation: policy.operation_name,
+          request_id: request_id,
+          latency: elapsed_since(started_at),
+          retries: retries,
+          response_status: response_status
+        )
+        normalized_response.fetch(:data)
+      rescue Errors::ApiError => e
+        log(
+          :error,
+          event: "api_call_failed",
+          endpoint: path,
+          operation: policy.operation_name,
+          request_id: request_id,
+          latency: elapsed_since(started_at),
+          retries: retries,
+          response_status: e.status,
+          category: e.category,
+          error_code: normalized_error_code(e.body),
+          error_message: normalized_error_message(e.body)
+        )
+        raise
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def apply_payload(request, method:, params:, body:, auth:)
+        request.params.update(encode_query(params)) unless params.empty?
+        return if method == :get && !auth
+
+        normalized_body = auth ? authenticated_body(request, body) : plain_body(request, body)
+        request.body = JSON.generate(Utils::Payload.stringify_keys(normalized_body)) unless normalized_body.empty?
+      end
+
+      def enforce_idempotency_contract!(policy:, path:, request_context:)
+        return unless policy.requires_idempotency?
+        return if policy.idempotency_satisfied?
+
+        raise Errors::ValidationError.new(
+          "client_order_id is required for #{path}",
+          category: :validation,
+          code: "missing_client_order_id",
+          request_context: request_context,
+          retryable: false
+        )
+      end
+
+      def authenticated_body(request, body)
+        signer = Auth::Signer.new(api_key: fetch_api_key, api_secret: fetch_api_secret)
+        normalized_body, headers = signer.authenticated_request(body)
+        request.headers["Content-Type"] = "application/json"
+        headers.each { |header_name, value| request.headers[header_name] = value }
+        normalized_body
+      end
+
+      def plain_body(request, body)
+        normalized_body = Utils::Payload.compact_hash(body)
+        request.headers["Content-Type"] = "application/json"
+        normalized_body
+      end
+
+      def parse_response(response, path, request_context:, policy:)
+        parsed_body = parse_body(response.body)
+        status = response.status.to_i
+        return ResponseNormalizer.success(parsed_body) if status.between?(200, 299)
+
+        raise classify_error(
+          status,
+          path,
+          parsed_body,
+          headers: response.headers,
+          request_context: request_context,
+          policy: policy
+        )
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def classify_error(status, path, body, headers:, request_context:, policy:)
+        message = "CoinDCX request failed for #{path}"
+        error_class, category, retryable = error_details_for(status: status, headers: headers, policy: policy)
+        normalized_body = ResponseNormalizer.failure(
+          status: status,
+          body: body,
+          fallback_message: message,
+          category: category,
+          request_context: request_context,
+          retryable: retryable
+        )
+        error_class.new(
+          message,
+          status: status,
+          body: normalized_body,
+          category: category,
+          code: normalized_body.dig(:error, :code),
+          request_context: request_context,
+          retryable: retryable,
+          retry_after: policy.retry_after(headers)
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def parse_body(body)
+        return {} if body.nil? || body.strip.empty?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        body
+      end
+
+      def encode_query(params)
+        Utils::Payload.compact_hash(params).each_with_object({}) do |(key, value), result|
+          result[key.to_s] = value
+        end
+      end
+
+      def request_context(method:, path:, base:, request_id:, operation_name:)
+        {
+          endpoint: path,
+          request_id: request_id,
+          method: method.to_s.upcase,
+          base: base,
+          operation: operation_name
+        }
+      end
+
+      def normalized_error_code(body)
+        return nil unless body.respond_to?(:dig)
+
+        body.dig(:error, :code)
+      end
+
+      def normalized_error_message(body)
+        return body.message if body.is_a?(StandardError)
+        return body.to_s unless body.respond_to?(:dig)
+
+        body.dig(:error, :message)
+      end
+
+      def error_details_for(status:, headers:, policy:)
+        return [Errors::AuthError, :auth, false] if status == 401
+        if status == 429 && policy.retryable_response?(status: status, headers: headers)
+          return [Errors::RetryableRateLimitError, :rate_limit, true]
+        end
+        return [Errors::RateLimitError, :rate_limit, false] if status == 429
+        return [Errors::UpstreamServerError, :upstream, policy.retryable_response?(status: status, headers: headers)] if status >= 500
+        return [Errors::RemoteValidationError, :validation, false] if policy.validation_status?(status)
+
+        [Errors::RequestError, :request, false]
+      end
+
+      def connection_for(base)
+        @connections.fetch(base) do
+          raise Errors::ConfigurationError, "unknown base url: #{base.inspect}"
+        end
+      end
+
+      def build_connection(base_url, stubs)
+        Faraday.new(url: base_url) do |connection|
+          connection.request :url_encoded
+          connection.adapter(stubs ? :test : Faraday.default_adapter, stubs)
+        end
+      end
+
+      def fetch_api_key
+        return configuration.api_key if configuration.api_key
+
+        raise Errors::AuthError, "api_key is required for authenticated endpoints"
+      end
+
+      def fetch_api_secret
+        return configuration.api_secret if configuration.api_secret
+
+        raise Errors::AuthError, "api_secret is required for authenticated endpoints"
+      end
+
+      def elapsed_since(started_at)
+        monotonic_time - started_at
+      end
+
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def log(level, payload)
+        Logging::StructuredLogger.log(logger, level, payload)
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/coindcx/transport/rate_limit_registry.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Transport
+    class RateLimitRegistry
+      def initialize(definitions = {})
+        @definitions = definitions.transform_keys(&:to_sym)
+        @timestamps = Hash.new { |hash, key| hash[key] = [] }
+        @mutex = Mutex.new
+      end
+
+      def throttle(bucket_name, required: false)
+        definition = definition_for(bucket_name, required: required)
+        return if definition.nil?
+
+        loop do
+          wait_time = @mutex.synchronize do
+            reserve_slot(bucket_name, definition)
+          end
+
+          return if wait_time.nil? || wait_time <= 0
+
+          sleep(wait_time)
+        end
+      end
+
+      alias acquire throttle
+
+      private
+
+      def definition_for(bucket_name, required:)
+        if bucket_name.nil?
+          return nil unless required
+
+          raise Errors::ConfigurationError, "missing rate limit definition for authenticated request"
+        end
+
+        definition = @definitions[bucket_name.to_sym]
+        return definition unless definition.nil?
+        return unless required
+
+        raise Errors::ConfigurationError, "missing rate limit definition for #{bucket_name}"
+      end
+
+      def reserve_slot(bucket_name, definition)
+        bucket_key = bucket_name.to_sym
+        now = monotonic_time
+        cutoff = now - definition.fetch(:period).to_f
+        bucket = @timestamps[bucket_key]
+        bucket.reject! { |timestamp| timestamp <= cutoff }
+
+        if bucket.length < definition.fetch(:limit)
+          bucket << now
+          return nil
+        end
+
+        definition.fetch(:period).to_f - (now - bucket.first)
+      end
+
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end