delta_exchange 0.1.2

data/lib/delta_exchange/resources/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Resources
+    class Base
+      attr_reader :client
+
+      def initialize(client = nil)
+        raise ArgumentError, "client must be provided" unless client
+
+        @client = client
+      end
+
+      protected
+
+      def get(path, params = {}, authenticate: true)
+        client.get(path, params, authenticate: authenticate)
+      end
+
+      def post(path, payload = {}, authenticate: true)
+        client.post(path, payload, authenticate: authenticate)
+      end
+
+      def put(path, payload = {}, authenticate: true)
+        client.put(path, payload, authenticate: authenticate)
+      end
+
+      def patch(path, payload = {}, authenticate: true)
+        client.patch(path, payload, authenticate: authenticate)
+      end
+
+      def delete(path, payload = {}, params = {}, authenticate: true)
+        client.delete(path, payload, params, authenticate: authenticate)
+      end
+    end
+  end
+end

data/lib/delta_exchange/resources/fills.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Resources
+    class Fills < Base
+      def all(params = {})
+        get("/v2/fills", params)
+      end
+
+      def history_csv(params = {})
+        get("/v2/fills/history/download/csv", params)
+      end
+    end
+  end
+end

data/lib/delta_exchange/resources/heartbeat.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Resources
+    # Session keepalive endpoints; confirm paths against your Delta environment (not in public REST slate list).
+    class Heartbeat < Base
+      def create(payload)
+        post("/v2/heartbeats", payload)
+      end
+
+      def ack(payload)
+        put("/v2/heartbeats/ack", payload)
+      end
+
+      def all(params = {})
+        get("/v2/heartbeats", params)
+      end
+    end
+  end
+end

data/lib/delta_exchange/resources/indices.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Resources
+    class Indices < Base
+      def all
+        get("/v2/indices", {}, authenticate: false)
+      end
+    end
+  end
+end

data/lib/delta_exchange/resources/market_data.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module DeltaExchange
+  module Resources
+    class MarketData < Base
+      def l2_orderbook(symbol, params = {})
+        sym = CGI.escape(symbol.to_s)
+        get("/v2/l2orderbook/#{sym}", params, authenticate: false)
+      end
+
+      def trades(symbol, params = {})
+        sym = CGI.escape(symbol.to_s)
+        get("/v2/trades/#{sym}", params, authenticate: false)
+      end
+
+      def candles(params = {})
+        get("/v2/history/candles", params, authenticate: false)
+      end
+
+      def sparklines(params = {})
+        get("/v2/history/sparklines", params, authenticate: false)
+      end
+
+      def stats(params = {})
+        get("/v2/stats", params, authenticate: false)
+      end
+
+      def mark_price(symbol)
+        sym = CGI.escape(symbol.to_s)
+        get("/v2/mark_price/#{sym}", {}, authenticate: false)
+      end
+
+      def insurance_fund
+        get("/v2/insurance_fund", {}, authenticate: false)
+      end
+
+      def option_greeks(params = {})
+        get("/v2/option_greeks", params, authenticate: false)
+      end
+
+      def funding_rates(params = {})
+        get("/v2/history/funding_rates", params, authenticate: false)
+      end
+
+      def open_interest(params = {})
+        get("/v2/history/open_interest", params, authenticate: false)
+      end
+
+      def volume_stats(params = {})
+        get("/v2/stats/volume", params, authenticate: false)
+      end
+    end
+  end
+end

data/lib/delta_exchange/resources/orders.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module DeltaExchange
+  module Resources
+    class Orders < Base
+      def all(params = {})
+        get("/v2/orders", params)
+      end
+
+      def find(id)
+        get("/v2/orders/#{id}")
+      end
+
+      def find_by_client_order_id(client_order_id)
+        oid = CGI.escape(client_order_id.to_s)
+        get("/v2/orders/client_order_id/#{oid}")
+      end
+
+      def history(params = {})
+        get("/v2/orders/history", params)
+      end
+
+      def create(payload)
+        validate_order!(payload)
+        post("/v2/orders", payload)
+      end
+
+      def create_bracket(payload)
+        # Bracket orders have similar but slightly different fields
+        post("/v2/orders/bracket", payload)
+      end
+
+      def create_batch(payload)
+        post("/v2/orders/batch", payload)
+      end
+
+      def update(payload)
+        validate_order!(payload)
+        put("/v2/orders", payload)
+      end
+
+      private
+
+      def validate_order!(payload)
+        result = Contracts::OrderContract.new.call(payload)
+        return if result.success?
+
+        raise ValidationError, "Invalid order parameters: #{result.errors.to_h}"
+      end
+
+      # @param payload [Hash] payload containing product_id and id (or client_order_id)
+      # @example client.orders.cancel(product_id: 1, id: 123)
+      def cancel(payload)
+        delete("/v2/orders", payload)
+      end
+
+      def cancel_all(params = {})
+        delete("/v2/orders/all", {}, params)
+      end
+
+      def cancel_batch(payload)
+        delete("/v2/orders/batch", payload)
+      end
+
+      def cancel_after(payload)
+        post("/v2/orders/cancel_after", payload)
+      end
+
+      def set_leverage(payload)
+        post("/v2/orders/leverage", payload)
+      end
+    end
+  end
+end

