coindcx-client 0.1.0

data/lib/coindcx/ws/socket_io_client.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module WS
+    class SocketIOClient
+      def initialize(configuration:, backend: nil, sleeper: Kernel, thread_factory: nil, monotonic_clock: nil, randomizer: nil)
+        @configuration = configuration
+        @logger = configuration.logger || Logging::NullLogger.new
+        @backend = Contracts::SocketBackend.validate!(backend || build_backend)
+        @private_channels = PrivateChannels.new(configuration: configuration)
+        @connection_manager = ConnectionManager.new(
+          configuration: configuration,
+          backend: @backend,
+          logger: @logger,
+          sleeper: sleeper,
+          thread_factory: thread_factory,
+          monotonic_clock: monotonic_clock,
+          randomizer: randomizer
+        )
+      end
+
+      def connect
+        connection_manager.connect
+        self
+      end
+
+      def disconnect
+        connection_manager.disconnect
+        self
+      end
+
+      def on(event_name, &block)
+        connection_manager.on(event_name, &block)
+        self
+      end
+
+      def subscribe_public(channel_name:, event_name:, &block)
+        register_subscription(type: :public, channel_name: channel_name, event_name: event_name, &block)
+      end
+
+      def subscribe_private(event_name:, channel_name: PrivateChannels::DEFAULT_CHANNEL_NAME, &block)
+        register_subscription(type: :private, channel_name: channel_name, event_name: event_name, &block)
+      end
+
+      def alive?
+        connection_manager.alive?
+      end
+
+      # Emits Socket.IO `leave` per CoinDCX docs. Does not remove handlers or registry entries; after a
+      # reconnect, {#subscribe_public} / {#subscribe_private} intents are still re-joined automatically.
+      def leave_channel(channel_name:)
+        backend.emit(
+          "leave",
+          { "channelName" => Contracts::ChannelName.validate!(channel_name) }
+        )
+        self
+      end
+
+      private
+
+      attr_reader :configuration, :backend, :private_channels, :connection_manager
+
+      def register_subscription(type:, channel_name:, event_name:, &block)
+        on(event_name, &block) if block_given?
+        connection_manager.subscribe(
+          type: type,
+          channel_name: channel_name,
+          event_name: event_name,
+          payload_builder: -> { join_payload(type: type, channel_name: channel_name) },
+          delivery_mode: :at_least_once
+        )
+        self
+      end
+
+      def join_payload(type:, channel_name:)
+        return { "channelName" => Contracts::ChannelName.validate!(channel_name) } if type == :public
+
+        private_channels.join_payload(channel_name: channel_name)
+      end
+
+      def build_backend
+        factory = configuration.socket_io_backend_factory
+        return Contracts::SocketBackend.validate!(factory.call) if factory
+
+        SocketIOSimpleBackend.new(connect_options: configuration.socket_io_connect_options)
+      end
+    end
+  end
+end

data/lib/coindcx/ws/socket_io_simple_backend.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "uri_ruby3_compat"
+require "socket.io-client-simple"
+
+module CoinDCX
+  module WS
+    class SocketIOSimpleBackend
+      def initialize(socket_client_class: ::SocketIO::Client::Simple::Client, connect_options: nil)
+        @socket_client_class = socket_client_class
+        @connect_options = connect_options || { EIO: 3 }
+      end
+
+      # Engine.IO version must match the server (`EIO` query param). CoinDCX stream uses Engine.IO v3
+      # (same as socket.io-client 2.3.x in their docs). This gem's default backend only supports v3;
+      # use `socket_io_backend_factory` if you need a different stack.
+      #
+      # Two-step setup so ConnectionManager can register Socket.IO listeners before the WebSocket
+      # opens; otherwise the Engine.IO "open" packet can fire :connect before we listen, and join
+      # emits run while the client still rejects emit (pre-handshake).
+      def connect(url)
+        disconnect
+        @socket = @socket_client_class.new(url, @connect_options.dup)
+        self
+      rescue StandardError => e
+        @socket = nil
+        raise Errors::SocketConnectionError, e.message
+      end
+
+      def start_transport!
+        raise Errors::SocketError, "socket client missing before start_transport!" if @socket.nil?
+
+        @socket.connect
+        self
+      end
+
+      def emit(event_name, payload)
+        socket.emit(event_name, payload)
+      end
+
+      def on(event_name, &block)
+        socket.on(event_name, &block)
+      end
+
+      def disconnect
+        return if @socket.nil?
+
+        if @socket.respond_to?(:disconnect)
+          @socket.disconnect
+        elsif @socket.respond_to?(:close)
+          @socket.close
+        end
+        @socket = nil
+      end
+
+      private
+
+      def socket
+        @socket || raise(Errors::SocketError, "socket connection has not been established")
+      end
+    end
+  end
+end

