coindcx-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aff1bffd5369c08e4ec429c808b0ec33d15ed8caad1cc2f6a92c31ba9c4c2ded
+  data.tar.gz: a1c49884264af908b3e24f0f2a4d2e3dd871d64cd0fee4cfb35e6813e0129fff
+SHA512:
+  metadata.gz: 727949f960ce763d670a4687361aa8a379028d9828f8ebd250cd8113ba5c34aa7fb135a96428f24badc006139b4f2cbe792b6d6f308e460972b2d9c8bc142d82
+  data.tar.gz: 84c1dceb9aba5448f127c2fd42168ed4b500594285860dac9d60395db8180d287e65739aea945c6cc570419d34b9fef79c747c8f654ab2b5b46eda865050fad4

data/.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [ main ]
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        ruby: ['3.2', '3.3']
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - name: Install dependencies
+        run: bundle install
+
+      - name: Verify version matches tag
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: |
+          VERSION=$(ruby -e "require './lib/coindcx/version'; puts CoinDCX::VERSION")
+          TAG=${GITHUB_REF#refs/tags/v}
+
+          if [ "$VERSION" != "$TAG" ]; then
+            echo "Version mismatch: $VERSION != $TAG"
+            exit 1
+          fi
+
+      - name: Run RuboCop
+        run: bundle exec rubocop
+
+      - name: Run RSpec
+        run: bundle exec rspec
+
+      - name: Verify coverage
+        run: |
+          if [ -f coverage/.last_run.json ]; then
+            cat coverage/.last_run.json
+          else
+            echo "coverage/.last_run.json not found"
+            exit 1
+          fi

data/.github/workflows/release.yml

@@ -0,0 +1,138 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Gem version to publish (must match lib/coindcx/version.rb)'
+        required: true
+      publish:
+        description: 'Publish to RubyGems'
+        required: true
+        type: boolean
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: rubygems-release
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2'
+          bundler-cache: true
+
+      - name: Run compatibility tests on minimum Ruby
+        run: bundle exec rspec
+
+      - name: Setup release Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - name: Install dependencies
+        run: bundle install
+
+      - name: Resolve release version
+        id: release_version
+        run: |
+          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
+            echo "value=${GITHUB_REF#refs/tags/v}" >> "$GITHUB_OUTPUT"
+          else
+            echo "value=${{ github.event.inputs.version }}" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Verify version matches release trigger
+        run: |
+          VERSION=$(ruby -e "require './lib/coindcx/version'; puts CoinDCX::VERSION")
+          TARGET_VERSION='${{ steps.release_version.outputs.value }}'
+
+          if [ "$VERSION" != "$TARGET_VERSION" ]; then
+            echo "Version mismatch: $VERSION != $TARGET_VERSION"
+            exit 1
+          fi
+
+      - name: Verify changelog entry exists
+        run: |
+          if [ ! -f CHANGELOG.md ]; then
+            echo "CHANGELOG.md is required for releases"
+            exit 1
+          fi
+
+          TARGET_VERSION='${{ steps.release_version.outputs.value }}'
+          if ! ruby -e "
+            version = ARGV[0]
+            found = File.read('CHANGELOG.md').lines.any? { |line| line.match?(/\A##\s+#{Regexp.escape(version)}\s*\z/) }
+            exit(found ? 0 : 1)
+          " "$TARGET_VERSION"; then
+            echo "Missing CHANGELOG entry for ${TARGET_VERSION}"
+            exit 1
+          fi
+
+      - name: Verify tag is on the current commit
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: |
+          TAG_COMMIT=$(git rev-list -n 1 "${GITHUB_REF}")
+          HEAD_COMMIT=$(git rev-parse HEAD)
+
+          if [ "$TAG_COMMIT" != "$HEAD_COMMIT" ]; then
+            echo "Release tag does not point to the checked out commit"
+            exit 1
+          fi
+
+      - name: Run RuboCop
+        run: bundle exec rubocop
+
+      - name: Run tests (gate)
+        run: bundle exec rspec
+
+      - name: Build gem
+        run: gem build coindcx-client.gemspec
+
+      - name: Verify built artifact
+        run: |
+          ls -1 coindcx-client-*.gem
+          gem specification coindcx-client-*.gem version > /tmp/gem-version.txt
+          gem specification coindcx-client-*.gem name platform > /tmp/gem-spec.txt
+          cat /tmp/gem-version.txt
+          cat /tmp/gem-spec.txt
+          if ! grep -qF "${{ steps.release_version.outputs.value }}" /tmp/gem-version.txt; then
+            echo "Built gem version does not match release version"
+            exit 1
+          fi
+
+      # Same pattern as dhanhq-client: API key via GEM_HOST_API_KEY + TOTP for RubyGems MFA.
+      # Add RUBYGEMS_OTP_SECRET (base32) to the rubygems-release environment secrets.
+      - name: Install OTP generator
+        if: startsWith(github.ref, 'refs/tags/v') || github.event.inputs.publish == 'true'
+        run: gem install rotp
+
+      - name: Publish to RubyGems
+        if: startsWith(github.ref, 'refs/tags/v') || github.event.inputs.publish == 'true'
+        env:
+          GEM_HOST_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
+          RUBYGEMS_OTP_SECRET: ${{ secrets.RUBYGEMS_OTP_SECRET }}
+        run: |
+          set -euo pipefail
+          otp_code=$(ruby -r rotp -e "puts ROTP::TOTP.new(ENV['RUBYGEMS_OTP_SECRET']).now")
+          gem_version=$(ruby -e "require './lib/coindcx/version'; puts CoinDCX::VERSION")
+          gem_file="coindcx-client-${gem_version}.gem"
+          if [ ! -f "$gem_file" ]; then
+            echo "ERROR: Gem file not found: $gem_file"
+            ls -la ./*.gem 2>/dev/null || echo "No gem files in working directory"
+            exit 1
+          fi
+          gem push "$gem_file" --otp "$otp_code"

data/.rubocop.yml

@@ -0,0 +1,56 @@
+AllCops:
+  TargetRubyVersion: 3.2
+  NewCops: enable
+  SuggestExtensions: false
+  Exclude:
+    - 'vendor/**/*'
+
+Layout/LineLength:
+  Max: 140
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+    - '.github/workflows/*.yml'
+
+Metrics/ClassLength:
+  Max: 120
+  Exclude:
+    - 'scripts/**/*'
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - 'scripts/**/*'
+
+Metrics/MethodLength:
+  Max: 15
+  Exclude:
+    - 'scripts/**/*'
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - 'scripts/**/*'
+
+Metrics/ParameterLists:
+  Max: 7
+
+Lint/ScriptPermission:
+  Exclude:
+    - 'scripts/**/*'
+
+Naming/BlockForwarding:
+  Enabled: false
+
+Style/ArgumentsForwarding:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false

data/AGENT.md

@@ -0,0 +1,352 @@
+# AGENT.md — CoinDCX Client (Pattern-Enforced Architecture)
+
+## 1. Design Philosophy
+
+- patterns are tools, not goals
+- each pattern must solve a real constraint
+- zero speculative abstraction
+
+## 2. Approved Design Patterns (STRICT)
+
+Only these patterns are allowed.
+
+| Pattern | Mandatory | Reason |
+| --- | --- | --- |
+| Factory | yes | resource/client creation |
+| Strategy | yes | auth + retry + rate limit |
+| Adapter | yes | HTTP + Socket.io isolation |
+| Observer | yes | WebSocket event system |
+| Command | yes | order execution encapsulation |
+| Template Method | yes | REST execution pipeline |
+| Builder | yes | request construction |
+| Decorator | yes | logging + retry wrapping |
+| Singleton | limited | config only |
+| Facade | yes | client interface |
+| State | limited | WS only, connection lifecycle |
+
+Everything else -> reject.
+
+## 3. Pattern Mapping to System
+
+### 3.1 Facade Pattern -> Client
+
+Purpose:
+
+- expose clean interface
+- `client.public.markets`
+- `client.spot.place_order(...)`
+- `client.ws.subscribe(...)`
+
+Implementation:
+
+```ruby
+module Coindcx
+  class Client
+    def public
+      @public ||= Rest::Public::Facade.new(http_client)
+    end
+
+    def spot
+      @spot ||= Rest::Spot::Facade.new(http_client)
+    end
+
+    def ws
+      @ws ||= Ws::Facade.new(ws_client)
+    end
+  end
+end
+```
+
+### 3.2 Factory Pattern -> Resource Creation
+
+Purpose:
+
+- decouple instantiation
+
+```ruby
+module Coindcx
+  class ResourceFactory
+    def self.build(type, client)
+      case type
+      when :markets then Rest::Public::Markets.new(client)
+      when :orders  then Rest::Spot::Orders.new(client)
+      else raise "Unknown resource"
+      end
+    end
+  end
+end
+```
+
+### 3.3 Strategy Pattern -> Auth / Retry / RateLimit
+
+Purpose:
+
+- swap runtime behavior without branching chaos
+
+Auth Strategy:
+
+```ruby
+class HmacAuthStrategy
+  def sign(payload, secret)
+    OpenSSL::HMAC.hexdigest('SHA256', secret, payload.to_json)
+  end
+end
+```
+
+Retry Strategy:
+
+```ruby
+class ExponentialBackoffStrategy
+  def execute
+    retries = 0
+    begin
+      yield
+    rescue => e
+      raise if retries >= 3
+      sleep(2 ** retries)
+      retries += 1
+      retry
+    end
+  end
+end
+```
+
+### 3.4 Adapter Pattern -> HTTP + Socket.io
+
+Purpose:
+
+- shield external libraries
+
+HTTP Adapter:
+
+```ruby
+class FaradayAdapter
+  def call(method, url, payload, headers)
+    Faraday.public_send(method, url) do |req|
+      req.headers = headers
+      req.body = payload.to_json if method == :post
+    end
+  end
+end
+```
+
+Socket Adapter:
+
+```ruby
+class SocketIoAdapter
+  def initialize(url)
+    @socket = SocketIO::Client::Simple.connect(url)
+  end
+
+  def emit(event, payload)
+    @socket.emit(event, payload)
+  end
+
+  def on(event, &block)
+    @socket.on(event, &block)
+  end
+end
+```
+
+### 3.5 Observer Pattern -> WebSocket Events (CRITICAL)
+
+Reference: Observer Pattern Ruby example
+
+Purpose:
+
+- event-driven system (mandatory for trading)
+
+Subject:
+
+```ruby
+module Coindcx
+  module Ws
+    class EventBus
+      def initialize
+        @listeners = {}
+      end
+
+      def subscribe(event, listener)
+        @listeners[event] ||= []
+        @listeners[event] << listener
+      end
+
+      def publish(event, data)
+        (@listeners[event] || []).each do |listener|
+          listener.call(data)
+        end
+      end
+    end
+  end
+end
+```
+
+Usage:
+
+```ruby
+event_bus.subscribe(:ltp_update, ->(data) {
+  puts data
+})
+
+event_bus.publish(:ltp_update, payload)
+```
+
+### 3.6 Command Pattern -> Order Execution
+
+Purpose:
+
+- encapsulate actions (important for retries + audit)
+
+```ruby
+class PlaceOrderCommand
+  def initialize(client, params)
+    @client = client
+    @params = params
+  end
+
+  def execute
+    @client.post("/orders", @params)
+  end
+end
+```
+
+### 3.7 Template Method -> HTTP Pipeline
+
+Purpose:
+
+- standardize request flow
+
+```ruby
+class BaseRequest
+  def execute
+    validate
+    payload = build_payload
+    signed = sign(payload)
+    response = send_request(signed)
+    parse(response)
+  end
+
+  def validate; end
+  def build_payload; end
+  def sign(payload); payload; end
+  def send_request(payload); end
+  def parse(response); end
+end
+```
+
+### 3.8 Builder Pattern -> Request Construction
+
+Purpose:
+
+- avoid hash chaos
+
+```ruby
+class OrderBuilder
+  def initialize
+    @params = {}
+  end
+
+  def symbol(val); @params[:symbol] = val; self; end
+  def side(val); @params[:side] = val; self; end
+  def quantity(val); @params[:quantity] = val; self; end
+
+  def build
+    raise "Missing fields" unless @params[:symbol]
+    @params
+  end
+end
+```
+
+### 3.9 Decorator Pattern -> Logging / Retry
+
+Purpose:
+
+- add behavior without modifying core
+
+```ruby
+class LoggingDecorator
+  def initialize(client, logger)
+    @client = client
+    @logger = logger
+  end
+
+  def call(*args)
+    start = Time.now
+    result = @client.call(*args)
+    @logger.info("Latency: #{Time.now - start}")
+    result
+  end
+end
+```
+
+### 3.10 State Pattern -> WebSocket Lifecycle
+
+Purpose:
+
+- handle connection transitions cleanly
+
+```ruby
+class ConnectedState
+  def handle(context)
+    # active
+  end
+end
+
+class ReconnectingState
+  def handle(context)
+    context.reconnect
+  end
+end
+```
+
+## 4. Pattern Anti-Abuse Rules
+
+Reject if:
+
+- pattern used without clear constraint
+- multiple patterns solving same problem
+- inheritance chains > 2 levels
+- over-engineered builders for simple calls
+
+## 5. Critical Integration Insight
+
+Where Observer connects to your system:
+
+- `CoinDCX WS -> EventBus -> AlgoTradingApi -> Exit Engine`
+
+This is how you replicate:
+
+- Dhan WebSocket feed
+- ActiveCache updates
+- real-time exit logic
+
+## 6. What NOT to implement (explicit)
+
+- Repository pattern (no DB)
+- Service layer (anti-pattern for this gem)
+- CQRS (overkill)
+- Event sourcing (belongs to trading system)
+- ActiveRecord-style models
+
+## 7. Final Enforcement Rule
+
+> Every pattern must map to a production failure mode.
+
+If it doesn't: -> remove it.
+
+## 8. Next Step
+
+If proceeding correctly, the next move is:
+
+- bootstrap with patterns wired from day 1
+
+I can generate:
+
+- full gem scaffold
+- all patterns pre-wired
+- working REST + WS base
+- RSpec coverage
+
+Say:
+
+`bootstrap pattern gem`