quidax 0.1.0

data/lib/quidax/objects/base.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Base object for HTTP requests
+class QuidaxBaseObject
+  require "json"
+
+  attr_reader :quidax
+
+  def initialize(quidax_object)
+    raise ArgumentError, "Quidax object cannot be nil!" if quidax_object.nil?
+
+    @quidax = quidax_object
+  end
+
+  def self.get_request(q_object, path, params = {})
+    result = nil
+    begin
+      response = Faraday.get(url(path), params, { "Authorization" => "Bearer #{q_object.secret_key}" })
+
+      raise QuidaxServerError, response unless response.status == 200 || response.status == 201
+
+      result = JSON.parse(response.body)
+    rescue QuidaxServerError => e
+      Utils.handle_server_error(e)
+    rescue JSON::ParserError => e
+      raise QuidaxServerError.new(response),
+            "Invalid result data. Could not parse JSON response body \n #{e.message}"
+    end
+    result
+  end
+
+  def self.post_request(q_object, path, body = {})
+    result = nil
+
+    begin
+      response = Faraday.post(url(path), body.to_json,
+                              { "Authorization" => "Bearer #{q_object.secret_key}", "Content-Type" => "application/json", "Accept" => "application/json" })
+      raise QuidaxServerError, response unless response.status == 200 || response.status == 201
+
+      result = JSON.parse(response.body)
+    rescue QuidaxServerError => e
+      Utils.handle_server_error(e)
+    end
+    result
+  end
+
+  def self.put_request(q_object, path, body = {})
+    response = Faraday.put("#{API::BASE_URL}#{path}", body,
+                           { "Authorization" => "Bearer #{q_object.secret_key}" })
+    raise QuidaxServerError, response unless response.status == 200 || response.status == 201
+
+    JSON.parse(response.body)
+  rescue QuidaxServerError => e
+    Utils.handle_server_error(e)
+  end
+
+  def self.url(path)
+    "#{API::BASE_URL}#{path}"
+  end
+end

data/lib/quidax/objects/beneficiary.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Beneficiary object
+class QuidaxBeneficiary < QuidaxBaseObject
+  def get_all(user_id:, query:)
+    QuidaxBeneficiary.get_all(q_object: @quidax, user_id: user_id, query: query)
+  end
+
+  def create(user_id:, body:)
+    QuidaxBeneficiary.create(q_object: @quidax, user_id: user_id, body: body)
+  end
+
+  def get_account(user_id:, beneficiary_id:)
+    QuidaxBeneficiary.get_account(q_object: @quidax, user_id: user_id, beneficiary_id: beneficiary_id)
+  end
+
+  def edit_account(user_id:, beneficiary_id:, body:)
+    QuidaxBeneficiary.edit_account(q_object: @quidax, user_id: user_id, beneficiary_id: beneficiary_id, body: body)
+  end
+
+  def self.get_all(q_object:, user_id:, query:)
+    query.stringify_keys!
+    allowed_currencies = %w[btc ltc xrp dash trx doge]
+    Utils.check_missing_keys(required_keys: %w[currency], keys: query.keys, field: "query")
+
+    currency = query["currency"]
+    Utils.validate_value_in_array(array: allowed_currencies, value: currency, field: "currency")
+
+    path = "#{API::USER_PATH}/#{user_id}#{API::BENEFICIARY_PATH}"
+
+    get_request(q_object, path, query)
+  end
+
+  def self.create(q_object:, user_id:, body:)
+    body.stringify_keys!
+    expected_query_keys = %w[currency uid extra]
+    Utils.check_missing_keys(required_keys: expected_query_keys, keys: body.keys, field: "body")
+
+    path = "#{API::USER_PATH}/#{user_id}#{API::BENEFICIARY_PATH}"
+
+    post_request(q_object, path, body)
+  end
+
+  def self.get_account(q_object:, user_id:, beneficiary_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::BENEFICIARY_PATH}/#{beneficiary_id}"
+
+    get_request(q_object, path)
+  end
+
+  def self.edit_account(q_object:, user_id:, beneficiary_id:, body:)
+    body.stringify_keys!
+    path = "#{API::USER_PATH}/#{user_id}#{API::BENEFICIARY_PATH}/#{beneficiary_id}"
+
+    Utils.check_missing_keys(required_keys: %w[uid], keys: body.keys, field: "body")
+
+    put_request(q_object, path, body)
+  end
+end

