orionx-sdk-ruby 1.0.0

data/lib/orionx/api.rb

@@ -0,0 +1,168 @@
+require "faraday"
+require "json"
+require "openssl"
+
+module OrionX
+  class API
+    attr_reader :api_key, :api_secret, :api_endpoint, :config, :logger
+
+    def initialize(api_key: nil, api_secret: nil, api_endpoint: nil, config: nil)
+      @config = config || OrionX.configuration
+      @api_key = api_key || @config.api_key
+      @api_secret = api_secret || @config.api_secret
+      @api_endpoint = api_endpoint || @config.api_endpoint
+      @logger = @config.logger
+
+      validate_credentials!
+      setup_connection
+    end
+
+    def call(query, variables = {})
+      retries = 0
+      begin
+        @logger.debug("GraphQL Query: #{query}")
+        @logger.debug("Variables: #{variables.inspect}")
+
+        response = execute_request(query, variables)
+        handle_response(response)
+      rescue Faraday::TimeoutError => e
+        @logger.error("Request timeout: #{e.message}")
+        raise OrionX::NetworkError, "Request timeout: #{e.message}"
+      rescue Faraday::ConnectionFailed => e
+        @logger.error("Connection failed: #{e.message}")
+        raise OrionX::NetworkError, "Connection failed: #{e.message}"
+      rescue OrionX::APIError => e
+        if retries < @config.retries && retryable_error?(e)
+          retries += 1
+          @logger.warn("Retrying request (attempt #{retries}/#{@config.retries}): #{e.message}")
+          sleep(backoff_delay(retries))
+          retry
+        else
+          raise e
+        end
+      rescue => e
+        @logger.error("Unexpected error: #{e.message}")
+        @logger.debug("Backtrace: #{e.backtrace.join("\n")}")
+        raise OrionX::Error, "Unexpected error: #{e.message}"
+      end
+    end
+
+    private
+
+    def validate_credentials!
+      raise OrionX::AuthenticationError, "API key is required" if @api_key.nil? || @api_key.empty?
+      raise OrionX::AuthenticationError, "API secret is required" if @api_secret.nil? || @api_secret.empty?
+      raise OrionX::ValidationError, "API endpoint is required" if @api_endpoint.nil? || @api_endpoint.empty?
+    end
+
+    def setup_connection
+      @connection = Faraday.new(@api_endpoint) do |conn|
+        conn.request :json
+        conn.response :json, content_type: /\bjson$/
+        conn.options.timeout = @config.timeout
+        conn.adapter Faraday.default_adapter
+        
+        if @config.debug?
+          conn.response :logger, @logger.logger, bodies: true, headers: true
+        end
+      end
+      
+      @logger.info("API connection established to #{@api_endpoint}")
+    end
+
+    def execute_request(query, variables)
+      timestamp = Time.now.to_f
+      body = JSON.generate({ query: query, variables: variables })
+      signature = generate_signature(timestamp.to_s, body)
+
+      headers = {
+        "X-ORIONX-TIMESTAMP" => timestamp.to_s,
+        "X-ORIONX-APIKEY" => @api_key,
+        "X-ORIONX-SIGNATURE" => signature,
+        "Content-Type" => "application/json"
+      }
+
+      @logger.debug("Request headers: #{headers.inspect}")
+      @logger.debug("Request body: #{body}")
+
+      response = @connection.post do |req|
+        req.headers.merge!(headers)
+        req.body = body
+      end
+
+      @logger.debug("Response status: #{response.status}")
+      @logger.debug("Response body: #{response.body.inspect}")
+
+      response
+    end
+
+    def generate_signature(timestamp, body)
+      data = timestamp + body
+      signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha512"), @api_secret, data)
+      @logger.debug("Generated signature for timestamp #{timestamp}")
+      signature
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200
+        handle_success_response(response.body)
+      when 401
+        @logger.error("Authentication failed")
+        raise OrionX::AuthenticationError, "Authentication failed: Invalid API credentials"
+      when 429
+        @logger.error("Rate limit exceeded")
+        raise OrionX::RateLimitError, "Rate limit exceeded"
+      when 500
+        @logger.error("Internal server error")
+        raise OrionX::APIError, "Internal server error"
+      else
+        @logger.error("Unexpected response status: #{response.status}")
+        raise OrionX::APIError, "HTTP #{response.status}: #{response.body}"
+      end
+    end
+
+    def handle_success_response(body)
+      return {} if body.nil? || body.empty?
+
+      if body.is_a?(String)
+        begin
+          parsed_body = JSON.parse(body)
+        rescue JSON::ParserError => e
+          @logger.error("Failed to parse response JSON: #{e.message}")
+          raise OrionX::APIError, "Invalid JSON response: #{e.message}"
+        end
+      else
+        parsed_body = body
+      end
+
+      if parsed_body.key?("errors") && !parsed_body["errors"].empty?
+        error_message = parsed_body["errors"].first["message"]
+        @logger.error("GraphQL error: #{error_message}")
+
+        # Check if we have partial data
+        if parsed_body.key?("data") && !parsed_body["data"].nil?
+          errors_count = parsed_body["errors"].length
+          data_keys_count = parsed_body["data"].keys.length
+          
+          # Return data if errors don't affect all fields
+          return parsed_body["data"] if errors_count < data_keys_count
+        end
+
+        raise OrionX::APIError, "GraphQL error: #{error_message}"
+      end
+
+      parsed_body["data"] || {}
+    end
+
+    def retryable_error?(error)
+      error.is_a?(OrionX::RateLimitError) || 
+        (error.is_a?(OrionX::APIError) && error.message.include?("500"))
+    end
+
+    def backoff_delay(attempt)
+      # Exponential backoff: 1s, 2s, 4s
+      2 ** (attempt - 1)
+    end
+  end
+end

