coindcx-client 0.1.0

data/spec/rest/futures/orders_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::Futures::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
+
+  describe "#create" do
+    it "validates futures order payloads and applies a create-order bucket" do
+      resource.create(order: { side: "sell", quantity: 2, client_order_id: "futures-123" })
+
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/derivatives/futures/orders/create",
+        body: { order: { side: "sell", quantity: 2, client_order_id: "futures-123" } },
+        auth: true,
+        base: :api,
+        bucket: :futures_create_order
+      )
+    end
+
+    it "accepts total_quantity for bot-style market orders" do
+      resource.create(
+        order: {
+          side: "buy",
+          pair: "B-SOL_USDT",
+          total_quantity: "0.05",
+          order_type: "market_order",
+          client_order_id: "futures-124",
+          leverage: 2
+        }
+      )
+
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/derivatives/futures/orders/create",
+        body: {
+          order: {
+            side: "buy",
+            pair: "B-SOL_USDT",
+            total_quantity: "0.05",
+            order_type: "market_order",
+            client_order_id: "futures-124",
+            leverage: 2
+          }
+        },
+        auth: true,
+        base: :api,
+        bucket: :futures_create_order
+      )
+    end
+
+    it "rejects an invalid side" do
+      expect do
+        resource.create(order: { side: "wait", quantity: 2 })
+      end.to raise_error(CoinDCX::Errors::ValidationError, /side/)
+    end
+
+    it "rejects a non-positive quantity" do
+      expect do
+        resource.create(order: { side: "buy", quantity: 0 })
+      end.to raise_error(CoinDCX::Errors::ValidationError, /quantity/)
+    end
+  end
+
+  describe "authenticated routing" do
+    it "routes futures order operations through authenticated transport calls" do
+      resource.list
+      resource.list_trades
+      resource.cancel(id: "1")
+      resource.edit(id: "1")
+
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/derivatives/futures/orders",
+        body: {},
+        auth: true,
+        base: :api,
+        bucket: :futures_list_orders
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/derivatives/futures/orders/cancel",
+        body: { id: "1" },
+        auth: true,
+        base: :api,
+        bucket: :futures_cancel_order
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/derivatives/futures/trades",
+        body: {},
+        auth: true,
+        base: :api,
+        bucket: :futures_trades
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/derivatives/futures/orders/edit",
+        body: { id: "1" },
+        auth: true,
+        base: :api,
+        bucket: :futures_edit_order
+      )
+    end
+  end
+end

data/spec/rest/futures/positions_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::Futures::Positions 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({})
+    allow(http_client).to receive(:get).and_return({})
+  end
+
+  it 'routes futures position operations through authenticated transport calls' do
+    resource.list
+    resource.update_leverage(id: '1')
+    resource.add_margin(id: '1')
+    resource.remove_margin(id: '1')
+    resource.cancel_all_open_orders(id: '1')
+    resource.cancel_all_open_orders_for_position(id: '1')
+    resource.exit_position(id: '1')
+    resource.create_take_profit_stop_loss(id: '1')
+    resource.list_transactions
+    resource.fetch_cross_margin_details
+    resource.update_margin_type(id: '1')
+
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions', body: {}, auth: true, base: :api,
+                                                                                                   bucket: :futures_positions_list)
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions/update_leverage', body: { id: '1' },
+                                                                                                                   auth: true, base: :api, bucket: :futures_positions_update_leverage)
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions/add_margin', body: { id: '1' },
+                                                                                                              auth: true, base: :api, bucket: :futures_positions_add_margin)
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions/remove_margin', body: { id: '1' },
+                                                                                                                 auth: true, base: :api, bucket: :futures_positions_remove_margin)
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions/cancel_all_open_orders',
+                                                     body: { id: '1' }, auth: true, base: :api, bucket: :futures_positions_cancel_all_open_orders)
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions/cancel_all_open_orders_for_position',
+                                                     body: { id: '1' }, auth: true, base: :api, bucket: :futures_positions_cancel_all_open_orders_for_position)
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions/exit', body: { id: '1' }, auth: true,
+                                                                                                        base: :api, bucket: :futures_positions_exit)
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions/create_tpsl', body: { id: '1' },
+                                                                                                               auth: true, base: :api, bucket: :futures_positions_create_tpsl)
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions/transactions', body: {}, auth: true,
+                                                                                                                base: :api, bucket: :futures_positions_transactions)
+    expect(http_client).to have_received(:get).with(
+      '/exchange/v1/derivatives/futures/positions/cross_margin_details',
+      params: {},
+      body: {},
+      auth: true,
+      base: :api,
+      bucket: :futures_positions_cross_margin_details
+    )
+    expect(http_client).to have_received(:post).with('/exchange/v1/derivatives/futures/positions/margin_type', body: { id: '1' },
+                                                                                                               auth: true, base: :api, bucket: :futures_positions_margin_type)
+  end
+end

