delta_exchange 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7e237fcff01ceb49340e97b9488881c8db98854360a69d44f809bb7eb2714dac
+  data.tar.gz: 10f2351163211453f02454f6d1b22d53dbea71d6ec4e3b26de7479720438ac1b
+SHA512:
+  metadata.gz: 28e3ed680eaa5d5f88cfb715eb3f4288b9b71657801a0237c608d1bbb307a89b1c8610d5e8a3fe2cfe407237edd1d39a79a1758f36518fb475c324ee17ee6047
+  data.tar.gz: bb3e23553b102c42264682ff961ca427179fc39d8e1302020e94a352c71380a87f1aed032cfab5f0aa9b8eae9bcc8e61dc117aed5a965a050062846cd75eaad8

data/.cursor/.gitignore

@@ -0,0 +1 @@
+plans/

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+## [Unreleased]
+
+## [0.1.2] - 2026-03-25
+### Changed
+- Refactored `Models` namespace wrapper classes to invoke resource dependencies through a global lazy `DeltaExchange.client` factory, enforcing Dependency Injection boundaries natively and patching `ArgumentError` crashes.
+- Hardened WebSockets `Faye` bindings and stabilized internal EventMachine reactor loops bridging payload sockets directly over Testnet domain gateways.
+- Expanded core client capabilities utilizing dynamic `set_leverage` modifiers, VCR-tested Dry-Validation wrappers, and exhaustive test coverage matrices shielding internal `raise ApiError` resolutions.
+
+## [0.1.1] - 2026-03-21
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"delta_exchange" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["shubhamtaywade82@gmail.com"](mailto:"shubhamtaywade82@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Shubham Taywade
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,253 @@
+# DeltaExchange
+
+A Ruby client for the Delta Exchange API.
+
+![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.2.0-red)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Quick Links
+
+| Resource | Document | Description |
+|----------|----------|-------------|
+| **Orders** | [REST API Guide](docs/REST_API_GUIDE.md#orders) | Create, manage, and cancel orders |
+| **Products** | [REST API Guide](docs/REST_API_GUIDE.md#products) | Fetch trading pairs and market specs |
+| **WebSocket** | [WebSocket Guide](docs/WEBSOCKET_GUIDE.md) | Real-time data streams |
+| **Auth** | [Authentication](docs/AUTHENTICATION.md) | API Key & Signature management |
+
+---
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'delta_exchange'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install delta_exchange
+
+## Releasing
+
+Publishing is handled by GitHub Actions when a version tag is pushed.
+
+### One-time RubyGems setup
+
+Configure `delta_exchange` as a trusted publisher on RubyGems.org:
+
+1. Open the gem page on RubyGems.org and manage trusted publishers.
+2. Add this GitHub repository:
+   - Owner: `shubhamtaywade82`
+   - Repository: `delta_exchange`
+   - Workflow file: `release.yml`
+   - Environment: `release`
+3. Save the publisher configuration.
+
+This uses GitHub OIDC trusted publishing, so the workflow does not need a long-lived `RUBYGEMS_API_KEY` or OTP secret. RubyGems must match all four values exactly.
+
+### Release a new version
+
+1. Update `lib/delta_exchange/version.rb`.
+2. Update `CHANGELOG.md`.
+3. Merge the changes to `main`.
+4. Create and push a matching tag:
+
+```bash
+git tag v0.1.2
+git push origin v0.1.2
+```
+
+The release workflow validates that the tag matches `DeltaExchange::VERSION` before publishing the gem to RubyGems.org.
+
+## Documentation
+
+For detailed guides and examples, see:
+
+*   [Getting Started](docs/GETTING_STARTED.md)
+*   [Authentication Guide](docs/AUTHENTICATION.md)
+*   [REST API Guide](docs/REST_API_GUIDE.md)
+*   [WebSocket Guide](docs/WEBSOCKET_GUIDE.md)
+*   [Rails Integration](docs/RAILS_INTEGRATION.md)
+*   [Standalone Ruby Guide](docs/STANDALONE_RUBY_GUIDE.md)
+
+## Usage
+
+### Configuration
+
+```ruby
+DeltaExchange.configure do |config|
+  config.api_key = ENV['DELTA_API_KEY'] || 'YOUR_API_KEY'
+  config.api_secret = ENV['DELTA_API_SECRET'] || 'YOUR_API_SECRET'
+  config.testnet = true # Optional, defaults to false
+  config.websocket_reconnect_delay = 5 # Optional, defaults to 5 seconds
+end
+```
+
+**Note:** If you are testing the client via `./bin/console`, it will automatically load any variables from a `.env` file in the root directory into `ENV`.
+
+### REST API
+
+The client employs a highly robust **ActiveRecord**-style abstraction via the `DeltaExchange::Models::` namespace. Rather than interacting with raw unstructured JSON payloads via `Client.new`, you query the platform utilizing structured properties and class-level queries. 
+
+#### 1. Products & Market Data
+Retrieve available trading pairs, orderbooks, and option chains natively.
+```ruby
+# Get all products (returns array of Models::Product)
+DeltaExchange::Models::Product.all
+
+product = DeltaExchange::Models::Product.find('BTCUSD')
+puts product.contract_type # "perpetual_futures"
+
+# Get all live tickers and access price via .close (India API standard)
+ticker = DeltaExchange::Models::Ticker.find('BTCUSD')
+puts "Current Price: #{ticker.close}"
+
+# Get all live tickers
+DeltaExchange::Models::Ticker.all
+
+# Mutating methods like set_leverage return the raw API response hash
+response = product.set_leverage(50)
+puts "New Leverage: #{response[:leverage]}"
+```
+
+#### 2. Orders
+Create, manage, and cancel your active orders.
+```ruby
+# Create a new order (Returns a Models::Order)
+order = DeltaExchange::Models::Order.create({
+  product_id: 1,
+  size: 10,
+  side: 'buy',
+  order_type: 'limit_order',
+  limit_price: '50000'
+})
+
+# Access properties
+puts order.status # "open"
+
+# List your active orders
+DeltaExchange::Models::Order.all
+
+# Cancel the order directly from its instance
+order.cancel
+```
+
+#### 3. Positions & Fills
+Track open derivatives positions and execution histories cleanly.
+
+You can instantly execute commands atop the models natively using class methods. This bypasses structural scaffolding because the library manages connections globally by default!
+
+```ruby
+# Retrieve Native Ruby Objects instead of messy Array Hashes
+orders = DeltaExchange::Models::Order.all
+
+# Manipulate endpoints using direct class directives
+DeltaExchange::Models::Position.close_all(
+  product_id: 27 # BTCUSD testnet
+)
+
+# Find an isolated position by Product ID
+position = DeltaExchange::Models::Position.find(1)
+
+# Modify your isolated positions natively
+position.adjust_margin('150.5', type: 'add')
+position.set_auto_topup(true)
+
+# Retrieve recent trade fills (Returns an array of Models::Fill)
+DeltaExchange::Models::Fill.all(product_id: 1, limit: 50)
+```
+
+#### 4. Account & Wallet
+Monitor balances and configure account-level preferences.
+```ruby
+# Get wallet balances across all assets
+DeltaExchange::Models::WalletBalance.all
+
+# Isolate a specific currency balance
+btc_balance = DeltaExchange::Models::WalletBalance.find_by_asset('BTC')
+
+# List recent wallet transactions
+DeltaExchange::Models::WalletTransaction.all
+
+# View your user profile details
+profile = DeltaExchange::Models::Profile.fetch
+puts "Hello #{profile.first_name}!"
+
+# Update trading preferences natively
+prefs = DeltaExchange::Models::TradingPreferences.fetch
+puts "User ID: #{prefs.user_id}"
+prefs.update(cancel_on_disconnect: true)
+```
+
+#### 5. Assets & Indices
+Pull infrastructure parameters mapping indices to component assets.
+```ruby
+# Get all platform assets
+DeltaExchange::Models::Asset.all
+
+# Get all tracked indices
+DeltaExchange::Models::Index.all
+```
+
+### Error Handling
+
+The gem wraps network and API responses within native Ruby classes.
+
+```ruby
+begin
+  client.orders.create({ product_id: 999999, size: 10 })
+rescue DeltaExchange::RateLimitError => e
+  puts "Rate limited! Retry after #{e.retry_after_seconds} seconds"
+rescue DeltaExchange::ApiError => e
+  puts "API rejected the request: #{e.message} (Code: #{e.code})"
+rescue DeltaExchange::NetworkError => e
+  puts "Could not connect: #{e.message}"
+end
+```
+
+### WebSocket
+
+> [!IMPORTANT]
+> The WebSocket client uses EventMachine in a detached thread. While the gem handles automatic reconnections, you must ensure your main process remains alive (e.g., via `loop { sleep 1 }` or joining the EM thread).
+
+```ruby
+ws = DeltaExchange::Websocket::Client.new
+
+ws.on :open do |event|
+  puts "Connected!"
+  ws.subscribe([
+    { name: "v2/ticker", symbols: ["BTCUSD"] }
+  ])
+end
+
+ws.on :message do |data|
+  puts "Received: #{data}"
+end
+
+ws.connect!
+
+# Keep the main thread alive if necessary
+loop { sleep 1 }
+```
+
+## Debugging
+
+You can enable HTTP traffic logging via the command-line environment variables. 
+The `api-key` and `signature` headers are **automatically redacted** during debug rendering to protect your credentials.
+
+```bash
+DELTA_DEBUG=true ruby app.rb
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/shubhamtaywade82/delta_exchange.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/docs/AUTHENTICATION.md

@@ -0,0 +1,49 @@
+# Authentication Details
+
+DeltaExchange v2 uses a signature-based authentication method (HMAC-SHA256).
+
+## Credentials Needed
+
+1.  **API Key**: A unique key provided by Delta Exchange.
+2.  **API Secret**: Used to sign requests (never share this!).
+
+## Configuration Methods
+
+### Block-style (Recommended for Initializers)
+
+```ruby
+DeltaExchange.configure do |config|
+  config.api_key = ENV['DELTA_API_KEY']
+  config.api_secret = ENV['DELTA_API_SECRET']
+  config.testnet = true # Set to false for production
+end
+```
+
+### Direct Initialization
+
+You can also pass credentials directly when creating a client:
+
+```ruby
+client = DeltaExchange::Client.new(
+  api_key: 'custom_key',
+  api_secret: 'custom_secret',
+  testnet: false
+)
+```
+
+## Security Best Practices
+
+*   **Environment Variables**: Never hardcode your API keys in the source code. Use gems like `dotenv` or Rails Credentials.
+*   **IP Whitelisting**: For production, it is highly recommended to whitelist your server's IP in your Delta Exchange API settings.
+*   **Permissions**: Only enable the permissions your bot needs (e.g., "Read" and "Trade"). Avoid "Withdrawal" permissions unless necessary.
+
+## How the Gem Signs Requests
+
+The gem handles signature generation automatically for every authenticated request. The pre-hash string follows the format:
+`method + timestamp + path + query_string + payload`
+
+Example internal logic:
+```ruby
+signature = OpenSSL::HMAC.hexdigest("SHA256", secret, prehash_string)
+```
+This is fully encapsulated in the `DeltaExchange::Auth` module.

data/docs/GETTING_STARTED.md

@@ -0,0 +1,67 @@
+# Getting Started with DeltaExchange
+
+DeltaExchange is a powerful Ruby gem designed for algorithmic trading on the Delta Exchange India platform. It provides a clean, model-based interface for REST API v2 and a real-time WebSocket client.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'delta_exchange'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+## Basic Configuration
+
+The gem needs to be configured with your API credentials. You can do this in an initializer (for Rails) or at the top of your script.
+
+```ruby
+require 'delta_exchange'
+
+DeltaExchange.configure do |config|
+  config.api_key = 'YOUR_API_KEY'
+  config.api_secret = 'YOUR_API_SECRET'
+  config.testnet = true # Use Delta Testnet for testing
+end
+```
+
+## Quick Start Example
+
+```ruby
+# 1. Initialize the client
+client = DeltaExchange::Client.new
+
+# 2. Fetch all products
+products = client.products.all
+
+# 3. Find a specific product (e.g., BTCUSD perpetual)
+btc_perp = products.find { |p| p[:symbol] == 'BTCUSD' }
+puts "Trading #{btc_perp[:symbol]} with ID: #{btc_perp[:id]}"
+
+# 4. Check your balance
+balances = client.wallet.balances
+puts "Available USDT: #{balances.find { |b| b[:asset_symbol] == 'USDT' }[:available_balance]}"
+
+# 5. Place a limit order
+order = client.orders.create(
+  product_id: btc_perp[:id],
+  size: 10,
+  side: 'buy',
+  order_type: 'limit_order',
+  limit_price: '50000.0'
+)
+puts "Order placed! ID: #{order[:id]}"
+```
+
+## Next Steps
+
+*   [Authentication Details](./AUTHENTICATION.md)
+*   [REST API Guide](./REST_API_GUIDE.md)
+*   [WebSocket Guide](./WEBSOCKET_GUIDE.md)
+*   [Rails Integration](./RAILS_INTEGRATION.md)
+*   [Standalone Ruby Guide](./STANDALONE_RUBY_GUIDE.md)

data/docs/RAILS_INTEGRATION.md

@@ -0,0 +1,135 @@
+# Rails Integration Guide
+
+Integrating the DeltaExchange gem into a Rails application is simple.
+
+## Step 1: Add the Gem
+
+Add the gem to your `Gemfile`:
+
+```ruby
+gem 'delta_exchange'
+```
+
+And run:
+
+```bash
+bundle install
+```
+
+## Step 2: Configure with Initializer
+
+Create `config/initializers/delta_exchange.rb`:
+
+```ruby
+# frozen_string_literal: true
+
+DeltaExchange.configure do |config|
+  config.api_key = Rails.application.credentials.dig(:delta, :api_key)
+  config.api_secret = Rails.application.credentials.dig(:delta, :api_secret)
+  config.testnet = Rails.env.development? || Rails.env.test?
+end
+```
+
+## Step 3: Use in Models or Services
+
+For best practices, wrap the client in a service class:
+
+```ruby
+# app/services/trading_service.rb
+class TradingService
+  def initialize
+    @client = DeltaExchange::Client.new
+  end
+
+  def place_btc_limit_order(price, size)
+    @client.orders.create(
+      product_id: 1, # BTCUSD
+      size: size,
+      side: 'buy',
+      order_type: 'limit_order',
+      limit_price: price.to_s
+    )
+  end
+end
+```
+
+## Step 4: Background Jobs for WebSocket
+
+Since WebSockets need a persistent connection, it's best to run them in a separate process. You can use a custom rake task or a background job (like Sidekiq) to manage the stream.
+
+**Example Rake Task (`lib/tasks/trading.rake`):**
+
+```ruby
+namespace :trading do
+  desc "Start the Delta Exchange WebSocket stream"
+  task stream: :environment do
+    ws = DeltaExchange::Websocket::Client.new
+    
+    ws.on :message do |data|
+      # Handle live updates and maybe update your database
+      if data['type'] == 'v2/ticker'
+        MarketPrice.update_price(data['symbol'], data['last_price'])
+      end
+    end
+
+    ws.on :open do
+      puts "Market stream active..."
+      ws.subscribe([{ name: "v2/ticker", symbols: ["BTCUSD"] }])
+    end
+
+    ws.connect!
+    
+    # Keep the task alive
+    loop { sleep 1 }
+  end
+end
+```
+
+## Step 5: Real-time UI with ActionCable
+
+You can broadcast the incoming WebSocket data from the Rake task to your frontend using Rails ActionCable:
+
+```ruby
+# inside the rake task's :message block
+ActionCable.server.broadcast('price_channel', { symbol: data['symbol'], price: data['last_price'] })
+```
+
+## Step 6: Caching Real-time Data (Redis/Rails Cache)
+
+For high-frequency data like LTP (Last Traded Price), you typically want to store the latest value in a fast cache so that your controllers, models, or other background jobs can access it instantly without hitting the database.
+
+### Using Rails.cache
+
+```ruby
+# inside the rake task's :message block
+if data['type'] == 'v2/ticker'
+  Rails.cache.write("ltp:#{data['symbol']}", data['last_price'])
+end
+
+# accessing it anywhere else in Rails
+ltp = Rails.cache.read("ltp:BTCUSD")
+```
+
+### Using Redis Directly (Recommended for Performance)
+
+If you have a dedicated Redis instance for market data:
+
+```ruby
+# inside the rake task's :message block
+$redis.hset("delta:ltp", data['symbol'], data['last_price'])
+
+# accessing it elsewhere
+ltp = $redis.hget("delta:ltp", "BTCUSD")
+```
+
+### Pattern: Fetcher Helper
+
+It's common to create a helper in your `MarketPrice` model or a specific service:
+
+```ruby
+class MarketPrice
+  def self.ltp(symbol)
+    Rails.cache.read("ltp:#{symbol}") || DeltaExchange::Models::Ticker.find(symbol)&.last_price
+  end
+end
+```