data/lib/coindcx/ws/subscription_registry.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module WS
+    class SubscriptionRegistry
+      SubscriptionIntent = Struct.new(
+        :type,
+        :channel_name,
+        :event_name,
+        :payload_builder,
+        :delivery_mode
+      ) do
+        def payload
+          payload_builder.call
+        end
+
+        def private_channel?
+          type == :private
+        end
+      end
+
+      def initialize
+        @subscriptions = []
+        @mutex = Mutex.new
+      end
+
+      def add(type:, channel_name:, event_name:, payload_builder:, delivery_mode:)
+        @mutex.synchronize do
+          subscription = SubscriptionIntent.new(
+            type: type,
+            channel_name: channel_name,
+            event_name: event_name,
+            payload_builder: payload_builder,
+            delivery_mode: delivery_mode
+          )
+
+          @subscriptions << subscription unless include?(subscription)
+        end
+      end
+
+      def each(&block)
+        snapshot.each(&block)
+      end
+
+      def any?
+        snapshot.any?
+      end
+
+      def count
+        snapshot.count
+      end
+
+      def event_names
+        snapshot.map(&:event_name).uniq
+      end
+
+      def private_subscriptions?
+        snapshot.any?(&:private_channel?)
+      end
+
+      def public_subscriptions?
+        snapshot.any? { |subscription| !subscription.private_channel? }
+      end
+
+      private
+
+      def include?(candidate)
+        @subscriptions.any? do |subscription|
+          subscription.type == candidate.type &&
+            subscription.channel_name == candidate.channel_name &&
+            subscription.event_name == candidate.event_name
+        end
+      end
+
+      def snapshot
+        @mutex.synchronize { @subscriptions.dup }
+      end
+    end
+  end
+end

data/lib/coindcx/ws/uri_ruby3_compat.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "uri"
+
+# socket.io-client-simple 1.2.x builds the Engine.IO query string with URI.encode, which was
+# removed in Ruby 3.0 (use URI::DEFAULT_PARSER.escape instead). Load this before socket.io-client-simple.
+unless URI.respond_to?(:encode)
+  module URI
+    def self.encode(str)
+      DEFAULT_PARSER.escape(str.to_s)
+    end
+  end
+end