data/spec/rest/futures/wallets_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::Futures::Wallets 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({})
+    allow(http_client).to receive(:get).and_return({})
+  end
+
+  it 'routes futures wallet operations through authenticated transport calls' do
+    resource.transfer(transfer_type: 'withdraw', amount: 1, currency_short_name: 'USDT')
+    resource.fetch_details
+    resource.list_transactions
+
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/derivatives/futures/wallets/transfer',
+      body: { transfer_type: 'withdraw', amount: 1, currency_short_name: 'USDT', timestamp: nil },
+      auth: true,
+      base: :api,
+      bucket: :futures_wallet_transfer
+    )
+    expect(http_client).to have_received(:get).with(
+      '/exchange/v1/derivatives/futures/wallets',
+      params: {},
+      body: {},
+      auth: true,
+      base: :api,
+      bucket: :futures_wallet_details
+    )
+    expect(http_client).to have_received(:get).with(
+      '/exchange/v1/derivatives/futures/wallets/transactions',
+      params: { page: 1, size: 1000 },
+      body: {},
+      auth: true,
+      base: :api,
+      bucket: :futures_wallet_transactions
+    )
+  end
+end

data/spec/rest/margin/orders_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::Margin::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 margin operations through authenticated transport calls' do
+    resource.create(side: 'buy', order_type: 'market_order', market: 'SNTBTC', quantity: 1, client_order_id: 'margin-1')
+    resource.list
+    resource.fetch(id: '1')
+    resource.cancel(id: '1')
+    resource.exit_order(id: '1')
+    resource.edit_target(id: '1')
+    resource.edit_stop_loss(id: '1')
+    resource.edit_trailing_stop_loss(id: '1')
+    resource.edit_target_order_price(id: '1')
+    resource.add_margin(id: '1')
+    resource.remove_margin(id: '1')
+
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/margin/create',
+      body: { side: 'buy', order_type: 'market_order', market: 'SNTBTC', quantity: 1, client_order_id: 'margin-1' },
+      auth: true,
+      base: :api,
+      bucket: :margin_create_order
+    )
+    expect(http_client).to have_received(:post).with('/exchange/v1/margin/fetch_orders', body: {}, auth: true, base: :api, bucket: :margin_list_orders)
+    expect(http_client).to have_received(:post).with('/exchange/v1/margin/order', body: { id: '1' }, auth: true, base: :api, bucket: :margin_fetch_order)
+    expect(http_client).to have_received(:post).with('/exchange/v1/margin/cancel', body: { id: '1' }, auth: true, base: :api, bucket: :margin_cancel_order)
+    expect(http_client).to have_received(:post).with('/exchange/v1/margin/exit', body: { id: '1' }, auth: true, base: :api, bucket: :margin_exit_order)
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/margin/edit_target',
+      body: { id: '1' },
+      auth: true,
+      base: :api,
+      bucket: :margin_edit_target
+    )
+    expect(http_client).to have_received(:post).with('/exchange/v1/margin/edit_sl', body: { id: '1' }, auth: true, base: :api, bucket: :margin_edit_stop_loss)
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/margin/edit_trailing_sl',
+      body: { id: '1' },
+      auth: true,
+      base: :api,
+      bucket: :margin_edit_trailing_stop_loss
+    )
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/margin/edit_price_of_target_order',
+      body: { id: '1' },
+      auth: true,
+      base: :api,
+      bucket: :margin_edit_target_order_price
+    )
+    expect(http_client).to have_received(:post).with('/exchange/v1/margin/add_margin', body: { id: '1' }, auth: true, base: :api, bucket: :margin_add_margin)
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/margin/remove_margin',
+      body: { id: '1' },
+      auth: true,
+      base: :api,
+      bucket: :margin_remove_margin
+    )
+  end
+
+  describe '#create' do
+    context 'when side is invalid' do
+      it 'raises a validation error' do
+        expect do
+          resource.create(side: 'hold', order_type: 'market_order', market: 'SNTBTC', quantity: 1)
+        end.to raise_error(CoinDCX::Errors::ValidationError, /side/)
+      end
+    end
+
+    context 'when quantity is not positive' do
+      it 'raises a validation error' do
+        expect do
+          resource.create(side: 'buy', order_type: 'market_order', market: 'SNTBTC', quantity: 0)
+        end.to raise_error(CoinDCX::Errors::ValidationError, /quantity/)
+      end
+    end
+  end
+end