data/lib/quidax/objects/deposits.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Deposit Object
+class QuidaxDeposits < QuidaxBaseObject
+  def by_user(user_id:, query:)
+    QuidaxDeposits.by_user(q_object: @quidax, user_id: user_id, query: query)
+  end
+
+  def get_a_deposit(user_id:, deposit_id:)
+    QuidaxDeposits.get_a_deposit(q_object: @quidax, user_id: user_id, deposit_id: deposit_id)
+  end
+
+  def by_sub_users
+    QuidaxDeposits.by_sub_users(q_object: @quidax)
+  end
+
+  def self.by_user(q_object:, user_id:, query:)
+    query.stringify_keys!
+
+    Utils.check_missing_keys(required_keys: %w[currency state], keys: query.keys, field: "query")
+    allowed_states = %w[submitting canceled submitted rejected failed accepted checked]
+    Utils.validate_value_in_array(array: allowed_states, value: query["state"], field: "state")
+
+    path = "#{API::USER_PATH}/#{user_id}/#{API::DEPOSIT_PATH}"
+
+    get_request(q_object, path, query)
+  end
+
+  def self.get_a_deposit(q_object:, user_id:, deposit_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::DEPOSIT_PATH}/#{deposit_id}"
+
+    get_request(q_object, path)
+  end
+
+  def self.by_sub_users(q_object:)
+    path = "#{API::USER_PATH}#{API::DEPOSIT_PATH}/all"
+
+    get_request(q_object, path)
+  end
+end

data/lib/quidax/objects/fee.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Fees object
+class QuidaxFee < QuidaxBaseObject
+  def get(query:)
+    QuidaxFee.get(q_object: @quidax, query: query)
+  end
+
+  def self.get(q_object:, query:)
+    query.stringify_keys!
+
+    Utils.check_missing_keys(required_keys: %w[currency network], keys: query.keys, field: "query")
+    path = API::FEE_PATH
+
+    get_request(q_object, path, query)
+  end
+end

