coindcx-client 0.1.0

data/lib/coindcx/models/balance.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Models
+    class Balance < BaseModel
+    end
+  end
+end

data/lib/coindcx/models/base_model.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Models
+    class BaseModel
+      def initialize(attributes = {})
+        @attributes = Utils::Payload.symbolize_keys(attributes || {})
+      end
+
+      attr_reader :attributes
+
+      def [](key)
+        attributes[key.to_sym]
+      end
+
+      def to_h
+        attributes.dup
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        attributes.key?(method_name.to_sym) || super
+      end
+
+      def method_missing(method_name, *arguments)
+        return attributes.fetch(method_name.to_sym) if arguments.empty? && attributes.key?(method_name.to_sym)
+
+        super
+      end
+    end
+  end
+end

data/lib/coindcx/models/instrument.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Models
+    class Instrument < BaseModel
+    end
+  end
+end

data/lib/coindcx/models/market.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Models
+    class Market < BaseModel
+    end
+  end
+end

data/lib/coindcx/models/order.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Models
+    class Order < BaseModel
+    end
+  end
+end

data/lib/coindcx/models/trade.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module Models
+    class Trade < BaseModel
+    end
+  end
+end

data/lib/coindcx/rest/base_resource.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    class BaseResource
+      def initialize(http_client:)
+        @http_client = http_client
+      end
+
+      private
+
+      attr_reader :http_client
+
+      def get(path, params: {}, body: {}, auth: false, base: :api, bucket: nil)
+        http_client.get(path, params: params, body: body, auth: auth, base: base, bucket: bucket)
+      end
+
+      def post(path, body: {}, auth: false, base: :api, bucket: nil)
+        http_client.post(path, body: body, auth: auth, base: base, bucket: bucket)
+      end
+
+      def delete(path, body: {}, auth: false, base: :api, bucket: nil)
+        http_client.delete(path, body: body, auth: auth, base: base, bucket: bucket)
+      end
+
+      def build_model(model_class, attributes)
+        model_class.new(attributes)
+      end
+
+      def build_models(model_class, collection)
+        Array(collection).map { |attributes| model_class.new(attributes) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Funding
+      # Funding facade exposing CoinDCX funding-order APIs.
+      class Facade
+        def initialize(http_client:)
+          @http_client = http_client
+        end
+
+        def orders
+          @orders ||= Orders.new(http_client: @http_client)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Funding
+      # Funding endpoints for lend, settle, and order-history flows.
+      class Orders < BaseResource
+        # Fetches funding orders for the authenticated account.
+        # @param attributes [Hash] request filters accepted by CoinDCX
+        # @return [Hash] raw CoinDCX payload
+        def list(attributes = {})
+          post(
+            "/exchange/v1/funding/fetch_orders",
+            auth: true,
+            bucket: :funding_fetch_orders,
+            body: attributes
+          )
+        end
+
+        # Places a funding lend order.
+        # @param attributes [Hash] lend payload accepted by CoinDCX
+        # @return [Hash] raw CoinDCX payload
+        def lend(attributes)
+          post(
+            "/exchange/v1/funding/lend",
+            auth: true,
+            bucket: :funding_lend,
+            body: attributes
+          )
+        end
+
+        # Settles a funding order.
+        # @param attributes [Hash] settle payload accepted by CoinDCX
+        # @return [Hash] raw CoinDCX payload
+        def settle(attributes)
+          post(
+            "/exchange/v1/funding/settle",
+            auth: true,
+            bucket: :funding_settle,
+            body: attributes
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Futures
+      class Facade
+        def initialize(http_client:)
+          @http_client = http_client
+        end
+
+        def market_data
+          @market_data ||= MarketData.new(http_client: @http_client)
+        end
+
+        def orders
+          @orders ||= Orders.new(http_client: @http_client)
+        end
+
+        def positions
+          @positions ||= Positions.new(http_client: @http_client)
+        end
+
+        def wallets
+          @wallets ||= Wallets.new(http_client: @http_client)
+        end
+      end
+    end
+  end
+end

data/lib/coindcx/rest/futures/market_data.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Futures
+      class MarketData < BaseResource
+        VALID_ORDER_BOOK_DEPTHS = [10, 20, 50].freeze
+
+        def list_active_instruments(margin_currency_short_names: ["USDT"])
+          get(
+            "/exchange/v1/derivatives/futures/data/active_instruments",
+            params: { 'margin_currency_short_name[]': margin_currency_short_names }
+          )
+        end
+
+        def fetch_instrument(pair:, margin_currency_short_name:)
+          build_model(
+            Models::Instrument,
+            get(
+              "/exchange/v1/derivatives/futures/data/instrument",
+              params: { pair: pair, margin_currency_short_name: margin_currency_short_name },
+              body: {},
+              auth: true,
+              bucket: :futures_instrument_detail
+            )
+          )
+        end
+
+        def list_trades(pair:)
+          build_models(Models::Trade, get("/exchange/v1/derivatives/futures/data/trades", params: { pair: pair }))
+        end
+
+        def fetch_order_book(instrument:, depth: 50)
+          validate_order_book_depth!(depth)
+          get("/market_data/v3/orderbook/#{instrument}-futures/#{depth}", base: :public)
+        end
+
+        def list_candlesticks(pair:, from:, to:, resolution:)
+          get(
+            "/market_data/candlesticks",
+            base: :public,
+            params: { pair: pair, from: from, to: to, resolution: resolution, pcode: "f" }
+          )
+        end
+
+        def current_prices
+          get("/market_data/v3/current_prices/futures/rt", base: :public, bucket: :public_market_data)
+        end
+
+        def stats(pair:)
+          get(
+            "/api/v1/derivatives/futures/data/stats",
+            params: { pair: pair }
+          )
+        end
+
+        def conversions
+          get("/api/v1/derivatives/futures/data/conversions")
+        end
+
+        private
+
+        def validate_order_book_depth!(depth)
+          return depth if VALID_ORDER_BOOK_DEPTHS.include?(depth)
+
+          raise Errors::ValidationError, "futures order book depth must be one of #{VALID_ORDER_BOOK_DEPTHS.join(', ')}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Futures
+      class Orders < BaseResource
+        def list(attributes = {})
+          build_models(
+            Models::Order,
+            post("/exchange/v1/derivatives/futures/orders", auth: true, bucket: :futures_list_orders, body: attributes)
+          )
+        end
+
+        def list_trades(attributes = {})
+          build_models(
+            Models::Trade,
+            post("/exchange/v1/derivatives/futures/trades", auth: true, bucket: :futures_trades, body: attributes)
+          )
+        end
+
+        def create(order:)
+          validated_order = Contracts::OrderRequest.validate_futures_create!(order)
+          build_model(
+            Models::Order,
+            post(
+              "/exchange/v1/derivatives/futures/orders/create",
+              auth: true,
+              bucket: :futures_create_order,
+              body: { order: validated_order }
+            )
+          )
+        end
+
+        def cancel(attributes)
+          post("/exchange/v1/derivatives/futures/orders/cancel", auth: true, bucket: :futures_cancel_order, body: attributes)
+        end
+
+        def edit(attributes)
+          build_model(
+            Models::Order,
+            post("/exchange/v1/derivatives/futures/orders/edit", auth: true, bucket: :futures_edit_order, body: attributes)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/coindcx/rest/futures/positions.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Futures
+      class Positions < BaseResource
+        def list(attributes = {})
+          post("/exchange/v1/derivatives/futures/positions", auth: true, bucket: :futures_positions_list, body: attributes)
+        end
+
+        def update_leverage(attributes)
+          post(
+            "/exchange/v1/derivatives/futures/positions/update_leverage",
+            auth: true,
+            bucket: :futures_positions_update_leverage,
+            body: attributes
+          )
+        end
+
+        def add_margin(attributes)
+          post("/exchange/v1/derivatives/futures/positions/add_margin", auth: true, bucket: :futures_positions_add_margin, body: attributes)
+        end
+
+        def remove_margin(attributes)
+          post(
+            "/exchange/v1/derivatives/futures/positions/remove_margin",
+            auth: true,
+            bucket: :futures_positions_remove_margin,
+            body: attributes
+          )
+        end
+
+        def cancel_all_open_orders(attributes)
+          post(
+            "/exchange/v1/derivatives/futures/positions/cancel_all_open_orders",
+            auth: true,
+            bucket: :futures_positions_cancel_all_open_orders,
+            body: attributes
+          )
+        end
+
+        def cancel_all_open_orders_for_position(attributes)
+          post(
+            "/exchange/v1/derivatives/futures/positions/cancel_all_open_orders_for_position",
+            auth: true,
+            bucket: :futures_positions_cancel_all_open_orders_for_position,
+            body: attributes
+          )
+        end
+
+        def exit_position(attributes)
+          post("/exchange/v1/derivatives/futures/positions/exit", auth: true, bucket: :futures_positions_exit, body: attributes)
+        end
+
+        def create_take_profit_stop_loss(attributes)
+          post(
+            "/exchange/v1/derivatives/futures/positions/create_tpsl",
+            auth: true,
+            bucket: :futures_positions_create_tpsl,
+            body: attributes
+          )
+        end
+
+        def list_transactions(attributes = {})
+          post(
+            "/exchange/v1/derivatives/futures/positions/transactions",
+            auth: true,
+            bucket: :futures_positions_transactions,
+            body: attributes
+          )
+        end
+
+        def fetch_cross_margin_details(attributes = {})
+          get(
+            "/exchange/v1/derivatives/futures/positions/cross_margin_details",
+            body: attributes,
+            auth: true,
+            bucket: :futures_positions_cross_margin_details
+          )
+        end
+
+        def update_margin_type(attributes)
+          post(
+            "/exchange/v1/derivatives/futures/positions/margin_type",
+            auth: true,
+            bucket: :futures_positions_margin_type,
+            body: attributes
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Futures
+      class Wallets < BaseResource
+        def transfer(transfer_type:, amount:, currency_short_name:, timestamp: nil)
+          post(
+            "/exchange/v1/derivatives/futures/wallets/transfer",
+            auth: true,
+            bucket: :futures_wallet_transfer,
+            body: {
+              transfer_type: transfer_type,
+              amount: amount,
+              currency_short_name: currency_short_name,
+              timestamp: timestamp
+            }
+          )
+        end
+
+        def fetch_details(attributes = {})
+          get(
+            "/exchange/v1/derivatives/futures/wallets",
+            body: attributes,
+            auth: true,
+            bucket: :futures_wallet_details
+          )
+        end
+
+        def list_transactions(page: 1, size: 1000, timestamp: nil)
+          body = {}
+          body[:timestamp] = timestamp unless timestamp.nil?
+          get(
+            "/exchange/v1/derivatives/futures/wallets/transactions",
+            params: { page: page, size: size },
+            body: body,
+            auth: true,
+            bucket: :futures_wallet_transactions
+          )
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Margin
+      class Orders < BaseResource
+        def create(attributes)
+          validated_attributes = Contracts::OrderRequest.validate_margin_create!(attributes)
+          build_model(
+            Models::Order,
+            post("/exchange/v1/margin/create", auth: true, bucket: :margin_create_order, body: validated_attributes)
+          )
+        end
+
+        def list(attributes = {})
+          build_models(Models::Order, post("/exchange/v1/margin/fetch_orders", auth: true, bucket: :margin_list_orders, body: attributes))
+        end
+
+        def fetch(attributes)
+          build_model(Models::Order, post("/exchange/v1/margin/order", auth: true, bucket: :margin_fetch_order, body: attributes))
+        end
+
+        def cancel(attributes)
+          post("/exchange/v1/margin/cancel", auth: true, bucket: :margin_cancel_order, body: attributes)
+        end
+
+        def exit_order(attributes)
+          post("/exchange/v1/margin/exit", auth: true, bucket: :margin_exit_order, body: attributes)
+        end
+
+        def edit_target(attributes)
+          post("/exchange/v1/margin/edit_target", auth: true, bucket: :margin_edit_target, body: attributes)
+        end
+
+        def edit_stop_loss(attributes)
+          post("/exchange/v1/margin/edit_sl", auth: true, bucket: :margin_edit_stop_loss, body: attributes)
+        end
+
+        def edit_trailing_stop_loss(attributes)
+          post("/exchange/v1/margin/edit_trailing_sl", auth: true, bucket: :margin_edit_trailing_stop_loss, body: attributes)
+        end
+
+        def edit_target_order_price(attributes)
+          post("/exchange/v1/margin/edit_price_of_target_order", auth: true, bucket: :margin_edit_target_order_price, body: attributes)
+        end
+
+        def add_margin(attributes)
+          post("/exchange/v1/margin/add_margin", auth: true, bucket: :margin_add_margin, body: attributes)
+        end
+
+        def remove_margin(attributes)
+          post("/exchange/v1/margin/remove_margin", auth: true, bucket: :margin_remove_margin, body: attributes)
+        end
+      end
+    end
+  end
+end

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

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

data/lib/coindcx/rest/public/market_data.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module CoinDCX
+  module REST
+    module Public
+      class MarketData < BaseResource
+        def list_tickers
+          build_models(Models::Market, get("/exchange/ticker", bucket: :public_ticker))
+        end
+
+        def list_markets
+          get("/exchange/v1/markets", bucket: :public_market_data)
+        end
+
+        def list_market_details
+          build_models(Models::Market, get("/exchange/v1/markets_details", bucket: :public_market_data))
+        end
+
+        def list_trades(pair:, limit: nil)
+          build_models(
+            Models::Trade,
+            get(
+              "/market_data/trade_history",
+              base: :public,
+              bucket: :public_trades,
+              params: { pair: pair, limit: limit }
+            )
+          )
+        end
+
+        def fetch_order_book(pair:)
+          get("/market_data/orderbook", base: :public, bucket: :public_order_book, params: { pair: pair })
+        end
+
+        def list_candles(pair:, interval:, start_time: nil, end_time: nil, limit: nil)
+          get(
+            "/market_data/candles",
+            base: :public,
+            bucket: :public_candles,
+            params: {
+              pair: pair,
+              interval: interval,
+              startTime: start_time,
+              endTime: end_time,
+              limit: limit
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

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