data/lib/delta_exchange/resources/positions.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Resources
+    class Positions < Base
+      def all(params = {})
+        get("/v2/positions", params)
+      end
+
+      def margined(params = {})
+        get("/v2/positions/margined", params)
+      end
+
+      def find(product_id)
+        get("/v2/positions/#{product_id}")
+      end
+
+      def adjust_margin(payload)
+        validate_position!(payload)
+        post("/v2/positions/change_margin", payload)
+      end
+
+      def change_leverage(payload)
+        validate_position!(payload)
+        post("/v2/positions/change_leverage", payload)
+      end
+
+      private
+
+      def validate_position!(payload)
+        result = Contracts::PositionContract.new.call(payload)
+        return if result.success?
+
+        raise ValidationError, "Invalid position parameters: #{result.errors.to_h}"
+      end
+
+      def auto_topup(payload)
+        put("/v2/positions/auto_topup", payload)
+      end
+
+      def close_all(payload = {})
+        post("/v2/positions/close_all", payload)
+      end
+      public :auto_topup, :close_all
+    end
+  end
+end

data/lib/delta_exchange/resources/products.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module DeltaExchange
+  module Resources
+    class Products < Base
+      def all(params = {})
+        get("/v2/products", params, authenticate: false)
+      end
+
+      def find(symbol)
+        sym = CGI.escape(symbol.to_s)
+        get("/v2/products/#{sym}", {}, authenticate: false)
+      end
+
+      def tickers(params = {})
+        get("/v2/tickers", params, authenticate: false)
+      end
+
+      def ticker(symbol)
+        sym = CGI.escape(symbol.to_s)
+        get("/v2/tickers/#{sym}", {}, authenticate: false)
+      end
+
+      def settlement_prices(params = {})
+        get("/v2/settlement_prices", params, authenticate: false)
+      end
+
+      def leverage(product_id)
+        get("/v2/products/#{product_id}/orders/leverage")
+      end
+
+      def set_leverage(product_id, payload)
+        post("/v2/products/#{product_id}/orders/leverage", payload)
+      end
+    end
+  end
+end

data/lib/delta_exchange/resources/wallet.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Resources
+    class Wallet < Base
+      def balances
+        get("/v2/wallet/balances")
+      end
+
+      def transactions(params = {})
+        get("/v2/wallet/transactions", params)
+      end
+
+      def transactions_download(params = {})
+        get("/v2/wallet/transactions/download", params)
+      end
+
+      def subaccount_transfer_history(params = {})
+        get("/v2/wallets/sub_accounts_transfer_history", params)
+      end
+
+      def subaccount_transfer(payload)
+        validate_transfer!(payload)
+        post("/v2/wallets/sub_account_balance_transfer", payload)
+      end
+
+      private
+
+      def validate_transfer!(payload)
+        result = Contracts::WalletTransferContract.new.call(payload)
+        return if result.success?
+
+        raise ValidationError, "Invalid transfer parameters: #{result.errors.to_h}"
+      end
+
+      def withdrawals(params = {})
+        get("/v2/wallet/withdrawals", params)
+      end
+
+      def deposits(params = {})
+        get("/v2/wallet/deposits", params)
+      end
+    end
+  end
+end

data/lib/delta_exchange/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  VERSION = "0.1.2"
+end