data/lib/quidax/objects/instant_order.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative "../validators/instant_order_validator"
+
+# Instant Order Object
+class QuidaxInstantOrder < QuidaxBaseObject
+  def get_all(user_id:, market: nil, state: nil, order_by: nil)
+    QuidaxInstantOrder.get_all(q_object: @quidax, user_id: user_id, market: market, state: state, order_by: order_by)
+  end
+
+  def by_sub_users(side:, start_date:, end_date:, market: nil, state: nil)
+    QuidaxInstantOrder.by_sub_users(q_object: @quidax, side: side, start_date: start_date, end_date: end_date, market: market,
+                                    state: state)
+  end
+
+  def get_detail(user_id:, instant_order_id:)
+    QuidaxInstantOrder.get_detail(q_object: @quidax, user_id: user_id, instant_order_id: instant_order_id)
+  end
+
+  def buy_crypto_from_fiat(user_id:, body:)
+    QuidaxInstantOrder.buy_crypto_from_fiat(q_object: @quidax, user_id: user_id, body: body)
+  end
+
+  def sell_crypto_to_fiat(user_id:, body:)
+    QuidaxInstantOrder.sell_crypto_to_fiat(q_object: @quidax, user_id: user_id, body: body)
+  end
+
+  def confirm(user_id:, instant_order_id:)
+    QuidaxInstantOrder.confirm(q_object: @quidax, user_id: user_id, instant_order_id: instant_order_id)
+  end
+
+  def requote(user_id:, instant_order_id:)
+    QuidaxInstantOrder.requote(q_object: @quidax, user_id: user_id, instant_order_id: instant_order_id)
+  end
+
+  def self.get_all(q_object:, user_id:, market: nil, state: nil, order_by: nil)
+    market ||= "btcngn"
+    state ||= "done"
+    order_by ||= "asc"
+
+    allowed_order_by = %w[asc desc]
+    Utils.validate_value_in_array(array: allowed_order_by, value: order_by, field: "order_by")
+
+    allowed_states = %w[done wait cancel confirm]
+    Utils.validate_value_in_array(array: allowed_states, value: state, field: "state")
+
+    path = "#{API::USER_PATH}/#{user_id}#{API::INSTANT_ORDER_PATH}"
+    params = {
+      market: market,
+      state: state,
+      order_by: order_by
+    }
+
+    get_request(q_object, path, params)
+  end
+
+  def self.by_sub_users(q_object:, side:, start_date:, end_date:, market: nil, state: nil)
+    state ||= "done"
+    market ||= "btcngn"
+
+    allowed_sides = %w[buy sell]
+    Utils.validate_value_in_array(array: allowed_sides, value: side, field: "side")
+
+    allowed_states = %w[pend wait confirm done partially_done failed cancel]
+    Utils.validate_value_in_array(array: allowed_states, value: state, field: "state")
+    path = "#{API::USER_PATH}#{API::INSTANT_ORDER_PATH}/all"
+
+    params = {
+      side: side,
+      state: state,
+      market: market,
+      start_date: start_date,
+      end_date: end_date
+    }
+
+    get_request(q_object, path, params)
+  end
+
+  def self.get_detail(q_object:, user_id:, instant_order_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::INSTANT_ORDER_PATH}/#{instant_order_id}"
+
+    get_request(q_object, path)
+  end
+
+  def self.buy_crypto_from_fiat(q_object:, user_id:, body:)
+    body.transform_keys!(&:to_s)
+
+    InstantOrderValidator.validate_buy_from_crypto_body(body)
+    type = "buy"
+    unit = body["bid"]
+    body["unit"] = unit
+    body["type"] = type
+
+    path = "#{API::USER_PATH}/#{user_id}#{API::INSTANT_ORDER_PATH}"
+    post_request(q_object, path, body)
+  end
+
+  def self.sell_crypto_to_fiat(q_object:, user_id:, body:)
+    body.transform_keys!(&:to_s)
+    InstantOrderValidator.validate_sell_crypto_to_fiat(body)
+    unit = body["bid"]
+    body["unit"] = unit
+    body["type"] = "sell"
+
+    path = "#{API::USER_PATH}/#{user_id}#{API::INSTANT_ORDER_PATH}"
+    post_request(q_object, path, body)
+  end
+
+  def self.confirm(q_object:, user_id:, instant_order_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::INSTANT_ORDER_PATH}/#{instant_order_id}/confirm"
+
+    post_request(q_object, path)
+  end
+
+  def self.requote(q_object:, user_id:, instant_order_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::INSTANT_ORDER_PATH}/#{instant_order_id}/requote"
+
+    post_request(q_object, path)
+  end
+end