data/lib/coindcx.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require_relative "coindcx/version"
+require_relative "coindcx/utils/payload"
+require_relative "coindcx/errors/base_error"
+require_relative "coindcx/logging/null_logger"
+require_relative "coindcx/logging/structured_logger"
+require_relative "coindcx/contracts/channel_name"
+require_relative "coindcx/contracts/identifiers"
+require_relative "coindcx/contracts/order_request"
+require_relative "coindcx/contracts/wallet_transfer_request"
+require_relative "coindcx/contracts/socket_backend"
+require_relative "coindcx/models/base_model"
+
+Dir[File.join(__dir__, "coindcx/models/*.rb")].each do |file|
+  require file unless file.end_with?("base_model.rb")
+end
+
+require_relative "coindcx/auth/signer"
+require_relative "coindcx/transport/circuit_breaker"
+require_relative "coindcx/transport/rate_limit_registry"
+require_relative "coindcx/transport/request_policy"
+require_relative "coindcx/transport/retry_policy"
+require_relative "coindcx/transport/response_normalizer"
+require_relative "coindcx/transport/http_client"
+require_relative "coindcx/rest/base_resource"
+
+Dir[File.join(__dir__, "coindcx/rest/**/*.rb")].each do |file|
+  require file unless file.end_with?("base_resource.rb")
+end
+
+Dir[File.join(__dir__, "coindcx/ws/**/*.rb")].each do |file|
+  require file
+end
+
+require_relative "coindcx/configuration"
+require_relative "coindcx/client"
+
+module CoinDCX
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def client
+      Client.new(configuration: configuration)
+    end
+
+    def generate_client_order_id
+      SecureRandom.uuid
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/spec/auth_signer_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+require "spec_helper"
+
+RSpec.describe CoinDCX::Auth::Signer do
+  subject(:signer) { described_class.new(api_key: "key-123", api_secret: "secret-456") }
+
+  describe "#authenticated_request" do
+    it "adds the documented authentication headers" do
+      request_body, headers = signer.authenticated_request(market: "SNTBTC", timestamp: 1234)
+      expected_signature = OpenSSL::HMAC.hexdigest("SHA256", "secret-456", JSON.generate("market" => "SNTBTC", "timestamp" => 1234))
+
+      expect(request_body).to eq(market: "SNTBTC", timestamp: 1234)
+      expect(headers).to eq(
+        "X-AUTH-APIKEY" => "key-123",
+        "X-AUTH-SIGNATURE" => expected_signature
+      )
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::Client do
+  subject(:client) { described_class.new(configuration: configuration) }
+
+  let(:configuration) { CoinDCX::Configuration.new }
+
+  it 'builds facades for each API namespace' do
+    expect(client.public).to be_a(CoinDCX::REST::Public::Facade)
+    expect(client.spot).to be_a(CoinDCX::REST::Spot::Facade)
+    expect(client.margin).to be_a(CoinDCX::REST::Margin::Facade)
+    expect(client.user).to be_a(CoinDCX::REST::User::Facade)
+    expect(client.transfers).to be_a(CoinDCX::REST::Transfers::Facade)
+    expect(client.futures).to be_a(CoinDCX::REST::Futures::Facade)
+    expect(client.funding).to be_a(CoinDCX::REST::Funding::Facade)
+  end
+end