data/lib/delta_exchange/websocket/client.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Websocket
+    class Client
+      def initialize(api_key: nil, api_secret: nil, testnet: nil)
+        @api_key = api_key || DeltaExchange.configuration.api_key
+        @api_secret = api_secret || DeltaExchange.configuration.api_secret
+        use_testnet = testnet.nil? ? DeltaExchange.configuration.testnet : testnet
+        @url = use_testnet ? Constants::Urls::WEBSOCKET_TESTNET : Constants::Urls::WEBSOCKET_PRODUCTION
+        @callbacks = Hash.new { |h, k| h[k] = [] }
+
+        @connection = Connection.new(@url, api_key: @api_key, api_secret: @api_secret)
+        @connection.on_open = ->(event) { emit(:open, event) }
+        @connection.on_message = ->(msg) { emit(:message, msg) }
+        @connection.on_close = ->(event) { emit(:close, event) }
+        @connection.on_error = ->(event) { emit(:error, event) }
+      end
+
+      def on(event, &block)
+        @callbacks[event] << block
+        self
+      end
+
+      def connect!
+        @connection.start
+        self
+      end
+
+      def subscribe(channels)
+        @connection.send_json({
+                                type: "subscribe",
+                                payload: { channels: channels }
+                              })
+      end
+
+      def unsubscribe(channels)
+        @connection.send_json({
+                                type: "unsubscribe",
+                                payload: { channels: channels }
+                              })
+      end
+
+      def close
+        @connection.stop
+      end
+
+      private
+
+      def emit(event, data)
+        @callbacks[event].each { |cb| cb.call(data) }
+      end
+    end
+  end
+end

data/lib/delta_exchange/websocket/connection.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "faye/websocket"
+require "eventmachine"
+require "json"
+
+module DeltaExchange
+  module Websocket
+    class Connection
+      RECONNECT_DELAY = 5
+      attr_accessor :on_open, :on_message, :on_close, :on_error
+
+      def initialize(url, api_key: nil, api_secret: nil)
+        @url = url
+        @api_key = api_key
+        @api_secret = api_secret
+        @ws = nil
+        @stop = false
+      end
+
+      def start
+        @thr = Thread.new { loop_run }
+      end
+
+      def stop
+        @stop = true
+        @ws&.close
+        EM.stop if EM.reactor_running?
+      end
+
+      def send_json(data)
+        @ws&.send(data.to_json)
+      end
+
+      def authenticate!
+        timestamp = Time.now.utc.to_i
+        path = "/v2/websocket"
+        method = "GET"
+        signature = Auth.sign(method, timestamp.to_s, path, "", "", @api_secret)
+
+        send_json({
+                    type: "auth",
+                    api_key: @api_key,
+                    timestamp: timestamp,
+                    signature: signature
+                  })
+      end
+
+      private
+
+      def loop_run
+        until @stop
+          begin
+            if EM.reactor_running?
+              setup_ws
+              wait_for_connection_close
+            else
+              EM.run { setup_ws }
+            end
+          rescue StandardError => e
+            DeltaExchange.logger.error("[DeltaExchange::WS] Loop Error: #{e.message}")
+          end
+          handle_reconnect_delay
+        end
+      end
+
+      def wait_for_connection_close
+        # Instead of a tight loop, we sleep for longer intervals while connected
+        # or we could use a ConditionVariable if we wanted to be more reactive.
+        # But even a longer sleep is better than the original "busy-wait".
+        # The WebSocket's on :close will resume the loop if EM stops.
+        sleep 1 while @ws&.ready_state == 1 && !@stop
+      end
+
+      def handle_reconnect_delay
+        return if @stop
+
+        delay = DeltaExchange.configuration.websocket_reconnect_delay
+        sleep delay
+      end
+
+      def setup_ws
+        headers = { "User-Agent" => DeltaExchange.configuration.user_agent }
+        @ws = Faye::WebSocket::Client.new(@url, nil, { headers: headers })
+
+        @ws.on :open do |event|
+          DeltaExchange.logger.info("[DeltaExchange::WS] Connected")
+          authenticate! if @api_key && @api_secret
+          @on_open&.call(event)
+        end
+
+        @ws.on :message do |event|
+          data = begin
+            JSON.parse(event.data)
+          rescue StandardError
+            event.data
+          end
+          @on_message&.call(data)
+        end
+
+        @ws.on :close do |event|
+          DeltaExchange.logger.warn("[DeltaExchange::WS] Closed: #{event.code} #{event.reason}")
+          @on_close&.call(event)
+          EM.stop unless EM.reactor_running? # Only stop if we started it
+        end
+
+        @ws.on :error do |event|
+          DeltaExchange.logger.error("[DeltaExchange::WS] Error: #{event.message}")
+          @on_error&.call(event)
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/object/blank"
+require "logger"
+
+module DeltaExchange
+  loader = Zeitwerk::Loader.for_gem
+  loader.setup
+
+  require_relative "delta_exchange/error"
+
+  class << self
+    attr_writer :configuration, :logger
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+      self.logger ||= Logger.new($stdout, level: Logger::INFO)
+    end
+
+    def logger
+      @logger ||= Logger.new($stdout, level: Logger::INFO)
+    end
+
+    def ensure_configuration!
+      self.configuration ||= Configuration.new
+    end
+
+    def reset!
+      @configuration = Configuration.new
+    end
+  end
+end

data/sig/delta_exchange.rbs

@@ -0,0 +1,4 @@
+module DeltaExchange
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end