data/lib/orionx/client.rb

@@ -0,0 +1,55 @@
+module OrionX
+  class Client
+    attr_reader :user, :orders, :accounts, :markets, :transactions, :api, :logger
+
+    def initialize(api_key: nil, api_secret: nil, api_endpoint: nil, debug: false)
+      # Configure the SDK if parameters are provided
+      if api_key || api_secret || api_endpoint || debug
+        OrionX.configure do |config|
+          config.api_key = api_key if api_key
+          config.api_secret = api_secret if api_secret
+          config.api_endpoint = api_endpoint if api_endpoint
+          config.debug = debug
+        end
+      end
+
+      @api = OrionX::API.new
+      @logger = @api.logger
+
+      # Initialize endpoint modules
+      @user = OrionX::Endpoints::User.new(@api)
+      @orders = OrionX::Endpoints::Orders.new(@api)
+      @accounts = OrionX::Endpoints::Accounts.new(@api)
+      @markets = OrionX::Endpoints::Markets.new(@api)
+      @transactions = OrionX::Endpoints::Transactions.new(@api)
+
+      @logger.info("OrionX Client initialized successfully")
+    end
+
+    # Convenience method to get current user information
+    def me
+      @user.me
+    end
+
+    # Health check method
+    def ping
+      begin
+        me
+        { status: "ok", message: "Connection successful" }
+      rescue => e
+        { status: "error", message: e.message }
+      end
+    end
+
+    # Enable/disable debug mode
+    def debug=(enabled)
+      OrionX.configuration.debug = enabled
+      @logger.level = enabled ? ::Logger::DEBUG : ::Logger::INFO
+      @logger.info("Debug mode #{enabled ? 'enabled' : 'disabled'}")
+    end
+
+    def debug?
+      OrionX.configuration.debug?
+    end
+  end
+end

data/lib/orionx/configuration.rb

@@ -0,0 +1,43 @@
+require "logger"
+
+module OrionX
+  class Configuration
+    attr_accessor :api_key, :api_secret, :api_endpoint, :debug, :logger, :timeout, :retries
+
+    def initialize
+      @api_key = nil
+      @api_secret = nil
+      @api_endpoint = "https://api.orionx.com/graphql"
+      @debug = false
+      @logger = nil
+      @timeout = 30
+      @retries = 3
+    end
+
+    def valid?
+      !api_key.nil? && !api_secret.nil? && !api_endpoint.nil?
+    end
+
+    def logger
+      @logger ||= OrionX::Logger.new(level: debug? ? ::Logger::DEBUG : ::Logger::INFO)
+    end
+
+    def debug?
+      @debug
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+      configuration.logger.debug("OrionX SDK configured with endpoint: #{configuration.api_endpoint}")
+      configuration.logger.debug("Debug mode: #{configuration.debug?}")
+    end
+  end
+end

data/lib/orionx/endpoints/accounts.rb