data/spec/contracts/order_request_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe CoinDCX::Contracts::OrderRequest do
+  describe ".validate_spot_create!" do
+    it "accepts a valid spot order" do
+      attributes = described_class.validate_spot_create!(
+        side: "buy",
+        order_type: "limit_order",
+        market: "SNTBTC",
+        total_quantity: 2,
+        client_order_id: "spot-order-1",
+        price_per_unit: "0.03244"
+      )
+
+      expect(attributes).to include(
+        side: "buy",
+        order_type: "limit_order",
+        market: "SNTBTC",
+        total_quantity: 2,
+        client_order_id: "spot-order-1"
+      )
+    end
+
+    it "rejects unsupported sides" do
+      expect do
+        described_class.validate_spot_create!(
+          side: "hold",
+          order_type: "limit_order",
+          market: "SNTBTC",
+          total_quantity: 2
+        )
+      end.to raise_error(CoinDCX::Errors::ValidationError, /side/)
+    end
+
+    it "rejects non-positive quantities" do
+      expect do
+        described_class.validate_spot_create!(
+          side: "buy",
+          order_type: "limit_order",
+          market: "SNTBTC",
+          total_quantity: 0,
+          client_order_id: "spot-order-3"
+        )
+      end.to raise_error(CoinDCX::Errors::ValidationError, /total_quantity/)
+    end
+
+    it "rejects invalid market symbols" do
+      expect do
+        described_class.validate_spot_create!(
+          side: "buy",
+          order_type: "limit_order",
+          market: "btc-usdt",
+          total_quantity: 1,
+          client_order_id: "spot-order-4"
+        )
+      end.to raise_error(CoinDCX::Errors::ValidationError, /market/)
+    end
+
+    it "requires a client_order_id for safety" do
+      expect do
+        described_class.validate_spot_create!(
+          side: "buy",
+          order_type: "market_order",
+          market: "SNTBTC",
+          total_quantity: 1
+        )
+      end.to raise_error(CoinDCX::Errors::ValidationError, /client_order_id/)
+    end
+  end
+
+  describe ".validate_futures_create!" do
+    it "accepts a valid futures order" do
+      order = described_class.validate_futures_create!(
+        side: "sell",
+        order_type: "limit_order",
+        pair: "B-BTC_USDT",
+        quantity: 1,
+        client_order_id: "futures-order-1"
+      )
+
+      expect(order).to include(side: "sell", pair: "B-BTC_USDT", quantity: 1)
+    end
+
+    it "accepts total_quantity (CoinDCX futures create payload style)" do
+      order = described_class.validate_futures_create!(
+        side: "buy",
+        pair: "B-SOL_USDT",
+        total_quantity: "0.01",
+        order_type: "market_order",
+        client_order_id: "futures-order-2",
+        margin_currency_short_name: "USDT",
+        leverage: 3
+      )
+
+      expect(order).to include(side: "buy", pair: "B-SOL_USDT", total_quantity: "0.01")
+    end
+
+    it "rejects malformed pair identifiers" do
+      expect do
+        described_class.validate_futures_create!(
+          side: "sell",
+          pair: "BTCUSDT",
+          quantity: 1,
+          client_order_id: "futures-order-3"
+        )
+      end.to raise_error(CoinDCX::Errors::ValidationError, /pair/)
+    end
+  end
+
+  describe ".validate_margin_create!" do
+    it "accepts a valid margin order" do
+      attributes = described_class.validate_margin_create!(
+        side: "buy",
+        order_type: "market_order",
+        market: "SNTBTC",
+        quantity: 1,
+        client_order_id: "margin-order-1"
+      )
+
+      expect(attributes).to include(side: "buy", market: "SNTBTC", quantity: 1)
+    end
+
+    it "rejects missing quantities" do
+      expect do
+        described_class.validate_margin_create!(
+          side: "buy",
+          order_type: "market_order",
+          market: "SNTBTC",
+          client_order_id: "margin-order-2"
+        )
+      end.to raise_error(CoinDCX::Errors::ValidationError, /quantity/)
+    end
+  end
+end

data/spec/contracts/wallet_transfer_request_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe CoinDCX::Contracts::WalletTransferRequest do
+  describe ".validate_transfer!" do
+    it "accepts a valid wallet transfer request" do
+      attributes = described_class.validate_transfer!(
+        source_wallet_type: "spot",
+        destination_wallet_type: "futures",
+        currency_short_name: "USDT",
+        amount: 1
+      )
+
+      expect(attributes).to include(
+        source_wallet_type: "spot",
+        destination_wallet_type: "futures",
+        currency_short_name: "USDT",
+        amount: 1
+      )
+    end
+
+    it "rejects unsupported wallet types" do
+      expect do
+        described_class.validate_transfer!(
+          source_wallet_type: "vault",
+          destination_wallet_type: "futures",
+          currency_short_name: "USDT",
+          amount: 1
+        )
+      end.to raise_error(CoinDCX::Errors::ValidationError, /source_wallet_type/)
+    end
+
+    it "rejects non-positive amounts" do
+      expect do
+        described_class.validate_transfer!(
+          source_wallet_type: "spot",
+          destination_wallet_type: "futures",
+          currency_short_name: "USDT",
+          amount: 0
+        )
+      end.to raise_error(CoinDCX::Errors::ValidationError, /amount/)
+    end
+  end
+end

data/spec/models/base_model_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::Models::BaseModel do
+  subject(:model) { described_class.new('status' => 'open', 'nested' => { 'count' => 2 }) }
+
+  it 'provides hash-like and method-style access to attributes' do
+    expect(model[:status]).to eq('open')
+    expect(model.status).to eq('open')
+    expect(model.to_h).to eq(status: 'open', nested: { count: 2 })
+  end
+
+  it 'reports dynamic methods through respond_to?' do
+    expect(model).to respond_to(:status)
+    expect(model).not_to respond_to(:missing_attribute)
+  end
+end