data/lib/quidax/objects/markets.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# Object for markets
+class QuidaxMarkets < QuidaxBaseObject
+  def get_all
+    QuidaxMarkets.get_all(q_object: @quidax)
+  end
+
+  def get_all_tickers
+    QuidaxMarkets.get_all_tickers(q_object: @quidax)
+  end
+
+  def get_ticker(market:)
+    QuidaxMarkets.get_ticker(q_object: @quidax, market: market)
+  end
+
+  def get_k_line(market:, query: nil)
+    QuidaxMarkets.get_k_line(q_object: @quidax, market: market, query: query)
+  end
+
+  def get_k_line_with_pending_trades(market:, trade_id:, query: nil)
+    QuidaxMarkets.get_k_line_with_pending_trades(q_object: @quidax, market: market, trade_id: trade_id,
+                                                 query: query)
+  end
+
+  def get_orderbook_items(market:, query: nil)
+    QuidaxMarkets.get_orderbook_items(q_object: @quidax, market: market, query: query)
+  end
+
+  def get_depth_for_a_market(market:, query: nil)
+    QuidaxMarkets.get_depth_for_a_market(q_object: @quidax, market: market, query: query)
+  end
+
+  def self.get_all(q_object:)
+    get_request(q_object, API::MARKET_PATH)
+  end
+
+  def self.get_all_tickers(q_object:)
+    path = "#{API::MARKET_PATH}/tickers"
+    get_request(q_object, path)
+  end
+
+  def self.get_ticker(q_object:, market:)
+    path = "#{API::MARKET_PATH}/tickers/#{market}"
+    get_request(q_object, path)
+  end
+
+  def self.get_k_line(q_object:, market:, query: nil)
+    query ||= {
+      period: 1,
+      limit: 30
+    }
+
+    query.stringify_keys!
+
+    Utils.check_missing_keys(required_keys: %w[period limit], keys: query.keys, field: "query")
+    allowed_periods = [1, 5, 15, 30, 60, 120, 240, 360, 720, 1440, 4320, 10_080]
+    Utils.validate_value_in_array(array: allowed_periods, value: query["period"], field: "period")
+
+    raise ArgumentError, "limit must be in range 1..10_00" unless (1..10_000).include?(query["limit"])
+
+    path = "#{API::MARKET_PATH}/#{market}/k"
+
+    get_request(q_object, path, query)
+  end
+
+  def self.get_k_line_with_pending_trades(q_object:, market:, trade_id:, query: nil)
+    query ||= {
+      period: 1,
+      limit: 30
+    }
+    query.stringify_keys!
+
+    Utils.check_missing_keys(required_keys: %w[period limit], keys: query.keys, field: "query")
+    allowed_periods = [1, 5, 15, 30, 60, 120, 240, 360, 720, 1440, 4320, 10_080]
+
+    Utils.validate_value_in_array(array: allowed_periods, value: query["period"], field: "period")
+
+    Utils.validate_value_in_range(range: 1..10_000, value: query["limit"], field: 'query["limit"]')
+
+    path = "#{API::MARKET_PATH}/#{market}/k_with_pending_trades/#{trade_id}"
+
+    get_request(q_object, path, query)
+  end
+
+  def self.get_orderbook_items(q_object:, market:, query: nil)
+    query ||= {
+      ask_limit: "20",
+      bids_limit: "20"
+    }
+
+    query.stringify_keys!
+
+    Utils.check_missing_keys(required_keys: %w[ask_limit bids_limit], keys: query.keys, field: "query")
+
+    Utils.validate_value_in_range(range: 1..200, value: query["ask_limit"], field: 'query["ask_limit"]')
+    Utils.validate_value_in_range(range: 1..200, value: query["bids_limit"], field: 'query["bids_limit"]')
+
+    path = "#{API::MARKET_PATH}/#{market}/order_book"
+
+    get_request(q_object, path, query)
+  end
+
+  def self.get_depth_for_a_market(q_object:, market:, query: nil)
+    query ||= {
+      limit: 10
+    }
+    query.stringify_keys!
+    Utils.check_missing_keys(required_keys: %w[limit], keys: query.keys, field: "query")
+    Utils.validate_value_in_range(range: 1..10_000, value: query["limit"], field: 'query["limit"]')
+    path = "#{API::MARKET_PATH}/#{market}/depth"
+
+    get_request(q_object, path, query)
+  end
+end

