DhanHQ 3.0.1 → 3.2.0

data/lib/DhanHQ/dry_run/ledger.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module DhanHQ
+  module DryRun
+    # Remembers the orders a dry run pretended to place, so a follow-up read for one
+    # of those simulated ids can be answered locally.
+    #
+    # This exists because the high-level models re-fetch after placing:
+    # `Models::Order.place` and `GlobalStocks::Order.place` both call `find(order_id)`
+    # to return the complete record. Without a ledger that GET would leave the process
+    # carrying a `DRYRUN-…` id to the live API, which is both a real network call and a
+    # guaranteed miss — so dry run would only have worked for direct
+    # {DhanHQ::Client#request} calls, not the API people actually use.
+    #
+    # Entries are per-process and capped; a long rehearsal evicts its oldest records
+    # rather than growing without bound.
+    class Ledger
+      # Maximum simulated orders retained before the oldest are evicted.
+      MAX_ENTRIES = 500
+
+      def initialize(max_entries: MAX_ENTRIES)
+        @max_entries = max_entries
+        @records = {}
+        @mutex = Mutex.new
+      end
+
+      # Process-wide ledger used by {DhanHQ::DryRun::Simulator}.
+      #
+      # @return [Ledger]
+      def self.instance
+        @instance ||= new
+      end
+
+      # Records a simulated order.
+      #
+      # @param order_id [String] The simulated order id
+      # @param record [Hash] The response to replay for reads of that id
+      # @return [Hash] The stored record
+      def record(order_id, record)
+        @mutex.synchronize do
+          @records.delete(order_id)
+          @records[order_id] = record
+          @records.shift while @records.size > @max_entries
+          record
+        end
+      end
+
+      # Fetches a previously simulated order.
+      #
+      # @param order_id [String]
+      # @return [Hash, nil] nil when the id was never simulated in this process
+      def fetch(order_id)
+        @mutex.synchronize { @records[order_id] }
+      end
+
+      # @return [Integer] Number of retained records
+      def size
+        @mutex.synchronize { @records.size }
+      end
+
+      # Drops every retained record. Intended for test isolation.
+      #
+      # @return [void]
+      def clear
+        @mutex.synchronize { @records.clear }
+      end
+    end
+  end
+end