data/spec/rest/funding/orders_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::Funding::Orders do
+  subject(:resource) { described_class.new(http_client: http_client) }
+
+  let(:http_client) { instance_double(CoinDCX::Transport::HttpClient) }
+
+  before do
+    allow(http_client).to receive(:post).and_return({})
+  end
+
+  it 'routes funding endpoints through authenticated transport calls' do
+    resource.list
+    resource.lend(currency: 'USDT', amount: '10')
+    resource.settle(id: 'abc123')
+
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/funding/fetch_orders',
+      body: {},
+      auth: true,
+      base: :api,
+      bucket: :funding_fetch_orders
+    )
+
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/funding/lend',
+      body: { currency: 'USDT', amount: '10' },
+      auth: true,
+      base: :api,
+      bucket: :funding_lend
+    )
+
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/funding/settle',
+      body: { id: 'abc123' },
+      auth: true,
+      base: :api,
+      bucket: :funding_settle
+    )
+  end
+end

data/spec/rest/futures/market_data_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::Futures::MarketData do
+  subject(:resource) { described_class.new(http_client: http_client) }
+
+  let(:http_client) { instance_double(CoinDCX::Transport::HttpClient) }
+
+  before do
+    allow(http_client).to receive(:get).and_return({})
+  end
+
+  it 'routes futures market data requests to the expected endpoints' do
+    resource.list_active_instruments
+    resource.fetch_instrument(pair: 'B-BTC_USDT', margin_currency_short_name: 'USDT')
+    resource.list_trades(pair: 'B-BTC_USDT')
+    resource.fetch_order_book(instrument: 'B-BTC_USDT', depth: 50)
+    resource.list_candlesticks(pair: 'B-BTC_USDT', from: 1, to: 2, resolution: '1D')
+    resource.current_prices
+    resource.stats(pair: 'B-BTC_USDT')
+    resource.conversions
+
+    expect(http_client).to have_received(:get).with('/exchange/v1/derivatives/futures/data/active_instruments',
+                                                    params: { 'margin_currency_short_name[]': ['USDT'] }, body: {}, auth: false, base: :api, bucket: nil)
+    expect(http_client).to have_received(:get).with('/exchange/v1/derivatives/futures/data/instrument',
+                                                    params: { pair: 'B-BTC_USDT', margin_currency_short_name: 'USDT' }, body: {}, auth: true,
+                                                    base: :api, bucket: :futures_instrument_detail)
+    expect(http_client).to have_received(:get).with('/exchange/v1/derivatives/futures/data/trades', params: { pair: 'B-BTC_USDT' }, body: {},
+                                                                                                    auth: false, base: :api, bucket: nil)
+    expect(http_client).to have_received(:get).with('/market_data/v3/orderbook/B-BTC_USDT-futures/50', params: {}, body: {}, auth: false,
+                                                                                                       base: :public, bucket: nil)
+    expect(http_client).to have_received(:get).with('/market_data/candlesticks',
+                                                    params: { pair: 'B-BTC_USDT', from: 1, to: 2, resolution: '1D', pcode: 'f' }, body: {},
+                                                    auth: false, base: :public, bucket: nil)
+    expect(http_client).to have_received(:get).with('/market_data/v3/current_prices/futures/rt', params: {}, body: {}, auth: false,
+                                                                                                 base: :public, bucket: :public_market_data)
+    expect(http_client).to have_received(:get).with('/api/v1/derivatives/futures/data/stats', params: { pair: 'B-BTC_USDT' }, body: {},
+                                                                                              auth: false, base: :api, bucket: nil)
+    expect(http_client).to have_received(:get).with('/api/v1/derivatives/futures/data/conversions', params: {}, body: {}, auth: false,
+                                                                                                    base: :api, bucket: nil)
+  end
+
+  it 'rejects unsupported order book depths' do
+    expect do
+      resource.fetch_order_book(instrument: 'B-BTC_USDT', depth: 5)
+    end.to raise_error(CoinDCX::Errors::ValidationError)
+  end
+end