data/lib/quidax/objects/order.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Order object
+class QuidaxOrder < QuidaxBaseObject
+  def get_all(user_id:, query:)
+    QuidaxOrder.get_all(q_object: @quidax, user_id: user_id, query: query)
+  end
+
+  def create(user_id:, body:)
+    QuidaxOrder.create(q_object: @quidax, user_id: user_id, body: body)
+  end
+
+  def cancel(user_id:, order_id:)
+    QuidaxOrder.cancel(q_object: @quidax, user_id: user_id, order_id: order_id)
+  end
+
+  def get_details(user_id:, order_id:)
+    QuidaxOrder.get_details(q_object: @quidax, user_id: user_id, order_id: order_id)
+  end
+
+  def self.get_all(q_object:, user_id:, query:)
+    query.stringify_keys!
+    Utils.check_missing_keys(required_keys: %w[market], keys: query.keys, field: "query")
+    query["order_by"] = "asc" unless query.include?("order_by")
+    query["state"] = "done" unless query.include?("state")
+    Utils.validate_value_in_array(array: %w[asc desc], value: query["order_by"], field: 'query["order_by"]')
+    Utils.validate_value_in_array(array: %w[done wait cancel], value: query["state"], field: 'query["state"]')
+
+    path = "#{API::USER_PATH}/#{user_id}#{API::ORDER_PATH}"
+
+    get_request(q_object, path, query)
+  end
+
+  def self.create(q_object:, user_id:, body:)
+    body.stringify_keys!
+
+    expected_data_keys = %w[market side ord_type price volume]
+    Utils.check_missing_keys(required_keys: expected_data_keys, keys: body.keys, field: "body")
+
+    Utils.validate_value_in_array(array: %w[buy sell], value: body["side"], field: 'body["side"]')
+    body["ord_type"] = "limit" unless body.include?("ord_type")
+    Utils.validate_value_in_array(array: %w[limit market], value: body["ord_type"], field: 'body["ord_type"]')
+
+    path = "#{API::USER_PATH}/#{user_id}#{API::ORDER_PATH}"
+
+    post_request(q_object, path, body)
+  end
+
+  def self.cancel(q_object:, user_id:, order_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::ORDER_PATH}/#{order_id}/cancel"
+
+    post_request(q_object, path)
+  end
+
+  def self.get_details(q_object:, user_id:, order_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::ORDER_PATH}/#{order_id}"
+
+    get_request(q_object, path)
+  end
+end

data/lib/quidax/objects/quote.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Object for quotes
+class QuidaxQuote < QuidaxBaseObject
+  def get(query:)
+    QuidaxQuote.get(q_object: @quidax, query: query)
+  end
+
+  def self.get(q_object:, query:)
+    query.stringify_keys!
+    Utils.check_missing_keys(required_keys: %w[market unit kind volume], keys: query.keys, field: "query")
+    Utils.validate_value_in_array(array: %w[ask bid], value: query["kind"], field: 'query["kind"]')
+
+    path = API::QUOTE_PATH
+
+    get_request(q_object, path, query)
+  end
+end

data/lib/quidax/objects/trade.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Trade object
+class QuidaxTrade < QuidaxBaseObject
+  def for_user(user_id:)
+    QuidaxTrade.for_user(q_object: @quidax, user_id: user_id)
+  end
+
+  def for_market(market:)
+    QuidaxTrade.for_market(q_object: @quidax, market: market)
+  end
+
+  def self.for_user(q_object:, user_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::TRADES_PATH}"
+
+    get_request(q_object, path)
+  end
+
+  def self.for_market(q_object:, market:)
+    path = "#{API::TRADES_PATH}/#{market}"
+    get_request(q_object, path)
+  end
+end

data/lib/quidax/objects/user.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Object for user related operations
+class QuidaxUser < QuidaxBaseObject
+  def get_account_details(user_id:)
+    QuidaxUser.get_account_details(q_object: @quidax, user_id: user_id)
+  end
+
+  def create_sub_account(body:)
+    QuidaxUser.create_sub_account(q_object: @quidax, body: body)
+  end
+
+  def get_all_sub_accounts
+    QuidaxUser.get_all_sub_accounts(q_object: @quidax)
+  end
+
+  def edit_account(user_id:, body:)
+    QuidaxUser.edit_account(q_object: @quidax, user_id: user_id, body: body)
+  end
+
+  def self.get_account_details(q_object:, user_id:)
+    path = "#{API::USER_PATH}/#{user_id}"
+    get_request(q_object, path)
+  end
+
+  def self.create_sub_account(q_object:, body:)
+    body.stringify_keys!
+    Utils.check_missing_keys(required_keys: %w[email first_name last_name phone_number], keys: body.keys,
+                             field: "body")
+    post_request(q_object, API::USER_PATH, body)
+  end
+
+  def self.get_all_sub_accounts(q_object:)
+    get_request(q_object, API::USER_PATH)
+  end
+
+  def self.edit_account(q_object:, user_id:, body:)
+    path = "#{API::USER_PATH}/#{user_id}"
+    put_request(q_object, path, body)
+  end
+end

