DhanHQ 3.0.1 → 3.2.0

data/lib/DhanHQ/skills/builtin/square_off_position.rb

@@ -14,6 +14,10 @@ module DhanHQ
       #   )
       #
       class SquareOffPosition < Base
+        risk "destructive_write"
+        scope "orders:write"
+        description "Exit a specific open position by symbol and exchange segment."
+
         param :symbol, type: :string, required: true
         param :exchange_segment, type: :string, required: true
 
@@ -23,17 +27,15 @@ module DhanHQ
         def find_position(ctx)
           positions = DhanHQ::Models::Position.all
           target = positions.find do |p|
-            seg = p[:exchange_segment] || p["exchange_segment"]
-            sym = p[:trading_symbol] || p["tradingSymbol"] || p[:symbol] || p["symbol"]
-            seg.to_s == ctx[:exchange_segment].to_s && sym.to_s.upcase == ctx[:symbol].to_s.upcase
+            p.exchange_segment.to_s == ctx[:exchange_segment].to_s && p.trading_symbol.to_s.upcase == ctx[:symbol].to_s.upcase
           end
 
           raise ArgumentError, "No open position found for #{ctx[:symbol]} on #{ctx[:exchange_segment]}" unless target
 
           ctx[:position] = target
-          ctx[:security_id] = target[:security_id] || target["securityId"]
-          ctx[:trading_symbol] = target[:trading_symbol] || target["tradingSymbol"]
-          ctx[:net_quantity] = (target[:net_quantity] || target["netQuantity"] || target.net_quantity).to_i
+          ctx[:security_id] = target.security_id
+          ctx[:trading_symbol] = target.trading_symbol
+          ctx[:net_quantity] = target.net_qty.to_i
           ctx
         end
 

data/lib/DhanHQ/skills/builtin/straddle.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Skills
+    module Builtin
+      # Skill to build a long straddle (buy ATM call + buy ATM put).
+      #
+      # Steps: find instrument → spot price → option chain →
+      # select ATM strikes → build intent.
+      #
+      # @example
+      #   result = DhanHQ::Skills::Registry.call("straddle",
+      #     symbol: "NIFTY",
+      #     expiry: "2026-01-30",
+      #     quantity: 25
+      #   )
+      #
+      class Straddle < Base
+        risk "trade_adjacent_read"
+        scope "orders:read"
+        description "Build a long straddle: buy ATM call + buy ATM put at the same strike."
+
+        param :symbol, type: :string, required: true
+        param :expiry, type: :string, required: true
+        param :quantity, type: :integer, default: 25
+        param :stop_loss, type: :number, default: 300
+        param :target, type: :number, default: 600
+
+        step :find_instrument, priority: 1
+        step :get_spot_price, priority: 2
+        step :get_option_chain, priority: 3
+        step :select_atm_strikes, priority: 4
+        step :build_intent, priority: 5
+
+        def find_instrument(ctx)
+          ctx[:instrument] = DhanHQ::Models::Instrument.find(DhanHQ::Constants::ExchangeSegment::IDX_I, ctx[:symbol])
+          ctx
+        end
+
+        def get_spot_price(ctx)
+          ctx[:spot_price] = ctx[:instrument].ltp
+          ctx
+        end
+
+        def get_option_chain(ctx)
+          ctx[:chain] = ctx[:instrument].option_chain(expiry: ctx[:expiry])
+          ctx
+        end
+
+        def select_atm_strikes(ctx)
+          spot = ctx[:spot_price].to_f
+          chain = ctx[:chain]
+
+          atm = nearest_strike(chain, spot)
+          raise ArgumentError, "Could not find ATM strike" unless atm
+
+          ctx[:atm_strike] = atm[:strike]
+          ctx[:ce_security_id] = leg_security_id(atm, "CE")
+          ctx[:pe_security_id] = leg_security_id(atm, "PE")
+          ctx[:ce_premium] = leg_premium(atm, "CE")
+          ctx[:pe_premium] = leg_premium(atm, "PE")
+          ctx[:total_premium] = ctx[:ce_premium].to_f + ctx[:pe_premium].to_f
+          ctx
+        end
+
+        def build_intent(ctx)
+          ctx[:intent] = {
+            trade_type: "STRADDLE",
+            symbol: ctx[:symbol],
+            expiry: ctx[:expiry],
+            quantity: ctx[:quantity],
+            legs: [
+              { action: DhanHQ::Constants::TransactionType::BUY, option_type: "CE", strike: ctx[:atm_strike], security_id: ctx[:ce_security_id], premium: ctx[:ce_premium] },
+              { action: DhanHQ::Constants::TransactionType::BUY, option_type: "PE", strike: ctx[:atm_strike], security_id: ctx[:pe_security_id], premium: ctx[:pe_premium] }
+            ],
+            total_premium: ctx[:total_premium],
+            break_even_upside: ctx[:atm_strike].to_f + ctx[:total_premium],
+            break_even_downside: ctx[:atm_strike].to_f - ctx[:total_premium],
+            stop_loss: ctx[:stop_loss],
+            target: ctx[:target],
+            note: "Long straddle prepared. Await human confirmation."
+          }
+          ctx
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/skills/builtin/strangle.rb