data/lib/DhanHQ/dry_run/simulator.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "active_support/core_ext/hash/indifferent_access"
+
+module DhanHQ
+  module DryRun
+    # Answers state-changing requests locally instead of sending them.
+    #
+    # Reads still go to the API, so market data, the option chain, positions and
+    # holdings stay live and a strategy can be rehearsed against real prices. The one
+    # exception is a read for an order this simulator itself invented: those carry the
+    # {ID_PREFIX} sentinel, can only exist because of a dry run, and are replayed from
+    # the {Ledger} so the models' place-then-refetch flow completes without touching
+    # the network.
+    #
+    # Responses are shaped per endpoint family, because callers inspect them: order
+    # placements need an `orderId` for the models to treat the write as successful, and
+    # the basket endpoint needs an `orders` array or {DhanHQ::Models::MultiOrder} sees
+    # a failure.
+    class Simulator
+      # Marks an order id as fabricated by a dry run.
+      ID_PREFIX = "DRYRUN-"
+
+      # Extracts a fabricated id out of a request path.
+      ID_PATTERN = /#{Regexp.escape(ID_PREFIX)}[A-Za-z0-9]+/
+
+      def initialize(ledger: Ledger.instance)
+        @ledger = ledger
+      end
+
+      # Whether this request should be answered locally.
+      #
+      # @param method [Symbol] HTTP method
+      # @param path [String, nil] Request path
+      # @return [Boolean]
+      def simulates?(method, path)
+        return false unless DhanHQ.configuration&.dry_run?
+
+        WritePaths.mutating?(method, path) || replayable_read?(method, path)
+      end
+
+      # Builds — and logs — the response for a simulated request.
+      #
+      # @param method [Symbol] HTTP method
+      # @param path [String] Request path
+      # @param payload [Hash] The request body that will not be sent
+      # @return [ActiveSupport::HashWithIndifferentAccess]
+      def response_for(method, path, payload)
+        return replay(path) if replayable_read?(method, path)
+
+        log(method, path, payload)
+        body = simulated_body(method, path, payload)
+        body.merge("dryRun" => true, "method" => method.to_s.upcase, "path" => path)
+            .with_indifferent_access
+      end
+
+      private
+
+      # A GET for an id this simulator minted. Only reachable in dry run, so
+      # intercepting it never shadows a real read.
+      def replayable_read?(method, path)
+        method == :get && path.to_s.include?(ID_PREFIX)
+      end
+
+      def replay(path)
+        order_id = path.to_s[ID_PATTERN]
+        record = @ledger.fetch(order_id)
+        return record.with_indifferent_access if record
+
+        # Simulated in another process, or evicted from the ledger. Answer with the
+        # minimum a caller needs rather than falling through to a live request.
+        { "orderId" => order_id, "orderStatus" => DhanHQ::Constants::OrderStatus::TRANSIT, "dryRun" => true }
+          .with_indifferent_access
+      end
+
+      def simulated_body(method, path, payload)
+        if WritePaths.multi_order?(path)
+          simulated_basket(payload)
+        elsif WritePaths.order_placement?(method, path)
+          simulated_order(payload)
+        else
+          {}
+        end
+      end
+
+      # Echoes the submitted fields back alongside the fabricated id, so a model built
+      # from the ledger record looks like the order that would have been placed.
+      def simulated_order(payload)
+        order_id = generate_id
+        record = stringify(payload).merge(
+          "orderId" => order_id,
+          "orderStatus" => DhanHQ::Constants::OrderStatus::TRANSIT,
+          "dryRun" => true
+        )
+        @ledger.record(order_id, record)
+        { "orderId" => order_id, "orderStatus" => DhanHQ::Constants::OrderStatus::TRANSIT }
+      end
+
+      # One result per submitted leg, keyed by the caller's sequence, mirroring the
+      # real basket response.
+      def simulated_basket(payload)
+        legs = stringify(payload)["orders"]
+        legs = [] unless legs.is_a?(Array)
+
+        orders = legs.each_with_index.map do |leg, index|
+          order_id = generate_id
+          sequence = (leg.is_a?(Hash) ? leg["sequence"] : nil) || (index + 1).to_s
+          @ledger.record(order_id, (leg.is_a?(Hash) ? leg : {}).merge("orderId" => order_id, "dryRun" => true))
+          {
+            "orderId" => order_id,
+            "sequence" => sequence,
+            "orderStatus" => DhanHQ::Constants::OrderStatus::TRANSIT
+          }
+        end
+
+        { "orders" => orders }
+      end
+
+      def generate_id
+        "#{ID_PREFIX}#{SecureRandom.hex(6).upcase}"
+      end
+
+      def stringify(payload)
+        payload.is_a?(Hash) ? payload.transform_keys(&:to_s) : {}
+      end
+
+      def log(method, path, payload)
+        DhanHQ.logger&.warn(
+          JSON.generate(
+            event: "DHAN_DRY_RUN",
+            method: method.to_s.upcase,
+            path: path,
+            payload: payload.is_a?(Hash) ? payload : nil
+          )
+        )
+      end
+    end
+  end
+end

data/lib/DhanHQ/helpers/attribute_helper.rb

@@ -11,6 +11,29 @@ module DhanHQ
       hash.transform_keys { |key| key.to_s.camelize(:lower) }
     end
 
+    # Recursively convert keys from snake_case to camelCase, descending into nested
+    # hashes and through arrays.
+    #
+    # {#camelize_keys} only rewrites the top level, which is correct for the flat
+    # payloads most endpoints take. Endpoints whose body nests objects — the basket
+    # order `orders` array, an alert's `condition` — need this instead, or the nested
+    # fields reach the API still in snake_case and are rejected.
+    #
+    # @param value [Hash, Array, Object] The value to convert
+    # @return [Hash, Array, Object] The converted value; non-collections pass through
+    def deep_camelize_keys(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, nested), out|
+          out[key.to_s.camelize(:lower)] = deep_camelize_keys(nested)
+        end
+      when Array
+        value.map { |nested| deep_camelize_keys(nested) }
+      else
+        value
+      end
+    end
+
     # Convert keys from snake_case to TitleCase
     #
     # @param hash [Hash] The hash to convert

