DhanHQ 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26a3e58a35f27dcc1902c2ec1c6849f0e03f80b5123c6ac310588c8e7a0d3a58
-  data.tar.gz: 516cc99f9e3a61f8ec261788babc4309f1b6acc97b1c0ef98f5dbe22b1499217
+  metadata.gz: b583e87aa598f3891e937f44859f9b451fc8f6bcec7a304cc0c33790fe9117ea
+  data.tar.gz: 1a090fa608fba141da311ba8aaf21d36e750f78e90497f728c5f96d580044c7e
 SHA512:
-  metadata.gz: ce920dd5a3804a4b7ddc41867f742ea187fe38255c1468c4a0f1528641dc144752571591de74812241b2d985c40381604a235032250eb4580d6e3b4ad2ffc0bc
-  data.tar.gz: 418f01c9b4bebc8bda9e8d20567dc6d157b60fad7e00eda2522106fd9abfdea607142179e50f2c79c7cfa45a246941be252263354737a8279cb8ab7152d0b9b3
+  metadata.gz: '0966f2a2aa331b675ecc1675510f6ad3dca6b7a987c8dde15dde2efe506ac659157b6e0979d0c23f480d2835fa603bfd37530f33275d422226abb2419e46bfd0'
+  data.tar.gz: 74ea10d0744fb01324afd4a1768fa6969b07f4d1fcb9da94d7a6caf01fd01c2863d6a3746d288628d10e497bd55c68687e0b54e237bd91736ad4bb8c1decc9f8

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ---
 
+## [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

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.

data/README.md

@@ -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/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

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

data/docs/standalone_ruby_websocket_integration.md

@@ -31,8 +31,8 @@ require 'dhan_hq'
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 
@@ -59,8 +59,8 @@ market_client.stop
 
 ```bash
 # Set environment variables
-export CLIENT_ID="your_client_id"
-export ACCESS_TOKEN="your_access_token"
+export DHAN_CLIENT_ID="your_client_id"
+export DHAN_ACCESS_TOKEN="your_access_token"
 
 # Run the script
 ruby market_feed_script.rb
@@ -74,8 +74,8 @@ For dynamic token at request time use `config.access_token_provider`. For web-ge
 
 ```bash
 # Required
-export CLIENT_ID="your_client_id"
-export ACCESS_TOKEN="your_access_token"
+export DHAN_CLIENT_ID="your_client_id"
+export DHAN_ACCESS_TOKEN="your_access_token"
 
 # Optional
 export DHAN_WS_USER_TYPE="SELF"  # or "PARTNER"
@@ -132,8 +132,8 @@ require 'json'
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 
@@ -264,8 +264,8 @@ require 'json'
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 
@@ -394,8 +394,8 @@ require 'json'
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 
@@ -542,8 +542,8 @@ WorkingDirectory=/opt/dhanhq-market-feed
 ExecStart=/usr/bin/ruby market_feed_daemon.rb
 Restart=always
 RestartSec=10
-Environment=CLIENT_ID=your_client_id
-Environment=ACCESS_TOKEN=your_access_token
+Environment=DHAN_CLIENT_ID=your_client_id
+Environment=DHAN_ACCESS_TOKEN=your_access_token
 Environment=DHAN_WS_USER_TYPE=SELF
 
 [Install]
@@ -562,8 +562,8 @@ require 'fileutils'
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 
@@ -779,8 +779,8 @@ require 'json'
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 
@@ -1061,8 +1061,8 @@ require 'json'
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 
@@ -1264,8 +1264,8 @@ end
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
   config.logger = logger
 end
@@ -1383,8 +1383,8 @@ require 'json'
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 

data/docs/technical_analysis.md

@@ -12,7 +12,7 @@ This guide explains how to use the technical analysis modules bundled with this
 
 ## Prerequisites
 
-- Environment variables set: `CLIENT_ID`, `ACCESS_TOKEN`
+- Environment variables set: `DHAN_CLIENT_ID`, `DHAN_ACCESS_TOKEN`
 - Optional indicator gems:
   - `gem install ruby-technical-analysis technical-analysis`
 

data/docs/websocket_integration.md

@@ -28,8 +28,8 @@ require 'dhan_hq'
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 # For dynamic token: use config.access_token_provider. For web-generated tokens, refresh with DhanHQ::Auth.renew_token. API key/Partner flows: implement in your app. See docs/AUTHENTICATION.md.
@@ -787,8 +787,8 @@ puts "Depth subscriptions: #{depth_client.subscriptions}"
 ```ruby
 # ✅ Good: Environment variables
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"]
-  config.access_token = ENV["ACCESS_TOKEN"]
+  config.client_id = ENV["DHAN_CLIENT_ID"]
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"]
 end
 
 # ❌ Bad: Hardcoded credentials

data/examples/comprehensive_websocket_examples.rb

@@ -12,8 +12,8 @@ require "dhan_hq"
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 

data/examples/instrument_finder_test.rb

@@ -8,8 +8,8 @@ require "dhan_hq"
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 

data/examples/market_depth_example.rb

@@ -10,8 +10,8 @@ require "dhan_hq"
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 

data/examples/market_feed_example.rb

@@ -10,8 +10,8 @@ require "dhan_hq"
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 

data/examples/order_update_example.rb

@@ -10,8 +10,8 @@ require "dhan_hq"
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 

data/examples/trading_fields_example.rb

@@ -9,8 +9,8 @@ require "dhan_hq"
 
 # Configure DhanHQ
 DhanHQ.configure do |config|
-  config.client_id = ENV["CLIENT_ID"] || "your_client_id"
-  config.access_token = ENV["ACCESS_TOKEN"] || "your_access_token"
+  config.client_id = ENV["DHAN_CLIENT_ID"] || "your_client_id"
+  config.access_token = ENV["DHAN_ACCESS_TOKEN"] || "your_access_token"
   config.ws_user_type = ENV["DHAN_WS_USER_TYPE"] || "SELF"
 end
 

data/lib/DhanHQ/auth/token_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Auth
+    # Backward-compatible wrapper for token generation.
+    # Delegates to module-level Auth.generate_access_token.
+    class TokenGenerator
+      def generate(dhan_client_id:, pin:, totp: nil, totp_secret: nil)
+        otp = resolve_totp(totp, totp_secret)
+
+        response = Auth.generate_access_token(
+          dhan_client_id: dhan_client_id,
+          pin: pin,
+          totp: otp
+        )
+
+        Models::TokenResponse.new(response)
+      end
+
+      private
+
+      def resolve_totp(totp, secret)
+        totp = totp.to_s.strip
+        return totp unless totp.empty?
+
+        secret = secret.to_s.strip
+        raise ArgumentError, "Provide `totp` or `totp_secret` (e.g. ENV['DHAN_TOTP_SECRET'])" if secret.empty?
+
+        Auth.generate_totp(secret)
+      end
+    end
+  end
+end