delta_exchange 0.1.2

data/lib/delta_exchange/contracts/order_contract.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+
+module DeltaExchange
+  module Contracts
+    class OrderContract < Dry::Validation::Contract
+      params do
+        required(:product_id).filled(:integer)
+        required(:size).filled(:integer)
+        required(:side).filled(:string, included_in?: DeltaExchange::Constants::Side::ALL)
+        required(:order_type).filled(:string, included_in?: DeltaExchange::Constants::OrderType::ALL)
+        optional(:limit_price).maybe(:string)
+        optional(:stop_price).maybe(:string)
+        optional(:client_order_id).maybe(:string)
+        optional(:time_in_force).maybe(:string, included_in?: DeltaExchange::Constants::TimeInForce::ALL)
+      end
+
+      rule(:limit_price) do
+        key.failure("is required for limit orders") if values[:order_type] == DeltaExchange::Constants::OrderType::LIMIT && values[:limit_price].nil?
+      end
+    end
+  end
+end

data/lib/delta_exchange/contracts/position_contract.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+
+module DeltaExchange
+  module Contracts
+    class PositionContract < Dry::Validation::Contract
+      params do
+        required(:product_id).filled(:integer)
+        optional(:amount).maybe(:string)
+        optional(:type).maybe(:string, included_in?: %w[add remove])
+        optional(:leverage).maybe(:string)
+        optional(:auto_topup).maybe(:bool)
+      end
+
+      rule(:amount) do
+        key.failure("is required when type is present") if values[:type] && values[:amount].nil?
+      end
+    end
+  end
+end

data/lib/delta_exchange/contracts/wallet_transfer_contract.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+
+module DeltaExchange
+  module Contracts
+    class WalletTransferContract < Dry::Validation::Contract
+      params do
+        required(:asset_id).filled(:integer)
+        required(:amount).filled(:string)
+        required(:sub_account_id).filled(:integer)
+        required(:method).filled(:string, included_in?: %w[deposit withdraw])
+      end
+    end
+  end
+end

data/lib/delta_exchange/core/base_model.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+
+module DeltaExchange
+  module Core
+    class BaseModel
+      include Helpers::AttributeHelper
+      include Helpers::ValidationHelper
+
+      attr_reader :raw_attributes, :errors
+
+      def initialize(attributes = {}, skip_validation: false)
+        @raw_attributes = normalize_keys(attributes)
+        @errors = {}
+        validate! unless skip_validation
+        assign_attributes
+      end
+
+      # Expose raw_attributes as attributes for backward compatibility or clarity.
+      def attributes
+        @raw_attributes
+      end
+
+      class << self
+        attr_reader :defined_attributes
+
+        def attributes(*args)
+          @defined_attributes ||= Set.new
+          @defined_attributes.merge(args.map(&:to_s))
+          args.each do |attr|
+            define_method(attr) { @raw_attributes[attr] }
+          end
+          @defined_attributes.to_a
+        end
+
+        def build_from_response(response)
+          payload = response.is_a?(Hash) && response.key?(:result) ? response[:result] : response
+          return payload.map { |r| new(r, skip_validation: true) } if payload.is_a?(Array)
+
+          new(payload, skip_validation: true)
+        end
+      end
+
+      private
+
+      def assign_attributes
+        self.class.defined_attributes&.each do |attr|
+          instance_variable_set("@#{attr}", @raw_attributes[attr])
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/core/error_handler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Core
+    class ErrorHandler
+      def self.handle(error)
+        case error
+        when Dry::Validation::Result
+          raise Error, "Validation failed: #{error.errors.to_h}"
+        else
+          raise Error, error.message
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/error.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  class Error < StandardError; end
+
+  class ApiError < Error
+    attr_reader :code, :response_body
+
+    def initialize(message = nil, code: nil, response_body: nil)
+      super(message)
+      @code = code
+      @response_body = response_body
+    end
+
+    def self.from_hash(hash, status: nil)
+      msg = hash[:error] || hash[:message] || "API error"
+      new(msg, code: status || hash[:code], response_body: hash)
+    end
+  end
+
+  class AuthenticationError < ApiError; end
+  class InvalidAuthenticationError < AuthenticationError; end
+
+  class RateLimitError < ApiError
+    attr_reader :retry_after_seconds
+
+    def initialize(message = nil, retry_after_seconds: nil, **)
+      super(message, **)
+      @retry_after_seconds = retry_after_seconds
+    end
+  end
+
+  class ValidationError < Error; end
+  class NotFoundError < ApiError; end
+  class InternalServerError < ApiError; end
+  class InputExceptionError < ApiError; end
+end