data/lib/quidax/objects/wallet.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# Object for wallet related actions
+class QuidaxWallet < QuidaxBaseObject
+  def get_user_wallets(user_id:)
+    QuidaxWallet.get_user_wallets(q_object: @quidax, user_id: user_id)
+  end
+
+  def get_user_wallet(user_id:, currency:)
+    QuidaxWallet.get_user_wallet(q_object: @quidax, user_id: user_id, currency: currency)
+  end
+
+  def get_payment_address(user_id:, currency:)
+    QuidaxWallet.get_payment_address(q_object: @quidax, user_id: user_id, currency: currency)
+  end
+
+  def get_payment_address_by_id(user_id:, currency:, address_id:)
+    QuidaxWallet.get_payment_address_by_id(q_object: @quidax, user_id: user_id, currency: currency,
+                                           address_id: address_id)
+  end
+
+  def get_payment_addresses(user_id:, currency:)
+    QuidaxWallet.get_payment_addresses(q_object: @quidax, user_id: user_id, currency: currency)
+  end
+
+  def create_crypto_payment_address(user_id:, currency:)
+    QuidaxWallet.create_crypto_payment_address(q_object: @quidax, user_id: user_id, currency: currency)
+  end
+
+  def validate_address(currency:, address:)
+    QuidaxWallet.validate_address(q_object: @quidax, currency: currency, address: address)
+  end
+
+  def self.get_user_wallets(q_object:, user_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::WALLET_PATH}"
+    get_request(q_object, path)
+  end
+
+  def self.get_user_wallet(q_object:, user_id:, currency:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::WALLET_PATH}/#{currency}"
+    get_request(q_object, path)
+  end
+
+  def self.get_payment_address(q_object:, user_id:, currency:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::WALLET_PATH}/#{currency}/address"
+    get_request(q_object, path)
+  end
+
+  def self.get_payment_address_by_id(q_object:, user_id:, currency:, address_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::WALLET_PATH}/#{currency}/addresses/#{address_id}"
+    get_request(q_object, path)
+  end
+
+  def self.get_payment_addresses(q_object:, user_id:, currency:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::WALLET_PATH}/#{currency}/addresses"
+    get_request(q_object, path)
+  end
+
+  def self.create_crypto_payment_address(q_object:, user_id:, currency:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::WALLET_PATH}/#{currency}/addresses"
+    post_request(q_object, path)
+  end
+
+  def self.validate_address(q_object:, currency:, address:)
+    path = "/#{currency}/#{address}/validate_address"
+    get_request(q_object, path)
+  end
+end

data/lib/quidax/objects/withdrawal.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Object for withdrawal related actions
+class QuidaxWithdrawal < QuidaxBaseObject
+  def get_all_withdrawals_detail(user_id:, query:)
+    QuidaxWithdrawal.get_all_withdrawals_detail(q_object: @quidax, user_id: user_id, query: query)
+  end
+
+  def get_detail(user_id:, withdrawal_id:)
+    QuidaxWithdrawal.get_detail(q_object: @quidax, user_id: user_id, withdrawal_id: withdrawal_id)
+  end
+
+  def cancel(withdrawal_id:)
+    QuidaxWithdrawal.cancel(q_object: @quidax, withdrawal_id: withdrawal_id)
+  end
+
+  def self.get_all_withdrawals_detail(q_object:, user_id:, query:)
+    Utils.check_missing_keys(required_keys: %w[currency state], keys: query.keys, field: "query")
+    path = "#{API::USER_PATH}/#{user_id}#{API::WITHDRAWAL_PATH}"
+
+    get_request(q_object, path, query)
+  end
+
+  def self.get_detail(q_object:, user_id:, withdrawal_id:)
+    path = "#{API::USER_PATH}/#{user_id}#{API::WITHDRAWAL_PATH}/#{withdrawal_id}"
+    get_request(q_object, path)
+  end
+
+  def self.cancel(q_object:, withdrawal_id:)
+    path = "#{API::USER_PATH}/me#{API::WITHDRAWAL_PATH}/#{withdrawal_id}/cancel"
+    post_request(q_object, path)
+  end
+end