@@ -16,6 +16,10 @@ module DhanHQ
       #   )
       #
       class Strangle < Base
+        risk "trade_adjacent_read"
+        scope "orders:read"
+        description "Build a long strangle: buy OTM call + buy OTM put around the current spot price."
+
         param :symbol, type: :string, required: true
         param :expiry, type: :string, required: true
         param :quantity, type: :integer, default: 50
@@ -35,8 +39,7 @@ module DhanHQ
         end
 
         def get_spot_price(ctx)
-          ltp = ctx[:instrument].ltp
-          ctx[:spot_price] = ltp[:ltp] || ltp["ltp"]
+          ctx[:spot_price] = ctx[:instrument].ltp
           ctx
         end
 
@@ -50,24 +53,21 @@ module DhanHQ
           chain = ctx[:chain]
           offset = ctx[:offset_pct] / 100.0
 
-          ce_options = chain.select { |o| (o[:option_type] || o["optionType"]) == "CE" }
-          pe_options = chain.select { |o| (o[:option_type] || o["optionType"]) == "PE" }
-
           ce_strike = spot * (1 + offset)
           pe_strike = spot * (1 - offset)
 
-          long_ce = ce_options.min_by { |o| ((o[:strike] || o["strike"]).to_f - ce_strike).abs }
-          long_pe = pe_options.min_by { |o| ((o[:strike] || o["strike"]).to_f - pe_strike).abs }
+          long_ce = nearest_strike(chain, ce_strike)
+          long_pe = nearest_strike(chain, pe_strike)
 
           raise ArgumentError, "Could not find suitable CE strike near #{ce_strike}" unless long_ce
           raise ArgumentError, "Could not find suitable PE strike near #{pe_strike}" unless long_pe
 
-          ctx[:ce_strike] = long_ce[:strike] || long_ce["strike"]
-          ctx[:pe_strike] = long_pe[:strike] || long_pe["strike"]
-          ctx[:ce_security_id] = long_ce[:security_id] || long_ce["securityId"]
-          ctx[:pe_security_id] = long_pe[:security_id] || long_pe["securityId"]
-          ctx[:ce_premium] = long_ce[:last_price] || long_ce["lastPrice"] || long_ce[:ltp]
-          ctx[:pe_premium] = long_pe[:last_price] || long_pe["lastPrice"] || long_pe[:ltp]
+          ctx[:ce_strike] = long_ce[:strike]
+          ctx[:pe_strike] = long_pe[:strike]
+          ctx[:ce_security_id] = leg_security_id(long_ce, "CE")
+          ctx[:pe_security_id] = leg_security_id(long_pe, "PE")
+          ctx[:ce_premium] = leg_premium(long_ce, "CE")
+          ctx[:pe_premium] = leg_premium(long_pe, "PE")
           ctx
         end
 

data/lib/DhanHQ/version.rb

@@ -2,5 +2,5 @@
 
 module DhanHQ
   # Semantic version of the DhanHQ client gem.
-  VERSION = "3.0.1"
+  VERSION = "3.2.0"
 end