data/lib/delta_exchange/helpers/attribute_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/hash/keys"
+
+module DeltaExchange
+  module Helpers
+    module AttributeHelper
+      def camelize_keys(hash)
+        hash.transform_keys { |key| key.to_s.camelize(:lower) }
+      end
+
+      def snake_case_keys(hash)
+        hash.transform_keys { |key| key.to_s.underscore.to_sym }
+      end
+
+      def normalize_keys(hash)
+        hash.transform_keys { |k| k.to_s.underscore }.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/delta_exchange/helpers/validation_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Helpers
+    module ValidationHelper
+      def validate_params!(params, contract_class)
+        contract = contract_class.new
+        result = contract.call(params)
+
+        raise ValidationError, "Invalid parameters: #{result.errors.to_h}" unless result.success?
+
+        result.to_h
+      end
+
+      def validate!
+        contract_class = self.class.respond_to?(:validation_contract) ? self.class.validation_contract : nil
+        return unless contract_class
+
+        contract = contract_class.new
+        payload = instance_variable_get(:@raw_attributes) || instance_variable_get(:@attributes)
+        result = contract.call(payload)
+
+        return if result.success?
+
+        @errors = result.errors.to_h
+        raise ValidationError, "Invalid parameters: #{@errors.inspect}"
+      end
+
+      def valid?
+        @errors.nil? || @errors.empty?
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/asset.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class Asset < Core::BaseModel
+      attributes :id, :symbol, :precision, :is_deposit_enabled, :is_withdrawal_enabled, :network
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.assets
+        end
+
+        def all
+          build_from_response(resource.all)
+        end
+
+        def find(id_or_symbol)
+          build_from_response(resource.find(id_or_symbol))
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/fee_tier.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class FeeTier < Core::BaseModel
+      attributes :tier, :maker_fee, :taker_fee, :volume_30d, :min_volume
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.account
+        end
+
+        def current
+          build_from_response(resource.fee_tiers)
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/fill.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class Fill < Core::BaseModel
+      attributes :id, :order_id, :product_id, :symbol, :size, :price, :side,
+                 :role, :fee, :fee_asset_id, :margin, :timestamp
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.fills
+        end
+
+        def all(params = {})
+          build_from_response(resource.all(params))
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/funding_rate.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class FundingRate < Core::BaseModel
+      attributes :product_id, :funding_rate, :funding_rate_daily, :funding_time
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.market_data
+        end
+
+        def history(product_id, params = {})
+          build_from_response(resource.funding_rates(params.merge(product_id: product_id)))
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/index.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class Index < Core::BaseModel
+      attributes :id, :symbol, :description, :constituent_exchanges, :price_method, :is_composite
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.indices
+        end
+
+        def all
+          build_from_response(resource.all)
+        end
+
+        def find(symbol)
+          build_from_response(resource.find(symbol))
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/open_interest.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class OpenInterest < Core::BaseModel
+      attributes :product_id, :open_interest, :time
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.market_data
+        end
+
+        def history(product_id, params = {})
+          build_from_response(resource.open_interest(params.merge(product_id: product_id)))
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/order.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class Order < Core::BaseModel
+      attributes :id, :client_order_id, :product_id, :side, :order_type, :limit_price,
+                 :stop_price, :size, :filled_size, :unfilled_size, :average_fill_price,
+                 :status, :created_at, :updated_at
+
+      class << self
+        def resource
+          # Lazily instantiate a client and reuse its Orders resource.
+          @resource ||= DeltaExchange::Client.new.orders
+        end
+
+        def all(params = {})
+          build_from_response(resource.all(params))
+        end
+
+        def find(id)
+          build_from_response(resource.find(id))
+        end
+
+        def create(payload)
+          build_from_response(resource.create(payload))
+        end
+      end
+
+      def cancel
+        self.class.resource.cancel(product_id: product_id, id: id)
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/position.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class Position < Core::BaseModel
+      attributes :product_id, :size, :side, :entry_price, :mark_price, :liquidation_price,
+                 :margin, :unrealized_pnl, :realized_pnl, :commission, :auto_topup
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.positions
+        end
+
+        def all(params = {})
+          build_from_response(resource.margined(params))
+        end
+
+        def find(product_id)
+          build_from_response(resource.find(product_id))
+        end
+
+        def close_all
+          resource.close_all
+        end
+      end
+
+      def adjust_margin(amount, type: "add")
+        self.class.resource.adjust_margin(
+          product_id: product_id,
+          amount: amount,
+          type: type
+        )
+      end
+
+      def set_auto_topup(enabled)
+        self.class.resource.set_auto_topup(
+          product_id: product_id,
+          auto_topup: enabled
+        )
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/product.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class Product < Core::BaseModel
+      attributes :id, :symbol, :description, :contract_type, :contract_value, :lot_size, :tick_size,
+                 :underlying_asset_symbol, :quoting_asset_symbol, :settlement_asset_symbol,
+                 :state, :funding_method, :impact_size, :initial_margin, :maintenance_margin,
+                 :strike_price, :expiration_time
+
+      # Delta documents per-contract sizing under product `contract_value` (and may add `lot_size`).
+      # Order `size` is in contracts; multiply by this for notional / linear PnL in the quoting currency.
+      def contract_lot_multiplier
+        raw = lot_size.presence || contract_value
+        return BigDecimal("0") if raw.blank?
+
+        BigDecimal(raw.to_s)
+      end
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.products
+        end
+
+        def all(params = {})
+          build_from_response(resource.all(params))
+        end
+
+        def find(symbol)
+          build_from_response(resource.find(symbol))
+        end
+      end
+
+      def leverage
+        self.class.resource.leverage(id)
+      end
+
+      def set_leverage(new_leverage)
+        self.class.resource.set_leverage(id, { leverage: new_leverage })
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/profile.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class Profile < Core::BaseModel
+      attributes :id, :email, :first_name, :last_name, :country, :kyc_status,
+                 :referral_code, :is_subaccount, :margin_mode, :api_trading_enabled
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.account
+        end
+
+        def fetch
+          build_from_response(resource.profile)
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/ticker.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class Ticker < Core::BaseModel
+      attributes :symbol, :contract_type, :mark_price, :spot_price, :strike_price,
+                 :open, :high, :low, :close, :volume, :turnover, :turnover_usd,
+                 :size, :quotes, :price_band, :greeks, :funding_rate, :oi, :oi_value,
+                 :oi_value_usd, :ltp_change_24h, :mark_change_24h
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.products
+        end
+
+        def all(params = {})
+          build_from_response(resource.tickers(params))
+        end
+
+        def find(symbol)
+          build_from_response(resource.ticker(symbol))
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/trading_preferences.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class TradingPreferences < Core::BaseModel
+      attributes :user_id, :vip_level, :volume_30d, :referral_discount_factor,
+                 :default_auto_topup, :email_preferences, :notification_preferences,
+                 :deto_balance, :deto_for_commission, :cancel_on_disconnect
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.account
+        end
+
+        def fetch
+          build_from_response(resource.trading_preferences)
+        end
+      end
+
+      def update(cancel_on_disconnect: true)
+        self.class.resource.update_trading_preferences(
+          cancel_on_disconnect: cancel_on_disconnect
+        )
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/wallet_balance.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class WalletBalance < Core::BaseModel
+      attributes :asset_id, :asset_symbol, :balance, :available_balance, :pending_withdrawal, :commission
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.wallet
+        end
+
+        def all
+          build_from_response(resource.balances)
+        end
+
+        def find_by_asset(symbol)
+          all.find { |b| b.asset_symbol == symbol.to_s.upcase }
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/models/wallet_transaction.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Models
+    class WalletTransaction < Core::BaseModel
+      attributes :id, :asset_id, :amount, :type, :status, :timestamp,
+                 :tx_hash, :network, :address
+
+      class << self
+        def resource
+          @resource ||= DeltaExchange::Client.new.wallet
+        end
+
+        def all(params = {})
+          build_from_response(resource.transactions(params))
+        end
+      end
+    end
+  end
+end

data/lib/delta_exchange/resources/account.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DeltaExchange
+  module Resources
+    class Account < Base
+      def profile
+        get("/v2/profile")
+      end
+
+      def trading_preferences
+        get("/v2/users/trading_preferences")
+      end
+
+      def update_trading_preferences(payload)
+        put("/v2/users/trading_preferences", payload)
+      end
+
+      def change_margin_mode(payload)
+        put("/v2/users/margin_mode", payload)
+      end
+
+      def subaccounts
+        get("/v2/sub_accounts")
+      end
+
+      def update_mmp(payload)
+        put("/v2/users/update_mmp", payload)
+      end
+
+      def reset_mmp(payload)
+        put("/v2/users/reset_mmp", payload)
+      end
+
+      def fee_tiers
+        get("/v2/users/fee_tiers")
+      end
+
+      def referrals
+        get("/v2/users/referrals")
+      end
+
+      # @deprecated Use {#trading_preferences} - Delta v2 uses +/v2/users/trading_preferences+.
+      def preferences
+        trading_preferences
+      end
+
+      # @deprecated Use {#update_trading_preferences}
+      def update_preferences(payload)
+        update_trading_preferences(payload)
+      end
+    end
+  end
+end

data/lib/delta_exchange/resources/assets.rb

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