DhanHQ 2.2.2 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09510cd95013213714d5ba4878e87dfa6bd5968cb90ea4e0a539ddb0d05bc2b0'
-  data.tar.gz: 459c316d0f2c68ad8b0556518dfd70762e460e5c68ef063439e73f68ca33ba02
+  metadata.gz: b583e87aa598f3891e937f44859f9b451fc8f6bcec7a304cc0c33790fe9117ea
+  data.tar.gz: 1a090fa608fba141da311ba8aaf21d36e750f78e90497f728c5f96d580044c7e
 SHA512:
-  metadata.gz: d54cf0cc58e82d1566f525303ea25fddd051b1c838152da39f12509435a16e4005f55417d5516c52f6222b4ba6286c421202d0a148f743be7ca4127b7ef03bae
-  data.tar.gz: ea522dfeb54054d8162d00ead357efb4c444c3dd0c4c182c4d688a2bd9a484d44af7b2bab221476c93fded44511bfff7e8cf4b75d6e962fc8191486bee5440b1
+  metadata.gz: '0966f2a2aa331b675ecc1675510f6ad3dca6b7a987c8dde15dde2efe506ac659157b6e0979d0c23f480d2835fa603bfd37530f33275d422226abb2419e46bfd0'
+  data.tar.gz: 74ea10d0744fb01324afd4a1768fa6969b07f4d1fcb9da94d7a6caf01fd01c2863d6a3746d288628d10e497bd55c68687e0b54e237bd91736ad4bb8c1decc9f8

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 ## [Unreleased]
 
