# -*- coding: utf-8 -*-

# PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
# https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code

from ccxt.base.exchange import Exchange
from ccxt.abstract.ellipx import ImplicitAPI
import math
from ccxt.base.types import Any, Balances, Currencies, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Ticker, Trade, TradingFeeInterface, Transaction
from typing import List
from ccxt.base.errors import ExchangeError
from ccxt.base.errors import AuthenticationError
from ccxt.base.errors import PermissionDenied
from ccxt.base.errors import ArgumentsRequired
from ccxt.base.errors import BadRequest
from ccxt.base.errors import NotSupported
from ccxt.base.errors import DDoSProtection
from ccxt.base.decimal_to_precision import TICK_SIZE
from ccxt.base.precise import Precise


class ellipx(Exchange, ImplicitAPI):

    def describe(self) -> Any:
        return self.deep_extend(super(ellipx, self).describe(), {
            'id': 'ellipx',
            'name': 'Ellipx',
            'countries': ['PL'],
            'rateLimit': 200,  # todo check
            'version': 'v1',
            'certified': False,
            'pro': False,
            'has': {
                'CORS': None,
                'spot': True,
                'margin': False,
                'swap': False,
                'future': False,
                'option': False,
                'addMargin': False,
                'borrowCrossMargin': False,
                'borrowIsolatedMargin': False,
                'borrowMargin': False,
                'cancelAllOrders': False,
                'cancelAllOrdersAfter': False,
                'cancelOrder': True,
                'cancelOrders': False,
                'cancelWithdraw': False,
                'closeAllPositions': False,
                'closePosition': False,
                'createConvertTrade': False,
                'createDepositAddress': False,
                'createMarketBuyOrderWithCost': False,
                'createMarketOrder': False,
                'createMarketOrderWithCost': False,
                'createMarketSellOrderWithCost': False,
                'createOrder': True,
                'createOrderWithTakeProfitAndStopLoss': False,
                'createOrderWithTakeProfitAndStopLossWs': False,
                'createPostOnlyOrder': False,
                'createReduceOnlyOrder': False,
                'createStopLimitOrder': False,
                'createStopLossOrder': False,
                'createStopMarketOrder': False,
                'createStopOrder': False,
                'createTakeProfitOrder': False,
                'createTrailingAmountOrder': False,
                'createTrailingPercentOrder': False,
                'createTriggerOrder': False,
                'fetchAccounts': False,
                'fetchBalance': True,
                'fetchBorrowInterest': False,
                'fetchBorrowRate': False,
                'fetchBorrowRateHistories': False,
                'fetchBorrowRateHistory': False,
                'fetchBorrowRates': False,
                'fetchBorrowRatesPerSymbol': False,
                'fetchCanceledAndClosedOrders': False,
                'fetchCanceledOrders': False,
                'fetchClosedOrder': False,
                'fetchClosedOrders': False,
                'fetchConvertCurrencies': False,
                'fetchConvertQuote': False,
                'fetchConvertTrade': False,
                'fetchConvertTradeHistory': False,
                'fetchCrossBorrowRate': False,
                'fetchCrossBorrowRates': False,
                'fetchCurrencies': True,
                'fetchDepositAddress': True,
                'fetchDeposits': False,
                'fetchDepositsWithdrawals': False,
                'fetchFundingHistory': False,
                'fetchFundingInterval': False,
                'fetchFundingIntervals': False,
                'fetchFundingRate': False,
                'fetchFundingRateHistory': False,
                'fetchFundingRates': False,
                'fetchGreeks': False,
                'fetchIndexOHLCV': False,
                'fetchIsolatedBorrowRate': False,
                'fetchIsolatedBorrowRates': False,
                'fetchIsolatedPositions': False,
                'fetchLedger': False,
                'fetchLeverage': False,
                'fetchLeverages': False,
                'fetchLeverageTiers': False,
                'fetchLiquidations': False,
                'fetchLongShortRatio': False,
                'fetchLongShortRatioHistory': False,
                'fetchMarginAdjustmentHistory': False,
                'fetchMarginMode': False,
                'fetchMarginModes': False,
                'fetchMarketLeverageTiers': False,
                'fetchMarkets': True,
                'fetchMarkOHLCV': False,
                'fetchMarkPrices': False,
                'fetchMyLiquidations': False,
                'fetchMySettlementHistory': False,
                'fetchMyTrades': False,
                'fetchOHLCV': True,
                'fetchOpenInterest': False,
                'fetchOpenInterestHistory': False,
                'fetchOpenInterests': False,
                'fetchOpenOrder': False,
                'fetchOpenOrders': True,
                'fetchOption': False,
                'fetchOptionChain': False,
                'fetchOrder': True,
                'fetchOrderBook': True,
                'fetchOrders': True,
                'fetchOrderTrades': True,
                'fetchPosition': False,
                'fetchPositionHistory': False,
                'fetchPositionMode': False,
                'fetchPositions': False,
                'fetchPositionsForSymbol': False,
                'fetchPositionsHistory': False,
                'fetchPositionsRisk': False,
                'fetchPremiumIndexOHLCV': False,
                'fetchSettlementHistory': False,
                'fetchStatus': False,
                'fetchTicker': True,
                'fetchTickers': False,
                'fetchTime': False,
                'fetchTrades': True,
                'fetchTradingFee': True,
                'fetchTradingFees': False,
                'fetchTransactions': False,
                'fetchTransfers': False,
                'fetchVolatilityHistory': False,
                'fetchWithdrawals': False,
                'reduceMargin': False,
                'repayCrossMargin': False,
                'repayIsolatedMargin': False,
                'repayMargin': False,
                'sandbox': False,
                'setLeverage': False,
                'setMargin': False,
                'setMarginMode': False,
                'setPositionMode': False,
                'transfer': False,
                'withdraw': True,
            },
            'timeframes': {
                '1m': '1m',
                '5m': '5m',
                '10m': '10m',
                '1h': '1h',
                '6h': '6h',
                '12h': '12h',
                '1d': '1d',
            },
            'urls': {
                'logo': 'https://github.com/user-attachments/assets/e07c3f40-281c-4cdf-bacf-fa1c58218a2c',
                'api': {
                    'public': 'https://data.ellipx.com',
                    'private': 'https://app.ellipx.com/_rest',
                    '_rest': 'https://app.ellipx.com/_rest',
                },
                'www': 'https://www.ellipx.com',
                'doc': 'https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM',
                'fees': 'https://www.ellipx.com/pages/pricing',
                'referral': '',  # todo
            },
            'api': {
                '_rest': {
                    'get': {
                        'Market': 1,
                        'Market/{currencyPair}': 1,
                        'Crypto/Token/Info': 1,
                    },
                },
                'public': {
                    'get': {
                        'Market/{currencyPair}:getDepth': 1,
                        'Market/{currencyPair}:ticker': 1,
                        'Market/{currencyPair}:getTrades': 1,
                        'Market/{currencyPair}:getGraph': 1,
                        'CMC:summary': 1,
                        'CMC/{currencyPair}:ticker': 1,
                    },
                },
                'private': {
                    'get': {
                        'User/Wallet': 1,
                        'Market/{currencyPair}/Order': 1,
                        'Market/Order/{orderUuid}': 1,
                        'Market/{currencyPair}/Trade': 1,
                        'Market/TradeFee:query': 1,
                        'Unit/{currency}': 1,
                        'Crypto/Token/{currency}': 1,
                        'Crypto/Token/{currency}:chains': 1,
                    },
                    'post': {
                        'Market/{currencyPair}/Order': 1,
                        'Crypto/Address:fetch': 1,
                        'Crypto/Disbursement:withdraw': 1,
                    },
                    'delete': {
                        'Market/Order/{orderUuid}': 1,
                    },
                },
            },
            'fees': {
                'trading': {
                    'tierBased': True,
                    'feeSide': 'get',
                    'percentage': True,
                    'maker': self.parse_number('0.0025'),  # default 25bps
                    'taker': self.parse_number('0.0030'),  # default 30bps
                    'tiers': {
                        # volume in USDT
                        'maker': [
                            [self.parse_number('0'), self.parse_number('0.0025')],     # 0-10k: 25bps
                            [self.parse_number('10000'), self.parse_number('0.0020')],  # 10k-50k: 20bps
                            [self.parse_number('50000'), self.parse_number('0.0015')],  # 50k-100k: 15bps
                            [self.parse_number('100000'), self.parse_number('0.0010')],  # 100k-1M: 10bps
                            [self.parse_number('1000000'), self.parse_number('0.0008')],  # 1M-5M: 8bps
                            [self.parse_number('5000000'), self.parse_number('0.0003')],  # 5M-15M: 3bps
                            [self.parse_number('15000000'), self.parse_number('0.0000')],  # 15M-75M: 0bps
                            [self.parse_number('75000000'), self.parse_number('0.0000')],  # 75M-100M: 0bps
                            [self.parse_number('100000000'), self.parse_number('0.0000')],  # 100M+: 0bps
                        ],
                        'taker': [
                            [self.parse_number('0'), self.parse_number('0.0030')],     # 0-10k: 30bps
                            [self.parse_number('10000'), self.parse_number('0.0025')],  # 10k-50k: 25bps
                            [self.parse_number('50000'), self.parse_number('0.0020')],  # 50k-100k: 20bps
                            [self.parse_number('100000'), self.parse_number('0.0015')],  # 100k-1M: 15bps
                            [self.parse_number('1000000'), self.parse_number('0.0012')],  # 1M-5M: 12bps
                            [self.parse_number('5000000'), self.parse_number('0.0010')],  # 5M-15M: 10bps
                            [self.parse_number('15000000'), self.parse_number('0.0008')],  # 15M-75M: 8bps
                            [self.parse_number('75000000'), self.parse_number('0.0005')],  # 75M-100M: 5bps
                            [self.parse_number('100000000'), self.parse_number('0.0003')],  # 100M+: 3bps
                        ],
                    },
                },
                'stablecoin': {
                    'tierBased': False,
                    'percentage': True,
                    'maker': self.parse_number('0.0000'),  # 0%
                    'taker': self.parse_number('0.000015'),  # 0.0015%
                },
            },
            'options': {
                'defaultType': 'spot',
                'recvWindow': 5 * 1000,
                'broker': 'CCXT',
                'networks': {
                    'Bitcoin': 'Bitcoin',
                    'Ethereum': 'ERC20',
                },
                'defaultNetwork': 'defaultNetwork',
                'defaultNetworkCodeReplacements': {
                    'BTC': 'Bitcoin',
                    'ETH': 'Ethereum',
                },
            },
            'features': {
                'spot': {
                    'sandbox': False,
                    'createOrder': {
                        'marginMode': False,
                        'triggerPrice': False,
                        'triggerPriceType': None,
                        'triggerDirection': False,
                        'stopLossPrice': False,
                        'takeProfitPrice': False,
                        'attachedStopLossTakeProfit': None,
                        'timeInForce': {
                            'IOC': False,
                            'FOK': False,
                            'PO': False,
                            'GTD': False,
                        },
                        'hedged': False,
                        'selfTradePrevention': False,
                        'trailing': False,
                        'leverage': False,
                        'marketBuyByCost': True,
                        'marketBuyRequiresPrice': False,
                        'iceberg': False,
                    },
                    'createOrders': None,
                    'fetchMyTrades': None,
                    'fetchOrder': {
                        'marginMode': False,
                        'trigger': False,
                        'trailing': False,
                        'symbolRequired': False,
                    },
                    'fetchOpenOrders': {
                        'marginMode': False,
                        'limit': None,
                        'trigger': False,
                        'trailing': False,
                        'symbolRequired': True,
                    },
                    'fetchOrders': {
                        'marginMode': False,
                        'limit': None,  # todo
                        'daysBack': None,  # todo
                        'untilDays': None,  # todo
                        'trigger': False,
                        'trailing': False,
                        'symbolRequired': True,
                    },
                    'fetchClosedOrders': None,
                    'fetchOHLCV': {
                        'limit': 100,
                    },
                },
                'swap': {
                    'linear': None,
                    'inverse': None,
                },
                'future': {
                    'linear': None,
                    'inverse': None,
                },
            },
            'commonCurrencies': {},
            'exceptions': {
                'exact': {
                    # todo
                    '400': BadRequest,
                    '401': AuthenticationError,
                    '403': PermissionDenied,
                    '404': BadRequest,
                    '429': DDoSProtection,
                    '418': PermissionDenied,
                    '500': ExchangeError,
                    '504': ExchangeError,
                },
                'broad': {},
            },
            'precisionMode': TICK_SIZE,
        })

    def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
        path = self.implode_params(path, params)
        url = self.urls['api'][api] + '/' + path
        if api == 'private':
            self.check_required_credentials()
            nonce = self.uuid()
            timestamp = str(self.seconds())
            if method == 'GET':
                body = ''
            else:
                body = self.json(params)
            params = self.extend({
                '_key': self.apiKey,
                '_time': timestamp,
                '_nonce': nonce,
            }, params)
            query = self.urlencode(params)
            bodyHash = self.hash(self.encode(body), 'sha256')
            # Create sign string components
            bodyHashBytes = self.base16_to_binary(bodyHash)
            nulByte = self.number_to_be(0, 1)
            components = [
                self.encode(method),
                nulByte,
                self.encode(path),
                nulByte,
                self.encode(query),
                nulByte,
                bodyHashBytes,
            ]
            # Join with null byte separator using encode
            signString = self.binary_concat_array(components)
            sec = self.secret
            remainder = self.calculate_mod(len(sec), 4)
            paddingLength = 4 - remainder if remainder else 0
            secretWithPadding = self.secret.replace('-', '+')
            secretWithPadding = secretWithPadding.replace('_', '/')
            secretWithPadding = secretWithPadding.ljust(len(self.secret) + paddingLength, '=')
            secretBytes = self.base64_to_binary(secretWithPadding)
            seed = self.array_slice(secretBytes, 0, 32)  # Extract first 32 bytes
            signature = self.eddsa(signString, seed, 'ed25519')
            params['_sign'] = signature
        if params:
            url += '?' + self.urlencode(params)
        if method == 'GET':
            body = None
        else:
            headers = {
                'Content-Type': 'application/json',
            }
        return {'url': url, 'method': method, 'body': body, 'headers': headers}

    def calculate_mod(self, a, b):
        # trick to fix php transpiling error
        return a % b

    def fetch_markets(self, params={}) -> List[Market]:
        """
        Fetches market information from the exchange.

        https://docs.ccxt.com/en/latest/manual.html#markets
        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.1a1t05wpgfof

        :param dict [params]: - Extra parameters specific to the exchange API endpoint
        :returns Promise<Market[]>: An array of market structures.
        """
        response = self._restGetMarket(params)
        # {
        #     Market__: "mkt-lrnp2e-eaor-eobj-ua73-75j6sjxe",
        #     Primary_Unit__: "unit-aebkye-u35b-e5zm-zt22-2qvwhsqa",
        #     Secondary_Unit__: "unit-jcevlk-soxf-fepb-yjwm-b32q5bom",
        #     Primary_Step: null,
        #     Secondary_Step: null,
        #     Status: "active",
        #     Default_Scale: "5",
        #     Priority: "100",
        #     Created: {
        #       unix: "1728113809",
        #       us: "0",
        #       iso: "2024-10-05 07:36:49.000000",
        #       tz: "UTC",
        #       full: "1728113809000000",
        #       unixms: "1728113809000",
        #     },
        #     Start: {
        #       unix: "1728295200",
        #       us: "0",
        #       iso: "2024-10-07 10:00:00.000000",
        #       tz: "UTC",
        #       full: "1728295200000000",
        #       unixms: "1728295200000",
        #     },
        #     Key: "BTC_USDC",
        #     Primary: {
        #       Unit__: "unit-aebkye-u35b-e5zm-zt22-2qvwhsqa",
        #       Currency__: "BTC",
        #       Crypto_Token__: "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
        #       Key: "BTC",
        #       Symbol: "BTC",
        #       Symbol_Position: "after",
        #       Name: "Bitcoin",
        #       Decimals: "8",
        #       Display_Decimals: "8",
        #       Legacy_Decimals: null,
        #       Type: "crypto_token",
        #       Visible: "Y",
        #       Created: {
        #         unix: "1495247415",
        #         us: "0",
        #         iso: "2017-05-20 02:30:15.000000",
        #         tz: "UTC",
        #         full: "1495247415000000",
        #         unixms: "1495247415000",
        #       },
        #     },
        #     Secondary: {
        #       Unit__: "unit-jcevlk-soxf-fepb-yjwm-b32q5bom",
        #       Currency__: null,
        #       Crypto_Token__: "crtok-ptabkh-ra4r-anbd-cqra-bqfbtnba",
        #       Key: "USDC",
        #       Symbol: null,
        #       Symbol_Position: "before",
        #       Name: "Circle USD",
        #       Decimals: "6",
        #       Display_Decimals: "6",
        #       Legacy_Decimals: null,
        #       Type: "crypto_token",
        #       Visible: "Y",
        #       Created: {
        #         unix: "1694859829",
        #         us: "0",
        #         iso: "2023-09-16 10:23:49.000000",
        #         tz: "UTC",
        #         full: "1694859829000000",
        #         unixms: "1694859829000",
        #       },
        #     },
        #   }
        markets = self.safe_value(response, 'data', [])
        return self.parse_markets(markets)

    def parse_market(self, market: dict) -> Market:
        id = self.safe_string(market, 'Key')
        base = self.safe_string(market['Primary'], 'Key')
        quote = self.safe_string(market['Secondary'], 'Key')
        baseId = self.safe_string(market['Primary'], 'Crypto_Token__')
        quoteId = self.safe_string(market['Secondary'], 'Crypto_Token__')
        status = self.safe_string(market, 'Status') == 'active'
        created = self.safe_timestamp(market['Created'], 'unix')
        amountPrecision = self.parse_number(self.parse_precision(self.safe_string(market['Primary'], 'Decimals')))
        pricePrecision = self.parse_number(self.parse_precision(self.safe_string(market['Secondary'], 'Decimals')))
        fees = self.fees  # should use fetchTradingFees
        return self.safe_market_structure({
            'id': id,
            'symbol': base + '/' + quote,
            'base': base,
            'quote': quote,
            'settle': None,
            'baseId': baseId,
            'quoteId': quoteId,
            'settleId': None,
            'type': 'spot',
            'spot': True,
            'margin': False,
            'swap': False,
            'future': False,
            'option': False,
            'active': status,
            'contract': False,
            'linear': None,
            'inverse': None,
            'taker': fees['trading']['taker'],
            'maker': fees['trading']['maker'],
            'contractSize': None,
            'expiry': None,
            'expiryDatetime': None,
            'strike': None,
            'optionType': None,
            'precision': {
                'amount': amountPrecision,
                'price': pricePrecision,
            },
            'limits': {
                'amount': {
                    'min': None,
                    'max': None,
                },
                'price': {
                    'min': None,
                    'max': None,
                },
                'cost': {
                    'min': None,
                    'max': None,
                },
            },
            'info': market,
            'created': created,
        })

    def fetch_ticker(self, symbol: str, params={}) -> Ticker:
        """
        fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.d2jylz4u6pmu

        :param str symbol: unified symbol of the market to fetch the ticker for
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
        """
        self.load_markets()
        market = self.market(symbol)
        marketId = market['id']
        request = {
            'currencyPair': marketId,
        }
        response = self.publicGetMarketCurrencyPairTicker(self.extend(request, params))
        #
        #     {
        #         "data": {
        #             "market": "BTC_USDC",
        #             "ticker": {
        #                 "time": 1730814600,
        #                 "count": 2135,
        #                 "high": {
        #                     "v": "74766990000",
        #                     "e": 6,
        #                     "f": 74766.99
        #                 },
        #                 "low": {
        #                     "v": "68734020000",
        #                     "e": 6,
        #                     "f": 68734.02
        #                 },
        #                 "avg": {
        #                     "v": "72347941430",
        #                     "e": 6,
        #                     "f": 72347.94143
        #                 },
        #                 "vwap": {
        #                     "v": "73050064447",
        #                     "e": 6,
        #                     "f": 73050.064447
        #                 },
        #                 "vol": {
        #                     "v": "4885361",
        #                     "e": 8,
        #                     "f": 0.04885361
        #                 },
        #                 "secvol": {
        #                     "v": "3568759346",
        #                     "e": 6,
        #                     "f": 3568.759346
        #                 },
        #                 "open": {
        #                     "v": "68784020000",
        #                     "e": 6,
        #                     "f": 68784.02
        #                 },
        #                 "close": {
        #                     "v": "73955570000",
        #                     "e": 6,
        #                     "f": 73955.57
        #                 }
        #             }
        #         },
        #         "request_id": "cbf183e0-7a62-4674-838c-6693031fa240",
        #         "result": "success",
        #         "time": 0.015463566
        #     }
        #
        ticker = self.safe_value(response['data'], 'ticker', {})
        return self.parse_ticker(ticker, market)

    def parse_ticker(self, ticker: dict, market: Market = None) -> Ticker:
        timestamp = self.safe_integer_product(ticker, 'time', 1000)
        open = self.parse_amount(self.safe_value(ticker, 'open'))
        high = self.parse_amount(self.safe_value(ticker, 'high'))
        low = self.parse_amount(self.safe_value(ticker, 'low'))
        close = self.parse_amount(self.safe_value(ticker, 'close'))
        avg = self.parse_amount(self.safe_value(ticker, 'avg'))
        vwap = self.parse_amount(self.safe_value(ticker, 'vwap'))
        baseVolume = self.parse_amount(self.safe_value(ticker, 'vol'))
        quoteVolume = self.parse_amount(self.safe_value(ticker, 'secvol'))
        # count = self.safe_integer(ticker, 'count'); not used
        return self.safe_ticker({
            'symbol': self.safe_symbol(None, market),
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'high': high,
            'low': low,
            'bid': None,
            'bidVolume': None,
            'ask': None,
            'askVolume': None,
            'vwap': vwap,
            'open': open,
            'close': close,
            'last': close,
            'previousClose': None,
            'change': None,
            'percentage': None,
            'average': avg,
            'baseVolume': baseVolume,
            'quoteVolume': quoteVolume,
            'info': ticker,
        }, market)

    def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
        """
        fetches information on open orders with bid(buy) and ask(sell) prices, volumes and other data

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.bqmucewhkpdz

        :param str symbol: unified symbol of the market to fetch the order book for
        :param int [limit]: the maximum amount of order book entries to return the exchange not supported yet.
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
        """
        self.load_markets()
        market = self.market(symbol)
        marketId = market['id']
        request = {
            'currencyPair': marketId,
        }
        response = self.publicGetMarketCurrencyPairGetDepth(self.extend(request, params))
        # {
        #     "data": {
        #         "asks": [
        #             {
        #                 "price": {
        #                     "v": "74941875231",
        #                     "e": 6,
        #                     "f": 74941.875231
        #                 },
        #                 "amount": {
        #                     "v": "149",
        #                     "e": 8,
        #                     "f": 0.00000149
        #                 }
        #             },
        #             {
        #                 "price": {
        #                     "v": "75063426037",
        #                     "e": 6,
        #                     "f": 75063.426037
        #                 },
        #                 "amount": {
        #                     "v": "335",
        #                     "e": 8,
        #                     "f": 0.00000335
        #                 }
        #             }
        #         ],
        #         "bids": [
        #             {
        #                 "price": {
        #                     "v": "64518711040",
        #                     "e": 6,
        #                     "f": 64518.71104
        #                 },
        #                 "amount": {
        #                     "v": "132",
        #                     "e": 8,
        #                     "f": 0.00000132
        #                 }
        #             },
        #             {
        #                 "price": {
        #                     "v": "64263569273",
        #                     "e": 6,
        #                     "f": 64263.569273
        #                 },
        #                 "amount": {
        #                     "v": "210",
        #                     "e": 8,
        #                     "f": 0.0000021
        #                 }
        #             }
        #         ],
        #         "market": "BTC_USDC"
        #     },
        #     "request_id": "71b7dffc-3120-4e46-a0bb-49ece5aea7e1",
        #     "result": "success",
        #     "time": 0.000074661
        # }
        data = self.safe_value(response, 'data', {})  # exchange specific v e f params
        timestamp = self.milliseconds()  # the exchange does not provide timestamp for self.
        dataBidsLength = len(data['bids'])
        dataAsksLength = len(data['asks'])
        for i in range(0, dataBidsLength):
            data['bids'][i]['price'] = self.parse_amount(data['bids'][i]['price'])
            data['bids'][i]['amount'] = self.parse_amount(data['bids'][i]['amount'])
        for i in range(0, dataAsksLength):
            data['asks'][i]['price'] = self.parse_amount(data['asks'][i]['price'])
            data['asks'][i]['amount'] = self.parse_amount(data['asks'][i]['amount'])
        return self.parse_order_book(data, symbol, timestamp, 'bids', 'asks', 'price', 'amount')

    def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}):
        """
        fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market, default will return the last 24h period.

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.w65baeuhxwt8

        :param str symbol: unified symbol of the market to fetch OHLCV data for
        :param str timeframe: the length of time each candle represents
        :param int [since]: timestamp in ms of the earliest candle to fetch
        :param int [limit]: the maximum amount of candles to fetch
        :param dict [params]: extra parameters specific to the API endpoint
        :param int [params.until]: timestamp in ms of the earliest candle to fetch
        :returns OHLCV[]: A list of candles ordered, open, high, low, close, volume
        """
        self.load_markets()
        methodName = 'fetchOHLCV'
        paginate = False
        paginate, params = self.handle_option_and_params(params, methodName, 'paginate')
        if paginate:
            return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 1000)
        market = self.market(symbol)
        marketId = market['id']
        time_frame = self.safe_string(self.timeframes, timeframe, None)
        request: dict = {
            'currencyPair': marketId,
            'interval': time_frame,
        }
        if since is not None:
            request['start'] = int(math.floor(since / 1000))
        until: Int = None
        until, params = self.handle_option_and_params(params, methodName, 'until')
        if until is not None:
            request['end'] = until
        # {
        #     "data": {
        #         "market": "BTC_USDC",
        #         "real_end": 1730970780,
        #         "requested_end": 1730970784,
        #         "start": 1730884200,
        #         "stats": [
        #             {
        #                 "time": 1730884200,
        #                 "count": 48,
        #                 "high": {"v": "73898950000", "e": 6, "f": 73898.95},
        #                 "low": {"v": "73642930000", "e": 6, "f": 73642.93},
        #                 "open": {"v": "73830990000", "e": 6, "f": 73830.99},
        #                 "close": {"v": "73682510000", "e": 6, "f": 73682.51},
        #                 "vol": {"v": "88159", "e": 8, "f": 0.00088159}
        #             }
        #         ]
        #     }
        # }
        # No limit parameter supported by the API
        response = self.publicGetMarketCurrencyPairGetGraph(self.extend(request, params))
        data = self.safe_dict(response, 'data', {})
        ohlcv = self.safe_list(data, 'stats', [])
        return self.parse_ohlcvs(ohlcv, market, timeframe, since, limit)

    def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
        return [
            self.safe_integer(ohlcv, 'time') * 1000,  # timestamp
            self.parse_number(self.parse_amount(self.safe_dict(ohlcv, 'open'))),      # open
            self.parse_number(self.parse_amount(self.safe_dict(ohlcv, 'high'))),      # high
            self.parse_number(self.parse_amount(self.safe_dict(ohlcv, 'low'))),       # low
            self.parse_number(self.parse_amount(self.safe_dict(ohlcv, 'close'))),     # close
            self.parse_number(self.parse_amount(self.safe_dict(ohlcv, 'vol'))),       # volume
        ]

    def fetch_currencies(self, params={}) -> Currencies:
        """
        fetches information on all currencies from the exchange, including deposit/withdrawal details and available chains

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.x65f9s9j74jf

        :param dict [params]: extra parameters specific to the ellipx API endpoint
        :param str [params.Can_Deposit]: filter currencies by deposit availability, Y for available
        :param number [params.results_per_page]: number of results per page, default 100
        :param str [params._expand]: additional fields to expand in response, default '/Crypto_Token,/Crypto_Chain'
        :returns Promise<Currencies>: An object of currency structures indexed by currency codes
        """
        response = self._restGetCryptoTokenInfo(self.extend({
            'Can_Deposit': 'Y',
            'results_per_page': 100,
            '_expand': '/Crypto_Token,/Crypto_Chain',
        }, params))
        result = {}
        data = self.safe_list(response, 'data', [])
        for i in range(0, len(data)):
            networkEntry = data[i]
            #
            #    {
            #        "Crypto_Token_Info__": "crtev-5nsn35-f4ir-g5hp-iaft-i4ztx6zu",
            #        "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
            #        "Crypto_Chain__": "chain-xjbini-7wlz-dmzf-gm7z-zf7ei6fq",
            #        "Type": "native",
            #        "Symbol": null,
            #        "Name": null,
            #        "Contract_Address": null,
            #        "Minimum_Deposit": {
            #            "v": "6",
            #            "e": "6",
            #            "f": "6.0e-6"
            #        },
            #        "Minimum_Withdraw": {
            #            "v": "15",
            #            "e": "5",
            #            "f": "0.00015"
            #        },
            #        "Withdraw_Fee": {
            #            "v": "1",
            #            "e": "4",
            #            "f": "0.0001"
            #        },
            #        "Minimum_Collect": null,
            #        "Status": "valid",
            #        "Can_Deposit": "Y",
            #        "Decimals": null,
            #        "Priority": "100",
            #        "Created": {
            #            "unix": "1727552199",
            #            "us": "0",
            #            "iso": "2024-09-28 19:36:39.000000",
            #            "tz": "UTC",
            #            "full": "1727552199000000",
            #            "unixms": "1727552199000"
            #        },
            #        "Crypto_Token": {
            #            "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
            #            "Name": "Bitcoin",
            #            "Symbol": "BTC",
            #            "Decimals": "8",
            #            "CMC_Id": "1",
            #            "Priority": "100",
            #            "Can_Deposit": "Y",
            #            "Category": "token",
            #            "Testnet": "N",
            #            "Created": {
            #                "unix": "1727552113",
            #                "us": "0",
            #                "iso": "2024-09-28 19:35:13.000000",
            #                "tz": "UTC",
            #                "full": "1727552113000000",
            #                "unixms": "1727552113000"
            #            },
            #            "Logo": [
            #                {
            #                    "Crypto_Token_Logo__": "ctklg-aoozyr-rzm5-fphf-dhm7-5wbtetha",
            #                    "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
            #                    "Blob__": "blob-d6hvgx-37s5-dh5h-ogj5-qxqvnaoy",
            #                    "Default": "Y",
            #                    "Format": "png",
            #                    "Priority": "0",
            #                    "Created": {
            #                        "unix": "1730196627",
            #                        "us": "929660",
            #                        "iso": "2024-10-29 10:10:27.929660",
            #                        "tz": "UTC",
            #                        "full": "1730196627929660",
            #                        "unixms": "1730196627929"
            #                    },
            #                    "Source": {
            #                        "Media_Image__": "blob-d6hvgx-37s5-dh5h-ogj5-qxqvnaoy",
            #                        "Url": "https://static.atonline.net/image/m_X7_tnmIYFCwn6EUVQuMKqrCuPB3CMl4ONTegeYpC0wIg68YZM0CuBpbjspnYwz/1a942eab068a2173e66d08c736283cfe22e1c1ed"
            #                    }
            #                }
            #            ]
            #        },
            #        "Crypto_Chain": {
            #            "Crypto_Chain__": "chain-xjbini-7wlz-dmzf-gm7z-zf7ei6fq",
            #            "EVM_Chain__": null,
            #            "Crypto_Token__": "crtok-c5v3mh-grfn-hl5d-lmel-fvggbf4i",
            #            "Name": "Bitcoin",
            #            "Key": "bitcoin",
            #            "Type": "Bitcoin",
            #            "Curve": "secp256k1",
            #            "Backend_Url": null,
            #            "Wallet_Verification_Methods": {
            #                "signature": True
            #            },
            #            "Block_Margin": "3",
            #            "Created": {
            #                "unix": "1725340084",
            #                "us": "0",
            #                "iso": "2024-09-03 05:08:04.000000",
            #                "tz": "UTC",
            #                "full": "1725340084000000",
            #                "unixms": "1725340084000"
            #            }
            #        }
            #    }
            #
            id = self.safe_string(networkEntry, 'Crypto_Token__')
            token = self.safe_dict(networkEntry, 'Crypto_Token', {})
            code = self.safe_currency_code(self.safe_string(token, 'Symbol'))
            if not (code in result):
                result[code] = {
                    'id': id,
                    'code': code,
                    'info': [],
                    'type': None,
                    'name': self.safe_string(token, 'Name'),
                    'active': None,
                    'deposit': None,
                    'withdraw': None,
                    'fee': None,
                    'precision': None,
                    'limits': {
                        'amount': {
                            'min': None,
                            'max': None,
                        },
                        'withdraw': {
                            'min': None,
                            'max': None,
                        },
                        'deposit': {
                            'min': None,
                            'max': None,
                        },
                    },
                    'networks': {},
                }
            networkId = self.safe_string(networkEntry, 'Crypto_Chain__')
            cryptoChainDict = self.safe_string(networkEntry, 'Crypto_Chain')
            networkName = self.safe_string(cryptoChainDict, 'Type', 'default')
            networkCode = self.network_id_to_code(networkName)
            result[code]['networks'][networkCode] = {
                'id': networkId,
                'network': networkCode,
                'active': self.safe_string(networkEntry, 'Status') == 'valid',
                'deposit': self.safe_string(networkEntry, 'Can_Deposit') == 'Y',
                'withdraw': None,
                'fee': self.parse_number(self.parse_amount(networkEntry['Withdraw_Fee'])),
                'precision': self.parse_number(self.parse_precision(self.safe_string(token, 'Decimals'))),
                'limits': {
                    'amount': {
                        'min': None,
                        'max': None,
                    },
                    'withdraw': {
                        'min': self.parse_amount(networkEntry['Minimum_Withdraw']),
                        'max': None,
                    },
                    'deposit': {
                        'min': self.parse_amount(networkEntry['Minimum_Deposit']),
                        'max': None,
                    },
                },
            }
            infos = self.safe_list(result[code], 'info', [])
            infos.append(networkEntry)
            result[code]['info'] = infos
        # only after all entries are formed in currencies, restructure each entry
        allKeys = list(result.keys())
        for i in range(0, len(allKeys)):
            code = allKeys[i]
            result[code] = self.safe_currency_structure(result[code])  # self is needed after adding network entry
        return result

    def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
        """
        fetches all completed trades for a particular market/symbol
        :param str symbol: unified market symbol(e.g. 'BTC/USDT')
        :param int [since]: timestamp in ms of the earliest trade to fetch
        :param int [limit]: the maximum amount of trades to fetch
        :param dict [params]: extra parameters specific to the EllipX API endpoint
        :param str [params.before]: get trades before the given trade ID
        :returns Trade[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
        """
        self.load_markets()
        market = self.market(symbol)
        marketId = market['id']
        request = {
            'currencyPair': marketId,
        }
        # endpoint support before trade id.
        # The actual endpoint URL will be: https://data.ellipx.com/Market/{currencyPair}:getTrades
        # {
        #     "id": "BTC_USDC:1731053859:914141972:0",
        #     "pair": [
        #         "BTC",
        #         "USDC"
        #     ],
        #     "bid": {
        #         "id": "mktor-swishf-uv6n-hrzj-63ye-bdqnk33q",
        #         "iss": "ellipx:beta",
        #         "uniq": "order:1731053859:914141972:0"
        #     },
        #     "ask": {
        #         "id": "mktor-p3ozvt-qurz-gmzo-bf5n-g4rcuy6u",
        #         "iss": "ellipx:beta",
        #         "uniq": "order:1731053859:874659786:0"
        #     },
        #     "type": "bid",
        #     "amount": {
        #         "v": "412",
        #         "e": 8,
        #         "f": 0.00000412
        #     },
        #     "price": {
        #         "v": "75878090000",
        #         "e": 6,
        #         "f": 75878.09
        #     },
        #     "date": "2024-11-08T08:17:39.914141972Z"
        # }
        response = self.publicGetMarketCurrencyPairGetTrades(self.extend(request, params))
        data = self.safe_dict(response, 'data', {})
        trades = self.safe_list(data, 'trades', [])
        return self.parse_trades(trades, market, since, limit)

    def parse_trade(self, trade, market=None) -> Trade:
        # Format of trade ID: "BTC_USDC:1731053859:914141972:0"
        id = self.safe_string(trade, 'id')
        # fetchTrades and fetchMyTrades return different trade structures
        date = self.safe_dict(trade, 'date')
        timestamp = None
        if date is None:
            timestamp = self.parse8601(self.safe_string(trade, 'date'))
        else:
            timestamp = self.safe_integer(date, 'unixms')
        type = self.safe_string(trade, 'type')
        side = 'buy' if (type == 'bid') else 'sell'
        amount = self.safe_dict(trade, 'amount')
        price = self.safe_dict(trade, 'price')
        amountFloat = self.parse_amount(amount)
        priceFloat = self.parse_amount(price)
        # fetchTrades and fetchMyTrades return different trade structures
        pair = self.safe_list(trade, 'pair')
        marketSymbol = None
        if pair is None:
            symbol = self.safe_string(trade, 'pair')
            base, quote = symbol.split('_')
            marketSymbol = base + '/' + quote
        else:
            marketSymbol = self.safe_string(pair, 0) + '/' + self.safe_string(pair, 1)
        bidOrder = self.safe_dict(trade, 'bid')
        askOrder = self.safe_dict(trade, 'ask')
        isBuy = (side == 'buy')
        orderId = self.safe_string(bidOrder, 'id') if isBuy else self.safe_string(askOrder, 'id')
        return self.safe_trade({
            'id': id,
            'info': trade,
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'symbol': marketSymbol,
            'type': None,
            'side': side,
            'order': orderId,
            'takerOrMaker': None,
            'price': priceFloat,
            'amount': amountFloat,
            'cost': None,
            'fee': None,
        })

    def fetch_balance(self, params={}) -> Balances:
        """
        query for balance and get the amount of funds available for trading or funds locked in orders

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.ihrjov144txg

        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
        """
        self.load_markets()
        response = self.privateGetUserWallet(params)
        # {
        #     "User_Wallet__": "usw-vv7hzo-qel5-gupk-neqi-7f3wz5pq",
        #     "User__": "usr-...",
        #     "Realm__": "usrr-cb3c7n-qvxv-fdrb-uc2q-gpja2foi",
        #     "Unit__": "unit-aebkye-u35b-e5zm-zt22-2qvwhsqa",
        #     "Balance": {
        #         "value": "0.00006394",
        #         "value_int": "6394",
        #         "value_disp": "0.00006394",
        #         "value_xint": {
        #             "v": "6394",
        #             "e": 8,
        #             "f": 0.00006394
        #         },
        #         "display": "0.00006394BTC",
        #         "display_short": "0.00006394BTC",
        #         "currency": "BTC",
        #         "unit": "BTC",
        #         "has_vat": False,
        #         "tax_profile": null
        #     },
        #     "Balance_Date": {
        #         "unix": 1731128270,
        #         "us": 426208,
        #         "iso": "2024-11-09 04:57:50.426208",
        #         "tz": "UTC",
        #         "full": "1731128270426208",
        #         "unixms": "1731128270426"
        #     },
        #     "Liabilities": {
        #         "value": "0.00000000",
        #         "value_int": "0",
        #         "value_disp": "0.00000000",
        #         "value_xint": {
        #             "v": "0",
        #             "e": 8,
        #             "f": 0
        #         },
        #         "display": "0.00000000BTC",
        #         "display_short": "0.00000000BTC",
        #         "currency": "BTC",
        #         "unit": "BTC",
        #         "has_vat": False,
        #         "tax_profile": null
        #     },
        #     "Index": "5",
        #     "Backend": "virtual",
        #     "Disable_Limits": "N",
        #     "Unencumbered_Balance": {
        #         "value": "0.00006394",
        #         "value_int": "6394",
        #         "value_disp": "0.00006394",
        #         "value_xint": {
        #             "v": "6394",
        #             "e": 8,
        #             "f": 0.00006394
        #         },
        #         "display": "0.00006394BTC",
        #         "display_short": "0.00006394BTC",
        #         "currency": "BTC",
        #         "unit": "BTC",
        #         "has_vat": False,
        #         "tax_profile": null
        #     }
        # }
        result: dict = {
            'info': response,
            'timestamp': None,
            'datetime': None,
        }
        dataArray = self.safe_list(response, 'data', [])
        # Use first item's timestamp if available
        dataArrayLength = len(dataArray)
        if dataArrayLength > 0:
            firstItem = dataArray[0]
            balanceDate = self.safe_dict(firstItem, 'Balance_Date', {})
            result['timestamp'] = self.safe_integer(balanceDate, 'unixms')
            result['datetime'] = self.iso8601(result['timestamp'])
        # Process each balance entry
        for i in range(0, len(dataArray)):
            entry = dataArray[i]
            balance = self.safe_dict(entry, 'Balance', {})
            code = self.safe_string(balance, 'currency')
            if code is not None:
                account = {
                    'free': self.parse_amount(entry['Unencumbered_Balance']['value_xint']),
                    'used': self.parse_amount(entry['Liabilities']['value_xint']),
                    'total': self.parse_amount(balance['value_xint']),
                }
                result[code] = account
        return self.safe_balance(result)

    def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
        """
        create a new order in a market

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.yzfak2n2bwpo

        :param str symbol: unified market symbol(e.g. 'BTC/USDT')
        :param str type: order type - the exchange automatically sets type to 'limit' if price defined, 'market' if None
        :param str side: 'buy' or 'sell'
        :param float [amount]: amount of base currency to trade(can be None if using Spend_Limit)
        :param float [price]: price per unit of base currency for limit orders
        :param dict [params]: extra parameters specific to the EllipX API endpoint
        :param float [params.cost]: maximum amount to spend in quote currency(required for market orders if amount None)
        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
        """
        self.load_markets()
        market = self.market(symbol)
        # the exchange automatically sets the type to 'limit' if the price is defined and to 'market' if it is not
        marketId = market['id']
        orderType = 'bid'
        if side == 'buy':
            orderType = 'bid'
        else:
            orderType = 'ask'
        request: Any = {
            'currencyPair': marketId,
            'Type': orderType,
        }
        if amount is not None:
            request['Amount'] = self.amount_to_precision(symbol, amount)
        if price is not None:
            request['Price'] = self.price_to_precision(symbol, price)
        cost = self.safe_string(params, 'cost')
        if cost is not None:
            params = self.omit(params, 'cost')
            request['Spend_Limit'] = self.price_to_precision(symbol, cost)
        response = self.privatePostMarketCurrencyPairOrder(self.extend(request, params))
        # {
        #     "result": "success",
        #     "data": {
        #         "Market_Order__": "mktor-x2grmu-zwo5-fyxc-4gue-vd4ouvsa",
        #         "Market__": "mkt-lrnp2e-eaor-eobj-ua73-75j6sjxe",
        #         "User__": "usr-...",
        #         "Uniq": "order:1728719021:583795548:0",
        #         "Type": "bid",
        #         "Status": "pending",
        #         "Flags": {},
        #         "Amount": {
        #             "v": "100000000",
        #             "e": 8,
        #             "f": 1
        #         },
        #         "Price": null,
        #         "Spend_Limit": {
        #             "v": "1000000",
        #             "e": 6,
        #             "f": 1
        #         },
        #         "Executed": {
        #             "v": "0",
        #             "e": 0,
        #             "f": 0
        #         },
        #         "Secured": {
        #             "v": "1000000",
        #             "e": 6,
        #             "f": 1
        #         },
        #         "Version": "0",
        #         "Created": {
        #             "unix": 1728719020,
        #             "us": 315195,
        #             "iso": "2024-10-12 07:43:40.315195",
        #             "tz": "UTC",
        #             "full": "1728719020315195",
        #             "unixms": "1728719020315"
        #         },
        #         "Updated": {
        #             "unix": 1728719020,
        #             "us": 315195,
        #             "iso": "2024-10-12 07:43:40.315195",
        #             "tz": "UTC",
        #             "full": "1728719020315195",
        #             "unixms": "1728719020315"
        #         }
        #     }
        # }
        order = self.safe_dict(response, 'data', {})
        return self.parse_order(order, market)

    def fetch_order(self, id: str, symbol: Str = None, params={}) -> Order:
        """
        fetches information on an order made by the user
        :param str id: the order ID by createOrder or fetchOrders
        :param str|None symbol: not used by ellipx.fetchOrder
        :param dict [params]: extra parameters specific to the EllipX API endpoint
        :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
        """
        self.load_markets()
        request = {
            'orderUuid': id,
        }
        response = self.privateGetMarketOrderOrderUuid(self.extend(request, params))
        data = self.safe_dict(response, 'data', {})
        return self.parse_order(data, None)

    def fetch_orders_by_status(self, status, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
        """
        fetches a list of orders placed on the exchange

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.5z2nh2b5s81n

        :param str status: 'open' or 'closed', omit for all orders
        :param str symbol: unified market symbol
        :param int [since]: timestamp in ms of the earliest order
        :param int [limit]: the maximum amount of orders to fetch
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
        """
        self.load_markets()
        market = None
        request: Any = {}
        if symbol is not None:
            market = self.market(symbol)
            marketId = market['id']
            request['currencyPair'] = marketId
        if status is not None:
            request['Status'] = status
        response = self.privateGetMarketCurrencyPairOrder(self.extend(request, params))
        # {
        #     "result": "success",
        #     "data": [
        #         {
        #             "Market_Order__": "mktor-aglvd2-iy5v-enbj-nwrb-scqsnosa",
        #             "Market__": "mkt-lrnp2e-eaor-eobj-ua73-75j6sjxe",
        #             "User__": "usr-...",
        #             "Uniq": "order:1728712511:964332600:0",
        #             "Type": "ask",
        #             "Status": "open",
        #             "Flags": {},
        #             "Amount": {
        #                 "v": "1",
        #                 "e": 8,
        #                 "f": 1.0e-8
        #             },
        #             "Price": {
        #                 "v": "63041306872",
        #                 "e": 6,
        #                 "f": 63041.306872
        #             },
        #             "Spend_Limit": null,
        #             "Executed": {
        #                 "v": "892",
        #                 "e": 8,
        #                 "f": 8.92e-6
        #             },
        #             "Secured": null,
        #             "Version": "3",
        #             "Created": {
        #                 "unix": 1728712510,
        #                 "us": 669096,
        #                 "iso": "2024-10-12 05:55:10.669096",
        #                 "tz": "UTC",
        #                 "full": "1728712510669096",
        #                 "unixms": "1728712510669"
        #             },
        #             "Updated": {
        #                 "unix": 1728712510,
        #                 "us": 669096,
        #                 "iso": "2024-10-12 05:55:10.669096",
        #                 "tz": "UTC",
        #                 "full": "1728712510669096",
        #                 "unixms": "1728712510669"
        #             }
        #         }
        #     ],
        #     "paging": {
        #         "page_no": 1,
        #         "count": "1",
        #         "page_max": 1,
        #         "results_per_page": 20
        #     }
        # }
        data = self.safe_value(response, 'data', [])
        return self.parse_orders(data, market, since, limit)

    def fetch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
        """
        fetches information on multiple orders made by the user

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.5z2nh2b5s81n

        :param str symbol: unified market symbol of the market orders were made in
        :param int|None since: timestamp in ms of the earliest order
        :param int|None limit: the maximum amount of orders to fetch
        :param dict params: extra parameters specific to the exchange API endpoint
        :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
        """
        if symbol is None:
            raise ArgumentsRequired(self.id + ' fetchOrders requires a symbol parameter')
        return self.fetch_orders_by_status(None, symbol, since, limit, params)

    def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
        """
        fetches information on open orders made by the user

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.5z2nh2b5s81n

        :param str symbol: unified market symbol of the market orders were made in
        :param int|None since: timestamp in ms of the earliest order
        :param int|None limit: the maximum amount of orders to fetch
        :param dict params: extra parameters specific to the exchange API endpoint
        :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
        """
        if symbol is None:
            raise ArgumentsRequired(self.id + ' fetchOpenOrders requires a symbol parameter')
        return self.fetch_orders_by_status('open', symbol, since, limit, params)

    def parse_order(self, order, market=None) -> Order:
        id = self.safe_string(order, 'Market_Order__')
        timestamp = self.safe_integer(self.safe_dict(order, 'Created'), 'unixms')
        orderType = self.safe_string(order, 'Type')
        side = 'sell'
        if orderType == 'bid':
            side = 'buy'
        status = self.parse_order_status(self.safe_string(order, 'Status'))
        amount = self.parse_number(self.parse_amount(self.safe_dict(order, 'Amount')))
        price = self.parse_number(self.parse_amount(self.safe_dict(order, 'Price')))
        type = 'market' if (price is None) else 'limit'
        executed = self.parse_number(self.parse_amount(self.safe_dict(order, 'Executed')))
        filled = executed
        remaining = self.parse_number(self.parse_amount(self.safe_dict(order, 'Secured')))
        cost = self.parse_number(self.parse_amount(self.safe_dict(order, 'Total_Spent')))
        symbol = market['symbol'] if market else None
        clientOrderId = None
        timeInForce = 'GTC'  # default to Good Till Cancelled
        postOnly = False
        updated = self.safe_dict(order, 'Updated', {})
        lastTradeTimestamp = self.safe_integer(updated, 'unixms', None)
        return self.safe_order({
            'id': id,
            'clientOrderId': clientOrderId,
            'info': order,
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'lastTradeTimestamp': lastTradeTimestamp,
            'status': self.parse_order_status(status),
            'symbol': symbol,
            'type': type,
            'timeInForce': timeInForce,
            'postOnly': postOnly,
            'side': side,
            'price': price,
            'triggerPrice': None,
            'average': None,
            'cost': cost,
            'amount': amount,
            'filled': filled,
            'remaining': remaining,
            'fee': None,
            'trades': None,
        }, market)

    def cancel_order(self, id: str, symbol: Str = None, params={}) -> Order:
        """
        Cancels an open order on the exchange

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.f1qu1pb1rebn

        :param str id: - The order ID to cancel(format: mktor-xxxxx-xxxx-xxxx-xxxx-xxxxxxxx)
        :param str [symbol]: - ellipx.cancelOrder does not use the symbol parameter
        :param dict [params]: - Extra parameters specific to the exchange API
        :returns Promise<dict>: A Promise that resolves to the canceled order info
        """
        self.load_markets()
        request = {
            'orderUuid': id,
        }
        response = self.privateDeleteMarketOrderOrderUuid(self.extend(request, params))
        # {
        #     result: "success",
        #     request_id: "887dba33-d11b-43f0-8034-dd7890882cc5",
        #     time: "0.8975801467895508",
        #     data: True,
        #     access: {
        #       "mktor-rf5k5b-5fhf-dmde-wxqj-3y23jeii": {
        #         required: "A",
        #         available: "O",
        #       },
        #     },
        #   }
        # self endpoint always returns True and a warning message if the order cancelled before.
        warningResponse = self.safe_value(response, 'warning', None)
        statusResponse = self.safe_bool(response, 'data')
        status = 'canceled'
        if statusResponse is not True or warningResponse is not None:
            status = 'closed'
        return self.safe_order({
            'id': id,
            'clientOrderId': None,
            'info': self.json(response),  # original response
            'timestamp': None,
            'datetime': None,
            'lastTradeTimestamp': None,
            'status': status,
            'symbol': None,
            'type': None,
            'timeInForce': None,
            'postOnly': None,
            'side': None,
            'price': None,
            'triggerPrice': None,
            'average': None,
            'cost': None,
            'amount': None,
            'filled': None,
            'remaining': None,
            'fee': None,
            'trades': None,
        }, None)

    def fetch_order_trades(self, id: str, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
        """
        fetch all the trades made from a single order
        :param str id: order id
        :param str symbol: unified market symbol
        :param int [since]: the earliest time in ms to fetch trades for
        :param int [limit]: the maximum number of trades to retrieve
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
        """
        if symbol is None:
            raise ArgumentsRequired('fetchMyTrades requires a symbol parameter')
        self.load_markets()
        market = self.market(symbol)
        currencyPair = market['id']
        request = {
            'Market_Order__': id,
            'currencyPair': currencyPair,
        }
        response = self.privateGetMarketCurrencyPairTrade(self.extend(request, params))
        # {
        #     "result": "success",
        #     "request_id": "fc5be99d-d085-46f8-9228-e46d0996f112",
        #     "time": 0.030913114547729492,
        #     "data": [
        #         {
        #             "id": "DOGE_USDC:1731505789:911642994:0",
        #             "pair": "DOGE_USDC",
        #             "bid": {
        #                 "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
        #             },
        #             "ask": {
        #                 "id": "mktor-oxmac4-mtkf-gi3o-mamg-u2cboqe4"
        #             },
        #             "type": "bid",
        #             "amount": {
        #                 "v": "334609419",
        #                 "e": 8,
        #                 "f": 3.34609419
        #             },
        #             "price": {
        #                 "v": "410673",
        #                 "e": 6,
        #                 "f": 0.410673
        #             },
        #             "date": {
        #                 "unix": 1731505789,
        #                 "us": 911642,
        #                 "iso": "2024-11-13 13:49:49.911642",
        #                 "tz": "UTC",
        #                 "full": "1731505789911642",
        #                 "unixms": "1731505789911"
        #             }
        #         },
        #         {
        #             "id": "DOGE_USDC:1731505789:911642994:4",
        #             "pair": "DOGE_USDC",
        #             "bid": {
        #                 "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
        #             },
        #             "ask": {
        #                 "id": "mktor-cmtztk-3z3n-gupp-uqdg-74g4wjfq"
        #             },
        #             "type": "bid",
        #             "amount": {
        #                 "v": "145453950",
        #                 "e": 8,
        #                 "f": 1.4545395
        #             },
        #             "price": {
        #                 "v": "412589",
        #                 "e": 6,
        #                 "f": 0.412589
        #             },
        #             "date": {
        #                 "unix": 1731505789,
        #                 "us": 911642,
        #                 "iso": "2024-11-13 13:49:49.911642",
        #                 "tz": "UTC",
        #                 "full": "1731505789911642",
        #                 "unixms": "1731505789911"
        #             }
        #         },
        #         {
        #             "id": "DOGE_USDC:1731505789:911642994:2",
        #             "pair": "DOGE_USDC",
        #             "bid": {
        #                 "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
        #             },
        #             "ask": {
        #                 "id": "mktor-6tyslh-b33b-flnm-2ata-acjkco4y"
        #             },
        #             "type": "bid",
        #             "amount": {
        #                 "v": "587627076",
        #                 "e": 8,
        #                 "f": 5.87627076
        #             },
        #             "price": {
        #                 "v": "411005",
        #                 "e": 6,
        #                 "f": 0.411005
        #             },
        #             "date": {
        #                 "unix": 1731505789,
        #                 "us": 911642,
        #                 "iso": "2024-11-13 13:49:49.911642",
        #                 "tz": "UTC",
        #                 "full": "1731505789911642",
        #                 "unixms": "1731505789911"
        #             }
        #         },
        #         {
        #             "id": "DOGE_USDC:1731505789:911642994:1",
        #             "pair": "DOGE_USDC",
        #             "bid": {
        #                 "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
        #             },
        #             "ask": {
        #                 "id": "mktor-ihpjlj-5ufj-dm5l-fmud-oftkqcgu"
        #             },
        #             "type": "bid",
        #             "amount": {
        #                 "v": "475845734",
        #                 "e": 8,
        #                 "f": 4.75845734
        #             },
        #             "price": {
        #                 "v": "410830",
        #                 "e": 6,
        #                 "f": 0.41083
        #             },
        #             "date": {
        #                 "unix": 1731505789,
        #                 "us": 911642,
        #                 "iso": "2024-11-13 13:49:49.911642",
        #                 "tz": "UTC",
        #                 "full": "1731505789911642",
        #                 "unixms": "1731505789911"
        #             }
        #         },
        #         {
        #             "id": "DOGE_USDC:1731505789:911642994:3",
        #             "pair": "DOGE_USDC",
        #             "bid": {
        #                 "id": "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4"
        #             },
        #             "ask": {
        #                 "id": "mktor-d2uyb3-nzsj-aevn-dikr-tq3sxhre"
        #             },
        #             "type": "bid",
        #             "amount": {
        #                 "v": "641013461",
        #                 "e": 8,
        #                 "f": 6.41013461
        #             },
        #             "price": {
        #                 "v": "411846",
        #                 "e": 6,
        #                 "f": 0.411846
        #             },
        #             "date": {
        #                 "unix": 1731505789,
        #                 "us": 911642,
        #                 "iso": "2024-11-13 13:49:49.911642",
        #                 "tz": "UTC",
        #                 "full": "1731505789911642",
        #                 "unixms": "1731505789911"
        #             }
        #         }
        #     ],
        #     "access": {
        #         "mkt-xrkg5l-akjz-cxxl-3a2e-mul5gfo4": {
        #             "required": "r",
        #             "available": "?"
        #         },
        #         "mktor-xb3ne5-emm5-fx7e-xggk-fyfoiye4": {
        #             "required": "R",
        #             "available": "O"
        #         }
        #     },
        #     "paging": {
        #         "page_no": 1,
        #         "count": "5",
        #         "page_max": 1,
        #         "results_per_page": 20
        #     }
        # }
        data = self.safe_list(response, 'data')
        return self.parse_trades(data, market, since, limit)

    def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
        """
        fetches a crypto deposit address for a specific currency

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.k7qe5aricayh

        :param str code: unified currency code(e.g. "BTC", "ETH", "USDT")
        :param dict [params]: extra parameters specific to the EllipX API endpoint
        :returns dict: an address structure {
     'currency': string,  # unified currency code
     'address': string,  # the address for deposits
     'tag': string|None,  # tag/memo for deposits if needed
     'network': object,  # network object from currency info
     'info': object  # raw response from exchange
}
        :throws ExchangeError if: currency does not support deposits
        """
        self.load_markets()
        currency = self.currency(code)
        network = self.safe_value(currency['info'], 'Crypto_Chain', None)
        request = {
            'Crypto_Token__': self.safe_string(network, 'Crypto_Token__'),
            'Crypto_Chain__': self.safe_string(network, 'Crypto_Chain__'),
        }
        response = self.privatePostCryptoAddressFetch(self.extend(request, params))
        data = self.safe_value(response, 'data', {})
        address = self.safe_string(data, 'Address')
        tag = self.safe_string(data, 'memo')
        self.check_address(address)
        return {
            'currency': code,
            'address': address,
            'tag': tag,
            'network': network,
            'info': response,
        }

    def fetch_trading_fee(self, symbol: str, params={}) -> TradingFeeInterface:
        """
        Fetches the current trading fees(maker and taker) applicable to the user.

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.kki5jay2c8it

        :param str [symbol]: Not used by EllipX are not symbol-specific.
        :param dict [params]: Extra parameters specific to the EllipX API endpoint.
        :returns Promise<dict>: A promise resolving to a unified trading fee structure:
 {
     'info': object,        # the raw response from the exchange
     'symbol': None,   # symbol is not used for self exchange
     'maker': number,       # maker fee rate in decimal form
     'taker': number,       # taker fee rate in decimal form
     'percentage': True,    # indicates fees are in percentage
     'tierBased': False,    # indicates fees do not vary by volume tiers
}
        """
        self.load_markets()
        response = self.privateGetMarketTradeFeeQuery(params)
        #
        # Example response:
        # {
        #     "result": "success",
        #     "data": {
        #         "maker": 15.0,      # in basis points
        #         "taker": 25.0,      # in basis points
        #         "volume": 123456.78,
        #         "promo": {
        #             # promotional discounts if any
        #         }
        #     }
        # }
        #
        data = self.safe_value(response, 'data', {})
        maker = self.safe_number(data, 'maker')  # in basis points
        taker = self.safe_number(data, 'taker')  # in basis points
        makerFee = maker / 10000 if (maker is not None) else None
        takerFee = taker / 10000 if (taker is not None) else None
        return {
            'info': response,
            'symbol': None,  # the exchange only have separate fees for stablecoin pairs
            'maker': makerFee,
            'taker': takerFee,
            'percentage': True,  # fees are expressed in percentages
            'tierBased': True,  # fees can vary based on volume tiers
        }

    def withdraw(self, code: str, amount: float, address: str, tag: Str = None, params={}) -> Transaction:
        """
        Make a withdrawal request

        https://docs.google.com/document/d/1ZXzTQYffKE_EglTaKptxGQERRnunuLHEMmar7VC9syM/edit?tab=t.0#heading=h.zegupoa8g4t9

        :param str code: unified currency code
        :param number amount: Amount to withdraw
        :param str address: Destination wallet address
        :param str [tag]: Additional tag/memo for currencies that require it
        :param dict params: Extra parameters specific to the EllipX API endpoint(Crypto_Chain__, Unit__)
        :returns dict: a `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
        """
        self.check_address(address)
        self.load_markets()
        currency = self.currency(code)
        networks = self.safe_value(currency, 'networks')
        if networks is None:
            raise NotSupported(self.id + ' withdraw() for ' + code + ' is not supported')
        chainsResponse = self.privateGetUnitCurrency({'currency': currency['code']})  # fetch Unit__ params for currency
        chainsData = self.safe_value(chainsResponse, 'data', [])
        unit = self.safe_string(chainsData, 'Unit__')
        # check params again and omit params
        self.omit(params, 'Unit__')
        self.omit(params, 'Crypto_Chain__')
        amountString = str(amount)
        request = {
            'Unit__': unit,
            'amount': amountString,
            'address': address,
            'Crypto_Chain__': networks['id'],
        }
        if tag is not None:
            request['memo'] = tag
        response = self.privatePostCryptoDisbursementWithdraw(self.extend(request, params))
        # {
        #     Crypto_Disbursement__: "crdsb-4pw3kg-ipn5-amvb-da4n-6xncy4r4",
        #     Crypto_Token__: "crtok-dnehz4-wbgv-bunf-iyd3-m7gtsz2q",
        #     Crypto_Chain__: "chain-kjfvwn-l2xn-eclc-ul5d-mb6fu5hm",
        #     User__: "usr-5oint6-ozpr-alfp-2wxi-zgbm4osy",
        #     Value: {
        #       v: "1000000000",
        #       e: "8",
        #       f: "10",
        #     },
        #     Value_USD: "4.08723",
        #     Address: "D6z62LUwyNBi3QbPkzW8C4m7VDAgu9wb2Z",
        #     Status: "pending",
        #     Transaction: null,
        #     Requested: {
        #       unix: "1731570982",
        #       us: "203569",
        #       iso: "2024-11-14 07:56:22.203569",
        #       tz: "UTC",
        #       full: "1731570982203569",
        #       unixms: "1731570982203",
        #     },
        #     Scheduled: null,
        #     Processed: null,
        #     Amount: {
        #       value: "10.00000000",
        #       value_int: "1000000000",
        #       value_disp: "10.00000000",
        #       value_xint: {
        #         v: "1000000000",
        #         e: "8",
        #         f: "10",
        #       },
        #       display: "10.00000000DOGE",
        #       display_short: "10.00000000DOGE",
        #       currency: "DOGE",
        #       unit: "DOGE",
        #       has_vat: False,
        #       tax_profile: null,
        #       raw: {
        #         value: "10.00000000",
        #         value_int: "1000000000",
        #         value_disp: "10.00000000",
        #         value_xint: {
        #           v: "1000000000",
        #           e: "8",
        #           f: "10",
        #         },
        #         display: "10.00000000DOGE",
        #         display_short: "10.00000000DOGE",
        #         currency: "DOGE",
        #         unit: "DOGE",
        #         has_vat: False,
        #         tax_profile: null,
        #       },
        #       tax: {
        #         value: "10.00000000",
        #         value_int: "1000000000",
        #         value_disp: "10.00000000",
        #         value_xint: {
        #           v: "1000000000",
        #           e: "8",
        #           f: "10",
        #         },
        #         display: "10.00000000DOGE",
        #         display_short: "10.00000000DOGE",
        #         currency: "DOGE",
        #         unit: "DOGE",
        #         has_vat: True,
        #         tax_profile: null,
        #       },
        #       tax_only: {
        #         value: "0.000",
        #         value_int: "0",
        #         value_disp: "0",
        #         value_xint: {
        #           v: "0",
        #           e: "3",
        #           f: "0",
        #         },
        #         display: "¥0",
        #         display_short: "¥0",
        #         currency: "JPY",
        #         unit: "JPY",
        #         has_vat: False,
        #         tax_profile: null,
        #       },
        #       tax_rate: "0",
        #     },
        #   }
        data = self.safe_dict(response, 'data')
        amountResponse = self.safe_dict(data, 'Amount')
        requested = self.safe_dict(data, 'Requested')
        processed = self.safe_dict(data, 'Processed')
        withdrawId = self.safe_string(data, 'Crypto_Disbursement__')
        timestamp = self.safe_integer(requested, 'unixms')
        return {
            'info': response,
            'id': withdrawId,
            'txid': None,
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'network': self.safe_string(data, 'Crypto_Chain__'),
            'address': self.safe_string(data, 'Address'),
            'addressTo': self.safe_string(data, 'Address'),
            'addressFrom': None,
            'tag': tag,
            'tagTo': tag,
            'tagFrom': None,
            'type': 'withdrawal',
            'amount': self.safe_number(amountResponse, 'value'),
            'currency': code,
            'status': self.parse_transaction_status(self.safe_string(data, 'Status')),
            'updated': self.safe_timestamp(processed, 'unix'),
            'internal': False,
            'comment': None,
            'fee': {
                'currency': code,
                'cost': None,  # Fee information not provided in response
                'rate': None,
            },
        }

    def parse_transaction_status(self, status: str) -> str:
        statuses = {
            'pending': 'pending',
            'completed': 'ok',
            'failed': 'failed',
            'cancelled': 'canceled',
        }
        return self.safe_string(statuses, status, status)

    def parse_order_status(self, status):
        statuses = {
            'pending': 'open',  # starting state of all orders
            'running': 'open',  # when order is being executed
            'post-pending': 'open',  # post-only order waiting to be placed
            'open': 'open',  # active order in the orderbook
            'stop': 'open',  # when stop order not yet triggered
            'invalid': 'rejected',  # order rejected
            'done': 'closed',  # order fully executed
            'cancel': 'canceled',  # order canceled by user
            'canceled': 'canceled',  # alternative spelling
        }
        return self.safe_string(statuses, status, status)

    def parse_amount(self, amount) -> Str:
        v = self.safe_string(amount, 'v', None)
        e = self.safe_integer(amount, 'e', None)
        if v is None or e is None:
            return None
        precise = Precise(v)
        precise.decimals = e
        precise.reduce()
        amountString = str(precise)
        return amountString

    def to_amount(self, amount: float, precision: float) -> dict:
        v = str(amount)
        e = precision
        return {
            'v': v,
            'e': e,
        }

    def handle_errors(self, code: int, reason: str, url: str, method: str, headers: dict, body: str, response, requestHeaders, requestBody):
        # {
        #     "code": 404,
        #     "error": "Not Found: Crypto\\Token(US)",
        #     "exception": "Exception\\NotFound",
        #     "message": "[I18N:error_not_found]",
        #     "request": "cc83738a-2438-4f53-ae44-f15306c07f32",
        #     "result": "error",
        #     "time": 0.0089569091796875,
        #     "token": "error_not_found"
        # }
        errorCode = self.safe_string(response, 'code')
        message = self.safe_string(response, 'message')
        if errorCode is not None:
            self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, message)
            raise ExchangeError(self.id + ' ' + message)
        return None