data/spec/rest/public/market_data_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::Public::MarketData do
+  subject(:resource) { described_class.new(http_client: http_client) }
+
+  let(:http_client) { instance_double(CoinDCX::Transport::HttpClient) }
+
+  it 'requests public market endpoints through the transport' do
+    allow(http_client).to receive(:get).and_return([])
+
+    resource.list_tickers
+    resource.list_markets
+    resource.list_market_details
+    resource.list_trades(pair: 'B-BTC_USDT', limit: 10)
+    resource.fetch_order_book(pair: 'B-BTC_USDT')
+    resource.list_candles(pair: 'B-BTC_USDT', interval: '1m', start_time: 1, end_time: 2, limit: 3)
+
+    expect(http_client).to have_received(:get).with('/exchange/ticker', params: {}, body: {}, auth: false, base: :api, bucket: :public_ticker)
+    expect(http_client).to have_received(:get).with('/exchange/v1/markets', params: {}, body: {}, auth: false, base: :api, bucket: :public_market_data)
+    expect(http_client).to have_received(:get).with('/exchange/v1/markets_details', params: {}, body: {}, auth: false, base: :api, bucket: :public_market_data)
+    expect(http_client).to have_received(:get).with('/market_data/trade_history', params: { pair: 'B-BTC_USDT', limit: 10 }, body: {},
+                                                                                  auth: false, base: :public, bucket: :public_trades)
+    expect(http_client).to have_received(:get).with('/market_data/orderbook', params: { pair: 'B-BTC_USDT' }, body: {}, auth: false, base: :public,
+                                                                              bucket: :public_order_book)
+    expect(http_client).to have_received(:get).with('/market_data/candles',
+                                                    params: { pair: 'B-BTC_USDT', interval: '1m', startTime: 1, endTime: 2, limit: 3 }, body: {},
+                                                    auth: false, base: :public, bucket: :public_candles)
+  end
+end