data/lib/DhanHQ/mcp/server.rb

@@ -1,16 +1,47 @@
 # frozen_string_literal: true
 
 require "json"
+require "timeout"
 require_relative "../agent"
+require_relative "../ai"
 
 module DhanHQ
   module MCP
     # Minimal MCP-compatible stdio JSON-RPC server for DhanHQ agent tools.
     class Server
-      def initialize(input: $stdin, output: $stdout, policy: DhanHQ::Agent::Policy.from_env)
+      # Raised for an unrecognized top-level JSON-RPC method (maps to -32601).
+      class UnknownMethodError < StandardError; end
+      # Raised for a well-formed request with invalid/unknown params (maps to -32602).
+      class InvalidParamsError < StandardError; end
+
+      SUPPORTED_PROTOCOL_VERSIONS = ["2024-11-05"].freeze
+      DEFAULT_TOOL_CALL_TIMEOUT_SECONDS = 15
+
+      RESOURCES = [
+        { uri: "dhanhq://account/profile", name: "Dhan Profile", description: "Current account profile including client ID, PAN, name, and trading permissions",
+          mimeType: "application/json" },
+        { uri: "dhanhq://account/funds", name: "Fund Limits", description: "Available balance, used margin, and withdrawal capacity", mimeType: "application/json" },
+        { uri: "dhanhq://account/holdings", name: "Portfolio Holdings", description: "Current equity holdings with quantity, average price, and P&L", mimeType: "application/json" },
+        { uri: "dhanhq://account/positions", name: "Open Positions", description: "Current F&O and equity positions with net quantity and unrealized P&L",
+          mimeType: "application/json" },
+        { uri: "dhanhq://account/orders", name: "Recent Orders", description: "Recent order history with status, quantity, and fill details", mimeType: "application/json" },
+        { uri: "dhanhq://market/capabilities", name: "Agent Capabilities", description: "All available tools, scopes, risk levels, and version info", mimeType: "application/json" }
+      ].freeze
+
+      PROMPTS = [
+        { name: "portfolio_summary", description: "Generate a human-readable summary of your current portfolio, positions, and available funds" },
+        { name: "market_analysis", description: "Analyze current market conditions and generate a trading context summary" },
+        { name: "risk_report", description: "Review current risk exposure including open positions, P&L, and position limits" },
+        { name: "suggest_strategy", description: "Suggest a trading strategy based on current portfolio and market conditions" },
+        { name: "order_preview", description: "Preview an order before placing it with risk validation" }
+      ].freeze
+
+      def initialize(input: $stdin, output: $stdout, policy: DhanHQ::Agent::Policy.from_env,
+                     tool_call_timeout: DEFAULT_TOOL_CALL_TIMEOUT_SECONDS)
         @input = input
         @output = output
         @policy = policy
+        @tool_call_timeout = tool_call_timeout
       end
 
       def run
@@ -19,32 +50,164 @@ module DhanHQ
 
       def handle_line(line)
         request = JSON.parse(line)
-        respond(request["id"], dispatch(request["method"], request["params"] || {}))
-      rescue StandardError => e
-        respond(nil, nil, code: -32_000, message: e.message)
+      rescue JSON::ParserError => e
+        respond(nil, nil, code: -32_700, message: "Parse error: #{e.message}")
+      else
+        handle_request(request)
       end
 
       private
 
+      def handle_request(request)
+        return unless request.key?("id") # JSON-RPC notification — must not receive a response
+
+        id = request["id"]
+        respond(id, dispatch(request["method"], request["params"] || {}))
+      rescue StandardError => e
+        respond(id, nil, code: error_code_for(e), message: e.message)
+      end
+
+      def error_code_for(error)
+        case error
+        when UnknownMethodError then -32_601
+        when InvalidParamsError then -32_602
+        else -32_603
+        end
+      end
+
       def dispatch(method, params)
         case method
         when "initialize"
           {
-            protocolVersion: "2024-11-05",
+            protocolVersion: negotiate_protocol_version(params["protocolVersion"]),
             serverInfo: { name: "dhanhq-ruby", version: DhanHQ::VERSION },
-            capabilities: { tools: {} }
+            capabilities: { tools: {}, resources: {}, prompts: {} }
           }
         when "tools/list"
           { tools: DhanHQ::Agent::ToolRegistry.list.map { |t| mcp_tool(t) } }
         when "tools/call"