data/lib/DhanHQ/write_paths.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  # Classifies request paths by whether they change account state.
+  #
+  # The distinction that matters on this API is **mutating vs read-only**, not GET vs
+  # POST: the option chain, market feed, historical charts and the margin calculators
+  # are all read-only POSTs. Both dry-run simulation and non-idempotent retry gating
+  # need that answer, so it lives here rather than in {DhanHQ::Client}.
+  module WritePaths
+    # HTTP methods that can change server-side state.
+    WRITE_METHODS = %i[post put patch delete].freeze
+
+    # Path of the basket order endpoint, which answers with one result per leg
+    # rather than a single order id.
+    MULTI_ORDER_PATH = "/v2/alerts/multi/orders"
+
+    module_function
+
+    # True when this request changes real account state.
+    #
+    # @param method [Symbol] HTTP method
+    # @param path [String, nil] Request path
+    # @return [Boolean]
+    def mutating?(method, path)
+      return false unless WRITE_METHODS.include?(method)
+
+      match?(path, DhanHQ::Constants::MUTATING_PATH_PREFIXES)
+    end
+
+    # True when this request places one or more orders.
+    #
+    # @param method [Symbol] HTTP method
+    # @param path [String, nil] Request path
+    # @return [Boolean]
+    def order_placement?(method, path)
+      return false unless method == :post
+
+      match?(path, DhanHQ::Constants::ORDER_PLACEMENT_PATH_PREFIXES)
+    end
+
+    # True for the basket order endpoint.
+    #
+    # @param path [String, nil] Request path
+    # @return [Boolean]
+    def multi_order?(path)
+      path.to_s.start_with?(MULTI_ORDER_PATH)
+    end
+
+    def match?(path, prefixes)
+      return false if path.nil?
+
+      prefixes.any? { |prefix| path.start_with?(prefix) }
+    end
+    private_class_method :match?
+  end
+end

data/lib/DhanHQ/ws/client.rb

@@ -26,6 +26,9 @@ module DhanHQ
         @state = SubState.new
         @callbacks = Concurrent::Map.new { |h, k| h[k] = [] }
         @started = Concurrent::AtomicBoolean.new(false)
+        @last_message_at = Concurrent::AtomicReference.new(nil)
+        @connected_at = Concurrent::AtomicReference.new(nil)
+        @reconnects = Concurrent::AtomicFixnum.new(0)
 
         token = DhanHQ.configuration.resolved_access_token
         raise DhanHQ::AuthenticationError, "Missing access token" if token.nil? || token.empty?
@@ -43,7 +46,8 @@ module DhanHQ
         return self if @started.true?
 
         @started.make_true
-        @conn = Connection.new(url: @url, mode: @mode, bus: @bus, state: @state) do |binary|
+        @conn = Connection.new(url: @url, mode: @mode, bus: @bus, state: @state,
+                               on_event: method(:handle_connection_event)) do |binary|
           tick = Decoder.decode(binary)
           emit(:tick, tick) if tick
         end
@@ -90,6 +94,80 @@ module DhanHQ
         @conn&.open? || false
       end
 
+      # Timestamp of the most recently received frame.
+      #
+      # A feed can be "connected" and still be dead — the socket stays open while
+      # the server has stopped publishing. Long-running daemons should watch this
+      # rather than {#connected?} alone.
+      #
+      # @return [Time, nil] nil until the first frame arrives.
+      def last_message_at
+        @last_message_at.get
+      end
+
+      # Seconds since the last frame arrived.
+      #
+      # @return [Float, nil] nil until the first frame arrives.
+      def seconds_since_last_message
+        stamp = last_message_at
+        return nil unless stamp
+
+        Time.now - stamp
+      end
+
+      # Whether the feed looks alive: connected and delivering frames recently.
+      #
+      # @param stale_after [Numeric] Seconds of silence after which the feed is
+      #   considered stale. The server pings roughly every 10 seconds, so the
+      #   default allows several missed intervals.
+      # @return [Boolean]
+      def healthy?(stale_after: 45)
+        return false unless connected?
+
+        idle = seconds_since_last_message
+        idle.nil? || idle <= stale_after
+      end
+
+      # Timestamp of the current connection's establishment.
+      #
+      # @return [Time, nil]
+      def connected_at
+        @connected_at.get
+      end
+
+      # Number of times the connection has been re-established since {#start}.
+      #
+      # @return [Integer]
+      def reconnect_count
+        @reconnects.value
+      end
+
+      # Instruments currently subscribed, as `"SEGMENT:SECURITY_ID"` strings.
+      #
+      # Survives reconnects: the connection replays this set on every new session.
+      #
+      # @return [Array<String>]
+      def subscriptions
+        @state.snapshot
+      end
+
+      # Point-in-time health snapshot, suitable for a monitoring endpoint or log line.
+      #
+      # @return [Hash]
+      def health
+        {
+          mode: @mode,
+          started: @started.true?,
+          connected: connected?,
+          healthy: healthy?,
+          connected_at: connected_at,
+          last_message_at: last_message_at,
+          seconds_since_last_message: seconds_since_last_message,
+          reconnect_count: reconnect_count,
+          subscription_count: subscriptions.size
+        }
+      end
+
       # Subscribes to updates for a single instrument.
       #
       # @param segment [String, Symbol, Integer]