data/spec/rest/spot/orders_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::Spot::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
+
+  describe "#create" do
+    it "validates spot order payloads before sending them" do
+      resource.create(
+        side: "buy",
+        order_type: "limit_order",
+        market: "SNTBTC",
+        price_per_unit: "0.03244",
+        total_quantity: 400,
+        client_order_id: "client-123"
+      )
+
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/create",
+        body: {
+          side: "buy",
+          order_type: "limit_order",
+          market: "SNTBTC",
+          price_per_unit: "0.03244",
+          total_quantity: 400,
+          client_order_id: "client-123"
+        },
+        auth: true,
+        base: :api,
+        bucket: :spot_create_order
+      )
+    end
+
+    it "rejects an invalid side" do
+      expect do
+        resource.create(side: "hold", order_type: "limit_order", market: "SNTBTC", total_quantity: 1)
+      end.to raise_error(CoinDCX::Errors::ValidationError, /side/)
+    end
+
+    it "rejects a non-positive quantity" do
+      expect do
+        resource.create(side: "buy", order_type: "limit_order", market: "SNTBTC", total_quantity: 0)
+      end.to raise_error(CoinDCX::Errors::ValidationError, /total_quantity/)
+    end
+  end
+
+  describe "authenticated routing" do
+    it "routes the remaining spot order operations through authenticated transport calls" do
+      resource.create_many(
+        orders: [{ side: "buy", order_type: "limit_order", market: "SNTBTC", total_quantity: 1, price_per_unit: "0.03244", client_order_id: "client-124" }]
+      )
+      resource.fetch_status(id: "1")
+      resource.fetch_statuses(ids: ["1"])
+      resource.list_active
+      resource.count_active
+      resource.list_trade_history
+      resource.cancel(id: "1")
+      resource.cancel_many(ids: ["1"])
+      resource.cancel_all
+      resource.edit_price(id: "1")
+
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/create_multiple",
+        body: {
+          orders: [
+            {
+              side: "buy",
+              order_type: "limit_order",
+              market: "SNTBTC",
+              total_quantity: 1,
+              price_per_unit: "0.03244",
+              client_order_id: "client-124"
+            }
+          ]
+        },
+        auth: true,
+        base: :api,
+        bucket: :spot_create_order_multiple
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/status",
+        body: { id: "1" },
+        auth: true,
+        base: :api,
+        bucket: :spot_order_status
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/status_multiple",
+        body: { ids: ["1"] },
+        auth: true,
+        base: :api,
+        bucket: :spot_order_status_multiple
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/active_orders",
+        body: {},
+        auth: true,
+        base: :api,
+        bucket: :spot_active_order
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/active_orders_count",
+        body: {},
+        auth: true,
+        base: :api,
+        bucket: :spot_active_order_count
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/trade_history",
+        body: {},
+        auth: true,
+        base: :api,
+        bucket: :spot_trade_history
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/cancel",
+        body: { id: "1" },
+        auth: true,
+        base: :api,
+        bucket: :spot_cancel_order
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/cancel_by_ids",
+        body: { ids: ["1"] },
+        auth: true,
+        base: :api,
+        bucket: :spot_cancel_multiple_by_id
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/cancel_all",
+        body: {},
+        auth: true,
+        base: :api,
+        bucket: :spot_cancel_all
+      )
+      expect(http_client).to have_received(:post).with(
+        "/exchange/v1/orders/edit",
+        body: { id: "1" },
+        auth: true,
+        base: :api,
+        bucket: :spot_edit_price
+      )
+    end
+  end
+end

data/spec/rest/transfers/wallets_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::Transfers::Wallets 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 transfer operations through authenticated transport calls' do
+    resource.transfer(source_wallet_type: 'spot', destination_wallet_type: 'futures', currency_short_name: 'USDT', amount: 1)
+    resource.sub_account_transfer(from_account_id: 'A', to_account_id: 'B', currency_short_name: 'USDT', amount: 1)
+
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/wallets/transfer',
+      body: { source_wallet_type: 'spot', destination_wallet_type: 'futures', currency_short_name: 'USDT', amount: 1, timestamp: nil },
+      auth: true,
+      base: :api,
+      bucket: :wallets_transfer
+    )
+    expect(http_client).to have_received(:post).with(
+      '/exchange/v1/wallets/sub_account_transfer',
+      body: { from_account_id: 'A', to_account_id: 'B', currency_short_name: 'USDT', amount: 1, timestamp: nil },
+      auth: true,
+      base: :api,
+      bucket: :wallets_sub_account_transfer
+    )
+  end
+end

data/spec/rest/user/accounts_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CoinDCX::REST::User::Accounts 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 user account operations through authenticated transport calls' do
+    resource.list_balances
+    resource.fetch_info
+
+    expect(http_client).to have_received(:post).with('/exchange/v1/users/balances', body: {}, auth: true, base: :api, bucket: :user_balances)
+    expect(http_client).to have_received(:post).with('/exchange/v1/users/info', body: {}, auth: true, base: :api, bucket: :user_info)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "simplecov"
+
+SimpleCov.start do
+  minimum_coverage 90
+  add_filter "/spec/"
+end
+
+require "rspec"
+require "coindcx"