+---
+
+## [2.4.0] - 2026-02-18
+
+### Added
+- Support for Individual TOTP-based access token generation
+- `DhanHQ::Auth.generate_access_token`
+- `DhanHQ::Auth.generate_totp`
+
+### Updated
+- RenewToken now uses POST (aligned with Dhan API behavior)
+- Improved error handling for authentication APIs
+
+### Notes
+- TOTP tokens can now be programmatically regenerated without browser login
+- RenewToken still applies only to web-generated tokens
+
+---
+
+## [2.3.0] - 2026-02-04
+
+### Added
+- **Alert Orders**: `DhanHQ::Resources::AlertOrders` (BaseResource) and `DhanHQ::Models::AlertOrder` with full CRUD. Endpoints: GET/POST `/alerts/orders`, GET/PUT/DELETE `/alerts/orders/{id}` (per API docs). Validation via `DhanHQ::Contracts::AlertOrderContract`.
+- **IP Setup**: `DhanHQ::Resources::IPSetup` (resource-only). Methods: `current` (GET `/ip/getIP`), `set(ip:)` (POST `/ip/setIP`), `update(ip:)` (PUT `/ip/modifyIP`) per API docs.
+- **Trader Control (Kill Switch)**: `DhanHQ::Resources::TraderControl` (resource-only). Methods: `status` (GET `/trader-control`), `enable` (POST action ENABLE), `disable` (POST action DISABLE). `DhanHQ::Resources::KillSwitch` and `DhanHQ::Models::KillSwitch` remain for backward compatibility.
+- **docs/API_VERIFICATION.md**: Documents alignment with [dhanhq.co/docs/v2](https://dhanhq.co/docs/v2/) and [api.dhan.co/v2](https://api.dhan.co/v2/#/) for EDIS, Alert Orders, IP Setup.
+
+### Changed
+- **EDIS**: Resource-only, aligned with [dhanhq.co/docs/v2/edis](https://dhanhq.co/docs/v2/edis/). Use `DhanHQ::Resources::Edis`: `form(params)` (POST `/edis/form`; isin, qty, exchange, segment, bulk), `bulk_form(params)` (POST `/edis/bulkform`), `tpin` (GET `/edis/tpin`), `inquire(isin)` (GET `/edis/inquire/{isin}`).
+- **BaseResource**: Fixed path building: `all`/`find`/`create`/`update`/`delete` now pass relative endpoints (`""`, `"/#{id}"`) so the base path is not doubled.
+
+---
+
 ## [2.2.2] - 2026-01-31
 
 ### Contracts (date validation)

data/CODE_REVIEW_ISSUES.md

@@ -12,9 +12,9 @@
 **Location**: `lib/DhanHQ/client.rb:40`
 **Issue**: The client initializes configuration conditionally, which can lead to runtime errors:
 ```ruby
-DhanHQ.configure_with_env if ENV.fetch("CLIENT_ID", nil)
+DhanHQ.configure_with_env if ENV.fetch("DHAN_CLIENT_ID", nil)
 ```
-**Problem**: If `CLIENT_ID` exists but `ACCESS_TOKEN` doesn't, configuration will be partially initialized, leading to authentication failures later.
+**Problem**: If `DHAN_CLIENT_ID` exists but `DHAN_ACCESS_TOKEN` doesn't, configuration will be partially initialized, leading to authentication failures later.
 **Recommendation**: Validate both required credentials before proceeding or fail fast with a clear error message.
 
 ### 2. **Race Condition in Rate Limiter**

data/GUIDE.md

@@ -44,8 +44,8 @@ DhanHQ.logger.level = (ENV["DHAN_LOG_LEVEL"] || "INFO").upcase.then { |level| Lo
 
 | Variable       | Description                                          |
 | -------------- | ---------------------------------------------------- |
-| `CLIENT_ID`    | Your Dhan trading client id.                         |
-| `ACCESS_TOKEN` | REST/WebSocket access token generated via Dhan APIs. |
+| `DHAN_CLIENT_ID`    | Your Dhan trading client id.                         |
+| `DHAN_ACCESS_TOKEN` | REST/WebSocket access token generated via Dhan APIs. |
 
 Provide them via `.env`, Rails credentials, or your secret manager of choice
 before the initializer runs.
@@ -641,33 +641,75 @@ profile.active_segment   # => "Equity, Derivative, Currency, Commodity"
 
 If the credentials are invalid the helper raises `DhanHQ::InvalidAuthenticationError`.
 
-### EDIS (Electronic Delivery Instruction Slip)
+### Alert Orders
 
 ```ruby
-# Generate a CDSL form for a single ISIN
-form = DhanHQ::Models::Edis.form(
-  isin: "INE0ABCDE123",
-  qty: 1,
-  exchange: "NSE",
-  segment: "EQ",
-  bulk: false
+# Model (CRUD)
+DhanHQ::Models::AlertOrder.all
+alert = DhanHQ::Models::AlertOrder.find("alert-id")
+alert = DhanHQ::Models::AlertOrder.create(
+  exchange_segment: "NSE_EQ",
+  security_id: "11536",
+  condition: "GTE",
+  trigger_price: 100.0,
+  transaction_type: "BUY",
+  quantity: 10
 )
+alert.save
+alert.destroy
 
-# Prepare a bulk file
-bulk_form = DhanHQ::Models::Edis.bulk_form(
-  isin: %w[INE0ABCDE123 INE0XYZ89012],
-  exchange: "NSE",
-  segment: "EQ"
-)
+# Resource only
+DhanHQ::Resources::AlertOrders.new.all
+```
+
+### EDIS (Electronic Delivery Instruction Slip)
+
+EDIS is resource-only (no model). Use `DhanHQ::Resources::Edis` per [dhanhq.co/docs/v2/edis](https://dhanhq.co/docs/v2/edis/):
+
+```ruby
+edis = DhanHQ::Resources::Edis.new
+
+# Generate T-PIN (GET /edis/tpin)
+edis.tpin
+
+# Retrieve form & enter T-PIN (POST /edis/form): isin, qty, exchange, segment, bulk
+edis.form(isin: "INE733E01010", qty: 1, exchange: "NSE", segment: "EQ", bulk: false)
 
-# Manage T-PIN and status inquiries
-DhanHQ::Models::Edis.tpin                    # => {"status"=>"TPIN sent"}
-authorisations = DhanHQ::Models::Edis.inquire("ALL")
+# Bulk form (POST /edis/bulkform)
+edis.bulk_form(exchange: "NSE", segment: "EQ", bulk: true)
+
+# Inquire status (GET /edis/inquire/{isin})
+edis.inquire("INE002A01018")
+edis.inquire("ALL")
+```
+
+Params use snake_case; the client camelizes them before calling `/edis/...`.
+
+### IP Setup
+
+Resource-only (account configuration) per API docs: GET /ip/getIP, POST /ip/setIP, PUT /ip/modifyIP.
+
+```ruby
+ip = DhanHQ::Resources::IPSetup.new
+ip.current              # GET /ip/getIP
+ip.set(ip: "103.21.58.121")
+ip.update(ip: "103.21.58.121")
+```
+
+### Trader Control (Kill Switch)
+
+Resource-only control toggle:
+
+```ruby
+tc = DhanHQ::Resources::TraderControl.new
+tc.status               # GET /trader-control
+tc.disable             # Kill switch ON — trading blocked
+tc.enable              # Trading resumed
 ```
 
-All helpers accept snake_case keys; the client camelizes them before calling `/v2/edis/...`.
+### Kill Switch (model)
 
-### Kill Switch
+Existing model API for backward compatibility:
 
 ```ruby
 activate_payload   = DhanHQ::Models::KillSwitch.activate

data/README.md

@@ -4,7 +4,7 @@ A clean Ruby client for **Dhan API v2** with ORM-like models (Orders, Positions,
 
 * ActiveRecord-style models: `find`, `all`, `where`, `save`, `update`, `cancel`
 * Validations & errors exposed via ActiveModel-like interfaces
-* REST coverage: Orders, Super Orders, Forever Orders, Trades, Positions, Holdings, Funds/Margin, HistoricalData, OptionChain, MarketFeed, ExpiredOptionsData
+* REST coverage: Orders, Alert Orders, Super Orders, Forever Orders, Trades, Positions, Holdings, Funds/Margin, HistoricalData, OptionChain, MarketFeed, ExpiredOptionsData, EDIS, IP Setup, Trader Control (Kill Switch)
 * **WebSocket**: Orders, Market Feed, Market Depth - subscribe/unsubscribe dynamically, auto-reconnect with backoff, 429 cool-off, idempotent subs, header+payload binary parsing, normalized ticks
 
 ## ⚠️ BREAKING CHANGE NOTICE
@@ -53,7 +53,7 @@ gem install DhanHQ
 
 ## Configuration
 
-### From ENV / .env
+### From ENV / .env (static token)
 
 ```ruby
 require 'dhan_hq'
@@ -66,8 +66,8 @@ DhanHQ.logger.level = (ENV["DHAN_LOG_LEVEL"] || "INFO").upcase.then { |level| Lo
 
 | Variable       | Purpose                                           |
 | -------------- | ------------------------------------------------- |
-| `CLIENT_ID`    | Trading account client id issued by Dhan.         |
-| `ACCESS_TOKEN` | API access token generated from the Dhan console. |
+| `DHAN_CLIENT_ID`    | Trading account client id issued by Dhan.         |
+| `DHAN_ACCESS_TOKEN` | API access token generated from the Dhan console. |
 
 `configure_with_env` raises if either value is missing. Load them via `dotenv`,
 Rails credentials, or any other mechanism that populates `ENV` before
@@ -114,7 +114,18 @@ end
 
 If the API returns **401** or error code **807** (token expired) and `access_token_provider` is set, the client retries the request **once** with a fresh token from the provider. Otherwise it raises `DhanHQ::InvalidAuthenticationError` or `DhanHQ::TokenExpiredError`. Missing or nil token from config raises `DhanHQ::AuthenticationError`.
 
-**RenewToken (web-generated tokens):** For tokens generated from Dhan Web (24h validity), use `DhanHQ::Auth.renew_token(access_token, client_id)` to refresh; use the returned token in your provider or store. The gem does **not** implement API key/secret or Partner consent flows—implement those in your app and pass the token to the gem. See [docs/AUTHENTICATION.md](docs/AUTHENTICATION.md).
+### Authentication approaches (overview)
+
+The gem intentionally **does not own** Dhan’s consent flows (web, API key/secret, Partner). You obtain a token using Dhan’s docs, then choose one of these approaches:
+
+- **Static token (ENV / config)**: Set `DHAN_CLIENT_ID` and `DHAN_ACCESS_TOKEN` via ENV and call `DhanHQ.configure_with_env`, or assign `config.client_id` / `config.access_token` manually. Best when you’re comfortable rotating tokens out-of-band (cron, runbook).
+- **Dynamic token provider**: Use `config.access_token_provider` (and optional `config.on_token_expired`) so the gem asks your app for the token on every request and retries **once** on 401 with a fresh token. Ideal for OAuth-style flows or central token stores.
+- **Token endpoint bootstrap**: Call `DhanHQ.configure_from_token_endpoint(base_url:, bearer_token:)` to fetch `{ access_token, client_id, base_url? }` from your own HTTP endpoint and populate configuration in one step.
+- **TOTP-based token generation (individuals)**: Use `DhanHQ::Auth.generate_totp(secret)` + `DhanHQ::Auth.generate_access_token(dhan_client_id:, pin:, totp:)` when you want fully automated, TOTP-backed tokens for a single account. The low-level API returns the raw response hash from Dhan.
+- **Client helpers + auto management**: Use `client.generate_access_token(dhan_client_id:, pin:, totp: nil, totp_secret: nil)` and `client.enable_auto_token_management!(dhan_client_id:, pin:, totp_secret:)` when you want `TokenResponse` objects, config auto-updates, and background token lifecycle (generate + renew) wrapped around each request.
+- **RenewToken (web-generated tokens)**: For 24h tokens generated from **Dhan Web**, call `DhanHQ::Auth.renew_token(access_token:, client_id:)` or `client.renew_access_token` / `TokenManager#refresh!` to renew. This only works for active web tokens; for TOTP-generated tokens prefer regenerating.
+
+For detailed behavior, timelines, and error types, see **[docs/AUTHENTICATION.md](docs/AUTHENTICATION.md)**.
 
 ### Logging
 

data/README1.md

@@ -45,8 +45,8 @@ DhanHQ.logger.level = (ENV["DHAN_LOG_LEVEL"] || "INFO").upcase.then { |level| Lo
 
 **Minimum environment variables**
 
-* `CLIENT_ID` – trading account client id issued by Dhan.
-* `ACCESS_TOKEN` – API access token generated from the Dhan console.
+* `DHAN_CLIENT_ID` – trading account client id issued by Dhan.
+* `DHAN_ACCESS_TOKEN` – API access token generated from the Dhan console.
 
 If either key is missing `configure_with_env` raises an error. Ensure your
 application loads them into `ENV` before requiring the gem.
@@ -64,8 +64,8 @@ Create a `.env` file in your project root to supply the minimum values (and any
 optional overrides you need):
 
 ```dotenv
-CLIENT_ID=your_client_id
-ACCESS_TOKEN=your_access_token
+DHAN_CLIENT_ID=your_client_id
+DHAN_ACCESS_TOKEN=your_access_token
 ```
 
 The gem requires `dotenv/load`, so these variables are loaded automatically when you require `DhanHQ`.

data/REVIEW_SUMMARY.md

@@ -1,6 +1,6 @@
 # DhanHQ Client Gem - Review Summary
 
-**API Documentation**: https://api.dhan.co/v2/#/  
+**API Documentation**: https://api.dhan.co/v2/#/
 **Review Date**: 2025-01-27
 
 ## 🚨 Top 10 Critical Issues
@@ -15,7 +15,7 @@
 - **File**: `lib/DhanHQ/client.rb:40`
 - **Issue**: Partial configuration can lead to runtime authentication failures
 - **Impact**: Silent failures, difficult debugging
-- **Fix**: Validate both `CLIENT_ID` and `ACCESS_TOKEN` before proceeding
+- **Fix**: Validate both `DHAN_CLIENT_ID` and `DHAN_ACCESS_TOKEN` before proceeding
 
 ### 3. **Memory Leak in Order Tracker** (HIGH)
 - **File**: `lib/DhanHQ/ws/orders/client.rb:18`

data/docs/API_VERIFICATION.md

@@ -0,0 +1,67 @@
+# API Verification (Dhan v2)
+
+This document records how the gem’s implementation aligns with the official Dhan API v2 docs.
+
+**Sources:**
+
+- [dhanhq.co/docs/v2](https://dhanhq.co/docs/v2/) – main docs
+- [dhanhq.co/docs/v2/edis](https://dhanhq.co/docs/v2/edis/) – EDIS
+- [api.dhan.co/v2](https://api.dhan.co/v2/#/) – Developer Kit (when available)
+- In-repo: `CODE_REVIEW_ISSUES.md` (Alert Orders, IP Setup paths)
+
+---
+
+## EDIS
+
+**Doc:** [dhanhq.co/docs/v2/edis](https://dhanhq.co/docs/v2/edis/)
+
+| Doc endpoint              | Method | Gem method   | Path / behaviour |
+|---------------------------|--------|--------------|-------------------|
+| Generate T-PIN            | GET    | `#tpin`      | `/edis/tpin`      |
+| Retrieve form & enter T-PIN | POST | `#form(params)` | `/edis/form`; body: `isin`, `qty`, `exchange`, `segment`, `bulk` |
+| Bulk form                 | POST   | `#bulk_form(params)` | `/edis/bulkform` (aligned with TODO-1 / legacy) |
+| Inquire status            | GET    | `#inquire(isin)` | `/edis/inquire/{isin}` |
+
+**Request (form):** `isin`, `qty`, `exchange` (NSE/BSE), `segment` (EQ), `bulk` (boolean).
+
+---
+
+## Alert Orders
+
+**Doc ref:** `CODE_REVIEW_ISSUES.md` (§31) – Alert Orders endpoints.
+
+| Doc path                  | Gem resource              | Path used        |
+|---------------------------|---------------------------|------------------|
+| `/alerts/orders`          | `Resources::AlertOrders`  | `HTTP_PATH = "/alerts/orders"` |
+| GET/POST `/alerts/orders` | `#all`, `#create`         | BaseResource     |
+| GET/PUT/DELETE `/alerts/orders/{trigger-id}` | `#find`, `#update`, `#delete` | `/{id}` |
+
+Model: `Models::AlertOrder`; ID attribute `alert_id` (response field name may be `alertId` or `triggerId` depending on API; adjust if production returns `triggerId`).
+
+---
+
+## IP Setup
+
+**Doc ref:** `CODE_REVIEW_ISSUES.md` (§32) – IP Setup endpoints.
+
+| Doc path        | Gem method     | Path used     |
+|-----------------|----------------|---------------|
+| GET /ip/getIP   | `#current`     | `get("/getIP")`   |
+| POST /ip/setIP  | `#set(ip:)`    | `post("/setIP", params: { ip: ip })` |
+| PUT /ip/modifyIP| `#update(ip:)` | `put("/modifyIP", params: { ip: ip })` |
+
+---
+
+## Trader Control / Kill Switch
+
+- **Existing:** `Resources::KillSwitch`, `Models::KillSwitch` – path `/v2/killswitch`.
+- **Added:** `Resources::TraderControl` – path `/trader-control`; `#status`, `#enable`, `#disable`.  
+  Not found on the public docs pages checked; kept for compatibility with design that referenced trader-control.
+
+---
+
+## Base URL and paths
+
+- Default base URL: `https://api.dhan.co/v2`.
+- Resource `HTTP_PATH` values are relative to that base (e.g. `/edis`, `/alerts/orders`, `/ip`).
+- Order API resources use `API_TYPE = :order_api`.

data/docs/AUTHENTICATION.md

@@ -23,7 +23,7 @@ Set `access_token` once; it is sent on every request:
 ```ruby
 DhanHQ.configure do |config|
   config.client_id = ENV["DHAN_CLIENT_ID"]
-  config.access_token = ENV["ACCESS_TOKEN"]
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"]
 end
 ```
 
@@ -68,7 +68,7 @@ Example: refresh in provider and cache the result until near expiry:
 config.access_token_provider = lambda do
   stored = YourTokenStore.current
   if stored.nil? || stored.expired_soon?
-    response = DhanHQ::Auth.renew_token(stored&.access_token || ENV["ACCESS_TOKEN"], config.client_id)
+    response = DhanHQ::Auth.renew_token(stored&.access_token || ENV["DHAN_ACCESS_TOKEN"], config.client_id)
     YourTokenStore.update!(response["accessToken"], response["expiryTime"])
     stored = YourTokenStore.current
   end
@@ -108,3 +108,55 @@ Rescue `AuthenticationError` for local config/token resolution failures; rescue
 - [rails_integration.md](rails_integration.md) — Rails initializer with optional `access_token_provider` and RenewToken
 - [TESTING_GUIDE.md](TESTING_GUIDE.md) — Config examples and RenewToken
 - [CHANGELOG.md](../CHANGELOG.md) — 2.2.0 and 2.2.1 auth and token changes
+
+
+# SUPPORTED AUTHENTICATION AND TOKEN GENERATION APPROACHES:
+
+We now support five distinct authentication approaches in this gem.
+1️⃣ Static token (manual, simplest)
+What: You paste a token you got from Dhan (web, OAuth, partner, whatever) into config.
+How:
+DhanHQ.configure do |config|  config.client_id    = ENV["DHAN_CLIENT_ID"]  config.access_token = ENV["DHAN_ACCESS_TOKEN"]end
+When: You’re OK rotating tokens manually (e.g. cron job, ops runbook).
+2️⃣ Dynamic token via access_token_provider
+What: Gem asks you for a token on every request (proc/lambda).
+How:
+DhanHQ.configure do |config|  config.client_id = ENV["DHAN_CLIENT_ID"]  config.access_token_provider = -> { MyTokenStore.fetch_current_token }  config.on_token_expired = ->(error) { MyTokenStore.refresh!(error) }end
+Behavior:
+On 401 (auth failure), client calls on_token_expired, then retries once using a fresh token from access_token_provider.
+3️⃣ Fetch-from-token-endpoint (configure_from_token_endpoint)
+What: Gem calls your HTTP endpoint once to get access_token + client_id.
+How:
+DhanHQ.configure_from_token_endpoint(  base_url:    "https://myapp.com",  bearer_token: ENV["DHAN_TOKEN_ENDPOINT_BEARER"])# expects JSON: { access_token: "...", client_id: "...", base_url: "..." (optional) }
+When: Multi-tenant or central credential service, you don’t want tokens in ENV directly.
+4️⃣ TOTP-based token generation (new DhanHQ::Auth flow)
+Module API (low-level)
+What: Direct call to Dhan’s generateAccessToken endpoint using TOTP.
+totp = DhanHQ::Auth.generate_totp(ENV["DHAN_TOTP_SECRET"])response = DhanHQ::Auth.generate_access_token(  dhan_client_id: ENV["DHAN_CLIENT_ID"],  pin:           ENV["DHAN_PIN"],  totp:          totp)token  = response["accessToken"]expiry = response["expiryTime"]
+Client API (high-level, returns TokenResponse)
+client = DhanHQ::Client.new(api_type: :order_api)token = client.generate_access_token(  dhan_client_id: ENV["DHAN_CLIENT_ID"],  pin:           ENV["DHAN_PIN"],  totp_secret:   ENV["DHAN_TOTP_SECRET"] # or `totp:` if you computed it)# auto-applies token + client_id to `DhanHQ.configuration`
+When: Fully automated individual setup (no manual web token generation).
+5️⃣ Auto token lifecycle management (TokenManager)
+What: Gem handles generate + renew + retry around every API call.
+How:
+client = DhanHQ::Client.new(api_type: :order_api)client.enable_auto_token_management!(  dhan_client_id: ENV["DHAN_CLIENT_ID"],  pin:           ENV["DHAN_PIN"],  totp_secret:   ENV["DHAN_TOTP_SECRET"])# From now on, `client.request` auto-ensures a valid token.
+Behavior:
+On first use: calls TOTP TokenGenerator → applies token.
+Before each request: ensure_valid_token!:
+If no token → generate.
+If needs_refresh? → TokenRenewal (POST /v2/RenewToken) with current token + dhanClientId.
+If renewal fails with auth error → falls back to full generate.
+6️⃣ Web-token renewal only (RenewToken)
+Module API:
+response = DhanHQ::Auth.renew_token(  access_token: current_token,  client_id:    ENV["DHAN_CLIENT_ID"])
+Client / manager (high-level):
+client.renew_access_token (returns TokenResponse, updates config).
+TokenManager#refresh! internally uses Auth::TokenRenewal.
+When: You’re using web-generated 24h tokens and want to extend them without switching to TOTP.
+TL;DR
+Manual: Static token (access_token)
+Dynamic: access_token_provider (+ optional on_token_expired)
+Central service: configure_from_token_endpoint
+Fully automated: TOTP generate (Auth / Client#generate_access_token)
+Production-grade automation: enable_auto_token_management! (generate + renew)
+If you tell me your exact deployment style (single user box, multi-user SaaS, on-prem, etc.), I can tell you which one you should actually use and what to delete as overkill.

data/docs/TESTING_GUIDE.md

@@ -72,8 +72,8 @@ puts "Token provider: #{DhanHQ.configuration.access_token_provider ? 'Set' : 'No
 
 ```ruby
 # Check current environment variables
-puts "CLIENT_ID: #{ENV['CLIENT_ID']}"
-puts "ACCESS_TOKEN: #{ENV['ACCESS_TOKEN'] ? 'Set' : 'Not Set'}"
+puts "DHAN_CLIENT_ID: #{ENV['DHAN_CLIENT_ID']}"
+puts "DHAN_ACCESS_TOKEN: #{ENV['DHAN_ACCESS_TOKEN'] ? 'Set' : 'Not Set'}"
 puts "DHAN_LOG_LEVEL: #{ENV['DHAN_LOG_LEVEL'] || 'INFO'}"
 puts "DHAN_CONNECT_TIMEOUT: #{ENV['DHAN_CONNECT_TIMEOUT'] || '10'}"
 puts "DHAN_READ_TIMEOUT: #{ENV['DHAN_READ_TIMEOUT'] || '30'}"
@@ -521,7 +521,7 @@ if position
     to_product_type: "MARGIN",
     quantity: position.net_qty.abs
   )
-  
+
   if result
     puts "Position converted successfully"
   else
@@ -784,22 +784,22 @@ if instrument
   # Get LTP
   ltp_data = instrument.ltp
   puts "LTP: ₹#{ltp_data[:last_price]}"
-  
+
   # Get OHLC
   ohlc_data = instrument.ohlc
   puts "OHLC: #{ohlc_data[:ohlc]}"
-  
+
   # Get Quote
   quote_data = instrument.quote
   puts "Quote: #{quote_data[:ltp]}"
-  
+
   # Get Daily Historical Data
   daily_data = instrument.daily(
     from_date: Date.today - 7,
     to_date: Date.today
   )
   puts "Daily candles: #{daily_data.size}"
-  
+
   # Get Intraday Historical Data
   intraday_data = instrument.intraday(
     from_date: Date.today,
@@ -807,7 +807,7 @@ if instrument
     interval: 5
   )
   puts "Intraday candles: #{intraday_data.size}"
-  
+
   # Get Expiry List (for F&O instruments)
   if instrument.instrument == "FUTSTK" || instrument.instrument == "OPTSTK"
     expiry_list = instrument.expiry_list
@@ -922,65 +922,63 @@ end
 
 ### EDIS
 
-#### Get EDIS Form
+EDIS is resource-only per [dhanhq.co/docs/v2/edis](https://dhanhq.co/docs/v2/edis/). Use `DhanHQ::Resources::Edis`.
+
+#### Get TPIN (GET /edis/tpin)
 
 ```ruby
-# Get EDIS form
-edis_form = DhanHQ::Models::Edis.form
-puts "EDIS Form:"
-puts "  ISIN: #{edis_form[:isin]}"
-puts "  Quantity: #{edis_form[:quantity]}"
+edis = DhanHQ::Resources::Edis.new
+tpin_response = edis.tpin
+puts "TPIN: #{tpin_response}"
 ```
 
-#### Get Bulk EDIS Form
+#### Form (POST /edis/form)
 
 ```ruby
-# Get bulk EDIS form
-bulk_form = DhanHQ::Models::Edis.bulk_form
-puts "Bulk Form: #{bulk_form.size} entries"
+edis = DhanHQ::Resources::Edis.new
+response = edis.form(isin: "INE467B01029", qty: 10, exchange: "NSE", segment: "EQ", bulk: false)
+puts "EDIS form: #{response.is_a?(Hash) ? 'OK' : response.class}"
 ```
 
-#### Generate TPIN
+#### Bulk form (POST /edis/bulkform)
 
 ```ruby
-# Generate TPIN
-tpin = DhanHQ::Models::Edis.generate_tpin
-puts "TPIN: #{tpin[:tpin]}"
+edis = DhanHQ::Resources::Edis.new
+response = edis.bulk_form(exchange: "NSE", segment: "EQ", bulk: true)
+puts "EDIS bulk form: #{response.is_a?(Hash) ? 'OK' : response.class}"
 ```
 
-#### Inquire EDIS Status
+#### Inquire (GET /edis/inquire/{isin})
 
 ```ruby
-# Inquire EDIS status by ISIN
-isin = "INE467B01029"  # Example ISIN
-status = DhanHQ::Models::Edis.inquire(isin: isin)
-puts "EDIS Status: #{status[:status]}"
+edis = DhanHQ::Resources::Edis.new
+status = edis.inquire("INE467B01029")
+puts "EDIS status: #{status}"
+# Or pass "ALL" for all holdings
+all_status = edis.inquire("ALL")
 ```
 
 ### Kill Switch
 
-#### Activate Kill Switch
+#### Trader Control (resource-only)
 
 ```ruby
-# Activate kill switch
-result = DhanHQ::Models::KillSwitch.update(status: "ACTIVATE")
-if result
-  puts "Kill switch activated"
-else
-  puts "Failed to activate kill switch"
-end
+tc = DhanHQ::Resources::TraderControl.new
+tc.disable   # Kill switch ON
+tc.enable    # Trading resumed
+tc.status
 ```
 
-#### Deactivate Kill Switch
+#### Kill Switch (model, backward compatible)
 
 ```ruby
+# Activate kill switch
+result = DhanHQ::Models::KillSwitch.update("ACTIVATE")
+puts result[:kill_switch_status] if result.is_a?(Hash)
+
 # Deactivate kill switch
-result = DhanHQ::Models::KillSwitch.update(status: "DEACTIVATE")
-if result
-  puts "Kill switch deactivated"
-else
-  puts "Failed to deactivate kill switch"
-end
+result = DhanHQ::Models::KillSwitch.update("DEACTIVATE")
+puts result[:kill_switch_status] if result.is_a?(Hash)
 ```
 
 ### Expired Options Data

data/docs/live_order_updates.md

@@ -194,8 +194,8 @@ client.start
 ### Environment Variables
 ```bash
 # Required
-CLIENT_ID=your_client_id
-ACCESS_TOKEN=your_access_token
+DHAN_CLIENT_ID=your_client_id
+DHAN_ACCESS_TOKEN=your_access_token
 
 # Optional WebSocket settings
 DHAN_WS_ORDER_URL=wss://api-order-update.dhan.co

data/docs/rails_integration.md

@@ -29,8 +29,8 @@ boot successfully:
 
 | Variable | Description |
 | --- | --- |
-| `CLIENT_ID` | Dhan trading client id for the account you want to trade with. |
-| `ACCESS_TOKEN` | REST/WebSocket access token (regenerate via the Dhan console or APIs). |
+| `DHAN_CLIENT_ID` | Dhan trading client id for the account you want to trade with. |
+| `DHAN_ACCESS_TOKEN` | REST/WebSocket access token (regenerate via the Dhan console or APIs). |
 
 ```bash
 bin/rails credentials:edit
@@ -61,8 +61,8 @@ environment variables (Rails credentials can be copied into ENV on boot):
 require 'dhan_hq'
 
 if (creds = Rails.application.credentials.dig(:dhanhq))
-  ENV['CLIENT_ID']        ||= creds[:client_id]
-  ENV['ACCESS_TOKEN']     ||= creds[:access_token]
+  ENV['DHAN_CLIENT_ID']        ||= creds[:client_id]
+  ENV['DHAN_ACCESS_TOKEN']     ||= creds[:access_token]
   ENV['DHAN_LOG_LEVEL']   ||= creds[:log_level]&.upcase
   ENV['DHAN_BASE_URL']    ||= creds[:base_url]
   ENV['DHAN_WS_ORDER_URL'] ||= creds[:ws_order_url]
@@ -77,8 +77,8 @@ if (creds = Rails.application.credentials.dig(:dhanhq))
 end
 
 # fall back to traditional ENV variables when credentials are not defined
-ENV['CLIENT_ID']    ||= ENV.fetch('DHAN_CLIENT_ID', nil)
-ENV['ACCESS_TOKEN'] ||= ENV.fetch('DHAN_ACCESS_TOKEN', nil)
+ENV['DHAN_CLIENT_ID']    ||= ENV.fetch('DHAN_CLIENT_ID', nil)
+ENV['DHAN_ACCESS_TOKEN'] ||= ENV.fetch('DHAN_ACCESS_TOKEN', nil)
 
 DhanHQ.configure_with_env
 
@@ -108,7 +108,7 @@ initializer calls `DhanHQ.configure_with_env`.
 For token rotation without restarting the app (e.g. token stored in DB or refreshed via OAuth), use `access_token_provider` so the token is resolved at request time:
 
 ```ruby
-# config/initializers/dhanhq.rb (alternative to static ACCESS_TOKEN)
+# config/initializers/dhanhq.rb (alternative to static DHAN_ACCESS_TOKEN)
 DhanHQ.configure do |config|
   config.client_id = ENV["DHAN_CLIENT_ID"] || Rails.application.credentials.dig(:dhanhq, :client_id)
   config.access_token_provider = lambda do