@@ -154,9 +232,27 @@ module DhanHQ
 
       # Registers a callback for a given event.
       #
-      # @param event [Symbol] Event name (:tick, :open, :close, :error).
+      # Supported events:
+      #
+      # - +:tick+ — a decoded market data packet.
+      # - +:open+ — the socket connected. Payload: `{ resubscribed: [...] }`.
+      # - +:reconnect+ — the socket re-connected after a drop. Payload:
+      #   `{ attempt: Integer, resubscribed: [...] }`. Subscriptions are replayed
+      #   automatically before this fires; use it to re-seed derived state such as
+      #   candle builders or to alert.
+      # - +:close+ — the socket closed. Payload:
+      #   `{ code:, reason:, reconnecting: Boolean }`.
+      # - +:error+ — a socket-level error. Payload: the error message.
+      #
+      # @param event [Symbol] Event name.
       # @yieldparam payload [Object] Event payload.
       # @return [DhanHQ::WS::Client] self.
+      #
+      # @example React to a reconnect
+      #   client.on(:reconnect) do |info|
+      #     logger.warn "feed reconnected (attempt #{info[:attempt]}), " \
+      #                 "#{info[:resubscribed].size} instruments restored"
+      #   end
       def on(event, &blk)
         @callbacks[event] << blk
         self
@@ -164,6 +260,25 @@ module DhanHQ
 
       private
 
+      # Bridges connection-level lifecycle events onto the client's callback bus and
+      # updates the health counters. +:message+ is internal bookkeeping only — the
+      # decoded payload reaches users as +:tick+.
+      def handle_connection_event(event, payload)
+        case event
+        when :message
+          @last_message_at.set(Time.now)
+          return
+        when :open
+          @connected_at.set(Time.now)
+        when :reconnect
+          @reconnects.increment
+        when :close
+          @connected_at.set(nil)
+        end
+
+        emit(event, payload)
+      end
+
       def prune(hash) = { ExchangeSegment: hash[:ExchangeSegment], SecurityId: hash[:SecurityId] }
 
       def emit(event, payload)

data/lib/DhanHQ/ws/connection.rb

@@ -23,13 +23,18 @@ module DhanHQ
       # @param bus [DhanHQ::WS::CmdBus] Command queue feeding subscription
       #   changes.
       # @param state [DhanHQ::WS::SubState] Tracks subscription status.
+      # @param on_event [Proc, nil] Optional callable invoked as
+      #   +on_event.call(event, payload)+ for lifecycle events (+:open+, +:close+,
+      #   +:error+, +:reconnect+). Lets the owning client surface connection state
+      #   to user callbacks.
       # @yield [binary]
       # @yieldparam binary [String] Raw binary frame received from the socket.
-      def initialize(url:, mode:, bus:, state:, &on_binary)
+      def initialize(url:, mode:, bus:, state:, on_event: nil, &on_binary)
         @url = url
         @mode = mode
         @bus = bus
         @state = state
+        @on_event = on_event
         @on_binary = on_binary
         @stop = false
         @stopping = false
@@ -90,11 +95,41 @@ module DhanHQ
 
       private
 
+      # Notifies the owning client of a lifecycle event. Never lets a user callback
+      # take down the connection thread.
+      def notify(event, payload = nil)
+        @on_event&.call(event, payload)
+      rescue StandardError => e
+        DhanHQ.logger&.error("[DhanHQ::WS] on_event(#{event}) raised #{e.class}: #{e.message}")
+      end
+
+      # Restores subscriptions and starts the command drain for a freshly opened
+      # socket, then reports the transition.
+      #
+      # @param session [Integer] 1-based index of this connection attempt. Anything
+      #   past the first is a reconnect.
+      def handle_open(session)
+        DhanHQ.logger&.info("[DhanHQ::WS] open")
+
+        # The server keeps no subscription state across connections, so the desired set
+        # is replayed on every new session. See SubState#resubscribe_payload.
+        snapshot = @state.resubscribe_payload
+        send_sub(snapshot) unless snapshot.empty?
+        @timer = EM.add_periodic_timer(0.25) { drain_and_send }
+
+        # :reconnect lets callers re-seed derived state (candle builders, caches)
+        # and see exactly which instruments were restored for them.
+        notify(:reconnect, { attempt: session - 1, resubscribed: snapshot }) if session > 1
+        notify(:open, { resubscribed: snapshot })
+      end
+
       def loop_run
         backoff = 2.0