@@ -0,0 +1,103 @@
+module OrionX
+  module Endpoints
+    class Accounts
+      def initialize(api_client)
+        @api = api_client
+        @logger = api_client.logger
+      end
+
+      # Get a specific account by currency code
+      def get_account(currency_code)
+        raise OrionX::ValidationError, "Currency code cannot be nil or empty" if currency_code.nil? || currency_code.empty?
+
+        query = <<~GRAPHQL
+          query sdk_getAccount($assetId: ID!) {
+            wallet(code: $assetId) {
+              _id
+              currency {
+                code
+                units
+              }
+              balance
+              availableBalance
+              availableNetworks {
+                code
+              }
+              balanceUSD
+              balanceCLP
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching account for currency: #{currency_code}")
+        response = @api.call(query, { assetId: currency_code })
+        
+        result = response.dig("wallet")
+        @logger.info("Account for #{currency_code} retrieved successfully") if result
+        result
+      end
+
+      # Get all accounts for the user
+      def get_accounts
+        query = <<~GRAPHQL
+          query sdk_getAccounts {
+            me {
+              wallets {
+                _id
+                currency {
+                  code
+                  units
+                }
+                balance
+                availableBalance
+                availableNetworks {
+                  code
+                }
+                balanceUSD
+                balanceCLP
+              }
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching all accounts")
+        response = @api.call(query)
+        
+        result = response.dig("me", "wallets")
+        @logger.info("All accounts retrieved: #{result&.length || 0} accounts") if result
+        result
+      end
+
+      # Get account balance for a specific currency
+      def get_balance(currency_code)
+        account = get_account(currency_code)
+        return nil unless account
+
+        {
+          currency: account.dig("currency", "code"),
+          balance: account["balance"],
+          available_balance: account["availableBalance"],
+          balance_usd: account["balanceUSD"],
+          balance_clp: account["balanceCLP"]
+        }
+      end
+
+      # Get balances for all currencies
+      def get_balances
+        accounts = get_accounts
+        return [] unless accounts
+
+        accounts.map do |account|
+          {
+            currency: account.dig("currency", "code"),
+            balance: account["balance"],
+            available_balance: account["availableBalance"],
+            balance_usd: account["balanceUSD"],
+            balance_clp: account["balanceCLP"],
+            wallet_id: account["_id"]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/orionx/endpoints/markets.rb

@@ -0,0 +1,128 @@
+module OrionX
+  module Endpoints
+    class Markets
+      def initialize(api_client)
+        @api = api_client
+        @logger = api_client.logger
+      end
+
+      # Get information for a specific market
+      def get_market(market_code)
+        raise OrionX::ValidationError, "Market code cannot be nil or empty" if market_code.nil? || market_code.empty?
+
+        query = <<~GRAPHQL
+          query sdk_market($code: ID) {
+            market(code: $code) {
+              code
+              name
+              mainCurrency {
+                code
+                name
+                units
+              }
+              secondaryCurrency {
+                code
+                name
+                units
+              }
+              lastTrade {
+                price
+              }
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching market data for: #{market_code}")
+        response = @api.call(query, { code: market_code })
+        
+        result = response.dig("market")
+        @logger.info("Market #{market_code} data retrieved successfully") if result
+        result
+      end
+
+      # Get all available markets
+      def get_markets
+        query = <<~GRAPHQL
+          query sdk_markets {
+            markets {
+              code
+              name
+              mainCurrency {
+                code
+                name
+                units
+              }
+              secondaryCurrency {
+                code
+                name
+                units
+              }
+              lastTrade {
+                price
+              }
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching all markets")
+        response = @api.call(query)
+        
+        result = response.dig("markets")
+        @logger.info("All markets retrieved: #{result&.length || 0} markets") if result
+        result
+      end
+
+      # Get order book for a specific market
+      def get_orderbook(market_code, limit: 50)
+        raise OrionX::ValidationError, "Market code cannot be nil or empty" if market_code.nil? || market_code.empty?
+        raise OrionX::ValidationError, "Limit must be positive" if limit <= 0
+
+        query = <<~GRAPHQL
+          query sdk_marketOrderBook($marketCode: ID!, $limit: Int) {
+            marketOrderBook(marketCode: $marketCode, limit: $limit) {
+              sell {
+                amount
+                limitPrice
+              }
+              buy {
+                amount
+                limitPrice
+              }
+              spread
+              mid
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching orderbook for #{market_code} (limit: #{limit})")
+        response = @api.call(query, { marketCode: market_code, limit: limit })
+        
+        result = response.dig("marketOrderBook")
+        if result
+          @logger.info("Orderbook for #{market_code} retrieved - Buy orders: #{result.dig('buy')&.length || 0}, Sell orders: #{result.dig('sell')&.length || 0}")
+        end
+        result
+      end
+
+      # Get market statistics
+      def get_market_stats(market_code)
+        market = get_market(market_code)
+        orderbook = get_orderbook(market_code, limit: 1)
+
+        return nil unless market && orderbook
+
+        {
+          code: market["code"],
+          name: market["name"],
+          last_price: market.dig("lastTrade", "price"),
+          spread: orderbook["spread"],
+          mid_price: orderbook["mid"],
+          best_bid: orderbook.dig("buy", 0, "limitPrice"),
+          best_ask: orderbook.dig("sell", 0, "limitPrice"),
+          main_currency: market.dig("mainCurrency", "code"),
+          secondary_currency: market.dig("secondaryCurrency", "code")
+        }
+      end
+    end
+  end
+end