orionx-sdk-ruby 1.0.0

data/lib/orionx/endpoints/orders.rb

@@ -0,0 +1,328 @@
+module OrionX
+  module Endpoints
+    class Orders
+      def initialize(api_client)
+        @api = api_client
+        @logger = api_client.logger
+      end
+
+      # Get a specific order by ID
+      def get_order(order_id)
+        raise OrionX::ValidationError, "Order ID cannot be nil or empty" if order_id.nil? || order_id.empty?
+
+        query = <<~GRAPHQL
+          query sdk_getOrder($orderId: ID!) {
+            order(orderId: $orderId) {
+              _id
+              type
+              amount
+              limitPrice
+              stopPriceDown
+              stopPriceUp
+              status
+              createdAt
+              activatedAt
+              closedAt
+              market {
+                code
+                mainCurrency {
+                  code
+                  units
+                }
+                secondaryCurrency {
+                  code
+                  units
+                }
+              }
+              clientId
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching order: #{order_id}")
+        response = @api.call(query, { orderId: order_id })
+        
+        result = response.dig("order")
+        @logger.info("Order #{order_id} retrieved successfully") if result
+        result
+      end
+
+      # Get orders with optional filters
+      def get_orders(filters = {})
+        query = <<~GRAPHQL
+          query sdk_getOrders($filter: String, $marketCode: ID, $onlyOpen: Boolean, $onlyClosed: Boolean, $currencyCode: ID, $onlyFilled: Boolean, $page: Int, $limit: Int, $sortBy: String, $sortType: SortType) {
+            orders(filter: $filter, marketCode: $marketCode, onlyOpen: $onlyOpen, onlyClosed: $onlyClosed, currencyCode: $currencyCode, onlyFilled: $onlyFilled, page: $page, limit: $limit, sortBy: $sortBy, sortType: $sortType) {
+              _id
+              items {
+                type
+                amount
+                limitPrice
+                stopPriceUp
+                stopPriceDown
+                status
+                createdAt
+                activatedAt
+                closedAt
+                market {
+                  code
+                  mainCurrency {
+                    code
+                    units
+                  }
+                  secondaryCurrency {
+                    code
+                    units
+                  }
+                }
+                clientId
+              }
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching orders with filters: #{filters.inspect}")
+        response = @api.call(query, filters)
+        
+        result = response.dig("orders")
+        @logger.info("Orders retrieved: #{result&.dig('items')&.length || 0} orders") if result
+        result
+      end
+
+      # Place a limit order
+      def place_limit_order(market_code:, amount:, limit_price:, sell:, client_id: nil)
+        validate_order_params(market_code, amount)
+        raise OrionX::ValidationError, "Limit price must be positive" if limit_price.nil? || limit_price <= 0
+
+        query = <<~GRAPHQL
+          mutation sdk_placeLimitOrder(
+            $marketCode: ID
+            $amount: BigInt
+            $limitPrice: BigInt
+            $sell: Boolean
+            $clientId: String
+          ) {
+            placeLimitOrder(
+              marketCode: $marketCode
+              amount: $amount
+              limitPrice: $limitPrice
+              sell: $sell
+              clientId: $clientId
+            ) {
+              _id
+              type
+              amount
+              limitPrice
+              status
+              createdAt
+              market {
+                code
+              }
+              clientId
+            }
+          }
+        GRAPHQL
+
+        variables = {
+          marketCode: market_code,
+          amount: amount,
+          limitPrice: limit_price,
+          sell: sell,
+          clientId: client_id
+        }
+
+        @logger.debug("Placing limit order: #{variables.inspect}")
+        response = @api.call(query, variables)
+        
+        result = response.dig("placeLimitOrder")
+        @logger.info("Limit order placed successfully: #{result&.dig('_id')}") if result
+        result
+      end
+
+      # Place a market order
+      def place_market_order(market_code:, amount:, sell:, client_id: nil)
+        validate_order_params(market_code, amount)
+
+        query = <<~GRAPHQL
+          mutation sdk_placeMarketOrder(
+            $marketCode: ID
+            $amount: BigInt
+            $sell: Boolean
+            $clientId: String
+          ) {
+            placeMarketOrder(
+              marketCode: $marketCode
+              amount: $amount
+              sell: $sell
+              clientId: $clientId
+            ) {
+              _id
+              type
+              amount
+              limitPrice
+              status
+              createdAt
+              market {
+                code
+              }
+              clientId
+            }
+          }
+        GRAPHQL
+
+        variables = {
+          marketCode: market_code,
+          amount: amount,
+          sell: sell,
+          clientId: client_id
+        }
+
+        @logger.debug("Placing market order: #{variables.inspect}")
+        response = @api.call(query, variables)
+        
+        result = response.dig("placeMarketOrder")
+        @logger.info("Market order placed successfully: #{result&.dig('_id')}") if result
+        result
+      end
+
+      # Place a stop limit order
+      def place_stop_limit_order(market_code:, stop_price_up:, stop_price_down:, amount:, limit_price:, sell:, client_id: nil)
+        validate_order_params(market_code, amount)
+        raise OrionX::ValidationError, "Limit price must be positive" if limit_price.nil? || limit_price <= 0
+        raise OrionX::ValidationError, "At least one stop price must be provided" if stop_price_up.nil? && stop_price_down.nil?
+
+        query = <<~GRAPHQL
+          mutation sdk_placeStopLimitOrder(
+            $marketCode: ID
+            $stopPriceUp: BigInt
+            $stopPriceDown: BigInt
+            $amount: BigInt
+            $limitPrice: BigInt
+            $sell: Boolean
+            $clientId: String
+          ) {
+            placeStopLimitOrder(
+              marketCode: $marketCode
+              stopPriceUp: $stopPriceUp
+              stopPriceDown: $stopPriceDown
+              amount: $amount
+              limitPrice: $limitPrice
+              sell: $sell
+              clientId: $clientId
+            ) {
+              _id
+              type
+              amount
+              limitPrice
+              status
+              createdAt
+              market {
+                code
+              }
+              clientId
+            }
+          }
+        GRAPHQL
+
+        variables = {
+          marketCode: market_code,
+          stopPriceUp: stop_price_up,
+          stopPriceDown: stop_price_down,
+          amount: amount,
+          limitPrice: limit_price,
+          sell: sell,
+          clientId: client_id
+        }
+
+        @logger.debug("Placing stop limit order: #{variables.inspect}")
+        response = @api.call(query, variables)
+        
+        result = response.dig("placeStopLimitOrder")
+        @logger.info("Stop limit order placed successfully: #{result&.dig('_id')}") if result
+        result
+      end
+
+      # Place a stop market order
+      def place_stop_market_order(market_code:, stop_price_up:, stop_price_down:, amount:, sell:, client_id: nil)
+        validate_order_params(market_code, amount)
+        raise OrionX::ValidationError, "At least one stop price must be provided" if stop_price_up.nil? && stop_price_down.nil?
+
+        query = <<~GRAPHQL
+          mutation sdk_placeStopMarketOrder(
+            $marketCode: ID
+            $stopPriceUp: BigInt
+            $stopPriceDown: BigInt
+            $amount: BigInt
+            $sell: Boolean
+            $clientId: String
+          ) {
+            placeStopMarketOrder(
+              marketCode: $marketCode
+              stopPriceUp: $stopPriceUp
+              stopPriceDown: $stopPriceDown
+              amount: $amount
+              sell: $sell
+              clientId: $clientId
+            ) {
+              _id
+              type
+              amount
+              limitPrice
+              status
+              createdAt
+              market {
+                code
+              }
+              clientId
+            }
+          }
+        GRAPHQL
+
+        variables = {
+          marketCode: market_code,
+          stopPriceUp: stop_price_up,
+          stopPriceDown: stop_price_down,
+          amount: amount,
+          sell: sell,
+          clientId: client_id
+        }
+
+        @logger.debug("Placing stop market order: #{variables.inspect}")
+        response = @api.call(query, variables)
+        
+        result = response.dig("placeStopMarketOrder")
+        @logger.info("Stop market order placed successfully: #{result&.dig('_id')}") if result
+        result
+      end
+
+      # Cancel an order
+      def cancel_order(order_id)
+        raise OrionX::ValidationError, "Order ID cannot be nil or empty" if order_id.nil? || order_id.empty?
+
+        query = <<~GRAPHQL
+          mutation sdk_cancelOrder($orderId: ID!) {
+            cancelOrder(orderId: $orderId) {
+              _id
+              type
+              status
+              clientId
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Cancelling order: #{order_id}")
+        response = @api.call(query, { orderId: order_id })
+        
+        result = response.dig("cancelOrder")
+        @logger.info("Order #{order_id} cancelled successfully") if result
+        result
+      end
+
+      private
+
+      def validate_order_params(market_code, amount)
+        raise OrionX::ValidationError, "Market code cannot be nil or empty" if market_code.nil? || market_code.empty?
+        raise OrionX::ValidationError, "Amount must be positive" if amount.nil? || amount <= 0
+      end
+    end
+  end
+end

data/lib/orionx/endpoints/transactions.rb

@@ -0,0 +1,269 @@
+module OrionX
+  module Endpoints
+    class Transactions
+      def initialize(api_client)
+        @api = api_client
+        @logger = api_client.logger
+      end
+
+      # Get a specific transaction by ID
+      def get_transaction(transaction_id)
+        raise OrionX::ValidationError, "Transaction ID cannot be nil or empty" if transaction_id.nil? || transaction_id.empty?
+
+        query = <<~GRAPHQL
+          query sdk_getTransaction($_id: ID!) {
+            transaction(_id: $_id) {
+              _id
+              amount
+              balance
+              commission
+              currency {
+                code
+                units
+              }
+              date
+              type
+              adds
+              hash
+              description
+              market {
+                code
+                mainCurrency {
+                  code
+                  units
+                }
+                secondaryCurrency {
+                  code
+                  units
+                }
+              }
+              price
+              cost
+              explorerURL
+              isInside
+              meta {
+                status
+              }
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching transaction: #{transaction_id}")
+        response = @api.call(query, { _id: transaction_id })
+        
+        result = response.dig("transaction")
+        @logger.info("Transaction #{transaction_id} retrieved successfully") if result
+        result
+      end
+
+      # Get transactions with optional filters
+      def get_transactions(filters = {})
+        query = <<~GRAPHQL
+          query sdk_getTransactions($filter: String, $walletId: ID, $types: [String], $initPeriod: Date, $finalPeriod: Date, $page: Int, $limit: Int, $sortBy: String, $sortType: SortType) {
+            transactions(filter: $filter, walletId: $walletId, types: $types, initPeriod: $initPeriod, finalPeriod: $finalPeriod, page: $page, limit: $limit, sortBy: $sortBy, sortType: $sortType) {
+              _id
+              items {
+                amount
+                balance
+                commission
+                currency {
+                  code
+                  units
+                }
+                date
+                type
+                adds
+                hash
+                description
+                market {
+                  code
+                  mainCurrency {
+                    code
+                    units
+                  }
+                  secondaryCurrency {
+                    code
+                    units
+                  }
+                }
+                price
+                cost
+                explorerURL
+                isInside
+                meta {
+                  status
+                }
+              }
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching transactions with filters: #{filters.inspect}")
+        response = @api.call(query, filters)
+        
+        result = response.dig("transactions")
+        @logger.info("Transactions retrieved: #{result&.dig('items')&.length || 0} transactions") if result
+        result
+      end
+
+      # Send cryptocurrency
+      def send_crypto(wallet_id:, network:, amount:, contact_id: nil, description: nil, client_id: nil)
+        raise OrionX::ValidationError, "Wallet ID cannot be nil or empty" if wallet_id.nil? || wallet_id.empty?
+        raise OrionX::ValidationError, "Network cannot be nil or empty" if network.nil? || network.empty?
+        raise OrionX::ValidationError, "Amount must be positive" if amount.nil? || amount <= 0
+
+        query = <<~GRAPHQL
+          mutation sdk_send(
+            $fromWalletId: ID!
+            $contactId: ID
+            $network: String!
+            $amount: BigInt!
+            $description: String
+            $clientId: ID
+          ) {
+            sendCrypto(
+              fromWalletId: $fromWalletId
+              contactId: $contactId
+              network: $network
+              amount: $amount
+              description: $description
+              clientId: $clientId
+            ) {
+              _id
+              type
+              amount
+              price
+              hash
+              date
+              market {
+                code
+              }
+              meta { 
+                status
+              }
+            }
+          }
+        GRAPHQL
+
+        variables = {
+          fromWalletId: wallet_id,
+          contactId: contact_id,
+          network: network,
+          amount: amount,
+          description: description,
+          clientId: client_id
+        }
+
+        @logger.debug("Sending crypto: #{variables.inspect}")
+        response = @api.call(query, variables)
+        
+        result = response.dig("sendCrypto")
+        @logger.info("Crypto send initiated successfully: #{result&.dig('_id')}") if result
+        result
+      end
+
+      # Request withdrawal
+      def withdrawal_request(wallet_id:, account_id:, amount:)
+        raise OrionX::ValidationError, "Wallet ID cannot be nil or empty" if wallet_id.nil? || wallet_id.empty?
+        raise OrionX::ValidationError, "Account ID cannot be nil or empty" if account_id.nil? || account_id.empty?
+        raise OrionX::ValidationError, "Amount must be positive" if amount.nil? || amount <= 0
+
+        query = <<~GRAPHQL
+          mutation sdk_withdrawalRequest(
+            $walletId: ID
+            $accountId: ID
+            $amount: BigInt
+          ) {
+            requestWithdrawal(
+              walletId: $walletId
+              accountId: $accountId
+              amount: $amount
+            ) {
+              _id
+              amount
+              commission
+              date
+              type
+              description
+            }
+          }
+        GRAPHQL
+
+        variables = {
+          walletId: wallet_id,
+          accountId: account_id,
+          amount: amount
+        }
+
+        @logger.debug("Requesting withdrawal: #{variables.inspect}")
+        response = @api.call(query, variables)
+        
+        result = response.dig("requestWithdrawal")
+        @logger.info("Withdrawal request created successfully: #{result&.dig('_id')}") if result
+        result
+      end
+
+      # Convert/Trade instantly
+      def convert(quote_option_id:, amount:, market_code:, sell:)
+        raise OrionX::ValidationError, "Quote option ID cannot be nil or empty" if quote_option_id.nil? || quote_option_id.empty?
+        raise OrionX::ValidationError, "Amount must be positive" if amount.nil? || amount <= 0
+        raise OrionX::ValidationError, "Market code cannot be nil or empty" if market_code.nil? || market_code.empty?
+
+        query = <<~GRAPHQL
+          mutation sdk_convert(
+            $quoteOptionId: String
+            $amount: BigInt!
+            $marketCode: String!
+            $sell: Boolean!
+          ) {
+            instantTransaction(
+              quoteOptionId: $quoteOptionId
+              amount: $amount
+              marketCode: $marketCode
+              sell: $sell
+            )
+          }
+        GRAPHQL
+
+        variables = {
+          quoteOptionId: quote_option_id,
+          amount: amount,
+          marketCode: market_code,
+          sell: sell
+        }
+
+        @logger.debug("Converting/trading instantly: #{variables.inspect}")
+        response = @api.call(query, variables)
+        
+        result = response.dig("instantTransaction")
+        @logger.info("Instant conversion completed successfully") if result
+        result
+      end
+
+      # Get transaction history for a specific currency
+      def get_history(currency_code, limit: 50, page: 1)
+        # First get the wallet ID for the currency
+        account_query = <<~GRAPHQL
+          query sdk_getAccount($assetId: ID!) {
+            wallet(code: $assetId) {
+              _id
+            }
+          }
+        GRAPHQL
+
+        account_response = @api.call(account_query, { assetId: currency_code })
+        wallet_id = account_response.dig("wallet", "_id")
+
+        return nil unless wallet_id
+
+        # Get transactions for this wallet
+        get_transactions({
+          walletId: wallet_id,
+          limit: limit,
+          page: page,
+          sortType: "DESC"
+        })
+      end
+    end
+  end
+end

data/lib/orionx/endpoints/user.rb

@@ -0,0 +1,54 @@
+module OrionX
+  module Endpoints
+    class User
+      def initialize(api_client)
+        @api = api_client
+        @logger = api_client.logger
+      end
+
+      # Get current user information
+      def me
+        query = <<~GRAPHQL
+          query sdk_getMe {
+            me {
+              _id
+              email
+              name
+              profile {
+                fullName
+                phone
+                kycVerified
+                birthdate
+                countryCode
+                occupation
+                address
+              }
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching user profile")
+        response = @api.call(query)
+        
+        result = response.dig("me")
+        @logger.info("User profile retrieved successfully") if result
+        result
+      end
+
+      # Get user ID only
+      def user_id
+        query = <<~GRAPHQL
+          query sdk_getUserId {
+            me {
+              _id
+            }
+          }
+        GRAPHQL
+
+        @logger.debug("Fetching user ID")
+        response = @api.call(query)
+        response.dig("me", "_id")
+      end
+    end
+  end
+end

data/lib/orionx/logger.rb

@@ -0,0 +1,63 @@
+require "logger"
+
+module OrionX
+  class Logger
+    attr_reader :logger
+
+    def initialize(level: ::Logger::INFO, output: STDOUT)
+      @logger = ::Logger.new(output)
+      @logger.level = level
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity.ljust(5)} OrionX: #{msg}\n"
+      end
+    end
+
+    def debug(message = nil, &block)
+      if block_given?
+        @logger.debug(&block)
+      else
+        @logger.debug(message)
+      end
+    end
+
+    def info(message = nil, &block)
+      if block_given?
+        @logger.info(&block)
+      else
+        @logger.info(message)
+      end
+    end
+
+    def warn(message = nil, &block)
+      if block_given?
+        @logger.warn(&block)
+      else
+        @logger.warn(message)
+      end
+    end
+
+    def error(message = nil, &block)
+      if block_given?
+        @logger.error(&block)
+      else
+        @logger.error(message)
+      end
+    end
+
+    def fatal(message = nil, &block)
+      if block_given?
+        @logger.fatal(&block)
+      else
+        @logger.fatal(message)
+      end
+    end
+
+    def level=(level)
+      @logger.level = level
+    end
+
+    def level
+      @logger.level
+    end
+  end
+end

data/lib/orionx/version.rb

@@ -0,0 +1,3 @@
+module OrionX
+  VERSION = "1.0.0"
+end