+        sessions = 0
         until @stop
           failed = false
           got_429 = false
+          sessions += 1
 
           # respect any active cool-off window
           sleep (@cooloff_until - Time.now).ceil if @cooloff_until && Time.now < @cooloff_until
@@ -103,18 +138,10 @@ module DhanHQ
             EM.run do
               @ws = Faye::WebSocket::Client.new(@url, nil, headers: default_headers)
 
-              @ws.on :open do |_|
-                DhanHQ.logger&.info("[DhanHQ::WS] open")
-                # re-subscribe snapshot on reconnect
-                snapshot = @state.snapshot.map do |k|
-                  seg, sid = k.split(":")
-                  { ExchangeSegment: seg, SecurityId: sid }
-                end
-                send_sub(snapshot) unless snapshot.empty?
-                @timer = EM.add_periodic_timer(0.25) { drain_and_send }
-              end
+              @ws.on(:open) { |_| handle_open(sessions) }
 
               @ws.on :message do |ev|
+                notify(:message, nil)
                 @on_binary&.call(ev.data) # raw frames to decoder
               end
 
@@ -131,12 +158,14 @@ module DhanHQ
                   failed  = (ev.code != 1000)
                   got_429 = ev.reason.to_s.include?("429")
                 end
+                notify(:close, { code: ev.code, reason: ev.reason, reconnecting: failed })
                 EM.stop
               end
 
               @ws.on :error do |ev|
                 DhanHQ.logger&.error("[DhanHQ::WS] error #{ev.message}")
                 failed = true
+                notify(:error, ev.message)
               end
             end
           rescue StandardError => e

data/lib/DhanHQ/ws/sub_state.rb

@@ -51,6 +51,20 @@ module DhanHQ
         @mutex.synchronize { @set.to_a }
       end
 
+      # The desired subscriptions rendered as instrument hashes, ready to be sent as a
+      # subscribe frame.
+      #
+      # The server keeps no subscription state across connections, so a reconnecting
+      # client replays this on every new session.
+      #
+      # @return [Array<Hash>] Instruments with +:ExchangeSegment+ and +:SecurityId+.
+      def resubscribe_payload
+        snapshot.map do |key|
+          segment, security_id = key.split(":")
+          { ExchangeSegment: segment, SecurityId: security_id }
+        end
+      end
+
       private
 
       def key_for(instrument) = "#{instrument[:ExchangeSegment]}:#{instrument[:SecurityId]}"

data/lib/dhan_hq.rb

@@ -53,6 +53,9 @@ module DhanHQ
   require_relative "DhanHQ/risk/checks/quantity"
   require_relative "DhanHQ/risk/checks/market_hours"
   require_relative "DhanHQ/risk/checks/options"
+  require_relative "DhanHQ/risk/checks/position_limits"
+  require_relative "DhanHQ/risk/checks/concentration"
+  require_relative "DhanHQ/risk/checks/max_loss"
   require_relative "DhanHQ/risk/pipeline"
 
   # Skills layer: multi-step trading workflows
@@ -65,6 +68,7 @@ module DhanHQ
   require_relative "DhanHQ/skills/builtin/square_off_position"
   require_relative "DhanHQ/skills/builtin/iron_condor"
   require_relative "DhanHQ/skills/builtin/strangle"
+  require_relative "DhanHQ/skills/builtin/market_data_summarizer"
   DhanHQ::Skills::Registry.load_builtins
 
   class Error < StandardError; end
@@ -186,6 +190,49 @@ module DhanHQ
       configuration
     end
 