-          result = DhanHQ::Agent::ToolRegistry.execute(
+          { content: [{ type: "text", text: JSON.pretty_generate(serialize(call_tool(params))) }] }
+        when "resources/list"
+          { resources: resource_definitions }
+        when "resources/read"
+          resource = resources.find { |r| r[:uri] == params["uri"] }
+          raise InvalidParamsError, "Unknown resource: #{params["uri"]}" unless resource
+
+          { contents: [resource_read(resource)] }
+        when "prompts/list"
+          { prompts: prompt_definitions }
+        when "prompts/get"
+          prompt = prompts.find { |p| p[:name] == params["name"] }
+          raise InvalidParamsError, "Unknown prompt: #{params["name"]}" unless prompt
+
+          prompt_result(prompt, params.fetch("arguments", {}))
+        else
+          raise UnknownMethodError, "Unsupported MCP method: #{method}"
+        end
+      end
+
+      def negotiate_protocol_version(requested)
+        SUPPORTED_PROTOCOL_VERSIONS.include?(requested) ? requested : SUPPORTED_PROTOCOL_VERSIONS.last
+      end
+
+      def call_tool(params)
+        Timeout.timeout(@tool_call_timeout) do
+          DhanHQ::Agent::ToolRegistry.execute(
             params.fetch("name"),
             params.fetch("arguments", {}),
             policy: @policy
           )
-          { content: [{ type: "text", text: JSON.pretty_generate(serialize(result)) }] }
+        end
+      rescue ArgumentError => e
+        raise InvalidParamsError, e.message
+      rescue Timeout::Error
+        raise "Tool call '#{params["name"]}' timed out after #{@tool_call_timeout}s " \
+              "(likely blocked on rate-limit backoff) — retry shortly"
+      end
+
+      def resources
+        RESOURCES
+      end
+
+      def prompts
+        PROMPTS
+      end
+
+      def resource_definitions
+        RESOURCES.map { |r| r.except(:handler) }
+      end
+
+      def resource_read(resource)
+        handler = resource_handler(resource[:uri])
+        data = handler.call
+        { uri: resource[:uri], mimeType: "application/json", text: JSON.pretty_generate(serialize(data)) }
+      end
+
+      def resource_handler(uri)
+        case uri
+        when "dhanhq://account/profile" then -> { DhanHQ::Models::Profile.fetch }
+        when "dhanhq://account/funds" then -> { DhanHQ::Models::Funds.fetch }
+        when "dhanhq://account/holdings" then -> { DhanHQ::Models::Holding.all }
+        when "dhanhq://account/positions" then -> { DhanHQ::Models::Position.all }
+        when "dhanhq://account/orders" then -> { DhanHQ::Models::Order.all }
+        when "dhanhq://market/capabilities" then -> { DhanHQ::Agent::ToolRegistry.capabilities }
+        else raise ArgumentError, "No handler for resource: #{uri}"
+        end
+      end
+
+      def prompt_definitions
+        PROMPTS.map { |p| { name: p[:name], description: p[:description], arguments: prompt_arguments(p[:name]) } }
+      end
+
+      def prompt_arguments(prompt_name)
+        case prompt_name
+        when "order_preview"
+          [{ name: "transaction_type", description: "BUY or SELL", required: true },
+           { name: "security_id", description: "Dhan security ID", required: true },
+           { name: "quantity", description: "Number of shares/lots", required: true },
+           { name: "exchange_segment", description: "NSE_EQ, NSE_FNO, etc.", required: true },
+           { name: "price", description: "Limit price (optional for MARKET)", required: false }]
+        when "market_analysis"
+          [{ name: "symbol", description: "Ticker symbol (e.g., NIFTY, RELIANCE)", required: false }]
+        else
+          []
+        end
+      end
+
+      def prompt_result(prompt, arguments)
+        case prompt[:name]
+        when "portfolio_summary"
+          holdings = DhanHQ::Models::Holding.all
+          positions = DhanHQ::Models::Position.all
+          funds = DhanHQ::Models::Funds.fetch
+          summary = DhanHQ::AI::PromptHelpers.portfolio_summary(holdings: holdings, positions: positions, funds: funds)
+          { messages: [{ role: "user", content: { type: "text", text: summary } }] }
+        when "market_analysis"
+          symbol = arguments["symbol"] || "NIFTY"
+          instrument = DhanHQ::Models::Instrument.find(DhanHQ::Constants::ExchangeSegment::IDX_I, symbol)
+          security_id = instrument&.security_id&.to_i
+          if security_id
+            snapshot = DhanHQ::Models::MarketFeed.quote(DhanHQ::Constants::ExchangeSegment::IDX_I => [security_id])
+            text = "Market snapshot for #{symbol}: #{snapshot}"
+          else
+            text = "Could not resolve symbol #{symbol} to a security ID for market data."
+          end
+          { messages: [{ role: "user", content: { type: "text", text: text } }] }
+        when "risk_report"
+          positions = DhanHQ::Models::Position.all
+          text = DhanHQ::AI::PromptHelpers.risk_report(positions: positions)
+          { messages: [{ role: "user", content: { type: "text", text: text } }] }
+        when "order_preview"
+          preview = DhanHQ::Agent::OrderPreview.new(arguments)
+          text = preview.valid? ? "Order preview: #{preview.to_h[:summary]}" : "Validation errors: #{preview.errors.join(", ")}"
+          { messages: [{ role: "user", content: { type: "text", text: text } }] }
+        when "suggest_strategy"
+          positions = DhanHQ::Models::Position.all
+          funds = DhanHQ::Models::Funds.fetch
+          text = "Current portfolio: #{positions.size} open positions, Available: ₹#{funds.available_balance}. Review positions for strategy suggestions."
+          { messages: [{ role: "user", content: { type: "text", text: text } }] }
         else
-          raise ArgumentError, "Unsupported MCP method: #{method}"
+          raise ArgumentError, "Unknown prompt: #{prompt[:name]}"
         end
       end
 

data/lib/DhanHQ/models/alert_order.rb

@@ -45,7 +45,10 @@ module DhanHQ
         def create(params)
           normalized = snake_case(params)
           validate_params!(normalized, DhanHQ::Contracts::AlertOrderContract)
-          response = resource.create(camelize_keys(normalized))
+          # `condition` and every entry of `orders` are nested objects whose fields the
+          # API expects in camelCase (AlertCondition#comparisonType, #securityId, …), so
+          # a shallow camelize would leave them snake_cased on the wire.
+          response = resource.create(deep_camelize_keys(normalized))
           return nil unless response.is_a?(Hash) && response["alertId"]
 
           find(response["alertId"])
@@ -69,7 +72,7 @@ module DhanHQ
           normalized = snake_case(params)
           validate_params!(normalized, DhanHQ::Contracts::AlertOrderContract)
           payload = normalized.merge(alert_id: alert_id)
-          response = resource.update(alert_id, camelize_keys(payload))
+          response = resource.update(alert_id, deep_camelize_keys(payload))
           return nil unless success_response?(response)
 
           find(alert_id)

data/lib/DhanHQ/models/global_stocks/funds.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Models
+    module GlobalStocks
+      ##
+      # USD fund limit for Global Stocks trading.
+      #
+      # This is a separate balance from the domestic INR limit exposed by
+      # {DhanHQ::Models::Funds}.
+      #
+      # @example
+      #   funds = DhanHQ::Models::GlobalStocks::Funds.fetch
+      #   puts "Available: $#{funds.available_cash}"
+      #   puts "Unsettled: $#{funds.unsettled_cash}"
+      #
+      class Funds < BaseModel
+        HTTP_PATH = "/v2/globalstocks/fundlimit"
+
+        attributes :dhan_client_id, :available_cash, :cash_on_account, :actual_cash,
+                   :settled_cash, :unsettled_cash, :margin_utilized
+
+        # Returns a concise prompt-friendly summary of the USD balance.
+        def to_prompt
+          parts = []
+          parts << "available=$#{available_cash}" if available_cash
+          parts << "settled=$#{settled_cash}" if settled_cash
+          parts << "unsettled=$#{unsettled_cash}" if unsettled_cash
+          parts << "utilized=$#{margin_utilized}" if margin_utilized&.positive?
+          parts.join(", ")
+        end
+
+        class << self
+          # @return [DhanHQ::Resources::GlobalStocks::Funds]
+          def resource
+            @resource ||= DhanHQ::Resources::GlobalStocks::Funds.new
+          end
+
+          # Fetches the Global Stocks fund limit.
+          #
+          # @return [Funds]
+          def fetch
+            new(resource.fetch, skip_validation: true)
+          end
+
+          # Convenience accessor for the available USD cash.
+          #
+          # @return [Float]
+          def balance
+            fetch.available_cash.to_f
+          end
+        end
+      end
+    end
+  end
+end

data/lib/DhanHQ/models/global_stocks/holding.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Models
+    module GlobalStocks
+      ##
+      # A single Global Stocks (US equity) holding.
+      #
+      # Unlike domestic holdings, US holdings report live valuation directly
+      # (+ltp+, +current_value+, +gain_value+), so no quote lookup is needed to
+      # compute unrealised P&L.
+      #
+      # @example Portfolio with unrealised P&L
+      #   holdings = DhanHQ::Models::GlobalStocks::Holding.all
+      #   holdings.each do |h|
+      #     puts "#{h.trading_symbol}: #{h.quantity} @ $#{h.avg_cost_price} (#{h.gain_percentage}%)"
+      #   end
+      #   puts "Total: $#{DhanHQ::Models::GlobalStocks::Holding.total_current_value}"
+      #
+      class Holding < BaseModel
+        HTTP_PATH = "/v2/globalstocks/holdings"
+
+        attributes :dhan_client_id, :trading_symbol, :display_name, :security_id,
+                   :exchange, :quantity, :avg_cost_price, :cost_value, :current_value,
+                   :gain_value, :ltp, :prev_close, :long_term_flag, :last_updated
+
+        # Returns a concise prompt-friendly summary of the holding.
+        def to_prompt
+          parts = ["#{quantity}x #{trading_symbol || security_id}"]
+          parts << "avg_cost=$#{avg_cost_price}" if avg_cost_price&.positive?
+          parts << "ltp=$#{ltp}" if ltp&.positive?
+          parts << "value=$#{current_value}" if current_value
+          parts << "pnl=$#{gain_value} (#{gain_percentage}%)" if gain_value
+          parts.join(", ")
+        end
+
+        # Unrealised gain as a percentage of cost.
+        #
+        # @return [Float] 0.0 when cost value is unknown or zero.
+        def gain_percentage
+          cost = cost_value.to_f
+          return 0.0 if cost.zero?
+
+          (gain_value.to_f / cost * 100).round(2)
+        end
+
+        # @return [Boolean] True when the position is in profit.
+        def profitable?
+          gain_value.to_f.positive?
+        end
+
+        # @return [Boolean] True for a fractional-share position.
+        def fractional?
+          quantity.is_a?(Float) && (quantity % 1 != 0)
+        end
+
+        # Change against the previous close, per share.
+        #
+        # @return [Float, nil] nil when either price is unavailable.
+        def day_change
+          return nil unless ltp && prev_close
+
+          (ltp.to_f - prev_close.to_f).round(4)
+        end
+
+        class << self
+          # @return [DhanHQ::Resources::GlobalStocks::Holdings]
+          def resource
+            @resource ||= DhanHQ::Resources::GlobalStocks::Holdings.new
+          end
+
+          # Retrieves all Global Stocks holdings.
+          #
+          # @return [Array<Holding>] Empty array when there are no US holdings.
+          def all
+            response = resource.all
+            return [] unless response.is_a?(Array)
+
+            response.map { |holding| new(holding, skip_validation: true) }
+          rescue DhanHQ::NoHoldingsError
+            []
+          end
+
+          # Total market value of the US portfolio.
+          #
+          # @return [Float]
+          def total_current_value
+            all.sum { |holding| holding.current_value.to_f }
+          end
+
+          # Total unrealised P&L across the US portfolio.
+          #
+          # @return [Float]
+          def total_gain
+            all.sum { |holding| holding.gain_value.to_f }
+          end
+        end
+      end
+    end
+  end
+end