+    # Configures the DhanHQ client by fetching credentials from a dashboard API.
+    #
+    # @param bearer_token [String] Secret dashboard token (e.g. YOUR_DASHBOARD_TOKEN)
+    # @param url [String] The full URL of the dashboard API
+    # @return [DhanHQ::Configuration] The configured configuration
+    # @raise [DhanHQ::TokenEndpointError] On HTTP error or missing credentials
+    def configure_from_dashboard(bearer_token:, url: "http://localhost:3011/api/dhan_access_token")
+      raise DhanHQ::TokenEndpointError, "bearer_token is required" if bearer_token.to_s.empty?
+
+      conn = ::Faraday.new(url: url) do |c|
+        c.request :url_encoded
+        c.adapter ::Faraday.default_adapter
+      end
+
+      response = conn.get("") do |req|
+        req.headers["Authorization"] = "Bearer #{bearer_token}"
+        req.headers["Accept"] = "application/json"
+      end
+
+      unless response.success?
+        body = parse_json_body(response.body)
+        msg = body["error"] || body["message"] || body["errorMessage"] || response.body.to_s
+        raise DhanHQ::TokenEndpointError, "Dashboard returned #{response.status}: #{msg}"
+      end
+
+      data = parse_json_body(response.body)
+      data = data.transform_keys(&:to_s) if data.is_a?(Hash)
+
+      access_token = data["access_token"] || data["accessToken"] || data["dhan_access_token"] || data["dhanaccesstoken"]
+      client_id = data["client_id"] || data["clientId"] || data["dhan_client_id"] || data["dhanClientId"]
+      client_id ||= self.configuration&.client_id || ENV.fetch("DHAN_CLIENT_ID", nil)
+
+      raise DhanHQ::TokenEndpointError, "Dashboard response missing access_token (tried access_token, dhan_access_token, dhanaccesstoken)" if access_token.to_s.empty?
+      raise DhanHQ::TokenEndpointError, "Dashboard response missing client_id, and no fallback client_id was found in config or ENV['DHAN_CLIENT_ID']" if client_id.to_s.empty?
+
+      self.configuration ||= Configuration.new
+      configuration.access_token = access_token.to_s
+      configuration.client_id = client_id.to_s
+      dhan_base = data["base_url"] || data["baseUrl"]
+      configuration.base_url = dhan_base.to_s if dhan_base.to_s != ""
+      configuration
+    end
+
     # @param body [String, Hash] Raw response body
     # @return [Hash] Parsed hash; empty hash on parse failure or empty string
     def parse_json_body(body)

data/lib/dhanhq/analysis/options_buying_advisor.rb

@@ -100,13 +100,13 @@ module DhanHQ
         # Choose the nearest expiry (first element); adjust selection if API returns sorted differently
         expiry = expiries.first
         raw = DhanHQ::Models::OptionChain.fetch(underlying_scrip: sid.to_i, underlying_seg: seg, expiry: expiry)
-        oc = raw[:oc] || {}
-        # Transform OC structure into advisor-friendly array [{ strike:, ce: {...}, pe: {...} }]
-        @data[:option_chain] = oc.map do |strike, strike_data|
+        strikes = raw[:strikes] || []
+        # Transform normalized strikes into advisor-friendly array [{ strike:, ce: {...}, pe: {...} }]
+        @data[:option_chain] = strikes.map do |entry|
           {
-            strike: strike.to_f,
-            ce: normalize_leg(strike_data["ce"] || {}),
-            pe: normalize_leg(strike_data["pe"] || {})
+            strike: entry[:strike].to_f,
+            ce: normalize_leg(entry[:call] || {}),
+            pe: normalize_leg(entry[:put] || {})
           }
         end
       rescue StandardError
@@ -114,11 +114,12 @@ module DhanHQ
       end
 
       def normalize_leg(cepe)
+        greeks = cepe[:greeks] || {}
         {
-          ltp: cepe["last_price"], bid: cepe["best_bid_price"], ask: cepe["best_ask_price"],
-          iv: cepe["iv"], oi: cepe["oi"], volume: cepe["volume"],
-          delta: cepe["delta"], gamma: cepe["gamma"], vega: cepe["vega"], theta: cepe["theta"],
-          lot_size: cepe["lot_size"], tradable: true
+          ltp: cepe[:last_price], bid: cepe[:top_bid_price], ask: cepe[:top_ask_price],
+          iv: cepe[:implied_volatility], oi: cepe[:oi], volume: cepe[:volume],
+          delta: greeks[:delta], gamma: greeks[:gamma], vega: greeks[:vega], theta: greeks[:theta],
+          security_id: cepe[:security_id], tradable: true
         }
       end